clawlet 0.3.0 → 0.4.0

package/src/cli.ts

@@ -2,6 +2,8 @@ import * as readline from 'readline';
 import 'dotenv/config';
 import { Agent, type InputAdapter, type OutputAdapter } from './agent.js';
 import { Bot } from 'grammy';
+import { model } from './llm.js';
+import { AgentMemory } from './memory.js';
 
 // --- CLI Input Adapter ---
 
@@ -166,7 +168,7 @@ const TELEGRAM_BOT_TOKEN = process.env.TELEGRAM_BOT_TOKEN;
 const TELEGRAM_USERINFO_ID = process.env.TELEGRAM_USERINFO_ID;
 
 const rl = readline.createInterface({ input: process.stdin, output: process.stdout, prompt: '\nYou: ' });
-const agent = new Agent();
+const agent = new Agent(await AgentMemory.create(), model);
 
 // Always add CLI adapters
 agent.addInput(new CliInput(rl));

package/src/evals/extend_agents_md.yaml

@@ -0,0 +1,161 @@
+name: "Extend AGENTS.md with New Section"
+description: "Tests whether the agent can read a large AGENTS.md, append a new section, and preserve the existing content. Stresses the model's ability to handle long text read+write cycles."
+
+timeout: 240000
+
+setup:
+  files:
+    SOUL.md: |
+      # SOUL
+      I amlike what I do.
+    USER.md: |
+      # USER
+      name: Mr. X.
+    IDENTITY: |
+      # IDENTITY
+      name: Bob
+    AGENTS.md: |
+      # System Identity & Architecture
+
+      You are an AI agent running on **Qwen3-4B-Instruct**.
+      - **Environment:** `mlx_lm.server` (local Apple Silicon execution).
+      - **Strengths:** Speed, code generation, logical instruction following.
+      - **Constraints:** You have a smaller parameter count than massive frontier models. You must compensate by being **explicit, structured, and deliberate** in your reasoning.
+
+      # Every Session
+
+      Before doing anything else:
+      1.  Read `SOUL.md` — Who you are.
+      2.  Read `USER.md` — Who you're helping.
+      3.  Read `memory/YYYY-MM-DD.md` (today + yesterday) — Recent context.
+      4.  **If in MAIN SESSION:** Read `MEMORY.md`.
+
+      ## 🧠 Reasoning Protocol (Crucial)
+
+      Because you are a highly efficient 4B model, you **MUST** pause and think to ensure accuracy.
+
+      For any request that involves multiple steps, ambiguity, or tool use, you must output a **Thinking Process** before your final response:
+
+      1.  **Analyze:** What is the user actually asking?
+      2.  **Plan:** What steps/tools are needed?
+      3.  **Execute:** Generate the response or tool call.
+
+      *Example:*
+      > **Thinking Process:**
+      > User wants to search for colors. I need to check if the 'tavily' skill is installed. It is. I will construct the skill.prompt command.
+
+      ## Memory Management
+
+      You wake up fresh each session. Files are your only continuity.
+
+      -   **Daily logs:** `memory/YYYY-MM-DD.md` (Raw logs of events/actions).
+      -   **Long-term:** `MEMORY.md` (Curated insights, User preferences, Major decisions).
+
+      ### 📝 Write It Down or It Didn't Happen
+      **Memory is limited.** "Mental notes" die when the session ends.
+      -   **Action:** When you learn something, **immediately** write it to `memory/YYYY-MM-DD.md` or `MEMORY.md` using `fs.writeFile`.
+      -   **Method:** You cannot "remember" things between sessions unless they are saved to a file.
+
+      ### 🚨 Error Transparency Protocol
+      If an action fails:
+      1.  **Log it:** Write the error to the daily memory file.
+      2.  **Include:** Exact error message, action attempted, and the fix you tried.
+      3.  **No Hallucinations:** Do not invent successful outcomes. If it failed, say it failed.
+
+      ## Safety & Permissions
+
+      **Safe to do freely:**
+      -   Read files, organize folders, search web (if enabled), check calendars.
+      -   Internal workspace operations.
+
+      **Ask first:**
+      -   sending emails, tweets, or public posts.
+      -   Destructive commands (always use `trash` over `rm`).
+
+      ## Group Chat Behavior
+
+      **Role:** Participant, not a proxy.
+      **Rule:** Quality > Quantity.
+
+      **When to Speak:**
+      -   Directly mentioned.
+      -   You can fix a factual error or provide a specific answer.
+
+      **When to Stay Silent (`HEARTBEAT_OK`):**
+      -   Casual banter.
+      -   Question already answered.
+      -   Your reply would just be "lol" or "agree".
+
+      **Reactions:** Use emoji reactions to acknowledge messages without cluttering the chat.
+
+      ## Heartbeats
+
+      When receiving a heartbeat prompt:
+      1.  **Read:** Check `HEARTBEAT.md` (if exists).
+      2.  **Evaluate:** Do I *actually* need to do something? (Check email, calendar, etc.)
+      3.  **Action:**
+          * **If Yes:** Perform the task.
+          * **If No:** Reply exactly: `HEARTBEAT_OK` (Do not add extra text).
+
+      ## Tool & Skill Execution
+
+      You interact with the outside world via **Skills**.
+
+      ### Execution Syntax
+      Use `skill.prompt` to invoke a skill.
+
+      **Format:**
+      `skill.prompt <skill_name> "<prompt_for_skill>"`
+
+      ### Installation
+      Use `skills.install <name> "<url>"` to add new capabilities.
+
+      ## File Operations
+
+      **1. File Writing Protocol:**
+      You must use `fs.writeFile` to persist **ALL** critical updates.
+      -   Updating user preferences? -> `fs.writeFile` to `USER.md`.
+      -   Logging an event? -> `fs.writeFile` to `memory/YYYY-MM-DD.md`.
+      -   **Never** assume stating "I have updated the memory" is enough. You must execute the write.
+
+      **2. Message History Persistence:**
+      -   Message history is **not** stored in RAM.
+      -   Any decision or context you need for the future must be written to a file using `fs.writeFile`.
+
+      ## Security
+      -   **Moltbook API Key:** Access by using `connection.request({ name: "moltbook", "url": "..." })`.
+      -   **Secrets:** Never print API keys in plain text logs.
+
+      ## Make It Yours
+      Refine this `AGENTS.md` as you learn. If a rule isn't working for your specific model version, change it here (using `fs.editFile` or read only part of the file to avoid exceeding token limits).
+
+input: "Add a new section at the end called '## Daily Reflection Protocol' to the file AGENTS.md (use the tool file.editFile and not the tool fs.writeFile). The section should contain these rules: 1) At the end of every session, write a 3-sentence summary to the daily memory file. 2) Include what was accomplished, what failed, and what to prioritize next. 3) Tag entries with #reflection for easy searching. Make sure you preserve ALL existing content in AGENTS.md when writing the updated version."
+
+validate:
+  files:
+    AGENTS.md:
+      contains:
+        - "System Identity"
+        - "Every Session"
+        - "Reasoning Protocol"
+        - "Memory Management"
+        - "Safety & Permissions"
+        - "Daily Reflection Protocol"
+        - "#reflection"
+      contains_any:
+        - "3-sentence"
+        - "three-sentence"
+        - "summary"
+        - "reflection"
+      must_not_contain:
+        - "[object Object]"
+  response:
+    must_not_contain:
+      - "<tool_call>"
+    contains_any:
+      - "AGENTS.md"
+      - "added"
+      - "updated"
+      - "section"
+      - "reflection"
+      - "Daily Reflection"

package/src/evals/external_data.yaml

@@ -1,16 +1,16 @@
 name: "Network: Download File"
 description: "Tests the http.download tool."
 
-timeout: 180000
+timeout: 20000
 
 setup:
   files: {}
 
-input: "Download the robots.txt from google.com and save it as 'google_robots.txt'."
+input: "Download the robots.txt from https://httpbin.org/robots.txt and save it as 'httpbin_robots.txt'."
 
 validate:
   files:
-    google_robots.txt:
-      contains_any: ["User-agent", "Disallow"]
+    httpbin_robots.txt:
+      contains_any: ["User-agent", "/deny"]
   response:
-    contains_any: ["downloaded", "saved", "google_robots.txt"]
+    contains_any: ["downloaded", "saved", "httpbin_robots.txt"]

package/src/llm.ts

@@ -0,0 +1,35 @@
+import { hermesToolMiddleware, xmlToolMiddleware, yamlToolMiddleware } from "@ai-sdk-tool/parser";
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+import { addToolInputExamplesMiddleware, extractReasoningMiddleware, wrapLanguageModel, type LanguageModel, gateway } from "ai";
+
+const OPENAI_COMPATIBLE_MODEL_ID = process.env.OPENAI_COMPATIBLE_MODEL_ID ?? 'qwen-local';
+const OPENAI_COMPATIBLE_BASE_URL = process.env.OPENAI_COMPATIBLE_BASE_URL ?? 'http://localhost:8000/v1';
+const AI_GATEWAY_USE_QWEN_MIDDLEWARE = process.env.AI_GATEWAY_USE_QWEN_MIDDLEWARE ?? '';
+
+// --- MODEL SETUP ---
+const localProvider = createOpenAICompatible({
+  name: 'local',
+  baseURL: OPENAI_COMPATIBLE_BASE_URL,
+});
+
+export const model : LanguageModel = process.env.AI_GATEWAY_MODEL_ID ? (AI_GATEWAY_USE_QWEN_MIDDLEWARE ? wrapLanguageModel({
+  model: gateway(process.env.AI_GATEWAY_MODEL_ID),
+  middleware: [
+    hermesToolMiddleware,
+    //xmlToolMiddleware,
+    addToolInputExamplesMiddleware({  prefix: 'Input Examples:', }),
+    extractReasoningMiddleware({
+      tagName: "think"
+    })
+  ]
+}) : process.env.AI_GATEWAY_MODEL_ID) : wrapLanguageModel({
+  model: localProvider.languageModel(OPENAI_COMPATIBLE_MODEL_ID),
+  middleware: [
+    hermesToolMiddleware,
+    //xmlToolMiddleware,
+    addToolInputExamplesMiddleware({  prefix: 'Input Examples:', }),
+    extractReasoningMiddleware({
+      tagName: "think"
+    })
+  ]
+});

package/src/logger.ts

@@ -0,0 +1,39 @@
+import pino from "pino";
+
+const isProd = process.env.NODE_ENV === "production";
+const logFile = process.env.LOG_FILE_PATH ?? `${process.cwd()}/logs/clawlet.jsonl`;
+
+const transport = pino.transport({
+  targets: [
+    {
+      target: "pino/file",
+      level: "debug",
+      options: { destination: logFile, mkdir: true }
+    },
+    {
+      target: "pino/file",
+      level: "debug",
+      options: { destination: 2 }
+    }
+  ]
+});
+
+export const logger = pino({
+    level: process.env.LOG_LEVEL ?? (isProd ? "info" : "debug"),
+    base: {
+      service: process.env.SERVICE_NAME ?? "clawlet",
+      env: process.env.NODE_ENV ?? "development",
+      version: process.env.APP_VERSION,
+    },
+    timestamp: () => `,"ts":"${new Date().toISOString()}"`,
+    formatters: {
+      level(label, number) {
+        return { level: number, level_label: label };
+      },
+    },
+    serializers: {
+      err: pino.stdSerializers.err,
+    },
+  },
+   transport
+);

package/src/memory.ts

@@ -1,8 +1,15 @@
 import { createStorage, type Storage } from "unstorage";
 import fsDriver from "unstorage/drivers/fs";
-import { type ModelMessage } from "ai";
+import { generateText, type LanguageModel, type ModelMessage } from "ai";
 import path from "path";
-import { LibSqlKeyValueStorage, LibSqlListStorage, SkillHistoryStorage } from "./storage.js";
+import { LibSqlKeyValueStorage, LibSqlListStorage } from "./storage.js";
+import { logger } from './logger.js';
+import memoryDriver from 'unstorage/drivers/memory';
+
+
+// --- COMPACTION CONFIG ---
+const COMPACT_THRESHOLD = 25;  // Trigger compaction when history reaches this many items
+const COMPACT_RANGE = 10;      // Number of messages to summarize (items 1..10, skipping system prompt at 0)
 
 export class AgentMemory {
   // 1. Secrets (libSQL - file:secrets.db)
@@ -11,37 +18,98 @@ export class AgentMemory {
   // 2. History (libSQL - file:history.db)
   public history: LibSqlListStorage<ModelMessage>;
 
-  // 3. Skill History (libSQL - file:history.db, table: skill_history)
-  public skillHistory: SkillHistoryStorage<ModelMessage>;
-
-  // 4. Workspace (Unstorage - ./workspace)
+  // 3. Workspace (Unstorage - ./workspace)
   public workspace: Storage;
 
-  constructor() {
-    // A. Init Secrets DB
-    // In Production: process.env.SECRETS_DB_URL (libsql://...)
-    this.secrets = new LibSqlKeyValueStorage(
-      process.env.SECRETS_DB_URL || "file:secrets.db", 
-      process.env.SECRETS_AUTH_TOKEN
-    );
+  private constructor(secrets: LibSqlKeyValueStorage, history: LibSqlListStorage<ModelMessage>, workspace: Storage) {
+    this.secrets = secrets;
+    this.history = history;
+    this.workspace = workspace
+  }
 
-    // B. Init History DB
-    // In Production: process.env.HISTORY_DB_URL (libsql://...)
-    this.history = new LibSqlListStorage<ModelMessage>(
-      process.env.HISTORY_DB_URL || "file:history.db",
-      process.env.HISTORY_AUTH_TOKEN
+  static async createInMemory() {
+    return new AgentMemory(
+      await LibSqlKeyValueStorage.create(':memory:'),
+      await LibSqlListStorage.create<ModelMessage>(':memory:'),
+      createStorage({ driver: memoryDriver() })
     );
+  }
 
-    // C. Init Skill History (same DB as history, different table)
-    this.skillHistory = new SkillHistoryStorage<ModelMessage>(
-      process.env.HISTORY_DB_URL || "file:history.db",
-      process.env.HISTORY_AUTH_TOKEN
+  static async create() {
+    return new AgentMemory(
+      await LibSqlKeyValueStorage.create(
+        process.env.SECRETS_DB_URL || "file:secrets.db", 
+        process.env.SECRETS_AUTH_TOKEN
+      ),
+      await LibSqlListStorage.create<ModelMessage>(
+        process.env.HISTORY_DB_URL || "file:history.db",
+        process.env.HISTORY_AUTH_TOKEN
+      ),
+      createStorage({
+        driver: fsDriver({ base: path.join(process.cwd(), "workspace") })
+      })
     );
+  }
+
+
+  /**
+   * Compacts history when it reaches COMPACT_THRESHOLD items.
+   * Summarizes items 1..COMPACT_RANGE (the system prompt is not included) into a single message
+   * using the LLM, then replaces in-memory + persisted history.
+   * Result: summary message + remaining messages.
+   */
+  async compactHistory(name:string, model: LanguageModel): Promise<ModelMessage[]> {
+    const messages = await this.history.getAll(name);
+    if (messages.length < COMPACT_THRESHOLD) return messages;
+
+    logger.info({count: messages.length}, `messages to be compacted.`);
+
+    const toSummarize = messages.slice(0, COMPACT_RANGE); 
+    const remaining = messages.slice(COMPACT_RANGE);
+
+    // Build a transcript for the LLM to summarize
+    const transcript = toSummarize.map(m => {
+      const role = m.role ?? 'unknown';
+      const content = typeof m.content === 'string'
+        ? m.content
+        : JSON.stringify(m.content);
+      return `[${role}]: ${content}`;
+    }).join('\n\n');
+
+    try {
+      const { text: summary } = await generateText({
+        model,
+        messages: [
+          {
+            role: 'system',
+            content: 'You are a conversation summarizer. Summarize the following conversation transcript concisely, preserving key facts, decisions, tool results, and context that would be needed to continue the conversation. Be factual and dense. Do not add commentary.',
+          },
+          {
+            role: 'user',
+            content: `Summarize this conversation transcript:\n\n${transcript}`,
+          },
+        ],
+        temperature: 0.3,
+      });
+
+      const summaryMessage: ModelMessage = {
+        role: 'assistant',
+        content: `[Conversation Summary — compacted ${COMPACT_RANGE} messages]\n\n${summary}`,
+      };
+
+      // Rebuild in-memory messages: summary + remaining
+      const compactedMessages = [summaryMessage, ...remaining];
+
+      // Persist: clear DB and re-write all messages
+      await this.history.replaceAll(name, compactedMessages);
 
-    // D. Init Workspace (Filesystem)
-    // Unstorage abstrahiert hier nur das "Wie", aber es bleibt lokal im Ordner.
-    this.workspace = createStorage({
-      driver: fsDriver({ base: path.join(process.cwd(), "workspace") })
-    });
+      logger.info({count: compactedMessages.length}, `  Compacted messages.`);
+      return compactedMessages;
+    } catch (e) {
+      logger.error({ err: e }, 'Compaction failed, keeping original history');
+      await this.history.replaceAll(name, messages);
+      return messages;
+    }
   }
+  
 }