teleton 0.7.3 → 0.7.5

package/dist/chunk-5UVXJMOX.js

@@ -0,0 +1,292 @@
+import {
+  getDatabase
+} from "./chunk-2GLHOJ5C.js";
+import {
+  createLogger
+} from "./chunk-RCMD3U65.js";
+
+// src/session/store.ts
+import { randomUUID } from "crypto";
+var log = createLogger("Session");
+function getDb() {
+  return getDatabase().getDb();
+}
+function rowToSession(row) {
+  return {
+    sessionId: row.id,
+    chatId: row.chat_id,
+    createdAt: row.started_at,
+    updatedAt: row.updated_at,
+    messageCount: row.message_count || 0,
+    lastMessageId: row.last_message_id ?? void 0,
+    lastChannel: row.last_channel ?? void 0,
+    lastTo: row.last_to ?? void 0,
+    contextTokens: row.context_tokens ?? void 0,
+    model: row.model ?? void 0,
+    provider: row.provider ?? void 0,
+    lastResetDate: row.last_reset_date ?? void 0,
+    inputTokens: row.input_tokens ?? void 0,
+    outputTokens: row.output_tokens ?? void 0
+  };
+}
+function loadSessionStore() {
+  try {
+    const db = getDb();
+    const rows = db.prepare("SELECT * FROM sessions").all();
+    const store = {};
+    for (const row of rows) {
+      const sessionKey = row.chat_id;
+      store[sessionKey] = rowToSession(row);
+    }
+    return store;
+  } catch (error) {
+    log.warn({ err: error }, "Failed to load sessions from database");
+    return {};
+  }
+}
+function saveSessionStore(store) {
+  try {
+    const db = getDb();
+    const insertStmt = db.prepare(`
+      INSERT INTO sessions (
+        id, chat_id, started_at, updated_at, message_count,
+        last_message_id, last_channel, last_to, context_tokens,
+        model, provider, last_reset_date, input_tokens, output_tokens
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    db.transaction(() => {
+      db.prepare("DELETE FROM sessions").run();
+      for (const [chatId, session] of Object.entries(store)) {
+        insertStmt.run(
+          session.sessionId,
+          chatId,
+          session.createdAt,
+          session.updatedAt,
+          session.messageCount,
+          session.lastMessageId,
+          session.lastChannel,
+          session.lastTo,
+          session.contextTokens,
+          session.model,
+          session.provider,
+          session.lastResetDate,
+          session.inputTokens ?? 0,
+          session.outputTokens ?? 0
+        );
+      }
+    })();
+  } catch (error) {
+    log.error({ err: error }, "Failed to save sessions to database");
+  }
+}
+function getOrCreateSession(chatId) {
+  const db = getDb();
+  const sessionKey = `telegram:${chatId}`;
+  const row = db.prepare("SELECT * FROM sessions WHERE chat_id = ?").get(sessionKey);
+  if (row) {
+    return rowToSession(row);
+  }
+  const now = Date.now();
+  const newSession = {
+    sessionId: randomUUID(),
+    chatId,
+    createdAt: now,
+    updatedAt: now,
+    messageCount: 0,
+    lastChannel: "telegram",
+    lastTo: chatId
+  };
+  db.prepare(
+    `
+    INSERT INTO sessions (
+      id, chat_id, started_at, updated_at, message_count, last_channel, last_to
+    ) VALUES (?, ?, ?, ?, ?, ?, ?)
+  `
+  ).run(
+    newSession.sessionId,
+    sessionKey,
+    newSession.createdAt,
+    newSession.updatedAt,
+    newSession.messageCount,
+    newSession.lastChannel,
+    newSession.lastTo
+  );
+  log.info(`New session created: ${newSession.sessionId} for chat ${chatId}`);
+  return newSession;
+}
+function updateSession(chatId, update) {
+  const db = getDb();
+  const sessionKey = `telegram:${chatId}`;
+  const existing = db.prepare("SELECT * FROM sessions WHERE chat_id = ?").get(sessionKey);
+  if (!existing) {
+    return getOrCreateSession(chatId);
+  }
+  const updates = [];
+  const values = [];
+  if (update.sessionId !== void 0) {
+    updates.push("id = ?");
+    values.push(update.sessionId);
+  }
+  if (update.messageCount !== void 0) {
+    updates.push("message_count = ?");
+    values.push(update.messageCount);
+  }
+  if (update.lastMessageId !== void 0) {
+    updates.push("last_message_id = ?");
+    values.push(update.lastMessageId);
+  }
+  if (update.lastChannel !== void 0) {
+    updates.push("last_channel = ?");
+    values.push(update.lastChannel);
+  }
+  if (update.lastTo !== void 0) {
+    updates.push("last_to = ?");
+    values.push(update.lastTo);
+  }
+  if (update.contextTokens !== void 0) {
+    updates.push("context_tokens = ?");
+    values.push(update.contextTokens);
+  }
+  if (update.model !== void 0) {
+    updates.push("model = ?");
+    values.push(update.model);
+  }
+  if (update.provider !== void 0) {
+    updates.push("provider = ?");
+    values.push(update.provider);
+  }
+  if (update.lastResetDate !== void 0) {
+    updates.push("last_reset_date = ?");
+    values.push(update.lastResetDate);
+  }
+  if (update.inputTokens !== void 0) {
+    updates.push("input_tokens = ?");
+    values.push(update.inputTokens);
+  }
+  if (update.outputTokens !== void 0) {
+    updates.push("output_tokens = ?");
+    values.push(update.outputTokens);
+  }
+  updates.push("updated_at = ?");
+  values.push(Date.now());
+  values.push(sessionKey);
+  db.prepare(
+    `
+    UPDATE sessions
+    SET ${updates.join(", ")}
+    WHERE chat_id = ?
+  `
+  ).run(...values);
+  const updated = db.prepare("SELECT * FROM sessions WHERE chat_id = ?").get(sessionKey);
+  return rowToSession(updated);
+}
+function incrementMessageCount(chatId) {
+  const db = getDb();
+  const sessionKey = `telegram:${chatId}`;
+  const result = db.prepare(
+    `UPDATE sessions SET message_count = message_count + 1, updated_at = ? WHERE chat_id = ?`
+  ).run(Date.now(), sessionKey);
+  if (result.changes === 0) {
+    getOrCreateSession(chatId);
+    db.prepare(
+      `UPDATE sessions SET message_count = message_count + 1, updated_at = ? WHERE chat_id = ?`
+    ).run(Date.now(), sessionKey);
+  }
+}
+function getSession(chatId) {
+  const db = getDb();
+  const sessionKey = `telegram:${chatId}`;
+  const row = db.prepare("SELECT * FROM sessions WHERE chat_id = ?").get(sessionKey);
+  return row ? rowToSession(row) : null;
+}
+function resetSession(chatId) {
+  const oldSession = getSession(chatId);
+  const now = Date.now();
+  const newSession = {
+    sessionId: randomUUID(),
+    chatId,
+    createdAt: now,
+    updatedAt: now,
+    messageCount: 0,
+    lastChannel: oldSession?.lastChannel || "telegram",
+    lastTo: oldSession?.lastTo || chatId,
+    contextTokens: oldSession?.contextTokens,
+    model: oldSession?.model,
+    provider: oldSession?.provider
+  };
+  const db = getDb();
+  const sessionKey = `telegram:${chatId}`;
+  db.prepare(
+    `
+    UPDATE sessions
+    SET id = ?, started_at = ?, updated_at = ?, message_count = 0
+    WHERE chat_id = ?
+  `
+  ).run(newSession.sessionId, newSession.createdAt, newSession.updatedAt, sessionKey);
+  log.info(`Session reset: ${oldSession?.sessionId} \u2192 ${newSession.sessionId}`);
+  return newSession;
+}
+function shouldResetSession(session, policy) {
+  const now = Date.now();
+  if (policy.daily_reset_enabled) {
+    const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    const lastReset = session.lastResetDate || new Date(session.createdAt).toISOString().split("T")[0];
+    if (lastReset !== today) {
+      const currentHour = (/* @__PURE__ */ new Date()).getHours();
+      const resetHour = policy.daily_reset_hour;
+      if (lastReset < today && currentHour >= resetHour) {
+        log.info(
+          `Daily reset triggered for session ${session.sessionId} (last reset: ${lastReset})`
+        );
+        return true;
+      }
+    }
+  }
+  if (policy.idle_expiry_enabled) {
+    const idleMs = now - session.updatedAt;
+    const idleMinutes = idleMs / (1e3 * 60);
+    const expiryMinutes = policy.idle_expiry_minutes;
+    if (idleMinutes >= expiryMinutes) {
+      log.info(
+        `Idle expiry triggered for session ${session.sessionId} (idle: ${Math.floor(idleMinutes)}m)`
+      );
+      return true;
+    }
+  }
+  return false;
+}
+function resetSessionWithPolicy(chatId, policy) {
+  const newSession = resetSession(chatId);
+  const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  return updateSession(chatId, {
+    lastResetDate: today
+  });
+}
+function pruneOldSessions(maxAgeDays = 30) {
+  try {
+    const db = getDb();
+    const cutoffMs = Date.now() - maxAgeDays * 24 * 60 * 60 * 1e3;
+    const result = db.prepare(`DELETE FROM sessions WHERE updated_at < ? AND updated_at > 0`).run(cutoffMs);
+    const pruned = result.changes;
+    if (pruned > 0) {
+      log.info(`\u{1F5D1}\uFE0F Pruned ${pruned} session(s) older than ${maxAgeDays} days`);
+    }
+    return pruned;
+  } catch (error) {
+    log.warn({ err: error }, "Failed to prune old sessions");
+    return 0;
+  }
+}
+
+export {
+  loadSessionStore,
+  saveSessionStore,
+  getOrCreateSession,
+  updateSession,
+  incrementMessageCount,
+  getSession,
+  resetSession,
+  shouldResetSession,
+  resetSessionWithPolicy,
+  pruneOldSessions
+};

package/dist/{chunk-DAMCNMYL.js → chunk-AVDWXYQ7.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-YP25WTQK.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(["pairing", "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"),
@@ -255,7 +279,7 @@ var TelegramConfigSchema = z.object({
   phone: z.string(),
   session_name: z.string().default("teleton_session"),
   session_path: z.string().default("~/.teleton"),
-  dm_policy: DMPolicy.default("pairing"),
+  dm_policy: DMPolicy.default("allowlist"),
   allow_from: z.array(z.number()).default([]),
   group_policy: GroupPolicy.default("open"),
   group_allow_from: z.array(z.number()).default([]),
@@ -275,7 +299,6 @@ var TelegramConfigSchema = z.object({
 });
 var StorageConfigSchema = z.object({
   sessions_file: z.string().default("~/.teleton/sessions.json"),
-  pairing_file: z.string().default("~/.teleton/pairing.json"),
   memory_file: z.string().default("~/.teleton/memory.json"),
   history_limit: z.number().default(100)
 });
@@ -288,7 +311,7 @@ var MetaConfigSchema = z.object({
 var _DealsObject = z.object({
   enabled: z.boolean().default(true),
   expiry_seconds: z.number().default(120),
-  buy_max_floor_percent: z.number().default(100),
+  buy_max_floor_percent: z.number().default(95),
   sell_min_floor_percent: z.number().default(105),
   poll_interval_ms: z.number().default(5e3),
   max_verification_retries: z.number().default(12),
@@ -333,7 +356,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",
@@ -347,6 +370,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,
@@ -358,12 +399,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)")
 });
 
@@ -382,13 +425,14 @@ function findPackageRoot() {
 }
 var TEMPLATES_DIR = join2(findPackageRoot(), "src", "templates");
 async function ensureWorkspace(config) {
+  const silent = config?.silent ?? false;
   if (!existsSync2(TELETON_ROOT)) {
     mkdirSync2(TELETON_ROOT, { recursive: true });
-    log2.info(`Created Teleton root at ${TELETON_ROOT}`);
+    if (!silent) log2.info(`Created Teleton root at ${TELETON_ROOT}`);
   }
   if (!existsSync2(WORKSPACE_ROOT)) {
     mkdirSync2(WORKSPACE_ROOT, { recursive: true });
-    log2.info(`Created workspace at ${WORKSPACE_ROOT}`);
+    if (!silent) log2.info(`Created workspace at ${WORKSPACE_ROOT}`);
   }
   const directories = [
     WORKSPACE_PATHS.MEMORY_DIR,
@@ -424,11 +468,11 @@ async function ensureWorkspace(config) {
     walletPath: join2(TELETON_ROOT, "wallet.json")
   };
   if (config?.ensureTemplates) {
-    await bootstrapTemplates(workspace);
+    await bootstrapTemplates(workspace, silent);
   }
   return workspace;
 }
-async function bootstrapTemplates(workspace) {
+async function bootstrapTemplates(workspace, silent = false) {
   const templates = [
     { name: "SOUL.md", path: workspace.soulPath },
     { name: "MEMORY.md", path: workspace.memoryPath },
@@ -442,7 +486,7 @@ async function bootstrapTemplates(workspace) {
       const templateSource = join2(TEMPLATES_DIR, template.name);
       if (existsSync2(templateSource)) {
         copyFileSync(templateSource, template.path);
-        log2.info(`Created ${template.name}`);
+        if (!silent) log2.info(`Created ${template.name}`);
       }
     }
   }
@@ -464,7 +508,8 @@ export {
   ensureWorkspace,
   isNewWorkspace,
   loadTemplate,
-  getCachedHttpEndpoint,
+  setToncenterApiKey,
+  invalidateEndpointCache,
   generateWallet,
   saveWallet,
   loadWallet,

package/dist/{chunk-RMLQS3X6.js → chunk-CB2Y45HA.js}

@@ -1,3 +1,7 @@
+import {
+  createLogger
+} from "./chunk-RCMD3U65.js";
+
 // src/config/providers.ts
 var PROVIDER_REGISTRY = {
   anthropic: {
@@ -154,8 +158,109 @@ function validateApiKeyFormat(provider, key) {
   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
+  validateApiKeyFormat,
+  getClaudeCodeApiKey,
+  refreshClaudeCodeApiKey,
+  isClaudeCodeTokenValid
 };

package/dist/{chunk-5PLZ3KSO.js → chunk-DMXTIRUW.js}

@@ -1,17 +1,15 @@
 import {
   getClaudeCodeApiKey,
+  getProviderMetadata,
   refreshClaudeCodeApiKey
-} from "./chunk-JQDLW7IE.js";
-import {
-  getProviderMetadata
-} from "./chunk-RMLQS3X6.js";
+} from "./chunk-CB2Y45HA.js";
 import {
   appendToTranscript,
   readTranscript
 } from "./chunk-OCLG5GKI.js";
 import {
   fetchWithTimeout
-} from "./chunk-VAUJSSD3.js";
+} from "./chunk-XQUHC3JZ.js";
 import {
   createLogger
 } from "./chunk-RCMD3U65.js";
@@ -306,7 +304,8 @@ async function chatWithContext(config, options) {
     apiKey: getEffectiveApiKey(provider, config.api_key),
     maxTokens: options.maxTokens ?? config.max_tokens,
     temperature,
-    sessionId: options.sessionId
+    sessionId: options.sessionId,
+    cacheRetention: "long"
   };
   if (isCocoon) {
     const { stripCocoonPayload } = await import("./tool-adapter-Y3TCEQOC.js");