@pikku/core 0.12.72 → 0.12.74

package/dist/utils/hmac.d.ts

@@ -1,16 +1,10 @@
 /**
- * HMAC-SHA256 a payload, hex-encoded.
- *
- * Senders wrap this in their own scheme prefix (`sha256=`, `v0=`, …).
- *
- * @param secret - The signing key shared with the other side
- * @param payload - The exact bytes that were signed
+ * HMAC-SHA256 of a payload, hex-encoded. Senders wrap this in their own scheme
+ * prefix (`sha256=`, `v0=`, …).
  */
 export declare function hmacSha256Hex(secret: string, payload: string): string;
 /**
- * Compare two signatures without leaking their contents through timing.
- *
- * Returns false rather than throwing on a length mismatch, which is what
- * `timingSafeEqual` does when the buffers differ in size.
+ * Constant-time signature comparison. Returns false on a length mismatch,
+ * where `timingSafeEqual` itself throws.
  */
 export declare function timingSafeStringEqual(a: string, b: string): boolean;

package/dist/utils/hmac.js

@@ -1,20 +1,14 @@
 import { createHmac, timingSafeEqual } from 'node:crypto';
 /**
- * HMAC-SHA256 a payload, hex-encoded.
- *
- * Senders wrap this in their own scheme prefix (`sha256=`, `v0=`, …).
- *
- * @param secret - The signing key shared with the other side
- * @param payload - The exact bytes that were signed
+ * HMAC-SHA256 of a payload, hex-encoded. Senders wrap this in their own scheme
+ * prefix (`sha256=`, `v0=`, …).
  */
 export function hmacSha256Hex(secret, payload) {
     return createHmac('sha256', secret).update(payload).digest('hex');
 }
 /**
- * Compare two signatures without leaking their contents through timing.
- *
- * Returns false rather than throwing on a length mismatch, which is what
- * `timingSafeEqual` does when the buffers differ in size.
+ * Constant-time signature comparison. Returns false on a length mismatch,
+ * where `timingSafeEqual` itself throws.
  */
 export function timingSafeStringEqual(a, b) {
     try {

package/dist/utils/safe-fetch.d.ts

@@ -1,23 +1,7 @@
 /**
- * SSRF-aware fetch helpers.
- *
- * `@pikku/core` runs in edge runtimes (Cloudflare Workers) with no Node `dns`,
- * so we cannot resolve hostnames to check for private targets. We reject the
- * obvious internal literals and, crucially, re-validate every redirect hop —
- * a public URL that 302s to `169.254.169.254` is the common bypass. This does
- * NOT defend against a public hostname that itself resolves to a private IP
- * (DNS rebinding), which is out of reach without DNS resolution.
- */
-/**
- * Whether a hostname is an obvious internal/private target (loopback, private
- * IPv4 ranges, link-local incl. the cloud metadata endpoint, or private IPv6).
- *
- * Alias/encoded forms that resolve to the same targets are also rejected: a
- * trailing-dot FQDN (`localhost.`), the `*.localhost` reserved name, IPv4-mapped
- * IPv6 (`::ffff:127.0.0.1`), and octal/decimal/hex-encoded IPv4. This is
- * best-effort literal matching only — it cannot catch a public hostname that
- * *resolves* to a private IP (DNS rebinding), which needs DNS resolution
- * unavailable in edge runtimes.
+ * Whether a hostname is an obvious internal target. Best-effort literal
+ * matching only: it cannot catch a public hostname that *resolves* to a
+ * private IP.
  */
 export declare function isPrivateHost(hostname: string): boolean;
 export interface SafeFetchOptions {
@@ -29,23 +13,11 @@ export interface SafeFetchOptions {
     /** Maximum redirect hops to follow (each re-validated). Defaults to 3. */
     maxRedirects?: number;
 }
-/**
- * Parse and validate a URL for outbound fetching: only http(s), and — unless an
- * `allowedHosts` allowlist is supplied — not an obvious private/internal host.
- * Returns the parsed URL or throws.
- */
 export declare function assertFetchableUrl(url: string, options?: SafeFetchOptions): URL;
 /**
- * `fetch` with SSRF protection. The initial URL and every redirect target are
- * validated with {@link assertFetchableUrl}. Redirects are followed manually
- * (`redirect: 'manual'`) so an unsafe `Location` can never be followed into the
- * internal network; only the redirect statuses in {@link REDIRECT_STATUSES} are
- * followed, and the method/body are transformed per {@link redirectInit}. Each
- * intermediate redirect response body is cancelled before the next hop so it is
- * not left dangling. When a redirect cannot or should not be followed (no
- * `Location`, or the hop budget is exhausted) the raw redirect response is
- * returned for the caller to handle by status. Credential headers
- * (`Authorization`, `Cookie`) are stripped whenever a redirect crosses origin,
- * so they never leak to a redirected host.
+ * `fetch` with SSRF protection on the initial URL and every redirect hop.
+ * When a redirect cannot be followed (no `Location`, or the hop budget is
+ * spent) the raw redirect response is returned for the caller to handle by
+ * status.
  */
 export declare function safeFetch(url: string, init?: RequestInit, options?: SafeFetchOptions): Promise<Response>;

package/dist/utils/safe-fetch.js

@@ -1,19 +1,7 @@
 /**
- * SSRF-aware fetch helpers.
- *
- * `@pikku/core` runs in edge runtimes (Cloudflare Workers) with no Node `dns`,
- * so we cannot resolve hostnames to check for private targets. We reject the
- * obvious internal literals and, crucially, re-validate every redirect hop —
- * a public URL that 302s to `169.254.169.254` is the common bypass. This does
- * NOT defend against a public hostname that itself resolves to a private IP
- * (DNS rebinding), which is out of reach without DNS resolution.
- */
-/**
- * Parse the many textual encodings of an IPv4 address that `fetch`/`undici`
- * (and `inet_aton`-style parsers) accept — a dotted quad whose octets may be
- * decimal, octal (`0177`) or hex (`0x7f`), or the whole address as a single
- * 32-bit integer (decimal `2130706433`, hex `0x7f000001`). Returns the four
- * octets, or `null` when the host is not a numeric IPv4 literal.
+ * Parses the textual IPv4 encodings `fetch`/`undici` accept — a dotted quad
+ * whose octets may be decimal, octal (`0177`) or hex (`0x7f`), or the whole
+ * address as a single 32-bit integer. `null` when not an IPv4 literal.
  */
 function parseIPv4Octets(host) {
     const toInt = (part) => {
@@ -47,15 +35,9 @@ function parseIPv4Octets(host) {
     return octets;
 }
 /**
- * Whether a hostname is an obvious internal/private target (loopback, private
- * IPv4 ranges, link-local incl. the cloud metadata endpoint, or private IPv6).
- *
- * Alias/encoded forms that resolve to the same targets are also rejected: a
- * trailing-dot FQDN (`localhost.`), the `*.localhost` reserved name, IPv4-mapped
- * IPv6 (`::ffff:127.0.0.1`), and octal/decimal/hex-encoded IPv4. This is
- * best-effort literal matching only — it cannot catch a public hostname that
- * *resolves* to a private IP (DNS rebinding), which needs DNS resolution
- * unavailable in edge runtimes.
+ * Whether a hostname is an obvious internal target. Best-effort literal
+ * matching only: it cannot catch a public hostname that *resolves* to a
+ * private IP.
  */
 export function isPrivateHost(hostname) {
     const host = hostname
@@ -96,11 +78,6 @@ export function isPrivateHost(hostname) {
     }
     return false;
 }
-/**
- * Parse and validate a URL for outbound fetching: only http(s), and — unless an
- * `allowedHosts` allowlist is supplied — not an obvious private/internal host.
- * Returns the parsed URL or throws.
- */
 export function assertFetchableUrl(url, options = {}) {
     const parsed = new URL(url);
     if (parsed.protocol !== 'https:' && parsed.protocol !== 'http:') {
@@ -116,16 +93,8 @@ export function assertFetchableUrl(url, options = {}) {
     }
     return parsed;
 }
-/**
- * The only 3xx statuses that request a redirect be followed. `300` (Multiple
- * Choices), `304` (Not Modified), `305` (Use Proxy) and `306` are returned to
- * the caller as-is rather than followed.
- */
+/** The only 3xx statuses followed; every other 3xx is returned to the caller. */
 const REDIRECT_STATUSES = new Set([301, 302, 303, 307, 308]);
-/**
- * Drop credential-bearing headers (`Authorization`, `Cookie`) so they are not
- * replayed to a different origin across a redirect.
- */
 function stripCredentialHeaders(init) {
     if (!init.headers)
         return init;
@@ -135,10 +104,8 @@ function stripCredentialHeaders(init) {
     return { ...init, headers };
 }
 /**
- * Apply the WHATWG-fetch method/body transform for a redirect: a `303` (and a
- * `301`/`302` on a `POST`) becomes a bodyless `GET`; `307`/`308` preserve the
- * original method and body. When the method changes to `GET` the request body
- * and its `Content-*` headers are dropped.
+ * The WHATWG method/body transform for a redirect: `303` (and `301`/`302` on
+ * a `POST`) becomes a bodyless `GET`; `307`/`308` preserve method and body.
  */
 function redirectInit(status, init) {
     const method = (init.method ?? 'GET').toUpperCase();
@@ -152,17 +119,10 @@ function redirectInit(status, init) {
     return { ...init, method: 'GET', body: undefined, headers };
 }
 /**
- * `fetch` with SSRF protection. The initial URL and every redirect target are
- * validated with {@link assertFetchableUrl}. Redirects are followed manually
- * (`redirect: 'manual'`) so an unsafe `Location` can never be followed into the
- * internal network; only the redirect statuses in {@link REDIRECT_STATUSES} are
- * followed, and the method/body are transformed per {@link redirectInit}. Each
- * intermediate redirect response body is cancelled before the next hop so it is
- * not left dangling. When a redirect cannot or should not be followed (no
- * `Location`, or the hop budget is exhausted) the raw redirect response is
- * returned for the caller to handle by status. Credential headers
- * (`Authorization`, `Cookie`) are stripped whenever a redirect crosses origin,
- * so they never leak to a redirected host.
+ * `fetch` with SSRF protection on the initial URL and every redirect hop.
+ * When a redirect cannot be followed (no `Location`, or the hop budget is
+ * spent) the raw redirect response is returned for the caller to handle by
+ * status.
  */
 export async function safeFetch(url, init = {}, options = {}) {
     const maxRedirects = options.maxRedirects ?? 3;

package/dist/utils.d.ts

@@ -5,12 +5,7 @@ export declare const createWeakUID: () => string;
 export declare const isSerializable: (data: any) => boolean;
 export declare const getTagGroups: <T>(tagGroups: Record<string, T>, tag: string) => T[];
 export declare const freezeDedupe: <T>(arr?: readonly T[] | T[] | undefined) => readonly T[];
-/**
- * Stop all singleton services, including addon package services.
- * Addon package services are stopped first, then the parent services.
- *
- * @param singletonServices - The parent singleton services to stop
- */
+/** Stops addon package services first, then the parent singleton services. */
 export declare const stopSingletonServices: () => Promise<void>;
 /** Wrap server lifecycle hooks so the inspector can discover them. */
 export declare const pikkuServerLifecycle: <SS extends CoreSingletonServices = CoreSingletonServices>(lifecycle: ServerLifecycle<SS>) => ServerLifecycle<SS>;

package/dist/utils.js

@@ -11,9 +11,12 @@ export const closeWireServices = async (logger, wireServices) => {
         }
     }));
 };
-const _uidPrefix = Date.now().toString(36);
+let _uidPrefix;
 let _uidCounter = 0;
-export const createWeakUID = () => `${_uidPrefix}-${++_uidCounter}`;
+export const createWeakUID = () => {
+    _uidPrefix ??= globalThis.crypto.randomUUID().slice(0, 8);
+    return `${_uidPrefix}-${++_uidCounter}`;
+};
 export const isSerializable = (data) => {
     return !(typeof data === 'string' ||
         data instanceof ArrayBuffer ||
@@ -58,9 +61,6 @@ export const freezeDedupe = (arr) => {
     }
     return Object.freeze(out);
 };
-/**
- * Stop a single service by calling its stop method if it exists
- */
 const stopService = async (logger, name, service) => {
     const stop = service?.stop;
     if (stop) {
@@ -73,20 +73,13 @@ const stopService = async (logger, name, service) => {
         }
     }
 };
-/**
- * Stop all singleton services, including addon package services.
- * Addon package services are stopped first, then the parent services.
- *
- * @param singletonServices - The parent singleton services to stop
- */
+/** Stops addon package services first, then the parent singleton services. */
 export const stopSingletonServices = async () => {
     const singletonServices = getSingletonServices();
     const logger = singletonServices.logger;
-    // Stop all addon package singleton services
     const stateMap = getAllPackageStates();
     if (stateMap.size > 0) {
         for (const [packageName, packageState] of stateMap) {
-            // Skip main package - we handle it separately
             if (packageName === '__main__')
                 continue;
             const packageServices = packageState.package?.singletonServices;
@@ -95,12 +88,10 @@ export const stopSingletonServices = async () => {
                 for (const [name, service] of Object.entries(packageServices)) {
                     await stopService(logger, `${packageName}/${name}`, service);
                 }
-                // Clear the cached services
                 packageState.package.singletonServices = null;
             }
         }
     }
-    // Then stop the parent singleton services
     for (const [name, service] of Object.entries(singletonServices)) {
         await stopService(logger, name, service);
     }

package/dist/wirings/actor-flow/actor-flow.types.d.ts

@@ -1,66 +1,33 @@
-/**
- * How an actor agent answers the target agent's tool-approval requests during
- * a conversation.
- * - `'in-persona'` — the actor agent decides as the persona would (default).
- * - `'always'` — approve every request (stress the happy path).
- * - `'never'` — deny every request (exercise refusal handling).
- */
 export type ActorFlowApprovalPolicy = 'in-persona' | 'always' | 'never';
-/**
- * Options for `actor.converse(...)` — a dynamic conversation an actor holds
- * with a target Pikku AI agent, in the actor's own persona. `TAgentName` is
- * bound to the generated union of agent names in a typed project.
- */
 export interface ConverseOptions<TAgentName extends string = string> {
-    /** Target Pikku AI agent name to converse with. */
     agent: TAgentName;
     /** What the actor is trying to get the agent to accomplish. */
     task: string;
-    /** Natural-language success criterion the actor evaluates at the end. */
+    /** Natural-language success criterion the actor judges the conversation against. */
     evaluate: string;
-    /** How the actor answers the agent's tool-approval requests. Default `'in-persona'`. */
     approvals?: ActorFlowApprovalPolicy;
-    /** Model the actor uses for its own turns/decisions. Falls back to the actor service default. */
     model?: string;
-    /** Hard cap on conversation turns before forcing evaluation. Default 12. */
     maxTurns?: number;
 }
-/**
- * The verdict a conversation produces: the persona's LLM self-evaluation of
- * whether the task was met. Deterministic checks are the caller's job — they
- * already hold the actor and can `actor.invoke(...)` afterwards.
- */
 export interface ActorFlowVerdict {
-    /** Whether the actor judged the task accomplished. */
     passed: boolean;
-    /** The actor's reasoning for its verdict. */
     reasoning: string;
-    /** The conversation transcript, for debugging/reporting. */
     transcript: string[];
 }
-/** A pending tool-approval request surfaced by the target agent. */
 export interface TargetPendingApproval {
     toolCallId: string;
     toolName: string;
     args: unknown;
     reason?: string;
 }
-/** A normalized reply from the target agent, independent of transport. */
 export interface TargetAgentReply {
     text: string;
     runId: string;
     status?: 'completed' | 'suspended';
     pendingApprovals?: TargetPendingApproval[];
 }
-/**
- * Drives the target agent. In production this is HTTP-backed (the actor's
- * `agentRun` / `agentApprove` calls as the signed-in actor); the conversation
- * engine only sees this transport-agnostic contract.
- */
 export interface TargetAgentDriver {
-    /** Send a message, starting or continuing the target agent's run. */
     run(message: string): Promise<TargetAgentReply>;
-    /** Answer the target agent's pending approvals and continue its run. */
     approve(runId: string, decisions: {
         toolCallId: string;
         approved: boolean;

package/dist/wirings/actor-flow/index.d.ts

@@ -1,11 +1,2 @@
-/**
- * Actor flow module exports.
- *
- * An actor holds a dynamic conversation with a target Pikku AI agent via
- * `actor.converse(...)` — playing its own persona, approving the agent's tool
- * requests in-persona, and evaluating whether the task was accomplished. The
- * conversation engine here is transport-agnostic; the actor drives the target
- * over HTTP.
- */
 export type { ActorFlowApprovalPolicy, ActorFlowVerdict, ConverseOptions, TargetAgentReply, TargetPendingApproval, TargetAgentDriver, } from './actor-flow.types.js';
 export { runConversation, type RunConversationParams, type ActorLLM, } from './run-conversation.js';

package/dist/wirings/actor-flow/run-conversation.d.ts

@@ -1,13 +1,13 @@
 import type { ActorFlowApprovalPolicy, ActorFlowVerdict, TargetAgentDriver } from './actor-flow.types.js';
-import type { ScenarioActorConfig } from '../../services/scenario-actors-service.js';
+import type { ResolvedPersona } from '../../services/personas-service.js';
 import type { AIAgentRunnerParams, AIAgentStepResult } from '../../services/ai-agent-runner-service.js';
 /** The LLM call the actor uses for its own turns/decisions/evaluation. */
 export type ActorLLM = (params: AIAgentRunnerParams) => Promise<AIAgentStepResult>;
 export interface RunConversationParams {
-    /** The actor's own config (personality/jobTitle/name), which shapes how it talks. */
-    actor: ScenarioActorConfig;
-    /** Stable actor name (for transcript labelling). */
-    actorName: string;
+    /** The person being played — name, job title, personality. */
+    persona: ResolvedPersona;
+    /** The id they were declared under (for transcript labelling). */
+    personaId: string;
     /** What the actor is trying to get the target agent to accomplish. */
     task: string;
     /** Natural-language success criterion the actor evaluates at the end. */

package/dist/wirings/actor-flow/run-conversation.js

@@ -60,16 +60,23 @@ function readObject(result) {
     }
     return null;
 }
-function actorInstructions(actor, task) {
+function actorInstructions(persona, task) {
     return [
         `You are role-playing a real user interacting with an AI assistant. Stay in character at all times — you are the user, not the assistant.`,
-        actor.name ? `Your name is ${actor.name}.` : '',
-        actor.jobTitle ? `Your role: ${actor.jobTitle}.` : '',
-        actor.personality
-            ? `Your personality and communication style: ${actor.personality}. Match this tone, vocabulary, and level of detail exactly.`
+        `Your name is ${persona.name}.`,
+        persona.jobTitle ? `Your role: ${persona.jobTitle}.` : '',
+        persona.personality
+            ? `Your personality and communication style: ${persona.personality}. Match this tone, vocabulary, and level of detail exactly.`
             : '',
         `Your goal in this conversation: ${task}.`,
         `Send one message at a time. Set "done" to true only once your goal is clearly accomplished, or clearly impossible.`,
+        // Every call the actor makes wants a schema'd object back, and a gateway
+        // that cannot take a JSON *schema* degrades to OpenAI's `json_object`
+        // mode — which refuses the request outright unless the word "json" appears
+        // somewhere in the prompt. Saying it once here covers all three call sites
+        // (turn, approvals, verdict), since each builds on these instructions, and
+        // it costs nothing on providers that never needed telling.
+        `Reply with json matching the schema you are given, and nothing else.`,
     ]
         .filter(Boolean)
         .join('\n');
@@ -129,7 +136,7 @@ async function converseWithTarget(params, instructions, message) {
  */
 export async function runConversation(params) {
     const maxTurns = params.maxTurns ?? DEFAULT_MAX_TURNS;
-    const instructions = actorInstructions(params.actor, params.task);
+    const instructions = actorInstructions(params.persona, params.task);
     // Seed a kickoff so the very first actor turn has a non-empty message list
     // (providers reject an empty prompt). It's an instruction TO the actor, so
     // it never appears in the transcript.
@@ -153,7 +160,7 @@ export async function runConversation(params) {
             break;
         }
         actorMessages.push(msg('assistant', actorMessage));
-        transcript.push(`${params.actorName}: ${actorMessage}`);
+        transcript.push(`${params.persona.name}: ${actorMessage}`);
         const reply = await converseWithTarget(params, instructions, actorMessage);
         actorMessages.push(msg('user', reply.text ?? ''));
         transcript.push(`${params.agentName}: ${reply.text ?? ''}`);

package/dist/wirings/ai-agent/ai-agent-agui.d.ts

@@ -74,11 +74,6 @@ export type { AGUIEvent };
 export type AGUIChannelOptions = {
     threadId?: string;
     runId?: string;
-    /**
-     * Late-bound runId source, resolved when the run is opened (first event).
-     * Lets the stream path report the AIRunStateService runId on RUN_STARTED
-     * even though that id is only created after the channel is wrapped.
-     */
     getRunId?: () => string | undefined;
 };
 export declare function wrapChannelWithAGUI(inner: AIStreamChannel, options?: AGUIChannelOptions): AIStreamChannel;

package/dist/wirings/ai-agent/ai-agent-agui.js

@@ -27,8 +27,6 @@ export function wrapChannelWithAGUI(inner, options) {
     let sawUsage = false;
     let usageModel;
     const usageTotals = { input: 0, output: 0 };
-    // The AG-UI client rejects any event arriving before RUN_STARTED, so the
-    // run is opened lazily with the first translated event.
     function send(event) {
         if (!runStartedSent) {
             runStartedSent = true;
@@ -77,11 +75,6 @@ export function wrapChannelWithAGUI(inner, options) {
         }
         return thinkingMessageId;
     }
-    // The AG-UI client treats RUN_FINISHED as terminal and rejects everything
-    // after it, so it is emitted exactly once — on 'done' — with the usage
-    // accumulated across all steps (per-step 'usage' events must NOT finish
-    // the run: on multi-step tool runs later steps would arrive after
-    // RUN_FINISHED and the client would drop the whole stream).
     function finishRun() {
         endTextMessage();
         endThinkingMessage();
@@ -112,6 +105,9 @@ export function wrapChannelWithAGUI(inner, options) {
         setState: (s) => inner.setState(s),
         getState: () => inner.getState(),
         clearState: () => inner.clearState(),
+        // Delegated: the wrapper is a view over the same connection, so a peer
+        // reachable from the channel underneath is reachable from here too.
+        remote: (funcName, data) => inner.remote(funcName, data),
         sendBinary: (data) => inner.sendBinary(data),
         close: () => inner.close(),
         send: (event) => {
@@ -190,9 +186,6 @@ export function wrapChannelWithAGUI(inner, options) {
                     finishRun();
                     break;
                 }
-                // Step names must be unique among active steps on the client and
-                // sub-agents reuse step numbers on the shared channel, so each
-                // step-start closes the previous step and gets a sequential name.
                 case 'step-start': {
                     endTextMessage();
                     endThinkingMessage();
@@ -288,9 +281,38 @@ export function wrapChannelWithAGUI(inner, options) {
                     });
                     break;
                 }
-                case 'audio-delta':
-                case 'audio-done':
+                case 'interrupted': {
+                    endTextMessage();
+                    endThinkingMessage();
+                    endStep();
+                    send({
+                        type: 'CUSTOM',
+                        name: 'pikku:interrupted',
+                        value: {
+                            runId: event.runId,
+                            text: event.text,
+                            reason: event.reason,
+                        },
+                    });
                     break;
+                }
+                // AG-UI has no event for speech, so it travels as CUSTOM like the other
+                // pikku-specific ones. Dropping it instead — which is what this did —
+                // means a voice agent reached over HTTP is inaudible: `voiceOutput`
+                // synthesizes every sentence, the provider bills for it, and nothing
+                // gets past the mapper.
+                case 'audio-delta': {
+                    send({
+                        type: 'CUSTOM',
+                        name: 'pikku:audio-delta',
+                        value: { data: event.data, format: event.format },
+                    });
+                    break;
+                }
+                case 'audio-done': {
+                    send({ type: 'CUSTOM', name: 'pikku:audio-done', value: {} });
+                    break;
+                }
             }
         },
     };

package/dist/wirings/ai-agent/ai-agent-helpers.d.ts

@@ -1,3 +1,4 @@
+import type { AgentInterruptResult } from './ai-agent-interrupt.js';
 export declare function agent<TAgentMap extends Record<string, {
     output: any;
 }>>(agentName: string & keyof TAgentMap): {
@@ -15,6 +16,12 @@ export declare function agentResume(): {
         approved: boolean;
     }, wire: any) => Promise<void>;
 };
+export declare function agentInterrupt(): {
+    func: (services: any, data: {
+        runId: string;
+        reason?: 'speech' | 'user' | 'timeout';
+    }, wire: any) => Promise<AgentInterruptResult>;
+};
 export declare function agentApprove<TAgentMap extends Record<string, {
     output: any;
 }>>(_agentName: string & keyof TAgentMap): {

package/dist/wirings/ai-agent/ai-agent-helpers.js

@@ -31,6 +31,13 @@ export function agentResume() {
         },
     };
 }
+export function agentInterrupt() {
+    return {
+        func: async (_services, data, { rpc }) => {
+            return rpc.agent.interrupt(data.runId, data.reason);
+        },
+    };
+}
 export function agentApprove(_agentName) {
     return {
         func: async (_services, data, { rpc }) => {