@seawork/server 1.0.2 → 1.0.7

package/dist/server/server/agent/providers/codex-app-server-agent.js

@@ -10,6 +10,7 @@ import { loadCodexPersistedTimeline } from "./codex-rollout-timeline.js";
 import { mapCodexRolloutToolCall, mapCodexToolCallFromThreadItem, } from "./codex/tool-call-mapper.js";
 import { applyProviderEnv, resolveProviderCommandPrefix, } from "../provider-launch-config.js";
 import { findExecutable } from "../../../utils/executable.js";
+import { getSeaworkModels } from "./seawork-models.js";
 import { spawnProcess } from "../../../utils/spawn.js";
 import { extractCodexTerminalSessionId, nonEmptyString } from "./tool-call-mapper-utils.js";
 import { buildCodexFeatures, codexModelSupportsFastMode } from "./codex-feature-definitions.js";
@@ -81,9 +82,6 @@ function normalizeCodexModelId(modelId) {
     }
     return normalized;
 }
-function normalizeCodexModelLabel(displayName) {
-    return displayName.replace(/\bgpt\b/gi, "GPT");
-}
 function isSchemaRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -1838,6 +1836,11 @@ export async function codexAppServerTurnInputFromPrompt(prompt, logger) {
 }
 function buildCodexAppServerEnv(runtimeSettings, launchEnv) {
     const env = applyProviderEnv(process.env, runtimeSettings);
+    // Clear proxy env vars to prevent interference with gateway requests
+    env.http_proxy = "";
+    env.https_proxy = "";
+    env.HTTP_PROXY = "";
+    env.HTTPS_PROXY = "";
     if (!launchEnv) {
         return env;
     }
@@ -3251,10 +3254,25 @@ export class CodexAppServerAgentClient {
         this.logger.trace({
             launchPrefix,
         }, "Spawning Codex app server");
-        return spawnProcess(launchPrefix.command, [...launchPrefix.args, "app-server"], {
+        const codexEnv = buildCodexAppServerEnv(this.runtimeSettings, launchEnv);
+        this.logger.info({
+            hasOpenaiKey: !!codexEnv.OPENAI_API_KEY,
+            openaiKeyPrefix: codexEnv.OPENAI_API_KEY?.slice(0, 10) ?? null,
+            openaiBaseUrl: codexEnv.OPENAI_BASE_URL ?? null,
+        }, "Codex app-server env check");
+        // If a Seawork-managed base URL is available, inject a "seawork" provider
+        // via -c flags to override any user config.
+        const extraArgs = [];
+        const seaworkBaseUrl = codexEnv.OPENAI_BASE_URL;
+        if (seaworkBaseUrl) {
+            extraArgs.push("-c", `model_provider="seawork"`, "-c", `model_providers.seawork.name="Seawork"`, "-c", `model_providers.seawork.base_url="${seaworkBaseUrl}/v1"`, "-c", `model_providers.seawork.env_key="SEAWORK_API_KEY"`, "--disable", "js_repl");
+            codexEnv.SEAWORK_API_KEY = codexEnv.OPENAI_API_KEY ?? "";
+        }
+        this.logger.info({ extraArgs }, "Codex app-server extra args");
+        return spawnProcess(launchPrefix.command, [...launchPrefix.args, "app-server", ...extraArgs], {
             detached: process.platform !== "win32",
             stdio: ["pipe", "pipe", "pipe"],
-            env: buildCodexAppServerEnv(this.runtimeSettings, launchEnv),
+            env: codexEnv,
         });
     }
     async createSession(config, launchContext) {
@@ -3337,72 +3355,7 @@ export class CodexAppServerAgentClient {
         }
     }
     async listModels(_options) {
-        const child = await this.spawnAppServer();
-        const client = new CodexAppServerClient(child, this.logger);
-        try {
-            await client.request("initialize", buildCodexAppServerInitializeParams());
-            client.notify("initialized", {});
-            const response = (await client.request("model/list", {}));
-            const models = Array.isArray(response?.data) ? response.data : [];
-            const configuredDefaults = await readCodexConfiguredDefaults(client, this.logger);
-            const configuredDefaultModelId = configuredDefaults.model;
-            const configuredDefaultThinkingOptionId = configuredDefaults.thinkingOptionId;
-            const hasConfiguredDefaultModel = typeof configuredDefaultModelId === "string"
-                ? models.some((model) => model?.id === configuredDefaultModelId)
-                : false;
-            return models.map((model) => {
-                const defaultReasoningEffort = normalizeCodexThinkingOptionId(typeof model.defaultReasoningEffort === "string" ? model.defaultReasoningEffort : null);
-                const resolvedDefaultReasoningEffort = configuredDefaultThinkingOptionId ?? defaultReasoningEffort;
-                const thinkingById = new Map();
-                if (Array.isArray(model.supportedReasoningEfforts)) {
-                    for (const entry of model.supportedReasoningEfforts) {
-                        const id = normalizeCodexThinkingOptionId(typeof entry?.reasoningEffort === "string" ? entry.reasoningEffort : null);
-                        if (!id)
-                            continue;
-                        const description = typeof entry?.description === "string" && entry.description.trim().length > 0
-                            ? entry.description
-                            : undefined;
-                        thinkingById.set(id, { id, label: id, description });
-                    }
-                }
-                if (resolvedDefaultReasoningEffort && !thinkingById.has(resolvedDefaultReasoningEffort)) {
-                    thinkingById.set(resolvedDefaultReasoningEffort, {
-                        id: resolvedDefaultReasoningEffort,
-                        label: resolvedDefaultReasoningEffort,
-                        description: configuredDefaultThinkingOptionId === resolvedDefaultReasoningEffort
-                            ? "Configured default reasoning effort"
-                            : "Model default reasoning effort",
-                    });
-                }
-                const thinkingOptions = Array.from(thinkingById.values()).map((option) => ({
-                    ...option,
-                    isDefault: option.id === resolvedDefaultReasoningEffort,
-                }));
-                const defaultThinkingOptionId = resolvedDefaultReasoningEffort ??
-                    thinkingOptions.find((option) => option.isDefault)?.id ??
-                    thinkingOptions[0]?.id;
-                const isDefaultModel = hasConfiguredDefaultModel
-                    ? model.id === configuredDefaultModelId
-                    : model.isDefault;
-                return {
-                    provider: CODEX_PROVIDER,
-                    id: model.id,
-                    label: normalizeCodexModelLabel(model.displayName),
-                    description: model.description,
-                    isDefault: isDefaultModel,
-                    thinkingOptions: thinkingOptions.length > 0 ? thinkingOptions : undefined,
-                    defaultThinkingOptionId,
-                    metadata: {
-                        model: model.model,
-                        defaultReasoningEffort: model.defaultReasoningEffort,
-                        supportedReasoningEfforts: model.supportedReasoningEfforts,
-                    },
-                };
-            });
-        }
-        finally {
-            await client.dispose();
-        }
+        return getSeaworkModels("codex");
     }
     async isAvailable() {
         const command = this.runtimeSettings?.command;