@seawork/server 1.0.4 → 1.0.10-rc.4

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);
 }
@@ -864,6 +862,8 @@ function normalizeCodexThreadItemType(rawType) {
             return "mcpToolCall";
         case "WebSearch":
             return "webSearch";
+        case "ImageGeneration":
+            return "imageGeneration";
         default:
             return rawType;
     }
@@ -1123,6 +1123,46 @@ function mapCodexTerminalInteractionToToolCall(params) {
         ...(processId ? { metadata: { processId } } : {}),
     };
 }
+function normalizeCodexGeneratedImageSource(item) {
+    const savedPath = nonEmptyString(item.savedPath) ??
+        nonEmptyString(item.saved_path) ??
+        nonEmptyString(item.path) ??
+        null;
+    if (savedPath) {
+        return savedPath;
+    }
+    const result = nonEmptyString(item.result);
+    if (!result) {
+        return null;
+    }
+    return result.startsWith("data:") ? result : `data:image/png;base64,${result}`;
+}
+function markdownImageSource(source) {
+    if (/^(https?:|data:|blob:)/i.test(source)) {
+        return source;
+    }
+    return `<${source.replace(/>/g, "%3E")}>`;
+}
+function mapCodexImageGenerationToTimeline(item) {
+    const source = normalizeCodexGeneratedImageSource(item);
+    if (!source) {
+        return null;
+    }
+    return {
+        type: "assistant_message",
+        text: `![Generated image](${markdownImageSource(source)})`,
+    };
+}
+function rawResponseItemToThreadItem(item) {
+    if (item.type !== "image_generation_call") {
+        return null;
+    }
+    return {
+        ...item,
+        type: "imageGeneration",
+        revisedPrompt: item.revised_prompt ?? item.revisedPrompt ?? null,
+    };
+}
 function threadItemToTimeline(item, options) {
     if (!item || typeof item !== "object")
         return null;
@@ -1165,6 +1205,8 @@ function threadItemToTimeline(item, options) {
         case "mcpToolCall":
         case "webSearch":
             return mapCodexToolCallFromThreadItem(normalizedItem, { cwd });
+        case "imageGeneration":
+            return mapCodexImageGenerationToTimeline(normalizedItem);
         default:
             return null;
     }
@@ -1270,6 +1312,16 @@ const ItemLifecycleNotificationSchema = z
         .passthrough(),
 })
     .passthrough();
+const RawResponseItemCompletedNotificationSchema = z
+    .object({
+    item: z
+        .object({
+        id: z.string().optional(),
+        type: z.string().optional(),
+    })
+        .passthrough(),
+})
+    .passthrough();
 const CodexEventTurnAbortedNotificationSchema = z
     .object({
     msg: z
@@ -1521,6 +1573,20 @@ const CodexNotificationSchema = z.union([
         method,
         params,
     })),
+    z
+        .object({
+        method: z.literal("rawResponseItem/completed"),
+        params: RawResponseItemCompletedNotificationSchema,
+    })
+        .transform(({ params }) => ({
+        kind: "raw_response_item_completed",
+        item: params.item,
+    })),
+    z.object({ method: z.literal("rawResponseItem/completed"), params: z.unknown() }).transform(({ method, params }) => ({
+        kind: "invalid_payload",
+        method,
+        params,
+    })),
     z
         .object({ method: z.literal("item/started"), params: ItemLifecycleNotificationSchema })
         .transform(({ params }) => ({
@@ -1838,6 +1904,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;
     }
@@ -2370,13 +2441,17 @@ class CodexAppServerAgentSession {
         }
         const turnId = this.createTurnId();
         this.activeForegroundTurnId = turnId;
+        const turnStartT0 = Date.now();
+        this.logger.info({ turnId }, "[timing] codex turn/start request sending");
         try {
             await this.client.request("turn/start", params, TURN_START_TIMEOUT_MS);
         }
         catch (error) {
+            this.logger.info({ turnId, elapsedMs: Date.now() - turnStartT0 }, "[timing] codex turn/start FAILED");
             this.activeForegroundTurnId = null;
             throw error;
         }
+        this.logger.info({ turnId, elapsedMs: Date.now() - turnStartT0 }, "[timing] codex turn/start acknowledged");
         return { turnId };
     }
     subscribe(callback) {
@@ -2944,6 +3019,27 @@ class CodexAppServerAgentSession {
             }
             return;
         }
+        if (parsed.kind === "raw_response_item_completed") {
+            const threadItem = rawResponseItemToThreadItem(parsed.item);
+            if (!threadItem) {
+                return;
+            }
+            const itemId = threadItem.id;
+            if (itemId && this.emittedItemCompletedIds.has(itemId)) {
+                return;
+            }
+            const timelineItem = threadItemToTimeline(threadItem, {
+                includeUserMessage: false,
+                cwd: this.config.cwd ?? null,
+            });
+            if (timelineItem) {
+                this.emitEvent({ type: "timeline", provider: CODEX_PROVIDER, item: timelineItem });
+                if (itemId) {
+                    this.emittedItemCompletedIds.add(itemId);
+                }
+            }
+            return;
+        }
         if (parsed.kind === "item_completed") {
             // Codex emits mirrored lifecycle notifications via both `codex/event/item_*`
             // and canonical `item/*`. We render only the canonical channel to avoid
@@ -3251,10 +3347,34 @@ 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 ?? "";
+        }
+        const fullArgs = [...launchPrefix.args, "app-server", ...extraArgs];
+        this.logger.debug({
+            command: launchPrefix.command,
+            args: fullArgs,
+            hasOpenaiKey: !!codexEnv.OPENAI_API_KEY,
+            openaiKeyPrefix: codexEnv.OPENAI_API_KEY?.slice(0, 10) ?? null,
+            openaiBaseUrl: codexEnv.OPENAI_BASE_URL ?? null,
+            hasSeaworkKey: !!codexEnv.SEAWORK_API_KEY,
+            launchEnvKeys: Object.keys(launchEnv ?? {}),
+        }, "codex_spawn");
+        return spawnProcess(launchPrefix.command, fullArgs, {
             detached: process.platform !== "win32",
             stdio: ["pipe", "pipe", "pipe"],
-            env: buildCodexAppServerEnv(this.runtimeSettings, launchEnv),
+            env: codexEnv,
         });
     }
     async createSession(config, launchContext) {
@@ -3270,6 +3390,7 @@ export class CodexAppServerAgentClient {
             ...overrides,
             provider: CODEX_PROVIDER,
             cwd: overrides?.cwd ?? storedConfig.cwd ?? process.cwd(),
+            modeId: overrides?.modeId ?? storedConfig.modeId ?? "auto",
         };
         const session = new CodexAppServerAgentSession(merged, handle, this.logger, () => this.spawnAppServer(launchContext?.env));
         await session.connect();
@@ -3337,79 +3458,14 @@ 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;
         if (command?.mode === "replace") {
             return existsSync(command.argv[0]);
         }
-        return true;
+        return (await findExecutable("codex")) !== null;
     }
     async getDiagnostic() {
         try {