teleton 0.5.2 → 0.7.0

package/dist/{task-dependency-resolver-TRPILAHM.js → task-dependency-resolver-WKZWJLLM.js}

@@ -1,12 +1,16 @@
+import {
+  MAX_DEPENDENTS_PER_TASK
+} from "./chunk-RO62LO6Z.js";
 import {
   BATCH_TRIGGER_DELAY_MS
 } from "./chunk-4DU3C27M.js";
 import {
-  MAX_DEPENDENTS_PER_TASK
-} from "./chunk-O4R7V5Y2.js";
+  createLogger
+} from "./chunk-RCMD3U65.js";
 import "./chunk-QGM4M3NI.js";
 
 // src/telegram/task-dependency-resolver.ts
+var log = createLogger("Telegram");
 var TaskDependencyResolver = class {
   constructor(taskStore, bridge) {
     this.taskStore = taskStore;
@@ -28,25 +32,25 @@ var TaskDependencyResolver = class {
       const dependentIds = allDependentIds.slice(0, MAX_DEPENDENTS_PER_TASK);
       const truncated = allDependentIds.length > MAX_DEPENDENTS_PER_TASK;
       if (truncated) {
-        console.warn(
+        log.warn(
           `\u26A0\uFE0F Task ${completedTaskId} has ${allDependentIds.length} dependents, only processing first ${MAX_DEPENDENTS_PER_TASK} (security limit)`
         );
       }
-      console.log(
+      log.info(
         `\u{1F4CA} Task ${completedTaskId} completed. Checking ${dependentIds.length} dependent task(s)...`
       );
       const tasksToTrigger = [];
       for (const depId of dependentIds) {
         const task = this.taskStore.getTask(depId);
         if (!task) {
-          console.warn(`Dependent task ${depId} not found`);
+          log.warn(`Dependent task ${depId} not found`);
           continue;
         }
         if (task.status !== "pending") {
           continue;
         }
         if (!this.taskStore.canExecute(depId)) {
-          console.log(`\u23F3 Task ${depId} still waiting for dependencies`);
+          log.info(`\u23F3 Task ${depId} still waiting for dependencies`);
           continue;
         }
         tasksToTrigger.push(task.id);
@@ -58,7 +62,7 @@ var TaskDependencyResolver = class {
         await this.triggerTask(tasksToTrigger[i]);
       }
     } catch (error) {
-      console.error("Error in dependency resolver:", error);
+      log.error({ err: error }, "Error in dependency resolver");
     }
   }
   /**
@@ -83,11 +87,11 @@ var TaskDependencyResolver = class {
       const dependentIds = allDependentIds.slice(0, MAX_DEPENDENTS_PER_TASK);
       const truncated = allDependentIds.length > MAX_DEPENDENTS_PER_TASK;
       if (truncated) {
-        console.warn(
+        log.warn(
           `\u26A0\uFE0F Task ${failedTaskId} has ${allDependentIds.length} dependents, only cancelling first ${MAX_DEPENDENTS_PER_TASK} (security limit)`
         );
       }
-      console.log(
+      log.info(
         `\u274C Task ${failedTaskId} failed. Cancelling ${dependentIds.length} dependent task(s)...`
       );
       for (const depId of dependentIds) {
@@ -105,12 +109,12 @@ var TaskDependencyResolver = class {
         }
         if (skipOnFailure) {
           this.taskStore.cancelTask(depId);
-          console.log(`  \u21B3 Cancelled task ${depId}: ${task.description}`);
+          log.info(`\u21B3 Cancelled task ${depId}: ${task.description}`);
           await this.onTaskFail(depId);
         }
       }
     } catch (error) {
-      console.error("Error handling task failure cascade:", error);
+      log.error({ err: error }, "Error handling task failure cascade");
     }
   }
   /**
@@ -120,18 +124,18 @@ var TaskDependencyResolver = class {
     try {
       const task = this.taskStore.getTask(taskId);
       if (!task) {
-        console.warn(`Cannot trigger task ${taskId}: not found`);
+        log.warn(`Cannot trigger task ${taskId}: not found`);
         return;
       }
-      console.log(`\u{1F680} Triggering dependent task: ${task.description}`);
+      log.info(`\u{1F680} Triggering dependent task: ${task.description}`);
       const gramJsClient = this.bridge.getClient().getClient();
       const me = await gramJsClient.getMe();
       await gramJsClient.sendMessage(me, {
         message: `[TASK:${taskId}] ${task.description}`
       });
-      console.log(`  \u21B3 Sent [TASK:${taskId}] to Saved Messages`);
+      log.info(`\u21B3 Sent [TASK:${taskId}] to Saved Messages`);
     } catch (error) {
-      console.error(`Error triggering task ${taskId}:`, error);
+      log.error({ err: error }, `Error triggering task ${taskId}`);
       this.taskStore.failTask(taskId, `Failed to trigger: ${error}`);
     }
   }

package/dist/{task-executor-N7XNVK5N.js → task-executor-PD3H4MLO.js}

@@ -1,9 +1,12 @@
+import {
+  getErrorMessage
+} from "./chunk-XBE4JB7C.js";
 import {
   MAX_JSON_FIELD_CHARS,
   MAX_TOTAL_PROMPT_CHARS,
   SECONDS_PER_DAY,
   SECONDS_PER_HOUR
-} from "./chunk-O4R7V5Y2.js";
+} from "./chunk-RO62LO6Z.js";
 import "./chunk-QGM4M3NI.js";
 
 // src/telegram/task-executor.ts
@@ -42,7 +45,7 @@ async function executeScheduledTask(task, agent, toolContext, toolRegistry, pare
         {
           toolExecuted: payload.tool,
           toolParams: payload.params,
-          toolError: error instanceof Error ? error.message : String(error)
+          toolError: getErrorMessage(error)
         },
         parentResults
       );

package/dist/tool-adapter-Y3TCEQOC.js

@@ -0,0 +1,145 @@
+import {
+  createLogger
+} from "./chunk-RCMD3U65.js";
+import "./chunk-QGM4M3NI.js";
+
+// src/cocoon/tool-adapter.ts
+import { randomUUID } from "crypto";
+var log = createLogger("Cocoon");
+var TOOL_PREAMBLE = `
+
+# Tools
+
+You may call one or more functions to assist with the user query.
+
+You are provided with function signatures within <tools></tools> XML tags:
+<tools>
+`;
+var TOOL_POSTAMBLE = `</tools>
+
+For each function call, return a json object with function name and arguments within <tool_call></tool_call> XML tags:
+<tool_call>
+{"name": <function-name>, "arguments": <args-json-object>}
+</tool_call>`;
+function injectToolsIntoSystemPrompt(systemPrompt, tools) {
+  if (!tools || tools.length === 0) return systemPrompt;
+  const toolLines = tools.map(
+    (t) => JSON.stringify({
+      type: "function",
+      function: {
+        name: t.name,
+        description: t.description,
+        parameters: t.parameters
+      }
+    })
+  );
+  return systemPrompt + TOOL_PREAMBLE + toolLines.join("\n") + "\n" + TOOL_POSTAMBLE;
+}
+var UNSUPPORTED_FIELDS = ["tools", "tool_choice", "store", "reasoning_effort", "stream_options"];
+function stripCocoonPayload(payload) {
+  if (typeof payload !== "object" || payload === null) return;
+  const obj = payload;
+  for (const field of UNSUPPORTED_FIELDS) {
+    delete obj[field];
+  }
+  obj.presence_penalty = obj.presence_penalty ?? 1.5;
+}
+var TOOL_CALL_OPEN = "<tool_call>";
+var TOOL_CALL_CLOSE = "</tool_call>";
+var THINK_RE = /<think>[\s\S]*?<\/think>/g;
+function extractJsonObject(text, startIndex) {
+  let braceCount = 0;
+  let inString = false;
+  let escaped = false;
+  for (let i = startIndex; i < text.length; i++) {
+    const ch = text[i];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (ch === "\\" && inString) {
+      escaped = true;
+      continue;
+    }
+    if (ch === '"') {
+      inString = !inString;
+      continue;
+    }
+    if (!inString) {
+      if (ch === "{") braceCount++;
+      if (ch === "}") {
+        braceCount--;
+        if (braceCount === 0) {
+          return { json: text.slice(startIndex, i + 1), endIndex: i };
+        }
+      }
+    }
+  }
+  return null;
+}
+function parseToolCallsFromText(text, allowedTools) {
+  const cleaned = text.replace(THINK_RE, "").trim();
+  const calls = [];
+  let searchFrom = 0;
+  while (true) {
+    const openIdx = cleaned.indexOf(TOOL_CALL_OPEN, searchFrom);
+    if (openIdx === -1) break;
+    const contentStart = openIdx + TOOL_CALL_OPEN.length;
+    const closeIdx = cleaned.indexOf(TOOL_CALL_CLOSE, contentStart);
+    if (closeIdx === -1) break;
+    const braceStart = cleaned.indexOf("{", contentStart);
+    if (braceStart === -1 || braceStart >= closeIdx) {
+      searchFrom = closeIdx + TOOL_CALL_CLOSE.length;
+      continue;
+    }
+    const extracted = extractJsonObject(cleaned, braceStart);
+    if (extracted) {
+      try {
+        const parsed = JSON.parse(extracted.json);
+        if (parsed.name && typeof parsed.name === "string") {
+          if (allowedTools && !allowedTools.has(parsed.name)) {
+            log.warn(`Cocoon: rejected tool call "${parsed.name}" \u2014 not in allowed set`);
+          } else {
+            calls.push({
+              type: "toolCall",
+              id: `cocoon_${randomUUID()}`,
+              name: parsed.name,
+              arguments: parsed.arguments ?? {}
+            });
+          }
+        }
+      } catch (e) {
+        log.debug(`Failed to parse tool call JSON: ${String(e)}`);
+        log.debug(`Raw: ${extracted.json.slice(0, 200)}`);
+      }
+    }
+    searchFrom = closeIdx + TOOL_CALL_CLOSE.length;
+  }
+  return calls;
+}
+function extractPlainText(text) {
+  let result = text.replace(THINK_RE, "");
+  let searchFrom = 0;
+  while (true) {
+    const openIdx = result.indexOf(TOOL_CALL_OPEN, searchFrom);
+    if (openIdx === -1) break;
+    const closeIdx = result.indexOf(TOOL_CALL_CLOSE, openIdx);
+    if (closeIdx === -1) break;
+    result = result.slice(0, openIdx) + result.slice(closeIdx + TOOL_CALL_CLOSE.length);
+    searchFrom = openIdx;
+  }
+  return result.trim();
+}
+function wrapToolResult(resultText) {
+  const safe = resultText.replace(/]]>/g, "]]]]><![CDATA[>");
+  return `<tool_response>
+<![CDATA[${safe}]]>
+</tool_response>`;
+}
+export {
+  extractPlainText,
+  injectToolsIntoSystemPrompt,
+  parseToolCallsFromText,
+  stripCocoonPayload,
+  wrapToolResult
+};

package/dist/tool-index-MIVK3D7H.js

@@ -0,0 +1,250 @@
+import {
+  serializeEmbedding
+} from "./chunk-FNV5FF35.js";
+import "./chunk-XBKSS6DM.js";
+import {
+  TOOL_RAG_KEYWORD_WEIGHT,
+  TOOL_RAG_MIN_SCORE,
+  TOOL_RAG_VECTOR_WEIGHT
+} from "./chunk-RO62LO6Z.js";
+import "./chunk-VAUJSSD3.js";
+import "./chunk-4DU3C27M.js";
+import "./chunk-EYWNOHMJ.js";
+import {
+  createLogger
+} from "./chunk-RCMD3U65.js";
+import "./chunk-QGM4M3NI.js";
+
+// src/agent/tools/tool-index.ts
+var log = createLogger("ToolRAG");
+function escapeFts5Query(query) {
+  return query.replace(/["\*\-\+\(\)\:\^\~\?\.\@\#\$\%\&\!\[\]\{\}\|\\\/<>=,;'`]/g, " ").replace(/\s+/g, " ").trim();
+}
+function bm25ToScore(rank) {
+  return 1 / (1 + Math.exp(rank));
+}
+var ToolIndex = class {
+  constructor(db, embedder, vectorEnabled, config) {
+    this.db = db;
+    this.embedder = embedder;
+    this.vectorEnabled = vectorEnabled;
+    this.config = config;
+  }
+  _isIndexed = false;
+  get isIndexed() {
+    return this._isIndexed;
+  }
+  /**
+   * Create the vector table (dimensions are dynamic, so can't be in schema migration).
+   */
+  ensureSchema() {
+    if (!this.vectorEnabled || this.embedder.dimensions === 0) return;
+    try {
+      const existing = this.db.prepare(`SELECT sql FROM sqlite_master WHERE type='table' AND name='tool_index_vec'`).get();
+      if (existing?.sql && !existing.sql.includes(`[${this.embedder.dimensions}]`)) {
+        this.db.exec(`DROP TABLE IF EXISTS tool_index_vec`);
+      }
+      this.db.exec(`
+        CREATE VIRTUAL TABLE IF NOT EXISTS tool_index_vec USING vec0(
+          name TEXT PRIMARY KEY,
+          embedding FLOAT[${this.embedder.dimensions}] distance_metric=cosine
+        );
+      `);
+    } catch (error) {
+      log.error({ err: error }, "Failed to create vector table");
+      this.vectorEnabled = false;
+    }
+  }
+  /**
+   * Index all registered tools. Replaces any previous index.
+   */
+  async indexAll(tools) {
+    try {
+      this.db.exec(`DELETE FROM tool_index`);
+      if (this.vectorEnabled) {
+        try {
+          this.db.exec(`DELETE FROM tool_index_vec`);
+        } catch {
+        }
+      }
+      const entries = tools.map((t) => ({
+        name: t.name,
+        description: t.description ?? "",
+        searchText: `${t.name} \u2014 ${t.description ?? ""}`
+      }));
+      const embeddings = [];
+      if (this.vectorEnabled && this.embedder.dimensions > 0) {
+        const texts = entries.map((e) => e.searchText);
+        const batchSize = 128;
+        for (let i = 0; i < texts.length; i += batchSize) {
+          const batch = texts.slice(i, i + batchSize);
+          const batchEmbeddings = await this.embedder.embedBatch(batch);
+          embeddings.push(...batchEmbeddings);
+        }
+      }
+      const insertTool = this.db.prepare(`
+        INSERT INTO tool_index (name, description, search_text, updated_at)
+        VALUES (?, ?, ?, unixepoch())
+      `);
+      const insertVec = this.vectorEnabled ? this.db.prepare(`INSERT INTO tool_index_vec (name, embedding) VALUES (?, ?)`) : null;
+      const txn = this.db.transaction(() => {
+        for (let i = 0; i < entries.length; i++) {
+          const e = entries[i];
+          insertTool.run(e.name, e.description, e.searchText);
+          if (insertVec && embeddings[i]?.length > 0) {
+            insertVec.run(e.name, serializeEmbedding(embeddings[i]));
+          }
+        }
+      });
+      txn();
+      this._isIndexed = true;
+      return entries.length;
+    } catch (error) {
+      log.error({ err: error }, "Indexing failed");
+      this._isIndexed = false;
+      return 0;
+    }
+  }
+  /**
+   * Delta update for hot-reload plugins.
+   */
+  async reindexTools(removed, added) {
+    try {
+      if (removed.length > 0) {
+        const deleteTool = this.db.prepare(`DELETE FROM tool_index WHERE name = ?`);
+        const deleteVec = this.vectorEnabled ? this.db.prepare(`DELETE FROM tool_index_vec WHERE name = ?`) : null;
+        for (const name of removed) {
+          deleteTool.run(name);
+          deleteVec?.run(name);
+        }
+      }
+      if (added.length > 0) {
+        const entries = added.map((t) => ({
+          name: t.name,
+          description: t.description ?? "",
+          searchText: `${t.name} \u2014 ${t.description ?? ""}`
+        }));
+        let embeddings = [];
+        if (this.vectorEnabled && this.embedder.dimensions > 0) {
+          embeddings = await this.embedder.embedBatch(entries.map((e) => e.searchText));
+        }
+        const insertTool = this.db.prepare(`
+          INSERT OR REPLACE INTO tool_index (name, description, search_text, updated_at)
+          VALUES (?, ?, ?, unixepoch())
+        `);
+        const deleteVec = this.vectorEnabled ? this.db.prepare(`DELETE FROM tool_index_vec WHERE name = ?`) : null;
+        const insertVec = this.vectorEnabled ? this.db.prepare(`INSERT INTO tool_index_vec (name, embedding) VALUES (?, ?)`) : null;
+        const txn = this.db.transaction(() => {
+          for (let i = 0; i < entries.length; i++) {
+            const e = entries[i];
+            insertTool.run(e.name, e.description, e.searchText);
+            if (insertVec && embeddings[i]?.length > 0) {
+              deleteVec.run(e.name);
+              insertVec.run(e.name, serializeEmbedding(embeddings[i]));
+            }
+          }
+        });
+        txn();
+      }
+      log.info(`Delta reindex: -${removed.length} +${added.length} tools`);
+    } catch (error) {
+      log.error({ err: error }, "Delta reindex failed");
+    }
+  }
+  /**
+   * Hybrid search: vector + FTS5, same pattern as HybridSearch.
+   */
+  async search(query, queryEmbedding, limit) {
+    const topK = limit ?? this.config.topK;
+    const vectorResults = this.vectorEnabled ? this.vectorSearch(queryEmbedding, topK * 3) : [];
+    const keywordResults = this.keywordSearch(query, topK * 3);
+    return this.mergeResults(vectorResults, keywordResults, topK);
+  }
+  /**
+   * Check if a tool name matches any always-include pattern.
+   */
+  isAlwaysIncluded(toolName) {
+    for (const pattern of this.config.alwaysInclude) {
+      if (pattern.endsWith("*")) {
+        const prefix = pattern.slice(0, -1);
+        if (toolName.startsWith(prefix)) return true;
+      } else if (toolName === pattern) {
+        return true;
+      }
+    }
+    return false;
+  }
+  vectorSearch(embedding, limit) {
+    if (!this.vectorEnabled || embedding.length === 0) return [];
+    try {
+      const embeddingBuffer = serializeEmbedding(embedding);
+      const rows = this.db.prepare(
+        `
+          SELECT tv.name, ti.description, tv.distance
+          FROM (
+            SELECT name, distance
+            FROM tool_index_vec
+            WHERE embedding MATCH ? AND k = ?
+          ) tv
+          JOIN tool_index ti ON ti.name = tv.name
+        `
+      ).all(embeddingBuffer, limit);
+      return rows.map((row) => ({
+        name: row.name,
+        description: row.description,
+        score: 1 - row.distance,
+        vectorScore: 1 - row.distance
+      }));
+    } catch (error) {
+      log.error({ err: error }, "Vector search error");
+      return [];
+    }
+  }
+  keywordSearch(query, limit) {
+    const safeQuery = escapeFts5Query(query);
+    if (!safeQuery) return [];
+    try {
+      const rows = this.db.prepare(
+        `
+          SELECT ti.name, ti.description, rank as score
+          FROM tool_index_fts tf
+          JOIN tool_index ti ON ti.rowid = tf.rowid
+          WHERE tool_index_fts MATCH ?
+          ORDER BY rank
+          LIMIT ?
+        `
+      ).all(safeQuery, limit);
+      return rows.map((row) => ({
+        name: row.name,
+        description: row.description,
+        score: bm25ToScore(row.score),
+        keywordScore: bm25ToScore(row.score)
+      }));
+    } catch (error) {
+      log.error({ err: error }, "FTS5 search error");
+      return [];
+    }
+  }
+  mergeResults(vectorResults, keywordResults, limit) {
+    const byName = /* @__PURE__ */ new Map();
+    for (const r of vectorResults) {
+      byName.set(r.name, { ...r, vectorScore: r.score });
+    }
+    for (const r of keywordResults) {
+      const existing = byName.get(r.name);
+      if (existing) {
+        existing.keywordScore = r.keywordScore;
+        existing.score = TOOL_RAG_VECTOR_WEIGHT * (existing.vectorScore ?? 0) + TOOL_RAG_KEYWORD_WEIGHT * (r.keywordScore ?? 0);
+      } else {
+        byName.set(r.name, {
+          ...r,
+          score: TOOL_RAG_KEYWORD_WEIGHT * (r.keywordScore ?? 0)
+        });
+      }
+    }
+    return Array.from(byName.values()).filter((r) => r.score >= TOOL_RAG_MIN_SCORE).sort((a, b) => b.score - a.score).slice(0, limit);
+  }
+};
+export {
+  ToolIndex
+};

package/dist/{transcript-7V4UNID4.js → transcript-UDJZP6NK.js}

@@ -7,8 +7,9 @@ import {
   getTranscriptSize,
   readTranscript,
   transcriptExists
-} from "./chunk-YBA6IBGT.js";
+} from "./chunk-OCLG5GKI.js";
 import "./chunk-EYWNOHMJ.js";
+import "./chunk-RCMD3U65.js";
 import "./chunk-QGM4M3NI.js";
 export {
   appendToTranscript,