@pikku/core 0.11.2 → 0.12.0

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

@@ -1,6 +1,17 @@
 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 { parseVersionedId } from '../../version.js';
+import { encryptJSON } from '../../crypto-utils.js';
+export class RPCNotFoundError extends PikkuError {
+    rpcName;
+    constructor(rpcName) {
+        super(`RPC function not found: ${rpcName}`);
+        this.rpcName = rpcName;
+    }
+}
+import { runAIAgent } from '../ai-agent/ai-agent-runner.js';
 /**
  * Resolve a namespaced function reference to package and function names
  * Uses pikkuState to look up the namespace -> package mapping
@@ -13,20 +24,26 @@ const resolveNamespace = (namespacedFunction) => {
     const namespace = namespacedFunction.substring(0, colonIndex);
     const functionName = namespacedFunction.substring(colonIndex + 1);
     const externalPackages = pikkuState(null, 'rpc', 'externalPackages');
-    const packageName = externalPackages.get(namespace);
-    if (!packageName) {
+    const pkgConfig = externalPackages.get(namespace);
+    if (!pkgConfig) {
         return null;
     }
     return {
-        package: packageName,
+        package: pkgConfig.package,
         function: functionName,
     };
 };
 const getPikkuFunctionName = (rpcName) => {
     const rpc = pikkuState(null, 'rpc', 'meta');
-    const rpcMeta = rpc[rpcName];
+    let rpcMeta = rpc[rpcName];
     if (!rpcMeta) {
-        throw new Error(`RPC function not found: ${rpcName}`);
+        const { baseName, version } = parseVersionedId(rpcName);
+        if (version !== null) {
+            rpcMeta = rpc[baseName];
+        }
+    }
+    if (!rpcMeta) {
+        throw new RPCNotFoundError(rpcName);
     }
     return rpcMeta;
 };
@@ -41,7 +58,16 @@ export class ContextAwareRPCService {
         this.options = options;
     }
     async rpcExposed(funcName, data) {
-        const functionMeta = pikkuState(null, 'function', 'meta')[funcName];
+        let functionMeta;
+        if (funcName.includes(':')) {
+            const resolved = resolveNamespace(funcName);
+            if (resolved) {
+                functionMeta = pikkuState(resolved.package, 'function', 'meta')[resolved.function];
+            }
+        }
+        else {
+            functionMeta = pikkuState(null, 'function', 'meta')[funcName];
+        }
         if (!functionMeta) {
             throw new Error(`Function not found: ${funcName}`);
         }
@@ -69,8 +95,6 @@ export class ContextAwareRPCService {
         // Main package function
         return runPikkuFunc('rpc', funcName, getPikkuFunctionName(funcName), {
             auth: this.options.requiresAuth,
-            // TODO: this is a hack since services have already been created
-            // but is valid since we don't want to keep creating new wire services
             singletonServices: this.services,
             data: () => data,
             wire: updatedWire,
@@ -97,7 +121,7 @@ export class ContextAwareRPCService {
             throw new Error(`Function '${resolved.function}' not found in package '${resolved.package}'. ` +
                 `Available functions: ${Object.keys(externalFunctionMeta).join(', ') || '(none)'}`);
         }
-        const funcName = funcMeta.pikkuFuncName || resolved.function;
+        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
         // Pass the function's tags so tag-based middleware/permissions are applied
@@ -130,26 +154,120 @@ export class ContextAwareRPCService {
             wire: mergedWire,
         });
     }
-    async startWorkflow(workflowName, input) {
+    async startWorkflow(workflowName, input, options) {
         if (!this.services.workflowService) {
             throw new Error('WorkflowService service not available');
         }
-        return this.services.workflowService.startWorkflow(workflowName, input, this);
+        const parentRunId = this.wire.workflowStep?.runId ?? this.wire.graph?.runId;
+        const wire = options?.wire ?? {
+            type: this.wire.wireType ?? 'unknown',
+            id: this.wire.wireId,
+            ...(parentRunId ? { parentRunId } : {}),
+        };
+        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,
+        });
+        return {
+            runId: result.runId,
+            result: result.object ?? result.text,
+            usage: result.usage,
+        };
+    }
+    async remote(funcName, data) {
+        let endpoint;
+        const headers = {
+            'Content-Type': 'application/json',
+        };
+        const colonIndex = funcName.indexOf(':');
+        if (colonIndex !== -1) {
+            const namespace = funcName.substring(0, colonIndex);
+            const externalPackages = pikkuState(null, 'rpc', 'externalPackages');
+            const pkgConfig = externalPackages.get(namespace);
+            endpoint = pkgConfig?.rpcEndpoint;
+        }
+        if (!endpoint && this.services.deploymentService) {
+            const deployments = await this.services.deploymentService.findFunction(funcName);
+            if (deployments.length > 0) {
+                endpoint = deployments[0].endpoint;
+            }
+        }
+        if (!endpoint) {
+            throw new Error(`No endpoint configured for remote RPC: ${funcName}. ` +
+                `Configure rpcEndpoint in externalPackages config or set up a DeploymentService.`);
+        }
+        let secret;
+        if (this.services.secrets) {
+            try {
+                secret = await this.services.secrets.getSecret('PIKKU_REMOTE_SECRET');
+            }
+            catch { }
+        }
+        if (secret) {
+            if (!this.services.jwt) {
+                throw new Error('PIKKU_REMOTE_SECRET is set but JWT service is not available');
+            }
+            const session = this.wire.getSession && typeof this.wire.getSession === 'function'
+                ? await this.wire.getSession()
+                : this.wire.session;
+            const sessionEnc = session
+                ? await encryptJSON(secret, { session })
+                : undefined;
+            const token = await this.services.jwt.encode({ value: 5, unit: 'minute' }, {
+                aud: 'pikku-remote',
+                fn: funcName,
+                iat: Date.now(),
+                session: sessionEnc,
+            });
+            headers.Authorization = `Bearer ${token}`;
+        }
+        const url = `${endpoint}/rpc/${encodeURIComponent(funcName)}`;
+        const timeoutMs = 30_000;
+        const response = await fetch(url, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify({ data }),
+            signal: AbortSignal.timeout(timeoutMs),
+        });
+        if (!response.ok) {
+            let errorBody;
+            try {
+                errorBody = JSON.stringify(await response.json());
+            }
+            catch {
+                errorBody = await response.text();
+            }
+            throw new Error(`Remote RPC call failed: ${response.status} ${response.statusText}. ${errorBody}`);
+        }
+        try {
+            return (await response.json());
+        }
+        catch {
+            const text = await response.text();
+            throw new Error(`Remote RPC call returned non-JSON response: ${response.status} ${response.statusText}. ${text}`);
+        }
     }
 }
 // RPC Service class for the global interface
 export class PikkuRPCService {
     // Convenience function for initializing
-    getContextRPCService(services, wire, requiresAuth, depth = 0) {
-        const serviceRPC = new ContextAwareRPCService(services, wire, {
-            requiresAuth,
-        });
+    getContextRPCService(services, wire, requiresAuthOrOptions, depth = 0) {
+        const options = typeof requiresAuthOrOptions === 'object' &&
+            requiresAuthOrOptions !== null
+            ? requiresAuthOrOptions
+            : { requiresAuth: requiresAuthOrOptions };
+        const serviceRPC = new ContextAwareRPCService(services, wire, options);
         return {
             depth,
             global: false,
             invoke: serviceRPC.rpc.bind(serviceRPC),
-            invokeExposed: serviceRPC.rpc.bind(serviceRPC),
+            remote: serviceRPC.remote.bind(serviceRPC),
+            exposed: serviceRPC.rpcExposed.bind(serviceRPC),
             startWorkflow: serviceRPC.startWorkflow.bind(serviceRPC),
+            agent: serviceRPC.agent.bind(serviceRPC),
             rpcWithWire: serviceRPC.rpcWithWire.bind(serviceRPC),
         };
     }

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

@@ -1,12 +1,16 @@
-export type PikkuRPC<invoke extends Function = any> = {
+export type PikkuRPC<Invoke extends Function = any, Remote extends Function = any, startWorkflow extends Function = any, Agent extends Function = any> = {
     depth: number;
     global: boolean;
-    invoke: invoke;
+    invoke: Invoke;
+    remote: Remote;
+    exposed: (name: string, data: any) => Promise<any>;
+    startWorkflow: startWorkflow;
+    agent: Agent;
 };
 export type RPCMeta = {
-    pikkuFuncName: string;
+    pikkuFuncId: string;
     expose: boolean;
-    internal?: boolean;
+    remote?: boolean;
 };
 /**
  * Type for RPC handlers

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

@@ -1,3 +1,3 @@
-export * from './scheduler.types.js';
-export { runScheduledTask, wireScheduler, getScheduledTasks, } from './scheduler-runner.js';
-export * from './log-schedulers.js';
+export { runScheduledTask, createSchedulerRuntimeHandlers, 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,3 +1,2 @@
-export * from './scheduler.types.js';
-export { runScheduledTask, wireScheduler, getScheduledTasks, } from './scheduler-runner.js';
-export * from './log-schedulers.js';
+export { runScheduledTask, createSchedulerRuntimeHandlers, wireScheduler, getScheduledTasks, } from './scheduler-runner.js';
+export { logSchedulers } from './log-schedulers.js';

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

@@ -1,6 +1,7 @@
 import { type CoreServices, type CoreSingletonServices, type CoreUserSession, type CreateWireServices } 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';
 export type RunScheduledTasksParams = {
     name: string;
     session?: CoreUserSession;
@@ -10,3 +11,7 @@ export type RunScheduledTasksParams = {
 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 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,15 +1,17 @@
 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 { addFunction, runPikkuFunc } from '../../function/function-runner.js';
-import { PikkuSessionService } from '../../services/user-session-service.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];
     if (!taskMeta) {
-        throw new Error('Task metadata not found');
+        throw new PikkuMissingMetaError(`Missing generated metadata for scheduled task '${scheduledTask.name}'`);
     }
-    addFunction(taskMeta.pikkuFuncName, {
+    addFunction(taskMeta.pikkuFuncId, {
         func: scheduledTask.func.func,
         auth: scheduledTask.func.auth,
         permissions: scheduledTask.func.permissions,
@@ -57,11 +59,11 @@ export async function runScheduledTask({ name, session, singletonServices, creat
                 throw new ScheduledTaskSkippedError(name, reason);
             },
         },
-        session: userSession,
+        ...createMiddlewareSessionWireProps(userSession),
     };
     try {
         singletonServices.logger.info(`Running schedule task: ${name} | schedule: ${task.schedule}`);
-        await runPikkuFunc('scheduler', meta.name, meta.pikkuFuncName, {
+        await runPikkuFunc('scheduler', meta.name, meta.pikkuFuncId, {
             singletonServices,
             createWireServices,
             auth: false,
@@ -70,6 +72,7 @@ export async function runScheduledTask({ name, session, singletonServices, creat
             wireMiddleware: task.middleware,
             tags: task.tags,
             wire,
+            sessionService: userSession,
         });
     }
     catch (e) {
@@ -88,3 +91,18 @@ export async function runScheduledTask({ name, session, singletonServices, creat
 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,
+        }),
+    };
+};

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

@@ -0,0 +1,3 @@
+export { wireSecret } from './secret.types.js';
+export type { CoreSecret, OAuth2CredentialConfig, SecretDefinitionMeta, SecretDefinitionsMeta, SecretDefinitions, } from './secret.types.js';
+export { validateAndBuildSecretDefinitionsMeta } from './validate-secret-definitions.js';

package/dist/wirings/secret/index.js

@@ -0,0 +1,2 @@
+export { wireSecret } from './secret.types.js';
+export { validateAndBuildSecretDefinitionsMeta } from './validate-secret-definitions.js';

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

@@ -0,0 +1,27 @@
+export type CoreSecret<T = unknown> = {
+    name: string;
+    displayName: string;
+    description?: string;
+    secretId: string;
+    schema: T;
+};
+export type OAuth2CredentialConfig = {
+    tokenSecretId: string;
+    authorizationUrl: string;
+    tokenUrl: string;
+    scopes: string[];
+    pkce?: boolean;
+    additionalParams?: Record<string, string>;
+};
+export type SecretDefinitionMeta = {
+    name: string;
+    displayName: string;
+    description?: string;
+    secretId: string;
+    schema?: Record<string, unknown> | string;
+    oauth2?: OAuth2CredentialConfig;
+    sourceFile?: string;
+};
+export type SecretDefinitionsMeta = Record<string, SecretDefinitionMeta>;
+export type SecretDefinitions = SecretDefinitionMeta[];
+export declare const wireSecret: <T>(_config: CoreSecret<T>) => void;

package/dist/wirings/secret/secret.types.js

@@ -0,0 +1 @@
+export const wireSecret = (_config) => { };

package/dist/wirings/secret/validate-secret-definitions.d.ts

@@ -0,0 +1,6 @@
+import type { SecretDefinitions, SecretDefinitionsMeta } from './secret.types.js';
+export interface SchemaRefLike {
+    variableName: string;
+    sourceFile: string;
+}
+export declare function validateAndBuildSecretDefinitionsMeta(definitions: SecretDefinitions, schemaLookup: Map<string, SchemaRefLike>): SecretDefinitionsMeta;

package/dist/wirings/secret/validate-secret-definitions.js

@@ -0,0 +1,55 @@
+export function validateAndBuildSecretDefinitionsMeta(definitions, schemaLookup) {
+    const meta = {};
+    const secretIdToDefinition = new Map();
+    for (const def of definitions) {
+        const existingDef = secretIdToDefinition.get(def.secretId);
+        if (existingDef) {
+            if (def.schema && existingDef.schema) {
+                const defSchemaRef = schemaLookup.get(def.schema);
+                const existingSchemaRef = schemaLookup.get(existingDef.schema);
+                if (defSchemaRef && existingSchemaRef) {
+                    if (defSchemaRef.variableName !== existingSchemaRef.variableName ||
+                        defSchemaRef.sourceFile !== existingSchemaRef.sourceFile) {
+                        throw new Error(`Secret '${def.secretId}' is defined with different schemas.\n` +
+                            `  First definition: ${existingDef.sourceFile} (schema: ${existingSchemaRef.variableName})\n` +
+                            `  Second definition: ${def.sourceFile} (schema: ${defSchemaRef.variableName})\n` +
+                            `Credentials sharing a secretId must use the same schema.`);
+                    }
+                }
+            }
+            if (def.oauth2 && existingDef.oauth2) {
+                if (JSON.stringify(def.oauth2) !== JSON.stringify(existingDef.oauth2)) {
+                    throw new Error(`OAuth2 secret '${def.secretId}' is defined with different configurations.\n` +
+                        `  First definition: ${existingDef.sourceFile}\n` +
+                        `  Second definition: ${def.sourceFile}\n` +
+                        `Credentials sharing a secretId must use the same configuration.`);
+                }
+            }
+            if (!meta[def.name]) {
+                meta[def.name] = {
+                    name: def.name,
+                    displayName: def.displayName,
+                    description: def.description,
+                    secretId: def.secretId,
+                    schema: def.schema,
+                    oauth2: def.oauth2,
+                    sourceFile: def.sourceFile,
+                };
+            }
+            continue;
+        }
+        secretIdToDefinition.set(def.secretId, def);
+        if (!meta[def.name]) {
+            meta[def.name] = {
+                name: def.name,
+                displayName: def.displayName,
+                description: def.description,
+                secretId: def.secretId,
+                schema: def.schema,
+                oauth2: def.oauth2,
+                sourceFile: def.sourceFile,
+            };
+        }
+    }
+    return meta;
+}

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

@@ -1,2 +1,3 @@
-export * from './trigger.types.js';
-export * from './trigger-runner.js';
+export { wireTrigger, wireTriggerSource } from './trigger-runner.js';
+export { PikkuTriggerService } from './pikku-trigger-service.js';
+export type { TriggerMeta, TriggerSourceMeta, CorePikkuTriggerFunction, CorePikkuTriggerFunctionConfig, CoreTrigger, PikkuTrigger, } from './trigger.types.js';

package/dist/wirings/trigger/index.js

@@ -1,2 +1,2 @@
-export * from './trigger.types.js';
-export * from './trigger-runner.js';
+export { wireTrigger, wireTriggerSource } from './trigger-runner.js';
+export { PikkuTriggerService } from './pikku-trigger-service.js';

package/dist/wirings/trigger/pikku-trigger-service.d.ts

@@ -0,0 +1,26 @@
+import { CoreSingletonServices, CreateWireServices, CoreServices, CoreUserSession } from '../../types/core.types.js';
+import { TriggerInstance } from './trigger.types.js';
+import { TriggerService } from '../../services/trigger-service.js';
+export type TriggerTarget = {
+    targetType: 'rpc' | 'workflow';
+    targetName: string;
+    startNode?: string;
+};
+export type TriggerSourceInfo = {
+    name: string;
+    input: unknown;
+};
+export declare abstract class PikkuTriggerService implements TriggerService {
+    protected activeTriggers: Map<string, TriggerInstance>;
+    protected singletonServices?: CoreSingletonServices;
+    protected createWireServices?: CreateWireServices<CoreSingletonServices, CoreServices, CoreUserSession>;
+    setServices(singletonServices: CoreSingletonServices, createWireServices?: CreateWireServices<CoreSingletonServices, CoreServices, CoreUserSession>): void;
+    abstract start(): Promise<void>;
+    stop(): Promise<void>;
+    protected getTriggerTargets(): Map<string, TriggerTarget[]>;
+    protected getTriggerSources(): Map<string, {
+        input?: unknown;
+    }>;
+    protected setupTriggerInstance(name: string, input: unknown, onTrigger: (data: unknown) => Promise<void>): Promise<TriggerInstance>;
+    protected onTriggerFire(triggerName: string, targets: TriggerTarget[], data: unknown): Promise<void>;
+}

package/dist/wirings/trigger/pikku-trigger-service.js

@@ -0,0 +1,75 @@
+import { rpcService } from '../rpc/rpc-runner.js';
+import { setupTrigger } from './trigger-runner.js';
+import { pikkuState } from '../../pikku-state.js';
+export class PikkuTriggerService {
+    activeTriggers = new Map();
+    singletonServices;
+    createWireServices;
+    setServices(singletonServices, createWireServices) {
+        this.singletonServices = singletonServices;
+        this.createWireServices = createWireServices;
+    }
+    async stop() {
+        for (const [name, instance] of this.activeTriggers) {
+            try {
+                await instance.teardown();
+                this.singletonServices.logger.info(`Stopped trigger: ${name}`);
+            }
+            catch (error) {
+                this.singletonServices.logger.error(`Error stopping trigger ${name}: ${error}`);
+            }
+        }
+        this.activeTriggers.clear();
+    }
+    getTriggerTargets() {
+        const triggers = pikkuState(null, 'trigger', 'triggers');
+        const triggerTargets = new Map();
+        for (const [name] of triggers) {
+            const meta = pikkuState(null, 'trigger', 'meta')[name];
+            if (meta) {
+                if (!triggerTargets.has(name)) {
+                    triggerTargets.set(name, []);
+                }
+                triggerTargets.get(name).push({
+                    targetType: 'rpc',
+                    targetName: meta.pikkuFuncId,
+                });
+            }
+        }
+        return triggerTargets;
+    }
+    getTriggerSources() {
+        return pikkuState(null, 'trigger', 'triggerSources');
+    }
+    async setupTriggerInstance(name, input, onTrigger) {
+        return setupTrigger({
+            name,
+            singletonServices: this.singletonServices,
+            createWireServices: this.createWireServices,
+            input,
+            onTrigger,
+        });
+    }
+    async onTriggerFire(triggerName, targets, data) {
+        const wireServices = await this.createWireServices?.(this.singletonServices, {});
+        const services = { ...this.singletonServices, ...wireServices };
+        const rpc = rpcService.getContextRPCService(services, {}, false);
+        for (const target of targets) {
+            try {
+                if (target.targetType === 'workflow') {
+                    await rpc.startWorkflow(target.targetName, data, {
+                        startNode: target.startNode,
+                    });
+                    this.singletonServices.logger.info(`Trigger '${triggerName}' started workflow '${target.targetName}'`);
+                }
+                else {
+                    await rpc.invoke(target.targetName, data);
+                    this.singletonServices.logger.info(`Trigger '${triggerName}' invoked RPC '${target.targetName}'`);
+                }
+            }
+            catch (error) {
+                this.singletonServices.logger.error(`Error invoking ${target.targetType} '${target.targetName}' from trigger '${triggerName}': ${error}`);
+            }
+        }
+    }
+}

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

@@ -1,28 +1,41 @@
-import type { CoreSingletonServices } from '../../types/core.types.js';
-import type { CoreTrigger, TriggerInstance } from './trigger.types.js';
-import type { CorePikkuTriggerFunctionConfig } from '../../function/functions.types.js';
+import { CreateWireServices, type CoreSingletonServices } from '../../types/core.types.js';
+import type { CoreTrigger, CoreTriggerSource, TriggerInstance } from './trigger.types.js';
 /**
  * Registers a trigger with the Pikku framework.
- * The trigger will be available for setup via setupTrigger.
+ * Declares a trigger name and its target pikku function.
+ * Runs everywhere. Inspector extracts at build time.
  */
-export declare const wireTrigger: <TConfig = unknown, TOutput = unknown, TriggerFunctionConfig extends CorePikkuTriggerFunctionConfig<TConfig, TOutput> = CorePikkuTriggerFunctionConfig<TConfig, TOutput>>(trigger: CoreTrigger<TConfig, TOutput, TriggerFunctionConfig>) => void;
+export declare const wireTrigger: (trigger: CoreTrigger) => void;
+/**
+ * Registers a trigger source with the Pikku framework.
+ * Provides the actual subscription function and input data.
+ * Only imported in the trigger worker process.
+ */
+export declare const wireTriggerSource: <TInput = unknown, TOutput = unknown>(source: CoreTriggerSource<TInput, TOutput>) => void;
 /**
  * Parameters for setting up a trigger
  */
-export type SetupTriggerParams<TOutput = unknown> = {
+export type SetupTriggerParams<TInput = unknown, TOutput = unknown> = {
     name: string;
     singletonServices: CoreSingletonServices;
+    createWireServices?: CreateWireServices;
+    input?: TInput;
     onTrigger: (data: TOutput) => void | Promise<void>;
 };
 /**
  * Sets up a registered trigger and starts listening for events.
  * Returns a TriggerInstance with a teardown function.
+ *
+ * @param name - The trigger name (must be registered via wireTrigger)
+ * @param singletonServices - The singleton services
+ * @param input - The input to pass to the trigger function
+ * @param onTrigger - Callback invoked when the trigger fires
  */
-export declare function setupTrigger<TOutput = unknown>({ name, singletonServices, onTrigger, }: SetupTriggerParams<TOutput>): Promise<TriggerInstance>;
+export declare function setupTrigger<TInput = unknown, TOutput = unknown>({ name, singletonServices, createWireServices, input, onTrigger, }: SetupTriggerParams<TInput, TOutput>): Promise<TriggerInstance>;
 /**
  * Gets all registered triggers
  */
-export declare const getRegisteredTriggers: () => Map<string, CoreTrigger<unknown, unknown, CorePikkuTriggerFunctionConfig<unknown, unknown>>>;
+export declare const getRegisteredTriggers: () => Map<string, CoreTrigger<any>>;
 /**
  * Gets trigger metadata
  */