@theokit/agents 0.30.2 → 0.32.0

package/dist/{chunk-QJKU2YMC.js → chunk-5VIRIPVV.js}

@@ -21,19 +21,19 @@ import {
   getProjectContextConfig,
   getSkillsConfig,
   getSubAgents
-} from "./chunk-FI6ZG2YP.js";
+} from "./chunk-3AX6M5TF.js";
 import {
   __name
 } from "./chunk-7QVYU63E.js";
 
 // src/bridge/agent-execution-context.ts
-function createAgentExecutionContext(base, agent, run, toolCall) {
+function createAgentExecutionContext(base, agent2, run, toolCall) {
   return {
     getRequest: /* @__PURE__ */ __name(() => base.getRequest(), "getRequest"),
     getUrl: /* @__PURE__ */ __name(() => base.getUrl(), "getUrl"),
     getClass: /* @__PURE__ */ __name(() => base.getClass(), "getClass"),
     getMethodName: /* @__PURE__ */ __name(() => base.getMethodName(), "getMethodName"),
-    getAgent: /* @__PURE__ */ __name(() => agent, "getAgent"),
+    getAgent: /* @__PURE__ */ __name(() => agent2, "getAgent"),
     getRun: /* @__PURE__ */ __name(() => run, "getRun"),
     getToolCall: /* @__PURE__ */ __name(() => toolCall ?? null, "getToolCall"),
     isAgentContext: /* @__PURE__ */ __name(() => true, "isAgentContext")
@@ -982,7 +982,8 @@ async function loadSdkRuntime() {
       InMemoryConversationStorage: InMemory,
       FileSystemConversationStorage: "FileSystemConversationStorage" in sdk ? sdk.FileSystemConversationStorage : InMemory
     };
-  } catch {
+  } catch (err) {
+    console.warn("[theokit] @theokit/sdk import failed:", err);
     return null;
   }
 }
@@ -1124,15 +1125,34 @@ function hasZodInputSchema(schema) {
   return typeof schema?.parse === "function";
 }
 __name(hasZodInputSchema, "hasZodInputSchema");
-function buildSdkTools(compiledTools, defineTool, extraSdkTools = []) {
+function withRunContext(handler, runContext) {
+  return (input, ctx) => handler(input, {
+    signal: ctx?.signal,
+    context: runContext
+  });
+}
+__name(withRunContext, "withRunContext");
+function buildSdkTools(compiledTools, defineTool, extraSdkTools = [], runContext) {
+  const has = runContext !== void 0;
   return [
-    ...compiledTools.map((t) => hasZodInputSchema(t.inputSchema) ? defineTool({
-      name: t.name,
-      description: t.description,
-      inputSchema: t.inputSchema,
-      handler: t.handler
-    }) : t),
-    ...extraSdkTools
+    ...compiledTools.map((t) => {
+      if (hasZodInputSchema(t.inputSchema)) {
+        return defineTool({
+          name: t.name,
+          description: t.description,
+          inputSchema: t.inputSchema,
+          handler: has ? withRunContext(t.handler, runContext) : t.handler
+        });
+      }
+      return has ? {
+        ...t,
+        handler: withRunContext(t.handler, runContext)
+      } : t;
+    }),
+    ...extraSdkTools.map((t) => has ? {
+      ...t,
+      handler: withRunContext(t.handler, runContext)
+    } : t)
   ];
 }
 __name(buildSdkTools, "buildSdkTools");
@@ -1140,6 +1160,7 @@ function createSdkAgentStream(compiled, compiledTools, apiKey, overrides = {}) {
   const model = overrides.model ?? compiled.model ?? "openai/gpt-4o-mini";
   const reasoningEffort = overrides.reasoningEffort ?? compiled.reasoningEffort;
   const { parseThinkTags, stripToolDialect } = resolveTextTransformFlags(compiled, overrides);
+  const runContext = overrides.runContext ?? compiled.runContext;
   let storage = overrides.conversationStorage;
   return (message, sessionId, factoryOpts) => ({
     async *[Symbol.asyncIterator]() {
@@ -1155,51 +1176,35 @@ function createSdkAgentStream(compiled, compiledTools, apiKey, overrides = {}) {
         };
         return;
       }
-      const { Agent, defineTool, InMemoryConversationStorage, FileSystemConversationStorage } = rt;
-      const sdkTools = buildSdkTools(compiledTools, defineTool, overrides.sdkTools);
-      let agent;
+      const { InMemoryConversationStorage, FileSystemConversationStorage } = rt;
+      const sdkTools = buildSdkTools(compiledTools, rt.defineTool, overrides.sdkTools, runContext);
+      let runContextSource;
+      if (overrides.runContext !== void 0) {
+        runContextSource = "per-run";
+      } else if (compiled.runContext !== void 0) {
+        runContextSource = "agent-level";
+      } else {
+        runContextSource = "none";
+      }
+      console.debug("[THEO_AGENT_M7_RUN_CONTEXT]", {
+        source: runContextSource,
+        keys: runContext !== void 0 ? Object.keys(runContext) : []
+      });
+      storage ??= newConversationStorage(compiled, InMemoryConversationStorage, FileSystemConversationStorage);
       try {
-        const { options: m8, applied } = assembleM8CreateOptions(compiled);
-        if (overrides.cwd !== void 0) m8.local = {
-          ...m8.local,
-          cwd: overrides.cwd
-        };
-        const extra = buildExtraCreateOptions(overrides, compiled);
-        storage ??= newConversationStorage(compiled, InMemoryConversationStorage, FileSystemConversationStorage);
-        if (applied.length > 0) {
-          console.debug("[THEO_AGENT_M8_RUNTIME_APPLIED]", {
-            skills: applied.includes("skills"),
-            context: applied.includes("context"),
-            projectContext: applied.includes("projectContext")
-          });
-        }
-        agent = await Agent.getOrCreate(sessionId, {
+        yield* streamSdkAgent(rt, compiled, sdkTools, storage, {
           apiKey,
-          model: buildModelSelection(model, reasoningEffort),
-          tools: sdkTools,
-          ...m8,
-          ...extra,
-          conversationStorage: storage
-        });
-        const queue = createAsyncQueue();
-        const { state, onDelta } = createDeltaSink(queue);
-        const sendPromise = agent.send(message, factoryOpts?.disableTools === true ? {
-          onDelta,
-          toolChoice: "none"
-        } : {
-          onDelta
-        });
-        const openStream = /* @__PURE__ */ __name(async () => (await sendPromise).stream(), "openStream");
-        const merged = mergeDeltaStream(queue, openStream, runId, state);
-        for await (const event of applyTextTransforms(merged, {
+          model,
+          reasoningEffort,
+          overrides,
           parseThinkTags,
-          stripToolDialect
-        })) {
-          yield event;
-        }
-        if (!state.sawError) {
-          yield realUsageDone(await (await sendPromise).wait(), t0);
-        }
+          stripToolDialect,
+          sessionId,
+          message,
+          factoryOpts,
+          runId,
+          t0
+        });
       } catch (err) {
         yield {
           type: "error",
@@ -1207,13 +1212,59 @@ function createSdkAgentStream(compiled, compiledTools, apiKey, overrides = {}) {
           message: err instanceof Error ? err.message : "SDK agent error",
           retryable: false
         };
-      } finally {
-        await agent?.dispose();
       }
     }
   });
 }
 __name(createSdkAgentStream, "createSdkAgentStream");
+async function* streamSdkAgent(rt, compiled, sdkTools, storage, 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
+  };
+  const extra = buildExtraCreateOptions(overrides, compiled);
+  if (applied.length > 0) {
+    console.debug("[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,
+    conversationStorage: storage
+  });
+  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);
+    }
+  } finally {
+    await agent2.dispose();
+  }
+}
+__name(streamSdkAgent, "streamSdkAgent");
 
 // src/bridge/ui-message-stream-translator.ts
 function* closeOpenBlock(state, textId) {
@@ -1390,11 +1441,12 @@ function isAgentDefinition(value) {
 }
 __name(isAgentDefinition, "isAgentDefinition");
 function toCompiledTool(tool) {
+  const handler = tool.handler;
   return {
     name: tool.name,
     description: tool.description,
     inputSchema: tool.inputSchema,
-    handler: /* @__PURE__ */ __name((input) => tool.handler(input), "handler")
+    handler: /* @__PURE__ */ __name((input, ctx) => handler(input, ctx), "handler")
   };
 }
 __name(toCompiledTool, "toCompiledTool");
@@ -1405,15 +1457,108 @@ function compileAgentDefinition(def) {
     systemPrompt: def.system,
     tools: (def.tools ?? []).map(toCompiledTool),
     agents: {},
-    stream: true
+    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)
   };
 }
 __name(compileAgentDefinition, "compileAgentDefinition");
+function compileSkillsSelection(skills) {
+  if (skills === void 0) return {};
+  if (typeof skills === "function") return {
+    skillsResolver: skills
+  };
+  return {
+    skills: {
+      enabled: [
+        ...skills
+      ],
+      autoInject: true
+    }
+  };
+}
+__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-builder.ts
+function contextualTool(tool, _requiredContext) {
+  return tool;
+}
+__name(contextualTool, "contextualTool");
+function makeBuilder(config) {
+  const runtime = {
+    input: /* @__PURE__ */ __name((schema) => makeBuilder({
+      ...config,
+      input: schema
+    }), "input"),
+    model: /* @__PURE__ */ __name((id) => makeBuilder({
+      ...config,
+      model: id
+    }), "model"),
+    system: /* @__PURE__ */ __name((prompt) => makeBuilder({
+      ...config,
+      system: prompt
+    }), "system"),
+    reasoningEffort: /* @__PURE__ */ __name((effort) => makeBuilder({
+      ...config,
+      reasoningEffort: effort
+    }), "reasoningEffort"),
+    context: /* @__PURE__ */ __name((value) => makeBuilder({
+      ...config,
+      context: value
+    }), "context"),
+    tool: /* @__PURE__ */ __name((tool) => makeBuilder({
+      ...config,
+      tools: [
+        ...config.tools ?? [],
+        tool
+      ]
+    }), "tool"),
+    use: /* @__PURE__ */ __name((preset) => preset(runtime), "use"),
+    build: /* @__PURE__ */ __name(() => defineAgent(config), "build")
+  };
+  return runtime;
+}
+__name(makeBuilder, "makeBuilder");
+function agent() {
+  return makeBuilder({});
+}
+__name(agent, "agent");
 
 // src/bridge/hitl-plugin.ts
 function createHitlPlugin(wiring) {
   return {
     name: "theokit-hitl",
+    version: "1.0.0",
+    // `kind: 'general'` is load-bearing — without it the SDK's isCodePlugin() drops this plugin and
+    // the HITL veto never fires (the run would proceed WITHOUT waiting for human approval).
+    kind: "general",
     register(ctx) {
       ctx.on("pre_tool_call", async (c) => {
         const opts = wiring.gated.get(c.name);
@@ -1426,12 +1571,25 @@ function createHitlPlugin(wiring) {
           question: opts.question,
           input: c.args,
           callbackUrl: `approve/${approvalId}`,
-          timeoutMs: opts.timeout ?? 3e5
+          timeoutMs: opts.timeout ?? 3e5,
+          // M20 — carry the declared custom-payload schema so the UI knows what to collect.
+          ...opts.payloadSchema !== void 0 ? {
+            payloadSchema: opts.payloadSchema
+          } : {}
         });
-        const approved = await wiring.awaitApproval(approvalId, opts);
-        return approved ? void 0 : {
+        const raw = await wiring.awaitApproval(approvalId, opts, c.name);
+        const decision = typeof raw === "boolean" ? {
+          approved: raw
+        } : raw;
+        if (decision.approved) return void 0;
+        let message = `Tool '${c.name}' denied by human approver`;
+        if (decision.reason) message += `: ${decision.reason}`;
+        if (decision.payload !== void 0) {
+          message += ` (payload: ${JSON.stringify(decision.payload)})`;
+        }
+        return {
           block: true,
-          message: `Tool '${c.name}' denied by human approver`
+          message
         };
       });
     }
@@ -1580,6 +1738,198 @@ 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";
@@ -2003,6 +2353,18 @@ var AgentRunner = class {
   * builder set `.stream(false)`, callers should use {@link run} instead.
   */
   stream(message, opts) {
+    const guardrails = this.compiled.guardrails;
+    if (guardrails && guardrails.length > 0) {
+      const runUnguarded = /* @__PURE__ */ __name((m) => this.streamUnguarded(m, opts), "runUnguarded");
+      return (/* @__PURE__ */ __name(async function* guarded() {
+        const safe = await runInputGuards(message, guardrails);
+        return yield* moderateOutputStream(runUnguarded(safe), guardrails, (e) => e.type === "text_delta" && typeof e.content === "string" ? e.content : void 0);
+      }, "guarded"))();
+    }
+    return this.streamUnguarded(message, opts);
+  }
+  /** The core stream path, after input guardrails have run (M9). */
+  streamUnguarded(message, opts) {
     const tools = opts.tools ? [
       ...opts.tools
     ] : this.compiled.tools;
@@ -2117,6 +2479,10 @@ function mergeTools(parentTools, subTools) {
 __name(mergeTools, "mergeTools");
 async function delegate(SubAgentClass, message, opts = {}) {
   const apiKey = requireApiKey(opts, SubAgentClass.name);
+  const effectiveMessage = opts.onDelegationStart ? await opts.onDelegationStart({
+    subAgent: SubAgentClass.name,
+    input: message
+  }) : message;
   const walk = walkAgentMetadata(SubAgentClass, []);
   const toolboxInstances = new Map(walk.toolboxes.map((tb) => [
     tb.class,
@@ -2125,7 +2491,7 @@ async function delegate(SubAgentClass, message, opts = {}) {
   const compiled = compileAgent(walk, toolboxInstances);
   const allTools = mergeTools(opts.parentTools ?? [], compiled.tools);
   const budget = Math.min(opts.budget ?? Infinity, opts.parentBudgetRemaining ?? Infinity);
-  const streamFactory = createSdkAgentStream(compiled, allTools, apiKey, {
+  const streamFactory = opts.streamFactory ?? createSdkAgentStream(compiled, allTools, apiKey, {
     model: opts.model ?? walk.agentConfig.model,
     cwd: opts.cwd,
     plugins: opts.plugins,
@@ -2138,7 +2504,7 @@ async function delegate(SubAgentClass, message, opts = {}) {
   const sessionId = opts.sessionId ?? `sub-${crypto.randomUUID()}`;
   const loopStrategy = resolveLoopStrategy(walk.mainLoop.strategy, opts.maxIterations ?? walk.mainLoop.maxIterations);
   const reflection = opts.reflection ?? (loopStrategy.name === "plan-act-reflect" ? ladderReflectionStrategy : noopReflectionStrategy);
-  return runReflectiveLoop(streamFactory, message, sessionId, {
+  const result = await runReflectiveLoop(streamFactory, effectiveMessage, sessionId, {
     loop: loopStrategy,
     reflection,
     budget,
@@ -2146,9 +2512,213 @@ async function delegate(SubAgentClass, message, opts = {}) {
     signal: opts.signal,
     retry: opts.retry
   });
+  if (opts.onDelegationComplete) {
+    return await opts.onDelegationComplete({
+      subAgent: SubAgentClass.name,
+      result
+    });
+  }
+  return result;
 }
 __name(delegate, "delegate");
 
+// src/bridge/tool-hooks-plugin.ts
+function createToolHooksPlugin(hooks) {
+  return {
+    name: "theokit-tool-hooks",
+    version: "1.0.0",
+    // `kind: 'general'` is load-bearing — without it the SDK's isCodePlugin() drops this plugin and
+    // no hook fires (M10/M19 latent bug, proven via a real OpenRouter run).
+    kind: "general",
+    register(ctx) {
+      const { beforeToolCall, afterToolCall, beforeLLMCall, afterLLMCall, processInput } = hooks;
+      if (beforeToolCall) {
+        ctx.on("pre_tool_call", (c) => beforeToolCall({
+          name: c.name ?? "",
+          args: c.args ?? {}
+        }));
+      }
+      if (afterToolCall) {
+        ctx.on("post_tool_call", (c) => afterToolCall({
+          name: c.name ?? "",
+          result: c.result
+        }));
+      }
+      if (beforeLLMCall) {
+        ctx.on("pre_llm_call", (c) => beforeLLMCall({
+          agentId: c.agentId,
+          runId: c.runId,
+          iteration: c.iteration
+        }));
+      }
+      if (afterLLMCall) {
+        ctx.on("post_llm_call", (c) => afterLLMCall({
+          agentId: c.agentId,
+          runId: c.runId,
+          iteration: c.iteration
+        }));
+      }
+      if (processInput) {
+        ctx.on("pre_user_send", async (c) => {
+          const injected = await processInput({
+            prompt: c.prompt ?? "",
+            agentId: c.agentId,
+            runId: c.runId
+          });
+          return injected !== void 0 && injected.length > 0 ? {
+            recalledContext: injected
+          } : void 0;
+        });
+      }
+    }
+  };
+}
+__name(createToolHooksPlugin, "createToolHooksPlugin");
+
+// src/bridge/api-error-handler.ts
+var DEFAULT_MAX_ATTEMPTS = 3;
+async function runWithApiErrorHandling(thunk, policy) {
+  const maxAttempts = policy.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
+  let attempt = 0;
+  for (; ; ) {
+    attempt += 1;
+    try {
+      return await thunk();
+    } catch (error) {
+      const decision = await policy.processApiError({
+        error,
+        attempt
+      });
+      if (decision.retry && attempt < maxAttempts) continue;
+      if (!decision.retry && "fallback" in decision && decision.fallback !== void 0) {
+        return decision.fallback;
+      }
+      throw error;
+    }
+  }
+}
+__name(runWithApiErrorHandling, "runWithApiErrorHandling");
+function createApiErrorHandler(policy) {
+  return (thunk) => runWithApiErrorHandling(thunk, policy);
+}
+__name(createApiErrorHandler, "createApiErrorHandler");
+
+// src/bridge/delegation-scoring.ts
+function delegateBackground(subAgent, message, opts = {}) {
+  const { delegateFn = delegate, ...delegateOpts } = opts;
+  let isSettled = false;
+  const promise = delegateFn(subAgent, message, delegateOpts).finally(() => {
+    isSettled = true;
+  });
+  promise.catch(() => void 0);
+  return {
+    wait: /* @__PURE__ */ __name(() => promise, "wait"),
+    settled: /* @__PURE__ */ __name(() => isSettled, "settled")
+  };
+}
+__name(delegateBackground, "delegateBackground");
+var DEFAULT_MAX_ROUNDS = 3;
+function defaultFeedbackTemplate(message, feedback) {
+  return `${message}
+
+Feedback from the reviewer (address this): ${feedback}`;
+}
+__name(defaultFeedbackTemplate, "defaultFeedbackTemplate");
+async function delegateWithScoring(subAgent, message, opts) {
+  const { scorer, maxRounds: maxRoundsOpt = DEFAULT_MAX_ROUNDS, delegateFn = delegate, feedbackTemplate = defaultFeedbackTemplate, ...delegateOpts } = opts;
+  const maxRounds = Math.max(1, maxRoundsOpt);
+  const verdicts = [];
+  let currentMessage = message;
+  let lastResult;
+  for (let round = 1; round <= maxRounds; round++) {
+    const result = await delegateFn(subAgent, currentMessage, delegateOpts);
+    lastResult = result;
+    const verdict = await scorer(result);
+    verdicts.push(verdict);
+    if (verdict.pass) {
+      return {
+        result,
+        rounds: round,
+        passed: true,
+        verdicts
+      };
+    }
+    if (verdict.feedback) currentMessage = feedbackTemplate(message, verdict.feedback);
+  }
+  return {
+    result: lastResult,
+    rounds: maxRounds,
+    passed: false,
+    verdicts
+  };
+}
+__name(delegateWithScoring, "delegateWithScoring");
+
+// src/bridge/mcp-resolver.ts
+async function resolveMcpServers(selection, ctx) {
+  if (selection === void 0) return void 0;
+  if (typeof selection !== "function") return selection;
+  const resolved = await selection(ctx);
+  if (typeof resolved !== "object" || resolved === null) {
+    throw new Error("[@theokit/agents] MCP resolver must return an McpServersMap object");
+  }
+  return resolved;
+}
+__name(resolveMcpServers, "resolveMcpServers");
+function mcpRegistry(config) {
+  const registry = config.registry;
+  if (registry === "composio") {
+    const apps = config.apps ?? [];
+    return {
+      composio: {
+        command: "npx",
+        args: [
+          "-y",
+          "@composio/mcp",
+          ...apps.length > 0 ? [
+            "--apps",
+            apps.join(",")
+          ] : []
+        ],
+        env: {
+          COMPOSIO_API_KEY: config.apiKey
+        }
+      }
+    };
+  }
+  if (registry === "mcp.run") {
+    return {
+      "mcp.run": {
+        command: "npx",
+        args: [
+          "-y",
+          "@mcp.run/cli",
+          "serve",
+          ...config.profile ? [
+            "--profile",
+            config.profile
+          ] : []
+        ],
+        env: {
+          MCP_RUN_API_KEY: config.apiKey
+        }
+      }
+    };
+  }
+  throw new Error(`mcpRegistry: unknown registry ${JSON.stringify(registry)} (supported: 'composio', 'mcp.run').`);
+}
+__name(mcpRegistry, "mcpRegistry");
+function mcpToolApprovals(specs) {
+  const out = {};
+  for (const [tool, spec] of Object.entries(specs)) {
+    out[tool] = typeof spec === "string" ? {
+      question: spec
+    } : spec;
+  }
+  return out;
+}
+__name(mcpToolApprovals, "mcpToolApprovals");
+
 // src/manifest/agent-manifest.ts
 function generateAgentManifest(walkResults) {
   return {
@@ -2304,9 +2874,22 @@ export {
   defineAgent,
   isAgentDefinition,
   compileAgentDefinition,
+  contextualTool,
+  agent,
   AgentDefinitionError,
   compileAgentModule,
   streamAgentUIMessages,
+  GuardrailViolationError,
+  CostBudgetExceededError,
+  estimateTokens,
+  promptInjectionDetector,
+  piiDetector,
+  unicodeNormalizer,
+  costGuard,
+  outputModeration,
+  runInputGuards,
+  runOutputGuards,
+  moderateOutputStream,
   DEFAULT_KEEP_TOKENS,
   compactionStrategyConfigSchema,
   resolveCompactionStrategy,
@@ -2322,7 +2905,15 @@ export {
   AgentRunner,
   AgentRunnerBuilder,
   delegate,
+  createToolHooksPlugin,
+  runWithApiErrorHandling,
+  createApiErrorHandler,
+  delegateBackground,
+  delegateWithScoring,
+  resolveMcpServers,
+  mcpRegistry,
+  mcpToolApprovals,
   generateAgentManifest,
   agentsPlugin
 };
-//# sourceMappingURL=chunk-QJKU2YMC.js.map
+//# sourceMappingURL=chunk-5VIRIPVV.js.map