@pikku/core 0.11.2 → 0.12.1

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

@@ -1,6 +1,19 @@
 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';
+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
@@ -12,21 +25,28 @@ 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 addons = pikkuState(null, 'rpc', 'addons');
+    const pkgConfig = addons.get(namespace);
+    if (!pkgConfig) {
         return null;
     }
     return {
-        package: packageName,
+        namespace,
+        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 +61,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}`);
         }
@@ -64,50 +93,51 @@ 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), {
             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,
         });
     }
     /**
-     * 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.pikkuFuncName || 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 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 ?? [])];
+        // 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) {
@@ -130,26 +160,142 @@ 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);
+    }
+    get agent() {
+        return {
+            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) {
+        let endpoint;
+        const headers = {
+            'Content-Type': 'application/json',
+        };
+        const colonIndex = funcName.indexOf(':');
+        if (colonIndex !== -1) {
+            const namespace = funcName.substring(0, colonIndex);
+            const addons = pikkuState(null, 'rpc', 'addons');
+            const pkgConfig = addons.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 addons 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),
+            get agent() {
+                return serviceRPC.agent;
+            },
             rpcWithWire: serviceRPC.rpcWithWire.bind(serviceRPC),
         };
     }

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

@@ -1,12 +1,27 @@
-export type PikkuRPC<invoke 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;
+    invoke: Invoke;
+    remote: Remote;
+    exposed: (name: string, data: any) => Promise<any>;
+    startWorkflow: startWorkflow;
+    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 = {
-    pikkuFuncName: string;
+    pikkuFuncId: string;
     expose: boolean;
-    internal?: boolean;
+    remote?: boolean;
 };
 /**
  * Type for RPC handlers
@@ -19,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 * from './scheduler.types.js';
 export { runScheduledTask, wireScheduler, getScheduledTasks, } from './scheduler-runner.js';
-export * from './log-schedulers.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 { 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,12 +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 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>;

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

@@ -1,15 +1,15 @@
 import { getErrorResponse, PikkuError } from '../../errors/error-handler.js';
-import { closeWireServices } from '../../utils.js';
-import { pikkuState } from '../../pikku-state.js';
+import { PikkuMissingMetaError } from '../../errors/errors.js';
+import { getSingletonServices, getCreateWireServices, 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';
 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,
@@ -33,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();
@@ -57,11 +58,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 +71,7 @@ export async function runScheduledTask({ name, session, singletonServices, creat
             wireMiddleware: task.middleware,
             tags: task.tags,
             wire,
+            sessionService: userSession,
         });
     }
     catch (e) {
@@ -79,11 +81,6 @@ 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');

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

@@ -1,5 +1,5 @@
-import { CoreUserSession, CorePikkuMiddleware, CommonWireMeta } from '../../types/core.types.js';
-import { CorePikkuFunctionConfig, CorePikkuFunctionSessionless } from '../../function/functions.types.js';
+import type { CoreUserSession, CorePikkuMiddleware, CommonWireMeta } from '../../types/core.types.js';
+import type { CorePikkuFunctionConfig, CorePikkuFunctionSessionless } from '../../function/functions.types.js';
 /**
  * Represents metadata for scheduled tasks, including title, schedule, and documentation.
  */

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,22 @@
+import type { TriggerInstance } from './trigger.types.js';
+import type { 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>;
+    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>;
+}