arcie 0.1.2 → 0.1.4

package/dist/chunk-2ZSKZYWK.js

@@ -0,0 +1,1901 @@
+import {
+  createMessageAppended,
+  createMessageCompleted,
+  createMessageReceived,
+  createSessionCompleted,
+  createSessionStarted,
+  createSessionWaiting,
+  createStepCompleted,
+  createStepStarted,
+  createSubagentCalled,
+  createSubagentCompleted,
+  createToolCallCompleted,
+  createToolCallStarted,
+  createTurnCompleted,
+  createTurnStarted
+} from "./chunk-QE46QFID.js";
+import {
+  toModelOutput
+} from "./chunk-PHTJLJOV.js";
+
+// src/loader.ts
+import { readFileSync, existsSync, readdirSync, statSync } from "fs";
+import { resolve, basename, extname } from "path";
+async function loadAgent(agentDir) {
+  const absDir = resolve(process.cwd(), agentDir);
+  if (!existsSync(absDir)) {
+    throw new Error(`Agent directory not found: ${absDir}`);
+  }
+  const agentFile = resolve(absDir, "agent.ts");
+  let config = { model: "gpt-4o" };
+  if (existsSync(agentFile)) {
+    try {
+      const mod = await import(agentFile);
+      if (mod.default) {
+        config = { ...config, ...mod.default };
+      }
+    } catch (err) {
+      console.warn(`[arcie] Failed to load agent.ts: ${err.message}. Using defaults.`);
+    }
+  }
+  const instructions = loadInstructionsFile(absDir);
+  const tools = await loadDirectory(absDir, "tools");
+  const skills = await loadDirectory(absDir, "skills");
+  const hooks = await loadDirectory(absDir, "hooks");
+  const channels = await loadDirectory(absDir, "channels");
+  const connections = await loadDirectory(absDir, "connections");
+  const schedules = await loadDirectory(absDir, "schedules");
+  const subagents = await loadSubagents(absDir);
+  const session = await loadSessionConfig(absDir);
+  const policy = await loadPolicyConfig(absDir);
+  return {
+    agentDir: absDir,
+    manifest: {
+      config,
+      instructions,
+      tools,
+      skills,
+      hooks,
+      channels,
+      connections,
+      schedules,
+      subagents,
+      session: session ?? void 0,
+      policy: policy ?? void 0
+    }
+  };
+}
+async function loadSubagents(agentDir) {
+  const dirPath = resolve(agentDir, "subagents");
+  if (!existsSync(dirPath)) return {};
+  const result = {};
+  for (const entry of readdirSync(dirPath, { withFileTypes: true })) {
+    if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
+    const id = entry.name;
+    const subDir = resolve(dirPath, id);
+    const agentFile = resolve(subDir, "agent.ts");
+    if (!existsSync(agentFile)) {
+      throw new Error(`Subagent "${id}" is missing agent.ts`);
+    }
+    let mod;
+    try {
+      mod = await import(agentFile);
+    } catch (err) {
+      throw new Error(`Failed to load subagent "${id}": ${err.message}`);
+    }
+    const config = mod.default;
+    if (!config) {
+      throw new Error(`Subagent "${id}" agent.ts must have a default export`);
+    }
+    if (!config.description) {
+      throw new Error(`Subagent "${id}" must declare a description in agent.ts`);
+    }
+    result[id] = {
+      config,
+      instructions: loadInstructionsFile(subDir),
+      tools: await loadDirectory(subDir, "tools"),
+      skills: await loadDirectory(subDir, "skills")
+    };
+  }
+  return result;
+}
+function loadInstructionsFile(agentDir) {
+  const mdPath = resolve(agentDir, "instructions.md");
+  if (existsSync(mdPath)) {
+    return readFileSync(mdPath, "utf-8");
+  }
+  return "You are a helpful AI agent.";
+}
+async function loadDirectory(agentDir, dirName) {
+  const dirPath = resolve(agentDir, dirName);
+  if (!existsSync(dirPath)) return {};
+  const entries = readdirSync(dirPath).filter(
+    (f) => !f.startsWith(".") && (f.endsWith(".ts") || f.endsWith(".js"))
+  );
+  const result = {};
+  for (const entry of entries) {
+    const name = basename(entry, extname(entry));
+    const filePath = resolve(dirPath, entry);
+    if (statSync(filePath).isFile()) {
+      try {
+        const mod = await import(filePath);
+        if (mod.default) {
+          result[name] = mod.default;
+        }
+      } catch {
+      }
+    }
+  }
+  return result;
+}
+async function loadSessionConfig(agentDir) {
+  const tsPath = resolve(agentDir, "sessions", "config.ts");
+  if (existsSync(tsPath)) {
+    try {
+      const mod = await import(tsPath);
+      return mod.default ?? null;
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+async function loadPolicyConfig(agentDir) {
+  const tsPath = resolve(agentDir, "policies", "index.ts");
+  if (existsSync(tsPath)) {
+    try {
+      const mod = await import(tsPath);
+      return mod.default ?? null;
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+
+// src/memory/store.ts
+var InMemoryStore = class {
+  entries = /* @__PURE__ */ new Map();
+  threads = /* @__PURE__ */ new Map();
+  key(resourceId, threadId) {
+    return `${resourceId}:${threadId}`;
+  }
+  async save(resourceId, threadId, entries) {
+    const k = this.key(resourceId, threadId);
+    const existing = this.entries.get(k) ?? [];
+    existing.push(...entries);
+    this.entries.set(k, existing);
+  }
+  async load(resourceId, threadId, limit) {
+    const entries = this.entries.get(this.key(resourceId, threadId)) ?? [];
+    if (limit === void 0 || limit >= entries.length) return [...entries];
+    return entries.slice(entries.length - limit);
+  }
+  async search(resourceId, threadId, query, limit) {
+    const entries = this.entries.get(this.key(resourceId, threadId)) ?? [];
+    const lower = query.toLowerCase();
+    const matched = entries.filter((e) => e.content.toLowerCase().includes(lower));
+    if (limit !== void 0 && matched.length > limit) return matched.slice(0, limit);
+    return matched;
+  }
+  async clear(resourceId, threadId) {
+    this.entries.delete(this.key(resourceId, threadId));
+  }
+  async close() {
+  }
+  async createThread(thread) {
+    this.threads.set(thread.id, thread);
+  }
+  async getThread(threadId, _resourceId) {
+    return this.threads.get(threadId) ?? null;
+  }
+  async listThreads(resourceId) {
+    return [...this.threads.values()].filter((t) => t.resourceId === resourceId);
+  }
+  async updateThread(thread) {
+    const existing = this.threads.get(thread.id);
+    if (!existing) throw new Error(`Thread not found: ${thread.id}`);
+    this.threads.set(thread.id, { ...existing, ...thread, updatedAt: Date.now() });
+  }
+  async deleteThread(threadId, _resourceId) {
+    this.threads.delete(threadId);
+    this.entries.delete(this.key(_resourceId, threadId));
+  }
+  async deleteMessages(opts) {
+    const k = this.key(opts.resourceId, opts.threadId);
+    const existing = this.entries.get(k) ?? [];
+    let keep = [...existing];
+    if (opts.messageIds && opts.messageIds.length > 0) {
+      const ids = new Set(opts.messageIds);
+      keep = keep.filter((e) => !(e.turnId && ids.has(e.turnId)));
+    }
+    if (opts.beforeTimestamp !== void 0) {
+      keep = keep.filter((e) => e.timestamp >= opts.beforeTimestamp);
+    }
+    if (opts.afterTimestamp !== void 0) {
+      keep = keep.filter((e) => e.timestamp <= opts.afterTimestamp);
+    }
+    const deleted = existing.length - keep.length;
+    this.entries.set(k, keep);
+    return deleted;
+  }
+  async cloneThread(source, dest) {
+    const src = this.entries.get(this.key(source.resourceId, source.threadId));
+    if (src) {
+      this.entries.set(this.key(dest.resourceId, dest.threadId), src.map((e) => ({ ...e })));
+    }
+  }
+};
+
+// src/memory/sqlite-store.ts
+import { createClient } from "@libsql/client";
+import { resolve as resolve2, dirname } from "path";
+import { homedir } from "os";
+import { mkdirSync } from "fs";
+var SqliteStore = class {
+  client;
+  constructor(dbPath) {
+    const path = dbPath ?? resolve2(homedir(), ".arcie", "memory.db");
+    mkdirSync(dirname(path), { recursive: true });
+    this.client = createClient({ url: `file:${path}` });
+    this.init();
+  }
+  init() {
+    this.client.execute(`
+      CREATE TABLE IF NOT EXISTS memories (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        resource_id TEXT NOT NULL,
+        thread_id TEXT NOT NULL,
+        role TEXT NOT NULL,
+        content TEXT NOT NULL,
+        timestamp INTEGER NOT NULL,
+        turn_id TEXT
+      )
+    `);
+    this.client.execute(`
+      CREATE INDEX IF NOT EXISTS idx_memories_lookup
+      ON memories(resource_id, thread_id, timestamp)
+    `);
+    this.client.execute(`
+      CREATE TABLE IF NOT EXISTS threads (
+        id TEXT PRIMARY KEY,
+        resource_id TEXT NOT NULL,
+        title TEXT,
+        metadata TEXT,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL
+      )
+    `);
+    this.client.execute(`
+      CREATE INDEX IF NOT EXISTS idx_threads_resource
+      ON threads(resource_id)
+    `);
+  }
+  async save(resourceId, threadId, entries) {
+    const stmt = `INSERT INTO memories (resource_id, thread_id, role, content, timestamp, turn_id) VALUES (?, ?, ?, ?, ?, ?)`;
+    for (const entry of entries) {
+      await this.client.execute({
+        sql: stmt,
+        args: [resourceId, threadId, entry.role, entry.content, entry.timestamp, entry.turnId ?? null]
+      });
+    }
+  }
+  async load(resourceId, threadId, limit) {
+    const rows = await this.client.execute({
+      sql: `SELECT role, content, timestamp, turn_id FROM memories WHERE resource_id = ? AND thread_id = ? ORDER BY timestamp ASC, id ASC`,
+      args: [resourceId, threadId]
+    });
+    let entries = rows.rows.map((r) => ({
+      role: r.role,
+      content: r.content,
+      timestamp: r.timestamp,
+      turnId: r.turn_id
+    }));
+    if (limit !== void 0 && entries.length > limit) {
+      entries = entries.slice(entries.length - limit);
+    }
+    return entries;
+  }
+  async clear(resourceId, threadId) {
+    await this.client.execute({
+      sql: `DELETE FROM memories WHERE resource_id = ? AND thread_id = ?`,
+      args: [resourceId, threadId]
+    });
+  }
+  async search(resourceId, threadId, query, limit) {
+    const rows = await this.client.execute({
+      sql: `SELECT role, content, timestamp, turn_id FROM memories WHERE resource_id = ? AND thread_id = ? AND content LIKE ? ORDER BY timestamp DESC`,
+      args: [resourceId, threadId, `%${query}%`]
+    });
+    let entries = rows.rows.map((r) => ({
+      role: r.role,
+      content: r.content,
+      timestamp: r.timestamp,
+      turnId: r.turn_id
+    }));
+    if (limit !== void 0 && entries.length > limit) {
+      entries = entries.slice(0, limit);
+    }
+    return entries;
+  }
+  async close() {
+    this.client.close();
+  }
+  async createThread(thread) {
+    await this.client.execute({
+      sql: `INSERT INTO threads (id, resource_id, title, metadata, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)`,
+      args: [
+        thread.id,
+        thread.resourceId,
+        thread.title ?? null,
+        thread.metadata ? JSON.stringify(thread.metadata) : null,
+        thread.createdAt,
+        thread.updatedAt
+      ]
+    });
+  }
+  async getThread(threadId, _resourceId) {
+    const rows = await this.client.execute({
+      sql: `SELECT id, resource_id, title, metadata, created_at, updated_at FROM threads WHERE id = ?`,
+      args: [threadId]
+    });
+    if (rows.rows.length === 0) return null;
+    const r = rows.rows[0];
+    return {
+      id: r.id,
+      resourceId: r.resource_id,
+      title: r.title,
+      metadata: r.metadata ? JSON.parse(r.metadata) : void 0,
+      createdAt: r.created_at,
+      updatedAt: r.updated_at
+    };
+  }
+  async listThreads(resourceId) {
+    const rows = await this.client.execute({
+      sql: `SELECT id, resource_id, title, metadata, created_at, updated_at FROM threads WHERE resource_id = ? ORDER BY updated_at DESC`,
+      args: [resourceId]
+    });
+    return rows.rows.map((r) => ({
+      id: r.id,
+      resourceId: r.resource_id,
+      title: r.title,
+      metadata: r.metadata ? JSON.parse(r.metadata) : void 0,
+      createdAt: r.created_at,
+      updatedAt: r.updated_at
+    }));
+  }
+  async updateThread(thread) {
+    const fields = [];
+    const args = [];
+    if (thread.title !== void 0) {
+      fields.push("title = ?");
+      args.push(thread.title);
+    }
+    if (thread.metadata !== void 0) {
+      fields.push("metadata = ?");
+      args.push(JSON.stringify(thread.metadata));
+    }
+    fields.push("updated_at = ?");
+    args.push(Date.now());
+    args.push(thread.id);
+    await this.client.execute({
+      sql: `UPDATE threads SET ${fields.join(", ")} WHERE id = ?`,
+      args
+    });
+  }
+  async deleteThread(threadId, _resourceId) {
+    await this.client.execute({
+      sql: `DELETE FROM memories WHERE thread_id = ?`,
+      args: [threadId]
+    });
+    await this.client.execute({
+      sql: `DELETE FROM threads WHERE id = ?`,
+      args: [threadId]
+    });
+  }
+  async deleteMessages(opts) {
+    const conditions = ["resource_id = ?", "thread_id = ?"];
+    const args = [opts.resourceId, opts.threadId];
+    if (opts.messageIds && opts.messageIds.length > 0) {
+      const placeholders = opts.messageIds.map(() => "?").join(",");
+      conditions.push(`turn_id IN (${placeholders})`);
+      args.push(...opts.messageIds);
+    }
+    if (opts.beforeTimestamp !== void 0) {
+      conditions.push("timestamp >= ?");
+      args.push(opts.beforeTimestamp);
+    }
+    if (opts.afterTimestamp !== void 0) {
+      conditions.push("timestamp <= ?");
+      args.push(opts.afterTimestamp);
+    }
+    const result = await this.client.execute({
+      sql: `DELETE FROM memories WHERE ${conditions.join(" AND ")}`,
+      args
+    });
+    return Number(result.rowsAffected);
+  }
+  async cloneThread(source, dest) {
+    const rows = await this.client.execute({
+      sql: `SELECT role, content, timestamp, turn_id FROM memories WHERE resource_id = ? AND thread_id = ? ORDER BY id ASC`,
+      args: [source.resourceId, source.threadId]
+    });
+    const stmt = `INSERT INTO memories (resource_id, thread_id, role, content, timestamp, turn_id) VALUES (?, ?, ?, ?, ?, ?)`;
+    for (const r of rows.rows) {
+      await this.client.execute({
+        sql: stmt,
+        args: [
+          dest.resourceId,
+          dest.threadId,
+          r.role,
+          r.content,
+          r.timestamp,
+          r.turn_id
+        ]
+      });
+    }
+  }
+};
+
+// src/memory/file-store.ts
+import { readFileSync as readFileSync2, existsSync as existsSync2, mkdirSync as mkdirSync2, writeFileSync } from "fs";
+import { resolve as resolve3, dirname as dirname2 } from "path";
+import { homedir as homedir2 } from "os";
+var FileStore = class {
+  baseDir;
+  constructor(baseDir) {
+    this.baseDir = baseDir ?? resolve3(homedir2(), ".arcie", "memory");
+  }
+  filePath(resourceId, threadId) {
+    const dir = resolve3(this.baseDir, resourceId);
+    return resolve3(dir, `${threadId}.json`);
+  }
+  threadsPath(resourceId) {
+    return resolve3(this.baseDir, resourceId, "__threads.json");
+  }
+  read(resourceId, threadId) {
+    const path = this.filePath(resourceId, threadId);
+    if (!existsSync2(path)) return [];
+    try {
+      const raw = readFileSync2(path, "utf-8");
+      return JSON.parse(raw);
+    } catch {
+      return [];
+    }
+  }
+  write(resourceId, threadId, entries) {
+    const path = this.filePath(resourceId, threadId);
+    mkdirSync2(dirname2(path), { recursive: true });
+    writeFileSync(path, JSON.stringify(entries, null, 2), "utf-8");
+  }
+  readThreads(resourceId) {
+    const path = this.threadsPath(resourceId);
+    if (!existsSync2(path)) return [];
+    try {
+      const raw = readFileSync2(path, "utf-8");
+      return JSON.parse(raw);
+    } catch {
+      return [];
+    }
+  }
+  writeThreads(resourceId, threads) {
+    const path = this.threadsPath(resourceId);
+    mkdirSync2(dirname2(path), { recursive: true });
+    writeFileSync(path, JSON.stringify(threads, null, 2), "utf-8");
+  }
+  async save(resourceId, threadId, entries) {
+    const existing = this.read(resourceId, threadId);
+    existing.push(...entries);
+    this.write(resourceId, threadId, existing);
+  }
+  async load(resourceId, threadId, limit) {
+    const entries = this.read(resourceId, threadId);
+    if (limit === void 0 || limit >= entries.length) return entries;
+    return entries.slice(entries.length - limit);
+  }
+  async clear(resourceId, threadId) {
+    this.write(resourceId, threadId, []);
+  }
+  async close() {
+  }
+  async createThread(thread) {
+    const threads = this.readThreads(thread.resourceId);
+    threads.push(thread);
+    this.writeThreads(thread.resourceId, threads);
+  }
+  async getThread(threadId, resourceId) {
+    const threads = this.readThreads(resourceId);
+    return threads.find((t) => t.id === threadId) ?? null;
+  }
+  async listThreads(resourceId) {
+    return this.readThreads(resourceId);
+  }
+  async updateThread(thread) {
+    const threads = this.readThreads(thread.resourceId);
+    const idx = threads.findIndex((t) => t.id === thread.id);
+    if (idx === -1) throw new Error(`Thread not found: ${thread.id}`);
+    threads[idx] = { ...threads[idx], ...thread, updatedAt: Date.now() };
+    this.writeThreads(thread.resourceId, threads);
+  }
+  async deleteThread(threadId, resourceId) {
+    const threads = this.readThreads(resourceId);
+    this.writeThreads(resourceId, threads.filter((t) => t.id !== threadId));
+    const path = this.filePath(resourceId, threadId);
+    if (existsSync2(path)) writeFileSync(path, "[]", "utf-8");
+  }
+  async deleteMessages(opts) {
+    let entries = this.read(opts.resourceId, opts.threadId);
+    const before = entries.length;
+    const { messageIds, beforeTimestamp, afterTimestamp } = opts;
+    if (messageIds && messageIds.length > 0) {
+      const ids = new Set(messageIds);
+      entries = entries.filter((e) => !(e.turnId && ids.has(e.turnId)));
+    }
+    if (beforeTimestamp !== void 0) {
+      entries = entries.filter((e) => e.timestamp >= beforeTimestamp);
+    }
+    if (afterTimestamp !== void 0) {
+      entries = entries.filter((e) => e.timestamp <= afterTimestamp);
+    }
+    this.write(opts.resourceId, opts.threadId, entries);
+    return before - entries.length;
+  }
+  async cloneThread(source, dest) {
+    const entries = this.read(source.resourceId, source.threadId);
+    this.write(dest.resourceId, dest.threadId, entries.map((e) => ({ ...e })));
+  }
+};
+
+// src/memory/cencori-store.ts
+var CencoriMemoryStore = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async save(resourceId, threadId, entries) {
+    for (const entry of entries) {
+      await this.client.store({
+        namespace: resourceId,
+        content: entry.content,
+        metadata: {
+          threadId,
+          role: entry.role,
+          timestamp: entry.timestamp,
+          turnId: entry.turnId
+        }
+      });
+    }
+  }
+  async load(resourceId, threadId, limit) {
+    const result = await this.client.search({
+      namespace: resourceId,
+      query: "*",
+      limit: limit ?? 100,
+      threshold: 0,
+      filter: { threadId }
+    });
+    return result.results.map((r) => ({
+      role: r.metadata.role ?? "user",
+      content: r.content,
+      timestamp: r.metadata.timestamp ?? Date.now(),
+      turnId: r.metadata.turnId,
+      score: r.similarity
+    }));
+  }
+  async clear(resourceId, threadId) {
+    if (this.client.delete) {
+      await this.client.delete({
+        namespace: resourceId,
+        filter: { threadId }
+      });
+    }
+  }
+  async search(resourceId, threadId, query, limit) {
+    const result = await this.client.search({
+      namespace: resourceId,
+      query,
+      limit: limit ?? 5,
+      threshold: 0.5,
+      filter: { threadId }
+    });
+    return result.results.map((r) => ({
+      role: r.metadata.role ?? "user",
+      content: r.content,
+      timestamp: r.metadata.timestamp ?? Date.now(),
+      turnId: r.metadata.turnId,
+      score: r.similarity
+    }));
+  }
+  async close() {
+  }
+  async createThread(_thread) {
+    throw new Error("Thread management not supported by CencoriMemoryStore");
+  }
+  async getThread(_threadId, _resourceId) {
+    throw new Error("Thread management not supported by CencoriMemoryStore");
+  }
+  async listThreads(_resourceId) {
+    throw new Error("Thread management not supported by CencoriMemoryStore");
+  }
+  async updateThread(_thread) {
+    throw new Error("Thread management not supported by CencoriMemoryStore");
+  }
+  async deleteThread(_threadId, _resourceId) {
+    throw new Error("Thread management not supported by CencoriMemoryStore");
+  }
+  async deleteMessages(opts) {
+    if (!this.client.delete) throw new Error("CencoriMemoryClient does not support delete");
+    const filter = { threadId: opts.threadId };
+    if (opts.messageIds && opts.messageIds.length > 0) {
+      filter.turnId = { $in: opts.messageIds };
+    }
+    if (opts.beforeTimestamp !== void 0) {
+      filter.timestamp = { $gte: opts.beforeTimestamp };
+    }
+    if (opts.afterTimestamp !== void 0) {
+      filter.timestamp = { ...filter.timestamp || {}, $lte: opts.afterTimestamp };
+    }
+    await this.client.delete({ namespace: opts.resourceId, filter });
+    return -1;
+  }
+  async cloneThread(source, dest) {
+    const entries = await this.load(source.resourceId, source.threadId);
+    for (const entry of entries) {
+      await this.client.store({
+        namespace: dest.resourceId,
+        content: entry.content,
+        metadata: {
+          threadId: dest.threadId,
+          role: entry.role,
+          timestamp: entry.timestamp,
+          turnId: entry.turnId
+        }
+      });
+    }
+  }
+};
+
+// src/memory/strategies/lastN.ts
+var LastNStrategy = class {
+  limit;
+  constructor(limit = 10) {
+    this.limit = limit;
+  }
+  async getInputContext(store, resourceId, threadId) {
+    const entries = await store.load(resourceId, threadId, this.limit * 2);
+    if (entries.length === 0) return "";
+    const lines = entries.map((e) => {
+      const prefix = e.role === "user" ? "User" : e.role === "assistant" ? "Assistant" : "Tool";
+      return `${prefix}: ${e.content}`;
+    });
+    return `## Recent conversation history
+
+${lines.join("\n")}`;
+  }
+  async recordTurn(store, resourceId, threadId, input, output, toolCalls) {
+    const entries = [
+      { role: "user", content: input, timestamp: Date.now() },
+      { role: "assistant", content: output, timestamp: Date.now() }
+    ];
+    if (toolCalls && toolCalls.length > 0) {
+      for (const tc of toolCalls) {
+        entries.push({
+          role: "tool",
+          content: JSON.stringify({ tool: tc.tool, result: tc.output }),
+          timestamp: Date.now()
+        });
+      }
+    }
+    await store.save(resourceId, threadId, entries);
+  }
+};
+
+// src/memory/strategies/keyFacts.ts
+var FACT_PATTERNS = [
+  /(?:I am|I'm|my name is)\s+(\w+)/i,
+  /(?:I (?:work|am)\s+(?:at|for))\s+([\w\s]+?)(?=[.!,]|$)/i,
+  /(?:I (?:like|love|enjoy|prefer)\s+)([\w\s]+?)(?=[.!,]|$)/i,
+  /(?:I (?:live|am based|am located)\s+(?:in|at))\s+([\w\s,]+?)(?=[.!,]|$)/i,
+  /(?:my (?:favorite|favourite)\s+\w+\s+is)\s+([\w\s]+?)(?=[.!,]|$)/i,
+  /(?:I (?:have|has)\s+(?:a|an|the)\s+)([\w\s]+?)(?=[.!,]|$)/i,
+  /(?:I (?:don't|do not)\s+)([\w\s]+?)(?=[.!,]|$)/i,
+  /(?:I (?:use|built|created|developed)\s+)([\w\s]+?)(?=[.!,]|$)/i
+];
+function extractFacts(text) {
+  const facts = /* @__PURE__ */ new Set();
+  for (const pattern of FACT_PATTERNS) {
+    const match = text.match(pattern);
+    if (match && match[1].trim().length > 1) {
+      facts.add(match[1].trim());
+    }
+  }
+  return [...facts];
+}
+var FACTS_PREFIX = "___keyfacts___:";
+var KeyFactsStrategy = class {
+  facts = /* @__PURE__ */ new Map();
+  loaded = false;
+  async ensureLoaded(store, resourceId, threadId) {
+    if (this.loaded) return;
+    this.loaded = true;
+    try {
+      const entries = await store.load(resourceId, threadId);
+      const factEntries = entries.filter((e) => e.content.startsWith(FACTS_PREFIX)).sort((a, b) => b.timestamp - a.timestamp);
+      if (factEntries.length > 0) {
+        this.facts = new Map(JSON.parse(factEntries[0].content.slice(FACTS_PREFIX.length)));
+      }
+    } catch {
+    }
+  }
+  async getInputContext(store, resourceId, threadId) {
+    await this.ensureLoaded(store, resourceId, threadId);
+    if (this.facts.size === 0) return "";
+    const lines = [...this.facts.entries()].sort((a, b) => b[1] - a[1]).map(([fact]) => `- ${fact}`);
+    return `## Known facts about the user
+
+${lines.join("\n")}`;
+  }
+  async recordTurn(store, resourceId, threadId, input, output, _toolCalls) {
+    await this.ensureLoaded(store, resourceId, threadId);
+    const extracted = [...extractFacts(input), ...extractFacts(output)];
+    for (const fact of extracted) {
+      this.facts.set(fact, (this.facts.get(fact) ?? 0) + 1);
+    }
+    await store.save(resourceId, threadId, [
+      { role: "user", content: input, timestamp: Date.now() },
+      { role: "assistant", content: output, timestamp: Date.now() },
+      {
+        role: "tool",
+        content: `${FACTS_PREFIX}${JSON.stringify([...this.facts.entries()])}`,
+        timestamp: Date.now()
+      }
+    ]);
+  }
+};
+
+// src/memory/strategies/summary.ts
+function truncate(text, maxChars = 2e3) {
+  if (text.length <= maxChars) return text;
+  return text.slice(0, maxChars) + "...";
+}
+var SummaryStrategy = class {
+  limit;
+  summary = "";
+  summarize;
+  mutex = Promise.resolve();
+  constructor(limit = 10, summarize) {
+    this.limit = limit;
+    this.summarize = summarize ?? this.defaultSummarize;
+  }
+  async exclusive(fn) {
+    const prev = this.mutex;
+    let release;
+    this.mutex = new Promise((resolve5) => {
+      release = resolve5;
+    });
+    await prev;
+    try {
+      return await fn();
+    } finally {
+      release();
+    }
+  }
+  async defaultSummarize(text) {
+    const truncated = truncate(text);
+    const apiKey = process.env.CENCORI_API_KEY;
+    const endpoint = process.env.CENCORI_API_URL || "https://cencori.com/v1";
+    if (!apiKey) {
+      return `Previous conversation: ${truncated.slice(0, 500)}`;
+    }
+    try {
+      const res = await fetch(`${endpoint}/responses`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${apiKey}`
+        },
+        body: JSON.stringify({
+          model: "gpt-4o-mini",
+          input: `Summarize this conversation concisely:
+
+${truncated}`,
+          max_output_tokens: 300
+        })
+      });
+      if (!res.ok) return `Previous conversation: ${truncated.slice(0, 500)}`;
+      const data = await res.json();
+      const text2 = data.output?.output?.[0]?.content?.[0]?.text;
+      return text2 ?? `Previous conversation: ${truncated.slice(0, 500)}`;
+    } catch {
+      return `Previous conversation: ${truncated.slice(0, 500)}`;
+    }
+  }
+  async getInputContext(store, resourceId, threadId) {
+    const entries = await store.load(resourceId, threadId);
+    const recentEntries = [];
+    const summarizeEntries = [];
+    if (this.summary) {
+      summarizeEntries.push(`Summary of earlier conversation: ${this.summary}`);
+    }
+    for (const e of entries) {
+      const prefix = e.role === "user" ? "User" : e.role === "assistant" ? "Assistant" : "Tool";
+      recentEntries.push(`${prefix}: ${e.content}`);
+    }
+    const parts = [...summarizeEntries, ...recentEntries];
+    if (parts.length === 0) return "";
+    return `## Conversation history
+
+${parts.join("\n")}`;
+  }
+  async recordTurn(store, resourceId, threadId, input, output, toolCalls) {
+    await this.exclusive(async () => {
+      const entries = [
+        { role: "user", content: input, timestamp: Date.now() },
+        { role: "assistant", content: output, timestamp: Date.now() }
+      ];
+      if (toolCalls && toolCalls.length > 0) {
+        for (const tc of toolCalls) {
+          entries.push({
+            role: "tool",
+            content: JSON.stringify({ tool: tc.tool, result: tc.output }),
+            timestamp: Date.now()
+          });
+        }
+      }
+      await store.save(resourceId, threadId, entries);
+      const allEntries = await store.load(resourceId, threadId);
+      if (allEntries.length > this.limit * 2) {
+        const textToSummarize = allEntries.slice(0, allEntries.length - this.limit).map((e) => `${e.role}: ${e.content}`).join("\n");
+        this.summary = await this.summarize(textToSummarize);
+        const recentEntries = allEntries.slice(allEntries.length - this.limit);
+        await store.clear(resourceId, threadId);
+        await store.save(resourceId, threadId, recentEntries);
+      }
+    });
+  }
+};
+
+// src/memory/semantic.ts
+var SemanticRecall = class {
+  topK;
+  constructor(topK = 5) {
+    this.topK = topK;
+  }
+  async getInputContext(store, resourceId, threadId) {
+    if (!store.search) return "";
+    try {
+      const entries = await store.search(resourceId, threadId, "*", this.topK);
+      if (entries.length === 0) return "";
+      const sorted = [...entries].sort((a, b) => {
+        const sa = a.score ?? -Infinity;
+        const sb = b.score ?? -Infinity;
+        if (sa !== sb) return sb - sa;
+        return b.timestamp - a.timestamp;
+      });
+      const lines = sorted.map((e) => {
+        const prefix = e.role === "user" ? "User" : e.role === "assistant" ? "Assistant" : "Tool";
+        const scoreStr = e.score !== void 0 ? ` [relevance: ${(e.score * 100).toFixed(0)}%]` : "";
+        return `${prefix}${scoreStr}: ${e.content}`;
+      });
+      return `## Relevant memories
+
+${lines.join("\n")}`;
+    } catch {
+      return "";
+    }
+  }
+  async recordTurn(store, resourceId, threadId, input, output, toolCalls) {
+    const entries = [
+      { role: "user", content: input, timestamp: Date.now() },
+      { role: "assistant", content: output, timestamp: Date.now() }
+    ];
+    if (toolCalls && toolCalls.length > 0) {
+      for (const tc of toolCalls) {
+        entries.push({
+          role: "tool",
+          content: JSON.stringify({ tool: tc.tool, result: tc.output }),
+          timestamp: Date.now()
+        });
+      }
+    }
+    await store.save(resourceId, threadId, entries);
+  }
+};
+
+// src/memory/working-memory.ts
+import { readFileSync as readFileSync3, existsSync as existsSync3, mkdirSync as mkdirSync3, writeFileSync as writeFileSync2 } from "fs";
+import { resolve as resolve4 } from "path";
+import { homedir as homedir3 } from "os";
+import { z } from "zod";
+var updateWorkingMemorySchema = z.object({
+  section: z.string().describe("The markdown section heading to update (e.g. 'Interests', 'Goals')"),
+  content: z.string().describe("The new bullet-list content for the section")
+});
+var DEFAULT_TEMPLATE = `# User Profile
+
+- **Name**:
+- **Interests**:
+- **Goals**:
+- **Preferences**:
+`;
+var WORKING_MEMORY_SYSTEM_INSTRUCTION = `You have access to a persistent working memory that stores information about the user.
+You can read the current working memory below and update it using the \`updateWorkingMemory\` tool.
+
+When the user tells you something about themselves, update the working memory to reflect it.
+Use the \`updateWorkingMemory\` tool with \`section\` set to the markdown heading (e.g. "Interests") and \`content\` set to the new bullet list content for that section.`;
+var WorkingMemory = class {
+  template;
+  content;
+  baseDir;
+  resourceId;
+  initialized = false;
+  constructor(template, baseDir, resourceId) {
+    this.template = template ?? DEFAULT_TEMPLATE;
+    this.content = this.template;
+    this.resourceId = resourceId ?? "default";
+    this.baseDir = baseDir ?? resolve4(homedir3(), ".arcie", "memory", "working");
+  }
+  ensureDir() {
+    if (!this.initialized) {
+      mkdirSync3(this.baseDir, { recursive: true });
+      this.initialized = true;
+    }
+  }
+  filePath(resourceId) {
+    return resolve4(this.baseDir, `${resourceId}.md`);
+  }
+  loadFromDisk(resourceId) {
+    this.ensureDir();
+    const path = this.filePath(resourceId);
+    if (existsSync3(path)) {
+      this.content = readFileSync3(path, "utf-8");
+    } else {
+      this.content = this.template;
+    }
+  }
+  saveToDisk(resourceId) {
+    this.ensureDir();
+    writeFileSync2(this.filePath(resourceId), this.content, "utf-8");
+  }
+  getSystemInstruction() {
+    return WORKING_MEMORY_SYSTEM_INSTRUCTION;
+  }
+  getCurrentContent(resourceId) {
+    this.loadFromDisk(resourceId);
+    return this.content;
+  }
+  updateSection(resourceId, section, content) {
+    this.loadFromDisk(resourceId);
+    const sectionRegex = new RegExp(`(##\\s*${escapeRegex(section)}[\\s\\S]*?)(?=\\n##\\s|\\n*$)`, "i");
+    const existing = this.content.match(sectionRegex);
+    if (existing) {
+      const headerMatch = existing[0].match(/^##\s+.+$/m);
+      const header = headerMatch ? headerMatch[0] : `## ${section}`;
+      this.content = this.content.replace(existing[0], `${header}
+
+${content}
+`);
+    } else {
+      this.content += `
+## ${section}
+
+${content}
+`;
+    }
+    this.saveToDisk(resourceId);
+  }
+  getToolDefinitions() {
+    const resourceId = this.resourceId;
+    return {
+      updateWorkingMemory: {
+        description: "Update a section of the working memory with new content. Use this when the user shares personal information.",
+        inputSchema: updateWorkingMemorySchema,
+        execute: async (input) => {
+          const { section, content } = input;
+          this.updateSection(resourceId, section, content);
+          return { updated: true, section };
+        }
+      }
+    };
+  }
+  async getInputContext(_store, resourceId, _threadId) {
+    this.loadFromDisk(resourceId);
+    if (!this.content || this.content === this.template) return "";
+    return `## Working Memory (persistent \u2014 edit ~/.arcie/memory/working/${resourceId}.md directly)
+
+${this.content}`;
+  }
+  async recordTurn(_store, _resourceId, _threadId, _input, _output, _toolCalls) {
+  }
+};
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/memory/processors/message-history.ts
+var MessageHistoryProcessor = class {
+  name = "message-history";
+  limit;
+  constructor(limit = 10) {
+    this.limit = limit;
+  }
+  async processInput(store, resourceId, threadId) {
+    const entries = await store.load(resourceId, threadId, this.limit);
+    if (entries.length === 0) return "";
+    const lines = entries.map((e) => {
+      const prefix = e.role === "user" ? "User" : e.role === "assistant" ? "Assistant" : "Tool";
+      return `${prefix}: ${e.content}`;
+    });
+    return `## Recent conversation history
+
+${lines.join("\n")}`;
+  }
+  async processOutput(store, resourceId, threadId, input, output, toolCalls) {
+    const entries = [
+      { role: "user", content: input, timestamp: Date.now() },
+      { role: "assistant", content: output, timestamp: Date.now() }
+    ];
+    if (toolCalls && toolCalls.length > 0) {
+      for (const tc of toolCalls) {
+        entries.push({
+          role: "tool",
+          content: JSON.stringify({ tool: tc.tool, result: tc.output }),
+          timestamp: Date.now()
+        });
+      }
+    }
+    await store.save(resourceId, threadId, entries);
+  }
+};
+
+// src/memory/processors/working-memory.ts
+import { z as z2 } from "zod";
+var WORKING_MEMORY_KEY = "__working_memory__";
+var DEFAULT_TEMPLATE2 = `# User Profile
+
+- **Name**:
+- **Interests**:
+- **Goals**:
+- **Preferences**:
+`;
+var TEMPLATE_SYSTEM_INSTRUCTION = `You have access to a persistent working memory that stores information about the user.
+You can read the current working memory below and update it using the \`updateWorkingMemory\` tool.
+
+When the user tells you something about themselves, update the working memory to reflect it.
+Use the \`updateWorkingMemory\` tool with \`content\` set to the full updated markdown content.`;
+var SCHEMA_SYSTEM_INSTRUCTION = `You have access to a persistent working memory that stores structured data about the user.
+You can read the current working memory below and update it using the \`updateWorkingMemory\` tool.
+
+When the user tells you something about themselves, update the working memory to reflect it.
+The tool uses merge semantics: send only the fields you want to add or change. Set a field to null to delete it.
+Objects are deep-merged. Arrays are replaced entirely.`;
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    const val = source[key];
+    if (val === null) {
+      delete result[key];
+    } else if (val !== null && typeof val === "object" && !Array.isArray(val) && typeof result[key] === "object" && result[key] !== null && !Array.isArray(result[key])) {
+      result[key] = deepMerge(result[key], val);
+    } else {
+      result[key] = val;
+    }
+  }
+  return result;
+}
+var WorkingMemoryProcessor = class {
+  name = "working-memory";
+  store;
+  resourceId;
+  threadId;
+  config;
+  mode;
+  currentContent = "";
+  constructor(store, resourceId, threadId, config) {
+    this.store = store;
+    this.resourceId = resourceId;
+    this.threadId = threadId;
+    this.config = {
+      enabled: true,
+      scope: "resource",
+      ...config
+    };
+    if (this.config.schema) {
+      this.mode = { type: "schema", schema: this.config.schema };
+    } else {
+      this.mode = { type: "template", template: this.config.template ?? DEFAULT_TEMPLATE2 };
+    }
+  }
+  key() {
+    return this.config.scope === "resource" ? this.resourceId : this.threadId;
+  }
+  defaultContent() {
+    if (this.mode.type === "template") return this.mode.template;
+    return JSON.stringify(this.mode.schema.parse({}), null, 2);
+  }
+  async loadContent() {
+    const k = this.key();
+    const entries = await this.store.load(k, WORKING_MEMORY_KEY);
+    if (entries.length === 0) return this.defaultContent();
+    const wm = entries.find((e) => e.role === "system");
+    return wm?.content ?? this.defaultContent();
+  }
+  async processInput(_store, _resourceId, _threadId) {
+    if (!this.config.enabled) return "";
+    this.currentContent = await this.loadContent();
+    if (!this.currentContent || this.currentContent === this.defaultContent()) return "";
+    const label = this.mode.type === "schema" ? "## Working Memory\n\n```json" : "## Working Memory";
+    const suffix = this.mode.type === "schema" ? "```" : "";
+    return `${label}
+${this.currentContent}${suffix ? `
+${suffix}` : ""}`;
+  }
+  async processOutput(_store, _resourceId, _threadId, _input, _output, _toolCalls) {
+  }
+  getSystemInstruction() {
+    if (!this.config.enabled) return "";
+    return this.mode.type === "schema" ? SCHEMA_SYSTEM_INSTRUCTION : TEMPLATE_SYSTEM_INSTRUCTION;
+  }
+  getToolDefinitions() {
+    if (!this.config.enabled) return {};
+    const self = this;
+    if (this.mode.type === "schema") {
+      return {
+        updateWorkingMemory: {
+          description: "Update the working memory with new information about the user or conversation. Uses merge semantics: send only the fields to add or change.",
+          inputSchema: z2.object({
+            updates: z2.record(z2.unknown()).describe("Partial data to merge into working memory. Objects deep-merge, arrays replace, null deletes.")
+          }),
+          execute: async (input) => {
+            const { updates } = input;
+            const k = self.key();
+            const raw = await self.loadContent();
+            let current;
+            try {
+              current = JSON.parse(raw);
+            } catch {
+              current = {};
+            }
+            const merged = deepMerge(current, updates);
+            const content = JSON.stringify(merged, null, 2);
+            await self.store.save(k, WORKING_MEMORY_KEY, [
+              { role: "system", content, timestamp: Date.now() }
+            ]);
+            return { updated: true };
+          }
+        }
+      };
+    }
+    const updateWmSchema = z2.object({
+      content: z2.string().describe("The full updated markdown content for working memory")
+    });
+    return {
+      updateWorkingMemory: {
+        description: "Update the working memory with new content about the user.",
+        inputSchema: updateWmSchema,
+        execute: async (input) => {
+          const { content } = input;
+          const k = self.key();
+          await self.store.save(k, WORKING_MEMORY_KEY, [
+            { role: "system", content, timestamp: Date.now() }
+          ]);
+          return { updated: true };
+        }
+      }
+    };
+  }
+};
+
+// src/memory/processors/semantic-recall.ts
+var SemanticRecallProcessor = class {
+  name = "semantic-recall";
+  config;
+  embedder;
+  vectorStore;
+  constructor(embedder, vectorStore, config) {
+    this.embedder = embedder;
+    this.vectorStore = vectorStore;
+    this.config = {
+      topK: 5,
+      messageRange: 2,
+      scope: "thread",
+      ...config
+    };
+  }
+  async processInput(store, resourceId, threadId) {
+    const entries = await store.load(resourceId, threadId, this.config.topK);
+    if (entries.length === 0) return "";
+    const lines = entries.map((e) => {
+      const prefix = e.role === "user" ? "User" : e.role === "assistant" ? "Assistant" : "Tool";
+      const scoreStr = e.score !== void 0 ? ` [relevance: ${(e.score * 100).toFixed(0)}%]` : "";
+      return `${prefix}${scoreStr}: ${e.content}`;
+    });
+    return `## Relevant past context
+
+${lines.join("\n")}`;
+  }
+  async processOutput(store, resourceId, threadId, input, output, toolCalls) {
+    const texts = [input, output];
+    if (toolCalls) {
+      for (const tc of toolCalls) {
+        texts.push(JSON.stringify({ tool: tc.tool, result: tc.output }));
+      }
+    }
+    const embeddings = await this.embedder.embedBatch(texts);
+    const namespace = this.config.scope === "resource" ? resourceId : threadId;
+    await this.vectorStore.upsert(namespace, embeddings.map((values, i) => ({
+      id: `${threadId}:${Date.now()}:${i}`,
+      values,
+      metadata: { role: i === 0 ? "user" : i === 1 ? "assistant" : "tool", threadId }
+    })));
+  }
+};
+
+// src/memory/processors/strategy-adapter.ts
+var StrategyAdapter = class {
+  name;
+  strategy;
+  constructor(strategy) {
+    this.strategy = strategy;
+    this.name = `${strategy.constructor.name}Adapter`;
+  }
+  async processInput(store, resourceId, threadId) {
+    return this.strategy.getInputContext(store, resourceId, threadId);
+  }
+  async processOutput(store, resourceId, threadId, input, output, toolCalls) {
+    await this.strategy.recordTurn(store, resourceId, threadId, input, output, toolCalls);
+  }
+  getToolDefinitions() {
+    if ("getToolDefinitions" in this.strategy) {
+      return this.strategy.getToolDefinitions();
+    }
+    return {};
+  }
+};
+
+// src/memory/index.ts
+var Memory = class _Memory {
+  store;
+  resourceId;
+  threadId;
+  processors;
+  readOnly;
+  buildSource;
+  constructor(configOrOptions, options) {
+    let config;
+    let opts;
+    if (configOrOptions && "store" in configOrOptions) {
+      opts = configOrOptions;
+      config = void 0;
+    } else {
+      config = configOrOptions;
+      opts = options ?? {};
+    }
+    this.buildSource = config ? { type: "config", config, opts } : { type: "options", opts };
+    this.store = opts.store ?? new InMemoryStore();
+    this.resourceId = opts.resourceId ?? "default";
+    this.threadId = opts.threadId ?? "default";
+    this.readOnly = opts.readOnly ?? false;
+    this.processors = [];
+    if (opts.processors) {
+      for (const p of opts.processors) {
+        if ("getInputContext" in p && "recordTurn" in p) {
+          this.processors.push(new StrategyAdapter(p));
+        } else {
+          this.processors.push(p);
+        }
+      }
+    } else if (config) {
+      this.buildFromConfig(config, opts);
+    } else if (opts.lastMessages) {
+      this.processors.push(new MessageHistoryProcessor(opts.lastMessages));
+    } else {
+      this.processors.push(new MessageHistoryProcessor(10));
+    }
+  }
+  buildFromConfig(config, opts) {
+    if (!config) return;
+    switch (config.strategy) {
+      case "lastN": {
+        const strategy = new LastNStrategy(config.limit ?? 10);
+        this.processors.push(new StrategyAdapter(strategy));
+        break;
+      }
+      case "summary": {
+        const strategy = new SummaryStrategy(config.limit ?? 10);
+        this.processors.push(new StrategyAdapter(strategy));
+        break;
+      }
+      case "keyFacts": {
+        const strategy = new KeyFactsStrategy();
+        this.processors.push(new StrategyAdapter(strategy));
+        break;
+      }
+      case "semantic": {
+        if (opts.embedder && opts.vectorStore) {
+          this.processors.push(new SemanticRecallProcessor(opts.embedder, opts.vectorStore, {
+            topK: config.limit ?? 5,
+            scope: "resource"
+          }));
+        } else {
+          const strategy = new SemanticRecall(config.limit ?? 5);
+          this.processors.push(new StrategyAdapter(strategy));
+        }
+        break;
+      }
+      default:
+        this.processors.push(new MessageHistoryProcessor(config.limit ?? 10));
+    }
+    if (config.workingMemory) {
+      this.processors.push(new WorkingMemoryProcessor(this.store, this.resourceId, this.threadId, {
+        enabled: true,
+        template: config.workingMemoryTemplate,
+        scope: "resource"
+      }));
+    }
+  }
+  /**
+   * Create a new Memory instance sharing the same store and configuration
+   * but with overridden resourceId, threadId, and/or readOnly.
+   * Useful for per-request memory config.
+   */
+  with(overrides) {
+    if (this.buildSource.type === "config") {
+      return new _Memory(this.buildSource.config, {
+        ...this.buildSource.opts,
+        resourceId: overrides.resourceId ?? this.resourceId,
+        threadId: overrides.threadId ?? this.threadId,
+        readOnly: overrides.readOnly ?? this.readOnly
+      });
+    }
+    return new _Memory({
+      ...this.buildSource.opts,
+      resourceId: overrides.resourceId ?? this.resourceId,
+      threadId: overrides.threadId ?? this.threadId,
+      readOnly: overrides.readOnly ?? this.readOnly
+    });
+  }
+  async destroy() {
+    await this.store.close?.();
+  }
+  async getInputContext() {
+    const parts = [];
+    for (const p of this.processors) {
+      const ctx = await p.processInput(this.store, this.resourceId, this.threadId);
+      if (ctx) parts.push(ctx);
+    }
+    return parts.join("\n\n");
+  }
+  getSystemInstruction() {
+    const parts = [];
+    for (const p of this.processors) {
+      if ("getSystemInstruction" in p) {
+        const si = p.getSystemInstruction();
+        if (si) parts.push(si);
+      }
+    }
+    return parts.join("\n\n");
+  }
+  getToolDefinitions() {
+    if (this.readOnly) return {};
+    for (const p of this.processors) {
+      if ("getToolDefinitions" in p) {
+        const tools = p.getToolDefinitions();
+        if (Object.keys(tools).length > 0) return tools;
+      }
+    }
+    return {};
+  }
+  async recordTurn(input, output, toolCalls) {
+    if (this.readOnly) return;
+    for (const p of this.processors) {
+      if (p.processOutput) {
+        await p.processOutput(this.store, this.resourceId, this.threadId, input, output, toolCalls);
+      }
+    }
+  }
+  async clear() {
+    await this.store.clear(this.resourceId, this.threadId);
+  }
+  // ── Thread API ──
+  async createThread(thread) {
+    if (!this.store.createThread) throw new Error("Store does not support thread creation");
+    await this.store.createThread(thread);
+  }
+  async getThread(threadId, resourceId) {
+    if (!this.store.getThread) throw new Error("Store does not support thread retrieval");
+    return this.store.getThread(threadId, resourceId);
+  }
+  async listThreads(resourceId) {
+    if (!this.store.listThreads) throw new Error("Store does not support thread listing");
+    return this.store.listThreads(resourceId);
+  }
+  async updateThread(thread) {
+    if (!this.store.updateThread) throw new Error("Store does not support thread updates");
+    await this.store.updateThread(thread);
+  }
+  async deleteThread(threadId, resourceId) {
+    if (!this.store.deleteThread) throw new Error("Store does not support thread deletion");
+    await this.store.deleteThread(threadId, resourceId);
+  }
+  // ── Delete messages ──
+  async deleteMessages(opts) {
+    if (!this.store.deleteMessages) throw new Error("Store does not support message deletion");
+    return this.store.deleteMessages(opts);
+  }
+  // ── Clone thread ──
+  async cloneThread(source, dest) {
+    if (!this.store.cloneThread) throw new Error("Store does not support thread cloning");
+    await this.store.cloneThread(source, dest);
+  }
+  // ── Recall API ──
+  async recall(opts) {
+    let entries = await this.store.load(opts.resourceId, opts.threadId);
+    if (opts.dateRange) {
+      const start2 = opts.dateRange.start?.getTime() ?? 0;
+      const end = opts.dateRange.end?.getTime() ?? Infinity;
+      entries = entries.filter((e) => e.timestamp >= start2 && e.timestamp <= end);
+    }
+    if (opts.include && opts.include.length > 0) {
+      const included = [];
+      for (const inc of opts.include) {
+        const idx = entries.findIndex((e) => e.turnId === inc.id);
+        if (idx === -1) continue;
+        const start2 = Math.max(0, idx - (inc.withPreviousMessages ?? 0));
+        const end = Math.min(entries.length, idx + 1 + (inc.withNextMessages ?? 0));
+        for (let i = start2; i < end; i++) {
+          included.push(entries[i]);
+        }
+      }
+      entries = included;
+    }
+    if (opts.vectorSearchString && this.store.search) {
+      entries = await this.store.search(opts.resourceId, opts.threadId, opts.vectorSearchString);
+    }
+    const total = entries.length;
+    const perPage = opts.perPage ?? 50;
+    const page = opts.page ?? 0;
+    const start = page * perPage;
+    const hasMore = start + perPage < total;
+    return {
+      messages: entries.slice(start, start + perPage),
+      total,
+      hasMore
+    };
+  }
+};
+
+// src/runner/index.ts
+var DEFAULT_ENDPOINT = "https://cencori.com/v1";
+async function createChildSession(endpoint, apiKey, agent, subagentId) {
+  const sub = agent.manifest.subagents[subagentId];
+  const res = await fetch(`${endpoint}/sessions`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`
+    },
+    body: JSON.stringify({
+      agent_id: `${agent.manifest.config.name ?? "unnamed"}.${subagentId}`,
+      metadata: {
+        model: sub.config.model,
+        instructions: sub.instructions
+      }
+    })
+  });
+  if (!res.ok) {
+    const err = await res.text();
+    throw new Error(`Subagent session error (${res.status}): ${err}`);
+  }
+  const data = await res.json();
+  return data.id;
+}
+async function executeSubagent(endpoint, apiKey, agent, subagentId, input, childSessionId) {
+  const sub = agent.manifest.subagents[subagentId];
+  childSessionId ??= await createChildSession(endpoint, apiKey, agent, subagentId);
+  const inputStr = typeof input === "string" ? input : JSON.stringify(input);
+  const tools = Object.entries(sub.tools).map(([name, tool]) => ({
+    name,
+    description: tool.description,
+    input_schema: {},
+    type: "function"
+  }));
+  const res = await fetch(`${endpoint}/sessions/${childSessionId}/turns`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`
+    },
+    body: JSON.stringify({
+      model: sub.config.model,
+      input: inputStr,
+      instructions: sub.instructions,
+      tools: tools.length > 0 ? tools : void 0,
+      stream: true,
+      pause_on_tool_calls: false
+    })
+  });
+  if (!res.ok) {
+    const err = await res.text();
+    throw new Error(`Subagent turn error (${res.status}): ${err}`);
+  }
+  let output = "";
+  let currentEvent = "";
+  const reader = res.body?.getReader();
+  if (reader) {
+    const decoder = new TextDecoder();
+    let buffer = "";
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        if (line.startsWith("event: ")) {
+          currentEvent = line.slice(7);
+        } else if (line.startsWith("data: ")) {
+          const payload = line.slice(6);
+          if (payload === "[DONE]") continue;
+          try {
+            const parsed = JSON.parse(payload);
+            const eventType = currentEvent || parsed.type;
+            if (eventType === "message.appended" && parsed.delta) {
+              output += parsed.delta;
+            }
+          } catch {
+          }
+        }
+      }
+    }
+  }
+  return output || inputStr;
+}
+function headers(apiKey, agent) {
+  return {
+    "Content-Type": "application/json",
+    Authorization: `Bearer ${apiKey}`,
+    ...agent.manifest.config.cencori?.project ? { "X-Project-ID": agent.manifest.config.cencori.project } : {}
+  };
+}
+async function createSession(endpoint, apiKey, agent) {
+  const res = await fetch(`${endpoint}/sessions`, {
+    method: "POST",
+    headers: headers(apiKey, agent),
+    body: JSON.stringify({
+      agent_id: agent.manifest.config.name,
+      metadata: {
+        model: agent.manifest.config.model,
+        instructions: agent.manifest.instructions
+      }
+    })
+  });
+  if (!res.ok) {
+    const err = await res.text();
+    throw new Error(`Cencori Sessions API error (${res.status}): ${err}`);
+  }
+  const data = await res.json();
+  return data.id;
+}
+async function runAgent(agentDir, input, options = {}) {
+  const agent = await loadAgent(agentDir);
+  const endpoint = options.endpoint || process.env.CENCORI_API_URL || DEFAULT_ENDPOINT;
+  const apiKey = options.apiKey || process.env.CENCORI_API_KEY || "";
+  const events = [];
+  let outputText = "";
+  if (!apiKey) {
+    throw new Error(
+      "Cencori API key required. Set CENCORI_API_KEY env var or pass apiKey in options."
+    );
+  }
+  const sessionId = options.sessionId || await createSession(endpoint, apiKey, agent);
+  for await (const event of streamAgent(agentDir, input, { ...options, sessionId, endpoint, apiKey })) {
+    events.push(event);
+    options.onEvent?.(event);
+    if (event.type === "message.completed" && event.data.text) {
+      outputText = event.data.text;
+    }
+  }
+  const toolCalls = [];
+  for (const e of events) {
+    if (e.type === "tool.started") {
+      const completed = events.find(
+        (ev) => ev.type === "tool.completed" && ev.data.callId === e.data.callId
+      );
+      const error = completed?.data.status === "failed" || completed?.data.status === "rejected" ? new Error(completed.data.error?.message ?? "Tool failed") : void 0;
+      toolCalls.push({
+        tool: e.data.name,
+        input: e.data.input,
+        output: completed?.data.output,
+        durationMs: void 0,
+        ...error ? { error } : {}
+      });
+    }
+  }
+  return {
+    output: outputText,
+    turns: [{
+      id: events.find((e) => e.type === "turn.started")?.data.turnId ?? "",
+      sessionId,
+      input,
+      output: outputText,
+      toolCalls
+    }],
+    events,
+    sessionId
+  };
+}
+async function* readTurnSSE(response, turnId) {
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`Cencori Sessions API error (${response.status}): ${error}`);
+  }
+  const reader = response.body?.getReader();
+  if (!reader) return { status: "completed", text: "" };
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let currentEvent = "";
+  let textSoFar = "";
+  const toolCalls = [];
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split("\n");
+    buffer = lines.pop() ?? "";
+    for (const line of lines) {
+      if (line.startsWith("event: ")) {
+        currentEvent = line.slice(7);
+      } else if (line.startsWith("data: ")) {
+        const payload = line.slice(6);
+        if (payload === "[DONE]") continue;
+        try {
+          const parsed = JSON.parse(payload);
+          const eventType = currentEvent || parsed.type;
+          switch (eventType) {
+            case "turn.started": {
+              yield createTurnStarted(parsed.turn_number ?? 1, turnId);
+              yield createMessageReceived(parsed.input_text ?? "", parsed.turn_number ?? 1, turnId);
+              yield createStepStarted(1, 0, turnId);
+              break;
+            }
+            case "output_text.delta": {
+              if (parsed.delta) {
+                textSoFar += parsed.delta;
+                yield createMessageAppended(parsed.delta, textSoFar, 1, 0, turnId);
+              }
+              break;
+            }
+            case "tool_call.started": {
+              toolCalls.push({
+                name: parsed.tool,
+                args: parsed.arguments,
+                actionId: parsed.action_id
+              });
+              yield createToolCallStarted(
+                parsed.tool,
+                parsed.arguments,
+                parsed.action_id,
+                1,
+                0,
+                turnId
+              );
+              break;
+            }
+            case "turn.paused": {
+              currentEvent = "";
+              return {
+                status: "paused",
+                toolCalls: [...toolCalls],
+                text: textSoFar
+              };
+            }
+            case "turn.completed": {
+              const out = parsed.output;
+              let finalText = textSoFar;
+              let finishReason = "stop";
+              if (out?.error) {
+                finishReason = "error";
+              } else if (Array.isArray(out?.output)) {
+                for (const item of out.output) {
+                  if (item.type === "message") {
+                    const tc = item.content?.find((c) => c.type === "output_text");
+                    if (tc?.text) finalText = tc.text;
+                  }
+                }
+              }
+              textSoFar = finalText;
+              yield createMessageCompleted(finalText, finishReason, 1, 0, turnId);
+              yield createStepCompleted(finishReason, 1, 0, turnId);
+              yield createTurnCompleted(1, turnId);
+              currentEvent = "";
+              return { status: "completed", text: finalText };
+            }
+            case "turn.resumed": {
+              break;
+            }
+            default: {
+              break;
+            }
+          }
+          currentEvent = "";
+        } catch {
+        }
+      }
+    }
+  }
+  return { status: "completed", text: textSoFar };
+}
+async function* streamAgent(agentDir, input, options = {}) {
+  const agent = await loadAgent(agentDir);
+  const endpoint = options.endpoint || process.env.CENCORI_API_URL || DEFAULT_ENDPOINT;
+  const apiKey = options.apiKey || process.env.CENCORI_API_KEY || "";
+  if (!apiKey) {
+    throw new Error(
+      "Cencori API key required. Set CENCORI_API_KEY env var or pass apiKey in options."
+    );
+  }
+  const sessionId = options.sessionId || await createSession(endpoint, apiKey, agent);
+  const model = agent.manifest.config.model;
+  const memory = agent.manifest.session?.memory ? new Memory(agent.manifest.session.memory, {
+    store: options.memoryStore,
+    resourceId: options.resourceId,
+    threadId: options.threadId
+  }) : null;
+  const memoryTools = memory ? memory.getToolDefinitions() : {};
+  const allTools = { ...agent.manifest.tools, ...memoryTools };
+  const tools = Object.entries(allTools).map(
+    ([name, tool]) => toModelOutput(name, tool)
+  );
+  const memoryContext = memory ? await memory.getInputContext() : "";
+  const memoryInstruction = memory ? memory.getSystemInstruction() : "";
+  const instructions = [
+    agent.manifest.instructions,
+    memoryInstruction,
+    memoryContext
+  ].filter(Boolean).join("\n\n");
+  yield createSessionStarted(sessionId, {
+    agentId: agent.manifest.config.name ?? "unnamed",
+    modelId: model,
+    arcieVersion: "0.1.2"
+  });
+  const turnId = crypto.randomUUID();
+  const maxToolLoops = options.maxTurns ?? 25;
+  let response = await fetch(`${endpoint}/sessions/${sessionId}/turns`, {
+    method: "POST",
+    headers: headers(apiKey, agent),
+    body: JSON.stringify({
+      model,
+      input,
+      instructions,
+      tools: tools.length > 0 ? tools : void 0,
+      stream: true,
+      pause_on_tool_calls: true
+    })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    yield createTurnCompleted(1, turnId);
+    yield createSessionCompleted();
+    throw new Error(`Cencori Sessions API error (${response.status}): ${error}`);
+  }
+  const approvedTools = /* @__PURE__ */ new Set();
+  const allToolCalls = [];
+  for (let loop = 0; loop < maxToolLoops; loop++) {
+    const eventGen = readTurnSSE(response, turnId);
+    let result;
+    let iter = await eventGen.next();
+    while (!iter.done) {
+      yield iter.value;
+      iter = await eventGen.next();
+    }
+    result = iter.value;
+    if (result.status === "completed") {
+      if (memory) {
+        await memory.recordTurn(input, result.text, allToolCalls.length > 0 ? allToolCalls : void 0);
+      }
+      break;
+    }
+    if (result.status !== "paused" || result.toolCalls.length === 0) break;
+    const toolResults = [];
+    let needsUserApproval = false;
+    for (const tc of result.toolCalls) {
+      const toolDef = agent.manifest.tools[tc.name] ?? memoryTools[tc.name];
+      const subDef = agent.manifest.subagents[tc.name];
+      const strategy = toolDef?.needsApproval;
+      if (strategy === "always" || strategy === "once" && !approvedTools.has(tc.name)) {
+        needsUserApproval = true;
+        yield createToolCallCompleted(
+          tc.name,
+          null,
+          tc.actionId,
+          "pending",
+          { code: "needs_approval", message: `Tool "${tc.name}" requires approval` },
+          1,
+          0,
+          turnId
+        );
+        continue;
+      }
+      if (strategy === "once") approvedTools.add(tc.name);
+      if (toolDef?.execute) {
+        try {
+          const output = await toolDef.execute(tc.args);
+          const outputStr = typeof output === "string" ? output : JSON.stringify(output);
+          yield createToolCallCompleted(tc.name, outputStr, tc.actionId, "completed", void 0, 1, 0, turnId);
+          toolResults.push({ action_id: tc.actionId, output: outputStr });
+          allToolCalls.push({ tool: tc.name, input: tc.args, output });
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : "Tool execution failed";
+          yield createToolCallCompleted(tc.name, msg, tc.actionId, "failed", { code: "execution_error", message: msg }, 1, 0, turnId);
+          toolResults.push({ action_id: tc.actionId, output: `Error: ${msg}` });
+          allToolCalls.push({ tool: tc.name, input: tc.args, output: `Error: ${msg}` });
+        }
+      } else if (subDef) {
+        const callId = tc.actionId;
+        try {
+          const childSessionId = await createChildSession(endpoint, apiKey, agent, tc.name);
+          yield createSubagentCalled(tc.name, callId, childSessionId, turnId);
+          const output = await executeSubagent(endpoint, apiKey, agent, tc.name, tc.args, childSessionId);
+          yield createSubagentCompleted(tc.name, callId, output);
+          yield createToolCallCompleted(tc.name, output, tc.actionId, "completed", void 0, 1, 0, turnId);
+          toolResults.push({ action_id: tc.actionId, output });
+          allToolCalls.push({ tool: tc.name, input: tc.args, output });
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : "Subagent execution failed";
+          yield createSubagentCompleted(tc.name, callId, `Error: ${msg}`);
+          yield createToolCallCompleted(tc.name, msg, tc.actionId, "failed", { code: "execution_error", message: msg }, 1, 0, turnId);
+          toolResults.push({ action_id: tc.actionId, output: `Error: ${msg}` });
+          allToolCalls.push({ tool: tc.name, input: tc.args, output: `Error: ${msg}` });
+        }
+      } else {
+        yield createToolCallCompleted(tc.name, "Tool not found in agent manifest", tc.actionId, "failed", { code: "tool_not_found", message: `Tool "${tc.name}" not defined in agent` }, 1, 0, turnId);
+        toolResults.push({ action_id: tc.actionId, output: "Error: tool not defined" });
+        allToolCalls.push({ tool: tc.name, input: tc.args, output: "Error: tool not defined" });
+      }
+    }
+    if (needsUserApproval && toolResults.length === 0) {
+      yield createSessionWaiting();
+      return;
+    }
+    const firstActionId = toolResults[0].action_id;
+    const approveRes = await fetch(
+      `${endpoint}/sessions/${sessionId}/approve`,
+      {
+        method: "POST",
+        headers: headers(apiKey, agent),
+        body: JSON.stringify({
+          action_id: firstActionId,
+          tool_results: toolResults
+        })
+      }
+    );
+    if (!approveRes.ok) {
+      const errText = await approveRes.text();
+      yield createTurnCompleted(1, turnId);
+      yield createSessionCompleted();
+      throw new Error(`Cencori Sessions approve error (${approveRes.status}): ${errText}`);
+    }
+    response = approveRes;
+  }
+  yield createSessionWaiting();
+}
+
+export {
+  InMemoryStore,
+  SqliteStore,
+  FileStore,
+  CencoriMemoryStore,
+  LastNStrategy,
+  KeyFactsStrategy,
+  SummaryStrategy,
+  SemanticRecall,
+  DEFAULT_TEMPLATE,
+  WORKING_MEMORY_SYSTEM_INSTRUCTION,
+  WorkingMemory,
+  Memory,
+  loadAgent,
+  runAgent,
+  streamAgent
+};
+//# sourceMappingURL=chunk-2ZSKZYWK.js.map