| import type { AcpElicitationRequest } from "@openclaw/acp-core/runtime/types"; |
| import { beforeEach, describe, expect, it, vi } from "vitest"; |
| import { claimPendingAgentQuestionAnswer } from "../../agents/harness/gateway-question.js"; |
|
|
| const gatewayCallMock = vi.hoisted(() => vi.fn()); |
|
|
| vi.mock("../../agents/tools/gateway.js", () => ({ callGatewayTool: gatewayCallMock })); |
|
|
| import { createAcpElicitationHandler } from "./acp-elicitation-handler.js"; |
|
|
| type GatewayQuestion = { questionId: string; options?: Array<{ label: string }> }; |
| type GatewayRequest = { |
| id: string; |
| questions: GatewayQuestion[]; |
| sessionKey?: string; |
| runId?: string; |
| }; |
|
|
| function formRequest( |
| properties: Record<string, unknown>, |
| required: string[] = [], |
| ): AcpElicitationRequest { |
| return { |
| mode: "form", |
| sessionId: "acp-session", |
| toolCallId: "tool-call", |
| message: "ACP needs input", |
| requestedSchema: { type: "object", properties, required }, |
| } as AcpElicitationRequest; |
| } |
|
|
| function urlRequest(overrides: Partial<Record<string, unknown>> = {}): AcpElicitationRequest { |
| return { |
| mode: "url", |
| sessionId: "acp-session", |
| toolCallId: "tool-call", |
| message: "Authenticate", |
| elicitationId: "login-1", |
| url: "https://example.com/login", |
| ...overrides, |
| } as AcpElicitationRequest; |
| } |
|
|
| function createFixture() { |
| const delivered: string[] = []; |
| let active = true; |
| const handler = createAcpElicitationHandler({ |
| sourceSessionKey: "agent:main:source", |
| targetSessionKey: "agent:codex:acp:target", |
| outerRequestId: "outer-turn", |
| agentId: "main", |
| runId: "run-1", |
| delivery: { |
| deliver: vi.fn(async (_kind, payload) => { |
| if (payload.text) { |
| delivered.push(payload.text); |
| } |
| return true; |
| }), |
| }, |
| isActive: () => active, |
| }); |
| return { |
| delivered, |
| handler, |
| deactivate: () => { |
| active = false; |
| }, |
| }; |
| } |
|
|
| function answerGateway( |
| answer: (questions: GatewayQuestion[]) => Record<string, string[]>, |
| ): GatewayRequest[] { |
| const requests = new Map<string, GatewayRequest>(); |
| const ordered: GatewayRequest[] = []; |
| gatewayCallMock.mockImplementation(async (method: string, _opts: unknown, rawParams: unknown) => { |
| const params = rawParams as GatewayRequest; |
| if (method === "question.request") { |
| requests.set(params.id, params); |
| ordered.push(params); |
| return { id: params.id }; |
| } |
| if (method === "question.waitAnswer") { |
| const request = requests.get(params.id); |
| if (!request) { |
| throw new Error("missing question registration"); |
| } |
| return { status: "answered", answers: { answers: answer(request.questions) } }; |
| } |
| if (method === "question.resolve") { |
| return { status: "cancelled" }; |
| } |
| throw new Error(`unexpected gateway method ${method}`); |
| }); |
| return ordered; |
| } |
|
|
| describe("ACP elicitation delivery", () => { |
| beforeEach(() => { |
| gatewayCallMock.mockReset(); |
| }); |
|
|
| it("rejects accessor-backed request objects without invoking the accessor", async () => { |
| let reads = 0; |
| const request = Object.defineProperty( |
| { |
| mode: "form", |
| sessionId: "acp-session", |
| message: "Input", |
| }, |
| "requestedSchema", |
| { |
| enumerable: true, |
| get() { |
| reads += 1; |
| return { type: "object", properties: { value: { type: "string" } } }; |
| }, |
| }, |
| ) as AcpElicitationRequest; |
| const { delivered, handler } = createFixture(); |
|
|
| const response = await handler(request, { |
| requestId: "accessor", |
| signal: new AbortController().signal, |
| }); |
|
|
| expect(response.action).toBe("decline"); |
| expect(reads).toBe(0); |
| expect(delivered.join("\n")).toContain("malformed"); |
| }); |
|
|
| it("uses outer, scope, session, and tool-call correlation in Gateway records", async () => { |
| const requests = answerGateway((questions) => ({ [questions[0]!.questionId]: ["Continue"] })); |
| const { handler } = createFixture(); |
|
|
| await handler(urlRequest(), { |
| requestId: 1, |
| signal: new AbortController().signal, |
| }); |
| await handler( |
| { |
| mode: "url", |
| requestId: "auth-request", |
| message: "Authenticate", |
| elicitationId: "login-2", |
| url: "https://example.com/login", |
| }, |
| { requestId: 2, signal: new AbortController().signal }, |
| ); |
|
|
| expect(requests).toHaveLength(2); |
| expect(requests[0]?.id).toMatch(/^acp_[a-f0-9]{24}_0$/u); |
| expect(requests[1]?.id).toMatch(/^acp_[a-f0-9]{24}_0$/u); |
| expect(requests[0]?.id).not.toBe(requests[1]?.id); |
| expect(requests[0]).toMatchObject({ |
| sessionKey: "agent:codex:acp:target", |
| runId: "run-1", |
| }); |
| }); |
|
|
| it("cancels an aborted request and rejects a late Gateway answer", async () => { |
| let registered = false; |
| gatewayCallMock.mockImplementation( |
| async ( |
| method: string, |
| _opts: unknown, |
| rawParams: unknown, |
| extra?: { signal?: AbortSignal }, |
| ) => { |
| if (method === "question.request") { |
| registered = true; |
| return { id: (rawParams as { id: string }).id }; |
| } |
| if (method === "question.waitAnswer") { |
| return await new Promise((_, reject) => { |
| extra?.signal?.addEventListener("abort", () => reject(new Error("late answer")), { |
| once: true, |
| }); |
| }); |
| } |
| return { status: "cancelled" }; |
| }, |
| ); |
| const controller = new AbortController(); |
| const { handler } = createFixture(); |
| const response = handler(urlRequest(), { requestId: "abort", signal: controller.signal }); |
| await vi.waitFor(() => expect(registered).toBe(true)); |
|
|
| controller.abort(); |
|
|
| await expect(response).resolves.toMatchObject({ action: "cancel" }); |
| }); |
|
|
| it("keeps explicitly marked Codex secrets out of Gateway question records", async () => { |
| gatewayCallMock.mockRejectedValue(new Error("secret must not reach Gateway questions")); |
| const { delivered, handler } = createFixture(); |
| const response = handler( |
| formRequest( |
| { |
| token: { |
| type: "string", |
| title: "Token", |
| _meta: { codex: { isSecret: true } }, |
| }, |
| }, |
| ["token"], |
| ), |
| { requestId: "secret", signal: new AbortController().signal }, |
| ); |
| await vi.waitFor(() => expect(delivered.join("\n")).toContain("may show your reply")); |
|
|
| await expect( |
| claimPendingAgentQuestionAnswer({ |
| sessionKey: "agent:codex:acp:target", |
| text: "private-value", |
| }), |
| ).resolves.toBe(true); |
|
|
| await expect(response).resolves.toEqual({ |
| action: "accept", |
| content: { token: "private-value" }, |
| }); |
| expect(gatewayCallMock).not.toHaveBeenCalled(); |
| }); |
|
|
| it("accepts an ACP form elicitation with an empty schema instead of declining it", async () => { |
| const { handler } = createFixture(); |
|
|
| const response = handler(formRequest({}), { |
| requestId: "empty-form", |
| signal: new AbortController().signal, |
| }); |
|
|
| await expect(response).resolves.toEqual({ |
| action: "accept", |
| content: {}, |
| }); |
| }); |
| }); |
|
|
