opencode-aicodewith-auth 0.1.0

package/dist/index.js

@@ -0,0 +1,1290 @@
+// @bun
+// provider.ts
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { createGoogleGenerativeAI } from "@ai-sdk/google";
+import { createOpenAI } from "@ai-sdk/openai";
+var isClaude = (modelId) => modelId.startsWith("claude-");
+var isGemini = (modelId) => modelId.startsWith("gemini-");
+var isResponses = (modelId) => modelId.startsWith("gpt-") || modelId.startsWith("codex");
+var normalizeModelId = (modelId) => String(modelId).trim();
+function createAicodewith(options = {}) {
+  const openai = createOpenAI({
+    apiKey: options.apiKey,
+    baseURL: options.baseURL,
+    headers: options.headers,
+    fetch: options.fetch
+  });
+  const openaiLanguageModel = typeof openai.languageModel === "function" ? openai.languageModel : openai.chat;
+  const openaiChatModel = typeof openai.chat === "function" ? openai.chat : openaiLanguageModel;
+  const anthropic = createAnthropic({
+    apiKey: options.anthropic?.apiKey ?? options.apiKey,
+    baseURL: options.anthropic?.baseURL,
+    headers: options.anthropic?.headers ?? options.headers,
+    fetch: options.fetch
+  });
+  const google = createGoogleGenerativeAI({
+    apiKey: options.google?.apiKey ?? options.apiKey,
+    baseURL: options.google?.baseURL,
+    headers: options.google?.headers ?? options.headers,
+    fetch: options.fetch
+  });
+  const createModel = (modelId) => {
+    const id = normalizeModelId(modelId);
+    if (isClaude(id))
+      return anthropic.languageModel(id);
+    if (isGemini(id))
+      return google.languageModel(id);
+    if (isResponses(id) && typeof openai.responses === "function")
+      return openai.responses(id);
+    return openaiLanguageModel(id);
+  };
+  const provider = (modelId) => createModel(modelId);
+  provider.languageModel = createModel;
+  provider.chat = (modelId) => {
+    const id = normalizeModelId(modelId);
+    if (isClaude(id))
+      return anthropic.languageModel(id);
+    if (isGemini(id))
+      return google.languageModel(id);
+    return openaiChatModel(id);
+  };
+  provider.responses = (modelId) => {
+    const id = normalizeModelId(modelId);
+    if (isClaude(id) || isGemini(id))
+      return provider.chat(id);
+    return openai.responses(id);
+  };
+  return provider;
+}
+var aicodewith = createAicodewith();
+
+// index.ts
+import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import path from "path";
+import os from "os";
+
+// lib/constants.ts
+var PLUGIN_NAME = "opencode-aicodewith-auth";
+var PROVIDER_ID = "aicodewith";
+var AUTH_METHOD_LABEL = "AICodewith API Key";
+var CODEX_BASE_URL = "https://api.aicodewith.com/chatgpt/v1";
+var AICODEWITH_ANTHROPIC_BASE_URL = "https://api.aicodewith.com";
+var AICODEWITH_GEMINI_BASE_URL = "https://api.aicodewith.com/gemini_cli";
+var GEMINI_USER_AGENT = "GeminiCLI/v25.2.1 (darwin; arm64)";
+var GEMINI_API_CLIENT = "google-genai-sdk/1.30.0 gl-node/v25.2.1";
+var GEMINI_PRIVILEGED_USER_ID_ENV = "AICODEWITH_GEMINI_USER_ID";
+var USER_AGENT = "codex_cli_rs/0.77.0 (Mac OS 26.2.0; arm64) iTerm.app/3.6.6";
+var ORIGINATOR = "codex_cli_rs";
+var HEADER_NAMES = {
+  AUTHORIZATION: "authorization",
+  ORIGINATOR: "originator",
+  SESSION_ID: "session_id",
+  CONVERSATION_ID: "conversation_id",
+  USER_AGENT: "user-agent",
+  ACCEPT: "accept",
+  CONTENT_TYPE: "content-type",
+  OPENAI_BETA: "openai-beta",
+  CHATGPT_ACCOUNT_ID: "chatgpt-account-id",
+  X_GOOG_API_KEY: "x-goog-api-key",
+  X_GOOG_API_CLIENT: "x-goog-api-client",
+  X_GEMINI_PRIVILEGED_USER_ID: "x-gemini-api-privileged-user-id"
+};
+
+// lib/logger.ts
+import { writeFileSync, mkdirSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var LOGGING_ENABLED = process.env.ENABLE_PLUGIN_REQUEST_LOGGING === "1";
+var DEBUG_ENABLED = process.env.DEBUG_CODEX_PLUGIN === "1" || LOGGING_ENABLED;
+var LOG_DIR = join(homedir(), ".opencode", "logs", PLUGIN_NAME);
+if (LOGGING_ENABLED) {
+  console.log(`[${PLUGIN_NAME}] Request logging ENABLED - logs will be saved to:`, LOG_DIR);
+}
+if (DEBUG_ENABLED && !LOGGING_ENABLED) {
+  console.log(`[${PLUGIN_NAME}] Debug logging ENABLED`);
+}
+var requestCounter = 0;
+function logRequest(stage, data) {
+  if (!LOGGING_ENABLED)
+    return;
+  if (!existsSync(LOG_DIR)) {
+    mkdirSync(LOG_DIR, { recursive: true });
+  }
+  const timestamp = new Date().toISOString();
+  const requestId = ++requestCounter;
+  const filename = join(LOG_DIR, `request-${requestId}-${stage}.json`);
+  try {
+    writeFileSync(filename, JSON.stringify({
+      timestamp,
+      requestId,
+      stage,
+      ...data
+    }, null, 2), "utf8");
+    console.log(`[${PLUGIN_NAME}] Logged ${stage} to ${filename}`);
+  } catch (e) {
+    const error = e;
+    console.error(`[${PLUGIN_NAME}] Failed to write log:`, error.message);
+  }
+}
+function logDebug(message, data) {
+  if (!DEBUG_ENABLED)
+    return;
+  if (data !== undefined) {
+    console.log(`[${PLUGIN_NAME}] ${message}`, data);
+  } else {
+    console.log(`[${PLUGIN_NAME}] ${message}`);
+  }
+}
+function logWarn(message, data) {
+  if (!DEBUG_ENABLED && !LOGGING_ENABLED)
+    return;
+  if (data !== undefined) {
+    console.warn(`[${PLUGIN_NAME}] ${message}`, data);
+  } else {
+    console.warn(`[${PLUGIN_NAME}] ${message}`);
+  }
+}
+
+// lib/prompts/codex.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync, writeFileSync as writeFileSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { dirname, join as join2 } from "path";
+import { fileURLToPath } from "url";
+var GITHUB_API_RELEASES = "https://api.github.com/repos/openai/codex/releases/latest";
+var GITHUB_HTML_RELEASES = "https://github.com/openai/codex/releases/latest";
+var CACHE_DIR = join2(homedir2(), ".opencode", "cache");
+var __filename2 = fileURLToPath(import.meta.url);
+var __dirname2 = dirname(__filename2);
+var PROMPT_FILES = {
+  "gpt-5.2-codex": "gpt-5.2-codex_prompt.md",
+  "codex-max": "gpt-5.1-codex-max_prompt.md",
+  codex: "gpt_5_codex_prompt.md",
+  "gpt-5.2": "gpt_5_2_prompt.md",
+  "gpt-5.1": "gpt_5_1_prompt.md"
+};
+var CACHE_FILES = {
+  "gpt-5.2-codex": "gpt-5.2-codex-instructions.md",
+  "codex-max": "codex-max-instructions.md",
+  codex: "codex-instructions.md",
+  "gpt-5.2": "gpt-5.2-instructions.md",
+  "gpt-5.1": "gpt-5.1-instructions.md"
+};
+var FALLBACK_FILE = join2(__dirname2, "fallback-instructions.txt");
+function getModelFamily(normalizedModel) {
+  if (normalizedModel.includes("gpt-5.2-codex") || normalizedModel.includes("gpt 5.2 codex")) {
+    return "gpt-5.2-codex";
+  }
+  if (normalizedModel.includes("codex-max")) {
+    return "codex-max";
+  }
+  if (normalizedModel.includes("codex") || normalizedModel.startsWith("codex-")) {
+    return "codex";
+  }
+  if (normalizedModel.includes("gpt-5.2")) {
+    return "gpt-5.2";
+  }
+  return "gpt-5.1";
+}
+async function getLatestReleaseTag() {
+  try {
+    const response = await fetch(GITHUB_API_RELEASES);
+    if (response.ok) {
+      const data = await response.json();
+      if (data.tag_name) {
+        return data.tag_name;
+      }
+    }
+  } catch {}
+  const htmlResponse = await fetch(GITHUB_HTML_RELEASES);
+  if (!htmlResponse.ok) {
+    throw new Error(`Failed to fetch latest release: ${htmlResponse.status}`);
+  }
+  const finalUrl = htmlResponse.url;
+  if (finalUrl) {
+    const parts = finalUrl.split("/tag/");
+    const last = parts[parts.length - 1];
+    if (last && !last.includes("/")) {
+      return last;
+    }
+  }
+  const html = await htmlResponse.text();
+  const match = html.match(/\/openai\/codex\/releases\/tag\/([^"]+)/);
+  if (match && match[1]) {
+    return match[1];
+  }
+  throw new Error("Failed to determine latest release tag from GitHub");
+}
+async function getCodexInstructions(normalizedModel = "gpt-5.1-codex") {
+  const modelFamily = getModelFamily(normalizedModel);
+  const promptFile = PROMPT_FILES[modelFamily];
+  const cacheFile = join2(CACHE_DIR, CACHE_FILES[modelFamily]);
+  const cacheMetaFile = join2(CACHE_DIR, `${CACHE_FILES[modelFamily].replace(".md", "-meta.json")}`);
+  try {
+    let cachedETag = null;
+    let cachedTag = null;
+    let cachedTimestamp = null;
+    if (existsSync2(cacheMetaFile)) {
+      const metadata = JSON.parse(readFileSync(cacheMetaFile, "utf8"));
+      cachedETag = metadata.etag;
+      cachedTag = metadata.tag;
+      cachedTimestamp = metadata.lastChecked;
+    }
+    const CACHE_TTL_MS = 15 * 60 * 1000;
+    if (cachedTimestamp && Date.now() - cachedTimestamp < CACHE_TTL_MS && existsSync2(cacheFile)) {
+      return readFileSync(cacheFile, "utf8");
+    }
+    const latestTag = await getLatestReleaseTag();
+    const url = `https://raw.githubusercontent.com/openai/codex/${latestTag}/codex-rs/core/${promptFile}`;
+    if (cachedTag != latestTag) {
+      cachedETag = null;
+    }
+    const headers = {};
+    if (cachedETag) {
+      headers["If-None-Match"] = cachedETag;
+    }
+    const response = await fetch(url, { headers });
+    if (response.status === 304) {
+      if (existsSync2(cacheFile)) {
+        return readFileSync(cacheFile, "utf8");
+      }
+    }
+    if (response.ok) {
+      const instructions = await response.text();
+      const newETag = response.headers.get("etag");
+      if (!existsSync2(CACHE_DIR)) {
+        mkdirSync2(CACHE_DIR, { recursive: true });
+      }
+      writeFileSync2(cacheFile, instructions, "utf8");
+      writeFileSync2(cacheMetaFile, JSON.stringify({
+        etag: newETag,
+        tag: latestTag,
+        lastChecked: Date.now(),
+        url
+      }), "utf8");
+      return instructions;
+    }
+    throw new Error(`HTTP ${response.status}`);
+  } catch (error) {
+    const err = error;
+    console.error(`[${PLUGIN_NAME}] Failed to fetch Codex instructions from GitHub:`, err.message);
+    if (existsSync2(FALLBACK_FILE)) {
+      console.error(`[${PLUGIN_NAME}] Using fallback instructions`);
+      return readFileSync(FALLBACK_FILE, "utf8");
+    }
+    throw new Error("No fallback instructions available");
+  }
+}
+
+// lib/prompts/codex-opencode-bridge.ts
+var CODEX_OPENCODE_BRIDGE = `# Codex Running in OpenCode
+
+You are running Codex through OpenCode, an open-source terminal coding assistant. OpenCode provides different tools but follows Codex operating principles.
+
+## CRITICAL: Tool Replacements
+
+<critical_rule priority="0">
+\u274C APPLY_PATCH DOES NOT EXIST \u2192 \u2705 USE "edit" INSTEAD
+- NEVER use: apply_patch, applyPatch
+- ALWAYS use: edit tool for ALL file modifications
+- Before modifying files: Verify you're using "edit", NOT "apply_patch"
+</critical_rule>
+
+<critical_rule priority="0">
+\u274C UPDATE_PLAN DOES NOT EXIST \u2192 \u2705 USE "todowrite" INSTEAD
+- NEVER use: update_plan, updatePlan, read_plan, readPlan
+- ALWAYS use: todowrite for task/plan updates, todoread to read plans
+- Before plan operations: Verify you're using "todowrite", NOT "update_plan"
+</critical_rule>
+
+## Available OpenCode Tools
+
+**File Operations:**
+- \`write\`  - Create new files
+  - Overwriting existing files requires a prior Read in this session; default to ASCII unless the file already uses Unicode.
+- \`edit\`   - Modify existing files (REPLACES apply_patch)
+  - Requires a prior Read in this session; preserve exact indentation; ensure \`oldString\` uniquely matches or use \`replaceAll\`; edit fails if ambiguous or missing.
+- \`read\`   - Read file contents
+
+**Search/Discovery:**
+- \`grep\`   - Search file contents (tool, not bash grep); use \`include\` to filter patterns; set \`path\` only when not searching workspace root; for cross-file match counts use bash with \`rg\`.
+- \`glob\`   - Find files by pattern; defaults to workspace cwd unless \`path\` is set.
+- \`list\`   - List directories (requires absolute paths)
+
+**Execution:**
+- \`bash\`   - Run shell commands
+  - No workdir parameter; do not include it in tool calls.
+  - Always include a short description for the command.
+  - Do not use cd; use absolute paths in commands.
+  - Quote paths containing spaces with double quotes.
+  - Chain multiple commands with ';' or '&&'; avoid newlines.
+  - Use Grep/Glob tools for searches; only use bash with \`rg\` when you need counts or advanced features.
+  - Do not use \`ls\`/\`cat\` in bash; use \`list\`/\`read\` tools instead.
+  - For deletions (rm), verify by listing parent dir with \`list\`.
+
+**Network:**
+- \`webfetch\` - Fetch web content
+  - Use fully-formed URLs (http/https; http auto-upgrades to https).
+  - Always set \`format\` to one of: text | markdown | html; prefer markdown unless otherwise required.
+  - Read-only; short cache window.
+
+**Task Management:**
+- \`todowrite\` - Manage tasks/plans (REPLACES update_plan)
+- \`todoread\`  - Read current plan
+
+## Substitution Rules
+
+Base instruction says:    You MUST use instead:
+apply_patch           \u2192   edit
+update_plan           \u2192   todowrite
+read_plan             \u2192   todoread
+
+**Path Usage:** Use per-tool conventions to avoid conflicts:
+- Tool calls: \`read\`, \`edit\`, \`write\`, \`list\` require absolute paths.
+- Searches: \`grep\`/\`glob\` default to the workspace cwd; prefer relative include patterns; set \`path\` only when a different root is needed.
+- Presentation: In assistant messages, show workspace-relative paths; use absolute paths only inside tool calls.
+- Tool schema overrides general path preferences\u2014do not convert required absolute paths to relative.
+
+## Verification Checklist
+
+Before file/plan modifications:
+1. Am I using "edit" NOT "apply_patch"?
+2. Am I using "todowrite" NOT "update_plan"?
+3. Is this tool in the approved list above?
+4. Am I following each tool's path requirements?
+
+If ANY answer is NO \u2192 STOP and correct before proceeding.
+
+## OpenCode Working Style
+
+**Communication:**
+- Send brief preambles (8-12 words) before tool calls, building on prior context
+- Provide progress updates during longer tasks
+
+**Execution:**
+- Keep working autonomously until query is fully resolved before yielding
+- Don't return to user with partial solutions
+
+**Code Approach:**
+- New projects: Be ambitious and creative
+- Existing codebases: Surgical precision - modify only what's requested unless explicitly instructed to do otherwise
+
+**Testing:**
+- If tests exist: Start specific to your changes, then broader validation
+
+## Advanced Tools
+
+**Task Tool (Sub-Agents):**
+- Use the Task tool (functions.task) to launch sub-agents
+- Check the Task tool description for current agent types and their capabilities
+- Useful for complex analysis, specialized workflows, or tasks requiring isolated context
+- The agent list is dynamically generated - refer to tool schema for available agents
+
+**Parallelization:**
+- When multiple independent tool calls are needed, use multi_tool_use.parallel to run them concurrently.
+- Reserve sequential calls for ordered or data-dependent steps.
+
+**MCP Tools:**
+- Model Context Protocol servers provide additional capabilities
+- MCP tools are prefixed: \`mcp__<server-name>__<tool-name>\`
+- Check your available tools for MCP integrations
+- Use when the tool's functionality matches your task needs
+
+## What Remains from Codex
+ 
+Sandbox policies, approval mechanisms, final answer formatting, git commit protocols, and file reference formats all follow Codex instructions. In approval policy "never", never request escalations.
+
+## Approvals & Safety
+- Assume workspace-write filesystem, network enabled, approval on-failure unless explicitly stated otherwise.
+- When a command fails due to sandboxing or permissions, retry with escalated permissions if allowed by policy, including a one-line justification.
+- Treat destructive commands (e.g., \`rm\`, \`git reset --hard\`) as requiring explicit user request or approval.
+- When uncertain, prefer non-destructive verification first (e.g., confirm file existence with \`list\`, then delete with \`bash\`).`;
+
+// lib/prompts/opencode-codex.ts
+import { join as join3 } from "path";
+import { homedir as homedir3 } from "os";
+import { mkdir, readFile, writeFile } from "fs/promises";
+var OPENCODE_CODEX_URL = "https://raw.githubusercontent.com/anomalyco/opencode/dev/packages/opencode/src/session/prompt/codex.txt";
+var CACHE_DIR2 = join3(homedir3(), ".opencode", "cache");
+var CACHE_FILE = join3(CACHE_DIR2, "opencode-codex.txt");
+var CACHE_META_FILE = join3(CACHE_DIR2, "opencode-codex-meta.json");
+async function getOpenCodeCodexPrompt() {
+  await mkdir(CACHE_DIR2, { recursive: true });
+  let cachedContent = null;
+  let cachedMeta = null;
+  try {
+    cachedContent = await readFile(CACHE_FILE, "utf-8");
+    const metaContent = await readFile(CACHE_META_FILE, "utf-8");
+    cachedMeta = JSON.parse(metaContent);
+  } catch {}
+  const CACHE_TTL_MS = 15 * 60 * 1000;
+  if (cachedMeta?.lastChecked && Date.now() - cachedMeta.lastChecked < CACHE_TTL_MS && cachedContent) {
+    return cachedContent;
+  }
+  const headers = {};
+  if (cachedMeta?.etag) {
+    headers["If-None-Match"] = cachedMeta.etag;
+  }
+  try {
+    const response = await fetch(OPENCODE_CODEX_URL, { headers });
+    if (response.status === 304 && cachedContent) {
+      return cachedContent;
+    }
+    if (response.ok) {
+      const content = await response.text();
+      const etag = response.headers.get("etag") || "";
+      await writeFile(CACHE_FILE, content, "utf-8");
+      await writeFile(CACHE_META_FILE, JSON.stringify({
+        etag,
+        lastFetch: new Date().toISOString(),
+        lastChecked: Date.now()
+      }, null, 2), "utf-8");
+      return content;
+    }
+    if (cachedContent) {
+      return cachedContent;
+    }
+    throw new Error(`Failed to fetch OpenCode codex.txt: ${response.status}`);
+  } catch (error) {
+    if (cachedContent) {
+      return cachedContent;
+    }
+    throw new Error(`Failed to fetch OpenCode codex.txt and no cache available: ${error}`);
+  }
+}
+
+// lib/request/helpers/model-map.ts
+var MODEL_MAP = {
+  "gpt-5.1-codex": "gpt-5.1-codex",
+  "gpt-5.1-codex-low": "gpt-5.1-codex",
+  "gpt-5.1-codex-medium": "gpt-5.1-codex",
+  "gpt-5.1-codex-high": "gpt-5.1-codex",
+  "gpt-5.1-codex-max": "gpt-5.1-codex-max",
+  "gpt-5.1-codex-max-low": "gpt-5.1-codex-max",
+  "gpt-5.1-codex-max-medium": "gpt-5.1-codex-max",
+  "gpt-5.1-codex-max-high": "gpt-5.1-codex-max",
+  "gpt-5.1-codex-max-xhigh": "gpt-5.1-codex-max",
+  "gpt-5.2": "gpt-5.2",
+  "gpt-5.2-none": "gpt-5.2",
+  "gpt-5.2-low": "gpt-5.2",
+  "gpt-5.2-medium": "gpt-5.2",
+  "gpt-5.2-high": "gpt-5.2",
+  "gpt-5.2-xhigh": "gpt-5.2",
+  "gpt-5.2-codex": "gpt-5.2-codex",
+  "gpt-5.2-codex-low": "gpt-5.2-codex",
+  "gpt-5.2-codex-medium": "gpt-5.2-codex",
+  "gpt-5.2-codex-high": "gpt-5.2-codex",
+  "gpt-5.2-codex-xhigh": "gpt-5.2-codex",
+  "gpt-5.1-codex-mini": "gpt-5.1-codex-mini",
+  "gpt-5.1-codex-mini-medium": "gpt-5.1-codex-mini",
+  "gpt-5.1-codex-mini-high": "gpt-5.1-codex-mini",
+  "gpt-5.1": "gpt-5.1",
+  "gpt-5.1-none": "gpt-5.1",
+  "gpt-5.1-low": "gpt-5.1",
+  "gpt-5.1-medium": "gpt-5.1",
+  "gpt-5.1-high": "gpt-5.1",
+  "gpt-5.1-chat-latest": "gpt-5.1",
+  "gpt-5-codex": "gpt-5.1-codex",
+  "codex-mini-latest": "gpt-5.1-codex-mini",
+  "gpt-5-codex-mini": "gpt-5.1-codex-mini",
+  "gpt-5-codex-mini-medium": "gpt-5.1-codex-mini",
+  "gpt-5-codex-mini-high": "gpt-5.1-codex-mini",
+  "gpt-5": "gpt-5.1",
+  "gpt-5-mini": "gpt-5.1",
+  "gpt-5-nano": "gpt-5.1"
+};
+function getNormalizedModel(modelId) {
+  try {
+    if (MODEL_MAP[modelId]) {
+      return MODEL_MAP[modelId];
+    }
+    const lowerModelId = modelId.toLowerCase();
+    const match = Object.keys(MODEL_MAP).find((key) => key.toLowerCase() === lowerModelId);
+    return match ? MODEL_MAP[match] : undefined;
+  } catch {
+    return;
+  }
+}
+
+// lib/request/helpers/input-utils.ts
+var OPENCODE_PROMPT_SIGNATURES = [
+  "you are a coding agent running in the opencode",
+  "you are opencode, an agent",
+  "you are opencode, an interactive cli agent",
+  "you are opencode, an interactive cli tool",
+  "you are opencode, the best coding agent on the planet"
+].map((signature) => signature.toLowerCase());
+var OPENCODE_CONTEXT_MARKERS = [
+  "here is some useful information about the environment you are running in:",
+  "<env>",
+  "instructions from:",
+  "<instructions>"
+].map((marker) => marker.toLowerCase());
+var getContentText = (item) => {
+  if (typeof item.content === "string") {
+    return item.content;
+  }
+  if (Array.isArray(item.content)) {
+    return item.content.filter((c) => c.type === "input_text" && c.text).map((c) => c.text).join(`
+`);
+  }
+  return "";
+};
+var replaceContentText = (item, contentText) => {
+  if (typeof item.content === "string") {
+    return { ...item, content: contentText };
+  }
+  if (Array.isArray(item.content)) {
+    return {
+      ...item,
+      content: [{ type: "input_text", text: contentText }]
+    };
+  }
+  return { ...item, content: contentText };
+};
+var extractOpenCodeContext = (contentText) => {
+  const lower = contentText.toLowerCase();
+  let earliestIndex = -1;
+  for (const marker of OPENCODE_CONTEXT_MARKERS) {
+    const index = lower.indexOf(marker);
+    if (index >= 0 && (earliestIndex === -1 || index < earliestIndex)) {
+      earliestIndex = index;
+    }
+  }
+  if (earliestIndex === -1)
+    return null;
+  return contentText.slice(earliestIndex).trimStart();
+};
+function isOpenCodeSystemPrompt(item, cachedPrompt) {
+  const isSystemRole = item.role === "developer" || item.role === "system";
+  if (!isSystemRole)
+    return false;
+  const contentText = getContentText(item);
+  if (!contentText)
+    return false;
+  if (cachedPrompt) {
+    const contentTrimmed = contentText.trim();
+    const cachedTrimmed = cachedPrompt.trim();
+    if (contentTrimmed === cachedTrimmed) {
+      return true;
+    }
+    if (contentTrimmed.startsWith(cachedTrimmed)) {
+      return true;
+    }
+    const contentPrefix = contentTrimmed.substring(0, 200);
+    const cachedPrefix = cachedTrimmed.substring(0, 200);
+    if (contentPrefix === cachedPrefix) {
+      return true;
+    }
+  }
+  const normalized = contentText.trimStart().toLowerCase();
+  return OPENCODE_PROMPT_SIGNATURES.some((signature) => normalized.startsWith(signature));
+}
+function filterOpenCodeSystemPromptsWithCachedPrompt(input, cachedPrompt) {
+  if (!Array.isArray(input))
+    return input;
+  return input.flatMap((item) => {
+    if (item.role === "user")
+      return [item];
+    if (!isOpenCodeSystemPrompt(item, cachedPrompt)) {
+      return [item];
+    }
+    const contentText = getContentText(item);
+    const preservedContext = extractOpenCodeContext(contentText);
+    if (preservedContext) {
+      return [replaceContentText(item, preservedContext)];
+    }
+    return [];
+  });
+}
+var getCallId = (item) => {
+  const rawCallId = item.call_id;
+  if (typeof rawCallId !== "string")
+    return null;
+  const trimmed = rawCallId.trim();
+  return trimmed.length > 0 ? trimmed : null;
+};
+var convertOrphanedOutputToMessage = (item, callId) => {
+  const toolName = typeof item.name === "string" ? item.name : "tool";
+  const labelCallId = callId ?? "unknown";
+  let text;
+  try {
+    const out = item.output;
+    text = typeof out === "string" ? out : JSON.stringify(out);
+  } catch {
+    text = String(item.output ?? "");
+  }
+  if (text.length > 16000) {
+    text = text.slice(0, 16000) + `
+...[truncated]`;
+  }
+  return {
+    type: "message",
+    role: "assistant",
+    content: `[Previous ${toolName} result; call_id=${labelCallId}]: ${text}`
+  };
+};
+var collectCallIds = (input) => {
+  const functionCallIds = new Set;
+  const localShellCallIds = new Set;
+  const customToolCallIds = new Set;
+  for (const item of input) {
+    const callId = getCallId(item);
+    if (!callId)
+      continue;
+    switch (item.type) {
+      case "function_call":
+        functionCallIds.add(callId);
+        break;
+      case "local_shell_call":
+        localShellCallIds.add(callId);
+        break;
+      case "custom_tool_call":
+        customToolCallIds.add(callId);
+        break;
+      default:
+        break;
+    }
+  }
+  return { functionCallIds, localShellCallIds, customToolCallIds };
+};
+var normalizeOrphanedToolOutputs = (input) => {
+  const { functionCallIds, localShellCallIds, customToolCallIds } = collectCallIds(input);
+  return input.map((item) => {
+    if (item.type === "function_call_output") {
+      const callId = getCallId(item);
+      const hasMatch = !!callId && (functionCallIds.has(callId) || localShellCallIds.has(callId));
+      if (!hasMatch) {
+        return convertOrphanedOutputToMessage(item, callId);
+      }
+    }
+    if (item.type === "custom_tool_call_output") {
+      const callId = getCallId(item);
+      const hasMatch = !!callId && customToolCallIds.has(callId);
+      if (!hasMatch) {
+        return convertOrphanedOutputToMessage(item, callId);
+      }
+    }
+    if (item.type === "local_shell_call_output") {
+      const callId = getCallId(item);
+      const hasMatch = !!callId && localShellCallIds.has(callId);
+      if (!hasMatch) {
+        return convertOrphanedOutputToMessage(item, callId);
+      }
+    }
+    return item;
+  });
+};
+
+// lib/request/request-transformer.ts
+function normalizeModel(model) {
+  if (!model)
+    return "gpt-5.1";
+  const modelId = model.includes("/") ? model.split("/").pop() : model;
+  const mappedModel = getNormalizedModel(modelId);
+  if (mappedModel) {
+    return mappedModel;
+  }
+  const normalized = modelId.toLowerCase();
+  if (normalized.includes("gpt-5.2-codex") || normalized.includes("gpt 5.2 codex")) {
+    return "gpt-5.2-codex";
+  }
+  if (normalized.includes("gpt-5.2") || normalized.includes("gpt 5.2")) {
+    return "gpt-5.2";
+  }
+  if (normalized.includes("gpt-5.1-codex-max") || normalized.includes("gpt 5.1 codex max")) {
+    return "gpt-5.1-codex-max";
+  }
+  if (normalized.includes("gpt-5.1-codex-mini") || normalized.includes("gpt 5.1 codex mini")) {
+    return "gpt-5.1-codex-mini";
+  }
+  if (normalized.includes("codex-mini-latest") || normalized.includes("gpt-5-codex-mini") || normalized.includes("gpt 5 codex mini")) {
+    return "codex-mini-latest";
+  }
+  if (normalized.includes("gpt-5.1-codex") || normalized.includes("gpt 5.1 codex")) {
+    return "gpt-5.1-codex";
+  }
+  if (normalized.includes("gpt-5.1") || normalized.includes("gpt 5.1")) {
+    return "gpt-5.1";
+  }
+  if (normalized.includes("codex")) {
+    return "gpt-5.1-codex";
+  }
+  if (normalized.includes("gpt-5") || normalized.includes("gpt 5")) {
+    return "gpt-5.1";
+  }
+  return "gpt-5.1";
+}
+function resolveReasoningConfig(modelName, body) {
+  const providerOpenAI = body.providerOptions?.openai;
+  const existingEffort = body.reasoning?.effort ?? providerOpenAI?.reasoningEffort;
+  const existingSummary = body.reasoning?.summary ?? providerOpenAI?.reasoningSummary;
+  const mergedConfig = {
+    ...existingEffort ? { reasoningEffort: existingEffort } : {},
+    ...existingSummary ? { reasoningSummary: existingSummary } : {}
+  };
+  return getReasoningConfig(modelName, mergedConfig);
+}
+function resolveTextVerbosity(body) {
+  const providerOpenAI = body.providerOptions?.openai;
+  return body.text?.verbosity ?? providerOpenAI?.textVerbosity;
+}
+function resolveInclude(body) {
+  const providerOpenAI = body.providerOptions?.openai;
+  const base = body.include ?? providerOpenAI?.include ?? ["reasoning.encrypted_content"];
+  const include = Array.from(new Set(base.filter(Boolean)));
+  if (!include.includes("reasoning.encrypted_content")) {
+    include.push("reasoning.encrypted_content");
+  }
+  return include;
+}
+function filterInput(input) {
+  if (!Array.isArray(input))
+    return input;
+  return input.filter((item) => {
+    if (item.type === "item_reference") {
+      return false;
+    }
+    return true;
+  }).map((item) => {
+    if (item.id) {
+      const { id, ...itemWithoutId } = item;
+      return itemWithoutId;
+    }
+    return item;
+  });
+}
+async function filterOpenCodeSystemPrompts(input) {
+  if (!Array.isArray(input))
+    return input;
+  let cachedPrompt = null;
+  try {
+    cachedPrompt = await getOpenCodeCodexPrompt();
+  } catch {}
+  return filterOpenCodeSystemPromptsWithCachedPrompt(input, cachedPrompt);
+}
+function addCodexBridgeMessage(input, hasTools) {
+  if (!hasTools || !Array.isArray(input))
+    return input;
+  const bridgeMessage = {
+    type: "message",
+    role: "developer",
+    content: [
+      {
+        type: "input_text",
+        text: CODEX_OPENCODE_BRIDGE
+      }
+    ]
+  };
+  return [bridgeMessage, ...input];
+}
+function getReasoningConfig(modelName, userConfig = {}) {
+  const normalizedName = modelName?.toLowerCase() ?? "";
+  const isGpt52Codex = normalizedName.includes("gpt-5.2-codex") || normalizedName.includes("gpt 5.2 codex");
+  const isGpt52General = (normalizedName.includes("gpt-5.2") || normalizedName.includes("gpt 5.2")) && !isGpt52Codex;
+  const isCodexMax = normalizedName.includes("codex-max") || normalizedName.includes("codex max");
+  const isCodexMini = normalizedName.includes("codex-mini") || normalizedName.includes("codex mini") || normalizedName.includes("codex_mini") || normalizedName.includes("codex-mini-latest");
+  const isCodex = normalizedName.includes("codex") && !isCodexMini;
+  const isLightweight = !isCodexMini && (normalizedName.includes("nano") || normalizedName.includes("mini"));
+  const isGpt51General = (normalizedName.includes("gpt-5.1") || normalizedName.includes("gpt 5.1")) && !isCodex && !isCodexMax && !isCodexMini;
+  const supportsXhigh = isGpt52General || isGpt52Codex || isCodexMax;
+  const supportsNone = isGpt52General || isGpt51General;
+  const defaultEffort = isCodexMini ? "medium" : supportsXhigh ? "high" : isLightweight ? "minimal" : "medium";
+  let effort = userConfig.reasoningEffort || defaultEffort;
+  if (isCodexMini) {
+    if (effort === "minimal" || effort === "low" || effort === "none") {
+      effort = "medium";
+    }
+    if (effort === "xhigh") {
+      effort = "high";
+    }
+    if (effort !== "high" && effort !== "medium") {
+      effort = "medium";
+    }
+  }
+  if (!supportsXhigh && effort === "xhigh") {
+    effort = "high";
+  }
+  if (!supportsNone && effort === "none") {
+    effort = "low";
+  }
+  if (isCodex && effort === "minimal") {
+    effort = "low";
+  }
+  return {
+    effort,
+    summary: userConfig.reasoningSummary || "auto"
+  };
+}
+async function transformRequestBody(body, codexInstructions) {
+  const originalModel = body.model;
+  const normalizedModel = normalizeModel(body.model);
+  logDebug(`Model lookup: "${originalModel}" -> "${normalizedModel}"`, {
+    hasTools: !!body.tools
+  });
+  body.model = normalizedModel;
+  body.store = false;
+  body.stream = true;
+  body.instructions = codexInstructions;
+  if (body.input && Array.isArray(body.input)) {
+    const originalIds = body.input.filter((item) => item.id).map((item) => item.id);
+    if (originalIds.length > 0) {
+      logDebug("Filtering message IDs", originalIds);
+    }
+    body.input = filterInput(body.input);
+    const remainingIds = (body.input || []).filter((item) => item.id).map((item) => item.id);
+    if (remainingIds.length > 0) {
+      logWarn("IDs still present after filtering", remainingIds);
+    }
+    body.input = await filterOpenCodeSystemPrompts(body.input);
+    body.input = addCodexBridgeMessage(body.input, !!body.tools);
+    if (body.input) {
+      body.input = normalizeOrphanedToolOutputs(body.input);
+    }
+  }
+  const reasoningConfig = resolveReasoningConfig(normalizedModel, body);
+  body.reasoning = {
+    ...body.reasoning,
+    ...reasoningConfig
+  };
+  const verbosity = resolveTextVerbosity(body);
+  if (verbosity) {
+    body.text = {
+      ...body.text,
+      verbosity
+    };
+  }
+  body.include = resolveInclude(body);
+  body.max_output_tokens = undefined;
+  body.max_completion_tokens = undefined;
+  return body;
+}
+
+// lib/request/response-handler.ts
+function parseSseStream(sseText) {
+  const lines = sseText.split(`
+`);
+  for (const line of lines) {
+    if (line.startsWith("data: ")) {
+      try {
+        const data = JSON.parse(line.substring(6));
+        if (data.type === "response.done" || data.type === "response.completed") {
+          return data.response;
+        }
+      } catch (e) {}
+    }
+  }
+  return null;
+}
+async function convertSseToJson(response, headers) {
+  if (!response.body) {
+    throw new Error(`[${PLUGIN_NAME}] Response has no body`);
+  }
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder;
+  let fullText = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      fullText += decoder.decode(value, { stream: true });
+    }
+    if (LOGGING_ENABLED) {
+      logRequest("stream-full", { fullContent: fullText });
+    }
+    const finalResponse = parseSseStream(fullText);
+    if (!finalResponse) {
+      console.error(`[${PLUGIN_NAME}] Could not find final response in SSE stream`);
+      logRequest("stream-error", { error: "No response.done event found" });
+      return new Response(fullText, {
+        status: response.status,
+        statusText: response.statusText,
+        headers
+      });
+    }
+    const jsonHeaders = new Headers(headers);
+    jsonHeaders.set("content-type", "application/json; charset=utf-8");
+    return new Response(JSON.stringify(finalResponse), {
+      status: response.status,
+      statusText: response.statusText,
+      headers: jsonHeaders
+    });
+  } catch (error) {
+    console.error(`[${PLUGIN_NAME}] Error converting stream:`, error);
+    logRequest("stream-error", { error: String(error) });
+    throw error;
+  }
+}
+function ensureContentType(headers) {
+  const responseHeaders = new Headers(headers);
+  if (!responseHeaders.has("content-type")) {
+    responseHeaders.set("content-type", "text/event-stream; charset=utf-8");
+  }
+  return responseHeaders;
+}
+
+// lib/request/fetch-helpers.ts
+function extractRequestUrl(input) {
+  if (typeof input === "string")
+    return input;
+  if (input instanceof URL)
+    return input.toString();
+  return input.url;
+}
+async function transformRequestForCodex(init) {
+  if (!init?.body || typeof init.body !== "string")
+    return;
+  try {
+    const body = JSON.parse(init.body);
+    const normalizedModel = normalizeModel(body.model);
+    const codexInstructions = await getCodexInstructions(normalizedModel);
+    const transformedBody = await transformRequestBody(body, codexInstructions);
+    logRequest("after-transform", {
+      model: transformedBody.model,
+      hasTools: !!transformedBody.tools,
+      hasInput: !!transformedBody.input
+    });
+    return {
+      body: transformedBody,
+      updatedInit: { ...init, body: JSON.stringify(transformedBody) }
+    };
+  } catch {
+    return;
+  }
+}
+function createAicodewithHeaders(init, apiKey, opts) {
+  const headers = new Headers(init?.headers ?? {});
+  headers.delete(HEADER_NAMES.OPENAI_BETA);
+  headers.delete(HEADER_NAMES.CHATGPT_ACCOUNT_ID);
+  headers.delete("x-api-key");
+  headers.set(HEADER_NAMES.AUTHORIZATION, `Bearer ${apiKey}`);
+  headers.set(HEADER_NAMES.ORIGINATOR, ORIGINATOR);
+  headers.set(HEADER_NAMES.USER_AGENT, USER_AGENT);
+  headers.set(HEADER_NAMES.ACCEPT, "text/event-stream");
+  if (!headers.has(HEADER_NAMES.CONTENT_TYPE)) {
+    headers.set(HEADER_NAMES.CONTENT_TYPE, "application/json");
+  }
+  const cacheKey = opts?.promptCacheKey;
+  if (cacheKey) {
+    headers.set(HEADER_NAMES.CONVERSATION_ID, cacheKey);
+    headers.set(HEADER_NAMES.SESSION_ID, cacheKey);
+  } else {
+    headers.delete(HEADER_NAMES.CONVERSATION_ID);
+    headers.delete(HEADER_NAMES.SESSION_ID);
+  }
+  return headers;
+}
+async function handleErrorResponse(response) {
+  logRequest("error-response", {
+    status: response.status,
+    statusText: response.statusText
+  });
+  return response;
+}
+async function handleSuccessResponse(response, isStreaming) {
+  const responseHeaders = ensureContentType(response.headers);
+  if (!isStreaming) {
+    return await convertSseToJson(response, responseHeaders);
+  }
+  return new Response(response.body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: responseHeaders
+  });
+}
+
+// index.ts
+var CODEX_MODEL_PREFIXES = ["gpt-", "codex"];
+var PACKAGE_NAME = "opencode-aicodewith-auth";
+var PROVIDER_NAME = "AICodewith";
+var PLUGIN_ENTRY = import.meta.url;
+var PROVIDER_NPM = new URL("./provider.ts", import.meta.url).href;
+var DEFAULT_API = "https://api.openai.com/v1";
+var DEFAULT_ENV = ["AICODEWITH_API_KEY"];
+var DEFAULT_OUTPUT_TOKEN_MAX = 32000;
+var ALLOWED_MODEL_IDS = [
+  "gpt-5.2-codex",
+  "gpt-5.2",
+  "claude-sonnet-4-5-20250929",
+  "claude-opus-4-5-20251101",
+  "gemini-3-pro-high"
+];
+var ALLOWED_MODEL_SET = new Set(ALLOWED_MODEL_IDS);
+var homeDir = process.env.OPENCODE_TEST_HOME || os.homedir();
+var configRoot = process.env.XDG_CONFIG_HOME || path.join(homeDir, ".config");
+var configDir = path.join(configRoot, "opencode");
+var configPath = path.join(configDir, "opencode.json");
+var ensureConfigPromise;
+var toModelMap = (ids, existing = {}) => ids.reduce((acc, id) => {
+  acc[id] = Object.prototype.hasOwnProperty.call(existing, id) ? existing[id] : {};
+  return acc;
+}, {});
+var readJson = async (filePath) => {
+  try {
+    const text = await readFile2(filePath, "utf-8");
+    return JSON.parse(text);
+  } catch {
+    return;
+  }
+};
+var isPackageEntry = (value) => value === PACKAGE_NAME || value.startsWith(`${PACKAGE_NAME}@`);
+var ensurePluginEntry = (list) => {
+  if (!Array.isArray(list))
+    return [PLUGIN_ENTRY];
+  const hasPlugin = list.some((entry) => typeof entry === "string" && (entry === PLUGIN_ENTRY || isPackageEntry(entry)));
+  return hasPlugin ? list : [...list, PLUGIN_ENTRY];
+};
+var applyProviderConfig = (config) => {
+  let changed = false;
+  const providerMap = config.provider && typeof config.provider === "object" ? config.provider : {};
+  const existing = providerMap[PROVIDER_ID] && typeof providerMap[PROVIDER_ID] === "object" ? providerMap[PROVIDER_ID] : {};
+  const existingModels = existing.models && typeof existing.models === "object" ? existing.models : {};
+  const next = { ...existing };
+  if (!next.name) {
+    next.name = PROVIDER_NAME;
+    changed = true;
+  }
+  if (!Array.isArray(next.env)) {
+    next.env = DEFAULT_ENV;
+    changed = true;
+  }
+  if (!next.npm || typeof next.npm === "string" && isPackageEntry(next.npm)) {
+    next.npm = PROVIDER_NPM;
+    changed = true;
+  }
+  if (!next.api) {
+    next.api = DEFAULT_API;
+    changed = true;
+  }
+  const hasExtraModels = Object.keys(existingModels).some((id) => !ALLOWED_MODEL_SET.has(id));
+  const hasMissingModels = ALLOWED_MODEL_IDS.some((id) => !Object.prototype.hasOwnProperty.call(existingModels, id));
+  if (!next.models || hasExtraModels || hasMissingModels) {
+    next.models = toModelMap(ALLOWED_MODEL_IDS, existingModels);
+    changed = true;
+  }
+  providerMap[PROVIDER_ID] = next;
+  if (config.provider !== providerMap) {
+    config.provider = providerMap;
+    changed = true;
+  }
+  const nextPlugins = ensurePluginEntry(config.plugin);
+  if (nextPlugins !== config.plugin) {
+    config.plugin = nextPlugins;
+    changed = true;
+  }
+  return changed;
+};
+var ensureConfigFile = async () => {
+  if (ensureConfigPromise)
+    return ensureConfigPromise;
+  ensureConfigPromise = (async () => {
+    const config = await readJson(configPath) ?? {};
+    if (!config || typeof config !== "object")
+      return;
+    const changed = applyProviderConfig(config);
+    if (!changed)
+      return;
+    await mkdir2(configDir, { recursive: true });
+    await writeFile2(configPath, `${JSON.stringify(config, null, 2)}
+`, "utf-8");
+  })();
+  return ensureConfigPromise;
+};
+var isPluginInput = (input) => {
+  if (!input || typeof input !== "object")
+    return false;
+  return "client" in input && "project" in input && "directory" in input;
+};
+function createAicodewith2(input) {
+  if (isPluginInput(input))
+    return {};
+  return createAicodewith(input);
+}
+var parseRequestBody = (init) => {
+  if (!init?.body || typeof init.body !== "string") {
+    return { body: undefined, model: undefined, isStreaming: false };
+  }
+  try {
+    const body = JSON.parse(init.body);
+    const model = typeof body?.model === "string" ? body.model : undefined;
+    return { body, model, isStreaming: body?.stream === true };
+  } catch {
+    return { body: undefined, model: undefined, isStreaming: false };
+  }
+};
+var isGeminiUrl = (url) => url.includes(":generateContent") || url.includes(":streamGenerateContent") || url.includes("/models/") && url.includes("/v1");
+var isClaudeUrl = (url) => url.includes("/v1/messages");
+var isModel = (model, prefix) => Boolean(model && model.startsWith(prefix));
+var isCodexModel = (model) => Boolean(model && CODEX_MODEL_PREFIXES.some((prefix) => model.startsWith(prefix)));
+var rewriteUrl = (originalUrl, baseUrl) => {
+  const base = new URL(baseUrl);
+  const original = new URL(originalUrl);
+  const basePath = base.pathname.replace(/\/$/, "");
+  const normalizedBase = `${base.origin}${basePath}`;
+  const normalizedOriginal = `${original.origin}${original.pathname}`;
+  if (normalizedOriginal.startsWith(normalizedBase)) {
+    return original.toString();
+  }
+  const rewritten = new URL(original.toString());
+  rewritten.protocol = base.protocol;
+  rewritten.host = base.host;
+  rewritten.pathname = `${basePath}${original.pathname}`;
+  return rewritten.toString();
+};
+var ensureGeminiSseParam = (url) => {
+  const parsed = new URL(url);
+  const alt = parsed.searchParams.get("alt");
+  if (alt === "sse")
+    return url;
+  parsed.searchParams.set("alt", "sse");
+  return parsed.toString();
+};
+var buildGeminiUrl = (originalUrl, streaming) => {
+  const original = new URL(originalUrl);
+  let path2 = original.pathname;
+  if (!path2.includes("/v1beta/") && !path2.includes("/v1/")) {
+    path2 = `/v1beta${path2.startsWith("/") ? "" : "/"}${path2}`;
+  }
+  const base = new URL(AICODEWITH_GEMINI_BASE_URL);
+  const basePath = base.pathname.replace(/\/$/, "");
+  const target = new URL(base.origin);
+  target.pathname = `${basePath}${path2}`;
+  target.search = original.search;
+  const url = target.toString();
+  return streaming ? ensureGeminiSseParam(url) : url;
+};
+var createGeminiHeaders = (init, apiKey) => {
+  const headers = new Headers(init?.headers ?? {});
+  headers.delete(HEADER_NAMES.AUTHORIZATION);
+  headers.delete("x-api-key");
+  headers.set(HEADER_NAMES.USER_AGENT, GEMINI_USER_AGENT);
+  headers.set(HEADER_NAMES.X_GOOG_API_CLIENT, GEMINI_API_CLIENT);
+  headers.set(HEADER_NAMES.X_GOOG_API_KEY, apiKey);
+  if (!headers.has(HEADER_NAMES.ACCEPT)) {
+    headers.set(HEADER_NAMES.ACCEPT, "*/*");
+  }
+  if (!headers.has(HEADER_NAMES.CONTENT_TYPE)) {
+    headers.set(HEADER_NAMES.CONTENT_TYPE, "application/json");
+  }
+  const userId = process.env[GEMINI_PRIVILEGED_USER_ID_ENV];
+  if (userId && !headers.has(HEADER_NAMES.X_GEMINI_PRIVILEGED_USER_ID)) {
+    headers.set(HEADER_NAMES.X_GEMINI_PRIVILEGED_USER_ID, userId);
+  }
+  return headers;
+};
+var getOutputTokenLimit = (input, output) => {
+  const modelLimit = input.model.limit.output;
+  if (typeof modelLimit === "number" && modelLimit > 0) {
+    return modelLimit;
+  }
+  const optionLimit = output.options?.maxTokens;
+  if (typeof optionLimit === "number" && optionLimit > 0) {
+    return optionLimit;
+  }
+  return DEFAULT_OUTPUT_TOKEN_MAX;
+};
+var AicodewithCodexAuthPlugin = async (_ctx) => {
+  await ensureConfigFile().catch((error) => {
+    console.warn(`[${PACKAGE_NAME}] Failed to update opencode config: ${error instanceof Error ? error.message : error}`);
+  });
+  const authHook = {
+    provider: PROVIDER_ID,
+    loader: async (getAuth, _provider) => {
+      const auth = await getAuth();
+      if (auth.type !== "api" || !auth.key) {
+        return {};
+      }
+      const apiKey = auth.key.trim();
+      if (!apiKey)
+        return {};
+      return {
+        apiKey,
+        fetch: async (input, init) => {
+          const originalUrl = extractRequestUrl(input);
+          const { model, isStreaming } = parseRequestBody(init);
+          const isClaudeRequest = isModel(model, "claude-") || isClaudeUrl(originalUrl);
+          const isGeminiRequest = isModel(model, "gemini-") || isGeminiUrl(originalUrl);
+          const isGeminiStreaming = isGeminiRequest && (isStreaming || originalUrl.includes("streamGenerateContent"));
+          const isCodexRequest = !isClaudeRequest && !isGeminiRequest && isCodexModel(model);
+          if (isCodexRequest) {
+            const transformation = await transformRequestForCodex(init);
+            const requestInit = transformation?.updatedInit ?? init;
+            const headers = createAicodewithHeaders(requestInit, apiKey, {
+              promptCacheKey: transformation?.body.prompt_cache_key
+            });
+            const targetUrl = rewriteUrl(originalUrl, CODEX_BASE_URL);
+            const response = await fetch(targetUrl, {
+              ...requestInit,
+              headers
+            });
+            if (!response.ok) {
+              return await handleErrorResponse(response);
+            }
+            return await handleSuccessResponse(response, isStreaming);
+          }
+          if (isGeminiRequest) {
+            const geminiUrl = buildGeminiUrl(originalUrl, isGeminiStreaming);
+            const headers = createGeminiHeaders(init, apiKey);
+            const requestInit = { ...init, headers };
+            return await fetch(geminiUrl, requestInit);
+          }
+          if (isClaudeRequest) {
+            const targetUrl = rewriteUrl(originalUrl, AICODEWITH_ANTHROPIC_BASE_URL);
+            return await fetch(targetUrl, init);
+          }
+          return await fetch(originalUrl, init);
+        }
+      };
+    },
+    methods: [
+      {
+        type: "api",
+        label: AUTH_METHOD_LABEL,
+        prompts: [
+          {
+            type: "text",
+            key: "apiKey",
+            message: "AICodewith API key",
+            placeholder: "sk-..."
+          }
+        ],
+        authorize: async (inputs) => {
+          const key = inputs?.apiKey?.trim();
+          if (!key)
+            return { type: "failed" };
+          return { type: "success", key };
+        }
+      }
+    ]
+  };
+  return {
+    auth: authHook,
+    config: async (config) => {
+      applyProviderConfig(config);
+    },
+    "chat.params": async (input, output) => {
+      if (input.model.providerID !== PROVIDER_ID)
+        return;
+      if (!input.model.id?.startsWith("claude-"))
+        return;
+      const thinking = output.options?.thinking;
+      if (!thinking || typeof thinking !== "object")
+        return;
+      const budgetTokens = thinking.budgetTokens;
+      if (typeof budgetTokens !== "number")
+        return;
+      const maxTokens = getOutputTokenLimit(input, output);
+      if (budgetTokens < maxTokens)
+        return;
+      const next = { ...output.options };
+      delete next.thinking;
+      output.options = next;
+    }
+  };
+};
+var opencode_aicodewith_auth_default = AicodewithCodexAuthPlugin;
+export {
+  opencode_aicodewith_auth_default as default,
+  createAicodewith2 as createAicodewith,
+  AicodewithCodexAuthPlugin
+};