mirror of
https://github.com/hansjone/dsh-im-ops.git
synced 2026-10-09 03:03:24 +08:00
1882 lines
63 KiB
JavaScript
1882 lines
63 KiB
JavaScript
import assert from 'node:assert/strict';
|
|
import { mkdtemp, rm, writeFile } from 'node:fs/promises';
|
|
import { tmpdir } from 'node:os';
|
|
import { join } from 'node:path';
|
|
import test from 'node:test';
|
|
|
|
import {
|
|
sendWecomImage,
|
|
WecomHarnessBridge,
|
|
wecomInboundMessage,
|
|
} from '../../../src/channels/wecom/wecom-bridge.mjs';
|
|
import { DEFAULT_IMAGE_PROMPT } from '../../../src/channels/shared/image-prompt.mjs';
|
|
import { connectionTestTarget } from '../../../src/channels/shared/connection-test.mjs';
|
|
import {
|
|
OUTBOUND_ARTIFACT_TOOL,
|
|
OutboundArtifactRegistry,
|
|
createOutboundArtifactTool,
|
|
} from '../../../src/channels/shared/semantic/artifact.mjs';
|
|
|
|
const PNG_1X1 = Buffer.from(
|
|
'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII=',
|
|
'base64',
|
|
);
|
|
|
|
test('Enterprise WeChat native image adapter uploads and sends an image media message', async () => {
|
|
const calls = [];
|
|
const result = { body: { msgid: 'wecom-image-1', errcode: 0 } };
|
|
const file = {
|
|
artifactId: 'image-artifact',
|
|
deliveryKey: 'image-delivery',
|
|
fileName: 'diagram.png',
|
|
mediaType: 'image/png',
|
|
bytes: PNG_1X1,
|
|
};
|
|
const returned = await sendWecomImage({
|
|
uploadMedia: async (bytes, options) => {
|
|
calls.push({ operation: 'upload', bytes: Buffer.from(bytes), options });
|
|
return { media_id: 'image-media-1' };
|
|
},
|
|
sendMediaMessage: async (chatId, type, mediaId) => {
|
|
calls.push({ operation: 'send', chatId, type, mediaId });
|
|
return result;
|
|
},
|
|
}, 'chat-1', file);
|
|
|
|
assert.equal(returned, result);
|
|
assert.deepEqual(calls, [{
|
|
operation: 'upload',
|
|
bytes: PNG_1X1,
|
|
options: { type: 'image', filename: 'diagram.png' },
|
|
}, {
|
|
operation: 'send',
|
|
chatId: 'chat-1',
|
|
type: 'image',
|
|
mediaId: 'image-media-1',
|
|
}]);
|
|
});
|
|
|
|
test('Enterprise WeChat native image adapter preserves definite upload errors', async () => {
|
|
let sends = 0;
|
|
await assert.rejects(sendWecomImage({
|
|
uploadMedia: async () => {
|
|
const error = new Error('forbidden');
|
|
error.httpStatus = 403;
|
|
throw error;
|
|
},
|
|
sendMediaMessage: async () => { sends += 1; },
|
|
}, 'chat-1', {
|
|
fileName: 'diagram.png',
|
|
bytes: PNG_1X1,
|
|
}), (error) => error.code === 'artifact-permission-required');
|
|
assert.equal(sends, 0);
|
|
});
|
|
|
|
test('Enterprise WeChat native image adapter marks an unacknowledged message as uncertain', async () => {
|
|
await assert.rejects(sendWecomImage({
|
|
uploadMedia: async () => ({ media_id: 'image-media-uncertain' }),
|
|
sendMediaMessage: async () => new Promise(() => {}),
|
|
}, 'chat-1', {
|
|
fileName: 'diagram.png',
|
|
bytes: PNG_1X1,
|
|
}, { timeoutMs: 20 }), (error) => error.code === 'artifact-delivery-uncertain');
|
|
});
|
|
|
|
test('Enterprise WeChat sends an image artifact as a native image message', async (t) => {
|
|
const artifact = await committedArtifact(t, 'native.png', PNG_1X1, 'native-image');
|
|
const uploads = [];
|
|
const messages = [];
|
|
const bridge = new WecomHarnessBridge({
|
|
client: {
|
|
replyStream: async (_source, _streamId, _content, finish) => (
|
|
finish ? { body: { msgid: 'wecom-text' } } : undefined
|
|
),
|
|
replyStreamNonBlocking: async () => {},
|
|
sendMessage: async () => {},
|
|
uploadMedia: async (bytes, options) => {
|
|
uploads.push({ bytes: Buffer.from(bytes), options });
|
|
return { media_id: 'native-image-media' };
|
|
},
|
|
sendMediaMessage: async (chatId, type, mediaId) => {
|
|
messages.push({ chatId, type, mediaId });
|
|
return { body: { msgid: 'wecom-image', errcode: 0 } };
|
|
},
|
|
},
|
|
generateStreamId: () => 'native-image-stream',
|
|
harness: {
|
|
sessionExists: async () => true,
|
|
ask: async (_sessionId, _text, options) => {
|
|
await options.onArtifact(artifact);
|
|
return '图片已生成。';
|
|
},
|
|
},
|
|
state: state(),
|
|
});
|
|
|
|
const receipt = await bridge.accept(frame({ msgid: 'wecom-native-image' }));
|
|
|
|
assert.deepEqual(uploads, [{
|
|
bytes: PNG_1X1,
|
|
options: { type: 'image', filename: 'native.png' },
|
|
}]);
|
|
assert.deepEqual(messages, [{
|
|
chatId: 'member-1',
|
|
type: 'image',
|
|
mediaId: 'native-image-media',
|
|
}]);
|
|
assert.equal(receipt.artifacts[0].artifactId, artifact.artifactId);
|
|
assert.equal(receipt.artifacts[0].outcome, 'sent');
|
|
assert.equal(receipt.providerMessageIds.includes('wecom-image'), true);
|
|
});
|
|
|
|
test('Enterprise WeChat falls back to a file after a definite native-image rejection', async (t) => {
|
|
const artifact = await committedArtifact(t, 'fallback.png', PNG_1X1, 'image-fallback');
|
|
const uploads = [];
|
|
const messages = [];
|
|
const bridge = new WecomHarnessBridge({
|
|
client: {
|
|
replyStream: async () => {},
|
|
replyStreamNonBlocking: async () => {},
|
|
sendMessage: async () => {},
|
|
uploadMedia: async (_bytes, options) => {
|
|
uploads.push(options.type);
|
|
if (options.type === 'image') {
|
|
const error = new Error('image format rejected');
|
|
error.providerCode = 40014;
|
|
throw error;
|
|
}
|
|
return { media_id: 'fallback-file-media' };
|
|
},
|
|
sendMediaMessage: async (_chatId, type, mediaId) => {
|
|
messages.push({ type, mediaId });
|
|
return { body: { msgid: 'wecom-file', errcode: 0 } };
|
|
},
|
|
},
|
|
harness: {
|
|
sessionExists: async () => true,
|
|
ask: async (_sessionId, _text, options) => {
|
|
await options.onArtifact(artifact);
|
|
return '图片已生成。';
|
|
},
|
|
},
|
|
state: state(),
|
|
});
|
|
|
|
const receipt = await bridge.accept(frame({ msgid: 'wecom-image-fallback' }));
|
|
|
|
assert.deepEqual(uploads, ['image', 'file']);
|
|
assert.deepEqual(messages, [{ type: 'file', mediaId: 'fallback-file-media' }]);
|
|
assert.equal(receipt.artifacts[0].outcome, 'sent');
|
|
});
|
|
|
|
test('Enterprise WeChat does not file-fallback after an uncertain native image send', async (t) => {
|
|
const artifact = await committedArtifact(t, 'uncertain.png', PNG_1X1, 'image-uncertain');
|
|
const uploads = [];
|
|
const notices = [];
|
|
const bridge = new WecomHarnessBridge({
|
|
client: {
|
|
replyStream: async () => {},
|
|
replyStreamNonBlocking: async () => {},
|
|
sendMessage: async (_chatId, body) => {
|
|
notices.push(body.markdown.content);
|
|
return { body: { msgid: 'wecom-uncertain-notice' } };
|
|
},
|
|
uploadMedia: async (_bytes, options) => {
|
|
uploads.push(options.type);
|
|
return { media_id: 'uncertain-image-media' };
|
|
},
|
|
sendMediaMessage: async () => new Promise(() => {}),
|
|
},
|
|
harness: {
|
|
sessionExists: async () => true,
|
|
ask: async (_sessionId, _text, options) => {
|
|
await options.onArtifact(artifact);
|
|
return '图片已生成。';
|
|
},
|
|
},
|
|
state: state(),
|
|
fileUploadTimeoutMs: 20,
|
|
logger: { warn() {}, error() {} },
|
|
});
|
|
|
|
const receipt = await bridge.accept(frame({ msgid: 'wecom-image-uncertain' }));
|
|
|
|
assert.deepEqual(uploads, ['image']);
|
|
assert.match(notices[0], /发送结果未能确认.*不要立即重试/);
|
|
assert.equal(receipt.artifacts[0].outcome, 'unknown');
|
|
});
|
|
|
|
function frame(overrides = {}) {
|
|
return {
|
|
headers: { req_id: 'req-1' },
|
|
body: {
|
|
msgid: 'msg-1',
|
|
chattype: 'single',
|
|
from: { userid: 'member-1' },
|
|
msgtype: 'text',
|
|
text: { content: '请回答' },
|
|
...overrides,
|
|
},
|
|
};
|
|
}
|
|
|
|
function state() {
|
|
const seen = new Set();
|
|
return {
|
|
seen,
|
|
hasSeen: (id) => seen.has(id),
|
|
markSeen: async (id) => seen.add(id),
|
|
sessionFor: () => 'session-existing',
|
|
sessionExists: async () => true,
|
|
setSession: async () => {},
|
|
clearSession: async () => {},
|
|
};
|
|
}
|
|
|
|
function deferred() {
|
|
let resolve;
|
|
let reject;
|
|
const promise = new Promise((resolvePromise, rejectPromise) => {
|
|
resolve = resolvePromise;
|
|
reject = rejectPromise;
|
|
});
|
|
return { promise, resolve, reject };
|
|
}
|
|
|
|
async function eventually(predicate, timeoutMs = 1_000) {
|
|
const deadline = Date.now() + timeoutMs;
|
|
while (Date.now() < deadline) {
|
|
if (predicate()) return;
|
|
await new Promise((resolve) => setTimeout(resolve, 1));
|
|
}
|
|
throw new Error('condition did not become true');
|
|
}
|
|
|
|
function testClient() {
|
|
const streamed = [];
|
|
const active = [];
|
|
return {
|
|
streamed,
|
|
active,
|
|
client: {
|
|
replyStream: async (source, streamId, content, finish) => {
|
|
streamed.push({ messageId: source.body.msgid, streamId, content, finish });
|
|
},
|
|
replyStreamNonBlocking: async (source, streamId, content, finish) => {
|
|
streamed.push({ messageId: source.body.msgid, streamId, content, finish });
|
|
},
|
|
sendMessage: async (chatId, body) => active.push({ chatId, body }),
|
|
},
|
|
};
|
|
}
|
|
|
|
async function committedArtifact(t, fileName, content, suffix) {
|
|
const workspace = await mkdtemp(join(tmpdir(), `dsh-im-wecom-artifact-${suffix}-`));
|
|
t.after(() => rm(workspace, { recursive: true, force: true }));
|
|
let nextId = 0;
|
|
const registry = new OutboundArtifactRegistry({ uuid: () => `${suffix}-${++nextId}` });
|
|
t.after(() => registry.clear());
|
|
const rpcId = `rpc-${suffix}`;
|
|
const agent = {
|
|
session: {
|
|
header: { id: `session-${suffix}`, cwd: workspace },
|
|
events: [
|
|
{ type: 'turn/start', data: { turn: 1 } },
|
|
{ type: 'user/message', data: { turn: 1, source: { rpcId } } },
|
|
],
|
|
},
|
|
};
|
|
const tool = createOutboundArtifactTool({ registry });
|
|
const exec = {
|
|
name: OUTBOUND_ARTIFACT_TOOL,
|
|
callId: `call-${suffix}`,
|
|
rootCallId: `call-${suffix}`,
|
|
token: Symbol(`call-${suffix}`),
|
|
agent,
|
|
};
|
|
await writeFile(join(workspace, fileName), content);
|
|
await tool.definition.execute({ path: fileName }, exec);
|
|
tool.onResult(exec, { isError: false });
|
|
const [artifact] = registry.take(agent.session.header.id, 1);
|
|
return artifact;
|
|
}
|
|
|
|
function questionInteraction({
|
|
interactionId = 'question-1',
|
|
sessionId = 'session-existing',
|
|
questions = [{
|
|
id: 'environment',
|
|
question: '请选择测试环境',
|
|
options: [{ label: '测试环境' }, { label: '生产环境' }],
|
|
}],
|
|
recovered = false,
|
|
respond = async () => {},
|
|
reconnect = () => {},
|
|
} = {}) {
|
|
return {
|
|
kind: 'question',
|
|
interactionId,
|
|
rpcId: interactionId,
|
|
sessionId,
|
|
payload: { questions },
|
|
recovered,
|
|
respond,
|
|
reconnect,
|
|
};
|
|
}
|
|
|
|
test('Enterprise WeChat remembers any private inbound as a connection-test target', async () => {
|
|
const privateState = state();
|
|
const privateTransport = testClient();
|
|
const privateBridge = new WecomHarnessBridge({
|
|
client: privateTransport.client,
|
|
harness: { ensureRunning: async () => true },
|
|
state: privateState,
|
|
});
|
|
await privateBridge.accept(frame({ msgid: 'help-private', text: { content: '/help' } }));
|
|
assert.deepEqual(connectionTestTarget(privateState), { chatId: 'member-1' });
|
|
|
|
const groupState = state();
|
|
const groupTransport = testClient();
|
|
const groupBridge = new WecomHarnessBridge({
|
|
client: groupTransport.client,
|
|
harness: { ensureRunning: async () => true },
|
|
state: groupState,
|
|
});
|
|
await groupBridge.accept(frame({
|
|
msgid: 'help-group',
|
|
chattype: 'group',
|
|
chatid: 'group-1',
|
|
text: { content: '@机器人 /help' },
|
|
}));
|
|
assert.equal(connectionTestTarget(groupState), null);
|
|
});
|
|
|
|
test('Enterprise WeChat executes /compact for the bound Session without prompting the model', async () => {
|
|
const store = state();
|
|
const transport = testClient();
|
|
const executed = [];
|
|
const bridge = new WecomHarnessBridge({
|
|
client: transport.client,
|
|
generateStreamId: () => 'unused-stream',
|
|
harness: {
|
|
executeCommand: async (sessionId, line) => {
|
|
executed.push({ sessionId, line });
|
|
return { commandId: 'compact-wecom', result: { kind: 'success', text: 'No compactable history yet.' } };
|
|
},
|
|
ask: async () => assert.fail('/compact must not be submitted to the model'),
|
|
},
|
|
state: store,
|
|
});
|
|
|
|
await bridge.accept(frame({ msgid: 'compact-wecom', text: { content: '/compact' } }));
|
|
|
|
assert.deepEqual(executed, [{ sessionId: 'session-existing', line: '/compact' }]);
|
|
assert.equal(transport.streamed.at(-1).content, '暂无可压缩的历史记录。');
|
|
assert.equal(transport.streamed.at(-1).finish, true);
|
|
assert.deepEqual(transport.active, []);
|
|
});
|
|
|
|
test('Enterprise WeChat lists models and presets without prompting and advertises fast commands', async () => {
|
|
const store = state();
|
|
store.sessionFor = () => null;
|
|
const transport = testClient();
|
|
const presetUpdates = [];
|
|
let agentPreset = null;
|
|
let asks = 0;
|
|
let creates = 0;
|
|
const agentPresetCatalog = {
|
|
defaultId: 'preset-001',
|
|
items: Array.from({ length: 70 }, (_, index) => ({
|
|
id: `preset-${String(index + 1).padStart(3, '0')}`,
|
|
label: `WeCom Preset ${index + 1} ${'x'.repeat(64)}`,
|
|
})),
|
|
};
|
|
const bridge = new WecomHarnessBridge({
|
|
client: transport.client,
|
|
generateStreamId: () => 'models-stream',
|
|
harness: {
|
|
listModels: async () => ({
|
|
groups: [{
|
|
id: 'wecom-provider',
|
|
name: 'WeCom Provider',
|
|
models: [{ id: 'model-one', name: 'Model One' }],
|
|
}],
|
|
failures: [],
|
|
}),
|
|
agentPresetSettings: async () => ({ agentPreset, agentPresetCatalog }),
|
|
updateAgentPreset: async (value) => {
|
|
presetUpdates.push(value);
|
|
agentPreset = value;
|
|
return { agentPreset, agentPresetCatalog };
|
|
},
|
|
createSession: async () => { creates += 1; return 'wecom-session'; },
|
|
ask: async () => { asks += 1; return 'unexpected model reply'; },
|
|
},
|
|
state: store,
|
|
});
|
|
|
|
await bridge.accept(frame({ msgid: 'models-wecom', text: { content: '/models' } }));
|
|
assert.match(transport.streamed.at(-1).content, /1\. wecom-provider\/model-one/);
|
|
assert.equal(asks, 0);
|
|
assert.equal(creates, 0);
|
|
|
|
const presetReplyStart = transport.streamed.length;
|
|
await bridge.accept(frame({ msgid: 'presets-wecom', text: { content: '/presetlist' } }));
|
|
const presetReplies = transport.streamed
|
|
.slice(presetReplyStart)
|
|
.map((entry) => entry.content);
|
|
assert.ok(presetReplies.length > 1);
|
|
assert.match(presetReplies.join('\n'), /preset-070/);
|
|
assert.equal(asks, 0);
|
|
assert.equal(creates, 0);
|
|
|
|
await bridge.accept(frame({ msgid: 'preset-current-wecom', text: { content: '/preset' } }));
|
|
assert.match(transport.streamed.at(-1).content, /跟随 Host 默认/);
|
|
assert.equal(asks, 0);
|
|
assert.equal(creates, 0);
|
|
|
|
const selectReplyStart = transport.streamed.length;
|
|
await bridge.accept(frame({ msgid: 'preset-select-wecom', text: { content: '/preset 2' } }));
|
|
assert.deepEqual(presetUpdates, ['preset-002']);
|
|
assert.equal(transport.streamed.length, selectReplyStart + 1);
|
|
assert.match(transport.streamed.at(-1).content, /preset-002/);
|
|
assert.equal(transport.streamed.at(-1).finish, true);
|
|
|
|
const defaultReplyStart = transport.streamed.length;
|
|
await bridge.accept(frame({ msgid: 'preset-default-wecom', text: { content: '/preset --default' } }));
|
|
assert.deepEqual(presetUpdates, ['preset-002', null]);
|
|
assert.equal(transport.streamed.length, defaultReplyStart + 1);
|
|
assert.match(transport.streamed.at(-1).content, /跟随 Host 默认/);
|
|
assert.equal(transport.streamed.at(-1).finish, true);
|
|
assert.equal(asks, 0);
|
|
assert.equal(creates, 0);
|
|
|
|
await bridge.accept(frame({ msgid: 'help-models-wecom', text: { content: '/help' } }));
|
|
const help = transport.streamed.at(-1).content;
|
|
for (const command of ['/models', '/model', '/presetlist', '/preset', '/preset --default', '/stop', '/steer']) {
|
|
assert.equal(help.includes(command), true, command);
|
|
}
|
|
assert.match(help, /\/model 2/);
|
|
assert.match(help, /\/preset id:<ID>/);
|
|
});
|
|
|
|
test('Enterprise WeChat messages stream Harness progress and finalize once', async () => {
|
|
const replies = [];
|
|
const active = [];
|
|
const store = state();
|
|
const bridge = new WecomHarnessBridge({
|
|
client: {
|
|
replyStream: async (_frame, streamId, content, finish) => replies.push({ streamId, content, finish }),
|
|
replyStreamNonBlocking: async (_frame, streamId, content, finish) => replies.push({ streamId, content, finish }),
|
|
sendMessage: async (chatId, body) => active.push({ chatId, body }),
|
|
},
|
|
generateStreamId: () => 'stream-1',
|
|
harness: {
|
|
sessionExists: async () => true,
|
|
createSession: async () => 'session-new',
|
|
ensureRunning: async () => true,
|
|
ask: async (_session, _text, { onUpdate }) => {
|
|
await onUpdate({ type: 'tool', name: '网页搜索' });
|
|
await onUpdate({ type: 'text', text: '回答中' });
|
|
return '最终回答';
|
|
},
|
|
},
|
|
state: store,
|
|
});
|
|
|
|
await bridge.accept(frame());
|
|
assert.deepEqual(replies, [
|
|
{ streamId: 'stream-1', content: '正在思考中…', finish: false },
|
|
{ streamId: 'stream-1', content: '正在使用网页搜索…', finish: false },
|
|
{ streamId: 'stream-1', content: '回答中', finish: false },
|
|
{ streamId: 'stream-1', content: '最终回答', finish: true },
|
|
]);
|
|
assert.deepEqual(active, []);
|
|
assert.equal(store.seen.has('msg-1'), true);
|
|
assert.equal(bridge.status.messagesReplied, 1);
|
|
});
|
|
|
|
test('Enterprise WeChat downloads an image with its AES key and submits structured content once', async () => {
|
|
const transport = testClient();
|
|
const downloads = [];
|
|
const asked = [];
|
|
transport.client.downloadFile = async (url, aeskey) => {
|
|
downloads.push({ url, aeskey });
|
|
return { buffer: PNG_1X1, filename: 'photo.png' };
|
|
};
|
|
const bridge = new WecomHarnessBridge({
|
|
client: transport.client,
|
|
generateStreamId: () => 'stream-image',
|
|
harness: {
|
|
sessionExists: async () => true,
|
|
ask: async (sessionId, content) => {
|
|
asked.push({ sessionId, content });
|
|
return '图片识别完成';
|
|
},
|
|
},
|
|
state: state(),
|
|
});
|
|
const imageFrame = frame({
|
|
msgid: 'image-1',
|
|
msgtype: 'image',
|
|
text: undefined,
|
|
image: { url: 'https://wecom.example/image', aeskey: 'aes-image' },
|
|
});
|
|
|
|
await bridge.accept(imageFrame);
|
|
await bridge.accept(imageFrame);
|
|
|
|
assert.deepEqual(downloads, [{
|
|
url: 'https://wecom.example/image',
|
|
aeskey: 'aes-image',
|
|
}]);
|
|
assert.deepEqual(asked, [{
|
|
sessionId: 'session-existing',
|
|
content: [
|
|
{ type: 'text', text: DEFAULT_IMAGE_PROMPT },
|
|
{
|
|
type: 'image',
|
|
mediaType: 'image/png',
|
|
data: PNG_1X1.toString('base64'),
|
|
name: 'photo.png',
|
|
},
|
|
],
|
|
}]);
|
|
assert.equal(transport.streamed.at(-1).content, '图片识别完成');
|
|
});
|
|
|
|
test('Enterprise WeChat preserves mixed-message text and image order', async () => {
|
|
const transport = testClient();
|
|
const jpeg = Buffer.from([0xff, 0xd8, 0xff, 0xd9]);
|
|
const gif = Buffer.from('GIF89a payload');
|
|
transport.client.downloadFile = async (url) => ({
|
|
buffer: url.endsWith('/one') ? jpeg : gif,
|
|
});
|
|
let prompt;
|
|
const bridge = new WecomHarnessBridge({
|
|
client: transport.client,
|
|
generateStreamId: () => 'stream-mixed',
|
|
harness: {
|
|
sessionExists: async () => true,
|
|
ask: async (_sessionId, content) => { prompt = content; return 'ok'; },
|
|
},
|
|
state: state(),
|
|
});
|
|
|
|
await bridge.accept(frame({
|
|
msgid: 'mixed-image',
|
|
msgtype: 'mixed',
|
|
text: undefined,
|
|
mixed: { msg_item: [
|
|
{ msgtype: 'text', text: { content: '比较这两张图' } },
|
|
{ msgtype: 'image', image: { url: 'https://wecom.example/one', aeskey: 'one' } },
|
|
{ msgtype: 'image', image: { url: 'https://wecom.example/two', aeskey: 'two' } },
|
|
] },
|
|
}));
|
|
|
|
assert.deepEqual(prompt, [
|
|
{ type: 'text', text: '比较这两张图' },
|
|
{ type: 'image', mediaType: 'image/jpeg', data: jpeg.toString('base64') },
|
|
{ type: 'image', mediaType: 'image/gif', data: gif.toString('base64') },
|
|
]);
|
|
});
|
|
|
|
test('Enterprise WeChat exposes native file callbacks through the SDK downloader without file limits', async () => {
|
|
const calls = [];
|
|
const bytes = Buffer.from('wecom-native-file');
|
|
const message = wecomInboundMessage(frame({
|
|
msgtype: 'file',
|
|
text: undefined,
|
|
file: {
|
|
url: 'https://wecom.example/encrypted-file',
|
|
aeskey: 'file-specific-key',
|
|
},
|
|
}), {
|
|
downloadFile: async (url, aeskey) => {
|
|
calls.push({ url, aeskey });
|
|
return { buffer: bytes, filename: '企业微信报告.pdf' };
|
|
},
|
|
});
|
|
|
|
assert.equal(message.content, '');
|
|
assert.deepEqual(message.images, []);
|
|
assert.equal(message.files.length, 1);
|
|
assert.equal(message.files[0].name, 'file');
|
|
assert.equal(calls.length, 0, 'file download stays lazy at normalization time');
|
|
assert.deepEqual(await message.files[0].load({}), {
|
|
data: bytes,
|
|
name: '企业微信报告.pdf',
|
|
});
|
|
assert.deepEqual(calls, [{
|
|
url: 'https://wecom.example/encrypted-file',
|
|
aeskey: 'file-specific-key',
|
|
}]);
|
|
});
|
|
|
|
test('Enterprise WeChat bridge hands its prefetched native file to the current Harness turn', async () => {
|
|
const transport = testClient();
|
|
const bytes = Buffer.from('wecom-bridge-file');
|
|
const downloads = [];
|
|
const prompts = [];
|
|
transport.client.downloadFile = async (url, aeskey) => {
|
|
downloads.push({ url, aeskey });
|
|
return { buffer: bytes, filename: '企微报告.docx' };
|
|
};
|
|
const bridge = new WecomHarnessBridge({
|
|
client: transport.client,
|
|
generateStreamId: () => 'file-stream',
|
|
harness: {
|
|
sessionExists: async () => true,
|
|
ask: async (sessionId, prompt, options) => {
|
|
const loaded = await options.files[0].load({ signal: options.signal });
|
|
prompts.push({ sessionId, prompt, name: options.files[0].name, loaded });
|
|
return '文件已收到';
|
|
},
|
|
},
|
|
state: state(),
|
|
});
|
|
|
|
await bridge.accept(frame({
|
|
msgid: 'wecom-native-file',
|
|
msgtype: 'file',
|
|
text: undefined,
|
|
file: { url: 'https://wecom.example/file', aeskey: 'file-key' },
|
|
}));
|
|
|
|
assert.deepEqual(downloads, [{ url: 'https://wecom.example/file', aeskey: 'file-key' }]);
|
|
assert.deepEqual(prompts, [{
|
|
sessionId: 'session-existing',
|
|
prompt: '',
|
|
name: 'file',
|
|
loaded: { data: bytes, name: '企微报告.docx' },
|
|
}]);
|
|
assert.equal(transport.streamed.at(-1).content, '文件已收到');
|
|
});
|
|
|
|
test('Enterprise WeChat starts image download before an earlier conversation turn finishes', async () => {
|
|
const transport = testClient();
|
|
const firstStarted = deferred();
|
|
const releaseFirst = deferred();
|
|
const downloads = [];
|
|
const prompts = [];
|
|
transport.client.downloadFile = async (url, aeskey) => {
|
|
downloads.push({ url, aeskey });
|
|
return { buffer: PNG_1X1, filename: 'queued.png' };
|
|
};
|
|
const bridge = new WecomHarnessBridge({
|
|
client: transport.client,
|
|
generateStreamId: (() => { let index = 0; return () => `queued-${++index}`; })(),
|
|
harness: {
|
|
sessionExists: async () => true,
|
|
async ask(_sessionId, prompt) {
|
|
prompts.push(prompt);
|
|
if (prompt === '先处理这个慢任务') {
|
|
firstStarted.resolve();
|
|
await releaseFirst.promise;
|
|
}
|
|
return 'ok';
|
|
},
|
|
},
|
|
state: state(),
|
|
});
|
|
|
|
const first = bridge.accept(frame({
|
|
msgid: 'queued-text',
|
|
text: { content: '先处理这个慢任务' },
|
|
}));
|
|
await firstStarted.promise;
|
|
const second = bridge.accept(frame({
|
|
msgid: 'queued-image',
|
|
msgtype: 'image',
|
|
text: undefined,
|
|
image: { url: 'https://wecom.example/expiring', aeskey: 'queued-key' },
|
|
}));
|
|
|
|
await eventually(() => downloads.length === 1);
|
|
assert.deepEqual(prompts, ['先处理这个慢任务']);
|
|
releaseFirst.resolve();
|
|
await Promise.all([first, second]);
|
|
assert.deepEqual(downloads, [{
|
|
url: 'https://wecom.example/expiring',
|
|
aeskey: 'queued-key',
|
|
}]);
|
|
assert.equal(Array.isArray(prompts[1]), true);
|
|
assert.equal(prompts[1][1].mediaType, 'image/png');
|
|
});
|
|
|
|
test('Enterprise WeChat bounds prefetched image memory while a conversation is queued', async () => {
|
|
const transport = testClient();
|
|
const firstStarted = deferred();
|
|
const releaseFirst = deferred();
|
|
const downloads = [];
|
|
const prompts = [];
|
|
transport.client.downloadFile = async (url) => {
|
|
downloads.push(url);
|
|
return { buffer: PNG_1X1 };
|
|
};
|
|
const bridge = new WecomHarnessBridge({
|
|
client: transport.client,
|
|
generateStreamId: (() => { let index = 0; return () => `bounded-${++index}`; })(),
|
|
harness: {
|
|
sessionExists: async () => true,
|
|
async ask(_sessionId, prompt) {
|
|
prompts.push(prompt);
|
|
if (prompt === '阻塞队列') {
|
|
firstStarted.resolve();
|
|
await releaseFirst.promise;
|
|
}
|
|
return 'ok';
|
|
},
|
|
},
|
|
state: state(),
|
|
logger: { error() {}, warn() {} },
|
|
});
|
|
|
|
const pending = [bridge.accept(frame({
|
|
msgid: 'bounded-start',
|
|
text: { content: '阻塞队列' },
|
|
}))];
|
|
await firstStarted.promise;
|
|
for (let index = 0; index < 5; index += 1) {
|
|
pending.push(bridge.accept(frame({
|
|
msgid: `bounded-image-${index}`,
|
|
msgtype: 'image',
|
|
text: undefined,
|
|
image: { url: `https://wecom.example/bounded-${index}`, aeskey: `key-${index}` },
|
|
})));
|
|
}
|
|
|
|
await eventually(() => downloads.length === 4);
|
|
releaseFirst.resolve();
|
|
await Promise.all(pending);
|
|
assert.equal(downloads.length, 4);
|
|
assert.equal(prompts.length, 5);
|
|
assert.equal(transport.streamed.some(({ content }) => (
|
|
content === '当前待处理图片较多，请稍后重新发送。'
|
|
)), true);
|
|
});
|
|
|
|
test('Enterprise WeChat image references enforce the caller byte limit after SDK decryption', async () => {
|
|
const message = wecomInboundMessage(frame({
|
|
msgtype: 'image',
|
|
image: { url: 'https://wecom.example/large', aeskey: 'large-key' },
|
|
}), {
|
|
downloadFile: async () => ({ buffer: Buffer.alloc(5) }),
|
|
});
|
|
await assert.rejects(message.images[0].load({ maxBytes: 4 }), /exceeds/);
|
|
});
|
|
|
|
test('Enterprise WeChat visibility scope accepts direct and group conversations without local approval', async () => {
|
|
let asks = 0;
|
|
const client = {
|
|
replyStream: async () => {},
|
|
replyStreamNonBlocking: async () => {},
|
|
sendMessage: async () => {},
|
|
};
|
|
const harness = {
|
|
sessionExists: async () => true,
|
|
ask: async () => { asks += 1; return 'ok'; },
|
|
};
|
|
const bridge = new WecomHarnessBridge({ client, harness, state: state(), generateStreamId: () => 'stream' });
|
|
await bridge.accept(frame({ msgid: 'direct', from: { userid: 'member-a' } }));
|
|
await bridge.accept(frame({ msgid: 'group', chattype: 'group', chatid: 'group-1', from: { userid: 'member-b' } }));
|
|
assert.equal(asks, 2);
|
|
});
|
|
|
|
test('Enterprise WeChat finalizes an existing progress stream when Harness fails', async () => {
|
|
const replies = [];
|
|
const store = state();
|
|
const bridge = new WecomHarnessBridge({
|
|
client: {
|
|
replyStream: async (_frame, streamId, content, finish) => replies.push({ streamId, content, finish }),
|
|
replyStreamNonBlocking: async () => {},
|
|
sendMessage: async () => {},
|
|
},
|
|
generateStreamId: () => 'stream-failure',
|
|
harness: {
|
|
sessionExists: async () => true,
|
|
ensureRunning: async () => true,
|
|
ask: async () => { throw new Error('Harness unavailable'); },
|
|
},
|
|
state: store,
|
|
logger: { error() {} },
|
|
});
|
|
|
|
await bridge.accept(frame());
|
|
assert.deepEqual(replies, [
|
|
{ streamId: 'stream-failure', content: '正在思考中…', finish: false },
|
|
{ streamId: 'stream-failure', content: '消息处理失败，请稍后重试。', finish: true },
|
|
]);
|
|
assert.equal(store.seen.has('msg-1'), true);
|
|
});
|
|
|
|
test('an Enterprise WeChat answer bypasses the original conversation queue', async () => {
|
|
const transport = testClient();
|
|
const answered = deferred();
|
|
const responses = [];
|
|
const bridge = new WecomHarnessBridge({
|
|
client: transport.client,
|
|
generateStreamId: (() => { let index = 0; return () => `stream-${++index}`; })(),
|
|
harness: {
|
|
sessionExists: async () => true,
|
|
ask: async (_sessionId, _text, options) => {
|
|
await options.onInteraction(questionInteraction({
|
|
respond: async (result) => {
|
|
responses.push(result);
|
|
answered.resolve();
|
|
},
|
|
}));
|
|
await answered.promise;
|
|
return '你选择了：测试环境';
|
|
},
|
|
},
|
|
state: state(),
|
|
});
|
|
|
|
const prompt = bridge.accept(frame({ msgid: 'question-start' }));
|
|
await eventually(() => transport.active.some(({ body }) => (
|
|
body.markdown.content.includes('请选择测试环境')
|
|
)));
|
|
const answer = bridge.accept(frame({
|
|
msgid: 'question-answer',
|
|
text: { content: '1' },
|
|
}));
|
|
await Promise.all([prompt, answer]);
|
|
|
|
assert.deepEqual(responses, [{
|
|
ok: true,
|
|
value: {
|
|
sessionId: 'session-existing',
|
|
answer: { answers: [{ id: 'environment', selected: ['测试环境'] }] },
|
|
},
|
|
}]);
|
|
assert.equal(transport.streamed.at(-1).content, '你选择了：测试环境');
|
|
assert.equal(transport.streamed.at(-1).finish, true);
|
|
});
|
|
|
|
test('an answer waits for the first Enterprise WeChat question delivery acknowledgement', async () => {
|
|
const questionSendStarted = deferred();
|
|
const questionAcknowledged = deferred();
|
|
const answered = deferred();
|
|
const streamed = [];
|
|
const active = [];
|
|
const prompts = [];
|
|
const responses = [];
|
|
const bridge = new WecomHarnessBridge({
|
|
client: {
|
|
replyStream: async (source, streamId, content, finish) => {
|
|
streamed.push({ messageId: source.body.msgid, streamId, content, finish });
|
|
},
|
|
sendMessage: async (chatId, body) => {
|
|
active.push({ chatId, body });
|
|
questionSendStarted.resolve();
|
|
await questionAcknowledged.promise;
|
|
},
|
|
},
|
|
generateStreamId: (() => { let index = 0; return () => `first-ack-${++index}`; })(),
|
|
harness: {
|
|
sessionExists: async () => true,
|
|
ask: async (_sessionId, text, options) => {
|
|
prompts.push(text);
|
|
await options.onInteraction(questionInteraction({
|
|
interactionId: 'first-ack-question',
|
|
respond: async (result) => {
|
|
responses.push(result);
|
|
answered.resolve();
|
|
},
|
|
}));
|
|
await answered.promise;
|
|
return '首问回答完成';
|
|
},
|
|
},
|
|
state: state(),
|
|
});
|
|
|
|
const prompt = bridge.accept(frame({ msgid: 'first-ack-start' }));
|
|
await questionSendStarted.promise;
|
|
let answerSettled = false;
|
|
const answer = bridge.accept(frame({
|
|
msgid: 'first-ack-answer',
|
|
text: { content: '1' },
|
|
}));
|
|
answer.then(
|
|
() => { answerSettled = true; },
|
|
() => { answerSettled = true; },
|
|
);
|
|
await new Promise((resolve) => setImmediate(resolve));
|
|
|
|
assert.equal(answerSettled, false);
|
|
assert.equal(active.length, 1);
|
|
assert.deepEqual(responses, []);
|
|
|
|
questionAcknowledged.resolve();
|
|
await eventually(() => responses.length === 1);
|
|
await Promise.all([prompt, answer]);
|
|
|
|
assert.deepEqual(prompts, ['请回答']);
|
|
assert.equal(active.length, 1);
|
|
assert.deepEqual(responses[0].value.answer.answers, [
|
|
{ id: 'environment', selected: ['测试环境'] },
|
|
]);
|
|
assert.equal(streamed.at(-1).content, '首问回答完成');
|
|
});
|
|
|
|
test('pending Enterprise WeChat questions stay isolated by conversation', async () => {
|
|
const transport = testClient();
|
|
const gates = new Map([
|
|
['ask-a', deferred()],
|
|
['ask-b', deferred()],
|
|
]);
|
|
const responses = [];
|
|
const bridge = new WecomHarnessBridge({
|
|
client: transport.client,
|
|
generateStreamId: (() => { let index = 0; return () => `isolation-${++index}`; })(),
|
|
harness: {
|
|
sessionExists: async () => true,
|
|
ask: async (_sessionId, text, options) => {
|
|
const gate = gates.get(text);
|
|
await options.onInteraction(questionInteraction({
|
|
interactionId: `question-${text}`,
|
|
respond: async (result) => {
|
|
responses.push({ text, result });
|
|
gate.resolve();
|
|
},
|
|
}));
|
|
await gate.promise;
|
|
return `done-${text}`;
|
|
},
|
|
},
|
|
state: state(),
|
|
});
|
|
|
|
const first = bridge.accept(frame({
|
|
msgid: 'isolation-a',
|
|
from: { userid: 'member-a' },
|
|
text: { content: 'ask-a' },
|
|
}));
|
|
const second = bridge.accept(frame({
|
|
msgid: 'isolation-b',
|
|
from: { userid: 'member-b' },
|
|
text: { content: 'ask-b' },
|
|
}));
|
|
await eventually(() => transport.active.filter(({ body }) => (
|
|
body.markdown.content.includes('请选择测试环境')
|
|
)).length === 2);
|
|
|
|
const answerA = bridge.accept(frame({
|
|
msgid: 'isolation-answer-a',
|
|
from: { userid: 'member-a' },
|
|
text: { content: '1' },
|
|
}));
|
|
await Promise.all([first, answerA]);
|
|
assert.deepEqual(responses.map(({ text }) => text), ['ask-a']);
|
|
|
|
const answerB = bridge.accept(frame({
|
|
msgid: 'isolation-answer-b',
|
|
from: { userid: 'member-b' },
|
|
text: { content: '2' },
|
|
}));
|
|
await Promise.all([second, answerB]);
|
|
assert.deepEqual(responses.map(({ text }) => text), ['ask-a', 'ask-b']);
|
|
assert.deepEqual(
|
|
responses[1].result.value.answer.answers,
|
|
[{ id: 'environment', selected: ['生产环境'] }],
|
|
);
|
|
});
|
|
|
|
test('Enterprise WeChat accepts only an exact approval decision and never forwards a fuzzy reply', async () => {
|
|
const transport = testClient();
|
|
const completed = deferred();
|
|
const prompts = [];
|
|
const responses = [];
|
|
const bridge = new WecomHarnessBridge({
|
|
client: transport.client,
|
|
generateStreamId: (() => { let index = 0; return () => `approval-${++index}`; })(),
|
|
harness: {
|
|
sessionExists: async () => true,
|
|
ask: async (sessionId, text, options) => {
|
|
prompts.push(text);
|
|
await options.onInteraction({
|
|
kind: 'approval',
|
|
interactionId: 'wecom-approval',
|
|
rpcId: 'wecom-approval-rpc',
|
|
sessionId,
|
|
payload: {
|
|
type: 'approval/requested',
|
|
sessionId,
|
|
approvalId: 'wecom-approval',
|
|
toolName: 'bash',
|
|
callId: 'wecom-approval-call',
|
|
reason: '允许执行企业微信审批测试',
|
|
},
|
|
toolCall: {
|
|
callId: 'wecom-approval-call',
|
|
name: 'bash',
|
|
arguments: JSON.stringify({ command: "printf 'wecom-approval\\n'" }),
|
|
},
|
|
respond: async (result) => {
|
|
responses.push(result);
|
|
completed.resolve();
|
|
return { accepted: true };
|
|
},
|
|
});
|
|
await completed.promise;
|
|
return '审批已继续';
|
|
},
|
|
},
|
|
state: state(),
|
|
});
|
|
|
|
const outputTexts = () => [
|
|
...transport.active.map(({ body }) => body.markdown.content),
|
|
...transport.streamed.map(({ content }) => content),
|
|
];
|
|
const prompt = bridge.accept(frame({
|
|
msgid: 'approval-start',
|
|
text: { content: '启动审批' },
|
|
}));
|
|
await eventually(() => outputTexts().some((text) => text.includes('允许执行企业微信审批测试')));
|
|
|
|
const outputCountBeforeFuzzyReply = outputTexts().length;
|
|
const fuzzy = bridge.accept(frame({
|
|
msgid: 'approval-fuzzy',
|
|
text: { content: '可以' },
|
|
}));
|
|
await eventually(() => outputTexts().slice(outputCountBeforeFuzzyReply).some((text) => text.includes('回复')
|
|
&& text.includes('批准') && text.includes('拒绝')));
|
|
assert.deepEqual(responses, []);
|
|
assert.deepEqual(prompts, ['启动审批']);
|
|
|
|
await Promise.all([
|
|
fuzzy,
|
|
bridge.accept(frame({
|
|
msgid: 'approval-exact',
|
|
text: { content: ' YES ' },
|
|
})),
|
|
prompt,
|
|
]);
|
|
|
|
assert.deepEqual(responses, [{
|
|
ok: true,
|
|
value: {
|
|
sessionId: 'session-existing',
|
|
approvalId: 'wecom-approval',
|
|
outcome: 'allowed-once',
|
|
},
|
|
}]);
|
|
assert.deepEqual(prompts, ['启动审批']);
|
|
});
|
|
|
|
test('question replays are deduplicated and approvals remain fail-closed', async () => {
|
|
const transport = testClient();
|
|
const answered = deferred();
|
|
let approvalResponses = 0;
|
|
let questionResponses = 0;
|
|
const bridge = new WecomHarnessBridge({
|
|
client: transport.client,
|
|
generateStreamId: () => 'replay-stream',
|
|
harness: {
|
|
sessionExists: async () => true,
|
|
ask: async (_sessionId, _text, options) => {
|
|
await options.onInteraction({
|
|
kind: 'approval',
|
|
interactionId: 'approval-1',
|
|
rpcId: 'approval-rpc-1',
|
|
sessionId: 'session-existing',
|
|
payload: { type: 'approval/requested', toolName: 'bash' },
|
|
respond: async () => { approvalResponses += 1; },
|
|
});
|
|
const interaction = questionInteraction({
|
|
interactionId: 'replayed-question',
|
|
respond: async () => {
|
|
questionResponses += 1;
|
|
answered.resolve();
|
|
},
|
|
});
|
|
await options.onInteraction(interaction);
|
|
await options.onInteraction({ ...interaction });
|
|
await answered.promise;
|
|
return 'done';
|
|
},
|
|
},
|
|
state: state(),
|
|
});
|
|
|
|
const prompt = bridge.accept(frame({ msgid: 'replay-start' }));
|
|
await eventually(() => transport.active.length === 1);
|
|
const answer = bridge.accept(frame({ msgid: 'replay-answer', text: { content: '1' } }));
|
|
await Promise.all([prompt, answer]);
|
|
|
|
assert.equal(transport.active.length, 1);
|
|
assert.equal(approvalResponses, 0);
|
|
assert.equal(questionResponses, 1);
|
|
});
|
|
|
|
test('a failed Enterprise WeChat interaction response can be retried', async () => {
|
|
const transport = testClient();
|
|
const answered = deferred();
|
|
const attempts = [];
|
|
const bridge = new WecomHarnessBridge({
|
|
client: transport.client,
|
|
generateStreamId: (() => { let index = 0; return () => `retry-${++index}`; })(),
|
|
harness: {
|
|
sessionExists: async () => true,
|
|
ask: async (_sessionId, _text, options) => {
|
|
await options.onInteraction(questionInteraction({
|
|
respond: async (result) => {
|
|
attempts.push(structuredClone(result.value.answer.answers));
|
|
if (attempts.length === 1) throw new Error('temporary response failure');
|
|
answered.resolve();
|
|
},
|
|
}));
|
|
await answered.promise;
|
|
return 'retry complete';
|
|
},
|
|
},
|
|
state: state(),
|
|
logger: { error() {} },
|
|
});
|
|
|
|
const prompt = bridge.accept(frame({ msgid: 'retry-start' }));
|
|
await eventually(() => transport.active.length === 1);
|
|
await bridge.accept(frame({ msgid: 'retry-first', text: { content: '1' } }));
|
|
assert.equal(transport.streamed.some(({ content }) => content.includes('回答提交失败')), true);
|
|
|
|
const second = bridge.accept(frame({ msgid: 'retry-second', text: { content: '2' } }));
|
|
await Promise.all([prompt, second]);
|
|
assert.deepEqual(attempts, [
|
|
[{ id: 'environment', selected: ['测试环境'] }],
|
|
[{ id: 'environment', selected: ['生产环境'] }],
|
|
]);
|
|
});
|
|
|
|
test('an externally resolved Enterprise WeChat answer is not submitted as a new prompt', async () => {
|
|
const transport = testClient();
|
|
const resolved = deferred();
|
|
let interactionOptions;
|
|
const prompts = [];
|
|
const bridge = new WecomHarnessBridge({
|
|
client: transport.client,
|
|
generateStreamId: (() => { let index = 0; return () => `resolved-${++index}`; })(),
|
|
harness: {
|
|
sessionExists: async () => true,
|
|
ask: async (_sessionId, text, options) => {
|
|
prompts.push(text);
|
|
interactionOptions = options;
|
|
await options.onInteraction(questionInteraction({ interactionId: 'resolved-question' }));
|
|
await resolved.promise;
|
|
return '外部客户端已处理';
|
|
},
|
|
},
|
|
state: state(),
|
|
});
|
|
|
|
const prompt = bridge.accept(frame({ msgid: 'resolved-start' }));
|
|
await eventually(() => transport.active.length === 1 && interactionOptions);
|
|
const lateAnswer = bridge.accept(frame({
|
|
msgid: 'resolved-answer',
|
|
text: { content: '1' },
|
|
}));
|
|
interactionOptions.onInteractionResolved({
|
|
kind: 'question',
|
|
interactionId: 'resolved-question',
|
|
});
|
|
resolved.resolve();
|
|
await Promise.all([prompt, lateAnswer]);
|
|
|
|
assert.deepEqual(prompts, ['请回答']);
|
|
assert.equal(transport.streamed.some(({ messageId, content }) => (
|
|
messageId === 'resolved-answer' && content === '这个问题已在其他客户端处理，无需再次回答。'
|
|
)), true);
|
|
});
|
|
|
|
test('an Enterprise WeChat answer reports resolution when respond loses an in-flight race', async () => {
|
|
const transport = testClient();
|
|
const responseStarted = deferred();
|
|
const releaseResponse = deferred();
|
|
const turnResolved = deferred();
|
|
const prompts = [];
|
|
let interactionOptions;
|
|
const bridge = new WecomHarnessBridge({
|
|
client: transport.client,
|
|
generateStreamId: (() => { let index = 0; return () => `respond-race-${++index}`; })(),
|
|
harness: {
|
|
sessionExists: async () => true,
|
|
ask: async (_sessionId, text, options) => {
|
|
prompts.push(text);
|
|
interactionOptions = options;
|
|
await options.onInteraction(questionInteraction({
|
|
interactionId: 'respond-race-question',
|
|
respond: async () => {
|
|
responseStarted.resolve();
|
|
await releaseResponse.promise;
|
|
const error = new Error('interaction resolved elsewhere');
|
|
error.code = 'interaction-not-pending';
|
|
throw error;
|
|
},
|
|
}));
|
|
await turnResolved.promise;
|
|
return '外部客户端已完成';
|
|
},
|
|
},
|
|
state: state(),
|
|
});
|
|
|
|
const prompt = bridge.accept(frame({ msgid: 'respond-race-start' }));
|
|
await eventually(() => transport.active.length === 1 && interactionOptions);
|
|
const answer = bridge.accept(frame({
|
|
msgid: 'respond-race-answer',
|
|
text: { content: '1' },
|
|
}));
|
|
await responseStarted.promise;
|
|
|
|
interactionOptions.onInteractionResolved({
|
|
kind: 'question',
|
|
interactionId: 'respond-race-question',
|
|
});
|
|
turnResolved.resolve();
|
|
releaseResponse.resolve();
|
|
await Promise.all([prompt, answer]);
|
|
|
|
assert.deepEqual(prompts, ['请回答']);
|
|
assert.equal(transport.streamed.filter(({ messageId, content }) => (
|
|
messageId === 'respond-race-answer'
|
|
&& content === '这个问题已在其他客户端处理，无需再次回答。'
|
|
)).length, 1);
|
|
});
|
|
|
|
test('a recovered orphan question is cancelled without exposing its content', async () => {
|
|
const transport = testClient();
|
|
const responses = [];
|
|
const bridge = new WecomHarnessBridge({
|
|
client: transport.client,
|
|
generateStreamId: () => 'orphan-stream',
|
|
harness: {
|
|
sessionExists: async () => true,
|
|
ask: async (_sessionId, _text, options) => {
|
|
await options.onInteraction(questionInteraction({
|
|
recovered: true,
|
|
questions: [{ id: 'secret', question: '不应显示的旧问题' }],
|
|
respond: async (result) => responses.push(result),
|
|
}));
|
|
return '新消息继续完成';
|
|
},
|
|
},
|
|
state: state(),
|
|
});
|
|
|
|
await bridge.accept(frame({ msgid: 'orphan-start' }));
|
|
assert.equal(responses[0].ok, false);
|
|
assert.equal(responses[0].error.code, 'cancelled');
|
|
assert.equal(transport.active.some(({ body }) => (
|
|
body.markdown.content.includes('不应显示的旧问题')
|
|
)), false);
|
|
assert.equal(transport.active.some(({ body }) => (
|
|
body.markdown.content.includes('遗留的待回答问题')
|
|
)), true);
|
|
});
|
|
|
|
test('multi-question Enterprise WeChat interactions preserve canonical answer order', async () => {
|
|
const transport = testClient();
|
|
const answered = deferred();
|
|
let submitted;
|
|
const questions = [
|
|
{
|
|
id: 'environment',
|
|
question: '请选择环境',
|
|
options: [{ label: '测试环境' }, { label: '生产环境' }],
|
|
},
|
|
{
|
|
id: 'features',
|
|
question: '请选择功能',
|
|
multiSelect: true,
|
|
options: [{ label: '日志' }, { label: '指标' }],
|
|
},
|
|
];
|
|
const bridge = new WecomHarnessBridge({
|
|
client: transport.client,
|
|
generateStreamId: (() => { let index = 0; return () => `batch-${++index}`; })(),
|
|
harness: {
|
|
sessionExists: async () => true,
|
|
ask: async (_sessionId, _text, options) => {
|
|
await options.onInteraction(questionInteraction({
|
|
interactionId: 'batch-question',
|
|
questions,
|
|
respond: async (result) => {
|
|
submitted = result;
|
|
answered.resolve();
|
|
},
|
|
}));
|
|
await answered.promise;
|
|
return 'batch complete';
|
|
},
|
|
},
|
|
state: state(),
|
|
});
|
|
|
|
const prompt = bridge.accept(frame({ msgid: 'batch-start' }));
|
|
await eventually(() => transport.active.length === 1);
|
|
await bridge.accept(frame({ msgid: 'batch-first', text: { content: '2' } }));
|
|
await eventually(() => transport.active.length === 2);
|
|
const second = bridge.accept(frame({
|
|
msgid: 'batch-second',
|
|
text: { content: '1, 指标, 自定义' },
|
|
}));
|
|
await Promise.all([prompt, second]);
|
|
|
|
assert.deepEqual(submitted.value.answer.answers, [
|
|
{ id: 'environment', selected: ['生产环境'] },
|
|
{ id: 'features', selected: ['日志', '指标'], custom: '自定义' },
|
|
]);
|
|
});
|
|
|
|
test('a second answer stays claimed while its Enterprise WeChat question awaits acknowledgement', async () => {
|
|
const secondQuestionStarted = deferred();
|
|
const secondQuestionAcknowledged = deferred();
|
|
const turnResolved = deferred();
|
|
const streamed = [];
|
|
const active = [];
|
|
const prompts = [];
|
|
let interactionOptions;
|
|
let responseCalls = 0;
|
|
const bridge = new WecomHarnessBridge({
|
|
client: {
|
|
replyStream: async (source, streamId, content, finish) => {
|
|
streamed.push({ messageId: source.body.msgid, streamId, content, finish });
|
|
},
|
|
sendMessage: async (chatId, body) => {
|
|
active.push({ chatId, body });
|
|
if (body.markdown.content.includes('请选择功能')) {
|
|
secondQuestionStarted.resolve();
|
|
await secondQuestionAcknowledged.promise;
|
|
}
|
|
},
|
|
},
|
|
generateStreamId: (() => { let index = 0; return () => `second-ack-${++index}`; })(),
|
|
harness: {
|
|
sessionExists: async () => true,
|
|
ask: async (_sessionId, text, options) => {
|
|
prompts.push(text);
|
|
interactionOptions = options;
|
|
await options.onInteraction(questionInteraction({
|
|
interactionId: 'second-ack-question',
|
|
questions: [
|
|
{
|
|
id: 'environment',
|
|
question: '请选择环境',
|
|
options: [{ label: '测试环境' }, { label: '生产环境' }],
|
|
},
|
|
{
|
|
id: 'features',
|
|
question: '请选择功能',
|
|
options: [{ label: '日志' }, { label: '指标' }],
|
|
},
|
|
],
|
|
respond: async () => { responseCalls += 1; },
|
|
}));
|
|
await turnResolved.promise;
|
|
return '外部客户端已处理多问';
|
|
},
|
|
},
|
|
state: state(),
|
|
});
|
|
|
|
const prompt = bridge.accept(frame({ msgid: 'second-ack-start' }));
|
|
await eventually(() => active.some(({ body }) => body.markdown.content.includes('请选择环境')));
|
|
const firstAnswer = bridge.accept(frame({
|
|
msgid: 'second-ack-first',
|
|
text: { content: '1' },
|
|
}));
|
|
await secondQuestionStarted.promise;
|
|
const secondAnswer = bridge.accept(frame({
|
|
msgid: 'second-ack-answer',
|
|
text: { content: '2' },
|
|
}));
|
|
|
|
interactionOptions.onInteractionResolved({
|
|
kind: 'question',
|
|
interactionId: 'second-ack-question',
|
|
});
|
|
turnResolved.resolve();
|
|
secondQuestionAcknowledged.resolve();
|
|
await Promise.all([prompt, firstAnswer, secondAnswer]);
|
|
|
|
assert.deepEqual(prompts, ['请回答']);
|
|
assert.equal(responseCalls, 0);
|
|
assert.equal(streamed.filter(({ messageId, content }) => (
|
|
messageId === 'second-ack-answer'
|
|
&& content === '这个问题已在其他客户端处理，无需再次回答。'
|
|
)).length, 1);
|
|
});
|
|
|
|
test('only the initiating actor can answer an Enterprise WeChat group question', async () => {
|
|
const transport = testClient();
|
|
const answered = deferred();
|
|
const order = [];
|
|
let groupResponse;
|
|
const bridge = new WecomHarnessBridge({
|
|
client: transport.client,
|
|
generateStreamId: (() => { let index = 0; return () => `group-${++index}`; })(),
|
|
harness: {
|
|
sessionExists: async () => true,
|
|
ask: async (_sessionId, text, options) => {
|
|
if (text !== '启动问题') {
|
|
order.push(`normal:${text}`);
|
|
return '普通消息完成';
|
|
}
|
|
await options.onInteraction(questionInteraction({
|
|
interactionId: 'group-question',
|
|
respond: async (result) => {
|
|
groupResponse = result;
|
|
order.push('answered');
|
|
answered.resolve();
|
|
},
|
|
}));
|
|
await answered.promise;
|
|
return '问题完成';
|
|
},
|
|
},
|
|
state: state(),
|
|
});
|
|
|
|
const prompt = bridge.accept(frame({
|
|
msgid: 'group-start',
|
|
chattype: 'group',
|
|
chatid: 'group-1',
|
|
from: { userid: 'member-a' },
|
|
text: { content: '@RobotA 启动问题' },
|
|
}));
|
|
await eventually(() => transport.active.some(({ chatId }) => chatId === 'group-1'));
|
|
assert.match(
|
|
transport.active.find(({ chatId }) => chatId === 'group-1').body.markdown.content,
|
|
/群聊中请 @机器人 后发送答案/,
|
|
);
|
|
const outsider = bridge.accept(frame({
|
|
msgid: 'group-outsider',
|
|
chattype: 'group',
|
|
chatid: 'group-1',
|
|
from: { userid: 'member-b' },
|
|
text: { content: '@RobotA 1' },
|
|
}));
|
|
await new Promise((resolve) => setImmediate(resolve));
|
|
assert.deepEqual(order, []);
|
|
|
|
const actor = bridge.accept(frame({
|
|
msgid: 'group-actor',
|
|
chattype: 'group',
|
|
chatid: 'group-1',
|
|
from: { userid: 'member-a' },
|
|
text: { content: '@RobotA 2' },
|
|
}));
|
|
await Promise.all([prompt, actor, outsider]);
|
|
assert.deepEqual(order, ['answered', 'normal:1']);
|
|
assert.deepEqual(groupResponse.value.answer.answers, [
|
|
{ id: 'environment', selected: ['生产环境'] },
|
|
]);
|
|
});
|
|
|
|
test('aborting Enterprise WeChat work cancels its pending question without a failure reply', async () => {
|
|
const transport = testClient();
|
|
const controller = new AbortController();
|
|
const cancellations = [];
|
|
const bridge = new WecomHarnessBridge({
|
|
client: transport.client,
|
|
generateStreamId: () => 'abort-stream',
|
|
signal: controller.signal,
|
|
harness: {
|
|
sessionExists: async () => true,
|
|
ask: async (_sessionId, _text, options) => {
|
|
assert.equal(options.signal, controller.signal);
|
|
await options.onInteraction(questionInteraction({
|
|
interactionId: 'abort-question',
|
|
respond: async (result, responseOptions) => {
|
|
cancellations.push({ result, responseOptions });
|
|
},
|
|
}));
|
|
await new Promise((resolve, reject) => {
|
|
if (options.signal.aborted) reject(options.signal.reason);
|
|
else options.signal.addEventListener('abort', () => reject(options.signal.reason), { once: true });
|
|
});
|
|
return 'unreachable';
|
|
},
|
|
},
|
|
state: state(),
|
|
});
|
|
|
|
const prompt = bridge.accept(frame({ msgid: 'abort-start' }));
|
|
await eventually(() => transport.active.length === 1);
|
|
controller.abort(new DOMException('runtime stopped', 'AbortError'));
|
|
await prompt;
|
|
|
|
assert.equal(cancellations.length, 1);
|
|
assert.equal(cancellations[0].result.ok, false);
|
|
assert.equal(cancellations[0].result.error.code, 'cancelled');
|
|
assert.equal(cancellations[0].responseOptions.signal.aborted, false);
|
|
assert.equal(transport.streamed.some(({ content }) => content === '消息处理失败，请稍后重试。'), false);
|
|
});
|
|
|
|
test('Enterprise WeChat sends registered files after the final text and continues after one file fails', async (t) => {
|
|
const first = await committedArtifact(t, 'first.txt', 'first bytes', 'partial-first');
|
|
const second = await committedArtifact(t, 'second.html', '<h1>second</h1>', 'partial-second');
|
|
const order = [];
|
|
const uploads = [];
|
|
const active = [];
|
|
const status = {
|
|
messagesReceived: 0,
|
|
messagesReplied: 0,
|
|
messagesRejected: 0,
|
|
artifactsSent: 0,
|
|
artifactSendErrors: 0,
|
|
lastMessageAt: null,
|
|
lastReplyAt: null,
|
|
lastRejectedAt: null,
|
|
lastError: null,
|
|
};
|
|
const client = {
|
|
replyStream: async (_source, _streamId, content, finish) => {
|
|
if (finish) order.push(`text:${content}`);
|
|
},
|
|
replyStreamNonBlocking: async () => {},
|
|
sendMessage: async (chatId, body) => {
|
|
const content = body.markdown.content;
|
|
active.push({ chatId, content });
|
|
order.push(`notice:${content}`);
|
|
return { body: { msgid: `notice-${active.length}` } };
|
|
},
|
|
uploadMedia: async (bytes, options) => {
|
|
uploads.push({ bytes: Buffer.from(bytes), options });
|
|
order.push(`upload:${options.filename}`);
|
|
return { media_id: `media-${options.filename}` };
|
|
},
|
|
sendMediaMessage: async (chatId, type, mediaId) => {
|
|
order.push(`file:${mediaId}`);
|
|
if (mediaId === 'media-first.txt') {
|
|
const error = new Error('private provider detail');
|
|
error.code = 'artifact-provider-failed';
|
|
throw error;
|
|
}
|
|
return { body: { msgid: 'wecom-file-2' }, chatId, type };
|
|
},
|
|
};
|
|
const bridge = new WecomHarnessBridge({
|
|
client,
|
|
generateStreamId: () => 'artifact-stream',
|
|
harness: {
|
|
sessionExists: async () => true,
|
|
ask: async (_sessionId, _text, options) => {
|
|
await options.onArtifact(first);
|
|
await options.onArtifact(second);
|
|
return '文件处理完成。';
|
|
},
|
|
},
|
|
state: state(),
|
|
status,
|
|
logger: { warn() {}, error() {} },
|
|
});
|
|
|
|
await bridge.accept(frame({ msgid: 'wecom-artifact-partial' }));
|
|
|
|
assert.deepEqual(order.map((entry) => entry.split(':', 1)[0]), [
|
|
'text', 'upload', 'file', 'notice', 'upload', 'file',
|
|
]);
|
|
assert.deepEqual(uploads.map(({ options }) => options), [
|
|
{ type: 'file', filename: 'first.txt' },
|
|
{ type: 'file', filename: 'second.html' },
|
|
]);
|
|
assert.equal(uploads[0].bytes.toString(), 'first bytes');
|
|
assert.equal(uploads[1].bytes.toString(), '<h1>second</h1>');
|
|
assert.equal(active.length, 1);
|
|
assert.match(active[0].content, /first\.txt.*暂时未能/);
|
|
assert.doesNotMatch(active[0].content, /private provider detail/);
|
|
assert.equal(status.artifactsSent, 1);
|
|
assert.equal(status.artifactSendErrors, 1);
|
|
});
|
|
|
|
test('Enterprise WeChat still delivers registered files when final text delivery fails', async (t) => {
|
|
const artifact = await committedArtifact(
|
|
t,
|
|
'survives-text-failure.txt',
|
|
'file bytes',
|
|
'text-failure',
|
|
);
|
|
const files = [];
|
|
let finalTextAttempts = 0;
|
|
let activeTextAttempts = 0;
|
|
const bridge = new WecomHarnessBridge({
|
|
client: {
|
|
replyStream: async (_source, _streamId, _content, finish) => {
|
|
if (finish) {
|
|
finalTextAttempts += 1;
|
|
throw new Error('stream finalization unavailable');
|
|
}
|
|
},
|
|
replyStreamNonBlocking: async () => {},
|
|
sendMessage: async () => {
|
|
activeTextAttempts += 1;
|
|
throw new Error('active text unavailable');
|
|
},
|
|
uploadMedia: async () => ({ media_id: 'media-after-text-failure' }),
|
|
sendMediaMessage: async (chatId, type, mediaId) => {
|
|
files.push({ chatId, type, mediaId });
|
|
return { body: { msgid: 'wecom-file-after-text-failure' } };
|
|
},
|
|
},
|
|
generateStreamId: () => 'text-failure-stream',
|
|
harness: {
|
|
sessionExists: async () => true,
|
|
ask: async (_sessionId, _text, options) => {
|
|
await options.onArtifact(artifact);
|
|
return '文字结果';
|
|
},
|
|
},
|
|
state: state(),
|
|
logger: { warn() {}, error() {} },
|
|
});
|
|
|
|
await bridge.accept(frame({ msgid: 'wecom-text-failure' }));
|
|
|
|
assert.deepEqual(files, [{
|
|
chatId: 'member-1',
|
|
type: 'file',
|
|
mediaId: 'media-after-text-failure',
|
|
}]);
|
|
assert.equal(finalTextAttempts, 1, 'must not append a generic retry stream after file success');
|
|
assert.equal(activeTextAttempts, 1);
|
|
});
|
|
|
|
test('Enterprise WeChat returns the authoritative receipt and one safe notice when text and file delivery fail', async (t) => {
|
|
const artifact = await committedArtifact(t, 'mismatch.txt', 'file bytes', 'all-fail');
|
|
const attemptedActiveTexts = [];
|
|
const visibleActiveTexts = [];
|
|
const finalStreamTexts = [];
|
|
const bridge = new WecomHarnessBridge({
|
|
client: {
|
|
replyStream: async (_source, _streamId, content, finish) => {
|
|
if (finish) {
|
|
finalStreamTexts.push(content);
|
|
throw new Error('stream finalization unavailable');
|
|
}
|
|
},
|
|
replyStreamNonBlocking: async () => {},
|
|
sendMessage: async (_chatId, body) => {
|
|
const text = body.markdown.content;
|
|
attemptedActiveTexts.push(text);
|
|
if (text === '文字结果') throw new Error('active text unavailable');
|
|
visibleActiveTexts.push(text);
|
|
return {};
|
|
},
|
|
uploadMedia: async () => {
|
|
const error = new Error('mismatched file signature');
|
|
error.code = 'artifact-invalid';
|
|
throw error;
|
|
},
|
|
sendMediaMessage: async () => assert.fail('a rejected upload must not be sent'),
|
|
},
|
|
generateStreamId: () => 'all-fail-stream',
|
|
harness: {
|
|
sessionExists: async () => true,
|
|
ask: async (_sessionId, _text, options) => {
|
|
await options.onArtifact(artifact);
|
|
return '文字结果';
|
|
},
|
|
},
|
|
state: state(),
|
|
logger: { warn() {}, error() {} },
|
|
});
|
|
|
|
const receipt = await bridge.accept(frame({ msgid: 'wecom-all-fail' }));
|
|
|
|
assert.deepEqual(finalStreamTexts, ['文字结果']);
|
|
assert.equal(attemptedActiveTexts.length, 2, 'must not append a generic error after the safe notice');
|
|
assert.equal(visibleActiveTexts.length, 1);
|
|
assert.match(visibleActiveTexts[0], /暂时无法读取或准备发送.*仍可访问/);
|
|
assert.deepEqual(receipt, {
|
|
schemaVersion: 1,
|
|
deliveryId: 'wecom-all-fail',
|
|
presentation: 'wecom-files',
|
|
providerMessageIds: [],
|
|
artifacts: [{
|
|
artifactId: artifact.artifactId,
|
|
outcome: 'rejected',
|
|
reason: 'artifact-invalid',
|
|
}],
|
|
});
|
|
});
|
|
|
|
test('Enterprise WeChat keeps the generic error when no answer or file failure notice is visible', async (t) => {
|
|
const artifact = await committedArtifact(t, 'unavailable.txt', 'file bytes', 'no-visible-failure');
|
|
const attemptedActiveTexts = [];
|
|
const finalStreamTexts = [];
|
|
const bridge = new WecomHarnessBridge({
|
|
client: {
|
|
replyStream: async (_source, _streamId, content, finish) => {
|
|
if (!finish) return;
|
|
finalStreamTexts.push(content);
|
|
if (finalStreamTexts.length === 1) throw new Error('stream finalization unavailable');
|
|
},
|
|
replyStreamNonBlocking: async () => {},
|
|
sendMessage: async (_chatId, body) => {
|
|
attemptedActiveTexts.push(body.markdown.content);
|
|
throw new Error('active text unavailable');
|
|
},
|
|
uploadMedia: async () => {
|
|
const error = new Error('file transport unavailable');
|
|
error.code = 'artifact-provider-failed';
|
|
throw error;
|
|
},
|
|
sendMediaMessage: async () => assert.fail('a rejected upload must not be sent'),
|
|
},
|
|
generateStreamId: () => 'no-visible-failure-stream',
|
|
harness: {
|
|
sessionExists: async () => true,
|
|
ask: async (_sessionId, _text, options) => {
|
|
await options.onArtifact(artifact);
|
|
return '文字结果';
|
|
},
|
|
},
|
|
state: state(),
|
|
logger: { warn() {}, error() {} },
|
|
});
|
|
|
|
await bridge.accept(frame({ msgid: 'wecom-no-visible-failure' }));
|
|
|
|
assert.equal(attemptedActiveTexts.length, 2);
|
|
assert.deepEqual(finalStreamTexts, ['文字结果', '消息处理失败，请稍后重试。']);
|
|
});
|
|
|
|
test('Enterprise WeChat reports an unacknowledged file message as uncertain', async (t) => {
|
|
const artifact = await committedArtifact(t, 'uncertain.txt', 'file bytes', 'uncertain');
|
|
const active = [];
|
|
const bridge = new WecomHarnessBridge({
|
|
client: {
|
|
replyStream: async () => {},
|
|
replyStreamNonBlocking: async () => {},
|
|
sendMessage: async (_chatId, body) => active.push(body.markdown.content),
|
|
uploadMedia: async () => ({ media_id: 'media-uncertain' }),
|
|
sendMediaMessage: async () => new Promise(() => {}),
|
|
},
|
|
harness: {
|
|
sessionExists: async () => true,
|
|
ask: async (_sessionId, _text, options) => {
|
|
await options.onArtifact(artifact);
|
|
return '文件已生成。';
|
|
},
|
|
},
|
|
state: state(),
|
|
fileUploadTimeoutMs: 20,
|
|
logger: { warn() {}, error() {} },
|
|
});
|
|
|
|
await bridge.accept(frame({ msgid: 'wecom-uncertain-file' }));
|
|
|
|
assert.match(active[0], /发送结果未能确认.*先检查聊天内是否已收到.*不要立即重试/);
|
|
});
|
|
|
|
test('Enterprise WeChat cancellation interrupts an in-flight file send and skips later files', async (t) => {
|
|
const first = await committedArtifact(t, 'first.txt', 'first', 'abort-first');
|
|
const second = await committedArtifact(t, 'second.txt', 'second', 'abort-second');
|
|
const started = deferred();
|
|
const controller = new AbortController();
|
|
const uploads = [];
|
|
const active = [];
|
|
const bridge = new WecomHarnessBridge({
|
|
client: {
|
|
replyStream: async () => {},
|
|
replyStreamNonBlocking: async () => {},
|
|
sendMessage: async (_chatId, body) => active.push(body.markdown.content),
|
|
uploadMedia: async (_bytes, options) => {
|
|
uploads.push(options.filename);
|
|
return { media_id: `media-${options.filename}` };
|
|
},
|
|
sendMediaMessage: async () => {
|
|
started.resolve();
|
|
return new Promise(() => {});
|
|
},
|
|
},
|
|
harness: {
|
|
sessionExists: async () => true,
|
|
ask: async (_sessionId, _text, options) => {
|
|
await options.onArtifact(first);
|
|
await options.onArtifact(second);
|
|
return '文件如下。';
|
|
},
|
|
},
|
|
state: state(),
|
|
signal: controller.signal,
|
|
logger: { warn() {}, error() {} },
|
|
});
|
|
|
|
const processing = bridge.accept(frame({ msgid: 'wecom-abort-file' }));
|
|
await started.promise;
|
|
controller.abort(new DOMException('runtime stopped', 'AbortError'));
|
|
await Promise.race([
|
|
processing,
|
|
new Promise((_, reject) => setTimeout(() => reject(new Error('WeCom abort timed out')), 500)),
|
|
]);
|
|
|
|
assert.deepEqual(uploads, ['first.txt']);
|
|
assert.equal(active.some((text) => text.includes('发送结果未能确认')), false);
|
|
assert.equal(active.some((text) => text === '消息处理失败，请稍后重试。'), false);
|
|
});
|
|
|
|
test('Enterprise WeChat uses a neutral final text for a file-only Turn', async (t) => {
|
|
const artifact = await committedArtifact(t, 'only.txt', 'only bytes', 'file-only');
|
|
const finalTexts = [];
|
|
const files = [];
|
|
const bridge = new WecomHarnessBridge({
|
|
client: {
|
|
replyStream: async (_source, _streamId, content, finish) => {
|
|
if (finish) finalTexts.push(content);
|
|
},
|
|
replyStreamNonBlocking: async () => {},
|
|
sendMessage: async () => {},
|
|
uploadMedia: async () => ({ media_id: 'media-only' }),
|
|
sendMediaMessage: async (chatId, type, mediaId) => {
|
|
files.push({ chatId, type, mediaId });
|
|
return {};
|
|
},
|
|
},
|
|
generateStreamId: () => 'file-only-stream',
|
|
harness: {
|
|
sessionExists: async () => true,
|
|
ask: async (_sessionId, _text, options) => {
|
|
await options.onArtifact(artifact);
|
|
return '';
|
|
},
|
|
},
|
|
state: state(),
|
|
});
|
|
|
|
await bridge.accept(frame({ msgid: 'wecom-file-only' }));
|
|
|
|
assert.deepEqual(finalTexts, ['结果文件已生成。']);
|
|
assert.deepEqual(files, [{ chatId: 'member-1', type: 'file', mediaId: 'media-only' }]);
|
|
});
|
|
|
|
test('Enterprise WeChat cancellation prevents SDK upload', async (t) => {
|
|
let uploads = 0;
|
|
const artifact = await committedArtifact(t, 'cancelled.txt', 'cancelled bytes', 'cancelled');
|
|
const controller = new AbortController();
|
|
const cancelledBridge = new WecomHarnessBridge({
|
|
client: {
|
|
replyStream: async () => {},
|
|
replyStreamNonBlocking: async () => {},
|
|
sendMessage: async () => {},
|
|
uploadMedia: async () => { uploads += 1; return { media_id: 'must-not-upload' }; },
|
|
sendMediaMessage: async () => {},
|
|
},
|
|
harness: {
|
|
sessionExists: async () => true,
|
|
ask: async (_sessionId, _text, options) => {
|
|
await options.onArtifact(artifact);
|
|
controller.abort(new DOMException('stopped', 'AbortError'));
|
|
return '停止前的回答';
|
|
},
|
|
},
|
|
state: state(),
|
|
signal: controller.signal,
|
|
});
|
|
await cancelledBridge.accept(frame({ msgid: 'wecom-artifact-cancelled' }));
|
|
assert.equal(uploads, 0);
|
|
});
|