toolcraft 0.0.26 → 0.0.33

package/dist/error-report.js

@@ -116,6 +116,25 @@ function redactValue(value) {
     }
     return `<set, ${value.length} chars>`;
 }
+function collectStringLeaves(value, output) {
+    if (typeof value === "string") {
+        if (value.length > 0) {
+            output.add(value);
+        }
+        return;
+    }
+    if (Array.isArray(value)) {
+        for (const entry of value) {
+            collectStringLeaves(entry, output);
+        }
+        return;
+    }
+    if (isPlainObject(value)) {
+        for (const entry of Object.values(value)) {
+            collectStringLeaves(entry, output);
+        }
+    }
+}
 function schemaSecretValue(schema) {
     const unwrapped = unwrapOptional(schema);
     if (unwrapped.kind === "string" || unwrapped.kind === "number") {
@@ -155,6 +174,52 @@ function redactParams(params, command) {
     }
     return redactParamsValue(params, command.params, "");
 }
+function collectSensitiveParamValues(value, schema, name, output) {
+    if (shouldRedactParam(name, schema)) {
+        collectStringLeaves(value, output);
+        return;
+    }
+    const unwrapped = unwrapOptional(schema);
+    if (unwrapped.kind === "object" && isPlainObject(value)) {
+        for (const [key, childValue] of Object.entries(value)) {
+            const childSchema = unwrapped.shape[key];
+            if (childSchema !== undefined) {
+                collectSensitiveParamValues(childValue, childSchema, key, output);
+            }
+        }
+        return;
+    }
+    if (unwrapped.kind === "array" && Array.isArray(value)) {
+        for (const entry of value) {
+            collectSensitiveParamValues(entry, unwrapped.item, name, output);
+        }
+    }
+}
+function createReportStringRedactor(context, env) {
+    const values = new Set();
+    for (const value of Object.values(context.secrets ?? {})) {
+        if (value !== undefined && value.length > 0) {
+            values.add(value);
+        }
+    }
+    for (const [name, secret] of Object.entries(context.command?.secrets ?? {})) {
+        const value = context.secrets?.[name] ?? env[secret.env];
+        if (value !== undefined && value.length > 0) {
+            values.add(value);
+        }
+    }
+    if (context.command !== undefined) {
+        collectSensitiveParamValues(context.params, context.command.params, "", values);
+    }
+    const orderedValues = [...values].sort((left, right) => right.length - left.length);
+    return (value) => {
+        let redacted = value;
+        for (const secretValue of orderedValues) {
+            redacted = redacted.split(secretValue).join("<redacted>");
+        }
+        return redacted;
+    };
+}
 function commandSecretEnvNames(secrets) {
     if (secrets === undefined) {
         return [];
@@ -203,7 +268,7 @@ function redactArgv(argv, options) {
 function stableJson(value) {
     return JSON.stringify(value, null, 2) ?? "undefined";
 }
-function redactStructuredErrorField(name, value) {
+function redactStructuredErrorField(name, value, redactString) {
     if (typeof value === "string") {
         const redactedHeaderValue = redactHttpHeaderValue(name, value);
         if (redactedHeaderValue !== value) {
@@ -212,23 +277,27 @@ function redactStructuredErrorField(name, value) {
         if (isSensitiveName(name)) {
             return "<redacted>";
         }
+        return redactString(value);
     }
     if (Array.isArray(value)) {
-        return value.map((entry) => redactStructuredErrorField(name, entry));
+        return value.map((entry) => redactStructuredErrorField(name, entry, redactString));
     }
     if (isPlainObject(value)) {
-        return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, redactStructuredErrorField(key, entry)]));
+        return Object.fromEntries(Object.entries(value).map(([key, entry]) => [
+            key,
+            redactStructuredErrorField(key, entry, redactString)
+        ]));
     }
     return value;
 }
-function ownStructuredFields(error) {
+function ownStructuredFields(error, redactString) {
     const fields = {};
     for (const key of Object.keys(error)) {
         if (key === "name" || key === "message" || key === "stack" || key === "cause") {
             continue;
         }
         Object.defineProperty(fields, key, {
-            value: redactStructuredErrorField(key, error[key]),
+            value: redactStructuredErrorField(key, error[key], redactString),
             enumerable: true,
             configurable: true,
             writable: true
@@ -236,47 +305,47 @@ function ownStructuredFields(error) {
     }
     return fields;
 }
-function formatStackChain(error) {
+function formatStackChain(error, redactString) {
     const lines = [];
     let current = error;
     let index = 0;
     while (current !== undefined) {
         if (current instanceof Error) {
-            lines.push(index === 0
-                ? (current.stack ?? String(current))
-                : `Caused by: ${current.stack ?? String(current)}`);
+            const stack = current.stack ?? String(current);
+            lines.push(redactString(index === 0 ? stack : `Caused by: ${stack}`));
             current = current.cause;
         }
         else {
-            lines.push(index === 0 ? String(current) : `Caused by: ${String(current)}`);
+            const message = String(current);
+            lines.push(redactString(index === 0 ? message : `Caused by: ${message}`));
             current = undefined;
         }
         index += 1;
     }
     return lines.join("\n");
 }
-function formatHeaderValue(name, value) {
-    return redactHttpHeaderValue(name, value);
+function formatHeaderValue(name, value, redactString) {
+    return redactString(redactHttpHeaderValue(name, value));
 }
-function formatHeaders(headers) {
+function formatHeaders(headers, redactString) {
     return Object.entries(headers)
-        .map(([name, value]) => `${name}: ${formatHeaderValue(name, value)}`)
+        .map(([name, value]) => `${name}: ${formatHeaderValue(name, value, redactString)}`)
         .join("\n");
 }
-function formatBody(body) {
+function formatBody(body, redactString) {
     const redactedBody = redactHttpBody(body);
     if (typeof redactedBody === "string") {
-        return redactedBody;
+        return redactString(redactedBody);
     }
-    return stableJson(redactedBody);
+    return redactString(stableJson(redactedBody));
 }
-function formatHttpTranscript(error) {
+function formatHttpTranscript(error, redactString) {
     const requestLines = [
         `${error.request.method} ${error.request.url}`,
-        formatHeaders(error.request.headers)
+        formatHeaders(error.request.headers, redactString)
     ].filter((line) => line.length > 0);
     if (error.request.body !== undefined) {
-        requestLines.push("", formatBody(error.request.body));
+        requestLines.push("", formatBody(error.request.body, redactString));
     }
     return [
         "Request:",
@@ -284,9 +353,9 @@ function formatHttpTranscript(error) {
         "",
         "Response:",
         `${error.response.status} ${error.response.statusText}`,
-        formatHeaders(error.response.headers),
+        formatHeaders(error.response.headers, redactString),
         "",
-        formatBody(error.response.body)
+        formatBody(error.response.body, redactString)
     ].join("\n");
 }
 function resolveToolcraftVersion(version) {
@@ -297,9 +366,10 @@ function resolveToolcraftVersion(version) {
 function buildReport(context) {
     const env = context.env ?? process.env;
     const error = context.error;
+    const redactString = createReportStringRedactor(context, env);
     const errorName = error instanceof Error ? error.name : typeof error;
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    const structuredFields = error instanceof Error ? ownStructuredFields(error) : {};
+    const errorMessage = redactString(error instanceof Error ? error.message : String(error));
+    const structuredFields = error instanceof Error ? ownStructuredFields(error, redactString) : {};
     const secretLines = Object.entries(context.command?.secrets ?? {}).map(([name, secret]) => {
         const value = context.secrets?.[name] ?? env[secret.env];
         return `${secret.env}=${redactValue(value)}`;
@@ -313,7 +383,7 @@ function buildReport(context) {
         `platform: ${process.platform} ${process.arch}`,
         "",
         "Argv",
-        stableJson(redactArgv(context.argv, { command: context.command, secrets: context.secrets })),
+        redactString(stableJson(redactArgv(context.argv, { command: context.command, secrets: context.secrets }))),
         "",
         "Resolved Secrets",
         ...(secretLines.length === 0 ? ["<none>"] : secretLines),
@@ -324,19 +394,19 @@ function buildReport(context) {
             : context.commandPath,
         "",
         "Parsed Params",
-        stableJson(redactParams(context.params, context.command)),
+        redactString(stableJson(redactParams(context.params, context.command))),
         "",
         "Error",
         `name: ${errorName}`,
         `message: ${errorMessage}`,
         "structured fields:",
-        stableJson(structuredFields),
+        redactString(stableJson(structuredFields)),
         "",
         "Stack",
-        formatStackChain(error)
+        formatStackChain(error, redactString)
     ];
     if (hasHttpContext(error)) {
-        lines.push("", "HTTP Transcript", formatHttpTranscript(error));
+        lines.push("", "HTTP Transcript", formatHttpTranscript(error, redactString));
     }
     return `${lines.join("\n")}\n`;
 }

package/dist/human-in-loop/approvals-commands.js

@@ -1,5 +1,6 @@
 import { TaskNotFoundError } from "@poe-code/task-list";
 import { S } from "toolcraft-schema";
+import { hasOwnErrorCode } from "../error-codes.js";
 import { UserError, defineCommand, defineGroup } from "../index.js";
 import { ensureApprovalList } from "./approval-tasks.js";
 import { runApproval } from "./runner.js";
@@ -231,5 +232,5 @@ function escapeMarkdownCell(value) {
     return value.replaceAll("|", "\\|");
 }
 function isMissingStateError(error) {
-    return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+    return hasOwnErrorCode(error, "ENOENT");
 }

package/dist/human-in-loop/runner.js

@@ -184,8 +184,8 @@ function createHandlerContext(command, params) {
 function createFs() {
     return {
         readFile: async (path, encoding = "utf8") => readFile(path, { encoding }),
-        writeFile: async (path, contents) => {
-            await writeFile(path, contents);
+        writeFile: async (path, contents, options) => {
+            await writeFile(path, contents, options);
         },
         exists: async (path) => {
             try {

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import type { McpServerConfig } from "@poe-code/agent-mcp-config";
 import type { ObjectSchema, Static } from "toolcraft-schema";
-import type { LoggerOutput, RenderTableOptions, ThemePalette } from "@poe-code/design-system";
+import type { LoggerOutput, RenderTableOptions, ThemePalette } from "toolcraft-design";
 import { ApprovalDeclinedError } from "./human-in-loop/types.js";
 import type { HumanInLoopConfig, HumanInLoopPending, HumanInLoopRuntimeOptions } from "./human-in-loop/types.js";
 import { ToolcraftBugError, UserError } from "./user-error.js";
@@ -33,7 +33,11 @@ export type InferSecrets<TSecrets extends SecretDeclarations | undefined> = TSec
 } : Record<string, never>;
 export interface HandlerFs {
     readFile(path: string, encoding?: BufferEncoding): Promise<string>;
-    writeFile(path: string, contents: string): Promise<void>;
+    writeFile(path: string, contents: string, options?: {
+        encoding?: BufferEncoding;
+        flag?: string;
+        mode?: number;
+    }): Promise<void>;
     exists(path: string): Promise<boolean>;
     lstat(path: string): Promise<{
         isSymbolicLink(): boolean;

package/dist/json-schema-converter.js

@@ -152,7 +152,7 @@ function convertObjectSchema(schema, root, options) {
             "properties",
             key
         ]);
-        shape[key] = requiredKeys.has(key) ? convertedProperty : S.Optional(convertedProperty);
+        setOwnShapeProperty(shape, key, requiredKeys.has(key) ? convertedProperty : S.Optional(convertedProperty));
     }
     return applyMetadata(S.Object(shape, {
         ...(typeof normalizedSchema.schema.additionalProperties === "boolean"
@@ -162,6 +162,14 @@ function convertObjectSchema(schema, root, options) {
         nullable: options.nullable ?? normalizedSchema.nullable
     });
 }
+function setOwnShapeProperty(shape, key, value) {
+    Object.defineProperty(shape, key, {
+        configurable: true,
+        enumerable: true,
+        writable: true,
+        value
+    });
+}
 function createCommonOptions(schema, nullable, defaultValue) {
     return {
         ...(schema.description === undefined ? {} : { description: schema.description }),
@@ -408,6 +416,9 @@ function resolveLocalRef(root, ref) {
         if (!isPlainObject(current)) {
             return undefined;
         }
+        if (!Object.prototype.hasOwnProperty.call(current, segment)) {
+            return undefined;
+        }
         current = current[segment];
     }
     return isPlainObject(current) ? current : undefined;

package/dist/mcp-proxy.js

@@ -1,9 +1,10 @@
 import { existsSync } from "node:fs";
-import { lstat, mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { lstat, mkdir, readFile, rename, unlink, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { createHash, randomUUID } from "node:crypto";
-import { createLogger } from "@poe-code/design-system";
+import { createLogger } from "toolcraft-design";
 import { HttpTransport, McpClient, StdioTransport } from "tiny-mcp-client";
+import { hasOwnErrorCode } from "./error-codes.js";
 import { convertJsonSchema } from "./json-schema-converter.js";
 const GROUP_CONFIG_SYMBOL_DESCRIPTION = "toolcraft.group.config";
 const MCP_PROXY_SCHEMA_URL = "https://poe-platform.github.io/poe-code/schemas/toolcraft/mcp-proxy.schema.json";
@@ -175,8 +176,7 @@ async function readCache(cachePath) {
         };
     }
     catch (error) {
-        const code = error.code;
-        if (code === "ENOENT" || error instanceof SyntaxError) {
+        if (hasOwnErrorCode(error, "ENOENT") || error instanceof SyntaxError) {
             return undefined;
         }
         return undefined;
@@ -185,14 +185,31 @@ async function readCache(cachePath) {
 async function writeCache(cachePath, cache) {
     const directory = path.dirname(cachePath);
     const tempPath = `${cachePath}.tmp-${randomUUID()}`;
+    let tempCreated = false;
     await assertCachePathHasNoSymlinks(cachePath);
     await assertCachePathHasNoSymlinks(tempPath);
     await mkdir(directory, { recursive: true });
     await assertCachePathHasNoSymlinks(directory);
-    await writeFile(tempPath, `${JSON.stringify(cache, null, 2)}\n`);
-    await assertCachePathHasNoSymlinks(tempPath);
-    await assertCachePathHasNoSymlinks(cachePath);
-    await rename(tempPath, cachePath);
+    try {
+        await writeFile(tempPath, `${JSON.stringify(cache, null, 2)}\n`, {
+            encoding: "utf8",
+            flag: "wx"
+        });
+        tempCreated = true;
+        await assertCachePathHasNoSymlinks(tempPath);
+        await assertCachePathHasNoSymlinks(cachePath);
+        await rename(tempPath, cachePath);
+        tempCreated = false;
+    }
+    catch (error) {
+        if (tempCreated || !isAlreadyExistsError(error)) {
+            await unlink(tempPath).catch(() => undefined);
+        }
+        throw error;
+    }
+}
+function isAlreadyExistsError(error) {
+    return hasOwnErrorCode(error, "EEXIST");
 }
 async function fetchCache(name, config) {
     const logger = createLogger((message) => {
@@ -402,7 +419,7 @@ async function assertCachePathHasNoSymlinks(filePath) {
             }
         }
         catch (error) {
-            if (error.code !== "ENOENT") {
+            if (!hasOwnErrorCode(error, "ENOENT")) {
                 throw error;
             }
         }

package/dist/mcp.js

@@ -93,8 +93,8 @@ function isPlainObject(value) {
 function createFs() {
     return {
         readFile: async (path, encoding = "utf8") => readFile(path, { encoding }),
-        writeFile: async (path, contents) => {
-            await writeFile(path, contents);
+        writeFile: async (path, contents, options) => {
+            await writeFile(path, contents, options);
         },
         exists: async (path) => {
             try {
@@ -356,6 +356,48 @@ function validateSchemaValue(schema, value, casing, label, errors) {
             return value.map((item, index) => validateSchemaValue(unwrappedSchema.item, item, casing, `${label}[${index}]`, errors));
         case "object":
             return validateObjectSchema(unwrappedSchema, value, casing, label, errors);
+        case "json":
+            return value;
+        case "record": {
+            if (!isPlainObject(value)) {
+                errors.push({
+                    path: label,
+                    message: `Invalid value for "${label}". Expected an object, got ${describeReceived(value)}.`
+                });
+                return value;
+            }
+            return Object.fromEntries(Object.entries(value).map(([key, item]) => [
+                key,
+                validateSchemaValue(unwrappedSchema.value, item, casing, `${label}.${key}`, errors)
+            ]));
+        }
+        case "oneOf": {
+            if (!isPlainObject(value)) {
+                return value;
+            }
+            const discriminatorKey = formatSegment(unwrappedSchema.discriminator, casing);
+            const discriminator = value[discriminatorKey];
+            const branch = typeof discriminator === "string" ? unwrappedSchema.branches[discriminator] : undefined;
+            if (branch === undefined) {
+                return value;
+            }
+            const { [discriminatorKey]: ignoredDiscriminator, ...branchValue } = value;
+            void ignoredDiscriminator;
+            return {
+                [unwrappedSchema.discriminator]: discriminator,
+                ...validateObjectSchema(branch, branchValue, casing, label, errors)
+            };
+        }
+        case "union": {
+            if (!isPlainObject(value)) {
+                return value;
+            }
+            const branch = unwrappedSchema.branches.find((candidate) => Object.keys(candidate.shape).every((key) => candidate.shape[key]?.kind === "optional" ||
+                Object.prototype.hasOwnProperty.call(value, formatSegment(key, casing))));
+            return branch === undefined
+                ? value
+                : validateObjectSchema(branch, value, casing, label, errors);
+        }
     }
 }
 function validateObjectSchema(schema, value, casing, label, errors) {
@@ -373,6 +415,15 @@ function validateObjectSchema(schema, value, casing, label, errors) {
     }
     for (const key of Object.keys(value)) {
         if (!expectedKeys.has(key)) {
+            if (schema.additionalProperties === true) {
+                Object.defineProperty(result, key, {
+                    value: value[key],
+                    enumerable: true,
+                    configurable: true,
+                    writable: true
+                });
+                continue;
+            }
             const fieldLabel = label.length === 0 ? key : `${label}.${key}`;
             errors.push({
                 path: fieldLabel,
@@ -557,7 +608,7 @@ function createDeferredMCPServer(root, options) {
 }
 export function createMCPServer(roots, options) {
     const normalizedRoot = normalizeRoots(roots);
-    const root = options.approvals === false ? normalizedRoot : mergeApprovalsGroup(normalizedRoot);
+    const root = options.approvals === true ? mergeApprovalsGroup(normalizedRoot) : normalizedRoot;
     if (!hasMcpProxyGroups(root)) {
         return createResolvedMCPServer(root, options);
     }
@@ -566,7 +617,7 @@ export function createMCPServer(roots, options) {
 export async function runMCP(roots, options) {
     enableSourceMaps();
     const normalizedRoot = normalizeRoots(roots);
-    const root = options.approvals === false ? normalizedRoot : mergeApprovalsGroup(normalizedRoot);
+    const root = options.approvals === true ? mergeApprovalsGroup(normalizedRoot) : normalizedRoot;
     await resolveMcpProxies(root, { projectRoot: options.projectRoot });
     const server = createResolvedMCPServer(root, options);
     await server.listen();

package/dist/renderer.js

@@ -1,5 +1,5 @@
 import YAML from "yaml";
-import { renderDetailCard } from "@poe-code/design-system";
+import { renderDetailCard } from "toolcraft-design";
 function isObject(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);
 }

package/dist/schema-scope.js

@@ -21,14 +21,35 @@ export function filterSchemaForScope(schema, scope) {
         case "number":
         case "boolean":
         case "enum":
+        case "json":
             return schema;
+        case "record": {
+            const value = filterSchemaForScope(schema.value, scope);
+            return value === undefined ? undefined : { ...schema, value };
+        }
+        case "oneOf":
+            return {
+                ...schema,
+                branches: Object.fromEntries(Object.entries(schema.branches).flatMap(([name, branch]) => {
+                    const filtered = filterSchemaForScope(branch, scope);
+                    return filtered?.kind === "object" ? [[name, filtered]] : [];
+                }))
+            };
+        case "union":
+            return {
+                ...schema,
+                branches: schema.branches.flatMap((branch) => {
+                    const filtered = filterSchemaForScope(branch, scope);
+                    return filtered?.kind === "object" ? [filtered] : [];
+                })
+            };
         case "object":
             return {
                 ...schema,
                 shape: Object.fromEntries(Object.entries(schema.shape).flatMap(([key, childSchema]) => {
                     const filtered = filterSchemaForScope(childSchema, scope);
                     return filtered === undefined ? [] : [[key, filtered]];
-                })),
+                }))
             };
     }
 }

package/dist/sdk.js

@@ -74,8 +74,8 @@ function isPlainObject(value) {
 function createFs() {
     return {
         readFile: async (path, encoding = "utf8") => readFile(path, { encoding }),
-        writeFile: async (path, contents) => {
-            await writeFile(path, contents);
+        writeFile: async (path, contents, options) => {
+            await writeFile(path, contents, options);
         },
         exists: async (path) => {
             try {
@@ -179,6 +179,45 @@ function validateSchemaValue(schema, value, label, errors) {
             return value.map((item, index) => validateSchemaValue(unwrappedSchema.item, item, `${label}[${index}]`, errors));
         case "object":
             return validateObjectSchema(unwrappedSchema, value, label, errors);
+        case "json":
+            return value;
+        case "record": {
+            if (!isPlainObject(value)) {
+                errors.push({
+                    path: label,
+                    message: `Invalid value for "${label}". Expected an object, got ${describeReceived(value)}.`
+                });
+                return value;
+            }
+            return Object.fromEntries(Object.entries(value).map(([key, item]) => [
+                key,
+                validateSchemaValue(unwrappedSchema.value, item, `${label}.${key}`, errors)
+            ]));
+        }
+        case "oneOf": {
+            if (!isPlainObject(value)) {
+                return value;
+            }
+            const discriminator = value[unwrappedSchema.discriminator];
+            const branch = typeof discriminator === "string" ? unwrappedSchema.branches[discriminator] : undefined;
+            if (branch === undefined) {
+                return value;
+            }
+            const { [unwrappedSchema.discriminator]: ignoredDiscriminator, ...branchValue } = value;
+            void ignoredDiscriminator;
+            return {
+                [unwrappedSchema.discriminator]: discriminator,
+                ...validateObjectSchema(branch, branchValue, label, errors)
+            };
+        }
+        case "union": {
+            if (!isPlainObject(value)) {
+                return value;
+            }
+            const branch = unwrappedSchema.branches.find((candidate) => Object.keys(candidate.shape).every((key) => candidate.shape[key]?.kind === "optional" ||
+                Object.prototype.hasOwnProperty.call(value, formatSegment(key))));
+            return branch === undefined ? value : validateObjectSchema(branch, value, label, errors);
+        }
     }
 }
 function validateObjectSchema(schema, value, label, errors) {
@@ -196,6 +235,15 @@ function validateObjectSchema(schema, value, label, errors) {
     }
     for (const key of Object.keys(value)) {
         if (!expectedKeys.has(key)) {
+            if (schema.additionalProperties === true) {
+                Object.defineProperty(result, key, {
+                    value: value[key],
+                    enumerable: true,
+                    configurable: true,
+                    writable: true
+                });
+                continue;
+            }
             const fieldLabel = label.length === 0 ? key : `${label}.${key}`;
             errors.push({
                 path: fieldLabel,
@@ -266,7 +314,7 @@ function defineMember(target, key, value) {
 }
 export function createSDK(root, options = {}) {
     enableSourceMaps();
-    const mergedRoot = options.approvals === false ? root : mergeApprovalsGroup(root);
+    const mergedRoot = options.approvals === true ? mergeApprovalsGroup(root) : root;
     if (!hasMcpProxyGroups(mergedRoot)) {
         return createResolvedSDK(mergedRoot, options);
     }

package/dist/source-snippet.js

@@ -1,4 +1,4 @@
-import { text } from "@poe-code/design-system";
+import { text } from "toolcraft-design";
 export function renderSourceSnippet(opts) {
     const lines = opts.source.replaceAll("\r\n", "\n").replaceAll("\r", "\n").split("\n");
     const line = clampInteger(opts.line, 1, Math.max(lines.length, 1));

package/node_modules/@poe-code/agent-defs/dist/agents/claude-code.js

@@ -6,6 +6,11 @@ export const claudeCodeAgent = {
     aliases: ["claude"],
     binaryName: "claude",
     apiShapes: ["anthropic-messages"],
+    otelCapture: {
+        env: {
+            CLAUDE_CODE_ENABLE_TELEMETRY: "1"
+        }
+    },
     configPath: "~/.claude/settings.json",
     branding: {
         colors: {

package/node_modules/@poe-code/agent-defs/dist/agents/codex.js

@@ -5,6 +5,16 @@ export const codexAgent = {
     summary: "Configure Codex to use Poe as the model provider.",
     binaryName: "codex",
     apiShapes: ["openai-responses"],
+    otelCapture: {
+        args: (endpoint, content) => [
+            "-c",
+            `otel.trace_exporter={"otlp-http"={endpoint=${JSON.stringify(`${endpoint}/v1/traces`)},protocol="json"}}`,
+            "-c",
+            `otel.exporter={"otlp-http"={endpoint=${JSON.stringify(`${endpoint}/v1/logs`)},protocol="json"}}`,
+            "-c",
+            `otel.log_user_prompt=${content}`
+        ]
+    },
     configPath: "~/.codex/config.toml",
     branding: {
         colors: {

package/node_modules/@poe-code/agent-defs/dist/agents/cursor.d.ts

@@ -0,0 +1,2 @@
+import type { AgentDefinition } from "../types.js";
+export declare const cursorAgent: AgentDefinition;

package/node_modules/@poe-code/agent-defs/dist/agents/cursor.js

@@ -0,0 +1,15 @@
+export const cursorAgent = {
+    id: "cursor",
+    name: "cursor",
+    aliases: ["cursor-agent"],
+    label: "Cursor",
+    summary: "Cursor's CLI coding agent.",
+    binaryName: "cursor-agent",
+    configPath: "~/.cursor/cli-config.json",
+    branding: {
+        colors: {
+            dark: "#FFFFFF",
+            light: "#000000"
+        }
+    }
+};