@rowan-agent/agent 0.5.5 → 0.6.0

package/dist/index.js

@@ -380,9 +380,9 @@ function createExtensionAPI(hooks, _extensionPath, options, runtime, eventBus) {
 }
 
 // src/harness/phases/loader.ts
-import { existsSync as existsSync2, statSync } from "fs";
+import { existsSync, statSync } from "fs";
 import { readdir } from "fs/promises";
-import { dirname as dirname2, join as join2, resolve } from "path";
+import { dirname as dirname2, join, resolve } from "path";
 
 // src/harness/loader.ts
 import { readFile } from "fs/promises";
@@ -447,181 +447,8 @@ function inferResourceName(path, markerFile) {
   return extension ? file.slice(0, -extension.length) : file;
 }
 
-// src/harness/config.ts
-import { existsSync } from "fs";
-import { readFile as readFile2 } from "fs/promises";
-import { join } from "path";
-import { parse as parseYaml } from "yaml";
-import { registerModel } from "@rowan-agent/models";
-var DEFAULT_REASONING = false;
-var DEFAULT_INPUT = ["text"];
-var DEFAULT_CONTEXT_WINDOW = 128e3;
-var DEFAULT_MAX_TOKENS = 16384;
-var DEFAULT_COST = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
-var DEFAULT_TIMEOUT_MS = 6e4;
-var ENV_VAR_PATTERN = /\$\{([^}]+)\}/g;
-function interpolateEnvVars(value) {
-  return value.replace(ENV_VAR_PATTERN, (match, varName) => {
-    const resolved = process.env[varName];
-    if (resolved === void 0 || resolved === "") {
-      throw new Error(
-        `Environment variable "${varName}" is not set but is referenced in config.yaml via "${match}".`
-      );
-    }
-    return resolved;
-  });
-}
-var CONFIG_CANDIDATES = ["config.yaml", "config.yml"];
-async function loadConfigFile(workspace) {
-  let configPath;
-  let configFilename;
-  for (const candidate of CONFIG_CANDIDATES) {
-    const p = join(workspace.rowanDir, candidate);
-    if (existsSync(p)) {
-      configPath = p;
-      configFilename = candidate;
-      break;
-    }
-  }
-  if (!configPath || !configFilename) {
-    return void 0;
-  }
-  const raw = await readFile2(configPath, "utf8");
-  let parsed;
-  try {
-    parsed = parseYaml(raw);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw new Error(`Failed to parse .rowan/${configFilename}: ${message}`);
-  }
-  if (parsed === null || parsed === void 0) {
-    return void 0;
-  }
-  return validateConfigFile(parsed, configFilename);
-}
-function validateConfigFile(parsed, configFilename) {
-  if (typeof parsed !== "object" || parsed === null) {
-    throw new Error(`.rowan/${configFilename} must be a YAML object at the top level.`);
-  }
-  const obj = parsed;
-  const providers = obj.providers;
-  if (!Array.isArray(providers)) {
-    throw new Error(`.rowan/${configFilename} must have a "providers" array.`);
-  }
-  const validatedProviders = providers.map((p, i) => {
-    if (typeof p !== "object" || p === null) {
-      throw new Error(`providers[${i}] must be an object.`);
-    }
-    const provider = p;
-    if (typeof provider.id !== "string" || !provider.id) {
-      throw new Error(`providers[${i}].id is required and must be a non-empty string.`);
-    }
-    if (typeof provider.baseUrl !== "string" || !provider.baseUrl) {
-      throw new Error(`providers[${i}].baseUrl is required and must be a non-empty string.`);
-    }
-    if (typeof provider.apiKey !== "string" || !provider.apiKey) {
-      throw new Error(`providers[${i}].apiKey is required and must be a non-empty string.`);
-    }
-    if (typeof provider.protocol !== "string" || !provider.protocol) {
-      throw new Error(`providers[${i}].protocol is required and must be a non-empty string.`);
-    }
-    if (!Array.isArray(provider.models) || provider.models.length === 0) {
-      throw new Error(`providers[${i}].models must be a non-empty array.`);
-    }
-    const interpolatedApiKey = interpolateEnvVars(provider.apiKey);
-    const validatedModels = provider.models.map((m, j) => {
-      if (typeof m !== "object" || m === null) {
-        throw new Error(`providers[${i}].models[${j}] must be an object.`);
-      }
-      const model = m;
-      if (typeof model.id !== "string" || !model.id) {
-        throw new Error(`providers[${i}].models[${j}].id is required and must be a non-empty string.`);
-      }
-      return model;
-    });
-    return {
-      id: provider.id,
-      baseUrl: provider.baseUrl,
-      apiKey: interpolatedApiKey,
-      protocol: provider.protocol,
-      ...typeof provider.name === "string" ? { name: provider.name } : {},
-      ...typeof provider.timeoutMs === "number" ? { timeoutMs: provider.timeoutMs } : {},
-      ...typeof provider.maxRetries === "number" ? { maxRetries: provider.maxRetries } : {},
-      ...typeof provider.retryDelayMs === "number" ? { retryDelayMs: provider.retryDelayMs } : {},
-      ...provider.headers && typeof provider.headers === "object" ? { headers: provider.headers } : {},
-      models: validatedModels
-    };
-  });
-  const result = { providers: validatedProviders };
-  if (obj.model && typeof obj.model === "object") {
-    const modelRef = obj.model;
-    if (typeof modelRef.provider !== "string" || typeof modelRef.id !== "string") {
-      throw new Error(`.rowan/${configFilename} "model" must have "provider" and "id" string fields.`);
-    }
-    result.model = { provider: modelRef.provider, id: modelRef.id };
-  }
-  if (obj.logLevel !== void 0) {
-    const valid = ["debug", "info", "warn", "error", "silent"];
-    if (typeof obj.logLevel !== "string" || !valid.includes(obj.logLevel)) {
-      throw new Error(`.rowan/${configFilename} "logLevel" must be one of: ${valid.join(", ")}.`);
-    }
-    result.logLevel = obj.logLevel;
-  }
-  return result;
-}
-function resolveDefaultModel(config) {
-  if (config.model) {
-    return { provider: config.model.provider, id: config.model.id };
-  }
-  for (const provider of config.providers) {
-    for (const model of provider.models) {
-      if (model.primary) {
-        return { provider: provider.id, id: model.id };
-      }
-    }
-  }
-  for (const provider of config.providers) {
-    if (provider.models.length > 0) {
-      return { provider: provider.id, id: provider.models[0].id };
-    }
-  }
-  return void 0;
-}
-function registerConfigModels(config) {
-  for (const provider of config.providers) {
-    for (const fileModel of provider.models) {
-      const model = {
-        id: fileModel.id,
-        name: fileModel.name ?? fileModel.id,
-        protocol: provider.protocol,
-        provider: provider.id,
-        baseUrl: provider.baseUrl,
-        reasoning: fileModel.reasoning ?? DEFAULT_REASONING,
-        input: fileModel.input ?? DEFAULT_INPUT,
-        cost: { ...DEFAULT_COST, ...fileModel.cost },
-        contextWindow: fileModel.contextWindow ?? DEFAULT_CONTEXT_WINDOW,
-        maxTokens: fileModel.maxTokens ?? DEFAULT_MAX_TOKENS,
-        apiKey: provider.apiKey,
-        timeoutMs: provider.timeoutMs ?? DEFAULT_TIMEOUT_MS,
-        ...provider.maxRetries !== void 0 ? { maxRetries: provider.maxRetries } : {},
-        ...provider.retryDelayMs !== void 0 ? { retryDelayMs: provider.retryDelayMs } : {},
-        ...provider.headers ? { headers: provider.headers } : {}
-      };
-      registerModel(model);
-    }
-  }
-}
-function parseModelRef(input) {
-  if (!input) return void 0;
-  const slashIndex = input.indexOf("/");
-  if (slashIndex === -1) {
-    return { provider: "*", id: input };
-  }
-  return {
-    provider: input.slice(0, slashIndex),
-    id: input.slice(slashIndex + 1)
-  };
-}
+// src/harness/phases/loader.ts
+import { parseModelRef } from "@rowan-agent/models";
 
 // src/harness/context/resource-formatter.ts
 function escapeXml(value) {
@@ -725,7 +552,7 @@ function buildPhaseDirectiveMessage(phase, output, toolUseId) {
 var PHASE_MARKER = "PHASE.md";
 function resolvePhasePath(input) {
   const resolved = resolve(input);
-  return existsSync2(resolved) && statSync(resolved).isDirectory() ? join2(resolved, PHASE_MARKER) : resolved;
+  return existsSync(resolved) && statSync(resolved).isDirectory() ? join(resolved, PHASE_MARKER) : resolved;
 }
 async function loadPhase(targetPath) {
   const resolved = resolvePhasePath(targetPath);
@@ -772,18 +599,15 @@ function readPhaseContent(phase) {
     baseDir: phase.baseDir
   });
 }
-function resolvePhaseLoadTarget(targetPath) {
-  return typeof targetPath === "string" ? targetPath : join2(targetPath.rowanDir, "phases");
-}
 async function loadPhases(targetPath) {
   const phases = /* @__PURE__ */ new Map();
-  const phasesDir = resolve(resolvePhaseLoadTarget(targetPath));
-  if (existsSync2(phasesDir) && statSync(phasesDir).isFile()) {
+  const phasesDir = resolve(targetPath);
+  if (existsSync(phasesDir) && statSync(phasesDir).isFile()) {
     const phase = await loadPhase(phasesDir);
     phases.set(phase.id, phase);
     return { phases, entryPhaseId: null };
   }
-  if (existsSync2(join2(phasesDir, PHASE_MARKER))) {
+  if (existsSync(join(phasesDir, PHASE_MARKER))) {
     const phase = await loadPhase(phasesDir);
     phases.set(phase.id, phase);
     return { phases, entryPhaseId: null };
@@ -791,8 +615,8 @@ async function loadPhases(targetPath) {
   const entries = await readdir(phasesDir, { withFileTypes: true });
   for (const entry of [...entries].sort((a, b) => a.name.localeCompare(b.name))) {
     if (!entry.isDirectory()) continue;
-    const phaseFile = join2(phasesDir, entry.name, PHASE_MARKER);
-    if (!existsSync2(phaseFile)) continue;
+    const phaseFile = join(phasesDir, entry.name, PHASE_MARKER);
+    if (!existsSync(phaseFile)) continue;
     try {
       const phase = await loadPhase(phaseFile);
       phases.set(phase.id, phase);
@@ -805,8 +629,8 @@ async function loadPhases(targetPath) {
 async function discoverPhaseCode(baseDir) {
   const candidates = ["index.ts", "index.js"];
   for (const candidate of candidates) {
-    const fullPath = join2(baseDir, candidate);
-    if (existsSync2(fullPath)) {
+    const fullPath = join(baseDir, candidate);
+    if (existsSync(fullPath)) {
       return fullPath;
     }
   }
@@ -815,7 +639,9 @@ async function discoverPhaseCode(baseDir) {
 async function loadPhaseCode(codePath) {
   const { createJiti: createJiti2 } = await import("jiti");
   const jiti = createJiti2(import.meta.url, {
-    moduleCache: false
+    fsCache: false,
+    moduleCache: false,
+    tryNative: false
   });
   const mod = await jiti.import(codePath, { default: true });
   const fn = typeof mod === "function" ? mod : mod?.default;
@@ -827,19 +653,6 @@ async function loadPhaseCode(codePath) {
   }
   throw new Error(`Phase code at "${codePath}" must export a default function or a run() function.`);
 }
-async function reloadPhases(registry) {
-  for (const [id, phase] of registry.phases) {
-    if (!phase.filePath) {
-      continue;
-    }
-    try {
-      const fresh = await loadPhase(phase.filePath);
-      registry.phases.set(id, fresh);
-    } catch (error) {
-      console.warn(`Failed to reload phase "${id}":`, error);
-    }
-  }
-}
 
 // src/harness/phases/default.ts
 var DEFAULT_PHASE_ID = "default";
@@ -855,119 +668,16 @@ function createDefaultPhase() {
 }
 
 // src/harness/tools/index.ts
-import { mkdir, readFile as readFile3, stat, writeFile } from "fs/promises";
-import { basename as basename2, dirname as dirname4, isAbsolute as isAbsolute2, relative as relative2, resolve as resolve3, sep as sep2 } from "path";
+import { mkdir, readFile as readFile2, stat, writeFile } from "fs/promises";
+import { basename as basename2, dirname as dirname3, isAbsolute as isAbsolute2, relative as relative2, resolve as resolve3, sep as sep2 } from "path";
 import Type2 from "typebox";
 import Schema from "typebox/schema";
 
-// src/harness/env/path.ts
-import { existsSync as existsSync3, readFileSync } from "fs";
-import { homedir } from "os";
-import { dirname as dirname3, isAbsolute, join as join3, parse, relative, resolve as resolve2, sep } from "path";
-var WORKSPACE_ENV = "ROWAN_WORKSPACE";
-var BINARY_WORKSPACE_DIR = ".rowan";
-function nonEmptyEnv(env, key) {
-  const value = env[key]?.trim();
-  return value ? value : void 0;
-}
-function resolveUserPath(path, homeDir) {
-  if (path === "~") {
-    return homeDir;
-  }
-  if (path.startsWith("~/") || path.startsWith("~\\")) {
-    return join3(homeDir, path.slice(2));
-  }
-  return resolve2(path);
-}
-function isSourceWorkspaceRoot(path) {
-  const packagePath = join3(path, "package.json");
-  if (!existsSync3(packagePath)) {
-    return false;
-  }
-  try {
-    const manifest = JSON.parse(readFileSync(packagePath, "utf8"));
-    return manifest.name === "rowan-agent" || Array.isArray(manifest.workspaces);
-  } catch {
-    return false;
-  }
-}
-function findSourceWorkspaceRoot(startDir = process.cwd()) {
-  let current = resolve2(startDir);
-  const { root } = parse(current);
-  while (true) {
-    if (isSourceWorkspaceRoot(current)) {
-      return current;
-    }
-    if (current === root) {
-      return resolve2(startDir);
-    }
-    current = dirname3(current);
-  }
-}
-function defaultWorkspaceStartDir(options) {
-  if (options.cwd) {
-    return options.cwd;
-  }
-  return process.cwd();
-}
-function resolveWorkspaceRoot(options = {}) {
-  const env = options.env ?? process.env;
-  const homeDir = options.homeDir ?? homedir();
-  const override = nonEmptyEnv(env, WORKSPACE_ENV);
-  if (override) {
-    return resolveUserPath(override, homeDir);
-  }
-  return findSourceWorkspaceRoot(defaultWorkspaceStartDir(options));
-}
-function resolveWorkspacePaths(options = {}) {
-  const cwd = resolveWorkspaceRoot(options);
-  return {
-    cwd,
-    rowanDir: resolveProjectRowanDir(cwd, options.rowanDir)
-  };
-}
-function resolveProjectRowanDir(cwd, rowanDir = BINARY_WORKSPACE_DIR) {
-  const inputPath = rowanDir.trim() || BINARY_WORKSPACE_DIR;
-  if (isAbsolute(inputPath)) {
-    throw new Error(`Project Rowan dir must be a relative path: ${rowanDir}`);
-  }
-  return resolveWorkspacePath({ root: cwd }, inputPath).absolutePath;
-}
-function resolveInWorkspace(path, rootOrPaths) {
-  if (path === "~" || path.startsWith("~/") || path.startsWith("~\\")) {
-    return resolveUserPath(path, homedir());
-  }
-  if (isAbsolute(path)) {
-    return path;
-  }
-  const root = typeof rootOrPaths === "string" ? rootOrPaths : rootOrPaths.cwd;
-  return resolve2(root, path);
-}
+// src/harness/path.ts
+import { isAbsolute, relative, resolve as resolve2, sep } from "path";
 function normalizeRelativePath(path) {
   return path.split(sep).join("/");
 }
-function normalizeWorkspaceInputPath(path = ".") {
-  const trimmed = path.trim();
-  if (!trimmed || trimmed === "/" || trimmed === "\\") {
-    return ".";
-  }
-  return path;
-}
-function resolveWorkspacePath(context, path = ".") {
-  const root = resolve2(context.root);
-  const inputPath = normalizeWorkspaceInputPath(path);
-  const absolutePath = resolve2(root, inputPath);
-  const relativePath = relative(root, absolutePath);
-  if (relativePath === ".." || relativePath.startsWith(`..${sep}`) || isAbsolute(relativePath)) {
-    throw new Error(`Path escapes workspace root: ${path}`);
-  }
-  return {
-    root,
-    inputPath,
-    absolutePath,
-    relativePath: normalizeRelativePath(relativePath || ".")
-  };
-}
 
 // src/harness/tools/route-tool.ts
 import Type from "typebox";
@@ -1310,7 +1020,7 @@ function createReadTool(context) {
           error: `Not a file: ${resolved.relativePath}`
         });
       }
-      const bytes = await readFile3(resolved.absolutePath);
+      const bytes = await readFile2(resolved.absolutePath);
       const sliced = bytes.subarray(0, maxBytes);
       const text = new TextDecoder().decode(sliced);
       const resourceType = parsed.type ?? detectResourceType(resolved.absolutePath);
@@ -1320,7 +1030,7 @@ function createReadTool(context) {
         const { frontmatter } = parseFrontmatter(text);
         const marker = resourceType === "skill" ? "SKILL.md" : "PHASE.md";
         name = frontmatter.name ?? inferResourceName(resolved.absolutePath, marker);
-        baseDir = dirname4(resolved.absolutePath);
+        baseDir = dirname3(resolved.absolutePath);
       } else {
         name = inferResourceName(resolved.absolutePath, basename2(resolved.absolutePath));
       }
@@ -1351,7 +1061,7 @@ function createWriteTool(context) {
     async execute(args, toolContext) {
       const parsed = WriteArgsValidator.Parse(args);
       const resolved = resolveCoreToolPath(context, parsed.path);
-      await mkdir(dirname4(resolved.absolutePath), { recursive: true });
+      await mkdir(dirname3(resolved.absolutePath), { recursive: true });
       await writeFile(resolved.absolutePath, parsed.content, "utf8");
       return toolResult({
         context: toolContext,
@@ -1388,7 +1098,7 @@ function createEditTool(context) {
         });
       }
       const resolved = resolveCoreToolPath(context, parsed.path);
-      const current = await readFile3(resolved.absolutePath, "utf8");
+      const current = await readFile2(resolved.absolutePath, "utf8");
       if (!current.includes(parsed.oldText)) {
         return toolResult({
           context: toolContext,
@@ -1576,15 +1286,6 @@ function serializeSkills(skills) {
     disableModelInvocation: skill.disableModelInvocation
   }));
 }
-function latestUserInput(messages) {
-  for (let index = messages.length - 1; index >= 0; index -= 1) {
-    const message = messages[index];
-    if (message.role === "user") {
-      return messageContentText(message.content);
-    }
-  }
-  return "";
-}
 function conversationMessages(messages) {
   return messages.flatMap((message) => {
     if (message.role === "user") {
@@ -2398,13 +2099,13 @@ async function completeRun2(config, state, outcome) {
 }
 
 // src/harness/skills.ts
-import { existsSync as existsSync4, statSync as statSync2 } from "fs";
+import { existsSync as existsSync2, statSync as statSync2 } from "fs";
 import { readdir as readdir2 } from "fs/promises";
-import { dirname as dirname5, join as join4, resolve as resolve4 } from "path";
+import { dirname as dirname4, join as join2, resolve as resolve4 } from "path";
 var SKILL_MARKER = "SKILL.md";
 function resolveSkillPath(input) {
   const resolved = resolve4(input);
-  return existsSync4(resolved) && statSync2(resolved).isDirectory() ? join4(resolved, SKILL_MARKER) : resolved;
+  return existsSync2(resolved) && statSync2(resolved).isDirectory() ? join2(resolved, SKILL_MARKER) : resolved;
 }
 function readSkillContent(skill) {
   return formatResourceOutput({
@@ -2422,25 +2123,25 @@ async function loadSkill(path) {
     name: frontmatter.name ?? inferResourceName(resolved, SKILL_MARKER),
     description: frontmatter.description ?? "",
     filePath: resolved,
-    baseDir: dirname5(resolved),
+    baseDir: dirname4(resolved),
     content: body,
     disableModelInvocation: frontmatter["disable-model-invocation"] === true
   };
 }
 async function loadSkills(targetPath) {
   const skillsDir = resolve4(targetPath);
-  if (existsSync4(skillsDir) && statSync2(skillsDir).isFile()) {
+  if (existsSync2(skillsDir) && statSync2(skillsDir).isFile()) {
     return [await loadSkill(skillsDir)];
   }
-  if (existsSync4(join4(skillsDir, SKILL_MARKER))) {
+  if (existsSync2(join2(skillsDir, SKILL_MARKER))) {
     return [await loadSkill(skillsDir)];
   }
   const entries = await readdir2(skillsDir, { withFileTypes: true });
   const skills = [];
   for (const entry of [...entries].sort((a, b) => a.name.localeCompare(b.name))) {
     if (!entry.isDirectory()) continue;
-    const skillFile = join4(skillsDir, entry.name, SKILL_MARKER);
-    if (!existsSync4(skillFile)) continue;
+    const skillFile = join2(skillsDir, entry.name, SKILL_MARKER);
+    if (!existsSync2(skillFile)) continue;
     try {
       const skill = await loadSkill(skillFile);
       skills.push(skill);
@@ -2561,19 +2262,11 @@ var HooksManager = class {
     return void 0;
   }
 };
-var _globalHooks;
-function getGlobalHooks() {
-  _globalHooks ??= new HooksManager();
-  return _globalHooks;
-}
-function resetGlobalHooks() {
-  _globalHooks = void 0;
-}
 
 // src/extensions/runner.ts
 import { execFile } from "child_process";
 import {
-  registerModel as registerModel2,
+  registerModel,
   unregisterProviderModels,
   registerApiProvider
 } from "@rowan-agent/models";
@@ -2624,6 +2317,9 @@ function createExtensionRuntime() {
   return runtime;
 }
 
+// src/extensions/runner.ts
+import { parseModelRef as parseModelRef2 } from "@rowan-agent/models";
+
 // src/extensions/event-bus.ts
 function createEventBus() {
   const listeners = /* @__PURE__ */ new Map();
@@ -2705,7 +2401,7 @@ function applyProviderRegistration(config) {
     registerApiProvider({ protocol: config.protocol, stream: config.streamSimple });
   }
   for (const modelConfig of config.models) {
-    registerModel2({
+    registerModel({
       id: modelConfig.id,
       name: modelConfig.name,
       protocol: config.protocol,
@@ -2977,7 +2673,7 @@ var ExtensionRunner = class {
       filePath: "",
       baseDir: "",
       content: "",
-      ...def.model ? { model: parseModelRef(def.model) } : {}
+      ...def.model ? { model: parseModelRef2(def.model) } : {}
     };
   }
   // ---------------------------------------------------------------------------
@@ -3300,10 +2996,10 @@ function createExtensionRunner(options) {
 }
 
 // src/extensions/loader.ts
-import { existsSync as existsSync5, readFileSync as readFileSync2 } from "fs";
-import { readdir as readdir3, readFile as readFile4, stat as stat2 } from "fs/promises";
+import { existsSync as existsSync3, readFileSync } from "fs";
+import { readdir as readdir3, readFile as readFile3, stat as stat2 } from "fs/promises";
 import { fileURLToPath } from "url";
-import { dirname as dirname6, extname as extname2, join as join5, resolve as resolve5 } from "path";
+import { basename as basename3, dirname as dirname5, extname as extname2, join as join3, resolve as resolve5 } from "path";
 import { createJiti } from "jiti";
 function isExtensionFile(path) {
   const extension = extname2(path).toLowerCase();
@@ -3313,12 +3009,12 @@ function isSyntheticPath(path) {
   return path.startsWith("<") && path.endsWith(">");
 }
 function readManifestSync(dir) {
-  const manifestPath = join5(dir, "package.json");
-  if (!existsSync5(manifestPath)) {
+  const manifestPath = join3(dir, "package.json");
+  if (!existsSync3(manifestPath)) {
     return void 0;
   }
   try {
-    const content = readFileSync2(manifestPath, "utf8");
+    const content = readFileSync(manifestPath, "utf8");
     const pkg = JSON.parse(content);
     const rowan = pkg.rowan;
     if (!rowan) return void 0;
@@ -3336,7 +3032,7 @@ function jitiAliases() {
     return {};
   }
   const agentSourcePath = fileURLToPath(new URL("../index.ts", moduleUrl));
-  if (!existsSync5(agentSourcePath)) {
+  if (!existsSync3(agentSourcePath)) {
     return {};
   }
   return { "@rowan-agent/agent": agentSourcePath };
@@ -3344,7 +3040,9 @@ function jitiAliases() {
 var sharedJiti;
 function getJiti() {
   sharedJiti ??= createJiti(import.meta.url || process.cwd(), {
+    fsCache: false,
     moduleCache: false,
+    tryNative: false,
     alias: jitiAliases()
   });
   return sharedJiti;
@@ -3355,21 +3053,21 @@ async function loadExtensionModule(extensionPath) {
   return typeof module === "function" ? module : void 0;
 }
 async function readPackageManifest(path) {
-  if (!existsSync5(path)) {
+  if (!existsSync3(path)) {
     return void 0;
   }
-  const content = await readFile4(path, "utf8");
+  const content = await readFile3(path, "utf8");
   return JSON.parse(content);
 }
 async function resolveExtensionEntries(dir) {
-  const manifest = await readPackageManifest(join5(dir, "package.json"));
+  const manifest = await readPackageManifest(join3(dir, "package.json"));
   const declared = manifest?.rowan?.extensions;
   if (declared && declared.length > 0) {
     return declared.map((entry) => resolve5(dir, entry));
   }
   for (const name of ["index.ts", "index.js"]) {
-    const entry = join5(dir, name);
-    if (existsSync5(entry)) {
+    const entry = join3(dir, name);
+    if (existsSync3(entry)) {
       return [entry];
     }
   }
@@ -3384,7 +3082,7 @@ async function discoverExtensionsInDir(dir) {
   });
   const paths = [];
   for (const entry of [...entries].sort((a, b) => a.name.localeCompare(b.name))) {
-    const entryPath = join5(dir, entry.name);
+    const entryPath = join3(dir, entry.name);
     if ((entry.isFile() || entry.isSymbolicLink()) && isExtensionFile(entry.name)) {
       paths.push(entryPath);
       continue;
@@ -3404,8 +3102,8 @@ async function discoverExtensionsInDir(dir) {
 function loadExtensionFromFactory(factory, cwd, extensionPath = "<inline>") {
   const resolvedCwd = resolve5(cwd);
   const resolvedPath = isSyntheticPath(extensionPath) ? extensionPath : resolve5(resolvedCwd, extensionPath);
-  const name = isSyntheticPath(extensionPath) ? extensionPath : dirname6(resolvedPath).split("/").pop() ?? "unknown";
-  const manifestDir = isSyntheticPath(extensionPath) ? resolvedCwd : dirname6(resolvedPath);
+  const name = isSyntheticPath(extensionPath) ? extensionPath : basename3(dirname5(resolvedPath)) || "unknown";
+  const manifestDir = isSyntheticPath(extensionPath) ? resolvedCwd : dirname5(resolvedPath);
   const manifest = readManifestSync(manifestDir);
   return {
     path: resolvedPath,
@@ -3443,14 +3141,14 @@ async function loadExtensionsFromPath(path) {
   const resolvedPath = resolve5(path);
   const info = await stat2(resolvedPath);
   if (!info.isDirectory()) {
-    return loadExtensions([resolvedPath], dirname6(resolvedPath));
+    return loadExtensions([resolvedPath], dirname5(resolvedPath));
   }
   const entries = await resolveExtensionEntries(resolvedPath) ?? await discoverExtensionsInDir(resolvedPath);
   return loadExtensions(entries, resolvedPath);
 }
 
-// src/agent.ts
-var Agent = class {
+// src/agent-execution.ts
+var AgentExecution = class {
   state;
   options;
   listeners = /* @__PURE__ */ new Set();
@@ -3460,6 +3158,17 @@ var Agent = class {
   extensionRunner;
   loadedExtensions;
   loadedExtensionsCwd;
+  runtimeRunId;
+  get id() {
+    const agentId = this.state.agentId;
+    if (!agentId) throw new Error("Agent has no durable identity.");
+    return agentId;
+  }
+  get sessionId() {
+    const sessionId = this.state.sessionId;
+    if (!sessionId) throw new Error("Agent has no Session.");
+    return sessionId;
+  }
   static loadSkills(targetPath) {
     return loadSkills(targetPath);
   }
@@ -3476,6 +3185,7 @@ var Agent = class {
       context
     };
     this.state = {
+      ...this.options.agentId ? { agentId: this.options.agentId } : {},
       ...this.options.sessionId ? { sessionId: this.options.sessionId } : {},
       context: prepareAgentContext(context),
       model: this.options.model,
@@ -3511,7 +3221,7 @@ var Agent = class {
     this.appendUserMessage(input);
     return this.run(options);
   }
-  runWithMessage(message, options) {
+  runWithMessage(message, options, internalHooks = {}) {
     const activeRun = this.activeRun;
     if (activeRun?.resume) {
       activeRun.resume([message]);
@@ -3521,7 +3231,17 @@ var Agent = class {
       return Promise.reject(new Error("Agent is already running."));
     }
     this.appendMessage(message);
-    return this.run(options);
+    return this.run(options, internalHooks);
+  }
+  /** Internal Runtime seam: executes one leased Agent Input. */
+  async executeAgentInput(input, runId, control) {
+    this.runtimeRunId = runId;
+    const internal = { onSuspend: control.suspend };
+    try {
+      return (await this.runWithMessage(input, void 0, internal)).outcome;
+    } finally {
+      if (!this.activeRun) this.runtimeRunId = void 0;
+    }
   }
   resetInitialization() {
     this.state.initialized = false;
@@ -3593,6 +3313,13 @@ var Agent = class {
   getSessionId() {
     return this.state.sessionId;
   }
+  getAgentId() {
+    return this.state.agentId;
+  }
+  /** Internal Runtime hook for associating Tool Calls with the leased Run. */
+  getRuntimeRunId() {
+    return this.runtimeRunId;
+  }
   setModel(model) {
     this.options = {
       ...this.options,
@@ -3740,18 +3467,25 @@ var Agent = class {
     const message = error instanceof Error ? error.message : "Agent run failed.";
     this.state.error = message;
   }
-  runWithLifecycle(executor) {
+  runWithLifecycle(executor, hooks = {}) {
     if (this.activeRun) {
       return Promise.reject(new Error("Agent is already running."));
     }
     const abortController = new AbortController();
-    const waitForInput = () => new Promise((resolve7) => {
-      const activeRun = this.activeRun;
-      activeRun.resume = (messages) => {
-        activeRun.resume = void 0;
-        resolve7(messages);
-      };
-    });
+    let suspensionRequested = false;
+    const waitForInput = () => {
+      if (!suspensionRequested) {
+        suspensionRequested = true;
+        void hooks.onSuspend?.("Agent requested input.");
+      }
+      return new Promise((resolve7) => {
+        const activeRun = this.activeRun;
+        activeRun.resume = (messages) => {
+          activeRun.resume = void 0;
+          resolve7(messages);
+        };
+      });
+    };
     const promise = Promise.resolve().then(() => executor({ signal: abortController.signal, waitForInput })).catch((error) => {
       this.handleRunFailure(error, abortController.signal.aborted);
       throw error;
@@ -3785,7 +3519,7 @@ var Agent = class {
     this.loadedExtensions = extensions;
     this.loadedExtensionsCwd = cwd;
   }
-  run(config) {
+  run(config, internalHooks = {}) {
     return this.runWithLifecycle(async ({ signal, waitForInput }) => {
       const resolved = this.resolveRunConfig(config);
       const extensions = resolved.extensions ?? [];
@@ -3846,7 +3580,8 @@ var Agent = class {
         onMessage: resolved.onMessage,
         onOutcome: resolved.onOutcome,
         onModelTranscript: resolved.onModelTranscript,
-        waitForInput
+        waitForInput,
+        runtime: resolved.runtime
       });
       const nextContext = {
         ...prepareAgentContext(resolved.context),
@@ -3862,13 +3597,20 @@ var Agent = class {
         context: nextContext
       };
       return result;
-    });
+    }, internalHooks);
   }
   abort(reason = "Aborted by caller.") {
+    this.abortLocal(reason);
+  }
+  abortLocal(reason) {
     const activeRun = this.activeRun;
     activeRun?.resume?.([]);
     activeRun?.abortController.abort(reason);
   }
+  /** Internal Runtime hook; public callers abort a precise AgentRun. */
+  abortFromRuntime(reason = "Agent Runtime aborted the Run.") {
+    this.abortLocal(reason);
+  }
   /**
    * Get formatted skill content for LLM consumption.
    *
@@ -3962,9 +3704,126 @@ function prepareAgentContext(context, extensionRunner) {
   };
 }
 
+// src/agent.ts
+var AGENT_CONSTRUCTION = /* @__PURE__ */ Symbol("rowan.agent.construction");
+var ATTACH_AGENT = /* @__PURE__ */ Symbol("rowan.agent.attach");
+var Agent = class _Agent {
+  constructor(token, id, sessionId, execution, submitInput) {
+    this.id = id;
+    this.sessionId = sessionId;
+    this.execution = execution;
+    this.submitInput = submitInput;
+    if (token !== AGENT_CONSTRUCTION) {
+      throw new Error("Agent lifecycle is owned by AgentRuntime.");
+    }
+  }
+  id;
+  sessionId;
+  execution;
+  submitInput;
+  static [ATTACH_AGENT](id, sessionId, execution, submitInput) {
+    return new _Agent(AGENT_CONSTRUCTION, id, sessionId, execution, submitInput);
+  }
+  static loadSkills(targetPath) {
+    return AgentExecution.loadSkills(targetPath);
+  }
+  static loadPhases(targetPath) {
+    return AgentExecution.loadPhases(targetPath);
+  }
+  static loadExtensions(targetPath) {
+    return AgentExecution.loadExtensions(targetPath);
+  }
+  subscribe(listener) {
+    return this.execution.subscribe(listener);
+  }
+  flushEvents() {
+    return this.execution.flushEvents();
+  }
+  send(input) {
+    const message = typeof input === "string" ? createMessage("user", input) : input;
+    return this.submitInput(message);
+  }
+};
+async function attachAgent(input) {
+  const restoredContext = await input.manager.buildAgentContext({
+    tools: input.options.context.tools,
+    skills: input.options.context.skills
+  });
+  const context = {
+    ...restoredContext,
+    systemPrompt: input.options.context.systemPrompt || restoredContext.systemPrompt,
+    phases: input.options.context.phases
+  };
+  const persistInput = async (message) => {
+    await input.manager.appendMessage(message);
+  };
+  let execution;
+  execution = new AgentExecution({
+    ...input.options,
+    context,
+    agentId: input.agentId,
+    sessionId: input.sessionId,
+    runtime: {
+      tools: async ({ config, toolCall }) => {
+        const tool = config.context.tools.find((candidate) => candidate.name === toolCall.name);
+        const runId = execution.getRuntimeRunId();
+        if (!tool || !runId) {
+          const message = `Tool ${toolCall.name} is not available to this Agent Run.`;
+          return {
+            toolCallId: toolCall.id,
+            toolName: toolCall.name,
+            ok: false,
+            content: message,
+            error: message
+          };
+        }
+        return input.executeTool({
+          agentId: input.agentId,
+          runId,
+          tool,
+          toolCall,
+          context: config.context,
+          beforeToolCall: config.beforeToolCall,
+          afterToolCall: config.afterToolCall,
+          signal: config.signal
+        });
+      }
+    },
+    onMessage: async (message) => {
+      await input.manager.appendMessage(message);
+      await input.options.onMessage?.(message);
+    },
+    onInput: persistInput,
+    onOutcome: async (outcome) => {
+      await input.manager.appendOutcome(outcome);
+      await input.options.onOutcome?.(outcome);
+    },
+    onModelTranscript: async (transcript, meta) => {
+      await input.manager.appendModelTranscript(transcript, meta);
+      await input.options.onModelTranscript?.(transcript, meta);
+    }
+  });
+  const agent = Agent[ATTACH_AGENT](
+    input.agentId,
+    input.sessionId,
+    execution,
+    (message) => input.submit(message, () => persistInput(message))
+  );
+  return {
+    agent,
+    binding: {
+      abort: (reason) => execution.abortFromRuntime(reason),
+      execute: (message, runId, control) => execution.executeAgentInput(message, runId, control)
+    }
+  };
+}
+
+// src/harness/session/jsonl.ts
+import { appendFile, mkdir as mkdir2, readFile as readFile4, readdir as readdir4, stat as stat3, unlink, writeFile as writeFile2 } from "fs/promises";
+import { join as join4, relative as relative3, resolve as resolve6, sep as sep3 } from "path";
+
 // src/harness/session/session.ts
 import Type3 from "typebox";
-var SESSION_SCHEMA_VERSION = "0.4.4";
 var AgentMessageSchema = Type3.Object({
   id: Type3.String(),
   role: Type3.Union([
@@ -3985,39 +3844,6 @@ var SkillSchema = Type3.Object({
   content: Type3.String(),
   disableModelInvocation: Type3.Boolean()
 });
-function createMessage2(role, content, metadata) {
-  return {
-    id: createId("msg"),
-    role,
-    content,
-    createdAt: createTimestamp(),
-    ...metadata ? { metadata } : {}
-  };
-}
-function createSession(input) {
-  const createdAt = createTimestamp();
-  const messages = [
-    createMessage2("user", input.input)
-  ];
-  return {
-    version: SESSION_SCHEMA_VERSION,
-    id: input.id ?? createId("ses"),
-    ...input.parentSessionId ? { parentSessionId: input.parentSessionId } : {},
-    systemPrompt: input.systemPrompt,
-    input: input.input,
-    messages,
-    log: [],
-    skills: input.skills ?? [],
-    createdAt,
-    updatedAt: createdAt,
-    ...input.title ? { title: input.title } : {}
-  };
-}
-function appendUserTurn(session, input) {
-  session.messages.push(createMessage2("user", input));
-  session.updatedAt = createTimestamp();
-  return session;
-}
 
 // src/harness/session/session-manager.ts
 var SESSION_MANAGER_SCHEMA_VERSION = "0.4.4";
@@ -4214,8 +4040,6 @@ function summarizeSessionManagerRecords(records) {
 }
 
 // src/harness/session/jsonl.ts
-import { appendFile, mkdir as mkdir2, readFile as readFile5, readdir as readdir4, stat as stat3, unlink, writeFile as writeFile2 } from "fs/promises";
-import { join as join6, relative as relative3, resolve as resolve6, sep as sep3 } from "path";
 var SESSION_ID_PATTERN = /^ses_[A-Za-z0-9_-]+$/;
 function isPathInside(parent, child) {
   const relativePath = relative3(parent, child);
@@ -4237,7 +4061,7 @@ function parseRecord(line) {
   return value;
 }
 async function readRecords(path) {
-  const text = await readFile5(path, "utf8").catch((error) => {
+  const text = await readFile4(path, "utf8").catch((error) => {
     if (error.code === "ENOENT") {
       return void 0;
     }
@@ -4326,7 +4150,7 @@ var LocalJsonlSessionManager = class _LocalJsonlSessionManager {
     });
     const sessions = await Promise.all(
       entries.filter((entry) => entry.isFile() && entry.name.endsWith(".jsonl")).map(async (entry) => {
-        const path = join6(sessionsDir, entry.name);
+        const path = join4(sessionsDir, entry.name);
         const records = await readRecords(path);
         return records ? summarizeSessionManagerRecords(records) : void 0;
       })
@@ -4416,114 +4240,2004 @@ var LocalJsonlSessionManager = class _LocalJsonlSessionManager {
   }
 };
 
-// src/event-stream.ts
-var EventStream = class {
-  queue = [];
-  waiting = [];
-  done = false;
-  finalResultPromise;
-  resolveFinalResult;
-  isComplete;
-  extractResult;
-  constructor(isComplete, extractResult) {
-    this.isComplete = isComplete;
-    this.extractResult = extractResult;
-    this.finalResultPromise = new Promise((resolve7) => {
-      this.resolveFinalResult = resolve7;
-    });
+// src/harness/session/provider.ts
+var InMemorySessionProvider = class {
+  sessions = /* @__PURE__ */ new Map();
+  async create(input) {
+    const session = InMemorySessionManager.create(input);
+    this.sessions.set(session.getSessionId(), session);
+    return session;
+  }
+  async open(sessionId) {
+    return this.sessions.get(sessionId);
+  }
+};
+var LocalJsonlSessionProvider = class {
+  constructor(sessionsDir) {
+    this.sessionsDir = sessionsDir;
+  }
+  sessionsDir;
+  create(input) {
+    return LocalJsonlSessionManager.create(this.sessionsDir, input);
+  }
+  open(sessionId) {
+    return LocalJsonlSessionManager.open(this.sessionsDir, sessionId);
+  }
+  list() {
+    return LocalJsonlSessionManager.list(this.sessionsDir);
+  }
+};
+
+// src/runtime/tool-runtime.ts
+function failed(toolCall, message) {
+  return {
+    toolCallId: toolCall.id,
+    toolName: toolCall.name,
+    ok: false,
+    content: message,
+    error: message
+  };
+}
+function positiveLimit(value, fallback) {
+  if (value === void 0) return fallback;
+  if (!Number.isFinite(value) || value <= 0) {
+    throw new Error("Tool Runtime concurrency limits must be positive finite numbers.");
   }
-  push(event) {
-    if (this.done) return;
-    if (this.isComplete(event)) {
-      this.done = true;
-      this.resolveFinalResult(this.extractResult(event));
+  return Math.floor(value);
+}
+var ToolRuntime = class {
+  constructor(stateStore, policy = {}, onTransition = () => void 0) {
+    this.stateStore = stateStore;
+    this.onTransition = onTransition;
+    this.maxConcurrent = positiveLimit(policy.maxConcurrent, Number.MAX_SAFE_INTEGER);
+    this.perToolMaxConcurrent = Object.fromEntries(
+      Object.entries(policy.perToolMaxConcurrent ?? {}).map(([name, value]) => [name, positiveLimit(value, 1)])
+    );
+    this.allowedTools = policy.allowedTools ? new Set(policy.allowedTools) : void 0;
+  }
+  stateStore;
+  onTransition;
+  maxConcurrent;
+  perToolMaxConcurrent;
+  running = 0;
+  runningByTool = /* @__PURE__ */ new Map();
+  waiters = [];
+  activeToolCalls = /* @__PURE__ */ new Map();
+  allowedTools;
+  async execute(input) {
+    const call = await this.stateStore.createToolCall({
+      agentId: input.agentId,
+      runId: input.runId,
+      name: input.toolCall.name,
+      args: input.toolCall.args
+    });
+    await this.onTransition();
+    if (!input.tool || this.allowedTools && !this.allowedTools.has(input.tool.name)) {
+      const result = failed(input.toolCall, `Tool ${input.toolCall.name} is not permitted by Runtime policy.`);
+      await this.stateStore.completeToolCall({ toolCallId: call.id, result, state: "failed" });
+      await this.onTransition();
+      return result;
     }
-    const waiter = this.waiting.shift();
-    if (waiter) {
-      waiter({ value: event, done: false });
-    } else {
-      this.queue.push(event);
+    const before = await input.beforeToolCall?.({ tool: input.tool, args: input.toolCall.args });
+    if (before && !before.allow) {
+      const result = failed(input.toolCall, before.reason);
+      await this.stateStore.completeToolCall({ toolCallId: call.id, result, state: "failed" });
+      await this.onTransition();
+      return result;
+    }
+    let release;
+    const controller = new AbortController();
+    const forwardAbort = () => controller.abort(input.signal?.reason);
+    input.signal?.addEventListener("abort", forwardAbort, { once: true });
+    this.activeToolCalls.set(call.id, { runId: input.runId, controller });
+    try {
+      try {
+        release = await this.acquire(input.tool.name, controller.signal);
+      } catch (error) {
+        const result2 = failed(input.toolCall, error instanceof Error ? error.message : "Tool execution was cancelled.");
+        await this.stateStore.completeToolCall({ toolCallId: call.id, result: result2, state: "failed" });
+        await this.onTransition();
+        return result2;
+      }
+      if (controller.signal.aborted) {
+        const result2 = failed(input.toolCall, "Tool execution was aborted before it started.");
+        await this.stateStore.completeToolCall({ toolCallId: call.id, result: result2, state: "failed" });
+        await this.onTransition();
+        return result2;
+      }
+      await this.stateStore.startToolCall(call.id);
+      await this.onTransition();
+      let result;
+      try {
+        result = await input.tool.execute(input.toolCall.args, {
+          skills: input.context.skills,
+          toolCallId: call.id
+        }, controller.signal);
+      } catch (error) {
+        if (controller.signal.aborted) {
+          await this.stateStore.markToolCallIndeterminate({
+            toolCallId: call.id,
+            reason: error instanceof Error ? error.message : "Tool execution was interrupted."
+          });
+          await this.onTransition();
+          return failed(input.toolCall, "Tool Call became indeterminate after abort.");
+        }
+        result = failed(input.toolCall, error instanceof Error ? error.message : "Tool execution failed.");
+      }
+      if (controller.signal.aborted) {
+        await this.stateStore.markToolCallIndeterminate({ toolCallId: call.id, reason: "Tool execution was interrupted after it may have had an external effect." });
+        await this.onTransition();
+        return failed(input.toolCall, "Tool Call became indeterminate after abort.");
+      }
+      try {
+        result = await input.afterToolCall?.({ tool: input.tool, result }) ?? result;
+      } catch (error) {
+        result = failed(input.toolCall, error instanceof Error ? error.message : "Tool result review failed.");
+      }
+      await this.stateStore.completeToolCall({
+        toolCallId: call.id,
+        result,
+        state: result.ok ? "completed" : "failed"
+      });
+      await this.onTransition();
+      return result;
+    } finally {
+      input.signal?.removeEventListener("abort", forwardAbort);
+      this.activeToolCalls.delete(call.id);
+      release?.();
     }
   }
-  end(result) {
-    this.done = true;
-    if (result !== void 0) {
-      this.resolveFinalResult(result);
+  abortRun(runId) {
+    for (const active of this.activeToolCalls.values()) {
+      if (active.runId === runId) active.controller.abort("Agent Run aborted.");
     }
-    while (this.waiting.length > 0) {
-      const waiter = this.waiting.shift();
-      waiter({ value: void 0, done: true });
+  }
+  async acquire(toolName, signal) {
+    if (signal.aborted) throw new Error("Tool execution aborted while waiting for capacity.");
+    const limit = this.perToolMaxConcurrent[toolName] ?? this.maxConcurrent;
+    if (this.running < this.maxConcurrent && (this.runningByTool.get(toolName) ?? 0) < limit) {
+      return this.reserve(toolName);
     }
+    return new Promise((resolve7, reject) => {
+      let waiter;
+      const onAbort = () => {
+        const index = this.waiters.indexOf(waiter);
+        if (index >= 0) this.waiters.splice(index, 1);
+        reject(new Error("Tool execution aborted while waiting for capacity."));
+      };
+      waiter = { toolName, signal, onAbort, resolve: resolve7, reject };
+      this.waiters.push(waiter);
+      signal.addEventListener("abort", onAbort, { once: true });
+    });
+  }
+  reserve(toolName) {
+    this.running += 1;
+    this.runningByTool.set(toolName, (this.runningByTool.get(toolName) ?? 0) + 1);
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      this.running -= 1;
+      const count = (this.runningByTool.get(toolName) ?? 1) - 1;
+      if (count <= 0) this.runningByTool.delete(toolName);
+      else this.runningByTool.set(toolName, count);
+      this.pumpWaiters();
+    };
+  }
+  pumpWaiters() {
+    for (let index = 0; index < this.waiters.length; index += 1) {
+      const waiter = this.waiters[index];
+      const limit = this.perToolMaxConcurrent[waiter.toolName] ?? this.maxConcurrent;
+      if (this.running >= this.maxConcurrent || (this.runningByTool.get(waiter.toolName) ?? 0) >= limit) continue;
+      this.waiters.splice(index, 1);
+      waiter.signal.removeEventListener("abort", waiter.onAbort);
+      waiter.resolve(this.reserve(waiter.toolName));
+      index -= 1;
+    }
+  }
+};
+
+// src/runtime/agent-run.ts
+var AGENT_RUN_CONSTRUCTION = /* @__PURE__ */ Symbol("rowan.agentRun.construction");
+var CREATE_AGENT_RUN = /* @__PURE__ */ Symbol("rowan.agentRun.create");
+var AgentRun = class _AgentRun {
+  constructor(token, host, initial, publicMessageId) {
+    this.host = host;
+    this.publicMessageId = publicMessageId;
+    if (token !== AGENT_RUN_CONSTRUCTION) {
+      throw new Error("AgentRun lifecycle is owned by AgentRuntime.");
+    }
+    this.current = structuredClone(initial);
+    host.register(this);
+  }
+  host;
+  publicMessageId;
+  current;
+  listeners = /* @__PURE__ */ new Set();
+  static [CREATE_AGENT_RUN](host, initial, publicMessageId) {
+    return new _AgentRun(AGENT_RUN_CONSTRUCTION, host, initial, publicMessageId);
+  }
+  get id() {
+    return this.current.id;
+  }
+  get messageId() {
+    return this.publicMessageId;
+  }
+  get status() {
+    return this.current.state;
+  }
+  get state() {
+    return this.current.state;
+  }
+  async getStatus() {
+    const run = await this.host.getRun(this.id);
+    if (run) this.notify(run);
+    return this.current.state;
   }
-  async *[Symbol.asyncIterator]() {
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  consumeRuntimeEvents(consumerId, listener) {
+    return this.host.consumeEvents(consumerId, (event) => {
+      if (event.runId === this.id) return listener(event);
+    });
+  }
+  async result() {
     while (true) {
-      if (this.queue.length > 0) {
-        yield this.queue.shift();
-      } else if (this.done) {
+      const run = await this.host.getRun(this.id);
+      if (!run) throw new Error(`Agent Run not found: ${this.id}.`);
+      this.notify(run);
+      if (["completed", "failed", "cancelled"].includes(run.state)) {
+        if (!run.outcome) {
+          throw new Error(`Agent Run ${this.id} reached ${run.state} without an Outcome.`);
+        }
+        return structuredClone(run.outcome);
+      }
+      await this.host.waitForRunChange(this.id, run.state, run.updatedAt);
+    }
+  }
+  async abort(reason = "Agent Run aborted by caller.") {
+    await this.host.abortRun(this.id, reason);
+  }
+  notify(run) {
+    this.current = structuredClone(run);
+    for (const listener of this.listeners) {
+      try {
+        const result = listener(run.state);
+        if (result && typeof result.then === "function") {
+          void Promise.resolve(result).catch(() => void 0);
+        }
+      } catch {
+      }
+    }
+  }
+};
+function createAgentRun(host, initial, publicMessageId = initial.messageId) {
+  return AgentRun[CREATE_AGENT_RUN](host, initial, publicMessageId);
+}
+
+// src/runtime/agent-runtime.ts
+var InfrastructureFailureError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "InfrastructureFailureError";
+  }
+};
+var activeRuntime;
+var AgentRuntime = class _AgentRuntime {
+  stateStore;
+  sessionProvider;
+  maxConcurrentRuns;
+  maxInfrastructureAttempts;
+  leaseDurationMs;
+  leaseRenewalIntervalMs;
+  toolRuntime;
+  factories;
+  bindings = /* @__PURE__ */ new Map();
+  runHandles = /* @__PURE__ */ new Map();
+  runWaiters = /* @__PURE__ */ new Map();
+  pendingRuns = [];
+  scheduledRunIds = /* @__PURE__ */ new Set();
+  runningAgents = /* @__PURE__ */ new Set();
+  pausedAgents = /* @__PURE__ */ new Set();
+  eventSubscriptions = /* @__PURE__ */ new Map();
+  activeDispatches = /* @__PURE__ */ new Set();
+  runningRuns = 0;
+  pumping = false;
+  nextWorkerId = 0;
+  stopped = false;
+  constructor(options) {
+    this.stateStore = options.stateStore;
+    this.sessionProvider = options.sessionProvider;
+    this.maxConcurrentRuns = options.maxConcurrentRuns ?? Number.POSITIVE_INFINITY;
+    this.maxInfrastructureAttempts = options.maxInfrastructureAttempts ?? 3;
+    this.leaseDurationMs = options.leaseDurationMs ?? 6e4;
+    this.leaseRenewalIntervalMs = options.leaseRenewalIntervalMs ?? Math.max(1, Math.floor(this.leaseDurationMs / 2));
+    this.toolRuntime = new ToolRuntime(options.stateStore, options.toolPolicy, () => this.publishEvents());
+    this.factories = options.factories instanceof Map ? new Map([...options.factories.entries()].map(([id, factory]) => [String(id), factory])) : new Map(Object.entries(options.factories ?? {}));
+    for (const id of this.factories.keys()) {
+      if (id.trim().length === 0) throw new Error("Factory ID must not be empty.");
+    }
+  }
+  static async start(options) {
+    if (activeRuntime) {
+      throw new Error("Agent Runtime is already started in this process.");
+    }
+    if (!options.stateStore) {
+      throw new Error("Agent Runtime requires a RuntimeStateStore.");
+    }
+    if (!Number.isFinite(options.maxConcurrentRuns ?? 1) || (options.maxConcurrentRuns ?? 1) <= 0) {
+      throw new Error("Agent Runtime maxConcurrentRuns must be a positive finite number.");
+    }
+    if (!Number.isInteger(options.maxInfrastructureAttempts ?? 3) || (options.maxInfrastructureAttempts ?? 3) <= 0) {
+      throw new Error("Agent Runtime maxInfrastructureAttempts must be a positive integer.");
+    }
+    if (!Number.isFinite(options.leaseDurationMs ?? 6e4) || (options.leaseDurationMs ?? 6e4) <= 0) {
+      throw new Error("Agent Runtime leaseDurationMs must be a positive finite number.");
+    }
+    const leaseDurationMs = options.leaseDurationMs ?? 6e4;
+    const renewalIntervalMs = options.leaseRenewalIntervalMs ?? Math.max(1, Math.floor(leaseDurationMs / 2));
+    if (!Number.isFinite(renewalIntervalMs) || renewalIntervalMs <= 0 || renewalIntervalMs >= leaseDurationMs) {
+      throw new Error("Agent Runtime leaseRenewalIntervalMs must be positive and shorter than leaseDurationMs.");
+    }
+    const runtime = new _AgentRuntime(options);
+    activeRuntime = runtime;
+    try {
+      await runtime.recover();
+      return runtime;
+    } catch (error) {
+      await runtime.stop().catch(() => void 0);
+      throw error;
+    }
+  }
+  async createAgent(options) {
+    this.assertRunning();
+    if (options.factoryId !== void 0 && options.factoryId.trim().length === 0) {
+      throw new Error("Factory ID must not be empty.");
+    }
+    const provider = this.sessionProvider;
+    if (!provider) throw new Error("Agent Runtime requires a SessionManager provider to create an Agent.");
+    const manager = await provider.create({
+      systemPrompt: options.context.systemPrompt,
+      input: options.input ?? "",
+      skills: options.context.skills
+    });
+    if (options.input) await manager.appendMessage(createMessage("user", options.input));
+    const record = await this.stateStore.createAgent({
+      sessionId: manager.getSessionId(),
+      ...options.factoryId ? { factoryId: options.factoryId } : {}
+    });
+    this.pausedAgents.delete(record.id);
+    const agent = await this.attachAgent(record, manager, options);
+    this.publishEvents();
+    return agent;
+  }
+  async reconstructAgent(agentId, options) {
+    this.assertRunning();
+    const record = await this.stateStore.getAgent(agentId);
+    if (!record) throw new Error(`Agent not found: ${agentId}.`);
+    if (record.state === "paused") this.pausedAgents.add(record.id);
+    else this.pausedAgents.delete(record.id);
+    const provider = this.sessionProvider;
+    if (!provider) throw new Error("Agent Runtime requires a SessionManager provider to reconstruct an Agent.");
+    const manager = await provider.open(record.sessionId);
+    if (!manager) throw new Error(`Session not found: ${record.sessionId}.`);
+    const agent = await this.attachAgent(record, manager, options);
+    this.publishEvents();
+    return agent;
+  }
+  async stop() {
+    if (this.stopped) return;
+    this.stopped = true;
+    for (const binding of this.bindings.values()) {
+      binding.abort("Agent Runtime stopped.");
+    }
+    this.bindings.clear();
+    this.pendingRuns.length = 0;
+    this.scheduledRunIds.clear();
+    this.pausedAgents.clear();
+    const activeDispatches = [...this.activeDispatches];
+    this.runHandles.clear();
+    for (const waiters of this.runWaiters.values()) {
+      for (const resolve7 of waiters) resolve7();
+    }
+    this.runWaiters.clear();
+    this.eventSubscriptions.clear();
+    await Promise.allSettled(activeDispatches);
+    if (activeRuntime === this) activeRuntime = void 0;
+  }
+  bindAgent(agentId, agent) {
+    this.assertRunning();
+    if (this.bindings.has(agentId)) {
+      throw new Error(`Agent ${agentId} is already bound to a live Agent.`);
+    }
+    this.bindings.set(agentId, agent);
+    if (!this.pausedAgents.has(agentId)) void this.scheduleQueuedRuns(agentId);
+  }
+  registerRunHandle(runId, handle) {
+    this.runHandles.set(runId, handle);
+  }
+  waitForRunChange(runId, state, updatedAt) {
+    return new Promise((resolve7) => {
+      const waiters = this.runWaiters.get(runId) ?? /* @__PURE__ */ new Set();
+      let settled = false;
+      const finish = () => {
+        if (settled) return;
+        settled = true;
+        waiters.delete(finish);
+        if (waiters.size === 0) this.runWaiters.delete(runId);
+        resolve7();
+      };
+      waiters.add(finish);
+      this.runWaiters.set(runId, waiters);
+      void this.stateStore.getRun(runId).then((current) => {
+        if (!current || current.state !== state || current.updatedAt !== updatedAt) finish();
+      }, finish);
+    });
+  }
+  scheduleRun(agentId, runId) {
+    this.assertRunning();
+    if (this.scheduledRunIds.has(runId)) return;
+    this.scheduledRunIds.add(runId);
+    this.pendingRuns.push({ agentId, runId });
+    void this.pump();
+  }
+  async pauseAgent(agentId) {
+    this.assertRunning();
+    this.pausedAgents.add(agentId);
+    try {
+      await this.stateStore.setAgentState(agentId, "paused");
+    } catch (error) {
+      this.pausedAgents.delete(agentId);
+      throw error;
+    }
+    this.publishEvents();
+  }
+  async resumeAgent(agentId) {
+    this.assertRunning();
+    await this.stateStore.setAgentState(agentId, "active");
+    this.pausedAgents.delete(agentId);
+    await this.scheduleQueuedRuns(agentId);
+    void this.pump();
+    this.publishEvents();
+  }
+  async abortRun(runId, reason = "Agent Run aborted by caller.") {
+    const run = await this.stateStore.getRun(runId);
+    if (!run || ["completed", "failed", "cancelled"].includes(run.state)) return;
+    const aborted = await this.stateStore.abortRun({
+      runId,
+      outcome: { id: createId("out"), message: reason }
+    });
+    this.notifyRun(aborted);
+    if (run.state === "queued") {
+      const pendingIndex = this.pendingRuns.findIndex((job) => job.runId === runId);
+      if (pendingIndex >= 0) this.pendingRuns.splice(pendingIndex, 1);
+      this.scheduledRunIds.delete(runId);
+    }
+    this.toolRuntime.abortRun(runId);
+    if (run.state === "running" || run.state === "suspended") {
+      this.bindings.get(aborted.agentId)?.abort(reason);
+    }
+    this.publishEvents();
+  }
+  consumeEvents(consumerId, listener) {
+    this.assertRunning();
+    if (consumerId.trim().length === 0) {
+      throw new Error("Runtime Event Consumer ID must not be empty.");
+    }
+    if (this.eventSubscriptions.has(consumerId)) {
+      throw new Error(`Runtime Event Consumer is already active: ${consumerId}.`);
+    }
+    const subscription = {
+      consumerId,
+      listener,
+      delivering: false,
+      redeliver: false
+    };
+    this.eventSubscriptions.set(consumerId, subscription);
+    void this.deliverEvents(subscription).catch(() => void 0);
+    return () => {
+      if (this.eventSubscriptions.get(consumerId) === subscription) {
+        this.eventSubscriptions.delete(consumerId);
+      }
+    };
+  }
+  async listEvents(cursor) {
+    return this.stateStore.listEvents(cursor);
+  }
+  async recover() {
+    await this.stateStore.recoverLeases();
+    const agents = await this.stateStore.listAgents();
+    for (const record of agents) {
+      if (record.state === "paused") this.pausedAgents.add(record.id);
+    }
+    for (const record of agents) {
+      if (record.state !== "active" || !record.factoryId) continue;
+      const factory = this.factories.get(String(record.factoryId));
+      if (!factory) {
+        await this.stateStore.recordEvent({ kind: "factory_missing", related: { agentId: record.id }, payload: { factoryId: record.factoryId } });
+        continue;
+      }
+      try {
+        const options = await factory({ agentId: record.id, sessionId: record.sessionId, factoryId: record.factoryId });
+        if (!options) {
+          await this.stateStore.recordEvent({
+            kind: "agent_recovery_failed",
+            related: { agentId: record.id },
+            payload: { factoryId: record.factoryId, error: "Factory returned no reconstruction options." }
+          });
+          continue;
+        }
+        await this.reconstructAgent(record.id, options);
+        await this.stateStore.recordEvent({ kind: "agent_recovered", related: { agentId: record.id }, payload: { factoryId: record.factoryId } });
+      } catch (error) {
+        await this.stateStore.recordEvent({ kind: "agent_recovery_failed", related: { agentId: record.id }, payload: { factoryId: record.factoryId, error: error instanceof Error ? error.message : String(error) } });
+      }
+    }
+    for (const record of await this.stateStore.listAgents()) {
+      if (this.bindings.has(record.id)) await this.scheduleQueuedRuns(record.id);
+    }
+    this.publishEvents();
+  }
+  async scheduleQueuedRuns(agentId) {
+    if (!this.bindings.has(agentId)) return;
+    const runs = await this.stateStore.listRuns({ agentId, states: ["queued"] });
+    for (const run of runs) this.scheduleRun(agentId, run.id);
+  }
+  async attachAgent(record, manager, options) {
+    const attached = await attachAgent({
+      options,
+      agentId: record.id,
+      sessionId: record.sessionId,
+      manager,
+      submit: (message, persist) => this.submitAgentInput(record.id, message, persist),
+      executeTool: (input) => this.toolRuntime.execute(input)
+    });
+    this.bindAgent(record.id, attached.binding);
+    return attached.agent;
+  }
+  async submitAgentInput(agentId, input, persist) {
+    this.assertRunning();
+    if (!this.bindings.has(agentId)) throw new Error(`Agent ${agentId} has no live Agent Binding.`);
+    const enqueued = await this.stateStore.enqueueAgentInput({ agentId, input });
+    await persist();
+    const run = createAgentRun({
+      register: (handle) => this.registerRunHandle(enqueued.run.id, handle),
+      getRun: (runId) => this.stateStore.getRun(runId),
+      waitForRunChange: (runId, state, updatedAt) => this.waitForRunChange(runId, state, updatedAt),
+      abortRun: (runId, reason) => this.abortRun(runId, reason),
+      consumeEvents: (consumerId, listener) => this.consumeEvents(consumerId, listener)
+    }, enqueued.run, input.id);
+    this.scheduleRun(agentId, enqueued.run.id);
+    this.publishEvents();
+    return run;
+  }
+  async pump() {
+    if (this.pumping || this.stopped) return;
+    this.pumping = true;
+    try {
+      while (this.runningRuns < this.maxConcurrentRuns) {
+        const index = this.pendingRuns.findIndex((job2) => this.bindings.has(job2.agentId) && !this.pausedAgents.has(job2.agentId) && !this.runningAgents.has(job2.agentId));
+        if (index < 0) return;
+        const [job] = this.pendingRuns.splice(index, 1);
+        if (!job) return;
+        this.runningRuns += 1;
+        this.runningAgents.add(job.agentId);
+        let dispatch;
+        dispatch = this.dispatchRun(job).finally(() => {
+          this.runningRuns -= 1;
+          this.runningAgents.delete(job.agentId);
+          this.scheduledRunIds.delete(job.runId);
+          this.activeDispatches.delete(dispatch);
+          void this.pump();
+        });
+        this.activeDispatches.add(dispatch);
+        void dispatch;
+      }
+    } finally {
+      this.pumping = false;
+    }
+  }
+  async dispatchRun(job) {
+    const binding = this.bindings.get(job.agentId);
+    if (!binding) return;
+    const workerId = `runtime-worker-${++this.nextWorkerId}`;
+    let suspendedResolve;
+    let suspended = false;
+    const suspendedSignal = new Promise((resolve7) => {
+      suspendedResolve = resolve7;
+    });
+    const control = {
+      suspend: async (reason) => {
+        if (suspended) return;
+        suspended = true;
+        const current = await this.stateStore.suspendRun({ runId: job.runId, reason });
+        this.notifyRun(current);
+        this.publishEvents();
+        suspendedResolve?.();
+      }
+    };
+    let renewalTimer;
+    let renewalFailed = false;
+    let failRenewal;
+    const renewalFailureSignal = new Promise((resolve7) => {
+      failRenewal = resolve7;
+    });
+    try {
+      const leased = await this.stateStore.leaseRun({
+        runId: job.runId,
+        workerId,
+        leaseDurationMs: this.leaseDurationMs
+      });
+      this.notifyRun(leased.run);
+      renewalTimer = setInterval(() => {
+        void this.stateStore.renewLease({
+          runId: job.runId,
+          leaseId: leased.lease.id,
+          leaseDurationMs: this.leaseDurationMs
+        }).catch((error) => {
+          if (renewalFailed) return;
+          renewalFailed = true;
+          const failure = new InfrastructureFailureError("Agent Run Lease renewal failed.", { cause: error });
+          binding.abort(failure.message);
+          failRenewal(failure);
+        });
+      }, this.leaseRenewalIntervalMs);
+      const execution = binding.execute(leased.message.input, job.runId, control);
+      const outcome = await Promise.race([
+        execution.then((value) => ({ kind: "terminal", value })).catch((error) => ({ kind: "error", error })),
+        suspendedSignal.then(() => ({ kind: "suspended" })),
+        renewalFailureSignal.then((error) => ({ kind: "renewal_failure", error }))
+      ]);
+      if (outcome.kind === "suspended") {
+        void execution.catch(() => void 0);
+        return;
+      }
+      if (outcome.kind === "error") {
+        await this.finishFailedRun(job, outcome.error);
         return;
-      } else {
-        const result = await new Promise((resolve7) => this.waiting.push(resolve7));
-        if (result.done) return;
-        yield result.value;
       }
+      if (outcome.kind === "renewal_failure") {
+        await execution.catch(() => void 0);
+        await this.finishFailedRun(job, outcome.error);
+        return;
+      }
+      await this.finishRun(job, outcome.value);
+    } catch (error) {
+      const current = await this.stateStore.getRun(job.runId);
+      if (!current || ["completed", "failed", "cancelled", "suspended"].includes(current.state)) {
+        if (current) this.notifyRun(current);
+        return;
+      }
+      if (current.state !== "running") {
+        this.notifyRun(current);
+        return;
+      }
+      await this.finishFailedRun(job, error);
+    } finally {
+      if (renewalTimer) clearInterval(renewalTimer);
     }
   }
-  result() {
-    return this.finalResultPromise;
+  async finishRun(job, outcome) {
+    const current = await this.stateStore.getRun(job.runId);
+    if (!current || ["completed", "failed", "cancelled"].includes(current.state)) {
+      if (current) this.notifyRun(current);
+      return;
+    }
+    const completed = await this.stateStore.completeRun({ runId: current.id, outcome });
+    this.notifyRun(completed);
+    this.publishEvents();
+  }
+  async finishFailedRun(job, error) {
+    const current = await this.stateStore.getRun(job.runId);
+    if (!current || ["completed", "failed", "cancelled"].includes(current.state)) {
+      if (current) this.notifyRun(current);
+      return;
+    }
+    const message = error instanceof Error ? error.message : "Agent Run failed.";
+    const outcome = { id: createId("out"), message };
+    const retryable = isRetryableInfrastructureError(error);
+    if (retryable && current.attempt < this.maxInfrastructureAttempts) {
+      const retried = await this.stateStore.retryRun({ runId: current.id, reason: message });
+      this.notifyRun(retried);
+      this.pendingRuns.push(job);
+      this.publishEvents();
+      return;
+    }
+    const failed2 = retryable ? await this.stateStore.exhaustRun({ runId: current.id, outcome, reason: message }) : await this.stateStore.completeRun({ runId: current.id, state: "failed", outcome });
+    this.notifyRun(failed2);
+    this.publishEvents();
+  }
+  notifyRun(run) {
+    this.runHandles.get(run.id)?.notify(run);
+    const waiters = this.runWaiters.get(run.id);
+    if (!waiters) return;
+    this.runWaiters.delete(run.id);
+    for (const resolve7 of waiters) resolve7();
+  }
+  publishEvents() {
+    for (const subscription of this.eventSubscriptions.values()) {
+      void this.deliverEvents(subscription).catch(() => void 0);
+    }
+  }
+  async deliverEvents(subscription) {
+    if (subscription.delivering) {
+      subscription.redeliver = true;
+      return;
+    }
+    subscription.delivering = true;
+    try {
+      do {
+        subscription.redeliver = false;
+        const checkpoint = await this.stateStore.getEventCheckpoint(subscription.consumerId);
+        const events = await this.stateStore.listEvents(
+          checkpoint.eventId ? { after: checkpoint.eventId } : void 0
+        );
+        for (const event of events) {
+          if (this.eventSubscriptions.get(subscription.consumerId) !== subscription) return;
+          await subscription.listener(structuredClone(event));
+          await this.stateStore.acknowledgeEvent(subscription.consumerId, event.id);
+        }
+      } while (subscription.redeliver);
+    } finally {
+      subscription.delivering = false;
+    }
+  }
+  assertRunning() {
+    if (this.stopped || activeRuntime !== this) throw new Error("Agent Runtime is stopped.");
   }
 };
-var AgentEventStream = class extends EventStream {
-  constructor() {
-    super(
-      (event) => event.type === "agent_end",
-      (event) => event.type === "agent_end" ? event.messages : []
+function isRetryableInfrastructureError(error) {
+  if (error instanceof InfrastructureFailureError) return true;
+  return typeof error === "object" && error !== null && "retryable" in error && error.retryable === true;
+}
+
+// src/runtime/memory-store.ts
+function clone2(value) {
+  return structuredClone(value);
+}
+function transitionError(entity, id, state, action) {
+  return new Error(`Cannot ${action} ${entity} ${id} from state "${state}".`);
+}
+function requireTransition(entity, id, state, action, allowedStates) {
+  if (!allowedStates.includes(state)) {
+    throw transitionError(entity, id, state, action);
+  }
+}
+function now(input) {
+  const date = input ? new Date(input) : /* @__PURE__ */ new Date();
+  return { date, timestamp: createTimestamp(date) };
+}
+var InMemoryRuntimeStateStore = class {
+  agents = /* @__PURE__ */ new Map();
+  messages = /* @__PURE__ */ new Map();
+  runs = /* @__PURE__ */ new Map();
+  toolCalls = /* @__PURE__ */ new Map();
+  events = [];
+  eventCheckpoints = /* @__PURE__ */ new Map();
+  async createAgent(input) {
+    const { timestamp } = now();
+    const agent = {
+      id: createId("agt"),
+      sessionId: input.sessionId,
+      ...input.factoryId ? { factoryId: input.factoryId } : {},
+      state: "active",
+      createdAt: timestamp,
+      updatedAt: timestamp
+    };
+    this.agents.set(agent.id, agent);
+    this.recordEvent("agent_created", { agentId: agent.id });
+    return clone2(agent);
+  }
+  async getAgent(agentId) {
+    const agent = this.agents.get(agentId);
+    return agent ? clone2(agent) : void 0;
+  }
+  async listAgents() {
+    return clone2([...this.agents.values()]);
+  }
+  async setAgentState(agentId, state) {
+    const agent = this.requireAgent(agentId);
+    if (agent.state === state) return clone2(agent);
+    const { timestamp } = now();
+    agent.state = state;
+    agent.updatedAt = timestamp;
+    this.recordEvent(state === "paused" ? "agent_paused" : "agent_resumed", { agentId });
+    return clone2(agent);
+  }
+  async enqueueAgentInput(input) {
+    this.requireAgent(input.agentId);
+    const suspended = [...this.runs.values()].filter((run2) => run2.agentId === input.agentId && run2.state === "suspended").sort((a, b) => a.createdAt.localeCompare(b.createdAt))[0];
+    const { timestamp } = now();
+    const messageId = createId("rmsg");
+    const runId = suspended?.id ?? createId("run");
+    const message = {
+      id: messageId,
+      agentId: input.agentId,
+      kind: "agent_input",
+      input: clone2(input.input),
+      state: "queued",
+      attempts: 0,
+      runId,
+      createdAt: timestamp,
+      updatedAt: timestamp
+    };
+    if (suspended) {
+      suspended.state = "queued";
+      suspended.messageId = messageId;
+      delete suspended.suspensionReason;
+      suspended.updatedAt = timestamp;
+      message.runId = suspended.id;
+    }
+    const run = {
+      id: runId,
+      agentId: input.agentId,
+      messageId,
+      state: "queued",
+      attempt: 0,
+      createdAt: timestamp,
+      updatedAt: timestamp
+    };
+    this.messages.set(message.id, message);
+    this.runs.set(run.id, suspended ?? run);
+    this.recordEvent("message_enqueued", { agentId: input.agentId, messageId });
+    this.recordEvent("run_enqueued", { agentId: input.agentId, messageId, runId });
+    return { message: clone2(message), run: clone2(suspended ?? run), resumed: Boolean(suspended) };
+  }
+  async getMessage(messageId) {
+    const message = this.messages.get(messageId);
+    return message ? clone2(message) : void 0;
+  }
+  async getRun(runId) {
+    const run = this.runs.get(runId);
+    return run ? clone2(run) : void 0;
+  }
+  async listRuns(input = {}) {
+    return clone2([...this.runs.values()].filter((run) => input.agentId === void 0 || run.agentId === input.agentId).filter((run) => !input.states || input.states.includes(run.state)).sort((a, b) => a.createdAt.localeCompare(b.createdAt)));
+  }
+  async leaseRun(input) {
+    const run = this.requireRun(input.runId);
+    requireTransition("Agent Run", run.id, run.state, "lease", ["queued"]);
+    const message = this.requireMessage(run.messageId);
+    requireTransition("Runtime Message", message.id, message.state, "lease", ["queued"]);
+    const agent = this.requireAgent(run.agentId);
+    if (agent.state !== "active") {
+      throw transitionError("Agent", agent.id, agent.state, "lease a Run for");
+    }
+    if ([...this.runs.values()].some(
+      (candidate) => candidate.agentId === run.agentId && candidate.id !== run.id && (candidate.state === "running" || candidate.state === "suspended")
+    )) {
+      throw new Error(`Agent ${run.agentId} already has an active Run.`);
+    }
+    if (!Number.isFinite(input.leaseDurationMs) || input.leaseDurationMs <= 0) {
+      throw new Error("Lease duration must be a positive finite number.");
+    }
+    const { date, timestamp } = now(input.now);
+    const lease = {
+      id: createId("lease"),
+      runId: run.id,
+      workerId: input.workerId,
+      leasedAt: timestamp,
+      expiresAt: createTimestamp(new Date(date.getTime() + input.leaseDurationMs))
+    };
+    run.state = "running";
+    run.attempt += 1;
+    run.leaseId = lease.id;
+    run.updatedAt = timestamp;
+    message.state = "leased";
+    message.attempts += 1;
+    message.lease = lease;
+    message.updatedAt = timestamp;
+    this.recordEvent("run_leased", { agentId: run.agentId, messageId: message.id, runId: run.id }, lease);
+    return { run: clone2(run), message: clone2(message), lease: clone2(lease) };
+  }
+  async renewLease(input) {
+    const run = this.requireRun(input.runId);
+    requireTransition("Agent Run", run.id, run.state, "renew Lease", ["running"]);
+    const message = this.requireMessage(run.messageId);
+    requireTransition("Runtime Message", message.id, message.state, "renew Lease", ["leased"]);
+    if (run.leaseId !== input.leaseId || message.lease?.id !== input.leaseId) {
+      throw new Error(`Lease ${input.leaseId} does not own Agent Run ${run.id}.`);
+    }
+    if (!Number.isFinite(input.leaseDurationMs) || input.leaseDurationMs <= 0) {
+      throw new Error("Lease duration must be a positive finite number.");
+    }
+    const { date, timestamp } = now(input.now);
+    const lease = {
+      ...message.lease,
+      expiresAt: createTimestamp(new Date(date.getTime() + input.leaseDurationMs))
+    };
+    message.lease = lease;
+    message.updatedAt = timestamp;
+    return clone2(lease);
+  }
+  async suspendRun(input) {
+    const run = this.requireRun(input.runId);
+    requireTransition("Agent Run", run.id, run.state, "suspend", ["running"]);
+    const message = this.requireMessage(run.messageId);
+    const { timestamp } = now();
+    run.state = "suspended";
+    run.suspensionReason = input.reason;
+    delete run.leaseId;
+    run.updatedAt = timestamp;
+    requireTransition("Runtime Message", message.id, message.state, "acknowledge", ["leased"]);
+    message.state = "acknowledged";
+    delete message.lease;
+    message.updatedAt = timestamp;
+    this.recordEvent("run_suspended", { agentId: run.agentId, messageId: message.id, runId: run.id }, {
+      reason: input.reason
+    });
+    return clone2(run);
+  }
+  async completeRun(input) {
+    const run = this.requireRun(input.runId);
+    requireTransition("Agent Run", run.id, run.state, "complete", ["running"]);
+    const message = this.requireMessage(run.messageId);
+    requireTransition("Runtime Message", message.id, message.state, "acknowledge", ["leased"]);
+    const { timestamp } = now();
+    const state = input.state ?? "completed";
+    run.state = state;
+    run.outcome = clone2(input.outcome);
+    delete run.leaseId;
+    run.updatedAt = timestamp;
+    message.state = "acknowledged";
+    delete message.lease;
+    message.updatedAt = timestamp;
+    this.recordEvent("run_completed", { agentId: run.agentId, messageId: run.messageId, runId: run.id }, {
+      state,
+      outcome: input.outcome
+    });
+    this.recordEvent("message_acknowledged", { agentId: message.agentId, messageId: message.id });
+    return clone2(run);
+  }
+  async retryRun(input) {
+    const run = this.requireRun(input.runId);
+    requireTransition("Agent Run", run.id, run.state, "retry", ["running"]);
+    const message = this.requireMessage(run.messageId);
+    requireTransition("Runtime Message", message.id, message.state, "retry", ["leased"]);
+    const { timestamp } = now();
+    run.state = "queued";
+    delete run.leaseId;
+    run.updatedAt = timestamp;
+    message.state = "queued";
+    delete message.lease;
+    message.updatedAt = timestamp;
+    this.recordEvent("run_retry_scheduled", {
+      agentId: run.agentId,
+      messageId: message.id,
+      runId: run.id
+    }, { reason: input.reason, attempt: run.attempt });
+    return clone2(run);
+  }
+  async exhaustRun(input) {
+    const run = this.requireRun(input.runId);
+    requireTransition("Agent Run", run.id, run.state, "exhaust retries", ["running"]);
+    const message = this.requireMessage(run.messageId);
+    requireTransition("Runtime Message", message.id, message.state, "dead-letter", ["leased"]);
+    const { timestamp } = now();
+    run.state = "failed";
+    run.outcome = clone2(input.outcome);
+    delete run.leaseId;
+    run.updatedAt = timestamp;
+    message.state = "dead_lettered";
+    message.deadLetterReason = input.reason;
+    delete message.lease;
+    message.updatedAt = timestamp;
+    this.recordEvent("run_completed", { agentId: run.agentId, messageId: message.id, runId: run.id }, {
+      state: "failed",
+      outcome: input.outcome
+    });
+    this.recordEvent("message_dead_lettered", { agentId: run.agentId, messageId: message.id }, {
+      reason: input.reason
+    });
+    return clone2(run);
+  }
+  async abortRun(input) {
+    const run = this.requireRun(input.runId);
+    requireTransition("Agent Run", run.id, run.state, "abort", ["queued", "running", "suspended"]);
+    const message = this.requireMessage(run.messageId);
+    const { timestamp } = now();
+    run.state = "cancelled";
+    run.outcome = clone2(input.outcome);
+    delete run.leaseId;
+    run.updatedAt = timestamp;
+    if (message.state === "queued" || message.state === "leased") {
+      message.state = "acknowledged";
+      delete message.lease;
+      message.updatedAt = timestamp;
+    }
+    this.recordEvent("run_aborted", { agentId: run.agentId, messageId: message.id, runId: run.id }, {
+      outcome: input.outcome
+    });
+    return clone2(run);
+  }
+  async recoverExpiredLeases(input) {
+    const { date, timestamp } = now(input);
+    const recovered = [];
+    for (const run of this.runs.values()) {
+      if (run.state !== "running" || !run.leaseId) continue;
+      const message = this.requireMessage(run.messageId);
+      if (message.state !== "leased" || !message.lease || Date.parse(message.lease.expiresAt) > date.getTime()) continue;
+      run.state = "queued";
+      delete run.leaseId;
+      run.updatedAt = timestamp;
+      message.state = "queued";
+      delete message.lease;
+      message.updatedAt = timestamp;
+      this.recordEvent("lease_expired", { agentId: run.agentId, messageId: message.id, runId: run.id });
+      recovered.push(clone2(run));
+    }
+    return recovered;
+  }
+  async recoverLeases() {
+    const { timestamp } = now();
+    const recovered = [];
+    for (const run of this.runs.values()) {
+      if (run.state !== "running" || !run.leaseId) continue;
+      const message = this.requireMessage(run.messageId);
+      if (message.state !== "leased" || !message.lease) continue;
+      run.state = "queued";
+      delete run.leaseId;
+      run.updatedAt = timestamp;
+      message.state = "queued";
+      delete message.lease;
+      message.updatedAt = timestamp;
+      this.recordEvent("lease_recovered", { agentId: run.agentId, messageId: message.id, runId: run.id });
+      recovered.push(clone2(run));
+    }
+    return recovered;
+  }
+  async createToolCall(input) {
+    this.requireAgent(input.agentId);
+    this.requireRun(input.runId);
+    const { timestamp } = now();
+    const toolCall = {
+      id: createId("call"),
+      agentId: input.agentId,
+      runId: input.runId,
+      name: input.name,
+      args: clone2(input.args),
+      state: "queued",
+      createdAt: timestamp,
+      updatedAt: timestamp
+    };
+    this.toolCalls.set(toolCall.id, toolCall);
+    this.recordEvent("tool_call_created", { agentId: input.agentId, runId: input.runId, toolCallId: toolCall.id });
+    return clone2(toolCall);
+  }
+  async startToolCall(toolCallId) {
+    const toolCall = this.requireToolCall(toolCallId);
+    requireTransition("Tool Call", toolCall.id, toolCall.state, "start", ["queued"]);
+    const { timestamp } = now();
+    toolCall.state = "running";
+    toolCall.updatedAt = timestamp;
+    this.recordEvent("tool_call_started", { agentId: toolCall.agentId, runId: toolCall.runId, toolCallId: toolCall.id });
+    return clone2(toolCall);
+  }
+  async completeToolCall(input) {
+    const toolCall = this.requireToolCall(input.toolCallId);
+    const state = input.state ?? (input.result.ok ? "completed" : "failed");
+    requireTransition(
+      "Tool Call",
+      toolCall.id,
+      toolCall.state,
+      "complete",
+      state === "failed" ? ["queued", "running"] : ["running"]
     );
+    const { timestamp } = now();
+    toolCall.state = state;
+    toolCall.result = clone2(input.result);
+    toolCall.updatedAt = timestamp;
+    this.recordEvent(state === "failed" ? "tool_call_failed" : "tool_call_completed", {
+      agentId: toolCall.agentId,
+      runId: toolCall.runId,
+      toolCallId: toolCall.id
+    }, { state: toolCall.state });
+    return clone2(toolCall);
+  }
+  async markToolCallIndeterminate(input) {
+    const toolCall = this.requireToolCall(input.toolCallId);
+    requireTransition("Tool Call", toolCall.id, toolCall.state, "mark indeterminate", ["running"]);
+    const { timestamp } = now();
+    toolCall.state = "indeterminate";
+    toolCall.indeterminateReason = input.reason;
+    toolCall.updatedAt = timestamp;
+    this.recordEvent("tool_call_indeterminate", {
+      agentId: toolCall.agentId,
+      runId: toolCall.runId,
+      toolCallId: toolCall.id
+    }, { reason: input.reason });
+    return clone2(toolCall);
+  }
+  async getToolCall(toolCallId) {
+    const toolCall = this.toolCalls.get(toolCallId);
+    return toolCall ? clone2(toolCall) : void 0;
+  }
+  async listEvents(cursor = {}) {
+    let events = this.events;
+    if (cursor.after) {
+      const index = events.findIndex((event) => event.id === cursor.after);
+      if (index >= 0) events = events.slice(index + 1);
+    }
+    return clone2(cursor.limit === void 0 ? events : events.slice(0, cursor.limit));
+  }
+  async recordEvent(input, related = {}, payload) {
+    this.recordEventInternal(typeof input === "string" ? input : input.kind, typeof input === "string" ? related : input.related ?? {}, typeof input === "string" ? payload : input.payload);
+    return clone2(this.events.at(-1));
+  }
+  async getEventCheckpoint(consumerId) {
+    return clone2(this.eventCheckpoints.get(consumerId) ?? {
+      consumerId,
+      sequence: 0,
+      updatedAt: createTimestamp(/* @__PURE__ */ new Date(0))
+    });
+  }
+  async acknowledgeEvent(consumerId, eventId) {
+    const event = this.events.find((candidate) => candidate.id === eventId);
+    if (!event) throw new Error(`Runtime Event not found: ${eventId}.`);
+    const current = await this.getEventCheckpoint(consumerId);
+    if (event.sequence <= current.sequence) return current;
+    if (event.sequence !== current.sequence + 1) {
+      throw new Error(`Runtime Event Consumer Checkpoint cannot advance from sequence ${current.sequence} to ${event.sequence}.`);
+    }
+    const checkpoint = {
+      consumerId,
+      sequence: event.sequence,
+      eventId: event.id,
+      updatedAt: createTimestamp()
+    };
+    this.eventCheckpoints.set(consumerId, checkpoint);
+    return clone2(checkpoint);
+  }
+  requireAgent(agentId) {
+    const agent = this.agents.get(agentId);
+    if (!agent) {
+      throw new Error(`Agent not found: ${agentId}.`);
+    }
+    return agent;
+  }
+  requireMessage(messageId) {
+    const message = this.messages.get(messageId);
+    if (!message) {
+      throw new Error(`Runtime Message not found: ${messageId}.`);
+    }
+    return message;
+  }
+  requireRun(runId) {
+    const run = this.runs.get(runId);
+    if (!run) {
+      throw new Error(`Agent Run not found: ${runId}.`);
+    }
+    return run;
+  }
+  requireToolCall(toolCallId) {
+    const toolCall = this.toolCalls.get(toolCallId);
+    if (!toolCall) {
+      throw new Error(`Tool Call not found: ${toolCallId}.`);
+    }
+    return toolCall;
+  }
+  recordEventInternal(kind, related, payload) {
+    this.events.push({
+      id: createId("evt"),
+      sequence: this.events.length + 1,
+      kind,
+      ...related,
+      ...payload !== void 0 ? { payload: clone2(payload) } : {},
+      createdAt: createTimestamp()
+    });
   }
 };
 
-// src/index.ts
-import {
-  createDispatchStream,
-  registerBuiltInApiProviders
-} from "@rowan-agent/models";
+// src/runtime/sqlite-store.ts
+import { Database } from "bun:sqlite";
+
+// src/runtime/runtime-schema.ts
+var RUNTIME_SCHEMA_SQL = `
+    CREATE TABLE IF NOT EXISTS agents (
+      id TEXT PRIMARY KEY NOT NULL,
+      session_id TEXT NOT NULL,
+      factory_id TEXT,
+      state TEXT NOT NULL CHECK (state IN ('active', 'paused')),
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS runtime_messages (
+      id TEXT PRIMARY KEY NOT NULL,
+      agent_id TEXT NOT NULL REFERENCES agents(id),
+      kind TEXT NOT NULL CHECK (kind IN ('agent_input')),
+      payload_json TEXT NOT NULL,
+      state TEXT NOT NULL CHECK (state IN ('queued', 'leased', 'acknowledged', 'dead_lettered')),
+      attempts INTEGER NOT NULL DEFAULT 0,
+      run_id TEXT,
+      dead_letter_reason TEXT,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS agent_runs (
+      id TEXT PRIMARY KEY NOT NULL,
+      agent_id TEXT NOT NULL REFERENCES agents(id),
+      message_id TEXT NOT NULL REFERENCES runtime_messages(id),
+      state TEXT NOT NULL CHECK (state IN ('queued', 'running', 'suspended', 'completed', 'failed', 'cancelled')),
+      attempt INTEGER NOT NULL DEFAULT 0,
+      lease_id TEXT,
+      outcome_json TEXT,
+      suspension_reason TEXT,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS runtime_leases (
+      id TEXT PRIMARY KEY NOT NULL,
+      run_id TEXT NOT NULL UNIQUE REFERENCES agent_runs(id),
+      worker_id TEXT NOT NULL,
+      leased_at TEXT NOT NULL,
+      expires_at TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS runtime_events (
+      id TEXT PRIMARY KEY NOT NULL,
+      sequence INTEGER NOT NULL DEFAULT 0,
+      kind TEXT NOT NULL,
+      agent_id TEXT,
+      message_id TEXT,
+      run_id TEXT,
+      tool_call_id TEXT,
+      payload_json TEXT,
+      created_at TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS runtime_tool_calls (
+      id TEXT PRIMARY KEY NOT NULL,
+      agent_id TEXT NOT NULL REFERENCES agents(id),
+      run_id TEXT NOT NULL REFERENCES agent_runs(id),
+      name TEXT NOT NULL,
+      args_json TEXT NOT NULL,
+      state TEXT NOT NULL CHECK (state IN ('queued', 'running', 'completed', 'failed', 'indeterminate')),
+      result_json TEXT,
+      indeterminate_reason TEXT,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS runtime_event_consumers (
+      consumer_id TEXT PRIMARY KEY NOT NULL,
+      sequence INTEGER NOT NULL DEFAULT 0,
+      event_id TEXT,
+      updated_at TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS runtime_messages_runnable_idx
+      ON runtime_messages (agent_id, state, created_at);
+    CREATE INDEX IF NOT EXISTS agent_runs_agent_state_idx
+      ON agent_runs (agent_id, state, created_at);
+    CREATE INDEX IF NOT EXISTS runtime_events_delivery_idx
+      ON runtime_events (sequence);
+
+    CREATE INDEX IF NOT EXISTS agent_runs_runnable_idx
+      ON agent_runs (state, created_at);
+`;
+function initializeRuntimeSchema(database) {
+  const initialize = database.transaction(() => {
+    for (const statement of RUNTIME_SCHEMA_SQL.split(";")) {
+      const sql = statement.trim();
+      if (sql.length > 0) {
+        database.run(sql);
+      }
+    }
+  });
+  initialize();
+}
+
+// src/runtime/sqlite-store.ts
+function clone3(value) {
+  return structuredClone(value);
+}
+function json(value) {
+  return JSON.stringify(value);
+}
+function parse(value) {
+  return JSON.parse(value);
+}
+function optionalJson(value) {
+  return value === null ? void 0 : parse(value);
+}
+function transitionError2(entity, id, state, action) {
+  return new Error(`Cannot ${action} ${entity} ${id} from state "${state}".`);
+}
+function requireTransition2(entity, id, state, action, allowedStates) {
+  if (!allowedStates.includes(state)) {
+    throw transitionError2(entity, id, state, action);
+  }
+}
+function timestampFor(input) {
+  const date = input ? new Date(input) : /* @__PURE__ */ new Date();
+  return { date, timestamp: createTimestamp(date) };
+}
+var SqliteRuntimeStateStore = class {
+  database;
+  constructor(filename = ":memory:") {
+    this.database = new Database(filename, { create: true, readwrite: true, strict: true });
+    this.database.run("PRAGMA foreign_keys = ON");
+    initializeRuntimeSchema(this.database);
+  }
+  close() {
+    this.database.close();
+  }
+  async createAgent(input) {
+    const { timestamp } = timestampFor();
+    const agent = {
+      id: createId("agt"),
+      sessionId: input.sessionId,
+      ...input.factoryId ? { factoryId: input.factoryId } : {},
+      state: "active",
+      createdAt: timestamp,
+      updatedAt: timestamp
+    };
+    const create = this.database.transaction(() => {
+      this.database.run(
+        "INSERT INTO agents (id, session_id, factory_id, state, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)",
+        [agent.id, agent.sessionId, agent.factoryId ?? null, agent.state, agent.createdAt, agent.updatedAt]
+      );
+      this.recordEvent("agent_created", { agentId: agent.id });
+    });
+    create();
+    return clone3(agent);
+  }
+  async getAgent(agentId) {
+    const row = this.database.query("SELECT * FROM agents WHERE id = ?").get(agentId);
+    return row ? this.agentFromRow(row) : void 0;
+  }
+  async listAgents() {
+    const rows = this.database.query("SELECT * FROM agents ORDER BY created_at, id").all();
+    return rows.map((row) => this.agentFromRow(row));
+  }
+  async setAgentState(agentId, state) {
+    const current = this.requireAgent(agentId);
+    if (current.state === state) return clone3(current);
+    const { timestamp } = timestampFor();
+    const updated = this.database.transaction(() => {
+      this.database.run("UPDATE agents SET state = ?, updated_at = ? WHERE id = ?", [state, timestamp, agentId]);
+      this.recordEvent(state === "paused" ? "agent_paused" : "agent_resumed", { agentId });
+      return this.requireAgent(agentId);
+    })();
+    return clone3(updated);
+  }
+  async enqueueAgentInput(input) {
+    this.requireAgent(input.agentId);
+    const { timestamp } = timestampFor();
+    const messageId = createId("rmsg");
+    const suspendedRow = this.database.query(
+      "SELECT * FROM agent_runs WHERE agent_id = ? AND state = 'suspended' ORDER BY created_at, id LIMIT 1"
+    ).get(input.agentId);
+    const runId = suspendedRow?.id ?? createId("run");
+    const message = {
+      id: messageId,
+      agentId: input.agentId,
+      kind: "agent_input",
+      input: clone3(input.input),
+      state: "queued",
+      attempts: 0,
+      runId,
+      createdAt: timestamp,
+      updatedAt: timestamp
+    };
+    const run = {
+      id: runId,
+      agentId: input.agentId,
+      messageId,
+      state: "queued",
+      attempt: 0,
+      createdAt: timestamp,
+      updatedAt: timestamp
+    };
+    if (suspendedRow) {
+      message.runId = runId;
+    }
+    const enqueue = this.database.transaction(() => {
+      this.insertMessage(message);
+      if (suspendedRow) {
+        this.database.run(
+          "UPDATE agent_runs SET message_id = ?, state = 'queued', lease_id = NULL, suspension_reason = NULL, updated_at = ? WHERE id = ?",
+          [messageId, timestamp, runId]
+        );
+      } else {
+        this.database.run(
+          "INSERT INTO agent_runs (id, agent_id, message_id, state, attempt, lease_id, outcome_json, suspension_reason, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
+          [run.id, run.agentId, run.messageId, run.state, run.attempt, null, null, null, run.createdAt, run.updatedAt]
+        );
+      }
+      this.recordEvent("message_enqueued", { agentId: input.agentId, messageId });
+      this.recordEvent("run_enqueued", { agentId: input.agentId, messageId, runId });
+    });
+    enqueue();
+    const storedRun = this.requireRun(runId);
+    return { message: clone3(message), run: clone3(storedRun), resumed: Boolean(suspendedRow) };
+  }
+  async getMessage(messageId) {
+    const row = this.messageRow(messageId);
+    return row ? this.messageFromRow(row) : void 0;
+  }
+  async getRun(runId) {
+    const row = this.runRow(runId);
+    return row ? this.runFromRow(row) : void 0;
+  }
+  async listRuns(input = {}) {
+    const clauses = [];
+    const params = [];
+    if (input.agentId) {
+      clauses.push("agent_id = ?");
+      params.push(input.agentId);
+    }
+    if (input.states && input.states.length > 0) {
+      clauses.push(`state IN (${input.states.map(() => "?").join(", ")})`);
+      params.push(...input.states);
+    }
+    const where = clauses.length > 0 ? `WHERE ${clauses.join(" AND ")}` : "";
+    const rows = this.database.query(`SELECT * FROM agent_runs ${where} ORDER BY created_at, id`).all(...params);
+    return rows.map((row) => this.runFromRow(row));
+  }
+  async leaseRun(input) {
+    const lease = this.database.transaction(() => {
+      const run2 = this.requireRun(input.runId);
+      requireTransition2("Agent Run", run2.id, run2.state, "lease", ["queued"]);
+      const message2 = this.requireMessage(run2.messageId);
+      requireTransition2("Runtime Message", message2.id, message2.state, "lease", ["queued"]);
+      const agent = this.requireAgent(run2.agentId);
+      if (agent.state !== "active") {
+        throw transitionError2("Agent", agent.id, agent.state, "lease a Run for");
+      }
+      const activeRun = this.database.query(
+        "SELECT id FROM agent_runs WHERE agent_id = ? AND id <> ? AND state IN ('running', 'suspended') LIMIT 1"
+      ).get(run2.agentId, run2.id);
+      if (activeRun) {
+        throw new Error(`Agent ${run2.agentId} already has an active Run.`);
+      }
+      if (!Number.isFinite(input.leaseDurationMs) || input.leaseDurationMs <= 0) {
+        throw new Error("Lease duration must be a positive finite number.");
+      }
+      const { date, timestamp } = timestampFor(input.now);
+      const runtimeLease = {
+        id: createId("lease"),
+        runId: run2.id,
+        workerId: input.workerId,
+        leasedAt: timestamp,
+        expiresAt: createTimestamp(new Date(date.getTime() + input.leaseDurationMs))
+      };
+      this.database.run(
+        "INSERT INTO runtime_leases (id, run_id, worker_id, leased_at, expires_at) VALUES (?, ?, ?, ?, ?)",
+        [runtimeLease.id, runtimeLease.runId, runtimeLease.workerId, runtimeLease.leasedAt, runtimeLease.expiresAt]
+      );
+      this.database.run(
+        "UPDATE agent_runs SET state = ?, attempt = attempt + 1, lease_id = ?, updated_at = ? WHERE id = ?",
+        ["running", runtimeLease.id, timestamp, run2.id]
+      );
+      this.database.run(
+        "UPDATE runtime_messages SET state = ?, attempts = attempts + 1, updated_at = ? WHERE id = ?",
+        ["leased", timestamp, message2.id]
+      );
+      this.recordEvent("run_leased", { agentId: run2.agentId, messageId: message2.id, runId: run2.id }, runtimeLease);
+      return runtimeLease;
+    })();
+    const run = this.requireRun(input.runId);
+    const message = this.requireMessage(run.messageId);
+    return { run, message, lease: clone3(lease) };
+  }
+  async renewLease(input) {
+    const lease = this.database.transaction(() => {
+      const run = this.requireRun(input.runId);
+      requireTransition2("Agent Run", run.id, run.state, "renew Lease", ["running"]);
+      const message = this.requireMessage(run.messageId);
+      requireTransition2("Runtime Message", message.id, message.state, "renew Lease", ["leased"]);
+      if (run.leaseId !== input.leaseId || message.lease?.id !== input.leaseId) {
+        throw new Error(`Lease ${input.leaseId} does not own Agent Run ${run.id}.`);
+      }
+      if (!Number.isFinite(input.leaseDurationMs) || input.leaseDurationMs <= 0) {
+        throw new Error("Lease duration must be a positive finite number.");
+      }
+      const { date, timestamp } = timestampFor(input.now);
+      const expiresAt = createTimestamp(new Date(date.getTime() + input.leaseDurationMs));
+      this.database.run("UPDATE runtime_leases SET expires_at = ? WHERE id = ?", [expiresAt, input.leaseId]);
+      this.database.run("UPDATE runtime_messages SET updated_at = ? WHERE id = ?", [timestamp, message.id]);
+      return { ...message.lease, expiresAt };
+    })();
+    return clone3(lease);
+  }
+  async suspendRun(input) {
+    const run = this.database.transaction(() => {
+      const current = this.requireRun(input.runId);
+      requireTransition2("Agent Run", current.id, current.state, "suspend", ["running"]);
+      const message = this.requireMessage(current.messageId);
+      requireTransition2("Runtime Message", message.id, message.state, "acknowledge", ["leased"]);
+      const { timestamp } = timestampFor();
+      this.database.run(
+        "UPDATE agent_runs SET state = ?, lease_id = NULL, suspension_reason = ?, updated_at = ? WHERE id = ?",
+        ["suspended", input.reason ?? null, timestamp, current.id]
+      );
+      this.database.run(
+        "UPDATE runtime_messages SET state = ?, updated_at = ? WHERE id = ?",
+        ["acknowledged", timestamp, message.id]
+      );
+      this.database.run("DELETE FROM runtime_leases WHERE run_id = ?", [current.id]);
+      this.recordEvent("run_suspended", { agentId: current.agentId, messageId: message.id, runId: current.id }, {
+        reason: input.reason
+      });
+      return this.requireRun(current.id);
+    })();
+    return clone3(run);
+  }
+  async completeRun(input) {
+    const run = this.database.transaction(() => {
+      const current = this.requireRun(input.runId);
+      requireTransition2("Agent Run", current.id, current.state, "complete", ["running"]);
+      const message = this.requireMessage(current.messageId);
+      requireTransition2("Runtime Message", message.id, message.state, "acknowledge", ["leased"]);
+      const { timestamp } = timestampFor();
+      const state = input.state ?? "completed";
+      this.database.run(
+        "UPDATE agent_runs SET state = ?, lease_id = NULL, outcome_json = ?, updated_at = ? WHERE id = ?",
+        [state, json(input.outcome), timestamp, current.id]
+      );
+      this.database.run(
+        "UPDATE runtime_messages SET state = 'acknowledged', updated_at = ? WHERE id = ?",
+        [timestamp, message.id]
+      );
+      this.database.run("DELETE FROM runtime_leases WHERE run_id = ?", [current.id]);
+      this.recordEvent("run_completed", { agentId: current.agentId, messageId: current.messageId, runId: current.id }, {
+        state,
+        outcome: input.outcome
+      });
+      this.recordEvent("message_acknowledged", { agentId: message.agentId, messageId: message.id });
+      return this.requireRun(current.id);
+    })();
+    return clone3(run);
+  }
+  async retryRun(input) {
+    const run = this.database.transaction(() => {
+      const current = this.requireRun(input.runId);
+      requireTransition2("Agent Run", current.id, current.state, "retry", ["running"]);
+      const message = this.requireMessage(current.messageId);
+      requireTransition2("Runtime Message", message.id, message.state, "retry", ["leased"]);
+      const { timestamp } = timestampFor();
+      this.database.run(
+        "UPDATE agent_runs SET state = 'queued', lease_id = NULL, updated_at = ? WHERE id = ?",
+        [timestamp, current.id]
+      );
+      this.database.run(
+        "UPDATE runtime_messages SET state = 'queued', updated_at = ? WHERE id = ?",
+        [timestamp, message.id]
+      );
+      this.database.run("DELETE FROM runtime_leases WHERE run_id = ?", [current.id]);
+      this.recordEvent("run_retry_scheduled", {
+        agentId: current.agentId,
+        messageId: message.id,
+        runId: current.id
+      }, { reason: input.reason, attempt: current.attempt });
+      return this.requireRun(current.id);
+    })();
+    return clone3(run);
+  }
+  async exhaustRun(input) {
+    const run = this.database.transaction(() => {
+      const current = this.requireRun(input.runId);
+      requireTransition2("Agent Run", current.id, current.state, "exhaust retries", ["running"]);
+      const message = this.requireMessage(current.messageId);
+      requireTransition2("Runtime Message", message.id, message.state, "dead-letter", ["leased"]);
+      const { timestamp } = timestampFor();
+      this.database.run(
+        "UPDATE agent_runs SET state = 'failed', lease_id = NULL, outcome_json = ?, updated_at = ? WHERE id = ?",
+        [json(input.outcome), timestamp, current.id]
+      );
+      this.database.run(
+        "UPDATE runtime_messages SET state = 'dead_lettered', dead_letter_reason = ?, updated_at = ? WHERE id = ?",
+        [input.reason, timestamp, message.id]
+      );
+      this.database.run("DELETE FROM runtime_leases WHERE run_id = ?", [current.id]);
+      this.recordEvent("run_completed", { agentId: current.agentId, messageId: message.id, runId: current.id }, {
+        state: "failed",
+        outcome: input.outcome
+      });
+      this.recordEvent("message_dead_lettered", { agentId: current.agentId, messageId: message.id }, {
+        reason: input.reason
+      });
+      return this.requireRun(current.id);
+    })();
+    return clone3(run);
+  }
+  async abortRun(input) {
+    const run = this.database.transaction(() => {
+      const current = this.requireRun(input.runId);
+      requireTransition2("Agent Run", current.id, current.state, "abort", ["queued", "running", "suspended"]);
+      const message = this.requireMessage(current.messageId);
+      const { timestamp } = timestampFor();
+      this.database.run(
+        "UPDATE agent_runs SET state = 'cancelled', lease_id = NULL, outcome_json = ?, updated_at = ? WHERE id = ?",
+        [json(input.outcome), timestamp, current.id]
+      );
+      if (message.state === "queued" || message.state === "leased") {
+        this.database.run("UPDATE runtime_messages SET state = 'acknowledged', updated_at = ? WHERE id = ?", [
+          timestamp,
+          message.id
+        ]);
+      }
+      this.database.run("DELETE FROM runtime_leases WHERE run_id = ?", [current.id]);
+      this.recordEvent("run_aborted", { agentId: current.agentId, messageId: message.id, runId: current.id }, {
+        outcome: input.outcome
+      });
+      return this.requireRun(current.id);
+    })();
+    return clone3(run);
+  }
+  async recoverExpiredLeases(input) {
+    const { timestamp } = timestampFor(input);
+    const rows = this.database.query(`
+      SELECT r.id
+      FROM agent_runs r
+      JOIN runtime_leases l ON l.id = r.lease_id
+      WHERE r.state = 'running' AND l.expires_at <= ?
+      ORDER BY l.expires_at, r.created_at
+    `).all(timestamp);
+    if (rows.length === 0) return [];
+    const recover = this.database.transaction(() => {
+      const recovered = [];
+      for (const row of rows) {
+        const run = this.requireRun(row.id);
+        if (run.state !== "running") continue;
+        const message = this.requireMessage(run.messageId);
+        this.database.run("UPDATE agent_runs SET state = 'queued', lease_id = NULL, updated_at = ? WHERE id = ?", [
+          timestamp,
+          run.id
+        ]);
+        this.database.run("UPDATE runtime_messages SET state = 'queued', updated_at = ? WHERE id = ?", [
+          timestamp,
+          message.id
+        ]);
+        this.database.run("DELETE FROM runtime_leases WHERE run_id = ?", [run.id]);
+        this.recordEvent("lease_expired", { agentId: run.agentId, messageId: message.id, runId: run.id });
+        recovered.push(this.requireRun(run.id));
+      }
+      return recovered;
+    })();
+    return clone3(recover);
+  }
+  async recoverLeases() {
+    const { timestamp } = timestampFor();
+    const rows = this.database.query(`
+      SELECT r.id
+      FROM agent_runs r
+      JOIN runtime_leases l ON l.id = r.lease_id
+      WHERE r.state = 'running'
+      ORDER BY l.leased_at, r.created_at
+    `).all();
+    if (rows.length === 0) return [];
+    const recovered = this.database.transaction(() => {
+      const runs = [];
+      for (const row of rows) {
+        const run = this.requireRun(row.id);
+        if (run.state !== "running") continue;
+        const message = this.requireMessage(run.messageId);
+        this.database.run("UPDATE agent_runs SET state = 'queued', lease_id = NULL, updated_at = ? WHERE id = ?", [
+          timestamp,
+          run.id
+        ]);
+        this.database.run("UPDATE runtime_messages SET state = 'queued', updated_at = ? WHERE id = ?", [
+          timestamp,
+          message.id
+        ]);
+        this.database.run("DELETE FROM runtime_leases WHERE run_id = ?", [run.id]);
+        this.recordEvent("lease_recovered", { agentId: run.agentId, messageId: message.id, runId: run.id });
+        runs.push(this.requireRun(run.id));
+      }
+      return runs;
+    })();
+    return clone3(recovered);
+  }
+  async createToolCall(input) {
+    this.requireAgent(input.agentId);
+    this.requireRun(input.runId);
+    const { timestamp } = timestampFor();
+    const toolCall = {
+      id: createId("call"),
+      agentId: input.agentId,
+      runId: input.runId,
+      name: input.name,
+      args: clone3(input.args),
+      state: "queued",
+      createdAt: timestamp,
+      updatedAt: timestamp
+    };
+    const create = this.database.transaction(() => {
+      this.database.run(
+        "INSERT INTO runtime_tool_calls (id, agent_id, run_id, name, args_json, state, result_json, indeterminate_reason, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
+        [toolCall.id, toolCall.agentId, toolCall.runId, toolCall.name, json(toolCall.args), toolCall.state, null, null, toolCall.createdAt, toolCall.updatedAt]
+      );
+      this.recordEvent("tool_call_created", { agentId: toolCall.agentId, runId: toolCall.runId, toolCallId: toolCall.id });
+    });
+    create();
+    return clone3(toolCall);
+  }
+  async startToolCall(toolCallId) {
+    const toolCall = this.database.transaction(() => {
+      const current = this.requireToolCall(toolCallId);
+      requireTransition2("Tool Call", current.id, current.state, "start", ["queued"]);
+      const { timestamp } = timestampFor();
+      this.database.run("UPDATE runtime_tool_calls SET state = ?, updated_at = ? WHERE id = ?", [
+        "running",
+        timestamp,
+        current.id
+      ]);
+      this.recordEvent("tool_call_started", { agentId: current.agentId, runId: current.runId, toolCallId: current.id });
+      return this.requireToolCall(current.id);
+    })();
+    return clone3(toolCall);
+  }
+  async completeToolCall(input) {
+    const toolCall = this.database.transaction(() => {
+      const current = this.requireToolCall(input.toolCallId);
+      const state = input.state ?? (input.result.ok ? "completed" : "failed");
+      requireTransition2(
+        "Tool Call",
+        current.id,
+        current.state,
+        "complete",
+        state === "failed" ? ["queued", "running"] : ["running"]
+      );
+      const { timestamp } = timestampFor();
+      this.database.run(
+        "UPDATE runtime_tool_calls SET state = ?, result_json = ?, updated_at = ? WHERE id = ?",
+        [state, json(input.result), timestamp, current.id]
+      );
+      this.recordEvent(state === "failed" ? "tool_call_failed" : "tool_call_completed", { agentId: current.agentId, runId: current.runId, toolCallId: current.id }, {
+        state
+      });
+      return this.requireToolCall(current.id);
+    })();
+    return clone3(toolCall);
+  }
+  async markToolCallIndeterminate(input) {
+    const toolCall = this.database.transaction(() => {
+      const current = this.requireToolCall(input.toolCallId);
+      requireTransition2("Tool Call", current.id, current.state, "mark indeterminate", ["running"]);
+      const { timestamp } = timestampFor();
+      this.database.run(
+        "UPDATE runtime_tool_calls SET state = ?, indeterminate_reason = ?, updated_at = ? WHERE id = ?",
+        ["indeterminate", input.reason, timestamp, current.id]
+      );
+      this.recordEvent("tool_call_indeterminate", { agentId: current.agentId, runId: current.runId, toolCallId: current.id }, {
+        reason: input.reason
+      });
+      return this.requireToolCall(current.id);
+    })();
+    return clone3(toolCall);
+  }
+  async getToolCall(toolCallId) {
+    const row = this.database.query("SELECT * FROM runtime_tool_calls WHERE id = ?").get(toolCallId);
+    return row ? this.toolCallFromRow(row) : void 0;
+  }
+  async listEvents(cursor = {}) {
+    const after = cursor.after ? this.database.query("SELECT sequence FROM runtime_events WHERE id = ?").get(cursor.after) : null;
+    const limit = cursor.limit === void 0 ? "" : ` LIMIT ${Math.max(0, Math.floor(cursor.limit))}`;
+    const rows = this.database.query(`SELECT * FROM runtime_events ${after ? "WHERE sequence > ?" : ""} ORDER BY sequence${limit}`).all(...after ? [after.sequence] : []);
+    return rows.map((row) => this.eventFromRow(row));
+  }
+  async recordEvent(input, related = {}, payload) {
+    if (typeof input === "string") {
+      this.recordEventInternal(input, related, payload);
+      const row = this.database.query("SELECT * FROM runtime_events ORDER BY sequence DESC LIMIT 1").get();
+      return clone3(this.eventFromRow(row));
+    }
+    const event = this.database.transaction(() => {
+      this.recordEventInternal(input.kind, input.related ?? {}, input.payload);
+      const row = this.database.query("SELECT * FROM runtime_events ORDER BY sequence DESC LIMIT 1").get();
+      return this.eventFromRow(row);
+    })();
+    return clone3(event);
+  }
+  async getEventCheckpoint(consumerId) {
+    return clone3(this.eventCheckpoint(consumerId));
+  }
+  async acknowledgeEvent(consumerId, eventId) {
+    const checkpoint = this.database.transaction(() => {
+      const event = this.requireEvent(eventId);
+      const current = this.eventCheckpoint(consumerId);
+      if (event.sequence <= current.sequence) return current;
+      if (event.sequence !== current.sequence + 1) {
+        throw new Error(`Runtime Event Consumer Checkpoint cannot advance from sequence ${current.sequence} to ${event.sequence}.`);
+      }
+      const updatedAt = createTimestamp();
+      this.database.run(
+        `INSERT INTO runtime_event_consumers (consumer_id, sequence, event_id, updated_at)
+         VALUES (?, ?, ?, ?)
+         ON CONFLICT(consumer_id) DO UPDATE SET
+           sequence = excluded.sequence,
+           event_id = excluded.event_id,
+           updated_at = excluded.updated_at`,
+        [consumerId, event.sequence, event.id, updatedAt]
+      );
+      return this.eventCheckpoint(consumerId);
+    })();
+    return clone3(checkpoint);
+  }
+  insertMessage(message) {
+    this.database.run(
+      "INSERT INTO runtime_messages (id, agent_id, kind, payload_json, state, attempts, run_id, dead_letter_reason, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
+      [message.id, message.agentId, message.kind, json(message.input), message.state, message.attempts, message.runId ?? null, null, message.createdAt, message.updatedAt]
+    );
+  }
+  agentFromRow(row) {
+    return {
+      id: row.id,
+      sessionId: row.session_id,
+      ...row.factory_id ? { factoryId: row.factory_id } : {},
+      state: row.state,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at
+    };
+  }
+  messageFromRow(row) {
+    const message = {
+      id: row.id,
+      agentId: row.agent_id,
+      kind: row.kind,
+      input: parse(row.payload_json),
+      state: row.state,
+      attempts: row.attempts,
+      ...row.run_id ? { runId: row.run_id } : {},
+      ...row.dead_letter_reason ? { deadLetterReason: row.dead_letter_reason } : {},
+      createdAt: row.created_at,
+      updatedAt: row.updated_at
+    };
+    if (row.lease_id && row.lease_run_id && row.worker_id && row.leased_at && row.expires_at) {
+      message.lease = {
+        id: row.lease_id,
+        runId: row.lease_run_id,
+        workerId: row.worker_id,
+        leasedAt: row.leased_at,
+        expiresAt: row.expires_at
+      };
+    }
+    return message;
+  }
+  runFromRow(row) {
+    return {
+      id: row.id,
+      agentId: row.agent_id,
+      messageId: row.message_id,
+      state: row.state,
+      attempt: row.attempt,
+      ...row.lease_id ? { leaseId: row.lease_id } : {},
+      ...row.outcome_json ? { outcome: parse(row.outcome_json) } : {},
+      ...row.suspension_reason ? { suspensionReason: row.suspension_reason } : {},
+      createdAt: row.created_at,
+      updatedAt: row.updated_at
+    };
+  }
+  eventFromRow(row) {
+    return {
+      id: row.id,
+      sequence: row.sequence,
+      kind: row.kind,
+      ...row.agent_id ? { agentId: row.agent_id } : {},
+      ...row.message_id ? { messageId: row.message_id } : {},
+      ...row.run_id ? { runId: row.run_id } : {},
+      ...row.tool_call_id ? { toolCallId: row.tool_call_id } : {},
+      ...row.payload_json ? { payload: optionalJson(row.payload_json) } : {},
+      createdAt: row.created_at
+    };
+  }
+  toolCallFromRow(row) {
+    return {
+      id: row.id,
+      agentId: row.agent_id,
+      runId: row.run_id,
+      name: row.name,
+      args: parse(row.args_json),
+      state: row.state,
+      ...row.result_json ? { result: parse(row.result_json) } : {},
+      ...row.indeterminate_reason ? { indeterminateReason: row.indeterminate_reason } : {},
+      createdAt: row.created_at,
+      updatedAt: row.updated_at
+    };
+  }
+  messageRow(messageId) {
+    return this.database.query(`
+      SELECT
+        m.*,
+        l.id AS lease_id,
+        l.run_id AS lease_run_id,
+        l.worker_id,
+        l.leased_at,
+        l.expires_at
+      FROM runtime_messages m
+      LEFT JOIN agent_runs r ON r.id = m.run_id
+      LEFT JOIN runtime_leases l ON l.id = r.lease_id
+      WHERE m.id = ?
+    `).get(messageId);
+  }
+  runRow(runId) {
+    return this.database.query("SELECT * FROM agent_runs WHERE id = ?").get(runId);
+  }
+  requireAgent(agentId) {
+    const row = this.database.query("SELECT * FROM agents WHERE id = ?").get(agentId);
+    if (!row) {
+      throw new Error(`Agent not found: ${agentId}.`);
+    }
+    return this.agentFromRow(row);
+  }
+  requireMessage(messageId) {
+    const row = this.messageRow(messageId);
+    if (!row) {
+      throw new Error(`Runtime Message not found: ${messageId}.`);
+    }
+    return this.messageFromRow(row);
+  }
+  requireRun(runId) {
+    const row = this.runRow(runId);
+    if (!row) {
+      throw new Error(`Agent Run not found: ${runId}.`);
+    }
+    return this.runFromRow(row);
+  }
+  requireToolCall(toolCallId) {
+    const row = this.database.query("SELECT * FROM runtime_tool_calls WHERE id = ?").get(toolCallId);
+    if (!row) {
+      throw new Error(`Tool Call not found: ${toolCallId}.`);
+    }
+    return this.toolCallFromRow(row);
+  }
+  requireEvent(eventId) {
+    const row = this.database.query("SELECT * FROM runtime_events WHERE id = ?").get(eventId);
+    if (!row) {
+      throw new Error(`Runtime Event not found: ${eventId}.`);
+    }
+    return this.eventFromRow(row);
+  }
+  eventCheckpoint(consumerId) {
+    const row = this.database.query(
+      "SELECT consumer_id, sequence, event_id, updated_at FROM runtime_event_consumers WHERE consumer_id = ?"
+    ).get(consumerId);
+    if (!row) {
+      return {
+        consumerId,
+        sequence: 0,
+        updatedAt: createTimestamp(/* @__PURE__ */ new Date(0))
+      };
+    }
+    return {
+      consumerId: row.consumer_id,
+      sequence: row.sequence,
+      ...row.event_id ? { eventId: row.event_id } : {},
+      updatedAt: row.updated_at
+    };
+  }
+  recordEventInternal(kind, related, payload) {
+    this.database.run(
+      "INSERT INTO runtime_events (id, sequence, kind, agent_id, message_id, run_id, tool_call_id, payload_json, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
+      [
+        createId("evt"),
+        (this.database.query("SELECT COALESCE(MAX(sequence), 0) AS sequence FROM runtime_events").get().sequence ?? 0) + 1,
+        kind,
+        related.agentId ?? null,
+        related.messageId ?? null,
+        related.runId ?? null,
+        related.toolCallId ?? null,
+        payload === void 0 ? null : json(payload),
+        createTimestamp()
+      ]
+    );
+  }
+};
 export {
   Agent,
-  AgentEventStream,
-  EmptyResponseError,
-  EventStream,
-  ExtensionRunner,
-  HooksManager,
-  LocalJsonlSessionManager,
-  appendUserTurn,
-  buildModelRequest,
-  buildSystemPrompt,
-  conversationMessages,
+  AgentRun,
+  AgentRuntime,
+  InMemoryRuntimeStateStore,
+  InMemorySessionProvider,
+  LocalJsonlSessionProvider,
+  SqliteRuntimeStateStore,
   createCoreTools,
-  createDispatchStream,
-  createEventBus,
-  createExtension,
-  createExtensionAPI,
-  createExtensionRunner,
-  createExtensionRuntime,
-  createId,
-  createMessage,
-  createSession,
-  createSourceInfo,
-  createTimestamp,
-  getGlobalHooks,
-  interpolateEnvVars,
-  latestUserInput,
-  loadConfigFile,
-  loadPhase,
-  loadPhases,
-  messageContentText,
-  parseModelRef,
-  registerBuiltInApiProviders,
-  registerConfigModels,
-  reloadPhases,
-  resetGlobalHooks,
-  resolveDefaultModel,
-  resolveInWorkspace,
-  resolveWorkspacePaths,
-  serializeSkills
+  createMessage
 };