@pikku/core 0.12.0 → 0.12.2

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

@@ -1,4 +1,4 @@
-import { serialize as serializeCookie, } from 'cookie';
+import { serialize as serializeCookie } from 'cookie';
 export class PikkuFetchHTTPResponse {
     #statusCode = 200;
     #headers = new Headers();
@@ -76,6 +76,11 @@ export class PikkuFetchHTTPResponse {
     //   return this
     // }
     redirect(location, status = 302) {
+        if (!location.startsWith('/') &&
+            !location.startsWith('https://') &&
+            !location.startsWith('http://')) {
+            throw new Error('Invalid redirect location: must be a relative path or absolute URL');
+        }
         this.#statusCode = status;
         this.header('Location', location);
         return this;

package/dist/wirings/http/routers/http-router.d.ts

@@ -1,4 +1,4 @@
-import { HTTPMethod } from '../http.types.js';
+import type { HTTPMethod } from '../http.types.js';
 import { PathToRegexRouter } from './path-to-regex.js';
 export type MatchResult = {
     route: string;

package/dist/wirings/http/routers/path-to-regex.d.ts

@@ -1,5 +1,5 @@
-import { MatchResult, Router } from './http-router.js';
-import { HTTPMethod } from '../http.types.js';
+import type { MatchResult, Router } from './http-router.js';
+import type { HTTPMethod } from '../http.types.js';
 export declare class PathToRegexRouter implements Router {
     private compiledRoutes;
     private staticRoutes;

package/dist/wirings/mcp/mcp-endpoint-registry.d.ts

@@ -1,4 +1,4 @@
-import { MCPResourceMeta, MCPToolMeta, MCPPromptMeta } from '@pikku/core/mcp';
+import type { MCPResourceMeta, MCPToolMeta, MCPPromptMeta } from '@pikku/core/mcp';
 export interface MCPToolEndpoint {
     name: string;
     title: string;

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

@@ -1,4 +1,3 @@
-import { type CoreServices, type CoreSingletonServices, type CoreUserSession, type CreateWireServices } from '../../types/core.types.js';
 import type { CoreMCPResource, CoreMCPPrompt, JsonRpcRequest, JsonRpcResponse, JsonRpcErrorResponse, PikkuMCP } from './mcp.types.js';
 import type { CorePikkuFunctionConfig, CorePikkuFunctionSessionless } from '../../function/functions.types.js';
 export declare class MCPError extends Error {
@@ -6,9 +5,7 @@ export declare class MCPError extends Error {
     constructor(error: JsonRpcErrorResponse);
 }
 export type RunMCPEndpointParams<Tools extends string = any> = {
-    singletonServices: CoreSingletonServices;
     mcp?: PikkuMCP<Tools>;
-    createWireServices?: CreateWireServices<CoreSingletonServices, CoreServices<CoreSingletonServices>, CoreUserSession>;
 };
 export type JsonRpcError = {
     code: number;

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

@@ -1,6 +1,6 @@
 import { getErrorResponse } from '../../errors/error-handler.js';
 import { closeWireServices } from '../../utils.js';
-import { pikkuState } from '../../pikku-state.js';
+import { pikkuState, getSingletonServices, getCreateWireServices, } from '../../pikku-state.js';
 import { addFunction, runPikkuFunc } from '../../function/function-runner.js';
 import { BadRequestError, NotFoundError, PikkuMissingMetaError, } from '../../errors/errors.js';
 import { PikkuSessionService, createMiddlewareSessionWireProps, } from '../../services/user-session-service.js';
@@ -85,7 +85,9 @@ export async function runMCPPrompt(request, params, name) {
 /**
  * JSON-RPC 2.0 compatible MCP endpoint runner
  */
-async function runMCPPikkuFunc(request, type, name, mcp, pikkuFuncId, { singletonServices, createWireServices, mcp: mcpWire }) {
+async function runMCPPikkuFunc(request, type, name, mcp, pikkuFuncId, { mcp: mcpWire }) {
+    const singletonServices = getSingletonServices();
+    const createWireServices = getCreateWireServices();
     let wireServices;
     try {
         if (request.jsonrpc !== '2.0') {

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

@@ -1,5 +1,5 @@
-import { CorePermissionGroup, CorePikkuFunctionConfig, CorePikkuFunctionSessionless, CorePikkuPermission } from '../../function/functions.types.js';
-import { CorePikkuMiddleware, MiddlewareMetadata, PermissionMetadata } from '../../types/core.types.js';
+import type { CorePermissionGroup, CorePikkuFunctionConfig, CorePikkuFunctionSessionless, CorePikkuPermission } from '../../function/functions.types.js';
+import type { CorePikkuMiddleware, MiddlewareMetadata, PermissionMetadata } from '../../types/core.types.js';
 /**
  * Extract URI parameters from MCP resource URI template.
  * E.g., "user/{userId}/post/{postId}" => "userId" | "postId"

package/dist/wirings/oauth2/oauth2-client.d.ts

@@ -1,6 +1,6 @@
-import { OAuth2Token } from './oauth2.types.js';
-import { OAuth2CredentialConfig } from '../secret/secret.types.js';
-import { SecretService } from '../../services/secret-service.js';
+import type { OAuth2Token } from './oauth2.types.js';
+import type { OAuth2CredentialConfig } from '../secret/secret.types.js';
+import type { SecretService } from '../../services/secret-service.js';
 export declare class OAuth2Client {
     private oauth2Config;
     private appCredentialSecretId;

package/dist/wirings/oauth2/wire-oauth2-credential.d.ts

@@ -1,4 +1,4 @@
-import { CoreOAuth2Credential } from './oauth2.types.js';
+import type { CoreOAuth2Credential } from './oauth2.types.js';
 /**
  * No-op function for declaring OAuth2 credentials.
  * This exists purely for TypeScript type checking and will be tree-shaken.

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

@@ -1,5 +1,5 @@
 export type { ConfigValidationResult, CoreQueueWorker, JobOptions, PikkuJobConfig, PikkuWorkerConfig, PikkuQueue, QueueJob, QueueJobStatus, QueueService, QueueWorkers, QueueWorkersMeta, } from './queue.types.js';
-export { wireQueueWorker, runQueueJob, createQueueJobRunner, getQueueWorkers, removeQueueWorker, QueueJobDiscardedError, QueueJobFailedError, } from './queue-runner.js';
+export { wireQueueWorker, runQueueJob, getQueueWorkers, removeQueueWorker, QueueJobDiscardedError, QueueJobFailedError, } from './queue-runner.js';
 export { validateWorkerConfig } from './validate-worker-config.js';
 export type { QueueConfigMapping } from './validate-worker-config.js';
 export { registerQueueWorkers } from './register-queue-helper.js';

package/dist/wirings/queue/index.js

@@ -1,5 +1,5 @@
 // Queue processor management
-export { wireQueueWorker, runQueueJob, createQueueJobRunner, getQueueWorkers, removeQueueWorker, QueueJobDiscardedError, QueueJobFailedError, } from './queue-runner.js';
+export { wireQueueWorker, runQueueJob, getQueueWorkers, removeQueueWorker, QueueJobDiscardedError, QueueJobFailedError, } from './queue-runner.js';
 // Configuration validation
 export { validateWorkerConfig } from './validate-worker-config.js';
 // Queue registration helper

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

@@ -1,8 +1,6 @@
-import type { CoreServices } from '../../types/core.types.js';
 import type { CoreQueueWorker, QueueJob } from './queue.types.js';
 import type { CorePikkuFunctionConfig, CorePikkuFunctionSessionless } from '../../function/functions.types.js';
 import { PikkuError } from '../../errors/error-handler.js';
-import { CreateWireServices } from '../../types/core.types.js';
 /**
  * Error class for when a queue job is explicitly failed
  */
@@ -30,16 +28,7 @@ export declare function removeQueueWorker(name: string): Promise<void>;
 /**
  * Process a single queue job - this function is called by queue consumers
  */
-export declare function runQueueJob({ singletonServices, createWireServices, job, updateProgress, }: {
-    singletonServices: CoreServices;
-    createWireServices?: CreateWireServices;
+export declare function runQueueJob({ job, updateProgress, }: {
     job: QueueJob;
     updateProgress?: (progress: number | string | object) => Promise<void>;
 }): Promise<void>;
-export declare const createQueueJobRunner: ({ singletonServices, createWireServices, }: {
-    singletonServices: CoreServices;
-    createWireServices?: CreateWireServices;
-}) => ({ job, updateProgress, }: {
-    job: QueueJob;
-    updateProgress?: (progress: number | string | object) => Promise<void>;
-}) => Promise<void>;

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

@@ -1,6 +1,6 @@
 import { getErrorResponse, PikkuError } from '../../errors/error-handler.js';
 import { PikkuMissingMetaError } from '../../errors/errors.js';
-import { pikkuState } from '../../pikku-state.js';
+import { getSingletonServices, getCreateWireServices, pikkuState, } from '../../pikku-state.js';
 import { addFunction, runPikkuFunc } from '../../function/function-runner.js';
 /**
  * Error class for queue processor not found
@@ -70,7 +70,9 @@ export async function removeQueueWorker(name) {
 /**
  * Process a single queue job - this function is called by queue consumers
  */
-export async function runQueueJob({ singletonServices, createWireServices, job, updateProgress, }) {
+export async function runQueueJob({ job, updateProgress, }) {
+    const singletonServices = getSingletonServices();
+    const createWireServices = getCreateWireServices();
     const logger = singletonServices.logger;
     const meta = pikkuState(null, 'queue', 'meta');
     const processorMeta = meta[job.queueName];
@@ -128,13 +130,3 @@ export async function runQueueJob({ singletonServices, createWireServices, job,
         throw error;
     }
 }
-export const createQueueJobRunner = ({ singletonServices, createWireServices, }) => {
-    return async ({ job, updateProgress, }) => {
-        await runQueueJob({
-            singletonServices,
-            createWireServices,
-            job,
-            updateProgress,
-        });
-    };
-};

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

@@ -1,7 +1,6 @@
-import { CommonWireMeta } from '../../types/core.types.js';
-import { CorePikkuFunctionConfig } from '../../function/functions.types.js';
-import { QueueConfigMapping } from './validate-worker-config.js';
-import { Logger } from '../../services/logger.js';
+import type { CommonWireMeta } from '../../types/core.types.js';
+import type { CorePikkuFunctionConfig } from '../../function/functions.types.js';
+import type { QueueConfigMapping } from './validate-worker-config.js';
 /**
  * Configuration for queue workers - how jobs are processed
  */
@@ -125,11 +124,6 @@ export interface QueueWorkers {
     supportsResults: boolean;
     /** Configuration mapping for validation */
     configMappings: QueueConfigMapping;
-    /** Set runtime queue job runner callback and logger */
-    setJobRunner(runJob: (params: {
-        job: QueueJob;
-        updateProgress?: (progress: number | string | object) => Promise<void>;
-    }) => Promise<void>, logger: Logger): void;
     /** Scan state and register all compatible processors */
     registerQueues(): Promise<Record<string, ConfigValidationResult[]>>;
 }

package/dist/wirings/queue/register-queue-helper.d.ts

@@ -1,6 +1,6 @@
 import type { ConfigValidationResult, CoreQueueWorker } from './queue.types.js';
-import { QueueConfigMapping } from './validate-worker-config.js';
-import { Logger } from '../../services/logger.js';
+import type { QueueConfigMapping } from './validate-worker-config.js';
+import type { Logger } from '../../services/logger.js';
 /**
  * Queue processor registration callback
  */

package/dist/wirings/queue/register-queue-helper.js

@@ -1,5 +1,5 @@
 import { getQueueWorkers } from './queue-runner.js';
-import { validateWorkerConfig, } from './validate-worker-config.js';
+import { validateWorkerConfig } from './validate-worker-config.js';
 /**
  * Helper function to register queue processors with validation
  * This centralizes the common logic for looping over processors and validating configs

package/dist/wirings/queue/validate-worker-config.d.ts

@@ -1,4 +1,4 @@
-import { PikkuWorkerConfig, ConfigValidationResult } from './queue.types.js';
+import type { PikkuWorkerConfig, ConfigValidationResult } from './queue.types.js';
 /**
  * Configuration mapping structure for queue implementations
  */

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

@@ -1,2 +1,4 @@
 export { PikkuRPCService, rpcService, RPCNotFoundError } from './rpc-runner.js';
 export type { PikkuRPC, RPCMeta } from './rpc-types.js';
+export { wireAddon } from './wire-addon.js';
+export type { WireAddonConfig } from './wire-addon.js';

package/dist/wirings/rpc/index.js

@@ -1 +1,2 @@
 export { PikkuRPCService, rpcService, RPCNotFoundError } from './rpc-runner.js';
+export { wireAddon } from './wire-addon.js';

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

@@ -1,13 +1,14 @@
-import { CoreServices, CoreSingletonServices, PikkuWire } from '../../types/core.types.js';
+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 { PikkuRPC } from './rpc-types.js';
+import type { PikkuRPC } 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';
 export declare class ContextAwareRPCService {
     private services;
     private wire;
@@ -19,12 +20,12 @@ export declare class ContextAwareRPCService {
     rpcExposed(funcName: string, data: any): Promise<any>;
     rpc<In = any, Out = any>(funcName: string, data: In): Promise<Out>;
     /**
-     * Invoke a function from an external package
-     * External packages register their functions in pikkuState under their package name.
+     * Invoke a function from an addon package
+     * Addon packages register their functions in pikkuState under their package name.
      * The function is executed using the parent services (shared singleton services).
      * @private
      */
-    private invokeExternalPackageFunction;
+    private invokeAddonFunction;
     rpcWithWire<In = any, Out = any>(rpcName: string, data: In, wire: PikkuWire): Promise<Out>;
     startWorkflow<In = any>(workflowName: string, input: In, options?: {
         startNode?: string;
@@ -36,14 +37,35 @@ export declare class ContextAwareRPCService {
     }): Promise<{
         runId: string;
     }>;
-    agent(agentName: string, input: AIAgentInput): Promise<{
-        runId: string;
-        result: unknown;
-        usage: {
-            inputTokens: number;
-            outputTokens: number;
-        };
-    }>;
+    get agent(): {
+        run: (agentName: string, input: AIAgentInput) => Promise<{
+            runId: string;
+            result: {};
+            usage: {
+                inputTokens: number;
+                outputTokens: number;
+            };
+        }>;
+        stream: (agentName: string, input: {
+            message: string;
+            threadId: string;
+            resourceId: string;
+        } | Record<string, unknown>, options?: StreamAIAgentOptions) => Promise<void>;
+        resume: (runId: string, input: {
+            toolCallId: string;
+            approved: boolean;
+        }, options?: StreamAIAgentOptions) => Promise<void>;
+        approve: (runId: string, approvals: {
+            toolCallId: string;
+            approved: boolean;
+        }[], expectedAgentName?: string) => Promise<{
+            status: "resumed" | "suspended";
+            runId: string;
+            approved: string[];
+            rejected: string[];
+            remainingApprovals: number;
+        }>;
+    };
     remote<In = any, Out = any>(funcName: string, data: In): Promise<Out>;
 }
 export declare class PikkuRPCService<Services extends CoreServices, TypedRPC = PikkuRPC> {
@@ -52,7 +74,7 @@ export declare class PikkuRPCService<Services extends CoreServices, TypedRPC = P
         sessionService?: SessionService<CoreUserSession>;
     } | undefined, depth?: number): TypedRPC;
 }
-export declare const rpcService: PikkuRPCService<CoreSingletonServices<{
+export declare const rpcService: PikkuRPCService<import("../../types/core.types.js").CoreSingletonServices<{
     logLevel?: import("../../services/logger.js").LogLevel;
     secrets?: {};
     workflow?: import("../workflow/workflow.types.js").WorkflowServiceConfig;

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

@@ -12,6 +12,8 @@ export class RPCNotFoundError extends PikkuError {
     }
 }
 import { runAIAgent } 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
@@ -23,12 +25,13 @@ const resolveNamespace = (namespacedFunction) => {
     }
     const namespace = namespacedFunction.substring(0, colonIndex);
     const functionName = namespacedFunction.substring(colonIndex + 1);
-    const externalPackages = pikkuState(null, 'rpc', 'externalPackages');
-    const pkgConfig = externalPackages.get(namespace);
+    const addons = pikkuState(null, 'rpc', 'addons');
+    const pkgConfig = addons.get(namespace);
     if (!pkgConfig) {
         return null;
     }
     return {
+        namespace,
         package: pkgConfig.package,
         function: functionName,
     };
@@ -90,7 +93,7 @@ export class ContextAwareRPCService {
         };
         // Check if it's a namespaced function call (e.g., 'stripe:createCharge')
         if (funcName.includes(':')) {
-            return this.invokeExternalPackageFunction(funcName, data, updatedWire);
+            return this.invokeAddonFunction(funcName, data, updatedWire);
         }
         // Main package function
         return runPikkuFunc('rpc', funcName, getPikkuFunctionName(funcName), {
@@ -101,37 +104,40 @@ export class ContextAwareRPCService {
         });
     }
     /**
-     * Invoke a function from an external package
-     * External packages register their functions in pikkuState under their package name.
+     * Invoke a function from an addon package
+     * Addon packages register their functions in pikkuState under their package name.
      * The function is executed using the parent services (shared singleton services).
      * @private
      */
-    async invokeExternalPackageFunction(namespacedFunction, data, wire) {
+    async invokeAddonFunction(namespacedFunction, data, wire) {
         // Resolve namespace to package name
         const resolved = resolveNamespace(namespacedFunction);
         if (!resolved) {
             throw new Error(`Unknown namespace in function reference: ${namespacedFunction}. ` +
-                `Make sure the package is registered in externalPackages config.`);
+                `Make sure the package is registered in addons config.`);
         }
-        // Get the function meta from the external package
-        // External packages use function meta, not RPC meta
-        const externalFunctionMeta = pikkuState(resolved.package, 'function', 'meta');
-        const funcMeta = externalFunctionMeta[resolved.function];
+        // Get the function meta from the addon package
+        // Addon packages use function meta, not RPC meta
+        const addonFunctionMeta = pikkuState(resolved.package, 'function', 'meta');
+        const funcMeta = addonFunctionMeta[resolved.function];
         if (!funcMeta) {
             throw new Error(`Function '${resolved.function}' not found in package '${resolved.package}'. ` +
-                `Available functions: ${Object.keys(externalFunctionMeta).join(', ') || '(none)'}`);
+                `Available functions: ${Object.keys(addonFunctionMeta).join(', ') || '(none)'}`);
         }
         const funcName = funcMeta.pikkuFuncId || resolved.function;
-        // Execute the function using runPikkuFunc with the external package's state
-        // We use the parent services (this.services) since external packages share services
+        const addonConfig = pikkuState(null, 'rpc', 'addons').get(resolved.namespace);
+        const auth = addonConfig?.auth ?? this.options.requiresAuth;
+        const tags = [...(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
         return runPikkuFunc('rpc', namespacedFunction, funcName, {
-            auth: this.options.requiresAuth,
+            auth,
             singletonServices: this.services,
             data: () => data,
             wire,
             packageName: resolved.package,
-            tags: funcMeta.tags,
+            tags,
         });
     }
     async rpcWithWire(rpcName, data, wire) {
@@ -166,15 +172,35 @@ export class ContextAwareRPCService {
         };
         return this.services.workflowService.startWorkflow(workflowName, input, wire, this, options);
     }
-    async agent(agentName, input) {
-        const result = await runAIAgent(agentName, input, {
-            singletonServices: this.services,
-            sessionService: this.options.sessionService,
-        });
+    get agent() {
         return {
-            runId: result.runId,
-            result: result.object ?? result.text,
-            usage: result.usage,
+            run: async (agentName, input) => {
+                const result = await runAIAgent(agentName, input, {
+                    sessionService: this.options.sessionService,
+                });
+                return {
+                    runId: result.runId,
+                    result: result.object ?? result.text,
+                    usage: result.usage,
+                };
+            },
+            stream: async (agentName, input, options) => {
+                const channel = this.wire.channel;
+                if (!channel)
+                    throw new Error('No channel available for streaming');
+                await streamAIAgent(agentName, input, channel, { sessionService: this.options.sessionService }, undefined, options);
+            },
+            resume: async (runId, input, options) => {
+                const channel = this.wire.channel;
+                if (!channel)
+                    throw new Error('No channel available for streaming');
+                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);
+            },
         };
     }
     async remote(funcName, data) {
@@ -185,8 +211,8 @@ export class ContextAwareRPCService {
         const colonIndex = funcName.indexOf(':');
         if (colonIndex !== -1) {
             const namespace = funcName.substring(0, colonIndex);
-            const externalPackages = pikkuState(null, 'rpc', 'externalPackages');
-            const pkgConfig = externalPackages.get(namespace);
+            const addons = pikkuState(null, 'rpc', 'addons');
+            const pkgConfig = addons.get(namespace);
             endpoint = pkgConfig?.rpcEndpoint;
         }
         if (!endpoint && this.services.deploymentService) {
@@ -197,7 +223,7 @@ export class ContextAwareRPCService {
         }
         if (!endpoint) {
             throw new Error(`No endpoint configured for remote RPC: ${funcName}. ` +
-                `Configure rpcEndpoint in externalPackages config or set up a DeploymentService.`);
+                `Configure rpcEndpoint in addons config or set up a DeploymentService.`);
         }
         let secret;
         if (this.services.secrets) {
@@ -267,7 +293,9 @@ export class PikkuRPCService {
             remote: serviceRPC.remote.bind(serviceRPC),
             exposed: serviceRPC.rpcExposed.bind(serviceRPC),
             startWorkflow: serviceRPC.startWorkflow.bind(serviceRPC),
-            agent: serviceRPC.agent.bind(serviceRPC),
+            get agent() {
+                return serviceRPC.agent;
+            },
             rpcWithWire: serviceRPC.rpcWithWire.bind(serviceRPC),
         };
     }

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

@@ -1,11 +1,22 @@
-export type PikkuRPC<Invoke extends Function = any, Remote extends Function = any, startWorkflow extends Function = any, Agent extends Function = any> = {
+export type PikkuRPC<Invoke extends Function = any, Remote extends Function = any, startWorkflow extends Function = any, AgentRun extends Function = any, AgentStream extends Function = any> = {
     depth: number;
     global: boolean;
     invoke: Invoke;
     remote: Remote;
     exposed: (name: string, data: any) => Promise<any>;
     startWorkflow: startWorkflow;
-    agent: Agent;
+    agent: {
+        run: AgentRun;
+        stream: AgentStream;
+        resume: (runId: string, input: {
+            toolCallId: string;
+            approved: boolean;
+        }, options?: any) => Promise<void>;
+        approve: (runId: string, approvals: {
+            toolCallId: string;
+            approved: boolean;
+        }[], expectedAgentName?: string) => Promise<any>;
+    };
 };
 export type RPCMeta = {
     pikkuFuncId: string;
@@ -23,6 +34,7 @@ export interface RPCHandler<Input, Output> {
  * Resolved function reference from namespace
  */
 export interface ResolvedFunction {
+    namespace: string;
     package: string;
     function: string;
 }

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

@@ -0,0 +1,10 @@
+export type WireAddonConfig = {
+    name: string;
+    package: string;
+    rpcEndpoint?: string;
+    auth?: boolean;
+    tags?: string[];
+    secretOverrides?: Record<string, string>;
+    variableOverrides?: Record<string, string>;
+};
+export declare const wireAddon: (config: WireAddonConfig) => void;

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

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

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

@@ -1,3 +1,3 @@
-export { runScheduledTask, createSchedulerRuntimeHandlers, wireScheduler, getScheduledTasks, } from './scheduler-runner.js';
+export { runScheduledTask, wireScheduler, getScheduledTasks, } from './scheduler-runner.js';
 export { logSchedulers } from './log-schedulers.js';
 export type { CoreScheduledTask, ScheduledTasksMeta, PikkuScheduledTask, } from './scheduler.types.js';

package/dist/wirings/scheduler/index.js

@@ -1,2 +1,2 @@
-export { runScheduledTask, createSchedulerRuntimeHandlers, wireScheduler, getScheduledTasks, } from './scheduler-runner.js';
+export { runScheduledTask, wireScheduler, getScheduledTasks, } from './scheduler-runner.js';
 export { logSchedulers } from './log-schedulers.js';

package/dist/wirings/scheduler/log-schedulers.d.ts

@@ -1,4 +1,4 @@
-import { Logger } from '../../services/index.js';
+import type { Logger } from '../../services/index.js';
 /**
  * Logs all the loaded scheduled tasks.
  * @param logger - A logger for logging information.

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

@@ -1,17 +1,10 @@
-import { type CoreServices, type CoreSingletonServices, type CoreUserSession, type CreateWireServices } from '../../types/core.types.js';
+import type { CoreUserSession } from '../../types/core.types.js';
 import type { CoreScheduledTask } from './scheduler.types.js';
-import { CorePikkuFunctionConfig, CorePikkuFunctionSessionless } from '../../function/functions.types.js';
-import { SchedulerRuntimeHandlers } from '../../services/scheduler-service.js';
+import type { CorePikkuFunctionConfig, CorePikkuFunctionSessionless } from '../../function/functions.types.js';
 export type RunScheduledTasksParams = {
     name: string;
     session?: CoreUserSession;
-    singletonServices: CoreSingletonServices;
-    createWireServices?: CreateWireServices<CoreSingletonServices, CoreServices<CoreSingletonServices>, CoreUserSession>;
 };
 export declare const wireScheduler: <PikkuFunctionConfig extends CorePikkuFunctionConfig<CorePikkuFunctionSessionless<void, void>>>(scheduledTask: CoreScheduledTask<PikkuFunctionConfig>) => void;
-export declare function runScheduledTask({ name, session, singletonServices, createWireServices, }: RunScheduledTasksParams): Promise<void>;
+export declare function runScheduledTask({ name, session, }: RunScheduledTasksParams): Promise<void>;
 export declare const getScheduledTasks: () => Map<string, CoreScheduledTask>;
-export declare const createSchedulerRuntimeHandlers: ({ singletonServices, createWireServices, }: {
-    singletonServices: CoreSingletonServices;
-    createWireServices?: CreateWireServices<CoreSingletonServices, CoreServices<CoreSingletonServices>, CoreUserSession>;
-}) => SchedulerRuntimeHandlers;

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

@@ -1,10 +1,8 @@
 import { getErrorResponse, PikkuError } from '../../errors/error-handler.js';
 import { PikkuMissingMetaError } from '../../errors/errors.js';
-import { closeWireServices } from '../../utils.js';
-import { pikkuState } from '../../pikku-state.js';
+import { getSingletonServices, getCreateWireServices, pikkuState, } from '../../pikku-state.js';
 import { addFunction, runPikkuFunc } from '../../function/function-runner.js';
 import { PikkuSessionService, createMiddlewareSessionWireProps, } from '../../services/user-session-service.js';
-import { rpcService } from '../rpc/rpc-runner.js';
 export const wireScheduler = (scheduledTask) => {
     const meta = pikkuState(null, 'scheduler', 'meta');
     const taskMeta = meta[scheduledTask.name];
@@ -35,8 +33,9 @@ class ScheduledTaskSkippedError extends PikkuError {
         this.name = 'ScheduledTaskSkippedError';
     }
 }
-export async function runScheduledTask({ name, session, singletonServices, createWireServices, }) {
-    let wireServices;
+export async function runScheduledTask({ name, session, }) {
+    const singletonServices = getSingletonServices();
+    const createWireServices = getCreateWireServices();
     const task = pikkuState(null, 'scheduler', 'tasks').get(name);
     const meta = pikkuState(null, 'scheduler', 'meta')[name];
     const userSession = new PikkuSessionService();
@@ -82,27 +81,7 @@ export async function runScheduledTask({ name, session, singletonServices, creat
         }
         throw e;
     }
-    finally {
-        if (wireServices) {
-            await closeWireServices(singletonServices.logger, wireServices);
-        }
-    }
 }
 export const getScheduledTasks = () => {
     return pikkuState(null, 'scheduler', 'tasks');
 };
-export const createSchedulerRuntimeHandlers = ({ singletonServices, createWireServices, }) => {
-    return {
-        logger: singletonServices.logger,
-        invokeRPC: async (rpcName, data, session) => {
-            const wire = session ? { session } : {};
-            const rpc = rpcService.getContextRPCService(singletonServices, wire);
-            await rpc.invoke(rpcName, data);
-        },
-        runScheduledTask: async (name) => runScheduledTask({
-            name,
-            singletonServices,
-            createWireServices,
-        }),
-    };
-};