npm - @bitkyc08/opencodex - Versions diffs - 2.6.13 → 2.6.14 - Mend

@bitkyc08/opencodex 2.6.13 → 2.6.14

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (16) hide show

package/gui/dist/assets/{index-BTTqyZ-C.js → index-B64_jgH-.js} +1 -1
package/gui/dist/index.html +1 -1
package/package.json +1 -1
package/src/adapters/anthropic.ts +8 -3
package/src/adapters/client-fingerprint.ts +4 -0
package/src/adapters/google.ts +0 -3
package/src/adapters/kiro-wire.ts +2 -2
package/src/adapters/kiro.ts +1 -1
package/src/adapters/openai-chat.ts +104 -69
package/src/adapters/openai-responses.ts +36 -1
package/src/oauth/anthropic.ts +2 -2
package/src/oauth/google-antigravity.ts +4 -3
package/src/oauth/kimi.ts +2 -2
package/src/server/adapter-resolve.ts +43 -0
package/src/server/gui-static.ts +98 -0
package/src/server.ts +8 -125

package/gui/dist/index.html CHANGED Viewed

@@ -16,7 +16,7 @@
         } catch (e) {}
       })();
     </script>
-    <script type="module" crossorigin src="/assets/index-BTTqyZ-C.js"></script>
+    <script type="module" crossorigin src="/assets/index-B64_jgH-.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-DIBiVVC0.css">
   </head>
   <body>

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@bitkyc08/opencodex",
-  "version": "2.6.13",
+  "version": "2.6.14",
   "description": "Universal provider proxy for OpenAI Codex — use any LLM with Codex CLI/App/SDK",
   "type": "module",
   "main": "./bin/package-main.mjs",

package/src/adapters/anthropic.ts CHANGED Viewed

@@ -40,7 +40,7 @@ const MIN_THINKING_BUDGET = 1024;
 const OUTPUT_HEADROOM = 8192;
 /** Minimum visible-output room kept below `max_tokens` (so `max_tokens > budget_tokens` always holds). */
 const OUTPUT_FLOOR = 4096;
-const COMPAT_TOOL_PREFIX = "ocx_";
+const COMPAT_TOOL_PREFIX = "cx_";
 /** Map a Responses reasoning effort to an Anthropic extended-thinking budget (tokens, >= 1024). */
 function reasoningBudget(effort: string): number {
@@ -172,7 +172,7 @@ function messagesToAnthropicFormat(
               resultBlocks.push({
                 type: "tool_result",
                 tool_use_id: id,
-                content: "[opencodex: missing tool_result for this tool_use in Codex history]",
+                content: "[missing tool_result for this tool_use in history]",
                 is_error: true,
               });
             }
@@ -240,7 +240,10 @@ export function createAnthropicAdapter(provider: OcxProviderConfig): ProviderAda
       if (parsed.options.topP !== undefined) body.top_p = parsed.options.topP;
       if (parsed.options.stopSequences) body.stop_sequences = parsed.options.stopSequences;
-      if (parsed.options.reasoning) {
+      // `reasoning` is a Codex effort string; "none" is the disable sentinel (see parser.ts
+      // REASONING_EFFORTS). A bare truthy check would treat "none" as truthy and wrongly enable
+      // extended thinking (and strip temperature/top_p), so gate on a real, non-disable effort.
+      if (typeof parsed.options.reasoning === "string" && parsed.options.reasoning !== "none") {
         // Anthropic requires max_tokens > thinking.budget_tokens (max_tokens caps thinking +
         // visible output) and budget_tokens >= 1024. Codex sends the SAME value for both, which
         // 400s ("max_tokens must be greater than thinking.budget_tokens"). Size them so max_tokens
@@ -270,6 +273,8 @@ export function createAnthropicAdapter(provider: OcxProviderConfig): ProviderAda
       const headers: Record<string, string> = {
         "Content-Type": "application/json",
         "anthropic-version": "2023-06-01",
+        "Accept": parsed.stream ? "text/event-stream" : "application/json",
+        "User-Agent": "@anthropic-ai/sdk/0.74.0",
       };
       if (isOAuth) {
         if (provider.apiKey) headers["Authorization"] = `Bearer ${provider.apiKey}`;

package/src/adapters/client-fingerprint.ts CHANGED Viewed

@@ -20,6 +20,10 @@ export const CLAUDE_CODE_HEADERS: Record<string, string> = {
   "X-Stainless-Runtime": "node",
   "X-Stainless-Lang": "js",
   "X-Stainless-Timeout": "600",
+  "X-Stainless-Arch": process.arch,
+  "X-Stainless-OS": process.platform,
+  "X-Stainless-Package-Version": "0.74.0",
+  "X-Stainless-Runtime-Version": process.version.slice(1),
 };
 /**

package/src/adapters/google.ts CHANGED Viewed

@@ -19,7 +19,6 @@ import { isVertexTruncationReason, vertexTruncationErrorMessage } from "./google
 import { ANTIGRAVITY_REQUEST_UA, antigravitySessionId, isLikelyRealThoughtSignature, sanitizeAntigravityClaudeSignatures } from "./google-antigravity-wire";
 import { sanitizeGeminiToolParameters } from "./google-tool-schema";
 import { neutralizeIdentity } from "./identity";
-import { ANTIGRAVITY_GOOG_API_CLIENT_UA } from "./client-fingerprint";
 import { antigravityUsesReplayCache, applyAntigravityReplay, clearAntigravityReplay, observeAntigravityReplay } from "./google-antigravity-replay";
 // Google-family models (Gemini/Vertex/Antigravity) tend to emit long running commentary between
@@ -264,8 +263,6 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
           request,
         };
         headers["User-Agent"] = ANTIGRAVITY_REQUEST_UA;
-        // The Antigravity client library reports a secondary Google API client UA alongside the CLI UA.
-        headers["x-goog-api-client"] = ANTIGRAVITY_GOOG_API_CLIENT_UA;
         if (provider.apiKey) headers["Authorization"] = `Bearer ${provider.apiKey}`;
         return { url, method: "POST", headers, body: JSON.stringify(envelope) };
       }

package/src/adapters/kiro-wire.ts CHANGED Viewed

@@ -8,9 +8,9 @@ let cachedFp: string | undefined;
 export function fingerprint(): string {
   if (cachedFp) return cachedFp;
   try {
-    cachedFp = createHash("sha256").update(`${hostname()}-${userInfo().username}-kiro-ocx`).digest("hex");
+    cachedFp = createHash("sha256").update(`${hostname()}-${userInfo().username}-kiro`).digest("hex");
   } catch {
-    cachedFp = createHash("sha256").update("default-kiro-ocx").digest("hex");
+    cachedFp = createHash("sha256").update("default-kiro").digest("hex");
   }
   return cachedFp;
 }

package/src/adapters/kiro.ts CHANGED Viewed

@@ -33,7 +33,7 @@ import { neutralizeIdentity } from "./identity";
 const AMZ_TARGET = "AmazonCodeWhispererStreamingService.GenerateAssistantResponse";
 const SDK_VERSION = "1.0.27";
 const NODE_VERSION = "22.21.1";
-const KIRO_IDE_VERSION = "1.2.0";
+const KIRO_IDE_VERSION = "1.0.0";
 // Payload construction (conversationState)
 interface KiroToolUse {

package/src/adapters/openai-chat.ts CHANGED Viewed

@@ -223,92 +223,127 @@ export function createOpenAIChatAdapter(provider: OcxProviderConfig): ProviderAd
       let currentToolCallId = "";
       let currentToolCallName = "";
       let pendingUsage: OcxUsage | undefined;
+      // Track terminal signals so a socket EOF without any terminator can fail closed instead of
+      // being reported as a clean completion (silent truncation). A graceful close is either an
+      // explicit `[DONE]` sentinel OR a chunk carrying a non-null `finish_reason` (some
+      // OpenAI-compatible providers omit `[DONE]` but do send finish_reason).
+      let sawFinish = false;
-      try {
-        while (true) {
-          const { done, value } = await reader.read();
-          if (done) break;
-          buffer += decoder.decode(value, { stream: true });
-          const lines = buffer.split("\n");
-          buffer = lines.pop() ?? "";
+      // Single per-line handler shared by the streaming loop and the EOF residual-frame flush, so
+      // a final frame is parsed identically wherever it lands (no duplicated, drift-prone parsing).
+      // Yields adapter events and returns "terminate" for a terminal frame ([DONE] / error) that
+      // must end the stream, or "continue" otherwise. Mutates the closure's terminal-signal state.
+      const handleDataLine = function* (line: string): Generator<AdapterEvent, "continue" | "terminate"> {
+        if (!line.startsWith("data: ")) return "continue";
+        const payload = line.slice(6).trim();
+        if (payload === "[DONE]") {
+          if (currentToolCallId) {
+            yield { type: "tool_call_end" };
+            currentToolCallId = "";
+          }
+          yield { type: "done", usage: pendingUsage };
+          return "terminate";
+        }
-          for (const line of lines) {
-            if (!line.startsWith("data: ")) continue;
-            const payload = line.slice(6).trim();
-            if (payload === "[DONE]") {
-              if (currentToolCallId) {
-                yield { type: "tool_call_end" };
-                currentToolCallId = "";
-              }
-              yield { type: "done", usage: pendingUsage };
-              return;
-            }
+        let chunk: Record<string, unknown>;
+        try {
+          chunk = JSON.parse(payload) as Record<string, unknown>;
+        } catch {
+          debugDroppedFrame("openai-chat", payload);
+          return "continue";
+        }
-            let chunk: Record<string, unknown>;
-            try {
-              chunk = JSON.parse(payload) as Record<string, unknown>;
-            } catch {
-              debugDroppedFrame("openai-chat", payload);
-              continue;
-            }
+        // A 200/OK chat-completions stream may carry an inline provider error envelope
+        // instead of a clean [DONE]. Surface it as a terminal error so the bridge emits a
+        // classified response.failed (bridge case "error") — never a truncated completion.
+        if (chunk.error) {
+          const err = chunk.error as { message?: string } | undefined;
+          if (currentToolCallId) yield { type: "tool_call_end" };
+          yield { type: "error", message: err?.message ?? "upstream error" };
+          return "terminate";
+        }
-            // A 200/OK chat-completions stream may carry an inline provider error envelope
-            // instead of a clean [DONE]. Surface it as a terminal error so the bridge emits a
-            // classified response.failed (bridge case "error") — never a truncated completion.
-            if (chunk.error) {
-              const err = chunk.error as { message?: string } | undefined;
-              if (currentToolCallId) yield { type: "tool_call_end" };
-              yield { type: "error", message: err?.message ?? "upstream error" };
-              return;
-            }
+        if (chunk.usage) {
+          // Record usage but keep parsing: some providers send usage and the final content
+          // delta in the SAME chunk; a bail here would drop that content. The choices
+          // guard below no-ops a usage-only chunk.
+          pendingUsage = usageFromOpenAIChat(chunk.usage as Record<string, unknown>);
+        }
-            if (chunk.usage) {
-              // Record usage but keep parsing: some providers send usage and the final content
-              // delta in the SAME chunk; a `continue` here would drop that content. The choices
-              // guard below no-ops a usage-only chunk.
-              pendingUsage = usageFromOpenAIChat(chunk.usage as Record<string, unknown>);
-            }
+        const choices = chunk.choices as { delta?: Record<string, unknown>; finish_reason?: string }[] | undefined;
+        if (!choices || choices.length === 0) return "continue";
+        // Observe the terminator BEFORE the delta guard: a finish-only chunk (finish_reason set,
+        // no delta) is a graceful close and must mark sawFinish even though we skip it below.
+        if (typeof choices[0].finish_reason === "string" && choices[0].finish_reason) {
+          sawFinish = true;
+        }
+        const delta = choices[0].delta;
+        if (delta) {
+          if (typeof delta.content === "string" && delta.content.length > 0) {
+            yield { type: "text_delta", text: delta.content };
+          }
-            const choices = chunk.choices as { delta?: Record<string, unknown>; finish_reason?: string }[] | undefined;
-            if (!choices || choices.length === 0) continue;
-            const delta = choices[0].delta;
-            if (!delta) continue;
+          if (typeof delta.reasoning_content === "string" && delta.reasoning_content.length > 0) {
+            yield { type: "reasoning_raw_delta", text: delta.reasoning_content };
+          }
-            if (typeof delta.content === "string" && delta.content.length > 0) {
-              yield { type: "text_delta", text: delta.content };
+          const toolCalls = delta.tool_calls as { index: number; id?: string; function?: { name?: string; arguments?: string } }[] | undefined;
+          if (toolCalls) {
+            for (const tc of toolCalls) {
+              if (tc.id && tc.id !== currentToolCallId) {
+                if (currentToolCallId) yield { type: "tool_call_end" };
+                currentToolCallId = tc.id;
+                currentToolCallName = tc.function?.name ?? "";
+                yield { type: "tool_call_start", id: tc.id, name: currentToolCallName };
+              }
+              if (tc.function?.arguments) {
+                yield { type: "tool_call_delta", arguments: tc.function.arguments };
+              }
             }
+          }
+        }
-            if (typeof delta.reasoning_content === "string" && delta.reasoning_content.length > 0) {
-              yield { type: "reasoning_raw_delta", text: delta.reasoning_content };
-            }
+        if (choices[0].finish_reason === "tool_calls" && currentToolCallId) {
+          yield { type: "tool_call_end" };
+          currentToolCallId = "";
+        }
+        return "continue";
+      };
-            const toolCalls = delta.tool_calls as { index: number; id?: string; function?: { name?: string; arguments?: string } }[] | undefined;
-            if (toolCalls) {
-              for (const tc of toolCalls) {
-                if (tc.id && tc.id !== currentToolCallId) {
-                  if (currentToolCallId) yield { type: "tool_call_end" };
-                  currentToolCallId = tc.id;
-                  currentToolCallName = tc.function?.name ?? "";
-                  yield { type: "tool_call_start", id: tc.id, name: currentToolCallName };
-                }
-                if (tc.function?.arguments) {
-                  yield { type: "tool_call_delta", arguments: tc.function.arguments };
-                }
-              }
-            }
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          buffer += decoder.decode(value, { stream: true });
-            if (choices[0].finish_reason === "tool_calls" && currentToolCallId) {
-              yield { type: "tool_call_end" };
-              currentToolCallId = "";
-            }
+          const lines = buffer.split("\n");
+          buffer = lines.pop() ?? "";
+          for (const line of lines) {
+            if ((yield* handleDataLine(line)) === "terminate") return;
           }
         }
+        // Some providers send the terminal `data:` frame (carrying the final delta, finish_reason,
+        // and/or usage) WITHOUT a trailing newline before closing the socket, so it never crosses
+        // the split("\n") boundary and stays in `buffer`. Run it through the SAME handler so its
+        // content/tool-calls are emitted and its terminal signal observed — otherwise a genuinely
+        // complete stream loses its last frame and may be falsely failed below.
+        if (buffer.length > 0) {
+          if ((yield* handleDataLine(buffer)) === "terminate") return;
+        }
         if (currentToolCallId) {
           yield { type: "tool_call_end" };
         }
-        // EOF without a [DONE] sentinel: still surface any usage accumulated mid-stream.
+        // Reader EOF. A graceful close shows at least one terminal signal: `[DONE]` (returns above),
+        // a non-null finish_reason (sawFinish), or a trailing usage chunk (providers emit usage only
+        // at end-of-generation). If NONE of those were seen, the stream was cut mid-flight — fail
+        // closed so the bridge emits a classified response.failed rather than a silent truncation.
+        if (!sawFinish && pendingUsage === undefined) {
+          yield { type: "error", message: "upstream stream ended without a terminal signal ([DONE] or finish_reason) — possible truncation" };
+          return;
+        }
+        // Graceful close that omitted [DONE] but delivered finish_reason and/or final usage.
         yield { type: "done", usage: pendingUsage };
       } finally {
         reader.releaseLock();

package/src/adapters/openai-responses.ts CHANGED Viewed

@@ -42,6 +42,41 @@ function sanitizeReasoningInputContent(body: unknown): unknown {
   return changed ? { ...raw, input } : body;
 }
+/**
+ * Hosted (OpenAI-executed) tool types that specific native slugs reject at request time. Codex
+ * attaches these for app skills (e.g. `image_generation` for imagegen) regardless of the target
+ * model, and the passthrough path forwards the raw body untouched — so a slug that doesn't support
+ * the tool 400s (`Tool 'image_generation' is not supported with gpt-5.3-codex-spark.`). Each entry
+ * maps a model-slug matcher to the hosted tool types that must be stripped before forwarding.
+ * Extend this when another native slug rejects a hosted tool (e.g. `code_interpreter`).
+ */
+const UNSUPPORTED_HOSTED_TOOLS: ReadonlyArray<{ match: (model: string) => boolean; tools: ReadonlySet<string> }> = [
+  { match: model => model.includes("codex-spark"), tools: new Set(["image_generation"]) },
+];
+function isPlainObject(v: unknown): v is Record<string, unknown> {
+  return !!v && typeof v === "object" && !Array.isArray(v);
+}
+/**
+ * Remove hosted tool entries the target native slug rejects, so the OAuth-passthrough body never
+ * carries a tool the upstream model 400s on. No-op (returns the original reference) when nothing
+ * matches, keeping the common path allocation-free.
+ */
+function stripUnsupportedHostedTools(body: unknown): unknown {
+  if (!isPlainObject(body) || !Array.isArray(body.tools)) return body;
+  const model = typeof body.model === "string" ? body.model : "";
+  const unsupported = UNSUPPORTED_HOSTED_TOOLS.filter(e => e.match(model));
+  if (unsupported.length === 0) return body;
+  const tools = body.tools.filter(t => {
+    const type = isPlainObject(t) && typeof t.type === "string" ? t.type : undefined;
+    if (!type) return true;
+    return !unsupported.some(e => e.tools.has(type));
+  });
+  return tools.length === body.tools.length ? body : { ...body, tools };
+}
 export function createResponsesPassthroughAdapter(provider: OcxProviderConfig): ProviderAdapter & { passthrough: true } {
   return {
     name: "openai-responses",
@@ -82,7 +117,7 @@ export function createResponsesPassthroughAdapter(provider: OcxProviderConfig):
         url,
         method: "POST",
         headers,
-        body: JSON.stringify(sanitizeReasoningInputContent(parsed._rawBody)),
+        body: JSON.stringify(stripUnsupportedHostedTools(sanitizeReasoningInputContent(parsed._rawBody))),
       };
     },

package/src/oauth/anthropic.ts CHANGED Viewed

@@ -13,7 +13,7 @@ const SCOPES = "org:create_api_key user:profile user:inference";
 // ── OAuth-request requirements applied by the anthropic adapter when authMode==="oauth" ──
 export const ANTHROPIC_OAUTH_BETA = "claude-code-20250219,oauth-2025-04-20";
 export const CLAUDE_CODE_SYSTEM_INSTRUCTION = "You are a Claude agent, built on Anthropic's Claude Agent SDK.";
-const CLAUDE_TOOL_PREFIX = "proxy_";
+const CLAUDE_TOOL_PREFIX = "custom_";
 const ANTHROPIC_BUILTIN_TOOLS = new Set(["web_search", "code_execution", "text_editor", "computer"]);
 /** OAuth tokens reject arbitrary tool names; prefix custom tools (Anthropic builtins are exempt). */
@@ -22,7 +22,7 @@ export function applyClaudeToolPrefix(name: string): string {
   return CLAUDE_TOOL_PREFIX + name;
 }
-/** Strip the proxy_ prefix from a returned tool_use name so the caller (Codex) sees the original. */
+/** Strip the custom_ prefix from a returned tool_use name so the caller (Codex) sees the original. */
 export function stripClaudeToolPrefix(name: string): string {
   return name.startsWith(CLAUDE_TOOL_PREFIX) ? name.slice(CLAUDE_TOOL_PREFIX.length) : name;
 }

package/src/oauth/google-antigravity.ts CHANGED Viewed

@@ -12,6 +12,7 @@
 import { OAuthCallbackFlow, type OAuthCallbackFlowOptions } from "./callback-server";
 import { generatePKCE } from "./pkce";
 import type { OAuthController, OAuthCredentials } from "./types";
+import { antigravityUserAgent, ANTIGRAVITY_GOOG_API_CLIENT_UA } from "../adapters/client-fingerprint";
 const CLIENT_ID = process.env.GOOGLE_ANTIGRAVITY_CLIENT_ID
   || "1071006060591-tmhssin2h21lcre235vtolojh4g403ep.apps.googleusercontent.com";
@@ -94,7 +95,7 @@ function extractProjectId(data: Record<string, unknown> | undefined): string | u
 async function loadCodeAssistProject(accessToken: string, signal?: AbortSignal): Promise<string | undefined> {
   const response = await fetch(`${PROD_API}/${API_VERSION}:loadCodeAssist`, {
     method: "POST",
-    headers: { Authorization: `Bearer ${accessToken}`, Accept: "*/*", "Content-Type": "application/json" },
+    headers: { Authorization: `Bearer ${accessToken}`, Accept: "*/*", "Content-Type": "application/json", "User-Agent": antigravityUserAgent() },
     body: JSON.stringify({ metadata: { ideType: "ANTIGRAVITY" } }),
     signal: requestSignal(signal),
   });
@@ -107,8 +108,8 @@ async function onboardProject(accessToken: string, signal?: AbortSignal): Promis
     if (signal?.aborted) throw signal.reason ?? new Error("Antigravity onboarding aborted");
     const response = await fetch(`${DAILY_API}/${API_VERSION}:onboardUser`, {
       method: "POST",
-      headers: { Authorization: `Bearer ${accessToken}`, Accept: "*/*", "Content-Type": "application/json" },
-      body: JSON.stringify({ tier_id: "free-tier", metadata: { ide_type: "ANTIGRAVITY", ide_name: "antigravity" } }),
+      headers: { Authorization: `Bearer ${accessToken}`, Accept: "*/*", "Content-Type": "application/json", "User-Agent": antigravityUserAgent(), "x-goog-api-client": ANTIGRAVITY_GOOG_API_CLIENT_UA },
+      body: JSON.stringify({ tier_id: "free-tier", metadata: { ide_type: "ANTIGRAVITY", ide_name: "antigravity", ide_version: antigravityUserAgent() } }),
       signal: requestSignal(signal),
     });
     if (!response.ok) {

package/src/oauth/kimi.ts CHANGED Viewed

@@ -12,7 +12,7 @@ const DEVICE_ID_FILENAME = "kimi-device-id";
 const DEFAULT_POLL_INTERVAL_MS = 5000;
 const DEFAULT_DEVICE_FLOW_TTL_MS = 15 * 60 * 1000;
 const OAUTH_EXPIRY_SKEW_MS = 5 * 60 * 1000;
-const KIMI_CLI_VERSION = "1.0.0";
+const KIMI_CLI_VERSION = "0.14.0";
 interface DeviceAuthorizationResponse {
   user_code?: string;
@@ -70,7 +70,7 @@ function getDeviceId(): string {
 function getKimiCommonHeaders(): Record<string, string> {
   return {
     "User-Agent": `KimiCLI/${KIMI_CLI_VERSION}`,
-    "X-Msh-Platform": "kimi_cli",
+    "X-Msh-Platform": "kimi_code_cli",
     "X-Msh-Version": KIMI_CLI_VERSION,
     "X-Msh-Device-Name": os.hostname(),
     "X-Msh-Device-Model": getDeviceModel(),

package/src/server/adapter-resolve.ts ADDED Viewed

@@ -0,0 +1,43 @@
+import { createAnthropicAdapter } from "../adapters/anthropic";
+import { createAzureAdapter } from "../adapters/azure";
+import { createGoogleAdapter } from "../adapters/google";
+import { createKiroAdapter } from "../adapters/kiro";
+import { createOpenAIChatAdapter } from "../adapters/openai-chat";
+import { createResponsesPassthroughAdapter } from "../adapters/openai-responses";
+import type { OcxProviderConfig } from "../types";
+/** Providers whose listed model ids must be driven over the Anthropic wire even if the provider's
+ *  configured adapter is something else (the upstream only speaks Anthropic for these models). */
+const ANTHROPIC_WIRE_MODELS: Record<string, Set<string>> = {
+  "opencode-go": new Set(["minimax-m2.5", "minimax-m2.7", "minimax-m3", "qwen3.5-plus", "qwen3.6-plus", "qwen3.7-max", "qwen3.7-plus"]),
+};
+/** Return a provider config whose adapter is forced to "anthropic" when the model id is wire-pinned. */
+export function resolveWireProtocolOverride(providerName: string, modelId: string, providerConfig: OcxProviderConfig): OcxProviderConfig {
+  const overrideSet = ANTHROPIC_WIRE_MODELS[providerName];
+  if (overrideSet?.has(modelId) && providerConfig.adapter !== "anthropic") {
+    return { ...providerConfig, adapter: "anthropic" };
+  }
+  return providerConfig;
+}
+/** Build the provider adapter for a resolved provider config. */
+export function resolveAdapter(providerConfig: OcxProviderConfig) {
+  switch (providerConfig.adapter) {
+    case "openai-chat":
+      return createOpenAIChatAdapter(providerConfig);
+    case "anthropic":
+      return createAnthropicAdapter(providerConfig);
+    case "openai-responses":
+      return createResponsesPassthroughAdapter(providerConfig);
+    case "google":
+      return createGoogleAdapter(providerConfig);
+    case "kiro":
+      return createKiroAdapter(providerConfig);
+    case "azure":
+    case "azure-openai":
+      return createAzureAdapter(providerConfig);
+    default:
+      throw new Error(`Unknown adapter: ${providerConfig.adapter}`);
+  }
+}

package/src/server/gui-static.ts ADDED Viewed

@@ -0,0 +1,98 @@
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { extname, isAbsolute, join, relative, resolve } from "node:path";
+/** opencodex version, read from the packaged package.json (same source as the server bootstrap). */
+const VERSION = (() => {
+  try {
+    return JSON.parse(readFileSync(new URL("../../package.json", import.meta.url), "utf8")).version as string;
+  } catch {
+    return "0.0.0";
+  }
+})();
+const MIME_TYPES: Record<string, string> = {
+  ".html": "text/html", ".js": "application/javascript", ".css": "text/css",
+  ".json": "application/json", ".svg": "image/svg+xml", ".png": "image/png",
+  ".ico": "image/x-icon",
+};
+function findGuiDist(): string | null {
+  const candidates = [
+    join(import.meta.dir, "..", "..", "gui", "dist"),
+    join(import.meta.dir, "..", "..", "..", "gui", "dist"),
+  ];
+  for (const c of candidates) {
+    if (existsSync(join(c, "index.html"))) return c;
+  }
+  return null;
+}
+export function resolveGuiFilePath(guiDist: string, pathname: string): string | null {
+  let decodedPath: string;
+  try {
+    decodedPath = decodeURIComponent(pathname);
+  } catch {
+    return null;
+  }
+  if (decodedPath.includes("\0")) return null;
+  const relativePath = decodedPath === "/" || decodedPath === ""
+    ? "index.html"
+    : decodedPath.replace(/\\/g, "/").replace(/^\/+/, "");
+  const root = resolve(guiDist);
+  const filePath = resolve(root, relativePath);
+  const rel = relative(root, filePath);
+  if (rel === "" || rel.startsWith("..") || isAbsolute(rel)) return null;
+  return filePath;
+}
+function isFile(path: string): boolean {
+  try {
+    return statSync(path).isFile();
+  } catch {
+    return false;
+  }
+}
+export function serveGuiFile(pathname: string): Response | null {
+  const guiDist = findGuiDist();
+  if (!guiDist) return null;
+  const filePath = resolveGuiFilePath(guiDist, pathname);
+  if (!filePath) return null;
+  if (!isFile(filePath)) {
+    if (!extname(pathname)) {
+      const indexPath = join(guiDist, "index.html");
+      if (isFile(indexPath)) {
+        return new Response(Bun.file(indexPath), {
+          headers: { "Content-Type": "text/html" },
+        });
+      }
+    }
+    return null;
+  }
+  const ext = extname(filePath);
+  const contentType = MIME_TYPES[ext] || "application/octet-stream";
+  return new Response(Bun.file(filePath), {
+    headers: { "Content-Type": contentType },
+  });
+}
+export function rootFallbackPayload() {
+  return {
+    status: "ok",
+    service: "opencodex",
+    version: VERSION,
+    dashboard: {
+      available: false,
+      reason: "GUI build not found. Run `bun run build:gui` from the opencodex repo, or use `ocx gui` from a packaged install.",
+    },
+    endpoints: {
+      health: "/healthz",
+      models: "/v1/models",
+      responses: "/v1/responses",
+      management: "/api/*",
+    },
+  };
+}