@theokit/agents 0.31.0 → 0.32.0

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

@@ -21,7 +21,7 @@ import {
   getProjectContextConfig,
   getSkillsConfig,
   getSubAgents
-} from "./chunk-FI6ZG2YP.js";
+} from "./chunk-3AX6M5TF.js";
 import {
   __name
 } from "./chunk-7QVYU63E.js";
@@ -1555,6 +1555,10 @@ __name(agent, "agent");
 function createHitlPlugin(wiring) {
   return {
     name: "theokit-hitl",
+    version: "1.0.0",
+    // `kind: 'general'` is load-bearing — without it the SDK's isCodePlugin() drops this plugin and
+    // the HITL veto never fires (the run would proceed WITHOUT waiting for human approval).
+    kind: "general",
     register(ctx) {
       ctx.on("pre_tool_call", async (c) => {
         const opts = wiring.gated.get(c.name);
@@ -1567,12 +1571,25 @@ function createHitlPlugin(wiring) {
           question: opts.question,
           input: c.args,
           callbackUrl: `approve/${approvalId}`,
-          timeoutMs: opts.timeout ?? 3e5
+          timeoutMs: opts.timeout ?? 3e5,
+          // M20 — carry the declared custom-payload schema so the UI knows what to collect.
+          ...opts.payloadSchema !== void 0 ? {
+            payloadSchema: opts.payloadSchema
+          } : {}
         });
-        const approved = await wiring.awaitApproval(approvalId, opts, c.name);
-        return approved ? void 0 : {
+        const raw = await wiring.awaitApproval(approvalId, opts, c.name);
+        const decision = typeof raw === "boolean" ? {
+          approved: raw
+        } : raw;
+        if (decision.approved) return void 0;
+        let message = `Tool '${c.name}' denied by human approver`;
+        if (decision.reason) message += `: ${decision.reason}`;
+        if (decision.payload !== void 0) {
+          message += ` (payload: ${JSON.stringify(decision.payload)})`;
+        }
+        return {
           block: true,
-          message: `Tool '${c.name}' denied by human approver`
+          message
         };
       });
     }
@@ -2509,8 +2526,12 @@ __name(delegate, "delegate");
 function createToolHooksPlugin(hooks) {
   return {
     name: "theokit-tool-hooks",
+    version: "1.0.0",
+    // `kind: 'general'` is load-bearing — without it the SDK's isCodePlugin() drops this plugin and
+    // no hook fires (M10/M19 latent bug, proven via a real OpenRouter run).
+    kind: "general",
     register(ctx) {
-      const { beforeToolCall, afterToolCall, beforeLLMCall, afterLLMCall } = hooks;
+      const { beforeToolCall, afterToolCall, beforeLLMCall, afterLLMCall, processInput } = hooks;
       if (beforeToolCall) {
         ctx.on("pre_tool_call", (c) => beforeToolCall({
           name: c.name ?? "",
@@ -2537,11 +2558,167 @@ function createToolHooksPlugin(hooks) {
           iteration: c.iteration
         }));
       }
+      if (processInput) {
+        ctx.on("pre_user_send", async (c) => {
+          const injected = await processInput({
+            prompt: c.prompt ?? "",
+            agentId: c.agentId,
+            runId: c.runId
+          });
+          return injected !== void 0 && injected.length > 0 ? {
+            recalledContext: injected
+          } : void 0;
+        });
+      }
     }
   };
 }
 __name(createToolHooksPlugin, "createToolHooksPlugin");
 
+// src/bridge/api-error-handler.ts
+var DEFAULT_MAX_ATTEMPTS = 3;
+async function runWithApiErrorHandling(thunk, policy) {
+  const maxAttempts = policy.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
+  let attempt = 0;
+  for (; ; ) {
+    attempt += 1;
+    try {
+      return await thunk();
+    } catch (error) {
+      const decision = await policy.processApiError({
+        error,
+        attempt
+      });
+      if (decision.retry && attempt < maxAttempts) continue;
+      if (!decision.retry && "fallback" in decision && decision.fallback !== void 0) {
+        return decision.fallback;
+      }
+      throw error;
+    }
+  }
+}
+__name(runWithApiErrorHandling, "runWithApiErrorHandling");
+function createApiErrorHandler(policy) {
+  return (thunk) => runWithApiErrorHandling(thunk, policy);
+}
+__name(createApiErrorHandler, "createApiErrorHandler");
+
+// src/bridge/delegation-scoring.ts
+function delegateBackground(subAgent, message, opts = {}) {
+  const { delegateFn = delegate, ...delegateOpts } = opts;
+  let isSettled = false;
+  const promise = delegateFn(subAgent, message, delegateOpts).finally(() => {
+    isSettled = true;
+  });
+  promise.catch(() => void 0);
+  return {
+    wait: /* @__PURE__ */ __name(() => promise, "wait"),
+    settled: /* @__PURE__ */ __name(() => isSettled, "settled")
+  };
+}
+__name(delegateBackground, "delegateBackground");
+var DEFAULT_MAX_ROUNDS = 3;
+function defaultFeedbackTemplate(message, feedback) {
+  return `${message}
+
+Feedback from the reviewer (address this): ${feedback}`;
+}
+__name(defaultFeedbackTemplate, "defaultFeedbackTemplate");
+async function delegateWithScoring(subAgent, message, opts) {
+  const { scorer, maxRounds: maxRoundsOpt = DEFAULT_MAX_ROUNDS, delegateFn = delegate, feedbackTemplate = defaultFeedbackTemplate, ...delegateOpts } = opts;
+  const maxRounds = Math.max(1, maxRoundsOpt);
+  const verdicts = [];
+  let currentMessage = message;
+  let lastResult;
+  for (let round = 1; round <= maxRounds; round++) {
+    const result = await delegateFn(subAgent, currentMessage, delegateOpts);
+    lastResult = result;
+    const verdict = await scorer(result);
+    verdicts.push(verdict);
+    if (verdict.pass) {
+      return {
+        result,
+        rounds: round,
+        passed: true,
+        verdicts
+      };
+    }
+    if (verdict.feedback) currentMessage = feedbackTemplate(message, verdict.feedback);
+  }
+  return {
+    result: lastResult,
+    rounds: maxRounds,
+    passed: false,
+    verdicts
+  };
+}
+__name(delegateWithScoring, "delegateWithScoring");
+
+// src/bridge/mcp-resolver.ts
+async function resolveMcpServers(selection, ctx) {
+  if (selection === void 0) return void 0;
+  if (typeof selection !== "function") return selection;
+  const resolved = await selection(ctx);
+  if (typeof resolved !== "object" || resolved === null) {
+    throw new Error("[@theokit/agents] MCP resolver must return an McpServersMap object");
+  }
+  return resolved;
+}
+__name(resolveMcpServers, "resolveMcpServers");
+function mcpRegistry(config) {
+  const registry = config.registry;
+  if (registry === "composio") {
+    const apps = config.apps ?? [];
+    return {
+      composio: {
+        command: "npx",
+        args: [
+          "-y",
+          "@composio/mcp",
+          ...apps.length > 0 ? [
+            "--apps",
+            apps.join(",")
+          ] : []
+        ],
+        env: {
+          COMPOSIO_API_KEY: config.apiKey
+        }
+      }
+    };
+  }
+  if (registry === "mcp.run") {
+    return {
+      "mcp.run": {
+        command: "npx",
+        args: [
+          "-y",
+          "@mcp.run/cli",
+          "serve",
+          ...config.profile ? [
+            "--profile",
+            config.profile
+          ] : []
+        ],
+        env: {
+          MCP_RUN_API_KEY: config.apiKey
+        }
+      }
+    };
+  }
+  throw new Error(`mcpRegistry: unknown registry ${JSON.stringify(registry)} (supported: 'composio', 'mcp.run').`);
+}
+__name(mcpRegistry, "mcpRegistry");
+function mcpToolApprovals(specs) {
+  const out = {};
+  for (const [tool, spec] of Object.entries(specs)) {
+    out[tool] = typeof spec === "string" ? {
+      question: spec
+    } : spec;
+  }
+  return out;
+}
+__name(mcpToolApprovals, "mcpToolApprovals");
+
 // src/manifest/agent-manifest.ts
 function generateAgentManifest(walkResults) {
   return {
@@ -2729,7 +2906,14 @@ export {
   AgentRunnerBuilder,
   delegate,
   createToolHooksPlugin,
+  runWithApiErrorHandling,
+  createApiErrorHandler,
+  delegateBackground,
+  delegateWithScoring,
+  resolveMcpServers,
+  mcpRegistry,
+  mcpToolApprovals,
   generateAgentManifest,
   agentsPlugin
 };
-//# sourceMappingURL=chunk-BWYBOMKR.js.map
+//# sourceMappingURL=chunk-5VIRIPVV.js.map