@openclaw/codex 2026.5.1-beta.1

package/src/app-server/elicitation-bridge.test.ts

@@ -0,0 +1,625 @@
+import {
+  callGatewayTool,
+  embeddedAgentLog,
+  type EmbeddedRunAttemptParams,
+} from "openclaw/plugin-sdk/agent-harness-runtime";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { handleCodexAppServerElicitationRequest } from "./elicitation-bridge.js";
+
+vi.mock("openclaw/plugin-sdk/agent-harness-runtime", async (importOriginal) => ({
+  ...(await importOriginal<typeof import("openclaw/plugin-sdk/agent-harness-runtime")>()),
+  callGatewayTool: vi.fn(),
+}));
+
+const mockCallGatewayTool = vi.mocked(callGatewayTool);
+
+function createParams(): EmbeddedRunAttemptParams {
+  return {
+    sessionKey: "agent:main:session-1",
+    agentId: "main",
+    messageChannel: "telegram",
+    currentChannelId: "chat-1",
+    agentAccountId: "default",
+    currentThreadTs: "thread-ts",
+  } as unknown as EmbeddedRunAttemptParams;
+}
+
+function buildApprovalElicitation() {
+  return {
+    threadId: "thread-1",
+    turnId: "turn-1",
+    serverName: "codex_apps__github",
+    mode: "form",
+    message: "Approve app tool call?",
+    _meta: {
+      codex_approval_kind: "mcp_tool_call",
+      persist: ["session", "always"],
+    },
+    requestedSchema: {
+      type: "object",
+      properties: {
+        approve: {
+          type: "boolean",
+          title: "Approve this tool call",
+        },
+        persist: {
+          type: "string",
+          title: "Persist choice",
+          enum: ["session", "always"],
+        },
+      },
+      required: ["approve"],
+    },
+  };
+}
+
+function buildCurrentCodexApprovalElicitation() {
+  return {
+    ...buildApprovalElicitation(),
+    _meta: {
+      codex_approval_kind: "mcp_tool_call",
+      persist: ["session", "always"],
+      connector_name: "GitHub",
+      tool_title: "Create pull request",
+      tool_description: "Creates a pull request in the selected repository.",
+      tool_params_display: [
+        { name: "repo", display_name: "Repository", value: "openclaw/openclaw" },
+      ],
+    },
+    requestedSchema: {
+      type: "object",
+      properties: {},
+    },
+  };
+}
+
+describe("Codex app-server elicitation bridge", () => {
+  beforeEach(() => {
+    mockCallGatewayTool.mockReset();
+    vi.restoreAllMocks();
+  });
+
+  it("routes MCP tool approval elicitations through plugin approvals", async () => {
+    mockCallGatewayTool
+      .mockResolvedValueOnce({ id: "plugin:approval-1", status: "accepted" })
+      .mockResolvedValueOnce({ id: "plugin:approval-1", decision: "allow-once" });
+
+    const result = await handleCodexAppServerElicitationRequest({
+      requestParams: buildApprovalElicitation(),
+      paramsForRun: createParams(),
+      threadId: "thread-1",
+      turnId: "turn-1",
+    });
+
+    expect(result).toEqual({
+      action: "accept",
+      content: {
+        approve: true,
+      },
+      _meta: null,
+    });
+    expect(mockCallGatewayTool.mock.calls.map(([method]) => method)).toEqual([
+      "plugin.approval.request",
+      "plugin.approval.waitDecision",
+    ]);
+  });
+
+  it("does not trust request-time decisions for two-phase MCP approvals", async () => {
+    mockCallGatewayTool
+      .mockResolvedValueOnce({
+        id: "plugin:approval-untrusted",
+        status: "accepted",
+        decision: "allow-always",
+      })
+      .mockResolvedValueOnce({ id: "plugin:approval-untrusted", decision: "deny" });
+
+    const result = await handleCodexAppServerElicitationRequest({
+      requestParams: buildApprovalElicitation(),
+      paramsForRun: createParams(),
+      threadId: "thread-1",
+      turnId: "turn-1",
+    });
+
+    expect(result).toEqual({ action: "decline", content: null, _meta: null });
+    expect(mockCallGatewayTool.mock.calls.map(([method]) => method)).toEqual([
+      "plugin.approval.request",
+      "plugin.approval.waitDecision",
+    ]);
+  });
+
+  it("does not treat inherited request-time MCP decisions as final", async () => {
+    const inheritedDecisionResult = Object.assign(Object.create({ decision: null }), {
+      id: "plugin:approval-inherited",
+      status: "accepted",
+    });
+    mockCallGatewayTool
+      .mockResolvedValueOnce(inheritedDecisionResult)
+      .mockResolvedValueOnce({ id: "plugin:approval-inherited", decision: "allow-once" });
+
+    const result = await handleCodexAppServerElicitationRequest({
+      requestParams: buildApprovalElicitation(),
+      paramsForRun: createParams(),
+      threadId: "thread-1",
+      turnId: "turn-1",
+    });
+
+    expect(result).toEqual({
+      action: "accept",
+      content: {
+        approve: true,
+      },
+      _meta: null,
+    });
+    expect(mockCallGatewayTool.mock.calls.map(([method]) => method)).toEqual([
+      "plugin.approval.request",
+      "plugin.approval.waitDecision",
+    ]);
+  });
+
+  it("accepts current Codex MCP approval elicitations with an empty form schema", async () => {
+    mockCallGatewayTool
+      .mockResolvedValueOnce({ id: "plugin:approval-current", status: "accepted" })
+      .mockResolvedValueOnce({ id: "plugin:approval-current", decision: "allow-once" });
+
+    const result = await handleCodexAppServerElicitationRequest({
+      requestParams: buildCurrentCodexApprovalElicitation(),
+      paramsForRun: createParams(),
+      threadId: "thread-1",
+      turnId: "turn-1",
+    });
+
+    expect(result).toEqual({
+      action: "accept",
+      content: null,
+      _meta: null,
+    });
+    expect(mockCallGatewayTool).toHaveBeenCalledWith(
+      "plugin.approval.request",
+      expect.any(Object),
+      expect.objectContaining({
+        description: expect.stringContaining("App: GitHub"),
+      }),
+      { expectFinal: false },
+    );
+    const approvalRequest = mockCallGatewayTool.mock.calls[0]?.[2] as {
+      description: string;
+    };
+    expect(approvalRequest.description).toContain("Tool: Create pull request");
+    expect(approvalRequest.description).toContain("Repository: openclaw/openclaw");
+  });
+
+  it("strips control and invisible formatting from approval display text", async () => {
+    mockCallGatewayTool
+      .mockResolvedValueOnce({ id: "plugin:approval-sanitized", status: "accepted" })
+      .mockResolvedValueOnce({ id: "plugin:approval-sanitized", decision: "allow-once" });
+
+    await handleCodexAppServerElicitationRequest({
+      requestParams: {
+        ...buildCurrentCodexApprovalElicitation(),
+        message: "Approve\u202e hidden",
+        serverName: "codex\u009b31m_apps__github",
+        _meta: {
+          codex_approval_kind: "mcp_tool_call",
+          connector_name: "GitHub\nInjected: approve",
+          tool_title: "\u001b]8;;https://evil.example\u001b\\Visible tool\u001b]8;;\u001b\\",
+          tool_description: "Creates\u0000 a\u202e pull request",
+          tool_params_display: [
+            {
+              name: "repo",
+              display_name: "Repository\u202e",
+              value: "\u001b]8;;https://evil.example\u001b\\openclaw/openclaw\u001b]8;;\u001b\\",
+            },
+          ],
+        },
+        requestedSchema: {
+          type: "object",
+          properties: {
+            approve: {
+              type: "boolean",
+              title: "Approve\u202e this tool call",
+              description: "Confirm\u009b31m access",
+            },
+          },
+          required: ["approve"],
+        },
+      },
+      paramsForRun: createParams(),
+      threadId: "thread-1",
+      turnId: "turn-1",
+    });
+
+    const approvalRequest = mockCallGatewayTool.mock.calls[0]?.[2] as {
+      title: string;
+      description: string;
+    };
+    expect(approvalRequest.title).toBe("Approve hidden");
+    expect(approvalRequest.description).toContain("GitHub Injected: approve");
+    expect(approvalRequest.description).toContain("Tool: Visible tool");
+    expect(approvalRequest.description).toContain("Repository: openclaw/openclaw");
+    expect(approvalRequest.description).toContain("- Approve this tool call: Confirm access");
+    expect(approvalRequest.description).not.toContain("https://evil.example");
+    expect(approvalRequest.description).not.toContain("\u001b");
+    expect(approvalRequest.description).not.toContain("\u009b");
+    expect(approvalRequest.description).not.toContain("\u202e");
+  });
+
+  it("falls back to stable names when display labels sanitize to empty", async () => {
+    mockCallGatewayTool
+      .mockResolvedValueOnce({ id: "plugin:approval-label-fallback", status: "accepted" })
+      .mockResolvedValueOnce({ id: "plugin:approval-label-fallback", decision: "allow-once" });
+
+    await handleCodexAppServerElicitationRequest({
+      requestParams: {
+        ...buildCurrentCodexApprovalElicitation(),
+        message: "Approve",
+        _meta: {
+          codex_approval_kind: "mcp_tool_call",
+          connector_name: "App",
+          tool_params_display: [
+            {
+              name: "repo",
+              display_name: "\u202e",
+              value: "openclaw/openclaw",
+            },
+          ],
+        },
+        requestedSchema: {
+          type: "object",
+          properties: {
+            approve: {
+              type: "boolean",
+              title: "\u202e",
+              description: "Confirm access",
+            },
+          },
+          required: ["approve"],
+        },
+      },
+      paramsForRun: createParams(),
+      threadId: "thread-1",
+      turnId: "turn-1",
+    });
+
+    const approvalRequest = mockCallGatewayTool.mock.calls[0]?.[2] as {
+      description: string;
+    };
+    expect(approvalRequest.description).toContain("- repo: openclaw/openclaw");
+    expect(approvalRequest.description).toContain("- approve: Confirm access");
+    expect(approvalRequest.description).not.toContain("- field: Confirm access");
+  });
+
+  it("bounds deep approval display parameter values before forwarding them", async () => {
+    mockCallGatewayTool
+      .mockResolvedValueOnce({ id: "plugin:approval-bounded-params", status: "accepted" })
+      .mockResolvedValueOnce({ id: "plugin:approval-bounded-params", decision: "allow-once" });
+
+    await handleCodexAppServerElicitationRequest({
+      requestParams: {
+        ...buildCurrentCodexApprovalElicitation(),
+        message: "Approve",
+        _meta: {
+          codex_approval_kind: "mcp_tool_call",
+          connector_name: "App",
+          tool_title: "Tool",
+          tool_params_display: [
+            {
+              name: "payload",
+              value: {
+                key0: { nested: { deeper: { secret: "hidden" } } },
+                key1: 1,
+                key2: 2,
+                key3: 3,
+                key4: 4,
+                key5: 5,
+                key6: 6,
+                key7: 7,
+                key8: 8,
+              },
+            },
+          ],
+        },
+      },
+      paramsForRun: createParams(),
+      threadId: "thread-1",
+      turnId: "turn-1",
+    });
+
+    const approvalRequest = mockCallGatewayTool.mock.calls[0]?.[2] as {
+      description: string;
+    };
+    expect(approvalRequest.description).toContain("payload");
+    expect(approvalRequest.description).toContain("key0");
+    expect(approvalRequest.description).not.toContain("key8");
+    expect(approvalRequest.description).not.toContain("hidden");
+  });
+
+  it("caps approval display parameter entries before forwarding them", async () => {
+    mockCallGatewayTool
+      .mockResolvedValueOnce({ id: "plugin:approval-capped-params", status: "accepted" })
+      .mockResolvedValueOnce({ id: "plugin:approval-capped-params", decision: "allow-once" });
+
+    await handleCodexAppServerElicitationRequest({
+      requestParams: {
+        ...buildCurrentCodexApprovalElicitation(),
+        message: "Approve",
+        serverName: "",
+        _meta: {
+          codex_approval_kind: "mcp_tool_call",
+          connector_name: "App",
+          tool_params_display: Array.from({ length: 9 }, (_, index) => ({
+            name: `p${index}`,
+            value: index,
+          })),
+        },
+      },
+      paramsForRun: createParams(),
+      threadId: "thread-1",
+      turnId: "turn-1",
+    });
+
+    const approvalRequest = mockCallGatewayTool.mock.calls[0]?.[2] as {
+      description: string;
+    };
+    expect(approvalRequest.description).toContain("p0");
+    expect(approvalRequest.description).toContain("p7");
+    expect(approvalRequest.description).toContain("Additional parameters: 1 more");
+    expect(approvalRequest.description).not.toContain("p8");
+  });
+
+  it("accepts approval elicitations with a null turn id when the thread matches", async () => {
+    mockCallGatewayTool
+      .mockResolvedValueOnce({ id: "plugin:approval-null-turn", status: "accepted" })
+      .mockResolvedValueOnce({ id: "plugin:approval-null-turn", decision: "allow-once" });
+
+    const result = await handleCodexAppServerElicitationRequest({
+      requestParams: {
+        ...buildCurrentCodexApprovalElicitation(),
+        turnId: null,
+      },
+      paramsForRun: createParams(),
+      threadId: "thread-1",
+      turnId: "turn-1",
+    });
+
+    expect(result).toEqual({
+      action: "accept",
+      content: null,
+      _meta: null,
+    });
+  });
+
+  it("ignores unscoped approval elicitations without the active thread id", async () => {
+    const { turnId, serverName, mode, message, _meta, requestedSchema } =
+      buildCurrentCodexApprovalElicitation();
+    const result = await handleCodexAppServerElicitationRequest({
+      requestParams: { turnId, serverName, mode, message, _meta, requestedSchema },
+      paramsForRun: createParams(),
+      threadId: "thread-1",
+      turnId: "turn-1",
+    });
+
+    expect(result).toBeUndefined();
+    expect(mockCallGatewayTool).not.toHaveBeenCalled();
+  });
+
+  it("maps allow-always decisions onto persistent approval metadata when offered", async () => {
+    mockCallGatewayTool
+      .mockResolvedValueOnce({ id: "plugin:approval-2", status: "accepted" })
+      .mockResolvedValueOnce({ id: "plugin:approval-2", decision: "allow-always" });
+
+    const result = await handleCodexAppServerElicitationRequest({
+      requestParams: buildApprovalElicitation(),
+      paramsForRun: createParams(),
+      threadId: "thread-1",
+      turnId: "turn-1",
+    });
+
+    expect(result).toEqual({
+      action: "accept",
+      content: {
+        approve: true,
+        persist: "always",
+      },
+      _meta: {
+        persist: "always",
+      },
+    });
+  });
+
+  it("maps allow-always decisions onto metadata for current empty-schema approvals", async () => {
+    mockCallGatewayTool
+      .mockResolvedValueOnce({ id: "plugin:approval-current-always", status: "accepted" })
+      .mockResolvedValueOnce({ id: "plugin:approval-current-always", decision: "allow-always" });
+
+    const result = await handleCodexAppServerElicitationRequest({
+      requestParams: buildCurrentCodexApprovalElicitation(),
+      paramsForRun: createParams(),
+      threadId: "thread-1",
+      turnId: "turn-1",
+    });
+
+    expect(result).toEqual({
+      action: "accept",
+      content: null,
+      _meta: {
+        persist: "always",
+      },
+    });
+  });
+
+  it("does not inherit persist defaults for one-time approvals", async () => {
+    mockCallGatewayTool
+      .mockResolvedValueOnce({ id: "plugin:approval-5", status: "accepted" })
+      .mockResolvedValueOnce({ id: "plugin:approval-5", decision: "allow-once" });
+
+    const result = await handleCodexAppServerElicitationRequest({
+      requestParams: {
+        ...buildApprovalElicitation(),
+        requestedSchema: {
+          type: "object",
+          properties: {
+            approve: {
+              type: "boolean",
+              title: "Approve this tool call",
+            },
+            persist: {
+              type: "string",
+              title: "Persist choice",
+              enum: ["session", "always"],
+              default: "always",
+            },
+          },
+          required: ["approve"],
+        },
+      },
+      paramsForRun: createParams(),
+      threadId: "thread-1",
+      turnId: "turn-1",
+    });
+
+    expect(result).toEqual({
+      action: "accept",
+      content: {
+        approve: true,
+      },
+      _meta: null,
+    });
+  });
+
+  it("truncates long approval titles and descriptions before requesting approval", async () => {
+    mockCallGatewayTool
+      .mockResolvedValueOnce({ id: "plugin:approval-4", status: "accepted" })
+      .mockResolvedValueOnce({ id: "plugin:approval-4", decision: "allow-once" });
+
+    const result = await handleCodexAppServerElicitationRequest({
+      requestParams: {
+        ...buildApprovalElicitation(),
+        message: "Approve ".repeat(20).trim(),
+        requestedSchema: {
+          type: "object",
+          properties: {
+            approve: {
+              type: "boolean",
+              title: "Approve this tool call",
+              description: "Explain ".repeat(60).trim(),
+            },
+          },
+          required: ["approve"],
+        },
+      },
+      paramsForRun: createParams(),
+      threadId: "thread-1",
+      turnId: "turn-1",
+    });
+
+    expect(result).toEqual({
+      action: "accept",
+      content: {
+        approve: true,
+      },
+      _meta: null,
+    });
+    expect(mockCallGatewayTool).toHaveBeenCalledWith(
+      "plugin.approval.request",
+      expect.any(Object),
+      expect.objectContaining({
+        title: expect.any(String),
+        description: expect.any(String),
+      }),
+      { expectFinal: false },
+    );
+    const approvalRequest = mockCallGatewayTool.mock.calls[0]?.[2] as {
+      title: string;
+      description: string;
+    };
+    expect(approvalRequest.title.length).toBeLessThanOrEqual(80);
+    expect(approvalRequest.description.length).toBeLessThanOrEqual(256);
+  });
+
+  it("fails closed when the approval route is unavailable", async () => {
+    mockCallGatewayTool.mockResolvedValueOnce({ id: "plugin:approval-3", decision: null });
+
+    const result = await handleCodexAppServerElicitationRequest({
+      requestParams: buildApprovalElicitation(),
+      paramsForRun: createParams(),
+      threadId: "thread-1",
+      turnId: "turn-1",
+    });
+
+    expect(result).toEqual({
+      action: "decline",
+      content: null,
+      _meta: null,
+    });
+  });
+
+  it("ignores non-approval elicitation requests", async () => {
+    const result = await handleCodexAppServerElicitationRequest({
+      requestParams: {
+        threadId: "thread-1",
+        turnId: "turn-1",
+        serverName: "codex_apps__github",
+        mode: "form",
+        message: "Choose a template",
+        _meta: {},
+        requestedSchema: {
+          type: "object",
+          properties: {
+            template: {
+              type: "string",
+              enum: ["simple", "fancy"],
+            },
+          },
+          required: ["template"],
+        },
+      },
+      paramsForRun: createParams(),
+      threadId: "thread-1",
+      turnId: "turn-1",
+    });
+
+    expect(result).toBeUndefined();
+    expect(mockCallGatewayTool).not.toHaveBeenCalled();
+  });
+
+  it("logs and declines approved elicitations that do not expose an approval field", async () => {
+    const warn = vi.spyOn(embeddedAgentLog, "warn").mockImplementation(() => undefined);
+    mockCallGatewayTool
+      .mockResolvedValueOnce({ id: "plugin:approval-6", status: "accepted" })
+      .mockResolvedValueOnce({ id: "plugin:approval-6", decision: "allow-once" });
+
+    const result = await handleCodexAppServerElicitationRequest({
+      requestParams: {
+        ...buildApprovalElicitation(),
+        requestedSchema: {
+          type: "object",
+          properties: {
+            confirmChoice: {
+              type: "string",
+              title: "Confirmation choice",
+              enum: ["yes", "no"],
+            },
+          },
+          required: ["confirmChoice"],
+        },
+      },
+      paramsForRun: createParams(),
+      threadId: "thread-1",
+      turnId: "turn-1",
+    });
+
+    expect(result).toEqual({
+      action: "decline",
+      content: null,
+      _meta: null,
+    });
+    expect(warn).toHaveBeenCalledWith(
+      "codex MCP approval elicitation approved without a mappable response",
+      expect.objectContaining({
+        approvalKind: "mcp_tool_call",
+        fields: ["confirmChoice"],
+        outcome: "approved-once",
+      }),
+    );
+  });
+});