npm - @bitkyc08/opencodex - Versions diffs - 2.7.34 → 2.7.35 - Mend

@bitkyc08/opencodex 2.7.34 → 2.7.35

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 (33) hide show

package/README.md +1 -0
package/gui/dist/assets/index-BunUANVE.js +52 -0
package/gui/dist/index.html +1 -1
package/package.json +5 -2
package/src/adapters/anthropic.ts +22 -37
package/src/adapters/cursor/cursor-errors.ts +11 -0
package/src/adapters/cursor/discovery.ts +25 -0
package/src/adapters/cursor/live-transport.ts +5 -0
package/src/adapters/cursor/protobuf-events.ts +14 -0
package/src/adapters/cursor/protobuf-request.ts +11 -1
package/src/adapters/cursor/request-builder.ts +20 -3
package/src/adapters/cursor.ts +69 -22
package/src/adapters/google-http.ts +23 -4
package/src/adapters/google-tool-schema.ts +143 -68
package/src/adapters/google-wire-compiler.ts +228 -0
package/src/adapters/google.ts +27 -18
package/src/adapters/kiro.ts +25 -1
package/src/chat/inbound.ts +295 -0
package/src/chat/outbound.ts +565 -0
package/src/claude/agents-inject.ts +4 -2
package/src/codex/catalog.ts +31 -2
package/src/codex/home.ts +1 -1
package/src/codex/quota.ts +43 -13
package/src/index.ts +1 -0
package/src/lib/sse-decoder.ts +84 -0
package/src/providers/antigravity-models.ts +9 -3
package/src/server/chat-completions.ts +258 -0
package/src/server/gui-static.ts +1 -0
package/src/server/index.ts +24 -0
package/src/server/management-api.ts +9 -0
package/src/server/responses.ts +28 -2
package/src/types.ts +6 -3
package/gui/dist/assets/index-BkmJJgg6.js +0 -52

package/gui/dist/index.html CHANGED Viewed

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

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@bitkyc08/opencodex",
-  "version": "2.7.34",
+  "version": "2.7.35",
   "description": "Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code",
   "type": "module",
   "main": "./bin/package-main.mjs",
@@ -36,7 +36,7 @@
     "dev:proxy": "bun run src/cli/index.ts start",
     "dev:gui": "cd gui && bun run dev",
     "start": "bun run src/cli/index.ts start",
-    "test": "bun test --isolate ./tests/",
+    "test": "bun scripts/test.ts",
     "typecheck": "bun x tsc --noEmit",
     "privacy:scan": "bun scripts/privacy-scan.ts",
     "generate:jawcode-metadata": "bun scripts/generate-jawcode-metadata.ts",
@@ -63,6 +63,9 @@
     "@types/bun": "1.3.14",
     "typescript": "5.9.3"
   },
+  "overrides": {
+    "fast-uri": "^3.1.4"
+  },
   "keywords": [
     "codex",
     "openai",

package/src/adapters/anthropic.ts CHANGED Viewed

@@ -21,6 +21,7 @@ import { normalizeAnthropicImages } from "./anthropic-image-normalize";
 import { neutralizeIdentity } from "./identity";
 import { CLAUDE_CODE_HEADERS, claudeCodeSessionId } from "./client-fingerprint";
 import { buildNonOpenAIToolCatalogNudgeForTools } from "./tool-catalog-nudge";
+import { decodeServerSentEvents } from "../lib/sse-decoder";
 /** Map a user content part to an Anthropic content block (text or image source). */
 function toAnthropicContentPart(p: OcxContentPart): unknown {
@@ -719,9 +720,6 @@ export function createAnthropicAdapter(provider: OcxProviderConfig, cacheRetenti
         return;
       }
-      const reader = response.body.getReader();
-      const decoder = new TextDecoder();
-      let buffer = "";
       let currentBlockType = "";
       let currentToolCallId = "";
       let currentToolCallName = "";
@@ -739,34 +737,19 @@ export function createAnthropicAdapter(provider: OcxProviderConfig, cacheRetenti
         };
       };
-      try {
-        while (true) {
-          const { done, value } = await reader.read();
-          if (done) break;
-          buffer += decoder.decode(value, { stream: true });
+      for await (const record of decodeServerSentEvents(response.body)) {
+        const payload = record.data.trim();
+        if (!payload) continue;
-          const lines = buffer.split("\n");
-          buffer = lines.pop() ?? "";
-          let currentEventType = "";
-          for (const line of lines) {
-            if (line.startsWith("event: ")) {
-              currentEventType = line.slice(7).trim();
-              continue;
-            }
-            if (!line.startsWith("data: ")) continue;
-            const payload = line.slice(6).trim();
-            if (!payload) continue;
-            let data: Record<string, unknown>;
-            try {
-              data = JSON.parse(payload) as Record<string, unknown>;
-            } catch {
-              debugDroppedFrame("anthropic", payload);
-              continue;
-            }
+        let data: Record<string, unknown>;
+        try {
+          data = JSON.parse(payload) as Record<string, unknown>;
+        } catch {
+          debugDroppedFrame("anthropic", payload);
+          continue;
+        }
-            switch (currentEventType || data.type) {
+        switch (record.event || data.type) {
               case "message_start": {
                 const message = data.message as { usage?: Record<string, number> } | undefined;
                 pendingUsage = mergeAnthropicUsage(pendingUsage, message?.usage);
@@ -794,7 +777,12 @@ export function createAnthropicAdapter(provider: OcxProviderConfig, cacheRetenti
                   yield { type: "text_delta", text: delta.text };
                 } else if (delta.type === "thinking_delta" && typeof delta.thinking === "string") {
                   yield { type: "thinking_delta", thinking: delta.thinking };
-                } else if (delta.type === "signature_delta" && typeof delta.signature === "string" && currentBlockType === "thinking") {
+                } else if (delta.type === "reasoning_delta" && typeof delta.reasoning === "string") {
+                  // Some Anthropic-compatible reasoning models use `reasoning` names for the
+                  // otherwise equivalent thinking block. Preserve it as raw reasoning and keep
+                  // later text blocks independent.
+                  yield { type: "thinking_delta", thinking: delta.reasoning };
+                } else if (delta.type === "signature_delta" && typeof delta.signature === "string" && (currentBlockType === "thinking" || currentBlockType === "reasoning")) {
                   // Arrives once, just before the thinking block's content_block_stop; block-scoped
                   // so a stray signature on a non-thinking block can never be captured.
                   yield { type: "thinking_signature", signature: delta.signature };
@@ -827,20 +815,15 @@ export function createAnthropicAdapter(provider: OcxProviderConfig, cacheRetenti
                 yield { type: "error", message: err?.message ?? "Anthropic error" };
                 return;
               }
-            }
-            currentEventType = "";
-          }
         }
-        if (pendingUsage && !emittedDone) yield* emitDone();
-      } finally {
-        reader.releaseLock();
       }
+      if (pendingUsage && !emittedDone) yield* emitDone();
     },
     async parseResponse(response: Response): Promise<AdapterEvent[]> {
       const json = await response.json() as Record<string, unknown>;
       const events: AdapterEvent[] = [];
-      const content = json.content as { type: string; text?: string; id?: string; name?: string; input?: unknown; thinking?: string; signature?: string; data?: string }[] | undefined;
+      const content = json.content as { type: string; text?: string; id?: string; name?: string; input?: unknown; thinking?: string; reasoning?: string; signature?: string; data?: string }[] | undefined;
       if (content) {
         for (const block of content) {
           if (block.type === "text" && block.text) {
@@ -850,6 +833,8 @@ export function createAnthropicAdapter(provider: OcxProviderConfig, cacheRetenti
             if (typeof block.signature === "string" && block.signature) {
               events.push({ type: "thinking_signature", signature: block.signature });
             }
+          } else if (block.type === "reasoning" && typeof block.reasoning === "string") {
+            events.push({ type: "thinking_delta", thinking: block.reasoning });
           } else if (block.type === "redacted_thinking" && typeof block.data === "string") {
             events.push({ type: "redacted_thinking", data: block.data });
           } else if (block.type === "tool_use") {

package/src/adapters/cursor/cursor-errors.ts CHANGED Viewed

@@ -36,6 +36,17 @@ export function isCursorBenignCancelError(value: unknown): boolean {
   return false;
 }
+/**
+ * True when Cursor Connect rejected the turn with invalid_argument.
+ * Seen after stepCompleted on brittle external-model continuations.
+ */
+export function isCursorInvalidArgumentError(value: unknown): boolean {
+  const code = errorCode(value).toLowerCase();
+  if (code === "invalid_argument") return true;
+  const message = errorMessage(value).toLowerCase();
+  return message.includes("invalid_argument");
+}
 /**
  * Classify a Cursor transport/Connect/gRPC error message into an actionable category.
  * The returned prefix string is recognized by `src/lib/errors.ts` `classifyError` keywords,

package/src/adapters/cursor/discovery.ts CHANGED Viewed

@@ -120,6 +120,31 @@ export function cursorCodexToWireModelId(modelId: string): string {
   return cursorWireModelSelection(modelId).modelId;
 }
+/**
+ * Cursor-native wire models keep server-side conversation state reliably.
+ * External models (gpt/claude/gemini/grok families and similar) are more brittle on resumeAction.
+ */
+export function isCursorNativeWireModel(modelId: string): boolean {
+  const wire = cursorCodexToWireModelId(modelId).trim().toLowerCase();
+  const bare = stripCursorEffortSuffix(wire);
+  if (bare === CURSOR_AUTO_WIRE_MODEL_ID || bare === CURSOR_AUTO_MODEL_ID) return true;
+  return bare.startsWith("composer-");
+}
+/** Inverse of {@link isCursorNativeWireModel}. */
+export function isCursorExternalWireModel(modelId: string): boolean {
+  return !isCursorNativeWireModel(modelId);
+}
+function stripCursorEffortSuffix(wireModelId: string): string {
+  const suffixes = [...CANONICAL_EFFORT_SUFFIXES].sort((a, b) => b.length - a.length);
+  for (const suffix of suffixes) {
+    const marker = `-${suffix}`;
+    if (wireModelId.endsWith(marker)) return wireModelId.slice(0, -marker.length);
+  }
+  return wireModelId;
+}
 export function isCursorRouterModelId(modelId: string): boolean {
   return (CURSOR_ROUTER_MODEL_IDS as readonly string[]).includes(modelId);
 }

package/src/adapters/cursor/live-transport.ts CHANGED Viewed

@@ -70,6 +70,11 @@ const GENERIC_TOOL_COUNT_MAX_FINALIZE_GRACE_MS = 1_800;
 const GENERIC_TOOL_COUNT_PER_TOOL_GRACE_MS = 125;
 const cursorContextUsageTracker = createCursorContextUsageTracker();
+/** Carry context-usage totals across conversation-id rotation for external-model replay. */
+export function rekeyCursorContextUsage(fromConversationId: string, toConversationId: string): void {
+  cursorContextUsageTracker.rekey(fromConversationId, toConversationId);
+}
 export class CursorMissingCredentialError extends Error {
   readonly code = "cursor_missing_credential";

package/src/adapters/cursor/protobuf-events.ts CHANGED Viewed

@@ -22,6 +22,8 @@ export interface CursorContextUsageTracker {
   controlsForConversation(conversationId: string, options?: { clearPrior?: boolean; storeCheckpoints?: boolean }): CursorContextUsageControls;
   get(conversationId: string): number | undefined;
   record(conversationId: string, tokens: number): void;
+  /** Copy numeric carry-forward totals when a conversation id is rotated for replay. */
+  rekey(fromConversationId: string, toConversationId: string): void;
   clear(conversationId: string): void;
   clearAll(): void;
 }
@@ -91,6 +93,18 @@ export function createCursorContextUsageTracker(options: { maxEntries?: number;
     },
     get,
     record,
+    rekey(fromConversationId, toConversationId) {
+      if (!fromConversationId || !toConversationId || fromConversationId === toConversationId) return;
+      prune();
+      const from = entries.get(fromConversationId);
+      if (!from) return;
+      const to = entries.get(toConversationId);
+      const tokens = Math.max(from.tokens, to?.tokens ?? 0);
+      entries.delete(fromConversationId);
+      entries.delete(toConversationId);
+      entries.set(toConversationId, { tokens, updatedAt: now() });
+      prune();
+    },
     clear(conversationId) {
       entries.delete(conversationId);
     },

package/src/adapters/cursor/protobuf-request.ts CHANGED Viewed

@@ -4,6 +4,8 @@ import { ValueSchema } from "@bufbuild/protobuf/wkt";
 import type { OcxAssistantContentPart, OcxMessage, OcxToolResultMessage } from "../../types";
 import { namespacedToolName } from "../../types";
 import type { CursorRunRequest } from "./types";
+import { isCursorExternalWireModel } from "./discovery";
+import { debugProviderDiagnostic } from "../../lib/debug";
 import { storeCursorBlob } from "./native-exec";
 import {
   AgentClientMessageSchema,
@@ -326,8 +328,9 @@ export function encodeCursorRunRequest(request: CursorRunRequest): Uint8Array {
   // would pollute the model input and double-deliver the result. Use ResumeAction so Cursor picks up
   // from the history we provided.
   const lastRawIsToolResult = request.rawMessages?.at(-1)?.role === "toolResult";
+  const actionCase = !lastRawIsToolResult && text.trim().length > 0 ? "userMessageAction" : "resumeAction";
   const action = create(ConversationActionSchema, {
-    action: !lastRawIsToolResult && text.trim().length > 0
+    action: actionCase === "userMessageAction"
       ? {
           case: "userMessageAction",
           value: create(UserMessageActionSchema, {
@@ -345,6 +348,13 @@ export function encodeCursorRunRequest(request: CursorRunRequest): Uint8Array {
           }),
         },
   });
+  debugProviderDiagnostic("cursor", "run-request", {
+    wireModel: request.modelId,
+    action: actionCase,
+    conversationId: request.conversationId,
+    turnType: lastRawIsToolResult ? "tool-continuation" : "initial",
+    externalModel: isCursorExternalWireModel(request.modelId),
+  });
   const runRequest = create(AgentRunRequestSchema, {
     conversationId: request.conversationId,

package/src/adapters/cursor/request-builder.ts CHANGED Viewed

@@ -8,7 +8,7 @@ import type {
 } from "../../types";
 import { isAllowedToolChoice, namespacedToolName, toolChoiceAliases, type OcxTool, type OcxToolChoice } from "../../types";
 import type { CursorRequestMessage, CursorRunRequest } from "./types";
-import { cursorWireModelSelection, type CursorRoutingLevel } from "./discovery";
+import { cursorWireModelSelection, isCursorExternalWireModel, type CursorRoutingLevel } from "./discovery";
 import { cursorEffortSuffix } from "./effort-map";
 import {
   cursorMcpToolEncodedSize,
@@ -159,7 +159,15 @@ export function generatedCursorConversationId(): string {
   return `cursor_${crypto.randomUUID().replace(/-/g, "")}`;
 }
-export function createCursorRequest(parsed: OcxParsedRequest): CursorRunRequest {
+export interface CreateCursorRequestOptions {
+  /** Force a brand-new Cursor conversation id even when remembered state exists. */
+  forceFreshConversation?: boolean;
+}
+export function createCursorRequest(
+  parsed: OcxParsedRequest,
+  options: CreateCursorRequestOptions = {},
+): CursorRunRequest {
   const messages = parsed.context.messages
     .map(requestMessage)
     .filter((message): message is CursorRequestMessage => !!message && message.content.length > 0);
@@ -168,6 +176,13 @@ export function createCursorRequest(parsed: OcxParsedRequest): CursorRunRequest
   const budget = applyCursorToolBudget(visibleTools, parsed.options.toolChoice);
   const limitNote = catalogLimitNote(budget.tools, budget.omitted);
   const model = normalizeCursorModelId(parsed.modelId, parsed.options.reasoning);
+  const lastRaw = parsed.context.messages.at(-1);
+  // External Cursor models (e.g. gpt-5.6-sol) can corrupt server-side conversation state across
+  // tool-result continuations when ResumeAction reuses the same conversationId. Force a fresh id
+  // so the full history is replayed without depending on that state.
+  const forceFreshConversation =
+    options.forceFreshConversation === true
+    || (lastRaw?.role === "toolResult" && isCursorExternalWireModel(model.modelId));
   return {
     modelId: model.modelId,
     ...(model.routingLevel ? { routingLevel: model.routingLevel } : {}),
@@ -175,7 +190,9 @@ export function createCursorRequest(parsed: OcxParsedRequest): CursorRunRequest
     // back to the OpenAI Responses previous_response_id (resp_*): that is a Responses-chain id in a
     // different namespace and would start an unrelated Cursor conversation, breaking tool-result
     // continuation. If we have no remembered Cursor conversation, start a fresh one.
-    conversationId: parsed._cursorConversationId ?? generatedCursorConversationId(),
+    conversationId: forceFreshConversation
+      ? generatedCursorConversationId()
+      : (parsed._cursorConversationId ?? generatedCursorConversationId()),
     system: [...(parsed.context.systemPrompt ?? []), ...(limitNote ? [limitNote] : [])],
     messages,
     rawMessages: parsed.context.messages,

package/src/adapters/cursor.ts CHANGED Viewed

@@ -1,11 +1,16 @@
 import type { AdapterEvent, OcxProviderConfig } from "../types";
 import type { ProviderAdapter } from "./base";
 import { cursorExecDeniedMessage, cursorRequestDeclaresFullAccess } from "./cursor/exec-policy";
-import { isCursorBenignCancelError, safeCursorErrorMessage } from "./cursor/cursor-errors";
+import { isCursorBenignCancelError, isCursorInvalidArgumentError, safeCursorErrorMessage } from "./cursor/cursor-errors";
+import { isCursorExternalWireModel } from "./cursor/discovery";
 import { createCursorKvStore, type CursorKvStore } from "./cursor/kv-store";
 import { mapCursorServerMessage } from "./cursor/message-mapper";
 import { createCursorRequest, generatedCursorConversationId } from "./cursor/request-builder";
-import { createLiveCursorTransport, CursorMissingCredentialError } from "./cursor/live-transport";
+import {
+  createLiveCursorTransport,
+  CursorMissingCredentialError,
+  rekeyCursorContextUsage,
+} from "./cursor/live-transport";
 import { runCursorTurnWithRetry } from "./cursor/transport-retry";
 import {
   createDisabledCursorTransport,
@@ -70,26 +75,68 @@ export function createCursorAdapter(provider: OcxProviderConfig, deps: CursorAda
         const makeTransport = deps.createTransport ?? createLiveCursorTransport;
         const kv = deps.kv ?? createCursorKvStore();
         _parsed._cursorConversationId ??= generatedCursorConversationId();
-        const request = createCursorRequest(_parsed);
-        await runCursorTurnWithRetry(
-          makeTransport,
-          { provider, headers: incoming.headers, requestDeclaresFullAccess: cursorRequestDeclaresFullAccess(request) },
-          request,
-          incoming.abortSignal,
-          (message, activeTransport) => {
-            if (incoming.abortSignal?.aborted) {
-              emit({ type: "error", message: "Cursor turn was aborted." });
-              return;
-            }
-            const events = mapCursorServerMessage(message, {
-              kv,
-              writeClient: clientMessage => {
-                void activeTransport.writeClient(clientMessage);
-              },
-            });
-            for (const event of events) emit(event);
-          },
-        );
+        const previousConversationId = _parsed._cursorConversationId;
+        let request = createCursorRequest(_parsed);
+        // Keep remembered conversation id in sync when the request builder mints a fresh id
+        // for external-model tool-result continuations (stateless replay).
+        if (request.conversationId !== previousConversationId) {
+          rekeyCursorContextUsage(previousConversationId, request.conversationId);
+        }
+        _parsed._cursorConversationId = request.conversationId;
+        let emittedOutput = false;
+        const lastRawIsToolResult = _parsed.context.messages.at(-1)?.role === "toolResult";
+        const runOnce = async (activeRequest: ReturnType<typeof createCursorRequest>) => {
+          await runCursorTurnWithRetry(
+            makeTransport,
+            {
+              provider,
+              headers: incoming.headers,
+              requestDeclaresFullAccess: cursorRequestDeclaresFullAccess(activeRequest),
+            },
+            activeRequest,
+            incoming.abortSignal,
+            (message, activeTransport) => {
+              if (incoming.abortSignal?.aborted) {
+                emit({ type: "error", message: "Cursor turn was aborted." });
+                return;
+              }
+              const events = mapCursorServerMessage(message, {
+                kv,
+                writeClient: clientMessage => {
+                  void activeTransport.writeClient(clientMessage);
+                },
+              });
+              for (const event of events) {
+                if (event.type !== "heartbeat") emittedOutput = true;
+                emit(event);
+              }
+            },
+          );
+        };
+        try {
+          await runOnce(request);
+        } catch (err) {
+          // One-shot fallback: only for external-model tool-result continuations that fail
+          // with Connect invalid_argument before any non-heartbeat output was forwarded.
+          // Replaying after text/tool events would duplicate output.
+          if (
+            !isCursorInvalidArgumentError(err)
+            || !isCursorExternalWireModel(request.modelId)
+            || !lastRawIsToolResult
+            || emittedOutput
+            || incoming.abortSignal?.aborted
+          ) {
+            throw err;
+          }
+          const failedConversationId = request.conversationId;
+          _parsed._cursorConversationId = undefined;
+          request = createCursorRequest(_parsed, { forceFreshConversation: true });
+          rekeyCursorContextUsage(failedConversationId, request.conversationId);
+          _parsed._cursorConversationId = request.conversationId;
+          await runOnce(request);
+        }
       } catch (err) {
         if (isCursorBenignCancelError(err)) return;
         const partialUsage = (err as { partialUsage?: import("../types").OcxUsage }).partialUsage;

package/src/adapters/google-http.ts CHANGED Viewed

@@ -1,5 +1,6 @@
 import type { AdapterFetchContext, AdapterRequest } from "./base";
 import { isQuotaExhaustedBody, retryableGoogleStatus, safeGoogleHttpErrorMessage } from "./google-errors";
+import { repairGoogleInvalidRequestBody } from "./google-wire-compiler";
 import { normalizeUpstreamHttpErrorResponse, readDisplaySafeErrorPayloadText } from "./upstream-http-error";
 import {
   abortError,
@@ -29,14 +30,32 @@ async function normalizeFinalGoogleError(label: string, res: Response, signal?:
 export async function fetchGoogleWithRetry(label: string, request: AdapterRequest, ctx: AdapterFetchContext = {}): Promise<Response> {
   const timeoutMs = ctx.timeoutMs ?? 200_000;
   let lastError: unknown;
+  let activeRequest = request;
+  let compatibilityReplayUsed = false;
   for (let attempt = 0; attempt < GOOGLE_RETRY_ATTEMPTS; attempt++) {
     if (ctx.abortSignal?.aborted) throw abortError(ctx.abortSignal);
     try {
-      const res = await fetchWithAttemptDeadline(request.url, {
-        method: request.method,
-        headers: request.headers,
-        body: request.body,
+      const res = await fetchWithAttemptDeadline(activeRequest.url, {
+        method: activeRequest.method,
+        headers: activeRequest.headers,
+        body: activeRequest.body,
       }, timeoutMs, ctx.abortSignal, ctx.stream);
+      if (res.status === 400 && !compatibilityReplayUsed) {
+        let payloadText = "";
+        try {
+          payloadText = await readDisplaySafeErrorPayloadText(res.clone(), ctx.abortSignal);
+        } catch (error) {
+          if (ctx.abortSignal?.aborted) throw error;
+        }
+        const repairedBody = repairGoogleInvalidRequestBody(activeRequest.body, payloadText);
+        if (repairedBody !== undefined) {
+          compatibilityReplayUsed = true;
+          activeRequest = { ...activeRequest, body: repairedBody };
+          cancelResponseBodyBestEffort(res);
+          attempt--; // The changed-request replay is separate from transient retry accounting.
+          continue;
+        }
+      }
       if (!retryableGoogleStatus(res.status) || attempt === GOOGLE_RETRY_ATTEMPTS - 1) {
         return ctx.returnRawErrors ? res : normalizeFinalGoogleError(label, res, ctx.abortSignal);
       }