npm - @bitkyc08/opencodex - Versions diffs - 0.1.0 - Mend

@bitkyc08/opencodex 0.1.0

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

package/LICENSE +21 -0
package/README.ko.md +164 -0
package/README.md +165 -0
package/README.zh-CN.md +162 -0
package/gui/README.md +73 -0
package/gui/dist/assets/index-C1wlp1SM.css +1 -0
package/gui/dist/assets/index-C9y3iMF1.js +9 -0
package/gui/dist/favicon.png +0 -0
package/gui/dist/icons.svg +24 -0
package/gui/dist/index.html +15 -0
package/gui/dist/logo.png +0 -0
package/package.json +56 -0
package/scripts/postinstall.mjs +57 -0
package/src/adapters/anthropic.ts +306 -0
package/src/adapters/azure.ts +31 -0
package/src/adapters/base.ts +20 -0
package/src/adapters/google.ts +195 -0
package/src/adapters/image.ts +23 -0
package/src/adapters/openai-chat.ts +265 -0
package/src/adapters/openai-responses.ts +43 -0
package/src/bridge.ts +296 -0
package/src/cli.ts +183 -0
package/src/codex-catalog.ts +318 -0
package/src/codex-inject.ts +186 -0
package/src/config.ts +108 -0
package/src/index.ts +20 -0
package/src/init.ts +163 -0
package/src/model-cache.ts +42 -0
package/src/oauth/anthropic.ts +151 -0
package/src/oauth/callback-server.ts +249 -0
package/src/oauth/index.ts +235 -0
package/src/oauth/key-providers.ts +126 -0
package/src/oauth/kimi.ts +160 -0
package/src/oauth/local-token-detect.ts +71 -0
package/src/oauth/login-cli.ts +90 -0
package/src/oauth/pkce.ts +15 -0
package/src/oauth/store.ts +39 -0
package/src/oauth/types.ts +22 -0
package/src/oauth/xai.ts +234 -0
package/src/responses/parser.ts +402 -0
package/src/responses/schema.ts +145 -0
package/src/router.ts +86 -0
package/src/server.ts +522 -0
package/src/service.ts +130 -0
package/src/star-prompt.ts +50 -0
package/src/types.ts +228 -0
package/src/update.ts +64 -0
package/src/vision/describe.ts +98 -0
package/src/vision/index.ts +141 -0
package/src/web-search/executor.ts +75 -0
package/src/web-search/format-result.ts +45 -0
package/src/web-search/index.ts +62 -0
package/src/web-search/loop.ts +188 -0
package/src/web-search/parse.ts +128 -0
package/src/web-search/synthetic-tool.ts +42 -0

package/gui/dist/index.html ADDED Viewed

@@ -0,0 +1,15 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/png" href="/favicon.png" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <meta name="color-scheme" content="dark" />
+    <title>opencodex · proxy dashboard</title>
+    <script type="module" crossorigin src="/assets/index-C9y3iMF1.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-C1wlp1SM.css">
+  </head>
+  <body>
+    <div id="root"></div>
+  </body>
+</html>

package/gui/dist/logo.png ADDED Viewed

Binary file

package/package.json ADDED Viewed

@@ -0,0 +1,56 @@
+{
+  "name": "@bitkyc08/opencodex",
+  "version": "0.1.0",
+  "description": "Universal provider proxy for OpenAI Codex — use any LLM with Codex CLI/App/SDK",
+  "type": "module",
+  "main": "src/index.ts",
+  "bin": {
+    "opencodex": "./src/cli.ts",
+    "ocx": "./src/cli.ts"
+  },
+  "files": [
+    "src",
+    "scripts/postinstall.mjs",
+    "gui/dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "bun": ">=1.1.0"
+  },
+  "scripts": {
+    "dev": "bun run src/cli.ts start",
+    "start": "bun run src/cli.ts start",
+    "typecheck": "bun x tsc --noEmit",
+    "build:gui": "cd gui && bun install && bun run build",
+    "postinstall": "node scripts/postinstall.mjs",
+    "prepublishOnly": "bun run typecheck && bun run build:gui",
+    "release": "bun scripts/release.ts",
+    "release:watch": "bun scripts/release.ts watch"
+  },
+  "dependencies": {
+    "zod": "^4.0.0"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "typescript": "^5.8.0"
+  },
+  "keywords": [
+    "codex",
+    "openai",
+    "proxy",
+    "llm",
+    "ollama",
+    "anthropic",
+    "responses-api"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lidge-jun/opencodex.git"
+  },
+  "homepage": "https://lidge-jun.github.io/opencodex/",
+  "bugs": {
+    "url": "https://github.com/lidge-jun/opencodex/issues"
+  },
+  "license": "MIT"
+}

package/scripts/postinstall.mjs ADDED Viewed

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+/**
+ * postinstall — one-time GitHub-star prompt during `npm install -g opencx`.
+ *
+ * Behavior:
+ *   - TTY-only (skips CI / piped installs)
+ *   - Requires `gh` CLI with auth (stars directly via `gh api`)
+ *   - Prompts once; shares the ~/.opencodex/.star-prompted marker with the first-`ocx start` prompt
+ *     (so bun users — where postinstall may not run on `-g` — still get it exactly once on start)
+ *   - Never blocks the install (all errors silently caught)
+ */
+import { spawnSync } from "node:child_process";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { homedir } from "node:os";
+const REPO = "lidge-jun/opencodex";
+const MARKER = join(homedir(), ".opencodex", ".star-prompted");
+function ghInstalled() {
+  const r = spawnSync("gh", ["--version"], { stdio: "ignore", timeout: 3000, windowsHide: true });
+  return !r.error && r.status === 0;
+}
+function starRepo() {
+  const r = spawnSync("gh", ["api", "-X", "PUT", `/user/starred/${REPO}`],
+    { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: 10000, windowsHide: true });
+  if (r.error) return { ok: false, error: r.error.message };
+  if (r.status !== 0) return { ok: false, error: (r.stderr || r.stdout || "").trim() || `gh exited ${r.status}` };
+  return { ok: true };
+}
+async function askYesNo(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const a = (await rl.question(question)).trim().toLowerCase();
+    return a === "" || a === "y" || a === "yes";
+  } finally {
+    rl.close();
+  }
+}
+async function main() {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) return;
+  if (existsSync(MARKER)) return;
+  if (!ghInstalled()) return;
+  try { mkdirSync(join(homedir(), ".opencodex"), { recursive: true }); writeFileSync(MARKER, new Date().toISOString()); } catch { /* best-effort */ }
+  const yes = await askYesNo("[opencodex] Enjoying opencodex? Star it on GitHub? [Y/n] ");
+  if (!yes) return;
+  const r = starRepo();
+  console.log(r.ok ? "[opencodex] Thanks for the star! ⭐" : `[opencodex] Couldn't star automatically: ${r.error}`);
+}
+main().catch(() => { /* never fail the install */ });

package/src/adapters/anthropic.ts ADDED Viewed

@@ -0,0 +1,306 @@
+import type { ProviderAdapter } from "./base";
+import type {
+  AdapterEvent,
+  OcxAssistantMessage,
+  OcxContentPart,
+  OcxMessage,
+  OcxParsedRequest,
+  OcxProviderConfig,
+  OcxTextContent,
+  OcxThinkingContent,
+  OcxToolCall,
+} from "../types";
+import { ANTHROPIC_OAUTH_BETA, CLAUDE_CODE_SYSTEM_INSTRUCTION, applyClaudeToolPrefix, stripClaudeToolPrefix } from "../oauth/anthropic";
+import { parseDataUrl } from "./image";
+/** Map a user content part to an Anthropic content block (text or image source). */
+function toAnthropicContentPart(p: OcxContentPart): unknown {
+  if (p.type === "image") {
+    const data = parseDataUrl(p.imageUrl);
+    return data
+      ? { type: "image", source: { type: "base64", media_type: data.mediaType, data: data.base64 } }
+      : { type: "image", source: { type: "url", url: p.imageUrl } };
+  }
+  return { type: "text", text: p.text };
+}
+/** Default `max_tokens` when Codex omits `max_output_tokens`. */
+const DEFAULT_MAX_TOKENS = 8192;
+/** Safe ceiling for `max_tokens` (thinking + visible output) across current Claude 4.x models. */
+const REASONING_MAX_TOKENS_CEILING = 32_000;
+/** Anthropic's documented minimum `thinking.budget_tokens`. */
+const MIN_THINKING_BUDGET = 1024;
+/** Visible-output room added above the thinking budget when sizing `max_tokens`. */
+const OUTPUT_HEADROOM = 8192;
+/** Minimum visible-output room kept below `max_tokens` (so `max_tokens > budget_tokens` always holds). */
+const OUTPUT_FLOOR = 4096;
+/** Map a Responses reasoning effort to an Anthropic extended-thinking budget (tokens, >= 1024). */
+function reasoningBudget(effort: string): number {
+  switch (effort) {
+    case "minimal": return 1024;
+    case "low": return 4096;
+    case "high": return 16384;
+    case "xhigh": return 24576;
+    case "max": return 32000;
+    case "medium":
+    default: return 8192;
+  }
+}
+function messagesToAnthropicFormat(parsed: OcxParsedRequest, isOAuth: boolean): { system: string | undefined; messages: unknown[] } {
+  const system = parsed.context.systemPrompt?.join("\n\n") || undefined;
+  const messages: unknown[] = [];
+  for (const msg of parsed.context.messages) {
+    switch (msg.role) {
+      case "user":
+      case "developer": {
+        const content = typeof msg.content === "string"
+          ? msg.content
+          : (msg.content as OcxContentPart[]).map(toAnthropicContentPart);
+        messages.push({ role: "user", content });
+        break;
+      }
+      case "assistant": {
+        const aMsg = msg as OcxAssistantMessage;
+        const content: unknown[] = [];
+        for (const part of aMsg.content) {
+          if (part.type === "text") {
+            content.push({ type: "text", text: (part as OcxTextContent).text });
+          } else if (part.type === "thinking") {
+            const t = part as OcxThinkingContent;
+            content.push({ type: "thinking", thinking: t.thinking, ...(t.signature ? { signature: t.signature } : {}) });
+          } else if (part.type === "toolCall") {
+            const tc = part as OcxToolCall;
+            content.push({ type: "tool_use", id: tc.id, name: isOAuth ? applyClaudeToolPrefix(tc.name) : tc.name, input: tc.arguments });
+          }
+        }
+        messages.push({ role: "assistant", content });
+        break;
+      }
+      case "toolResult": {
+        // Anthropic tool_result accepts a string OR content blocks — render images natively
+        // (e.g. Codex view_image output) instead of dropping them.
+        const trContent = typeof msg.content === "string"
+          ? msg.content
+          : (msg.content as OcxContentPart[]).map(toAnthropicContentPart);
+        messages.push({
+          role: "user",
+          content: [{
+            type: "tool_result",
+            tool_use_id: msg.toolCallId,
+            content: trContent,
+          }],
+        });
+        break;
+      }
+    }
+  }
+  return { system, messages };
+}
+function toolsToAnthropicFormat(parsed: OcxParsedRequest, isOAuth: boolean): unknown[] | undefined {
+  if (!parsed.context.tools || parsed.context.tools.length === 0) return undefined;
+  return parsed.context.tools.map(t => ({
+    name: isOAuth ? applyClaudeToolPrefix(t.name) : t.name,
+    description: t.description,
+    input_schema: t.parameters,
+  }));
+}
+export function createAnthropicAdapter(provider: OcxProviderConfig): ProviderAdapter {
+  const isOAuth = provider.authMode === "oauth";
+  return {
+    name: "anthropic",
+    buildRequest(parsed: OcxParsedRequest) {
+      const { system, messages } = messagesToAnthropicFormat(parsed, isOAuth);
+      const tools = toolsToAnthropicFormat(parsed, isOAuth);
+      const body: Record<string, unknown> = {
+        model: parsed.modelId,
+        messages,
+        stream: parsed.stream,
+        max_tokens: parsed.options.maxOutputTokens ?? DEFAULT_MAX_TOKENS,
+      };
+      if (isOAuth) {
+        // Claude OAuth (Pro/Max) requires the first system block to be the Claude Code identity.
+        body.system = [
+          { type: "text", text: CLAUDE_CODE_SYSTEM_INSTRUCTION },
+          ...(system ? [{ type: "text", text: system }] : []),
+        ];
+      } else if (system) {
+        body.system = system;
+      }
+      if (tools) body.tools = tools;
+      if (parsed.options.temperature !== undefined) body.temperature = parsed.options.temperature;
+      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) {
+        // 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
+        // always exceeds the budget within a model-safe ceiling, reserving room for visible output.
+        const maxOut = parsed.options.maxOutputTokens ?? DEFAULT_MAX_TOKENS;
+        const wantBudget = reasoningBudget(parsed.options.reasoning);
+        const maxTokens = Math.min(REASONING_MAX_TOKENS_CEILING, Math.max(maxOut, wantBudget + OUTPUT_HEADROOM));
+        const budget = Math.max(MIN_THINKING_BUDGET, Math.min(wantBudget, maxTokens - OUTPUT_FLOOR));
+        body.max_tokens = maxTokens;
+        body.thinking = { type: "enabled", budget_tokens: budget };
+        // Extended thinking disallows temperature != 1 and top_p — drop both or the API 400s.
+        delete body.temperature;
+        delete body.top_p;
+      }
+      if (parsed.options.toolChoice) {
+        const tc = parsed.options.toolChoice;
+        if (tc === "auto") body.tool_choice = { type: "auto" };
+        else if (tc === "none") body.tool_choice = { type: "none" };
+        else if (tc === "required") body.tool_choice = { type: "any" };
+        else if (typeof tc === "object" && "name" in tc) body.tool_choice = { type: "tool", name: isOAuth ? applyClaudeToolPrefix(tc.name) : tc.name };
+      }
+      const url = `${provider.baseUrl}/v1/messages`;
+      const headers: Record<string, string> = {
+        "Content-Type": "application/json",
+        "anthropic-version": "2023-06-01",
+      };
+      if (isOAuth) {
+        if (provider.apiKey) headers["Authorization"] = `Bearer ${provider.apiKey}`;
+        headers["anthropic-beta"] = ANTHROPIC_OAUTH_BETA;
+      } else if (provider.apiKey) {
+        headers["x-api-key"] = provider.apiKey;
+      }
+      if (provider.headers) Object.assign(headers, provider.headers);
+      return { url, method: "POST", headers, body: JSON.stringify(body) };
+    },
+    async *parseStream(response: Response): AsyncGenerator<AdapterEvent> {
+      if (!response.body) {
+        yield { type: "error", message: "No response body" };
+        return;
+      }
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = "";
+      let currentBlockType = "";
+      let currentToolCallId = "";
+      let currentToolCallName = "";
+      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() ?? "";
+          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 {
+              continue;
+            }
+            switch (currentEventType || data.type) {
+              case "content_block_start": {
+                const block = data.content_block as { type: string; id?: string; name?: string } | undefined;
+                if (!block) break;
+                currentBlockType = block.type;
+                if (block.type === "tool_use") {
+                  currentToolCallId = block.id ?? "";
+                  currentToolCallName = isOAuth ? stripClaudeToolPrefix(block.name ?? "") : (block.name ?? "");
+                  yield { type: "tool_call_start", id: currentToolCallId, name: currentToolCallName };
+                }
+                break;
+              }
+              case "content_block_delta": {
+                const delta = data.delta as Record<string, unknown> | undefined;
+                if (!delta) break;
+                if (delta.type === "text_delta" && typeof delta.text === "string") {
+                  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 === "input_json_delta" && typeof delta.partial_json === "string") {
+                  yield { type: "tool_call_delta", arguments: delta.partial_json };
+                }
+                break;
+              }
+              case "content_block_stop": {
+                if (currentBlockType === "tool_use") {
+                  yield { type: "tool_call_end" };
+                  currentToolCallId = "";
+                  currentBlockType = "";
+                }
+                break;
+              }
+              case "message_delta": {
+                const usage = data.usage as Record<string, number> | undefined;
+                if (usage) {
+                  yield {
+                    type: "done",
+                    usage: {
+                      inputTokens: usage.input_tokens ?? 0,
+                      outputTokens: usage.output_tokens ?? 0,
+                    },
+                  };
+                }
+                break;
+              }
+              case "message_stop": {
+                break;
+              }
+              case "error": {
+                const err = data.error as { message?: string } | undefined;
+                yield { type: "error", message: err?.message ?? "Anthropic error" };
+                return;
+              }
+            }
+            currentEventType = "";
+          }
+        }
+      } finally {
+        reader.releaseLock();
+      }
+    },
+    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 }[] | undefined;
+      if (content) {
+        for (const block of content) {
+          if (block.type === "text" && block.text) {
+            events.push({ type: "text_delta", text: block.text });
+          } else if (block.type === "tool_use") {
+            events.push({ type: "tool_call_start", id: block.id ?? "", name: isOAuth ? stripClaudeToolPrefix(block.name ?? "") : (block.name ?? "") });
+            events.push({ type: "tool_call_delta", arguments: JSON.stringify(block.input ?? {}) });
+            events.push({ type: "tool_call_end" });
+          }
+        }
+      }
+      const usage = json.usage as Record<string, number> | undefined;
+      events.push({
+        type: "done",
+        usage: usage ? { inputTokens: usage.input_tokens ?? 0, outputTokens: usage.output_tokens ?? 0 } : undefined,
+      });
+      return events;
+    },
+  };
+}

package/src/adapters/azure.ts ADDED Viewed

@@ -0,0 +1,31 @@
+import type { ProviderAdapter } from "./base";
+import type { OcxParsedRequest, OcxProviderConfig } from "../types";
+import { createResponsesPassthroughAdapter } from "./openai-responses";
+export function createAzureAdapter(provider: OcxProviderConfig): ProviderAdapter & { passthrough: true } {
+  const inner = createResponsesPassthroughAdapter({
+    ...provider,
+    baseUrl: provider.baseUrl,
+  });
+  return {
+    ...inner,
+    name: "azure-openai",
+    buildRequest(parsed: OcxParsedRequest) {
+      const request = inner.buildRequest(parsed);
+      const headers = { ...request.headers };
+      if (provider.apiKey) {
+        headers["api-key"] = provider.apiKey;
+        delete headers["Authorization"];
+      }
+      const apiVersion = (provider.headers?.["api-version"]) ?? "2025-04-01-preview";
+      const separator = request.url.includes("?") ? "&" : "?";
+      return {
+        ...request,
+        url: `${request.url}${separator}api-version=${apiVersion}`,
+        headers,
+      };
+    },
+  };
+}

package/src/adapters/base.ts ADDED Viewed

@@ -0,0 +1,20 @@
+import type { AdapterEvent, OcxParsedRequest } from "../types";
+/** Metadata about the caller's incoming request, for auth-forwarding adapters. */
+export interface IncomingMeta {
+  headers: Headers;
+}
+export interface ProviderAdapter {
+  name: string;
+  buildRequest(parsed: OcxParsedRequest, incoming?: IncomingMeta): {
+    url: string;
+    method: string;
+    headers: Record<string, string>;
+    body: string;
+  };
+  parseStream(response: Response): AsyncGenerator<AdapterEvent>;
+  parseResponse?(response: Response): Promise<AdapterEvent[]>;
+}

package/src/adapters/google.ts ADDED Viewed

@@ -0,0 +1,195 @@
+import type { ProviderAdapter } from "./base";
+import type {
+  AdapterEvent,
+  OcxAssistantMessage,
+  OcxContentPart,
+  OcxParsedRequest,
+  OcxProviderConfig,
+  OcxTextContent,
+  OcxToolCall,
+} from "../types";
+import { contentPartsToText, parseDataUrl } from "./image";
+function messagesToGeminiFormat(parsed: OcxParsedRequest): { systemInstruction?: unknown; contents: unknown[] } {
+  const systemInstruction = parsed.context.systemPrompt?.length
+    ? { parts: [{ text: parsed.context.systemPrompt.join("\n\n") }] }
+    : undefined;
+  const contents: unknown[] = [];
+  for (const msg of parsed.context.messages) {
+    switch (msg.role) {
+      case "user":
+      case "developer": {
+        if (typeof msg.content === "string") {
+          contents.push({ role: "user", parts: [{ text: msg.content }] });
+        } else {
+          const parts = (msg.content as OcxContentPart[]).map(p => {
+            if (p.type === "image") {
+              const data = parseDataUrl(p.imageUrl);
+              // Gemini takes base64 via inline_data; a remote URL needs a mime type we don't have, so
+              // fall back to a short marker rather than inlining the URL as a huge text blob.
+              return data ? { inline_data: { mime_type: data.mediaType, data: data.base64 } } : { text: `[image: ${p.imageUrl}]` };
+            }
+            return { text: p.text };
+          });
+          contents.push({ role: "user", parts });
+        }
+        break;
+      }
+      case "assistant": {
+        const aMsg = msg as OcxAssistantMessage;
+        const parts: unknown[] = [];
+        for (const p of aMsg.content) {
+          if (p.type === "text") parts.push({ text: (p as OcxTextContent).text });
+          else if (p.type === "toolCall") {
+            const tc = p as OcxToolCall;
+            parts.push({ functionCall: { name: tc.name, args: tc.arguments } });
+          }
+        }
+        contents.push({ role: "model", parts });
+        break;
+      }
+      case "toolResult": {
+        contents.push({
+          role: "user",
+          parts: [{ functionResponse: { name: msg.toolName, response: { result: contentPartsToText(msg.content) } } }],
+        });
+        break;
+      }
+    }
+  }
+  return { systemInstruction, contents };
+}
+function toolsToGeminiFormat(parsed: OcxParsedRequest): unknown[] | undefined {
+  if (!parsed.context.tools?.length) return undefined;
+  return [{
+    functionDeclarations: parsed.context.tools.map(t => ({
+      name: t.name,
+      description: t.description,
+      parameters: t.parameters,
+    })),
+  }];
+}
+export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapter {
+  return {
+    name: "google",
+    buildRequest(parsed: OcxParsedRequest) {
+      const { systemInstruction, contents } = messagesToGeminiFormat(parsed);
+      const tools = toolsToGeminiFormat(parsed);
+      const body: Record<string, unknown> = { contents };
+      if (systemInstruction) body.systemInstruction = systemInstruction;
+      if (tools) body.tools = tools;
+      const generationConfig: Record<string, unknown> = {};
+      if (parsed.options.maxOutputTokens) generationConfig.maxOutputTokens = parsed.options.maxOutputTokens;
+      if (parsed.options.temperature !== undefined) generationConfig.temperature = parsed.options.temperature;
+      if (parsed.options.topP !== undefined) generationConfig.topP = parsed.options.topP;
+      if (parsed.options.stopSequences) generationConfig.stopSequences = parsed.options.stopSequences;
+      if (Object.keys(generationConfig).length > 0) body.generationConfig = generationConfig;
+      const method = parsed.stream ? "streamGenerateContent" : "generateContent";
+      const streamParam = parsed.stream ? "?alt=sse" : "";
+      const url = `${provider.baseUrl}/v1beta/models/${parsed.modelId}:${method}${streamParam}`;
+      const headers: Record<string, string> = { "Content-Type": "application/json" };
+      if (provider.apiKey) headers["x-goog-api-key"] = provider.apiKey;
+      if (provider.headers) Object.assign(headers, provider.headers);
+      return { url, method: "POST", headers, body: JSON.stringify(body) };
+    },
+    async *parseStream(response: Response): AsyncGenerator<AdapterEvent> {
+      if (!response.body) {
+        yield { type: "error", message: "No response body" };
+        return;
+      }
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = "";
+      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() ?? "";
+          for (const line of lines) {
+            if (!line.startsWith("data: ")) continue;
+            const payload = line.slice(6).trim();
+            if (!payload) continue;
+            let chunk: Record<string, unknown>;
+            try { chunk = JSON.parse(payload); } catch { continue; }
+            const candidates = chunk.candidates as { content?: { parts?: unknown[] }; finishReason?: string }[] | undefined;
+            if (!candidates?.length) continue;
+            const parts = candidates[0].content?.parts as { text?: string; functionCall?: { name: string; args: unknown } }[] | undefined;
+            if (parts) {
+              for (const part of parts) {
+                if (part.text) {
+                  yield { type: "text_delta", text: part.text };
+                }
+                if (part.functionCall) {
+                  const id = `call_${crypto.randomUUID().slice(0, 8)}`;
+                  yield { type: "tool_call_start", id, name: part.functionCall.name };
+                  yield { type: "tool_call_delta", arguments: JSON.stringify(part.functionCall.args ?? {}) };
+                  yield { type: "tool_call_end" };
+                }
+              }
+            }
+            const usageMeta = chunk.usageMetadata as Record<string, number> | undefined;
+            if (candidates[0].finishReason && usageMeta) {
+              yield {
+                type: "done",
+                usage: {
+                  inputTokens: usageMeta.promptTokenCount ?? 0,
+                  outputTokens: usageMeta.candidatesTokenCount ?? 0,
+                },
+              };
+            }
+          }
+        }
+        yield { type: "done" };
+      } finally {
+        reader.releaseLock();
+      }
+    },
+    async parseResponse(response: Response): Promise<AdapterEvent[]> {
+      const json = await response.json() as Record<string, unknown>;
+      const events: AdapterEvent[] = [];
+      const candidates = json.candidates as { content?: { parts?: { text?: string; functionCall?: { name: string; args: unknown } }[] } }[] | undefined;
+      if (candidates?.[0]?.content?.parts) {
+        for (const part of candidates[0].content.parts) {
+          if (part.text) events.push({ type: "text_delta", text: part.text });
+          if (part.functionCall) {
+            const id = `call_${crypto.randomUUID().slice(0, 8)}`;
+            events.push({ type: "tool_call_start", id, name: part.functionCall.name });
+            events.push({ type: "tool_call_delta", arguments: JSON.stringify(part.functionCall.args ?? {}) });
+            events.push({ type: "tool_call_end" });
+          }
+        }
+      }
+      const usage = json.usageMetadata as Record<string, number> | undefined;
+      events.push({
+        type: "done",
+        usage: usage ? { inputTokens: usage.promptTokenCount ?? 0, outputTokens: usage.candidatesTokenCount ?? 0 } : undefined,
+      });
+      return events;
+    },
+  };
+}