@theokit/sdk 2.19.0 → 2.21.0

package/dist/index.cjs

@@ -1,12 +1,12 @@
 'use strict';
 
+var zod = require('zod');
+var module$1 = require('module');
 var crypto = require('crypto');
 var fs = require('fs');
 var path = require('path');
 var promises = require('fs/promises');
-var zod = require('zod');
 var async_hooks = require('async_hooks');
-var module$1 = require('module');
 var os = require('os');
 var child_process = require('child_process');
 var url = require('url');
@@ -519,6 +519,256 @@ var init_errors = __esm({
     };
   }
 });
+function toJsonSchema(schema, options = { unrepresentable: "any" }) {
+  return zod.toJSONSchema(schema, options);
+}
+var init_to_json_schema = __esm({
+  "src/internal/zod/to-json-schema.ts"() {
+  }
+});
+function requireZod() {
+  if (cachedZ !== void 0) return cachedZ;
+  const r = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
+  let mod;
+  try {
+    mod = r("zod");
+  } catch (cause) {
+    throw new exports.ConfigurationError(
+      'Structured output requires the optional peer dependency `zod`. Add `"zod": "^3.25.0 || ^4.0.0"` to your package.json and reinstall.',
+      { code: "zod_not_installed", cause }
+    );
+  }
+  cachedZ = mod.z ?? mod;
+  return cachedZ;
+}
+function makeOutputTool(jsonSchema, onCapture) {
+  return {
+    name: "output",
+    description: "Call this tool with your final structured answer. Match the JSON schema exactly.",
+    inputSchema: jsonSchema,
+    handler: (input) => {
+      const out = onCapture(input);
+      if (typeof out === "string") return out;
+      if (out instanceof Promise) return out;
+      return "";
+    }
+  };
+}
+function buildTransientAgentOptions(params) {
+  return {
+    model: params.model,
+    local: params.local,
+    tools: [params.outputTool],
+    systemPrompt: params.systemPrompt ?? "You produce structured output by calling the `output` tool exactly once. Match the JSON schema.",
+    ...params.apiKey !== void 0 ? { apiKey: params.apiKey } : {},
+    ...params.providers !== void 0 ? { providers: params.providers } : {}
+  };
+}
+function extractUsage(result) {
+  const u = result.usage;
+  if (u === void 0) return { inputTokens: 0, outputTokens: 0 };
+  return { inputTokens: u.inputTokens ?? 0, outputTokens: u.outputTokens ?? 0 };
+}
+function buildToolPrompt(prompt) {
+  return `${prompt}
+
+Respond by calling the \`output\` tool with the structured answer that matches the schema.`;
+}
+function setupStructuredOutput(schema, maxRetries) {
+  const z8 = requireZod();
+  const jsonSchema = toJsonSchema(schema, { unrepresentable: "any" });
+  return {
+    z: z8,
+    jsonSchema,
+    maxRetries: maxRetries ?? 1,
+    initialUsage: { inputTokens: 0, outputTokens: 0 }
+  };
+}
+async function disposeAndDeleteTransient(agent, deletor) {
+  await agent.dispose();
+  try {
+    await deletor(agent.agentId);
+  } catch {
+  }
+}
+var cachedZ;
+var init_structured_output_helpers = __esm({
+  "src/internal/structured-output-helpers.ts"() {
+    init_errors();
+    init_to_json_schema();
+  }
+});
+
+// src/generate-object.ts
+var generate_object_exports = {};
+__export(generate_object_exports, {
+  GenerateObjectError: () => exports.GenerateObjectError,
+  generateObjectImpl: () => generateObjectImpl
+});
+function salvagePartial(schema, raw) {
+  if (typeof raw !== "object" || raw === null) return raw;
+  const shape = schema.shape;
+  if (shape === void 0 || typeof shape !== "object") return raw;
+  const rawObj = raw;
+  const out = {};
+  for (const [key2, fieldSchema] of Object.entries(shape)) {
+    if (typeof fieldSchema?.safeParse !== "function") continue;
+    const parsed = fieldSchema.safeParse(rawObj[key2]);
+    if (parsed.success) out[key2] = parsed.data;
+  }
+  return out;
+}
+async function runReasoningPhase(options, deps) {
+  const reasoningOptions = {
+    model: options.model,
+    local: options.local,
+    ...options.systemPrompt !== void 0 ? { systemPrompt: options.systemPrompt } : {},
+    ...options.apiKey !== void 0 ? { apiKey: options.apiKey } : {},
+    ...options.providers !== void 0 ? { providers: options.providers } : {}
+  };
+  const reasoningAgent = await deps.create(reasoningOptions);
+  try {
+    const run = await reasoningAgent.send(options.prompt);
+    const result = await run.wait();
+    const text = result.result;
+    return typeof text === "string" ? text : options.prompt;
+  } finally {
+    await disposeAndDeleteTransient(reasoningAgent, deps.delete);
+  }
+}
+async function generateObjectImpl(options, deps) {
+  const { jsonSchema, maxRetries, initialUsage } = setupStructuredOutput(
+    options.schema,
+    options.maxRetries
+  );
+  let capturedRaw;
+  let lastUsage = initialUsage;
+  const sentinel = /* @__PURE__ */ Symbol("generate-object-sentinel");
+  class CaptureSentinel extends Error {
+    constructor(captured) {
+      super("generate-object-capture");
+      this.captured = captured;
+    }
+    captured;
+    [sentinel] = true;
+  }
+  const outputTool = makeOutputTool(jsonSchema, (input) => {
+    if (capturedRaw === void 0) {
+      capturedRaw = input;
+    }
+    throw new CaptureSentinel(input);
+  });
+  const reasoningText = options.structuringModel !== void 0 ? await runReasoningPhase(options, deps) : void 0;
+  const structuringModel = options.structuringModel ?? options.model;
+  const structuringPrompt = reasoningText ?? options.prompt;
+  const agentOptions = buildTransientAgentOptions({
+    model: structuringModel,
+    local: options.local,
+    outputTool,
+    ...options.systemPrompt !== void 0 ? { systemPrompt: options.systemPrompt } : {},
+    ...options.apiKey !== void 0 ? { apiKey: options.apiKey } : {},
+    ...options.providers !== void 0 ? { providers: options.providers } : {}
+  });
+  const agent = await deps.create(agentOptions);
+  try {
+    const userMessage = buildToolPrompt(structuringPrompt);
+    let lastParseError;
+    for (let attempt = 0; attempt <= maxRetries; attempt += 1) {
+      capturedRaw = void 0;
+      const run = await agent.send(userMessage);
+      const result = await run.wait();
+      lastUsage = extractUsage(result);
+      if (capturedRaw === void 0) {
+        if (result.status === "error" && result.error !== void 0) {
+          throw new exports.GenerateObjectError(
+            "no_tool_call",
+            `Agent run failed before the model could reply: ${result.error.message ?? "unknown error"} [${result.error.code ?? "?"}]`,
+            result.error
+          );
+        }
+        if (attempt === maxRetries) {
+          throw new exports.GenerateObjectError(
+            "no_tool_call",
+            "The model returned text instead of calling the `output` tool."
+          );
+        }
+        continue;
+      }
+      const parsed = options.schema.safeParse(capturedRaw);
+      if (parsed.success) {
+        return {
+          object: parsed.data,
+          raw: capturedRaw,
+          usage: lastUsage,
+          finishReason: "tool_use"
+        };
+      }
+      lastParseError = parsed.error;
+    }
+    if (options.errorStrategy === "return-raw") {
+      return {
+        object: capturedRaw,
+        raw: capturedRaw,
+        usage: lastUsage,
+        finishReason: "tool_use"
+      };
+    }
+    if (options.errorStrategy === "return-partial") {
+      return {
+        object: salvagePartial(options.schema, capturedRaw),
+        raw: capturedRaw,
+        usage: lastUsage,
+        finishReason: "tool_use"
+      };
+    }
+    throw new exports.GenerateObjectError(
+      "parse_failed",
+      "Schema parse failed after all retries.",
+      lastParseError
+    );
+  } finally {
+    await disposeAndDeleteTransient(agent, deps.delete);
+  }
+}
+exports.GenerateObjectError = void 0;
+var init_generate_object = __esm({
+  "src/generate-object.ts"() {
+    init_structured_output_helpers();
+    exports.GenerateObjectError = class extends Error {
+      name = "GenerateObjectError";
+      code;
+      cause;
+      constructor(code, message, cause) {
+        super(message);
+        this.code = code;
+        if (cause !== void 0) this.cause = cause;
+      }
+    };
+  }
+});
+
+// src/internal/runtime/registry/agent-factory-registry.ts
+var agent_factory_registry_exports = {};
+__export(agent_factory_registry_exports, {
+  getAgentFacade: () => getAgentFacade,
+  setAgentFacade: () => setAgentFacade
+});
+function setAgentFacade(facade) {
+  registered = facade;
+}
+function getAgentFacade() {
+  if (registered === void 0) {
+    throw new Error(
+      "internal: Agent facade not registered. The `agent.ts` module must be loaded before internal subsystems (LocalAgent.runUntil/fork, eval, scorers, cron) invoke it."
+    );
+  }
+  return registered;
+}
+var registered;
+var init_agent_factory_registry = __esm({
+  "src/internal/runtime/registry/agent-factory-registry.ts"() {
+  }
+});
 
 // src/internal/persistence/cwd-mutex.ts
 function withCwdMutex(key2, fn) {
@@ -2789,29 +3039,6 @@ var init_judge_call = __esm({
   }
 });
 
-// src/internal/runtime/registry/agent-factory-registry.ts
-var agent_factory_registry_exports = {};
-__export(agent_factory_registry_exports, {
-  getAgentFacade: () => getAgentFacade,
-  setAgentFacade: () => setAgentFacade
-});
-function setAgentFacade(facade) {
-  registered3 = facade;
-}
-function getAgentFacade() {
-  if (registered3 === void 0) {
-    throw new Error(
-      "internal: Agent facade not registered. The `agent.ts` module must be loaded before internal subsystems (LocalAgent.runUntil/fork, eval, scorers, cron) invoke it."
-    );
-  }
-  return registered3;
-}
-var registered3;
-var init_agent_factory_registry = __esm({
-  "src/internal/runtime/registry/agent-factory-registry.ts"() {
-  }
-});
-
 // src/internal/runtime/lifecycle/run-to-completion.ts
 var run_to_completion_exports = {};
 __export(run_to_completion_exports, {
@@ -2976,14 +3203,14 @@ async function forkAgentImpl(parent, options, deps) {
       return {
         result: result.result,
         toolCalls: [],
-        usage: extractUsage(result)
+        usage: extractUsage2(result)
       };
     });
   } finally {
     await fork.dispose();
   }
 }
-function extractUsage(result) {
+function extractUsage2(result) {
   if (typeof result !== "object" || result === null) {
     return { inputTokens: 0, outputTokens: 0 };
   }
@@ -3615,309 +3842,103 @@ async function submit(internal) {
     });
   }
   const release = await acquireSlot();
-  void (async () => {
-    try {
-      await checkCancelRequestedAt(resolvedId, aborter);
-      if (aborter.signal.aborted) {
-        const cancelledAt = Date.now();
-        await transition(resolvedId, "cancelled", { cancelledAt });
-        emitToSubscribers(resolvedId, { type: "cancelled", taskId: resolvedId, cancelledAt });
-        return;
-      }
-      const startedAt = Date.now();
-      await transition(resolvedId, "running", { startedAt });
-      emitToSubscribers(resolvedId, { type: "started", taskId: resolvedId, startedAt });
-      await runWorkAndFinalize(resolvedId, aborter, internal.work);
-    } finally {
-      release();
-      state.aborters.delete(resolvedId);
-    }
-  })();
-  return queuedHandle;
-}
-async function list(filter = {}) {
-  return state.store.list(filter);
-}
-async function get(id) {
-  if (!isValidTaskId(id, true)) return void 0;
-  return state.store.get(id);
-}
-async function cancel(id, reason) {
-  if (!isValidTaskId(id, true)) return { cancelled: false, alreadyTerminal: false };
-  const handle = await state.store.get(id);
-  if (handle === void 0) return { cancelled: false, alreadyTerminal: false };
-  if (handle.state === "finished" || handle.state === "error" || handle.state === "cancelled") {
-    return { cancelled: false, alreadyTerminal: true };
-  }
-  const span = startTaskCancelSpan({
-    taskId: id,
-    ...reason !== void 0 ? { reason } : {},
-    via: "api"
-  });
-  try {
-    return await cancelInternal(id, handle.state, reason);
-  } finally {
-    span.end();
-  }
-}
-async function cancelInternal(id, currentState, reason) {
-  if (currentState === "queued") {
-    const cancelledAt = Date.now();
-    await transition(id, "cancelled", { cancelledAt });
-    emitToSubscribers(id, {
-      type: "cancelled",
-      taskId: id,
-      cancelledAt,
-      ...reason !== void 0 ? { reason } : {}
-    });
-    state.aborters.delete(id);
-    return { cancelled: true, alreadyTerminal: false };
-  }
-  const aborter = state.aborters.get(id);
-  if (aborter !== void 0) aborter.abort(reason ?? "cancelled");
-  return { cancelled: true, alreadyTerminal: false };
-}
-async function evictNow(now = Date.now()) {
-  return state.store.evictTerminalOlderThan(now - state.retentionMs);
-}
-var DEFAULT_CONCURRENCY, DEFAULT_RETENTION_MS, EVICTION_INTERVAL_MS, RING_CAP, reentryAls, state, subscribe;
-var init_registry = __esm({
-  "src/internal/task/registry.ts"() {
-    init_errors();
-    init_task();
-    init_async_semaphore();
-    init_ring_buffer();
-    init_store();
-    init_subscribe();
-    init_telemetry();
-    DEFAULT_CONCURRENCY = 8;
-    DEFAULT_RETENTION_MS = 60 * 60 * 1e3;
-    EVICTION_INTERVAL_MS = 5 * 60 * 1e3;
-    RING_CAP = 64;
-    reentryAls = new async_hooks.AsyncLocalStorage();
-    state = buildState({});
-    subscribe = buildSubscribe({
-      getBuffer: (id) => state.buffers.get(id),
-      getOrCreateSubscriberSet: (id) => {
-        let subs = state.subscribers.get(id);
-        if (subs === void 0) {
-          subs = /* @__PURE__ */ new Set();
-          state.subscribers.set(id, subs);
-        }
-        return subs;
-      },
-      removeSubscriber: (id, cb) => {
-        const set = state.subscribers.get(id);
-        set?.delete(cb);
-        if (set !== void 0 && set.size === 0) state.subscribers.delete(id);
-      }
-    });
-  }
-});
-function toJsonSchema(schema, options = { unrepresentable: "any" }) {
-  return zod.toJSONSchema(schema, options);
-}
-var init_to_json_schema = __esm({
-  "src/internal/zod/to-json-schema.ts"() {
-  }
-});
-function requireZod() {
-  if (cachedZ !== void 0) return cachedZ;
-  const r = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
-  let mod;
-  try {
-    mod = r("zod");
-  } catch (cause) {
-    throw new exports.ConfigurationError(
-      'Structured output requires the optional peer dependency `zod`. Add `"zod": "^3.25.0 || ^4.0.0"` to your package.json and reinstall.',
-      { code: "zod_not_installed", cause }
-    );
-  }
-  cachedZ = mod.z ?? mod;
-  return cachedZ;
-}
-function makeOutputTool(jsonSchema, onCapture) {
-  return {
-    name: "output",
-    description: "Call this tool with your final structured answer. Match the JSON schema exactly.",
-    inputSchema: jsonSchema,
-    handler: (input) => {
-      const out = onCapture(input);
-      if (typeof out === "string") return out;
-      if (out instanceof Promise) return out;
-      return "";
-    }
-  };
-}
-function buildTransientAgentOptions(params) {
-  return {
-    model: params.model,
-    local: params.local,
-    tools: [params.outputTool],
-    systemPrompt: params.systemPrompt ?? "You produce structured output by calling the `output` tool exactly once. Match the JSON schema.",
-    ...params.apiKey !== void 0 ? { apiKey: params.apiKey } : {},
-    ...params.providers !== void 0 ? { providers: params.providers } : {}
-  };
-}
-function extractUsage2(result) {
-  const u = result.usage;
-  if (u === void 0) return { inputTokens: 0, outputTokens: 0 };
-  return { inputTokens: u.inputTokens ?? 0, outputTokens: u.outputTokens ?? 0 };
-}
-function buildToolPrompt(prompt) {
-  return `${prompt}
-
-Respond by calling the \`output\` tool with the structured answer that matches the schema.`;
-}
-function setupStructuredOutput(schema, maxRetries) {
-  const z8 = requireZod();
-  const jsonSchema = toJsonSchema(schema, { unrepresentable: "any" });
-  return {
-    z: z8,
-    jsonSchema,
-    maxRetries: maxRetries ?? 1,
-    initialUsage: { inputTokens: 0, outputTokens: 0 }
-  };
-}
-async function disposeAndDeleteTransient(agent, deletor) {
-  await agent.dispose();
-  try {
-    await deletor(agent.agentId);
-  } catch {
-  }
-}
-var cachedZ;
-var init_structured_output_helpers = __esm({
-  "src/internal/structured-output-helpers.ts"() {
-    init_errors();
-    init_to_json_schema();
-  }
-});
-
-// src/generate-object.ts
-var generate_object_exports = {};
-__export(generate_object_exports, {
-  GenerateObjectError: () => exports.GenerateObjectError,
-  generateObjectImpl: () => generateObjectImpl
-});
-function salvagePartial(schema, raw) {
-  if (typeof raw !== "object" || raw === null) return raw;
-  const shape = schema.shape;
-  if (shape === void 0 || typeof shape !== "object") return raw;
-  const rawObj = raw;
-  const out = {};
-  for (const [key2, fieldSchema] of Object.entries(shape)) {
-    if (typeof fieldSchema?.safeParse !== "function") continue;
-    const parsed = fieldSchema.safeParse(rawObj[key2]);
-    if (parsed.success) out[key2] = parsed.data;
-  }
-  return out;
-}
-async function generateObjectImpl(options, deps) {
-  const { jsonSchema, maxRetries, initialUsage } = setupStructuredOutput(
-    options.schema,
-    options.maxRetries
-  );
-  let capturedRaw;
-  let lastUsage = initialUsage;
-  const sentinel = /* @__PURE__ */ Symbol("generate-object-sentinel");
-  class CaptureSentinel extends Error {
-    constructor(captured) {
-      super("generate-object-capture");
-      this.captured = captured;
-    }
-    captured;
-    [sentinel] = true;
-  }
-  const outputTool = makeOutputTool(jsonSchema, (input) => {
-    if (capturedRaw === void 0) {
-      capturedRaw = input;
-    }
-    throw new CaptureSentinel(input);
-  });
-  const agentOptions = buildTransientAgentOptions({
-    model: options.model,
-    local: options.local,
-    outputTool,
-    ...options.systemPrompt !== void 0 ? { systemPrompt: options.systemPrompt } : {},
-    ...options.apiKey !== void 0 ? { apiKey: options.apiKey } : {},
-    ...options.providers !== void 0 ? { providers: options.providers } : {}
-  });
-  const agent = await deps.create(agentOptions);
-  try {
-    const userMessage = buildToolPrompt(options.prompt);
-    let lastParseError;
-    for (let attempt = 0; attempt <= maxRetries; attempt += 1) {
-      capturedRaw = void 0;
-      const run = await agent.send(userMessage);
-      const result = await run.wait();
-      lastUsage = extractUsage2(result);
-      if (capturedRaw === void 0) {
-        if (result.status === "error" && result.error !== void 0) {
-          throw new exports.GenerateObjectError(
-            "no_tool_call",
-            `Agent run failed before the model could reply: ${result.error.message ?? "unknown error"} [${result.error.code ?? "?"}]`,
-            result.error
-          );
-        }
-        if (attempt === maxRetries) {
-          throw new exports.GenerateObjectError(
-            "no_tool_call",
-            "The model returned text instead of calling the `output` tool."
-          );
-        }
-        continue;
-      }
-      const parsed = options.schema.safeParse(capturedRaw);
-      if (parsed.success) {
-        return {
-          object: parsed.data,
-          raw: capturedRaw,
-          usage: lastUsage,
-          finishReason: "tool_use"
-        };
-      }
-      lastParseError = parsed.error;
-    }
-    if (options.errorStrategy === "return-raw") {
-      return {
-        object: capturedRaw,
-        raw: capturedRaw,
-        usage: lastUsage,
-        finishReason: "tool_use"
-      };
-    }
-    if (options.errorStrategy === "return-partial") {
-      return {
-        object: salvagePartial(options.schema, capturedRaw),
-        raw: capturedRaw,
-        usage: lastUsage,
-        finishReason: "tool_use"
-      };
+  void (async () => {
+    try {
+      await checkCancelRequestedAt(resolvedId, aborter);
+      if (aborter.signal.aborted) {
+        const cancelledAt = Date.now();
+        await transition(resolvedId, "cancelled", { cancelledAt });
+        emitToSubscribers(resolvedId, { type: "cancelled", taskId: resolvedId, cancelledAt });
+        return;
+      }
+      const startedAt = Date.now();
+      await transition(resolvedId, "running", { startedAt });
+      emitToSubscribers(resolvedId, { type: "started", taskId: resolvedId, startedAt });
+      await runWorkAndFinalize(resolvedId, aborter, internal.work);
+    } finally {
+      release();
+      state.aborters.delete(resolvedId);
     }
-    throw new exports.GenerateObjectError(
-      "parse_failed",
-      "Schema parse failed after all retries.",
-      lastParseError
-    );
+  })();
+  return queuedHandle;
+}
+async function list(filter = {}) {
+  return state.store.list(filter);
+}
+async function get(id) {
+  if (!isValidTaskId(id, true)) return void 0;
+  return state.store.get(id);
+}
+async function cancel(id, reason) {
+  if (!isValidTaskId(id, true)) return { cancelled: false, alreadyTerminal: false };
+  const handle = await state.store.get(id);
+  if (handle === void 0) return { cancelled: false, alreadyTerminal: false };
+  if (handle.state === "finished" || handle.state === "error" || handle.state === "cancelled") {
+    return { cancelled: false, alreadyTerminal: true };
+  }
+  const span = startTaskCancelSpan({
+    taskId: id,
+    ...reason !== void 0 ? { reason } : {},
+    via: "api"
+  });
+  try {
+    return await cancelInternal(id, handle.state, reason);
   } finally {
-    await disposeAndDeleteTransient(agent, deps.delete);
+    span.end();
   }
 }
-exports.GenerateObjectError = void 0;
-var init_generate_object = __esm({
-  "src/generate-object.ts"() {
-    init_structured_output_helpers();
-    exports.GenerateObjectError = class extends Error {
-      name = "GenerateObjectError";
-      code;
-      cause;
-      constructor(code, message, cause) {
-        super(message);
-        this.code = code;
-        if (cause !== void 0) this.cause = cause;
+async function cancelInternal(id, currentState, reason) {
+  if (currentState === "queued") {
+    const cancelledAt = Date.now();
+    await transition(id, "cancelled", { cancelledAt });
+    emitToSubscribers(id, {
+      type: "cancelled",
+      taskId: id,
+      cancelledAt,
+      ...reason !== void 0 ? { reason } : {}
+    });
+    state.aborters.delete(id);
+    return { cancelled: true, alreadyTerminal: false };
+  }
+  const aborter = state.aborters.get(id);
+  if (aborter !== void 0) aborter.abort(reason ?? "cancelled");
+  return { cancelled: true, alreadyTerminal: false };
+}
+async function evictNow(now = Date.now()) {
+  return state.store.evictTerminalOlderThan(now - state.retentionMs);
+}
+var DEFAULT_CONCURRENCY, DEFAULT_RETENTION_MS, EVICTION_INTERVAL_MS, RING_CAP, reentryAls, state, subscribe;
+var init_registry = __esm({
+  "src/internal/task/registry.ts"() {
+    init_errors();
+    init_task();
+    init_async_semaphore();
+    init_ring_buffer();
+    init_store();
+    init_subscribe();
+    init_telemetry();
+    DEFAULT_CONCURRENCY = 8;
+    DEFAULT_RETENTION_MS = 60 * 60 * 1e3;
+    EVICTION_INTERVAL_MS = 5 * 60 * 1e3;
+    RING_CAP = 64;
+    reentryAls = new async_hooks.AsyncLocalStorage();
+    state = buildState({});
+    subscribe = buildSubscribe({
+      getBuffer: (id) => state.buffers.get(id),
+      getOrCreateSubscriberSet: (id) => {
+        let subs = state.subscribers.get(id);
+        if (subs === void 0) {
+          subs = /* @__PURE__ */ new Set();
+          state.subscribers.set(id, subs);
+        }
+        return subs;
+      },
+      removeSubscriber: (id, cb) => {
+        const set = state.subscribers.get(id);
+        set?.delete(cb);
+        if (set !== void 0 && set.size === 0) state.subscribers.delete(id);
       }
-    };
+    });
   }
 });
 
@@ -3975,7 +3996,7 @@ async function* streamObjectImpl(options, deps) {
         }
       }
       const result = await run.wait();
-      lastUsage = extractUsage2(result);
+      lastUsage = extractUsage(result);
       if (capturedRaw === void 0) {
         if (result.status === "error" && result.error !== void 0) {
           throw new exports.StreamObjectError(
@@ -4727,7 +4748,10 @@ async function runAgentStep(step, input, ctx) {
     };
   }
   const exec = async () => {
-    const run = await step.agent.send(prompt);
+    const run = await step.agent.send(
+      prompt,
+      step.origin !== void 0 ? { origin: step.origin } : void 0
+    );
     const result = await run.wait();
     if (result.status === "finished") {
       return result.result ?? "";
@@ -5499,6 +5523,7 @@ var AgentBuilder = class {
   constructor(deps) {
     this.deps = deps;
   }
+  /** SE8 — accepts a bare-string id shorthand (`"openai/gpt-4o-mini"`) or a {@link ModelSelection}. */
   model(m) {
     this.opts.model = m;
     return this;
@@ -5856,13 +5881,87 @@ function isLocalAgentId(id) {
   return id.startsWith(PREFIX.localAgent);
 }
 
+// src/internal/runtime/config/default-model.ts
+var DEFAULT_AGENTIC_MODEL_ID = "google/gemini-2.0-flash-001";
+
+// src/agent-generate.ts
+async function agentGenerate(agent, agentModel, agentApiKey, agentLocal, input, options) {
+  const { output, maxRetries, errorStrategy, ...sendOptions } = options;
+  const run = await agent.send(input, sendOptions);
+  const result = await run.wait();
+  const { generateObjectImpl: generateObjectImpl2, GenerateObjectError: GenerateObjectError2 } = await Promise.resolve().then(() => (init_generate_object(), generate_object_exports));
+  const answer = structurableAnswerOrThrow(result, GenerateObjectError2);
+  const { getAgentFacade: getAgentFacade2 } = await Promise.resolve().then(() => (init_agent_factory_registry(), agent_factory_registry_exports));
+  const facade = getAgentFacade2();
+  const structured = await generateObjectImpl2(
+    {
+      prompt: answer,
+      schema: output,
+      // `agentModel` arrives already normalized (`this.model` passed through
+      // `normalizeModel` in the LocalAgent/CloudAgent constructor), so the widened
+      // `string | ModelSelection` field only ever receives a `ModelSelection` here.
+      model: agentModel ?? { id: DEFAULT_AGENTIC_MODEL_ID },
+      // `local` is required to keep the transient structuring agent local-only;
+      // default to the process cwd when the agent had no explicit local config.
+      local: agentLocal ?? { cwd: process.cwd() },
+      ...agentApiKey !== void 0 ? { apiKey: agentApiKey } : {},
+      ...maxRetries !== void 0 ? { maxRetries } : {},
+      ...errorStrategy !== void 0 ? { errorStrategy } : {}
+    },
+    {
+      create: (opts) => facade.create(opts),
+      delete: (agentId) => facade.delete(agentId)
+    }
+  );
+  return {
+    object: structured.object,
+    result,
+    raw: structured.raw,
+    usage: structured.usage
+  };
+}
+function structurableAnswerOrThrow(result, GenerateObjectError2) {
+  if (result.status === "error") {
+    throw new GenerateObjectError2(
+      "no_tool_call",
+      `Agent run failed before an answer could be structured: ${result.error?.message ?? "unknown error"} [${result.error?.code ?? "?"}]`,
+      result.error
+    );
+  }
+  if (result.status === "cancelled") {
+    throw new GenerateObjectError2(
+      "no_tool_call",
+      "Agent run was cancelled before an answer could be structured."
+    );
+  }
+  const answer = result.result;
+  if (answer === void 0 || answer.length === 0) {
+    throw new GenerateObjectError2(
+      "no_tool_call",
+      "The tool loop finished with no text answer (tool-only completion) \u2014 there is nothing to structure."
+    );
+  }
+  return answer;
+}
+
 // src/internal/runtime/cloud/cloud-agent.ts
 init_errors();
 init_cwd_mutex();
 init_path_guard();
 
-// src/internal/runtime/config/default-model.ts
-var DEFAULT_AGENTIC_MODEL_ID = "google/gemini-2.0-flash-001";
+// src/internal/runtime/model-selection.ts
+init_errors();
+function normalizeModel(m) {
+  if (m === void 0 || typeof m !== "string") return m;
+  const id = m.trim();
+  if (id.length === 0) {
+    throw new exports.ConfigurationError(
+      'model must be a non-empty "provider/model" id string or a ModelSelection object',
+      { code: "invalid_model_selection" }
+    );
+  }
+  return { id };
+}
 
 // src/internal/runtime/registry/agent-registry-store.ts
 init_cwd_mutex();
@@ -5939,7 +6038,10 @@ var REGISTRY_RELATIVE_PATH = path.join(".theokit", "agents", "registry.json");
 function stripSecretsFromOptions(options) {
   return assignDefined({
     name: options.name,
-    model: options.model !== void 0 ? { id: options.model.id } : void 0,
+    model: (() => {
+      const m = normalizeModel(options.model);
+      return m !== void 0 ? { id: m.id } : void 0;
+    })(),
     systemPrompt: typeof options.systemPrompt === "string" ? options.systemPrompt : void 0,
     local: serializeLocal(options.local),
     cloud: serializeCloud(options.cloud),
@@ -6224,7 +6326,8 @@ function serializeCloudAgentConfig(options) {
     cloud: serializeCloud2(options.cloud)
   };
   if (typeof options.agentId === "string") payload.agentId = options.agentId;
-  if (options.model !== void 0) payload.model = { id: options.model.id };
+  const cfgModel = normalizeModel(options.model);
+  if (cfgModel !== void 0) payload.model = { id: cfgModel.id };
   if (typeof options.systemPrompt === "string") payload.systemPrompt = options.systemPrompt;
   const skills = serializeSkills(options.skills);
   if (skills !== void 0) payload.skills = skills;
@@ -7029,6 +7132,7 @@ function applyScriptMetrics(base, script) {
   if (script.cost !== void 0) base.cost = script.cost;
   if (script.stoppedAtIterationLimit === true) base.stoppedAtIterationLimit = true;
   if (script.stoppedByDoomLoop === true) base.stoppedByDoomLoop = true;
+  if (script.origin !== void 0) base.origin = script.origin;
 }
 
 // src/internal/runtime/cloud/cloud-run.ts
@@ -7384,7 +7488,7 @@ var CloudAgent = class {
   disposed = false;
   constructor(options, providedAgentId) {
     this.agentId = providedAgentId ?? options.agentId ?? generateCloudAgentId();
-    this.model = options.model;
+    this.model = normalizeModel(options.model);
     this.options = options;
     this.cloudPayload = serializeCloudAgentConfig({ ...options, agentId: this.agentId });
     const repoUrls = (options.cloud?.repos ?? []).map((repo) => repo.url);
@@ -7414,6 +7518,17 @@ var CloudAgent = class {
     const apiKey = resolveApiKey(this.options.apiKey);
     return isFixtureApiKey(apiKey) && getConfiguredBaseUrl() === void 0;
   }
+  // SE9 — integrated structured output; delegates to the shared helper.
+  generate(message, options) {
+    return agentGenerate(
+      this,
+      this.model,
+      this.options.apiKey,
+      this.options.local,
+      message,
+      options
+    );
+  }
   async send(message, options = {}) {
     if (options.tools !== void 0 && options.tools.length > 0) {
       throw new exports.ConfigurationError(
@@ -7444,7 +7559,7 @@ var CloudAgent = class {
     });
   }
   async sendLocked(message, options) {
-    const overrideModel = options.model;
+    const overrideModel = normalizeModel(options.model);
     if (overrideModel !== void 0) {
       this.model = overrideModel;
       updateRegisteredAgent(this.agentId, { model: overrideModel });
@@ -8361,18 +8476,18 @@ var ALL_ADAPTERS = [
   arizeAdapter,
   braintrustAdapter
 ];
-var registered = /* @__PURE__ */ new Set();
+var registered2 = /* @__PURE__ */ new Set();
 function tryAutoRegisterAdapters(settings) {
   if (settings?.enabled !== true) return;
   if (settings.autoDetect === false) return;
   const disabled = new Set(settings.disable ?? []);
   for (const adapter of ALL_ADAPTERS) {
-    if (registered.has(adapter.moduleName)) continue;
+    if (registered2.has(adapter.moduleName)) continue;
     if (disabled.has(adapter.displayName.toLowerCase())) continue;
     if (!adapter.detect()) continue;
     try {
       adapter.register();
-      registered.add(adapter.moduleName);
+      registered2.add(adapter.moduleName);
       process.stderr.write(`[theokit-sdk] telemetry: ${adapter.displayName} auto-instrumented.
 `);
     } catch (cause) {
@@ -8902,6 +9017,26 @@ function paginate(items, opts) {
   return items.slice(start, end);
 }
 
+// src/internal/persistence/session-meta.ts
+function applyMetaPatch(current, patch) {
+  const next = {};
+  if (current.title !== void 0) next.title = current.title;
+  if (current.tag !== void 0) next.tag = current.tag;
+  if (patch.title === null) delete next.title;
+  else if (patch.title !== void 0) next.title = patch.title;
+  if (patch.tag === null) delete next.tag;
+  else if (patch.tag !== void 0) next.tag = patch.tag;
+  return next;
+}
+function coerceSessionMeta(raw) {
+  if (typeof raw !== "object" || raw === null) return void 0;
+  const obj = raw;
+  const meta = {};
+  if (typeof obj.title === "string") meta.title = obj.title;
+  if (typeof obj.tag === "string") meta.tag = obj.tag;
+  return meta.title === void 0 && meta.tag === void 0 ? void 0 : meta;
+}
+
 // src/internal/persistence/conversation-storage-fs.ts
 var FileSystemConversationStorage = class {
   #root;
@@ -8952,6 +9087,37 @@ var FileSystemConversationStorage = class {
   async compact(conversationId, maxTurns) {
     await compactSessionFile(this.#root, conversationId, maxTurns);
   }
+  // SE4 — session metadata persisted as a per-conversation sidecar
+  // `<root>/.theokit/agents/<safeId>/session.json` (same sanitized perimeter as
+  // the transcript). Kept separate from messages.jsonl so a title/tag write does
+  // not rewrite the append-only log.
+  #metaPath(conversationId) {
+    const safe2 = sanitizeIdentifier(conversationId, { maxLen: 128 });
+    return safePathJoin(this.#root, ".theokit", "agents", safe2, "session.json");
+  }
+  async getSessionMeta(conversationId) {
+    try {
+      const raw = await promises.readFile(this.#metaPath(conversationId), "utf8");
+      return coerceSessionMeta(JSON.parse(raw));
+    } catch (cause) {
+      if (cause.code === "ENOENT") return void 0;
+      throw cause;
+    }
+  }
+  async setSessionMeta(conversationId, patch) {
+    const metaPath = this.#metaPath(conversationId);
+    await promises.mkdir(path.dirname(metaPath), { recursive: true });
+    await withFileLock(metaPath, async () => {
+      let current = {};
+      try {
+        current = coerceSessionMeta(JSON.parse(await promises.readFile(metaPath, "utf8"))) ?? {};
+      } catch (cause) {
+        if (cause.code !== "ENOENT") throw cause;
+      }
+      const next = applyMetaPatch(current, patch);
+      await promises.writeFile(metaPath, redactSecrets(JSON.stringify(next)), "utf8");
+    });
+  }
   async dispose() {
   }
 };
@@ -10803,23 +10969,27 @@ function tryParseSkill(raw, fallbackName, source, options) {
 
 // src/internal/runtime/skills/skills-manager.ts
 var SkillsManager = class {
-  constructor(cwd, _enabled, settingSourcesIncludeProject) {
+  constructor(cwd, _enabled, settingSourcesIncludeProject, skillsDir, inline) {
     this.cwd = cwd;
     this.settingSourcesIncludeProject = settingSourcesIncludeProject;
+    this.skillsDir = skillsDir;
+    this.inline = inline;
   }
   cwd;
   settingSourcesIncludeProject;
+  skillsDir;
+  inline;
   skills = [];
   async initialize() {
     if (!this.settingSourcesIncludeProject) {
-      this.skills = [];
+      this.skills = this.mergeInline([]);
       return;
     }
     await this.refresh();
   }
   async refresh() {
-    const skillsRoot = path.join(this.cwd, ".theokit", "skills");
-    this.skills = await discoverSkills(skillsRoot, {
+    const skillsRoot = this.skillsDir ?? path.join(this.cwd, ".theokit", "skills");
+    const discovered = await discoverSkills(skillsRoot, {
       onInvalidSkill: (info) => {
         process.stderr.write(
           `[theokit-sdk] skill ${info.name} skipped (${info.code}): ${info.message}
@@ -10827,6 +10997,13 @@ var SkillsManager = class {
         );
       }
     });
+    this.skills = this.mergeInline(discovered);
+  }
+  /** M22 — merge inline skills over discovered ones; inline wins on a name conflict. */
+  mergeInline(discovered) {
+    if (this.inline === void 0 || this.inline.length === 0) return discovered;
+    const inlineNames = new Set(this.inline.map((s) => s.name));
+    return [...discovered.filter((s) => !inlineNames.has(s.name)), ...this.inline];
   }
   list() {
     return Promise.resolve(this.skills);
@@ -10862,7 +11039,7 @@ function bootstrapSubmanagers(args) {
   const providerCount = (args.options.providers?.routes?.length ?? 0) + enabledPluginNames(args.options.plugins).length;
   if (providerCount > 0 || args.options.providers !== void 0) {
     out.providers = new ProvidersManagerImpl(
-      args.options.model,
+      normalizeModel(args.options.model),
       args.options.providers,
       args.options.plugins
     );
@@ -10871,7 +11048,10 @@ function bootstrapSubmanagers(args) {
     out.skillsManager = new SkillsManager(
       args.workspaceCwd,
       args.options.skills?.enabled,
-      args.settingSourcesIncludeProject
+      args.settingSourcesIncludeProject,
+      // M22 — custom skills directory + inline (code-defined) skills.
+      args.options.skills?.skillsDir,
+      args.options.skills?.inline
     );
     const localSkills = out.skillsManager;
     out.skills = { list: () => localSkills.list() };
@@ -10929,6 +11109,7 @@ function createLocalRun(options) {
     projectMcpServers: options.projectMcpServers,
     ...options.persistMemoryFact !== void 0 ? { persistMemoryFact: options.persistMemoryFact } : {}
   });
+  if (options.sendOptions.origin !== void 0) script.origin = options.sendOptions.origin;
   const handle = new LocalRun({
     id,
     agentId: options.agentId,
@@ -11577,6 +11758,15 @@ async function emitReasoningDeltaCallback(inputs, text) {
   );
 }
 
+// src/types/run-events.ts
+function emitRunEvent(sink, event) {
+  if (sink === void 0) return;
+  try {
+    sink(event);
+  } catch {
+  }
+}
+
 // src/internal/agent-loop/tool-dispatch.ts
 init_async_local_storage();
 
@@ -11674,6 +11864,22 @@ function coerceArgsToSchema(args, schema) {
   return { value: out, changed };
 }
 
+// src/tool-error.ts
+init_errors();
+var ToolError = class extends exports.TheokitAgentError {
+  name = "ToolError";
+  /** The error content surfaced to the model: a string, or text/image blocks. */
+  content;
+  constructor(content, options = {}) {
+    super(renderToolErrorMessage(content), { ...options, isRetryable: false });
+    this.content = content;
+  }
+};
+function renderToolErrorMessage(content) {
+  if (typeof content === "string") return content;
+  return content.map((block) => block.type === "text" ? block.text : `[${block.source.media_type} image]`).join("\n");
+}
+
 // src/internal/runtime/tools/shell-tool.ts
 async function runShell(options) {
   if (options.sandbox === true && isObviouslyUnsafe(options.command)) {
@@ -11727,9 +11933,13 @@ async function runHandlerTool(kind, handler, call, signal, context) {
     return { stdout: "", stderr: `${kind} tool ${call.name} has no handler`, exitCode: 127 };
   }
   try {
-    const stdout = await handler(call.input, { signal, context });
-    return { stdout, stderr: "", exitCode: 0 };
+    const out = await handler(call.input, { signal, context });
+    if (typeof out !== "string") return { stdout: "", stderr: "", exitCode: 0, content: out };
+    return { stdout: out, stderr: "", exitCode: 0 };
   } catch (cause) {
+    if (cause instanceof ToolError) {
+      return { stdout: "", stderr: cause.message, exitCode: 1, content: cause.content };
+    }
     const message = cause instanceof Error ? cause.message : String(cause);
     return { stdout: "", stderr: message, exitCode: 1 };
   }
@@ -11848,6 +12058,11 @@ async function dispatchSingleCall(inputs, tools, call, events, parentSpan) {
     toolSpan?.end();
     return fileVeto;
   }
+  emitRunEvent(inputs.runEventSink, {
+    type: "tool_progress",
+    toolName: workingCall.name,
+    toolCallId: callId
+  });
   const result = await runToolWithLifecycle(inputs, resolved, workingCall, callId);
   await inputs.pluginManager?.runPostToolCallHooks({
     name: workingCall.name,
@@ -11874,6 +12089,13 @@ function applyRepairAndExtractCall(tools, call) {
 function vetoFromForkWhitelist(inputs, call, callId, events) {
   const whitelistDecision = checkToolWhitelist(call.name);
   if (whitelistDecision.allowed) return void 0;
+  emitRunEvent(inputs.runEventSink, {
+    type: "permission_denied",
+    toolName: call.name,
+    toolCallId: callId,
+    source: "fork_whitelist",
+    message: whitelistDecision.reason ?? "tool not available in fork"
+  });
   events.push(buildToolUseRunning(inputs, callId, call));
   events.push(
     buildToolUseCompleted(inputs, callId, call, {
@@ -11910,6 +12132,13 @@ async function vetoFromPluginPreHook(inputs, call, callId, events) {
     runId: inputs.runId
   });
   if (pluginVeto === void 0) return void 0;
+  emitRunEvent(inputs.runEventSink, {
+    type: "permission_denied",
+    toolName: call.name,
+    toolCallId: callId,
+    source: "plugin",
+    message: pluginVeto.message
+  });
   events.push(
     buildToolUseCompleted(inputs, callId, call, {
       stdout: "",
@@ -11932,6 +12161,13 @@ async function vetoFromFileHookPreDecision(inputs, call, callId, events) {
     runId: inputs.runId
   });
   if (!preDecision.blocked) return void 0;
+  emitRunEvent(inputs.runEventSink, {
+    type: "permission_denied",
+    toolName: call.name,
+    toolCallId: callId,
+    source: "file_hook",
+    message: preDecision.reason ?? "blocked by hook"
+  });
   events.push(
     buildToolUseCompleted(inputs, callId, call, {
       stdout: "",
@@ -11975,7 +12211,9 @@ async function runToolWithLifecycle(inputs, resolved, call, callId) {
     await safeEmitToolHook(inputs.onToolEnd, {
       toolName: call.name,
       args: call.input,
-      result: result.stdout,
+      // SE7 — a block-returning handler has empty `stdout`; surface its structured
+      // content to the hook instead of an empty string.
+      result: result.content !== void 0 ? result.content : result.stdout,
       conversationId: inputs.agentId,
       callId,
       durationMs
@@ -11997,7 +12235,10 @@ function finalizeSpanAndPostHook(inputs, call, callId, result, events, toolSpan)
     output: {
       stdout: result.stdout,
       stderr: result.stderr,
-      exitCode: result.exitCode ?? 0
+      exitCode: result.exitCode ?? 0,
+      // SE7 — structured content (text + image blocks) when the handler
+      // returned/threw blocks; absent for the string path.
+      ...result.content !== void 0 ? { content: result.content } : {}
     },
     agentId: inputs.agentId,
     runId: inputs.runId
@@ -12010,7 +12251,9 @@ function finalizeSpanAndPostHook(inputs, call, callId, result, events, toolSpan)
   return {
     type: "tool_result",
     toolUseId: call.id,
-    content: renderToolResult(result),
+    // SE7 — structured content blocks (handler-returned or ToolError-carried)
+    // are authoritative; otherwise the legacy string rendering.
+    content: result.content !== void 0 ? result.content : renderToolResult(result),
     ...result.exitCode !== 0 && result.exitCode !== void 0 ? { isError: true } : {}
   };
 }
@@ -12059,6 +12302,29 @@ function buildToolUseCompleted(inputs, callId, call, result) {
   };
 }
 
+// src/internal/llm/tool-result-content.ts
+init_errors();
+function toBlockToolResultContent(content) {
+  return content;
+}
+function toStringToolResultContent(content, providerName) {
+  if (typeof content === "string") return content;
+  if (content.some((block) => block.type === "image")) {
+    throw new exports.ConfigurationError(
+      `provider "${providerName}" does not support image content in tool results`
+    );
+  }
+  return content.filter(
+    (block) => block.type === "text"
+  ).map((block) => block.text).join("\n");
+}
+function renderToolResultContentText(content, fn) {
+  if (typeof content === "string") return fn(content);
+  return content.map(
+    (block) => block.type === "text" ? { type: "text", text: fn(block.text) } : block
+  );
+}
+
 // src/internal/agent-loop/tool-result-guard.ts
 var OPEN = "<untrusted-tool-output>";
 var CLOSE = "</untrusted-tool-output>";
@@ -12084,7 +12350,11 @@ ${CLOSE}`;
 function applyToolResultGuard(parts, opts) {
   if (opts.delimit !== true && opts.redactPii !== true) return parts;
   return parts.map(
-    (p) => p.type === "tool_result" ? { ...p, content: guardText(p.content, opts) } : p
+    (p) => (
+      // SE7 — guard the TEXT of a tool result (string or the text blocks of a
+      // structured content); image blocks pass through untouched.
+      p.type === "tool_result" ? { ...p, content: renderToolResultContentText(p.content, (t) => guardText(t, opts)) } : p
+    )
   );
 }
 
@@ -13015,10 +13285,10 @@ function stripVertexPrefix(modelId) {
 }
 
 // src/internal/providers/builtin/index.ts
-var registered2 = false;
+var registered3 = false;
 function registerBuiltins() {
-  if (registered2) return;
-  registered2 = true;
+  if (registered3) return;
+  registered3 = true;
   registerProvider(ANTHROPIC);
   registerProvider(OPENAI);
   registerProvider(OPENROUTER);
@@ -13247,7 +13517,9 @@ function toAnthropicWireMessage(message) {
     return {
       type: "tool_result",
       tool_use_id: part.toolUseId,
-      content: part.content,
+      // SE7 — this wire is block-capable: strings pass through, structured
+      // text/image blocks are forwarded natively.
+      content: toBlockToolResultContent(part.content),
       ...part.isError === true ? { is_error: true } : {}
     };
   });
@@ -14039,7 +14311,8 @@ function toOllamaMessages(message) {
       if (part.type === "tool_result") {
         out.push({
           role: "tool",
-          content: part.content,
+          // SE7 — string-only tool role: text blocks flatten; image fails fast.
+          content: toStringToolResultContent(part.content, "ollama"),
           tool_name: part.toolUseId
         });
       }
@@ -14576,7 +14849,9 @@ function userOrToolMessages(message) {
       out.push({
         role: "tool",
         tool_call_id: part.toolUseId,
-        content: part.content
+        // SE7 — this wire's tool role is string-only: text blocks flatten; an
+        // image block fails fast (ConfigurationError).
+        content: toStringToolResultContent(part.content, "openai")
       });
     }
   }
@@ -15506,18 +15781,20 @@ function levenshtein(a, b) {
 function createRealLocalRun(options) {
   const { userText, id, startTime } = prepareRunContext(options.message);
   const supported = /* @__PURE__ */ new Set(["stream", "wait", "cancel", "conversation"]);
-  const unusedFixtureScript = {
+  const runScript = {
     events: [],
     finalStatus: "running",
     cancellable: false,
-    conversation: []
+    conversation: [],
+    // SE3 — carry the turn's provenance so buildResult forwards it onto RunResult.origin.
+    ...options.sendOptions.origin !== void 0 ? { origin: options.sendOptions.origin } : {}
   };
   const handle = new RealLocalRun(
     {
       id,
       agentId: options.agentId,
       model: options.model,
-      script: unusedFixtureScript,
+      script: runScript,
       supportedOps: supported,
       startTime
     },
@@ -15629,6 +15906,8 @@ function buildLoopInputs(options, runId, userText) {
     // M7 — forward SendOptions.context to the loop so every tool handler receives
     // it on `ctx.context` (shared run config set once, e.g. projectRoot).
     ...options.sendOptions.context !== void 0 ? { context: options.sendOptions.context } : {},
+    // SE2 — forward the opt-in typed runtime-event sink to the loop.
+    ...options.sendOptions.onRunEvent !== void 0 ? { runEventSink: options.sendOptions.onRunEvent } : {},
     // #58 / #57 — forward the per-tool timeout + tool-result guard so a consumer
     // can enable them via SendOptions (not only internal AgentLoopInputs).
     ...options.sendOptions.perToolTimeoutMs !== void 0 ? { perToolTimeoutMs: options.sendOptions.perToolTimeoutMs } : {},
@@ -17373,7 +17652,7 @@ function wrapRunWithPostReplyHook(args) {
 async function executeSendLocked(inputs, message, options) {
   if (inputs.disposed) throw new exports.AgentDisposedError(inputs.agentId);
   await consumePending(inputs.agentId, inputs.invalidationPending, inputs.clearInvalidation, inputs.reload);
-  inputs.applyModelOverride(options.model);
+  inputs.applyModelOverride(normalizeModel(options.model));
   const userText = typeof message === "string" ? message : message.text;
   if (inputs.options.onBeforeSend !== void 0) {
     await inputs.options.onBeforeSend({
@@ -17525,7 +17804,7 @@ var LocalAgent = class {
   constructor(options) {
     this.agentId = options.agentId ?? generateLocalAgentId();
     this._telemetry = createTelemetry(options.telemetry);
-    this.model = options.model;
+    this.model = normalizeModel(options.model);
     this.options = options;
     this.workspaceCwd = resolveCwd(options.local?.cwd);
     this.conversationStorage = options.conversationStorage;
@@ -17592,6 +17871,11 @@ var LocalAgent = class {
   hooks() {
     return this.hooksExecutor;
   }
+  // SE9 — integrated structured output; delegates to the shared helper.
+  generate(message, options) {
+    const { apiKey, local } = this.options;
+    return agentGenerate(this, this.model, apiKey, local, message, options);
+  }
   async send(message, options = {}) {
     if (options.tools !== void 0 && options.tools.length > 0) {
       validateToolCatalog(options.tools);
@@ -17831,6 +18115,7 @@ function includesSetting(options, source) {
 
 // src/agent-helpers.ts
 async function runCreateUnderSpan(options, span) {
+  options = { ...options, model: normalizeModel(options.model) };
   validateAgentOptions(options);
   validateCloudToolParity(options);
   await guardAgainstIdCollision(options);
@@ -17904,7 +18189,10 @@ async function createLocalAgent(options) {
   const willFlowToProvider = !isFixtureApiKey(apiKey) && !shouldUseRealLocalRuntime(apiKey);
   const shape = validateApiKeyShape(apiKey, {
     strict: willFlowToProvider,
-    ...willFlowToProvider ? { provider: providerFromModelId(options.model?.id) } : {}
+    // `options.model` is already normalized by `runCreateUnderSpan`; `normalizeModel`
+    // here is the idempotent narrowing of the widened public type (`{id}` passes
+    // through by reference) — cleaner than an `as` cast.
+    ...willFlowToProvider ? { provider: providerFromModelId(normalizeModel(options.model)?.id) } : {}
   });
   if (shape.malformed) {
     throw new exports.AuthenticationError(shape.message, { code: "malformed_api_key" });
@@ -17970,6 +18258,10 @@ async function rehydrateExistingAgent(agentId, existing, options) {
     ...existing.options,
     ...options,
     ...mergedLocal !== void 0 ? { local: mergedLocal } : {},
+    // SE8 — normalize a caller-supplied bare-string model override at this resume
+    // boundary (Agent.resume never flows through runCreateUnderSpan). Cloud resume
+    // honors it; local resume forces the persisted model below.
+    model: normalizeModel(options.model ?? existing.options.model),
     mcpServers: void 0,
     agentId
   };
@@ -18336,6 +18628,7 @@ async function getOrCreateUncached(agentId, options) {
 }
 setAgentFacade({
   create: (options) => Agent.create(options),
+  delete: (agentId) => Agent.delete(agentId),
   prompt: (message, options) => Agent.prompt(message, options),
   get: (agentId) => Agent.get(agentId),
   resume: (agentId, options) => Agent.resume(agentId, options),
@@ -18773,6 +19066,20 @@ var Budget = class {
   }
 };
 
+// src/create-skill.ts
+function createSkill(spec) {
+  if (!spec.name) throw new Error("createSkill: `name` is required.");
+  if (!spec.description) throw new Error("createSkill: `description` is required.");
+  return {
+    name: spec.name,
+    description: spec.description,
+    source: `inline://${spec.name}`,
+    instructions: spec.instructions,
+    ...spec.category !== void 0 ? { category: spec.category } : {},
+    ...spec.dependencies !== void 0 ? { dependencies: spec.dependencies } : {}
+  };
+}
+
 // src/cron.ts
 init_errors();
 
@@ -19282,6 +19589,8 @@ init_generate_object();
 // src/internal/persistence/conversation-storage-memory.ts
 var InMemoryConversationStorage = class {
   #store = /* @__PURE__ */ new Map();
+  // SE4 — session-level metadata (title/tag), kept beside the transcript.
+  #meta = /* @__PURE__ */ new Map();
   async getMessages(conversationId, opts) {
     const existing = this.#store.get(conversationId);
     return existing === void 0 ? [] : paginate(existing.slice(), opts);
@@ -19310,15 +19619,20 @@ var InMemoryConversationStorage = class {
   }
   async deleteConversation(conversationId) {
     this.#store.delete(conversationId);
+    this.#meta.delete(conversationId);
   }
   async deleteScope(prefix) {
     let n = 0;
     for (const id of [...this.#store.keys()]) {
       if (id.startsWith(prefix)) {
         this.#store.delete(id);
+        this.#meta.delete(id);
         n += 1;
       }
     }
+    for (const id of [...this.#meta.keys()]) {
+      if (id.startsWith(prefix)) this.#meta.delete(id);
+    }
     return n;
   }
   async listConversationIds(opts) {
@@ -19326,8 +19640,17 @@ var InMemoryConversationStorage = class {
     if (opts?.limit !== void 0) return all.slice(0, opts.limit);
     return all;
   }
+  async getSessionMeta(conversationId) {
+    const meta = this.#meta.get(conversationId);
+    return meta === void 0 ? void 0 : { ...meta };
+  }
+  async setSessionMeta(conversationId, patch) {
+    const current = this.#meta.get(conversationId) ?? {};
+    this.#meta.set(conversationId, applyMetaPatch(current, patch));
+  }
   async dispose() {
     this.#store.clear();
+    this.#meta.clear();
   }
 };
 
@@ -20067,6 +20390,21 @@ async function migrateSqliteToLance2(options) {
 }
 
 // src/permission-engine.ts
+function applyMode(verdict, mode, explicit) {
+  if (verdict === "deny") return "deny";
+  switch (mode) {
+    case "default":
+      return verdict;
+    case "plan":
+      return verdict === "allow" ? "allow" : "deny";
+    case "acceptEdits":
+      if (verdict === "ask") return explicit ? "ask" : "allow";
+      return verdict;
+    // allow stays allow
+    case "bypass":
+      return "allow";
+  }
+}
 function argMatches(matcher, value) {
   if (typeof matcher === "function") return matcher(value);
   if (value === void 0) return false;
@@ -20087,14 +20425,14 @@ var PermissionEngine = class {
    * argument values, so the same tool name can resolve to different actions
    * depending on what it is asked to do.
    */
-  evaluate(toolName, args) {
+  evaluate(toolName, args, mode = "default") {
     for (const rule of this.rules) {
       const nameMatches = typeof rule.tool === "string" ? rule.tool === toolName : rule.tool.test(toolName);
       if (!nameMatches) continue;
       if (rule.args !== void 0 && !this.#argsMatch(rule.args, args)) continue;
-      return rule.action;
+      return applyMode(rule.action, mode, true);
     }
-    return this.defaultAction;
+    return applyMode(this.defaultAction, mode, false);
   }
   #argsMatch(matchers, args) {
     const call = args ?? {};
@@ -20106,27 +20444,85 @@ var PermissionEngine = class {
 };
 
 // src/permission-plugin.ts
+async function resolveAsk(opts, name, args, mode) {
+  if (opts.canUseTool !== void 0) {
+    let decision;
+    try {
+      decision = await opts.canUseTool(name, args, { toolName: name, mode });
+    } catch {
+      return { block: true, message: `permission gate error (fail-closed): ${name}` };
+    }
+    return decision.behavior === "deny" ? { block: true, message: decision.message ?? `denied: ${name}` } : void 0;
+  }
+  return opts.onAsk ? opts.onAsk(name) : { block: true, message: `requires approval: ${name}` };
+}
 function createPermissionPlugin(engine, opts = {}) {
+  const mode = opts.mode ?? "default";
   return definePlugin({
     name: opts.name ?? "permission-engine",
     version: "1.0.0",
     kind: "general",
     register(ctx) {
-      ctx.on("pre_tool_call", (rawCtx) => {
+      ctx.on("pre_tool_call", async (rawCtx) => {
         const { name, args } = rawCtx;
-        const action = engine.evaluate(name, args);
+        const action = engine.evaluate(name, args, mode);
         if (action === "deny") {
           return { block: true, message: `denied by permission engine: ${name}` };
         }
-        if (action === "ask") {
-          return opts.onAsk ? opts.onAsk(name) : { block: true, message: `requires approval: ${name}` };
-        }
+        if (action === "ask") return resolveAsk(opts, name, args, mode);
         return void 0;
       });
     }
   });
 }
 
+// src/schema-normalizer.ts
+init_to_json_schema();
+function isJsonSchemaObject(s) {
+  if (typeof s !== "object" || s === null) return false;
+  const o = s;
+  if ("$schema" in o) return true;
+  return o.type === "object" && typeof o.properties === "object" && o.properties !== null;
+}
+function hasToJsonSchemaMethod(s) {
+  return typeof s === "object" && s !== null && typeof s.toJsonSchema === "function";
+}
+function isZodSchema(s) {
+  if (typeof s !== "object" || s === null) return false;
+  const o = s;
+  return typeof o.safeParse === "function" && ("_def" in o || "def" in o);
+}
+function isValibotSchema(s) {
+  if (typeof s !== "object" || s === null) return false;
+  const o = s;
+  return o.kind === "schema" && "type" in o && typeof o.toJsonSchema !== "function";
+}
+async function normalizeSchema(schema) {
+  if (isJsonSchemaObject(schema)) return schema;
+  if (isValibotSchema(schema)) {
+    const specifier = "@valibot/to-json-schema";
+    try {
+      const mod = await import(specifier);
+      return mod.toJsonSchema(schema);
+    } catch (err) {
+      const missing = err instanceof Error && /Cannot find|Cannot resolve|ERR_MODULE_NOT_FOUND/.test(err.message);
+      if (missing) {
+        throw new Error(
+          "normalizeSchema: a Valibot schema requires the optional '@valibot/to-json-schema' package. Install it, or use a Zod schema (the default recommendation)."
+        );
+      }
+      throw err;
+    }
+  }
+  if (isZodSchema(schema)) {
+    return toJsonSchema(schema, { unrepresentable: "any" });
+  }
+  if (hasToJsonSchemaMethod(schema)) return schema.toJsonSchema();
+  throw new Error(
+    "normalizeSchema: unsupported schema. Supported: Zod (default), JSON Schema, ArkType (.toJsonSchema()), Valibot (with @valibot/to-json-schema)."
+  );
+}
+
 // src/security.ts
 init_security();
 var Security = class {
@@ -20179,6 +20575,96 @@ var Security = class {
   }
 };
 
+// src/session-manager.ts
+var SUMMARY_PREVIEW_MAX = 80;
+function createSessionManager(storage2) {
+  return {
+    async listSessions(opts) {
+      if (typeof storage2.listConversationIds !== "function") {
+        return {
+          supported: false,
+          reason: "storage adapter does not support listing conversations (listConversationIds)"
+        };
+      }
+      const ids = await storage2.listConversationIds();
+      if (ids === void 0) {
+        return {
+          supported: false,
+          reason: "storage adapter reported listing as unsupported (listConversationIds \u2192 undefined)"
+        };
+      }
+      const windowed = windowIds(ids, opts);
+      const summaries = [];
+      for (const id of windowed) {
+        summaries.push(await buildSummary(storage2, id));
+      }
+      return { supported: true, value: summaries };
+    },
+    getSessionMessages(id, opts) {
+      return storage2.getMessages(id, opts);
+    },
+    async renameSession(id, title) {
+      if (typeof storage2.setSessionMeta !== "function") {
+        return unsupportedWrite();
+      }
+      await storage2.setSessionMeta(id, { title });
+      return { supported: true, value: void 0 };
+    },
+    async tagSession(id, tag) {
+      if (typeof storage2.setSessionMeta !== "function") {
+        return unsupportedWrite();
+      }
+      await storage2.setSessionMeta(id, { tag });
+      return { supported: true, value: void 0 };
+    }
+  };
+}
+function unsupportedWrite() {
+  return {
+    supported: false,
+    reason: "storage adapter does not support writing session metadata (setSessionMeta)"
+  };
+}
+function windowIds(ids, opts) {
+  const start = opts?.offset !== void 0 && opts.offset > 0 ? opts.offset : 0;
+  const rawLimit = opts?.limit;
+  if (rawLimit !== void 0 && rawLimit <= 0) return [];
+  const end = rawLimit !== void 0 ? start + rawLimit : void 0;
+  return ids.slice(start, end);
+}
+async function buildSummary(storage2, id) {
+  const messages = await storage2.getMessages(id);
+  const firstUser = messages.find((m) => m.role === "user")?.content;
+  const firstPrompt = firstUser !== void 0 && firstUser.length > 0 ? firstUser : void 0;
+  const lastModified = deriveLastModified(messages);
+  const meta = typeof storage2.getSessionMeta === "function" ? await storage2.getSessionMeta(id) : void 0;
+  const title = meta?.title;
+  const tag = meta?.tag;
+  const summary = title ?? previewOf(firstPrompt);
+  return {
+    id,
+    messageCount: messages.length,
+    ...firstPrompt !== void 0 ? { firstPrompt } : {},
+    ...lastModified !== void 0 ? { lastModified } : {},
+    ...title !== void 0 ? { title } : {},
+    ...tag !== void 0 ? { tag } : {},
+    ...summary !== void 0 ? { summary } : {}
+  };
+}
+function deriveLastModified(messages) {
+  let last;
+  for (const m of messages) {
+    if (m.at !== void 0 && (last === void 0 || m.at > last)) last = m.at;
+  }
+  return last;
+}
+function previewOf(text) {
+  if (text === void 0) return void 0;
+  const oneLine = text.replace(/\s+/g, " ").trim();
+  if (oneLine.length === 0) return void 0;
+  return oneLine.length > SUMMARY_PREVIEW_MAX ? `${oneLine.slice(0, SUMMARY_PREVIEW_MAX - 1)}\u2026` : oneLine;
+}
+
 // src/session-scope.ts
 function scopedConversationId(scope, id) {
   return `${scope}__${id}`;
@@ -20199,7 +20685,7 @@ var PersistenceSchema = zod.z.object({
 // src/workflow.ts
 init_path_guard();
 init_workflow();
-zod.z.object({
+var RetryPolicySchema = zod.z.object({
   // EC-3 absorbed: maxAttempts MUST be a finite int in [1, 20].
   maxAttempts: zod.z.number().int("retry.maxAttempts must be integer").min(1, "retry.maxAttempts must be >= 1").max(20, "retry.maxAttempts must be <= 20"),
   initialBackoffMs: zod.z.number().int().min(0).optional(),
@@ -20397,12 +20883,15 @@ var Workflow = class {
 };
 function agentStep(id, agent, promptTemplate, opts) {
   validateStepId(id);
+  if (opts?.retry !== void 0) RetryPolicySchema.parse(opts.retry);
   return {
     kind: "agent",
     id,
     agent,
     promptTemplate,
-    ...{}
+    ...opts?.retry !== void 0 ? { retry: opts.retry } : {},
+    // SE3 — carry the turn's provenance down to `agent.send()` (metadata-only).
+    ...opts?.origin !== void 0 ? { origin: opts.origin } : {}
   };
 }
 function validateStepId(id) {
@@ -20450,7 +20939,8 @@ function createSquad(options) {
       for (let i = 0; i < agents2.length; i++) {
         const agent = agents2[i];
         if (agent === void 0) continue;
-        builder = builder.then(agentStep(`agent-${i}`, agent, (prev) => String(prev)));
+        const opts = i > 0 ? { origin: { kind: "peer", from: `agent-${i - 1}` } } : void 0;
+        builder = builder.then(agentStep(`agent-${i}`, agent, (prev) => String(prev), opts));
       }
       const run = await builder.commit().run(input);
       return { result: run.output, status: run.status, steps: run.stepResults };
@@ -20917,7 +21407,9 @@ exports.PermissionEngine = PermissionEngine;
 exports.Security = Security;
 exports.Task = Task;
 exports.Theokit = Theokit;
+exports.ToolError = ToolError;
 exports.UsageAccumulator = UsageAccumulator;
+exports.applyMode = applyMode;
 exports.buildReplayHistory = buildReplayHistory;
 exports.chargeAndCheckThresholds = chargeAndCheckThresholds;
 exports.computeCost = computeCost;
@@ -20925,16 +21417,20 @@ exports.createAgentFactory = createAgentFactory;
 exports.createCounterBudgetTracker = createCounterBudgetTracker;
 exports.createNoopMemoryProvider = createNoopMemoryProvider;
 exports.createPermissionPlugin = createPermissionPlugin;
+exports.createSessionManager = createSessionManager;
+exports.createSkill = createSkill;
 exports.createSquad = createSquad;
 exports.definePlugin = definePlugin;
 exports.defineProvider = defineProvider;
 exports.defineTool = defineTool;
+exports.emitRunEvent = emitRunEvent;
 exports.extractRawId = extractRawId;
 exports.getPricingEntry = getPricingEntry;
 exports.inferApiMode = inferApiMode;
 exports.isTransientError = isTransientError;
 exports.migrateSqliteToLance = migrateSqliteToLance2;
 exports.mkMemoryId = mkMemoryId;
+exports.normalizeSchema = normalizeSchema;
 exports.normalizeUsage = normalizeUsage;
 exports.preflightCheck = preflightCheck;
 exports.scopedConversationId = scopedConversationId;