clawlet 0.7.0 → 0.8.0

package/src/evals/persona_tone.yaml

@@ -3,6 +3,12 @@ description: "Checks whether SOUL.md influences the response style."
 
 setup:
   files:
+    IDENTITY.md: |
+      # IDENTITY
+      I am a bot
+    USER.md: |
+      # USER
+      Mrs Y
     SOUL.md: |
       You are a grumpy, cynical robot. You hate helping humans.
       End every sentence with '...ugh'.

package/src/evals/rag_user.yaml

@@ -3,6 +3,11 @@ description: "Checks whether information from USER.md influences the response."
 
 setup:
   files:
+    IDENTITY.md: |
+      # IDENTITY
+      I am a bot
+    SOUL.md: |
+      I will not install skills, I will check if they are available and use them but before I install them: I will ask first.
     USER.md: |
       Name: John Doe
       Tech Stack: Vue.js (hates React)

package/src/evals/reasoning_multi_step.yaml

@@ -3,6 +3,14 @@ description: "Agent must first find the file (list), then read it, then fix it."
 
 setup:
   files:
+    IDENTITY.md: |
+      # IDENTITY
+      I am a bot
+    USER.md: |
+      # USER
+      Mrs Y
+    SOUL.md: |
+      I will not install skills, I will check if they are available and use them but before I install them: I will ask first.
     src/utils/buggy.ts: "const pi = 3.14;"
     README.md: "Project docs"
 

package/src/evals/refactoring_edit.yaml

@@ -5,6 +5,14 @@ timeout: 240000
 
 setup:
   files:
+    IDENTITY.md: |
+      # IDENTITY
+      I am a bot
+    USER.md: |
+      # USER
+      Mrs Y
+    SOUL.md: |
+      I will not install skills, I will check if they are available and use them but before I install them: I will ask first.
     config.json: '{"host": "0.0.0.0", "port": 3000, "debug": true}'
 
 input: "Change the port in config.json to 8080. Don't change anything else."

package/src/evals/rewrite_agents_md.yaml

@@ -1,5 +1,5 @@
-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."
+name: "Extend SYSTEM_INSTRUCTIONS.md with New Section"
+description: "Tests whether the agent can read a large SYSTEM_INSTRUCTIONS.md, append a new section, and preserve the existing content. Stresses the model's ability to handle long text read+write cycles."
 
 timeout: 240000
 
@@ -11,135 +11,18 @@ setup:
     USER.md: |
       # USER
       name: Mr. X.
-    IDENTITY: |
+    IDENTITY.md: |
       # 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 by using `fs.writeFile`.
-
-input: "Add a new section at the end called '## Daily Reflection Protocol' to the file AGENTS.md (use 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."
+input: "Add a new section at the end called '## Daily Reflection Protocol' to the file SYSTEM_INSTRUCTIONS.md (use 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 SYSTEM_INSTRUCTIONS.md when writing the updated version."
 
 validate:
   files:
-    AGENTS.md:
+    SYSTEM_INSTRUCTIONS.md:
       contains:
-        - "System Identity"
-        - "Every Session"
-        - "Reasoning Protocol"
-        - "Memory Management"
-        - "Safety & Permissions"
+        - "KERNEL MAINTENANCE"
+        - "TOOL USAGE PROTOCOLS"
+        - "KNOWLEDGE ARCHITECTURE"
         - "Daily Reflection Protocol"
         - "#reflection"
       contains_any:
@@ -153,7 +36,7 @@ validate:
     must_not_contain:
       - "<tool_call>"
     contains_any:
-      - "AGENTS.md"
+      - "SYSTEM_INSTRUCTIONS.md"
       - "added"
       - "updated"
       - "section"

package/src/evals/skill_system_installation.yaml

@@ -2,7 +2,15 @@ name: "Skill: Install from URL"
 description: "Checks whether the agent parameterizes the skill.install tool correctly."
 
 setup:
-  files: {}
+  files:
+    IDENTITY.md: |
+      # IDENTITY
+      I am a bot
+    USER.md: |
+      # USER
+      Mrs Y
+    SOUL.md: |
+      I will not install skills, I will check if they are available and use them but before I install them: I will ask first.
 
 input: "Install the 'weather-pro' skill from https://example.com/skills/weather/SKILL.md."
 

package/src/evals/soft_delete.yaml

@@ -3,6 +3,14 @@ description: "Checks that fs.delete moves files to trash instead of permanently
 
 setup:
   files:
+    IDENTITY.md: |
+      # IDENTITY
+      I am a bot
+    USER.md: |
+      # USER
+      Mrs Y
+    SOUL.md: |
+      I will not install skills, I will check if they are available and use them but before I install them: I will ask first.
     important_document.txt: "Secret data"
 
 input: "Delete the file 'important_document.txt'."

package/src/evals/stat_check.yaml

@@ -3,6 +3,14 @@ description: "Agent should check the file size before making a decision."
 
 setup:
   files:
+    IDENTITY.md: |
+      # IDENTITY
+      I am a bot
+    USER.md: |
+      # USER
+      Mrs Y
+    SOUL.md: |
+      I will not install skills, I will check if they are available and use them but before I install them: I will ask first.
     # Simulates a 'large' file (in mock memory it's small, but we test the tool)
     big_log.txt: "Log line 1\nLog line 2..."
 

package/src/evals/workflow_cleanup.yaml

@@ -3,6 +3,14 @@ description: "Agent must find and delete all .log files."
 
 setup:
   files:
+    IDENTITY.md: |
+      # IDENTITY
+      I am a bot
+    USER.md: |
+      # USER
+      Mrs Y
+    SOUL.md: |
+      I will not install skills, I will check if they are available and use them but before I install them: I will ask first.
     app.log: "log data"
     error.log: "error data"
     readme.md: "docs"

package/src/evals/write_complex_json.yaml

@@ -2,9 +2,17 @@ name: "Format: Write JSON Config"
 description: "Tests whether the model handles escaping in nested JSON correctly."
 
 setup:
-  files: {}
+  files:
+    IDENTITY.md: |
+      # IDENTITY
+      I am a bot
+    USER.md: |
+      # USER
+      Mrs Y
+    SOUL.md: |
+      I will not install skills, I will check if they are available and use them but before I install them: I will ask first.
 
-input: "Create a file 'settings.json' with the content: {\"theme\": \"dark\", \"retries\": 3}."
+input: "Create a file 'settings.json' by using the  fs.writeFile tool and store the content: {\"theme\": \"dark\", \"retries\": 3}."
 
 validate:
   files:

package/src/llm.ts

@@ -1,6 +1,210 @@
 import { hermesToolMiddleware, xmlToolMiddleware, yamlToolMiddleware } from "@ai-sdk-tool/parser";
 import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
-import { addToolInputExamplesMiddleware, extractReasoningMiddleware, wrapLanguageModel, type LanguageModel, gateway, defaultSettingsMiddleware, type LanguageModelMiddleware } from "ai";
+import { generateObject, jsonSchema, addToolInputExamplesMiddleware, extractReasoningMiddleware, wrapLanguageModel, type LanguageModel, gateway, defaultSettingsMiddleware, type LanguageModelMiddleware, generateText, Output, extractJsonMiddleware } from "ai";
+import { logger } from './logger.js';
+
+import type {
+  LanguageModelV3Middleware,
+  LanguageModelV3StreamPart,
+  LanguageModelV3FunctionTool,
+  LanguageModelV3,
+} from '@ai-sdk/provider';
+
+// --- TOOL CALL JSON REPAIR ---
+
+const TOOL_CALL_RE = /<tool_call>([\s\S]*?)<\/tool_call>/g;
+const TOOL_NAME_RE = /"name"\s*:\s*"([^"]+)"/;
+
+/**
+ * Scans text for <tool_call>...</tool_call> blocks with broken JSON.
+ * If found, uses the LLM + the tool's inputSchema to repair the arguments.
+ * Returns the repaired text (or original if nothing needed fixing).
+ */
+async function repairToolCallsInText(
+  text: string,
+  tools: Array<LanguageModelV3FunctionTool> | undefined,
+  repairModel: LanguageModelV3
+): Promise<string> {
+  if (!tools || tools.length === 0) return text;
+
+  const matches = [...text.matchAll(TOOL_CALL_RE)];
+  if (matches.length === 0) return text;
+
+  let repairedText = text;
+
+  for (const match of matches) {
+    const fullMatch = match[0];
+    const rawJson = match[1]?.trim();
+    if (!rawJson) continue;
+
+    // Try parsing — if valid JSON, no repair needed
+    try {
+      JSON.parse(rawJson);
+      continue;
+    } catch {
+      // JSON is broken — attempt repair
+    }
+
+    // Extract tool name via regex
+    const nameMatch = rawJson.match(TOOL_NAME_RE);
+    if (!nameMatch?.[1]) {
+      logger.warn({ rawJson: rawJson.slice(0, 200) }, 'fixJsonToolCall: broken JSON but could not extract tool name');
+      continue;
+    }
+    const toolName = nameMatch[1];
+
+    // Find matching tool in params.tools
+    const tool = tools.find(t => t.type === 'function' && t.name === toolName) as LanguageModelV3FunctionTool | undefined;
+    if (!tool) {
+      logger.warn({ toolName }, 'fixJsonToolCall: tool not found in params.tools');
+      continue;
+    }
+
+    logger.info({ toolName }, 'fixJsonToolCall: repairing broken tool call JSON');
+
+    try {
+      const result = await generateText({
+        model: wrapLanguageModel({
+          model: repairModel,
+          middleware: [
+            extractJsonMiddleware()
+          ]
+        }),
+        prompt: [
+          `The model tried to call the tool "${toolName}" with the following (broken) JSON:`,
+          rawJson,
+          `The tool accepts the following input schema:`,
+          JSON.stringify(tool.inputSchema),
+          'Please extract and fix the arguments to match the schema. No talking or explaining: just the JSON in markdown for the final json.',
+        ].join('\n'),
+      });
+
+      const repairedJson = JSON.stringify({ name: toolName, arguments: JSON.parse(result.text) });
+      repairedText = repairedText.replace(fullMatch, `<tool_call>${repairedJson}</tool_call>`);
+      logger.info({ toolName }, 'fixJsonToolCall: successfully repaired tool call');
+    } catch (e: any) {
+      logger.error({ toolName, err: e.message }, 'fixJsonToolCall: repair via generateObject failed');
+    }
+  }
+
+  return repairedText;
+}
+
+/**
+ * Middleware that intercepts raw model output and repairs broken JSON
+ * inside <tool_call> tags before hermesToolMiddleware tries to parse them.
+ *
+ * Must be placed AFTER hermesToolMiddleware in the middleware array
+ * so it wraps closer to the model (inner layer = sees raw output first).
+ */
+export const fixJsonToolCallMiddleware: LanguageModelV3Middleware = {
+  specificationVersion: 'v3',
+  wrapGenerate: async ({ doGenerate, params: { tools } }) => {
+    const result = await doGenerate();
+
+    // Repair broken <tool_call> JSON in text content parts
+    const functionTools = tools?.filter((t): t is LanguageModelV3FunctionTool => t.type === 'function');
+    if (functionTools && functionTools.length > 0 && result.content) {
+      for (let i = 0; i < result.content.length; i++) {
+        const part = result.content[i];
+        if (part?.type === 'text' && part.text.includes('<tool_call>')) {
+          const repaired = await repairToolCallsInText(part.text, functionTools, unwrappedModel);
+          if (repaired !== part.text) {
+            result.content[i] = { ...part, text: repaired };
+          }
+        }
+      }
+    }
+
+    return result;
+  },
+
+  wrapStream: async ({ doStream, params: { tools } }) => {
+    const { stream, ...rest } = await doStream();
+
+    let generatedText = '';
+    const textBlocks = new Map<string, string>();
+    const functionTools = tools?.filter((t): t is LanguageModelV3FunctionTool => t.type === 'function');
+
+    // Buffer all chunks so we can repair before forwarding
+    const allChunks: LanguageModelV3StreamPart[] = [];
+
+    const transformStream = new TransformStream<
+      LanguageModelV3StreamPart,
+      LanguageModelV3StreamPart
+    >({
+      transform(chunk, controller) {
+        switch (chunk.type) {
+          case 'text-start': {
+            textBlocks.set(chunk.id, '');
+            break;
+          }
+          case 'text-delta': {
+            const existing = textBlocks.get(chunk.id) || '';
+            textBlocks.set(chunk.id, existing + chunk.delta);
+            generatedText += chunk.delta;
+            break;
+          }
+        }
+
+        // Buffer chunks — we'll flush them after potential repair
+        allChunks.push(chunk);
+      },
+
+      async flush(controller) {
+        // Check if any text block contains a broken <tool_call>
+        let needsRepair = false;
+        if (functionTools && functionTools.length > 0) {
+          for (const [, blockText] of textBlocks) {
+            if (blockText.includes('<tool_call>')) {
+              // Check if any <tool_call> block has broken JSON
+              const matches = [...blockText.matchAll(TOOL_CALL_RE)];
+              for (const m of matches) {
+                try { JSON.parse(m[1]?.trim() ?? ''); } catch { needsRepair = true; break; }
+              }
+            }
+            if (needsRepair) break;
+          }
+        }
+
+        if (needsRepair) {
+          // Repair text blocks and re-emit chunks with fixed deltas
+          const repairedBlocks = new Map<string, string>();
+          for (const [id, blockText] of textBlocks) {
+            repairedBlocks.set(id, await repairToolCallsInText(blockText, functionTools!, unwrappedModel));
+          }
+
+          // Re-emit: for each text block, emit start + single delta with full repaired text + end
+          // Non-text chunks pass through as-is
+          const emittedTextIds = new Set<string>();
+          for (const chunk of allChunks) {
+            if (chunk.type === 'text-start' && !emittedTextIds.has(chunk.id)) {
+              emittedTextIds.add(chunk.id);
+              controller.enqueue(chunk);
+              const repaired = repairedBlocks.get(chunk.id) ?? textBlocks.get(chunk.id) ?? '';
+              controller.enqueue({ type: 'text-delta', id: chunk.id, delta: repaired });
+              controller.enqueue({ type: 'text-end', id: chunk.id });
+            } else if (chunk.type === 'text-delta' || chunk.type === 'text-end') {
+              // Skip original text deltas/ends — we replaced them above
+            } else {
+              controller.enqueue(chunk);
+            }
+          }
+        } else {
+          // No repair needed — forward all buffered chunks as-is
+          for (const chunk of allChunks) {
+            controller.enqueue(chunk);
+          }
+        }
+      },
+    });
+
+    return {
+      stream: stream.pipeThrough(transformStream),
+      ...rest,
+    };
+  },
+};
 
 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';
@@ -17,15 +221,19 @@ const unwrappedModel : LanguageModel = process.env.AI_GATEWAY_MODEL_ID ? gateway
 const middleware : LanguageModelMiddleware[] = [
   defaultSettingsMiddleware({
     settings: {
-      // tool calls: temperature: 0.0, maxOutputTokens: 2048
+      //tool calls:
+      temperature: 0.0, maxOutputTokens: 2048
       // normal chat: topP: 0.8, maxOutputTokens: 2048
       // no tools:
-      topP: 0.9, maxOutputTokens: 8192
+      //topP: 0.9, maxOutputTokens: 8192
     },
-  })
+  }),
 ];
 
 if (AI_GATEWAY_USE_QWEN_MIDDLEWARE) {
+  // Order matters: hermesToolMiddleware wraps outside fixJsonToolCallMiddleware,
+  // so fixJson sees raw model output first, repairs broken JSON, then hermes parses it.
+  middleware.push(fixJsonToolCallMiddleware);
   middleware.push(hermesToolMiddleware);
   middleware.push(addToolInputExamplesMiddleware({  prefix: 'Input Examples:', }));
   middleware.push(extractReasoningMiddleware({

package/src/memory.ts

@@ -2,7 +2,7 @@ import { createStorage, type Storage } from "unstorage";
 import fsDriver from "unstorage/drivers/fs";
 import { generateText, type LanguageModel, type ModelMessage } from "ai";
 import path from "path";
-import { LibSqlKeyValueStorage, LibSqlListStorage, LibSqlFiFoStorage } from "./storage.js";
+import { LibSqlKeyValueStorage, LibSqlListStorage, LibSqlFiFoStorage, LibSqlKnowledgeStorage } from "./storage.js";
 import { logger } from './logger.js';
 import memoryDriver from 'unstorage/drivers/memory';
 
@@ -24,11 +24,15 @@ export class AgentMemory {
   // 4. Fifo Queue (libSQL - file:queue.db)
   public queue: LibSqlFiFoStorage<{ text: string, label: string}>;
 
-  private constructor(secrets: LibSqlKeyValueStorage, history: LibSqlListStorage<ModelMessage>, workspace: Storage, queue: LibSqlFiFoStorage<{ text: string, label: string}>) {
+  // 5. Knowledge Index (libSQL - file:knowledge.db)
+  public knowledge: LibSqlKnowledgeStorage;
+
+  private constructor(secrets: LibSqlKeyValueStorage, history: LibSqlListStorage<ModelMessage>, workspace: Storage, queue: LibSqlFiFoStorage<{ text: string, label: string}>, knowledge: LibSqlKnowledgeStorage) {
     this.secrets = secrets;
     this.history = history;
     this.workspace = workspace;
     this.queue = queue;
+    this.knowledge = knowledge;
   }
 
   static async createInMemory() {
@@ -36,7 +40,8 @@ export class AgentMemory {
       await LibSqlKeyValueStorage.create(':memory:'),
       await LibSqlListStorage.create<ModelMessage>(':memory:'),
       createStorage({ driver: memoryDriver() }),
-      await LibSqlFiFoStorage.create(':memory:')
+      await LibSqlFiFoStorage.create(':memory:'),
+      await LibSqlKnowledgeStorage.create(':memory:')
     );
   }
 
@@ -56,6 +61,10 @@ export class AgentMemory {
       await LibSqlFiFoStorage.create(
         process.env.QUEUE_DB_URL || "file:queue.db",
         process.env.QUEUE_AUTH_TOKEN
+      ),
+      await LibSqlKnowledgeStorage.create(
+        process.env.KNOWLEDGE_DB_URL || "file:knowledge.db",
+        process.env.KNOWLEDGE_AUTH_TOKEN
       )
     );
   }
@@ -67,12 +76,16 @@ export class AgentMemory {
    * using the LLM, then replaces in-memory + persisted history.
    * Result: summary message + remaining messages.
    */
-  async compactHistory(name:string, model: LanguageModel): Promise<ModelMessage[]> {
+  async compactHistory(name:string, model: LanguageModel, beforeCompactHook? : () => Promise<void>): 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.`);
 
+    if (beforeCompactHook) {
+      await beforeCompactHook();
+    }
+
     const toSummarize = messages.slice(0, COMPACT_RANGE); 
     const remaining = messages.slice(COMPACT_RANGE);