teleton 0.8.4 → 0.8.6

package/dist/chunk-CXTZPOTA.js

@@ -0,0 +1,107 @@
+import {
+  TELETON_ROOT,
+  WORKSPACE_PATHS,
+  WORKSPACE_ROOT
+} from "./chunk-L653KKCR.js";
+import {
+  createLogger
+} from "./chunk-V3S3NXBQ.js";
+
+// src/workspace/manager.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync, copyFileSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+var log = createLogger("Workspace");
+function findPackageRoot() {
+  let dir = dirname(fileURLToPath(import.meta.url));
+  for (let i = 0; i < 10; i++) {
+    if (existsSync(join(dir, "package.json"))) return dir;
+    dir = dirname(dir);
+  }
+  return process.cwd();
+}
+var TEMPLATES_DIR = join(findPackageRoot(), "src", "templates");
+async function ensureWorkspace(config) {
+  const silent = config?.silent ?? false;
+  if (!existsSync(TELETON_ROOT)) {
+    mkdirSync(TELETON_ROOT, { recursive: true });
+    if (!silent) log.info(`Created Teleton root at ${TELETON_ROOT}`);
+  }
+  if (!existsSync(WORKSPACE_ROOT)) {
+    mkdirSync(WORKSPACE_ROOT, { recursive: true });
+    if (!silent) log.info(`Created workspace at ${WORKSPACE_ROOT}`);
+  }
+  const directories = [
+    WORKSPACE_PATHS.MEMORY_DIR,
+    WORKSPACE_PATHS.DOWNLOADS_DIR,
+    WORKSPACE_PATHS.UPLOADS_DIR,
+    WORKSPACE_PATHS.TEMP_DIR,
+    WORKSPACE_PATHS.MEMES_DIR
+  ];
+  for (const dir of directories) {
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+  }
+  const workspace = {
+    root: TELETON_ROOT,
+    workspace: WORKSPACE_ROOT,
+    // Workspace files
+    soulPath: WORKSPACE_PATHS.SOUL,
+    memoryPath: WORKSPACE_PATHS.MEMORY,
+    identityPath: WORKSPACE_PATHS.IDENTITY,
+    userPath: WORKSPACE_PATHS.USER,
+    strategyPath: WORKSPACE_PATHS.STRATEGY,
+    securityPath: WORKSPACE_PATHS.SECURITY,
+    // Workspace directories
+    memoryDir: WORKSPACE_PATHS.MEMORY_DIR,
+    downloadsDir: WORKSPACE_PATHS.DOWNLOADS_DIR,
+    uploadsDir: WORKSPACE_PATHS.UPLOADS_DIR,
+    tempDir: WORKSPACE_PATHS.TEMP_DIR,
+    memesDir: WORKSPACE_PATHS.MEMES_DIR,
+    // Protected files (outside workspace)
+    sessionPath: join(TELETON_ROOT, "telegram_session.txt"),
+    configPath: join(TELETON_ROOT, "config.yaml"),
+    walletPath: join(TELETON_ROOT, "wallet.json")
+  };
+  if (config?.ensureTemplates) {
+    await bootstrapTemplates(workspace, silent);
+  }
+  return workspace;
+}
+async function bootstrapTemplates(workspace, silent = false) {
+  const templates = [
+    { name: "SOUL.md", path: workspace.soulPath },
+    { name: "MEMORY.md", path: workspace.memoryPath },
+    { name: "IDENTITY.md", path: workspace.identityPath },
+    { name: "USER.md", path: workspace.userPath },
+    { name: "SECURITY.md", path: workspace.securityPath },
+    { name: "STRATEGY.md", path: workspace.strategyPath },
+    { name: "HEARTBEAT.md", path: WORKSPACE_PATHS.HEARTBEAT }
+  ];
+  for (const template of templates) {
+    if (!existsSync(template.path)) {
+      const templateSource = join(TEMPLATES_DIR, template.name);
+      if (existsSync(templateSource)) {
+        copyFileSync(templateSource, template.path);
+        if (!silent) log.info(`Created ${template.name}`);
+      }
+    }
+  }
+}
+function isNewWorkspace(workspace) {
+  return !existsSync(workspace.configPath);
+}
+function loadTemplate(name) {
+  const templatePath = join(TEMPLATES_DIR, name);
+  if (!existsSync(templatePath)) {
+    throw new Error(`Template ${name} not found at ${templatePath}`);
+  }
+  return readFileSync(templatePath, "utf-8");
+}
+
+export {
+  ensureWorkspace,
+  isNewWorkspace,
+  loadTemplate
+};

package/dist/{chunk-LVTKJQ7O.js → chunk-D3GT6YIY.js}

@@ -1,24 +1,25 @@
 import {
   getClaudeCodeApiKey,
   refreshClaudeCodeApiKey
-} from "./chunk-WTDAICGT.js";
+} from "./chunk-R6W4DJRK.js";
 import {
   getProviderMetadata
-} from "./chunk-6OOHHJ4N.js";
+} from "./chunk-TFTNZZDH.js";
 import {
   fetchWithTimeout
 } from "./chunk-XQUHC3JZ.js";
 import {
   appendToTranscript,
   readTranscript
-} from "./chunk-LC4TV3KL.js";
+} from "./chunk-4MG2AROG.js";
 import {
   createLogger
-} from "./chunk-NQ6FZKCE.js";
+} from "./chunk-V3S3NXBQ.js";
 
 // src/agent/client.ts
 import {
   complete,
+  stream,
   getModel
 } from "@mariozechner/pi-ai";
 
@@ -264,7 +265,7 @@ async function chatWithContext(config, options) {
     systemPrompt = "/no_think\n" + systemPrompt;
     if (tools && tools.length > 0) {
       cocoonAllowedTools = new Set(tools.map((t) => t.name));
-      const { injectToolsIntoSystemPrompt } = await import("./tool-adapter-IVX2XQJE.js");
+      const { injectToolsIntoSystemPrompt } = await import("./tool-adapter-VKLUZSQS.js");
       systemPrompt = injectToolsIntoSystemPrompt(systemPrompt, tools);
       tools = void 0;
     }
@@ -283,7 +284,7 @@ async function chatWithContext(config, options) {
     cacheRetention: "long"
   };
   if (isCocoon) {
-    const { stripCocoonPayload } = await import("./tool-adapter-IVX2XQJE.js");
+    const { stripCocoonPayload } = await import("./tool-adapter-VKLUZSQS.js");
     completeOptions.onPayload = stripCocoonPayload;
   }
   let response = await complete(model, context, completeOptions);
@@ -298,7 +299,7 @@ async function chatWithContext(config, options) {
   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-IVX2XQJE.js");
+      const { parseToolCallsFromText, extractPlainText } = await import("./tool-adapter-VKLUZSQS.js");
       const syntheticCalls = parseToolCallsFromText(textBlock.text, cocoonAllowedTools);
       if (syntheticCalls.length > 0) {
         const plainText = extractPlainText(textBlock.text);
@@ -331,6 +332,56 @@ async function chatWithContext(config, options) {
     context: updatedContext
   };
 }
+function streamWithContext(config, options) {
+  const provider = config.provider || "anthropic";
+  const model = getProviderModel(provider, config.model);
+  const tools = provider === "google" && options.tools ? sanitizeToolsForGemini(options.tools) : options.tools;
+  const systemPrompt = options.systemPrompt || options.context.systemPrompt || "";
+  const context = {
+    ...options.context,
+    systemPrompt,
+    tools
+  };
+  const temperature = options.temperature ?? config.temperature;
+  const streamOptions = {
+    apiKey: getEffectiveApiKey(provider, config.api_key),
+    maxTokens: options.maxTokens ?? config.max_tokens,
+    temperature,
+    sessionId: options.sessionId,
+    cacheRetention: "long"
+  };
+  const eventStream = stream(model, context, streamOptions);
+  async function* textDeltas() {
+    for await (const event of eventStream) {
+      if (event.type === "text_delta" && event.delta) {
+        yield event.delta;
+      }
+      if (event.type === "toolcall_start") {
+        return;
+      }
+    }
+  }
+  const resultPromise = (async () => {
+    const response = await eventStream.result();
+    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 };
+  })();
+  return { textStream: textDeltas(), result: resultPromise };
+}
 function loadContextFromTranscript(sessionId, systemPrompt) {
   const messages = readTranscript(sessionId);
   const seenToolCallIds = /* @__PURE__ */ new Set();
@@ -358,6 +409,7 @@ export {
   getProviderModel,
   getUtilityModel,
   chatWithContext,
+  streamWithContext,
   loadContextFromTranscript,
   createClient
 };

package/dist/chunk-EKCXKL5M.js

@@ -0,0 +1,53 @@
+// packages/sdk/dist/index.js
+var PluginSDKError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+  }
+  name = "PluginSDKError";
+};
+var SDK_VERSION = "1.0.0";
+
+// src/sdk/telegram-utils.ts
+function requireBridge(bridge) {
+  if (!bridge.isAvailable()) {
+    throw new PluginSDKError(
+      "Telegram bridge not connected. SDK telegram methods can only be called at runtime (inside tool executors or start()), not during plugin loading.",
+      "BRIDGE_NOT_CONNECTED"
+    );
+  }
+}
+function getClient(bridge) {
+  return bridge.getRawClient().getClient();
+}
+function toSimpleMessage(msg) {
+  const fromId = msg.fromId;
+  let senderId = 0;
+  if (fromId) {
+    if ("userId" in fromId) senderId = Number(fromId.userId);
+    else if ("channelId" in fromId) senderId = Number(fromId.channelId);
+    else if ("chatId" in fromId) senderId = Number(fromId.chatId);
+  }
+  return {
+    id: msg.id,
+    text: msg.message ?? "",
+    senderId,
+    timestamp: new Date(msg.date * 1e3)
+  };
+}
+var _Api;
+async function getApi() {
+  if (!_Api) {
+    _Api = (await import("telegram")).Api;
+  }
+  return _Api;
+}
+
+export {
+  PluginSDKError,
+  SDK_VERSION,
+  requireBridge,
+  getClient,
+  toSimpleMessage,
+  getApi
+};

package/dist/{chunk-XDZDOKIF.js → chunk-F6S3L3OV.js}

@@ -1,9 +1,9 @@
 import {
   getDatabase
-} from "./chunk-GHMXWAXI.js";
+} from "./chunk-ULVL2W3D.js";
 import {
   createLogger
-} from "./chunk-NQ6FZKCE.js";
+} from "./chunk-V3S3NXBQ.js";
 
 // src/session/store.ts
 import { randomUUID } from "crypto";
@@ -269,7 +269,7 @@ function pruneOldSessions(maxAgeDays = 30) {
     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`);
+      log.info(`Pruned ${pruned} session(s) older than ${maxAgeDays} days`);
     }
     return pruned;
   } catch (error) {

package/dist/{chunk-C4NKJT2Z.js → chunk-J4WDJ7XS.js}

@@ -59,7 +59,7 @@ var RESULT_TRUNCATION_KEEP_CHARS = 500;
 var EMBEDDING_CACHE_EVICTION_RATIO = 0.1;
 var WEB_FETCH_MAX_TEXT_LENGTH = 2e4;
 var WEB_SEARCH_MAX_RESULTS = 10;
-var TOOL_CONCURRENCY_LIMIT = 2;
+var TOOL_CONCURRENCY_LIMIT = 3;
 var TOOL_RAG_MIN_SCORE = 0.1;
 var TOOL_RAG_VECTOR_WEIGHT = 0.6;
 var TOOL_RAG_KEYWORD_WEIGHT = 0.4;