@posthog/agent 2.3.520 → 2.3.526

package/dist/adapters/codex/structured-output-mcp-server.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/adapters/codex/structured-output-mcp-server.js

@@ -0,0 +1,54 @@
+// src/adapters/codex/structured-output-mcp-server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+
+// src/adapters/codex/structured-output-constants.ts
+var STRUCTURED_OUTPUT_MCP_NAME = "posthog_output";
+var STRUCTURED_OUTPUT_TOOL_NAME = "create_output";
+
+// src/adapters/codex/structured-output-mcp-server.ts
+function die(message) {
+  process.stderr.write(`[structured-output-mcp-server] ${message}
+`);
+  process.exit(1);
+}
+var schemaEnv = process.env.POSTHOG_OUTPUT_SCHEMA;
+if (!schemaEnv) {
+  die("POSTHOG_OUTPUT_SCHEMA env var is required");
+}
+var jsonSchema;
+try {
+  jsonSchema = JSON.parse(Buffer.from(schemaEnv, "base64").toString("utf-8"));
+} catch (err) {
+  die(`Failed to parse POSTHOG_OUTPUT_SCHEMA as base64-encoded JSON: ${err}`);
+}
+var zodType = z.fromJSONSchema(jsonSchema);
+if (!(zodType instanceof z.ZodObject)) {
+  die(
+    `POSTHOG_OUTPUT_SCHEMA must describe a JSON object schema (got ${zodType.constructor.name})`
+  );
+}
+var zodShape = { ...zodType.shape };
+var server = new McpServer({
+  name: STRUCTURED_OUTPUT_MCP_NAME,
+  version: "1.0.0"
+});
+server.tool(
+  STRUCTURED_OUTPUT_TOOL_NAME,
+  "Submit the structured output for this task. Call this tool with the required fields to deliver your final result.",
+  zodShape,
+  async () => {
+    return {
+      content: [
+        {
+          type: "text",
+          text: "Output submitted successfully."
+        }
+      ]
+    };
+  }
+);
+var transport = new StdioServerTransport();
+await server.connect(transport);
+//# sourceMappingURL=structured-output-mcp-server.js.map

package/dist/adapters/codex/structured-output-mcp-server.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/adapters/codex/structured-output-mcp-server.ts","../../../src/adapters/codex/structured-output-constants.ts"],"sourcesContent":["/**\n * Standalone stdio MCP server for structured output in the Codex adapter.\n *\n * Spawned by codex-acp as an MCP server process. Reads the JSON schema\n * from the POSTHOG_OUTPUT_SCHEMA env var (base64-encoded) and registers\n * a tool whose Zod shape McpServer.tool() validates on each call.\n *\n * Usage:\n *   POSTHOG_OUTPUT_SCHEMA=<base64> node structured-output-mcp-server.js\n */\n\nimport { McpServer } from \"@modelcontextprotocol/sdk/server/mcp.js\";\nimport { StdioServerTransport } from \"@modelcontextprotocol/sdk/server/stdio.js\";\nimport { z } from \"zod\";\nimport {\n  STRUCTURED_OUTPUT_MCP_NAME,\n  STRUCTURED_OUTPUT_TOOL_NAME,\n} from \"./structured-output-constants\";\n\nfunction die(message: string): never {\n  process.stderr.write(`[structured-output-mcp-server] ${message}\\n`);\n  process.exit(1);\n}\n\nconst schemaEnv = process.env.POSTHOG_OUTPUT_SCHEMA;\nif (!schemaEnv) {\n  die(\"POSTHOG_OUTPUT_SCHEMA env var is required\");\n}\n\nlet jsonSchema: Record<string, unknown>;\ntry {\n  jsonSchema = JSON.parse(Buffer.from(schemaEnv, \"base64\").toString(\"utf-8\"));\n} catch (err) {\n  die(`Failed to parse POSTHOG_OUTPUT_SCHEMA as base64-encoded JSON: ${err}`);\n}\n\nconst zodType = z.fromJSONSchema(jsonSchema);\nif (!(zodType instanceof z.ZodObject)) {\n  die(\n    `POSTHOG_OUTPUT_SCHEMA must describe a JSON object schema (got ${zodType.constructor.name})`,\n  );\n}\n// McpServer.tool() expects a mutable ZodRawShape\nconst zodShape = { ...zodType.shape } as z.ZodRawShape;\n\nconst server = new McpServer({\n  name: STRUCTURED_OUTPUT_MCP_NAME,\n  version: \"1.0.0\",\n});\n\nserver.tool(\n  STRUCTURED_OUTPUT_TOOL_NAME,\n  \"Submit the structured output for this task. Call this tool with the required fields to deliver your final result.\",\n  zodShape,\n  async () => {\n    // McpServer.tool() validates `args` against `zodShape` before invoking\n    // this handler, so reaching this point means the input is valid. The\n    // parent process captures the validated output by intercepting the\n    // tool call in the ACP stream.\n    return {\n      content: [\n        {\n          type: \"text\" as const,\n          text: \"Output submitted successfully.\",\n        },\n      ],\n    };\n  },\n);\n\nconst transport = new StdioServerTransport();\nawait server.connect(transport);\n","/**\n * Shared identifiers for the injected structured-output MCP server.\n * Imported by codex-agent.ts (server config), codex-client.ts (tool-call\n * matching), and structured-output-mcp-server.ts (tool registration) so the\n * three stay in sync.\n */\n\nexport const STRUCTURED_OUTPUT_MCP_NAME = \"posthog_output\";\nexport const STRUCTURED_OUTPUT_TOOL_NAME = \"create_output\";\n"],"mappings":";AAWA,SAAS,iBAAiB;AAC1B,SAAS,4BAA4B;AACrC,SAAS,SAAS;;;ACNX,IAAM,6BAA6B;AACnC,IAAM,8BAA8B;;;ADW3C,SAAS,IAAI,SAAwB;AACnC,UAAQ,OAAO,MAAM,kCAAkC,OAAO;AAAA,CAAI;AAClE,UAAQ,KAAK,CAAC;AAChB;AAEA,IAAM,YAAY,QAAQ,IAAI;AAC9B,IAAI,CAAC,WAAW;AACd,MAAI,2CAA2C;AACjD;AAEA,IAAI;AACJ,IAAI;AACF,eAAa,KAAK,MAAM,OAAO,KAAK,WAAW,QAAQ,EAAE,SAAS,OAAO,CAAC;AAC5E,SAAS,KAAK;AACZ,MAAI,iEAAiE,GAAG,EAAE;AAC5E;AAEA,IAAM,UAAU,EAAE,eAAe,UAAU;AAC3C,IAAI,EAAE,mBAAmB,EAAE,YAAY;AACrC;AAAA,IACE,iEAAiE,QAAQ,YAAY,IAAI;AAAA,EAC3F;AACF;AAEA,IAAM,WAAW,EAAE,GAAG,QAAQ,MAAM;AAEpC,IAAM,SAAS,IAAI,UAAU;AAAA,EAC3B,MAAM;AAAA,EACN,SAAS;AACX,CAAC;AAED,OAAO;AAAA,EACL;AAAA,EACA;AAAA,EACA;AAAA,EACA,YAAY;AAKV,WAAO;AAAA,MACL,SAAS;AAAA,QACP;AAAA,UACE,MAAM;AAAA,UACN,MAAM;AAAA,QACR;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF;AAEA,IAAM,YAAY,IAAI,qBAAqB;AAC3C,MAAM,OAAO,QAAQ,SAAS;","names":[]}

package/dist/agent.js

@@ -4030,7 +4030,7 @@ import { v7 as uuidv7 } from "uuid";
 // package.json
 var package_default = {
   name: "@posthog/agent",
-  version: "2.3.520",
+  version: "2.3.526",
   repository: "https://github.com/PostHog/code",
   description: "TypeScript agent framework wrapping Claude Agent SDK with Git-based task execution for PostHog",
   exports: {
@@ -4147,7 +4147,6 @@ var package_default = {
   },
   dependencies: {
     "@agentclientprotocol/sdk": "0.19.0",
-    ajv: "^8.17.1",
     "@anthropic-ai/claude-agent-sdk": "0.2.112",
     "@anthropic-ai/sdk": "0.89.0",
     "@hono/node-server": "^1.19.9",
@@ -4161,6 +4160,7 @@ var package_default = {
     hono: "^4.11.7",
     jsonwebtoken: "^9.0.2",
     minimatch: "^10.0.3",
+    "@modelcontextprotocol/sdk": "1.29.0",
     tar: "^7.5.0",
     uuid: "13.0.0",
     "yoga-wasm-web": "^0.3.3",
@@ -17808,13 +17808,30 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
 };
 
 // src/adapters/codex/codex-agent.ts
+import { existsSync as existsSync5 } from "fs";
+import { resolve as resolvePath } from "path";
 import {
   ClientSideConnection,
   ndJsonStream,
   RequestError as RequestError3
 } from "@agentclientprotocol/sdk";
 
+// src/adapters/codex/structured-output-constants.ts
+var STRUCTURED_OUTPUT_MCP_NAME = "posthog_output";
+var STRUCTURED_OUTPUT_TOOL_NAME = "create_output";
+
 // src/adapters/codex/codex-client.ts
+function isStructuredOutputToolCall(title) {
+  if (!title) return false;
+  if (title === STRUCTURED_OUTPUT_TOOL_NAME) return true;
+  return title.includes(STRUCTURED_OUTPUT_MCP_NAME) && title.includes(STRUCTURED_OUTPUT_TOOL_NAME);
+}
+function toRecord(value) {
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    return value;
+  }
+  return null;
+}
 var AUTO_APPROVED_KINDS = {
   default: /* @__PURE__ */ new Set(["read", "search", "fetch", "think"]),
   acceptEdits: /* @__PURE__ */ new Set(["read", "edit", "search", "fetch", "think"]),
@@ -17853,6 +17870,7 @@ function shouldAutoApprove(mode, kind) {
 }
 function createCodexClient(upstreamClient, logger, sessionState, callbacks) {
   const terminalHandles = /* @__PURE__ */ new Map();
+  const structuredOutputState = /* @__PURE__ */ new Map();
   return {
     async requestPermission(params) {
       const kind = params.toolCall?.kind;
@@ -17876,6 +17894,26 @@ function createCodexClient(upstreamClient, logger, sessionState, callbacks) {
     },
     async sessionUpdate(params) {
       const update = params.update;
+      if (callbacks?.onStructuredOutput && (update?.sessionUpdate === "tool_call" || update?.sessionUpdate === "tool_call_update")) {
+        const toolCallId = update.toolCallId;
+        const title = update.title;
+        if (toolCallId && isStructuredOutputToolCall(title)) {
+          const entry = structuredOutputState.get(toolCallId) ?? {
+            fired: false
+          };
+          const rawInput = toRecord(update.rawInput);
+          if (rawInput) entry.rawInput = rawInput;
+          structuredOutputState.set(toolCallId, entry);
+          if (update.status === "completed" && !entry.fired && entry.rawInput) {
+            entry.fired = true;
+            try {
+              await callbacks.onStructuredOutput(entry.rawInput);
+            } catch (err2) {
+              logger.warn("onStructuredOutput callback threw", { error: err2 });
+            }
+          }
+        }
+      }
       if (update?.sessionUpdate === "usage_update") {
         const used = update.used;
         const size = update.size;
@@ -18237,6 +18275,33 @@ function getCurrentPermissionMode(currentModeId, fallbackMode) {
   }
   return toCodexPermissionMode(fallbackMode);
 }
+var STRUCTURED_OUTPUT_INSTRUCTIONS = `
+
+When you have completed the task, call the \`${STRUCTURED_OUTPUT_TOOL_NAME}\` tool with the final structured result. The tool's input schema matches the required output format for this task. Do not describe the result in a plain message \u2014 submitting it via the tool is required for the task to be considered complete.`;
+function resolveStructuredOutputMcpScript() {
+  const rel = "adapters/codex/structured-output-mcp-server.js";
+  let dir = import.meta.dirname ?? __dirname;
+  for (let i2 = 0; i2 < 5; i2++) {
+    const candidate = resolvePath(dir, rel);
+    if (existsSync5(candidate)) return candidate;
+    dir = resolvePath(dir, "..");
+  }
+  throw new Error(
+    `Could not locate ${rel} relative to ${import.meta.dirname ?? __dirname}.`
+  );
+}
+function buildStructuredOutputMcpServer(jsonSchema) {
+  const scriptPath = resolveStructuredOutputMcpScript();
+  const schemaBase64 = Buffer.from(JSON.stringify(jsonSchema)).toString(
+    "base64"
+  );
+  return {
+    name: STRUCTURED_OUTPUT_MCP_NAME,
+    command: process.execPath,
+    args: [scriptPath],
+    env: [{ name: "POSTHOG_OUTPUT_SCHEMA", value: schemaBase64 }]
+  };
+}
 var CodexAcpAgent = class extends BaseAcpAgent {
   adapterName = "codex";
   codexProcess;
@@ -18255,6 +18320,7 @@ var CodexAcpAgent = class extends BaseAcpAgent {
   promptMutex = Promise.resolve();
   codexProcessOptions;
   processCallbacks;
+  onStructuredOutput;
   // Snapshot of the initialize() request so refreshSession can replay the
   // same handshake against a respawned codex-acp subprocess.
   lastInitRequest;
@@ -18266,6 +18332,7 @@ var CodexAcpAgent = class extends BaseAcpAgent {
     const settingsManager = new CodexSettingsManager(cwd);
     this.codexProcessOptions = options.codexProcessOptions;
     this.processCallbacks = options.processCallbacks;
+    this.onStructuredOutput = options.onStructuredOutput;
     this.codexProcess = spawnCodexProcess({
       ...options.codexProcessOptions,
       settings: settingsManager.getSettings(),
@@ -18287,7 +18354,8 @@ var CodexAcpAgent = class extends BaseAcpAgent {
     this.enrichment = createEnrichment(options.posthogApiConfig, this.logger);
     this.codexConnection = new ClientSideConnection(
       (_agent) => createCodexClient(this.client, this.logger, this.sessionState, {
-        enrichmentDeps: this.enrichment?.deps
+        enrichmentDeps: this.enrichment?.deps,
+        onStructuredOutput: this.onStructuredOutput
       }),
       codexStream
     );
@@ -18321,7 +18389,8 @@ var CodexAcpAgent = class extends BaseAcpAgent {
   async newSession(params) {
     const meta = params._meta;
     const requestedPermissionMode = toCodexPermissionMode(meta?.permissionMode);
-    const response = await this.codexConnection.newSession(params);
+    const injectedParams = this.applyStructuredOutput(params, meta);
+    const response = await this.codexConnection.newSession(injectedParams);
     response.configOptions = normalizeCodexConfigOptions(
       response.configOptions
     );
@@ -18353,11 +18422,12 @@ var CodexAcpAgent = class extends BaseAcpAgent {
     return response;
   }
   async loadSession(params) {
-    const response = await this.codexConnection.loadSession(params);
+    const meta = params._meta;
+    const injectedParams = this.applyStructuredOutput(params, meta);
+    const response = await this.codexConnection.loadSession(injectedParams);
     response.configOptions = normalizeCodexConfigOptions(
       response.configOptions
     );
-    const meta = params._meta;
     const currentPermissionMode = getCurrentPermissionMode(
       response.modes?.currentModeId,
       meta?.permissionMode
@@ -18380,15 +18450,20 @@ var CodexAcpAgent = class extends BaseAcpAgent {
     return response;
   }
   async unstable_resumeSession(params) {
-    const loadResponse = await this.codexConnection.loadSession({
-      sessionId: params.sessionId,
-      cwd: params.cwd,
-      mcpServers: params.mcpServers ?? []
-    });
+    const meta = params._meta;
+    const injectedParams = this.applyStructuredOutput(
+      {
+        sessionId: params.sessionId,
+        cwd: params.cwd,
+        mcpServers: params.mcpServers ?? [],
+        _meta: params._meta
+      },
+      meta
+    );
+    const loadResponse = await this.codexConnection.loadSession(injectedParams);
     loadResponse.configOptions = normalizeCodexConfigOptions(
       loadResponse.configOptions
     );
-    const meta = params._meta;
     const currentPermissionMode = getCurrentPermissionMode(
       loadResponse.modes?.currentModeId,
       meta?.permissionMode
@@ -18415,15 +18490,19 @@ var CodexAcpAgent = class extends BaseAcpAgent {
     };
   }
   async unstable_forkSession(params) {
-    const newResponse = await this.codexConnection.newSession({
-      cwd: params.cwd,
-      mcpServers: params.mcpServers ?? [],
-      _meta: params._meta
-    });
+    const meta = params._meta;
+    const injectedParams = this.applyStructuredOutput(
+      {
+        cwd: params.cwd,
+        mcpServers: params.mcpServers ?? [],
+        _meta: params._meta
+      },
+      meta
+    );
+    const newResponse = await this.codexConnection.newSession(injectedParams);
     newResponse.configOptions = normalizeCodexConfigOptions(
       newResponse.configOptions
     );
-    const meta = params._meta;
     const requestedPermissionMode = toCodexPermissionMode(meta?.permissionMode);
     this.sessionState = createSessionState(newResponse.sessionId, params.cwd, {
       taskRunId: meta?.taskRunId,
@@ -18440,6 +18519,30 @@ var CodexAcpAgent = class extends BaseAcpAgent {
     );
     return newResponse;
   }
+  /**
+   * When the caller wires up `onStructuredOutput` and provides a JSON schema
+   * via `_meta.jsonSchema`, inject the stdio MCP server that exposes
+   * `create_output` and append instructions telling the model to use it.
+   *
+   * Codex has no native equivalent of Claude's `outputFormat`, so we lean on
+   * MCP tool-calling to get validated structured output back.
+   */
+  applyStructuredOutput(request, meta) {
+    if (!meta?.jsonSchema || !this.onStructuredOutput) {
+      return request;
+    }
+    const mcpServer = buildStructuredOutputMcpServer(meta.jsonSchema);
+    const existingMeta = request._meta ?? {};
+    const existingSystemPrompt = typeof existingMeta.systemPrompt === "string" ? existingMeta.systemPrompt : "";
+    return {
+      ...request,
+      mcpServers: [...request.mcpServers ?? [], mcpServer],
+      _meta: {
+        ...existingMeta,
+        systemPrompt: existingSystemPrompt + STRUCTURED_OUTPUT_INSTRUCTIONS
+      }
+    };
+  }
   async applyInitialPermissionMode(sessionId, permissionMode, currentModeId) {
     if (!permissionMode) {
       return;
@@ -18598,7 +18701,9 @@ var CodexAcpAgent = class extends BaseAcpAgent {
     const codexStream = ndJsonStream(codexWritable, codexReadable);
     const newAbortController = new AbortController();
     const newConnection = new ClientSideConnection(
-      (_agent) => createCodexClient(this.client, this.logger, this.sessionState),
+      (_agent) => createCodexClient(this.client, this.logger, this.sessionState, {
+        onStructuredOutput: this.onStructuredOutput
+      }),
       codexStream
     );
     const initRequest = this.lastInitRequest ?? {
@@ -18778,7 +18883,8 @@ function createCodexConnection(config) {
     agent = new CodexAcpAgent(client, {
       codexProcessOptions: config.codexOptions ?? {},
       processCallbacks: config.processCallbacks,
-      posthogApiConfig: resolveEnricherApiConfig(config)
+      posthogApiConfig: resolveEnricherApiConfig(config),
+      onStructuredOutput: config.onStructuredOutput
     });
     return agent;
   }, agentStream);