zen-code 4.6.1 → 4.6.2

package/dist/{index-DEcMgCTj.mjs → index-B6kFMamn.mjs}

@@ -1,4 +1,4 @@
-import { A as s, C as m, F as o, e as c, S as i, a as p, d as h, b as k, h as n, f as g, g as T, T as f, c as l } from "./graphBuilder-B3IJ7dB2.mjs";
+import { A as s, C as m, F as o, e as c, S as i, a as p, d as h, b as k, h as n, f as g, g as T, T as f, c as l } from "./graphBuilder-mpLrx9tk.mjs";
 import { FileSystemSkillStore as y } from "./FileSystemSkillStore-yvEvcRxB.mjs";
 import { FileSystemPluginStore as F } from "./FileSystemPluginStore-ChortK7z.mjs";
 import "lowdb";

package/dist/index-BW3-KScB.mjs

@@ -0,0 +1,463 @@
+import { B as C, u as v, c as x, T as $, m as I } from "./app-Cynj004J.mjs";
+import "./graphBuilder-mpLrx9tk.mjs";
+import { createClient as O, createCluster as N } from "redis";
+const W = [
+  {
+    index: "checkpoints",
+    prefix: "checkpoint:",
+    schema: {
+      "$.thread_id": {
+        type: "TAG",
+        AS: "thread_id"
+      },
+      "$.checkpoint_ns": {
+        type: "TAG",
+        AS: "checkpoint_ns"
+      },
+      "$.checkpoint_id": {
+        type: "TAG",
+        AS: "checkpoint_id"
+      },
+      "$.parent_checkpoint_id": {
+        type: "TAG",
+        AS: "parent_checkpoint_id"
+      },
+      "$.checkpoint_ts": {
+        type: "NUMERIC",
+        AS: "checkpoint_ts"
+      },
+      "$.has_writes": {
+        type: "TAG",
+        AS: "has_writes"
+      },
+      "$.source": {
+        type: "TAG",
+        AS: "source"
+      },
+      "$.step": {
+        type: "NUMERIC",
+        AS: "step"
+      }
+    }
+  },
+  {
+    index: "checkpoint_blobs",
+    prefix: "checkpoint_blob:",
+    schema: {
+      "$.thread_id": {
+        type: "TAG",
+        AS: "thread_id"
+      },
+      "$.checkpoint_ns": {
+        type: "TAG",
+        AS: "checkpoint_ns"
+      },
+      "$.checkpoint_id": {
+        type: "TAG",
+        AS: "checkpoint_id"
+      },
+      "$.channel": {
+        type: "TAG",
+        AS: "channel"
+      },
+      "$.version": {
+        type: "TAG",
+        AS: "version"
+      },
+      "$.type": {
+        type: "TAG",
+        AS: "type"
+      }
+    }
+  },
+  {
+    index: "checkpoint_writes",
+    prefix: "checkpoint_write:",
+    schema: {
+      "$.thread_id": {
+        type: "TAG",
+        AS: "thread_id"
+      },
+      "$.checkpoint_ns": {
+        type: "TAG",
+        AS: "checkpoint_ns"
+      },
+      "$.checkpoint_id": {
+        type: "TAG",
+        AS: "checkpoint_id"
+      },
+      "$.task_id": {
+        type: "TAG",
+        AS: "task_id"
+      },
+      "$.idx": {
+        type: "NUMERIC",
+        AS: "idx"
+      },
+      "$.channel": {
+        type: "TAG",
+        AS: "channel"
+      },
+      "$.type": {
+        type: "TAG",
+        AS: "type"
+      }
+    }
+  }
+];
+var E = class T extends C {
+  client;
+  ttlConfig;
+  constructor(e, t) {
+    super(), this.client = e, this.ttlConfig = t;
+  }
+  static async fromUrl(e, t) {
+    const s = O({ url: e });
+    await s.connect();
+    const i = new T(s, t);
+    return await i.ensureIndexes(), i;
+  }
+  static async fromCluster(e, t) {
+    const s = N({ rootNodes: e });
+    await s.connect();
+    const i = new T(s, t);
+    return await i.ensureIndexes(), i;
+  }
+  async get(e) {
+    return (await this.getTuple(e))?.checkpoint;
+  }
+  async getTuple(e) {
+    const t = e.configurable?.thread_id, s = e.configurable?.checkpoint_ns ?? "", i = e.configurable?.checkpoint_id;
+    if (!t) return;
+    let c, o;
+    if (i)
+      c = `checkpoint:${t}:${s}:${i}`, o = await this.client.json.get(c);
+    else {
+      const r = `checkpoint:${t}:${s}:*`, p = await this.client.keys(r);
+      if (p.length === 0) return;
+      p.sort(), c = p[p.length - 1], o = await this.client.json.get(c);
+    }
+    if (!o) return;
+    this.ttlConfig?.refreshOnRead && this.ttlConfig?.defaultTTL && await this.applyTTL(c);
+    const { checkpoint: f, pendingWrites: n } = await this.loadCheckpointWithWrites(o);
+    return await this.createCheckpointTuple(o, f, n);
+  }
+  async put(e, t, s, i) {
+    await this.ensureIndexes();
+    const c = e.configurable?.thread_id, o = e.configurable?.checkpoint_ns ?? "", f = e.configurable?.checkpoint_id;
+    if (!c) throw new Error("thread_id is required");
+    const n = t.id || v(0), r = `checkpoint:${c}:${o}:${n}`, p = x(t);
+    if (p.channel_values && i !== void 0) if (Object.keys(i).length === 0) p.channel_values = {};
+    else {
+      const u = {};
+      for (const a of Object.keys(i)) a in p.channel_values && (u[a] = p.channel_values[a]);
+      p.channel_values = u;
+    }
+    const l = {
+      thread_id: c,
+      checkpoint_ns: o === "" ? "__empty__" : o,
+      checkpoint_id: n,
+      parent_checkpoint_id: f || null,
+      checkpoint: p,
+      metadata: s,
+      checkpoint_ts: Date.now(),
+      has_writes: "false"
+    };
+    return this.addSearchableMetadataFields(l, s), await this.client.json.set(r, "$", l), this.ttlConfig?.defaultTTL && await this.applyTTL(r), { configurable: {
+      thread_id: c,
+      checkpoint_ns: o,
+      checkpoint_id: n
+    } };
+  }
+  async *list(e, t) {
+    if (await this.ensureIndexes(), t?.filter !== void 0) {
+      const i = Object.values(t.filter).some((n) => n === null), c = [];
+      if (e?.configurable?.thread_id) {
+        const n = e.configurable.thread_id.replace(/[-.@]/g, "\\$&");
+        c.push(`(@thread_id:{${n}})`);
+      }
+      if (e?.configurable?.checkpoint_ns !== void 0) {
+        const n = e.configurable.checkpoint_ns;
+        if (n === "") c.push("(@checkpoint_ns:{__empty__})");
+        else {
+          const r = n.replace(/[-.@]/g, "\\$&");
+          c.push(`(@checkpoint_ns:{${r}})`);
+        }
+      }
+      if (!t?.before && t?.filter)
+        for (const [n, r] of Object.entries(t.filter)) r === void 0 || r === null || (typeof r == "string" ? c.push(`(@${n}:{${r}})`) : typeof r == "number" ? c.push(`(@${n}:[${r} ${r}])`) : typeof r == "object" && Object.keys(r).length);
+      c.length === 0 && c.push("*");
+      const o = c.join(" "), f = t?.limit ?? 10;
+      try {
+        const n = t?.before && !e?.configurable?.thread_id ? 1e3 : t?.before ? f * 10 : f;
+        let p = (await this.client.ft.search("checkpoints", o, {
+          LIMIT: {
+            from: 0,
+            size: n
+          },
+          SORTBY: {
+            BY: "checkpoint_ts",
+            DIRECTION: "DESC"
+          }
+        })).documents, l = 0;
+        for (const u of p) {
+          if (l >= f) break;
+          if (t?.before?.configurable?.checkpoint_id) {
+            const k = u.value.checkpoint_id, d = t.before.configurable.checkpoint_id;
+            if (k >= d) continue;
+          }
+          const a = u.value;
+          let h = !0;
+          if ((i || t?.before) && t?.filter) {
+            for (const [k, d] of Object.entries(t.filter)) if (d === null) {
+              if (a.metadata?.[k] !== null) {
+                h = !1;
+                break;
+              }
+            } else if (d !== void 0) {
+              const b = a.metadata?.[k];
+              if (typeof d == "object" && d !== null) {
+                if (g(b) !== g(d)) {
+                  h = !1;
+                  break;
+                }
+              } else if (b !== d) {
+                h = !1;
+                break;
+              }
+            }
+            if (!h) continue;
+          }
+          const { checkpoint: y, pendingWrites: _ } = await this.loadCheckpointWithWrites(a);
+          yield await this.createCheckpointTuple(a, y, _), l++;
+        }
+        return;
+      } catch (n) {
+        if (!n.message?.includes("no such index")) throw n;
+      }
+      if (e?.configurable?.thread_id) {
+        const n = e.configurable.thread_id, r = e.configurable.checkpoint_ns ?? "", p = `checkpoint:${n}:${r}:*`, l = await this.client.keys(p);
+        l.sort().reverse();
+        let u = l;
+        if (t?.before?.configurable?.checkpoint_id) {
+          const y = t.before.configurable.thread_id || n, _ = t.before.configurable.checkpoint_ns ?? r, k = `checkpoint:${y}:${_}:${t.before.configurable.checkpoint_id}`, d = l.indexOf(k);
+          d > 0 ? u = l.slice(d + 1) : d === 0 && (u = []);
+        }
+        const a = t?.limit ?? 10, h = u.slice(0, a);
+        for (const y of h) {
+          const _ = await this.client.json.get(y);
+          if (_) {
+            let k = !0;
+            for (const [S, m] of Object.entries(t.filter)) {
+              const A = _.metadata?.[S];
+              if (m === null) {
+                if (A !== null) {
+                  k = !1;
+                  break;
+                }
+              } else if (A !== m) {
+                k = !1;
+                break;
+              }
+            }
+            if (!k) continue;
+            const { checkpoint: d, pendingWrites: b } = await this.loadCheckpointWithWrites(_);
+            yield await this.createCheckpointTuple(_, d, b);
+          }
+        }
+      } else {
+        const n = e?.configurable?.checkpoint_ns !== void 0 ? `checkpoint:*:${e.configurable.checkpoint_ns === "" ? "__empty__" : e.configurable.checkpoint_ns}:*` : "checkpoint:*", r = await this.client.keys(n), p = [];
+        for (const a of r) {
+          const h = await this.client.json.get(a);
+          h && p.push({
+            key: a,
+            doc: h
+          });
+        }
+        p.sort((a, h) => h.doc.checkpoint_ts - a.doc.checkpoint_ts);
+        let l = 0;
+        const u = t?.limit ?? 10;
+        for (const { doc: a } of p) {
+          if (l >= u) break;
+          if (t?.before?.configurable?.checkpoint_id) {
+            const k = a.checkpoint_id, d = t.before.configurable.checkpoint_id;
+            if (k >= d) continue;
+          }
+          let h = !0;
+          if (t?.filter) {
+            for (const [k, d] of Object.entries(t.filter)) if (d === null) {
+              if (a.metadata?.[k] !== null) {
+                h = !1;
+                break;
+              }
+            } else if (d !== void 0) {
+              const b = a.metadata?.[k];
+              if (typeof d == "object" && d !== null) {
+                if (g(b) !== g(d)) {
+                  h = !1;
+                  break;
+                }
+              } else if (b !== d) {
+                h = !1;
+                break;
+              }
+            }
+            if (!h) continue;
+          }
+          const { checkpoint: y, pendingWrites: _ } = await this.loadCheckpointWithWrites(a);
+          yield await this.createCheckpointTuple(a, y, _), l++;
+        }
+      }
+      return;
+    }
+    const s = {
+      ...t,
+      filter: {}
+    };
+    yield* this.list(e, s);
+  }
+  async putWrites(e, t, s) {
+    await this.ensureIndexes();
+    const i = e.configurable?.thread_id, c = e.configurable?.checkpoint_ns ?? "", o = e.configurable?.checkpoint_id;
+    if (!i || !o) throw new Error("thread_id and checkpoint_id are required");
+    const f = [], n = performance.now() * 1e3;
+    for (let l = 0; l < t.length; l++) {
+      const [u, a] = t[l], h = `checkpoint_write:${i}:${c}:${o}:${s}:${l}`;
+      f.push(h);
+      const y = {
+        thread_id: i,
+        checkpoint_ns: c,
+        checkpoint_id: o,
+        task_id: s,
+        idx: l,
+        channel: u,
+        type: typeof a == "object" ? "json" : "string",
+        value: a,
+        timestamp: n,
+        global_idx: n + l
+      };
+      await this.client.json.set(h, "$", y);
+    }
+    if (f.length > 0) {
+      const l = `write_keys_zset:${i}:${c}:${o}`, u = {};
+      f.forEach((a, h) => {
+        u[a] = n + h;
+      }), await this.client.zAdd(l, Object.entries(u).map(([a, h]) => ({
+        score: h,
+        value: a
+      }))), this.ttlConfig?.defaultTTL && await this.applyTTL(...f, l);
+    }
+    const r = `checkpoint:${i}:${c}:${o}`;
+    if (await this.client.exists(r)) {
+      const l = await this.client.json.get(r);
+      l && (l.has_writes = "true", await this.client.json.set(r, "$", l));
+    }
+  }
+  async deleteThread(e) {
+    const t = `checkpoint:${e}:*`, s = await this.client.keys(t);
+    s.length > 0 && await this.client.del(s);
+    const i = `writes:${e}:*`, c = await this.client.keys(i);
+    c.length > 0 && await this.client.del(c);
+  }
+  async end() {
+    await this.client.quit();
+  }
+  async loadPendingWrites(e, t, s) {
+    const i = `checkpoint_write:${e}:${t}:${s}:*`, c = await this.client.keys(i);
+    if (c.length === 0) return;
+    const o = [];
+    for (const n of c) {
+      const r = await this.client.json.get(n);
+      r && o.push(r);
+    }
+    o.sort((n, r) => (n.global_idx || 0) - (r.global_idx || 0));
+    const f = [];
+    for (const n of o) {
+      const r = await this.serde.loadsTyped("json", JSON.stringify(n.value));
+      f.push([
+        n.task_id,
+        n.channel,
+        r
+      ]);
+    }
+    return f;
+  }
+  async loadCheckpointWithWrites(e) {
+    const t = await this.serde.loadsTyped("json", JSON.stringify(e.checkpoint));
+    if (t.v < 4 && e.parent_checkpoint_id != null) {
+      const i = e.checkpoint_ns === "__empty__" ? "" : e.checkpoint_ns;
+      await this.migratePendingSends(t, e.thread_id, i, e.parent_checkpoint_id);
+    }
+    let s;
+    if (e.has_writes === "true") {
+      const i = e.checkpoint_ns === "__empty__" ? "" : e.checkpoint_ns;
+      s = await this.loadPendingWrites(e.thread_id, i, e.checkpoint_id);
+    }
+    return {
+      checkpoint: t,
+      pendingWrites: s
+    };
+  }
+  async migratePendingSends(e, t, s, i) {
+    const c = await this.loadPendingWrites(t, s, i);
+    if (!c || c.length === 0) return;
+    const o = c.filter(([, n]) => n === $);
+    if (o.length === 0) return;
+    const f = [];
+    for (const [, , n] of o) f.push(n);
+    e.channel_values ??= {}, e.channel_values[$] = f, e.channel_versions[$] = Object.keys(e.channel_versions).length > 0 ? I(...Object.values(e.channel_versions)) : 1;
+  }
+  async createCheckpointTuple(e, t, s) {
+    const i = e.checkpoint_ns === "__empty__" ? "" : e.checkpoint_ns, c = await this.serde.loadsTyped("json", JSON.stringify(e.metadata));
+    return {
+      config: { configurable: {
+        thread_id: e.thread_id,
+        checkpoint_ns: i,
+        checkpoint_id: e.checkpoint_id
+      } },
+      checkpoint: t,
+      metadata: c,
+      parentConfig: e.parent_checkpoint_id ? { configurable: {
+        thread_id: e.thread_id,
+        checkpoint_ns: i,
+        checkpoint_id: e.parent_checkpoint_id
+      } } : void 0,
+      pendingWrites: s
+    };
+  }
+  addSearchableMetadataFields(e, t) {
+    t && ("source" in t && (e.source = t.source), "step" in t && (e.step = t.step), "writes" in t && (e.writes = typeof t.writes == "object" ? JSON.stringify(t.writes) : t.writes), "score" in t && (e.score = t.score));
+  }
+  async applyTTL(...e) {
+    if (!this.ttlConfig?.defaultTTL) return;
+    const t = Math.floor(this.ttlConfig.defaultTTL * 60), s = await Promise.allSettled(e.map((i) => this.client.expire(i, t)));
+    for (let i = 0; i < s.length; i++) s[i].status === "rejected" && console.warn(`Failed to set TTL for key ${e[i]}:`, s[i].reason);
+  }
+  async ensureIndexes() {
+    for (const e of W) try {
+      await this.client.ft.create(e.index, e.schema, {
+        ON: "JSON",
+        PREFIX: e.prefix
+      });
+    } catch (t) {
+      t.message?.includes("Index already exists") || console.error(`Failed to create index ${e.index}:`, t.message);
+    }
+  }
+};
+function g(w) {
+  if (w === null || typeof w != "object") return JSON.stringify(w);
+  if (Array.isArray(w)) return JSON.stringify(w.map((s) => g(s)));
+  const e = {}, t = Object.keys(w).sort();
+  for (const s of t) e[s] = w[s];
+  return JSON.stringify(e, (s, i) => {
+    if (i !== null && typeof i == "object" && !Array.isArray(i)) {
+      const c = {}, o = Object.keys(i).sort();
+      for (const f of o) c[f] = i[f];
+      return c;
+    }
+    return i;
+  });
+}
+export {
+  E as RedisSaver
+};

package/dist/index-FHDPQ2Qk.mjs

@@ -0,0 +1,211 @@
+import { l as n } from "./graphBuilder-mpLrx9tk.mjs";
+import { D as b, u as j, y as v, t as R, B as T, z as L, E as x, G as A, r as $, w as _, s as C, M as I, P as E, x as z, q as U, v as F, p as W, H as K } from "./graphBuilder-mpLrx9tk.mjs";
+import r from "node:fs/promises";
+import { join as m } from "node:path";
+import { l as d } from "./load-Cjl9cJ0o.mjs";
+const k = `
+
+## Project Documentation
+
+{docs_content}`;
+class g {
+  name = "AgentsMdMiddleware";
+  stateSchema = void 0;
+  contextSchema = void 0;
+  tools = [];
+  projectRoot;
+  systemPromptTemplate;
+  /**
+   * Initialize the documentation middleware.
+   *
+   * @param projectRoot - Path to the project root directory (defaults to process.cwd())
+   */
+  constructor(s = {}) {
+    this.projectRoot = s.projectRoot || process.cwd(), this.systemPromptTemplate = k;
+  }
+  /**
+   * Find and read the project documentation file.
+   * Priority: CLAUDE.md > AGENTS.md
+   *
+   * @returns The content of the first found documentation file, or null if none exist
+   */
+  async findDocumentationFile() {
+    const s = ["CLAUDE.md", "AGENTS.md"];
+    for (const i of s) {
+      const l = m(this.projectRoot, i);
+      try {
+        return await r.access(l), { content: await r.readFile(l, "utf-8"), filename: i };
+      } catch {
+        continue;
+      }
+    }
+    return null;
+  }
+  /**
+   * Inject project documentation into the system prompt.
+   *
+   * This runs on every model call to ensure documentation info is always available.
+   *
+   * @param request - The model request being processed
+   * @param handler - The handler function to call with the modified request
+   * @returns The model response from the handler
+   */
+  async wrapModelCall(s, i) {
+    const l = await this.findDocumentationFile();
+    if (!l)
+      return await i(s);
+    const t = this.systemPromptTemplate.replace("{docs_content}", l.content);
+    let e;
+    s.systemPrompt ? e = s.systemPrompt + `
+
+` + t : e = t;
+    const a = new n(e), o = {
+      ...s,
+      systemMessage: a
+    };
+    return await i(o);
+  }
+}
+const u = `
+
+## Skills System
+
+You have access to a skills library that provides specialized capabilities and domain knowledge.
+
+{skills_locations}
+
+**Available Skills:**
+
+{skills_list}
+
+**How to Use Skills (Progressive Disclosure):**
+
+Skills follow a **progressive disclosure** pattern - you know they exist (name + description above), but you only read the full instructions when needed:
+
+1. **Recognize when a skill applies**: Check if the user's task matches any skill's description
+2. **Read the skill's full instructions**: The skill list above shows the exact path to use with read_file
+3. **Follow the skill's instructions**: SKILL.md contains step-by-step workflows, best practices, and examples
+4. **Access supporting files**: Skills may include Python scripts, configs, or reference docs - use absolute paths
+
+**When to Use Skills:**
+- When the user's request matches a skill's domain (e.g., "research X" → web-research skill)
+- When you need specialized knowledge or structured workflows
+- When a skill provides proven patterns for complex tasks
+
+**Skills are Self-Documenting:**
+- Each SKILL.md tells you exactly what the skill does and how to use it
+- The skill list above shows the full path for each skill's SKILL.md file
+
+**Executing Skill Scripts:**
+Skills may contain Python scripts or other executable files. Always use absolute paths from the skill list.
+
+**Example Workflow:**
+
+User: "Can you research the latest developments in quantum computing?"
+
+1. Check available skills above → See "web-research" skill with its full path
+2. Read the skill using the path shown in the list
+3. Follow the skill's research workflow (search → organize → synthesize)
+4. Use any helper scripts with absolute paths
+
+Remember: Skills are tools to make you more capable and consistent. When in doubt, check if a skill exists for the task!
+`;
+class P {
+  name = "SkillsMiddleware";
+  // No context schema needed
+  stateSchema = void 0;
+  // No context schema needed
+  contextSchema = void 0;
+  // No additional tools
+  tools = [];
+  skillsDir;
+  assistantId;
+  projectSkillsDir;
+  userSkillsDisplay;
+  systemPromptTemplate;
+  /**
+   * Initialize the skills middleware.
+   *
+   * @param skillsDir - Path to the user-level skills directory (per-agent)
+   * @param assistantId - The agent identifier for path references in prompts
+   * @param projectSkillsDir - Optional path to project-level skills directory
+   */
+  constructor(s = {}) {
+    this.skillsDir = s.skillsDir, this.assistantId = s.assistantId, this.projectSkillsDir = s.projectSkillsDir || "./.claude/skills", this.skillsDir && !this.assistantId && console.warn("user skills directory is provided, but assistant id is not provided"), this.assistantId && (this.userSkillsDisplay = `~/.claude/${this.assistantId}/skills`), this.systemPromptTemplate = u;
+  }
+  /**
+   * Format skills locations for display in system prompt.
+   */
+  formatSkillsLocations() {
+    const s = [];
+    return this.userSkillsDisplay && s.push(`**User Skills**: \`${this.userSkillsDisplay}\``), this.projectSkillsDir && s.push(`**Project Skills**: \`${this.projectSkillsDir}\` (overrides user skills)`), s.join(`
+`);
+  }
+  /**
+   * Format skills metadata for display in system prompt.
+   */
+  formatSkillsList(s) {
+    if (!s.length) {
+      const e = [`${this.userSkillsDisplay}/`];
+      return this.projectSkillsDir && e.push(`${this.projectSkillsDir}/`), `(No skills available yet. You can create skills in ${e.join(" or ")})`;
+    }
+    const i = s.filter((e) => e.source === "user"), l = s.filter((e) => e.source === "project"), t = [];
+    if (i.length) {
+      t.push("**User Skills:**");
+      for (const e of i)
+        t.push(`- **${e.name}**: ${e.description}`), t.push(`  → Read \`${e.path}\` for full instructions`);
+      t.push("");
+    }
+    if (l.length) {
+      t.push("**Project Skills:**");
+      for (const e of l)
+        t.push(`- **${e.name}**: ${e.description}`), t.push(`  → Read \`${e.path}\` for full instructions`);
+    }
+    return t.join(`
+`);
+  }
+  /**
+   * Inject skills documentation into the system prompt.
+   *
+   * This runs on every model call to ensure skills info is always available.
+   *
+   * @param request - The model request being processed
+   * @param handler - The handler function to call with the modified request
+   * @returns The model response from the handler
+   */
+  async wrapModelCall(s, i) {
+    const l = d(this.skillsDir, this.projectSkillsDir), t = this.formatSkillsLocations(), e = this.formatSkillsList(l), a = this.systemPromptTemplate.replace("{skills_locations}", t).replace("{skills_list}", e);
+    let o;
+    s.systemPrompt ? o = s.systemPrompt + `
+
+` + a : o = a;
+    const h = new n(o), p = {
+      ...s,
+      systemMessage: h
+    };
+    return await i(p);
+  }
+}
+export {
+  b as AgentPackage,
+  j as AgentPackageSchema,
+  v as AgentRepository,
+  R as AgentSchema,
+  T as AgentSerializer,
+  L as AgentValidator,
+  g as AgentsMdMiddleware,
+  x as BaseStorage,
+  A as MemoryStorage,
+  $ as MiddlewareCustomParamsSchema,
+  _ as MiddlewareRegistry,
+  C as MiddlewareSchema,
+  I as ModelSchema,
+  E as PromptSchema,
+  P as SkillsMiddleware,
+  z as StandardAgent,
+  U as ToolCustomParamsSchema,
+  F as ToolRegistry,
+  W as ToolSchema,
+  K as anthropicPromptCachingMiddleware,
+  d as listSkills
+};