teleton 0.6.0 → 0.7.0

package/dist/{chunk-ADCMUNYU.js → chunk-N3F7E7DR.js}

@@ -3,16 +3,19 @@ import {
   createEmbeddingProvider,
   hashText,
   serializeEmbedding
-} from "./chunk-D5I7GBV7.js";
+} from "./chunk-FNV5FF35.js";
 import {
   JOURNAL_SCHEMA
-} from "./chunk-ECSCVEQQ.js";
+} from "./chunk-UCN6TI25.js";
 import {
   HYBRID_SEARCH_MIN_SCORE,
   KNOWLEDGE_CHUNK_SIZE,
   SQLITE_CACHE_SIZE_KB,
   SQLITE_MMAP_SIZE
 } from "./chunk-RO62LO6Z.js";
+import {
+  createLogger
+} from "./chunk-RCMD3U65.js";
 
 // src/memory/database.ts
 import Database from "better-sqlite3";
@@ -21,6 +24,7 @@ import { dirname } from "path";
 import * as sqliteVec from "sqlite-vec";
 
 // src/memory/schema.ts
+var log = createLogger("Memory");
 function compareSemver(a, b) {
   const parseVersion = (v) => {
     const parts = v.split("-")[0].split(".").map(Number);
@@ -313,11 +317,11 @@ var CURRENT_SCHEMA_VERSION = "1.11.0";
 function runMigrations(db) {
   const currentVersion = getSchemaVersion(db);
   if (!currentVersion || versionLessThan(currentVersion, "1.1.0")) {
-    console.log("\u{1F4E6} Running migration: Adding scheduled task columns...");
+    log.info("Running migration: Adding scheduled task columns...");
     try {
       const tableExists = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='tasks'").get();
       if (!tableExists) {
-        console.log("  Tasks table doesn't exist yet, skipping column migration");
+        log.info("Tasks table doesn't exist yet, skipping column migration");
         setSchemaVersion(db, CURRENT_SCHEMA_VERSION);
         return;
       }
@@ -350,15 +354,15 @@ function runMigrations(db) {
         CREATE INDEX IF NOT EXISTS idx_task_deps_task ON task_dependencies(task_id);
         CREATE INDEX IF NOT EXISTS idx_task_deps_parent ON task_dependencies(depends_on_task_id);
       `);
-      console.log("\u2705 Migration 1.1.0 complete: Scheduled tasks support added");
+      log.info("Migration 1.1.0 complete: Scheduled tasks support added");
     } catch (error) {
-      console.error("\u274C Migration 1.1.0 failed:", error);
+      log.error({ err: error }, "Migration 1.1.0 failed");
       throw error;
     }
   }
   if (!currentVersion || versionLessThan(currentVersion, "1.2.0")) {
     try {
-      console.log("\u{1F504} Running migration 1.2.0: Extend sessions table for SQLite backend");
+      log.info("Running migration 1.2.0: Extend sessions table for SQLite backend");
       const addColumnIfNotExists = (table, column, type) => {
         try {
           db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${type}`);
@@ -387,14 +391,14 @@ function runMigrations(db) {
         );
       }
       db.exec("CREATE INDEX IF NOT EXISTS idx_sessions_updated ON sessions(updated_at DESC)");
-      console.log("\u2705 Migration 1.2.0 complete: Sessions table extended");
+      log.info("Migration 1.2.0 complete: Sessions table extended");
     } catch (error) {
-      console.error("\u274C Migration 1.2.0 failed:", error);
+      log.error({ err: error }, "Migration 1.2.0 failed");
       throw error;
     }
   }
   if (!currentVersion || versionLessThan(currentVersion, "1.9.0")) {
-    console.log("\u{1F504} Running migration 1.9.0: Upgrade embedding_cache to BLOB storage");
+    log.info("Running migration 1.9.0: Upgrade embedding_cache to BLOB storage");
     try {
       db.exec(`DROP TABLE IF EXISTS embedding_cache`);
       db.exec(`
@@ -410,14 +414,14 @@ function runMigrations(db) {
         );
         CREATE INDEX IF NOT EXISTS idx_embedding_cache_accessed ON embedding_cache(accessed_at);
       `);
-      console.log("\u2705 Migration 1.9.0 complete: embedding_cache upgraded to BLOB storage");
+      log.info("Migration 1.9.0 complete: embedding_cache upgraded to BLOB storage");
     } catch (error) {
-      console.error("\u274C Migration 1.9.0 failed:", error);
+      log.error({ err: error }, "Migration 1.9.0 failed");
       throw error;
     }
   }
   if (!currentVersion || versionLessThan(currentVersion, "1.10.0")) {
-    console.log("\u{1F504} Running migration 1.10.0: Add tool_config table for runtime tool management");
+    log.info("Running migration 1.10.0: Add tool_config table for runtime tool management");
     try {
       db.exec(`
         CREATE TABLE IF NOT EXISTS tool_config (
@@ -428,37 +432,37 @@ function runMigrations(db) {
           updated_by INTEGER
         );
       `);
-      console.log("\u2705 Migration 1.10.0 complete: tool_config table created");
+      log.info("Migration 1.10.0 complete: tool_config table created");
     } catch (error) {
-      console.error("\u274C Migration 1.10.0 failed:", error);
+      log.error({ err: error }, "Migration 1.10.0 failed");
       throw error;
     }
   }
   if (!currentVersion || versionLessThan(currentVersion, "1.10.1")) {
-    console.log(
-      "\u{1F504} Running migration 1.10.1: Fix tool_config scope CHECK constraint (add admin-only)"
-    );
+    log.info("Running migration 1.10.1: Fix tool_config scope CHECK constraint (add admin-only)");
     try {
-      db.exec(`
-        CREATE TABLE IF NOT EXISTS tool_config_new (
-          tool_name TEXT PRIMARY KEY,
-          enabled INTEGER NOT NULL DEFAULT 1 CHECK(enabled IN (0, 1)),
-          scope TEXT CHECK(scope IN ('always', 'dm-only', 'group-only', 'admin-only')),
-          updated_at INTEGER NOT NULL DEFAULT (unixepoch()),
-          updated_by INTEGER
-        );
-        INSERT OR IGNORE INTO tool_config_new SELECT * FROM tool_config;
-        DROP TABLE tool_config;
-        ALTER TABLE tool_config_new RENAME TO tool_config;
-      `);
-      console.log("\u2705 Migration 1.10.1 complete: tool_config CHECK constraint updated");
+      db.transaction(() => {
+        db.exec(`
+          CREATE TABLE IF NOT EXISTS tool_config_new (
+            tool_name TEXT PRIMARY KEY,
+            enabled INTEGER NOT NULL DEFAULT 1 CHECK(enabled IN (0, 1)),
+            scope TEXT CHECK(scope IN ('always', 'dm-only', 'group-only', 'admin-only')),
+            updated_at INTEGER NOT NULL DEFAULT (unixepoch()),
+            updated_by INTEGER
+          );
+          INSERT OR IGNORE INTO tool_config_new SELECT * FROM tool_config;
+          DROP TABLE tool_config;
+          ALTER TABLE tool_config_new RENAME TO tool_config;
+        `);
+      })();
+      log.info("Migration 1.10.1 complete: tool_config CHECK constraint updated");
     } catch (error) {
-      console.error("\u274C Migration 1.10.1 failed:", error);
+      log.error({ err: error }, "Migration 1.10.1 failed");
       throw error;
     }
   }
   if (!currentVersion || versionLessThan(currentVersion, "1.11.0")) {
-    console.log("\u{1F504} Running migration 1.11.0: Add tool_index tables for Tool RAG");
+    log.info("Running migration 1.11.0: Add tool_index tables for Tool RAG");
     try {
       db.exec(`
         CREATE TABLE IF NOT EXISTS tool_index (
@@ -490,9 +494,9 @@ function runMigrations(db) {
           VALUES (new.rowid, new.search_text, new.name);
         END;
       `);
-      console.log("\u2705 Migration 1.11.0 complete: tool_index tables created");
+      log.info("Migration 1.11.0 complete: tool_index tables created");
     } catch (error) {
-      console.error("\u274C Migration 1.11.0 failed:", error);
+      log.error({ err: error }, "Migration 1.11.0 failed");
       throw error;
     }
   }
@@ -500,6 +504,7 @@ function runMigrations(db) {
 }
 
 // src/memory/database.ts
+var log2 = createLogger("Memory");
 var MemoryDatabase = class {
   db;
   config;
@@ -511,7 +516,7 @@ var MemoryDatabase = class {
       mkdirSync(dir, { recursive: true });
     }
     this.db = new Database(config.path, {
-      verbose: process.env.DEBUG_SQL ? console.log : void 0
+      verbose: process.env.DEBUG_SQL ? (msg) => log2.debug(String(msg)) : void 0
     });
     try {
       chmodSync(config.path, 384);
@@ -551,18 +556,16 @@ var MemoryDatabase = class {
       ensureVectorTables(this.db, dims);
       this.vectorReady = true;
     } catch (error) {
-      console.warn(
-        `\u26A0\uFE0F  sqlite-vec not available, vector search disabled: ${error.message}`
-      );
-      console.warn("   Falling back to keyword-only search");
+      log2.warn(`sqlite-vec not available, vector search disabled: ${error.message}`);
+      log2.warn("Falling back to keyword-only search");
       this.config.enableVectorSearch = false;
     }
   }
   migrate(from, to) {
-    console.log(`Migrating database from ${from} to ${to}...`);
+    log2.info(`Migrating database from ${from} to ${to}...`);
     runMigrations(this.db);
     ensureSchema(this.db);
-    console.log("Migration complete");
+    log2.info("Migration complete");
   }
   getDb() {
     return this.db;
@@ -811,6 +814,7 @@ var KnowledgeIndexer = class {
 
 // src/memory/agent/sessions.ts
 import { randomUUID } from "crypto";
+var log3 = createLogger("Memory");
 var SessionStore = class {
   constructor(db, embedder, vectorEnabled) {
     this.db = db;
@@ -931,13 +935,12 @@ ${session.summary}`;
       ).run(knowledgeId, sessionId, text, hash);
       if (embedding && this.vectorEnabled) {
         const embeddingBuffer = serializeEmbedding(embedding);
-        const rowid = this.db.prepare(`SELECT rowid FROM knowledge WHERE id = ?`).get(knowledgeId);
-        this.db.prepare(`DELETE FROM knowledge_vec WHERE rowid = ?`).run(rowid.rowid);
-        this.db.prepare(`INSERT INTO knowledge_vec (rowid, embedding) VALUES (?, ?)`).run(rowid.rowid, embeddingBuffer);
+        this.db.prepare(`DELETE FROM knowledge_vec WHERE id = ?`).run(knowledgeId);
+        this.db.prepare(`INSERT INTO knowledge_vec (id, embedding) VALUES (?, ?)`).run(knowledgeId, embeddingBuffer);
       }
-      console.log(`Indexed session ${sessionId} to knowledge base`);
+      log3.info(`Indexed session ${sessionId} to knowledge base`);
     } catch (error) {
-      console.error("Error indexing session:", error);
+      log3.error({ err: error }, "Error indexing session");
     }
   }
   deleteSession(sessionId) {
@@ -1302,6 +1305,7 @@ var UserStore = class {
 };
 
 // src/memory/search/hybrid.ts
+var log4 = createLogger("Memory");
 function escapeFts5Query(query) {
   return query.replace(/["\*\-\+\(\)\:\^\~\?\.\@\#\$\%\&\!\[\]\{\}\|\\\/<>=,;'`]/g, " ").replace(/\s+/g, " ").trim();
 }
@@ -1349,7 +1353,7 @@ var HybridSearch = class {
         vectorScore: 1 - row.distance
       }));
     } catch (error) {
-      console.error("Vector search error (knowledge):", error);
+      log4.error({ err: error }, "Vector search error (knowledge)");
       return [];
     }
   }
@@ -1372,7 +1376,7 @@ var HybridSearch = class {
         keywordScore: this.bm25ToScore(row.score)
       }));
     } catch (error) {
-      console.error("FTS5 search error (knowledge):", error);
+      log4.error({ err: error }, "FTS5 search error (knowledge)");
       return [];
     }
   }
@@ -1407,7 +1411,7 @@ var HybridSearch = class {
         vectorScore: 1 - row.distance
       }));
     } catch (error) {
-      console.error("Vector search error (messages):", error);
+      log4.error({ err: error }, "Vector search error (messages)");
       return [];
     }
   }
@@ -1437,7 +1441,7 @@ var HybridSearch = class {
         keywordScore: this.bm25ToScore(row.score)
       }));
     } catch (error) {
-      console.error("FTS5 search error (messages):", error);
+      log4.error({ err: error }, "FTS5 search error (messages)");
       return [];
     }
   }
@@ -1467,6 +1471,7 @@ var HybridSearch = class {
 };
 
 // src/memory/search/context.ts
+var log5 = createLogger("Memory");
 var ContextBuilder = class {
   constructor(db, embedder, vectorEnabled) {
     this.db = db;
@@ -1500,7 +1505,7 @@ var ContextBuilder = class {
         });
         relevantKnowledge.push(...knowledgeResults.map((r) => r.text));
       } catch (error) {
-        console.warn("Knowledge search failed:", error);
+        log5.warn({ err: error }, "Knowledge search failed");
       }
     }
     const recentTextsSet = new Set(
@@ -1530,7 +1535,7 @@ var ContextBuilder = class {
           }
         }
       } catch (error) {
-        console.warn("Feed search failed:", error);
+        log5.warn({ err: error }, "Feed search failed");
       }
       if (relevantFeed.length === 0 && recentTgMessages.length > 0) {
         const recentTexts = recentTgMessages.filter((m) => m.text && m.text.length > 0).slice(-maxRelevantChunks).map((m) => {

package/dist/chunk-ND2X5FWB.js

@@ -0,0 +1,368 @@
+import {
+  getProviderMetadata
+} from "./chunk-LRCPA7SC.js";
+import {
+  appendToTranscript,
+  readTranscript
+} from "./chunk-OCLG5GKI.js";
+import {
+  fetchWithTimeout
+} from "./chunk-VAUJSSD3.js";
+import {
+  createLogger
+} from "./chunk-RCMD3U65.js";
+
+// src/agent/client.ts
+import {
+  complete,
+  getModel
+} from "@mariozechner/pi-ai";
+
+// src/agent/schema-sanitizer.ts
+var UNSUPPORTED_KEYS = /* @__PURE__ */ new Set([
+  "$schema",
+  "$id",
+  "$ref",
+  "$defs",
+  "$anchor",
+  "title",
+  "default",
+  "examples"
+]);
+function sanitizeSchema(schema) {
+  if (!schema || typeof schema !== "object") return schema;
+  const result = { ...schema };
+  for (const key of UNSUPPORTED_KEYS) {
+    delete result[key];
+  }
+  if (Array.isArray(result.anyOf)) {
+    const items = result.anyOf;
+    const nonNull = items.filter((s) => s.type !== "null");
+    const allConst = nonNull.length > 0 && nonNull.every((s) => s.const !== void 0);
+    if (allConst) {
+      const enumValues = nonNull.map((s) => s.const);
+      const inferredType = nonNull[0]?.type || "string";
+      delete result.anyOf;
+      result.type = inferredType;
+      result.enum = enumValues;
+    } else if (nonNull.length > 0) {
+      delete result.anyOf;
+      const first = nonNull[0];
+      if (first.type) result.type = first.type;
+      if (first.enum) result.enum = first.enum;
+      if (first.description && !result.description) {
+        result.description = first.description;
+      }
+    }
+  }
+  if (Array.isArray(result.anyOf)) {
+    delete result.anyOf;
+    if (!result.type) result.type = "string";
+  }
+  if (result.const !== void 0) {
+    result.enum = [result.const];
+    if (!result.type) {
+      const jsType = typeof result.const;
+      result.type = jsType === "string" ? "string" : jsType === "boolean" ? "boolean" : "number";
+    }
+    delete result.const;
+  }
+  if (result.properties && typeof result.properties === "object") {
+    const props = result.properties;
+    const sanitized = {};
+    for (const [key, value] of Object.entries(props)) {
+      sanitized[key] = value && typeof value === "object" && !Array.isArray(value) ? sanitizeSchema(value) : value;
+    }
+    result.properties = sanitized;
+  }
+  if (result.items && typeof result.items === "object" && !Array.isArray(result.items)) {
+    result.items = sanitizeSchema(result.items);
+  }
+  return result;
+}
+function sanitizeToolsForGemini(tools) {
+  return tools.map(
+    (tool) => ({
+      ...tool,
+      parameters: sanitizeSchema({ ...tool.parameters })
+    })
+  );
+}
+
+// src/agent/client.ts
+var log = createLogger("LLM");
+function isOAuthToken(apiKey, provider) {
+  if (provider && provider !== "anthropic") return false;
+  return apiKey.startsWith("sk-ant-oat01-");
+}
+function getEffectiveApiKey(provider, rawKey) {
+  if (provider === "local") return "local";
+  if (provider === "cocoon") return "";
+  return rawKey;
+}
+var modelCache = /* @__PURE__ */ new Map();
+var COCOON_MODELS = {};
+async function registerCocoonModels(httpPort) {
+  try {
+    const res = await fetch(`http://localhost:${httpPort}/v1/models`);
+    if (!res.ok) return [];
+    const body = await res.json();
+    const models = body.data || body.models || [];
+    if (!Array.isArray(models)) return [];
+    const ids = [];
+    for (const m of models) {
+      const id = m.id || m.name || String(m);
+      COCOON_MODELS[id] = {
+        id,
+        name: id,
+        api: "openai-completions",
+        provider: "cocoon",
+        baseUrl: `http://localhost:${httpPort}/v1`,
+        reasoning: false,
+        input: ["text"],
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+        contextWindow: 128e3,
+        maxTokens: 4096,
+        compat: {
+          supportsStore: false,
+          supportsDeveloperRole: false,
+          supportsReasoningEffort: false
+        }
+      };
+      ids.push(id);
+    }
+    return ids;
+  } catch {
+    return [];
+  }
+}
+var LOCAL_MODELS = {};
+async function registerLocalModels(baseUrl) {
+  try {
+    const parsed = new URL(baseUrl);
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+      log.warn(`Local LLM base_url must use http or https (got ${parsed.protocol})`);
+      return [];
+    }
+    const url = baseUrl.replace(/\/+$/, "");
+    const res = await fetchWithTimeout(`${url}/models`, { timeoutMs: 1e4 });
+    if (!res.ok) return [];
+    const body = await res.json();
+    const rawModels = body.data || body.models || [];
+    if (!Array.isArray(rawModels)) return [];
+    const models = rawModels.slice(0, 500);
+    const ids = [];
+    for (const m of models) {
+      const id = m.id || m.name || String(m);
+      LOCAL_MODELS[id] = {
+        id,
+        name: id,
+        api: "openai-completions",
+        provider: "local",
+        baseUrl: url,
+        reasoning: false,
+        input: ["text"],
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+        contextWindow: 128e3,
+        maxTokens: 4096,
+        compat: {
+          supportsStore: false,
+          supportsDeveloperRole: false,
+          supportsReasoningEffort: false,
+          supportsStrictMode: false,
+          maxTokensField: "max_tokens"
+        }
+      };
+      ids.push(id);
+    }
+    return ids;
+  } catch {
+    return [];
+  }
+}
+var MOONSHOT_MODELS = {
+  "kimi-k2.5": {
+    id: "kimi-k2.5",
+    name: "Kimi K2.5",
+    api: "openai-completions",
+    provider: "moonshot",
+    baseUrl: "https://api.moonshot.ai/v1",
+    reasoning: false,
+    input: ["text", "image"],
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    contextWindow: 256e3,
+    maxTokens: 8192
+  },
+  "kimi-k2-thinking": {
+    id: "kimi-k2-thinking",
+    name: "Kimi K2 Thinking",
+    api: "openai-completions",
+    provider: "moonshot",
+    baseUrl: "https://api.moonshot.ai/v1",
+    reasoning: true,
+    input: ["text"],
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    contextWindow: 256e3,
+    maxTokens: 8192
+  }
+};
+function getProviderModel(provider, modelId) {
+  const cacheKey = `${provider}:${modelId}`;
+  const cached = modelCache.get(cacheKey);
+  if (cached) return cached;
+  const meta = getProviderMetadata(provider);
+  if (meta.piAiProvider === "cocoon") {
+    let model = COCOON_MODELS[modelId];
+    if (!model) {
+      model = Object.values(COCOON_MODELS)[0];
+      if (model) log.warn(`Cocoon model "${modelId}" not found, using "${model.id}"`);
+    }
+    if (model) {
+      modelCache.set(cacheKey, model);
+      return model;
+    }
+    throw new Error("No Cocoon models available. Is the cocoon client running?");
+  }
+  if (meta.piAiProvider === "local") {
+    let model = LOCAL_MODELS[modelId];
+    if (!model) {
+      model = Object.values(LOCAL_MODELS)[0];
+      if (model) log.warn(`Local model "${modelId}" not found, using "${model.id}"`);
+    }
+    if (model) {
+      modelCache.set(cacheKey, model);
+      return model;
+    }
+    throw new Error("No local models available. Is the LLM server running?");
+  }
+  if (meta.piAiProvider === "moonshot") {
+    const model = MOONSHOT_MODELS[modelId] ?? MOONSHOT_MODELS[meta.defaultModel];
+    if (model) {
+      modelCache.set(cacheKey, model);
+      return model;
+    }
+  }
+  try {
+    const model = getModel(meta.piAiProvider, modelId);
+    if (!model) {
+      throw new Error(`getModel returned undefined for ${provider}/${modelId}`);
+    }
+    modelCache.set(cacheKey, model);
+    return model;
+  } catch (e) {
+    log.warn(`Model ${modelId} not found for ${provider}, falling back to ${meta.defaultModel}`);
+    const fallbackKey = `${provider}:${meta.defaultModel}`;
+    const fallbackCached = modelCache.get(fallbackKey);
+    if (fallbackCached) return fallbackCached;
+    try {
+      const model = getModel(meta.piAiProvider, meta.defaultModel);
+      if (!model) {
+        throw new Error(
+          `Fallback model ${meta.defaultModel} also returned undefined for ${provider}`
+        );
+      }
+      modelCache.set(fallbackKey, model);
+      return model;
+    } catch {
+      throw new Error(
+        `Could not find model ${modelId} or fallback ${meta.defaultModel} for ${provider}`
+      );
+    }
+  }
+}
+function getUtilityModel(provider, overrideModel) {
+  const meta = getProviderMetadata(provider);
+  const modelId = overrideModel || meta.utilityModel;
+  return getProviderModel(provider, modelId);
+}
+async function chatWithContext(config, options) {
+  const provider = config.provider || "anthropic";
+  const model = getProviderModel(provider, config.model);
+  const isCocoon = provider === "cocoon";
+  let tools = provider === "google" && options.tools ? sanitizeToolsForGemini(options.tools) : options.tools;
+  let systemPrompt = options.systemPrompt || options.context.systemPrompt || "";
+  let cocoonAllowedTools;
+  if (isCocoon) {
+    systemPrompt = "/no_think\n" + systemPrompt;
+    if (tools && tools.length > 0) {
+      cocoonAllowedTools = new Set(tools.map((t) => t.name));
+      const { injectToolsIntoSystemPrompt } = await import("./tool-adapter-Y3TCEQOC.js");
+      systemPrompt = injectToolsIntoSystemPrompt(systemPrompt, tools);
+      tools = void 0;
+    }
+  }
+  const context = {
+    ...options.context,
+    systemPrompt,
+    tools
+  };
+  const temperature = provider === "moonshot" ? 1 : options.temperature ?? config.temperature;
+  const completeOptions = {
+    apiKey: getEffectiveApiKey(provider, config.api_key),
+    maxTokens: options.maxTokens ?? config.max_tokens,
+    temperature,
+    sessionId: options.sessionId
+  };
+  if (isCocoon) {
+    const { stripCocoonPayload } = await import("./tool-adapter-Y3TCEQOC.js");
+    completeOptions.onPayload = stripCocoonPayload;
+  }
+  const response = await complete(model, context, completeOptions);
+  if (isCocoon) {
+    const textBlock = response.content.find((b) => b.type === "text");
+    if (textBlock?.type === "text" && textBlock.text.includes("<tool_call>")) {
+      const { parseToolCallsFromText, extractPlainText } = await import("./tool-adapter-Y3TCEQOC.js");
+      const syntheticCalls = parseToolCallsFromText(textBlock.text, cocoonAllowedTools);
+      if (syntheticCalls.length > 0) {
+        const plainText = extractPlainText(textBlock.text);
+        response.content = [
+          ...plainText ? [{ type: "text", text: plainText }] : [],
+          ...syntheticCalls
+        ];
+        response.stopReason = "toolUse";
+      }
+    }
+  }
+  const thinkRe = /<think>[\s\S]*?<\/think>/g;
+  for (const block of response.content) {
+    if (block.type === "text" && block.text.includes("<think>")) {
+      block.text = block.text.replace(thinkRe, "").trim();
+    }
+  }
+  if (options.persistTranscript && options.sessionId) {
+    appendToTranscript(options.sessionId, response);
+  }
+  const textContent = response.content.find((block) => block.type === "text");
+  const text = textContent?.type === "text" ? textContent.text : "";
+  const updatedContext = {
+    ...context,
+    messages: [...context.messages, response]
+  };
+  return {
+    message: response,
+    text,
+    context: updatedContext
+  };
+}
+function loadContextFromTranscript(sessionId, systemPrompt) {
+  const messages = readTranscript(sessionId);
+  return {
+    systemPrompt,
+    messages
+  };
+}
+function createClient(_config) {
+  return null;
+}
+
+export {
+  isOAuthToken,
+  getEffectiveApiKey,
+  registerCocoonModels,
+  registerLocalModels,
+  getProviderModel,
+  getUtilityModel,
+  chatWithContext,
+  loadContextFromTranscript,
+  createClient
+};