teleton 0.6.0 → 0.7.1

package/dist/{task-dependency-resolver-72DLY2HV.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-RO62LO6Z.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-VXB6DAV2.js → task-executor-PD3H4MLO.js}

@@ -1,3 +1,6 @@
+import {
+  getErrorMessage
+} from "./chunk-XBE4JB7C.js";
 import {
   MAX_JSON_FIELD_CHARS,
   MAX_TOTAL_PROMPT_CHARS,
@@ -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-DKI2ZNOU.js → tool-index-MIVK3D7H.js}

@@ -1,17 +1,22 @@
 import {
   serializeEmbedding
-} from "./chunk-D5I7GBV7.js";
-import "./chunk-GDCODBNO.js";
-import "./chunk-4DU3C27M.js";
+} 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();
 }
@@ -46,7 +51,7 @@ var ToolIndex = class {
         );
       `);
     } catch (error) {
-      console.error("[tool-rag] Failed to create vector table:", error);
+      log.error({ err: error }, "Failed to create vector table");
       this.vectorEnabled = false;
     }
   }
@@ -95,7 +100,7 @@ var ToolIndex = class {
       this._isIndexed = true;
       return entries.length;
     } catch (error) {
-      console.error("[tool-rag] Indexing failed:", error);
+      log.error({ err: error }, "Indexing failed");
       this._isIndexed = false;
       return 0;
     }
@@ -141,9 +146,9 @@ var ToolIndex = class {
         });
         txn();
       }
-      console.log(`[tool-rag] Delta reindex: -${removed.length} +${added.length} tools`);
+      log.info(`Delta reindex: -${removed.length} +${added.length} tools`);
     } catch (error) {
-      console.error("[tool-rag] Delta reindex failed:", error);
+      log.error({ err: error }, "Delta reindex failed");
     }
   }
   /**
@@ -191,7 +196,7 @@ var ToolIndex = class {
         vectorScore: 1 - row.distance
       }));
     } catch (error) {
-      console.error("[tool-rag] Vector search error:", error);
+      log.error({ err: error }, "Vector search error");
       return [];
     }
   }
@@ -216,7 +221,7 @@ var ToolIndex = class {
         keywordScore: bm25ToScore(row.score)
       }));
     } catch (error) {
-      console.error("[tool-rag] FTS5 search error:", error);
+      log.error({ err: error }, "FTS5 search error");
       return [];
     }
   }

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,