440 lines
13 KiB
TypeScript
440 lines
13 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("forwards opencode permission requests as SSE payloads", async () => {
|
|
const runtime = {
|
|
subscribeEvents: async () =>
|
|
createEventStream([
|
|
{
|
|
type: "permission.asked",
|
|
sessionId: "runtime-session-1",
|
|
request: {
|
|
id: "perm-1",
|
|
action: "shell",
|
|
resources: ["rm *"],
|
|
metadata: { command: "rm tmp.txt" },
|
|
save: ["rm *"],
|
|
},
|
|
},
|
|
{
|
|
type: "session.execution.succeeded",
|
|
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: "shell",
|
|
patterns: ["rm *"],
|
|
target: "rm tmp.txt",
|
|
always: ["rm *"],
|
|
} satisfies Partial<PermissionRequestPayload>);
|
|
});
|
|
|
|
it("auto replies always when approval mode is always", async () => {
|
|
const replies: Array<Record<string, unknown>> = [];
|
|
const runtime = {
|
|
subscribeEvents: async () =>
|
|
createEventStream([
|
|
{
|
|
type: "permission.asked",
|
|
sessionId: "runtime-session-1",
|
|
request: {
|
|
id: "perm-1",
|
|
action: "shell",
|
|
resources: ["npm test"],
|
|
metadata: { command: "npm test" },
|
|
save: ["npm test"],
|
|
},
|
|
},
|
|
{
|
|
type: "session.execution.succeeded",
|
|
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",
|
|
write: (event, data) => events.push({ event, data }),
|
|
});
|
|
|
|
expect(replies).toEqual([
|
|
{
|
|
requestId: "perm-1",
|
|
sessionId: "runtime-session-1",
|
|
reply: "always",
|
|
},
|
|
]);
|
|
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: "always",
|
|
});
|
|
});
|
|
|
|
it("forwards external-directory V2 permission requests as SSE payloads", async () => {
|
|
const runtime = {
|
|
subscribeEvents: async () =>
|
|
createEventStream([
|
|
{
|
|
type: "permission.asked",
|
|
sessionId: "runtime-session-1",
|
|
request: {
|
|
id: "perm-v2-1",
|
|
action: "external_directory",
|
|
resources: ["/tmp"],
|
|
save: ["/tmp"],
|
|
metadata: { path: "/tmp" },
|
|
},
|
|
},
|
|
{
|
|
type: "session.execution.succeeded",
|
|
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",
|
|
sessionId: "runtime-session-1",
|
|
request: {
|
|
id: "question-1",
|
|
questions: [
|
|
{
|
|
header: "范围",
|
|
question: "选择分析范围",
|
|
options: [{ label: "城区", description: "中心城区" }],
|
|
multiple: false,
|
|
custom: true,
|
|
},
|
|
],
|
|
},
|
|
},
|
|
{
|
|
type: "question.replied",
|
|
sessionId: "runtime-session-1",
|
|
requestId: "question-1",
|
|
answers: [["城区", "补充说明"]],
|
|
},
|
|
{
|
|
type: "session.execution.succeeded",
|
|
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("waits for the Form event instead of exposing the question tool call ID", async () => {
|
|
const runtime = {
|
|
subscribeEvents: async () =>
|
|
createEventStream([
|
|
{
|
|
type: "tool.updated",
|
|
sessionId: "runtime-session-1",
|
|
part: {
|
|
id: "tool-part-1",
|
|
messageID: "message-1",
|
|
callID: "call-1",
|
|
tool: "question",
|
|
state: {
|
|
status: "running",
|
|
input: {
|
|
questions: [
|
|
{
|
|
question: "你觉得这个 question 工具好用吗？",
|
|
header: "测试问题",
|
|
options: [
|
|
{
|
|
label: "非常好用",
|
|
description: "交互清晰，选项方便",
|
|
},
|
|
],
|
|
},
|
|
],
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
type: "question.asked",
|
|
sessionId: "runtime-session-1",
|
|
request: {
|
|
id: "frm_1",
|
|
questions: [
|
|
{
|
|
header: "测试问题",
|
|
question: "你觉得这个 question 工具好用吗？",
|
|
options: [
|
|
{
|
|
label: "非常好用",
|
|
description: "交互清晰，选项方便",
|
|
},
|
|
],
|
|
},
|
|
],
|
|
},
|
|
},
|
|
{
|
|
type: "session.execution.succeeded",
|
|
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: "frm_1",
|
|
questions: [
|
|
{
|
|
header: "测试问题",
|
|
question: "你觉得这个 question 工具好用吗？",
|
|
options: [
|
|
{
|
|
label: "非常好用",
|
|
description: "交互清晰，选项方便",
|
|
},
|
|
],
|
|
},
|
|
],
|
|
});
|
|
expect(
|
|
events.some(
|
|
(item) => item.event === "question_request" && item.data.request_id === "call-1",
|
|
),
|
|
).toBe(false);
|
|
expect(
|
|
events.some(
|
|
(item) => item.event === "tool_call" && item.data.tool === "question",
|
|
),
|
|
).toBe(false);
|
|
});
|
|
|
|
it("forwards normalized V2 text and reasoning deltas", async () => {
|
|
const runtime = {
|
|
subscribeEvents: async () =>
|
|
createEventStream([
|
|
{
|
|
type: "reasoning.updated",
|
|
sessionId: "runtime-session-1",
|
|
partId: "reasoning-1",
|
|
delta: "分析中",
|
|
completed: false,
|
|
},
|
|
{
|
|
type: "reasoning.updated",
|
|
sessionId: "runtime-session-1",
|
|
partId: "reasoning-1",
|
|
completed: true,
|
|
},
|
|
{
|
|
type: "text.delta",
|
|
sessionId: "runtime-session-1",
|
|
partId: "text-1",
|
|
delta: "完成",
|
|
},
|
|
{
|
|
type: "session.execution.succeeded",
|
|
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.find((item) => item.event === "token")?.data).toEqual({
|
|
session_id: "client-session-1",
|
|
content: "完成",
|
|
});
|
|
expect(
|
|
events.find(
|
|
(item) =>
|
|
item.event === "progress" &&
|
|
item.data.id === "reasoning-1" &&
|
|
item.data.status === "completed",
|
|
)?.data,
|
|
).toMatchObject({
|
|
phase: "planning",
|
|
title: "分析规划完成",
|
|
});
|
|
});
|
|
|
|
it("retains the first runtime event when prompt resolves before delivery", async () => {
|
|
const runtime = {
|
|
subscribeEvents: async () => ({
|
|
async *[Symbol.asyncIterator]() {
|
|
await Promise.resolve();
|
|
yield {
|
|
type: "text.delta",
|
|
sessionId: "runtime-session-1",
|
|
partId: "text-1",
|
|
delta: "首个事件",
|
|
};
|
|
yield {
|
|
type: "session.execution.succeeded",
|
|
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: "race",
|
|
write: (event, data) => events.push({ event, data }),
|
|
});
|
|
|
|
expect(events.find((item) => item.event === "token")?.data.content).toBe("首个事件");
|
|
expect(events.find((item) => item.event === "done")?.data.session_id).toBe(
|
|
"client-session-1",
|
|
);
|
|
});
|
|
|
|
it("terminates the stream when V2 reports execution failure", async () => {
|
|
const runtime = {
|
|
subscribeEvents: async () =>
|
|
createEventStream([
|
|
{
|
|
type: "session.execution.failed",
|
|
sessionId: "runtime-session-1",
|
|
error: { name: "ExecutionError", data: { message: "执行失败" } },
|
|
},
|
|
]),
|
|
prompt: async () => undefined,
|
|
messages: async () => [],
|
|
} 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: "fail",
|
|
write: (event, data) => events.push({ event, data }),
|
|
});
|
|
|
|
expect(events.find((item) => item.event === "error")?.data.message).toBe("执行失败");
|
|
expect(result.failed).toBe(true);
|
|
});
|
|
});
|