@deepagents/context 0.11.0 → 0.12.1

package/dist/index.js

@@ -175,12 +175,6 @@ function fragment(name, ...children) {
     data: children
   };
 }
-function role(content) {
-  return {
-    name: "role",
-    data: content
-  };
-}
 function user(content) {
   const message2 = typeof content === "string" ? {
     id: generateId(),
@@ -228,7 +222,7 @@ function message(content) {
   } : content;
   return {
     id: message2.id,
-    name: "message",
+    name: message2.role,
     data: "content",
     type: "message",
     persist: true,
@@ -250,6 +244,22 @@ function assistantText(content, options) {
     parts: [{ type: "text", text: content }]
   });
 }
+var LAZY_ID = Symbol("lazy-id");
+function isLazyFragment(fragment2) {
+  return LAZY_ID in fragment2;
+}
+function lastAssistantMessage(content) {
+  return {
+    name: "assistant",
+    type: "message",
+    persist: true,
+    data: "content",
+    [LAZY_ID]: {
+      type: "last-assistant",
+      content
+    }
+  };
+}
 
 // packages/context/src/lib/renderers/abstract.renderer.ts
 import pluralize from "pluralize";
@@ -277,6 +287,68 @@ var ContextRenderer = class {
     }
     return groups;
   }
+  /**
+   * Remove null/undefined from fragments and fragment data recursively.
+   * This protects renderers from nullish values and ensures they are ignored
+   * consistently across all output formats.
+   */
+  sanitizeFragments(fragments) {
+    const sanitized = [];
+    for (const fragment2 of fragments) {
+      const cleaned = this.sanitizeFragment(fragment2, /* @__PURE__ */ new WeakSet());
+      if (cleaned) {
+        sanitized.push(cleaned);
+      }
+    }
+    return sanitized;
+  }
+  sanitizeFragment(fragment2, seen) {
+    const data = this.sanitizeData(fragment2.data, seen);
+    if (data == null) {
+      return null;
+    }
+    return {
+      ...fragment2,
+      data
+    };
+  }
+  sanitizeData(data, seen) {
+    if (data == null) {
+      return void 0;
+    }
+    if (isFragment(data)) {
+      return this.sanitizeFragment(data, seen) ?? void 0;
+    }
+    if (Array.isArray(data)) {
+      if (seen.has(data)) {
+        return void 0;
+      }
+      seen.add(data);
+      const cleaned = [];
+      for (const item of data) {
+        const sanitizedItem = this.sanitizeData(item, seen);
+        if (sanitizedItem != null) {
+          cleaned.push(sanitizedItem);
+        }
+      }
+      return cleaned;
+    }
+    if (isFragmentObject(data)) {
+      if (seen.has(data)) {
+        return void 0;
+      }
+      seen.add(data);
+      const cleaned = {};
+      for (const [key, value] of Object.entries(data)) {
+        const sanitizedValue = this.sanitizeData(value, seen);
+        if (sanitizedValue != null) {
+          cleaned[key] = sanitizedValue;
+        }
+      }
+      return cleaned;
+    }
+    return data;
+  }
   /**
    * Template method - dispatches value to appropriate handler.
    */
@@ -304,7 +376,8 @@ var ContextRenderer = class {
 };
 var XmlRenderer = class extends ContextRenderer {
   render(fragments) {
-    return fragments.map((f) => this.#renderTopLevel(f)).filter(Boolean).join("\n");
+    const sanitized = this.sanitizeFragments(fragments);
+    return sanitized.map((f) => this.#renderTopLevel(f)).filter(Boolean).join("\n");
   }
   #renderTopLevel(fragment2) {
     if (this.isPrimitive(fragment2.data)) {
@@ -317,10 +390,13 @@ var XmlRenderer = class extends ContextRenderer {
       const child = this.renderFragment(fragment2.data, { depth: 1, path: [] });
       return this.#wrap(fragment2.name, [child]);
     }
-    return this.#wrap(
-      fragment2.name,
-      this.renderEntries(fragment2.data, { depth: 1, path: [] })
-    );
+    if (isFragmentObject(fragment2.data)) {
+      return this.#wrap(
+        fragment2.name,
+        this.renderEntries(fragment2.data, { depth: 1, path: [] })
+      );
+    }
+    return "";
   }
   #renderArray(name, items, depth) {
     const fragmentItems = items.filter(isFragment);
@@ -328,9 +404,19 @@ var XmlRenderer = class extends ContextRenderer {
     const children = [];
     for (const item of nonFragmentItems) {
       if (item != null) {
-        children.push(
-          this.#leaf(pluralize.singular(name), String(item), depth + 1)
-        );
+        if (isFragmentObject(item)) {
+          children.push(
+            this.#wrapIndented(
+              pluralize.singular(name),
+              this.renderEntries(item, { depth: depth + 2, path: [] }),
+              depth + 1
+            )
+          );
+        } else {
+          children.push(
+            this.#leaf(pluralize.singular(name), String(item), depth + 1)
+          );
+        }
       }
     }
     if (this.options.groupFragments && fragmentItems.length > 0) {
@@ -372,8 +458,14 @@ ${this.#indent(safe, 2)}
     if (Array.isArray(data)) {
       return this.#renderArrayIndented(name, data, ctx.depth);
     }
-    const children = this.renderEntries(data, { ...ctx, depth: ctx.depth + 1 });
-    return this.#wrapIndented(name, children, ctx.depth);
+    if (isFragmentObject(data)) {
+      const children = this.renderEntries(data, {
+        ...ctx,
+        depth: ctx.depth + 1
+      });
+      return this.#wrapIndented(name, children, ctx.depth);
+    }
+    return "";
   }
   #renderArrayIndented(name, items, depth) {
     const fragmentItems = items.filter(isFragment);
@@ -381,9 +473,19 @@ ${this.#indent(safe, 2)}
     const children = [];
     for (const item of nonFragmentItems) {
       if (item != null) {
-        children.push(
-          this.#leaf(pluralize.singular(name), String(item), depth + 1)
-        );
+        if (isFragmentObject(item)) {
+          children.push(
+            this.#wrapIndented(
+              pluralize.singular(name),
+              this.renderEntries(item, { depth: depth + 2, path: [] }),
+              depth + 1
+            )
+          );
+        } else {
+          children.push(
+            this.#leaf(pluralize.singular(name), String(item), depth + 1)
+          );
+        }
       }
     }
     if (this.options.groupFragments && fragmentItems.length > 0) {
@@ -412,7 +514,19 @@ ${this.#indent(safe, 2)}
       return "";
     }
     const itemTag = pluralize.singular(key);
-    const children = items.filter((item) => item != null).map((item) => this.#leaf(itemTag, String(item), ctx.depth + 1));
+    const children = items.filter((item) => item != null).map((item) => {
+      if (isFragment(item)) {
+        return this.renderFragment(item, { ...ctx, depth: ctx.depth + 1 });
+      }
+      if (isFragmentObject(item)) {
+        return this.#wrapIndented(
+          itemTag,
+          this.renderEntries(item, { ...ctx, depth: ctx.depth + 2 }),
+          ctx.depth + 1
+        );
+      }
+      return this.#leaf(itemTag, String(item), ctx.depth + 1);
+    });
     return this.#wrapIndented(key, children, ctx.depth);
   }
   renderObject(key, obj, ctx) {
@@ -464,7 +578,7 @@ ${pad}</${tag}>`;
 };
 var MarkdownRenderer = class extends ContextRenderer {
   render(fragments) {
-    return fragments.map((f) => {
+    return this.sanitizeFragments(fragments).map((f) => {
       const title = `## ${titlecase(f.name)}`;
       if (this.isPrimitive(f.data)) {
         return `${title}
@@ -478,8 +592,12 @@ ${this.#renderArray(f.data, 0)}`;
         return `${title}
 ${this.renderFragment(f.data, { depth: 0, path: [] })}`;
       }
-      return `${title}
+      if (isFragmentObject(f.data)) {
+        return `${title}
 ${this.renderEntries(f.data, { depth: 0, path: [] }).join("\n")}`;
+      }
+      return `${title}
+`;
     }).join("\n\n");
   }
   #renderArray(items, depth) {
@@ -536,14 +654,17 @@ ${this.renderEntries(f.data, { depth: 0, path: [] }).join("\n")}`;
       return [header, child].join("\n");
     }
     if (Array.isArray(data)) {
-      const children2 = data.filter((item) => item != null).map((item) => this.#arrayItem(item, ctx.depth + 1));
-      return [header, ...children2].join("\n");
+      const children = data.filter((item) => item != null).map((item) => this.#arrayItem(item, ctx.depth + 1));
+      return [header, ...children].join("\n");
     }
-    const children = this.renderEntries(data, {
-      ...ctx,
-      depth: ctx.depth + 1
-    }).join("\n");
-    return [header, children].join("\n");
+    if (isFragmentObject(data)) {
+      const children = this.renderEntries(data, {
+        ...ctx,
+        depth: ctx.depth + 1
+      }).join("\n");
+      return [header, children].join("\n");
+    }
+    return header;
   }
   renderPrimitive(key, value, ctx) {
     return this.#leaf(key, value, ctx.depth);
@@ -564,22 +685,25 @@ ${this.renderEntries(f.data, { depth: 0, path: [] }).join("\n")}`;
 };
 var TomlRenderer = class extends ContextRenderer {
   render(fragments) {
-    return fragments.map((f) => {
+    const rendered = [];
+    for (const f of this.sanitizeFragments(fragments)) {
       if (this.isPrimitive(f.data)) {
-        return `${f.name} = ${this.#formatValue(f.data)}`;
-      }
-      if (Array.isArray(f.data)) {
-        return this.#renderTopLevelArray(f.name, f.data);
-      }
-      if (isFragment(f.data)) {
-        return [
-          `[${f.name}]`,
-          this.renderFragment(f.data, { depth: 0, path: [f.name] })
-        ].join("\n");
+        rendered.push(`${f.name} = ${this.#formatValue(f.data)}`);
+      } else if (Array.isArray(f.data)) {
+        rendered.push(this.#renderTopLevelArray(f.name, f.data));
+      } else if (isFragment(f.data)) {
+        rendered.push(
+          [
+            `[${f.name}]`,
+            this.renderFragment(f.data, { depth: 0, path: [f.name] })
+          ].join("\n")
+        );
+      } else if (isFragmentObject(f.data)) {
+        const entries = this.#renderObjectEntries(f.data, [f.name]);
+        rendered.push([`[${f.name}]`, ...entries].join("\n"));
       }
-      const entries = this.#renderObjectEntries(f.data, [f.name]);
-      return [`[${f.name}]`, ...entries].join("\n");
-    }).join("\n\n");
+    }
+    return rendered.join("\n\n");
   }
   #renderTopLevelArray(name, items) {
     const fragmentItems = items.filter(isFragment);
@@ -614,10 +738,12 @@ var TomlRenderer = class extends ContextRenderer {
     }
     return `${key} = ${this.#formatValue(value)}`;
   }
-  renderPrimitive(key, value, _ctx) {
+  renderPrimitive(key, value, ctx) {
+    void ctx;
     return `${key} = ${this.#formatValue(value)}`;
   }
-  renderArray(key, items, _ctx) {
+  renderArray(key, items, ctx) {
+    void ctx;
     const values = items.filter((item) => item != null).map((item) => this.#formatValue(item));
     return `${key} = [${values.join(", ")}]`;
   }
@@ -671,8 +797,11 @@ var TomlRenderer = class extends ContextRenderer {
       const values = nonFragmentItems.map((item) => this.#formatValue(item));
       return `${name} = [${values.join(", ")}]`;
     }
-    const entries = this.#renderObjectEntries(data, newPath);
-    return ["", `[${newPath.join(".")}]`, ...entries].join("\n");
+    if (isFragmentObject(data)) {
+      const entries = this.#renderObjectEntries(data, newPath);
+      return ["", `[${newPath.join(".")}]`, ...entries].join("\n");
+    }
+    return "";
   }
   #escape(value) {
     return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
@@ -692,7 +821,8 @@ var TomlRenderer = class extends ContextRenderer {
 };
 var ToonRenderer = class extends ContextRenderer {
   render(fragments) {
-    return fragments.map((f) => this.#renderTopLevel(f)).filter(Boolean).join("\n");
+    const sanitized = this.sanitizeFragments(fragments);
+    return sanitized.map((f) => this.#renderTopLevel(f)).filter(Boolean).join("\n");
   }
   #renderTopLevel(fragment2) {
     const { name, data } = fragment2;
@@ -741,18 +871,18 @@ ${entries}`;
     if (items.length === 0) return false;
     const objects = items.filter(isFragmentObject);
     if (objects.length !== items.length) return false;
-    const firstKeys = Object.keys(objects[0]).sort().join(",");
+    let intersection = new Set(Object.keys(objects[0]));
     for (const obj of objects) {
-      if (Object.keys(obj).sort().join(",") !== firstKeys) {
-        return false;
-      }
+      const keys = new Set(Object.keys(obj));
+      intersection = new Set([...intersection].filter((k) => keys.has(k)));
       for (const value of Object.values(obj)) {
-        if (!this.#isPrimitiveValue(value) && value !== null) {
+        if (value == null) continue;
+        if (!this.#isPrimitiveValue(value)) {
           return false;
         }
       }
     }
-    return true;
+    return intersection.size > 0;
   }
   #renderPrimitiveArray(key, items, depth) {
     const values = items.map((item) => this.#formatValue(item)).join(",");
@@ -762,10 +892,16 @@ ${entries}`;
     if (items.length === 0) {
       return `${this.#pad(depth)}${key}[0]:`;
     }
-    const fields = Object.keys(items[0]);
+    const fields = Array.from(
+      new Set(items.flatMap((obj) => Object.keys(obj)))
+    );
     const header = `${this.#pad(depth)}${key}[${items.length}]{${fields.join(",")}}:`;
     const rows = items.map((obj) => {
-      const values = fields.map((f) => this.#formatValue(obj[f]));
+      const values = fields.map((f) => {
+        const value = obj[f];
+        if (value == null) return "";
+        return this.#formatValue(value);
+      });
       return `${this.#pad(depth + 1)}${values.join(",")}`;
     });
     return [header, ...rows].join("\n");
@@ -913,6 +1049,7 @@ var ContextEngine = class {
   #pendingMessages = [];
   #store;
   #chatId;
+  #userId;
   #branchName;
   #branch = null;
   #chatData = null;
@@ -921,9 +1058,13 @@ var ContextEngine = class {
     if (!options.chatId) {
       throw new Error("chatId is required");
     }
+    if (!options.userId) {
+      throw new Error("userId is required");
+    }
     this.#store = options.store;
     this.#chatId = options.chatId;
-    this.#branchName = options.branch ?? "main";
+    this.#userId = options.userId;
+    this.#branchName = "main";
   }
   /**
    * Initialize the chat and branch if they don't exist.
@@ -932,24 +1073,11 @@ var ContextEngine = class {
     if (this.#initialized) {
       return;
     }
-    this.#chatData = await this.#store.upsertChat({ id: this.#chatId });
-    const existingBranch = await this.#store.getBranch(
-      this.#chatId,
-      this.#branchName
-    );
-    if (existingBranch) {
-      this.#branch = existingBranch;
-    } else {
-      this.#branch = {
-        id: crypto.randomUUID(),
-        chatId: this.#chatId,
-        name: this.#branchName,
-        headMessageId: null,
-        isActive: true,
-        createdAt: Date.now()
-      };
-      await this.#store.createBranch(this.#branch);
-    }
+    this.#chatData = await this.#store.upsertChat({
+      id: this.#chatId,
+      userId: this.#userId
+    });
+    this.#branch = await this.#store.getActiveBranch(this.#chatId);
     this.#initialized = true;
   }
   /**
@@ -1009,6 +1137,7 @@ var ContextEngine = class {
     }
     return {
       id: this.#chatData.id,
+      userId: this.#chatData.userId,
       createdAt: this.#chatData.createdAt,
       updatedAt: this.#chatData.updatedAt,
       title: this.#chatData.title,
@@ -1051,7 +1180,7 @@ var ContextEngine = class {
    *
    * @example
    * ```ts
-   * const context = new ContextEngine({ store, chatId: 'chat-1' })
+   * const context = new ContextEngine({ store, chatId: 'chat-1', userId: 'user-1' })
    *   .set(role('You are helpful'), user('Hello'));
    *
    * const { systemPrompt, messages } = await context.resolve();
@@ -1095,6 +1224,12 @@ var ContextEngine = class {
     if (this.#pendingMessages.length === 0) {
       return;
     }
+    for (let i = 0; i < this.#pendingMessages.length; i++) {
+      const fragment2 = this.#pendingMessages[i];
+      if (isLazyFragment(fragment2)) {
+        this.#pendingMessages[i] = await this.#resolveLazyFragment(fragment2);
+      }
+    }
     let parentId = this.#branch.headMessageId;
     const now = Date.now();
     for (const fragment2 of this.#pendingMessages) {
@@ -1114,6 +1249,39 @@ var ContextEngine = class {
     this.#branch.headMessageId = parentId;
     this.#pendingMessages = [];
   }
+  /**
+   * Resolve a lazy fragment by finding the appropriate ID.
+   */
+  async #resolveLazyFragment(fragment2) {
+    const lazy = fragment2[LAZY_ID];
+    if (lazy.type === "last-assistant") {
+      const lastId = await this.#getLastAssistantId();
+      return assistantText(lazy.content, { id: lastId ?? crypto.randomUUID() });
+    }
+    throw new Error(`Unknown lazy fragment type: ${lazy.type}`);
+  }
+  /**
+   * Find the most recent assistant message ID (pending or persisted).
+   */
+  async #getLastAssistantId() {
+    for (let i = this.#pendingMessages.length - 1; i >= 0; i--) {
+      const msg = this.#pendingMessages[i];
+      if (msg.name === "assistant" && !isLazyFragment(msg)) {
+        return msg.id;
+      }
+    }
+    if (this.#branch?.headMessageId) {
+      const chain = await this.#store.getMessageChain(
+        this.#branch.headMessageId
+      );
+      for (let i = chain.length - 1; i >= 0; i--) {
+        if (chain[i].name === "assistant") {
+          return chain[i].id;
+        }
+      }
+    }
+    return void 0;
+  }
   /**
    * Estimate token count and cost for the full context.
    *
@@ -1393,9 +1561,38 @@ var ContextEngine = class {
   consolidate() {
     return void 0;
   }
+  /**
+   * Extract skill path mappings from available_skills fragments.
+   * Returns array of { host, sandbox } for mounting in sandbox filesystem.
+   *
+   * Reads the original `paths` configuration stored in fragment metadata
+   * by the skills() fragment helper.
+   *
+   * @example
+   * ```ts
+   * const context = new ContextEngine({ store, chatId, userId })
+   *   .set(skills({ paths: [{ host: './skills', sandbox: '/skills' }] }));
+   *
+   * const mounts = context.getSkillMounts();
+   * // [{ host: './skills', sandbox: '/skills' }]
+   * ```
+   */
+  getSkillMounts() {
+    const mounts = [];
+    for (const fragment2 of this.#fragments) {
+      if (fragment2.name === "available_skills" && fragment2.metadata && Array.isArray(fragment2.metadata.paths)) {
+        for (const mapping of fragment2.metadata.paths) {
+          if (typeof mapping === "object" && mapping !== null && typeof mapping.host === "string" && typeof mapping.sandbox === "string") {
+            mounts.push({ host: mapping.host, sandbox: mapping.sandbox });
+          }
+        }
+      }
+    }
+    return mounts;
+  }
   /**
    * Inspect the full context state for debugging.
-   * Returns a comprehensive JSON-serializable object with all context information.
+   * Returns a JSON-serializable object with context information.
    *
    * @param options - Inspection options (modelId and renderer required)
    * @returns Complete inspection data including estimates, rendered output, fragments, and graph
@@ -1547,6 +1744,33 @@ function glossary(entries) {
     }))
   };
 }
+function role(content) {
+  return {
+    name: "role",
+    data: content
+  };
+}
+function principle(input) {
+  return {
+    name: "principle",
+    data: {
+      title: input.title,
+      description: input.description,
+      ...input.policies?.length && { policies: input.policies }
+    }
+  };
+}
+function policy(input) {
+  return {
+    name: "policy",
+    data: {
+      rule: input.rule,
+      ...input.before && { before: input.before },
+      ...input.reason && { reason: input.reason },
+      ...input.policies?.length && { policies: input.policies }
+    }
+  };
+}
 
 // packages/context/src/lib/fragments/user.ts
 function identity(input) {
@@ -1563,7 +1787,8 @@ function persona(input) {
     name: "persona",
     data: {
       name: input.name,
-      role: input.role,
+      ...input.role && { role: input.role },
+      ...input.objective && { objective: input.objective },
       ...input.tone && { tone: input.tone }
     }
   };
@@ -1612,11 +1837,79 @@ function runGuardrailChain(part, guardrails, context) {
   return pass(currentPart);
 }
 
+// packages/context/src/lib/guardrails/error-recovery.guardrail.ts
+import chalk from "chalk";
+var errorRecoveryGuardrail = {
+  id: "error-recovery",
+  name: "API Error Recovery",
+  handle: (part, context) => {
+    if (part.type !== "error") {
+      return pass(part);
+    }
+    const errorText = part.errorText || "";
+    const prefix = chalk.bold.magenta("[ErrorRecovery]");
+    console.log(
+      `${prefix} ${chalk.red("Caught error:")} ${chalk.dim(errorText.slice(0, 150))}`
+    );
+    const logAndFail = (pattern, feedback) => {
+      console.log(
+        `${prefix} ${chalk.yellow("Pattern:")} ${chalk.cyan(pattern)}`
+      );
+      console.log(
+        `${prefix} ${chalk.green("Feedback:")} ${chalk.dim(feedback.slice(0, 80))}...`
+      );
+      return fail(feedback);
+    };
+    if (errorText.includes("Tool choice is none")) {
+      if (context.availableTools.length > 0) {
+        return logAndFail(
+          "Tool choice is none",
+          `I tried to call a tool that doesn't exist. Available tools: ${context.availableTools.join(", ")}. Let me use one of these instead.`
+        );
+      }
+      return logAndFail(
+        "Tool choice is none (no tools)",
+        "I tried to call a tool, but no tools are available. Let me respond with plain text instead."
+      );
+    }
+    if (errorText.includes("not in request.tools") || errorText.includes("tool") && errorText.includes("not found")) {
+      const toolMatch = errorText.match(/tool '([^']+)'/);
+      const toolName = toolMatch ? toolMatch[1] : "unknown";
+      if (context.availableTools.length > 0) {
+        return logAndFail(
+          `Unregistered tool: ${toolName}`,
+          `I tried to call "${toolName}" but it doesn't exist. Available tools: ${context.availableTools.join(", ")}. Let me use one of these instead.`
+        );
+      }
+      return logAndFail(
+        `Unregistered tool: ${toolName} (no tools)`,
+        `I tried to call "${toolName}" but no tools are available. Let me respond with plain text instead.`
+      );
+    }
+    if (errorText.includes("Failed to parse tool call arguments") || errorText.includes("parse tool call") || errorText.includes("invalid JSON")) {
+      return logAndFail(
+        "Malformed JSON arguments",
+        "I generated malformed JSON for the tool arguments. Let me format my tool call properly with valid JSON."
+      );
+    }
+    if (errorText.includes("Parsing failed")) {
+      return logAndFail(
+        "Parsing failed",
+        "My response format was invalid. Let me try again with a properly formatted response."
+      );
+    }
+    return logAndFail(
+      "Unknown error",
+      `An error occurred: ${errorText}. Let me try a different approach.`
+    );
+  }
+};
+
 // packages/context/src/lib/sandbox/binary-bridges.ts
+import { existsSync } from "fs";
 import { defineCommand } from "just-bash";
 import spawn from "nano-spawn";
 import * as path from "path";
-import { existsSync } from "fs";
 function createBinaryBridges(...binaries) {
   return binaries.map((input) => {
     const config = typeof input === "string" ? { name: input } : input;
@@ -1662,6 +1955,17 @@ function createBinaryBridges(...binaries) {
           exitCode: 0
         };
       } catch (error) {
+        if (error && typeof error === "object") {
+          const err = error;
+          const cause = err.cause;
+          if (cause?.code === "ENOENT") {
+            return {
+              stdout: "",
+              stderr: `${name}: ${binaryPath} not found`,
+              exitCode: 127
+            };
+          }
+        }
         if (error && typeof error === "object" && "exitCode" in error) {
           const subprocessError = error;
           return {
@@ -2379,7 +2683,9 @@ function parseFrontmatter(content) {
     throw new Error('Invalid SKILL.md: frontmatter must have a "name" field');
   }
   if (!frontmatter.description || typeof frontmatter.description !== "string") {
-    throw new Error('Invalid SKILL.md: frontmatter must have a "description" field');
+    throw new Error(
+      'Invalid SKILL.md: frontmatter must have a "description" field'
+    );
   }
   return {
     frontmatter,
@@ -2420,9 +2726,13 @@ function discoverSkillsInDirectory(directory) {
 
 // packages/context/src/lib/skills/fragments.ts
 function skills(options) {
+  const pathMapping = /* @__PURE__ */ new Map();
+  for (const { host, sandbox } of options.paths) {
+    pathMapping.set(host, sandbox);
+  }
   const skillsMap = /* @__PURE__ */ new Map();
-  for (const dir of options.paths) {
-    const discovered = discoverSkillsInDirectory(dir);
+  for (const { host } of options.paths) {
+    const discovered = discoverSkillsInDirectory(host);
     for (const skill of discovered) {
       skillsMap.set(skill.name, skill);
     }
@@ -2437,14 +2747,26 @@ function skills(options) {
       (s) => !options.exclude.includes(s.name)
     );
   }
-  const skillFragments = filteredSkills.map((skill) => ({
-    name: "skill",
-    data: {
-      name: skill.name,
-      path: skill.skillMdPath,
-      description: skill.description
+  const skillFragments = filteredSkills.map((skill) => {
+    const originalPath = skill.skillMdPath;
+    let sandboxPath = originalPath;
+    for (const [host, sandbox] of pathMapping) {
+      if (originalPath.startsWith(host)) {
+        const relativePath = originalPath.slice(host.length);
+        sandboxPath = sandbox + relativePath;
+        break;
+      }
     }
-  }));
+    return {
+      name: "skill",
+      data: {
+        name: skill.name,
+        path: sandboxPath,
+        description: skill.description
+      },
+      metadata: { originalPath }
+    };
+  });
   return {
     name: "available_skills",
     data: [
@@ -2453,7 +2775,11 @@ function skills(options) {
         data: SKILLS_INSTRUCTIONS
       },
       ...skillFragments
-    ]
+    ],
+    metadata: {
+      paths: options.paths
+      // Store original path mappings for getSkillMounts()
+    }
   };
 }
 var SKILLS_INSTRUCTIONS = `When a user's request matches one of the skills listed below, read the skill's SKILL.md file to get detailed instructions before proceeding. Skills provide specialized knowledge and workflows for specific tasks.
@@ -2472,6 +2798,7 @@ var STORE_DDL = `
 -- createdAt/updatedAt: DEFAULT for insert, inline SET for updates
 CREATE TABLE IF NOT EXISTS chats (
   id TEXT PRIMARY KEY,
+  userId TEXT NOT NULL,
   title TEXT,
   metadata TEXT,
   createdAt INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000),
@@ -2479,6 +2806,7 @@ CREATE TABLE IF NOT EXISTS chats (
 );
 
 CREATE INDEX IF NOT EXISTS idx_chats_updatedAt ON chats(updatedAt);
+CREATE INDEX IF NOT EXISTS idx_chats_userId ON chats(userId);
 
 -- Messages table (nodes in the DAG)
 CREATE TABLE IF NOT EXISTS messages (
@@ -2544,37 +2872,67 @@ var SqliteContextStore = class extends ContextStore {
     this.#db.exec("PRAGMA foreign_keys = ON");
     this.#db.exec(STORE_DDL);
   }
+  /**
+   * Execute a function within a transaction.
+   * Automatically commits on success or rolls back on error.
+   */
+  #useTransaction(fn) {
+    this.#db.exec("BEGIN TRANSACTION");
+    try {
+      const result = fn();
+      this.#db.exec("COMMIT");
+      return result;
+    } catch (error) {
+      this.#db.exec("ROLLBACK");
+      throw error;
+    }
+  }
   // ==========================================================================
   // Chat Operations
   // ==========================================================================
   async createChat(chat) {
-    this.#db.prepare(
-      `INSERT INTO chats (id, title, metadata)
-         VALUES (?, ?, ?)`
-    ).run(
-      chat.id,
-      chat.title ?? null,
-      chat.metadata ? JSON.stringify(chat.metadata) : null
-    );
+    this.#useTransaction(() => {
+      this.#db.prepare(
+        `INSERT INTO chats (id, userId, title, metadata)
+           VALUES (?, ?, ?, ?)`
+      ).run(
+        chat.id,
+        chat.userId,
+        chat.title ?? null,
+        chat.metadata ? JSON.stringify(chat.metadata) : null
+      );
+      this.#db.prepare(
+        `INSERT INTO branches (id, chatId, name, headMessageId, isActive, createdAt)
+           VALUES (?, ?, 'main', NULL, 1, ?)`
+      ).run(crypto.randomUUID(), chat.id, Date.now());
+    });
   }
   async upsertChat(chat) {
-    const row = this.#db.prepare(
-      `INSERT INTO chats (id, title, metadata)
-         VALUES (?, ?, ?)
-         ON CONFLICT(id) DO UPDATE SET id = excluded.id
-         RETURNING *`
-    ).get(
-      chat.id,
-      chat.title ?? null,
-      chat.metadata ? JSON.stringify(chat.metadata) : null
-    );
-    return {
-      id: row.id,
-      title: row.title ?? void 0,
-      metadata: row.metadata ? JSON.parse(row.metadata) : void 0,
-      createdAt: row.createdAt,
-      updatedAt: row.updatedAt
-    };
+    return this.#useTransaction(() => {
+      const row = this.#db.prepare(
+        `INSERT INTO chats (id, userId, title, metadata)
+           VALUES (?, ?, ?, ?)
+           ON CONFLICT(id) DO UPDATE SET id = excluded.id
+           RETURNING *`
+      ).get(
+        chat.id,
+        chat.userId,
+        chat.title ?? null,
+        chat.metadata ? JSON.stringify(chat.metadata) : null
+      );
+      this.#db.prepare(
+        `INSERT OR IGNORE INTO branches (id, chatId, name, headMessageId, isActive, createdAt)
+           VALUES (?, ?, 'main', NULL, 1, ?)`
+      ).run(crypto.randomUUID(), chat.id, Date.now());
+      return {
+        id: row.id,
+        userId: row.userId,
+        title: row.title ?? void 0,
+        metadata: row.metadata ? JSON.parse(row.metadata) : void 0,
+        createdAt: row.createdAt,
+        updatedAt: row.updatedAt
+      };
+    });
   }
   async getChat(chatId) {
     const row = this.#db.prepare("SELECT * FROM chats WHERE id = ?").get(chatId);
@@ -2583,6 +2941,7 @@ var SqliteContextStore = class extends ContextStore {
     }
     return {
       id: row.id,
+      userId: row.userId,
       title: row.title ?? void 0,
       metadata: row.metadata ? JSON.parse(row.metadata) : void 0,
       createdAt: row.createdAt,
@@ -2606,16 +2965,33 @@ var SqliteContextStore = class extends ContextStore {
     ).get(...params);
     return {
       id: row.id,
+      userId: row.userId,
       title: row.title ?? void 0,
       metadata: row.metadata ? JSON.parse(row.metadata) : void 0,
       createdAt: row.createdAt,
       updatedAt: row.updatedAt
     };
   }
-  async listChats() {
+  async listChats(options) {
+    const params = [];
+    let whereClause = "";
+    let limitClause = "";
+    if (options?.userId) {
+      whereClause = "WHERE c.userId = ?";
+      params.push(options.userId);
+    }
+    if (options?.limit !== void 0) {
+      limitClause = " LIMIT ?";
+      params.push(options.limit);
+      if (options.offset !== void 0) {
+        limitClause += " OFFSET ?";
+        params.push(options.offset);
+      }
+    }
     const rows = this.#db.prepare(
       `SELECT
           c.id,
+          c.userId,
           c.title,
           c.createdAt,
           c.updatedAt,
@@ -2624,11 +3000,13 @@ var SqliteContextStore = class extends ContextStore {
         FROM chats c
         LEFT JOIN messages m ON m.chatId = c.id
         LEFT JOIN branches b ON b.chatId = c.id
+        ${whereClause}
         GROUP BY c.id
-        ORDER BY c.updatedAt DESC`
-    ).all();
+        ORDER BY c.updatedAt DESC${limitClause}`
+    ).all(...params);
     return rows.map((row) => ({
       id: row.id,
+      userId: row.userId,
       title: row.title ?? void 0,
       messageCount: row.messageCount,
       branchCount: row.branchCount,
@@ -2636,22 +3014,42 @@ var SqliteContextStore = class extends ContextStore {
       updatedAt: row.updatedAt
     }));
   }
+  async deleteChat(chatId, options) {
+    return this.#useTransaction(() => {
+      const messageIds = this.#db.prepare("SELECT id FROM messages WHERE chatId = ?").all(chatId);
+      let sql = "DELETE FROM chats WHERE id = ?";
+      const params = [chatId];
+      if (options?.userId !== void 0) {
+        sql += " AND userId = ?";
+        params.push(options.userId);
+      }
+      const result = this.#db.prepare(sql).run(...params);
+      if (result.changes > 0 && messageIds.length > 0) {
+        const placeholders = messageIds.map(() => "?").join(", ");
+        this.#db.prepare(
+          `DELETE FROM messages_fts WHERE messageId IN (${placeholders})`
+        ).run(...messageIds.map((m) => m.id));
+      }
+      return result.changes > 0;
+    });
+  }
   // ==========================================================================
   // Message Operations (Graph Nodes)
   // ==========================================================================
   async addMessage(message2) {
+    const existingParent = message2.parentId === message2.id ? this.#db.prepare("SELECT parentId FROM messages WHERE id = ?").get(message2.id) : void 0;
+    const parentId = message2.parentId === message2.id ? existingParent?.parentId ?? null : message2.parentId;
     this.#db.prepare(
       `INSERT INTO messages (id, chatId, parentId, name, type, data, createdAt)
          VALUES (?, ?, ?, ?, ?, ?, ?)
          ON CONFLICT(id) DO UPDATE SET
-           parentId = excluded.parentId,
            name = excluded.name,
            type = excluded.type,
            data = excluded.data`
     ).run(
       message2.id,
       message2.chatId,
-      message2.parentId,
+      parentId,
       message2.name,
       message2.type ?? null,
       JSON.stringify(message2.data),
@@ -2706,6 +3104,17 @@ var SqliteContextStore = class extends ContextStore {
     ).get(messageId);
     return row.hasChildren === 1;
   }
+  async getMessages(chatId) {
+    const chat = await this.getChat(chatId);
+    if (!chat) {
+      throw new Error(`Chat "${chatId}" not found`);
+    }
+    const activeBranch = await this.getActiveBranch(chatId);
+    if (!activeBranch?.headMessageId) {
+      return [];
+    }
+    return this.getMessageChain(activeBranch.headMessageId);
+  }
   // ==========================================================================
   // Branch Operations
   // ==========================================================================
@@ -3003,7 +3412,9 @@ function visualizeGraph(data) {
 }
 
 // packages/context/src/lib/agent.ts
+import { groq } from "@ai-sdk/groq";
 import {
+  NoSuchToolError,
   Output,
   convertToModelMessages,
   createUIMessageStream,
@@ -3013,7 +3424,7 @@ import {
   stepCountIs,
   streamText
 } from "ai";
-import chalk from "chalk";
+import chalk2 from "chalk";
 import "zod";
 import "@deepagents/agent";
 var Agent = class _Agent {
@@ -3040,16 +3451,17 @@ var Agent = class _Agent {
       providerOptions: this.#options.providerOptions,
       model: this.#options.model,
       system: systemPrompt,
-      messages: convertToModelMessages(messages),
+      messages: await convertToModelMessages(messages),
       stopWhen: stepCountIs(25),
       tools: this.#options.tools,
       experimental_context: contextVariables,
+      experimental_repairToolCall: repairToolCall,
       toolChoice: this.#options.toolChoice,
       onStepFinish: (step) => {
         const toolCall = step.toolCalls.at(-1);
         if (toolCall) {
           console.log(
-            `Debug: ${chalk.yellow("ToolCalled")}: ${toolCall.toolName}(${JSON.stringify(toolCall.input)})`
+            `Debug: ${chalk2.yellow("ToolCalled")}: ${toolCall.toolName}(${JSON.stringify(toolCall.input)})`
           );
         }
       }
@@ -3098,8 +3510,9 @@ var Agent = class _Agent {
       providerOptions: this.#options.providerOptions,
       model: this.#options.model,
       system: systemPrompt,
-      messages: convertToModelMessages(messages),
-      stopWhen: stepCountIs(25),
+      messages: await convertToModelMessages(messages),
+      experimental_repairToolCall: repairToolCall,
+      stopWhen: stepCountIs(50),
       experimental_transform: config?.transform ?? smoothStream(),
       tools: this.#options.tools,
       experimental_context: contextVariables,
@@ -3108,7 +3521,7 @@ var Agent = class _Agent {
         const toolCall = step.toolCalls.at(-1);
         if (toolCall) {
           console.log(
-            `Debug: (${runId}) ${chalk.bold.yellow("ToolCalled")}: ${toolCall.toolName}(${JSON.stringify(toolCall.input)})`
+            `Debug: (${runId}) ${chalk2.bold.yellow("ToolCalled")}: ${toolCall.toolName}(${JSON.stringify(toolCall.input)})`
           );
         }
       }
@@ -3155,7 +3568,7 @@ var Agent = class _Agent {
                 guardrailFailed = true;
                 failureFeedback = checkResult.feedback;
                 console.log(
-                  chalk.yellow(
+                  chalk2.yellow(
                     `[${this.#options.name}] Guardrail triggered (attempt ${attempt}/${maxRetries}): ${failureFeedback.slice(0, 50)}...`
                   )
                 );
@@ -3172,20 +3585,16 @@ var Agent = class _Agent {
             }
             if (attempt >= maxRetries) {
               console.error(
-                chalk.red(
+                chalk2.red(
                   `[${this.#options.name}] Guardrail retry limit (${maxRetries}) exceeded.`
                 )
               );
               writer.write({ type: "finish" });
               return;
             }
-            writer.write({
-              type: "text-delta",
-              id: generateId2(),
-              delta: ` ${failureFeedback}`
-            });
+            writeText(writer, failureFeedback);
             const selfCorrectionText = accumulatedText + " " + failureFeedback;
-            context.set(assistantText(selfCorrectionText));
+            context.set(lastAssistantMessage(selfCorrectionText));
             await context.save();
             currentResult = await this.#createRawStream(
               contextVariables,
@@ -3215,14 +3624,10 @@ function structuredOutput(options) {
   return {
     async generate(contextVariables, config) {
       if (!options.context) {
-        throw new Error(
-          `structuredOutput "${options.name}" is missing a context.`
-        );
+        throw new Error(`structuredOutput is missing a context.`);
       }
       if (!options.model) {
-        throw new Error(
-          `structuredOutput "${options.name}" is missing a model.`
-        );
+        throw new Error(`structuredOutput is missing a model.`);
       }
       const { messages, systemPrompt } = await options.context.resolve({
         renderer: new XmlRenderer()
@@ -3232,23 +3637,21 @@ function structuredOutput(options) {
         providerOptions: options.providerOptions,
         model: options.model,
         system: systemPrompt,
-        messages: convertToModelMessages(messages),
+        messages: await convertToModelMessages(messages),
         stopWhen: stepCountIs(25),
+        experimental_repairToolCall: repairToolCall,
         experimental_context: contextVariables,
-        experimental_output: Output.object({ schema: options.schema })
+        output: Output.object({ schema: options.schema }),
+        tools: options.tools
       });
-      return result.experimental_output;
+      return result.output;
     },
     async stream(contextVariables, config) {
       if (!options.context) {
-        throw new Error(
-          `structuredOutput "${options.name}" is missing a context.`
-        );
+        throw new Error(`structuredOutput is missing a context.`);
       }
       if (!options.model) {
-        throw new Error(
-          `structuredOutput "${options.name}" is missing a model.`
-        );
+        throw new Error(`structuredOutput is missing a model.`);
       }
       const { messages, systemPrompt } = await options.context.resolve({
         renderer: new XmlRenderer()
@@ -3258,15 +3661,70 @@ function structuredOutput(options) {
         providerOptions: options.providerOptions,
         model: options.model,
         system: systemPrompt,
-        messages: convertToModelMessages(messages),
-        stopWhen: stepCountIs(25),
+        experimental_repairToolCall: repairToolCall,
+        messages: await convertToModelMessages(messages),
+        stopWhen: stepCountIs(50),
         experimental_transform: config?.transform ?? smoothStream(),
         experimental_context: contextVariables,
-        experimental_output: Output.object({ schema: options.schema })
+        output: Output.object({ schema: options.schema }),
+        tools: options.tools
       });
     }
   };
 }
+var repairToolCall = async ({
+  toolCall,
+  tools,
+  inputSchema,
+  error
+}) => {
+  console.log(
+    `Debug: ${chalk2.yellow("RepairingToolCall")}: ${toolCall.toolName}`,
+    error.name
+  );
+  if (NoSuchToolError.isInstance(error)) {
+    return null;
+  }
+  const tool = tools[toolCall.toolName];
+  const { output } = await generateText({
+    model: groq("openai/gpt-oss-20b"),
+    output: Output.object({ schema: tool.inputSchema }),
+    prompt: [
+      `The model tried to call the tool "${toolCall.toolName}" with the following inputs:`,
+      JSON.stringify(toolCall.input),
+      `The tool accepts the following schema:`,
+      JSON.stringify(inputSchema(toolCall)),
+      "Please fix the inputs."
+    ].join("\n")
+  });
+  return { ...toolCall, input: JSON.stringify(output) };
+};
+function writeText(writer, text) {
+  const feedbackPartId = generateId2();
+  writer.write({
+    id: feedbackPartId,
+    type: "text-start"
+  });
+  writer.write({
+    id: feedbackPartId,
+    type: "text-delta",
+    delta: ` ${text}`
+  });
+  writer.write({
+    id: feedbackPartId,
+    type: "text-end"
+  });
+}
+
+// packages/context/src/lib/render.ts
+function render(tag, ...fragments) {
+  if (fragments.length === 0) {
+    return "";
+  }
+  const renderer = new XmlRenderer();
+  const wrapped = fragment(tag, ...fragments);
+  return renderer.render([wrapped]);
+}
 export {
   BinaryInstallError,
   ComposeStartError,
@@ -3281,6 +3739,7 @@ export {
   DockerfileBuildError,
   DockerfileStrategy,
   InMemoryContextStore,
+  LAZY_ID,
   MarkdownRenderer,
   ModelsRegistry,
   MountPathError,
@@ -3302,6 +3761,7 @@ export {
   createDockerSandbox,
   defaultTokenizer,
   discoverSkillsInDirectory,
+  errorRecoveryGuardrail,
   estimate,
   example,
   explain,
@@ -3316,14 +3776,19 @@ export {
   isDockerfileOptions,
   isFragment,
   isFragmentObject,
+  isLazyFragment,
   isMessageFragment,
+  lastAssistantMessage,
   loadSkillMetadata,
   message,
   parseFrontmatter,
   pass,
   persona,
+  policy,
   preference,
+  principle,
   quirk,
+  render,
   role,
   runGuardrailChain,
   skills,