@pikku/core 0.12.1 → 0.12.3

package/dist/wirings/gateway/gateway.types.d.ts

@@ -0,0 +1,127 @@
+import type { CommonWireMeta, CorePikkuMiddleware, CorePikkuMiddlewareGroup } from '../../types/core.types.js';
+import type { CorePikkuFunctionConfig, CorePermissionGroup, CorePikkuPermission } from '../../function/functions.types.js';
+import type { PikkuHTTPRequest } from '../http/http.types.js';
+/**
+ * Attachment in gateway messages (images, files, etc.)
+ */
+export interface GatewayAttachment {
+    type: string;
+    url?: string;
+    data?: ArrayBuffer | Uint8Array;
+    mimeType?: string;
+    filename?: string;
+}
+/**
+ * Normalized inbound message from any platform
+ */
+export interface GatewayInboundMessage {
+    /** Platform-specific sender identifier (phone number, Slack user ID, etc.) */
+    senderId: string;
+    /** Message text content */
+    text: string;
+    /** Original platform-specific payload */
+    raw: unknown;
+    /** Optional file/media attachments */
+    attachments?: GatewayAttachment[];
+    /** Optional platform-specific metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Outbound message to send back via the platform
+ */
+export interface GatewayOutboundMessage {
+    /** Plain text response */
+    text?: string;
+    /** Platform-specific rich content (Slack blocks, WhatsApp templates, etc.) */
+    richContent?: Record<string, unknown>;
+    /** Optional file/media attachments */
+    attachments?: GatewayAttachment[];
+}
+/**
+ * Result of webhook verification (e.g., WhatsApp GET challenge, Slack url_verification)
+ */
+export type WebhookVerificationResult = {
+    verified: true;
+    response: unknown;
+} | {
+    verified: false;
+};
+/**
+ * Gateway adapter interface — implemented by platform-specific addon packages.
+ *
+ * Two responsibilities:
+ * 1. Parse incoming platform-specific format into normalized GatewayInboundMessage
+ * 2. Send outgoing GatewayOutboundMessage via the platform's API
+ */
+export interface GatewayAdapter {
+    /** Platform name (e.g., 'whatsapp', 'slack', 'telegram') */
+    name: string;
+    /** Parse platform-specific payload into normalized message. Return null to ignore (e.g., delivery receipts). */
+    parse(data: unknown): GatewayInboundMessage | null;
+    /** Send a message to a specific sender via the platform's API */
+    send(senderId: string, message: GatewayOutboundMessage): Promise<void>;
+    /** Initialize the adapter (connect to platform, start listening).
+     *  Called by GatewayService.start() — the adapter should call onMessage for each incoming event. */
+    init(onMessage: (data: unknown) => Promise<void>): Promise<void>;
+    /** Tear down the adapter (disconnect, release resources). */
+    close(): Promise<void>;
+    /** Handle webhook verification challenges (only for webhook type).
+     *  Receives the data (body or query params) and the Pikku HTTP request for additional inspection. */
+    verifyWebhook?(data: unknown, request?: PikkuHTTPRequest): WebhookVerificationResult | Promise<WebhookVerificationResult>;
+}
+/**
+ * The gateway wire object available on wire.gateway inside handler functions and middleware
+ */
+export interface PikkuGateway {
+    /** Name of this gateway instance */
+    gatewayName: string;
+    /** Platform-specific sender identifier */
+    senderId: string;
+    /** Platform name from adapter.name */
+    platform: string;
+    /** Send a proactive message to the sender */
+    send(msg: GatewayOutboundMessage): Promise<void>;
+}
+/**
+ * Gateway transport type:
+ * - 'webhook': Platform POSTs to us (WhatsApp Cloud API, Slack Events API, Telegram webhooks)
+ * - 'websocket': Client connects via WebSocket (WebChat, browser widget)
+ * - 'listener': Standalone event loop, no route (Baileys, Signal CLI, Matrix sync)
+ */
+export type GatewayTransportType = 'webhook' | 'websocket' | 'listener';
+/**
+ * Core gateway configuration for wireGateway()
+ */
+export type CoreGateway<PikkuFunctionConfig = CorePikkuFunctionConfig<any, any>, PikkuPermission extends CorePikkuPermission = CorePikkuPermission, PikkuMiddleware extends CorePikkuMiddleware = CorePikkuMiddleware> = {
+    /** Unique name for this gateway */
+    name: string;
+    /** Transport type */
+    type: GatewayTransportType;
+    /** HTTP route for webhook/websocket types */
+    route?: string;
+    /** The gateway adapter (parse inbound, send outbound) */
+    adapter: GatewayAdapter;
+    /** The handler function that processes parsed messages */
+    func: PikkuFunctionConfig;
+    /** Optional middleware chain (e.g., auth) */
+    middleware?: CorePikkuMiddlewareGroup<any, any>;
+    /** Optional permissions */
+    permissions?: CorePermissionGroup | PikkuPermission[];
+    /** Optional tags for categorization */
+    tags?: string[];
+    /** Whether authentication is required (default: true) */
+    auth?: boolean;
+};
+/**
+ * Metadata for a registered gateway, stored in state
+ */
+export type GatewayMeta = CommonWireMeta & {
+    name: string;
+    type: GatewayTransportType;
+    route?: string;
+    gateway: true;
+};
+/**
+ * All gateway metadata keyed by name
+ */
+export type GatewaysMeta = Record<string, GatewayMeta>;

package/dist/wirings/gateway/gateway.types.js

@@ -0,0 +1 @@
+export {};

package/dist/wirings/gateway/index.d.ts

@@ -0,0 +1,2 @@
+export { wireGateway, createListenerMessageHandler } from './gateway-runner.js';
+export type { GatewayAdapter, GatewayAttachment, GatewayInboundMessage, GatewayOutboundMessage, GatewayMeta, GatewaysMeta, GatewayTransportType, CoreGateway, PikkuGateway, WebhookVerificationResult, } from './gateway.types.js';

package/dist/wirings/gateway/index.js

@@ -0,0 +1 @@
+export { wireGateway, createListenerMessageHandler } from './gateway-runner.js';

package/dist/wirings/http/http-routes.js

@@ -113,7 +113,6 @@ function registerRoute(route, groupConfig) {
         contentType: route.contentType,
         timeout: route.timeout,
         headers: route.headers,
-        docs: route.docs,
         sse: route.sse,
     });
 }

package/dist/wirings/http/http-runner.d.ts

@@ -136,4 +136,4 @@ export declare const pikkuFetch: <In, Out>(request: Request | PikkuHTTPRequest,
  * @param {RunHTTPWiringOptions} options - Options such as singleton services, session handling, and error configuration.
  * @returns {Promise<Out | void>} The output from the route handler or void if an error occurred.
  */
-export declare const fetchData: <In, Out>(request: Request | PikkuHTTPRequest, response: PikkuHTTPResponse, { skipUserSession, respondWith404, logWarningsForStatusCodes, coerceDataFromSchema, bubbleErrors, generateRequestId, }?: RunHTTPWiringOptions) => Promise<Out | void>;
+export declare const fetchData: <In, Out>(request: Request | PikkuHTTPRequest, response: PikkuHTTPResponse, { skipUserSession, respondWith404, logWarningsForStatusCodes, coerceDataFromSchema, bubbleErrors, exposeErrors, generateRequestId, }?: RunHTTPWiringOptions) => Promise<Out | void>;

package/dist/wirings/http/http-runner.js

@@ -7,6 +7,7 @@ import { pikkuState } from '../../pikku-state.js';
 import { PikkuFetchHTTPResponse } from './pikku-fetch-http-response.js';
 import { PikkuFetchHTTPRequest } from './pikku-fetch-http-request.js';
 import { addFunction, runPikkuFunc } from '../../function/function-runner.js';
+import { applyWebResponse } from './web-request.js';
 import { httpRouter } from './routers/http-router.js';
 import { validateSchema } from '../../schema.js';
 import { runMiddleware } from '../../middleware-runner.js';
@@ -240,6 +241,9 @@ const executeRoute = async (services, matchedRoute, http, options) => {
             send: (data) => {
                 response.arrayBuffer(isSerializable(data) ? JSON.stringify(data) : data);
             },
+            sendBinary: (data) => {
+                response.arrayBuffer(data);
+            },
             close: () => {
                 channel.state = 'closed';
                 response.close?.();
@@ -268,9 +272,13 @@ const executeRoute = async (services, matchedRoute, http, options) => {
         tags: route.tags,
         wire,
         sessionService: userSession,
+        packageName: meta.packageName,
     });
     if (!matchedRoute.route.sse) {
-        if (result === undefined || result === null) {
+        if (result instanceof Response) {
+            await applyWebResponse(http.response, result);
+        }
+        else if (result === undefined || result === null) {
             http?.response?.status(204);
         }
         else if (route.returnsJSON === false) {
@@ -338,7 +346,7 @@ export const pikkuFetch = async (request, params = {}) => {
  * @param {RunHTTPWiringOptions} options - Options such as singleton services, session handling, and error configuration.
  * @returns {Promise<Out | void>} The output from the route handler or void if an error occurred.
  */
-export const fetchData = async (request, response, { skipUserSession = false, respondWith404 = true, logWarningsForStatusCodes = [], coerceDataFromSchema = true, bubbleErrors = false, generateRequestId, } = {}) => {
+export const fetchData = async (request, response, { skipUserSession = false, respondWith404 = true, logWarningsForStatusCodes = [], coerceDataFromSchema = true, bubbleErrors = false, exposeErrors = false, generateRequestId, } = {}) => {
     const singletonServices = getSingletonServices();
     const createWireServices = getCreateWireServices();
     let wireServices;
@@ -386,7 +394,24 @@ export const fetchData = async (request, response, { skipUserSession = false, re
         return result;
     }
     catch (e) {
-        handleHTTPError(e, http, requestId, singletonServices.logger, logWarningsForStatusCodes, respondWith404, bubbleErrors);
+        if (matchedRoute?.route.sse) {
+            // For SSE routes, send error through the stream since the response is already in stream mode
+            singletonServices.logger.error(e instanceof Error ? e.message : e);
+            try {
+                response.arrayBuffer(JSON.stringify({
+                    type: 'error',
+                    errorText: e instanceof Error ? e.message : String(e),
+                }));
+                response.arrayBuffer('[DONE]');
+            }
+            catch (streamErr) {
+                singletonServices.logger.error(`SSE error while sending error payload: ${streamErr instanceof Error ? streamErr.message : String(streamErr)}`);
+            }
+            response.close?.();
+        }
+        else {
+            handleHTTPError(e, http, requestId, singletonServices.logger, logWarningsForStatusCodes, respondWith404, bubbleErrors, exposeErrors);
+        }
     }
     finally {
         // Clean up any session-specific services created during processing

package/dist/wirings/http/http.types.d.ts

@@ -1,6 +1,5 @@
 import type { SerializeOptions } from 'cookie';
 import type { StandardSchemaV1 } from '@standard-schema/spec';
-import type { PikkuError } from '../../errors/error-handler.js';
 import type { CorePikkuMiddleware, CommonWireMeta } from '../../types/core.types.js';
 import type { CorePikkuFunction, CorePikkuFunctionSessionless, CorePikkuPermission, CorePermissionGroup, CorePikkuFunctionConfig } from '../../function/functions.types.js';
 type ExtractHTTPWiringParams<S extends string> = S extends `${string}:${infer Param}/${infer Rest}` ? Param | ExtractHTTPWiringParams<`/${Rest}`> : S extends `${string}:${infer Param}` ? Param : never;
@@ -16,6 +15,7 @@ export type RunHTTPWiringOptions = Partial<{
     logWarningsForStatusCodes: number[];
     coerceDataFromSchema: boolean;
     bubbleErrors: boolean;
+    exposeErrors: boolean;
     generateRequestId: () => string;
 }>;
 /**
@@ -27,15 +27,6 @@ export type HTTPMethod = 'post' | 'get' | 'delete' | 'patch' | 'head' | 'put' |
  * Uses Standard Schema interface - works with Zod, Valibot, ArkType, Effect Schema, etc.
  */
 export type HTTPHeadersSchema = StandardSchemaV1<Record<string, string | string[] | undefined>>;
-/**
- * Documentation config for OpenAPI generation
- */
-export type HTTPRouteDocsConfig = {
-    description?: string;
-    response?: string;
-    errors?: Array<typeof PikkuError>;
-    tags?: string[];
-};
 /**
  * Common HTTP route configuration shared between wireHTTP and wireHTTPRoutes
  */
@@ -44,7 +35,6 @@ export type HTTPRouteBaseConfig = {
     timeout?: number;
     tags?: string[];
     headers?: HTTPHeadersSchema;
-    docs?: HTTPRouteDocsConfig;
 };
 /**
  * Represents an API HTTP wiring without a function, including metadata such as content type, route, and timeout settings.
@@ -167,6 +157,7 @@ export interface PikkuHTTPRequest<In = unknown> {
     data(): Promise<In>;
     json(): Promise<unknown>;
     arrayBuffer(): Promise<ArrayBuffer>;
+    headers(): Record<string, string>;
     header(headerName: string): string | null;
     cookie(name?: string): string | null;
     params(): Partial<Record<string, string | string[]>>;
@@ -179,6 +170,7 @@ export interface PikkuHTTPResponse<Out = unknown> {
     header(name: string, value: string | string[]): this;
     arrayBuffer(data: ArrayBuffer | ArrayBufferView | Blob | string | FormData | URLSearchParams | ReadableStream): this;
     json(data: Out): this;
+    send?(data: string | ArrayBuffer | Buffer): this;
     redirect(location: string, status?: number): this;
     close?: () => void;
     setMode?: (mode: 'stream') => void;

package/dist/wirings/http/index.d.ts

@@ -3,4 +3,5 @@ export { PikkuFetchHTTPResponse } from './pikku-fetch-http-response.js';
 export { logRoutes } from './log-http-routes.js';
 export { fetch, fetchData, wireHTTP, addHTTPMiddleware, addHTTPPermission, } from './http-runner.js';
 export { wireHTTPRoutes, defineHTTPRoutes } from './http-routes.js';
-export type { AssertHTTPWiringParams, CoreHTTPFunctionWiring, HTTPMethod, HTTPRouteBaseConfig, HTTPWiringsMeta, PikkuHTTPRequest, PikkuHTTPResponse, PikkuQuery, RunHTTPWiringOptions, } from './http.types.js';
+export { toWebRequest, applyWebResponse } from './web-request.js';
+export type { AssertHTTPWiringParams, CoreHTTPFunctionWiring, HTTPMethod, HTTPRouteBaseConfig, HTTPRouteContract, HTTPRouteMap, HTTPWiringsMeta, PikkuHTTPRequest, PikkuHTTPResponse, PikkuQuery, RunHTTPWiringOptions, } from './http.types.js';

package/dist/wirings/http/index.js

@@ -3,3 +3,4 @@ export { PikkuFetchHTTPResponse } from './pikku-fetch-http-response.js';
 export { logRoutes } from './log-http-routes.js';
 export { fetch, fetchData, wireHTTP, addHTTPMiddleware, addHTTPPermission, } from './http-runner.js';
 export { wireHTTPRoutes, defineHTTPRoutes } from './http-routes.js';
+export { toWebRequest, applyWebResponse } from './web-request.js';

package/dist/wirings/http/pikku-fetch-http-request.d.ts

@@ -20,6 +20,7 @@ export declare class PikkuFetchHTTPRequest<In = unknown> implements PikkuHTTPReq
      * @returns A promise that resolves to the raw request body.
      */
     arrayBuffer(): Promise<ArrayBuffer>;
+    headers(): Record<string, string>;
     /**
      * Retrieves the value of a specific header.
      * @param headerName - The name of the header to retrieve.

package/dist/wirings/http/pikku-fetch-http-request.js

@@ -35,6 +35,9 @@ export class PikkuFetchHTTPRequest {
     arrayBuffer() {
         return this.request.arrayBuffer();
     }
+    headers() {
+        return Object.fromEntries(this.request.headers.entries());
+    }
     /**
      * Retrieves the value of a specific header.
      * @param headerName - The name of the header to retrieve.

package/dist/wirings/http/pikku-fetch-http-response.d.ts

@@ -10,6 +10,7 @@ export declare class PikkuFetchHTTPResponse implements PikkuHTTPResponse {
     json(data: unknown): this;
     text(content: string): this;
     html(content: string): this;
+    send(data: any): this;
     redirect(location: string, status?: number): this;
     close(): this;
     toResponse(args?: Record<string, any>): Response;

package/dist/wirings/http/pikku-fetch-http-response.js

@@ -71,10 +71,10 @@ export class PikkuFetchHTTPResponse {
         }
         return this;
     }
-    // public body(body: BodyInit): this {
-    //   this.#body = body
-    //   return this
-    // }
+    send(data) {
+        this.#body = data;
+        return this;
+    }
     redirect(location, status = 302) {
         if (!location.startsWith('/') &&
             !location.startsWith('https://') &&

package/dist/wirings/http/web-request.d.ts

@@ -0,0 +1,12 @@
+import type { PikkuHTTPRequest } from './http.types.js';
+import type { PikkuHTTPResponse } from './http.types.js';
+/**
+ * Converts a PikkuHTTPRequest into a Web API Request.
+ * Useful for bridging Pikku routes to libraries that expect standard Web Request objects.
+ */
+export declare function toWebRequest(req: PikkuHTTPRequest, baseUrl?: string): Request;
+/**
+ * Applies a Web API Response to a PikkuHTTPResponse.
+ * Copies status, headers (including Set-Cookie), redirects, and body.
+ */
+export declare function applyWebResponse(res: PikkuHTTPResponse, webResponse: Response): Promise<void>;

package/dist/wirings/http/web-request.js

@@ -0,0 +1,85 @@
+/**
+ * Converts a PikkuHTTPRequest into a Web API Request.
+ * Useful for bridging Pikku routes to libraries that expect standard Web Request objects.
+ */
+export function toWebRequest(req, baseUrl) {
+    const url = new URL(req.path(), baseUrl ?? `http://${req.header('host') ?? 'localhost'}`);
+    const query = req.query();
+    for (const [key, value] of Object.entries(query)) {
+        if (value != null) {
+            url.searchParams.set(key, String(value));
+        }
+    }
+    const headers = new Headers(req.headers());
+    const method = req.method().toUpperCase();
+    const hasBody = !['GET', 'HEAD', 'OPTIONS'].includes(method);
+    if (!hasBody) {
+        return new Request(url, { method, headers });
+    }
+    return new Request(url, {
+        method,
+        headers,
+        body: new ReadableStream({
+            async start(controller) {
+                try {
+                    const buffer = await req.arrayBuffer();
+                    if (buffer.byteLength > 0) {
+                        controller.enqueue(new Uint8Array(buffer));
+                    }
+                    else {
+                        // arrayBuffer may be empty if body was pre-parsed (e.g., Express middleware)
+                        const contentType = (headers.get('content-type') || '').toLowerCase();
+                        const parsed = await req.json();
+                        if (parsed &&
+                            typeof parsed === 'object' &&
+                            Object.keys(parsed).length > 0) {
+                            let reconstructed;
+                            if (contentType.includes('application/x-www-form-urlencoded')) {
+                                reconstructed = new URLSearchParams(parsed).toString();
+                            }
+                            else {
+                                reconstructed = JSON.stringify(parsed);
+                            }
+                            controller.enqueue(new TextEncoder().encode(reconstructed));
+                        }
+                    }
+                }
+                catch {
+                    // Empty body
+                }
+                controller.close();
+            },
+        }),
+        // @ts-ignore - duplex is needed for streaming body in Node.js
+        duplex: 'half',
+    });
+}
+const SKIP_RESPONSE_HEADERS = new Set(['content-length', 'transfer-encoding']);
+/**
+ * Applies a Web API Response to a PikkuHTTPResponse.
+ * Copies status, headers (including Set-Cookie), redirects, and body.
+ */
+export async function applyWebResponse(res, webResponse) {
+    res.status(webResponse.status);
+    webResponse.headers.forEach((value, name) => {
+        const lower = name.toLowerCase();
+        if (SKIP_RESPONSE_HEADERS.has(lower)) {
+            return;
+        }
+        if (lower === 'location') {
+            res.redirect(value, webResponse.status);
+        }
+        else {
+            res.header(name, value);
+        }
+    });
+    const body = await webResponse.text();
+    if (body) {
+        if (res.send) {
+            res.send(body);
+        }
+        else {
+            res.arrayBuffer(body);
+        }
+    }
+}

package/dist/wirings/mcp/mcp-endpoint-registry.js

@@ -12,7 +12,7 @@ export class MCPEndpointRegistry {
                     name: tool.name,
                     title: tool.title,
                     description: tool.description,
-                    inputSchema: tool.parameters,
+                    inputSchema: tool.parameters ?? { type: 'object' },
                     outputSchema: tool.returns,
                     enabled: tool.enabled !== undefined ? tool.enabled : true,
                 });

package/dist/wirings/mcp/mcp-runner.js

@@ -2,6 +2,7 @@ import { getErrorResponse } from '../../errors/error-handler.js';
 import { closeWireServices } from '../../utils.js';
 import { pikkuState, getSingletonServices, getCreateWireServices, } from '../../pikku-state.js';
 import { addFunction, runPikkuFunc } from '../../function/function-runner.js';
+import { resolveNamespace } from '../rpc/rpc-runner.js';
 import { BadRequestError, NotFoundError, PikkuMissingMetaError, } from '../../errors/errors.js';
 import { PikkuSessionService, createMiddlewareSessionWireProps, } from '../../services/user-session-service.js';
 export class MCPError extends Error {
@@ -115,7 +116,17 @@ async function runMCPPikkuFunc(request, type, name, mcp, pikkuFuncId, { mcp: mcp
         else if (type === 'prompt') {
             meta = pikkuState(null, 'mcp', 'promptsMeta')[name];
         }
-        let result = await runPikkuFunc('mcp', `${type}:${name}`, pikkuFuncId, {
+        // Resolve namespaced function IDs (e.g., 'swaggerPetstore:findPetsByStatus')
+        let resolvedFuncName = pikkuFuncId;
+        let resolvedPackageName = meta?.packageName ?? null;
+        if (pikkuFuncId.includes(':')) {
+            const resolved = resolveNamespace(pikkuFuncId);
+            if (resolved) {
+                resolvedFuncName = resolved.function;
+                resolvedPackageName = resolved.package;
+            }
+        }
+        let result = await runPikkuFunc('mcp', `${type}:${name}`, resolvedFuncName, {
             singletonServices,
             createWireServices,
             data: () => request.params,
@@ -126,6 +137,7 @@ async function runMCPPikkuFunc(request, type, name, mcp, pikkuFuncId, { mcp: mcp
             tags: mcp?.tags,
             wire,
             sessionService: mcpSessionService,
+            packageName: resolvedPackageName,
         });
         if (type === 'tool' && meta?.outputSchema !== 'MCPToolResponse') {
             result = [{ type: 'text', text: JSON.stringify(result) }];

package/dist/wirings/rpc/rpc-runner.d.ts

@@ -2,13 +2,18 @@ import type { CoreServices, PikkuWire } from '../../types/core.types.js';
 import type { SessionService } from '../../services/user-session-service.js';
 import type { CoreUserSession } from '../../types/core.types.js';
 import { PikkuError } from '../../errors/error-handler.js';
-import type { PikkuRPC } from './rpc-types.js';
+import type { PikkuRPC, ResolvedFunction } from './rpc-types.js';
 export declare class RPCNotFoundError extends PikkuError {
     readonly rpcName: string;
     constructor(rpcName: string);
 }
 import type { AIAgentInput } from '../ai-agent/ai-agent.types.js';
 import type { StreamAIAgentOptions } from '../ai-agent/ai-agent-prepare.js';
+/**
+ * Resolve a namespaced function reference to package and function names
+ * Uses pikkuState to look up the namespace -> package mapping
+ */
+export declare const resolveNamespace: (namespacedFunction: string) => ResolvedFunction | null;
 export declare class ContextAwareRPCService {
     private services;
     private wire;
@@ -39,6 +44,14 @@ export declare class ContextAwareRPCService {
     }>;
     get agent(): {
         run: (agentName: string, input: AIAgentInput) => Promise<{
+            status?: "suspended" | undefined;
+            pendingApprovals?: {
+                toolCallId: string;
+                toolName: string;
+                args: unknown;
+                reason?: string;
+                runId: string;
+            }[] | undefined;
             runId: string;
             result: {};
             usage: {
@@ -50,7 +63,9 @@ export declare class ContextAwareRPCService {
             message: string;
             threadId: string;
             resourceId: string;
-        } | Record<string, unknown>, options?: StreamAIAgentOptions) => Promise<void>;
+            model?: string;
+            temperature?: number;
+        }, options?: StreamAIAgentOptions) => Promise<void>;
         resume: (runId: string, input: {
             toolCallId: string;
             approved: boolean;
@@ -59,11 +74,20 @@ export declare class ContextAwareRPCService {
             toolCallId: string;
             approved: boolean;
         }[], expectedAgentName?: string) => Promise<{
-            status: "resumed" | "suspended";
+            status?: "suspended" | undefined;
+            pendingApprovals?: {
+                toolCallId: string;
+                toolName: string;
+                args: unknown;
+                reason?: string;
+                runId: string;
+            }[] | undefined;
             runId: string;
-            approved: string[];
-            rejected: string[];
-            remainingApprovals: number;
+            result: {};
+            usage: {
+                inputTokens: number;
+                outputTokens: number;
+            };
         }>;
     };
     remote<In = any, Out = any>(funcName: string, data: In): Promise<Out>;