doer-agent 0.8.5 → 0.8.7

package/dist/agent-codex-cli.js

@@ -1,6 +1,8 @@
 import { spawn, spawnSync } from "node:child_process";
 import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
 import path from "node:path";
+const require = createRequire(import.meta.url);
 const ANSI_RE = /\u001b\[[0-9;]*m/g;
 function shellSingleQuote(value) {
     return `'${value.replace(/'/g, `'"'"'`)}'`;
@@ -32,6 +34,20 @@ function hasDirectCodexBinary() {
     });
     return result.status === 0;
 }
+function resolveBundledCodexCliBinPath() {
+    try {
+        const packageJsonPath = require.resolve("@openai/codex/package.json");
+        const packageJson = require(packageJsonPath);
+        const codexBin = packageJson.bin?.codex;
+        if (!codexBin) {
+            return null;
+        }
+        return path.resolve(path.dirname(packageJsonPath), codexBin);
+    }
+    catch {
+        return null;
+    }
+}
 export function stripAnsi(value) {
     return value.replace(ANSI_RE, "");
 }
@@ -144,6 +160,10 @@ function buildWorkspaceMcpConfigArgs(args) {
 }
 export function buildLocalCodexCliCommand(args) {
     const quotedArgs = args.map(shellSingleQuote).join(" ");
+    const bundledCodex = resolveBundledCodexCliBinPath();
+    if (bundledCodex) {
+        return `exec ${shellSingleQuote(process.execPath)} ${shellSingleQuote(bundledCodex)} ${quotedArgs}`;
+    }
     const direct = `exec codex ${quotedArgs}`;
     const fallback = `exec npm exec --yes --package doer-agent -- codex ${quotedArgs}`;
     const script = [
@@ -159,19 +179,27 @@ export function spawnManagedCodexCommand(args) {
         ...args.env,
         DOER_AGENT_TOKEN: args.agentToken,
     };
-    const child = hasDirectCodexBinary()
-        ? spawn("codex", args.codexArgs, {
+    const bundledCodex = resolveBundledCodexCliBinPath();
+    const child = bundledCodex
+        ? spawn(process.execPath, [bundledCodex, ...args.codexArgs], {
             cwd: args.taskWorkspace,
             detached: process.platform !== "win32",
             env,
             stdio: ["ignore", "pipe", "pipe"],
         })
-        : spawn("npm", ["exec", "--yes", "--package", "doer-agent", "--", "codex", ...args.codexArgs], {
-            cwd: args.taskWorkspace,
-            detached: process.platform !== "win32",
-            env,
-            stdio: ["ignore", "pipe", "pipe"],
-        });
+        : hasDirectCodexBinary()
+            ? spawn("codex", args.codexArgs, {
+                cwd: args.taskWorkspace,
+                detached: process.platform !== "win32",
+                env,
+                stdio: ["ignore", "pipe", "pipe"],
+            })
+            : spawn("npm", ["exec", "--yes", "--package", "doer-agent", "--", "codex", ...args.codexArgs], {
+                cwd: args.taskWorkspace,
+                detached: process.platform !== "win32",
+                env,
+                stdio: ["ignore", "pipe", "pipe"],
+            });
     child.stdout?.setEncoding("utf8");
     child.stderr?.setEncoding("utf8");
     return child;

package/dist/agent-settings.js

@@ -15,7 +15,9 @@ export function createDefaultAgentSettingsConfig() {
             personality: "pragmatic",
         },
         codex: {
-            model: "gpt-5.5",
+            providerModels: { openai: "gpt-5.5" },
+            modelProvider: null,
+            customProvider: null,
             reasoningEffort: "medium",
             serviceTier: null,
             authMode: "api_key",
@@ -63,6 +65,50 @@ function normalizeServiceTier(value) {
     }
     return normalized;
 }
+function normalizeCodexCustomProvider(value, fallback = null) {
+    if (value === null) {
+        return null;
+    }
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return fallback;
+    }
+    const raw = value;
+    const id = typeof raw.id === "string" ? raw.id.trim() : "";
+    const baseUrl = typeof raw.baseUrl === "string" ? raw.baseUrl.trim() : "";
+    if (!id || !baseUrl) {
+        return fallback;
+    }
+    const name = typeof raw.name === "string" && raw.name.trim() ? raw.name.trim() : id;
+    const envKey = typeof raw.envKey === "string" && raw.envKey.trim() ? raw.envKey.trim() : `${id.toUpperCase()}_API_KEY`;
+    const apiKey = raw.apiKey === null
+        ? null
+        : typeof raw.apiKey === "string" && raw.apiKey.trim()
+            ? raw.apiKey.trim()
+            : fallback?.id === id
+                ? fallback.apiKey
+                : null;
+    return {
+        id,
+        name,
+        baseUrl,
+        envKey,
+        apiKey,
+    };
+}
+function normalizeCodexProviderModels(value, fallback) {
+    const models = { ...fallback };
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return models;
+    }
+    for (const [rawKey, rawModel] of Object.entries(value)) {
+        const key = rawKey.trim();
+        const model = typeof rawModel === "string" ? rawModel.trim() : "";
+        if (key && model) {
+            models[key] = model;
+        }
+    }
+    return models;
+}
 function normalizeCodexPersonality(value, fallback) {
     return value === "friendly" || value === "pragmatic" ? value : fallback;
 }
@@ -200,7 +246,13 @@ export function normalizeAgentSettingsConfig(value, fallback) {
             personality: normalizeCodexPersonality(general.personality, base.general.personality),
         },
         codex: {
-            model: typeof codex.model === "string" && codex.model.trim() ? codex.model.trim() : base.codex.model,
+            providerModels: normalizeCodexProviderModels(codex.providerModels, base.codex.providerModels),
+            modelProvider: codex.modelProvider === null
+                ? null
+                : typeof codex.modelProvider === "string" && codex.modelProvider.trim()
+                    ? codex.modelProvider.trim()
+                    : base.codex.modelProvider,
+            customProvider: normalizeCodexCustomProvider(codex.customProvider, base.codex.customProvider),
             reasoningEffort: normalizeReasoningEffort(codex.reasoningEffort, base.codex.reasoningEffort),
             serviceTier: codex.serviceTier === null ? null : normalizeServiceTier(codex.serviceTier) ?? base.codex.serviceTier,
             authMode: codex.authMode === "chatgpt" ? "chatgpt" : codex.authMode === "api_key" ? "api_key" : base.codex.authMode,
@@ -275,6 +327,7 @@ function toMaskedSecret(value) {
 export async function toAgentSettingsPublic(args) {
     const realtimeKey = toMaskedSecret(args.config.realtime.apiKey);
     const gitOauth = toMaskedSecret(args.config.git.oauthToken);
+    const codexProviderKey = toMaskedSecret(args.config.codex.customProvider?.apiKey ?? null);
     const customInstructions = await readAgentModelInstructions(args.workspaceRoot);
     return {
         general: {
@@ -282,7 +335,19 @@ export async function toAgentSettingsPublic(args) {
             customInstructions,
         },
         codex: {
-            model: args.config.codex.model,
+            providerModels: { ...args.config.codex.providerModels },
+            modelProvider: args.config.codex.modelProvider,
+            customProvider: args.config.codex.customProvider
+                ? {
+                    id: args.config.codex.customProvider.id,
+                    name: args.config.codex.customProvider.name,
+                    baseUrl: args.config.codex.customProvider.baseUrl,
+                    envKey: args.config.codex.customProvider.envKey,
+                    hasApiKey: codexProviderKey.has,
+                    apiKeyMasked: codexProviderKey.masked,
+                    apiKeyLength: codexProviderKey.length,
+                }
+                : null,
             reasoningEffort: args.config.codex.reasoningEffort,
             serviceTier: args.config.codex.serviceTier,
             authMode: args.config.codex.authMode,
@@ -353,7 +418,9 @@ export function normalizeAgentSettingsPatch(value) {
         delete patch[flatKey];
     };
     move("personality", "general", "personality");
-    move("codexModel", "codex", "model");
+    move("codexProviderModels", "codex", "providerModels");
+    move("codexModelProvider", "codex", "modelProvider");
+    move("codexCustomProvider", "codex", "customProvider");
     move("codexReasoningEffort", "codex", "reasoningEffort");
     move("codexServiceTier", "codex", "serviceTier");
     move("codexAuthMode", "codex", "authMode");
@@ -377,6 +444,9 @@ export function normalizeAgentSettingsPatch(value) {
 }
 export function buildAgentSettingsEnvPatch(config) {
     const envPatch = {};
+    if (config.codex.customProvider?.apiKey && config.codex.customProvider.envKey) {
+        envPatch[config.codex.customProvider.envKey] = config.codex.customProvider.apiKey;
+    }
     if (config.git.enabled) {
         if (config.git.name)
             envPatch.GIT_AUTHOR_NAME = config.git.name;

package/dist/agent-skill-rpc.js

@@ -70,11 +70,18 @@ function normalizeGeneratedSkill(value) {
 function buildSkillGeneratorCodexArgs(prompt, model) {
     return ["--dangerously-bypass-approvals-and-sandbox", "--model", model, "exec", "--", prompt];
 }
+function resolveCodexModel(settings) {
+    const providerKey = settings.codex.modelProvider || "openai";
+    if (providerKey === "zai") {
+        return settings.codex.providerModels.zai || "glm-5.2";
+    }
+    return settings.codex.providerModels[providerKey] || settings.codex.providerModels.openai || "gpt-5.5";
+}
 async function generateSkillViaCodex(args) {
     const localAgentSettings = await args.readAgentSettingsConfig({ workspaceRoot: args.workspaceRoot });
     const envPatch = args.buildAgentSettingsEnvPatch(localAgentSettings);
     const prompt = buildSkillGeneratorPrompt(args.userPrompt);
-    const result = await args.runLocalCodexCli(buildSkillGeneratorCodexArgs(prompt, localAgentSettings.codex.model || "gpt-5.5"), 120_000, envPatch);
+    const result = await args.runLocalCodexCli(buildSkillGeneratorCodexArgs(prompt, resolveCodexModel(localAgentSettings)), 120_000, envPatch);
     if (result.timedOut) {
         throw new Error("Codex timed out while generating the skill");
     }

package/dist/codex-app-server-manager.js

@@ -1,6 +1,7 @@
 import { buildAgentSettingsEnvPatch, readAgentModelInstructions, resolveAgentModelInstructionsFilePath, } from "./agent-settings.js";
 import { buildCustomMcpConfigArgs, buildDaemonMcpConfigArgs, buildMobileMcpConfigArgs, buildThreadsMcpConfigArgs } from "./agent-codex-cli.js";
 import { CodexAppServerClient } from "./codex-app-server-client.js";
+import { startCodexChatBridge } from "./codex-chat-bridge.js";
 function toTomlStringLiteral(value) {
     return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
 }
@@ -10,9 +11,37 @@ function buildConfigArg(key, tomlValue) {
 function buildFeatureArg(enabled, name) {
     return [enabled ? "--enable" : "--disable", name];
 }
+function resolveCodexModel(settings) {
+    const providerKey = settings.codex.modelProvider || "openai";
+    if (providerKey === "zai") {
+        return settings.codex.providerModels.zai || "glm-5.2";
+    }
+    return settings.codex.providerModels[providerKey] || settings.codex.providerModels.openai || "gpt-5.5";
+}
+function resolveCodexModelContextWindow(settings) {
+    return settings.codex.modelProvider === "zai" ? 258400 : null;
+}
+function buildModelProviderConfigArgs(settings) {
+    const provider = settings.codex.customProvider;
+    const providerId = settings.codex.modelProvider;
+    if (!provider || !providerId || provider.id !== providerId) {
+        return [];
+    }
+    return [
+        ...buildConfigArg("model_provider", toTomlStringLiteral(provider.id)),
+        ...buildConfigArg(`model_providers.${provider.id}.name`, toTomlStringLiteral(provider.name)),
+        ...buildConfigArg(`model_providers.${provider.id}.base_url`, toTomlStringLiteral(provider.baseUrl)),
+        ...buildConfigArg(`model_providers.${provider.id}.env_key`, toTomlStringLiteral(provider.envKey)),
+        ...buildConfigArg(`model_providers.${provider.id}.wire_api`, toTomlStringLiteral("responses")),
+    ];
+}
 async function buildCodexAppServerArgs(args) {
+    const codexModel = resolveCodexModel(args.settings);
+    const modelContextWindow = resolveCodexModelContextWindow(args.settings);
     const configArgs = [
-        ...buildConfigArg("model", toTomlStringLiteral(args.settings.codex.model)),
+        ...buildConfigArg("model", toTomlStringLiteral(codexModel)),
+        ...(modelContextWindow ? buildConfigArg("model_context_window", String(modelContextWindow)) : []),
+        ...buildModelProviderConfigArgs(args.settings),
         ...buildConfigArg("model_reasoning_effort", toTomlStringLiteral(args.settings.codex.reasoningEffort)),
         ...(args.settings.codex.serviceTier
             ? buildConfigArg("service_tier", toTomlStringLiteral(args.settings.codex.serviceTier))
@@ -56,6 +85,34 @@ async function buildCodexAppServerArgs(args) {
         "stdio://",
     ];
 }
+async function resolveAppServerSettings(args) {
+    const provider = args.settings.codex.customProvider;
+    if (args.settings.codex.modelProvider !== "zai" || provider?.id !== "zai") {
+        return { settings: args.settings, proxy: null };
+    }
+    const proxy = await startCodexChatBridge({
+        providerApiKey: provider.apiKey ?? "",
+        providerId: provider.id,
+        providerName: provider.name,
+        targetBaseUrl: provider.baseUrl,
+        onLog: args.onLog,
+    });
+    return {
+        proxy,
+        settings: {
+            ...args.settings,
+            codex: {
+                ...args.settings.codex,
+                customProvider: {
+                    ...provider,
+                    baseUrl: proxy.baseUrl,
+                    envKey: proxy.envKey,
+                    apiKey: proxy.apiKey,
+                },
+            },
+        },
+    };
+}
 async function buildCodexAppServerEnv(args) {
     return {
         ...process.env,
@@ -69,18 +126,21 @@ async function buildCodexAppServerEnv(args) {
 }
 export function createCodexAppServerManager(args) {
     let client = null;
+    let providerProxy = null;
     let createPromise = null;
     let generation = 0;
     const notificationListeners = new Set();
     const createClient = async () => {
         const settings = await args.readAgentSettingsConfig({ workspaceRoot: args.workspaceRoot });
+        const resolved = await resolveAppServerSettings({ settings, onLog: args.onLog });
+        providerProxy = resolved.proxy;
         const appServerArgs = await buildCodexAppServerArgs({
             agentId: args.agentId,
             agentToken: args.agentToken,
             workspaceRoot: args.workspaceRoot,
             agentProjectDir: args.agentProjectDir,
             serverBaseUrl: args.serverBaseUrl,
-            settings,
+            settings: resolved.settings,
             userId: args.userId,
         });
         const env = await buildCodexAppServerEnv({
@@ -89,10 +149,10 @@ export function createCodexAppServerManager(args) {
             workspaceRoot: args.workspaceRoot,
             serverBaseUrl: args.serverBaseUrl,
             resolveCodexHomePath: args.resolveCodexHomePath,
-            settings,
+            settings: resolved.settings,
             userId: args.userId,
         });
-        args.onLog?.(`starting codex app-server model=${settings.codex.model} reasoningEffort=${settings.codex.reasoningEffort} personality=${settings.general.personality} computerUse=${settings.codex.computerUseEnabled} browserUse=${settings.codex.browserUseEnabled} mcpServers=${settings.mcp.servers.filter((server) => server.enabled).length}`);
+        args.onLog?.(`starting codex app-server model=${resolveCodexModel(resolved.settings)} reasoningEffort=${resolved.settings.codex.reasoningEffort} personality=${resolved.settings.general.personality} computerUse=${resolved.settings.codex.computerUseEnabled} browserUse=${resolved.settings.codex.browserUseEnabled} mcpServers=${resolved.settings.mcp.servers.filter((server) => server.enabled).length}`);
         return new CodexAppServerClient({
             cwd: args.workspaceRoot,
             args: appServerArgs,
@@ -144,7 +204,9 @@ export function createCodexAppServerManager(args) {
         async restart(reason) {
             generation += 1;
             const activeClient = client;
+            const activeProxy = providerProxy;
             client = null;
+            providerProxy = null;
             createPromise = null;
             if (!activeClient) {
                 args.onLog?.(`codex app-server restart requested before start reason=${reason}`);
@@ -152,12 +214,20 @@ export function createCodexAppServerManager(args) {
             }
             args.onLog?.(`restarting codex app-server reason=${reason}`);
             await activeClient.stop();
+            await activeProxy?.stop().catch((error) => {
+                args.onLog?.(`failed to stop provider proxy: ${error instanceof Error ? error.message : String(error)}`);
+            });
         },
         async stop() {
             const activeClient = client;
+            const activeProxy = providerProxy;
             client = null;
+            providerProxy = null;
             createPromise = null;
             await activeClient?.stop();
+            await activeProxy?.stop().catch((error) => {
+                args.onLog?.(`failed to stop provider proxy: ${error instanceof Error ? error.message : String(error)}`);
+            });
         },
     };
 }