@pikku/core 0.12.2 → 0.12.3

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';
@@ -271,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) {
@@ -341,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;
@@ -389,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>;

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

@@ -1,7 +1,7 @@
 import { runPikkuFunc } from '../../function/function-runner.js';
 import { pikkuState } from '../../pikku-state.js';
 import { ForbiddenError } from '../../errors/errors.js';
-import { PikkuError } from '../../errors/error-handler.js';
+import { PikkuError, addError } from '../../errors/error-handler.js';
 import { parseVersionedId } from '../../version.js';
 import { encryptJSON } from '../../crypto-utils.js';
 export class RPCNotFoundError extends PikkuError {
@@ -11,29 +11,33 @@ export class RPCNotFoundError extends PikkuError {
         this.rpcName = rpcName;
     }
 }
-import { runAIAgent } from '../ai-agent/ai-agent-runner.js';
+addError(RPCNotFoundError, {
+    status: 404,
+    mcpCode: -32601,
+    message: 'RPC function not found.',
+});
+import { runAIAgent, resumeAIAgentSync } from '../ai-agent/ai-agent-runner.js';
 import { streamAIAgent, resumeAIAgent } from '../ai-agent/ai-agent-stream.js';
-import { approveAIAgent } from '../ai-agent/ai-agent-registry.js';
 /**
  * Resolve a namespaced function reference to package and function names
  * Uses pikkuState to look up the namespace -> package mapping
  */
-const resolveNamespace = (namespacedFunction) => {
+export const resolveNamespace = (namespacedFunction) => {
     const colonIndex = namespacedFunction.indexOf(':');
     if (colonIndex === -1) {
         return null;
     }
     const namespace = namespacedFunction.substring(0, colonIndex);
     const functionName = namespacedFunction.substring(colonIndex + 1);
-    const addons = pikkuState(null, 'rpc', 'addons');
+    const addons = pikkuState(null, 'addons', 'packages');
     const pkgConfig = addons.get(namespace);
     if (!pkgConfig) {
         return null;
     }
     return {
-        namespace,
         package: pkgConfig.package,
         function: functionName,
+        addonConfig: pkgConfig,
     };
 };
 const getPikkuFunctionName = (rpcName) => {
@@ -72,7 +76,7 @@ export class ContextAwareRPCService {
             functionMeta = pikkuState(null, 'function', 'meta')[funcName];
         }
         if (!functionMeta) {
-            throw new Error(`Function not found: ${funcName}`);
+            throw new RPCNotFoundError(funcName);
         }
         if (!functionMeta.expose) {
             throw new ForbiddenError();
@@ -125,9 +129,11 @@ export class ContextAwareRPCService {
                 `Available functions: ${Object.keys(addonFunctionMeta).join(', ') || '(none)'}`);
         }
         const funcName = funcMeta.pikkuFuncId || resolved.function;
-        const addonConfig = pikkuState(null, 'rpc', 'addons').get(resolved.namespace);
-        const auth = addonConfig?.auth ?? this.options.requiresAuth;
-        const tags = [...(addonConfig?.tags ?? []), ...(funcMeta.tags ?? [])];
+        const auth = resolved.addonConfig?.auth ?? this.options.requiresAuth;
+        const tags = [
+            ...(resolved.addonConfig?.tags ?? []),
+            ...(funcMeta.tags ?? []),
+        ];
         // Execute the function using runPikkuFunc with the addon package's state
         // We use the parent services (this.services) since addon packages share services
         // Pass the function's tags so tag-based middleware/permissions are applied
@@ -153,6 +159,9 @@ export class ContextAwareRPCService {
                 }
                 : undefined,
         };
+        if (rpcName.includes(':')) {
+            return this.invokeAddonFunction(rpcName, data, mergedWire);
+        }
         return runPikkuFunc('rpc', rpcName, getPikkuFunctionName(rpcName), {
             auth: this.options.requiresAuth,
             singletonServices: this.services,
@@ -182,6 +191,10 @@ export class ContextAwareRPCService {
                     runId: result.runId,
                     result: result.object ?? result.text,
                     usage: result.usage,
+                    ...(result.status === 'suspended' && {
+                        status: 'suspended',
+                        pendingApprovals: result.pendingApprovals,
+                    }),
                 };
             },
             stream: async (agentName, input, options) => {
@@ -197,9 +210,18 @@ export class ContextAwareRPCService {
                 await resumeAIAgent({ runId, ...input }, channel, { sessionService: this.options.sessionService }, options);
             },
             approve: async (runId, approvals, expectedAgentName) => {
-                if (!this.services.aiRunState)
-                    throw new Error('AIRunStateService not available');
-                return approveAIAgent(this.services.aiRunState, runId, approvals, expectedAgentName);
+                const result = await resumeAIAgentSync(runId, approvals, {
+                    sessionService: this.options.sessionService,
+                }, expectedAgentName);
+                return {
+                    runId: result.runId,
+                    result: result.object ?? result.text,
+                    usage: result.usage,
+                    ...(result.status === 'suspended' && {
+                        status: 'suspended',
+                        pendingApprovals: result.pendingApprovals,
+                    }),
+                };
             },
         };
     }
@@ -211,7 +233,7 @@ export class ContextAwareRPCService {
         const colonIndex = funcName.indexOf(':');
         if (colonIndex !== -1) {
             const namespace = funcName.substring(0, colonIndex);
-            const addons = pikkuState(null, 'rpc', 'addons');
+            const addons = pikkuState(null, 'addons', 'packages');
             const pkgConfig = addons.get(namespace);
             endpoint = pkgConfig?.rpcEndpoint;
         }

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

@@ -34,7 +34,12 @@ export interface RPCHandler<Input, Output> {
  * Resolved function reference from namespace
  */
 export interface ResolvedFunction {
-    namespace: string;
     package: string;
     function: string;
+    addonConfig: {
+        package: string;
+        auth?: boolean;
+        tags?: string[];
+        rpcEndpoint?: string;
+    };
 }

package/dist/wirings/rpc/wire-addon.d.ts

@@ -3,6 +3,7 @@ export type WireAddonConfig = {
     package: string;
     rpcEndpoint?: string;
     auth?: boolean;
+    mcp?: boolean;
     tags?: string[];
     secretOverrides?: Record<string, string>;
     variableOverrides?: Record<string, string>;

package/dist/wirings/rpc/wire-addon.js

@@ -1,6 +1,6 @@
 import { pikkuState } from '../../pikku-state.js';
 export const wireAddon = (config) => {
-    pikkuState(null, 'rpc', 'addons').set(config.name, {
+    pikkuState(null, 'addons', 'packages').set(config.name, {
         package: config.package,
         rpcEndpoint: config.rpcEndpoint,
         auth: config.auth,

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

@@ -72,6 +72,7 @@ export async function runScheduledTask({ name, session, }) {
             tags: task.tags,
             wire,
             sessionService: userSession,
+            packageName: meta.packageName,
         });
     }
     catch (e) {

package/dist/wirings/workflow/graph/graph-validation.d.ts

@@ -0,0 +1,3 @@
+export declare function computeEntryNodeIds(nodes: Record<string, any>): string[];
+export declare function validateWorkflowWiring(nodes: Record<string, any>, toolNames: string[]): string[];
+export declare function generateMermaidDiagram(workflowName: string, nodes: Record<string, any>, entryNodeIds: string[]): string;