@pikku/core 0.12.78 → 0.12.80

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

@@ -3,6 +3,18 @@ import { addFunction } from '../../function/function-runner.js';
 import { pikkuState, getSingletonServices } from '../../pikku-state.js';
 import { coerceTopLevelDataFromSchema, validateSchema } from '../../schema.js';
 import { httpRouter } from '../http/routers/http-router.js';
+/**
+ * The config to register for a channel handler: the handler itself when it is a
+ * direct function config, or its inner `func` when it is a wrapper.
+ *
+ * knowledge: decisions/internals/channel-message-handlers-accept-three-config-shapes.md
+ */
+const registeredHandler = (handler) => {
+    const candidate = handler;
+    return typeof candidate.func === 'function'
+        ? handler
+        : candidate.func;
+};
 export const wireChannel = (channel) => {
     const channelsMeta = pikkuState(null, 'channel', 'meta');
     const channelMeta = channelsMeta[channel.name];
@@ -11,15 +23,13 @@ export const wireChannel = (channel) => {
         return;
     }
     if (channel.onConnect && channelMeta.connect) {
-        addFunction(channelMeta.connect.pikkuFuncId, channel.onConnect);
+        addFunction(channelMeta.connect.pikkuFuncId, registeredHandler(channel.onConnect));
     }
     if (channel.onDisconnect && channelMeta.disconnect) {
-        addFunction(channelMeta.disconnect.pikkuFuncId, channel.onDisconnect);
+        addFunction(channelMeta.disconnect.pikkuFuncId, registeredHandler(channel.onDisconnect));
     }
     if (channel.onMessage && channelMeta.message?.pikkuFuncId) {
-        addFunction(channelMeta.message.pikkuFuncId, channel.onMessage.func instanceof Function
-            ? channel.onMessage
-            : channel.onMessage.func);
+        addFunction(channelMeta.message.pikkuFuncId, registeredHandler(channel.onMessage));
     }
     if (channel.onMessageWiring && channelMeta.messageWirings) {
         Object.entries(channel.onMessageWiring).forEach(([channelKey, wirings]) => {
@@ -30,9 +40,7 @@ export const wireChannel = (channel) => {
                 const wiringMeta = channelWirings[wiringKey];
                 if (!wiringMeta)
                     return;
-                addFunction(wiringMeta.pikkuFuncId, handler.func instanceof Function
-                    ? handler
-                    : handler.func);
+                addFunction(wiringMeta.pikkuFuncId, registeredHandler(handler));
             });
         });
     }

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

@@ -37,6 +37,8 @@ export interface ChannelMeta {
     message: ChannelMessageMeta | null;
     messageWirings: Record<string, Record<string, ChannelMessageMeta>>;
     binary?: boolean | null;
+    /** Set when the channel was wired by a gateway rather than declared directly. */
+    gateway?: boolean;
     summary?: string;
     description?: string;
     errors?: string[];

package/dist/wirings/channel/pikku-abstract-channel-handler.js

@@ -22,6 +22,7 @@ export class PikkuAbstractChannelHandler {
                 setState: (s) => {
                     channelState = s;
                 },
+                // knowledge: decisions/internals/channel-state-accessors-are-unsound-generics-that-every-implementation-asserts.md
                 getState: () => channelState,
                 clearState: () => {
                     channelState = undefined;

package/dist/wirings/channel/serverless/serverless-channel-runner.js

@@ -55,6 +55,7 @@ export const runChannelConnect = async ({ channelId, channelObject, request, res
             channelName: channelConfig.name,
         });
         channel.setState = (state) => channelStore.setState(channelId, state);
+        // knowledge: decisions/internals/channel-state-accessors-are-unsound-generics-that-every-implementation-asserts.md
         channel.getState = () => channelStore.getState(channelId);
         channel.clearState = () => channelStore.clearState(channelId);
         const wire = {
@@ -116,6 +117,7 @@ export const runChannelDisconnect = async ({ channelId, channelStore, channelHan
         channelName,
     });
     channel.setState = (state) => channelStore.setState(channelId, state);
+    // knowledge: decisions/internals/channel-state-accessors-are-unsound-generics-that-every-implementation-asserts.md
     channel.getState = () => channelStore.getState(channelId);
     channel.clearState = () => channelStore.clearState(channelId);
     const userSession = new PikkuSessionService(singletonServices.sessionStore);
@@ -171,6 +173,7 @@ export const runChannelMessage = async ({ channelId, channelStore, channelHandle
         channelName,
     });
     channel.setState = (state) => channelStore.setState(channelId, state);
+    // knowledge: decisions/internals/channel-state-accessors-are-unsound-generics-that-every-implementation-asserts.md
     channel.getState = () => channelStore.getState(channelId);
     channel.clearState = () => channelStore.clearState(channelId);
     const userSession = new PikkuSessionService(singletonServices.sessionStore);

package/dist/wirings/cli/channel/cli-channel-runner.js

@@ -50,6 +50,8 @@ export async function executeCLIViaChannel({ programName, pikkuWS, args = proces
                 resolve(undefined);
                 return;
             }
+            // A CLI channel response is rendered off-process: there are no services
+            // to hand the renderer, and every CLI renderer ignores the argument.
             renderer(null, response, undefined);
         };
         commandRoute.subscribe(commandId, responseHandler);

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

@@ -2,7 +2,7 @@ import { NotFoundError } from '../../errors/errors.js';
 import { isExpectedError } from '../../errors/error-handler.js';
 import { addFunction, runPikkuFunc } from '../../function/function-runner.js';
 import { pikkuState } from '../../pikku-state.js';
-import { unsupportedChannelRemote } from '../channel/channel-rpc.js';
+import { unsupportedChannelRemote } from '../channel/channel-rpc.types.js';
 import { PikkuSessionService, createMiddlewareSessionWireProps, } from '../../services/user-session-service.js';
 import { LocalVariablesService } from '../../services/local-variables.js';
 import { generateCommandHelp, parseCLIArguments } from './command-parser.js';
@@ -186,6 +186,7 @@ export async function runCLICommand({ program, commandPath, data, singletonServi
         setState: (s) => {
             cliState = s;
         },
+        // knowledge: decisions/internals/channel-state-accessors-are-unsound-generics-that-every-implementation-asserts.md
         getState: () => cliState,
         clearState: () => {
             cliState = undefined;
@@ -230,7 +231,8 @@ export async function runCLICommand({ program, commandPath, data, singletonServi
         // caller, and emitting it here too would deliver it twice.
         if (result !== undefined && !onOutput) {
             const commandRenderer = programData?.renderers[commandId];
-            const jsonMode = data.json === true || data.output === 'json';
+            const jsonMode = data.json === true ||
+                data.output === 'json';
             const finalRenderer = jsonMode && commandRenderer !== undefined
                 ? defaultJSONRenderer
                 : (commandRenderer ?? programData?.defaultRenderer);

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

@@ -135,10 +135,6 @@ type AllParamsValid<Params extends readonly any[], Input> = Params extends reado
  * Validate that all parameter names are valid keys of the function input
  */
 export type ValidateParameters<Params extends string, Input> = AllParamsValid<ExtractParameterNames<Params>, Input> extends true ? Params : never;
-/**
- * Extract output type from a Pikku function config type
- */
-export type ExtractFunctionOutput<Func> = Func extends CorePikkuFunctionConfig<infer FuncType, any, any> ? FuncType extends CorePikkuFunction<any, infer Output, any, any, any> | CorePikkuFunctionSessionless<any, infer Output, any, any, any> ? Output : never : never;
 /**
  * CLI command configuration that infers options from function input type.
  * This is a helper type for creating type-safe CLI commands.
@@ -184,10 +180,6 @@ export interface CoreCLICommand<In, Out, PikkuFunctionConfig extends CorePikkuFu
  * Shorthand command definition (just a function)
  */
 export type CLICommandShorthand<In, Out, PikkuFunctionConfig extends CorePikkuFunctionConfig<CorePikkuFunction<In, Out, any, any, any> | CorePikkuFunctionSessionless<In, Out, any, any, any>>> = PikkuFunctionConfig;
-/**
- * Command definition (either full or shorthand)
- */
-export type CLICommandDefinition<In, Out, PikkuFunctionConfig extends CorePikkuFunctionConfig<CorePikkuFunction<In, Out, any, any, any> | CorePikkuFunctionSessionless<In, Out, any, any, any>>, PikkuPermission extends CorePikkuPermission<any, any, any>, PikkuMiddleware extends CorePikkuMiddleware, Options = any, Subcommands extends Record<string, CoreCLICommandConfig<any, any, any>> = Record<string, CoreCLICommandConfig<any, any, any>>> = CoreCLICommand<In, Out, PikkuFunctionConfig, PikkuPermission, PikkuMiddleware, Options, Subcommands> | CLICommandShorthand<In, Out, PikkuFunctionConfig>;
 /**
  * CLI wiring configuration
  */

package/dist/wirings/cli/command-parser.js

@@ -49,6 +49,14 @@ function warnUnknownOption(typed, availableOptions, result) {
     result.warnings.push(`Unknown option: --${typed} (ignored)` +
         (suggestion ? ` Did you mean --${suggestion}?` : ''));
 }
+/**
+ * A real short-flag cluster is a handful of characters (`-abc`). Anything past
+ * this is treated as a single malformed token rather than scanned per
+ * character — the parser runs over untrusted CLI-channel frames, and a
+ * multi-megabyte `-aaaa…` would otherwise be O(length) work that also pushed
+ * one error per character.
+ */
+const MAX_SHORT_FLAG_CLUSTER = 64;
 export function parseCLIArguments(args, programName, allMeta) {
     const result = {
         program: programName,
@@ -176,6 +184,11 @@ export function parseCLIArguments(args, programName, allMeta) {
             }
         }
         else if (arg.startsWith('-') && arg.length > 1) {
+            if (arg.length > MAX_SHORT_FLAG_CLUSTER) {
+                result.errors.push(`Unknown option: ${arg.slice(0, MAX_SHORT_FLAG_CLUSTER)}… (too long)`);
+                currentIndex++;
+                continue;
+            }
             for (let i = 1; i < arg.length; i++) {
                 const shortFlag = arg[i];
                 const longOption = findLongOption(shortFlag, availableOptions);

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

@@ -14,19 +14,42 @@ const bridgeMiddlewareSession = async (wire) => {
         wire.session = session;
     }
 };
+/**
+ * Metadata the inspector recorded for the function the gateway was wired with.
+ * The bootstrap loads every meta file before any wiring file, so this is
+ * already populated by the time a gateway wires itself. A gateway wired by
+ * hand rather than through codegen has no entry, and falls back to the
+ * sessionless default below.
+ */
+const declaredHandlerMeta = (config) => {
+    const declaredFuncId = pikkuState(null, 'gateway', 'meta')[config.name]
+        ?.pikkuFuncId;
+    return declaredFuncId
+        ? pikkuState(null, 'function', 'meta')[declaredFuncId]
+        : undefined;
+};
 // knowledge: decisions/security/gateway-handlers-run-through-the-function-runner-gate.md
 const registerGatewayHandler = (config) => {
     const funcId = gatewayHandlerFuncId(config.name);
     const funcMeta = pikkuState(null, 'function', 'meta');
+    const declared = declaredHandlerMeta(config);
     funcMeta[funcId] = {
+        ...declared,
         pikkuFuncId: funcId,
-        inputSchemaName: null,
-        outputSchemaName: null,
-        sessionless: true,
+        inputSchemaName: declared?.inputSchemaName ?? null,
+        outputSchemaName: declared?.outputSchemaName ?? null,
+        sessionless: declared?.sessionless ?? true,
     };
     addFunction(funcId, config.func);
     return funcId;
 };
+/**
+ * Tag middleware the inspector resolved for this gateway. It is keyed by
+ * gateway name rather than reachable from `config`, because `tags` is a
+ * compile-time input everywhere — nothing at runtime maps a tag to its
+ * middleware group.
+ */
+const gatewayInheritedMiddleware = (config) => pikkuState(null, 'gateway', 'meta')[config.name]?.middleware;
 export const resolveGatewayAdapter = (config, services) => {
     let resolved = resolvedAdapters.get(config);
     if (!resolved) {
@@ -74,6 +97,9 @@ const wireWebhookGateway = (config) => {
         route,
         func: postHandler,
         auth: false,
+        // A gateway handler takes (services, data, wire) rather than a pikku
+        // function's shape, so it never matches CorePikkuFunctionConfig. It is only
+        // ever invoked through runPikkuFunc, which is what makes that safe.
     });
     // knowledge: decisions/internals/gateway-adapters-resolve-lazily-and-are-promise-cached.md
     if (typeof adapter === 'function' || adapter.verifyWebhook) {
@@ -100,6 +126,7 @@ const wireWebhookGateway = (config) => {
 const createWebhookPostHandler = (config) => {
     const { name, middleware: userMiddleware } = config;
     const handlerFuncId = registerGatewayHandler(config);
+    const inheritedMiddleware = gatewayInheritedMiddleware(config);
     return async (services, data, wire) => {
         const adapter = await resolveGatewayAdapter(config, services);
         if (adapter.verifyWebhook) {
@@ -126,7 +153,8 @@ const createWebhookPostHandler = (config) => {
                 singletonServices: services,
                 data: () => parsed,
                 auth: config.auth,
-                wire: wire,
+                inheritedMiddleware,
+                wire,
             });
         };
         const gatewayMiddleware = userMiddleware;
@@ -186,11 +214,15 @@ const wireWebsocketGateway = (config) => {
         name,
         route,
         gateway: true,
+        input: null,
         connect: { pikkuFuncId: connectFuncId },
+        disconnect: null,
         message: { pikkuFuncId: messageFuncId },
+        messageWirings: {},
     };
     const userMiddleware = config.middleware;
     const handlerFuncId = registerGatewayHandler(config);
+    const inheritedMiddleware = gatewayInheritedMiddleware(config);
     addFunction(connectFuncId, {
         auth: false,
         func: async (services, _data, wire) => {
@@ -227,7 +259,8 @@ const wireWebsocketGateway = (config) => {
                     singletonServices: services,
                     data: () => parsed,
                     auth: config.auth,
-                    wire: wire,
+                    inheritedMiddleware,
+                    wire,
                 });
             };
             const gatewayMiddleware = userMiddleware;
@@ -256,6 +289,7 @@ const wireListenerGateway = (config) => {
 export const createListenerMessageHandler = (name, config, singletonServices) => {
     const userMiddleware = config.middleware;
     const handlerFuncId = registerGatewayHandler(config);
+    const inheritedMiddleware = gatewayInheritedMiddleware(config);
     return async (rawData) => {
         const adapter = await resolveGatewayAdapter(config, singletonServices);
         const parsed = adapter.parse(rawData);
@@ -275,9 +309,11 @@ export const createListenerMessageHandler = (name, config, singletonServices) =>
                 singletonServices,
                 data: () => parsed,
                 auth: config.auth,
+                inheritedMiddleware,
                 wire,
             });
         };
+        // knowledge: decisions/internals/gateway-listener-middleware-runs-without-an-rpc-on-the-wire.md
         const result = userMiddleware?.length
             ? await runMiddleware(singletonServices, wire, userMiddleware, invoke)
             : await invoke();

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

@@ -54,6 +54,8 @@ function registerRoute(route, groupConfig) {
         timeout: route.timeout,
         headers: route.headers,
         sse: route.sse,
+        // `CoreHTTPFunctionWiring` is discriminated by `method`, and a group builds
+        // its routes from a method chosen at runtime — no arm can be narrowed to.
     });
 }
 function isRouteConfig(value) {

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

@@ -3,16 +3,6 @@ import type { CorePikkuFunction, CorePikkuFunctionSessionless, CorePikkuPermissi
 import type { CorePikkuMiddleware, CorePikkuMiddlewareGroup } from '../../types/core.types.js';
 import { PikkuFetchHTTPResponse } from './pikku-fetch-http-response.js';
 export declare const addHTTPMiddleware: <PikkuMiddleware extends CorePikkuMiddleware>(pattern: string, middleware: CorePikkuMiddlewareGroup, packageName?: string | null) => CorePikkuMiddlewareGroup;
-/**
- * @deprecated HTTP-route-level permissions were removed in #972 — permissions
- * are now function-scoped only (declare them on the function via
- * `pikkuFunc({ permissions })`). This throwing stub exists solely so the pinned
- * bootstrap CLI (which still generates an `addHTTPPermission` wrapper) can
- * resolve the import at build time; it is never called. Delete once
- * `PIKKU_CLI_VERSION` in the CLI build is bumped past the release that removes
- * HTTP-route permissions.
- */
-export declare const addHTTPPermission: (_pattern: string, _permissions: Record<string, CorePikkuPermission | CorePikkuPermission[]> | CorePikkuPermission[]) => never;
 export declare const wireHTTP: <In, Out, Route extends string, PikkuFunction extends CorePikkuFunction<In, Out> = CorePikkuFunction<In, Out>, PikkuFunctionSessionless extends CorePikkuFunctionSessionless<In, Out> = CorePikkuFunctionSessionless<In, Out>, PikkuPermissionGroup extends CorePikkuPermission<In> = CorePikkuPermission<In>, PikkuMiddleware extends CorePikkuMiddleware = CorePikkuMiddleware>(httpWiring: CoreHTTPFunctionWiring<In, Out, Route, PikkuFunction, PikkuFunctionSessionless, PikkuPermissionGroup, PikkuMiddleware>) => void;
 export declare const createHTTPWire: (request: PikkuHTTPRequest | undefined, response: PikkuHTTPResponse | undefined) => PikkuHTTP | undefined;
 export declare const fetch: <In, Out>(request: Request, params?: RunHTTPWiringOptions) => Promise<Response>;

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

@@ -8,7 +8,9 @@ import { isProduction } from '../../env.js';
 import { pikkuState } from '../../pikku-state.js';
 import { PikkuFetchHTTPResponse } from './pikku-fetch-http-response.js';
 import { PikkuFetchHTTPRequest } from './pikku-fetch-http-request.js';
-import { unsupportedChannelRemote } from '../channel/channel-rpc.js';
+// The leaf module, not the channel-rpc barrel: http needs one refusal
+// function, and the barrel drags in 4,932 lines of channel RPC runtime.
+import { unsupportedChannelRemote } from '../channel/channel-rpc.types.js';
 import { addFunction, runPikkuFunc } from '../../function/function-runner.js';
 import { applyWebResponse } from './web-request.js';
 import { httpRouter } from './routers/http-router.js';
@@ -32,18 +34,6 @@ export const addHTTPMiddleware = (pattern, middleware, packageName = null) => {
         : middleware;
     return middleware;
 };
-/**
- * @deprecated HTTP-route-level permissions were removed in #972 — permissions
- * are now function-scoped only (declare them on the function via
- * `pikkuFunc({ permissions })`). This throwing stub exists solely so the pinned
- * bootstrap CLI (which still generates an `addHTTPPermission` wrapper) can
- * resolve the import at build time; it is never called. Delete once
- * `PIKKU_CLI_VERSION` in the CLI build is bumped past the release that removes
- * HTTP-route permissions.
- */
-export const addHTTPPermission = (_pattern, _permissions) => {
-    throw new Error('addHTTPPermission was removed in #972 — HTTP-route-level permissions no longer exist. Declare permissions on the function definition instead: pikkuFunc({ permissions }).');
-};
 export const wireHTTP = (httpWiring) => {
     const httpMeta = pikkuState(null, 'http', 'meta');
     const routeMeta = httpMeta[httpWiring.method][httpWiring.route];
@@ -60,6 +50,7 @@ export const wireHTTP = (httpWiring) => {
     }
     pikkuState(null, 'http', 'routes')
         .get(httpWiring.method)
+        // knowledge: decisions/internals/wiring-registries-erase-the-generics-their-wire-functions-capture.md
         ?.set(httpWiring.route, httpWiring);
 };
 const getMatchingRoute = (requestType, requestPath) => {
@@ -144,6 +135,7 @@ const executeRoute = async (services, matchedRoute, http, options) => {
             setState: (s) => {
                 sseState = s;
             },
+            // knowledge: decisions/internals/channel-state-accessors-are-unsound-generics-that-every-implementation-asserts.md
             getState: () => sseState,
             clearState: () => {
                 sseState = undefined;
@@ -272,6 +264,7 @@ export const fetchData = async (request, response, { skipUserSession = false, re
                 if (globalMiddleware) {
                     await runMiddleware(singletonServices, wire, globalMiddleware);
                 }
+                // 204 carries no body, and `json` has no no-content overload.
                 response.status(204).json(undefined);
                 return;
             }

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

@@ -39,7 +39,6 @@ export interface PikkuHTTP<In = unknown> {
     request?: PikkuHTTPRequest<In>;
     response?: PikkuHTTPResponse;
 }
-export type RequestHeaders = Record<string, string | string[] | undefined> | ((headerName: string) => string | string[] | undefined);
 export type PikkuQuery<T = Record<string, string | undefined>> = Record<string, string | T | null | Array<T | null>>;
 export type CoreHTTPFunctionWiring<In, Out, R extends string, PikkuFunction extends CorePikkuFunction<In, Out, any, any, any> = CorePikkuFunction<In, Out>, PikkuFunctionSessionless extends CorePikkuFunctionSessionless<In, Out, any, any, any> = CorePikkuFunctionSessionless<In, Out>, PikkuPermission extends CorePikkuPermission<In, any, any> = CorePikkuPermission<In, any, any>, PikkuMiddleware extends CorePikkuMiddleware<any, any> = CorePikkuMiddleware<any, any>> = (CoreHTTPFunction & {
     route: R;
@@ -114,15 +113,6 @@ export type HTTPWiringMeta = CommonWireMeta & {
     groupBasePath?: string;
 };
 export type HTTPWiringsMeta = Record<HTTPMethod, Record<string, HTTPWiringMeta>>;
-export type HTTPFunctionsMeta = Array<{
-    name: string;
-    inputs: string[] | null;
-    outputs: string[] | null;
-}>;
-export type HTTPWiringMiddleware = {
-    route: string;
-    middleware: CorePikkuMiddleware[];
-};
 export interface PikkuHTTPRequest<In = unknown> {
     method(): HTTPMethod;
     path(): string;

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

@@ -2,7 +2,7 @@ export { PikkuFetchHTTPRequest, DEFAULT_MAX_BODY_SIZE, } from './pikku-fetch-htt
 export type { PikkuFetchHTTPRequestOptions } from './pikku-fetch-http-request.js';
 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 { fetch, fetchData, wireHTTP, addHTTPMiddleware } from './http-runner.js';
 export { wireHTTPRoutes, defineHTTPRoutes } from './http-routes.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

@@ -1,6 +1,6 @@
 export { PikkuFetchHTTPRequest, DEFAULT_MAX_BODY_SIZE, } from './pikku-fetch-http-request.js';
 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 { fetch, fetchData, wireHTTP, addHTTPMiddleware } from './http-runner.js';
 export { wireHTTPRoutes, defineHTTPRoutes } from './http-routes.js';
 export { toWebRequest, applyWebResponse } from './web-request.js';

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

@@ -9,18 +9,11 @@ export type RunMCPEndpointParams<Tools extends string = any> = {
     /** Defaults to enabled outside production. */
     exposeErrors?: boolean;
 };
-export type JsonRpcError = {
-    code: number;
-    message: string;
-    data?: any;
-};
 export declare const wireMCPResource: <PikkuFunctionConfig extends CorePikkuFunctionConfig<CorePikkuFunctionSessionless<any, any>> = CorePikkuFunctionConfig<CorePikkuFunctionSessionless<any, any>>>(mcpResource: CoreMCPResource<PikkuFunctionConfig>) => void;
 export declare const wireMCPPrompt: <PikkuFunctionConfig extends CorePikkuFunctionConfig<CorePikkuFunctionSessionless<any, any>> = CorePikkuFunctionConfig<CorePikkuFunctionSessionless<any, any>>>(mcpPrompt: CoreMCPPrompt<PikkuFunctionConfig>) => void;
 export declare function runMCPResource(request: JsonRpcRequest, params: RunMCPEndpointParams, uri: string): Promise<JsonRpcResponse>;
 export declare function runMCPTool(request: JsonRpcRequest, params: RunMCPEndpointParams, name: string): Promise<JsonRpcResponse>;
 export declare function runMCPPrompt(request: JsonRpcRequest, params: RunMCPEndpointParams, name: string): Promise<JsonRpcResponse>;
-export declare const getMCPResources: () => Map<string, CoreMCPResource>;
 export declare const getMCPResourcesMeta: () => import("./mcp.types.js").MCPResourceMeta;
 export declare const getMCPToolsMeta: () => import("./mcp.types.js").MCPToolMeta;
-export declare const getMCPPrompts: () => Map<string, CoreMCPPrompt>;
 export declare const getMCPPromptsMeta: () => import("./mcp.types.js").MCPPromptMeta;

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

@@ -165,18 +165,12 @@ async function runMCPPikkuFunc(request, type, name, mcp, pikkuFuncId, { mcp: mcp
         }
     }
 }
-export const getMCPResources = () => {
-    return pikkuState(null, 'mcp', 'resources');
-};
 export const getMCPResourcesMeta = () => {
     return pikkuState(null, 'mcp', 'resourcesMeta');
 };
 export const getMCPToolsMeta = () => {
     return pikkuState(null, 'mcp', 'toolsMeta');
 };
-export const getMCPPrompts = () => {
-    return pikkuState(null, 'mcp', 'prompts');
-};
 export const getMCPPromptsMeta = () => {
     return pikkuState(null, 'mcp', 'promptsMeta');
 };

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

@@ -14,8 +14,6 @@ export declare class RemoteAddonRequestError extends PikkuError {
     readonly httpStatus: number;
     constructor(namespace: string, fnName: string, status: number, detail: string);
 }
-import type { AIAgentInput } from '../ai-agent/ai-agent.types.js';
-import type { StreamAIAgentOptions } from '../ai-agent/ai-agent-prepare.js';
 export declare const resolveNamespace: (namespacedFunction: string) => ResolvedFunction | null;
 export declare class ContextAwareRPCService {
     private services;
@@ -51,55 +49,14 @@ export declare class ContextAwareRPCService {
     }): Promise<{
         runId: string;
     }>;
-    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: {
-                inputTokens: number;
-                outputTokens: number;
-            };
-        }>;
-        stream: (agentName: string, input: {
-            message: string;
-            threadId: string;
-            resourceId: string;
-            model?: string;
-            temperature?: number;
-        }, options?: StreamAIAgentOptions) => Promise<void>;
-        resume: (runId: string, input: {
-            toolCallId: string;
-            approved: boolean;
-        }, options?: StreamAIAgentOptions) => Promise<void>;
-        interrupt: (runId: string, reason?: "speech" | "user" | "timeout") => Promise<import("../ai-agent/ai-agent-interrupt.js").AgentInterruptResult>;
-        approve: (runId: string, approvals: {
-            toolCallId: string;
-            approved: boolean;
-        }[], expectedAgentName?: string) => Promise<{
-            status?: "suspended" | undefined;
-            pendingApprovals?: {
-                toolCallId: string;
-                toolName: string;
-                args: unknown;
-                reason?: string;
-                runId: string;
-            }[] | undefined;
-            runId: string;
-            result: {};
-            usage: {
-                inputTokens: number;
-                outputTokens: number;
-            };
-        }>;
-    };
+    /**
+     * The agent facade, built on access.
+     *
+     * The implementation lives in `ai-agent/agent-rpc.ts` so the agent surface is
+     * one file rather than a wing of this one; a getter rather than a field so a
+     * request that never touches an agent never builds it.
+     */
+    get agent(): PikkuRPC['agent'];
     remote<In = any, Out = any>(funcName: string, data: In): Promise<Out>;
 }
 export declare class PikkuRPCService<Services extends CoreServices, TypedRPC = PikkuRPC> {