@archships/dim-agent-sdk 0.0.1

package/dist/index.js

@@ -0,0 +1,2997 @@
+// src/utils/guards.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+
+// src/contracts/content-normalize.ts
+function isTextContent(value) {
+  return isRecord(value) && value.type === "text" && typeof value.text === "string" && (value.annotations === undefined || isRecord(value.annotations)) && (value._meta === undefined || isRecord(value._meta));
+}
+function isImageContent(value) {
+  return isRecord(value) && value.type === "image" && typeof value.data === "string" && typeof value.mimeType === "string" && (value.annotations === undefined || isRecord(value.annotations)) && (value._meta === undefined || isRecord(value._meta));
+}
+function isContentBlock(value) {
+  return isTextContent(value) || isImageContent(value);
+}
+function normalizeContent(input) {
+  if (typeof input === "string") {
+    return [{ type: "text", text: input }];
+  }
+  if (Array.isArray(input)) {
+    const blocks = input.filter((item) => item != null);
+    if (!blocks.every(isContentBlock))
+      throw new TypeError("Content array must contain only text or image blocks");
+    return blocks.map((block) => ({ ...block }));
+  }
+  if (!isContentBlock(input))
+    throw new TypeError("Content must be a string, content block, or content block array");
+  return [{ ...input }];
+}
+function contentToText(content) {
+  return content.filter((block) => block.type === "text").map((block) => block.text).join("");
+}
+// src/context/AutoContextManager.ts
+import path from "node:path";
+
+// src/utils/id.ts
+function createId(prefix) {
+  return `${prefix}_${crypto.randomUUID()}`;
+}
+
+// src/context/AutoContextManager.ts
+class AutoContextManager {
+  services;
+  pluginHost;
+  maxItems;
+  maxChars;
+  constructor(options) {
+    this.services = options.services;
+    this.pluginHost = options.pluginHost;
+    this.maxItems = options.maxItems ?? 8;
+    this.maxChars = options.maxChars ?? 8000;
+  }
+  async resolve(options) {
+    const items = [];
+    if (options.cwd) {
+      items.push({
+        id: createId("ctx"),
+        type: "cwd",
+        title: "Working directory",
+        content: options.cwd,
+        priority: 10,
+        source: "agent"
+      });
+    }
+    items.push(...await this.resolveExplicitFiles(options.input, options.cwd));
+    items.push(...await this.resolveRecentFiles(options.cwd));
+    items.push(...await this.resolveGitState(options.cwd));
+    const contributed = await this.pluginHost?.collectContext({
+      sessionId: options.sessionId,
+      input: options.input,
+      messages: options.messages,
+      cwd: options.cwd
+    });
+    if (contributed)
+      items.push(...contributed);
+    return budgetContext(items, this.maxItems, this.maxChars);
+  }
+  format(items) {
+    if (items.length === 0)
+      return [];
+    const sections = items.map((item) => {
+      return [`[${item.title}]`, item.content].join(`
+`);
+    });
+    return [`Additional context for this turn:
+
+${sections.join(`
+
+`)}`];
+  }
+  async resolveExplicitFiles(input, cwd) {
+    const text = inputToText(input);
+    const candidates = extractFileCandidates(text);
+    const items = [];
+    for (const candidate of candidates) {
+      if (!cwd)
+        break;
+      if (!await this.services.fileSystem.exists(candidate, { cwd }))
+        continue;
+      const content = await safeReadText(this.services, candidate, cwd);
+      if (!content)
+        continue;
+      items.push({
+        id: createId("ctx"),
+        type: "file",
+        title: `File: ${candidate}`,
+        content,
+        priority: 100,
+        source: "explicit-file"
+      });
+    }
+    return items;
+  }
+  async resolveRecentFiles(cwd) {
+    if (!cwd || !this.pluginHost)
+      return [];
+    const items = [];
+    for (const filePath of this.pluginHost.recentFiles(3)) {
+      const relative = toRelative(cwd, filePath);
+      const content = await safeReadText(this.services, relative, cwd);
+      if (!content)
+        continue;
+      items.push({
+        id: createId("ctx"),
+        type: "file",
+        title: `Recent file: ${relative}`,
+        content,
+        priority: 70,
+        source: "recent-file"
+      });
+    }
+    return items;
+  }
+  async resolveGitState(cwd) {
+    if (!cwd)
+      return [];
+    const items = [];
+    const status = await this.services.git.status({ cwd });
+    if (status) {
+      items.push({
+        id: createId("ctx"),
+        type: "git_status",
+        title: "Git status",
+        content: status,
+        priority: 60,
+        source: "git"
+      });
+    }
+    const diff = await this.services.git.diff({ cwd });
+    if (diff) {
+      items.push({
+        id: createId("ctx"),
+        type: "git_diff",
+        title: "Git diff",
+        content: trimText(diff, 4000),
+        priority: 50,
+        source: "git"
+      });
+    }
+    return items;
+  }
+}
+function inputToText(input) {
+  return contentToText(normalizeContent(input));
+}
+function extractFileCandidates(text) {
+  const matches = text.match(/(?:[A-Za-z0-9._-]+\/)*[A-Za-z0-9._-]+\.[A-Za-z0-9_-]+/g) ?? [];
+  return [...new Set(matches)];
+}
+function trimText(text, maxChars) {
+  return text.length <= maxChars ? text : `${text.slice(0, maxChars)}
+...`;
+}
+async function safeReadText(services, filePath, cwd) {
+  try {
+    const text = await services.fileSystem.readText(filePath, { cwd });
+    return trimText(text, 2000);
+  } catch {
+    return null;
+  }
+}
+function budgetContext(items, maxItems, maxChars) {
+  const sorted = [...items].sort((left, right) => right.priority - left.priority);
+  const selected = [];
+  let totalChars = 0;
+  for (const item of sorted) {
+    if (selected.length >= maxItems)
+      break;
+    if (totalChars + item.content.length > maxChars && selected.length > 0)
+      continue;
+    selected.push(item);
+    totalChars += item.content.length;
+  }
+  return selected;
+}
+function toRelative(cwd, filePath) {
+  if (!path.isAbsolute(filePath))
+    return filePath;
+  return path.relative(cwd, filePath) || path.basename(filePath);
+}
+// src/plugin-host/helpers.ts
+function isHookControlResult(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const candidate = value;
+  return (candidate.type === "continue" || candidate.type === "replace" || candidate.type === "stop") && "payload" in candidate;
+}
+
+// src/plugin-host/HookPipeline.ts
+class HookPipeline {
+  registrations = [];
+  register(pluginId, priority, hooks) {
+    if (!hooks)
+      return;
+    if (hooks["model.event"]?.middleware && hooks["model.event"]?.middleware.length > 0)
+      throw new Error(`Plugin ${pluginId} cannot register middleware for model.event`);
+    this.registrations.push({ pluginId, priority, hooks });
+    this.registrations.sort((left, right) => right.priority - left.priority);
+  }
+  async runMiddleware(name, payload, context) {
+    let current = payload;
+    for (const registration of this.registrations) {
+      const middlewares = registration.hooks[name]?.middleware ?? [];
+      for (const middleware of middlewares) {
+        const result = await middleware({
+          payload: current,
+          context: { ...context, metadata: { ...context.metadata, pluginId: registration.pluginId } }
+        });
+        if (result === undefined)
+          continue;
+        if (isHookControlResult(result)) {
+          current = result.payload;
+          if (result.type === "stop")
+            return current;
+          continue;
+        }
+        current = result;
+      }
+    }
+    return current;
+  }
+  async runObservers(name, payload, context) {
+    for (const registration of this.registrations) {
+      const observers = registration.hooks[name]?.observers ?? [];
+      for (const observer of observers) {
+        await observer({
+          payload,
+          context: { ...context, metadata: { ...context.metadata, pluginId: registration.pluginId } }
+        });
+      }
+    }
+  }
+}
+
+// src/plugin-host/PluginHost.ts
+class PluginHost {
+  pipeline = new HookPipeline;
+  contextContributors = [];
+  promptContributors = [];
+  tools = [];
+  services;
+  cwd;
+  agentId;
+  tracker;
+  constructor(options) {
+    this.agentId = options.agentId;
+    this.cwd = options.cwd;
+    this.services = options.services;
+    this.tracker = options.tracker;
+    for (const plugin of options.plugins ?? []) {
+      const priority = plugin.manifest.priority ?? 0;
+      const scopedServices = options.permissionGateway.scopeServices(this.services, plugin.manifest.id, plugin.manifest.permissions);
+      const setup = plugin.setup?.({
+        cwd: this.cwd,
+        manifest: plugin.manifest,
+        services: scopedServices
+      });
+      this.pipeline.register(plugin.manifest.id, priority, setup?.hooks);
+      for (const tool of setup?.tools ?? []) {
+        this.tools.push({
+          pluginId: plugin.manifest.id,
+          tool: wrapTool(plugin.manifest.id, tool, scopedServices)
+        });
+      }
+      for (const contributor of setup?.contextContributors ?? [])
+        this.contextContributors.push({ pluginId: plugin.manifest.id, contributor });
+      for (const contributor of setup?.promptContributors ?? [])
+        this.promptContributors.push({ pluginId: plugin.manifest.id, contributor });
+    }
+  }
+  pluginTools() {
+    return this.tools.map((entry) => entry.tool);
+  }
+  recentFiles(limit = 5) {
+    return this.tracker?.recentFiles(limit) ?? [];
+  }
+  async runMiddleware(name, payload, context = {}) {
+    return this.pipeline.runMiddleware(name, payload, this.createRuntimeContext(context));
+  }
+  async runObservers(name, payload, context = {}) {
+    await this.pipeline.runObservers(name, payload, this.createRuntimeContext(context));
+  }
+  async collectContext(input) {
+    const items = [];
+    for (const entry of this.contextContributors) {
+      const next = await entry.contributor(input);
+      if (next.length > 0)
+        items.push(...next);
+    }
+    return items;
+  }
+  async collectPromptSegments(input) {
+    const segments = [];
+    for (const entry of this.promptContributors) {
+      const next = await entry.contributor(input);
+      if (!next)
+        continue;
+      if (Array.isArray(next))
+        segments.push(...next.filter(Boolean));
+      else
+        segments.push(next);
+    }
+    return segments;
+  }
+  createRuntimeContext(context) {
+    return {
+      agentId: this.agentId,
+      cwd: context.cwd ?? this.cwd,
+      sessionId: context.sessionId,
+      requestId: context.requestId,
+      iteration: context.iteration,
+      metadata: context.metadata,
+      services: context.services ?? this.services
+    };
+  }
+}
+function wrapTool(pluginId, tool, services) {
+  return {
+    definition: tool.definition,
+    async execute(args, context) {
+      return tool.execute(args, {
+        ...context,
+        metadata: {
+          ...context.metadata,
+          pluginId
+        },
+        services
+      });
+    }
+  };
+}
+
+// src/services/activity.ts
+class ActivityTracker {
+  records = [];
+  record(record) {
+    this.records.push({ ...record, timestamp: record.timestamp });
+    if (this.records.length > 200)
+      this.records.splice(0, this.records.length - 200);
+  }
+  recentFiles(limit = 5) {
+    const seen = new Set;
+    const files = [];
+    for (let index = this.records.length - 1;index >= 0; index -= 1) {
+      const record = this.records[index];
+      if (!record || record.type !== "file")
+        continue;
+      if (seen.has(record.label))
+        continue;
+      seen.add(record.label);
+      files.push(record.label);
+      if (files.length >= limit)
+        break;
+    }
+    return files;
+  }
+}
+// src/services/ExecGateway.ts
+import { spawn } from "node:child_process";
+
+class NodeExecGateway {
+  cwd;
+  env;
+  tracker;
+  constructor(options = {}) {
+    this.cwd = options.cwd;
+    this.env = options.env ?? process.env;
+    this.tracker = options.tracker;
+  }
+  async execute(command, options = {}) {
+    const cwd = options.cwd ?? this.cwd;
+    const env = {
+      ...this.env,
+      ...options.env
+    };
+    const result = await new Promise((resolve, reject) => {
+      const child = spawn(command, {
+        cwd,
+        env,
+        shell: true,
+        signal: options.signal
+      });
+      let stdout = "";
+      let stderr = "";
+      let settled = false;
+      let timedOut = false;
+      let timeout;
+      const finish = (value, isError) => {
+        if (settled)
+          return;
+        settled = true;
+        if (timeout)
+          clearTimeout(timeout);
+        if (isError)
+          reject(value);
+        else
+          resolve(value);
+      };
+      if (options.timeoutMs !== undefined) {
+        timeout = setTimeout(() => {
+          timedOut = true;
+          child.kill("SIGTERM");
+        }, options.timeoutMs);
+      }
+      child.stdout.on("data", (chunk) => {
+        stdout += String(chunk);
+      });
+      child.stderr.on("data", (chunk) => {
+        stderr += String(chunk);
+      });
+      child.on("error", (error) => finish(error, true));
+      child.on("close", (code, signal) => {
+        finish({
+          command,
+          cwd: cwd ?? null,
+          stdout,
+          stderr,
+          exitCode: code,
+          signal: signal ?? null,
+          timedOut
+        }, false);
+      });
+    });
+    this.tracker?.record({
+      type: "command",
+      label: command,
+      timestamp: Date.now()
+    });
+    return result;
+  }
+}
+// src/services/FileSystemGateway.ts
+import { mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
+import path2 from "node:path";
+
+class NodeFileSystemGateway {
+  cwd;
+  tracker;
+  constructor(options = {}) {
+    this.cwd = options.cwd;
+    this.tracker = options.tracker;
+  }
+  async readText(targetPath, options = {}) {
+    const resolved = resolvePath(this.cwd, targetPath, options.cwd);
+    const text = await readFile(resolved, "utf8");
+    this.recordFile(resolved);
+    return text;
+  }
+  async writeText(targetPath, content, options = {}) {
+    const resolved = resolvePath(this.cwd, targetPath, options.cwd);
+    await mkdir(path2.dirname(resolved), { recursive: true });
+    await writeFile(resolved, content, "utf8");
+    this.recordFile(resolved);
+    return {
+      path: resolved,
+      bytes: Buffer.byteLength(content, "utf8")
+    };
+  }
+  async editText(targetPath, options) {
+    const resolved = resolvePath(this.cwd, targetPath, options.cwd);
+    const source = await readFile(resolved, "utf8");
+    const matches = source.split(options.oldText).length - 1;
+    if (matches === 0)
+      throw new Error("oldText was not found in the target file");
+    if (!options.replaceAll && matches > 1)
+      throw new Error("oldText matched more than once; set replaceAll to true to replace all matches");
+    const updated = options.replaceAll ? source.split(options.oldText).join(options.newText) : source.replace(options.oldText, options.newText);
+    await writeFile(resolved, updated, "utf8");
+    this.recordFile(resolved);
+    return {
+      path: resolved,
+      replacements: options.replaceAll ? matches : 1
+    };
+  }
+  async exists(targetPath, options = {}) {
+    try {
+      const resolved = resolvePath(this.cwd, targetPath, options.cwd);
+      await stat(resolved);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async glob(pattern, options = {}) {
+    const root = path2.resolve(options.cwd ?? this.cwd ?? process.cwd());
+    const matcher = compileGlob(pattern);
+    const limit = options.limit ?? 100;
+    const matches = [];
+    await walk(root, root, async (absolutePath, relativePath) => {
+      if (matches.length >= limit)
+        return false;
+      if (matcher.test(relativePath))
+        matches.push(absolutePath);
+      return true;
+    });
+    return matches;
+  }
+  async grep(query, options = {}) {
+    const pattern = options.pattern ?? "**/*";
+    const files = await this.glob(pattern, options);
+    const matches = [];
+    const limit = options.limit ?? 50;
+    for (const filePath of files) {
+      if (matches.length >= limit)
+        break;
+      let text;
+      try {
+        text = await readFile(filePath, "utf8");
+      } catch {
+        continue;
+      }
+      const lines = text.split(/\r?\n/g);
+      for (let index = 0;index < lines.length; index += 1) {
+        const line = lines[index];
+        if (!line || !line.includes(query))
+          continue;
+        matches.push({
+          path: filePath,
+          lineNumber: index + 1,
+          line
+        });
+        if (matches.length >= limit)
+          break;
+      }
+    }
+    return matches;
+  }
+  recordFile(filePath) {
+    this.tracker?.record({
+      type: "file",
+      label: filePath,
+      timestamp: Date.now()
+    });
+  }
+}
+function resolvePath(defaultCwd, targetPath, cwdOverride) {
+  if (!targetPath.trim())
+    throw new Error("path is required");
+  if (path2.isAbsolute(targetPath))
+    return path2.normalize(targetPath);
+  return path2.resolve(cwdOverride ?? defaultCwd ?? process.cwd(), targetPath);
+}
+function compileGlob(pattern) {
+  const normalized = pattern.replace(/\\/g, "/").replace(/^\.\//, "");
+  let expression = "^";
+  for (let index = 0;index < normalized.length; index += 1) {
+    const character = normalized[index];
+    const next = normalized[index + 1];
+    if (character === "*" && next === "*") {
+      expression += ".*";
+      index += 1;
+      continue;
+    }
+    if (character === "*") {
+      expression += "[^/]*";
+      continue;
+    }
+    expression += /[.+^${}()|[\]\\]/.test(character) ? `\\${character}` : character;
+  }
+  expression += "$";
+  return new RegExp(expression);
+}
+async function walk(root, current, visit) {
+  const entries = await readdir(current, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.name === "node_modules" || entry.name === ".git")
+      continue;
+    const absolutePath = path2.join(current, entry.name);
+    const relativePath = path2.relative(root, absolutePath).replace(/\\/g, "/");
+    if (entry.isDirectory()) {
+      const keepGoing = await visit(absolutePath, relativePath);
+      if (keepGoing !== false)
+        await walk(root, absolutePath, visit);
+      continue;
+    }
+    await visit(absolutePath, relativePath);
+  }
+}
+// src/services/GitGateway.ts
+class DefaultGitGateway {
+  exec;
+  cwd;
+  constructor(options) {
+    this.exec = options.exec;
+    this.cwd = options.cwd;
+  }
+  async status(options = {}) {
+    return this.runGitCommand("git status --short", options.cwd);
+  }
+  async diff(options = {}) {
+    return this.runGitCommand('git diff --stat && printf "\\n---\\n" && git diff -- .', options.cwd);
+  }
+  async runGitCommand(command, cwd) {
+    try {
+      const result = await this.exec.execute(command, { cwd: cwd ?? this.cwd, timeoutMs: 1e4 });
+      if (result.exitCode !== 0)
+        return null;
+      const text = [result.stdout, result.stderr].filter(Boolean).join(result.stdout && result.stderr ? `
+` : "");
+      return text.trim() || null;
+    } catch {
+      return null;
+    }
+  }
+}
+// src/services/ModelGateway.ts
+class DefaultModelGateway {
+  model;
+  constructor(model) {
+    this.model = model;
+  }
+  stream(request) {
+    return this.model.stream(request);
+  }
+}
+// src/services/NetworkGateway.ts
+class DefaultNetworkGateway {
+  fetchImpl;
+  constructor(fetchImpl = globalThis.fetch) {
+    this.fetchImpl = fetchImpl;
+  }
+  fetch(input, init) {
+    return this.fetchImpl(input, init);
+  }
+}
+// src/services/permissions.ts
+var fullPermissions = {
+  fs: "full",
+  git: true,
+  network: true,
+  process: true,
+  model: true,
+  mcp: true
+};
+
+class PermissionDeniedError extends Error {
+  code = "permission_denied";
+  constructor(message) {
+    super(message);
+    this.name = "PermissionDeniedError";
+  }
+}
+function normalizePermissions(input) {
+  return {
+    ...fullPermissions,
+    ...input
+  };
+}
+function canReadFs(permissions) {
+  return permissions.fs === true || permissions.fs === "read" || permissions.fs === "full";
+}
+function canWriteFs(permissions) {
+  return permissions.fs === true || permissions.fs === "write" || permissions.fs === "full";
+}
+// src/services/PermissionGateway.ts
+class PermissionGateway {
+  permissions;
+  constructor(options = {}) {
+    this.permissions = normalizePermissions(options.permissions);
+  }
+  get agentPermissions() {
+    return { ...this.permissions };
+  }
+  scopeServices(services, pluginId, requested) {
+    const effective = intersectPermissions(this.permissions, requested);
+    return {
+      fileSystem: {
+        readText: (path3, options) => {
+          if (!canReadFs(effective))
+            throw new PermissionDeniedError(`Plugin ${pluginId} is not allowed to read files`);
+          return services.fileSystem.readText(path3, options);
+        },
+        writeText: (path3, content, options) => {
+          if (!canWriteFs(effective))
+            throw new PermissionDeniedError(`Plugin ${pluginId} is not allowed to write files`);
+          return services.fileSystem.writeText(path3, content, options);
+        },
+        editText: (path3, options) => {
+          if (!canWriteFs(effective))
+            throw new PermissionDeniedError(`Plugin ${pluginId} is not allowed to edit files`);
+          return services.fileSystem.editText(path3, options);
+        },
+        exists: (path3, options) => {
+          if (!canReadFs(effective))
+            throw new PermissionDeniedError(`Plugin ${pluginId} is not allowed to inspect files`);
+          return services.fileSystem.exists(path3, options);
+        },
+        glob: (pattern, options) => {
+          if (!canReadFs(effective))
+            throw new PermissionDeniedError(`Plugin ${pluginId} is not allowed to glob files`);
+          return services.fileSystem.glob(pattern, options);
+        },
+        grep: (query, options) => {
+          if (!canReadFs(effective))
+            throw new PermissionDeniedError(`Plugin ${pluginId} is not allowed to grep files`);
+          return services.fileSystem.grep(query, options);
+        }
+      },
+      exec: {
+        execute: (command, options) => {
+          if (effective.process !== true)
+            throw new PermissionDeniedError(`Plugin ${pluginId} is not allowed to execute commands`);
+          return services.exec.execute(command, options);
+        }
+      },
+      git: {
+        status: (options) => {
+          if (effective.git !== true)
+            throw new PermissionDeniedError(`Plugin ${pluginId} is not allowed to inspect git state`);
+          return services.git.status(options);
+        },
+        diff: (options) => {
+          if (effective.git !== true)
+            throw new PermissionDeniedError(`Plugin ${pluginId} is not allowed to inspect git diff`);
+          return services.git.diff(options);
+        }
+      },
+      network: {
+        fetch: (input, init) => {
+          if (effective.network !== true)
+            throw new PermissionDeniedError(`Plugin ${pluginId} is not allowed to access the network`);
+          return services.network.fetch(input, init);
+        }
+      },
+      model: {
+        stream: (request) => {
+          if (effective.model !== true)
+            throw new PermissionDeniedError(`Plugin ${pluginId} is not allowed to call the model gateway`);
+          return services.model.stream(request);
+        }
+      }
+    };
+  }
+}
+function intersectPermissions(agent, requested) {
+  const normalized = requested ?? {};
+  return {
+    fs: intersectFs(agent.fs, normalized.fs ?? false),
+    git: agent.git === true && normalized.git === true,
+    network: agent.network === true && normalized.network === true,
+    process: agent.process === true && normalized.process === true,
+    model: agent.model === true && normalized.model === true,
+    mcp: agent.mcp === true && normalized.mcp === true
+  };
+}
+function intersectFs(left, right) {
+  const rank = new Map([
+    [false, 0],
+    ["read", 1],
+    ["write", 1],
+    [true, 2],
+    ["full", 2]
+  ]);
+  const leftValue = left ?? false;
+  const rightValue = right ?? false;
+  if (leftValue === "full" || leftValue === true)
+    return rightValue;
+  if (rightValue === "full" || rightValue === true)
+    return leftValue;
+  if (leftValue === rightValue)
+    return leftValue;
+  if (rank.get(leftValue) === 0 || rank.get(rightValue) === 0)
+    return false;
+  if (leftValue === "read" && rightValue === "write" || leftValue === "write" && rightValue === "read")
+    return false;
+  return leftValue;
+}
+// src/utils/json.ts
+function isJsonSafeValue(value) {
+  if (value === null)
+    return true;
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean")
+    return true;
+  if (Array.isArray(value))
+    return value.every(isJsonSafeValue);
+  if (isRecord(value))
+    return Object.values(value).every(isJsonSafeValue);
+  return false;
+}
+function assertJsonSafeObject(value, label) {
+  if (!isRecord(value) || !isJsonSafeValue(value))
+    throw new TypeError(`${label} must be a JSON-safe object`);
+}
+function parseJsonObject(value, label) {
+  let parsed;
+  try {
+    parsed = JSON.parse(value);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`${label} must be valid JSON: ${message}`);
+  }
+  if (!isRecord(parsed))
+    throw new Error(`${label} must decode to a JSON object`);
+  return parsed;
+}
+
+// src/contracts/tool-normalize.ts
+function normalizeToolSchema(schema) {
+  if (!isRecord(schema) || schema.type !== "object")
+    throw new TypeError('Tool input schema must have type "object"');
+  const properties = schema.properties;
+  if (properties !== undefined && !isRecord(properties))
+    throw new TypeError("Tool input schema properties must be an object");
+  const required = schema.required;
+  if (required !== undefined && !isStringArray(required))
+    throw new TypeError("Tool input schema required must be a string array");
+  const normalized = {
+    ...schema,
+    type: "object",
+    properties: properties ? cloneSchemaRecord(properties) : {}
+  };
+  return normalized;
+}
+function cloneSchemaRecord(record) {
+  return Object.fromEntries(Object.entries(record).map(([key, value]) => {
+    if (!isRecord(value))
+      throw new TypeError(`Tool schema property ${key} must be an object`);
+    return [key, { ...value }];
+  }));
+}
+function normalizeToolResult(result) {
+  const normalized = {
+    content: normalizeContent(result.content),
+    isError: result.isError === true
+  };
+  if (result.structuredContent !== undefined) {
+    assertJsonSafeObject(result.structuredContent, "Tool structuredContent");
+    normalized.structuredContent = { ...result.structuredContent };
+  }
+  return normalized;
+}
+
+// src/tools/BaseTool.ts
+class BaseTool {
+  definition;
+  constructor(definition) {
+    this.definition = {
+      ...definition,
+      inputSchema: normalizeToolSchema(definition.inputSchema)
+    };
+  }
+}
+// src/tools/result.ts
+function textToolResult(text) {
+  return {
+    content: normalizeContent(text)
+  };
+}
+// src/tools/ToolRegistry.ts
+class ToolRegistry {
+  tools = new Map;
+  register(tool) {
+    const name = tool.definition.name.trim();
+    if (!name)
+      throw new Error("Tool name is required");
+    if (this.tools.has(name))
+      throw new Error(`Tool already registered: ${name}`);
+    const normalizedDefinition = {
+      ...tool.definition,
+      name,
+      description: tool.definition.description.trim(),
+      inputSchema: normalizeToolSchema(tool.definition.inputSchema)
+    };
+    const normalizedTool = {
+      definition: normalizedDefinition,
+      execute(args, context) {
+        return tool.execute(args, context);
+      }
+    };
+    this.tools.set(name, normalizedTool);
+    return this;
+  }
+  unregister(name) {
+    return this.tools.delete(name);
+  }
+  get(name) {
+    return this.tools.get(name);
+  }
+  list() {
+    return [...this.tools.values()];
+  }
+  definitions() {
+    return this.list().map((tool) => ({
+      ...tool.definition,
+      inputSchema: normalizeToolSchema(tool.definition.inputSchema)
+    }));
+  }
+}
+// src/tools/builtins/utils.ts
+function readStringArg(args, key, options = {}) {
+  const value = args[key];
+  if (typeof value !== "string")
+    throw new Error(`${key} must be a string`);
+  if (!options.allowEmpty && value.length === 0)
+    throw new Error(`${key} must be a non-empty string`);
+  return value;
+}
+function readOptionalBooleanArg(args, key) {
+  const value = args[key];
+  if (value === undefined)
+    return;
+  if (typeof value !== "boolean")
+    throw new Error(`${key} must be a boolean`);
+  return value;
+}
+function readOptionalNumberArg(args, key) {
+  const value = args[key];
+  if (value === undefined)
+    return;
+  if (typeof value !== "number" || !Number.isFinite(value))
+    throw new Error(`${key} must be a finite number`);
+  return value;
+}
+
+// src/tools/builtins/EditTool.ts
+class EditTool extends BaseTool {
+  constructor() {
+    super({
+      name: "edit",
+      description: "Replace text in a UTF-8 file.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          path: { type: "string", description: "File path to edit." },
+          oldText: { type: "string", description: "Text to replace." },
+          newText: { type: "string", description: "Replacement text." },
+          replaceAll: { type: "boolean", description: "Replace all matches when true." }
+        },
+        required: ["path", "oldText", "newText"]
+      }
+    });
+  }
+  async execute(args, context) {
+    const fileSystem = context.services?.fileSystem;
+    if (!fileSystem)
+      throw new Error("FileSystemGateway is not available in the tool execution context");
+    const targetPath = readStringArg(args, "path");
+    const oldText = readStringArg(args, "oldText");
+    const newText = readStringArg(args, "newText", { allowEmpty: true });
+    const replaceAll = readOptionalBooleanArg(args, "replaceAll") ?? false;
+    const result = await fileSystem.editText(targetPath, {
+      oldText,
+      newText,
+      replaceAll,
+      cwd: context.cwd
+    });
+    return normalizeToolResult({
+      content: [{ type: "text", text: `Edited ${result.path}` }],
+      structuredContent: result
+    });
+  }
+}
+// src/tools/builtins/ExecTool.ts
+class ExecTool extends BaseTool {
+  constructor() {
+    super({
+      name: "exec",
+      description: "Execute a shell command.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          command: { type: "string", description: "Shell command to execute." },
+          cwd: { type: "string", description: "Optional working directory override." },
+          timeoutMs: { type: "number", description: "Optional timeout in milliseconds." }
+        },
+        required: ["command"]
+      }
+    });
+  }
+  async execute(args, context) {
+    const exec = context.services?.exec;
+    if (!exec)
+      throw new Error("ExecGateway is not available in the tool execution context");
+    const command = readStringArg(args, "command");
+    const cwd = typeof args.cwd === "string" && args.cwd.length > 0 ? args.cwd : context.cwd;
+    const timeoutMs = readOptionalNumberArg(args, "timeoutMs");
+    const result = await exec.execute(command, {
+      cwd,
+      timeoutMs,
+      signal: context.signal
+    });
+    const text = [result.stdout, result.stderr].filter(Boolean).join(result.stdout && result.stderr ? `
+` : "");
+    return normalizeToolResult({
+      content: [{ type: "text", text: text || `Command exited with code ${result.exitCode ?? -1}` }],
+      structuredContent: { ...result },
+      isError: result.exitCode !== 0
+    });
+  }
+}
+// src/tools/builtins/ReadTool.ts
+class ReadTool extends BaseTool {
+  constructor() {
+    super({
+      name: "read",
+      description: "Read a UTF-8 text file.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          path: { type: "string", description: "File path to read." }
+        },
+        required: ["path"]
+      }
+    });
+  }
+  async execute(args, context) {
+    const fileSystem = context.services?.fileSystem;
+    if (!fileSystem)
+      throw new Error("FileSystemGateway is not available in the tool execution context");
+    const targetPath = readStringArg(args, "path");
+    const text = await fileSystem.readText(targetPath, { cwd: context.cwd });
+    return normalizeToolResult({
+      content: [{ type: "text", text }],
+      structuredContent: {
+        path: targetPath,
+        size: Buffer.byteLength(text, "utf8")
+      }
+    });
+  }
+}
+// src/tools/builtins/WriteTool.ts
+class WriteTool extends BaseTool {
+  constructor() {
+    super({
+      name: "write",
+      description: "Write a UTF-8 text file.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          path: { type: "string", description: "File path to write." },
+          content: { type: "string", description: "Text content to write." }
+        },
+        required: ["path", "content"]
+      }
+    });
+  }
+  async execute(args, context) {
+    const fileSystem = context.services?.fileSystem;
+    if (!fileSystem)
+      throw new Error("FileSystemGateway is not available in the tool execution context");
+    const targetPath = readStringArg(args, "path");
+    const content = readStringArg(args, "content", { allowEmpty: true });
+    const result = await fileSystem.writeText(targetPath, content, { cwd: context.cwd });
+    return normalizeToolResult({
+      content: [{ type: "text", text: `Wrote ${result.path}` }],
+      structuredContent: result
+    });
+  }
+}
+// src/agent-core/MessageFactory.ts
+class DefaultMessageFactory {
+  createSystemMessage(input) {
+    return {
+      id: createId("msg"),
+      role: "system",
+      content: normalizeContent(input),
+      createdAt: Date.now()
+    };
+  }
+  createUserMessage(input) {
+    return {
+      id: createId("msg"),
+      role: "user",
+      content: normalizeContent(input),
+      createdAt: Date.now()
+    };
+  }
+  createAssistantMessage(input) {
+    return {
+      id: createId("msg"),
+      role: "assistant",
+      content: input.text.length > 0 ? normalizeContent(input.text) : [],
+      createdAt: Date.now(),
+      thinking: input.thinking,
+      toolCalls: input.toolCalls.length > 0 ? input.toolCalls : undefined,
+      stopReason: input.stopReason,
+      metadata: input.metadata
+    };
+  }
+  createToolMessage(toolCall, result) {
+    return {
+      id: createId("msg"),
+      role: "tool",
+      content: result.content,
+      createdAt: Date.now(),
+      toolCallId: toolCall.id,
+      toolName: toolCall.function.name,
+      structuredContent: result.structuredContent,
+      isError: result.isError
+    };
+  }
+}
+
+// src/persistence/SnapshotCodec.ts
+class JsonSnapshotCodec {
+  encode(input) {
+    return structuredClone({
+      schemaVersion: 1,
+      sessionId: input.sessionId,
+      model: input.model,
+      cwd: input.cwd,
+      messages: input.messages,
+      usage: input.usage,
+      createdAt: input.createdAt,
+      updatedAt: input.updatedAt,
+      metadata: input.metadata
+    });
+  }
+  decode(value) {
+    if (!value || typeof value !== "object")
+      throw new TypeError("Session snapshot must be an object");
+    const snapshot = value;
+    if (snapshot.schemaVersion !== 1)
+      throw new TypeError("Unsupported session snapshot schemaVersion");
+    if (typeof snapshot.sessionId !== "string")
+      throw new TypeError("Session snapshot sessionId is required");
+    if (!Array.isArray(snapshot.messages))
+      throw new TypeError("Session snapshot messages must be an array");
+    if (typeof snapshot.createdAt !== "number" || typeof snapshot.updatedAt !== "number")
+      throw new TypeError("Session snapshot timestamps are required");
+    return structuredClone(snapshot);
+  }
+}
+var sessionSnapshotCodec = new JsonSnapshotCodec;
+
+// src/utils/usage.ts
+function createEmptyUsage() {
+  return {
+    promptTokens: 0,
+    completionTokens: 0,
+    totalTokens: 0
+  };
+}
+function addUsage(left, right) {
+  if (!right)
+    return { ...left };
+  return {
+    promptTokens: left.promptTokens + right.promptTokens,
+    completionTokens: left.completionTokens + right.completionTokens,
+    totalTokens: left.totalTokens + right.totalTokens
+  };
+}
+
+// src/agent-core/tool-call.ts
+function startToolCall(callId, toolName) {
+  if (!callId.trim())
+    throw new Error("Tool call id is required");
+  if (!toolName.trim())
+    throw new Error("Tool name is required");
+  return {
+    callId,
+    toolName,
+    argsText: ""
+  };
+}
+function appendToolCallArgsDelta(draft, delta) {
+  return {
+    ...draft,
+    argsText: `${draft.argsText}${delta}`
+  };
+}
+function finalizeToolCall(draft) {
+  const rawArgumentsText = draft.argsText.trim();
+  const argumentsObject = rawArgumentsText.length === 0 ? {} : parseJsonObject(rawArgumentsText, `Tool call ${draft.callId} arguments`);
+  return {
+    id: draft.callId,
+    type: "function",
+    function: {
+      name: draft.toolName,
+      arguments: argumentsObject
+    },
+    rawArgumentsText
+  };
+}
+
+// src/agent-core/errors.ts
+class SessionExecutionError extends Error {
+  payload;
+  constructor(payload) {
+    super(payload.message);
+    this.name = "SessionExecutionError";
+    this.payload = payload;
+  }
+}
+
+// src/agent-core/ModelTurnCollector.ts
+class DefaultModelTurnCollector {
+  async* collect(options) {
+    const assistantTextParts = [];
+    const thinkingParts = [];
+    const toolCalls = [];
+    const drafts = new Map;
+    let stopReason = "final";
+    let responseUsage;
+    let assistantMetadata;
+    for await (const event of options.events) {
+      await options.onEvent?.(event);
+      if (event.type === "response_start")
+        continue;
+      if (event.type === "text_delta") {
+        assistantTextParts.push(event.delta);
+        yield { type: "text_delta", sessionId: options.sessionId, delta: event.delta };
+        continue;
+      }
+      if (event.type === "thinking_delta") {
+        thinkingParts.push(event.delta);
+        yield { type: "thinking_delta", sessionId: options.sessionId, delta: event.delta };
+        continue;
+      }
+      if (event.type === "tool_call_start") {
+        drafts.set(event.callId, startToolCall(event.callId, event.toolName));
+        continue;
+      }
+      if (event.type === "tool_call_args_delta") {
+        const draft = drafts.get(event.callId);
+        if (!draft) {
+          const payload2 = {
+            code: "tool_call_state_error",
+            message: `Received tool_call_args_delta before tool_call_start for ${event.callId}`,
+            requestId: options.requestId
+          };
+          yield { type: "error", sessionId: options.sessionId, error: payload2 };
+          throw new SessionExecutionError(payload2);
+        }
+        drafts.set(event.callId, appendToolCallArgsDelta(draft, event.delta));
+        continue;
+      }
+      if (event.type === "tool_call_end") {
+        const draft = drafts.get(event.callId);
+        if (!draft) {
+          const payload2 = {
+            code: "tool_call_state_error",
+            message: `Received tool_call_end before tool_call_start for ${event.callId}`,
+            requestId: options.requestId
+          };
+          yield { type: "error", sessionId: options.sessionId, error: payload2 };
+          throw new SessionExecutionError(payload2);
+        }
+        try {
+          toolCalls.push(finalizeToolCall(draft));
+        } catch (error) {
+          const payload2 = {
+            code: "tool_call_parse_error",
+            message: error instanceof Error ? error.message : String(error),
+            requestId: options.requestId
+          };
+          yield { type: "error", sessionId: options.sessionId, error: payload2 };
+          throw new SessionExecutionError(payload2);
+        }
+        continue;
+      }
+      if (event.type === "response_end") {
+        stopReason = event.stopReason;
+        responseUsage = event.usage;
+        assistantMetadata = event.assistantMetadata;
+        continue;
+      }
+      const payload = {
+        ...event.error,
+        requestId: options.requestId
+      };
+      yield { type: "error", sessionId: options.sessionId, error: payload };
+      throw new SessionExecutionError(payload);
+    }
+    return {
+      requestId: options.requestId,
+      text: assistantTextParts.join(""),
+      thinking: thinkingParts.join("") || undefined,
+      toolCalls,
+      stopReason,
+      usage: responseUsage,
+      assistantMetadata
+    };
+  }
+}
+
+// src/agent-core/session-state.ts
+function touchRuntimeSessionState(state) {
+  state.updatedAt = Date.now();
+}
+
+// src/agent-core/LoopRunner.ts
+class LoopRunner {
+  messageFactory;
+  turnCollector;
+  toolExecutor;
+  terminationPolicy;
+  contextManager;
+  pluginHost;
+  constructor(dependencies) {
+    this.messageFactory = dependencies.messageFactory;
+    this.turnCollector = dependencies.turnCollector;
+    this.toolExecutor = dependencies.toolExecutor;
+    this.terminationPolicy = dependencies.terminationPolicy;
+    this.contextManager = dependencies.contextManager;
+    this.pluginHost = dependencies.pluginHost;
+  }
+  async* run(state, input, options = {}) {
+    const startPayload = await this.pluginHost?.runMiddleware("session.start", {
+      sessionId: state.id,
+      input
+    }, {
+      sessionId: state.id,
+      cwd: state.cwd,
+      metadata: state.metadata
+    });
+    const initialInput = startPayload?.input ?? input;
+    const userMessage = this.messageFactory.createUserMessage(initialInput);
+    state.messages.push(userMessage);
+    touchRuntimeSessionState(state);
+    let lastRequestId;
+    try {
+      for (let iteration = 0;iteration < state.maxIterations; iteration += 1) {
+        const requestId = createId("req");
+        lastRequestId = requestId;
+        const turnStart = await this.pluginHost?.runMiddleware("turn.start", {
+          requestId,
+          iteration,
+          messages: [...state.messages]
+        }, {
+          sessionId: state.id,
+          requestId,
+          iteration,
+          cwd: state.cwd,
+          metadata: state.metadata
+        });
+        const contextItems = await this.contextManager.resolve({
+          sessionId: state.id,
+          input: initialInput,
+          messages: state.messages,
+          cwd: state.cwd
+        });
+        const resolvedContext = await this.pluginHost?.runMiddleware("context.resolve", {
+          contextItems,
+          input: initialInput,
+          messages: [...state.messages]
+        }, {
+          sessionId: state.id,
+          requestId,
+          iteration,
+          cwd: state.cwd,
+          metadata: state.metadata
+        });
+        const effectiveContext = resolvedContext?.contextItems ?? contextItems;
+        const pluginPromptSegments = await this.pluginHost?.collectPromptSegments({
+          sessionId: state.id,
+          input: initialInput,
+          messages: state.messages,
+          contextItems: effectiveContext,
+          cwd: state.cwd
+        }) ?? [];
+        const promptSegments = [
+          ...this.contextManager.format(effectiveContext),
+          ...pluginPromptSegments
+        ];
+        const resolvedPrompt = await this.pluginHost?.runMiddleware("prompt.resolve", {
+          promptSegments,
+          contextItems: effectiveContext,
+          messages: [...state.messages]
+        }, {
+          sessionId: state.id,
+          requestId,
+          iteration,
+          cwd: state.cwd,
+          metadata: state.metadata
+        });
+        const effectivePromptSegments = resolvedPrompt?.promptSegments ?? promptSegments;
+        const toolDefinitions = state.tools?.definitions() ?? [];
+        const resolvedToolset = await this.pluginHost?.runMiddleware("toolset.resolve", {
+          tools: toolDefinitions
+        }, {
+          sessionId: state.id,
+          requestId,
+          iteration,
+          cwd: state.cwd,
+          metadata: state.metadata
+        });
+        const effectiveTools = resolvedToolset?.tools ?? toolDefinitions;
+        const requestMessages = [...turnStart?.messages ?? state.messages];
+        if (effectivePromptSegments.length > 0)
+          requestMessages.unshift(this.messageFactory.createSystemMessage(effectivePromptSegments.join(`
+
+`)));
+        const request = {
+          requestId,
+          model: state.modelRef,
+          messages: requestMessages,
+          tools: effectiveTools,
+          reasoning: state.reasoning,
+          signal: options.signal
+        };
+        const resolvedRequest = await this.pluginHost?.runMiddleware("model.request", {
+          request
+        }, {
+          sessionId: state.id,
+          requestId,
+          iteration,
+          cwd: state.cwd,
+          metadata: state.metadata
+        });
+        const effectiveRequest = resolvedRequest?.request ?? request;
+        const turn = yield* this.turnCollector.collect({
+          sessionId: state.id,
+          requestId,
+          events: state.model.stream(effectiveRequest),
+          onEvent: async (event) => {
+            await this.pluginHost?.runObservers("model.event", { event }, {
+              sessionId: state.id,
+              requestId,
+              iteration,
+              cwd: state.cwd,
+              metadata: state.metadata
+            });
+          }
+        });
+        const assistantDraft = this.messageFactory.createAssistantMessage({
+          text: turn.text,
+          thinking: turn.thinking,
+          toolCalls: turn.toolCalls,
+          stopReason: turn.stopReason,
+          metadata: turn.assistantMetadata
+        });
+        const assistantPayload = await this.pluginHost?.runMiddleware("assistant.message", {
+          message: assistantDraft
+        }, {
+          sessionId: state.id,
+          requestId,
+          iteration,
+          cwd: state.cwd,
+          metadata: state.metadata
+        });
+        const assistantMessage = assistantPayload?.message ?? assistantDraft;
+        state.messages.push(assistantMessage);
+        state.usage = addUsage(state.usage, turn.usage);
+        touchRuntimeSessionState(state);
+        const baseDecision = this.terminationPolicy.afterAssistantTurn(turn.toolCalls);
+        const decisionPayload = await this.pluginHost?.runMiddleware("loop.decide", {
+          toolCalls: turn.toolCalls,
+          stopReason: turn.stopReason,
+          decision: baseDecision
+        }, {
+          sessionId: state.id,
+          requestId,
+          iteration,
+          cwd: state.cwd,
+          metadata: state.metadata
+        });
+        const decision = decisionPayload?.decision ?? baseDecision;
+        if (decision.type === "done") {
+          yield {
+            type: "done",
+            sessionId: state.id,
+            message: assistantMessage,
+            usage: { ...state.usage }
+          };
+          await this.pluginHost?.runObservers("session.end", { message: assistantMessage }, {
+            sessionId: state.id,
+            requestId,
+            iteration,
+            cwd: state.cwd,
+            metadata: state.metadata
+          });
+          await options.onDone?.(assistantMessage);
+          return assistantMessage;
+        }
+        for (const toolCall of turn.toolCalls) {
+          yield { type: "tool_call", sessionId: state.id, toolCall };
+          const result = await this.toolExecutor.execute(toolCall, {
+            signal: options.signal,
+            cwd: state.cwd
+          });
+          const toolMessage = this.messageFactory.createToolMessage(toolCall, result);
+          state.messages.push(toolMessage);
+          touchRuntimeSessionState(state);
+          yield { type: "tool_result", sessionId: state.id, toolCallId: toolCall.id, result };
+        }
+      }
+    } catch (error) {
+      if (error instanceof SessionExecutionError) {
+        await this.pluginHost?.runObservers("session.error", { error: error.payload }, {
+          sessionId: state.id,
+          requestId: lastRequestId,
+          cwd: state.cwd,
+          metadata: state.metadata
+        });
+      }
+      throw error;
+    }
+    const payload = this.terminationPolicy.onMaxIterationsExceeded(state.maxIterations, lastRequestId);
+    yield { type: "error", sessionId: state.id, error: payload };
+    await this.pluginHost?.runObservers("session.error", { error: payload }, {
+      sessionId: state.id,
+      requestId: lastRequestId,
+      cwd: state.cwd,
+      metadata: state.metadata
+    });
+    throw new SessionExecutionError(payload);
+  }
+}
+
+// src/agent-core/TerminationPolicy.ts
+class DefaultTerminationPolicy {
+  afterAssistantTurn(toolCalls) {
+    return toolCalls.length === 0 ? { type: "done" } : { type: "continue" };
+  }
+  onMaxIterationsExceeded(maxIterations, requestId) {
+    return {
+      code: "max_iterations_exceeded",
+      message: `Session exceeded maxIterations (${maxIterations})`,
+      requestId
+    };
+  }
+}
+
+// src/agent-core/ToolExecutor.ts
+class DefaultToolExecutor {
+  sessionId;
+  tools;
+  metadata;
+  services;
+  pluginHost;
+  constructor(options) {
+    this.sessionId = options.sessionId;
+    this.tools = options.tools;
+    this.metadata = options.metadata;
+    this.services = options.services;
+    this.pluginHost = options.pluginHost;
+  }
+  async execute(toolCall, options = {}) {
+    const before = await this.pluginHost?.runMiddleware("tool.beforeExecute", {
+      toolCall
+    }, {
+      sessionId: this.sessionId,
+      cwd: options.cwd,
+      services: this.services,
+      metadata: this.metadata
+    });
+    const currentToolCall = before?.toolCall ?? toolCall;
+    const tool = this.tools?.get(currentToolCall.function.name);
+    if (!tool)
+      return normalizeToolResult({ ...textToolResult(`Tool not found: ${currentToolCall.function.name}`), isError: true });
+    let result;
+    try {
+      result = normalizeToolResult(await tool.execute(currentToolCall.function.arguments, {
+        sessionId: this.sessionId,
+        cwd: options.cwd,
+        signal: options.signal,
+        metadata: this.metadata,
+        services: this.services
+      }));
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      result = normalizeToolResult({
+        ...textToolResult(message),
+        isError: true
+      });
+    }
+    const after = await this.pluginHost?.runMiddleware("tool.afterExecute", {
+      toolCall: currentToolCall,
+      result
+    }, {
+      sessionId: this.sessionId,
+      cwd: options.cwd,
+      services: this.services,
+      metadata: this.metadata
+    });
+    return normalizeToolResult(after?.result ?? result);
+  }
+}
+
+// src/agent-core/Session.ts
+class Session {
+  id;
+  createdAt;
+  stateStore;
+  state;
+  pluginHost;
+  contextManager;
+  services;
+  constructor(options) {
+    const now = Date.now();
+    this.id = options.id ?? createId("session");
+    this.createdAt = options.createdAt ?? now;
+    this.stateStore = options.stateStore;
+    this.pluginHost = options.pluginHost;
+    this.contextManager = options.contextManager;
+    this.services = options.services;
+    this.state = {
+      id: this.id,
+      model: options.model,
+      modelRef: options.modelRef ?? options.model.model,
+      tools: options.tools,
+      maxIterations: options.maxIterations ?? 8,
+      cwd: options.cwd,
+      metadata: options.metadata,
+      reasoning: options.reasoning,
+      messages: [...options.messages ?? []],
+      usage: options.usage ? { ...options.usage } : createEmptyUsage(),
+      createdAt: this.createdAt,
+      updatedAt: options.updatedAt ?? now
+    };
+  }
+  get messages() {
+    return [...this.state.messages];
+  }
+  get usage() {
+    return { ...this.state.usage };
+  }
+  get updatedAt() {
+    return this.state.updatedAt;
+  }
+  getCwd() {
+    return this.state.cwd;
+  }
+  setCwd(cwd) {
+    this.state.cwd = cwd;
+    touchRuntimeSessionState(this.state);
+  }
+  async save() {
+    if (!this.stateStore)
+      return;
+    let snapshot = this.toSnapshot();
+    if (this.pluginHost) {
+      const payload = await this.pluginHost.runMiddleware("snapshot.encode", { snapshot }, {
+        sessionId: this.id,
+        cwd: this.state.cwd,
+        metadata: this.state.metadata,
+        services: this.services
+      });
+      snapshot = payload.snapshot;
+    }
+    await this.stateStore.save(snapshot);
+  }
+  toSnapshot() {
+    return sessionSnapshotCodec.encode({
+      sessionId: this.id,
+      model: this.state.modelRef,
+      cwd: this.state.cwd,
+      messages: this.messages,
+      usage: this.usage,
+      createdAt: this.createdAt,
+      updatedAt: this.updatedAt,
+      metadata: this.state.metadata ? { ...this.state.metadata } : undefined
+    });
+  }
+  async send(input, options) {
+    const stream = this.stream(input, options);
+    let doneMessage;
+    while (true) {
+      const next = await stream.next();
+      if (next.done) {
+        doneMessage = next.value;
+        break;
+      }
+    }
+    if (!doneMessage)
+      throw new Error("Session completed without a final assistant message");
+    return doneMessage;
+  }
+  async* stream(input, options) {
+    const runner = this.createLoopRunner();
+    return yield* runner.run(this.state, input, {
+      signal: options?.signal,
+      onDone: async () => {
+        await this.save();
+      }
+    });
+  }
+  createLoopRunner() {
+    return new LoopRunner({
+      messageFactory: new DefaultMessageFactory,
+      turnCollector: new DefaultModelTurnCollector,
+      toolExecutor: new DefaultToolExecutor({
+        sessionId: this.id,
+        tools: this.state.tools,
+        metadata: this.state.metadata,
+        services: this.services,
+        pluginHost: this.pluginHost
+      }),
+      terminationPolicy: new DefaultTerminationPolicy,
+      contextManager: this.contextManager,
+      pluginHost: this.pluginHost
+    });
+  }
+}
+
+// src/agent-core/Agent.ts
+class Agent {
+  id;
+  pluginHost;
+  services;
+  tools;
+  permissions;
+  options;
+  messageFactory = new DefaultMessageFactory;
+  contextManager;
+  tracker;
+  permissionGateway;
+  constructor(options) {
+    this.id = createId("agent");
+    this.options = options;
+    this.permissions = options.permissions;
+    this.tracker = new ActivityTracker;
+    this.services = createServices(options, this.tracker);
+    this.permissionGateway = new PermissionGateway({ permissions: options.permissions });
+    this.pluginHost = new PluginHost({
+      agentId: this.id,
+      cwd: options.cwd,
+      plugins: options.plugins,
+      services: this.services,
+      permissionGateway: this.permissionGateway,
+      tracker: this.tracker
+    });
+    this.contextManager = options.contextManager ?? new AutoContextManager({
+      services: this.services,
+      pluginHost: this.pluginHost
+    });
+    this.tools = createToolRegistry({
+      includeBuiltinTools: options.includeBuiltinTools !== false,
+      tools: options.tools,
+      pluginTools: this.pluginHost.pluginTools()
+    });
+  }
+  async createSession(options = {}) {
+    const messages = options.messages ? [...options.messages] : [];
+    if (options.systemPrompt)
+      messages.unshift(this.messageFactory.createSystemMessage(options.systemPrompt));
+    return new Session({
+      id: options.sessionId ?? createId("session"),
+      model: this.options.model,
+      modelRef: this.options.model.model,
+      tools: this.tools,
+      stateStore: this.options.stateStore,
+      maxIterations: this.options.maxIterations,
+      cwd: options.cwd ?? this.options.cwd,
+      metadata: options.metadata ?? this.options.metadata,
+      reasoning: this.options.reasoning,
+      messages,
+      pluginHost: this.pluginHost,
+      contextManager: this.contextManager,
+      services: this.services
+    });
+  }
+  async restoreSession(sessionId) {
+    if (!this.options.stateStore)
+      return null;
+    const snapshot = await this.options.stateStore.load(sessionId);
+    if (!snapshot)
+      return null;
+    return this.sessionFromSnapshot(snapshot);
+  }
+  sessionFromSnapshot(snapshot) {
+    return new Session({
+      id: snapshot.sessionId,
+      model: this.options.model,
+      modelRef: snapshot.model ?? this.options.model.model,
+      tools: this.tools,
+      stateStore: this.options.stateStore,
+      maxIterations: this.options.maxIterations,
+      cwd: snapshot.cwd ?? this.options.cwd,
+      metadata: snapshot.metadata ?? this.options.metadata,
+      reasoning: this.options.reasoning,
+      messages: snapshot.messages,
+      usage: snapshot.usage,
+      createdAt: snapshot.createdAt,
+      updatedAt: snapshot.updatedAt,
+      pluginHost: this.pluginHost,
+      contextManager: this.contextManager,
+      services: this.services
+    });
+  }
+}
+function createAgent(options) {
+  return new Agent(options);
+}
+function createServices(options, tracker) {
+  const exec = new NodeExecGateway({ cwd: options.cwd, tracker });
+  return {
+    fileSystem: new NodeFileSystemGateway({ cwd: options.cwd, tracker }),
+    exec,
+    git: new DefaultGitGateway({ exec, cwd: options.cwd }),
+    network: new DefaultNetworkGateway,
+    model: new DefaultModelGateway(options.model)
+  };
+}
+function createToolRegistry(input) {
+  const registry = input.tools instanceof ToolRegistry ? cloneRegistry(input.tools) : new ToolRegistry;
+  if (input.includeBuiltinTools) {
+    safeRegister(registry, new ReadTool);
+    safeRegister(registry, new WriteTool);
+    safeRegister(registry, new EditTool);
+    safeRegister(registry, new ExecTool);
+  }
+  for (const tool of Array.isArray(input.tools) ? input.tools : [])
+    safeRegister(registry, tool);
+  for (const tool of input.pluginTools)
+    safeRegister(registry, tool);
+  return registry;
+}
+function cloneRegistry(source) {
+  const registry = new ToolRegistry;
+  for (const tool of source.list())
+    registry.register(tool);
+  return registry;
+}
+function safeRegister(registry, tool) {
+  if (!registry.get(tool.definition.name))
+    registry.register(tool);
+}
+// src/persistence/FileStateStore.ts
+import { mkdir as mkdir2, readFile as readFile2, readdir as readdir2, rm, writeFile as writeFile2 } from "node:fs/promises";
+import path3 from "node:path";
+class FileStateStore {
+  directory;
+  constructor(options) {
+    this.directory = path3.resolve(options.directory);
+  }
+  async save(snapshot) {
+    const validated = sessionSnapshotCodec.decode(snapshot);
+    await mkdir2(this.directory, { recursive: true });
+    await writeFile2(this.filePath(validated.sessionId), JSON.stringify(validated, null, 2), "utf8");
+  }
+  async load(sessionId) {
+    try {
+      const raw = await readFile2(this.filePath(sessionId), "utf8");
+      return sessionSnapshotCodec.decode(JSON.parse(raw));
+    } catch (error) {
+      if (error.code === "ENOENT")
+        return null;
+      throw error;
+    }
+  }
+  async delete(sessionId) {
+    await rm(this.filePath(sessionId), { force: true });
+  }
+  async list() {
+    await mkdir2(this.directory, { recursive: true });
+    const entries = (await readdir2(this.directory)).sort();
+    const snapshots = [];
+    for (const entry of entries) {
+      if (!entry.endsWith(".json"))
+        continue;
+      const raw = await readFile2(path3.join(this.directory, entry), "utf8");
+      snapshots.push(sessionSnapshotCodec.decode(JSON.parse(raw)));
+    }
+    return snapshots;
+  }
+  filePath(sessionId) {
+    return path3.join(this.directory, `${encodeURIComponent(sessionId)}.json`);
+  }
+}
+// src/persistence/InMemoryStateStore.ts
+class InMemoryStateStore {
+  snapshots = new Map;
+  async save(snapshot) {
+    const validated = sessionSnapshotCodec.decode(snapshot);
+    this.snapshots.set(validated.sessionId, validated);
+  }
+  async load(sessionId) {
+    const snapshot = this.snapshots.get(sessionId);
+    return snapshot ? sessionSnapshotCodec.decode(snapshot) : null;
+  }
+  async delete(sessionId) {
+    this.snapshots.delete(sessionId);
+  }
+  async list() {
+    return [...this.snapshots.values()].map((snapshot) => sessionSnapshotCodec.decode(snapshot));
+  }
+}
+// src/providers/shared/http-error.ts
+var MAX_TEXT_CHARS = 4000;
+var MAX_JSON_DEPTH = 4;
+var MAX_JSON_ARRAY_ITEMS = 20;
+var MAX_JSON_OBJECT_KEYS = 40;
+var TRUNCATED_SUFFIX = "...[truncated]";
+async function createHttpErrorPayload(input) {
+  const responseBody = await readErrorResponseBody(input.response);
+  return {
+    code: input.code,
+    message: `${input.provider} request failed with status ${input.response.status}`,
+    status: input.response.status,
+    details: {
+      provider: input.provider,
+      endpoint: input.endpoint,
+      statusText: input.response.statusText,
+      ...responseBody === undefined ? {} : { responseBody }
+    }
+  };
+}
+async function readErrorResponseBody(response) {
+  let text = "";
+  try {
+    text = await response.text();
+  } catch {
+    return;
+  }
+  const normalized = text.trim();
+  if (!normalized)
+    return;
+  try {
+    return limitJsonValue(JSON.parse(normalized));
+  } catch {
+    return truncateText(normalized);
+  }
+}
+function limitJsonValue(value, depth = 0) {
+  if (value === null || typeof value === "boolean" || typeof value === "number")
+    return value;
+  if (typeof value === "string")
+    return truncateText(value);
+  if (Array.isArray(value))
+    return value.slice(0, MAX_JSON_ARRAY_ITEMS).map((item) => limitJsonValue(item, depth + 1));
+  if (typeof value === "object") {
+    if (depth >= MAX_JSON_DEPTH)
+      return truncateText(JSON.stringify(value));
+    const limited = {};
+    for (const [key, child] of Object.entries(value).slice(0, MAX_JSON_OBJECT_KEYS))
+      limited[key] = limitJsonValue(child, depth + 1);
+    return limited;
+  }
+  return truncateText(String(value));
+}
+function truncateText(value) {
+  if (value.length <= MAX_TEXT_CHARS)
+    return value;
+  return `${value.slice(0, MAX_TEXT_CHARS)}${TRUNCATED_SUFFIX}`;
+}
+
+// src/providers/shared/provider-state.ts
+var PROVIDER_STATE_METADATA_KEY = "_dimProviderState";
+function attachProviderState(metadata, provider, state) {
+  if (!state || Object.keys(state).length === 0)
+    return metadata;
+  const nextMetadata = metadata ? structuredClone(metadata) : {};
+  const currentBag = isRecord2(nextMetadata[PROVIDER_STATE_METADATA_KEY]) ? nextMetadata[PROVIDER_STATE_METADATA_KEY] : {};
+  nextMetadata[PROVIDER_STATE_METADATA_KEY] = {
+    ...currentBag,
+    [provider]: structuredClone(state)
+  };
+  return nextMetadata;
+}
+function readProviderState(message, provider) {
+  if (message.role !== "assistant" || !isRecord2(message.metadata))
+    return;
+  const bag = message.metadata[PROVIDER_STATE_METADATA_KEY];
+  if (!isRecord2(bag))
+    return;
+  const state = bag[provider];
+  return isRecord2(state) ? structuredClone(state) : undefined;
+}
+function isRecord2(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+// src/providers/shared/reasoning.ts
+function isRecord3(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeReasoningConfig(reasoning) {
+  if (!isRecord3(reasoning))
+    return;
+  if (reasoning.enabled === false)
+    return;
+  return reasoning;
+}
+function resolveReasoningBudget(reasoning, fallback = 1024) {
+  const normalized = normalizeReasoningConfig(reasoning);
+  if (!normalized)
+    return;
+  for (const key of ["budgetTokens", "budget_tokens", "thinkingBudget"]) {
+    const value = normalized[key];
+    if (typeof value === "number" && Number.isFinite(value) && value > 0)
+      return Math.floor(value);
+  }
+  return fallback;
+}
+function buildOpenAIResponsesReasoning(reasoning) {
+  const normalized = normalizeReasoningConfig(reasoning);
+  if (!normalized)
+    return;
+  const next = {};
+  for (const [key, value] of Object.entries(normalized)) {
+    if (key === "enabled" || key === "budgetTokens" || key === "budget_tokens" || key === "thinkingBudget" || key === "includeThoughts")
+      continue;
+    next[key] = value;
+  }
+  if (next.summary === undefined)
+    next.summary = "auto";
+  return next;
+}
+function buildAnthropicThinking(reasoning) {
+  const budget = resolveReasoningBudget(reasoning);
+  if (!budget)
+    return { maxTokens: undefined, thinking: undefined };
+  return {
+    maxTokens: Math.max(budget + 1, budget * 2),
+    thinking: {
+      type: "enabled",
+      budget_tokens: budget
+    }
+  };
+}
+function buildGeminiThinkingConfig(reasoning) {
+  const normalized = normalizeReasoningConfig(reasoning);
+  if (!normalized)
+    return;
+  return {
+    thinkingBudget: resolveReasoningBudget(normalized) ?? 1024,
+    includeThoughts: normalized.includeThoughts !== false
+  };
+}
+
+// src/providers/shared/usage.ts
+function normalizeUsage(raw) {
+  if (!raw || typeof raw !== "object")
+    return;
+  const usage = raw;
+  const promptTokens = numberOrZero(usage.prompt_tokens ?? usage.input_tokens ?? usage.promptTokenCount);
+  const completionTokens = numberOrZero(usage.completion_tokens ?? usage.output_tokens ?? usage.candidatesTokenCount);
+  const totalTokens = numberOrZero(usage.total_tokens ?? usage.totalTokenCount) || promptTokens + completionTokens;
+  if (promptTokens === 0 && completionTokens === 0 && totalTokens === 0)
+    return;
+  return {
+    promptTokens,
+    completionTokens,
+    totalTokens
+  };
+}
+function numberOrZero(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+
+// src/providers/anthropic/mapper.ts
+var ANTHROPIC_STATE_KEY = "anthropic";
+function mapToolDefinitionsToAnthropic(tools) {
+  if (!tools || tools.length === 0)
+    return;
+  return tools.map((tool) => ({
+    name: tool.name,
+    description: tool.description,
+    input_schema: tool.inputSchema
+  }));
+}
+function mapAnthropicStopReason(reason, toolCallCount) {
+  if (toolCallCount > 0 || reason === "tool_use")
+    return "tool_call";
+  if (reason === "max_tokens")
+    return "length";
+  if (reason === "cancelled")
+    return "cancelled";
+  if (reason === "error")
+    return "error";
+  return "final";
+}
+function messagesToAnthropic(messages) {
+  const systemChunks = [];
+  const converted = [];
+  for (const message of messages) {
+    if (message.role === "system") {
+      const text = contentToText(message.content);
+      if (text)
+        systemChunks.push(text);
+      continue;
+    }
+    if (message.role === "tool") {
+      converted.push({
+        role: "user",
+        content: [{
+          type: "tool_result",
+          tool_use_id: message.toolCallId,
+          content: contentToText(message.content),
+          is_error: message.isError === true
+        }]
+      });
+      continue;
+    }
+    if (message.role === "assistant") {
+      const blocks = [
+        ...restoreAnthropicThinkingBlocks(message),
+        ...message.content.map((block) => block.type === "text" ? { type: "text", text: block.text } : { type: "image", source: { type: "base64", media_type: block.mimeType, data: block.data } })
+      ];
+      for (const toolCall of message.toolCalls ?? []) {
+        blocks.push({
+          type: "tool_use",
+          id: toolCall.id,
+          name: toolCall.function.name,
+          input: toolCall.function.arguments
+        });
+      }
+      converted.push({ role: "assistant", content: blocks });
+      continue;
+    }
+    converted.push({
+      role: "user",
+      content: message.content.map((block) => block.type === "text" ? { type: "text", text: block.text } : { type: "image", source: { type: "base64", media_type: block.mimeType, data: block.data } })
+    });
+  }
+  return {
+    system: systemChunks.length > 0 ? systemChunks.join(`
+
+`) : undefined,
+    messages: converted
+  };
+}
+function normalizeAnthropicToolCalls(value) {
+  if (!value)
+    return [];
+  const calls = [];
+  for (const block of value) {
+    if (block.type !== "tool_use" || typeof block.id !== "string" || typeof block.name !== "string")
+      continue;
+    calls.push({
+      id: block.id,
+      name: block.name,
+      argsText: JSON.stringify(block.input ?? {})
+    });
+  }
+  return calls;
+}
+function extractAnthropicThinking(value) {
+  if (!value)
+    return [];
+  return value.filter((block) => block.type === "thinking").map((block) => block.thinking).filter((value2) => typeof value2 === "string" && value2.length > 0);
+}
+function createAnthropicThinkingState(value) {
+  if (!value)
+    return;
+  const blocks = value.filter((block) => block.type === "thinking" || block.type === "redacted_thinking").map((block) => {
+    if (block.type === "thinking")
+      return { type: "thinking", thinking: block.thinking, signature: block.signature };
+    return { type: "redacted_thinking", data: block.data };
+  }).filter((block) => block.type === "thinking" && typeof block.signature === "string" || block.type === "redacted_thinking" && typeof block.data === "string");
+  if (blocks.length === 0)
+    return;
+  return { blocks };
+}
+function restoreAnthropicThinkingBlocks(message) {
+  const state = readProviderState(message, ANTHROPIC_STATE_KEY);
+  const rawBlocks = state?.blocks;
+  if (!Array.isArray(rawBlocks))
+    return [];
+  const blocks = [];
+  for (const rawBlock of rawBlocks) {
+    if (!isRecord4(rawBlock) || typeof rawBlock.type !== "string")
+      continue;
+    if (rawBlock.type === "thinking" && typeof rawBlock.signature === "string") {
+      blocks.push({
+        type: "thinking",
+        thinking: typeof rawBlock.thinking === "string" ? rawBlock.thinking : undefined,
+        signature: rawBlock.signature
+      });
+      continue;
+    }
+    if (rawBlock.type === "redacted_thinking" && typeof rawBlock.data === "string") {
+      blocks.push({
+        type: "redacted_thinking",
+        data: rawBlock.data
+      });
+    }
+  }
+  return blocks;
+}
+function isRecord4(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+// src/providers/anthropic/adapter.ts
+function createAnthropicAdapter(options) {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const provider = options.provider ?? "anthropic";
+  const defaultModel = { provider, modelId: options.defaultModel };
+  const baseUrl = (options.baseUrl ?? "https://api.anthropic.com").replace(/\/$/, "");
+  const anthropicVersion = options.anthropicVersion ?? "2023-06-01";
+  return {
+    provider,
+    defaultModel,
+    async* stream(request) {
+      const requestId = request.requestId ?? crypto.randomUUID();
+      yield { type: "response_start", requestId, model: request.model };
+      const { system, messages } = messagesToAnthropic(request.messages);
+      const thinkingConfig = buildAnthropicThinking(request.reasoning);
+      const maxTokens = Math.max(request.maxOutputTokens ?? 1024, thinkingConfig.maxTokens ?? 0);
+      let response;
+      try {
+        response = await fetchImpl(`${baseUrl}/v1/messages`, {
+          method: "POST",
+          headers: {
+            "content-type": "application/json",
+            "anthropic-version": anthropicVersion,
+            ...options.apiKey ? { "x-api-key": options.apiKey } : {},
+            ...options.headers
+          },
+          body: JSON.stringify({
+            model: request.model.modelId,
+            system,
+            messages,
+            tools: mapToolDefinitionsToAnthropic(request.tools),
+            max_tokens: maxTokens,
+            temperature: request.temperature,
+            top_p: request.topP,
+            thinking: thinkingConfig.thinking
+          }),
+          signal: request.signal
+        });
+      } catch (error) {
+        yield { type: "error", requestId, error: toModelErrorPayload(error), terminal: true };
+        return;
+      }
+      if (!response.ok) {
+        yield {
+          type: "error",
+          requestId,
+          error: await createHttpErrorPayload({
+            code: "anthropic_http_error",
+            provider: "Anthropic",
+            endpoint: `${baseUrl}/v1/messages`,
+            response
+          }),
+          terminal: true
+        };
+        return;
+      }
+      const data = await response.json();
+      for (const delta of extractAnthropicThinking(data.content))
+        yield { type: "thinking_delta", requestId, delta };
+      for (const block of data.content ?? []) {
+        if (block.type === "text" && block.text)
+          yield { type: "text_delta", requestId, delta: block.text };
+      }
+      const toolCalls = normalizeAnthropicToolCalls(data.content);
+      for (const toolCall of toolCalls) {
+        yield { type: "tool_call_start", requestId, callId: toolCall.id, toolName: toolCall.name };
+        yield { type: "tool_call_args_delta", requestId, callId: toolCall.id, delta: toolCall.argsText };
+        yield { type: "tool_call_end", requestId, callId: toolCall.id };
+      }
+      yield {
+        type: "response_end",
+        requestId,
+        stopReason: mapAnthropicStopReason(data.stop_reason, toolCalls.length),
+        usage: normalizeUsage(data.usage),
+        assistantMetadata: attachProviderState(undefined, "anthropic", createAnthropicThinkingState(data.content))
+      };
+    }
+  };
+}
+function toModelErrorPayload(error) {
+  if (error instanceof Error) {
+    return {
+      code: "anthropic_request_error",
+      message: error.message
+    };
+  }
+  return {
+    code: "anthropic_request_error",
+    message: String(error)
+  };
+}
+// src/providers/gemini/mapper.ts
+var GEMINI_STATE_KEY = "gemini";
+function mapToolDefinitionsToGemini(tools) {
+  if (!tools || tools.length === 0)
+    return {};
+  return {
+    tools: [{
+      functionDeclarations: tools.map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        parametersJsonSchema: tool.inputSchema
+      }))
+    }],
+    toolConfig: {
+      functionCallingConfig: {
+        mode: "AUTO"
+      }
+    }
+  };
+}
+function mapGeminiStopReason(reason, toolCallCount) {
+  if (toolCallCount > 0 || reason === "STOPFUNCTIONCALL" || reason === "function_call")
+    return "tool_call";
+  if (reason === "MAX_TOKENS")
+    return "length";
+  if (reason === "CANCELLED")
+    return "cancelled";
+  if (reason === "SAFETY" || reason === "RECITATION" || reason === "ERROR")
+    return "error";
+  return "final";
+}
+function messagesToGemini(messages) {
+  const systemChunks = [];
+  const contents = [];
+  for (const message of messages) {
+    if (message.role === "system") {
+      const text = contentToText(message.content);
+      if (text)
+        systemChunks.push(text);
+      continue;
+    }
+    if (message.role === "tool") {
+      contents.push({
+        role: "user",
+        parts: [{
+          functionResponse: {
+            name: message.toolName,
+            response: message.structuredContent ?? {
+              content: contentToText(message.content),
+              isError: message.isError === true
+            }
+          }
+        }]
+      });
+      continue;
+    }
+    const parts = [];
+    if (message.role === "assistant")
+      parts.push(...restoreGeminiThoughtParts(message));
+    for (const block of message.content) {
+      if (block.type === "text")
+        parts.push({ text: block.text });
+      else
+        parts.push({ inlineData: { mimeType: block.mimeType, data: block.data } });
+    }
+    if (message.role === "assistant") {
+      for (const toolCall of message.toolCalls ?? []) {
+        parts.push({
+          functionCall: {
+            name: toolCall.function.name,
+            args: toolCall.function.arguments
+          }
+        });
+      }
+    }
+    contents.push({
+      role: message.role === "assistant" ? "model" : "user",
+      parts
+    });
+  }
+  return {
+    contents,
+    systemInstruction: systemChunks.length > 0 ? { parts: systemChunks.map((text) => ({ text })) } : undefined
+  };
+}
+function normalizeGeminiToolCalls(value) {
+  if (!value)
+    return [];
+  const calls = [];
+  for (const part of value) {
+    if (!("functionCall" in part) || typeof part.functionCall?.name !== "string")
+      continue;
+    calls.push({
+      id: crypto.randomUUID(),
+      name: String(part.functionCall.name),
+      argsText: JSON.stringify(part.functionCall.args ?? {})
+    });
+  }
+  return calls;
+}
+function extractGeminiThinking(value) {
+  if (!value)
+    return [];
+  const deltas = [];
+  for (const part of value) {
+    if ("text" in part && part.thought === true && typeof part.text === "string" && part.text.length > 0)
+      deltas.push(part.text);
+  }
+  return deltas;
+}
+function createGeminiThoughtState(value) {
+  if (!value)
+    return;
+  const parts = value.filter((part) => part.thought === true || typeof part.thoughtSignature === "string").map((part) => {
+    if ("functionCall" in part) {
+      return {
+        functionCall: part.functionCall,
+        thought: part.thought === true,
+        thoughtSignature: part.thoughtSignature
+      };
+    }
+    return {
+      text: "text" in part ? part.text : undefined,
+      thought: part.thought === true,
+      thoughtSignature: part.thoughtSignature
+    };
+  });
+  if (parts.length === 0)
+    return;
+  return { parts };
+}
+function restoreGeminiThoughtParts(message) {
+  const state = readProviderState(message, GEMINI_STATE_KEY);
+  const rawParts = state?.parts;
+  if (!Array.isArray(rawParts))
+    return [];
+  const parts = [];
+  for (const rawPart of rawParts) {
+    if (!isRecord5(rawPart))
+      continue;
+    const thought = rawPart.thought === true;
+    const thoughtSignature = typeof rawPart.thoughtSignature === "string" ? rawPart.thoughtSignature : undefined;
+    if (isRecord5(rawPart.functionCall) && typeof rawPart.functionCall.name === "string") {
+      parts.push({
+        functionCall: {
+          name: rawPart.functionCall.name,
+          args: isRecord5(rawPart.functionCall.args) ? rawPart.functionCall.args : {}
+        },
+        thought,
+        thoughtSignature
+      });
+      continue;
+    }
+    if (typeof rawPart.text === "string" || thoughtSignature) {
+      parts.push({
+        text: typeof rawPart.text === "string" ? rawPart.text : undefined,
+        thought,
+        thoughtSignature
+      });
+    }
+  }
+  return parts;
+}
+function isRecord5(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+// src/providers/gemini/adapter.ts
+function createGeminiAdapter(options) {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const provider = options.provider ?? "gemini";
+  const defaultModel = { provider, modelId: options.defaultModel };
+  const baseUrl = (options.baseUrl ?? "https://generativelanguage.googleapis.com").replace(/\/$/, "");
+  return {
+    provider,
+    defaultModel,
+    async* stream(request) {
+      const requestId = request.requestId ?? crypto.randomUUID();
+      yield { type: "response_start", requestId, model: request.model };
+      const { contents, systemInstruction } = messagesToGemini(request.messages);
+      const { tools, toolConfig } = mapToolDefinitionsToGemini(request.tools);
+      const thinkingConfig = buildGeminiThinkingConfig(request.reasoning);
+      const searchParams = new URLSearchParams;
+      if (options.apiKey)
+        searchParams.set("key", options.apiKey);
+      const url = `${baseUrl}/v1beta/models/${encodeURIComponent(request.model.modelId)}:generateContent${searchParams.toString() ? `?${searchParams}` : ""}`;
+      let response;
+      try {
+        response = await fetchImpl(url, {
+          method: "POST",
+          headers: {
+            "content-type": "application/json",
+            ...options.headers
+          },
+          body: JSON.stringify({
+            contents,
+            systemInstruction,
+            tools,
+            toolConfig,
+            generationConfig: {
+              temperature: request.temperature,
+              topP: request.topP,
+              maxOutputTokens: request.maxOutputTokens,
+              stopSequences: request.stop,
+              thinkingConfig
+            }
+          }),
+          signal: request.signal
+        });
+      } catch (error) {
+        yield { type: "error", requestId, error: toModelErrorPayload2(error), terminal: true };
+        return;
+      }
+      if (!response.ok) {
+        yield {
+          type: "error",
+          requestId,
+          error: await createHttpErrorPayload({
+            code: "gemini_http_error",
+            provider: "Gemini",
+            endpoint: url,
+            response
+          }),
+          terminal: true
+        };
+        return;
+      }
+      const data = await response.json();
+      const candidate = data.candidates?.[0];
+      for (const delta of extractGeminiThinking(candidate?.content?.parts))
+        yield { type: "thinking_delta", requestId, delta };
+      for (const part of candidate?.content?.parts ?? []) {
+        if ("text" in part && part.thought !== true && typeof part.text === "string" && part.text.length > 0)
+          yield { type: "text_delta", requestId, delta: part.text };
+      }
+      const toolCalls = normalizeGeminiToolCalls(candidate?.content?.parts);
+      for (const toolCall of toolCalls) {
+        yield { type: "tool_call_start", requestId, callId: toolCall.id, toolName: toolCall.name };
+        yield { type: "tool_call_args_delta", requestId, callId: toolCall.id, delta: toolCall.argsText };
+        yield { type: "tool_call_end", requestId, callId: toolCall.id };
+      }
+      yield {
+        type: "response_end",
+        requestId,
+        stopReason: mapGeminiStopReason(candidate?.finishReason, toolCalls.length),
+        usage: normalizeUsage(data.usageMetadata),
+        assistantMetadata: attachProviderState(undefined, "gemini", createGeminiThoughtState(candidate?.content?.parts))
+      };
+    }
+  };
+}
+function toModelErrorPayload2(error) {
+  if (error instanceof Error) {
+    return {
+      code: "gemini_request_error",
+      message: error.message
+    };
+  }
+  return {
+    code: "gemini_request_error",
+    message: String(error)
+  };
+}
+// src/providers/openai/mapper.ts
+function mapToolDefinitionsToOpenAI(tools) {
+  if (!tools || tools.length === 0)
+    return;
+  return tools.map((tool) => ({
+    type: "function",
+    function: {
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.inputSchema
+    }
+  }));
+}
+function mapOpenAIStopReason(reason, toolCallCount) {
+  if (toolCallCount > 0 || reason === "tool_calls")
+    return "tool_call";
+  if (reason === "length")
+    return "length";
+  if (reason === "content_filter" || reason === "error")
+    return "error";
+  if (reason === "cancelled")
+    return "cancelled";
+  return "final";
+}
+function messageContentToOpenAI(content) {
+  const hasImage = content.some((block) => block.type === "image");
+  if (!hasImage)
+    return contentToText(content);
+  return content.map((block) => mapContentBlockToOpenAIPart(block));
+}
+function mapContentBlockToOpenAIPart(block) {
+  if (block.type === "text")
+    return { type: "text", text: block.text };
+  return {
+    type: "image_url",
+    image_url: {
+      url: imageDataUrl(block)
+    }
+  };
+}
+function imageDataUrl(block) {
+  return `data:${block.mimeType};base64,${block.data}`;
+}
+function messagesToOpenAI(messages) {
+  return messages.map((message) => {
+    if (message.role === "tool") {
+      return {
+        role: "tool",
+        tool_call_id: message.toolCallId,
+        content: message.content.length > 0 ? contentToText(message.content) : JSON.stringify(message.structuredContent ?? {})
+      };
+    }
+    if (message.role === "assistant") {
+      return {
+        role: "assistant",
+        content: contentToText(message.content),
+        tool_calls: message.toolCalls?.map((toolCall) => ({
+          id: toolCall.id,
+          type: "function",
+          function: {
+            name: toolCall.function.name,
+            arguments: JSON.stringify(toolCall.function.arguments)
+          }
+        }))
+      };
+    }
+    return {
+      role: message.role,
+      content: messageContentToOpenAI(message.content),
+      ...message.role === "user" && message.name ? { name: message.name } : {}
+    };
+  });
+}
+function normalizeOpenAIToolCalls(value) {
+  if (!value)
+    return [];
+  const calls = [];
+  for (const call of value) {
+    if (typeof call?.id !== "string" || typeof call.function?.name !== "string")
+      continue;
+    calls.push({
+      id: call.id,
+      name: call.function.name,
+      argsText: typeof call.function.arguments === "string" ? call.function.arguments : "{}"
+    });
+  }
+  return calls;
+}
+
+// src/providers/openai/adapter.ts
+function createOpenAIAdapter(options) {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const provider = options.provider ?? "openai-compatible";
+  const defaultModel = { provider, modelId: options.defaultModel };
+  const baseUrl = (options.baseUrl ?? "https://api.openai.com/v1").replace(/\/$/, "");
+  return {
+    provider,
+    defaultModel,
+    async* stream(request) {
+      const requestId = request.requestId ?? crypto.randomUUID();
+      yield { type: "response_start", requestId, model: request.model };
+      let response;
+      try {
+        response = await fetchImpl(`${baseUrl}/chat/completions`, {
+          method: "POST",
+          headers: {
+            "content-type": "application/json",
+            ...options.apiKey ? { authorization: `Bearer ${options.apiKey}` } : {},
+            ...options.headers
+          },
+          body: JSON.stringify({
+            model: request.model.modelId,
+            messages: messagesToOpenAI(request.messages),
+            tools: mapToolDefinitionsToOpenAI(request.tools),
+            max_tokens: request.maxOutputTokens,
+            temperature: request.temperature,
+            top_p: request.topP,
+            stop: request.stop,
+            stream: false
+          }),
+          signal: request.signal
+        });
+      } catch (error) {
+        yield { type: "error", requestId, error: toModelErrorPayload3(error), terminal: true };
+        return;
+      }
+      if (!response.ok) {
+        yield {
+          type: "error",
+          requestId,
+          error: await createHttpErrorPayload({
+            code: "openai_http_error",
+            provider: "OpenAI-compatible",
+            endpoint: `${baseUrl}/chat/completions`,
+            response
+          }),
+          terminal: true
+        };
+        return;
+      }
+      const data = await response.json();
+      const choice = data.choices?.[0];
+      const text = choice?.message?.content ?? "";
+      if (text)
+        yield { type: "text_delta", requestId, delta: text };
+      const toolCalls = normalizeOpenAIToolCalls(choice?.message?.tool_calls);
+      for (const toolCall of toolCalls) {
+        yield { type: "tool_call_start", requestId, callId: toolCall.id, toolName: toolCall.name };
+        yield { type: "tool_call_args_delta", requestId, callId: toolCall.id, delta: toolCall.argsText };
+        yield { type: "tool_call_end", requestId, callId: toolCall.id };
+      }
+      yield {
+        type: "response_end",
+        requestId,
+        stopReason: mapOpenAIStopReason(choice?.finish_reason, toolCalls.length),
+        usage: normalizeUsage(data.usage)
+      };
+    }
+  };
+}
+function toModelErrorPayload3(error) {
+  if (error instanceof Error) {
+    return {
+      code: "openai_request_error",
+      message: error.message
+    };
+  }
+  return {
+    code: "openai_request_error",
+    message: String(error)
+  };
+}
+// src/providers/openai-responses/mapper.ts
+var OPENAI_RESPONSES_STATE_KEY = "openaiResponses";
+function mapToolDefinitionsToOpenAIResponses(tools) {
+  if (!tools || tools.length === 0)
+    return;
+  return tools.map((tool) => ({
+    type: "function",
+    name: tool.name,
+    description: tool.description,
+    parameters: tool.inputSchema
+  }));
+}
+function mapOpenAIResponsesStopReason(response, toolCallCount) {
+  if (toolCallCount > 0)
+    return "tool_call";
+  if (response?.status === "cancelled")
+    return "cancelled";
+  if (response?.status === "failed")
+    return "error";
+  if (response?.incomplete_details?.reason === "max_output_tokens")
+    return "length";
+  return "final";
+}
+function messagesToOpenAIResponses(messages) {
+  const instructions = messages.filter((message) => message.role === "system").map((message) => contentToText(message.content)).filter(Boolean).join(`
+
+`) || undefined;
+  let previousResponseId;
+  let startIndex = 0;
+  for (let index = messages.length - 1;index >= 0; index -= 1) {
+    const state = readProviderState(messages[index], OPENAI_RESPONSES_STATE_KEY);
+    if (typeof state?.responseId === "string") {
+      previousResponseId = state.responseId;
+      startIndex = index + 1;
+      break;
+    }
+  }
+  const input = [];
+  for (const message of messages.slice(startIndex)) {
+    if (message.role === "system")
+      continue;
+    if (message.role === "tool") {
+      input.push({
+        type: "function_call_output",
+        call_id: message.toolCallId,
+        output: JSON.stringify(message.structuredContent ?? {
+          content: contentToText(message.content),
+          isError: message.isError === true
+        })
+      });
+      continue;
+    }
+    if (message.role === "assistant") {
+      if (message.content.length > 0) {
+        input.push({
+          role: "assistant",
+          content: messageContentToOpenAIResponses(message.content)
+        });
+      }
+      for (const toolCall of message.toolCalls ?? []) {
+        input.push({
+          type: "function_call",
+          call_id: toolCall.id,
+          name: toolCall.function.name,
+          arguments: JSON.stringify(toolCall.function.arguments)
+        });
+      }
+      continue;
+    }
+    input.push({
+      role: "user",
+      content: messageContentToOpenAIResponses(message.content)
+    });
+  }
+  return {
+    instructions,
+    input,
+    previousResponseId
+  };
+}
+function normalizeOpenAIResponsesToolCalls(output) {
+  if (!output)
+    return [];
+  const calls = [];
+  for (const item of output) {
+    if (item.type !== "function_call" || typeof item.name !== "string")
+      continue;
+    const callId = typeof item.call_id === "string" && item.call_id.length > 0 ? item.call_id : typeof item.id === "string" && item.id.length > 0 ? item.id : crypto.randomUUID();
+    calls.push({
+      id: callId,
+      name: item.name,
+      argsText: typeof item.arguments === "string" ? item.arguments : JSON.stringify(item.arguments ?? {})
+    });
+  }
+  return calls;
+}
+function extractOpenAIResponsesText(output) {
+  if (!output)
+    return [];
+  const deltas = [];
+  for (const item of output) {
+    if (item.type !== "message")
+      continue;
+    for (const part of item.content ?? []) {
+      if ((part.type === "output_text" || part.type === "text") && typeof part.text === "string" && part.text.length > 0)
+        deltas.push(part.text);
+    }
+  }
+  return deltas;
+}
+function extractOpenAIResponsesThinking(output) {
+  if (!output)
+    return [];
+  const deltas = [];
+  for (const item of output) {
+    if (item.type !== "reasoning")
+      continue;
+    for (const part of item.summary ?? []) {
+      if (typeof part.text === "string" && part.text.length > 0)
+        deltas.push(part.text);
+    }
+  }
+  return deltas;
+}
+function createOpenAIResponsesState(responseId) {
+  if (!responseId)
+    return;
+  return { responseId };
+}
+function messageContentToOpenAIResponses(content) {
+  const hasImage = content.some((block) => block.type === "image");
+  if (!hasImage)
+    return contentToText(content);
+  return content.map((block) => {
+    if (block.type === "text")
+      return { type: "input_text", text: block.text };
+    return {
+      type: "input_image",
+      image_url: imageDataUrl2(block)
+    };
+  });
+}
+function imageDataUrl2(block) {
+  return `data:${block.mimeType};base64,${block.data}`;
+}
+
+// src/providers/openai-responses/adapter.ts
+function createOpenAIResponsesAdapter(options) {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const provider = options.provider ?? "openai-responses";
+  const defaultModel = { provider, modelId: options.defaultModel };
+  const baseUrl = (options.baseUrl ?? "https://api.openai.com/v1").replace(/\/$/, "");
+  return {
+    provider,
+    defaultModel,
+    async* stream(request) {
+      const requestId = request.requestId ?? crypto.randomUUID();
+      yield { type: "response_start", requestId, model: request.model };
+      const { instructions, input, previousResponseId } = messagesToOpenAIResponses(request.messages);
+      let response;
+      try {
+        response = await fetchImpl(`${baseUrl}/responses`, {
+          method: "POST",
+          headers: {
+            "content-type": "application/json",
+            ...options.apiKey ? { authorization: `Bearer ${options.apiKey}` } : {},
+            ...options.headers
+          },
+          body: JSON.stringify({
+            model: request.model.modelId,
+            instructions,
+            input,
+            previous_response_id: previousResponseId,
+            tools: mapToolDefinitionsToOpenAIResponses(request.tools),
+            max_output_tokens: request.maxOutputTokens,
+            temperature: request.temperature,
+            top_p: request.topP,
+            reasoning: buildOpenAIResponsesReasoning(request.reasoning),
+            stream: false
+          }),
+          signal: request.signal
+        });
+      } catch (error) {
+        yield { type: "error", requestId, error: toModelErrorPayload4(error), terminal: true };
+        return;
+      }
+      if (!response.ok) {
+        yield {
+          type: "error",
+          requestId,
+          error: await createHttpErrorPayload({
+            code: "openai_responses_http_error",
+            provider: "OpenAI Responses",
+            endpoint: `${baseUrl}/responses`,
+            response
+          }),
+          terminal: true
+        };
+        return;
+      }
+      const data = await response.json();
+      for (const delta of extractOpenAIResponsesThinking(data.output))
+        yield { type: "thinking_delta", requestId, delta };
+      for (const delta of extractOpenAIResponsesText(data.output))
+        yield { type: "text_delta", requestId, delta };
+      const toolCalls = normalizeOpenAIResponsesToolCalls(data.output);
+      for (const toolCall of toolCalls) {
+        yield { type: "tool_call_start", requestId, callId: toolCall.id, toolName: toolCall.name };
+        yield { type: "tool_call_args_delta", requestId, callId: toolCall.id, delta: toolCall.argsText };
+        yield { type: "tool_call_end", requestId, callId: toolCall.id };
+      }
+      yield {
+        type: "response_end",
+        requestId,
+        stopReason: mapOpenAIResponsesStopReason(data, toolCalls.length),
+        usage: normalizeUsage(data.usage),
+        assistantMetadata: attachProviderState(undefined, "openaiResponses", createOpenAIResponsesState(data.id))
+      };
+    }
+  };
+}
+function toModelErrorPayload4(error) {
+  if (error instanceof Error) {
+    return {
+      code: "openai_responses_request_error",
+      message: error.message
+    };
+  }
+  return {
+    code: "openai_responses_request_error",
+    message: String(error)
+  };
+}
+// src/agent-core/createModel.ts
+function createModel(adapter) {
+  return {
+    adapter,
+    model: adapter.defaultModel,
+    stream(request) {
+      return adapter.stream({
+        ...request,
+        model: request.model ?? adapter.defaultModel
+      });
+    }
+  };
+}
+export {
+  startToolCall,
+  normalizeToolSchema,
+  normalizeToolResult,
+  normalizePermissions,
+  normalizeContent,
+  fullPermissions,
+  finalizeToolCall,
+  createOpenAIResponsesAdapter,
+  createOpenAIAdapter,
+  createModel,
+  createGeminiAdapter,
+  createAnthropicAdapter,
+  createAgent,
+  appendToolCallArgsDelta,
+  WriteTool,
+  ToolRegistry,
+  SessionExecutionError,
+  Session,
+  ReadTool,
+  PermissionGateway,
+  PermissionDeniedError,
+  NodeFileSystemGateway,
+  NodeExecGateway,
+  InMemoryStateStore,
+  FileStateStore,
+  ExecTool,
+  EditTool,
+  DefaultNetworkGateway,
+  DefaultModelGateway,
+  DefaultGitGateway,
+  BaseTool,
+  AutoContextManager,
+  Agent,
+  ActivityTracker
+};