@microfox/ai-worker 1.0.1 → 1.0.2

package/dist/handler.d.ts

@@ -19,6 +19,25 @@ interface JobStoreUpdate {
         name?: string;
     };
 }
+interface JobRecord {
+    jobId: string;
+    workerId: string;
+    status: 'queued' | 'running' | 'completed' | 'failed';
+    input: any;
+    output?: any;
+    error?: {
+        message: string;
+        stack?: string;
+    };
+    metadata?: Record<string, any>;
+    internalJobs?: Array<{
+        jobId: string;
+        workerId: string;
+    }>;
+    createdAt: string;
+    updatedAt: string;
+    completedAt?: string;
+}
 interface JobStore {
     /**
      * Update job in job store.
@@ -29,21 +48,38 @@ interface JobStore {
      * Get current job record from job store.
      * @returns Job record or null if not found
      */
-    get(): Promise<{
+    get(): Promise<JobRecord | null>;
+    /**
+     * Append an internal (child) job to the current job's internalJobs list.
+     * Used when this worker dispatches another worker (fire-and-forget or await).
+     */
+    appendInternalJob?(entry: {
         jobId: string;
         workerId: string;
-        status: 'queued' | 'running' | 'completed' | 'failed';
-        input: any;
-        output?: any;
-        error?: {
-            message: string;
-            stack?: string;
-        };
-        metadata?: Record<string, any>;
-        createdAt: string;
-        updatedAt: string;
-        completedAt?: string;
-    } | null>;
+    }): Promise<void>;
+    /**
+     * Get any job by jobId (e.g. to poll child job status when await: true).
+     * @returns Job record or null if not found
+     */
+    getJob?(jobId: string): Promise<JobRecord | null>;
+}
+/** Max SQS delay in seconds (AWS limit). */
+declare const SQS_MAX_DELAY_SECONDS = 900;
+/** Options for ctx.dispatchWorker (worker-to-worker). */
+interface DispatchWorkerOptions {
+    webhookUrl?: string;
+    metadata?: Record<string, any>;
+    /** Optional job ID for the child job (default: generated). */
+    jobId?: string;
+    /** If true, poll job store until child completes or fails; otherwise fire-and-forget. */
+    await?: boolean;
+    pollIntervalMs?: number;
+    pollTimeoutMs?: number;
+    /**
+     * Delay before the child is invoked (fire-and-forget only; ignored when await is true).
+     * Uses SQS DelaySeconds (0–900). In local mode, waits this many seconds before sending the trigger request.
+     */
+    delaySeconds?: number;
 }
 interface WorkerHandlerParams<INPUT, OUTPUT> {
     input: INPUT;
@@ -56,10 +92,43 @@ interface WorkerHandlerParams<INPUT, OUTPUT> {
          * Uses MongoDB directly when configured; never HTTP/origin URL.
          */
         jobStore?: JobStore;
+        /**
+         * Dispatch another worker (fire-and-forget or await). Uses WORKER_QUEUE_URL_<SANITIZED_ID> env.
+         * Always provided by the runtime (Lambda and local).
+         */
+        dispatchWorker: (workerId: string, input: unknown, options?: DispatchWorkerOptions) => Promise<{
+            jobId: string;
+            messageId?: string;
+            output?: unknown;
+        }>;
         [key: string]: any;
     };
 }
 type WorkerHandler<INPUT, OUTPUT> = (params: WorkerHandlerParams<INPUT, OUTPUT>) => Promise<OUTPUT>;
+/** Result of getNextStep for queue chaining. */
+interface QueueNextStep {
+    workerId: string;
+    delaySeconds?: number;
+    mapInputFromPrev?: string;
+}
+/** Runtime helpers for queue-aware wrappers (provided by generated registry). */
+interface QueueRuntime {
+    getNextStep(queueId: string, stepIndex: number): QueueNextStep | undefined;
+    invokeMapInput?(queueId: string, stepIndex: number, prevOutput: unknown, initialInput: unknown): Promise<unknown> | unknown;
+}
+/**
+ * Wraps a user handler so that when the job has __workerQueue context (from
+ * dispatchQueue or queue cron), it dispatches the next worker in the sequence
+ * after the handler completes. Uses literal worker IDs so the CLI env injection
+ * picks up WORKER_QUEUE_URL_* for next-step workers.
+ */
+declare function wrapHandlerForQueue<INPUT, OUTPUT>(handler: WorkerHandler<INPUT, OUTPUT>, queueRuntime: QueueRuntime): WorkerHandler<INPUT & {
+    __workerQueue?: {
+        id: string;
+        stepIndex: number;
+        initialInput: unknown;
+    };
+}, OUTPUT>;
 interface SQSMessageBody {
     workerId: string;
     jobId: string;
@@ -93,4 +162,4 @@ interface WebhookPayload {
  */
 declare function createLambdaHandler<INPUT, OUTPUT>(handler: WorkerHandler<INPUT, OUTPUT>, outputSchema?: ZodType<OUTPUT>): (event: SQSEvent, context: Context) => Promise<void>;
 
-export { type JobStore, type JobStoreUpdate, type SQSMessageBody, type WebhookPayload, type WorkerHandler, type WorkerHandlerParams, createLambdaHandler };
+export { type DispatchWorkerOptions, type JobRecord, type JobStore, type JobStoreUpdate, type QueueNextStep, type QueueRuntime, type SQSMessageBody, SQS_MAX_DELAY_SECONDS, type WebhookPayload, type WorkerHandler, type WorkerHandlerParams, createLambdaHandler, wrapHandlerForQueue };