@theokit/agents 6.4.2 → 7.1.0

package/dist/{chunk-UJPG3K26.js → chunk-LJLNFCLS.js}

@@ -1,6 +1,6 @@
 import {
   __name
-} from "./chunk-7QVYU63E.js";
+} from "./chunk-Z4QWC7IK.js";
 
 // src/errors.ts
 import { ConfigurationError } from "@theokit/sdk/errors";
@@ -455,6 +455,198 @@ function generateAgentRoutes(ctx) {
 }
 __name(generateAgentRoutes, "generateAgentRoutes");
 
+// src/guardrails/types.ts
+var GuardrailViolationError = class extends Error {
+  static {
+    __name(this, "GuardrailViolationError");
+  }
+  guardName;
+  phase;
+  reason;
+  constructor(guardName, phase, reason) {
+    super(`Guardrail "${guardName}" blocked ${phase}: ${reason}`), this.guardName = guardName, this.phase = phase, this.reason = reason;
+    this.name = "GuardrailViolationError";
+  }
+};
+var CostBudgetExceededError = class extends Error {
+  static {
+    __name(this, "CostBudgetExceededError");
+  }
+  usedTokens;
+  maxTokens;
+  constructor(usedTokens, maxTokens) {
+    super(`Cost budget exceeded: ${usedTokens} > ${maxTokens} tokens`), this.usedTokens = usedTokens, this.maxTokens = maxTokens;
+    this.name = "CostBudgetExceededError";
+  }
+};
+
+// src/guardrails/detectors.ts
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+__name(estimateTokens, "estimateTokens");
+var INJECTION_PHRASES = [
+  "previous instructions",
+  "disregard the above",
+  "you are now dan",
+  "system prompt",
+  "no restrictions",
+  "without restrictions",
+  "no rules",
+  "override your"
+];
+function normalizeForMatch(text) {
+  return text.toLowerCase().replace(/\s+/g, " ");
+}
+__name(normalizeForMatch, "normalizeForMatch");
+function promptInjectionDetector(options = {}) {
+  const phrases = [
+    ...INJECTION_PHRASES,
+    ...(options.extra ?? []).map((p) => p.toLowerCase())
+  ];
+  return {
+    name: "prompt-injection",
+    checkInput(text) {
+      const normalized = normalizeForMatch(text);
+      for (const phrase of phrases) {
+        if (normalized.includes(phrase)) {
+          return {
+            action: "block",
+            reason: `prompt injection phrase matched: "${phrase}"`
+          };
+        }
+      }
+      return {
+        action: "allow"
+      };
+    }
+  };
+}
+__name(promptInjectionDetector, "promptInjectionDetector");
+var CPF = /\b\d{3}\.?\d{3}\.?\d{3}-?\d{2}\b/g;
+var EMAIL = /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/g;
+var PHONE = /\+?\d[\d\s()-]{7,13}\d/g;
+function piiDetector(options = {}) {
+  const placeholder = options.placeholder ?? "[REDACTED]";
+  return {
+    name: "pii",
+    checkInput(text) {
+      let redacted = text;
+      redacted = redacted.replace(EMAIL, placeholder);
+      redacted = redacted.replace(CPF, placeholder);
+      redacted = redacted.replace(PHONE, placeholder);
+      if (redacted === text) return {
+        action: "allow"
+      };
+      return {
+        action: "redact",
+        text: redacted,
+        reason: "PII detected and redacted"
+      };
+    }
+  };
+}
+__name(piiDetector, "piiDetector");
+var OBFUSCATION_CHARS = /[\u200B-\u200D\uFEFF\u202A-\u202E\u2066-\u2069]/g;
+function unicodeNormalizer() {
+  return {
+    name: "unicode-normalizer",
+    checkInput(text) {
+      const cleaned = text.normalize("NFKC").replace(OBFUSCATION_CHARS, "");
+      if (cleaned === text) return {
+        action: "allow"
+      };
+      return {
+        action: "redact",
+        text: cleaned,
+        reason: "obfuscation characters normalized"
+      };
+    }
+  };
+}
+__name(unicodeNormalizer, "unicodeNormalizer");
+function costGuard(options) {
+  let used = 0;
+  return {
+    name: "cost-guard",
+    // Returns a Promise explicitly (not `async`) so a budget breach REJECTS uniformly — never a
+    // sync throw — safe for direct callers and for the pipeline's `await g.checkInput()`.
+    checkInput(text) {
+      used += estimateTokens(text);
+      if (used > options.maxTokens) {
+        return Promise.reject(new CostBudgetExceededError(used, options.maxTokens));
+      }
+      return Promise.resolve({
+        action: "allow"
+      });
+    }
+  };
+}
+__name(costGuard, "costGuard");
+function outputModeration(options) {
+  return {
+    name: "output-moderation",
+    async checkOutput(text) {
+      const flagged = await options.moderate(text);
+      return flagged ? {
+        action: "block",
+        reason: "output flagged by moderation predicate"
+      } : {
+        action: "allow"
+      };
+    }
+  };
+}
+__name(outputModeration, "outputModeration");
+
+// src/guardrails/pipeline.ts
+async function runInputGuards(text, guards) {
+  let current = text;
+  for (const g of guards) {
+    if (!g.checkInput) continue;
+    const r = await g.checkInput(current);
+    if (r.action === "block") {
+      throw new GuardrailViolationError(g.name, "input", r.reason ?? "blocked");
+    }
+    if (r.action === "redact" && r.text !== void 0) current = r.text;
+  }
+  return current;
+}
+__name(runInputGuards, "runInputGuards");
+async function runOutputGuards(text, guards) {
+  let current = text;
+  for (const g of guards) {
+    if (!g.checkOutput) continue;
+    const r = await g.checkOutput(current);
+    if (r.action === "block") {
+      throw new GuardrailViolationError(g.name, "output", r.reason ?? "blocked");
+    }
+    if (r.action === "redact" && r.text !== void 0) current = r.text;
+  }
+  return current;
+}
+__name(runOutputGuards, "runOutputGuards");
+
+// src/guardrails/stream.ts
+async function* moderateOutputStream(inner, guards, extractText) {
+  const hasOutputGuard = guards.some((g) => g.checkOutput != null);
+  if (!hasOutputGuard) return yield* inner;
+  const buffered = [];
+  let accumulated = "";
+  let step = await inner.next();
+  while (!step.done) {
+    const event = step.value;
+    const text = extractText(event);
+    if (text !== void 0) accumulated += text;
+    buffered.push(event);
+    step = await inner.next();
+  }
+  await runOutputGuards(accumulated, guards);
+  for (const event of buffered) yield event;
+  return step.value;
+}
+__name(moderateOutputStream, "moderateOutputStream");
+
 // src/bridge/tool-hooks-plugin.ts
 function createToolHooksPlugin(hooks) {
   return {
@@ -508,6 +700,33 @@ function createToolHooksPlugin(hooks) {
 }
 __name(createToolHooksPlugin, "createToolHooksPlugin");
 
+// src/bridge/model-selection.ts
+var PARAM_THINKING = "thinking";
+function buildModelSelection(model, effort) {
+  const base = typeof model === "string" ? {
+    id: model
+  } : {
+    ...model
+  };
+  if (!effort) return base;
+  return {
+    ...base,
+    params: [
+      ...base.params ?? [],
+      {
+        id: PARAM_THINKING,
+        value: effort
+      }
+    ]
+  };
+}
+__name(buildModelSelection, "buildModelSelection");
+function reasoningEffortOf(model) {
+  const params = typeof model === "string" ? void 0 : model.params;
+  return params?.find((p) => p.id === PARAM_THINKING)?.value;
+}
+__name(reasoningEffortOf, "reasoningEffortOf");
+
 // src/bridge/event-translator.ts
 function asString(value, fallback) {
   if (typeof value === "string") return value;
@@ -551,7 +770,11 @@ function translateAssistantEvent(msg) {
     if (b.type === "tool_use") {
       events.push({
         type: "tool_call",
-        callId: b.id ?? `tc-${Date.now()}`,
+        // #138 — era `tc-${Date.now()}`. Um id novo a cada chamada NUNCA está no conjunto de
+        // dedup, então o fallback derrotava a dedup por construção — e ainda parecia um id de
+        // verdade para quem lê. String vazia é honesta: `isDuplicatedByDelta` a trata como
+        // "não sei identificar" e prefere um duplo-render visível a uma supressão silenciosa.
+        callId: b.id ?? "",
         toolName: b.name ?? "unknown",
         input: b.input ?? {}
       });
@@ -562,7 +785,7 @@ function translateAssistantEvent(msg) {
 __name(translateAssistantEvent, "translateAssistantEvent");
 function translateToolCallEvent(msg) {
   const status = msg.status;
-  const callId = asString(msg.call_id, `tc-${Date.now()}`);
+  const callId = asString(msg.call_id, "");
   const toolName = asString(msg.name, "unknown");
   if (status === "completed") {
     return [
@@ -631,6 +854,22 @@ function translateStatusEvent(msg) {
   return [];
 }
 __name(translateStatusEvent, "translateStatusEvent");
+var jaAvisados = /* @__PURE__ */ new Set();
+function avisarSeDesconhecido(tipo, ignoradosDeProposito) {
+  if (ignoradosDeProposito.has(tipo) || jaAvisados.has(tipo)) return;
+  jaAvisados.add(tipo);
+  console.warn(`[theokit] agents.bridge: evento "${tipo}" do SDK n\xE3o \xE9 traduzido e foi descartado. Se ele carrega informa\xE7\xE3o que a UI precisa, o tradutor precisa de um caso para ele (#141).`);
+}
+__name(avisarSeDesconhecido, "avisarSeDesconhecido");
+var SDK_MESSAGE_IGNORADOS = /* @__PURE__ */ new Set([
+  "user"
+]);
+var INTERACTION_UPDATE_IGNORADOS = /* @__PURE__ */ new Set([
+  "thinking-completed",
+  "token-delta",
+  "step-started",
+  "step-completed"
+]);
 function translateSdkEvent(msg, runId) {
   switch (msg.type) {
     case "system":
@@ -648,7 +887,31 @@ function translateSdkEvent(msg, runId) {
       ];
     case "status":
       return translateStatusEvent(msg);
+    case "request":
+      return [
+        {
+          type: "input_requested",
+          requestId: asString(msg.request_id, "")
+        }
+      ];
+    case "task": {
+      const status = typeof msg.status === "string" ? msg.status : void 0;
+      const text = typeof msg.text === "string" ? msg.text : void 0;
+      if (status === void 0 && text === void 0) return [];
+      return [
+        {
+          type: "task_progress",
+          ...status !== void 0 ? {
+            status
+          } : {},
+          ...text !== void 0 ? {
+            text
+          } : {}
+        }
+      ];
+    }
     default:
+      avisarSeDesconhecido(msg.type, SDK_MESSAGE_IGNORADOS);
       return [];
   }
 }
@@ -698,39 +961,20 @@ function translateInteractionUpdate(update) {
           isError: false
         }
       ];
+    case "shell-output-delta":
+      return [
+        {
+          type: "shell_output",
+          event: update.event
+        }
+      ];
     default:
+      avisarSeDesconhecido(update.type, INTERACTION_UPDATE_IGNORADOS);
       return [];
   }
 }
 __name(translateInteractionUpdate, "translateInteractionUpdate");
 
-// src/bridge/model-selection.ts
-var PARAM_THINKING = "thinking";
-function buildModelSelection(model, effort) {
-  const base = typeof model === "string" ? {
-    id: model
-  } : {
-    ...model
-  };
-  if (!effort) return base;
-  return {
-    ...base,
-    params: [
-      ...base.params ?? [],
-      {
-        id: PARAM_THINKING,
-        value: effort
-      }
-    ]
-  };
-}
-__name(buildModelSelection, "buildModelSelection");
-function reasoningEffortOf(model) {
-  const params = typeof model === "string" ? void 0 : model.params;
-  return params?.find((p) => p.id === PARAM_THINKING)?.value;
-}
-__name(reasoningEffortOf, "reasoningEffortOf");
-
 // src/bridge/think-tag-extractor.ts
 var TAG = "think";
 var OPEN = `<${TAG}>`;
@@ -1059,6 +1303,134 @@ function realUsageDone(result, t0) {
 }
 __name(realUsageDone, "realUsageDone");
 
+// src/bridge/sdk-adapter-merge.ts
+function createAsyncQueue() {
+  const items = [];
+  let wake = null;
+  let closed = false;
+  return {
+    push(item) {
+      items.push(item);
+      if (wake) {
+        wake();
+        wake = null;
+      }
+    },
+    close() {
+      closed = true;
+      if (wake) {
+        wake();
+        wake = null;
+      }
+    },
+    async *[Symbol.asyncIterator]() {
+      for (; ; ) {
+        while (items.length > 0) {
+          const next = items.shift();
+          if (next !== void 0) yield next;
+        }
+        if (closed) return;
+        await new Promise((resolve) => {
+          wake = resolve;
+        });
+      }
+    }
+  };
+}
+__name(createAsyncQueue, "createAsyncQueue");
+function streamCallId(ev) {
+  return typeof ev.callId === "string" ? ev.callId : "";
+}
+__name(streamCallId, "streamCallId");
+function idsDaMesmaChamada(ev, update) {
+  const ids = [];
+  const call = streamCallId(ev);
+  if (call !== "") ids.push(call);
+  const model = update?.modelCallId;
+  if (typeof model === "string" && model !== "" && model !== call) ids.push(model);
+  return ids;
+}
+__name(idsDaMesmaChamada, "idsDaMesmaChamada");
+function isDuplicatedByDelta(ev, state) {
+  if (ev.type === "text_delta") return state.sawTextDelta;
+  if (ev.type === "thinking") return state.sawThinkingDelta;
+  if (ev.type === "tool_call") {
+    const id = streamCallId(ev);
+    return id !== "" && state.emittedToolCallIds.has(id);
+  }
+  if (ev.type === "tool_result") {
+    const id = streamCallId(ev);
+    return id !== "" && state.emittedToolResultIds.has(id);
+  }
+  return false;
+}
+__name(isDuplicatedByDelta, "isDuplicatedByDelta");
+async function* mergeDeltaStream(queue, openStream, runId, state) {
+  let pumpError;
+  const pump = (async () => {
+    try {
+      const stream = await openStream();
+      for await (const msg of stream) queue.push({
+        kind: "sdk",
+        msg
+      });
+    } finally {
+      queue.close();
+    }
+  })().catch((thrown) => {
+    pumpError = {
+      thrown
+    };
+  });
+  for await (const item of queue) {
+    if (item.kind === "delta") {
+      state.lastEventType = item.event.type;
+      yield item.event;
+      continue;
+    }
+    for (const out of translateSdkEvent(item.msg, runId)) {
+      if (out.type === "done") continue;
+      if (isDuplicatedByDelta(out, state)) continue;
+      if (out.type === "error") state.sawError = true;
+      state.lastEventType = out.type;
+      yield out;
+    }
+  }
+  await pump;
+  if (pumpError) throw pumpError.thrown;
+}
+__name(mergeDeltaStream, "mergeDeltaStream");
+function createDeltaSink(queue) {
+  const state = {
+    sawTextDelta: false,
+    sawThinkingDelta: false,
+    emittedToolCallIds: /* @__PURE__ */ new Set(),
+    emittedToolResultIds: /* @__PURE__ */ new Set(),
+    sawError: false,
+    lastEventType: ""
+  };
+  const onDelta = /* @__PURE__ */ __name((d) => {
+    for (const event of translateInteractionUpdate(d.update)) {
+      if (event.type === "text_delta") state.sawTextDelta = true;
+      else if (event.type === "thinking") state.sawThinkingDelta = true;
+      else if (event.type === "tool_call") {
+        for (const id of idsDaMesmaChamada(event, d.update)) state.emittedToolCallIds.add(id);
+      } else if (event.type === "tool_result") {
+        for (const id of idsDaMesmaChamada(event, d.update)) state.emittedToolResultIds.add(id);
+      }
+      queue.push({
+        kind: "delta",
+        event
+      });
+    }
+  }, "onDelta");
+  return {
+    state,
+    onDelta
+  };
+}
+__name(createDeltaSink, "createDeltaSink");
+
 // src/bridge/tool-dialect-stripper.ts
 var OPEN2 = "<function=";
 var CLOSE2 = "</tool_call>";
@@ -1207,122 +1579,6 @@ async function loadSdkRuntime() {
   }
 }
 __name(loadSdkRuntime, "loadSdkRuntime");
-function createAsyncQueue() {
-  const items = [];
-  let wake = null;
-  let closed = false;
-  return {
-    push(item) {
-      items.push(item);
-      if (wake) {
-        wake();
-        wake = null;
-      }
-    },
-    close() {
-      closed = true;
-      if (wake) {
-        wake();
-        wake = null;
-      }
-    },
-    async *[Symbol.asyncIterator]() {
-      for (; ; ) {
-        while (items.length > 0) {
-          const next = items.shift();
-          if (next !== void 0) yield next;
-        }
-        if (closed) return;
-        await new Promise((resolve) => {
-          wake = resolve;
-        });
-      }
-    }
-  };
-}
-__name(createAsyncQueue, "createAsyncQueue");
-function streamCallId(ev) {
-  return typeof ev.callId === "string" ? ev.callId : "";
-}
-__name(streamCallId, "streamCallId");
-function isDuplicatedByDelta(ev, state) {
-  if (ev.type === "text_delta") return state.sawTextDelta;
-  if (ev.type === "thinking") return state.sawThinkingDelta;
-  if (ev.type === "tool_call") {
-    const id = streamCallId(ev);
-    return id !== "" && state.emittedToolCallIds.has(id);
-  }
-  if (ev.type === "tool_result") {
-    const id = streamCallId(ev);
-    return id !== "" && state.emittedToolResultIds.has(id);
-  }
-  return false;
-}
-__name(isDuplicatedByDelta, "isDuplicatedByDelta");
-async function* mergeDeltaStream(queue, openStream, runId, state) {
-  let pumpError;
-  const pump = (async () => {
-    try {
-      const stream = await openStream();
-      for await (const msg of stream) queue.push({
-        kind: "sdk",
-        msg
-      });
-    } finally {
-      queue.close();
-    }
-  })().catch((thrown) => {
-    pumpError = {
-      thrown
-    };
-  });
-  for await (const item of queue) {
-    if (item.kind === "delta") {
-      yield item.event;
-      continue;
-    }
-    for (const out of translateSdkEvent(item.msg, runId)) {
-      if (out.type === "done") continue;
-      if (isDuplicatedByDelta(out, state)) continue;
-      if (out.type === "error") state.sawError = true;
-      yield out;
-    }
-  }
-  await pump;
-  if (pumpError) throw pumpError.thrown;
-}
-__name(mergeDeltaStream, "mergeDeltaStream");
-function createDeltaSink(queue) {
-  const state = {
-    sawTextDelta: false,
-    sawThinkingDelta: false,
-    emittedToolCallIds: /* @__PURE__ */ new Set(),
-    emittedToolResultIds: /* @__PURE__ */ new Set(),
-    sawError: false
-  };
-  const onDelta = /* @__PURE__ */ __name((d) => {
-    for (const event of translateInteractionUpdate(d.update)) {
-      if (event.type === "text_delta") state.sawTextDelta = true;
-      else if (event.type === "thinking") state.sawThinkingDelta = true;
-      else if (event.type === "tool_call") {
-        const id = streamCallId(event);
-        if (id !== "") state.emittedToolCallIds.add(id);
-      } else if (event.type === "tool_result") {
-        const id = streamCallId(event);
-        if (id !== "") state.emittedToolResultIds.add(id);
-      }
-      queue.push({
-        kind: "delta",
-        event
-      });
-    }
-  }, "onDelta");
-  return {
-    state,
-    onDelta
-  };
-}
-__name(createDeltaSink, "createDeltaSink");
 function resolveTextTransformFlags(compiled, overrides) {
   return {
     parseThinkTags: overrides.parseThinkTags ?? compiled.parseThinkTags ?? false,
@@ -1466,6 +1722,7 @@ async function* streamSdkAgent(rt, compiled, sdkTools, opts) {
       onDelta
     };
     if (factoryOpts?.disableTools === true) sendOptions.toolChoice = "none";
+    if (overrides.onRunEvent !== void 0) sendOptions.onRunEvent = overrides.onRunEvent;
     const sendInput = overrides.images && overrides.images.length > 0 ? {
       text: message,
       images: overrides.images
@@ -1479,7 +1736,16 @@ async function* streamSdkAgent(rt, compiled, sdkTools, opts) {
     })) {
       yield event;
     }
-    if (!state.sawError) {
+    if (state.sawError) {
+      if (state.lastEventType !== "error") {
+        yield {
+          type: "error",
+          code: "RUN_FAILED",
+          message: "O turno terminou com erro; veja o evento `error` anterior.",
+          retryable: false
+        };
+      }
+    } else {
       yield realUsageDone(await (await sendPromise).wait(), t0);
     }
   } finally {
@@ -1518,534 +1784,38 @@ function toAgentFactory(def, opts) {
       tools: sdkTools,
       ...m8,
       ...extra
-    });
-    return agent;
-  };
-}
-__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;
-  }
-  /**
-  * 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;
-  }
-};
-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() : "";
-  }
-}
-__name(safeJson, "safeJson");
-__name2(safeJson, "safeJson");
-function suffix(open, value, close) {
-  return value === void 0 ? "" : open + value + close;
-}
-__name(suffix, "suffix");
-__name2(suffix, "suffix");
-var TerminalPresenter = class {
-  static {
-    __name(this, "TerminalPresenter");
-  }
-  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 [];
-    }
-  }
-  #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
-    };
-  }
-};
-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
-      }
-    ];
-  }
-};
+    });
+    return withGuardrails(agent, compiled.guardrails);
+  };
+}
+__name(toAgentFactory, "toAgentFactory");
+function withGuardrails(handle, guardrails) {
+  if (guardrails === void 0 || guardrails.length === 0) return handle;
+  return {
+    get agentId() {
+      return handle.agentId;
+    },
+    dispose: /* @__PURE__ */ __name(() => handle.dispose(), "dispose"),
+    send: /* @__PURE__ */ __name(async (msg, sendOpts) => {
+      const guarded = await runInputGuards(msg, guardrails);
+      const turn = await handle.send(guarded, sendOpts);
+      return {
+        wait: /* @__PURE__ */ __name(async () => {
+          const out = await turn.wait();
+          if (out.result === void 0) return out;
+          return {
+            ...out,
+            result: await runOutputGuards(out.result, guardrails)
+          };
+        }, "wait")
+      };
+    }, "send")
+  };
+}
+__name(withGuardrails, "withGuardrails");
 
 // src/bridge/present-ui-message-stream.ts
+import { UIMessageStreamPresenter } from "@theokit/presenter";
 function toAgentOutputEvent(e) {
   switch (e.type) {
     case "text_delta":
@@ -2089,6 +1859,61 @@ function doneToMetadata(event) {
   };
 }
 __name(doneToMetadata, "doneToMetadata");
+var ERROR_CODE_DATA_PART = "data-error-code";
+var INPUT_REQUESTED_DATA_PART = "data-input-requested";
+var TASK_PROGRESS_DATA_PART = "data-task-progress";
+var SHELL_OUTPUT_DATA_PART = "data-shell-output";
+function dataPart(type, data) {
+  return {
+    type,
+    data,
+    transient: true
+  };
+}
+__name(dataPart, "dataPart");
+function* errorChunks(errorText, code) {
+  if (code !== void 0) yield dataPart(ERROR_CODE_DATA_PART, {
+    code
+  });
+  yield {
+    type: "error",
+    errorText
+  };
+}
+__name(errorChunks, "errorChunks");
+function diagnosticDataPart(event) {
+  switch (event.type) {
+    case "checkpoint_saved":
+      return dataPart("data-checkpoint", {
+        checkpointId: event.checkpointId,
+        resumeToken: event.resumeToken,
+        step: event.step
+      });
+    // theokit#141 — without these cases the three restored events would be dropped by the loop's
+    // catch-all, which is the reported defect one layer down: translating an event and never
+    // presenting it leaves the consumer just as blind, minus even the warning.
+    case "input_requested":
+      return dataPart(INPUT_REQUESTED_DATA_PART, {
+        requestId: event.requestId
+      });
+    case "task_progress":
+      return dataPart(TASK_PROGRESS_DATA_PART, {
+        ...event.status !== void 0 ? {
+          status: event.status
+        } : {},
+        ...event.text !== void 0 ? {
+          text: event.text
+        } : {}
+      });
+    case "shell_output":
+      return dataPart(SHELL_OUTPUT_DATA_PART, {
+        event: event.event
+      });
+    default:
+      return null;
+  }
+}
+__name(diagnosticDataPart, "diagnosticDataPart");
 async function* presentUIMessageStream(events, opts) {
   const presenter = new UIMessageStreamPresenter({
     textId: opts.textId
@@ -2123,28 +1948,14 @@ async function* presentUIMessageStream(events, opts) {
         };
         continue;
       }
-      if (event.type === "checkpoint_saved") {
+      const diagnostic = diagnosticDataPart(event);
+      if (diagnostic !== null) {
         yield* presenter.closeBlock();
-        yield {
-          type: "data-checkpoint",
-          data: {
-            checkpointId: event.checkpointId,
-            resumeToken: event.resumeToken,
-            step: event.step
-          },
-          transient: true
-        };
+        yield diagnostic;
         continue;
       }
       if (event.type === "error") {
-        const code = event.code;
-        yield {
-          type: "error",
-          errorText: event.message,
-          ...code !== void 0 ? {
-            errorCode: code
-          } : {}
-        };
+        yield* errorChunks(event.message, event.code);
         break;
       }
       if (event.type === "done") {
@@ -2154,13 +1965,7 @@ async function* presentUIMessageStream(events, opts) {
     }
   } catch (err) {
     const code = err.code;
-    yield {
-      type: "error",
-      errorText: String(err),
-      ...typeof code === "string" ? {
-        errorCode: code
-      } : {}
-    };
+    yield* errorChunks(String(err), typeof code === "string" ? code : void 0);
   }
   yield* presenter.finish(turnMetadata);
 }
@@ -2364,6 +2169,7 @@ function streamAgentUIMessages(compiled, apiKey, input) {
   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;
+  if (input.onRunEvent !== void 0) overrides.onRunEvent = input.onRunEvent;
   let source;
   if (!input.hitl || input.hitl.gated.size === 0) {
     const events2 = createSdkAgentStream(compiled, compiled.tools, apiKey, overrides)(input.message, input.sessionId);
@@ -2414,198 +2220,6 @@ function streamAgentUIMessages(compiled, apiKey, input) {
 }
 __name(streamAgentUIMessages, "streamAgentUIMessages");
 
-// src/guardrails/types.ts
-var GuardrailViolationError = class extends Error {
-  static {
-    __name(this, "GuardrailViolationError");
-  }
-  guardName;
-  phase;
-  reason;
-  constructor(guardName, phase, reason) {
-    super(`Guardrail "${guardName}" blocked ${phase}: ${reason}`), this.guardName = guardName, this.phase = phase, this.reason = reason;
-    this.name = "GuardrailViolationError";
-  }
-};
-var CostBudgetExceededError = class extends Error {
-  static {
-    __name(this, "CostBudgetExceededError");
-  }
-  usedTokens;
-  maxTokens;
-  constructor(usedTokens, maxTokens) {
-    super(`Cost budget exceeded: ${usedTokens} > ${maxTokens} tokens`), this.usedTokens = usedTokens, this.maxTokens = maxTokens;
-    this.name = "CostBudgetExceededError";
-  }
-};
-
-// src/guardrails/detectors.ts
-function estimateTokens(text) {
-  return Math.ceil(text.length / 4);
-}
-__name(estimateTokens, "estimateTokens");
-var INJECTION_PHRASES = [
-  "previous instructions",
-  "disregard the above",
-  "you are now dan",
-  "system prompt",
-  "no restrictions",
-  "without restrictions",
-  "no rules",
-  "override your"
-];
-function normalizeForMatch(text) {
-  return text.toLowerCase().replace(/\s+/g, " ");
-}
-__name(normalizeForMatch, "normalizeForMatch");
-function promptInjectionDetector(options = {}) {
-  const phrases = [
-    ...INJECTION_PHRASES,
-    ...(options.extra ?? []).map((p) => p.toLowerCase())
-  ];
-  return {
-    name: "prompt-injection",
-    checkInput(text) {
-      const normalized = normalizeForMatch(text);
-      for (const phrase of phrases) {
-        if (normalized.includes(phrase)) {
-          return {
-            action: "block",
-            reason: `prompt injection phrase matched: "${phrase}"`
-          };
-        }
-      }
-      return {
-        action: "allow"
-      };
-    }
-  };
-}
-__name(promptInjectionDetector, "promptInjectionDetector");
-var CPF = /\b\d{3}\.?\d{3}\.?\d{3}-?\d{2}\b/g;
-var EMAIL = /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/g;
-var PHONE = /\+?\d[\d\s()-]{7,13}\d/g;
-function piiDetector(options = {}) {
-  const placeholder = options.placeholder ?? "[REDACTED]";
-  return {
-    name: "pii",
-    checkInput(text) {
-      let redacted = text;
-      redacted = redacted.replace(EMAIL, placeholder);
-      redacted = redacted.replace(CPF, placeholder);
-      redacted = redacted.replace(PHONE, placeholder);
-      if (redacted === text) return {
-        action: "allow"
-      };
-      return {
-        action: "redact",
-        text: redacted,
-        reason: "PII detected and redacted"
-      };
-    }
-  };
-}
-__name(piiDetector, "piiDetector");
-var OBFUSCATION_CHARS = /[\u200B-\u200D\uFEFF\u202A-\u202E\u2066-\u2069]/g;
-function unicodeNormalizer() {
-  return {
-    name: "unicode-normalizer",
-    checkInput(text) {
-      const cleaned = text.normalize("NFKC").replace(OBFUSCATION_CHARS, "");
-      if (cleaned === text) return {
-        action: "allow"
-      };
-      return {
-        action: "redact",
-        text: cleaned,
-        reason: "obfuscation characters normalized"
-      };
-    }
-  };
-}
-__name(unicodeNormalizer, "unicodeNormalizer");
-function costGuard(options) {
-  let used = 0;
-  return {
-    name: "cost-guard",
-    // Returns a Promise explicitly (not `async`) so a budget breach REJECTS uniformly — never a
-    // sync throw — safe for direct callers and for the pipeline's `await g.checkInput()`.
-    checkInput(text) {
-      used += estimateTokens(text);
-      if (used > options.maxTokens) {
-        return Promise.reject(new CostBudgetExceededError(used, options.maxTokens));
-      }
-      return Promise.resolve({
-        action: "allow"
-      });
-    }
-  };
-}
-__name(costGuard, "costGuard");
-function outputModeration(options) {
-  return {
-    name: "output-moderation",
-    async checkOutput(text) {
-      const flagged = await options.moderate(text);
-      return flagged ? {
-        action: "block",
-        reason: "output flagged by moderation predicate"
-      } : {
-        action: "allow"
-      };
-    }
-  };
-}
-__name(outputModeration, "outputModeration");
-
-// src/guardrails/pipeline.ts
-async function runInputGuards(text, guards) {
-  let current = text;
-  for (const g of guards) {
-    if (!g.checkInput) continue;
-    const r = await g.checkInput(current);
-    if (r.action === "block") {
-      throw new GuardrailViolationError(g.name, "input", r.reason ?? "blocked");
-    }
-    if (r.action === "redact" && r.text !== void 0) current = r.text;
-  }
-  return current;
-}
-__name(runInputGuards, "runInputGuards");
-async function runOutputGuards(text, guards) {
-  let current = text;
-  for (const g of guards) {
-    if (!g.checkOutput) continue;
-    const r = await g.checkOutput(current);
-    if (r.action === "block") {
-      throw new GuardrailViolationError(g.name, "output", r.reason ?? "blocked");
-    }
-    if (r.action === "redact" && r.text !== void 0) current = r.text;
-  }
-  return current;
-}
-__name(runOutputGuards, "runOutputGuards");
-
-// src/guardrails/stream.ts
-async function* moderateOutputStream(inner, guards, extractText) {
-  const hasOutputGuard = guards.some((g) => g.checkOutput != null);
-  if (!hasOutputGuard) return yield* inner;
-  const buffered = [];
-  let accumulated = "";
-  let step = await inner.next();
-  while (!step.done) {
-    const event = step.value;
-    const text = extractText(event);
-    if (text !== void 0) accumulated += text;
-    buffered.push(event);
-    step = await inner.next();
-  }
-  await runOutputGuards(accumulated, guards);
-  for (const event of buffered) yield event;
-  return step.value;
-}
-__name(moderateOutputStream, "moderateOutputStream");
-
 // src/loop/compaction-strategy.ts
 import { compactTranscript } from "@theokit/sdk/compaction";
 import { z } from "zod";
@@ -2738,10 +2352,10 @@ var DelegationError = class extends Error {
 };
 
 // src/loop/run-reflective-loop.ts
-function asString3(value, fallback) {
+function asString2(value, fallback) {
   return typeof value === "string" ? value : fallback;
 }
-__name(asString3, "asString");
+__name(asString2, "asString");
 function asNumber(value, fallback) {
   return typeof value === "number" ? value : fallback;
 }
@@ -2817,15 +2431,15 @@ function deriveFinishReason(signals) {
 }
 __name(deriveFinishReason, "deriveFinishReason");
 function pushToolResult(event, r, callInputs) {
-  const id = asString3(event.callId, "");
+  const id = asString2(event.callId, "");
   const call = callInputs.get(id);
   r.toolCalls.push({
     id,
-    name: call?.name ?? asString3(event.toolName, "unknown"),
+    name: call?.name ?? asString2(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: asString3(event.output, "")
+    output: asString2(event.output, "")
   });
 }
 __name(pushToolResult, "pushToolResult");
@@ -2844,8 +2458,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(asString3(event.callId, ""), {
-      name: asString3(event.toolName, "unknown"),
+    callInputs.set(asString2(event.callId, ""), {
+      name: asString2(event.toolName, "unknown"),
       input: event.input ?? {}
     });
   } else if (event.type === "tool_result") {
@@ -2853,11 +2467,11 @@ function accumulateEvent(event, r, signals, callInputs) {
     pushToolResult(event, r, callInputs);
   } else if (event.type === "done") {
     signals.sawDone = true;
-    signals.doneFinishReason = asString3(event.finishReason, "");
+    signals.doneFinishReason = asString2(event.finishReason, "");
     applyDone(event, r);
   } else if (event.type === "error") {
     signals.sawError = true;
-    r.errorMessage = asString3(event.message, "Unknown agent error");
+    r.errorMessage = asString2(event.message, "Unknown agent error");
   }
 }
 __name(accumulateEvent, "accumulateEvent");
@@ -3415,13 +3029,13 @@ __name(mcpToolApprovals, "mcpToolApprovals");
 import { existsSync, readFileSync } from "fs";
 import { join } from "path";
 import { TheokitAgentError } from "@theokit/sdk/errors";
-function canalDeAviso(opts) {
-  return opts.onWarn ?? ((aviso) => {
-    process.stderr.write(`[@theokit/agents] ${aviso}
+function warningChannel(opts) {
+  return opts.onWarn ?? ((warning) => {
+    process.stderr.write(`[@theokit/agents] ${warning}
 `);
   });
 }
-__name(canalDeAviso, "canalDeAviso");
+__name(warningChannel, "warningChannel");
 var McpFileError = class extends TheokitAgentError {
   static {
     __name(this, "McpFileError");
@@ -3447,7 +3061,7 @@ function loadMcpJson(cwd, opts = {}) {
   } catch (err) {
     throw new McpFileError(`${path} is not valid JSON: ${descrever(err)}`);
   }
-  return parseMcpJson(parsed, path, canalDeAviso(opts));
+  return parseMcpJson(parsed, path, warningChannel(opts));
 }
 __name(loadMcpJson, "loadMcpJson");
 function parseMcpJson(raw, source, onWarn) {
@@ -3466,7 +3080,7 @@ function parseMcpJson(raw, source, onWarn) {
       onWarn(`${source}: server "${name}" ignorado \u2014 ${motivo}`);
       continue;
     }
-    out[name] = montarEntrada(entryRaw);
+    out[name] = buildEntry(entryRaw);
   }
   return out;
 }
@@ -3514,16 +3128,16 @@ function validarRemoto(entry) {
   return void 0;
 }
 __name(validarRemoto, "validarRemoto");
-function montarEntrada(entry) {
+function buildEntry(entry) {
   if (entry.url !== void 0) {
-    const remoto = {
+    const remote = {
       url: entry.url
     };
-    if (entry.type !== void 0) remoto.type = entry.type;
-    if (entry.headers !== void 0) remoto.headers = entry.headers;
-    if (entry.auth !== void 0) remoto.auth = entry.auth;
-    if (entry.requestTimeoutMs !== void 0) remoto.requestTimeoutMs = entry.requestTimeoutMs;
-    return remoto;
+    if (entry.type !== void 0) remote.type = entry.type;
+    if (entry.headers !== void 0) remote.headers = entry.headers;
+    if (entry.auth !== void 0) remote.auth = entry.auth;
+    if (entry.requestTimeoutMs !== void 0) remote.requestTimeoutMs = entry.requestTimeoutMs;
+    return remote;
   }
   const stdio = {
     command: entry.command
@@ -3533,7 +3147,7 @@ function montarEntrada(entry) {
   if (entry.cwd !== void 0) stdio.cwd = entry.cwd;
   return stdio;
 }
-__name(montarEntrada, "montarEntrada");
+__name(buildEntry, "buildEntry");
 function descrever(err) {
   return err instanceof Error ? err.message : String(err);
 }
@@ -3704,10 +3318,21 @@ export {
   isError,
   isApprovalRequired,
   generateAgentRoutes,
+  GuardrailViolationError,
+  CostBudgetExceededError,
+  estimateTokens,
+  promptInjectionDetector,
+  piiDetector,
+  unicodeNormalizer,
+  costGuard,
+  outputModeration,
+  runInputGuards,
+  runOutputGuards,
+  moderateOutputStream,
   createToolHooksPlugin,
-  translateSdkEvent,
   buildModelSelection,
   reasoningEffortOf,
+  translateSdkEvent,
   createThinkTagExtractor,
   extractThinkTagStream,
   createSdkAgentStream,
@@ -3718,17 +3343,6 @@ export {
   AgentDefinitionError,
   compileAgentModule,
   streamAgentUIMessages,
-  GuardrailViolationError,
-  CostBudgetExceededError,
-  estimateTokens,
-  promptInjectionDetector,
-  piiDetector,
-  unicodeNormalizer,
-  costGuard,
-  outputModeration,
-  runInputGuards,
-  runOutputGuards,
-  moderateOutputStream,
   DEFAULT_KEEP_TOKENS,
   compactionStrategyConfigSchema,
   resolveCompactionStrategy,
@@ -3759,4 +3373,4 @@ export {
   generateAgentManifest,
   agentsPlugin
 };
-//# sourceMappingURL=chunk-UJPG3K26.js.map
+//# sourceMappingURL=chunk-LJLNFCLS.js.map