teleton 0.7.4 → 0.8.0

package/dist/{chunk-RO62LO6Z.js → chunk-IJBWWQE4.js}

@@ -21,9 +21,11 @@ var DEBOUNCE_MAX_MULTIPLIER = 3;
 var DEBOUNCE_MAX_BUFFER_SIZE = 20;
 var CONTEXT_MAX_RECENT_MESSAGES = 10;
 var CONTEXT_MAX_RELEVANT_CHUNKS = 5;
+var FEED_MESSAGE_MAX_CHARS = 2e3;
 var HYBRID_SEARCH_MIN_SCORE = 0.15;
 var CONTEXT_OVERFLOW_SUMMARY_MESSAGES = 15;
 var RATE_LIMIT_MAX_RETRIES = 3;
+var SERVER_ERROR_MAX_RETRIES = 3;
 var KNOWLEDGE_CHUNK_SIZE = 500;
 var PAYMENT_TOLERANCE_RATIO = 0.99;
 var TELEGRAM_CONNECTION_RETRIES = 5;
@@ -79,9 +81,11 @@ export {
   DEBOUNCE_MAX_BUFFER_SIZE,
   CONTEXT_MAX_RECENT_MESSAGES,
   CONTEXT_MAX_RELEVANT_CHUNKS,
+  FEED_MESSAGE_MAX_CHARS,
   HYBRID_SEARCH_MIN_SCORE,
   CONTEXT_OVERFLOW_SUMMARY_MESSAGES,
   RATE_LIMIT_MAX_RETRIES,
+  SERVER_ERROR_MAX_RETRIES,
   KNOWLEDGE_CHUNK_SIZE,
   PAYMENT_TOLERANCE_RATIO,
   TELEGRAM_CONNECTION_RETRIES,

package/dist/{chunk-BGC2IUM5.js → chunk-JHYZYFZJ.js}

@@ -1,13 +1,13 @@
 import {
   COINGECKO_API_URL,
   tonapiFetch
-} from "./chunk-XBKSS6DM.js";
+} from "./chunk-VFA7QMCZ.js";
 import {
   TELEGRAM_MAX_MESSAGE_LENGTH
-} from "./chunk-RO62LO6Z.js";
+} from "./chunk-IJBWWQE4.js";
 import {
   fetchWithTimeout
-} from "./chunk-VAUJSSD3.js";
+} from "./chunk-XQUHC3JZ.js";
 import {
   TELETON_ROOT,
   WORKSPACE_PATHS,
@@ -17,20 +17,21 @@ import {
   createLogger
 } from "./chunk-RCMD3U65.js";
 
-// src/ton/wallet-service.ts
-import { mnemonicNew, mnemonicToPrivateKey, mnemonicValidate } from "@ton/crypto";
-import { WalletContractV5R1, TonClient, fromNano } from "@ton/ton";
-import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
-import { join, dirname } from "path";
-
 // src/ton/endpoint.ts
 var ENDPOINT_CACHE_TTL_MS = 6e4;
 var ORBS_HOST = "ton.access.orbs.network";
 var ORBS_TOPOLOGY_URL = `https://${ORBS_HOST}/mngr/nodes?npm_version=2.3.3`;
-var TONCENTER_FALLBACK = `https://toncenter.com/api/v2/jsonRPC`;
+var TONCENTER_URL = `https://toncenter.com/api/v2/jsonRPC`;
 var _cache = null;
+var _toncenterApiKey;
+function setToncenterApiKey(key) {
+  _toncenterApiKey = key;
+}
+function getToncenterApiKey() {
+  return _toncenterApiKey;
+}
 async function discoverOrbsEndpoint() {
-  const res = await fetch(ORBS_TOPOLOGY_URL);
+  const res = await fetch(ORBS_TOPOLOGY_URL, { signal: AbortSignal.timeout(5e3) });
   const nodes = await res.json();
   const healthy = nodes.filter(
     (n) => n.Healthy === "1" && n.Weight > 0 && n.Mngr?.health?.["v2-mainnet"]
@@ -53,10 +54,28 @@ async function getCachedHttpEndpoint() {
     return _cache.url;
   }
   let url;
-  try {
-    url = await discoverOrbsEndpoint();
-  } catch {
-    url = TONCENTER_FALLBACK;
+  if (_toncenterApiKey) {
+    try {
+      const testUrl = `https://toncenter.com/api/v2/getAddressInformation?address=EQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM9c`;
+      const res = await fetch(testUrl, {
+        headers: { "X-API-Key": _toncenterApiKey },
+        signal: AbortSignal.timeout(5e3)
+      });
+      if (!res.ok) throw new Error(`TonCenter ${res.status}`);
+      url = TONCENTER_URL;
+    } catch {
+      try {
+        url = await discoverOrbsEndpoint();
+      } catch {
+        url = TONCENTER_URL;
+      }
+    }
+  } else {
+    try {
+      url = await discoverOrbsEndpoint();
+    } catch {
+      url = TONCENTER_URL;
+    }
   }
   _cache = { url, ts: Date.now() };
   return url;
@@ -66,6 +85,10 @@ function invalidateEndpointCache() {
 }
 
 // src/ton/wallet-service.ts
+import { mnemonicNew, mnemonicToPrivateKey, mnemonicValidate } from "@ton/crypto";
+import { WalletContractV5R1, TonClient, fromNano } from "@ton/ton";
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { join, dirname } from "path";
 var log = createLogger("TON");
 var WALLET_FILE = join(TELETON_ROOT, "wallet.json");
 var _walletCache;
@@ -147,7 +170,8 @@ async function getCachedTonClient() {
   if (_tonClientCache && _tonClientCache.endpoint === endpoint) {
     return _tonClientCache.client;
   }
-  const client = new TonClient({ endpoint });
+  const apiKey = getToncenterApiKey();
+  const client = new TonClient({ endpoint, ...apiKey && { apiKey } });
   _tonClientCache = { client, endpoint };
   return client;
 }
@@ -217,8 +241,8 @@ async function getTonPrice() {
 
 // src/config/schema.ts
 import { z } from "zod";
-var DMPolicy = z.enum(["allowlist", "open", "disabled"]);
-var GroupPolicy = z.enum(["open", "allowlist", "disabled"]);
+var DMPolicy = z.enum(["allowlist", "open", "admin-only", "disabled"]);
+var GroupPolicy = z.enum(["open", "allowlist", "admin-only", "disabled"]);
 var SessionResetPolicySchema = z.object({
   daily_reset_enabled: z.boolean().default(true).describe("Enable daily session reset"),
   daily_reset_hour: z.number().min(0).max(23).default(4).describe("Hour of day (0-23) to reset sessions"),
@@ -236,6 +260,10 @@ var AgentConfigSchema = z.object({
     "openrouter",
     "moonshot",
     "mistral",
+    "cerebras",
+    "zai",
+    "minimax",
+    "huggingface",
     "cocoon",
     "local"
   ]).default("anthropic"),
@@ -332,7 +360,7 @@ var _McpObject = z.object({
 });
 var McpConfigSchema = _McpObject.default(_McpObject.parse({}));
 var _ToolRagObject = z.object({
-  enabled: z.boolean().default(false).describe("Enable semantic tool retrieval (Tool RAG)"),
+  enabled: z.boolean().default(true).describe("Enable semantic tool retrieval (Tool RAG)"),
   top_k: z.number().default(25).describe("Max tools to retrieve per LLM call"),
   always_include: z.array(z.string()).default([
     "telegram_send_message",
@@ -346,6 +374,24 @@ var _ToolRagObject = z.object({
   skip_unlimited_providers: z.boolean().default(false).describe("Skip Tool RAG for providers with no tool limit (e.g. Anthropic)")
 });
 var ToolRagConfigSchema = _ToolRagObject.default(_ToolRagObject.parse({}));
+var _ExecLimitsObject = z.object({
+  timeout: z.number().min(1).max(3600).default(120).describe("Max seconds per command execution"),
+  max_output: z.number().min(1e3).max(5e5).default(5e4).describe("Max chars of stdout/stderr captured per command")
+});
+var _ExecAuditObject = z.object({
+  log_commands: z.boolean().default(true).describe("Log every command to SQLite audit table")
+});
+var _ExecObject = z.object({
+  mode: z.enum(["off", "yolo"]).default("off").describe("Exec mode: off (disabled) or yolo (full system access)"),
+  scope: z.enum(["admin-only", "allowlist", "all"]).default("admin-only").describe("Who can trigger exec tools"),
+  allowlist: z.array(z.number()).default([]).describe("Telegram user IDs allowed to use exec (when scope = allowlist)"),
+  limits: _ExecLimitsObject.default(_ExecLimitsObject.parse({})),
+  audit: _ExecAuditObject.default(_ExecAuditObject.parse({}))
+});
+var _CapabilitiesObject = z.object({
+  exec: _ExecObject.default(_ExecObject.parse({}))
+});
+var CapabilitiesConfigSchema = _CapabilitiesObject.default(_CapabilitiesObject.parse({}));
 var ConfigSchema = z.object({
   meta: MetaConfigSchema.default(MetaConfigSchema.parse({})),
   agent: AgentConfigSchema,
@@ -357,12 +403,14 @@ var ConfigSchema = z.object({
   logging: LoggingConfigSchema,
   dev: DevConfigSchema,
   tool_rag: ToolRagConfigSchema,
+  capabilities: CapabilitiesConfigSchema,
   mcp: McpConfigSchema,
   plugins: z.record(z.string(), z.unknown()).default({}).describe("Per-plugin config (key = plugin name with underscores)"),
   cocoon: z.object({
     port: z.number().min(1).max(65535).default(1e4).describe("HTTP port of the cocoon-cli proxy")
   }).optional().describe("Cocoon Network \u2014 expects external cocoon-cli running on this port"),
   tonapi_key: z.string().optional().describe("TonAPI key for higher rate limits (from @tonapi_bot)"),
+  toncenter_api_key: z.string().optional().describe("TonCenter API key for dedicated RPC endpoint (free at https://toncenter.com)"),
   tavily_api_key: z.string().optional().describe("Tavily API key for web search & extract (free at https://tavily.com)")
 });
 
@@ -464,7 +512,8 @@ export {
   ensureWorkspace,
   isNewWorkspace,
   loadTemplate,
-  getCachedHttpEndpoint,
+  setToncenterApiKey,
+  invalidateEndpointCache,
   generateWallet,
   saveWallet,
   loadWallet,

package/dist/{chunk-QOQWUUA4.js → chunk-OJCLKU5Z.js}

@@ -118,11 +118,11 @@ var MODEL_OPTIONS = {
     { value: "x-ai/grok-4", name: "Grok 4", description: "256K ctx, $3/M" }
   ],
   moonshot: [
-    { value: "kimi-k2.5", name: "Kimi K2.5", description: "Free, 256K ctx, multimodal" },
+    { value: "k2p5", name: "Kimi K2.5", description: "Free, 262K ctx, multimodal" },
     {
       value: "kimi-k2-thinking",
       name: "Kimi K2 Thinking",
-      description: "Free, 256K ctx, reasoning"
+      description: "Free, 262K ctx, reasoning"
     }
   ],
   mistral: [
@@ -146,6 +146,72 @@ var MODEL_OPTIONS = {
       name: "Magistral Small",
       description: "Reasoning, 128K ctx, $0.50/M"
     }
+  ],
+  cerebras: [
+    {
+      value: "qwen-3-235b-a22b-instruct-2507",
+      name: "Qwen 3 235B",
+      description: "131K ctx, $0.60/$1.20"
+    },
+    { value: "gpt-oss-120b", name: "GPT OSS 120B", description: "Reasoning, 131K ctx, $0.25/M" },
+    { value: "zai-glm-4.7", name: "ZAI GLM-4.7", description: "131K ctx, $2.25/M" },
+    { value: "llama3.1-8b", name: "Llama 3.1 8B", description: "Fast & cheap, 32K ctx, $0.10/M" }
+  ],
+  zai: [
+    { value: "glm-4.7", name: "GLM-4.7", description: "204K ctx, $0.60/$2.20" },
+    { value: "glm-5", name: "GLM-5", description: "Best quality, 204K ctx, $1.00/$3.20" },
+    { value: "glm-4.6", name: "GLM-4.6", description: "204K ctx, $0.60/$2.20" },
+    { value: "glm-4.7-flash", name: "GLM-4.7 Flash", description: "FREE, 200K ctx" },
+    { value: "glm-4.5-flash", name: "GLM-4.5 Flash", description: "FREE, 131K ctx" },
+    { value: "glm-4.5v", name: "GLM-4.5V", description: "Vision, 64K ctx, $0.60/$1.80" }
+  ],
+  minimax: [
+    { value: "MiniMax-M2.5", name: "MiniMax M2.5", description: "204K ctx, $0.30/$1.20" },
+    {
+      value: "MiniMax-M2.5-highspeed",
+      name: "MiniMax M2.5 Fast",
+      description: "204K ctx, $0.60/$2.40"
+    },
+    { value: "MiniMax-M2.1", name: "MiniMax M2.1", description: "204K ctx, $0.30/$1.20" },
+    { value: "MiniMax-M2", name: "MiniMax M2", description: "196K ctx, $0.30/$1.20" }
+  ],
+  huggingface: [
+    {
+      value: "deepseek-ai/DeepSeek-V3.2",
+      name: "DeepSeek V3.2",
+      description: "163K ctx, $0.28/$0.40"
+    },
+    {
+      value: "deepseek-ai/DeepSeek-R1-0528",
+      name: "DeepSeek R1",
+      description: "Reasoning, 163K ctx, $3/$5"
+    },
+    {
+      value: "Qwen/Qwen3-235B-A22B-Thinking-2507",
+      name: "Qwen3 235B",
+      description: "Reasoning, 262K ctx, $0.30/$3"
+    },
+    {
+      value: "Qwen/Qwen3-Coder-480B-A35B-Instruct",
+      name: "Qwen3 Coder 480B",
+      description: "Coding, 262K ctx, $2/$2"
+    },
+    {
+      value: "Qwen/Qwen3-Next-80B-A3B-Instruct",
+      name: "Qwen3 Next 80B",
+      description: "262K ctx, $0.25/$1"
+    },
+    {
+      value: "moonshotai/Kimi-K2.5",
+      name: "Kimi K2.5",
+      description: "262K ctx, $0.60/$3"
+    },
+    {
+      value: "zai-org/GLM-4.7-Flash",
+      name: "GLM-4.7 Flash",
+      description: "FREE, 200K ctx"
+    },
+    { value: "zai-org/GLM-5", name: "GLM-5", description: "202K ctx, $1/$3.20" }
   ]
 };
 function getModelsForProvider(provider) {

package/dist/{chunk-OCLG5GKI.js → chunk-P36I6OIV.js}

@@ -24,7 +24,7 @@ function getTranscriptPath(sessionId) {
 }
 function ensureSessionsDir() {
   if (!existsSync(SESSIONS_DIR)) {
-    mkdirSync(SESSIONS_DIR, { recursive: true });
+    mkdirSync(SESSIONS_DIR, { recursive: true, mode: 448 });
   }
 }
 function appendToTranscript(sessionId, message) {
@@ -32,7 +32,7 @@ function appendToTranscript(sessionId, message) {
   const transcriptPath = getTranscriptPath(sessionId);
   const line = JSON.stringify(message) + "\n";
   try {
-    appendFileSync(transcriptPath, line, "utf-8");
+    appendFileSync(transcriptPath, line, { encoding: "utf-8", mode: 384 });
   } catch (error) {
     log.error({ err: error }, `Failed to append to transcript ${sessionId}`);
   }

package/dist/chunk-PHSAHTK4.js

@@ -0,0 +1,314 @@
+import {
+  createLogger
+} from "./chunk-RCMD3U65.js";
+
+// src/config/providers.ts
+var PROVIDER_REGISTRY = {
+  anthropic: {
+    id: "anthropic",
+    displayName: "Anthropic (Claude)",
+    envVar: "ANTHROPIC_API_KEY",
+    keyPrefix: "sk-ant-",
+    keyHint: "sk-ant-api03-...",
+    consoleUrl: "https://console.anthropic.com/",
+    defaultModel: "claude-opus-4-6",
+    utilityModel: "claude-haiku-4-5-20251001",
+    toolLimit: null,
+    piAiProvider: "anthropic"
+  },
+  "claude-code": {
+    id: "claude-code",
+    displayName: "Claude Code (Auto)",
+    envVar: "ANTHROPIC_API_KEY",
+    keyPrefix: "sk-ant-",
+    keyHint: "Auto-detected from Claude Code",
+    consoleUrl: "https://console.anthropic.com/",
+    defaultModel: "claude-opus-4-6",
+    utilityModel: "claude-haiku-4-5-20251001",
+    toolLimit: null,
+    piAiProvider: "anthropic"
+  },
+  openai: {
+    id: "openai",
+    displayName: "OpenAI (GPT-4o)",
+    envVar: "OPENAI_API_KEY",
+    keyPrefix: "sk-",
+    keyHint: "sk-proj-...",
+    consoleUrl: "https://platform.openai.com/api-keys",
+    defaultModel: "gpt-4o",
+    utilityModel: "gpt-4o-mini",
+    toolLimit: 128,
+    piAiProvider: "openai"
+  },
+  google: {
+    id: "google",
+    displayName: "Google (Gemini)",
+    envVar: "GOOGLE_API_KEY",
+    keyPrefix: null,
+    keyHint: "AIza...",
+    consoleUrl: "https://aistudio.google.com/apikey",
+    defaultModel: "gemini-2.5-flash",
+    utilityModel: "gemini-2.0-flash-lite",
+    toolLimit: 128,
+    piAiProvider: "google"
+  },
+  xai: {
+    id: "xai",
+    displayName: "xAI (Grok)",
+    envVar: "XAI_API_KEY",
+    keyPrefix: "xai-",
+    keyHint: "xai-...",
+    consoleUrl: "https://console.x.ai/",
+    defaultModel: "grok-3",
+    utilityModel: "grok-3-mini-fast",
+    toolLimit: 128,
+    piAiProvider: "xai"
+  },
+  groq: {
+    id: "groq",
+    displayName: "Groq",
+    envVar: "GROQ_API_KEY",
+    keyPrefix: "gsk_",
+    keyHint: "gsk_...",
+    consoleUrl: "https://console.groq.com/keys",
+    defaultModel: "llama-3.3-70b-versatile",
+    utilityModel: "llama-3.1-8b-instant",
+    toolLimit: 128,
+    piAiProvider: "groq"
+  },
+  openrouter: {
+    id: "openrouter",
+    displayName: "OpenRouter",
+    envVar: "OPENROUTER_API_KEY",
+    keyPrefix: "sk-or-",
+    keyHint: "sk-or-v1-...",
+    consoleUrl: "https://openrouter.ai/keys",
+    defaultModel: "anthropic/claude-opus-4.5",
+    utilityModel: "google/gemini-2.5-flash-lite",
+    toolLimit: 128,
+    piAiProvider: "openrouter"
+  },
+  moonshot: {
+    id: "moonshot",
+    displayName: "Moonshot (Kimi K2.5)",
+    envVar: "MOONSHOT_API_KEY",
+    keyPrefix: "sk-",
+    keyHint: "sk-...",
+    consoleUrl: "https://platform.moonshot.ai/",
+    defaultModel: "k2p5",
+    utilityModel: "k2p5",
+    toolLimit: 128,
+    piAiProvider: "kimi-coding"
+  },
+  mistral: {
+    id: "mistral",
+    displayName: "Mistral AI",
+    envVar: "MISTRAL_API_KEY",
+    keyPrefix: null,
+    keyHint: "...",
+    consoleUrl: "https://console.mistral.ai/api-keys",
+    defaultModel: "devstral-small-2507",
+    utilityModel: "ministral-8b-latest",
+    toolLimit: 128,
+    piAiProvider: "mistral"
+  },
+  cerebras: {
+    id: "cerebras",
+    displayName: "Cerebras",
+    envVar: "CEREBRAS_API_KEY",
+    keyPrefix: "csk-",
+    keyHint: "csk-...",
+    consoleUrl: "https://cloud.cerebras.ai/",
+    defaultModel: "qwen-3-235b-a22b-instruct-2507",
+    utilityModel: "llama3.1-8b",
+    toolLimit: 128,
+    piAiProvider: "cerebras"
+  },
+  zai: {
+    id: "zai",
+    displayName: "ZAI (Zhipu)",
+    envVar: "ZAI_API_KEY",
+    keyPrefix: null,
+    keyHint: "...",
+    consoleUrl: "https://z.ai/manage-apikey/apikey-list",
+    defaultModel: "glm-4.7",
+    utilityModel: "glm-4.7-flash",
+    toolLimit: 128,
+    piAiProvider: "zai"
+  },
+  minimax: {
+    id: "minimax",
+    displayName: "MiniMax",
+    envVar: "MINIMAX_API_KEY",
+    keyPrefix: null,
+    keyHint: "Save your key \u2014 shown only once!",
+    consoleUrl: "https://platform.minimax.io/",
+    defaultModel: "MiniMax-M2.5",
+    utilityModel: "MiniMax-M2",
+    toolLimit: 128,
+    piAiProvider: "minimax"
+  },
+  huggingface: {
+    id: "huggingface",
+    displayName: "HuggingFace",
+    envVar: "HF_TOKEN",
+    keyPrefix: "hf_",
+    keyHint: "hf_...",
+    consoleUrl: "https://huggingface.co/settings/tokens",
+    defaultModel: "deepseek-ai/DeepSeek-V3.2",
+    utilityModel: "Qwen/Qwen3-Next-80B-A3B-Instruct",
+    toolLimit: 128,
+    piAiProvider: "huggingface"
+  },
+  cocoon: {
+    id: "cocoon",
+    displayName: "Cocoon Network (Decentralized)",
+    envVar: "",
+    keyPrefix: null,
+    keyHint: "No API key needed \u2014 pays in TON",
+    consoleUrl: "https://cocoon.network",
+    defaultModel: "Qwen/Qwen3-32B",
+    utilityModel: "Qwen/Qwen3-32B",
+    toolLimit: 128,
+    piAiProvider: "cocoon"
+  },
+  local: {
+    id: "local",
+    displayName: "Local (Ollama, vLLM, LM Studio...)",
+    envVar: "",
+    keyPrefix: null,
+    keyHint: "No API key needed",
+    consoleUrl: "",
+    defaultModel: "auto",
+    utilityModel: "auto",
+    toolLimit: 128,
+    piAiProvider: "local"
+  }
+};
+function getProviderMetadata(provider) {
+  const meta = PROVIDER_REGISTRY[provider];
+  if (!meta) {
+    throw new Error(`Unknown provider: ${provider}`);
+  }
+  return meta;
+}
+function getSupportedProviders() {
+  return Object.values(PROVIDER_REGISTRY);
+}
+function validateApiKeyFormat(provider, key) {
+  const meta = PROVIDER_REGISTRY[provider];
+  if (!meta) return `Unknown provider: ${provider}`;
+  if (provider === "cocoon" || provider === "local" || provider === "claude-code") return void 0;
+  if (!key || key.trim().length === 0) return "API key is required";
+  if (meta.keyPrefix && !key.startsWith(meta.keyPrefix)) {
+    return `Invalid format (should start with ${meta.keyPrefix})`;
+  }
+  return void 0;
+}
+
+// src/providers/claude-code-credentials.ts
+import { readFileSync, existsSync } from "fs";
+import { execSync } from "child_process";
+import { homedir } from "os";
+import { join } from "path";
+var log = createLogger("ClaudeCodeCreds");
+var cachedToken = null;
+var cachedExpiresAt = 0;
+function getClaudeConfigDir() {
+  return process.env.CLAUDE_CONFIG_DIR || join(homedir(), ".claude");
+}
+function getCredentialsFilePath() {
+  return join(getClaudeConfigDir(), ".credentials.json");
+}
+function readCredentialsFile() {
+  const filePath = getCredentialsFilePath();
+  if (!existsSync(filePath)) return null;
+  try {
+    const raw = readFileSync(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch (e) {
+    log.warn({ err: e, path: filePath }, "Failed to parse Claude Code credentials file");
+    return null;
+  }
+}
+function readKeychainCredentials() {
+  const serviceNames = ["Claude Code-credentials", "Claude Code"];
+  for (const service of serviceNames) {
+    try {
+      const raw = execSync(`security find-generic-password -s "${service}" -w`, {
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim();
+      return JSON.parse(raw);
+    } catch {
+    }
+  }
+  return null;
+}
+function readCredentials() {
+  if (process.platform === "darwin") {
+    const keychainCreds = readKeychainCredentials();
+    if (keychainCreds) return keychainCreds;
+    log.debug("Keychain read failed, falling back to credentials file");
+  }
+  return readCredentialsFile();
+}
+function extractToken(creds) {
+  const oauth = creds.claudeAiOauth;
+  if (!oauth?.accessToken) {
+    log.warn("Claude Code credentials found but missing accessToken");
+    return null;
+  }
+  return {
+    token: oauth.accessToken,
+    expiresAt: oauth.expiresAt ?? 0
+  };
+}
+function getClaudeCodeApiKey(fallbackKey) {
+  if (cachedToken && Date.now() < cachedExpiresAt) {
+    return cachedToken;
+  }
+  const creds = readCredentials();
+  if (creds) {
+    const extracted = extractToken(creds);
+    if (extracted) {
+      cachedToken = extracted.token;
+      cachedExpiresAt = extracted.expiresAt;
+      log.debug("Claude Code credentials loaded successfully");
+      return cachedToken;
+    }
+  }
+  if (fallbackKey && fallbackKey.length > 0) {
+    log.warn("Claude Code credentials not found, using fallback api_key from config");
+    return fallbackKey;
+  }
+  throw new Error("No Claude Code credentials found. Run 'claude login' or set api_key in config.");
+}
+function refreshClaudeCodeApiKey() {
+  cachedToken = null;
+  cachedExpiresAt = 0;
+  const creds = readCredentials();
+  if (creds) {
+    const extracted = extractToken(creds);
+    if (extracted) {
+      cachedToken = extracted.token;
+      cachedExpiresAt = extracted.expiresAt;
+      log.info("Claude Code credentials refreshed from disk");
+      return cachedToken;
+    }
+  }
+  log.warn("Failed to refresh Claude Code credentials from disk");
+  return null;
+}
+function isClaudeCodeTokenValid() {
+  return cachedToken !== null && Date.now() < cachedExpiresAt;
+}
+
+export {
+  getProviderMetadata,
+  getSupportedProviders,
+  validateApiKeyFormat,
+  getClaudeCodeApiKey,
+  refreshClaudeCodeApiKey,
+  isClaudeCodeTokenValid
+};