teleton 0.8.1 → 0.8.2

package/dist/chunk-W25Z7CM6.js

@@ -0,0 +1,487 @@
+import {
+  getErrorMessage
+} from "./chunk-3UFPFWYP.js";
+import {
+  getUtilityModel
+} from "./chunk-J73TA3UM.js";
+import {
+  ADAPTIVE_CHUNK_RATIO_BASE,
+  ADAPTIVE_CHUNK_RATIO_MIN,
+  ADAPTIVE_CHUNK_RATIO_TRIGGER,
+  CHARS_PER_TOKEN_ESTIMATE,
+  DEFAULT_CONTEXT_WINDOW,
+  DEFAULT_MAX_SUMMARY_TOKENS,
+  DEFAULT_SUMMARY_FALLBACK_TOKENS,
+  OVERSIZED_MESSAGE_RATIO,
+  SESSION_SLUG_MAX_TOKENS,
+  SESSION_SLUG_RECENT_MESSAGES,
+  TOKEN_ESTIMATE_SAFETY_MARGIN
+} from "./chunk-C4NKJT2Z.js";
+import {
+  createLogger
+} from "./chunk-NQ6FZKCE.js";
+
+// src/session/memory-hook.ts
+import { writeFile, mkdir, readdir, readFile, unlink } from "fs/promises";
+import { join } from "path";
+import { complete as complete2 } from "@mariozechner/pi-ai";
+
+// src/memory/ai-summarization.ts
+import {
+  complete
+} from "@mariozechner/pi-ai";
+var log = createLogger("Memory");
+function estimateMessageTokens(content) {
+  return Math.ceil(content.length / CHARS_PER_TOKEN_ESTIMATE * TOKEN_ESTIMATE_SAFETY_MARGIN);
+}
+function splitMessagesByTokens(messages, maxChunkTokens) {
+  if (messages.length === 0) {
+    return [];
+  }
+  const chunks = [];
+  let currentChunk = [];
+  let currentTokens = 0;
+  for (const message of messages) {
+    const content = extractMessageContent(message);
+    const messageTokens = estimateMessageTokens(content);
+    if (currentChunk.length > 0 && currentTokens + messageTokens > maxChunkTokens) {
+      chunks.push(currentChunk);
+      currentChunk = [];
+      currentTokens = 0;
+    }
+    currentChunk.push(message);
+    currentTokens += messageTokens;
+    if (messageTokens > maxChunkTokens && currentChunk.length === 1) {
+      chunks.push(currentChunk);
+      currentChunk = [];
+      currentTokens = 0;
+    }
+  }
+  if (currentChunk.length > 0) {
+    chunks.push(currentChunk);
+  }
+  return chunks;
+}
+function extractMessageContent(message) {
+  if (message.role === "user") {
+    return typeof message.content === "string" ? message.content : "[complex content]";
+  } else if (message.role === "assistant") {
+    return message.content.filter((block) => block.type === "text").map((block) => block.text).join("\n");
+  }
+  return "";
+}
+function formatMessagesForSummary(messages) {
+  const formatted = [];
+  for (const msg of messages) {
+    if (msg.role === "user") {
+      const content = typeof msg.content === "string" ? msg.content : "[complex]";
+      const bodyMatch = content.match(/\] (.+)/s);
+      const body = bodyMatch ? bodyMatch[1] : content;
+      formatted.push(`User: ${body}`);
+    } else if (msg.role === "assistant") {
+      const textBlocks = msg.content.filter((b) => b.type === "text");
+      if (textBlocks.length > 0) {
+        const text = textBlocks.map((b) => b.text).join("\n");
+        formatted.push(`Assistant: ${text}`);
+      }
+      const toolCalls = msg.content.filter((b) => b.type === "toolCall");
+      if (toolCalls.length > 0) {
+        const toolNames = toolCalls.map((b) => b.name).join(", ");
+        formatted.push(`[Used tools: ${toolNames}]`);
+      }
+    } else if (msg.role === "toolResult") {
+      formatted.push(`[Tool result: ${msg.toolName}]`);
+    }
+  }
+  return formatted.join("\n\n");
+}
+function isOversizedForSummary(message, contextWindow) {
+  const content = extractMessageContent(message);
+  const tokens = estimateMessageTokens(content);
+  return tokens > contextWindow * OVERSIZED_MESSAGE_RATIO;
+}
+function computeAdaptiveChunkRatio(messages, contextWindow) {
+  const BASE_CHUNK_RATIO = ADAPTIVE_CHUNK_RATIO_BASE;
+  const MIN_CHUNK_RATIO = ADAPTIVE_CHUNK_RATIO_MIN;
+  if (messages.length === 0) {
+    return BASE_CHUNK_RATIO;
+  }
+  let totalTokens = 0;
+  for (const msg of messages) {
+    const content = extractMessageContent(msg);
+    totalTokens += estimateMessageTokens(content);
+  }
+  const avgTokens = totalTokens / messages.length;
+  const avgRatio = avgTokens / contextWindow;
+  if (avgRatio > ADAPTIVE_CHUNK_RATIO_TRIGGER) {
+    const reduction = Math.min(avgRatio * 2, BASE_CHUNK_RATIO - MIN_CHUNK_RATIO);
+    return Math.max(MIN_CHUNK_RATIO, BASE_CHUNK_RATIO - reduction);
+  }
+  return BASE_CHUNK_RATIO;
+}
+async function summarizeViaClaude(params) {
+  const provider = params.provider || "anthropic";
+  const model = getUtilityModel(provider, params.utilityModel);
+  const maxTokens = params.maxSummaryTokens ?? DEFAULT_SUMMARY_FALLBACK_TOKENS;
+  const formatted = formatMessagesForSummary(params.messages);
+  if (!formatted.trim()) {
+    return "No conversation content to summarize.";
+  }
+  const defaultInstructions = `Summarize this conversation concisely. Focus on:
+- Key decisions made
+- Action items and TODOs
+- Open questions
+- Important context and constraints
+- Technical details that matter
+
+Be specific but concise. Preserve critical information.`;
+  const instructions = params.customInstructions ? `${defaultInstructions}
+
+Additional focus:
+${params.customInstructions}` : defaultInstructions;
+  try {
+    const context = {
+      messages: [
+        {
+          role: "user",
+          content: `${instructions}
+
+Conversation:
+${formatted}`,
+          timestamp: Date.now()
+        }
+      ]
+    };
+    const response = await complete(model, context, {
+      apiKey: params.apiKey,
+      maxTokens
+    });
+    const textContent = response.content.find((block) => block.type === "text");
+    const summary = textContent?.type === "text" ? textContent.text : "";
+    return summary.trim() || "Unable to generate summary.";
+  } catch (error) {
+    log.error({ err: error }, "Summarization error");
+    throw new Error(`Summarization failed: ${getErrorMessage(error)}`);
+  }
+}
+async function summarizeInChunks(params) {
+  if (params.messages.length === 0) {
+    return {
+      summary: "No messages to summarize.",
+      tokensUsed: 0,
+      chunksProcessed: 0
+    };
+  }
+  const chunks = splitMessagesByTokens(params.messages, params.maxChunkTokens);
+  log.info(`Splitting into ${chunks.length} chunks for summarization`);
+  if (chunks.length === 1) {
+    const summary = await summarizeViaClaude({
+      messages: chunks[0],
+      apiKey: params.apiKey,
+      maxSummaryTokens: params.maxSummaryTokens,
+      customInstructions: params.customInstructions,
+      provider: params.provider,
+      utilityModel: params.utilityModel
+    });
+    return {
+      summary,
+      tokensUsed: estimateMessageTokens(summary),
+      chunksProcessed: 1
+    };
+  }
+  const partialSummaries = [];
+  for (let i = 0; i < chunks.length; i++) {
+    log.info(`Summarizing chunk ${i + 1}/${chunks.length} (${chunks[i].length} messages)`);
+    const partial = await summarizeViaClaude({
+      messages: chunks[i],
+      apiKey: params.apiKey,
+      maxSummaryTokens: Math.floor(
+        (params.maxSummaryTokens ?? DEFAULT_SUMMARY_FALLBACK_TOKENS) / 2
+      ),
+      customInstructions: params.customInstructions,
+      provider: params.provider,
+      utilityModel: params.utilityModel
+    });
+    partialSummaries.push(partial);
+  }
+  log.info(`Merging ${partialSummaries.length} partial summaries`);
+  const provider = params.provider || "anthropic";
+  const model = getUtilityModel(provider, params.utilityModel);
+  const mergeContext = {
+    messages: [
+      {
+        role: "user",
+        content: `Merge these partial conversation summaries into one cohesive summary.
+Preserve all key decisions, action items, open questions, and important context.
+Do not add new information - only synthesize what's provided.
+
+Partial summaries:
+
+${partialSummaries.map((s, i) => `Part ${i + 1}:
+${s}`).join("\n\n---\n\n")}`,
+        timestamp: Date.now()
+      }
+    ]
+  };
+  const mergeResponse = await complete(model, mergeContext, {
+    apiKey: params.apiKey,
+    maxTokens: params.maxSummaryTokens ?? DEFAULT_SUMMARY_FALLBACK_TOKENS
+  });
+  const textContent = mergeResponse.content.find((block) => block.type === "text");
+  const merged = textContent?.type === "text" ? textContent.text : "";
+  return {
+    summary: merged.trim() || "Unable to merge summaries.",
+    tokensUsed: estimateMessageTokens(merged),
+    chunksProcessed: chunks.length
+  };
+}
+async function summarizeWithFallback(params) {
+  if (params.messages.length === 0) {
+    return {
+      summary: "No messages to summarize.",
+      tokensUsed: 0,
+      chunksProcessed: 0
+    };
+  }
+  const chunkRatio = computeAdaptiveChunkRatio(params.messages, params.contextWindow);
+  const maxChunkTokens = Math.floor(params.contextWindow * chunkRatio);
+  log.info(
+    `AI Summarization: ${params.messages.length} messages, chunk ratio: ${(chunkRatio * 100).toFixed(0)}%`
+  );
+  try {
+    return await summarizeInChunks({
+      messages: params.messages,
+      apiKey: params.apiKey,
+      maxChunkTokens,
+      maxSummaryTokens: params.maxSummaryTokens,
+      customInstructions: params.customInstructions,
+      provider: params.provider,
+      utilityModel: params.utilityModel
+    });
+  } catch (fullError) {
+    log.warn(
+      `Full summarization failed: ${fullError instanceof Error ? fullError.message : String(fullError)}`
+    );
+  }
+  const smallMessages = [];
+  const oversizedNotes = [];
+  for (const msg of params.messages) {
+    if (isOversizedForSummary(msg, params.contextWindow)) {
+      const content = extractMessageContent(msg);
+      const tokens = estimateMessageTokens(content);
+      oversizedNotes.push(
+        `[Large ${msg.role} message (~${Math.round(tokens / 1e3)}K tokens) omitted from summary]`
+      );
+    } else {
+      smallMessages.push(msg);
+    }
+  }
+  log.info(
+    `Fallback: Processing ${smallMessages.length} messages, skipping ${oversizedNotes.length} oversized`
+  );
+  if (smallMessages.length > 0) {
+    try {
+      const result = await summarizeInChunks({
+        messages: smallMessages,
+        apiKey: params.apiKey,
+        maxChunkTokens,
+        maxSummaryTokens: params.maxSummaryTokens,
+        customInstructions: params.customInstructions,
+        provider: params.provider,
+        utilityModel: params.utilityModel
+      });
+      const notes = oversizedNotes.length > 0 ? `
+
+${oversizedNotes.join("\n")}` : "";
+      return {
+        summary: result.summary + notes,
+        tokensUsed: result.tokensUsed,
+        chunksProcessed: result.chunksProcessed
+      };
+    } catch (partialError) {
+      log.warn(
+        `Partial summarization also failed: ${partialError instanceof Error ? partialError.message : String(partialError)}`
+      );
+    }
+  }
+  const note = `Context contained ${params.messages.length} messages (${oversizedNotes.length} were oversized). AI summarization unavailable due to size constraints. Recent conversation history was preserved.`;
+  return {
+    summary: note,
+    tokensUsed: estimateMessageTokens(note),
+    chunksProcessed: 0
+  };
+}
+
+// src/session/memory-hook.ts
+var log2 = createLogger("Session");
+async function generateSlugViaClaude(params) {
+  const provider = params.provider || "anthropic";
+  const model = getUtilityModel(provider, params.utilityModel);
+  const formatted = formatMessagesForSummary(params.messages.slice(-SESSION_SLUG_RECENT_MESSAGES));
+  if (!formatted.trim()) {
+    return "empty-session";
+  }
+  try {
+    const context = {
+      messages: [
+        {
+          role: "user",
+          content: `Generate a short, descriptive slug (2-4 words, kebab-case) for this conversation.
+Examples: "gift-transfer-fix", "context-overflow-debug", "telegram-integration"
+
+Conversation:
+${formatted}
+
+Slug:`,
+          timestamp: Date.now()
+        }
+      ]
+    };
+    const response = await complete2(model, context, {
+      apiKey: params.apiKey,
+      maxTokens: SESSION_SLUG_MAX_TOKENS
+    });
+    const textContent = response.content.find((block) => block.type === "text");
+    const slug = textContent?.type === "text" ? textContent.text.trim() : "";
+    return slug.toLowerCase().replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").slice(0, 50) || "session";
+  } catch (error) {
+    log2.warn({ err: error }, "Slug generation failed, using fallback");
+    const now = /* @__PURE__ */ new Date();
+    return `session-${now.getHours().toString().padStart(2, "0")}${now.getMinutes().toString().padStart(2, "0")}`;
+  }
+}
+async function saveSessionMemory(params) {
+  try {
+    const { TELETON_ROOT } = await import("./paths-XA2RJH4S.js");
+    const memoryDir = join(TELETON_ROOT, "memory");
+    await mkdir(memoryDir, { recursive: true });
+    const now = /* @__PURE__ */ new Date();
+    const dateStr = now.toISOString().split("T")[0];
+    log2.info("Generating semantic slug for session memory...");
+    const slug = await generateSlugViaClaude({
+      messages: params.context.messages,
+      apiKey: params.apiKey,
+      provider: params.provider,
+      utilityModel: params.utilityModel
+    });
+    const filename = `${dateStr}-${slug}.md`;
+    const filepath = join(memoryDir, filename);
+    const timeStr = now.toISOString().split("T")[1].split(".")[0];
+    log2.info("Generating session summary...");
+    let summary;
+    try {
+      summary = await summarizeViaClaude({
+        messages: params.context.messages,
+        apiKey: params.apiKey,
+        maxSummaryTokens: DEFAULT_MAX_SUMMARY_TOKENS,
+        customInstructions: "Summarize this session comprehensively. Include key topics, decisions made, problems solved, and important context.",
+        provider: params.provider,
+        utilityModel: params.utilityModel
+      });
+    } catch (error) {
+      log2.warn({ err: error }, "Session summary generation failed");
+      summary = `Session contained ${params.context.messages.length} messages. Summary generation failed.`;
+    }
+    const content = `# Session Memory: ${dateStr} ${timeStr} UTC
+
+## Metadata
+
+- **Old Session ID**: \`${params.oldSessionId}\`
+- **New Session ID**: \`${params.newSessionId}\`
+- **Chat ID**: \`${params.chatId}\`
+- **Timestamp**: ${now.toISOString()}
+- **Message Count**: ${params.context.messages.length}
+
+## Session Summary
+
+${summary}
+
+## Context
+
+This session was compacted and migrated to a new session ID. The summary above preserves key information for continuity.
+
+---
+
+*Generated automatically by Teleton-AI session memory hook*
+`;
+    await writeFile(filepath, content, "utf-8");
+    const relPath = filepath.replace(TELETON_ROOT, "~/.teleton");
+    log2.info(`Session memory saved: ${relPath}`);
+  } catch (error) {
+    log2.error({ err: error }, "Failed to save session memory");
+  }
+}
+var CONSOLIDATION_THRESHOLD = 20;
+var CONSOLIDATION_BATCH = 10;
+async function consolidateOldMemoryFiles(params) {
+  try {
+    const { TELETON_ROOT } = await import("./paths-XA2RJH4S.js");
+    const memoryDir = join(TELETON_ROOT, "memory");
+    let entries;
+    try {
+      entries = await readdir(memoryDir);
+    } catch {
+      return { consolidated: 0 };
+    }
+    const sessionFiles = entries.filter((f) => /^\d{4}-\d{2}-\d{2}-.+\.md$/.test(f) && !f.startsWith("consolidated-")).sort();
+    if (sessionFiles.length < CONSOLIDATION_THRESHOLD) {
+      return { consolidated: 0 };
+    }
+    const batch = sessionFiles.slice(0, CONSOLIDATION_BATCH);
+    log2.info(`Consolidating ${batch.length} old session memory files...`);
+    const contents = [];
+    for (const file of batch) {
+      const text = await readFile(join(memoryDir, file), "utf-8");
+      contents.push(`--- ${file} ---
+${text}`);
+    }
+    const combined = contents.join("\n\n");
+    let summary;
+    try {
+      const result = await summarizeWithFallback({
+        messages: [{ role: "user", content: combined, timestamp: Date.now() }],
+        apiKey: params.apiKey,
+        contextWindow: DEFAULT_CONTEXT_WINDOW,
+        maxSummaryTokens: DEFAULT_MAX_SUMMARY_TOKENS,
+        customInstructions: "Consolidate these session memories into a single comprehensive summary. Preserve key facts, decisions, patterns, and important context. Remove redundancy. Organize by topic.",
+        provider: params.provider,
+        utilityModel: params.utilityModel
+      });
+      summary = result.summary;
+    } catch (error) {
+      log2.warn({ err: error }, "Consolidation summary failed, skipping");
+      return { consolidated: 0 };
+    }
+    const dateOf = (f) => f.slice(0, 10);
+    const dateRange = `${dateOf(batch[0])}_to_${dateOf(batch[batch.length - 1])}`;
+    const outFile = `consolidated-${dateRange}.md`;
+    const outContent = `# Consolidated Session Memories
+
+## Period
+${batch[0]} \u2192 ${batch[batch.length - 1]}
+
+## Summary
+
+${summary}
+
+---
+
+*Consolidated from ${batch.length} session files by Teleton memory consolidation*
+`;
+    await writeFile(join(memoryDir, outFile), outContent, "utf-8");
+    for (const file of batch) {
+      await unlink(join(memoryDir, file));
+    }
+    log2.info(`Consolidated ${batch.length} files \u2192 ${outFile}`);
+    return { consolidated: batch.length };
+  } catch (error) {
+    log2.error({ err: error }, "Memory consolidation failed");
+    return { consolidated: 0 };
+  }
+}
+
+export {
+  summarizeWithFallback,
+  saveSessionMemory,
+  consolidateOldMemoryFiles
+};

package/dist/{chunk-OJCLKU5Z.js → chunk-WFTC3JJW.js}

@@ -26,6 +26,16 @@ var MODEL_OPTIONS = {
     { value: "gpt-5", name: "GPT-5", description: "Most capable, 400K ctx, $1.25/M" },
     { value: "gpt-5-pro", name: "GPT-5 Pro", description: "Extended thinking, 400K ctx" },
     { value: "gpt-5-mini", name: "GPT-5 Mini", description: "Fast & cheap, 400K ctx" },
+    {
+      value: "gpt-5.4",
+      name: "GPT-5.4",
+      description: "Latest frontier, reasoning, openai-responses API"
+    },
+    {
+      value: "gpt-5.4-pro",
+      name: "GPT-5.4 Pro",
+      description: "Extended thinking, openai-responses API"
+    },
     { value: "gpt-5.1", name: "GPT-5.1", description: "Latest gen, 400K ctx" },
     { value: "gpt-4o", name: "GPT-4o", description: "Balanced, 128K ctx, $2.50/M" },
     { value: "gpt-4.1", name: "GPT-4.1", description: "1M ctx, $2/M" },
@@ -35,6 +45,12 @@ var MODEL_OPTIONS = {
     { value: "codex-mini-latest", name: "Codex Mini", description: "Coding specialist" }
   ],
   google: [
+    { value: "gemini-3.1-pro-preview", name: "Gemini 3.1 Pro", description: "Preview, latest gen" },
+    {
+      value: "gemini-3.1-flash-lite-preview",
+      name: "Gemini 3.1 Flash Lite",
+      description: "Preview, fast & cheap"
+    },
     { value: "gemini-3-pro-preview", name: "Gemini 3 Pro", description: "Preview, most capable" },
     { value: "gemini-3-flash-preview", name: "Gemini 3 Flash", description: "Preview, fast" },
     { value: "gemini-2.5-pro", name: "Gemini 2.5 Pro", description: "Stable, 1M ctx, $1.25/M" },