1222 lines
39 KiB
TypeScript
1222 lines
39 KiB
TypeScript
import { describe, expect, it } from "bun:test";
|
|
|
|
import {
|
|
streamPromptResponse,
|
|
type PermissionRequestPayload,
|
|
} from "../../src/routes/chatStream.js";
|
|
import { type OpencodeRuntimeAdapter } from "../../src/runtime/opencode.js";
|
|
|
|
const createEventStream = (events: unknown[]) => ({
|
|
async *[Symbol.asyncIterator]() {
|
|
for (const event of events) {
|
|
yield event;
|
|
}
|
|
},
|
|
});
|
|
|
|
describe("streamPromptResponse", () => {
|
|
it("emits only the final assistant text after tool-driven intermediate messages", async () => {
|
|
let subscribedDirectory: string | undefined;
|
|
const runtime = {
|
|
subscribeEvents: async (directory?: string) => {
|
|
subscribedDirectory = directory;
|
|
return createEventStream([
|
|
{
|
|
type: "message.part.delta",
|
|
properties: {
|
|
sessionID: "runtime-session-1",
|
|
messageID: "assistant-intermediate",
|
|
partID: "text-part-intermediate",
|
|
field: "text",
|
|
delta: "正在加载工作流并尝试分页参数。",
|
|
},
|
|
},
|
|
{
|
|
type: "message.part.updated",
|
|
properties: {
|
|
sessionID: "runtime-session-1",
|
|
part: {
|
|
id: "text-part-intermediate",
|
|
sessionID: "runtime-session-1",
|
|
messageID: "assistant-intermediate",
|
|
type: "text",
|
|
text: "正在加载工作流并尝试分页参数。",
|
|
time: { start: 1, end: 2 },
|
|
},
|
|
time: 2,
|
|
},
|
|
},
|
|
{
|
|
type: "message.part.delta",
|
|
properties: {
|
|
sessionID: "runtime-session-1",
|
|
messageID: "assistant-final",
|
|
partID: "text-part-final",
|
|
field: "text",
|
|
delta: "共识别 56 条瓶颈管段，建议优先改造 Top 5。",
|
|
},
|
|
},
|
|
{
|
|
type: "message.part.updated",
|
|
properties: {
|
|
sessionID: "runtime-session-1",
|
|
part: {
|
|
id: "text-part-final",
|
|
sessionID: "runtime-session-1",
|
|
messageID: "assistant-final",
|
|
type: "text",
|
|
text: "共识别 56 条瓶颈管段，建议优先改造 Top 5。",
|
|
time: { start: 3, end: 4 },
|
|
},
|
|
time: 4,
|
|
},
|
|
},
|
|
{
|
|
type: "session.idle",
|
|
properties: { sessionID: "runtime-session-1" },
|
|
},
|
|
]);
|
|
},
|
|
prompt: async () => undefined,
|
|
messages: async () => [
|
|
{
|
|
info: { id: "assistant-intermediate", role: "assistant" },
|
|
parts: [
|
|
{
|
|
id: "text-part-intermediate",
|
|
sessionID: "runtime-session-1",
|
|
messageID: "assistant-intermediate",
|
|
type: "text",
|
|
text: "正在加载工作流并尝试分页参数。",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
info: { id: "assistant-final", role: "assistant" },
|
|
parts: [
|
|
{
|
|
id: "text-part-final",
|
|
sessionID: "runtime-session-1",
|
|
messageID: "assistant-final",
|
|
type: "text",
|
|
text: "共识别 56 条瓶颈管段，建议优先改造 Top 5。",
|
|
},
|
|
],
|
|
},
|
|
],
|
|
} as unknown as OpencodeRuntimeAdapter;
|
|
const events: Array<{ event: string; data: Record<string, unknown> }> = [];
|
|
|
|
await streamPromptResponse({
|
|
runtime,
|
|
sessionId: "runtime-session-1",
|
|
clientSessionId: "client-session-1",
|
|
message: "分析管网瓶颈",
|
|
workspaceRoot: "/tmp/conversation-workspace-1",
|
|
write: (event, data) => events.push({ event, data }),
|
|
});
|
|
|
|
expect(subscribedDirectory).toBe("/tmp/conversation-workspace-1");
|
|
expect(events.filter((item) => item.event === "token")).toEqual([
|
|
{
|
|
event: "token",
|
|
data: {
|
|
session_id: "client-session-1",
|
|
content: "共识别 56 条瓶颈管段，建议优先改造 Top 5。",
|
|
},
|
|
},
|
|
]);
|
|
expect(events.filter((item) => item.event === "final_answer")).toEqual([
|
|
{
|
|
event: "final_answer",
|
|
data: {
|
|
session_id: "client-session-1",
|
|
content: "共识别 56 条瓶颈管段，建议优先改造 Top 5。",
|
|
},
|
|
},
|
|
]);
|
|
});
|
|
|
|
it("buffers final_answer deltas and emits one complete answer", async () => {
|
|
let messagesCalls = 0;
|
|
const runtime = {
|
|
subscribeEvents: async () =>
|
|
createEventStream([
|
|
{
|
|
type: "message.part.updated",
|
|
properties: {
|
|
sessionID: "runtime-session-1",
|
|
part: {
|
|
id: "commentary-part",
|
|
sessionID: "runtime-session-1",
|
|
messageID: "assistant-commentary",
|
|
type: "text",
|
|
text: "",
|
|
metadata: { openai: { phase: "commentary" } },
|
|
time: { start: 1 },
|
|
},
|
|
},
|
|
},
|
|
{
|
|
type: "message.part.delta",
|
|
properties: {
|
|
sessionID: "runtime-session-1",
|
|
messageID: "assistant-commentary",
|
|
partID: "commentary-part",
|
|
field: "text",
|
|
delta: "我先检查相关数据。",
|
|
},
|
|
},
|
|
{
|
|
type: "message.part.updated",
|
|
properties: {
|
|
sessionID: "runtime-session-1",
|
|
part: {
|
|
id: "commentary-part",
|
|
sessionID: "runtime-session-1",
|
|
messageID: "assistant-commentary",
|
|
type: "text",
|
|
text: "我先检查相关数据。",
|
|
metadata: { openai: { phase: "commentary" } },
|
|
time: { start: 1, end: 2 },
|
|
},
|
|
},
|
|
},
|
|
{
|
|
type: "message.part.updated",
|
|
properties: {
|
|
sessionID: "runtime-session-1",
|
|
part: {
|
|
id: "final-part",
|
|
sessionID: "runtime-session-1",
|
|
messageID: "assistant-final",
|
|
type: "text",
|
|
text: "",
|
|
metadata: { openai: { phase: "final_answer" } },
|
|
time: { start: 3 },
|
|
},
|
|
},
|
|
},
|
|
{
|
|
type: "message.part.delta",
|
|
properties: {
|
|
sessionID: "runtime-session-1",
|
|
messageID: "assistant-final",
|
|
partID: "final-part",
|
|
field: "text",
|
|
delta: "分析完成，",
|
|
},
|
|
},
|
|
{
|
|
type: "message.part.delta",
|
|
properties: {
|
|
sessionID: "runtime-session-1",
|
|
messageID: "assistant-final",
|
|
partID: "final-part",
|
|
field: "text",
|
|
delta: "结果正常。",
|
|
},
|
|
},
|
|
{
|
|
type: "message.part.updated",
|
|
properties: {
|
|
sessionID: "runtime-session-1",
|
|
part: {
|
|
id: "final-part",
|
|
sessionID: "runtime-session-1",
|
|
messageID: "assistant-final",
|
|
type: "text",
|
|
text: "分析完成，结果正常。",
|
|
metadata: { openai: { phase: "final_answer" } },
|
|
time: { start: 3, end: 4 },
|
|
},
|
|
},
|
|
},
|
|
{
|
|
type: "session.idle",
|
|
properties: { sessionID: "runtime-session-1" },
|
|
},
|
|
]),
|
|
prompt: async () => undefined,
|
|
messages: async () => {
|
|
messagesCalls += 1;
|
|
return [];
|
|
},
|
|
} as unknown as OpencodeRuntimeAdapter;
|
|
const events: Array<{ event: string; data: Record<string, unknown> }> = [];
|
|
|
|
await streamPromptResponse({
|
|
runtime,
|
|
sessionId: "runtime-session-1",
|
|
clientSessionId: "client-session-1",
|
|
message: "分析管网",
|
|
write: (event, data) => events.push({ event, data }),
|
|
});
|
|
|
|
expect(events.find((item) => item.event === "token")?.data.content).toBe(
|
|
"分析完成，结果正常。",
|
|
);
|
|
expect(events.filter((item) => item.event === "final_answer")).toEqual([
|
|
{
|
|
event: "final_answer",
|
|
data: {
|
|
session_id: "client-session-1",
|
|
content: "分析完成，结果正常。",
|
|
},
|
|
},
|
|
]);
|
|
expect(messagesCalls).toBe(0);
|
|
expect(events.some((item) => item.event === "progress")).toBe(false);
|
|
expect(
|
|
events.some(
|
|
(item) => item.event === "token" && item.data.content === "我先检查相关数据。",
|
|
),
|
|
).toBe(false);
|
|
});
|
|
|
|
it("uses the final text event cache when the messages lookup fails", async () => {
|
|
const runtime = {
|
|
subscribeEvents: async () =>
|
|
createEventStream([
|
|
{
|
|
type: "message.part.updated",
|
|
properties: {
|
|
sessionID: "runtime-session-1",
|
|
part: {
|
|
id: "text-part-final",
|
|
sessionID: "runtime-session-1",
|
|
messageID: "assistant-final",
|
|
type: "text",
|
|
text: "最终分析结果。",
|
|
time: { start: 1, end: 2 },
|
|
},
|
|
time: 2,
|
|
},
|
|
},
|
|
{
|
|
type: "session.idle",
|
|
properties: { sessionID: "runtime-session-1" },
|
|
},
|
|
]),
|
|
prompt: async () => undefined,
|
|
messages: async () => {
|
|
throw new Error("transient messages lookup failure");
|
|
},
|
|
} as unknown as OpencodeRuntimeAdapter;
|
|
const events: Array<{ event: string; data: Record<string, unknown> }> = [];
|
|
|
|
const result = await streamPromptResponse({
|
|
runtime,
|
|
sessionId: "runtime-session-1",
|
|
clientSessionId: "client-session-1",
|
|
message: "分析管网瓶颈",
|
|
write: (event, data) => events.push({ event, data }),
|
|
});
|
|
|
|
expect(result.failed).toBe(false);
|
|
expect(events.find((item) => item.event === "token")?.data.content).toBe(
|
|
"最终分析结果。",
|
|
);
|
|
expect(events.find((item) => item.event === "final_answer")?.data.content).toBe(
|
|
"最终分析结果。",
|
|
);
|
|
});
|
|
|
|
it("groups concrete tool execution under the current activity", async () => {
|
|
const runtime = {
|
|
subscribeEvents: async () =>
|
|
createEventStream([
|
|
{
|
|
type: "message.part.updated",
|
|
properties: {
|
|
sessionID: "runtime-session-1",
|
|
part: {
|
|
id: "activity-part-1",
|
|
sessionID: "runtime-session-1",
|
|
messageID: "assistant-1",
|
|
type: "tool",
|
|
callID: "activity-call-1",
|
|
tool: "activity_update",
|
|
state: {
|
|
status: "completed",
|
|
input: {
|
|
title: "检查管网数据",
|
|
reason: "需要确认输入数据是否满足瓶颈分析条件。",
|
|
todos: [
|
|
{
|
|
id: "prepare-data",
|
|
content: "准备管网数据",
|
|
status: "completed",
|
|
priority: "high",
|
|
},
|
|
{
|
|
id: "analyze-data",
|
|
content: "分析瓶颈管段",
|
|
status: "in_progress",
|
|
priority: "medium",
|
|
},
|
|
],
|
|
},
|
|
output: "活动阶段已更新。",
|
|
time: { start: 1, end: 2 },
|
|
},
|
|
},
|
|
time: 2,
|
|
},
|
|
},
|
|
{
|
|
type: "message.part.updated",
|
|
properties: {
|
|
sessionID: "runtime-session-1",
|
|
part: {
|
|
id: "reasoning-part-1",
|
|
sessionID: "runtime-session-1",
|
|
messageID: "assistant-1",
|
|
type: "reasoning",
|
|
text: "内部推理：尝试 limit=5000 并读取临时路径。",
|
|
time: { start: 1, end: 2 },
|
|
},
|
|
time: 2,
|
|
},
|
|
},
|
|
{
|
|
type: "message.part.delta",
|
|
properties: {
|
|
sessionID: "runtime-session-1",
|
|
messageID: "assistant-1",
|
|
partID: "reasoning-part-1",
|
|
field: "text",
|
|
delta: "内部推理：尝试 limit=5000 并读取临时路径。",
|
|
},
|
|
},
|
|
{
|
|
type: "message.part.updated",
|
|
properties: {
|
|
sessionID: "runtime-session-1",
|
|
part: {
|
|
id: "tool-part-1",
|
|
sessionID: "runtime-session-1",
|
|
messageID: "assistant-1",
|
|
type: "tool",
|
|
callID: "call-1",
|
|
tool: "tjwater_cli",
|
|
state: {
|
|
status: "error",
|
|
input: {
|
|
command: "network get-all-pipes-properties --limit 5000",
|
|
},
|
|
error: "HTTP_422 raw backend payload with trace_id=secret-trace",
|
|
time: { start: 1, end: 2 },
|
|
},
|
|
},
|
|
time: 2,
|
|
},
|
|
},
|
|
{
|
|
type: "session.idle",
|
|
properties: { sessionID: "runtime-session-1" },
|
|
},
|
|
]),
|
|
prompt: async () => undefined,
|
|
messages: async () => [],
|
|
} as unknown as OpencodeRuntimeAdapter;
|
|
const events: Array<{ event: string; data: Record<string, unknown> }> = [];
|
|
|
|
await streamPromptResponse({
|
|
runtime,
|
|
sessionId: "runtime-session-1",
|
|
clientSessionId: "client-session-1",
|
|
message: "分析管网瓶颈",
|
|
write: (event, data) => events.push({ event, data }),
|
|
});
|
|
|
|
const activityUpdates = events.filter(
|
|
(item) => item.event === "activity_update" &&
|
|
(item.data.activity as { id?: string } | undefined)?.id === "activity-part-1",
|
|
);
|
|
expect(activityUpdates.at(-1)?.data.activity).toMatchObject({
|
|
title: "检查管网数据",
|
|
reason: "需要确认输入数据是否满足瓶颈分析条件。",
|
|
actions: [
|
|
expect.objectContaining({
|
|
id: "tool-part-1",
|
|
tool: "tjwater_cli",
|
|
status: "error",
|
|
target: "network get-all-pipes-properties --limit 5000",
|
|
}),
|
|
],
|
|
});
|
|
expect(activityUpdates[0]?.data.todos).toEqual([
|
|
expect.objectContaining({
|
|
id: "prepare-data",
|
|
content: "准备管网数据",
|
|
status: "completed",
|
|
priority: "high",
|
|
}),
|
|
expect.objectContaining({
|
|
id: "analyze-data",
|
|
content: "分析瓶颈管段",
|
|
status: "in_progress",
|
|
priority: "medium",
|
|
}),
|
|
]);
|
|
expect(events.some((item) => item.event === "progress")).toBe(false);
|
|
});
|
|
|
|
it("forwards opencode permission requests as SSE payloads", async () => {
|
|
const runtime = {
|
|
subscribeEvents: async () =>
|
|
createEventStream([
|
|
{
|
|
type: "permission.asked",
|
|
properties: {
|
|
id: "perm-1",
|
|
sessionID: "runtime-session-1",
|
|
permission: "bash",
|
|
patterns: ["rm *"],
|
|
metadata: { command: "rm tmp.txt" },
|
|
always: ["rm *"],
|
|
},
|
|
},
|
|
{
|
|
type: "session.idle",
|
|
properties: {
|
|
sessionID: "runtime-session-1",
|
|
},
|
|
},
|
|
]),
|
|
prompt: async () => undefined,
|
|
messages: async () => [],
|
|
} as unknown as OpencodeRuntimeAdapter;
|
|
const events: Array<{ event: string; data: Record<string, unknown> }> = [];
|
|
|
|
await streamPromptResponse({
|
|
runtime,
|
|
sessionId: "runtime-session-1",
|
|
clientSessionId: "client-session-1",
|
|
message: "delete temp",
|
|
write: (event, data) => events.push({ event, data }),
|
|
});
|
|
|
|
const permissionEvent = events.find((item) => item.event === "permission_request");
|
|
expect(permissionEvent?.data).toMatchObject({
|
|
session_id: "client-session-1",
|
|
request_id: "perm-1",
|
|
permission: "bash",
|
|
patterns: ["rm *"],
|
|
target: "rm tmp.txt",
|
|
activity_id: "activity-startup",
|
|
reason: "正在理解请求并确定本次分析需要完成的业务步骤。",
|
|
always: ["rm *"],
|
|
} satisfies Partial<PermissionRequestPayload>);
|
|
});
|
|
|
|
it("auto approves an allowlisted low-risk permission once", async () => {
|
|
const replies: Array<Record<string, unknown>> = [];
|
|
const runtime = {
|
|
subscribeEvents: async () =>
|
|
createEventStream([
|
|
{
|
|
type: "permission.asked",
|
|
properties: {
|
|
id: "perm-1",
|
|
sessionID: "runtime-session-1",
|
|
permission: "show_chart",
|
|
patterns: ["*"],
|
|
metadata: {},
|
|
always: ["*"],
|
|
},
|
|
},
|
|
{
|
|
type: "session.idle",
|
|
properties: {
|
|
sessionID: "runtime-session-1",
|
|
},
|
|
},
|
|
]),
|
|
prompt: async () => undefined,
|
|
messages: async () => [],
|
|
replyPermission: async (options: Record<string, unknown>) => {
|
|
replies.push(options);
|
|
},
|
|
} as unknown as OpencodeRuntimeAdapter;
|
|
const events: Array<{ event: string; data: Record<string, unknown> }> = [];
|
|
|
|
await streamPromptResponse({
|
|
runtime,
|
|
sessionId: "runtime-session-1",
|
|
clientSessionId: "client-session-1",
|
|
message: "run tests",
|
|
approvalMode: "auto",
|
|
workspaceRoot: "/tmp/conversation-workspace-1",
|
|
write: (event, data) => events.push({ event, data }),
|
|
});
|
|
|
|
expect(replies).toEqual([
|
|
{
|
|
requestId: "perm-1",
|
|
sessionId: "runtime-session-1",
|
|
directory: "/tmp/conversation-workspace-1",
|
|
reply: "once",
|
|
},
|
|
]);
|
|
expect(events.some((item) => item.event === "permission_request")).toBe(false);
|
|
expect(events.find((item) => item.event === "permission_response")?.data).toEqual({
|
|
session_id: "client-session-1",
|
|
request_id: "perm-1",
|
|
reply: "once",
|
|
});
|
|
});
|
|
|
|
it("keeps high-risk permissions interactive in auto mode", async () => {
|
|
const replies: Array<Record<string, unknown>> = [];
|
|
const runtime = {
|
|
subscribeEvents: async () =>
|
|
createEventStream([
|
|
{
|
|
type: "permission.asked",
|
|
properties: {
|
|
id: "perm-auto-bash",
|
|
sessionID: "runtime-session-1",
|
|
permission: "bash",
|
|
patterns: ["npm test"],
|
|
metadata: { command: "npm test" },
|
|
always: ["npm test"],
|
|
},
|
|
},
|
|
{ type: "session.idle", properties: { sessionID: "runtime-session-1" } },
|
|
]),
|
|
prompt: async () => undefined,
|
|
messages: async () => [],
|
|
replyPermission: async (options: Record<string, unknown>) => replies.push(options),
|
|
} as unknown as OpencodeRuntimeAdapter;
|
|
const events: Array<{ event: string; data: Record<string, unknown> }> = [];
|
|
|
|
await streamPromptResponse({
|
|
runtime,
|
|
sessionId: "runtime-session-1",
|
|
clientSessionId: "client-session-1",
|
|
message: "run tests",
|
|
approvalMode: "auto",
|
|
write: (event, data) => events.push({ event, data }),
|
|
});
|
|
|
|
expect(replies).toEqual([]);
|
|
expect(events.find((item) => item.event === "permission_request")?.data).toMatchObject({
|
|
request_id: "perm-auto-bash",
|
|
permission: "bash",
|
|
});
|
|
});
|
|
|
|
it("approves every OpenCode ask once in always mode", async () => {
|
|
const replies: Array<Record<string, unknown>> = [];
|
|
const runtime = {
|
|
subscribeEvents: async () =>
|
|
createEventStream([
|
|
{
|
|
type: "permission.asked",
|
|
properties: {
|
|
id: "perm-always-bash",
|
|
sessionID: "runtime-session-1",
|
|
permission: "bash",
|
|
patterns: ["npm test"],
|
|
metadata: { command: "npm test" },
|
|
always: ["npm test"],
|
|
},
|
|
},
|
|
{ type: "session.idle", properties: { sessionID: "runtime-session-1" } },
|
|
]),
|
|
prompt: async () => undefined,
|
|
messages: async () => [],
|
|
replyPermission: async (options: Record<string, unknown>) => replies.push(options),
|
|
} as unknown as OpencodeRuntimeAdapter;
|
|
const events: Array<{ event: string; data: Record<string, unknown> }> = [];
|
|
|
|
await streamPromptResponse({
|
|
runtime,
|
|
sessionId: "runtime-session-1",
|
|
clientSessionId: "client-session-1",
|
|
message: "run tests",
|
|
approvalMode: "always",
|
|
workspaceRoot: "/tmp/conversation-workspace-1",
|
|
write: (event, data) => events.push({ event, data }),
|
|
});
|
|
|
|
expect(replies).toEqual([
|
|
{
|
|
requestId: "perm-always-bash",
|
|
sessionId: "runtime-session-1",
|
|
directory: "/tmp/conversation-workspace-1",
|
|
reply: "once",
|
|
},
|
|
]);
|
|
expect(events.some((item) => item.event === "permission_request")).toBe(false);
|
|
});
|
|
|
|
it("rejects recursive force removal even in always mode", async () => {
|
|
const replies: Array<Record<string, unknown>> = [];
|
|
const runtime = {
|
|
subscribeEvents: async () =>
|
|
createEventStream([
|
|
{
|
|
type: "permission.asked",
|
|
properties: {
|
|
id: "perm-always-rm-rf",
|
|
sessionID: "runtime-session-1",
|
|
permission: "bash",
|
|
patterns: ["/bin/rm -rf ./target"],
|
|
metadata: { command: "/bin/rm -rf ./target" },
|
|
always: ["/bin/rm -rf ./target"],
|
|
},
|
|
},
|
|
{ type: "session.idle", properties: { sessionID: "runtime-session-1" } },
|
|
]),
|
|
prompt: async () => undefined,
|
|
messages: async () => [],
|
|
replyPermission: async (options: Record<string, unknown>) => replies.push(options),
|
|
} as unknown as OpencodeRuntimeAdapter;
|
|
const events: Array<{ event: string; data: Record<string, unknown> }> = [];
|
|
|
|
await streamPromptResponse({
|
|
runtime,
|
|
sessionId: "runtime-session-1",
|
|
clientSessionId: "client-session-1",
|
|
message: "delete recursively",
|
|
approvalMode: "always",
|
|
workspaceRoot: "/tmp/conversation-workspace-1",
|
|
write: (event, data) => events.push({ event, data }),
|
|
});
|
|
|
|
expect(replies).toEqual([
|
|
{
|
|
requestId: "perm-always-rm-rf",
|
|
sessionId: "runtime-session-1",
|
|
directory: "/tmp/conversation-workspace-1",
|
|
reply: "reject",
|
|
},
|
|
]);
|
|
expect(events.some((item) => item.event === "permission_request")).toBe(false);
|
|
expect(events.find((item) => item.event === "permission_response")?.data).toEqual({
|
|
session_id: "client-session-1",
|
|
request_id: "perm-always-rm-rf",
|
|
reply: "reject",
|
|
});
|
|
});
|
|
|
|
it("forwards opencode v2 permission requests as SSE payloads", async () => {
|
|
const runtime = {
|
|
subscribeEvents: async () =>
|
|
createEventStream([
|
|
{
|
|
type: "permission.v2.asked",
|
|
properties: {
|
|
id: "perm-v2-1",
|
|
sessionID: "runtime-session-1",
|
|
action: "external_directory",
|
|
resources: ["/tmp"],
|
|
save: ["/tmp"],
|
|
metadata: { path: "/tmp" },
|
|
},
|
|
},
|
|
{
|
|
type: "session.idle",
|
|
properties: {
|
|
sessionID: "runtime-session-1",
|
|
},
|
|
},
|
|
]),
|
|
prompt: async () => undefined,
|
|
messages: async () => [],
|
|
} as unknown as OpencodeRuntimeAdapter;
|
|
const events: Array<{ event: string; data: Record<string, unknown> }> = [];
|
|
|
|
await streamPromptResponse({
|
|
runtime,
|
|
sessionId: "runtime-session-1",
|
|
clientSessionId: "client-session-1",
|
|
message: "read /tmp",
|
|
write: (event, data) => events.push({ event, data }),
|
|
});
|
|
|
|
const permissionEvent = events.find((item) => item.event === "permission_request");
|
|
expect(permissionEvent?.data).toMatchObject({
|
|
session_id: "client-session-1",
|
|
request_id: "perm-v2-1",
|
|
permission: "external_directory",
|
|
patterns: ["/tmp"],
|
|
target: "/tmp",
|
|
always: ["/tmp"],
|
|
} satisfies Partial<PermissionRequestPayload>);
|
|
});
|
|
|
|
it("forwards opencode question requests and replies as SSE payloads", async () => {
|
|
const runtime = {
|
|
subscribeEvents: async () =>
|
|
createEventStream([
|
|
{
|
|
type: "question.asked",
|
|
properties: {
|
|
id: "question-1",
|
|
sessionID: "runtime-session-1",
|
|
questions: [
|
|
{
|
|
header: "范围",
|
|
question: "选择分析范围",
|
|
options: [{ label: "城区", description: "中心城区" }],
|
|
multiple: false,
|
|
custom: true,
|
|
},
|
|
],
|
|
},
|
|
},
|
|
{
|
|
type: "question.replied",
|
|
properties: {
|
|
sessionID: "runtime-session-1",
|
|
requestID: "question-1",
|
|
answers: [["城区", "补充说明"]],
|
|
},
|
|
},
|
|
{
|
|
type: "session.idle",
|
|
properties: {
|
|
sessionID: "runtime-session-1",
|
|
},
|
|
},
|
|
]),
|
|
prompt: async () => undefined,
|
|
messages: async () => [],
|
|
} as unknown as OpencodeRuntimeAdapter;
|
|
const events: Array<{ event: string; data: Record<string, unknown> }> = [];
|
|
|
|
await streamPromptResponse({
|
|
runtime,
|
|
sessionId: "runtime-session-1",
|
|
clientSessionId: "client-session-1",
|
|
message: "ask",
|
|
write: (event, data) => events.push({ event, data }),
|
|
});
|
|
|
|
expect(events.find((item) => item.event === "question_request")?.data).toMatchObject({
|
|
session_id: "client-session-1",
|
|
request_id: "question-1",
|
|
questions: [
|
|
{
|
|
header: "范围",
|
|
question: "选择分析范围",
|
|
options: [{ label: "城区", description: "中心城区" }],
|
|
multiple: false,
|
|
custom: true,
|
|
},
|
|
],
|
|
});
|
|
expect(events.find((item) => item.event === "question_response")?.data).toEqual({
|
|
session_id: "client-session-1",
|
|
request_id: "question-1",
|
|
answers: [["城区", "补充说明"]],
|
|
});
|
|
});
|
|
|
|
it("converts question tool parts into question request SSE payloads", async () => {
|
|
const runtime = {
|
|
subscribeEvents: async () =>
|
|
createEventStream([
|
|
{
|
|
type: "message.part.updated",
|
|
properties: {
|
|
sessionID: "runtime-session-1",
|
|
part: {
|
|
id: "tool-part-1",
|
|
sessionID: "runtime-session-1",
|
|
messageID: "message-1",
|
|
type: "tool",
|
|
callID: "call-1",
|
|
tool: "question",
|
|
state: {
|
|
status: "running",
|
|
input: {
|
|
questions: [
|
|
{
|
|
question: "你觉得这个 question 工具好用吗？",
|
|
header: "测试问题",
|
|
options: [
|
|
{
|
|
label: "非常好用",
|
|
description: "交互清晰，选项方便",
|
|
},
|
|
],
|
|
},
|
|
],
|
|
},
|
|
time: { start: Date.now() },
|
|
},
|
|
},
|
|
time: Date.now(),
|
|
},
|
|
},
|
|
{
|
|
type: "session.idle",
|
|
properties: {
|
|
sessionID: "runtime-session-1",
|
|
},
|
|
},
|
|
]),
|
|
prompt: async () => undefined,
|
|
messages: async () => [],
|
|
} as unknown as OpencodeRuntimeAdapter;
|
|
const events: Array<{ event: string; data: Record<string, unknown> }> = [];
|
|
|
|
await streamPromptResponse({
|
|
runtime,
|
|
sessionId: "runtime-session-1",
|
|
clientSessionId: "client-session-1",
|
|
message: "ask",
|
|
write: (event, data) => events.push({ event, data }),
|
|
});
|
|
|
|
expect(events.find((item) => item.event === "question_request")?.data).toMatchObject({
|
|
session_id: "client-session-1",
|
|
request_id: "call-1",
|
|
questions: [
|
|
{
|
|
header: "测试问题",
|
|
question: "你觉得这个 question 工具好用吗？",
|
|
options: [
|
|
{
|
|
label: "非常好用",
|
|
description: "交互清晰，选项方便",
|
|
},
|
|
],
|
|
},
|
|
],
|
|
tool: {
|
|
messageID: "message-1",
|
|
callID: "call-1",
|
|
},
|
|
});
|
|
expect(
|
|
events.some(
|
|
(item) => item.event === "tool_call" && item.data.tool === "question",
|
|
),
|
|
).toBe(false);
|
|
});
|
|
|
|
it("forwards todo updates independently from activity progress", async () => {
|
|
const runtime = {
|
|
subscribeEvents: async () =>
|
|
createEventStream([
|
|
{
|
|
type: "message.part.updated",
|
|
properties: {
|
|
sessionID: "runtime-session-1",
|
|
part: {
|
|
id: "todo-tool-part",
|
|
sessionID: "runtime-session-1",
|
|
messageID: "assistant-plan",
|
|
type: "tool",
|
|
callID: "todo-tool-call",
|
|
tool: "todowrite",
|
|
state: {
|
|
status: "completed",
|
|
input: {
|
|
todos: [
|
|
{ content: "分析水位", status: "completed", priority: "high" },
|
|
{ content: "生成建议", status: "in_progress", priority: "medium" },
|
|
],
|
|
},
|
|
output: "计划已更新",
|
|
time: { start: 1, end: 2 },
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
type: "todo.updated",
|
|
properties: {
|
|
sessionID: "runtime-session-1",
|
|
todos: [
|
|
{ content: "分析水位", status: "completed", priority: "high" },
|
|
{ content: "生成建议", status: "in_progress", priority: "medium" },
|
|
],
|
|
},
|
|
},
|
|
{
|
|
type: "session.idle",
|
|
properties: {
|
|
sessionID: "runtime-session-1",
|
|
},
|
|
},
|
|
]),
|
|
prompt: async () => undefined,
|
|
messages: async () => [],
|
|
} as unknown as OpencodeRuntimeAdapter;
|
|
const events: Array<{ event: string; data: Record<string, unknown> }> = [];
|
|
|
|
await streamPromptResponse({
|
|
runtime,
|
|
sessionId: "runtime-session-1",
|
|
clientSessionId: "client-session-1",
|
|
message: "plan",
|
|
write: (event, data) => events.push({ event, data }),
|
|
});
|
|
|
|
expect(events.some((item) => item.event === "progress")).toBe(false);
|
|
expect(events.find((item) => item.event === "todo_update")?.data).toMatchObject({
|
|
session_id: "client-session-1",
|
|
todos: [
|
|
expect.objectContaining({
|
|
content: "分析水位",
|
|
status: "completed",
|
|
priority: "high",
|
|
}),
|
|
expect.objectContaining({
|
|
content: "生成建议",
|
|
status: "in_progress",
|
|
priority: "medium",
|
|
}),
|
|
],
|
|
});
|
|
expect(
|
|
events.some(
|
|
(item) =>
|
|
item.event === "activity_update" &&
|
|
((item.data.activity as { actions?: Array<{ tool?: string }> } | undefined)
|
|
?.actions ?? [])
|
|
.some((action) => action.tool === "todowrite"),
|
|
),
|
|
).toBe(false);
|
|
expect(
|
|
events.some(
|
|
(item) => item.event === "tool_call" && item.data.tool === "todowrite",
|
|
),
|
|
).toBe(false);
|
|
});
|
|
|
|
it("buffers the voluntary DeepSeek final answer tool without forcing tool choice", async () => {
|
|
const promptCalls: unknown[][] = [];
|
|
const events: Array<{ event: string; data: Record<string, unknown> }> = [];
|
|
const runtime = {
|
|
subscribeEvents: async () => ({
|
|
async *[Symbol.asyncIterator]() {
|
|
yield {
|
|
type: "message.part.updated",
|
|
properties: {
|
|
sessionID: "runtime-session-1",
|
|
part: {
|
|
id: "final-answer-part",
|
|
sessionID: "runtime-session-1",
|
|
messageID: "assistant-final",
|
|
type: "tool",
|
|
callID: "final-answer-call",
|
|
tool: "final_answer",
|
|
state: {
|
|
status: "running",
|
|
input: { answer: "供水服务分区" },
|
|
time: { start: 1 },
|
|
},
|
|
},
|
|
},
|
|
};
|
|
expect(
|
|
events
|
|
.filter((item) => item.event === "final_answer")
|
|
.map((item) => item.data.content)
|
|
.join(""),
|
|
).toBe("");
|
|
yield {
|
|
type: "message.part.updated",
|
|
properties: {
|
|
sessionID: "runtime-session-1",
|
|
part: {
|
|
id: "final-answer-part",
|
|
sessionID: "runtime-session-1",
|
|
messageID: "assistant-final",
|
|
type: "tool",
|
|
callID: "final-answer-call",
|
|
tool: "final_answer",
|
|
state: {
|
|
status: "running",
|
|
input: { answer: "供水服务分区分析已完成。" },
|
|
time: { start: 1 },
|
|
},
|
|
},
|
|
},
|
|
};
|
|
expect(
|
|
events
|
|
.filter((item) => item.event === "final_answer")
|
|
.map((item) => item.data.content)
|
|
.join(""),
|
|
).toBe("");
|
|
yield {
|
|
type: "message.part.updated",
|
|
properties: {
|
|
sessionID: "runtime-session-1",
|
|
part: {
|
|
id: "final-answer-part",
|
|
sessionID: "runtime-session-1",
|
|
messageID: "assistant-final",
|
|
type: "tool",
|
|
callID: "final-answer-call",
|
|
tool: "final_answer",
|
|
state: {
|
|
status: "completed",
|
|
input: { answer: "供水服务分区分析已完成。" },
|
|
output: "最终回答已提交。",
|
|
title: "final_answer",
|
|
metadata: {},
|
|
time: { start: 1, end: 2 },
|
|
},
|
|
},
|
|
},
|
|
};
|
|
yield {
|
|
type: "session.idle",
|
|
properties: { sessionID: "runtime-session-1" },
|
|
};
|
|
},
|
|
}),
|
|
prompt: async (...args: unknown[]) => {
|
|
promptCalls.push(args);
|
|
},
|
|
messages: async () => [],
|
|
} as unknown as OpencodeRuntimeAdapter;
|
|
|
|
const result = await streamPromptResponse({
|
|
runtime,
|
|
sessionId: "runtime-session-1",
|
|
clientSessionId: "client-session-1",
|
|
message: "分析供水服务分区",
|
|
model: "deepseek/deepseek-v4-flash",
|
|
write: (event, data) => events.push({ event, data }),
|
|
});
|
|
|
|
expect(promptCalls[0]?.[3]).toBeUndefined();
|
|
expect(result).toEqual({ aborted: false, failed: false, toolCallCount: 0 });
|
|
expect(events.find((item) => item.event === "token")?.data.content).toBe(
|
|
"供水服务分区分析已完成。",
|
|
);
|
|
expect(events.filter((item) => item.event === "final_answer")).toEqual([
|
|
{
|
|
event: "final_answer",
|
|
data: {
|
|
session_id: "client-session-1",
|
|
content: "供水服务分区分析已完成。",
|
|
},
|
|
},
|
|
]);
|
|
expect(events.some((item) => item.event === "tool_call")).toBe(false);
|
|
expect(events.some((item) => item.event === "done")).toBe(true);
|
|
});
|
|
|
|
it("keeps the pending event read when prompt resolves before final_answer", async () => {
|
|
const events: Array<{ event: string; data: Record<string, unknown> }> = [];
|
|
const runtime = {
|
|
subscribeEvents: async () => ({
|
|
async *[Symbol.asyncIterator]() {
|
|
await new Promise((resolve) => setTimeout(resolve, 0));
|
|
yield {
|
|
type: "message.part.updated",
|
|
properties: {
|
|
sessionID: "runtime-session-1",
|
|
part: {
|
|
id: "final-answer-part",
|
|
sessionID: "runtime-session-1",
|
|
messageID: "assistant-final",
|
|
type: "tool",
|
|
callID: "final-answer-call",
|
|
tool: "final_answer",
|
|
state: {
|
|
status: "completed",
|
|
input: { answer: "最终答案不会因事件竞争而丢失。" },
|
|
output: "最终回答已提交。",
|
|
title: "final_answer",
|
|
metadata: {},
|
|
time: { start: 1, end: 2 },
|
|
},
|
|
},
|
|
},
|
|
};
|
|
yield {
|
|
type: "session.idle",
|
|
properties: { sessionID: "runtime-session-1" },
|
|
};
|
|
},
|
|
}),
|
|
prompt: async () => undefined,
|
|
messages: async () => [],
|
|
} as unknown as OpencodeRuntimeAdapter;
|
|
|
|
const result = await streamPromptResponse({
|
|
runtime,
|
|
sessionId: "runtime-session-1",
|
|
clientSessionId: "client-session-1",
|
|
message: "分析管网",
|
|
write: (event, data) => events.push({ event, data }),
|
|
});
|
|
|
|
expect(result.failed).toBe(false);
|
|
expect(events.find((item) => item.event === "final_answer")?.data.content).toBe(
|
|
"最终答案不会因事件竞争而丢失。",
|
|
);
|
|
expect(events.at(-1)?.event).toBe("done");
|
|
});
|
|
|
|
it("recovers a persisted final_answer tool result from message history", async () => {
|
|
const events: Array<{ event: string; data: Record<string, unknown> }> = [];
|
|
const runtime = {
|
|
subscribeEvents: async () =>
|
|
createEventStream([
|
|
{
|
|
type: "message.updated",
|
|
properties: {
|
|
sessionID: "runtime-session-1",
|
|
info: { id: "assistant-final", role: "assistant" },
|
|
},
|
|
},
|
|
{
|
|
type: "session.idle",
|
|
properties: { sessionID: "runtime-session-1" },
|
|
},
|
|
]),
|
|
prompt: async () => undefined,
|
|
messages: async () => [
|
|
{
|
|
info: { id: "assistant-final", role: "assistant" },
|
|
parts: [
|
|
{
|
|
id: "final-answer-part",
|
|
sessionID: "runtime-session-1",
|
|
messageID: "assistant-final",
|
|
type: "tool",
|
|
callID: "final-answer-call",
|
|
tool: "final_answer",
|
|
state: {
|
|
status: "completed",
|
|
input: { answer: "已从持久化工具结果恢复最终答案。" },
|
|
output: "最终回答已提交。",
|
|
title: "final_answer",
|
|
metadata: {},
|
|
time: { start: 1, end: 2 },
|
|
},
|
|
},
|
|
],
|
|
},
|
|
],
|
|
} as unknown as OpencodeRuntimeAdapter;
|
|
|
|
await streamPromptResponse({
|
|
runtime,
|
|
sessionId: "runtime-session-1",
|
|
clientSessionId: "client-session-1",
|
|
message: "分析管网",
|
|
write: (event, data) => events.push({ event, data }),
|
|
});
|
|
|
|
expect(events.find((item) => item.event === "final_answer")?.data.content).toBe(
|
|
"已从持久化工具结果恢复最终答案。",
|
|
);
|
|
});
|
|
|
|
});
|