@theokit/agents 0.45.0 → 0.47.0

package/dist/{chunk-XRPFOFYF.js → chunk-FEH7JFH7.js}

@@ -27,6 +27,142 @@ import {
   __name
 } from "./chunk-7QVYU63E.js";
 
+// src/bridge/define-agent.ts
+var AGENT_BRAND = /* @__PURE__ */ Symbol.for("theokit.agent.definition");
+function defineAgent(config) {
+  return {
+    ...config,
+    [AGENT_BRAND]: true
+  };
+}
+__name(defineAgent, "defineAgent");
+function isAgentDefinition(value) {
+  return typeof value === "object" && value !== null && value[AGENT_BRAND] === true;
+}
+__name(isAgentDefinition, "isAgentDefinition");
+function toCompiledTool(tool) {
+  const handler = tool.handler;
+  const compiled = {
+    name: tool.name,
+    description: tool.description,
+    inputSchema: tool.inputSchema,
+    handler: /* @__PURE__ */ __name((input, ctx) => handler(input, ctx), "handler")
+  };
+  for (const sym of Object.getOwnPropertySymbols(tool)) {
+    ;
+    compiled[sym] = tool[sym];
+  }
+  return compiled;
+}
+__name(toCompiledTool, "toCompiledTool");
+function compileAgentDefinition(def) {
+  return {
+    model: def.model,
+    reasoningEffort: def.reasoningEffort,
+    systemPrompt: def.system,
+    tools: (def.tools ?? []).map(toCompiledTool),
+    agents: {},
+    stream: true,
+    // M7 — run-context flows to CompiledAgentOptions.runContext (distinct from the
+    // context-window `context` field the decorator path uses); absent ⇒ no key.
+    ...def.context !== void 0 ? {
+      runContext: def.context
+    } : {},
+    // M9 — guardrails flow through unchanged; the runner applies them at the input boundary.
+    ...def.guardrails !== void 0 ? {
+      guardrails: def.guardrails
+    } : {},
+    // M14 — HITL approvals compile into the same `hitl` map the decorator path produces.
+    ...def.approvals !== void 0 ? {
+      hitl: compileApprovals(def)
+    } : {},
+    // M13 — skills: a static list → SDK skills.enabled; a resolver → carried for the request path.
+    ...compileSkillsSelection(def.skills),
+    // theokit-file-based-config — the declared `.theokit/` sources flow to the run path, which
+    // projects them into `Agent.create({ local.settingSources })`; absent ⇒ inline config only.
+    ...def.settingSources !== void 0 ? {
+      settingSources: def.settingSources
+    } : {},
+    // M49 — memory flows to the projection layer; `assembleM8CreateOptions` forwards it to Agent.create.
+    ...def.memory !== void 0 ? {
+      memory: def.memory
+    } : {},
+    // Hooks are converted here — the layer EVERY path converges on — rather than on the builder, so
+    // `defineAgent({ hooks })` cannot type-check and silently no-op. A lifecycle hook that is
+    // declared but never registered is a security gate that does not gate.
+    ...compileHooksAndPlugins(def),
+    // MCP — builder/`defineAgent` servers converge on the same `mcpServers` field the `@MCP`
+    // decorator path populates; the SDK adapter forwards it to `Agent.create({ mcpServers })`.
+    ...def.mcpServers !== void 0 ? {
+      mcpServers: def.mcpServers
+    } : {}
+  };
+}
+__name(compileAgentDefinition, "compileAgentDefinition");
+function compileHooksAndPlugins(def) {
+  const map = def.hooks;
+  const entries = Object.entries(map ?? {}).filter(([, h]) => typeof h === "function");
+  const explicit = def.plugins ?? [];
+  if (entries.length === 0) {
+    return def.plugins !== void 0 ? {
+      plugins: def.plugins
+    } : {};
+  }
+  const plugin = {
+    name: "theokit-builder-hooks",
+    version: "1.0.0",
+    kind: "general",
+    register(ctx) {
+      for (const [hookName, handler] of entries) {
+        ctx.on(hookName, handler);
+      }
+    }
+  };
+  return {
+    plugins: [
+      ...explicit,
+      plugin
+    ]
+  };
+}
+__name(compileHooksAndPlugins, "compileHooksAndPlugins");
+function compileSkillsSelection(skills) {
+  if (skills === void 0) return {};
+  if (typeof skills === "function") return {
+    skillsResolver: skills
+  };
+  const enabled = [];
+  const inline = [];
+  for (const entry of skills) {
+    if (typeof entry === "string") enabled.push(entry);
+    else inline.push(entry);
+  }
+  return {
+    skills: {
+      enabled,
+      autoInject: true,
+      ...inline.length > 0 ? {
+        inline
+      } : {}
+    }
+  };
+}
+__name(compileSkillsSelection, "compileSkillsSelection");
+function compileApprovals(def) {
+  const toolNames = new Set((def.tools ?? []).map((t) => t.name));
+  const gates = /* @__PURE__ */ new Map();
+  for (const [toolName, options] of Object.entries(def.approvals ?? {})) {
+    if (!toolNames.has(toolName)) {
+      throw new Error(`[@theokit/agents] defineAgent approval references unknown tool "${toolName}". Declared tools: ${[
+        ...toolNames
+      ].join(", ") || "(none)"}.`);
+    }
+    gates.set(toolName, options);
+  }
+  return gates;
+}
+__name(compileApprovals, "compileApprovals");
+
 // src/bridge/agent-execution-context.ts
 function createAgentExecutionContext(base, agent2, run, toolCall) {
   return {
@@ -506,110 +642,6 @@ function generateAgentRoutes(ctx) {
 }
 __name(generateAgentRoutes, "generateAgentRoutes");
 
-// src/bridge/define-agent.ts
-var AGENT_BRAND = /* @__PURE__ */ Symbol.for("theokit.agent.definition");
-function defineAgent(config) {
-  return {
-    ...config,
-    [AGENT_BRAND]: true
-  };
-}
-__name(defineAgent, "defineAgent");
-function isAgentDefinition(value) {
-  return typeof value === "object" && value !== null && value[AGENT_BRAND] === true;
-}
-__name(isAgentDefinition, "isAgentDefinition");
-function toCompiledTool(tool) {
-  const handler = tool.handler;
-  const compiled = {
-    name: tool.name,
-    description: tool.description,
-    inputSchema: tool.inputSchema,
-    handler: /* @__PURE__ */ __name((input, ctx) => handler(input, ctx), "handler")
-  };
-  for (const sym of Object.getOwnPropertySymbols(tool)) {
-    ;
-    compiled[sym] = tool[sym];
-  }
-  return compiled;
-}
-__name(toCompiledTool, "toCompiledTool");
-function compileAgentDefinition(def) {
-  return {
-    model: def.model,
-    reasoningEffort: def.reasoningEffort,
-    systemPrompt: def.system,
-    tools: (def.tools ?? []).map(toCompiledTool),
-    agents: {},
-    stream: true,
-    // M7 — run-context flows to CompiledAgentOptions.runContext (distinct from the
-    // context-window `context` field the decorator path uses); absent ⇒ no key.
-    ...def.context !== void 0 ? {
-      runContext: def.context
-    } : {},
-    // M9 — guardrails flow through unchanged; the runner applies them at the input boundary.
-    ...def.guardrails !== void 0 ? {
-      guardrails: def.guardrails
-    } : {},
-    // M14 — HITL approvals compile into the same `hitl` map the decorator path produces.
-    ...def.approvals !== void 0 ? {
-      hitl: compileApprovals(def)
-    } : {},
-    // M13 — skills: a static list → SDK skills.enabled; a resolver → carried for the request path.
-    ...compileSkillsSelection(def.skills),
-    // theokit-file-based-config — the declared `.theokit/` sources flow to the run path, which
-    // projects them into `Agent.create({ local.settingSources })`; absent ⇒ inline config only.
-    ...def.settingSources !== void 0 ? {
-      settingSources: def.settingSources
-    } : {},
-    ...def.plugins !== void 0 ? {
-      plugins: def.plugins
-    } : {},
-    // MCP — builder/`defineAgent` servers converge on the same `mcpServers` field the `@MCP`
-    // decorator path populates; the SDK adapter forwards it to `Agent.create({ mcpServers })`.
-    ...def.mcpServers !== void 0 ? {
-      mcpServers: def.mcpServers
-    } : {}
-  };
-}
-__name(compileAgentDefinition, "compileAgentDefinition");
-function compileSkillsSelection(skills) {
-  if (skills === void 0) return {};
-  if (typeof skills === "function") return {
-    skillsResolver: skills
-  };
-  const enabled = [];
-  const inline = [];
-  for (const entry of skills) {
-    if (typeof entry === "string") enabled.push(entry);
-    else inline.push(entry);
-  }
-  return {
-    skills: {
-      enabled,
-      autoInject: true,
-      ...inline.length > 0 ? {
-        inline
-      } : {}
-    }
-  };
-}
-__name(compileSkillsSelection, "compileSkillsSelection");
-function compileApprovals(def) {
-  const toolNames = new Set((def.tools ?? []).map((t) => t.name));
-  const gates = /* @__PURE__ */ new Map();
-  for (const [toolName, options] of Object.entries(def.approvals ?? {})) {
-    if (!toolNames.has(toolName)) {
-      throw new Error(`[@theokit/agents] defineAgent approval references unknown tool "${toolName}". Declared tools: ${[
-        ...toolNames
-      ].join(", ") || "(none)"}.`);
-    }
-    gates.set(toolName, options);
-  }
-  return gates;
-}
-__name(compileApprovals, "compileApprovals");
-
 // src/bridge/event-translator.ts
 function asString(value, fallback) {
   if (typeof value === "string") return value;
@@ -952,6 +984,21 @@ function assembleM8CreateOptions(compiled) {
     options.mcpServers = compiled.mcpServers;
     applied.push("mcpServers");
   }
+  if (compiled.memory !== void 0) {
+    if ("enabled" in compiled.memory) {
+      options.memory = compiled.memory;
+    } else {
+      const dropped = Object.keys(compiled.memory);
+      if (dropped.length > 0) {
+        process.stderr.write(`[theokit-agents] @Memory decorator options not yet mapped to the SDK (${dropped.join(", ")}) \u2014 memory enabled with defaults
+`);
+      }
+      options.memory = {
+        enabled: true
+      };
+    }
+    applied.push("memory");
+  }
   return {
     options,
     applied
@@ -1360,252 +1407,722 @@ function createSdkAgentStream(compiled, compiledTools, apiKey, overrides = {}) {
         };
       }
     }
-  });
-}
-__name(createSdkAgentStream, "createSdkAgentStream");
-async function* streamSdkAgent(rt, compiled, sdkTools, opts) {
-  const { Agent } = rt;
-  const { apiKey, model, reasoningEffort, overrides, parseThinkTags, stripToolDialect, sessionId, message, factoryOpts, runId, t0 } = opts;
-  const { options: m8, applied } = assembleM8CreateOptions(compiled);
-  if (overrides.cwd !== void 0) m8.local = {
-    ...m8.local,
-    cwd: overrides.cwd
-  };
-  if (overrides.baseDir !== void 0) m8.local = {
-    ...m8.local,
-    baseDir: overrides.baseDir
-  };
-  const extra = buildExtraCreateOptions(overrides, compiled);
-  if (applied.length > 0) {
-    debugLog("[THEO_AGENT_M8_RUNTIME_APPLIED]", {
-      skills: applied.includes("skills"),
-      contextWindow: applied.includes("context"),
-      projectContext: applied.includes("projectContext")
+  });
+}
+__name(createSdkAgentStream, "createSdkAgentStream");
+async function* streamSdkAgent(rt, compiled, sdkTools, opts) {
+  const { Agent } = rt;
+  const { apiKey, model, reasoningEffort, overrides, parseThinkTags, stripToolDialect, sessionId, message, factoryOpts, runId, t0 } = opts;
+  const { options: m8, applied } = assembleM8CreateOptions(compiled);
+  if (overrides.cwd !== void 0) m8.local = {
+    ...m8.local,
+    cwd: overrides.cwd
+  };
+  if (overrides.baseDir !== void 0) m8.local = {
+    ...m8.local,
+    baseDir: overrides.baseDir
+  };
+  const extra = buildExtraCreateOptions(overrides, compiled);
+  if (applied.length > 0) {
+    debugLog("[THEO_AGENT_M8_RUNTIME_APPLIED]", {
+      skills: applied.includes("skills"),
+      contextWindow: applied.includes("context"),
+      projectContext: applied.includes("projectContext")
+    });
+  }
+  const agent2 = await Agent.getOrCreate(sessionId, {
+    apiKey,
+    model: buildModelSelection(model, reasoningEffort),
+    tools: sdkTools,
+    ...m8,
+    ...extra
+  });
+  try {
+    const queue = createAsyncQueue();
+    const { state, onDelta } = createDeltaSink(queue);
+    const sendOptions = {
+      onDelta
+    };
+    if (factoryOpts?.disableTools === true) sendOptions.toolChoice = "none";
+    const sendInput = overrides.images && overrides.images.length > 0 ? {
+      text: message,
+      images: overrides.images
+    } : message;
+    const sendPromise = agent2.send(sendInput, sendOptions);
+    const openStream = /* @__PURE__ */ __name(async () => (await sendPromise).stream(), "openStream");
+    const merged = mergeDeltaStream(queue, openStream, runId, state);
+    for await (const event of applyTextTransforms(merged, {
+      parseThinkTags,
+      stripToolDialect
+    })) {
+      yield event;
+    }
+    if (!state.sawError) {
+      yield realUsageDone(await (await sendPromise).wait(), t0);
+    }
+  } finally {
+    await agent2.dispose();
+  }
+}
+__name(streamSdkAgent, "streamSdkAgent");
+function toAgentFactory(def, opts) {
+  const compiled = compileAgentDefinition(def);
+  const overrides = opts.overrides ?? {};
+  const model = overrides.model ?? compiled.model ?? "openai/gpt-4o-mini";
+  const reasoningEffort = overrides.reasoningEffort ?? compiled.reasoningEffort;
+  const runContext = overrides.runContext ?? compiled.runContext;
+  return async (sessionId) => {
+    const rt = await loadSdkRuntime();
+    if (!rt) {
+      throw new Error("[@theokit/agents] @theokit/sdk is not installed \u2014 run: pnpm add @theokit/sdk");
+    }
+    const sdkTools = buildSdkTools(compiled.tools, rt.defineTool, overrides.sdkTools, runContext);
+    const inlineSkills = compiled.skills?.inline;
+    if (inlineSkills !== void 0 && inlineSkills.length > 0 && rt.defineSkillReadTool !== void 0 && !compiled.tools.some((t) => t.name === "skill_read")) {
+      sdkTools.push(rt.defineSkillReadTool(inlineSkills));
+    }
+    const { options: m8 } = assembleM8CreateOptions(compiled);
+    if (overrides.cwd !== void 0) m8.local = {
+      ...m8.local,
+      cwd: overrides.cwd
+    };
+    if (overrides.baseDir !== void 0) m8.local = {
+      ...m8.local,
+      baseDir: overrides.baseDir
+    };
+    const extra = buildExtraCreateOptions(overrides, compiled);
+    const agent2 = await rt.Agent.getOrCreate(sessionId, {
+      apiKey: opts.apiKey,
+      model: buildModelSelection(model, reasoningEffort),
+      tools: sdkTools,
+      ...m8,
+      ...extra
+    });
+    return agent2;
+  };
+}
+__name(toAgentFactory, "toAgentFactory");
+
+// ../presenter/dist/index.js
+var __defProp = Object.defineProperty;
+var __name2 = /* @__PURE__ */ __name((target, value) => __defProp(target, "name", {
+  value,
+  configurable: true
+}), "__name");
+var UnknownPresenterError = class extends Error {
+  static {
+    __name(this, "UnknownPresenterError");
+  }
+  static {
+    __name2(this, "UnknownPresenterError");
+  }
+  name = "UnknownPresenterError";
+  constructor(surface, known) {
+    super(`No presenter registered for surface "${surface}". Known: ${known.join(", ") || "(none)"}.`);
+  }
+};
+var PresenterRegistry = class {
+  static {
+    __name(this, "PresenterRegistry");
+  }
+  static {
+    __name2(this, "PresenterRegistry");
+  }
+  #presenters = /* @__PURE__ */ new Map();
+  /** Register (or replace) the presenter for its surface. Returns `this` for fluent wiring. */
+  register(presenter) {
+    this.#presenters.set(presenter.surface, presenter);
+    return this;
+  }
+  /** Whether a presenter is registered for `surface`. */
+  has(surface) {
+    return this.#presenters.has(surface);
+  }
+  /** The registered surface keys. */
+  surfaces() {
+    return [
+      ...this.#presenters.keys()
+    ];
+  }
+  /** Resolve the presenter for `surface`, or throw {@link UnknownPresenterError} (never returns undefined). */
+  resolve(surface) {
+    const p = this.#presenters.get(surface);
+    if (p === void 0) throw new UnknownPresenterError(surface, this.surfaces());
+    return p;
+  }
+};
+function asString2(value, fallback) {
+  return typeof value === "string" ? value : fallback;
+}
+__name(asString2, "asString");
+__name2(asString2, "asString");
+function serializeToolResult(value, fallback) {
+  if (typeof value === "string") return value;
+  if (value === void 0 || value === null) return fallback;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return typeof value === "bigint" ? value.toString() : fallback;
+  }
+}
+__name(serializeToolResult, "serializeToolResult");
+__name2(serializeToolResult, "serializeToolResult");
+function fromAssistant(msg) {
+  const events = [];
+  const content = msg.message?.content;
+  if (!Array.isArray(content)) return events;
+  for (const block of content) {
+    const b = block;
+    if (b.type === "text" && b.text) events.push({
+      type: "text",
+      text: b.text
+    });
+    if (b.type === "tool_use") {
+      events.push({
+        type: "tool-call",
+        callId: b.id ?? `tc-${Date.now()}`,
+        name: b.name ?? "unknown",
+        input: b.input ?? {}
+      });
+    }
+  }
+  return events;
+}
+__name(fromAssistant, "fromAssistant");
+__name2(fromAssistant, "fromAssistant");
+function fromToolUse(msg) {
+  const status = msg.status;
+  const callId = asString2(msg.call_id, `tc-${Date.now()}`);
+  const name = asString2(msg.name, "unknown");
+  if (status === "completed") {
+    return [
+      {
+        type: "tool-result",
+        callId,
+        name,
+        result: serializeToolResult(msg.result, ""),
+        isError: false
+      }
+    ];
+  }
+  if (status === "error") {
+    return [
+      {
+        type: "tool-result",
+        callId,
+        name,
+        result: serializeToolResult(msg.result, "Tool failed"),
+        isError: true
+      }
+    ];
+  }
+  if (status === "running") {
+    return [
+      {
+        type: "tool-call",
+        callId,
+        name,
+        input: msg.args ?? msg.input ?? msg.arguments ?? {}
+      }
+    ];
+  }
+  return [];
+}
+__name(fromToolUse, "fromToolUse");
+__name2(fromToolUse, "fromToolUse");
+function fromStatus(msg) {
+  const s = msg.status;
+  if (s === "FINISHED" || s === "CANCELLED") return [
+    {
+      type: "finish",
+      reason: s.toLowerCase()
+    }
+  ];
+  if (s === "ERROR" || s === "EXPIRED") {
+    return [
+      {
+        type: "error",
+        message: asString2(msg.message, "Agent error"),
+        code: "AGENT_ERROR"
+      }
+    ];
+  }
+  return [];
+}
+__name(fromStatus, "fromStatus");
+__name2(fromStatus, "fromStatus");
+function fromSdkMessage(msg) {
+  switch (msg.type) {
+    case "assistant":
+      return fromAssistant(msg);
+    case "tool_call":
+      return fromToolUse(msg);
+    case "thinking":
+      return [
+        {
+          type: "reasoning",
+          text: asString2(msg.text, "")
+        }
+      ];
+    case "status":
+      return fromStatus(msg);
+    // `system` / run-lifecycle is framework framing, not pure output — intentionally skipped (ADR-4).
+    default:
+      return [];
+  }
+}
+__name(fromSdkMessage, "fromSdkMessage");
+__name2(fromSdkMessage, "fromSdkMessage");
+function fromInteractionUpdate(update) {
+  switch (update.type) {
+    case "text-delta":
+      return update.text ? [
+        {
+          type: "text",
+          text: update.text
+        }
+      ] : [];
+    case "thinking-delta":
+      return update.text ? [
+        {
+          type: "reasoning",
+          text: update.text
+        }
+      ] : [];
+    case "tool-call-started":
+      return [
+        {
+          type: "tool-call",
+          callId: update.callId,
+          name: update.toolCall.name,
+          input: update.toolCall.args ?? {}
+        }
+      ];
+    case "partial-tool-call":
+      return [
+        {
+          type: "partial-tool-call",
+          callId: update.callId,
+          name: update.toolCall.name,
+          input: update.toolCall.args ?? {}
+        }
+      ];
+    case "tool-call-completed":
+      return [
+        {
+          type: "tool-result",
+          callId: update.callId,
+          name: update.toolCall.name,
+          result: serializeToolResult(update.toolCall.result, ""),
+          isError: false
+        }
+      ];
+    default:
+      return [];
+  }
+}
+__name(fromInteractionUpdate, "fromInteractionUpdate");
+__name2(fromInteractionUpdate, "fromInteractionUpdate");
+var UIMessageStreamPresenter = class {
+  static {
+    __name(this, "UIMessageStreamPresenter");
+  }
+  static {
+    __name2(this, "UIMessageStreamPresenter");
+  }
+  surface = "ui-message-stream";
+  #textId;
+  #openBlock = null;
+  #reasoningId = null;
+  #seen = /* @__PURE__ */ new Set();
+  constructor(options) {
+    this.#textId = options.textId;
+  }
+  /** Emit the opening `start` chunk (exactly once, before any event). */
+  start() {
+    return [
+      {
+        type: "start"
+      }
+    ];
+  }
+  present(event) {
+    switch (event.type) {
+      case "text":
+        return this.#emitTextDelta(event.text);
+      case "reasoning":
+        return this.#emitReasoningDelta(event.text);
+      case "tool-call":
+        return [
+          ...this.#closeOpenBlock(),
+          ...this.#emitToolCall(event.callId, event.name, event.input)
+        ];
+      case "tool-result":
+        return [
+          ...this.#closeOpenBlock(),
+          ...this.#emitToolResult(event.callId, event.name, event.result, event.isError ?? false)
+        ];
+      case "error":
+        return [
+          {
+            type: "error",
+            errorText: event.message
+          }
+        ];
+      // `partial-tool-call` streams incremental args — the current web path emits no chunk for it
+      // (args are shown on the committed `tool-call`); `finish` / `status` are handled by finish()/host.
+      default:
+        return [];
+    }
+  }
+  /**
+  * Close any open text/reasoning block and emit the terminal `finish` chunk. When `metadata` is given
+  * (a clean run's turn totals from the framework `done`), it rides `messageMetadata`; otherwise the
+  * finish is bare (error/abort turns), byte-identical to the original translator.
+  */
+  finish(metadata) {
+    const out = this.#closeOpenBlock();
+    out.push(metadata ? {
+      type: "finish",
+      messageMetadata: metadata
+    } : {
+      type: "finish"
     });
+    return out;
   }
-  const agent2 = await Agent.getOrCreate(sessionId, {
-    apiKey,
-    model: buildModelSelection(model, reasoningEffort),
-    tools: sdkTools,
-    ...m8,
-    ...extra
-  });
-  try {
-    const queue = createAsyncQueue();
-    const { state, onDelta } = createDeltaSink(queue);
-    const sendOptions = {
-      onDelta
-    };
-    if (factoryOpts?.disableTools === true) sendOptions.toolChoice = "none";
-    const sendPromise = agent2.send(message, sendOptions);
-    const openStream = /* @__PURE__ */ __name(async () => (await sendPromise).stream(), "openStream");
-    const merged = mergeDeltaStream(queue, openStream, runId, state);
-    for await (const event of applyTextTransforms(merged, {
-      parseThinkTags,
-      stripToolDialect
-    })) {
-      yield event;
-    }
-    if (!state.sawError) {
-      yield realUsageDone(await (await sendPromise).wait(), t0);
+  /**
+  * Close any open text/reasoning block WITHOUT finishing the stream. The host calls this before
+  * interleaving a framework chunk (HITL approval / checkpoint) that must not appear inside an open text
+  * block — mirroring the original translator's `closeOpenBlock` before those chunks. Idempotent.
+  */
+  closeBlock() {
+    return this.#closeOpenBlock();
+  }
+  /**
+  * Whether a `callId` has already been introduced (a `tool-call` or a synthesized `tool-input`). The host
+  * uses this so a framework `approval_required` reuses the EC-1 synthesize-input-first rule exactly once.
+  */
+  hasSeen(callId) {
+    return this.#seen.has(callId);
+  }
+  /** Mark a `callId` as introduced (the host synthesized its `tool-input` for a framework chunk). */
+  markSeen(callId) {
+    this.#seen.add(callId);
+  }
+  // --- internal open-block state machine (verbatim from the original translator) ---
+  #closeOpenBlock() {
+    const out = [];
+    if (this.#openBlock === "text") {
+      out.push({
+        type: "text-end",
+        id: this.#textId
+      });
+    } else if (this.#openBlock === "reasoning" && this.#reasoningId) {
+      out.push({
+        type: "reasoning-end",
+        id: this.#reasoningId
+      });
     }
-  } finally {
-    await agent2.dispose();
+    this.#openBlock = null;
+    this.#reasoningId = null;
+    return out;
   }
-}
-__name(streamSdkAgent, "streamSdkAgent");
-function toAgentFactory(def, opts) {
-  const compiled = compileAgentDefinition(def);
-  const overrides = opts.overrides ?? {};
-  const model = overrides.model ?? compiled.model ?? "openai/gpt-4o-mini";
-  const reasoningEffort = overrides.reasoningEffort ?? compiled.reasoningEffort;
-  const runContext = overrides.runContext ?? compiled.runContext;
-  return async (sessionId) => {
-    const rt = await loadSdkRuntime();
-    if (!rt) {
-      throw new Error("[@theokit/agents] @theokit/sdk is not installed \u2014 run: pnpm add @theokit/sdk");
+  #emitTextDelta(content) {
+    const out = [];
+    if (this.#openBlock !== "text") {
+      out.push(...this.#closeOpenBlock(), {
+        type: "text-start",
+        id: this.#textId
+      });
+      this.#openBlock = "text";
     }
-    const sdkTools = buildSdkTools(compiled.tools, rt.defineTool, overrides.sdkTools, runContext);
-    const inlineSkills = compiled.skills?.inline;
-    if (inlineSkills !== void 0 && inlineSkills.length > 0 && rt.defineSkillReadTool !== void 0 && !compiled.tools.some((t) => t.name === "skill_read")) {
-      sdkTools.push(rt.defineSkillReadTool(inlineSkills));
+    out.push({
+      type: "text-delta",
+      id: this.#textId,
+      delta: content
+    });
+    return out;
+  }
+  #emitReasoningDelta(content) {
+    const out = [];
+    let reasoningId = this.#openBlock === "reasoning" ? this.#reasoningId : null;
+    if (reasoningId === null) {
+      out.push(...this.#closeOpenBlock());
+      reasoningId = crypto.randomUUID();
+      this.#reasoningId = reasoningId;
+      out.push({
+        type: "reasoning-start",
+        id: reasoningId
+      });
+      this.#openBlock = "reasoning";
     }
-    const { options: m8 } = assembleM8CreateOptions(compiled);
-    if (overrides.cwd !== void 0) m8.local = {
-      ...m8.local,
-      cwd: overrides.cwd
-    };
-    if (overrides.baseDir !== void 0) m8.local = {
-      ...m8.local,
-      baseDir: overrides.baseDir
-    };
-    const extra = buildExtraCreateOptions(overrides, compiled);
-    const agent2 = await rt.Agent.getOrCreate(sessionId, {
-      apiKey: opts.apiKey,
-      model: buildModelSelection(model, reasoningEffort),
-      tools: sdkTools,
-      ...m8,
-      ...extra
+    out.push({
+      type: "reasoning-delta",
+      id: reasoningId,
+      delta: content
     });
-    return agent2;
-  };
-}
-__name(toAgentFactory, "toAgentFactory");
-
-// src/bridge/ui-message-stream-translator.ts
-function* closeOpenBlock(state, textId) {
-  if (state.openBlock === "text") {
-    yield {
-      type: "text-end",
-      id: textId
-    };
-  } else if (state.openBlock === "reasoning" && state.reasoningId) {
-    yield {
-      type: "reasoning-end",
-      id: state.reasoningId
-    };
+    return out;
   }
-  state.openBlock = null;
-  state.reasoningId = null;
-}
-__name(closeOpenBlock, "closeOpenBlock");
-function* emitTextDelta(state, textId, content) {
-  if (state.openBlock !== "text") {
-    yield* closeOpenBlock(state, textId);
-    yield {
-      type: "text-start",
-      id: textId
-    };
-    state.openBlock = "text";
+  #emitToolCall(callId, name, input) {
+    this.#seen.add(callId);
+    return [
+      {
+        type: "tool-input-available",
+        toolCallId: callId,
+        toolName: name,
+        input,
+        dynamic: true
+      }
+    ];
   }
-  yield {
-    type: "text-delta",
-    id: textId,
-    delta: content
-  };
-}
-__name(emitTextDelta, "emitTextDelta");
-function* emitReasoningDelta(state, textId, content) {
-  let reasoningId = state.openBlock === "reasoning" ? state.reasoningId : null;
-  if (reasoningId === null) {
-    yield* closeOpenBlock(state, textId);
-    reasoningId = crypto.randomUUID();
-    state.reasoningId = reasoningId;
-    yield {
-      type: "reasoning-start",
-      id: reasoningId
-    };
-    state.openBlock = "reasoning";
+  #emitToolResult(callId, name, result, isError2) {
+    const out = [];
+    if (!this.#seen.has(callId)) {
+      this.#seen.add(callId);
+      out.push({
+        type: "tool-input-available",
+        toolCallId: callId,
+        toolName: name,
+        input: {},
+        dynamic: true
+      });
+    }
+    const output = typeof result === "string" ? result : "";
+    if (isError2) {
+      out.push({
+        type: "tool-output-error",
+        toolCallId: callId,
+        errorText: output
+      });
+    } else {
+      out.push({
+        type: "tool-output-available",
+        toolCallId: callId,
+        output
+      });
+    }
+    return out;
+  }
+};
+var ANSI = {
+  text: "",
+  reasoning: "\x1B[2m",
+  tool: "\x1B[36m",
+  "tool-result": "\x1B[2m",
+  "tool-error": "\x1B[31m",
+  error: "\x1B[31m",
+  status: "\x1B[35m",
+  finish: "\x1B[2m"
+};
+var RESET = "\x1B[0m";
+function preview(value, max) {
+  const raw = typeof value === "string" ? value : safeJson(value);
+  const flat = raw.replace(/\s+/g, " ").trim();
+  return flat.length > max ? `${flat.slice(0, max - 1)}\u2026` : flat;
+}
+__name(preview, "preview");
+__name2(preview, "preview");
+function safeJson(value) {
+  if (value === void 0 || value === null) return "";
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return typeof value === "bigint" ? value.toString() : "";
   }
-  yield {
-    type: "reasoning-delta",
-    id: reasoningId,
-    delta: content
-  };
 }
-__name(emitReasoningDelta, "emitReasoningDelta");
-function* emitToolCall(event, seen) {
-  seen.add(event.callId);
-  yield {
-    type: "tool-input-available",
-    toolCallId: event.callId,
-    toolName: event.toolName,
-    input: event.input,
-    dynamic: true
-  };
+__name(safeJson, "safeJson");
+__name2(safeJson, "safeJson");
+function suffix(open, value, close) {
+  return value === void 0 ? "" : open + value + close;
 }
-__name(emitToolCall, "emitToolCall");
-function* emitToolResult(event, seen) {
-  if (!seen.has(event.callId)) {
-    seen.add(event.callId);
-    yield {
-      type: "tool-input-available",
-      toolCallId: event.callId,
-      toolName: event.toolName,
-      input: {},
-      dynamic: true
-    };
+__name(suffix, "suffix");
+__name2(suffix, "suffix");
+var TerminalPresenter = class {
+  static {
+    __name(this, "TerminalPresenter");
   }
-  if (event.isError) {
-    yield {
-      type: "tool-output-error",
-      toolCallId: event.callId,
-      errorText: event.output
-    };
-  } else {
-    yield {
-      type: "tool-output-available",
-      toolCallId: event.callId,
-      output: event.output
-    };
+  static {
+    __name2(this, "TerminalPresenter");
+  }
+  surface = "terminal";
+  #ansi;
+  #max;
+  constructor(options = {}) {
+    this.#ansi = options.ansi ?? false;
+    this.#max = options.maxPreview ?? 88;
+  }
+  present(event) {
+    switch (event.type) {
+      case "text":
+        return event.text.length > 0 ? [
+          this.#row("text", event.text)
+        ] : [];
+      case "reasoning":
+        return event.text.length > 0 ? [
+          this.#row("reasoning", `\xB7 ${event.text}`)
+        ] : [];
+      case "tool-call":
+        return [
+          this.#row("tool", `\u23FA ${event.name}(${preview(event.input, this.#max)})`)
+        ];
+      case "tool-result":
+        return [
+          this.#toolResult(event.isError === true, preview(event.result, this.#max))
+        ];
+      case "error":
+        return [
+          this.#row("error", `\u2716 ${event.message}${suffix(" (", event.code, ")")}`)
+        ];
+      case "status":
+        return [
+          this.#row("status", `\u25CF ${event.status}${suffix(" \u2014 ", event.detail, "")}`)
+        ];
+      case "finish":
+        return [
+          this.#row("finish", this.#finishText(event.reason, event.usage?.totalTokens))
+        ];
+      // `partial-tool-call` streams incremental args — the committed `tool-call` renders them.
+      default:
+        return [];
+    }
   }
-}
-__name(emitToolResult, "emitToolResult");
-function* emitApprovalRequest(event, seen) {
-  if (!seen.has(event.callId)) {
-    seen.add(event.callId);
-    yield {
-      type: "tool-input-available",
-      toolCallId: event.callId,
-      toolName: event.toolName,
-      input: event.input ?? {},
-      dynamic: true
+  #toolResult(isError2, body) {
+    return this.#row(isError2 ? "tool-error" : "tool-result", `  \u23BF ${body}`);
+  }
+  #finishText(reason, tokens) {
+    const r = suffix(" ", reason, "");
+    const t = tokens === void 0 ? "" : ` \xB7 ${tokens} tokens`;
+    return `<<${r}${t} >>`;
+  }
+  #row(kind, text) {
+    return {
+      kind,
+      text: this.#ansi && ANSI[kind] !== "" ? `${ANSI[kind]}${text}${RESET}` : text
     };
   }
-  yield {
-    type: "tool-approval-request",
-    approvalId: event.callId,
-    toolCallId: event.callId
-  };
+};
+var JsonPresenter = class {
+  static {
+    __name(this, "JsonPresenter");
+  }
+  static {
+    __name2(this, "JsonPresenter");
+  }
+  surface = "json";
+  #ns;
+  constructor(options = {}) {
+    this.#ns = options.namespace ?? "agent.";
+  }
+  present(event) {
+    const { type, ...payload } = event;
+    return [
+      {
+        type: `${this.#ns}${type}`,
+        ...payload
+      }
+    ];
+  }
+};
+
+// src/bridge/present-ui-message-stream.ts
+function toAgentOutputEvent(e) {
+  switch (e.type) {
+    case "text_delta":
+      return {
+        type: "text",
+        text: e.content
+      };
+    case "thinking":
+      return {
+        type: "reasoning",
+        text: e.content
+      };
+    case "tool_call":
+      return {
+        type: "tool-call",
+        callId: e.callId,
+        name: e.toolName,
+        input: e.input
+      };
+    case "tool_result":
+      return {
+        type: "tool-result",
+        callId: e.callId,
+        name: e.toolName,
+        result: e.output,
+        isError: e.isError
+      };
+    default:
+      return null;
+  }
 }
-__name(emitApprovalRequest, "emitApprovalRequest");
-function* emitCheckpointSaved(event) {
-  yield {
-    type: "data-checkpoint",
-    data: {
-      checkpointId: event.checkpointId,
-      resumeToken: event.resumeToken,
-      step: event.step
-    },
-    transient: true
+__name(toAgentOutputEvent, "toAgentOutputEvent");
+function doneToMetadata(event) {
+  return event.cost === void 0 ? {
+    usage: event.usage,
+    durationMs: event.durationMs
+  } : {
+    usage: event.usage,
+    durationMs: event.durationMs,
+    cost: event.cost
   };
 }
-__name(emitCheckpointSaved, "emitCheckpointSaved");
-async function* translateToUIMessageStream(events, opts) {
+__name(doneToMetadata, "doneToMetadata");
+async function* presentUIMessageStream(events, opts) {
+  const presenter = new UIMessageStreamPresenter({
+    textId: opts.textId
+  });
   yield {
     type: "start"
   };
-  const state = {
-    openBlock: null,
-    reasoningId: null
-  };
-  const seenToolCallIds = /* @__PURE__ */ new Set();
   let turnMetadata;
   try {
     for await (const event of events) {
-      if (event.type === "text_delta") {
-        yield* emitTextDelta(state, opts.textId, event.content);
-      } else if (event.type === "thinking") {
-        yield* emitReasoningDelta(state, opts.textId, event.content);
-      } else if (event.type === "tool_call") {
-        yield* closeOpenBlock(state, opts.textId);
-        yield* emitToolCall(event, seenToolCallIds);
-      } else if (event.type === "approval_required") {
-        yield* closeOpenBlock(state, opts.textId);
-        yield* emitApprovalRequest(event, seenToolCallIds);
-      } else if (event.type === "tool_result") {
-        yield* closeOpenBlock(state, opts.textId);
-        yield* emitToolResult(event, seenToolCallIds);
-      } else if (event.type === "checkpoint_saved") {
-        yield* closeOpenBlock(state, opts.textId);
-        yield* emitCheckpointSaved(event);
-      } else if (event.type === "error") {
+      const output = toAgentOutputEvent(event);
+      if (output !== null) {
+        yield* presenter.present(output);
+        continue;
+      }
+      if (event.type === "approval_required") {
+        yield* presenter.closeBlock();
+        if (!presenter.hasSeen(event.callId)) {
+          presenter.markSeen(event.callId);
+          yield {
+            type: "tool-input-available",
+            toolCallId: event.callId,
+            toolName: event.toolName,
+            input: event.input ?? {},
+            dynamic: true
+          };
+        }
+        yield {
+          type: "tool-approval-request",
+          approvalId: event.callId,
+          toolCallId: event.callId
+        };
+        continue;
+      }
+      if (event.type === "checkpoint_saved") {
+        yield* presenter.closeBlock();
+        yield {
+          type: "data-checkpoint",
+          data: {
+            checkpointId: event.checkpointId,
+            resumeToken: event.resumeToken,
+            step: event.step
+          },
+          transient: true
+        };
+        continue;
+      }
+      if (event.type === "error") {
         yield {
           type: "error",
           errorText: event.message
         };
         break;
-      } else if (event.type === "done") {
+      }
+      if (event.type === "done") {
         turnMetadata = doneToMetadata(event);
         break;
       }
@@ -1616,26 +2133,9 @@ async function* translateToUIMessageStream(events, opts) {
       errorText: String(err)
     };
   }
-  yield* closeOpenBlock(state, opts.textId);
-  yield turnMetadata ? {
-    type: "finish",
-    messageMetadata: turnMetadata
-  } : {
-    type: "finish"
-  };
-}
-__name(translateToUIMessageStream, "translateToUIMessageStream");
-function doneToMetadata(event) {
-  return event.cost === void 0 ? {
-    usage: event.usage,
-    durationMs: event.durationMs
-  } : {
-    usage: event.usage,
-    durationMs: event.durationMs,
-    cost: event.cost
-  };
+  yield* presenter.finish(turnMetadata);
 }
-__name(doneToMetadata, "doneToMetadata");
+__name(presentUIMessageStream, "presentUIMessageStream");
 
 // src/bridge/agent-builder.ts
 function contextualTool(tool, _requiredContext) {
@@ -1701,6 +2201,14 @@ function makeBuilder(config) {
       ...config,
       settingSources: sources
     }), "settingSources"),
+    memory: /* @__PURE__ */ __name((settings) => makeBuilder({
+      ...config,
+      memory: settings
+    }), "memory"),
+    hooks: /* @__PURE__ */ __name((map) => makeBuilder({
+      ...config,
+      hooks: map
+    }), "hooks"),
     plugins: /* @__PURE__ */ __name((list) => makeBuilder({
       ...config,
       plugins: list
@@ -1862,6 +2370,7 @@ function streamAgentUIMessages(compiled, apiKey, input) {
   const overrides = {};
   if (input.cwd !== void 0) overrides.cwd = input.cwd;
   if (input.baseDir !== void 0) overrides.baseDir = input.baseDir;
+  if (input.images !== void 0) overrides.images = input.images;
   let source;
   if (!input.hitl || input.hitl.gated.size === 0) {
     const events2 = createSdkAgentStream(compiled, compiled.tools, apiKey, overrides)(input.message, input.sessionId);
@@ -1902,7 +2411,7 @@ function streamAgentUIMessages(compiled, apiKey, input) {
   }
   const durableCheckpoint = compiled.checkpoint?.storage === "filesystem";
   const events = durableCheckpoint ? appendCheckpointSaved(source, input.sessionId) : source;
-  return translateToUIMessageStream(events, {
+  return presentUIMessageStream(events, {
     textId
   });
 }
@@ -2223,10 +2732,10 @@ var DelegationError = class extends Error {
 };
 
 // src/loop/run-reflective-loop.ts
-function asString2(value, fallback) {
+function asString3(value, fallback) {
   return typeof value === "string" ? value : fallback;
 }
-__name(asString2, "asString");
+__name(asString3, "asString");
 function asNumber(value, fallback) {
   return typeof value === "number" ? value : fallback;
 }
@@ -2302,15 +2811,15 @@ function deriveFinishReason(signals) {
 }
 __name(deriveFinishReason, "deriveFinishReason");
 function pushToolResult(event, r, callInputs) {
-  const id = asString2(event.callId, "");
+  const id = asString3(event.callId, "");
   const call = callInputs.get(id);
   r.toolCalls.push({
     id,
-    name: call?.name ?? asString2(event.toolName, "unknown"),
+    name: call?.name ?? asString3(event.toolName, "unknown"),
     // Prefer the correlated tool_call input (real SDK shape); fall back to an input on the
     // result event itself (some streams/tests carry it there), else {}.
     input: call?.input ?? event.input ?? {},
-    output: asString2(event.output, "")
+    output: asString3(event.output, "")
   });
 }
 __name(pushToolResult, "pushToolResult");
@@ -2329,8 +2838,8 @@ function accumulateEvent(event, r, signals, callInputs) {
   if (event.type === "text_delta" && typeof event.content === "string") {
     r.responseText += event.content;
   } else if (event.type === "tool_call") {
-    callInputs.set(asString2(event.callId, ""), {
-      name: asString2(event.toolName, "unknown"),
+    callInputs.set(asString3(event.callId, ""), {
+      name: asString3(event.toolName, "unknown"),
       input: event.input ?? {}
     });
   } else if (event.type === "tool_result") {
@@ -2338,11 +2847,11 @@ function accumulateEvent(event, r, signals, callInputs) {
     pushToolResult(event, r, callInputs);
   } else if (event.type === "done") {
     signals.sawDone = true;
-    signals.doneFinishReason = asString2(event.finishReason, "");
+    signals.doneFinishReason = asString3(event.finishReason, "");
     applyDone(event, r);
   } else if (event.type === "error") {
     signals.sawError = true;
-    r.errorMessage = asString2(event.message, "Unknown agent error");
+    r.errorMessage = asString3(event.message, "Unknown agent error");
   }
 }
 __name(accumulateEvent, "accumulateEvent");
@@ -3013,6 +3522,10 @@ function matchRoute(routes, method, pathname) {
 __name(matchRoute, "matchRoute");
 
 export {
+  AGENT_BRAND,
+  isAgentDefinition,
+  compileAgentDefinition,
+  compileSkillsSelection,
   createAgentExecutionContext,
   isAgentContext,
   compileContextWindow,
@@ -3033,16 +3546,13 @@ export {
   isError,
   isApprovalRequired,
   generateAgentRoutes,
-  AGENT_BRAND,
-  isAgentDefinition,
-  compileAgentDefinition,
   translateSdkEvent,
   buildModelSelection,
   createThinkTagExtractor,
   extractThinkTagStream,
   createSdkAgentStream,
   toAgentFactory,
-  translateToUIMessageStream,
+  presentUIMessageStream,
   contextualTool,
   agent,
   AgentDefinitionError,
@@ -3085,4 +3595,4 @@ export {
   generateAgentManifest,
   agentsPlugin
 };
-//# sourceMappingURL=chunk-XRPFOFYF.js.map
+//# sourceMappingURL=chunk-FEH7JFH7.js.map