@theokit/agents 7.4.2 → 7.5.0

package/dist/{chunk-PHUNONZT.js → chunk-WKBZZQBO.js}

@@ -1,21 +1,30 @@
+import {
+  __name
+} from "./chunk-Z4QWC7IK.js";
+
 // src/errors.ts
 import { ConfigurationError } from "@theokit/sdk/errors";
 
 // src/bridge/define-agent.ts
 var AGENT_BRAND = /* @__PURE__ */ Symbol.for("theokit.agent.definition");
 function defineAgent(config) {
-  return { ...config, [AGENT_BRAND]: true };
+  return {
+    ...config,
+    [AGENT_BRAND]: true
+  };
 }
+__name(defineAgent, "defineAgent");
 function isAgentDefinition(value) {
   return typeof value === "object" && value !== null && value[AGENT_BRAND] === true;
 }
+__name(isAgentDefinition, "isAgentDefinition");
 function toCompiledTool(tool) {
   const handler = tool.handler;
   const compiled = {
     name: tool.name,
     description: tool.description,
     inputSchema: tool.inputSchema,
-    handler: (input, ctx) => handler(input, ctx)
+    handler: /* @__PURE__ */ __name((input, ctx) => handler(input, ctx), "handler")
   };
   for (const sym of Object.getOwnPropertySymbols(tool)) {
     ;
@@ -23,6 +32,7 @@ function toCompiledTool(tool) {
   }
   return compiled;
 }
+__name(toCompiledTool, "toCompiledTool");
 function compileAgentDefinition(def) {
   return {
     model: def.model,
@@ -33,33 +43,48 @@ function compileAgentDefinition(def) {
     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 } : {},
+    ...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 } : {},
+    ...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) } : {},
+    ...def.approvals !== void 0 ? {
+      hitl: compileApprovals(def)
+    } : {},
     // M13 — skills: a static list → SDK skills.enabled; a resolver → carried for the request path.
     ...compileSkillsSelection(def.skills),
     // theokit-file-based-config — the declared `.theokit/` sources flow to the run path, which
     // projects them into `Agent.create({ local.settingSources })`; absent ⇒ inline config only.
-    ...def.settingSources !== void 0 ? { settingSources: def.settingSources } : {},
+    ...def.settingSources !== void 0 ? {
+      settingSources: def.settingSources
+    } : {},
     // M49 — memory flows to the projection layer; `assembleM8CreateOptions` forwards it to Agent.create.
-    ...def.memory !== void 0 ? { memory: def.memory } : {},
+    ...def.memory !== void 0 ? {
+      memory: def.memory
+    } : {},
     // Hooks are converted here — the layer EVERY path converges on — rather than on the builder, so
     // `defineAgent({ hooks })` cannot type-check and silently no-op. A lifecycle hook that is
     // declared but never registered is a security gate that does not gate.
     ...compileHooksAndPlugins(def),
     // MCP — builder/`defineAgent` servers converge on the same `mcpServers` field the `@MCP`
     // decorator path populates; the SDK adapter forwards it to `Agent.create({ mcpServers })`.
-    ...def.mcpServers !== void 0 ? { mcpServers: def.mcpServers } : {}
+    ...def.mcpServers !== void 0 ? {
+      mcpServers: def.mcpServers
+    } : {}
   };
 }
+__name(compileAgentDefinition, "compileAgentDefinition");
 function compileHooksAndPlugins(def) {
   const map = def.hooks;
   const entries = Object.entries(map ?? {}).filter(([, h]) => typeof h === "function");
   const explicit = def.plugins ?? [];
   if (entries.length === 0) {
-    return def.plugins !== void 0 ? { plugins: def.plugins } : {};
+    return def.plugins !== void 0 ? {
+      plugins: def.plugins
+    } : {};
   }
   const plugin = {
     name: "theokit-builder-hooks",
@@ -71,11 +96,19 @@ function compileHooksAndPlugins(def) {
       }
     }
   };
-  return { plugins: [...explicit, plugin] };
+  return {
+    plugins: [
+      ...explicit,
+      plugin
+    ]
+  };
 }
+__name(compileHooksAndPlugins, "compileHooksAndPlugins");
 function compileSkillsSelection(skills) {
   if (skills === void 0) return {};
-  if (typeof skills === "function") return { skillsResolver: skills };
+  if (typeof skills === "function") return {
+    skillsResolver: skills
+  };
   const enabled = [];
   const inline = [];
   for (const entry of skills) {
@@ -83,22 +116,30 @@ function compileSkillsSelection(skills) {
     else inline.push(entry);
   }
   return {
-    skills: { enabled, autoInject: true, ...inline.length > 0 ? { inline } : {} }
+    skills: {
+      enabled,
+      autoInject: true,
+      ...inline.length > 0 ? {
+        inline
+      } : {}
+    }
   };
 }
+__name(compileSkillsSelection, "compileSkillsSelection");
 function compileApprovals(def) {
   const toolNames = new Set((def.tools ?? []).map((t) => t.name));
   const gates = /* @__PURE__ */ new Map();
   for (const [toolName, options] of Object.entries(def.approvals ?? {})) {
     if (!toolNames.has(toolName)) {
-      throw new Error(
-        `[@theokit/agents] defineAgent approval references unknown tool "${toolName}". Declared tools: ${[...toolNames].join(", ") || "(none)"}.`
-      );
+      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/compile-context-window.ts
 var STRATEGY_KNOBS = [
@@ -114,16 +155,26 @@ function compileContextWindow(options) {
   }
   const opts = options;
   const metadataOnlyKnobs = STRATEGY_KNOBS.filter((knob) => opts[knob] !== void 0);
-  return { context, metadataOnlyKnobs };
+  return {
+    context,
+    metadataOnlyKnobs
+  };
 }
+__name(compileContextWindow, "compileContextWindow");
 
 // src/bridge/compile-skills.ts
 function compileSkills(options) {
   if (options.autoDiscover) {
-    return { autoInject: true };
+    return {
+      autoInject: true
+    };
   }
-  return { enabled: options.include, autoInject: true };
+  return {
+    enabled: options.include,
+    autoInject: true
+  };
 }
+__name(compileSkills, "compileSkills");
 
 // src/bridge/agent-compiler.ts
 var SDK_TOOL_NAME = /^[a-zA-Z][a-zA-Z0-9_-]{0,63}$/;
@@ -143,21 +194,18 @@ function toolRuntimeName(namespace, toolName) {
   const name = namespace ? `${namespace}_${toolName}` : toolName;
   if (!SDK_TOOL_NAME.test(name)) {
     if (SDK_TOOL_NAME_CHARSET.test(name)) {
-      throw new ConfigurationError(
-        `tool: name "${name}" has length ${name.length} \u2014 the composition namespace + "_" + tool exceeds the maximum of ${SDK_TOOL_NAME_MAX_LENGTH} the SDK accepts`
-      );
+      throw new ConfigurationError(`tool: name "${name}" has length ${name.length} \u2014 the composition namespace + "_" + tool exceeds the maximum of ${SDK_TOOL_NAME_MAX_LENGTH} the SDK accepts`);
     }
-    throw new ConfigurationError(
-      `tool: invalid name "${name}" \u2014 it must match ${String(SDK_TOOL_NAME)} (the SDK rejects the rest; check the namespace and the tool name)`
-    );
+    throw new ConfigurationError(`tool: invalid name "${name}" \u2014 it must match ${String(SDK_TOOL_NAME)} (the SDK rejects the rest; check the namespace and the tool name)`);
   }
   if (SDK_RESERVED_TOOL_NAMES.has(name) || name.startsWith(SDK_RESERVED_TOOL_PREFIX)) {
-    throw new ConfigurationError(
-      `tool: reserved name "${name}" \u2014 the SDK reserves ${[...SDK_RESERVED_TOOL_NAMES].join(", ")} and the prefix "${SDK_RESERVED_TOOL_PREFIX}"`
-    );
+    throw new ConfigurationError(`tool: reserved name "${name}" \u2014 the SDK reserves ${[
+      ...SDK_RESERVED_TOOL_NAMES
+    ].join(", ")} and the prefix "${SDK_RESERVED_TOOL_PREFIX}"`);
   }
   return name;
 }
+__name(toolRuntimeName, "toolRuntimeName");
 function compileHitlGates(toolboxes) {
   const gates = /* @__PURE__ */ new Map();
   for (const tb of toolboxes) {
@@ -169,50 +217,50 @@ function compileHitlGates(toolboxes) {
   }
   return gates;
 }
+__name(compileHitlGates, "compileHitlGates");
 function compileTools(toolboxes, toolboxInstances) {
   const tools = [];
   for (const tb of toolboxes) {
     const instance = toolboxInstances.get(tb.class);
     if (!instance) {
-      throw new ConfigurationError(
-        `toolbox: ${tb.class.name} was not instantiated \u2014 pass the instance in \`toolboxInstances\``
-      );
+      throw new ConfigurationError(`toolbox: ${tb.class.name} was not instantiated \u2014 pass the instance in \`toolboxInstances\``);
     }
     for (const tool of tb.tools) {
       const handler = instance[tool.propertyKey];
       if (typeof handler !== "function") {
-        throw new ConfigurationError(
-          `toolbox: ${tb.class.name}.${String(tool.propertyKey)} is not a method (tool "${tool.config.name}")`
-        );
+        throw new ConfigurationError(`toolbox: ${tb.class.name}.${String(tool.propertyKey)} is not a method (tool "${tool.config.name}")`);
       }
       const name = toolRuntimeName(tb.namespace, tool.config.name);
       tools.push({
         name,
         description: tool.config.description,
         inputSchema: tool.config.input,
-        handler: (input) => handler.call(instance, input)
+        handler: /* @__PURE__ */ __name((input) => handler.call(instance, input), "handler")
       });
     }
   }
   return tools;
 }
+__name(compileTools, "compileTools");
 
 // src/bridge/agent-execution-context.ts
 function createAgentExecutionContext(base, agent, run, toolCall) {
   return {
-    getRequest: () => base.getRequest(),
-    getUrl: () => base.getUrl(),
-    getClass: () => base.getClass(),
-    getMethodName: () => base.getMethodName(),
-    getAgent: () => agent,
-    getRun: () => run,
-    getToolCall: () => toolCall ?? null,
-    isAgentContext: () => true
+    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"),
+    getRun: /* @__PURE__ */ __name(() => run, "getRun"),
+    getToolCall: /* @__PURE__ */ __name(() => toolCall ?? null, "getToolCall"),
+    isAgentContext: /* @__PURE__ */ __name(() => true, "isAgentContext")
   };
 }
+__name(createAgentExecutionContext, "createAgentExecutionContext");
 function isAgentContext(ctx) {
   return "isAgentContext" in ctx && ctx.isAgentContext();
 }
+__name(isAgentContext, "isAgentContext");
 
 // src/bridge/compile-project-context.ts
 var UNMAPPED_KNOBS = [
@@ -226,6 +274,7 @@ function projectContextMetadataOnlyKnobs(options) {
   const opts = options;
   return UNMAPPED_KNOBS.filter((knob) => opts[knob] !== void 0);
 }
+__name(projectContextMetadataOnlyKnobs, "projectContextMetadataOnlyKnobs");
 function compileProjectContext(options, base) {
   return async (promptCtx) => {
     const resolvedBase = typeof base === "function" ? await base(promptCtx) : base;
@@ -236,16 +285,24 @@ function compileProjectContext(options, base) {
     const { buildEnvContext, buildRepoMap } = await import("@theokit/sdk-tools");
     const { readProjectInstructions } = await import("@theokit/sdk/project");
     const env = buildEnvContext(cwd);
-    const repoMap = buildRepoMap(cwd, { ignore: options.ignorePatterns });
+    const repoMap = buildRepoMap(cwd, {
+      ignore: options.ignorePatterns
+    });
     let instructions = "";
     try {
       instructions = (await readProjectInstructions(cwd)).content ?? "";
     } catch {
       instructions = "";
     }
-    return [env, repoMap, instructions, resolvedBase].filter(Boolean).join("\n\n");
+    return [
+      env,
+      repoMap,
+      instructions,
+      resolvedBase
+    ].filter(Boolean).join("\n\n");
   };
 }
+__name(compileProjectContext, "compileProjectContext");
 
 // src/bridge/agent-sse-handler.ts
 var encoder = new TextEncoder();
@@ -253,14 +310,14 @@ function streamAgentResponse(eventStream) {
   const stream = new ReadableStream({
     async start(controller) {
       let closed = false;
-      const safeEnqueue = (chunk) => {
+      const safeEnqueue = /* @__PURE__ */ __name((chunk) => {
         if (closed) return;
         try {
           controller.enqueue(chunk);
         } catch {
           closed = true;
         }
-      };
+      }, "safeEnqueue");
       try {
         for await (const event of eventStream) {
           if (closed) break;
@@ -275,7 +332,9 @@ data: ${data}
         if (!closed) {
           const errorEvent = {
             type: "error",
-            error: { message: err instanceof Error ? err.message : "Internal agent error" }
+            error: {
+              message: err instanceof Error ? err.message : "Internal agent error"
+            }
           };
           const frame = `event: error
 data: ${JSON.stringify(errorEvent)}
@@ -297,29 +356,37 @@ data: ${JSON.stringify(errorEvent)}
     }
   });
 }
+__name(streamAgentResponse, "streamAgentResponse");
 
 // src/bridge/agent-stream-events.ts
 function isTextDelta(e) {
   return e.type === "text_delta";
 }
+__name(isTextDelta, "isTextDelta");
 function isToolCall(e) {
   return e.type === "tool_call";
 }
+__name(isToolCall, "isToolCall");
 function isPartialToolCall(e) {
   return e.type === "partial_tool_call";
 }
+__name(isPartialToolCall, "isPartialToolCall");
 function isToolResult(e) {
   return e.type === "tool_result";
 }
+__name(isToolResult, "isToolResult");
 function isDone(e) {
   return e.type === "done";
 }
+__name(isDone, "isDone");
 function isError(e) {
   return e.type === "error";
 }
+__name(isError, "isError");
 function isApprovalRequired(e) {
   return e.type === "approval_required";
 }
+__name(isApprovalRequired, "isApprovalRequired");
 
 // src/bridge/agent-route-generator.ts
 function generateAgentRoutes(ctx) {
@@ -329,7 +396,7 @@ function generateAgentRoutes(ctx) {
   routes.push({
     method: "POST",
     path: `${basePath}/chat`,
-    handler: async (request) => {
+    handler: /* @__PURE__ */ __name(async (request) => {
       let body = null;
       try {
         body = await request.json();
@@ -337,75 +404,92 @@ function generateAgentRoutes(ctx) {
       }
       const message = body?.message;
       if (typeof message !== "string" || message.length === 0) {
-        return new Response(
-          JSON.stringify({ error: { code: "BAD_REQUEST", message: "message field required" } }),
-          { status: 400, headers: { "content-type": "application/json" } }
-        );
+        return new Response(JSON.stringify({
+          error: {
+            code: "BAD_REQUEST",
+            message: "message field required"
+          }
+        }), {
+          status: 400,
+          headers: {
+            "content-type": "application/json"
+          }
+        });
       }
       const rawSessionId = body?.sessionId;
       const sessionId = typeof rawSessionId === "string" ? rawSessionId : `session-${Date.now()}`;
       return streamAgentResponse(createRun(message, sessionId));
-    }
+    }, "handler")
   });
   if (getRun) {
     routes.push({
       method: "GET",
       path: `${basePath}/runs/:runId`,
-      handler: async (request) => {
+      handler: /* @__PURE__ */ __name(async (request) => {
         const url = new URL(request.url);
         const runId = url.pathname.split("/").pop() ?? "";
         const run = await getRun(runId);
         if (!run) {
-          return new Response(
-            JSON.stringify({ error: { code: "NOT_FOUND", message: `Run ${runId} not found` } }),
-            { status: 404, headers: { "content-type": "application/json" } }
-          );
+          return new Response(JSON.stringify({
+            error: {
+              code: "NOT_FOUND",
+              message: `Run ${runId} not found`
+            }
+          }), {
+            status: 404,
+            headers: {
+              "content-type": "application/json"
+            }
+          });
         }
         return new Response(JSON.stringify(run), {
           status: 200,
-          headers: { "content-type": "application/json" }
+          headers: {
+            "content-type": "application/json"
+          }
         });
-      }
+      }, "handler")
     });
   }
   return routes;
 }
+__name(generateAgentRoutes, "generateAgentRoutes");
 
 // src/guardrails/types.ts
 var GuardrailViolationError = class extends Error {
-  constructor(guardName, phase, reason) {
-    super(`Guardrail "${guardName}" blocked ${phase}: ${reason}`);
-    this.guardName = guardName;
-    this.phase = phase;
-    this.reason = reason;
-    this.name = "GuardrailViolationError";
+  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 {
-  constructor(usedTokens, maxTokens) {
-    super(`Cost budget exceeded: ${usedTokens} > ${maxTokens} tokens`);
-    this.usedTokens = usedTokens;
-    this.maxTokens = maxTokens;
-    this.name = "CostBudgetExceededError";
+  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",
-  // "ignore/disregard [all|the] previous instructions"
   "disregard the above",
   "you are now dan",
   "system prompt",
-  // "reveal your/the system prompt"
   "no restrictions",
   "without restrictions",
   "no rules",
@@ -414,21 +498,31 @@ var INJECTION_PHRASES = [
 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())];
+  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: "block",
+            reason: `prompt injection phrase matched: "${phrase}"`
+          };
         }
       }
-      return { action: "allow" };
+      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;
@@ -441,22 +535,36 @@ function piiDetector(options = {}) {
       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" };
+      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" };
+      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 {
@@ -468,19 +576,28 @@ function costGuard(options) {
       if (used > options.maxTokens) {
         return Promise.reject(new CostBudgetExceededError(used, options.maxTokens));
       }
-      return Promise.resolve({ action: "allow" });
+      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" };
+      return flagged ? {
+        action: "block",
+        reason: "output flagged by moderation predicate"
+      } : {
+        action: "allow"
+      };
     }
   };
 }
+__name(outputModeration, "outputModeration");
 
 // src/guardrails/pipeline.ts
 async function runInputGuards(text, guards) {
@@ -495,6 +612,7 @@ async function runInputGuards(text, guards) {
   }
   return current;
 }
+__name(runInputGuards, "runInputGuards");
 async function runOutputGuards(text, guards) {
   let current = text;
   for (const g of guards) {
@@ -507,6 +625,7 @@ async function runOutputGuards(text, guards) {
   }
   return current;
 }
+__name(runOutputGuards, "runOutputGuards");
 
 // src/guardrails/stream.ts
 async function* moderateOutputStream(inner, guards, extractText) {
@@ -526,6 +645,7 @@ async function* moderateOutputStream(inner, guards, extractText) {
   for (const event of buffered) yield event;
   return step.value;
 }
+__name(moderateOutputStream, "moderateOutputStream");
 
 // src/bridge/tool-hooks-plugin.ts
 function createToolHooksPlugin(hooks) {
@@ -538,22 +658,30 @@ function createToolHooksPlugin(hooks) {
     register(ctx) {
       const { beforeToolCall, afterToolCall, beforeLLMCall, afterLLMCall, processInput } = hooks;
       if (beforeToolCall) {
-        ctx.on("pre_tool_call", (c) => beforeToolCall({ name: c.name ?? "", args: c.args ?? {} }));
+        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 }));
+        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 })
-        );
+        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 })
-        );
+        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) => {
@@ -562,30 +690,49 @@ function createToolHooksPlugin(hooks) {
             agentId: c.agentId,
             runId: c.runId
           });
-          return injected !== void 0 && injected.length > 0 ? { recalledContext: injected } : void 0;
+          return injected !== void 0 && injected.length > 0 ? {
+            recalledContext: injected
+          } : void 0;
         });
       }
     }
   };
 }
+__name(createToolHooksPlugin, "createToolHooksPlugin");
 
 // src/bridge/model-selection.ts
 var PARAM_THINKING = "thinking";
 function buildModelSelection(model, effort) {
-  const base = typeof model === "string" ? { id: model } : { ...model };
+  const base = typeof model === "string" ? {
+    id: model
+  } : {
+    ...model
+  };
   if (!effort) return base;
-  return { ...base, params: [...base.params ?? [], { id: PARAM_THINKING, value: effort }] };
+  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;
   return fallback;
 }
+__name(asString, "asString");
 function serializeToolOutput(value, fallback) {
   if (typeof value === "string") return value;
   if (value === void 0 || value === null) return fallback;
@@ -595,6 +742,7 @@ function serializeToolOutput(value, fallback) {
     return typeof value === "bigint" ? value.toString() : fallback;
   }
 }
+__name(serializeToolOutput, "serializeToolOutput");
 function translateSystemEvent(msg, runId) {
   return [
     {
@@ -605,6 +753,7 @@ function translateSystemEvent(msg, runId) {
     }
   ];
 }
+__name(translateSystemEvent, "translateSystemEvent");
 function translateAssistantEvent(msg) {
   const events = [];
   const message = msg.message;
@@ -613,7 +762,10 @@ function translateAssistantEvent(msg) {
   for (const block of content) {
     const b = block;
     if (b.type === "text" && b.text) {
-      events.push({ type: "text_delta", content: b.text });
+      events.push({
+        type: "text_delta",
+        content: b.text
+      });
     }
     if (b.type === "tool_use") {
       events.push({
@@ -630,6 +782,7 @@ function translateAssistantEvent(msg) {
   }
   return events;
 }
+__name(translateAssistantEvent, "translateAssistantEvent");
 function translateToolCallEvent(msg) {
   const status = msg.status;
   const callId = asString(msg.call_id, "");
@@ -660,11 +813,17 @@ function translateToolCallEvent(msg) {
   }
   if (status === "running") {
     return [
-      { type: "tool_call", callId, toolName, input: msg.args ?? msg.input ?? msg.arguments ?? {} }
+      {
+        type: "tool_call",
+        callId,
+        toolName,
+        input: msg.args ?? msg.input ?? msg.arguments ?? {}
+      }
     ];
   }
   return [];
 }
+__name(translateToolCallEvent, "translateToolCallEvent");
 function translateStatusEvent(msg) {
   const s = msg.status;
   if (s === "FINISHED" || s === "CANCELLED") {
@@ -672,7 +831,11 @@ function translateStatusEvent(msg) {
       {
         type: "done",
         result: "",
-        usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 },
+        usage: {
+          inputTokens: 0,
+          outputTokens: 0,
+          totalTokens: 0
+        },
         durationMs: 0,
         cost: 0
       }
@@ -690,15 +853,17 @@ function translateStatusEvent(msg) {
   }
   return [];
 }
+__name(translateStatusEvent, "translateStatusEvent");
 var alreadyWarned = /* @__PURE__ */ new Set();
 function warnIfUnknown(type, deliberatelyIgnored) {
   if (deliberatelyIgnored.has(type) || alreadyWarned.has(type)) return;
   alreadyWarned.add(type);
-  console.warn(
-    `[theokit] agents.bridge: SDK event "${type}" is not translated and was discarded. If it carries information the UI needs, the translator needs a case for it (#141).`
-  );
+  console.warn(`[theokit] agents.bridge: SDK event "${type}" is not translated and was discarded. If it carries information the UI needs, the translator needs a case for it (#141).`);
 }
-var SDK_MESSAGE_IGNORED = /* @__PURE__ */ new Set(["user"]);
+__name(warnIfUnknown, "warnIfUnknown");
+var SDK_MESSAGE_IGNORED = /* @__PURE__ */ new Set([
+  "user"
+]);
 var INTERACTION_UPDATE_IGNORED = /* @__PURE__ */ new Set([
   "thinking-completed",
   "token-delta",
@@ -714,11 +879,21 @@ function translateSdkEvent(msg, runId) {
     case "tool_call":
       return translateToolCallEvent(msg);
     case "thinking":
-      return [{ type: "thinking", content: asString(msg.text, "") }];
+      return [
+        {
+          type: "thinking",
+          content: asString(msg.text, "")
+        }
+      ];
     case "status":
       return translateStatusEvent(msg);
     case "request":
-      return [{ type: "input_requested", requestId: asString(msg.request_id, "") }];
+      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;
@@ -726,8 +901,12 @@ function translateSdkEvent(msg, runId) {
       return [
         {
           type: "task_progress",
-          ...status !== void 0 ? { status } : {},
-          ...text !== void 0 ? { text } : {}
+          ...status !== void 0 ? {
+            status
+          } : {},
+          ...text !== void 0 ? {
+            text
+          } : {}
         }
       ];
     }
@@ -736,12 +915,23 @@ function translateSdkEvent(msg, runId) {
       return [];
   }
 }
+__name(translateSdkEvent, "translateSdkEvent");
 function translateInteractionUpdate(update) {
   switch (update.type) {
     case "text-delta":
-      return update.text ? [{ type: "text_delta", content: update.text }] : [];
+      return update.text ? [
+        {
+          type: "text_delta",
+          content: update.text
+        }
+      ] : [];
     case "thinking-delta":
-      return update.text ? [{ type: "thinking", content: update.text }] : [];
+      return update.text ? [
+        {
+          type: "thinking",
+          content: update.text
+        }
+      ] : [];
     case "tool-call-started":
       return [
         {
@@ -772,12 +962,18 @@ function translateInteractionUpdate(update) {
         }
       ];
     case "shell-output-delta":
-      return [{ type: "shell_output", event: update.event }];
+      return [
+        {
+          type: "shell_output",
+          event: update.event
+        }
+      ];
     default:
       warnIfUnknown(update.type, INTERACTION_UPDATE_IGNORED);
       return [];
   }
 }
+__name(translateInteractionUpdate, "translateInteractionUpdate");
 
 // src/bridge/think-tag-extractor.ts
 var TAG = "think";
@@ -790,10 +986,11 @@ function heldPrefixLength(s, delim) {
   }
   return 0;
 }
+__name(heldPrefixLength, "heldPrefixLength");
 function createThinkTagExtractor() {
   let mode = "text";
   let buffer = "";
-  const write = (chunk) => {
+  const write = /* @__PURE__ */ __name((chunk) => {
     buffer += chunk;
     const out = [];
     for (; ; ) {
@@ -801,30 +998,52 @@ function createThinkTagExtractor() {
       const idx = buffer.indexOf(delim);
       if (idx !== -1) {
         const content = buffer.slice(0, idx);
-        if (content) out.push({ kind: mode, content });
+        if (content) out.push({
+          kind: mode,
+          content
+        });
         buffer = buffer.slice(idx + delim.length);
         mode = mode === "text" ? "thinking" : "text";
         continue;
       }
       const keep = heldPrefixLength(buffer, delim);
       const emit = buffer.slice(0, buffer.length - keep);
-      if (emit) out.push({ kind: mode, content: emit });
+      if (emit) out.push({
+        kind: mode,
+        content: emit
+      });
       buffer = buffer.slice(buffer.length - keep);
       break;
     }
     return out;
-  };
-  const end = () => {
+  }, "write");
+  const end = /* @__PURE__ */ __name(() => {
     if (!buffer) return [];
-    const seg = { kind: mode, content: buffer };
+    const seg = {
+      kind: mode,
+      content: buffer
+    };
     buffer = "";
-    return [seg];
+    return [
+      seg
+    ];
+  }, "end");
+  return {
+    write,
+    end
   };
-  return { write, end };
 }
+__name(createThinkTagExtractor, "createThinkTagExtractor");
 function segmentToEvent(seg) {
-  return seg.kind === "thinking" ? { type: "thinking", content: seg.content } : { type: "text_delta", content: seg.content };
+  return seg.kind === "thinking" ? {
+    type: "thinking",
+    content: seg.content
+  } : {
+    type: "text_delta",
+    content: seg.content
+  };
 }
+__name(segmentToEvent, "segmentToEvent");
 async function* extractThinkTagStream(source) {
   const extractor = createThinkTagExtractor();
   try {
@@ -839,6 +1058,7 @@ async function* extractThinkTagStream(source) {
     for (const seg of extractor.end()) yield segmentToEvent(seg);
   }
 }
+__name(extractThinkTagStream, "extractThinkTagStream");
 
 // src/debug-log.ts
 function debugLog(marker, data) {
@@ -847,6 +1067,7 @@ function debugLog(marker, data) {
     console.debug(marker, data);
   }
 }
+__name(debugLog, "debugLog");
 
 // src/bridge/hitl-plugin.ts
 function createHitlPlugin(wiring) {
@@ -870,37 +1091,48 @@ function createHitlPlugin(wiring) {
           callbackUrl: `approve/${approvalId}`,
           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 } : {}
+          ...opts.payloadSchema !== void 0 ? {
+            payloadSchema: opts.payloadSchema
+          } : {}
         });
         const raw = await wiring.awaitApproval(approvalId, opts, c.name);
-        const decision = typeof raw === "boolean" ? { approved: raw } : raw;
+        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 };
+        return {
+          block: true,
+          message
+        };
       });
     }
   };
 }
+__name(createHitlPlugin, "createHitlPlugin");
 
 // src/bridge/approval-posture.ts
 function reasonOf(posturePolicy) {
   return posturePolicy.kind === "interactive" ? "human approver on this surface" : posturePolicy.reason;
 }
+__name(reasonOf, "reasonOf");
 function applyPosture(extra, m8, posturePolicy, gated) {
   const ofThePosture = posturePlugins(posturePolicy, gated);
   if (ofThePosture.length === 0) return;
   const currentOnes = extra.plugins ?? m8.plugins;
   if (currentOnes !== void 0 && !Array.isArray(currentOnes)) {
-    throw new Error(
-      `[@theokit/agents] approval posture "${posturePolicy.kind}" needs to install a plugin, but \`plugins\` was supplied in the legacy object form, which cannot carry both. Pass \`plugins\` as an array so the approval gate is not dropped.`
-    );
+    throw new Error(`[@theokit/agents] approval posture "${posturePolicy.kind}" needs to install a plugin, but \`plugins\` was supplied in the legacy object form, which cannot carry both. Pass \`plugins\` as an array so the approval gate is not dropped.`);
   }
-  extra.plugins = [...currentOnes ?? [], ...ofThePosture];
+  extra.plugins = [
+    ...currentOnes ?? [],
+    ...ofThePosture
+  ];
 }
+__name(applyPosture, "applyPosture");
 function posturePlugins(posturePolicy, gated) {
   debugLog("[theokit] approval posture", {
     kind: posturePolicy.kind,
@@ -919,7 +1151,7 @@ function posturePlugins(posturePolicy, gated) {
     case "auto-approve":
       return [
         createToolHooksPlugin({
-          beforeToolCall: (ctx) => {
+          beforeToolCall: /* @__PURE__ */ __name((ctx) => {
             if (gated.has(ctx.name)) {
               debugLog("[theokit] gated tool auto-approved", {
                 tool: ctx.name,
@@ -927,7 +1159,7 @@ function posturePlugins(posturePolicy, gated) {
               });
             }
             return void 0;
-          }
+          }, "beforeToolCall")
         })
       ];
     case "auto-reject":
@@ -935,16 +1167,17 @@ function posturePlugins(posturePolicy, gated) {
         createToolHooksPlugin({
           // Only GATED tools are refused: the posture describes the gate, not a universal block.
           // Refusing everything would break every agent with a free tool next to a gated one.
-          beforeToolCall: (ctx) => gated.has(ctx.name) ? {
+          beforeToolCall: /* @__PURE__ */ __name((ctx) => gated.has(ctx.name) ? {
             block: true,
             message: `Tool '${ctx.name}' requires human approval, and this surface has no approver (approval posture: auto-reject \u2014 ${posturePolicy.reason}). Refused (fail-closed).`
-          } : void 0
+          } : void 0, "beforeToolCall")
         })
       ];
     case "owned-by-surface":
       return [];
   }
 }
+__name(posturePlugins, "posturePlugins");
 
 // src/bridge/definition-or-thunk.ts
 function project(def, overrides) {
@@ -956,6 +1189,7 @@ function project(def, overrides) {
     runContext: overrides.runContext ?? compiled.runContext
   };
 }
+__name(project, "project");
 function resolveProjection(def, overrides) {
   if (typeof def === "function") {
     return async (sessionId) => project(await def(sessionId), overrides);
@@ -963,6 +1197,7 @@ function resolveProjection(def, overrides) {
   const eager = project(def, overrides);
   return () => Promise.resolve(eager);
 }
+__name(resolveProjection, "resolveProjection");
 
 // src/bridge/sdk-adapter-create-options.ts
 function assembleM8CreateOptions(compiled) {
@@ -979,7 +1214,10 @@ function assembleM8CreateOptions(compiled) {
   }
   const settingSources = resolveSettingSources(compiled);
   if (settingSources) {
-    options.local = { ...options.local, settingSources };
+    options.local = {
+      ...options.local,
+      settingSources
+    };
     applied.push("settingSources");
   }
   if (compiled.context) {
@@ -1002,23 +1240,32 @@ function assembleM8CreateOptions(compiled) {
     } 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
-`
-        );
+        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 };
+      options.memory = {
+        enabled: true
+      };
     }
     applied.push("memory");
   }
-  return { options, applied };
+  return {
+    options,
+    applied
+  };
 }
+__name(assembleM8CreateOptions, "assembleM8CreateOptions");
 function resolveSettingSources(compiled) {
   const explicit = compiled.settingSources;
-  if (explicit && explicit.length > 0) return [...explicit];
-  if (compiled.skills) return ["project"];
+  if (explicit && explicit.length > 0) return [
+    ...explicit
+  ];
+  if (compiled.skills) return [
+    "project"
+  ];
   return void 0;
 }
+__name(resolveSettingSources, "resolveSettingSources");
 function realUsageDone(result, t0) {
   const u = result.usage;
   const inputTokens = u?.inputTokens ?? 0;
@@ -1040,6 +1287,7 @@ function realUsageDone(result, t0) {
     cost: result.cost?.amount ?? 0
   };
 }
+__name(realUsageDone, "realUsageDone");
 
 // src/bridge/sdk-error.ts
 function sdkErrorEvent(err) {
@@ -1053,6 +1301,7 @@ function sdkErrorEvent(err) {
     retryable: sdkErr.isRetryable === true
   };
 }
+__name(sdkErrorEvent, "sdkErrorEvent");
 
 // src/bridge/sdk-timeline.ts
 function idsOf(e, raw) {
@@ -1063,11 +1312,13 @@ function idsOf(e, raw) {
   if (typeof model === "string" && model !== "" && model !== callId) ids.push(model);
   return ids;
 }
+__name(idsOf, "idsOf");
 function bucketFor(e, seen) {
   if (e.type === "tool_call") return seen.started;
   if (e.type === "tool_result") return seen.completed;
   return void 0;
 }
+__name(bucketFor, "bucketFor");
 function dedupeTools(events, raw, seen) {
   return events.filter((e) => {
     if (e.type === "thinking") {
@@ -1084,15 +1335,19 @@ function dedupeTools(events, raw, seen) {
     return true;
   });
 }
+__name(dedupeTools, "dedupeTools");
 function createToolSeen() {
-  return { started: /* @__PURE__ */ new Set(), completed: /* @__PURE__ */ new Set(), sawThinkingDelta: false };
+  return {
+    started: /* @__PURE__ */ new Set(),
+    completed: /* @__PURE__ */ new Set(),
+    sawThinkingDelta: false
+  };
 }
+__name(createToolSeen, "createToolSeen");
 function translateTimelineEvent(ev, runId, seen) {
   if (ev.kind === "delta") {
     if (ev.update === void 0) return [];
-    const events2 = translateInteractionUpdate(
-      ev.update
-    );
+    const events2 = translateInteractionUpdate(ev.update);
     return dedupeTools(events2, ev.update, seen);
   }
   if (ev.message === void 0) return [];
@@ -1100,6 +1355,7 @@ function translateTimelineEvent(ev, runId, seen) {
   const kept = ev.textAlreadyStreamed === true ? events.filter((e) => e.type !== "text_delta") : events;
   return dedupeTools(kept, ev.message, seen);
 }
+__name(translateTimelineEvent, "translateTimelineEvent");
 
 // src/bridge/tool-dialect-stripper.ts
 var OPEN2 = "<function=";
@@ -1111,11 +1367,12 @@ function heldPrefixLength2(s, delim) {
   }
   return 0;
 }
+__name(heldPrefixLength2, "heldPrefixLength");
 function createToolDialectStripper() {
   let mode = "text";
   let buffer = "";
   let pendingLeak = "";
-  const write = (chunk) => {
+  const write = /* @__PURE__ */ __name((chunk) => {
     buffer += chunk;
     const out = [];
     for (; ; ) {
@@ -1123,7 +1380,10 @@ function createToolDialectStripper() {
         const idx2 = buffer.indexOf(OPEN2);
         if (idx2 !== -1) {
           const content = buffer.slice(0, idx2);
-          if (content) out.push({ kind: "text", content });
+          if (content) out.push({
+            kind: "text",
+            content
+          });
           pendingLeak = OPEN2;
           buffer = buffer.slice(idx2 + OPEN2.length);
           mode = "stripping";
@@ -1131,7 +1391,10 @@ function createToolDialectStripper() {
         }
         const keep2 = heldPrefixLength2(buffer, OPEN2);
         const emit = buffer.slice(0, buffer.length - keep2);
-        if (emit) out.push({ kind: "text", content: emit });
+        if (emit) out.push({
+          kind: "text",
+          content: emit
+        });
         buffer = buffer.slice(buffer.length - keep2);
         break;
       }
@@ -1148,22 +1411,34 @@ function createToolDialectStripper() {
       break;
     }
     return out;
-  };
-  const end = () => {
+  }, "write");
+  const end = /* @__PURE__ */ __name(() => {
     const leftover = mode === "stripping" ? pendingLeak + buffer : buffer;
     buffer = "";
     pendingLeak = "";
-    return leftover ? [{ kind: "text", content: leftover }] : [];
+    return leftover ? [
+      {
+        kind: "text",
+        content: leftover
+      }
+    ] : [];
+  }, "end");
+  return {
+    write,
+    end
   };
-  return { write, end };
 }
+__name(createToolDialectStripper, "createToolDialectStripper");
 async function* stripToolDialectStream(source) {
   const stripper = createToolDialectStripper();
   try {
     for await (const event of source) {
       if (event.type === "text_delta" && typeof event.content === "string") {
         for (const seg of stripper.write(event.content)) {
-          yield { type: "text_delta", content: seg.content };
+          yield {
+            type: "text_delta",
+            content: seg.content
+          };
         }
       } else {
         yield event;
@@ -1171,26 +1446,37 @@ async function* stripToolDialectStream(source) {
     }
   } finally {
     for (const seg of stripper.end()) {
-      yield { type: "text_delta", content: seg.content };
+      yield {
+        type: "text_delta",
+        content: seg.content
+      };
     }
   }
 }
+__name(stripToolDialectStream, "stripToolDialectStream");
 
 // src/bridge/sdk-adapter.ts
 function withLeakedDialectRecovery(providers) {
   return {
     ...providers,
-    routes: providers.routes.map((route) => ({ ...route, extractToolCallsFromContent: true }))
+    routes: providers.routes.map((route) => ({
+      ...route,
+      extractToolCallsFromContent: true
+    }))
   };
 }
+__name(withLeakedDialectRecovery, "withLeakedDialectRecovery");
 function buildExtraCreateOptions(overrides, compiled) {
   const recoverLeakedToolCalls = overrides.recoverLeakedToolCalls ?? compiled.recoverLeakedToolCalls ?? false;
   const extra = {};
   if (overrides.plugins !== void 0) {
-    const asArray = (v) => Array.isArray(v) ? v : void 0;
+    const asArray = /* @__PURE__ */ __name((v) => Array.isArray(v) ? v : void 0, "asArray");
     const overrideList = asArray(overrides.plugins);
     const compiledList = asArray(compiled.plugins);
-    extra.plugins = overrideList !== void 0 && compiledList !== void 0 ? [...compiledList, ...overrideList] : overrides.plugins;
+    extra.plugins = overrideList !== void 0 && compiledList !== void 0 ? [
+      ...compiledList,
+      ...overrideList
+    ] : overrides.plugins;
   }
   if (overrides.providers !== void 0) {
     extra.providers = recoverLeakedToolCalls ? withLeakedDialectRecovery(overrides.providers) : overrides.providers;
@@ -1199,6 +1485,7 @@ function buildExtraCreateOptions(overrides, compiled) {
   if (overrides.budgetTracker !== void 0) extra.budgetTracker = overrides.budgetTracker;
   return extra;
 }
+__name(buildExtraCreateOptions, "buildExtraCreateOptions");
 async function loadSdkRuntime() {
   try {
     const sdk = await import("@theokit/sdk");
@@ -1208,30 +1495,40 @@ async function loadSdkRuntime() {
       // `.bind` keeps the static factory callable when detached from `sdk.Tool` (it takes no `this`,
       // but binding is explicit + satisfies unbound-method rather than relying on that).
       defineTool: sdk.Tool.create.bind(sdk.Tool),
-      ...skillReadTool ? { defineSkillReadTool: (skills) => skillReadTool.create(skills) } : {}
+      ...skillReadTool ? {
+        defineSkillReadTool: /* @__PURE__ */ __name((skills) => skillReadTool.create(skills), "defineSkillReadTool")
+      } : {}
     };
   } catch (err) {
     console.warn("[theokit] @theokit/sdk import failed:", err);
     return null;
   }
 }
+__name(loadSdkRuntime, "loadSdkRuntime");
 function resolveTextTransformFlags(compiled, overrides) {
   return {
     parseThinkTags: overrides.parseThinkTags ?? compiled.parseThinkTags ?? false,
     stripToolDialect: overrides.stripToolDialect ?? compiled.stripToolDialect ?? false
   };
 }
+__name(resolveTextTransformFlags, "resolveTextTransformFlags");
 function applyTextTransforms(events, opts) {
   let out = opts.parseThinkTags ? extractThinkTagStream(events) : events;
   if (opts.stripToolDialect) out = stripToolDialectStream(out);
   return out;
 }
+__name(applyTextTransforms, "applyTextTransforms");
 function hasZodInputSchema(schema) {
   return typeof schema?.parse === "function";
 }
+__name(hasZodInputSchema, "hasZodInputSchema");
 function withRunContext(handler, runContext) {
-  return (input, ctx) => handler(input, { ...ctx, context: runContext });
+  return (input, ctx) => handler(input, {
+    ...ctx,
+    context: runContext
+  });
 }
+__name(withRunContext, "withRunContext");
 function buildSdkTools(compiledTools, defineTool, extraSdkTools = [], runContext) {
   const has = runContext !== void 0;
   return [
@@ -1244,20 +1541,25 @@ function buildSdkTools(compiledTools, defineTool, extraSdkTools = [], runContext
           handler: has ? withRunContext(t.handler, runContext) : t.handler
         });
       }
-      return has ? { ...t, handler: withRunContext(t.handler, runContext) } : t;
+      return has ? {
+        ...t,
+        handler: withRunContext(t.handler, runContext)
+      } : t;
     }),
-    ...extraSdkTools.map(
-      (t) => has ? { ...t, handler: withRunContext(t.handler, runContext) } : t
-    )
+    ...extraSdkTools.map((t) => has ? {
+      ...t,
+      handler: withRunContext(t.handler, runContext)
+    } : t)
   ];
 }
-var resolverApiKey = async (k) => typeof k === "function" ? await k() : k;
+__name(buildSdkTools, "buildSdkTools");
+var resolverApiKey = /* @__PURE__ */ __name(async (k) => typeof k === "function" ? await k() : k, "resolverApiKey");
 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;
-  const factory = (message, sessionId, factoryOpts) => ({
+  const factory = /* @__PURE__ */ __name((message, sessionId, factoryOpts) => ({
     async *[Symbol.asyncIterator]() {
       const runId = `run-${Date.now()}`;
       const t0 = Date.now();
@@ -1306,27 +1608,24 @@ function createSdkAgentStream(compiled, compiledTools, apiKey, overrides = {}) {
         yield sdkErrorEvent(err);
       }
     }
+  }), "factory");
+  return Object.assign(factory, {
+    resolvedModel: model
   });
-  return Object.assign(factory, { resolvedModel: model });
 }
+__name(createSdkAgentStream, "createSdkAgentStream");
 async function* streamSdkAgent(rt, compiled, sdkTools, opts) {
   const { Agent } = rt;
-  const {
-    apiKey,
-    model,
-    reasoningEffort,
-    overrides,
-    parseThinkTags,
-    stripToolDialect,
-    sessionId,
-    message,
-    factoryOpts,
-    runId,
-    t0
-  } = opts;
+  const { apiKey, model, reasoningEffort, overrides, parseThinkTags, stripToolDialect, sessionId, message, factoryOpts, runId, t0 } = opts;
   const { options: m8, applied } = assembleM8CreateOptions(compiled);
-  if (overrides.cwd !== void 0) m8.local = { ...m8.local, cwd: overrides.cwd };
-  if (overrides.baseDir !== void 0) m8.local = { ...m8.local, baseDir: overrides.baseDir };
+  if (overrides.cwd !== void 0) m8.local = {
+    ...m8.local,
+    cwd: overrides.cwd
+  };
+  if (overrides.baseDir !== void 0) m8.local = {
+    ...m8.local,
+    baseDir: overrides.baseDir
+  };
   const extra = buildExtraCreateOptions(overrides, compiled);
   if (applied.length > 0) {
     debugLog("[THEO_AGENT_M8_RUNTIME_APPLIED]", {
@@ -1343,13 +1642,19 @@ async function* streamSdkAgent(rt, compiled, sdkTools, opts) {
     ...extra
   });
   try {
-    const state = { sawError: false, lastEventType: "" };
+    const state = {
+      sawError: false,
+      lastEventType: ""
+    };
     const sendOptions = {};
     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 } : message;
+    const sendInput = overrides.images && overrides.images.length > 0 ? {
+      text: message,
+      images: overrides.images
+    } : message;
     const sendPromise = agent.send(sendInput, sendOptions);
-    const timeline = async function* () {
+    const timeline = /* @__PURE__ */ __name(async function* () {
       const run = await sendPromise;
       const seen = createToolSeen();
       for await (const ev of run.events()) {
@@ -1360,7 +1665,7 @@ async function* streamSdkAgent(rt, compiled, sdkTools, opts) {
           yield event;
         }
       }
-    };
+    }, "timeline");
     for await (const event of applyTextTransforms(timeline(), {
       parseThinkTags,
       stripToolDialect
@@ -1383,6 +1688,7 @@ async function* streamSdkAgent(rt, compiled, sdkTools, opts) {
     await agent.dispose();
   }
 }
+__name(streamSdkAgent, "streamSdkAgent");
 function toAgentFactory(def, opts) {
   const overrides = opts.overrides ?? {};
   const projectPerSession = resolveProjection(def, overrides);
@@ -1390,9 +1696,7 @@ function toAgentFactory(def, opts) {
     const { compiled, model, reasoningEffort, runContext } = await projectPerSession(sessionId);
     const rt = await loadSdkRuntime();
     if (!rt) {
-      throw new Error(
-        "[@theokit/agents] @theokit/sdk is not installed \u2014 run: pnpm add @theokit/sdk"
-      );
+      throw new Error("[@theokit/agents] @theokit/sdk is not installed \u2014 run: pnpm add @theokit/sdk");
     }
     const sdkTools = buildSdkTools(compiled.tools, rt.defineTool, overrides.sdkTools, runContext);
     const inlineSkills = compiled.skills?.inline;
@@ -1400,8 +1704,14 @@ function toAgentFactory(def, opts) {
       sdkTools.push(rt.defineSkillReadTool(inlineSkills));
     }
     const { options: m8 } = assembleM8CreateOptions(compiled);
-    if (overrides.cwd !== void 0) m8.local = { ...m8.local, cwd: overrides.cwd };
-    if (overrides.baseDir !== void 0) m8.local = { ...m8.local, baseDir: overrides.baseDir };
+    if (overrides.cwd !== void 0) m8.local = {
+      ...m8.local,
+      cwd: overrides.cwd
+    };
+    if (overrides.baseDir !== void 0) m8.local = {
+      ...m8.local,
+      baseDir: overrides.baseDir
+    };
     const extra = buildExtraCreateOptions(overrides, compiled);
     applyPosture(extra, m8, opts.approvals, compiled.hitl);
     const agent = await rt.Agent.getOrCreate(sessionId, {
@@ -1414,37 +1724,53 @@ function toAgentFactory(def, opts) {
     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: () => handle.dispose(),
-    send: async (msg, sendOpts) => {
+    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: async () => {
+        wait: /* @__PURE__ */ __name(async () => {
           const out = await turn.wait();
           if (out.result === void 0) return out;
-          return { ...out, result: await runOutputGuards(out.result, guardrails) };
-        }
+          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":
-      return { type: "text", text: e.content };
+      return {
+        type: "text",
+        text: e.content
+      };
     case "thinking":
-      return { type: "reasoning", text: e.content };
+      return {
+        type: "reasoning",
+        text: e.content
+      };
     case "tool_call":
-      return { type: "tool-call", callId: e.callId, name: e.toolName, input: e.input };
+      return {
+        type: "tool-call",
+        callId: e.callId,
+        name: e.toolName,
+        input: e.input
+      };
     case "tool_result":
       return {
         type: "tool-result",
@@ -1457,20 +1783,40 @@ function toAgentOutputEvent(e) {
       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 };
+  return event.cost === void 0 ? {
+    usage: event.usage,
+    durationMs: event.durationMs
+  } : {
+    usage: event.usage,
+    durationMs: event.durationMs,
+    cost: event.cost
+  };
 }
+__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 };
+  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 };
+  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":
@@ -1483,21 +1829,34 @@ function diagnosticDataPart(event) {
     // 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 });
+      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 } : {}
+        ...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 });
+      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 });
-  yield { type: "start" };
+  const presenter = new UIMessageStreamPresenter({
+    textId: opts.textId
+  });
+  yield {
+    type: "start"
+  };
   let turnMetadata;
   try {
     for await (const event of events) {
@@ -1518,7 +1877,11 @@ async function* presentUIMessageStream(events, opts) {
             dynamic: true
           };
         }
-        yield { type: "tool-approval-request", approvalId: event.callId, toolCallId: event.callId };
+        yield {
+          type: "tool-approval-request",
+          approvalId: event.callId,
+          toolCallId: event.callId
+        };
         continue;
       }
       const diagnostic = diagnosticDataPart(event);
@@ -1542,46 +1905,105 @@ async function* presentUIMessageStream(events, opts) {
   }
   yield* presenter.finish(turnMetadata);
 }
+__name(presentUIMessageStream, "presentUIMessageStream");
 
 // src/bridge/agent-builder.ts
 var ContextualTool = {
   /**
-   * Tag a {@link CustomTool} with a literal name (so `.tool()` can accumulate the tool-name union)
-   * and, optionally, a required run-context type. The `requiredContext` argument is a type-only
-   * witness — pass `undefined as C` or a sample value; it is never read at runtime.
-   */
+  * Tag a {@link CustomTool} with a literal name (so `.tool()` can accumulate the tool-name union)
+  * and, optionally, a required run-context type. The `requiredContext` argument is a type-only
+  * witness — pass `undefined as C` or a sample value; it is never read at runtime.
+  */
   of(tool, _requiredContext) {
     return tool;
   }
 };
 function makeBuilder(config) {
   const runtime = {
-    input: (schema) => makeBuilder({ ...config, input: schema }),
-    model: (id) => makeBuilder({ ...config, model: id }),
-    system: (prompt) => makeBuilder({ ...config, system: prompt }),
-    reasoningEffort: (effort) => makeBuilder({ ...config, reasoningEffort: effort }),
-    context: (value) => makeBuilder({ ...config, context: value }),
-    tool: (tool) => makeBuilder({ ...config, tools: [...config.tools ?? [], tool] }),
-    guardrail: (g) => makeBuilder({ ...config, guardrails: [...config.guardrails ?? [], g] }),
-    guardrails: (gs) => makeBuilder({ ...config, guardrails: gs }),
-    approval: (toolName, options) => makeBuilder({ ...config, approvals: { ...config.approvals ?? {}, [toolName]: options } }),
-    approvals: (map) => makeBuilder({ ...config, approvals: map }),
-    skills: (selection) => makeBuilder({ ...config, skills: selection }),
-    settingSources: (sources) => makeBuilder({ ...config, settingSources: sources }),
-    memory: (settings) => makeBuilder({ ...config, memory: settings }),
-    hooks: (map) => makeBuilder({ ...config, hooks: map }),
-    plugins: (list) => makeBuilder({ ...config, plugins: list }),
-    mcp: (servers) => makeBuilder({ ...config, mcpServers: servers }),
-    use: (preset) => preset(runtime),
-    build: () => defineAgent(config)
+    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"),
+    guardrail: /* @__PURE__ */ __name((g) => makeBuilder({
+      ...config,
+      guardrails: [
+        ...config.guardrails ?? [],
+        g
+      ]
+    }), "guardrail"),
+    guardrails: /* @__PURE__ */ __name((gs) => makeBuilder({
+      ...config,
+      guardrails: gs
+    }), "guardrails"),
+    approval: /* @__PURE__ */ __name((toolName, options) => makeBuilder({
+      ...config,
+      approvals: {
+        ...config.approvals ?? {},
+        [toolName]: options
+      }
+    }), "approval"),
+    approvals: /* @__PURE__ */ __name((map) => makeBuilder({
+      ...config,
+      approvals: map
+    }), "approvals"),
+    skills: /* @__PURE__ */ __name((selection) => makeBuilder({
+      ...config,
+      skills: selection
+    }), "skills"),
+    settingSources: /* @__PURE__ */ __name((sources) => makeBuilder({
+      ...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
+    }), "plugins"),
+    mcp: /* @__PURE__ */ __name((servers) => makeBuilder({
+      ...config,
+      mcpServers: servers
+    }), "mcp"),
+    use: /* @__PURE__ */ __name((preset) => preset(runtime), "use"),
+    build: /* @__PURE__ */ __name(() => defineAgent(config), "build")
   };
   return runtime;
 }
+__name(makeBuilder, "makeBuilder");
 var AgentBuilder = {
   /**
-   * Start a fluent agent definition. Chain `.model()` (required) + `.context()` / `.system()` /
-   * `.input()` / `.tool()` / `.use()`, then `.build()` to get the branded {@link AgentDefinition}.
-   */
+  * Start a fluent agent definition. Chain `.model()` (required) + `.context()` / `.system()` /
+  * `.input()` / `.tool()` / `.use()`, then `.build()` to get the branded {@link AgentDefinition}.
+  */
   create() {
     return makeBuilder({});
   }
@@ -1589,10 +2011,11 @@ var AgentBuilder = {
 
 // src/bridge/agent-endpoint.ts
 var AgentDefinitionError = class extends Error {
+  static {
+    __name(this, "AgentDefinitionError");
+  }
   constructor(source) {
-    super(
-      `[@theokit/agents] ${source}: an agents/ file must default-export a defineAgent(...) value or an @Agent-decorated class.`
-    );
+    super(`[@theokit/agents] ${source}: an agents/ file must default-export a defineAgent(...) value or an @Agent-decorated class.`);
     this.name = "AgentDefinitionError";
   }
 };
@@ -1602,11 +2025,13 @@ function extractDefaultExport(mod) {
   }
   return mod;
 }
+__name(extractDefaultExport, "extractDefaultExport");
 function isCompiledAgentOptions(value) {
   if (typeof value !== "object" || value === null) return false;
   const v = value;
   return Array.isArray(v.tools) && typeof v.agents === "object" && v.agents !== null;
 }
+__name(isCompiledAgentOptions, "isCompiledAgentOptions");
 function compileAgentModule(mod, source = "agent module") {
   const def = extractDefaultExport(mod);
   if (isAgentDefinition(def)) {
@@ -1615,22 +2040,33 @@ function compileAgentModule(mod, source = "agent module") {
   if (isCompiledAgentOptions(def)) return def;
   throw new AgentDefinitionError(source);
 }
+__name(compileAgentModule, "compileAgentModule");
 async function* asAgentStream(events) {
   for await (const e of events) yield e;
 }
-var EventQueue = class {
+__name(asAgentStream, "asAgentStream");
+var EventQueue = class EventQueue2 {
+  static {
+    __name(this, "EventQueue");
+  }
   #items = [];
   #resolvers = [];
   #closed = false;
   push(item) {
     if (this.#closed) return;
     const r = this.#resolvers.shift();
-    if (r) r({ value: item, done: false });
+    if (r) r({
+      value: item,
+      done: false
+    });
     else this.#items.push(item);
   }
   close() {
     this.#closed = true;
-    for (const r of this.#resolvers.splice(0)) r({ value: void 0, done: true });
+    for (const r of this.#resolvers.splice(0)) r({
+      value: void 0,
+      done: true
+    });
   }
   async *drain() {
     for (; ; ) {
@@ -1647,12 +2083,12 @@ var EventQueue = class {
 };
 async function* appendCheckpointSaved(source, sessionId) {
   let emitted = false;
-  const checkpoint = () => ({
+  const checkpoint = /* @__PURE__ */ __name(() => ({
     type: "checkpoint_saved",
     checkpointId: crypto.randomUUID(),
     step: 0,
     resumeToken: sessionId
-  });
+  }), "checkpoint");
   for await (const ev of source) {
     if (ev.type === "done" && !emitted) {
       emitted = true;
@@ -1662,6 +2098,7 @@ async function* appendCheckpointSaved(source, sessionId) {
   }
   if (!emitted) yield checkpoint();
 }
+__name(appendCheckpointSaved, "appendCheckpointSaved");
 function streamAgentUIMessages(compiled, apiKey, input) {
   const textId = crypto.randomUUID();
   const overrides = {};
@@ -1671,34 +2108,29 @@ function streamAgentUIMessages(compiled, apiKey, input) {
   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);
+    const events2 = createSdkAgentStream(compiled, compiled.tools, apiKey, overrides)(input.message, input.sessionId);
     source = asAgentStream(events2);
   } else {
     const queue = new EventQueue();
-    input.signal?.addEventListener(
-      "abort",
-      () => {
-        queue.close();
-      },
-      { once: true }
-    );
+    input.signal?.addEventListener("abort", () => {
+      queue.close();
+    }, {
+      once: true
+    });
     const plugin = createHitlPlugin({
       gated: input.hitl.gated,
-      emit: (e) => {
+      emit: /* @__PURE__ */ __name((e) => {
         queue.push(e);
-      },
+      }, "emit"),
       awaitApproval: input.hitl.awaitApproval
     });
     const sdkStream = createSdkAgentStream(compiled, compiled.tools, apiKey, {
       ...overrides,
       // The HITL plugin is a structural @theokit/sdk Plugin (createHitlPlugin returns the
       // { name, register } shape); the RuntimeOverrides.plugins union is widened at the SDK edge.
-      plugins: [plugin]
+      plugins: [
+        plugin
+      ]
     })(input.message, input.sessionId);
     void (async () => {
       try {
@@ -1718,8 +2150,11 @@ function streamAgentUIMessages(compiled, apiKey, input) {
   }
   const durableCheckpoint = compiled.checkpoint?.storage === "filesystem";
   const events = durableCheckpoint ? appendCheckpointSaved(source, input.sessionId) : source;
-  return presentUIMessageStream(events, { textId });
+  return presentUIMessageStream(events, {
+    textId
+  });
 }
+__name(streamAgentUIMessages, "streamAgentUIMessages");
 
 // src/loop/compaction-strategy.ts
 import { compactTranscript } from "@theokit/sdk/compaction";
@@ -1730,56 +2165,73 @@ var compactionStrategyConfigSchema = z.object({
   keepTokens: z.number().int().positive()
 });
 function resolveCompactionStrategy(name, config) {
-  const cfg = compactionStrategyConfigSchema.parse({ name, keepTokens: config.keepTokens });
+  const cfg = compactionStrategyConfigSchema.parse({
+    name,
+    keepTokens: config.keepTokens
+  });
   return {
     name: cfg.name,
     keepTokens: cfg.keepTokens,
-    compact: (messages, options) => compactTranscript(messages, {
+    compact: /* @__PURE__ */ __name((messages, options) => compactTranscript(messages, {
       keepTokens: options?.keepTokens ?? cfg.keepTokens,
       summarize: options?.summarize,
       marker: options?.marker,
       summaryTemplate: options?.summaryTemplate,
       // Default-safe: a thrown summarize keeps the transcript (app opts out via failSafe:false).
       failSafe: options?.failSafe ?? true
-    })
+    }), "compact")
   };
 }
-var tokenBudgetCompactionStrategy = resolveCompactionStrategy("token-budget", { keepTokens: DEFAULT_KEEP_TOKENS });
+__name(resolveCompactionStrategy, "resolveCompactionStrategy");
+var tokenBudgetCompactionStrategy = resolveCompactionStrategy("token-budget", {
+  keepTokens: DEFAULT_KEEP_TOKENS
+});
 
 // src/loop/loop-strategy.ts
 import { z as z2 } from "zod";
 var DEFAULT_MAX_ITERATIONS = 8;
 var maxIterationsSchema = z2.number().int().min(1);
 var loopStrategyConfigSchema = z2.object({
-  name: z2.enum(["simple-chat", "plan-act-reflect", "react"]),
+  name: z2.enum([
+    "simple-chat",
+    "plan-act-reflect",
+    "react"
+  ]),
   maxIterations: maxIterationsSchema
 });
 function assertValidCustomLoopStrategy(strategy) {
   const result = maxIterationsSchema.safeParse(strategy.maxIterations);
   if (!result.success) {
-    throw new Error(
-      `loopStrategy: invalid maxIterations (${String(strategy.maxIterations)}) \u2014 must be a finite integer \u2265 1 (otherwise the round < maxIterations ceiling never terminates)`
-    );
+    throw new Error(`loopStrategy: invalid maxIterations (${String(strategy.maxIterations)}) \u2014 must be a finite integer \u2265 1 (otherwise the round < maxIterations ceiling never terminates)`);
   }
 }
+__name(assertValidCustomLoopStrategy, "assertValidCustomLoopStrategy");
 function resolveLoopStrategy(strategy, maxIterations = DEFAULT_MAX_ITERATIONS) {
-  const cfg = loopStrategyConfigSchema.parse({ name: strategy, maxIterations });
+  const cfg = loopStrategyConfigSchema.parse({
+    name: strategy,
+    maxIterations
+  });
   if (cfg.name === "simple-chat") {
-    return { name: cfg.name, maxIterations: cfg.maxIterations, shouldContinue: () => false };
+    return {
+      name: cfg.name,
+      maxIterations: cfg.maxIterations,
+      shouldContinue: /* @__PURE__ */ __name(() => false, "shouldContinue")
+    };
   }
   if (cfg.name === "plan-act-reflect") {
     return {
       name: cfg.name,
       maxIterations: cfg.maxIterations,
-      shouldContinue: (outcome) => outcome.round < cfg.maxIterations
+      shouldContinue: /* @__PURE__ */ __name((outcome) => outcome.round < cfg.maxIterations, "shouldContinue")
     };
   }
   return {
     name: cfg.name,
     maxIterations: cfg.maxIterations,
-    shouldContinue: (outcome) => outcome.finishReason === "tool-calls" && outcome.round < cfg.maxIterations
+    shouldContinue: /* @__PURE__ */ __name((outcome) => outcome.finishReason === "tool-calls" && outcome.round < cfg.maxIterations, "shouldContinue")
   };
 }
+__name(resolveLoopStrategy, "resolveLoopStrategy");
 
 // src/loop/reflection-strategy.ts
 import { z as z3 } from "zod";
@@ -1795,52 +2247,55 @@ var ladderReflectionStrategy = {
         continue: true
       };
     }
-    return { continue: false };
+    return {
+      continue: false
+    };
   }
 };
 var noopReflectionStrategy = {
   name: "noop",
   reflect() {
-    return { continue: true };
+    return {
+      continue: true
+    };
   }
 };
 
 // src/bridge/delegation-types.ts
 var DelegationBudgetExceededError = class extends Error {
-  constructor(agentName, actualCost, budgetLimit) {
-    super(
-      `Agent "${agentName}" exceeded budget: $${actualCost.toFixed(4)} > $${budgetLimit.toFixed(4)}`
-    );
-    this.agentName = agentName;
-    this.actualCost = actualCost;
-    this.budgetLimit = budgetLimit;
-    this.name = "DelegationBudgetExceededError";
+  static {
+    __name(this, "DelegationBudgetExceededError");
   }
   agentName;
   actualCost;
   budgetLimit;
+  constructor(agentName, actualCost, budgetLimit) {
+    super(`Agent "${agentName}" exceeded budget: $${actualCost.toFixed(4)} > $${budgetLimit.toFixed(4)}`), this.agentName = agentName, this.actualCost = actualCost, this.budgetLimit = budgetLimit;
+    this.name = "DelegationBudgetExceededError";
+  }
 };
 var BudgetExceededError = DelegationBudgetExceededError;
 var DelegationError = class extends Error {
-  constructor(agentName, cause) {
-    super(
-      `Delegation to agent "${agentName}" failed: ${cause instanceof Error ? cause.message : String(cause)}`
-    );
-    this.agentName = agentName;
-    this.cause = cause;
-    this.name = "DelegationError";
+  static {
+    __name(this, "DelegationError");
   }
   agentName;
   cause;
+  constructor(agentName, cause) {
+    super(`Delegation to agent "${agentName}" failed: ${cause instanceof Error ? cause.message : String(cause)}`), this.agentName = agentName, this.cause = cause;
+    this.name = "DelegationError";
+  }
 };
 
 // src/loop/run-reflective-loop.ts
 function asString2(value, fallback) {
   return typeof value === "string" ? value : fallback;
 }
+__name(asString2, "asString");
 function asNumber(value, fallback) {
   return typeof value === "number" ? value : fallback;
 }
+__name(asNumber, "asNumber");
 var NO_PROGRESS_THRESHOLD = 2;
 var MAINLOOP_METRIC = "[THEO_AGENT_MAINLOOP_RUNTIME_APPLIED]";
 var TOOL_CALLS = "tool-calls";
@@ -1853,15 +2308,17 @@ function stableStringify(value) {
   const entries = Object.keys(obj).sort((a, b) => a.localeCompare(b)).map((k) => `${JSON.stringify(k)}:${stableStringify(obj[k])}`);
   return `{${entries.join(",")}}`;
 }
+__name(stableStringify, "stableStringify");
 function roundSignature(toolCalls) {
   return toolCalls.map((tc) => `${tc.name}:${stableStringify(tc.input)}`).sort((a, b) => a.localeCompare(b)).join(",");
 }
+__name(roundSignature, "roundSignature");
 function terminalReason(reflectionContinue, roundReason, round, maxIterations) {
-  if (reflectionContinue && roundReason === TOOL_CALLS && round >= maxIterations)
-    return "step_limit";
+  if (reflectionContinue && roundReason === TOOL_CALLS && round >= maxIterations) return "step_limit";
   if (roundReason === TOOL_CALLS) return "stop";
   return roundReason;
 }
+__name(terminalReason, "terminalReason");
 var CONTINUE_PROMPT = "Continue from the prior turns above; finish the task and give a final answer.";
 function buildPrompt(round, maxIterations, message, feedback) {
   const hint = round === maxIterations ? `${STEP_LIMIT_HINT}
@@ -1871,20 +2328,16 @@ function buildPrompt(round, maxIterations, message, feedback) {
   const body = round === 1 ? message : continuation;
   return hint + body;
 }
+__name(buildPrompt, "buildPrompt");
 async function* consumeRoundOrThrow(inputs, agentName) {
   try {
-    return yield* consumeOneRound(
-      inputs.factory,
-      inputs.prompt,
-      inputs.sessionId,
-      inputs.signal,
-      inputs.retry
-    );
+    return yield* consumeOneRound(inputs.factory, inputs.prompt, inputs.sessionId, inputs.signal, inputs.retry);
   } catch (err) {
     if (err instanceof DelegationBudgetExceededError || err instanceof DelegationError) throw err;
     throw new DelegationError(agentName, err);
   }
 }
+__name(consumeRoundOrThrow, "consumeRoundOrThrow");
 function accumulateUsage(acc, r) {
   acc.cost += r.cost;
   acc.tokens += r.tokens;
@@ -1894,18 +2347,25 @@ function accumulateUsage(acc, r) {
   acc.cacheReadTokens = (acc.cacheReadTokens ?? 0) + r.cacheReadTokens;
   acc.cacheWriteTokens = (acc.cacheWriteTokens ?? 0) + r.cacheWriteTokens;
 }
+__name(accumulateUsage, "accumulateUsage");
 function finalize(acc, round, reason, strategyName) {
   acc.rounds = round;
   acc.finishReason = reason;
-  debugLog(MAINLOOP_METRIC, { strategy: strategyName, rounds: round, terminal: reason });
+  debugLog(MAINLOOP_METRIC, {
+    strategy: strategyName,
+    rounds: round,
+    terminal: reason
+  });
   return acc;
 }
+__name(finalize, "finalize");
 function deriveFinishReason(signals) {
   if (signals.sawError) return "error";
   if (signals.sawDone && signals.doneFinishReason === TOOL_CALLS) return TOOL_CALLS;
   if (signals.sawToolResult) return TOOL_CALLS;
   return "stop";
 }
+__name(deriveFinishReason, "deriveFinishReason");
 function pushToolResult(event, r, callInputs) {
   const id = asString2(event.callId, "");
   const call = callInputs.get(id);
@@ -1918,6 +2378,7 @@ function pushToolResult(event, r, callInputs) {
     output: asString2(event.output, "")
   });
 }
+__name(pushToolResult, "pushToolResult");
 function applyDone(event, r) {
   r.cost = asNumber(event.cost, 0);
   const usage = event.usage;
@@ -1928,6 +2389,7 @@ function applyDone(event, r) {
   r.cacheReadTokens = usage?.cacheReadTokens ?? 0;
   r.cacheWriteTokens = usage?.cacheWriteTokens ?? 0;
 }
+__name(applyDone, "applyDone");
 function accumulateEvent(event, r, signals, callInputs) {
   if (event.type === "text_delta" && typeof event.content === "string") {
     r.responseText += event.content;
@@ -1948,20 +2410,28 @@ function accumulateEvent(event, r, signals, callInputs) {
     r.errorMessage = asString2(event.message, "Unknown agent error");
   }
 }
+__name(accumulateEvent, "accumulateEvent");
 async function startRound(factory, prompt, sessionId, signal, retry) {
-  const open = async () => {
+  const open = /* @__PURE__ */ __name(async () => {
     const it = factory(prompt, sessionId)[Symbol.asyncIterator]();
     try {
-      return { it, first: await it.next() };
+      return {
+        it,
+        first: await it.next()
+      };
     } catch (err) {
       await it.return?.(void 0);
       throw err;
     }
-  };
+  }, "open");
   if (!retry) return open();
   const { Retry } = await import("@theokit/sdk/retry");
-  return Retry.create(open, { ...retry, signal: retry.signal ?? signal });
+  return Retry.create(open, {
+    ...retry,
+    signal: retry.signal ?? signal
+  });
 }
+__name(startRound, "startRound");
 async function* consumeOneRound(factory, prompt, sessionId, signal, retry) {
   const r = {
     responseText: "",
@@ -1997,19 +2467,16 @@ async function* consumeOneRound(factory, prompt, sessionId, signal, retry) {
   r.finishReason = deriveFinishReason(signals);
   return r;
 }
+__name(consumeOneRound, "consumeOneRound");
 function ceilingRoundFactory(factory, round, maxIterations) {
   if (round !== maxIterations) return factory;
-  return (m, s) => factory(m, s, { disableTools: true });
+  return (m, s) => factory(m, s, {
+    disableTools: true
+  });
 }
+__name(ceilingRoundFactory, "ceilingRoundFactory");
 async function* runReflectiveLoopStream(factory, message, sessionId, config) {
-  const {
-    loop,
-    reflection,
-    budget = Number.POSITIVE_INFINITY,
-    signal,
-    agentName = loop.name,
-    retry
-  } = config;
+  const { loop, reflection, budget = Number.POSITIVE_INFINITY, signal, agentName = loop.name, retry } = config;
   const acc = {
     response: "",
     toolCalls: [],
@@ -2030,10 +2497,13 @@ async function* runReflectiveLoopStream(factory, message, sessionId, config) {
   while (!signal?.aborted) {
     const prompt = buildPrompt(round, loop.maxIterations, message, feedback);
     const roundFactory = ceilingRoundFactory(factory, round, loop.maxIterations);
-    const r = yield* consumeRoundOrThrow(
-      { factory: roundFactory, prompt, sessionId, signal, retry },
-      agentName
-    );
+    const r = yield* consumeRoundOrThrow({
+      factory: roundFactory,
+      prompt,
+      sessionId,
+      signal,
+      retry
+    }, agentName);
     acc.response += r.responseText;
     acc.toolCalls.push(...r.toolCalls);
     accumulateUsage(acc, r);
@@ -2055,12 +2525,7 @@ async function* runReflectiveLoopStream(factory, message, sessionId, config) {
     };
     const reflectionResult = reflection.reflect(outcome, reflectionContext);
     if (!(reflectionResult.continue && loop.shouldContinue(outcome) && round < loop.maxIterations)) {
-      const reason = terminalReason(
-        reflectionResult.continue,
-        r.finishReason,
-        round,
-        loop.maxIterations
-      );
+      const reason = terminalReason(reflectionResult.continue, r.finishReason, round, loop.maxIterations);
       return finalize(acc, round, reason, loop.name);
     }
     feedback = reflectionResult.feedback;
@@ -2069,15 +2534,20 @@ async function* runReflectiveLoopStream(factory, message, sessionId, config) {
   acc.rounds = round - 1;
   return acc;
 }
+__name(runReflectiveLoopStream, "runReflectiveLoopStream");
 async function runReflectiveLoop(factory, message, sessionId, config) {
   const gen = runReflectiveLoopStream(factory, message, sessionId, config);
   let res = await gen.next();
   while (!res.done) res = await gen.next();
   return res.value;
 }
+__name(runReflectiveLoop, "runReflectiveLoop");
 
 // src/loop/agent-runner.ts
 var AgentRunner = class {
+  static {
+    __name(this, "AgentRunner");
+  }
   compiled;
   agentName;
   /** The resolved terminal-decision strategy (parity with `delegate()`). */
@@ -2087,18 +2557,18 @@ var AgentRunner = class {
   /** The resolved between-round reflection (default or `.reflection(custom)` override). */
   reflectionStrategy;
   /**
-   * Recorded streaming preference. The reflective loop currently always streams via
-   * the SDK `Run.stream()`; a non-streaming collect mode is future work — the flag is
-   * captured + exposed here, not yet branched on (honest per G10: documented, not a
-   * silent no-op).
-   */
+  * Recorded streaming preference. The reflective loop currently always streams via
+  * the SDK `Run.stream()`; a non-streaming collect mode is future work — the flag is
+  * captured + exposed here, not yet branched on (honest per G10: documented, not a
+  * silent no-op).
+  */
   streamEnabled;
   /**
-   * V4-F: the resolved compaction strategy (from `@Compaction` or `.compaction()`),
-   * or `undefined` when neither is declared — compaction is opt-in (EC-4). CALLABLE
-   * by the app (ADR D1: `runner.compaction?.compact(messages, { summarize })`); the
-   * reflective loop does NOT auto-invoke it (the SDK owns per-turn context).
-   */
+  * V4-F: the resolved compaction strategy (from `@Compaction` or `.compaction()`),
+  * or `undefined` when neither is declared — compaction is opt-in (EC-4). CALLABLE
+  * by the app (ADR D1: `runner.compaction?.compact(messages, { summarize })`); the
+  * reflective loop does NOT auto-invoke it (the SDK owns per-turn context).
+  */
   compaction;
   constructor(state) {
     this.compiled = state.compiled;
@@ -2114,41 +2584,35 @@ var AgentRunner = class {
     return new AgentRunnerBuilder(spec);
   }
   /**
-   * V4-D-stream: stream the agent's events LIVE across the reflective loop, returning
-   * the aggregated {@link DelegationResult} as the generator's return value. This is the
-   * on-ramp for streaming-first apps (SSE) — `runReflectiveLoopStream` yields every
-   * round's events before the loop terminates. `streamEnabled` is honored: when the
-   * builder set `.stream(false)`, callers should use {@link run} instead.
-   */
+  * V4-D-stream: stream the agent's events LIVE across the reflective loop, returning
+  * the aggregated {@link DelegationResult} as the generator's return value. This is the
+  * on-ramp for streaming-first apps (SSE) — `runReflectiveLoopStream` yields every
+  * round's events before the loop terminates. `streamEnabled` is honored: when the
+  * 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 = (m) => this.streamUnguarded(m, opts);
-      return (async function* guarded() {
+      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
-        );
-      })();
+        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;
+    const tools = opts.tools ? [
+      ...opts.tools
+    ] : this.compiled.tools;
     const loop = this.resolvePerRunLoop(opts.maxIterations);
     const streamFactory = opts.streamFactory ?? createSdkAgentStream(this.compiled, tools, opts.apiKey, {
       model: opts.model,
       reasoningEffort: opts.reasoningEffort,
-      // M1: per-run extended-thinking effort
       parseThinkTags: opts.parseThinkTags,
-      // M2: per-run <think>-tag extraction opt-in
       stripToolDialect: opts.stripToolDialect,
-      // theocode#32: per-run tool-dialect strip opt-in
       recoverLeakedToolCalls: opts.recoverLeakedToolCalls,
-      // theokit#58: per-run leaked-dialect recovery opt-in
       cwd: opts.cwd,
       baseDir: opts.baseDir,
       plugins: opts.plugins,
@@ -2156,7 +2620,6 @@ var AgentRunner = class {
       agents: opts.agents,
       budgetTracker: opts.budgetTracker,
       sdkTools: opts.sdkTools
-      // V4-Q: pre-built SDK tools forwarded raw
     });
     const sessionId = opts.sessionId ?? `runner-${crypto.randomUUID()}`;
     return runReflectiveLoopStream(streamFactory, message, sessionId, {
@@ -2166,17 +2629,16 @@ var AgentRunner = class {
       agentName: this.agentName,
       signal: opts.signal,
       retry: opts.retry
-      // V4-P: per-round transient retry (opt-in)
     });
   }
   /** Run the agent to a terminal result via the shared reflective loop (collect mode). */
   /**
-   * Apply a per-call `maxIterations` override (M54 D4). A custom strategy must NOT be re-resolved by
-   * name — its name is outside the `z.enum`, which would throw — and its `shouldContinue` closure
-   * must survive; since the runner enforces the ceiling via `round < loop.maxIterations` (T1.1),
-   * overriding just that field bounds a custom without touching its logic. A built-in keeps the
-   * by-name re-resolution (zod fail-loud on `< 1`) — unchanged, zero-behavior.
-   */
+  * Apply a per-call `maxIterations` override (M54 D4). A custom strategy must NOT be re-resolved by
+  * name — its name is outside the `z.enum`, which would throw — and its `shouldContinue` closure
+  * must survive; since the runner enforces the ceiling via `round < loop.maxIterations` (T1.1),
+  * overriding just that field bounds a custom without touching its logic. A built-in keeps the
+  * by-name re-resolution (zod fail-loud on `< 1`) — unchanged, zero-behavior.
+  */
   resolvePerRunLoop(maxIterations) {
     if (maxIterations == null) return this.loopStrategy;
     if (this.loopStrategyIsCustom) {
@@ -2195,37 +2657,40 @@ var AgentRunner = class {
   }
 };
 var AgentRunnerBuilder = class {
-  constructor(spec) {
-    this.spec = spec;
+  static {
+    __name(this, "AgentRunnerBuilder");
   }
   spec;
   reflectionOverride;
   streamEnabled = true;
   compactionOverride;
   loopStrategyOverride;
+  constructor(spec) {
+    this.spec = spec;
+  }
   /** Override the default reflection strategy (OCP — plan Drawback #2). No arg ⇒ keep default. */
   reflection(strategy) {
     if (strategy) this.reflectionOverride = strategy;
     return this;
   }
   /**
-   * M54 — inject a custom terminal-decision strategy (the fourth OCP axis, alongside
-   * `.reflection()`/`.compaction()`/`streamFactory`). WINS over the strategy the spec's name would
-   * resolve to, exactly as `.compaction()` outranks the spec. The runner caps ANY strategy at
-   * `custom.maxIterations` (T1.1), so a `shouldContinue: () => true` still terminates — never an
-   * infinite loop.
-   *
-   * @example
-   * ```ts
-   * // Stop as soon as the confidence in the last round crosses 0.9, else run to the ceiling.
-   * const stopWhenConfident: LoopStrategy = {
-   *   name: 'confident',
-   *   maxIterations: 8,
-   *   shouldContinue: (o) => !o.responseText.includes('confidence: high'),
-   * }
-   * AgentRunner.fromSpec(spec).loopStrategy(stopWhenConfident).build()
-   * ```
-   */
+  * M54 — inject a custom terminal-decision strategy (the fourth OCP axis, alongside
+  * `.reflection()`/`.compaction()`/`streamFactory`). WINS over the strategy the spec's name would
+  * resolve to, exactly as `.compaction()` outranks the spec. The runner caps ANY strategy at
+  * `custom.maxIterations` (T1.1), so a `shouldContinue: () => true` still terminates — never an
+  * infinite loop.
+  *
+  * @example
+  * ```ts
+  * // Stop as soon as the confidence in the last round crosses 0.9, else run to the ceiling.
+  * const stopWhenConfident: LoopStrategy = {
+  *   name: 'confident',
+  *   maxIterations: 8,
+  *   shouldContinue: (o) => !o.responseText.includes('confidence: high'),
+  * }
+  * AgentRunner.fromSpec(spec).loopStrategy(stopWhenConfident).build()
+  * ```
+  */
   loopStrategy(custom) {
     assertValidCustomLoopStrategy(custom);
     this.loopStrategyOverride = custom;
@@ -2237,12 +2702,15 @@ var AgentRunnerBuilder = class {
     return this;
   }
   /**
-   * V4-F: declare the compaction strategy (e.g. `.compaction('token-budget', { keepTokens: 8000 })`).
-   * Resolved + validated at {@link build} (EC-5 — fail-fast there, not here). This builder
-   * call WINS over a `@Compaction` decorator on the same agent (EC-1 — explicit override).
-   */
+  * V4-F: declare the compaction strategy (e.g. `.compaction('token-budget', { keepTokens: 8000 })`).
+  * Resolved + validated at {@link build} (EC-5 — fail-fast there, not here). This builder
+  * call WINS over a `@Compaction` decorator on the same agent (EC-1 — explicit override).
+  */
   compaction(name, options = {}) {
-    this.compactionOverride = { name, keepTokens: options.keepTokens };
+    this.compactionOverride = {
+      name,
+      keepTokens: options.keepTokens
+    };
     return this;
   }
   /** Resolve strategies from the spec — the compile→execute boundary (no I/O). */
@@ -2253,7 +2721,9 @@ var AgentRunnerBuilder = class {
     const loopStrategy = this.loopStrategyOverride ?? resolveLoopStrategy(strategy, spec.maxIterations);
     const reflectionStrategy = this.reflectionOverride ?? (strategy === "plan-act-reflect" ? ladderReflectionStrategy : noopReflectionStrategy);
     const compactionDecl = this.compactionOverride ?? spec.compaction;
-    const compaction = compactionDecl ? resolveCompactionStrategy(compactionDecl.name, { keepTokens: compactionDecl.keepTokens }) : void 0;
+    const compaction = compactionDecl ? resolveCompactionStrategy(compactionDecl.name, {
+      keepTokens: compactionDecl.keepTokens
+    }) : void 0;
     return new AgentRunner({
       compiled: spec.compiled,
       agentName: spec.name,
@@ -2270,15 +2740,18 @@ var AgentRunnerBuilder = class {
 import { runGoalLoop } from "@theokit/sdk";
 import { JudgeCredentialError } from "@theokit/sdk";
 var GoalRunner = class {
+  static {
+    __name(this, "GoalRunner");
+  }
+  agent;
   constructor(agent) {
     this.agent = agent;
   }
-  agent;
   /**
-   * Drive `goal` to completion against the bound agent. Returns the SAME async generator `runGoalLoop`
-   * returns — yielding `GoalEvent`s, resolving a `GoalResult`. `deps` (judge/clock overrides) threads
-   * straight through; a test seam for the judge lives there, exactly as on the free function.
-   */
+  * Drive `goal` to completion against the bound agent. Returns the SAME async generator `runGoalLoop`
+  * returns — yielding `GoalEvent`s, resolving a `GoalResult`. `deps` (judge/clock overrides) threads
+  * straight through; a test seam for the judge lives there, exactly as on the free function.
+  */
   run(goal, options, deps) {
     return runGoalLoop(this.agent, goal, options, deps);
   }
@@ -2292,14 +2765,22 @@ function requireApiKey(opts, agentName) {
   }
   return apiKey;
 }
+__name(requireApiKey, "requireApiKey");
 function mergeTools(parentTools, subTools) {
   const subToolNames = new Set(subTools.map((t) => t.name));
   const inherited = parentTools.filter((t) => !subToolNames.has(t.name));
-  return [...inherited, ...subTools];
+  return [
+    ...inherited,
+    ...subTools
+  ];
 }
+__name(mergeTools, "mergeTools");
 async function delegate(spec, message, opts = {}) {
   const apiKey = requireApiKey(opts, spec.name);
-  const effectiveMessage = opts.onDelegationStart ? await opts.onDelegationStart({ subAgent: spec.name, input: message }) : message;
+  const effectiveMessage = opts.onDelegationStart ? await opts.onDelegationStart({
+    subAgent: spec.name,
+    input: message
+  }) : message;
   const { compiled } = spec;
   const allTools = mergeTools(opts.parentTools ?? [], compiled.tools);
   const budget = Math.min(opts.budget ?? Infinity, opts.parentBudgetRemaining ?? Infinity);
@@ -2313,10 +2794,7 @@ async function delegate(spec, message, opts = {}) {
     sdkTools: opts.sdkTools
   });
   const sessionId = opts.sessionId ?? `sub-${crypto.randomUUID()}`;
-  const loopStrategy = resolveLoopStrategy(
-    spec.strategy ?? "simple-chat",
-    opts.maxIterations ?? spec.maxIterations
-  );
+  const loopStrategy = resolveLoopStrategy(spec.strategy ?? "simple-chat", opts.maxIterations ?? spec.maxIterations);
   const reflection = opts.reflection ?? (loopStrategy.name === "plan-act-reflect" ? ladderReflectionStrategy : noopReflectionStrategy);
   const result = await runReflectiveLoop(streamFactory, effectiveMessage, sessionId, {
     loop: loopStrategy,
@@ -2325,13 +2803,16 @@ async function delegate(spec, message, opts = {}) {
     agentName: spec.name,
     signal: opts.signal,
     retry: opts.retry
-    // V4-T: per-round transient retry (V4-P) on the delegate path
   });
   if (opts.onDelegationComplete) {
-    return await opts.onDelegationComplete({ subAgent: spec.name, result });
+    return await opts.onDelegationComplete({
+      subAgent: spec.name,
+      result
+    });
   }
   return result;
 }
+__name(delegate, "delegate");
 
 // src/bridge/api-error-handler.ts
 var DEFAULT_MAX_ATTEMPTS = 3;
@@ -2343,7 +2824,10 @@ async function runWithApiErrorHandling(thunk, policy) {
     try {
       return await thunk();
     } catch (error) {
-      const decision = await policy.processApiError({ error, attempt });
+      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;
@@ -2352,9 +2836,11 @@ async function runWithApiErrorHandling(thunk, policy) {
     }
   }
 }
+__name(runWithApiErrorHandling, "runWithApiErrorHandling");
 function createApiErrorHandler(policy) {
   return (thunk) => runWithApiErrorHandling(thunk, policy);
 }
+__name(createApiErrorHandler, "createApiErrorHandler");
 
 // src/bridge/delegation-scoring.ts
 function delegateBackground(subAgent, message, opts = {}) {
@@ -2365,24 +2851,20 @@ function delegateBackground(subAgent, message, opts = {}) {
   });
   promise.catch(() => void 0);
   return {
-    wait: () => promise,
-    settled: () => isSettled
+    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 { scorer, maxRounds: maxRoundsOpt = DEFAULT_MAX_ROUNDS, delegateFn = delegate, feedbackTemplate = defaultFeedbackTemplate, ...delegateOpts } = opts;
   const maxRounds = Math.max(1, maxRoundsOpt);
   const verdicts = [];
   let currentMessage = message;
@@ -2393,7 +2875,12 @@ async function delegateWithScoring(subAgent, message, opts) {
     const verdict = await scorer(result);
     verdicts.push(verdict);
     if (verdict.pass) {
-      return { result, rounds: round, passed: true, verdicts };
+      return {
+        result,
+        rounds: round,
+        passed: true,
+        verdicts
+      };
     }
     if (verdict.feedback) currentMessage = feedbackTemplate(message, verdict.feedback);
   }
@@ -2407,6 +2894,7 @@ async function delegateWithScoring(subAgent, message, opts) {
     verdicts
   };
 }
+__name(delegateWithScoring, "delegateWithScoring");
 
 // src/bridge/mcp-resolver.ts
 async function resolveMcpServers(selection, ctx) {
@@ -2418,6 +2906,7 @@ async function resolveMcpServers(selection, ctx) {
   }
   return resolved;
 }
+__name(resolveMcpServers, "resolveMcpServers");
 function mcpRegistry(config) {
   const registry = config.registry;
   if (registry === "composio") {
@@ -2425,8 +2914,17 @@ function mcpRegistry(config) {
     return {
       composio: {
         command: "npx",
-        args: ["-y", "@composio/mcp", ...apps.length > 0 ? ["--apps", apps.join(",")] : []],
-        env: { COMPOSIO_API_KEY: config.apiKey }
+        args: [
+          "-y",
+          "@composio/mcp",
+          ...apps.length > 0 ? [
+            "--apps",
+            apps.join(",")
+          ] : []
+        ],
+        env: {
+          COMPOSIO_API_KEY: config.apiKey
+        }
       }
     };
   }
@@ -2438,23 +2936,30 @@ function mcpRegistry(config) {
           "-y",
           "@mcp.run/cli",
           "serve",
-          ...config.profile ? ["--profile", config.profile] : []
+          ...config.profile ? [
+            "--profile",
+            config.profile
+          ] : []
         ],
-        env: { MCP_RUN_API_KEY: config.apiKey }
+        env: {
+          MCP_RUN_API_KEY: config.apiKey
+        }
       }
     };
   }
-  throw new Error(
-    `mcpRegistry: unknown registry ${JSON.stringify(registry)} (supported: 'composio', 'mcp.run').`
-  );
+  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;
+    out[tool] = typeof spec === "string" ? {
+      question: spec
+    } : spec;
   }
   return out;
 }
+__name(mcpToolApprovals, "mcpToolApprovals");
 
 // src/bridge/mcp-file.ts
 import { existsSync, readFileSync } from "fs";
@@ -2466,7 +2971,11 @@ function warningChannel(opts) {
 `);
   });
 }
+__name(warningChannel, "warningChannel");
 var McpFileError = class extends TheokitAgentError {
+  static {
+    __name(this, "McpFileError");
+  }
   name = "McpFileError";
   constructor(message) {
     super(`[@theokit/agents] ${message}`);
@@ -2490,6 +2999,7 @@ function loadMcpJson(cwd, opts = {}) {
   }
   return parseMcpJson(parsed, path, warningChannel(opts));
 }
+__name(loadMcpJson, "loadMcpJson");
 function parseMcpJson(raw, source, onWarn) {
   if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
     throw new McpFileError(`${source}: root must be a JSON object with an "mcpServers" key.`);
@@ -2510,6 +3020,7 @@ function parseMcpJson(raw, source, onWarn) {
   }
   return out;
 }
+__name(parseMcpJson, "parseMcpJson");
 function validateEntry(name, entryRaw) {
   if (typeof entryRaw !== "object" || entryRaw === null || Array.isArray(entryRaw)) {
     return "the entry must be an object.";
@@ -2521,18 +3032,17 @@ function validateEntry(name, entryRaw) {
   if (!hasUrl && !hasCommand) return 'requires "command" (stdio) or "url" (http/sse).';
   return hasUrl ? validateRemote(entry) : validateStdio(entry);
 }
+__name(validateEntry, "validateEntry");
 function validateStdio(entry) {
   if (typeof entry.command !== "string" || entry.command.length === 0) {
     return 'field "command" must be a non-empty string.';
   }
-  if (entry.args !== void 0 && !isStringArray(entry.args))
-    return 'field "args" must be an array of strings.';
-  if (entry.env !== void 0 && !isStringRecord(entry.env))
-    return 'field "env" must be a map of strings.';
-  if (entry.cwd !== void 0 && typeof entry.cwd !== "string")
-    return 'field "cwd" must be a string.';
+  if (entry.args !== void 0 && !isStringArray(entry.args)) return 'field "args" must be an array of strings.';
+  if (entry.env !== void 0 && !isStringRecord(entry.env)) return 'field "env" must be a map of strings.';
+  if (entry.cwd !== void 0 && typeof entry.cwd !== "string") return 'field "cwd" must be a string.';
   return void 0;
 }
+__name(validateStdio, "validateStdio");
 function validateRemote(entry) {
   if (typeof entry.url !== "string" || entry.url.length === 0) {
     return 'field "url" must be a non-empty string.';
@@ -2553,30 +3063,39 @@ function validateRemote(entry) {
   }
   return void 0;
 }
+__name(validateRemote, "validateRemote");
 function buildEntry(entry) {
   if (entry.url !== void 0) {
-    const remote = { url: entry.url };
+    const remote = {
+      url: entry.url
+    };
     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 };
+  const stdio = {
+    command: entry.command
+  };
   if (entry.args !== void 0) stdio.args = entry.args;
   if (entry.env !== void 0) stdio.env = entry.env;
   if (entry.cwd !== void 0) stdio.cwd = entry.cwd;
   return stdio;
 }
+__name(buildEntry, "buildEntry");
 function describeIt(err) {
   return err instanceof Error ? err.message : String(err);
 }
+__name(describeIt, "describeIt");
 function isStringArray(v) {
   return Array.isArray(v) && v.every((x) => typeof x === "string");
 }
+__name(isStringArray, "isStringArray");
 function isStringRecord(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v) && Object.values(v).every((x) => typeof x === "string");
 }
+__name(isStringRecord, "isStringRecord");
 
 // src/manifest/agent-manifest.ts
 function generateAgentManifest(sources) {
@@ -2594,17 +3113,15 @@ function generateAgentManifest(sources) {
       },
       guards: r.guards.map((g) => g.name),
       interceptors: r.interceptors.map((i) => i.name),
-      tools: r.toolboxes.flatMap(
-        (tb) => tb.tools.map((t) => ({
-          name: tb.namespace ? `${tb.namespace}.${t.config.name}` : t.config.name,
-          description: t.config.description,
-          risk: t.config.risk,
-          approval: t.approval !== void 0,
-          capabilities: t.capabilities,
-          trace: t.trace,
-          audit: t.audit
-        }))
-      ),
+      tools: r.toolboxes.flatMap((tb) => tb.tools.map((t) => ({
+        name: tb.namespace ? `${tb.namespace}.${t.config.name}` : t.config.name,
+        description: t.config.description,
+        risk: t.config.risk,
+        approval: t.approval !== void 0,
+        capabilities: t.capabilities,
+        trace: t.trace,
+        audit: t.audit
+      }))),
       gateway: r.gateway ? {
         platforms: r.gateway.platforms,
         sessionStrategy: r.gateway.sessionStrategy ?? "per-user"
@@ -2621,6 +3138,7 @@ function generateAgentManifest(sources) {
     }))
   };
 }
+__name(generateAgentManifest, "generateAgentManifest");
 
 // src/theokit-plugin.ts
 function validateUniqueRoutes(results) {
@@ -2628,13 +3146,12 @@ function validateUniqueRoutes(results) {
   for (const r of results) {
     const existing = seen.get(r.route);
     if (existing !== void 0) {
-      throw new Error(
-        `[@theokit/agents] Duplicate agent route '${r.route}': both '${existing}' and '${r.agentConfig.name}' declare it.`
-      );
+      throw new Error(`[@theokit/agents] Duplicate agent route '${r.route}': both '${existing}' and '${r.agentConfig.name}' declare it.`);
     }
     seen.set(r.route, r.agentConfig.name);
   }
 }
+__name(validateUniqueRoutes, "validateUniqueRoutes");
 function agentsPlugin(opts) {
   let routes = null;
   return {
@@ -2652,23 +3169,30 @@ function agentsPlugin(opts) {
     }
   };
 }
+__name(agentsPlugin, "agentsPlugin");
 function initRoutes(opts) {
   const allRoutes = [];
   const routeIdentities = [];
   for (const entry of opts.agents) {
-    routeIdentities.push({ route: entry.route, agentConfig: { name: entry.name } });
+    routeIdentities.push({
+      route: entry.route,
+      agentConfig: {
+        name: entry.name
+      }
+    });
     const createRun = opts.createRunFactory ? opts.createRunFactory(entry.compiled) : defaultCreateRun(entry.compiled);
-    allRoutes.push(
-      ...generateAgentRoutes({
-        walkResult: { route: entry.route },
-        compiledOptions: entry.compiled,
-        createRun
-      })
-    );
+    allRoutes.push(...generateAgentRoutes({
+      walkResult: {
+        route: entry.route
+      },
+      compiledOptions: entry.compiled,
+      createRun
+    }));
   }
   validateUniqueRoutes(routeIdentities);
   return compileRoutePatterns(allRoutes);
 }
+__name(initRoutes, "initRoutes");
 function defaultCreateRun(compiled) {
   return async function* (_message, _sessionId) {
     await Promise.resolve();
@@ -2685,13 +3209,18 @@ function defaultCreateRun(compiled) {
     };
   };
 }
+__name(defaultCreateRun, "defaultCreateRun");
 function compileRoutePatterns(routes) {
   return routes.map((r) => {
     if (!r.path.includes(":")) return r;
     const regexSource = r.path.replace(/:[^/]+/g, "[^/]+");
-    return { ...r, regex: RegExp(`^${regexSource}$`) };
+    return {
+      ...r,
+      regex: RegExp(`^${regexSource}$`)
+    };
   });
 }
+__name(compileRoutePatterns, "compileRoutePatterns");
 function matchRoute(routes, method, pathname) {
   return routes.find((r) => {
     if (r.method !== method) return false;
@@ -2699,6 +3228,7 @@ function matchRoute(routes, method, pathname) {
     return r.path === pathname;
   });
 }
+__name(matchRoute, "matchRoute");
 
 export {
   ConfigurationError,
@@ -2779,4 +3309,4 @@ export {
   generateAgentManifest,
   agentsPlugin
 };
-//# sourceMappingURL=chunk-PHUNONZT.js.map
+//# sourceMappingURL=chunk-WKBZZQBO.js.map