@theokit/agents 0.45.0 → 0.46.0

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

@@ -562,9 +562,14 @@ function compileAgentDefinition(def) {
     ...def.settingSources !== void 0 ? {
       settingSources: def.settingSources
     } : {},
-    ...def.plugins !== void 0 ? {
-      plugins: def.plugins
+    // 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 ? {
@@ -573,6 +578,33 @@ function compileAgentDefinition(def) {
   };
 }
 __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 {
@@ -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
@@ -1397,7 +1444,11 @@ async function* streamSdkAgent(rt, compiled, sdkTools, opts) {
       onDelta
     };
     if (factoryOpts?.disableTools === true) sendOptions.toolChoice = "none";
-    const sendPromise = agent2.send(message, sendOptions);
+    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, {
@@ -1452,160 +1503,507 @@ function toAgentFactory(def, opts) {
 }
 __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
-    };
+// ../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()
+    ];
   }
-  state.openBlock = null;
-  state.reasoningId = null;
+  /** 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(closeOpenBlock, "closeOpenBlock");
-function* emitTextDelta(state, textId, content) {
-  if (state.openBlock !== "text") {
-    yield* closeOpenBlock(state, textId);
-    yield {
-      type: "text-start",
-      id: textId
-    };
-    state.openBlock = "text";
+__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;
   }
-  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";
+__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 ?? {}
+      });
+    }
   }
-  yield {
-    type: "reasoning-delta",
-    id: reasoningId,
-    delta: content
-  };
+  return events;
 }
-__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(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(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(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"
+      }
+    ];
   }
-  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
-    };
+  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(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
-    };
+__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 [];
   }
-  yield {
-    type: "tool-approval-request",
-    approvalId: event.callId,
-    toolCallId: event.callId
-  };
 }
-__name(emitApprovalRequest, "emitApprovalRequest");
-function* emitCheckpointSaved(event) {
-  yield {
-    type: "data-checkpoint",
-    data: {
-      checkpointId: event.checkpointId,
-      resumeToken: event.resumeToken,
-      step: event.step
-    },
-    transient: true
+__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;
+  }
+  /**
+  * 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
+      });
+    }
+    this.#openBlock = null;
+    this.#reasoningId = null;
+    return out;
+  }
+  #emitTextDelta(content) {
+    const out = [];
+    if (this.#openBlock !== "text") {
+      out.push(...this.#closeOpenBlock(), {
+        type: "text-start",
+        id: this.#textId
+      });
+      this.#openBlock = "text";
+    }
+    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";
+    }
+    out.push({
+      type: "reasoning-delta",
+      id: reasoningId,
+      delta: content
+    });
+    return out;
+  }
+  #emitToolCall(callId, name, input) {
+    this.#seen.add(callId);
+    return [
+      {
+        type: "tool-input-available",
+        toolCallId: callId,
+        toolName: name,
+        input,
+        dynamic: true
+      }
+    ];
+  }
+  #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;
+  }
+};
+
+// 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(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 +2014,9 @@ async function* translateToUIMessageStream(events, opts) {
       errorText: String(err)
     };
   }
-  yield* closeOpenBlock(state, opts.textId);
-  yield turnMetadata ? {
-    type: "finish",
-    messageMetadata: turnMetadata
-  } : {
-    type: "finish"
-  };
+  yield* presenter.finish(turnMetadata);
 }
-__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
-  };
-}
-__name(doneToMetadata, "doneToMetadata");
+__name(presentUIMessageStream, "presentUIMessageStream");
 
 // src/bridge/agent-builder.ts
 function contextualTool(tool, _requiredContext) {
@@ -1701,6 +2082,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 +2251,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 +2292,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 +2613,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 +2692,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 +2719,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 +2728,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");
@@ -3042,7 +3432,7 @@ export {
   extractThinkTagStream,
   createSdkAgentStream,
   toAgentFactory,
-  translateToUIMessageStream,
+  presentUIMessageStream,
   contextualTool,
   agent,
   AgentDefinitionError,
@@ -3085,4 +3475,4 @@ export {
   generateAgentManifest,
   agentsPlugin
 };
-//# sourceMappingURL=chunk-XRPFOFYF.js.map
+//# sourceMappingURL=chunk-YBNKD5UM.js.map