@levelcode/sdk 0.0.1 → 0.0.3

package/dist/index.cjs

@@ -13109,6 +13109,7 @@ __export(exports_src, {
   loadMCPConfigSync: () => loadMCPConfigSync,
   loadMCPConfig: () => loadMCPConfig,
   loadLocalAgents: () => loadLocalAgents,
+  isStandaloneMode: () => isStandaloneMode,
   isRetryableStatusCode: () => isRetryableStatusCode,
   isKnowledgeFile: () => isKnowledgeFile,
   isClaudeOAuthValid: () => isClaudeOAuthValid,
@@ -13116,6 +13117,7 @@ __export(exports_src, {
   getValidClaudeOAuthCredentials: () => getValidClaudeOAuthCredentials,
   getUserInfoFromApiKey: () => getUserInfoFromApiKey,
   getUserCredentials: () => getUserCredentials,
+  getOpenRouterApiKeyFromEnv: () => getOpenRouterApiKeyFromEnv,
   getFiles: () => getFiles,
   getFileTokenScores: () => getFileTokenScores,
   getErrorStatusCode: () => getErrorStatusCode,
@@ -13159,15 +13161,15 @@ var import_path12 = __toESM(require("path"));
 // ../common/src/env-schema.ts
 var import_v4 = __toESM(require("zod/v4"));
 var clientEnvSchema = import_v4.default.object({
-  NEXT_PUBLIC_CB_ENVIRONMENT: import_v4.default.enum(["dev", "test", "prod"]),
-  NEXT_PUBLIC_LEVELCODE_APP_URL: import_v4.default.url().min(1),
-  NEXT_PUBLIC_SUPPORT_EMAIL: import_v4.default.email().min(1),
-  NEXT_PUBLIC_POSTHOG_API_KEY: import_v4.default.string().min(1),
-  NEXT_PUBLIC_POSTHOG_HOST_URL: import_v4.default.url().min(1),
-  NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY: import_v4.default.string().min(1),
-  NEXT_PUBLIC_STRIPE_CUSTOMER_PORTAL: import_v4.default.url().min(1),
+  NEXT_PUBLIC_CB_ENVIRONMENT: import_v4.default.enum(["dev", "test", "prod"]).default("prod"),
+  NEXT_PUBLIC_LEVELCODE_APP_URL: import_v4.default.string().default(""),
+  NEXT_PUBLIC_SUPPORT_EMAIL: import_v4.default.string().default("support@levelcode.ai"),
+  NEXT_PUBLIC_POSTHOG_API_KEY: import_v4.default.string().default(""),
+  NEXT_PUBLIC_POSTHOG_HOST_URL: import_v4.default.string().default("https://app.posthog.com"),
+  NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY: import_v4.default.string().default(""),
+  NEXT_PUBLIC_STRIPE_CUSTOMER_PORTAL: import_v4.default.string().default("https://billing.stripe.com"),
   NEXT_PUBLIC_GOOGLE_SITE_VERIFICATION_ID: import_v4.default.string().optional(),
-  NEXT_PUBLIC_WEB_PORT: import_v4.default.coerce.number().min(1000)
+  NEXT_PUBLIC_WEB_PORT: import_v4.default.coerce.number().default(3000)
 });
 var clientEnvVars = clientEnvSchema.keyof().options;
 var clientProcessEnv = {
@@ -13184,10 +13186,18 @@ var clientProcessEnv = {
 
 // ../common/src/env.ts
 var parsedEnv = clientEnvSchema.safeParse(clientProcessEnv);
-if (!parsedEnv.success) {
-  throw parsedEnv.error;
-}
-var env = parsedEnv.data;
+var fallbackEnv = {
+  NEXT_PUBLIC_CB_ENVIRONMENT: "prod",
+  NEXT_PUBLIC_LEVELCODE_APP_URL: "",
+  NEXT_PUBLIC_SUPPORT_EMAIL: "support@levelcode.ai",
+  NEXT_PUBLIC_POSTHOG_API_KEY: "",
+  NEXT_PUBLIC_POSTHOG_HOST_URL: "https://app.posthog.com",
+  NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY: "",
+  NEXT_PUBLIC_STRIPE_CUSTOMER_PORTAL: "https://billing.stripe.com",
+  NEXT_PUBLIC_GOOGLE_SITE_VERIFICATION_ID: undefined,
+  NEXT_PUBLIC_WEB_PORT: 3000
+};
+var env = parsedEnv.success ? parsedEnv.data : fallbackEnv;
 if (env.NEXT_PUBLIC_CB_ENVIRONMENT !== "prod") {
   console.log("Using environment:", env.NEXT_PUBLIC_CB_ENVIRONMENT);
 }
@@ -35220,7 +35230,152 @@ var import_v461 = __toESM(require("zod/v4"));
 
 // src/constants.ts
 var LEVELCODE_BINARY = "levelcode";
-var WEBSITE_URL = env.NEXT_PUBLIC_LEVELCODE_APP_URL;
+var WEBSITE_URL = env.NEXT_PUBLIC_LEVELCODE_APP_URL || "";
+
+// ../common/src/constants/byok.ts
+var BYOK_OPENROUTER_HEADER = "x-openrouter-api-key";
+var BYOK_OPENROUTER_ENV_VAR = "LEVELCODE_BYOK_OPENROUTER";
+
+// ../common/src/constants/claude-oauth.ts
+var CLAUDE_OAUTH_CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
+var CLAUDE_OAUTH_TOKEN_ENV_VAR = "LEVELCODE_CLAUDE_OAUTH_TOKEN";
+var CLAUDE_OAUTH_BETA_HEADERS = [
+  "oauth-2025-04-20",
+  "claude-code-20250219",
+  "interleaved-thinking-2025-05-14",
+  "fine-grained-tool-streaming-2025-05-14"
+];
+var CLAUDE_CODE_SYSTEM_PROMPT_PREFIX = "You are Claude Code, Anthropic's official CLI for Claude.";
+var OPENROUTER_TO_ANTHROPIC_MODEL_MAP = {
+  "anthropic/claude-3.5-haiku-20241022": "claude-3-5-haiku-20241022",
+  "anthropic/claude-3.5-haiku": "claude-3-5-haiku-20241022",
+  "anthropic/claude-3-5-haiku": "claude-3-5-haiku-20241022",
+  "anthropic/claude-3-5-haiku-20241022": "claude-3-5-haiku-20241022",
+  "anthropic/claude-3-haiku": "claude-3-haiku-20240307",
+  "anthropic/claude-3.5-sonnet": "claude-3-5-sonnet-20241022",
+  "anthropic/claude-3-5-sonnet": "claude-3-5-sonnet-20241022",
+  "anthropic/claude-3-5-sonnet-20241022": "claude-3-5-sonnet-20241022",
+  "anthropic/claude-3-5-sonnet-20240620": "claude-3-5-sonnet-20240620",
+  "anthropic/claude-3-sonnet": "claude-3-sonnet-20240229",
+  "anthropic/claude-3-opus": "claude-3-opus-20240229",
+  "anthropic/claude-3-opus-20240229": "claude-3-opus-20240229",
+  "anthropic/claude-haiku-4.5": "claude-haiku-4-5-20251001",
+  "anthropic/claude-haiku-4": "claude-haiku-4-20250514",
+  "anthropic/claude-sonnet-4.5": "claude-sonnet-4-5-20250929",
+  "anthropic/claude-sonnet-4": "claude-sonnet-4-20250514",
+  "anthropic/claude-4-sonnet-20250522": "claude-sonnet-4-20250514",
+  "anthropic/claude-4-sonnet": "claude-sonnet-4-20250514",
+  "anthropic/claude-opus-4.5": "claude-opus-4-5-20251101",
+  "anthropic/claude-opus-4.1": "claude-opus-4-1-20250805",
+  "anthropic/claude-opus-4": "claude-opus-4-1-20250805"
+};
+function isClaudeModel(model) {
+  return model.startsWith("anthropic/") || model.startsWith("claude-");
+}
+function toAnthropicModelId(openrouterModel) {
+  if (!openrouterModel.includes("/")) {
+    return openrouterModel;
+  }
+  if (!openrouterModel.startsWith("anthropic/")) {
+    throw new Error(`Cannot convert non-Anthropic model to Anthropic model ID: ${openrouterModel}`);
+  }
+  const mapped = OPENROUTER_TO_ANTHROPIC_MODEL_MAP[openrouterModel];
+  if (mapped) {
+    return mapped;
+  }
+  return openrouterModel.replace("anthropic/", "");
+}
+
+// src/env.ts
+init_paths();
+
+// ../common/src/env-process.ts
+var getBaseEnv = () => ({
+  SHELL: process.env.SHELL,
+  COMSPEC: process.env.COMSPEC,
+  HOME: process.env.HOME,
+  USERPROFILE: process.env.USERPROFILE,
+  APPDATA: process.env.APPDATA,
+  XDG_CONFIG_HOME: process.env.XDG_CONFIG_HOME,
+  TERM: process.env.TERM,
+  TERM_PROGRAM: process.env.TERM_PROGRAM,
+  TERM_BACKGROUND: process.env.TERM_BACKGROUND,
+  TERMINAL_EMULATOR: process.env.TERMINAL_EMULATOR,
+  COLORFGBG: process.env.COLORFGBG,
+  NODE_ENV: "development",
+  NODE_PATH: process.env.NODE_PATH,
+  PATH: process.env.PATH
+});
+var getProcessEnv = () => ({
+  ...getBaseEnv(),
+  KITTY_WINDOW_ID: process.env.KITTY_WINDOW_ID,
+  SIXEL_SUPPORT: process.env.SIXEL_SUPPORT,
+  ZED_NODE_ENV: process.env.ZED_NODE_ENV,
+  VSCODE_THEME_KIND: process.env.VSCODE_THEME_KIND,
+  VSCODE_COLOR_THEME_KIND: process.env.VSCODE_COLOR_THEME_KIND,
+  VSCODE_GIT_IPC_HANDLE: process.env.VSCODE_GIT_IPC_HANDLE,
+  VSCODE_PID: process.env.VSCODE_PID,
+  VSCODE_CWD: process.env.VSCODE_CWD,
+  VSCODE_NLS_CONFIG: process.env.VSCODE_NLS_CONFIG,
+  CURSOR_PORT: process.env.CURSOR_PORT,
+  CURSOR: process.env.CURSOR,
+  JETBRAINS_REMOTE_RUN: process.env.JETBRAINS_REMOTE_RUN,
+  IDEA_INITIAL_DIRECTORY: process.env.IDEA_INITIAL_DIRECTORY,
+  IDE_CONFIG_DIR: process.env.IDE_CONFIG_DIR,
+  JB_IDE_CONFIG_DIR: process.env.JB_IDE_CONFIG_DIR,
+  VISUAL: process.env.VISUAL,
+  EDITOR: process.env.EDITOR,
+  LEVELCODE_CLI_EDITOR: process.env.LEVELCODE_CLI_EDITOR,
+  LEVELCODE_EDITOR: process.env.LEVELCODE_EDITOR,
+  OPEN_TUI_THEME: process.env.OPEN_TUI_THEME,
+  OPENTUI_THEME: process.env.OPENTUI_THEME,
+  LEVELCODE_IS_BINARY: process.env.LEVELCODE_IS_BINARY,
+  LEVELCODE_CLI_VERSION: process.env.LEVELCODE_CLI_VERSION,
+  LEVELCODE_CLI_TARGET: process.env.LEVELCODE_CLI_TARGET,
+  LEVELCODE_RG_PATH: process.env.LEVELCODE_RG_PATH,
+  LEVELCODE_WASM_DIR: process.env.LEVELCODE_WASM_DIR,
+  VERBOSE: process.env.VERBOSE,
+  OVERRIDE_TARGET: process.env.OVERRIDE_TARGET,
+  OVERRIDE_PLATFORM: process.env.OVERRIDE_PLATFORM,
+  OVERRIDE_ARCH: process.env.OVERRIDE_ARCH
+});
+var processEnv = getProcessEnv();
+
+// src/env.ts
+var getSdkEnv = () => ({
+  ...getBaseEnv(),
+  LEVELCODE_RG_PATH: process.env.LEVELCODE_RG_PATH,
+  LEVELCODE_WASM_DIR: process.env.LEVELCODE_WASM_DIR,
+  VERBOSE: process.env.VERBOSE,
+  OVERRIDE_TARGET: process.env.OVERRIDE_TARGET,
+  OVERRIDE_PLATFORM: process.env.OVERRIDE_PLATFORM,
+  OVERRIDE_ARCH: process.env.OVERRIDE_ARCH
+});
+var getLevelCodeApiKeyFromEnv = () => {
+  return process.env[API_KEY_ENV_VAR];
+};
+var getSystemProcessEnv = () => {
+  return process.env;
+};
+var getByokOpenrouterApiKeyFromEnv = () => {
+  return process.env[BYOK_OPENROUTER_ENV_VAR];
+};
+var getClaudeOAuthTokenFromEnv = () => {
+  return process.env[CLAUDE_OAUTH_TOKEN_ENV_VAR];
+};
+var getOpenRouterApiKeyFromEnv = () => {
+  return process.env.OPENROUTER_API_KEY;
+};
+var getAnthropicApiKeyFromEnv = () => {
+  return process.env.ANTHROPIC_API_KEY;
+};
+var isStandaloneMode = () => {
+  const appUrl = process.env.NEXT_PUBLIC_LEVELCODE_APP_URL;
+  if (!appUrl)
+    return true;
+  const hasDirectKey = !!getOpenRouterApiKeyFromEnv() || !!getAnthropicApiKeyFromEnv();
+  return hasDirectKey && !getLevelCodeApiKeyFromEnv();
+};
 
 // src/retry-config.ts
 var MAX_RETRIES_PER_MESSAGE = 3;
@@ -35263,6 +35418,10 @@ async function fetchWithRetry(url, options, logger2) {
   throw lastError ?? new Error("Request failed after retries");
 }
 async function getUserInfoFromApiKey(params2) {
+  if (isStandaloneMode()) {
+    const standaloneUser = { id: "standalone-user", email: "standalone@local" };
+    return Object.fromEntries(params2.fields.map((field) => [field, standaloneUser[field] ?? null]));
+  }
   const { apiKey, fields, logger: logger2 } = params2;
   const cached = userInfoCache[apiKey];
   if (cached === null) {
@@ -35325,6 +35484,9 @@ async function getUserInfoFromApiKey(params2) {
   return Object.fromEntries(fields.map((field) => [field, userInfo[field]]));
 }
 async function fetchAgentFromDatabase(params2) {
+  if (isStandaloneMode()) {
+    return null;
+  }
   const { apiKey, parsedAgentId, logger: logger2 } = params2;
   const { publisherId, agentId, version: version2 } = parsedAgentId;
   const url = new URL(`/api/v1/agents/${publisherId}/${agentId}/${version2 ? version2 : "latest"}`, WEBSITE_URL);
@@ -35378,6 +35540,9 @@ async function fetchAgentFromDatabase(params2) {
   }
 }
 async function startAgentRun(params2) {
+  if (isStandaloneMode()) {
+    return crypto.randomUUID();
+  }
   const { apiKey, agentId, ancestorRunIds, logger: logger2 } = params2;
   const url = new URL(`/api/v1/agent-runs`, WEBSITE_URL);
   try {
@@ -35407,6 +35572,9 @@ async function startAgentRun(params2) {
   }
 }
 async function finishAgentRun(params2) {
+  if (isStandaloneMode()) {
+    return;
+  }
   const {
     apiKey,
     runId,
@@ -35441,6 +35609,9 @@ async function finishAgentRun(params2) {
   }
 }
 async function addAgentStep2(params2) {
+  if (isStandaloneMode()) {
+    return crypto.randomUUID();
+  }
   const {
     apiKey,
     agentRunId,
@@ -35553,60 +35724,6 @@ var import_ai3 = require("ai");
 var import_path5 = __toESM(require("path"));
 var import_anthropic = require("@ai-sdk/anthropic");
 
-// ../common/src/constants/byok.ts
-var BYOK_OPENROUTER_HEADER = "x-openrouter-api-key";
-var BYOK_OPENROUTER_ENV_VAR = "LEVELCODE_BYOK_OPENROUTER";
-
-// ../common/src/constants/claude-oauth.ts
-var CLAUDE_OAUTH_CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
-var CLAUDE_OAUTH_TOKEN_ENV_VAR = "LEVELCODE_CLAUDE_OAUTH_TOKEN";
-var CLAUDE_OAUTH_BETA_HEADERS = [
-  "oauth-2025-04-20",
-  "claude-code-20250219",
-  "interleaved-thinking-2025-05-14",
-  "fine-grained-tool-streaming-2025-05-14"
-];
-var CLAUDE_CODE_SYSTEM_PROMPT_PREFIX = "You are Claude Code, Anthropic's official CLI for Claude.";
-var OPENROUTER_TO_ANTHROPIC_MODEL_MAP = {
-  "anthropic/claude-3.5-haiku-20241022": "claude-3-5-haiku-20241022",
-  "anthropic/claude-3.5-haiku": "claude-3-5-haiku-20241022",
-  "anthropic/claude-3-5-haiku": "claude-3-5-haiku-20241022",
-  "anthropic/claude-3-5-haiku-20241022": "claude-3-5-haiku-20241022",
-  "anthropic/claude-3-haiku": "claude-3-haiku-20240307",
-  "anthropic/claude-3.5-sonnet": "claude-3-5-sonnet-20241022",
-  "anthropic/claude-3-5-sonnet": "claude-3-5-sonnet-20241022",
-  "anthropic/claude-3-5-sonnet-20241022": "claude-3-5-sonnet-20241022",
-  "anthropic/claude-3-5-sonnet-20240620": "claude-3-5-sonnet-20240620",
-  "anthropic/claude-3-sonnet": "claude-3-sonnet-20240229",
-  "anthropic/claude-3-opus": "claude-3-opus-20240229",
-  "anthropic/claude-3-opus-20240229": "claude-3-opus-20240229",
-  "anthropic/claude-haiku-4.5": "claude-haiku-4-5-20251001",
-  "anthropic/claude-haiku-4": "claude-haiku-4-20250514",
-  "anthropic/claude-sonnet-4.5": "claude-sonnet-4-5-20250929",
-  "anthropic/claude-sonnet-4": "claude-sonnet-4-20250514",
-  "anthropic/claude-4-sonnet-20250522": "claude-sonnet-4-20250514",
-  "anthropic/claude-4-sonnet": "claude-sonnet-4-20250514",
-  "anthropic/claude-opus-4.5": "claude-opus-4-5-20251101",
-  "anthropic/claude-opus-4.1": "claude-opus-4-1-20250805",
-  "anthropic/claude-opus-4": "claude-opus-4-1-20250805"
-};
-function isClaudeModel(model) {
-  return model.startsWith("anthropic/") || model.startsWith("claude-");
-}
-function toAnthropicModelId(openrouterModel) {
-  if (!openrouterModel.includes("/")) {
-    return openrouterModel;
-  }
-  if (!openrouterModel.startsWith("anthropic/")) {
-    throw new Error(`Cannot convert non-Anthropic model to Anthropic model ID: ${openrouterModel}`);
-  }
-  const mapped = OPENROUTER_TO_ANTHROPIC_MODEL_MAP[openrouterModel];
-  if (mapped) {
-    return mapped;
-  }
-  return openrouterModel.replace("anthropic/", "");
-}
-
 // ../node_modules/@ai-sdk/provider/dist/index.mjs
 var marker = "vercel.ai.error";
 var symbol = Symbol.for(marker);
@@ -36005,6 +36122,38 @@ function withUserAgentSuffix(headers, ...userAgentSuffixParts) {
   return Object.fromEntries(normalizedHeaders.entries());
 }
 var VERSION = "3.0.20";
+function loadApiKey({
+  apiKey,
+  environmentVariableName,
+  apiKeyParameterName = "apiKey",
+  description: description31
+}) {
+  if (typeof apiKey === "string") {
+    return apiKey;
+  }
+  if (apiKey != null) {
+    throw new LoadAPIKeyError({
+      message: `${description31} API key must be a string.`
+    });
+  }
+  if (typeof process === "undefined") {
+    throw new LoadAPIKeyError({
+      message: `${description31} API key is missing. Pass it using the '${apiKeyParameterName}' parameter. Environment variables is not supported in this environment.`
+    });
+  }
+  apiKey = process.env[environmentVariableName];
+  if (apiKey == null) {
+    throw new LoadAPIKeyError({
+      message: `${description31} API key is missing. Pass it using the '${apiKeyParameterName}' parameter or the ${environmentVariableName} environment variable.`
+    });
+  }
+  if (typeof apiKey !== "string") {
+    throw new LoadAPIKeyError({
+      message: `${description31} API key must be a string. The value of the ${environmentVariableName} environment variable is not a string.`
+    });
+  }
+  return apiKey;
+}
 var suspectProtoRx = /"__proto__"\s*:/;
 var suspectConstructorRx = /"constructor"\s*:/;
 function _parse(text) {
@@ -36381,6 +36530,9 @@ function convertUint8ArrayToBase64(array) {
 function convertToBase64(value) {
   return value instanceof Uint8Array ? convertUint8ArrayToBase64(value) : value;
 }
+function withoutTrailingSlash(url) {
+  return url == null ? undefined : url.replace(/\/$/, "");
+}
 
 // ../packages/internal/src/openai-compatible/chat/openai-compatible-chat-language-model.ts
 var import_v464 = require("zod/v4");
@@ -37089,111 +37241,1395 @@ var createOpenAICompatibleChatChunkSchema = (errorSchema) => import_v464.z.union
 ]);
 // ../packages/internal/src/openai-compatible/version.ts
 var VERSION2 = typeof __PACKAGE_VERSION__ !== "undefined" ? __PACKAGE_VERSION__ : "0.0.0-test";
-// src/credentials.ts
-var import_fs = __toESM(require("fs"));
-var import_node_path = __toESM(require("node:path"));
-var import_os = __toESM(require("os"));
+// ../packages/internal/src/openrouter-ai-sdk/chat/is-url.ts
+function isUrl({
+  url,
+  protocols
+}) {
+  try {
+    const urlObj = new URL(url);
+    return protocols.has(urlObj.protocol);
+  } catch (_) {
+    return false;
+  }
+}
 
-// ../common/src/util/credentials.ts
+// ../packages/internal/src/openrouter-ai-sdk/chat/file-url-utils.ts
+function getFileUrl({
+  part,
+  defaultMediaType
+}) {
+  if (part.data instanceof Uint8Array) {
+    const base64 = convertUint8ArrayToBase64(part.data);
+    return `data:${part.mediaType ?? defaultMediaType};base64,${base64}`;
+  }
+  const stringUrl = part.data.toString();
+  if (isUrl({
+    url: stringUrl,
+    protocols: new Set(["http:", "https:"])
+  })) {
+    return stringUrl;
+  }
+  return stringUrl.startsWith("data:") ? stringUrl : `data:${part.mediaType ?? defaultMediaType};base64,${stringUrl}`;
+}
+
+// ../packages/internal/src/openrouter-ai-sdk/schemas/reasoning-details.ts
 var import_v465 = require("zod/v4");
-var userSchema = import_v465.z.object({
-  id: import_v465.z.string(),
-  email: import_v465.z.string(),
-  name: import_v465.z.string().nullable(),
-  authToken: import_v465.z.string(),
-  fingerprintId: import_v465.z.string(),
-  fingerprintHash: import_v465.z.string()
+var ReasoningDetailSummarySchema = import_v465.z.object({
+  type: import_v465.z.literal("reasoning.summary" /* Summary */),
+  summary: import_v465.z.string()
 });
-
-// src/credentials.ts
-var import_v466 = require("zod/v4");
-
-// src/env.ts
-init_paths();
-
-// ../common/src/env-process.ts
-var getBaseEnv = () => ({
-  SHELL: process.env.SHELL,
-  COMSPEC: process.env.COMSPEC,
-  HOME: process.env.HOME,
-  USERPROFILE: process.env.USERPROFILE,
-  APPDATA: process.env.APPDATA,
-  XDG_CONFIG_HOME: process.env.XDG_CONFIG_HOME,
-  TERM: process.env.TERM,
-  TERM_PROGRAM: process.env.TERM_PROGRAM,
-  TERM_BACKGROUND: process.env.TERM_BACKGROUND,
-  TERMINAL_EMULATOR: process.env.TERMINAL_EMULATOR,
-  COLORFGBG: process.env.COLORFGBG,
-  NODE_ENV: "development",
-  NODE_PATH: process.env.NODE_PATH,
-  PATH: process.env.PATH
+var ReasoningDetailEncryptedSchema = import_v465.z.object({
+  type: import_v465.z.literal("reasoning.encrypted" /* Encrypted */),
+  data: import_v465.z.string()
 });
-var getProcessEnv = () => ({
-  ...getBaseEnv(),
-  KITTY_WINDOW_ID: process.env.KITTY_WINDOW_ID,
-  SIXEL_SUPPORT: process.env.SIXEL_SUPPORT,
-  ZED_NODE_ENV: process.env.ZED_NODE_ENV,
-  VSCODE_THEME_KIND: process.env.VSCODE_THEME_KIND,
-  VSCODE_COLOR_THEME_KIND: process.env.VSCODE_COLOR_THEME_KIND,
-  VSCODE_GIT_IPC_HANDLE: process.env.VSCODE_GIT_IPC_HANDLE,
-  VSCODE_PID: process.env.VSCODE_PID,
-  VSCODE_CWD: process.env.VSCODE_CWD,
-  VSCODE_NLS_CONFIG: process.env.VSCODE_NLS_CONFIG,
-  CURSOR_PORT: process.env.CURSOR_PORT,
-  CURSOR: process.env.CURSOR,
-  JETBRAINS_REMOTE_RUN: process.env.JETBRAINS_REMOTE_RUN,
-  IDEA_INITIAL_DIRECTORY: process.env.IDEA_INITIAL_DIRECTORY,
-  IDE_CONFIG_DIR: process.env.IDE_CONFIG_DIR,
-  JB_IDE_CONFIG_DIR: process.env.JB_IDE_CONFIG_DIR,
-  VISUAL: process.env.VISUAL,
-  EDITOR: process.env.EDITOR,
-  LEVELCODE_CLI_EDITOR: process.env.LEVELCODE_CLI_EDITOR,
-  LEVELCODE_EDITOR: process.env.LEVELCODE_EDITOR,
-  OPEN_TUI_THEME: process.env.OPEN_TUI_THEME,
-  OPENTUI_THEME: process.env.OPENTUI_THEME,
-  LEVELCODE_IS_BINARY: process.env.LEVELCODE_IS_BINARY,
-  LEVELCODE_CLI_VERSION: process.env.LEVELCODE_CLI_VERSION,
-  LEVELCODE_CLI_TARGET: process.env.LEVELCODE_CLI_TARGET,
-  LEVELCODE_RG_PATH: process.env.LEVELCODE_RG_PATH,
-  LEVELCODE_WASM_DIR: process.env.LEVELCODE_WASM_DIR,
-  VERBOSE: process.env.VERBOSE,
-  OVERRIDE_TARGET: process.env.OVERRIDE_TARGET,
-  OVERRIDE_PLATFORM: process.env.OVERRIDE_PLATFORM,
-  OVERRIDE_ARCH: process.env.OVERRIDE_ARCH
+var ReasoningDetailTextSchema = import_v465.z.object({
+  type: import_v465.z.literal("reasoning.text" /* Text */),
+  text: import_v465.z.string().nullish(),
+  signature: import_v465.z.string().nullish()
+});
+var ReasoningDetailUnionSchema = import_v465.z.union([
+  ReasoningDetailSummarySchema,
+  ReasoningDetailEncryptedSchema,
+  ReasoningDetailTextSchema
+]);
+var ReasoningDetailsWithUnknownSchema = import_v465.z.union([
+  ReasoningDetailUnionSchema,
+  import_v465.z.unknown().transform(() => null)
+]);
+var ReasoningDetailArraySchema = import_v465.z.array(ReasoningDetailsWithUnknownSchema).transform((d) => d.filter((d2) => !!d2));
+
+// ../packages/internal/src/openrouter-ai-sdk/chat/convert-to-openrouter-chat-messages.ts
+function getCacheControl(providerMetadata) {
+  const anthropic = providerMetadata?.anthropic;
+  const openrouter = providerMetadata?.openrouter;
+  return openrouter?.cacheControl ?? openrouter?.cache_control ?? anthropic?.cacheControl ?? anthropic?.cache_control;
+}
+function convertToOpenRouterChatMessages(prompt2) {
+  const messages = [];
+  for (const { role, content, providerOptions } of prompt2) {
+    switch (role) {
+      case "system": {
+        messages.push({
+          role: "system",
+          content,
+          cache_control: getCacheControl(providerOptions)
+        });
+        break;
+      }
+      case "user": {
+        const messageCacheControl = getCacheControl(providerOptions);
+        const contentParts = content.map((part) => {
+          const cacheControl = getCacheControl(part.providerOptions) ?? messageCacheControl;
+          switch (part.type) {
+            case "text":
+              return {
+                type: "text",
+                text: part.text,
+                cache_control: cacheControl
+              };
+            case "file": {
+              if (part.mediaType?.startsWith("image/")) {
+                const url = getFileUrl({
+                  part,
+                  defaultMediaType: "image/jpeg"
+                });
+                return {
+                  type: "image_url",
+                  image_url: {
+                    url
+                  },
+                  cache_control: cacheControl
+                };
+              }
+              const fileName = String(part.providerOptions?.openrouter?.filename ?? part.filename ?? "");
+              const fileData = getFileUrl({
+                part,
+                defaultMediaType: "application/pdf"
+              });
+              if (isUrl({
+                url: fileData,
+                protocols: new Set(["http:", "https:"])
+              })) {
+                return {
+                  type: "file",
+                  file: {
+                    filename: fileName,
+                    file_data: fileData
+                  }
+                };
+              }
+              return {
+                type: "file",
+                file: {
+                  filename: fileName,
+                  file_data: fileData
+                },
+                cache_control: cacheControl
+              };
+            }
+            default: {
+              return {
+                type: "text",
+                text: "",
+                cache_control: cacheControl
+              };
+            }
+          }
+        });
+        messages.push({
+          role: "user",
+          content: contentParts
+        });
+        break;
+      }
+      case "assistant": {
+        let text = "";
+        let reasoning = "";
+        const reasoningDetails = [];
+        const toolCalls2 = [];
+        for (const part of content) {
+          switch (part.type) {
+            case "text": {
+              text += part.text;
+              break;
+            }
+            case "tool-call": {
+              toolCalls2.push({
+                id: part.toolCallId,
+                type: "function",
+                function: {
+                  name: part.toolName,
+                  arguments: JSON.stringify(part.input)
+                }
+              });
+              break;
+            }
+            case "reasoning": {
+              reasoning += part.text;
+              reasoningDetails.push({
+                type: "reasoning.text" /* Text */,
+                text: part.text
+              });
+              break;
+            }
+            case "file":
+              break;
+            default: {
+              break;
+            }
+          }
+        }
+        messages.push({
+          role: "assistant",
+          content: text,
+          tool_calls: toolCalls2.length > 0 ? toolCalls2 : undefined,
+          reasoning: reasoning || undefined,
+          reasoning_details: reasoningDetails.length > 0 ? reasoningDetails : undefined,
+          cache_control: getCacheControl(providerOptions)
+        });
+        break;
+      }
+      case "tool": {
+        for (const toolResponse of content) {
+          const content2 = getToolResultContent(toolResponse);
+          messages.push({
+            role: "tool",
+            tool_call_id: toolResponse.toolCallId,
+            content: content2,
+            cache_control: getCacheControl(providerOptions) ?? getCacheControl(toolResponse.providerOptions)
+          });
+        }
+        break;
+      }
+      default: {
+        break;
+      }
+    }
+  }
+  return messages;
+}
+function getToolResultContent(input) {
+  return input.output.type === "text" ? input.output.value : JSON.stringify(input.output.value);
+}
+
+// ../packages/internal/src/openrouter-ai-sdk/chat/get-tool-choice.ts
+var import_v466 = require("zod/v4");
+var ChatCompletionToolChoiceSchema = import_v466.z.union([
+  import_v466.z.literal("auto"),
+  import_v466.z.literal("none"),
+  import_v466.z.literal("required"),
+  import_v466.z.object({
+    type: import_v466.z.literal("function"),
+    function: import_v466.z.object({
+      name: import_v466.z.string()
+    })
+  })
+]);
+function getChatCompletionToolChoice(toolChoice) {
+  switch (toolChoice.type) {
+    case "auto":
+    case "none":
+    case "required":
+      return toolChoice.type;
+    case "tool": {
+      return {
+        type: "function",
+        function: { name: toolChoice.toolName }
+      };
+    }
+    default: {
+      throw new Error(`Invalid tool choice type: ${toolChoice}`);
+    }
+  }
+}
+
+// ../packages/internal/src/openrouter-ai-sdk/chat/schemas.ts
+var import_v468 = require("zod/v4");
+
+// ../packages/internal/src/openrouter-ai-sdk/schemas/error-response.ts
+var import_v467 = require("zod/v4");
+var OpenRouterErrorResponseSchema = import_v467.z.object({
+  error: import_v467.z.object({
+    code: import_v467.z.union([import_v467.z.string(), import_v467.z.number()]).nullable().optional().default(null),
+    message: import_v467.z.string(),
+    type: import_v467.z.string().nullable().optional().default(null),
+    param: import_v467.z.any().nullable().optional().default(null)
+  })
+});
+var openrouterFailedResponseHandler = createJsonErrorResponseHandler({
+  errorSchema: OpenRouterErrorResponseSchema,
+  errorToMessage: (data) => data.error.message
+});
+
+// ../packages/internal/src/openrouter-ai-sdk/chat/schemas.ts
+var OpenRouterChatCompletionBaseResponseSchema = import_v468.z.object({
+  id: import_v468.z.string().optional(),
+  model: import_v468.z.string().optional(),
+  provider: import_v468.z.string().optional(),
+  usage: import_v468.z.object({
+    prompt_tokens: import_v468.z.number(),
+    prompt_tokens_details: import_v468.z.object({
+      cached_tokens: import_v468.z.number()
+    }).nullish(),
+    completion_tokens: import_v468.z.number(),
+    completion_tokens_details: import_v468.z.object({
+      reasoning_tokens: import_v468.z.number()
+    }).nullish(),
+    total_tokens: import_v468.z.number(),
+    cost: import_v468.z.number().optional(),
+    cost_details: import_v468.z.object({
+      upstream_inference_cost: import_v468.z.number().nullish()
+    }).nullish()
+  }).nullish()
+});
+var OpenRouterNonStreamChatCompletionResponseSchema = OpenRouterChatCompletionBaseResponseSchema.extend({
+  choices: import_v468.z.array(import_v468.z.object({
+    message: import_v468.z.object({
+      role: import_v468.z.literal("assistant"),
+      content: import_v468.z.string().nullable().optional(),
+      reasoning: import_v468.z.string().nullable().optional(),
+      reasoning_details: ReasoningDetailArraySchema.nullish(),
+      tool_calls: import_v468.z.array(import_v468.z.object({
+        id: import_v468.z.string().optional().nullable(),
+        type: import_v468.z.literal("function"),
+        function: import_v468.z.object({
+          name: import_v468.z.string(),
+          arguments: import_v468.z.string()
+        })
+      })).optional(),
+      annotations: import_v468.z.array(import_v468.z.object({
+        type: import_v468.z.enum(["url_citation"]),
+        url_citation: import_v468.z.object({
+          end_index: import_v468.z.number(),
+          start_index: import_v468.z.number(),
+          title: import_v468.z.string(),
+          url: import_v468.z.string(),
+          content: import_v468.z.string().optional()
+        })
+      })).nullish()
+    }),
+    index: import_v468.z.number().nullish(),
+    logprobs: import_v468.z.object({
+      content: import_v468.z.array(import_v468.z.object({
+        token: import_v468.z.string(),
+        logprob: import_v468.z.number(),
+        top_logprobs: import_v468.z.array(import_v468.z.object({
+          token: import_v468.z.string(),
+          logprob: import_v468.z.number()
+        }))
+      })).nullable()
+    }).nullable().optional(),
+    finish_reason: import_v468.z.string().optional().nullable()
+  }))
+});
+var OpenRouterStreamChatCompletionChunkSchema = import_v468.z.union([
+  OpenRouterChatCompletionBaseResponseSchema.extend({
+    choices: import_v468.z.array(import_v468.z.object({
+      delta: import_v468.z.object({
+        role: import_v468.z.enum(["assistant"]).optional(),
+        content: import_v468.z.string().nullish(),
+        reasoning: import_v468.z.string().nullish().optional(),
+        reasoning_details: ReasoningDetailArraySchema.nullish(),
+        tool_calls: import_v468.z.array(import_v468.z.object({
+          index: import_v468.z.number().nullish(),
+          id: import_v468.z.string().nullish(),
+          type: import_v468.z.literal("function").optional(),
+          function: import_v468.z.object({
+            name: import_v468.z.string().nullish(),
+            arguments: import_v468.z.string().nullish()
+          })
+        })).nullish(),
+        annotations: import_v468.z.array(import_v468.z.object({
+          type: import_v468.z.enum(["url_citation"]),
+          url_citation: import_v468.z.object({
+            end_index: import_v468.z.number(),
+            start_index: import_v468.z.number(),
+            title: import_v468.z.string(),
+            url: import_v468.z.string(),
+            content: import_v468.z.string().optional()
+          })
+        })).nullish()
+      }).nullish(),
+      logprobs: import_v468.z.object({
+        content: import_v468.z.array(import_v468.z.object({
+          token: import_v468.z.string(),
+          logprob: import_v468.z.number(),
+          top_logprobs: import_v468.z.array(import_v468.z.object({
+            token: import_v468.z.string(),
+            logprob: import_v468.z.number()
+          }))
+        })).nullable()
+      }).nullish(),
+      finish_reason: import_v468.z.string().nullable().optional(),
+      index: import_v468.z.number().nullish()
+    }))
+  }),
+  OpenRouterErrorResponseSchema
+]);
+
+// ../packages/internal/src/openrouter-ai-sdk/utils/map-finish-reason.ts
+function mapOpenRouterFinishReason(finishReason) {
+  switch (finishReason) {
+    case "stop":
+      return "stop";
+    case "length":
+      return "length";
+    case "content_filter":
+      return "content-filter";
+    case "function_call":
+    case "tool_calls":
+      return "tool-calls";
+    default:
+      return "unknown";
+  }
+}
+
+// ../packages/internal/src/openrouter-ai-sdk/chat/index.ts
+class OpenRouterChatLanguageModel {
+  specificationVersion = "v2";
+  provider = "openrouter";
+  defaultObjectGenerationMode = "tool";
+  modelId;
+  supportedUrls = {
+    "image/*": [
+      /^data:image\/[a-zA-Z]+;base64,/,
+      /^https?:\/\/.+\.(jpg|jpeg|png|gif|webp)$/i
+    ],
+    "application/*": [/^data:application\//, /^https?:\/\/.+$/]
+  };
+  settings;
+  config;
+  constructor(modelId, settings, config) {
+    this.modelId = modelId;
+    this.settings = settings;
+    this.config = config;
+  }
+  getArgs({
+    prompt: prompt2,
+    maxOutputTokens,
+    temperature,
+    topP,
+    frequencyPenalty,
+    presencePenalty,
+    seed,
+    stopSequences,
+    responseFormat,
+    topK,
+    tools,
+    toolChoice
+  }) {
+    const baseArgs = {
+      model: this.modelId,
+      models: this.settings.models,
+      logit_bias: this.settings.logitBias,
+      logprobs: this.settings.logprobs === true || typeof this.settings.logprobs === "number" ? true : undefined,
+      top_logprobs: typeof this.settings.logprobs === "number" ? this.settings.logprobs : typeof this.settings.logprobs === "boolean" ? this.settings.logprobs ? 0 : undefined : undefined,
+      user: this.settings.user,
+      parallel_tool_calls: this.settings.parallelToolCalls,
+      max_tokens: maxOutputTokens,
+      temperature,
+      top_p: topP,
+      frequency_penalty: frequencyPenalty,
+      presence_penalty: presencePenalty,
+      seed,
+      ...this.modelId === "x-ai/grok-code-fast-1" ? {} : { stop: stopSequences },
+      response_format: responseFormat,
+      top_k: topK,
+      messages: convertToOpenRouterChatMessages(prompt2),
+      include_reasoning: this.settings.includeReasoning,
+      reasoning: this.settings.reasoning,
+      usage: this.settings.usage,
+      plugins: this.settings.plugins,
+      web_search_options: this.settings.web_search_options,
+      provider: this.settings.provider,
+      ...this.config.extraBody,
+      ...this.settings.extraBody
+    };
+    if (responseFormat?.type === "json" && responseFormat.schema != null) {
+      return {
+        ...baseArgs,
+        response_format: {
+          type: "json_schema",
+          json_schema: {
+            schema: responseFormat.schema,
+            strict: true,
+            name: responseFormat.name ?? "response",
+            ...responseFormat.description && {
+              description: responseFormat.description
+            }
+          }
+        }
+      };
+    }
+    if (tools && tools.length > 0) {
+      const mappedTools = tools.filter((tool) => tool.type === "function").map((tool) => ({
+        type: "function",
+        function: {
+          name: tool.name,
+          description: tool.description,
+          parameters: tool.inputSchema
+        }
+      }));
+      return {
+        ...baseArgs,
+        tools: mappedTools,
+        tool_choice: toolChoice ? getChatCompletionToolChoice(toolChoice) : undefined
+      };
+    }
+    return baseArgs;
+  }
+  async doGenerate(options) {
+    const providerOptions = options.providerOptions || {};
+    const openrouterOptions = providerOptions.openrouter || {};
+    const args = {
+      ...this.getArgs(options),
+      ...openrouterOptions
+    };
+    const { value: response, responseHeaders } = await postJsonToApi({
+      url: this.config.url({
+        path: "/chat/completions",
+        modelId: this.modelId
+      }),
+      headers: combineHeaders(this.config.headers(), options.headers),
+      body: args,
+      failedResponseHandler: openrouterFailedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler(OpenRouterNonStreamChatCompletionResponseSchema),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    const choice = response.choices[0];
+    if (!choice) {
+      throw new Error("No choice in response");
+    }
+    const usageInfo = response.usage ? {
+      inputTokens: response.usage.prompt_tokens ?? 0,
+      outputTokens: response.usage.completion_tokens ?? 0,
+      totalTokens: (response.usage.prompt_tokens ?? 0) + (response.usage.completion_tokens ?? 0),
+      reasoningTokens: response.usage.completion_tokens_details?.reasoning_tokens ?? 0,
+      cachedInputTokens: response.usage.prompt_tokens_details?.cached_tokens ?? 0
+    } : {
+      inputTokens: 0,
+      outputTokens: 0,
+      totalTokens: 0,
+      reasoningTokens: 0,
+      cachedInputTokens: 0
+    };
+    const reasoningDetails = choice.message.reasoning_details ?? [];
+    const reasoning = reasoningDetails.length > 0 ? reasoningDetails.map((detail) => {
+      switch (detail.type) {
+        case "reasoning.text" /* Text */: {
+          if (detail.text) {
+            return {
+              type: "reasoning",
+              text: detail.text
+            };
+          }
+          break;
+        }
+        case "reasoning.summary" /* Summary */: {
+          if (detail.summary) {
+            return {
+              type: "reasoning",
+              text: detail.summary
+            };
+          }
+          break;
+        }
+        case "reasoning.encrypted" /* Encrypted */: {
+          if (detail.data) {
+            return {
+              type: "reasoning",
+              text: "[REDACTED]"
+            };
+          }
+          break;
+        }
+        default: {}
+      }
+      return null;
+    }).filter((p) => p !== null) : choice.message.reasoning ? [
+      {
+        type: "reasoning",
+        text: choice.message.reasoning
+      }
+    ] : [];
+    const content = [];
+    content.push(...reasoning);
+    if (choice.message.content) {
+      content.push({
+        type: "text",
+        text: choice.message.content
+      });
+    }
+    if (choice.message.tool_calls) {
+      for (const toolCall of choice.message.tool_calls) {
+        content.push({
+          type: "tool-call",
+          toolCallId: toolCall.id ?? generateId(),
+          toolName: toolCall.function.name,
+          input: toolCall.function.arguments
+        });
+      }
+    }
+    if (choice.message.annotations) {
+      for (const annotation of choice.message.annotations) {
+        if (annotation.type === "url_citation") {
+          content.push({
+            type: "source",
+            sourceType: "url",
+            id: annotation.url_citation.url,
+            url: annotation.url_citation.url,
+            title: annotation.url_citation.title,
+            providerMetadata: {
+              openrouter: {
+                content: annotation.url_citation.content || ""
+              }
+            }
+          });
+        }
+      }
+    }
+    return {
+      content,
+      finishReason: mapOpenRouterFinishReason(choice.finish_reason),
+      usage: usageInfo,
+      warnings: [],
+      providerMetadata: {
+        openrouter: {
+          provider: response.provider ?? "",
+          usage: {
+            promptTokens: usageInfo.inputTokens ?? 0,
+            completionTokens: usageInfo.outputTokens ?? 0,
+            totalTokens: usageInfo.totalTokens ?? 0,
+            cost: response.usage?.cost,
+            promptTokensDetails: {
+              cachedTokens: response.usage?.prompt_tokens_details?.cached_tokens ?? 0
+            },
+            completionTokensDetails: {
+              reasoningTokens: response.usage?.completion_tokens_details?.reasoning_tokens ?? 0
+            },
+            costDetails: {
+              upstreamInferenceCost: response.usage?.cost_details?.upstream_inference_cost ?? 0
+            }
+          }
+        }
+      },
+      request: { body: args },
+      response: {
+        id: response.id,
+        modelId: response.model,
+        headers: responseHeaders
+      }
+    };
+  }
+  async doStream(options) {
+    const providerOptions = options.providerOptions || {};
+    const openrouterOptions = providerOptions.openrouter || {};
+    const args = {
+      ...this.getArgs(options),
+      ...openrouterOptions
+    };
+    const { value: response, responseHeaders } = await postJsonToApi({
+      url: this.config.url({
+        path: "/chat/completions",
+        modelId: this.modelId
+      }),
+      headers: combineHeaders(this.config.headers(), options.headers),
+      body: {
+        ...args,
+        stream: true,
+        stream_options: this.config.compatibility === "strict" ? {
+          include_usage: true,
+          ...this.settings.usage?.include ? { include_usage: true } : {}
+        } : undefined
+      },
+      failedResponseHandler: openrouterFailedResponseHandler,
+      successfulResponseHandler: createEventSourceResponseHandler(OpenRouterStreamChatCompletionChunkSchema),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    const toolCalls2 = [];
+    let finishReason = "other";
+    const usage = {
+      inputTokens: Number.NaN,
+      outputTokens: Number.NaN,
+      totalTokens: Number.NaN,
+      reasoningTokens: Number.NaN,
+      cachedInputTokens: Number.NaN
+    };
+    const openrouterUsage = {};
+    let textStarted = false;
+    let reasoningStarted = false;
+    let textId;
+    let reasoningId;
+    let openrouterResponseId;
+    let provider;
+    return {
+      stream: response.pipeThrough(new TransformStream({
+        transform(chunk, controller) {
+          if (!chunk.success) {
+            finishReason = "error";
+            controller.enqueue({ type: "error", error: chunk.error });
+            return;
+          }
+          const value = chunk.value;
+          if ("error" in value) {
+            finishReason = "error";
+            controller.enqueue({ type: "error", error: value.error });
+            return;
+          }
+          if (value.provider) {
+            provider = value.provider;
+          }
+          if (value.id) {
+            openrouterResponseId = value.id;
+            controller.enqueue({
+              type: "response-metadata",
+              id: value.id
+            });
+          }
+          if (value.model) {
+            controller.enqueue({
+              type: "response-metadata",
+              modelId: value.model
+            });
+          }
+          if (value.usage != null) {
+            usage.inputTokens = value.usage.prompt_tokens;
+            usage.outputTokens = value.usage.completion_tokens;
+            usage.totalTokens = value.usage.prompt_tokens + value.usage.completion_tokens;
+            openrouterUsage.promptTokens = value.usage.prompt_tokens;
+            if (value.usage.prompt_tokens_details) {
+              const cachedInputTokens = value.usage.prompt_tokens_details.cached_tokens ?? 0;
+              usage.cachedInputTokens = cachedInputTokens;
+              openrouterUsage.promptTokensDetails = {
+                cachedTokens: cachedInputTokens
+              };
+            }
+            openrouterUsage.completionTokens = value.usage.completion_tokens;
+            if (value.usage.completion_tokens_details) {
+              const reasoningTokens = value.usage.completion_tokens_details.reasoning_tokens ?? 0;
+              usage.reasoningTokens = reasoningTokens;
+              openrouterUsage.completionTokensDetails = {
+                reasoningTokens
+              };
+            }
+            const upstreamInferenceCost = value.usage.cost_details?.upstream_inference_cost;
+            if (upstreamInferenceCost != null && upstreamInferenceCost !== undefined) {
+              openrouterUsage.costDetails = {
+                upstreamInferenceCost
+              };
+            }
+            if (value.usage.cost !== undefined) {
+              openrouterUsage.cost = value.usage.cost;
+            }
+            openrouterUsage.totalTokens = value.usage.total_tokens;
+          }
+          const choice = value.choices[0];
+          if (choice?.finish_reason != null) {
+            finishReason = mapOpenRouterFinishReason(choice.finish_reason);
+          }
+          if (choice?.delta == null) {
+            return;
+          }
+          const delta = choice.delta;
+          const emitReasoningChunk = (chunkText) => {
+            if (!reasoningStarted) {
+              reasoningId = openrouterResponseId || generateId();
+              controller.enqueue({
+                type: "reasoning-start",
+                id: reasoningId
+              });
+              reasoningStarted = true;
+            }
+            controller.enqueue({
+              type: "reasoning-delta",
+              delta: chunkText,
+              id: reasoningId || generateId()
+            });
+          };
+          if (delta.reasoning_details && delta.reasoning_details.length > 0) {
+            for (const detail of delta.reasoning_details) {
+              switch (detail.type) {
+                case "reasoning.text" /* Text */: {
+                  if (detail.text) {
+                    emitReasoningChunk(detail.text);
+                  }
+                  break;
+                }
+                case "reasoning.encrypted" /* Encrypted */: {
+                  if (detail.data) {
+                    emitReasoningChunk("[REDACTED]");
+                  }
+                  break;
+                }
+                case "reasoning.summary" /* Summary */: {
+                  if (detail.summary) {
+                    emitReasoningChunk(detail.summary);
+                  }
+                  break;
+                }
+                default: {
+                  break;
+                }
+              }
+            }
+          } else if (delta.reasoning) {
+            emitReasoningChunk(delta.reasoning);
+          }
+          if (delta.content) {
+            if (reasoningStarted && !textStarted) {
+              controller.enqueue({
+                type: "reasoning-end",
+                id: reasoningId || generateId()
+              });
+              reasoningStarted = false;
+            }
+            if (!textStarted) {
+              textId = openrouterResponseId || generateId();
+              controller.enqueue({
+                type: "text-start",
+                id: textId
+              });
+              textStarted = true;
+            }
+            controller.enqueue({
+              type: "text-delta",
+              delta: delta.content,
+              id: textId || generateId()
+            });
+          }
+          if (delta.annotations) {
+            for (const annotation of delta.annotations) {
+              if (annotation.type === "url_citation") {
+                controller.enqueue({
+                  type: "source",
+                  sourceType: "url",
+                  id: annotation.url_citation.url,
+                  url: annotation.url_citation.url,
+                  title: annotation.url_citation.title,
+                  providerMetadata: {
+                    openrouter: {
+                      content: annotation.url_citation.content || ""
+                    }
+                  }
+                });
+              }
+            }
+          }
+          if (delta.tool_calls != null) {
+            for (const toolCallDelta of delta.tool_calls) {
+              const index = toolCallDelta.index ?? toolCalls2.length - 1;
+              if (toolCalls2[index] == null) {
+                if (toolCallDelta.type !== "function") {
+                  throw new InvalidResponseDataError({
+                    data: toolCallDelta,
+                    message: `Expected 'function' type.`
+                  });
+                }
+                if (toolCallDelta.id == null) {
+                  throw new InvalidResponseDataError({
+                    data: toolCallDelta,
+                    message: `Expected 'id' to be a string.`
+                  });
+                }
+                if (toolCallDelta.function?.name == null) {
+                  throw new InvalidResponseDataError({
+                    data: toolCallDelta,
+                    message: `Expected 'function.name' to be a string.`
+                  });
+                }
+                toolCalls2[index] = {
+                  id: toolCallDelta.id,
+                  type: "function",
+                  function: {
+                    name: toolCallDelta.function.name,
+                    arguments: toolCallDelta.function.arguments ?? ""
+                  },
+                  inputStarted: false,
+                  sent: false
+                };
+                const toolCall2 = toolCalls2[index];
+                if (toolCall2 == null) {
+                  throw new Error("Tool call is missing");
+                }
+                if (toolCall2.function?.name != null && toolCall2.function?.arguments != null && isParsableJson(toolCall2.function.arguments)) {
+                  toolCall2.inputStarted = true;
+                  controller.enqueue({
+                    type: "tool-input-start",
+                    id: toolCall2.id,
+                    toolName: toolCall2.function.name
+                  });
+                  controller.enqueue({
+                    type: "tool-input-delta",
+                    id: toolCall2.id,
+                    delta: toolCall2.function.arguments
+                  });
+                  controller.enqueue({
+                    type: "tool-input-end",
+                    id: toolCall2.id
+                  });
+                  controller.enqueue({
+                    type: "tool-call",
+                    toolCallId: toolCall2.id,
+                    toolName: toolCall2.function.name,
+                    input: toolCall2.function.arguments
+                  });
+                  toolCall2.sent = true;
+                }
+                continue;
+              }
+              const toolCall = toolCalls2[index];
+              if (toolCall == null) {
+                throw new Error("Tool call is missing");
+              }
+              if (!toolCall.inputStarted) {
+                toolCall.inputStarted = true;
+                controller.enqueue({
+                  type: "tool-input-start",
+                  id: toolCall.id,
+                  toolName: toolCall.function.name
+                });
+              }
+              if (toolCallDelta.function?.arguments != null) {
+                toolCall.function.arguments += toolCallDelta.function?.arguments ?? "";
+              }
+              controller.enqueue({
+                type: "tool-input-delta",
+                id: toolCall.id,
+                delta: toolCallDelta.function.arguments ?? ""
+              });
+              if (toolCall.function?.name != null && toolCall.function?.arguments != null && isParsableJson(toolCall.function.arguments)) {
+                controller.enqueue({
+                  type: "tool-call",
+                  toolCallId: toolCall.id ?? generateId(),
+                  toolName: toolCall.function.name,
+                  input: toolCall.function.arguments
+                });
+                toolCall.sent = true;
+              }
+            }
+          }
+        },
+        flush(controller) {
+          if (finishReason === "tool-calls") {
+            for (const toolCall of toolCalls2) {
+              if (toolCall && !toolCall.sent) {
+                controller.enqueue({
+                  type: "tool-call",
+                  toolCallId: toolCall.id ?? generateId(),
+                  toolName: toolCall.function.name,
+                  input: isParsableJson(toolCall.function.arguments) ? toolCall.function.arguments : "{}"
+                });
+                toolCall.sent = true;
+              }
+            }
+          }
+          if (reasoningStarted) {
+            controller.enqueue({
+              type: "reasoning-end",
+              id: reasoningId || generateId()
+            });
+          }
+          if (textStarted) {
+            controller.enqueue({
+              type: "text-end",
+              id: textId || generateId()
+            });
+          }
+          const openrouterMetadata = {
+            usage: openrouterUsage
+          };
+          if (provider !== undefined) {
+            openrouterMetadata.provider = provider;
+          }
+          controller.enqueue({
+            type: "finish",
+            finishReason,
+            usage,
+            providerMetadata: {
+              openrouter: openrouterMetadata
+            }
+          });
+        }
+      })),
+      warnings: [],
+      request: { body: args },
+      response: { headers: responseHeaders }
+    };
+  }
+}
+
+// ../packages/internal/src/openrouter-ai-sdk/completion/convert-to-openrouter-completion-prompt.ts
+function convertToOpenRouterCompletionPrompt({
+  prompt: prompt2,
+  inputFormat,
+  user = "user",
+  assistant = "assistant"
+}) {
+  if (inputFormat === "prompt" && prompt2.length === 1 && prompt2[0] && prompt2[0].role === "user" && prompt2[0].content.length === 1 && prompt2[0].content[0] && prompt2[0].content[0].type === "text") {
+    return { prompt: prompt2[0].content[0].text };
+  }
+  let text = "";
+  if (prompt2[0] && prompt2[0].role === "system") {
+    text += `${prompt2[0].content}
+
+`;
+    prompt2 = prompt2.slice(1);
+  }
+  for (const { role, content } of prompt2) {
+    switch (role) {
+      case "system": {
+        throw new InvalidPromptError({
+          message: `Unexpected system message in prompt: ${content}`,
+          prompt: prompt2
+        });
+      }
+      case "user": {
+        const userMessage2 = content.map((part) => {
+          switch (part.type) {
+            case "text": {
+              return part.text;
+            }
+            case "file": {
+              throw new UnsupportedFunctionalityError({
+                functionality: "file attachments"
+              });
+            }
+            default: {
+              return "";
+            }
+          }
+        }).join("");
+        text += `${user}:
+${userMessage2}
+
+`;
+        break;
+      }
+      case "assistant": {
+        const assistantMessage2 = content.map((part) => {
+          switch (part.type) {
+            case "text": {
+              return part.text;
+            }
+            case "tool-call": {
+              throw new UnsupportedFunctionalityError({
+                functionality: "tool-call messages"
+              });
+            }
+            case "tool-result": {
+              throw new UnsupportedFunctionalityError({
+                functionality: "tool-result messages"
+              });
+            }
+            case "reasoning": {
+              throw new UnsupportedFunctionalityError({
+                functionality: "reasoning messages"
+              });
+            }
+            case "file": {
+              throw new UnsupportedFunctionalityError({
+                functionality: "file attachments"
+              });
+            }
+            default: {
+              return "";
+            }
+          }
+        }).join("");
+        text += `${assistant}:
+${assistantMessage2}
+
+`;
+        break;
+      }
+      case "tool": {
+        throw new UnsupportedFunctionalityError({
+          functionality: "tool messages"
+        });
+      }
+      default: {
+        break;
+      }
+    }
+  }
+  text += `${assistant}:
+`;
+  return {
+    prompt: text
+  };
+}
+
+// ../packages/internal/src/openrouter-ai-sdk/completion/schemas.ts
+var import_v469 = require("zod/v4");
+var OpenRouterCompletionChunkSchema = import_v469.z.union([
+  import_v469.z.object({
+    id: import_v469.z.string().optional(),
+    model: import_v469.z.string().optional(),
+    choices: import_v469.z.array(import_v469.z.object({
+      text: import_v469.z.string(),
+      reasoning: import_v469.z.string().nullish().optional(),
+      reasoning_details: ReasoningDetailArraySchema.nullish(),
+      finish_reason: import_v469.z.string().nullish(),
+      index: import_v469.z.number().nullish(),
+      logprobs: import_v469.z.object({
+        tokens: import_v469.z.array(import_v469.z.string()),
+        token_logprobs: import_v469.z.array(import_v469.z.number()),
+        top_logprobs: import_v469.z.array(import_v469.z.record(import_v469.z.string(), import_v469.z.number())).nullable()
+      }).nullable().optional()
+    })),
+    usage: import_v469.z.object({
+      prompt_tokens: import_v469.z.number(),
+      prompt_tokens_details: import_v469.z.object({
+        cached_tokens: import_v469.z.number()
+      }).nullish(),
+      completion_tokens: import_v469.z.number(),
+      completion_tokens_details: import_v469.z.object({
+        reasoning_tokens: import_v469.z.number()
+      }).nullish(),
+      total_tokens: import_v469.z.number(),
+      cost: import_v469.z.number().optional()
+    }).nullish()
+  }),
+  OpenRouterErrorResponseSchema
+]);
+
+// ../packages/internal/src/openrouter-ai-sdk/completion/index.ts
+class OpenRouterCompletionLanguageModel {
+  specificationVersion = "v2";
+  provider = "openrouter";
+  modelId;
+  supportedUrls = {
+    "image/*": [
+      /^data:image\/[a-zA-Z]+;base64,/,
+      /^https?:\/\/.+\.(jpg|jpeg|png|gif|webp)$/i
+    ],
+    "text/*": [/^data:text\//, /^https?:\/\/.+$/],
+    "application/*": [/^data:application\//, /^https?:\/\/.+$/]
+  };
+  defaultObjectGenerationMode = undefined;
+  settings;
+  config;
+  constructor(modelId, settings, config) {
+    this.modelId = modelId;
+    this.settings = settings;
+    this.config = config;
+  }
+  getArgs({
+    prompt: prompt2,
+    maxOutputTokens,
+    temperature,
+    topP,
+    frequencyPenalty,
+    presencePenalty,
+    seed,
+    responseFormat,
+    topK,
+    stopSequences,
+    tools,
+    toolChoice
+  }) {
+    const { prompt: completionPrompt } = convertToOpenRouterCompletionPrompt({
+      prompt: prompt2,
+      inputFormat: "prompt"
+    });
+    if (tools?.length) {
+      throw new UnsupportedFunctionalityError({
+        functionality: "tools"
+      });
+    }
+    if (toolChoice) {
+      throw new UnsupportedFunctionalityError({
+        functionality: "toolChoice"
+      });
+    }
+    return {
+      model: this.modelId,
+      models: this.settings.models,
+      logit_bias: this.settings.logitBias,
+      logprobs: typeof this.settings.logprobs === "number" ? this.settings.logprobs : typeof this.settings.logprobs === "boolean" ? this.settings.logprobs ? 0 : undefined : undefined,
+      suffix: this.settings.suffix,
+      user: this.settings.user,
+      max_tokens: maxOutputTokens,
+      temperature,
+      top_p: topP,
+      frequency_penalty: frequencyPenalty,
+      presence_penalty: presencePenalty,
+      seed,
+      ...this.modelId === "x-ai/grok-code-fast-1" ? {} : { stop: stopSequences },
+      response_format: responseFormat,
+      top_k: topK,
+      prompt: completionPrompt,
+      include_reasoning: this.settings.includeReasoning,
+      reasoning: this.settings.reasoning,
+      ...this.config.extraBody,
+      ...this.settings.extraBody
+    };
+  }
+  async doGenerate(options) {
+    const providerOptions = options.providerOptions || {};
+    const openrouterOptions = providerOptions.openrouter || {};
+    const args = {
+      ...this.getArgs(options),
+      ...openrouterOptions
+    };
+    const { value: response, responseHeaders } = await postJsonToApi({
+      url: this.config.url({
+        path: "/completions",
+        modelId: this.modelId
+      }),
+      headers: combineHeaders(this.config.headers(), options.headers),
+      body: args,
+      failedResponseHandler: openrouterFailedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler(OpenRouterCompletionChunkSchema),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    if ("error" in response) {
+      throw new Error(`${response.error.message}`);
+    }
+    const choice = response.choices[0];
+    if (!choice) {
+      throw new Error("No choice in OpenRouter completion response");
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: choice.text ?? ""
+        }
+      ],
+      finishReason: mapOpenRouterFinishReason(choice.finish_reason),
+      usage: {
+        inputTokens: response.usage?.prompt_tokens ?? 0,
+        outputTokens: response.usage?.completion_tokens ?? 0,
+        totalTokens: (response.usage?.prompt_tokens ?? 0) + (response.usage?.completion_tokens ?? 0),
+        reasoningTokens: response.usage?.completion_tokens_details?.reasoning_tokens ?? 0,
+        cachedInputTokens: response.usage?.prompt_tokens_details?.cached_tokens ?? 0
+      },
+      warnings: [],
+      response: {
+        headers: responseHeaders
+      }
+    };
+  }
+  async doStream(options) {
+    const providerOptions = options.providerOptions || {};
+    const openrouterOptions = providerOptions.openrouter || {};
+    const args = {
+      ...this.getArgs(options),
+      ...openrouterOptions
+    };
+    const { value: response, responseHeaders } = await postJsonToApi({
+      url: this.config.url({
+        path: "/completions",
+        modelId: this.modelId
+      }),
+      headers: combineHeaders(this.config.headers(), options.headers),
+      body: {
+        ...args,
+        stream: true,
+        stream_options: this.config.compatibility === "strict" ? { include_usage: true } : undefined
+      },
+      failedResponseHandler: openrouterFailedResponseHandler,
+      successfulResponseHandler: createEventSourceResponseHandler(OpenRouterCompletionChunkSchema),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    let finishReason = "other";
+    const usage = {
+      inputTokens: Number.NaN,
+      outputTokens: Number.NaN,
+      totalTokens: Number.NaN,
+      reasoningTokens: Number.NaN,
+      cachedInputTokens: Number.NaN
+    };
+    const openrouterUsage = {};
+    return {
+      stream: response.pipeThrough(new TransformStream({
+        transform(chunk, controller) {
+          if (!chunk.success) {
+            finishReason = "error";
+            controller.enqueue({ type: "error", error: chunk.error });
+            return;
+          }
+          const value = chunk.value;
+          if ("error" in value) {
+            finishReason = "error";
+            controller.enqueue({ type: "error", error: value.error });
+            return;
+          }
+          if (value.usage != null) {
+            usage.inputTokens = value.usage.prompt_tokens;
+            usage.outputTokens = value.usage.completion_tokens;
+            usage.totalTokens = value.usage.prompt_tokens + value.usage.completion_tokens;
+            openrouterUsage.promptTokens = value.usage.prompt_tokens;
+            if (value.usage.prompt_tokens_details) {
+              const cachedInputTokens = value.usage.prompt_tokens_details.cached_tokens ?? 0;
+              usage.cachedInputTokens = cachedInputTokens;
+              openrouterUsage.promptTokensDetails = {
+                cachedTokens: cachedInputTokens
+              };
+            }
+            openrouterUsage.completionTokens = value.usage.completion_tokens;
+            if (value.usage.completion_tokens_details) {
+              const reasoningTokens = value.usage.completion_tokens_details.reasoning_tokens ?? 0;
+              usage.reasoningTokens = reasoningTokens;
+              openrouterUsage.completionTokensDetails = {
+                reasoningTokens
+              };
+            }
+            if (value.usage.cost !== undefined) {
+              openrouterUsage.cost = value.usage.cost;
+            }
+            openrouterUsage.totalTokens = value.usage.total_tokens;
+          }
+          const choice = value.choices[0];
+          if (choice?.finish_reason != null) {
+            finishReason = mapOpenRouterFinishReason(choice.finish_reason);
+          }
+          if (choice?.text != null) {
+            controller.enqueue({
+              type: "text-delta",
+              delta: choice.text,
+              id: generateId()
+            });
+          }
+        },
+        flush(controller) {
+          controller.enqueue({
+            type: "finish",
+            finishReason,
+            usage,
+            providerMetadata: {
+              openrouter: {
+                usage: openrouterUsage
+              }
+            }
+          });
+        }
+      })),
+      response: {
+        headers: responseHeaders
+      }
+    };
+  }
+}
+
+// ../packages/internal/src/openrouter-ai-sdk/provider.ts
+function createOpenRouter(options = {}) {
+  const baseURL = withoutTrailingSlash(options.baseURL ?? options.baseUrl) ?? "https://openrouter.ai/api/v1";
+  const compatibility = options.compatibility ?? "compatible";
+  const getHeaders = () => ({
+    Authorization: `Bearer ${loadApiKey({
+      apiKey: options.apiKey,
+      environmentVariableName: "OPENROUTER_API_KEY",
+      description: "OpenRouter"
+    })}`,
+    ...options.headers
+  });
+  const createChatModel = (modelId, settings = {}) => new OpenRouterChatLanguageModel(modelId, settings, {
+    provider: "openrouter.chat",
+    url: ({ path: path4 }) => `${baseURL}${path4}`,
+    headers: getHeaders,
+    compatibility,
+    fetch: options.fetch,
+    extraBody: options.extraBody
+  });
+  const createCompletionModel = (modelId, settings = {}) => new OpenRouterCompletionLanguageModel(modelId, settings, {
+    provider: "openrouter.completion",
+    url: ({ path: path4 }) => `${baseURL}${path4}`,
+    headers: getHeaders,
+    compatibility,
+    fetch: options.fetch,
+    extraBody: options.extraBody
+  });
+  const createLanguageModel = (modelId, settings) => {
+    if (new.target) {
+      throw new Error("The OpenRouter model function cannot be called with the new keyword.");
+    }
+    if (modelId === "openai/gpt-3.5-turbo-instruct") {
+      return createCompletionModel(modelId, settings);
+    }
+    return createChatModel(modelId, settings);
+  };
+  const provider = (modelId, settings) => createLanguageModel(modelId, settings);
+  provider.languageModel = createLanguageModel;
+  provider.chat = createChatModel;
+  provider.completion = createCompletionModel;
+  return provider;
+}
+var openrouter = createOpenRouter({
+  compatibility: "strict"
 });
-var processEnv = getProcessEnv();
 
-// src/env.ts
-var getSdkEnv = () => ({
-  ...getBaseEnv(),
-  LEVELCODE_RG_PATH: process.env.LEVELCODE_RG_PATH,
-  LEVELCODE_WASM_DIR: process.env.LEVELCODE_WASM_DIR,
-  VERBOSE: process.env.VERBOSE,
-  OVERRIDE_TARGET: process.env.OVERRIDE_TARGET,
-  OVERRIDE_PLATFORM: process.env.OVERRIDE_PLATFORM,
-  OVERRIDE_ARCH: process.env.OVERRIDE_ARCH
+// src/credentials.ts
+var import_fs = __toESM(require("fs"));
+var import_node_path = __toESM(require("node:path"));
+var import_os = __toESM(require("os"));
+
+// ../common/src/util/credentials.ts
+var import_v470 = require("zod/v4");
+var userSchema = import_v470.z.object({
+  id: import_v470.z.string(),
+  email: import_v470.z.string(),
+  name: import_v470.z.string().nullable(),
+  authToken: import_v470.z.string(),
+  fingerprintId: import_v470.z.string(),
+  fingerprintHash: import_v470.z.string()
 });
-var getLevelCodeApiKeyFromEnv = () => {
-  return process.env[API_KEY_ENV_VAR];
-};
-var getSystemProcessEnv = () => {
-  return process.env;
-};
-var getByokOpenrouterApiKeyFromEnv = () => {
-  return process.env[BYOK_OPENROUTER_ENV_VAR];
-};
-var getClaudeOAuthTokenFromEnv = () => {
-  return process.env[CLAUDE_OAUTH_TOKEN_ENV_VAR];
-};
 
 // src/credentials.ts
-var claudeOAuthSchema = import_v466.z.object({
-  accessToken: import_v466.z.string(),
-  refreshToken: import_v466.z.string(),
-  expiresAt: import_v466.z.number(),
-  connectedAt: import_v466.z.number()
+var import_v471 = require("zod/v4");
+var claudeOAuthSchema = import_v471.z.object({
+  accessToken: import_v471.z.string(),
+  refreshToken: import_v471.z.string(),
+  expiresAt: import_v471.z.number(),
+  connectedAt: import_v471.z.number()
 });
-var credentialsFileSchema = import_v466.z.object({
+var credentialsFileSchema = import_v471.z.object({
   default: userSchema.optional(),
   claudeOAuth: claudeOAuthSchema.optional()
 });
@@ -37401,6 +38837,15 @@ async function fetchClaudeOAuthResetTime(accessToken) {
     return null;
   }
 }
+function createDirectOpenRouterModel(openRouterApiKey, model) {
+  const provider = createOpenRouter({ apiKey: openRouterApiKey, compatibility: "strict" });
+  return provider.chat(model);
+}
+function createDirectAnthropicModel(anthropicApiKey, model) {
+  const anthropicModelId = toAnthropicModelId(model);
+  const anthropic = import_anthropic.createAnthropic({ apiKey: anthropicApiKey });
+  return anthropic(anthropicModelId);
+}
 async function getModelForRequest(params2) {
   const { apiKey, model, skipClaudeOAuth } = params2;
   if (!skipClaudeOAuth && !isClaudeOAuthRateLimited() && isClaudeModel(model)) {
@@ -37412,6 +38857,16 @@ async function getModelForRequest(params2) {
       };
     }
   }
+  if (isStandaloneMode()) {
+    const openRouterKey = getOpenRouterApiKeyFromEnv();
+    if (openRouterKey) {
+      return { model: createDirectOpenRouterModel(openRouterKey, model), isClaudeOAuth: false };
+    }
+    const anthropicKey = getAnthropicApiKeyFromEnv();
+    if (anthropicKey) {
+      return { model: createDirectAnthropicModel(anthropicKey, model), isClaudeOAuth: false };
+    }
+  }
   return {
     model: createLevelCodeBackendModel(apiKey, model),
     isClaudeOAuth: false
@@ -38602,7 +40057,7 @@ function parseFile(parser, query, sourceCode) {
 
 // src/run-state.ts
 var import_lodash17 = __toESM(require_lodash());
-var import_v468 = __toESM(require("zod/v4"));
+var import_v473 = __toESM(require("zod/v4"));
 
 // src/agents/load-agents.ts
 var import_fs2 = __toESM(require("fs"));
@@ -38844,21 +40299,21 @@ function isValidSkillName(name14) {
 }
 
 // ../common/src/types/skill.ts
-var import_v467 = require("zod/v4");
-var SkillMetadataSchema = import_v467.z.record(import_v467.z.string(), import_v467.z.string());
-var SkillFrontmatterSchema = import_v467.z.object({
-  name: import_v467.z.string().min(1).max(SKILL_NAME_MAX_LENGTH).regex(SKILL_NAME_REGEX, "Name must be lowercase alphanumeric with single hyphen separators"),
-  description: import_v467.z.string().min(1).max(SKILL_DESCRIPTION_MAX_LENGTH),
-  license: import_v467.z.string().optional(),
+var import_v472 = require("zod/v4");
+var SkillMetadataSchema = import_v472.z.record(import_v472.z.string(), import_v472.z.string());
+var SkillFrontmatterSchema = import_v472.z.object({
+  name: import_v472.z.string().min(1).max(SKILL_NAME_MAX_LENGTH).regex(SKILL_NAME_REGEX, "Name must be lowercase alphanumeric with single hyphen separators"),
+  description: import_v472.z.string().min(1).max(SKILL_DESCRIPTION_MAX_LENGTH),
+  license: import_v472.z.string().optional(),
   metadata: SkillMetadataSchema.optional()
 });
-var SkillDefinitionSchema = import_v467.z.object({
-  name: import_v467.z.string(),
-  description: import_v467.z.string(),
-  license: import_v467.z.string().optional(),
+var SkillDefinitionSchema = import_v472.z.object({
+  name: import_v472.z.string(),
+  description: import_v472.z.string(),
+  license: import_v472.z.string().optional(),
   metadata: SkillMetadataSchema.optional(),
-  content: import_v467.z.string(),
-  filePath: import_v467.z.string()
+  content: import_v472.z.string(),
+  filePath: import_v472.z.string()
 });
 
 // src/skills/load-skills.ts
@@ -38998,7 +40453,7 @@ function processAgentDefinitions(agentDefinitions) {
 }
 function processCustomToolDefinitions(customToolDefinitions) {
   return Object.fromEntries(customToolDefinitions.map((toolDefinition) => {
-    const jsonSchema = import_v468.default.toJSONSchema(toolDefinition.inputSchema, {
+    const jsonSchema = import_v473.default.toJSONSchema(toolDefinition.inputSchema, {
       io: "input"
     });
     delete jsonSchema["$schema"];
@@ -39396,11 +40851,11 @@ function buildFileTree(filePaths) {
 // src/tools/change-file.ts
 var import_path9 = __toESM(require("path"));
 var import_diff4 = require("diff");
-var import_v469 = __toESM(require("zod/v4"));
-var FileChangeSchema2 = import_v469.default.object({
-  type: import_v469.default.enum(["patch", "file"]),
-  path: import_v469.default.string(),
-  content: import_v469.default.string()
+var import_v474 = __toESM(require("zod/v4"));
+var FileChangeSchema2 = import_v474.default.object({
+  type: import_v474.default.enum(["patch", "file"]),
+  path: import_v474.default.string(),
+  content: import_v474.default.string()
 });
 function containsUpwardTraversal(dirPath) {
   const normalized = import_path9.default.normalize(dirPath);
@@ -40793,7 +42248,7 @@ init_paths();
 class LevelCodeClient {
   options;
   constructor(options) {
-    const foundApiKey = options.apiKey ?? getLevelCodeApiKeyFromEnv();
+    const foundApiKey = options.apiKey ?? getLevelCodeApiKeyFromEnv() ?? (isStandaloneMode() ? "standalone-mode" : undefined);
     if (!foundApiKey) {
       throw new Error(`LevelCode API key not found. Please provide an apiKey in the constructor of LevelCodeClient or set the ${API_KEY_ENV_VAR} environment variable.`);
     }
@@ -40814,6 +42269,9 @@ Provide a handleEvent function to handle this error.`);
     return run({ ...this.options, ...options });
   }
   async checkConnection() {
+    if (isStandaloneMode()) {
+      return true;
+    }
     try {
       const response = await fetch(`${WEBSITE_URL}/api/healthz`, {
         method: "GET",
@@ -40879,9 +42337,9 @@ var import_fs5 = __toESM(require("fs"));
 var import_promises = __toESM(require("fs/promises"));
 var import_os4 = __toESM(require("os"));
 var import_path13 = __toESM(require("path"));
-var import_v470 = require("zod/v4");
-var mcpFileSchema = import_v470.z.object({
-  mcpServers: import_v470.z.record(import_v470.z.string(), mcpConfigSchema).default(() => ({}))
+var import_v475 = require("zod/v4");
+var mcpFileSchema = import_v475.z.object({
+  mcpServers: import_v475.z.record(import_v475.z.string(), mcpConfigSchema).default(() => ({}))
 });
 var envKey = "env";
 var processEnv2 = process[envKey];
@@ -41010,5 +42468,5 @@ function loadMCPConfigSync(options) {
   return mergedConfig;
 }
 
-//# debugId=CD9F200A7524114264756E2164756E21
+//# debugId=3A02774EE46048ED64756E2164756E21
 //# sourceMappingURL=index.cjs.map