@microfox/ai-worker 1.0.1

package/dist/chunk-ZYYWZ3PR.mjs

@@ -0,0 +1,50 @@
+// src/config.ts
+var cachedConfig = null;
+var cacheExpiry = 0;
+var CACHE_TTL_MS = 5 * 60 * 1e3;
+async function getWorkersConfig(apiUrl, apiKey) {
+  const now = Date.now();
+  if (cachedConfig && now < cacheExpiry) {
+    return cachedConfig;
+  }
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (apiKey) {
+    headers["x-workers-config-key"] = apiKey;
+  }
+  const response = await fetch(apiUrl, {
+    method: "GET",
+    headers
+  });
+  if (!response.ok) {
+    throw new Error(
+      `Failed to fetch workers config: ${response.status} ${response.statusText}`
+    );
+  }
+  const config = await response.json();
+  cachedConfig = config;
+  cacheExpiry = now + CACHE_TTL_MS;
+  return config;
+}
+async function resolveQueueUrl(workerId, apiUrl, apiKey) {
+  const config = await getWorkersConfig(apiUrl, apiKey);
+  const worker = config.workers[workerId];
+  if (!worker) {
+    throw new Error(
+      `Worker "${workerId}" not found in workers config. Available workers: ${Object.keys(config.workers).join(", ")}`
+    );
+  }
+  return worker.queueUrl;
+}
+function clearWorkersConfigCache() {
+  cachedConfig = null;
+  cacheExpiry = 0;
+}
+
+export {
+  getWorkersConfig,
+  resolveQueueUrl,
+  clearWorkersConfigCache
+};
+//# sourceMappingURL=chunk-ZYYWZ3PR.mjs.map

package/dist/chunk-ZYYWZ3PR.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/config.ts"],"sourcesContent":["/**\n * Workers-config client for resolving queue URLs from the workers-config API Lambda.\n */\n\nexport interface WorkersConfig {\n  version: string;\n  stage: string;\n  region: string;\n  workers: Record<\n    string,\n    {\n      queueUrl: string;\n      region: string;\n    }\n  >;\n}\n\nlet cachedConfig: WorkersConfig | null = null;\nlet cacheExpiry: number = 0;\nconst CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes\n\n/**\n * Fetches the workers configuration from the workers-config API.\n * Results are cached for 5 minutes to reduce API calls.\n *\n * @param apiUrl - The URL of the workers-config API endpoint\n * @param apiKey - Optional API key for authentication (sent as x-workers-config-key header)\n * @returns The workers configuration mapping worker IDs to queue URLs\n */\nexport async function getWorkersConfig(\n  apiUrl: string,\n  apiKey?: string\n): Promise<WorkersConfig> {\n  const now = Date.now();\n\n  // Return cached config if still valid\n  if (cachedConfig && now < cacheExpiry) {\n    return cachedConfig;\n  }\n\n  const headers: Record<string, string> = {\n    'Content-Type': 'application/json',\n  };\n\n  if (apiKey) {\n    headers['x-workers-config-key'] = apiKey;\n  }\n\n  const response = await fetch(apiUrl, {\n    method: 'GET',\n    headers,\n  });\n\n  if (!response.ok) {\n    throw new Error(\n      `Failed to fetch workers config: ${response.status} ${response.statusText}`\n    );\n  }\n\n  const config = (await response.json()) as WorkersConfig;\n  cachedConfig = config;\n  cacheExpiry = now + CACHE_TTL_MS;\n\n  return config;\n}\n\n/**\n * Resolves the queue URL for a specific worker ID.\n * Throws an error if the worker ID is not found in the configuration.\n *\n * @param workerId - The ID of the worker\n * @param apiUrl - The URL of the workers-config API endpoint\n * @param apiKey - Optional API key for authentication\n * @returns The queue URL for the worker\n */\nexport async function resolveQueueUrl(\n  workerId: string,\n  apiUrl: string,\n  apiKey?: string\n): Promise<string> {\n  const config = await getWorkersConfig(apiUrl, apiKey);\n  const worker = config.workers[workerId];\n\n  if (!worker) {\n    throw new Error(\n      `Worker \"${workerId}\" not found in workers config. Available workers: ${Object.keys(config.workers).join(', ')}`\n    );\n  }\n\n  return worker.queueUrl;\n}\n\n/**\n * Clears the cached workers configuration.\n * Useful for testing or when you need to force a refresh.\n */\nexport function clearWorkersConfigCache(): void {\n  cachedConfig = null;\n  cacheExpiry = 0;\n}\n"],"mappings":";AAiBA,IAAI,eAAqC;AACzC,IAAI,cAAsB;AAC1B,IAAM,eAAe,IAAI,KAAK;AAU9B,eAAsB,iBACpB,QACA,QACwB;AACxB,QAAM,MAAM,KAAK,IAAI;AAGrB,MAAI,gBAAgB,MAAM,aAAa;AACrC,WAAO;AAAA,EACT;AAEA,QAAM,UAAkC;AAAA,IACtC,gBAAgB;AAAA,EAClB;AAEA,MAAI,QAAQ;AACV,YAAQ,sBAAsB,IAAI;AAAA,EACpC;AAEA,QAAM,WAAW,MAAM,MAAM,QAAQ;AAAA,IACnC,QAAQ;AAAA,IACR;AAAA,EACF,CAAC;AAED,MAAI,CAAC,SAAS,IAAI;AAChB,UAAM,IAAI;AAAA,MACR,mCAAmC,SAAS,MAAM,IAAI,SAAS,UAAU;AAAA,IAC3E;AAAA,EACF;AAEA,QAAM,SAAU,MAAM,SAAS,KAAK;AACpC,iBAAe;AACf,gBAAc,MAAM;AAEpB,SAAO;AACT;AAWA,eAAsB,gBACpB,UACA,QACA,QACiB;AACjB,QAAM,SAAS,MAAM,iBAAiB,QAAQ,MAAM;AACpD,QAAM,SAAS,OAAO,QAAQ,QAAQ;AAEtC,MAAI,CAAC,QAAQ;AACX,UAAM,IAAI;AAAA,MACR,WAAW,QAAQ,qDAAqD,OAAO,KAAK,OAAO,OAAO,EAAE,KAAK,IAAI,CAAC;AAAA,IAChH;AAAA,EACF;AAEA,SAAO,OAAO;AAChB;AAMO,SAAS,0BAAgC;AAC9C,iBAAe;AACf,gBAAc;AAChB;","names":[]}

package/dist/client.d.mts

@@ -0,0 +1,64 @@
+import { ZodType, z } from 'zod';
+
+/**
+ * Client for dispatching background worker jobs.
+ *
+ * In production, dispatching happens via the workers HTTP API:
+ *   POST /workers/trigger  -> enqueues message to SQS on the workers service side
+ *
+ * This avoids requiring AWS credentials in your Next.js app.
+ */
+
+interface DispatchOptions {
+    /**
+     * Optional webhook callback URL to notify when the job finishes.
+     * Only called when provided. Default: no webhook (use job store / MongoDB only).
+     */
+    webhookUrl?: string;
+    /**
+     * Controls how dispatch executes.
+     * - "auto" (default): local inline execution in development unless WORKERS_LOCAL_MODE=false.
+     * - "local": force inline execution (no SQS).
+     * - "remote": force SQS/Lambda dispatch even in development.
+     */
+    mode?: 'auto' | 'local' | 'remote';
+    jobId?: string;
+    metadata?: Record<string, any>;
+}
+interface DispatchResult {
+    messageId: string;
+    status: 'queued';
+    jobId: string;
+}
+interface SerializedContext {
+    requestId?: string;
+    userId?: string;
+    traceId?: string;
+    [key: string]: any;
+}
+/**
+ * Dispatches a background worker job to SQS.
+ *
+ * @param workerId - The ID of the worker to dispatch
+ * @param input - The input data for the worker (will be validated against inputSchema)
+ * @param inputSchema - Zod schema for input validation
+ * @param options - Dispatch options including webhook URL
+ * @param ctx - Optional context object (only serializable parts will be sent)
+ * @returns Promise resolving to dispatch result with messageId and jobId
+ */
+declare function dispatch<INPUT_SCHEMA extends ZodType<any>>(workerId: string, input: z.input<INPUT_SCHEMA>, inputSchema: INPUT_SCHEMA, options: DispatchOptions, ctx?: any): Promise<DispatchResult>;
+/**
+ * Local development mode: runs the handler immediately in the same process.
+ * This bypasses SQS and Lambda for faster iteration during development.
+ *
+ * @param handler - The worker handler function
+ * @param input - The input data
+ * @param ctx - The context object
+ * @returns The handler result
+ */
+declare function dispatchLocal<INPUT, OUTPUT>(handler: (params: {
+    input: INPUT;
+    ctx: any;
+}) => Promise<OUTPUT>, input: INPUT, ctx?: any): Promise<OUTPUT>;
+
+export { type DispatchOptions, type DispatchResult, type SerializedContext, dispatch, dispatchLocal };

package/dist/client.d.ts

@@ -0,0 +1,64 @@
+import { ZodType, z } from 'zod';
+
+/**
+ * Client for dispatching background worker jobs.
+ *
+ * In production, dispatching happens via the workers HTTP API:
+ *   POST /workers/trigger  -> enqueues message to SQS on the workers service side
+ *
+ * This avoids requiring AWS credentials in your Next.js app.
+ */
+
+interface DispatchOptions {
+    /**
+     * Optional webhook callback URL to notify when the job finishes.
+     * Only called when provided. Default: no webhook (use job store / MongoDB only).
+     */
+    webhookUrl?: string;
+    /**
+     * Controls how dispatch executes.
+     * - "auto" (default): local inline execution in development unless WORKERS_LOCAL_MODE=false.
+     * - "local": force inline execution (no SQS).
+     * - "remote": force SQS/Lambda dispatch even in development.
+     */
+    mode?: 'auto' | 'local' | 'remote';
+    jobId?: string;
+    metadata?: Record<string, any>;
+}
+interface DispatchResult {
+    messageId: string;
+    status: 'queued';
+    jobId: string;
+}
+interface SerializedContext {
+    requestId?: string;
+    userId?: string;
+    traceId?: string;
+    [key: string]: any;
+}
+/**
+ * Dispatches a background worker job to SQS.
+ *
+ * @param workerId - The ID of the worker to dispatch
+ * @param input - The input data for the worker (will be validated against inputSchema)
+ * @param inputSchema - Zod schema for input validation
+ * @param options - Dispatch options including webhook URL
+ * @param ctx - Optional context object (only serializable parts will be sent)
+ * @returns Promise resolving to dispatch result with messageId and jobId
+ */
+declare function dispatch<INPUT_SCHEMA extends ZodType<any>>(workerId: string, input: z.input<INPUT_SCHEMA>, inputSchema: INPUT_SCHEMA, options: DispatchOptions, ctx?: any): Promise<DispatchResult>;
+/**
+ * Local development mode: runs the handler immediately in the same process.
+ * This bypasses SQS and Lambda for faster iteration during development.
+ *
+ * @param handler - The worker handler function
+ * @param input - The input data
+ * @param ctx - The context object
+ * @returns The handler result
+ */
+declare function dispatchLocal<INPUT, OUTPUT>(handler: (params: {
+    input: INPUT;
+    ctx: any;
+}) => Promise<OUTPUT>, input: INPUT, ctx?: any): Promise<OUTPUT>;
+
+export { type DispatchOptions, type DispatchResult, type SerializedContext, dispatch, dispatchLocal };

package/dist/client.js

@@ -0,0 +1,108 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/client.ts
+var client_exports = {};
+__export(client_exports, {
+  dispatch: () => dispatch,
+  dispatchLocal: () => dispatchLocal
+});
+module.exports = __toCommonJS(client_exports);
+function getWorkersTriggerUrl() {
+  const raw = process.env.WORKER_BASE_URL || process.env.NEXT_PUBLIC_WORKER_BASE_URL || process.env.WORKERS_TRIGGER_API_URL || process.env.NEXT_PUBLIC_WORKERS_TRIGGER_API_URL || process.env.WORKERS_CONFIG_API_URL || process.env.NEXT_PUBLIC_WORKERS_CONFIG_API_URL;
+  if (!raw) {
+    throw new Error(
+      "WORKER_BASE_URL (preferred) or NEXT_PUBLIC_WORKER_BASE_URL is required for background workers"
+    );
+  }
+  const url = new URL(raw);
+  url.search = "";
+  url.hash = "";
+  const path = url.pathname || "";
+  url.pathname = path.replace(/\/?workers\/(trigger|config)\/?$/, "");
+  const basePath = url.pathname.replace(/\/+$/, "");
+  url.pathname = `${basePath}/workers/trigger`.replace(/\/+$/, "");
+  return url.toString();
+}
+function serializeContext(ctx) {
+  const serialized = {};
+  if (ctx.requestId) {
+    serialized.requestId = ctx.requestId;
+  }
+  if (ctx.metadata && typeof ctx.metadata === "object") {
+    Object.assign(serialized, ctx.metadata);
+  }
+  if (ctx._serializeContext && typeof ctx._serializeContext === "function") {
+    const custom = ctx._serializeContext();
+    Object.assign(serialized, custom);
+  }
+  return serialized;
+}
+async function dispatch(workerId, input, inputSchema, options, ctx) {
+  const validatedInput = inputSchema.parse(input);
+  const jobId = options.jobId || `job-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+  const triggerUrl = getWorkersTriggerUrl();
+  const serializedContext = ctx ? serializeContext(ctx) : {};
+  const messageBody = {
+    workerId,
+    jobId,
+    input: validatedInput,
+    context: serializedContext,
+    webhookUrl: options.webhookUrl,
+    metadata: options.metadata || {},
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  const triggerKey = process.env.WORKERS_TRIGGER_API_KEY;
+  if (triggerKey) {
+    headers["x-workers-trigger-key"] = triggerKey;
+  }
+  const response = await fetch(triggerUrl, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({
+      workerId,
+      body: messageBody
+    })
+  });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(
+      `Failed to trigger worker "${workerId}": ${response.status} ${response.statusText}${text ? ` - ${text}` : ""}`
+    );
+  }
+  const data = await response.json().catch(() => ({}));
+  const messageId = data?.messageId ? String(data.messageId) : `trigger-${jobId}`;
+  return {
+    messageId,
+    status: "queued",
+    jobId
+  };
+}
+async function dispatchLocal(handler, input, ctx) {
+  return handler({ input, ctx: ctx || {} });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  dispatch,
+  dispatchLocal
+});
+//# sourceMappingURL=client.js.map

package/dist/client.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/client.ts"],"sourcesContent":["/**\n * Client for dispatching background worker jobs.\n *\n * In production, dispatching happens via the workers HTTP API:\n *   POST /workers/trigger  -> enqueues message to SQS on the workers service side\n *\n * This avoids requiring AWS credentials in your Next.js app.\n */\n\nimport type { ZodType, z } from 'zod';\n\nexport interface DispatchOptions {\n  /**\n   * Optional webhook callback URL to notify when the job finishes.\n   * Only called when provided. Default: no webhook (use job store / MongoDB only).\n   */\n  webhookUrl?: string;\n  /**\n   * Controls how dispatch executes.\n   * - \"auto\" (default): local inline execution in development unless WORKERS_LOCAL_MODE=false.\n   * - \"local\": force inline execution (no SQS).\n   * - \"remote\": force SQS/Lambda dispatch even in development.\n   */\n  mode?: 'auto' | 'local' | 'remote';\n  jobId?: string;\n  metadata?: Record<string, any>;\n}\n\nexport interface DispatchResult {\n  messageId: string;\n  status: 'queued';\n  jobId: string;\n}\n\nexport interface SerializedContext {\n  requestId?: string;\n  userId?: string;\n  traceId?: string;\n  [key: string]: any;\n}\n\n/**\n * Derives the full /workers/trigger URL from env.\n *\n * Preferred env vars:\n * - WORKER_BASE_URL: base URL of the workers service (e.g. https://.../prod)\n * - NEXT_PUBLIC_WORKER_BASE_URL: same, but exposed to the browser\n *\n * Legacy env vars (still supported for backwards compatibility):\n * - WORKERS_TRIGGER_API_URL / NEXT_PUBLIC_WORKERS_TRIGGER_API_URL\n * - WORKERS_CONFIG_API_URL / NEXT_PUBLIC_WORKERS_CONFIG_API_URL\n */\nfunction getWorkersTriggerUrl(): string {\n  const raw =\n    process.env.WORKER_BASE_URL ||\n    process.env.NEXT_PUBLIC_WORKER_BASE_URL ||\n    process.env.WORKERS_TRIGGER_API_URL ||\n    process.env.NEXT_PUBLIC_WORKERS_TRIGGER_API_URL ||\n    process.env.WORKERS_CONFIG_API_URL ||\n    process.env.NEXT_PUBLIC_WORKERS_CONFIG_API_URL;\n\n  if (!raw) {\n    throw new Error(\n      'WORKER_BASE_URL (preferred) or NEXT_PUBLIC_WORKER_BASE_URL is required for background workers'\n    );\n  }\n\n  const url = new URL(raw);\n  url.search = '';\n  url.hash = '';\n\n  const path = url.pathname || '';\n\n  // If the user pointed at a specific endpoint, normalize back to the service root.\n  url.pathname = path.replace(/\\/?workers\\/(trigger|config)\\/?$/, '');\n\n  const basePath = url.pathname.replace(/\\/+$/, '');\n  url.pathname = `${basePath}/workers/trigger`.replace(/\\/+$/, '');\n\n  return url.toString();\n}\n\n/**\n * Serializes context data for transmission to Lambda.\n * Only serializes safe, JSON-compatible properties.\n */\nfunction serializeContext(ctx: any): SerializedContext {\n  const serialized: SerializedContext = {};\n\n  if (ctx.requestId) {\n    serialized.requestId = ctx.requestId;\n  }\n\n  // Extract any additional serializable metadata\n  if (ctx.metadata && typeof ctx.metadata === 'object') {\n    Object.assign(serialized, ctx.metadata);\n  }\n\n  // Allow custom context serialization via a helper property\n  if (ctx._serializeContext && typeof ctx._serializeContext === 'function') {\n    const custom = ctx._serializeContext();\n    Object.assign(serialized, custom);\n  }\n\n  return serialized;\n}\n\n/**\n * Dispatches a background worker job to SQS.\n *\n * @param workerId - The ID of the worker to dispatch\n * @param input - The input data for the worker (will be validated against inputSchema)\n * @param inputSchema - Zod schema for input validation\n * @param options - Dispatch options including webhook URL\n * @param ctx - Optional context object (only serializable parts will be sent)\n * @returns Promise resolving to dispatch result with messageId and jobId\n */\nexport async function dispatch<INPUT_SCHEMA extends ZodType<any>>(\n  workerId: string,\n  input: z.input<INPUT_SCHEMA>,\n  inputSchema: INPUT_SCHEMA,\n  options: DispatchOptions,\n  ctx?: any\n): Promise<DispatchResult> {\n  // Validate input against schema\n  const validatedInput = inputSchema.parse(input);\n\n  // Generate job ID if not provided\n  const jobId =\n    options.jobId || `job-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;\n\n  // Resolve /workers/trigger endpoint URL\n  const triggerUrl = getWorkersTriggerUrl();\n\n  // Serialize context (only safe, JSON-compatible parts)\n  const serializedContext = ctx ? serializeContext(ctx) : {};\n\n  // Job updates use MongoDB only; never pass jobStoreUrl/origin URL.\n  const messageBody = {\n    workerId,\n    jobId,\n    input: validatedInput,\n    context: serializedContext,\n    webhookUrl: options.webhookUrl,\n    metadata: options.metadata || {},\n    timestamp: new Date().toISOString(),\n  };\n\n  const headers: Record<string, string> = {\n    'Content-Type': 'application/json',\n  };\n  const triggerKey = process.env.WORKERS_TRIGGER_API_KEY;\n  if (triggerKey) {\n    headers['x-workers-trigger-key'] = triggerKey;\n  }\n\n  const response = await fetch(triggerUrl, {\n    method: 'POST',\n    headers,\n    body: JSON.stringify({\n      workerId,\n      body: messageBody,\n    }),\n  });\n\n  if (!response.ok) {\n    const text = await response.text().catch(() => '');\n    throw new Error(\n      `Failed to trigger worker \"${workerId}\": ${response.status} ${response.statusText}${text ? ` - ${text}` : ''}`\n    );\n  }\n\n  const data = (await response.json().catch(() => ({}))) as any;\n  const messageId = data?.messageId ? String(data.messageId) : `trigger-${jobId}`;\n\n  return {\n    messageId,\n    status: 'queued',\n    jobId,\n  };\n}\n\n/**\n * Local development mode: runs the handler immediately in the same process.\n * This bypasses SQS and Lambda for faster iteration during development.\n *\n * @param handler - The worker handler function\n * @param input - The input data\n * @param ctx - The context object\n * @returns The handler result\n */\nexport async function dispatchLocal<INPUT, OUTPUT>(\n  handler: (params: { input: INPUT; ctx: any }) => Promise<OUTPUT>,\n  input: INPUT,\n  ctx?: any\n): Promise<OUTPUT> {\n  return handler({ input, ctx: ctx || {} });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAoDA,SAAS,uBAA+B;AACtC,QAAM,MACJ,QAAQ,IAAI,mBACZ,QAAQ,IAAI,+BACZ,QAAQ,IAAI,2BACZ,QAAQ,IAAI,uCACZ,QAAQ,IAAI,0BACZ,QAAQ,IAAI;AAEd,MAAI,CAAC,KAAK;AACR,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EACF;AAEA,QAAM,MAAM,IAAI,IAAI,GAAG;AACvB,MAAI,SAAS;AACb,MAAI,OAAO;AAEX,QAAM,OAAO,IAAI,YAAY;AAG7B,MAAI,WAAW,KAAK,QAAQ,oCAAoC,EAAE;AAElE,QAAM,WAAW,IAAI,SAAS,QAAQ,QAAQ,EAAE;AAChD,MAAI,WAAW,GAAG,QAAQ,mBAAmB,QAAQ,QAAQ,EAAE;AAE/D,SAAO,IAAI,SAAS;AACtB;AAMA,SAAS,iBAAiB,KAA6B;AACrD,QAAM,aAAgC,CAAC;AAEvC,MAAI,IAAI,WAAW;AACjB,eAAW,YAAY,IAAI;AAAA,EAC7B;AAGA,MAAI,IAAI,YAAY,OAAO,IAAI,aAAa,UAAU;AACpD,WAAO,OAAO,YAAY,IAAI,QAAQ;AAAA,EACxC;AAGA,MAAI,IAAI,qBAAqB,OAAO,IAAI,sBAAsB,YAAY;AACxE,UAAM,SAAS,IAAI,kBAAkB;AACrC,WAAO,OAAO,YAAY,MAAM;AAAA,EAClC;AAEA,SAAO;AACT;AAYA,eAAsB,SACpB,UACA,OACA,aACA,SACA,KACyB;AAEzB,QAAM,iBAAiB,YAAY,MAAM,KAAK;AAG9C,QAAM,QACJ,QAAQ,SAAS,OAAO,KAAK,IAAI,CAAC,IAAI,KAAK,OAAO,EAAE,SAAS,EAAE,EAAE,OAAO,GAAG,CAAC,CAAC;AAG/E,QAAM,aAAa,qBAAqB;AAGxC,QAAM,oBAAoB,MAAM,iBAAiB,GAAG,IAAI,CAAC;AAGzD,QAAM,cAAc;AAAA,IAClB;AAAA,IACA;AAAA,IACA,OAAO;AAAA,IACP,SAAS;AAAA,IACT,YAAY,QAAQ;AAAA,IACpB,UAAU,QAAQ,YAAY,CAAC;AAAA,IAC/B,YAAW,oBAAI,KAAK,GAAE,YAAY;AAAA,EACpC;AAEA,QAAM,UAAkC;AAAA,IACtC,gBAAgB;AAAA,EAClB;AACA,QAAM,aAAa,QAAQ,IAAI;AAC/B,MAAI,YAAY;AACd,YAAQ,uBAAuB,IAAI;AAAA,EACrC;AAEA,QAAM,WAAW,MAAM,MAAM,YAAY;AAAA,IACvC,QAAQ;AAAA,IACR;AAAA,IACA,MAAM,KAAK,UAAU;AAAA,MACnB;AAAA,MACA,MAAM;AAAA,IACR,CAAC;AAAA,EACH,CAAC;AAED,MAAI,CAAC,SAAS,IAAI;AAChB,UAAM,OAAO,MAAM,SAAS,KAAK,EAAE,MAAM,MAAM,EAAE;AACjD,UAAM,IAAI;AAAA,MACR,6BAA6B,QAAQ,MAAM,SAAS,MAAM,IAAI,SAAS,UAAU,GAAG,OAAO,MAAM,IAAI,KAAK,EAAE;AAAA,IAC9G;AAAA,EACF;AAEA,QAAM,OAAQ,MAAM,SAAS,KAAK,EAAE,MAAM,OAAO,CAAC,EAAE;AACpD,QAAM,YAAY,MAAM,YAAY,OAAO,KAAK,SAAS,IAAI,WAAW,KAAK;AAE7E,SAAO;AAAA,IACL;AAAA,IACA,QAAQ;AAAA,IACR;AAAA,EACF;AACF;AAWA,eAAsB,cACpB,SACA,OACA,KACiB;AACjB,SAAO,QAAQ,EAAE,OAAO,KAAK,OAAO,CAAC,EAAE,CAAC;AAC1C;","names":[]}

package/dist/client.mjs

@@ -0,0 +1,10 @@
+import {
+  dispatch,
+  dispatchLocal
+} from "./chunk-FQCZSXDI.mjs";
+import "./chunk-BJTO5JO5.mjs";
+export {
+  dispatch,
+  dispatchLocal
+};
+//# sourceMappingURL=client.mjs.map

package/dist/client.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/config.d.mts

@@ -0,0 +1,38 @@
+/**
+ * Workers-config client for resolving queue URLs from the workers-config API Lambda.
+ */
+interface WorkersConfig {
+    version: string;
+    stage: string;
+    region: string;
+    workers: Record<string, {
+        queueUrl: string;
+        region: string;
+    }>;
+}
+/**
+ * Fetches the workers configuration from the workers-config API.
+ * Results are cached for 5 minutes to reduce API calls.
+ *
+ * @param apiUrl - The URL of the workers-config API endpoint
+ * @param apiKey - Optional API key for authentication (sent as x-workers-config-key header)
+ * @returns The workers configuration mapping worker IDs to queue URLs
+ */
+declare function getWorkersConfig(apiUrl: string, apiKey?: string): Promise<WorkersConfig>;
+/**
+ * Resolves the queue URL for a specific worker ID.
+ * Throws an error if the worker ID is not found in the configuration.
+ *
+ * @param workerId - The ID of the worker
+ * @param apiUrl - The URL of the workers-config API endpoint
+ * @param apiKey - Optional API key for authentication
+ * @returns The queue URL for the worker
+ */
+declare function resolveQueueUrl(workerId: string, apiUrl: string, apiKey?: string): Promise<string>;
+/**
+ * Clears the cached workers configuration.
+ * Useful for testing or when you need to force a refresh.
+ */
+declare function clearWorkersConfigCache(): void;
+
+export { type WorkersConfig, clearWorkersConfigCache, getWorkersConfig, resolveQueueUrl };

package/dist/config.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Workers-config client for resolving queue URLs from the workers-config API Lambda.
+ */
+interface WorkersConfig {
+    version: string;
+    stage: string;
+    region: string;
+    workers: Record<string, {
+        queueUrl: string;
+        region: string;
+    }>;
+}
+/**
+ * Fetches the workers configuration from the workers-config API.
+ * Results are cached for 5 minutes to reduce API calls.
+ *
+ * @param apiUrl - The URL of the workers-config API endpoint
+ * @param apiKey - Optional API key for authentication (sent as x-workers-config-key header)
+ * @returns The workers configuration mapping worker IDs to queue URLs
+ */
+declare function getWorkersConfig(apiUrl: string, apiKey?: string): Promise<WorkersConfig>;
+/**
+ * Resolves the queue URL for a specific worker ID.
+ * Throws an error if the worker ID is not found in the configuration.
+ *
+ * @param workerId - The ID of the worker
+ * @param apiUrl - The URL of the workers-config API endpoint
+ * @param apiKey - Optional API key for authentication
+ * @returns The queue URL for the worker
+ */
+declare function resolveQueueUrl(workerId: string, apiUrl: string, apiKey?: string): Promise<string>;
+/**
+ * Clears the cached workers configuration.
+ * Useful for testing or when you need to force a refresh.
+ */
+declare function clearWorkersConfigCache(): void;
+
+export { type WorkersConfig, clearWorkersConfigCache, getWorkersConfig, resolveQueueUrl };

package/dist/config.js

@@ -0,0 +1,76 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/config.ts
+var config_exports = {};
+__export(config_exports, {
+  clearWorkersConfigCache: () => clearWorkersConfigCache,
+  getWorkersConfig: () => getWorkersConfig,
+  resolveQueueUrl: () => resolveQueueUrl
+});
+module.exports = __toCommonJS(config_exports);
+var cachedConfig = null;
+var cacheExpiry = 0;
+var CACHE_TTL_MS = 5 * 60 * 1e3;
+async function getWorkersConfig(apiUrl, apiKey) {
+  const now = Date.now();
+  if (cachedConfig && now < cacheExpiry) {
+    return cachedConfig;
+  }
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (apiKey) {
+    headers["x-workers-config-key"] = apiKey;
+  }
+  const response = await fetch(apiUrl, {
+    method: "GET",
+    headers
+  });
+  if (!response.ok) {
+    throw new Error(
+      `Failed to fetch workers config: ${response.status} ${response.statusText}`
+    );
+  }
+  const config = await response.json();
+  cachedConfig = config;
+  cacheExpiry = now + CACHE_TTL_MS;
+  return config;
+}
+async function resolveQueueUrl(workerId, apiUrl, apiKey) {
+  const config = await getWorkersConfig(apiUrl, apiKey);
+  const worker = config.workers[workerId];
+  if (!worker) {
+    throw new Error(
+      `Worker "${workerId}" not found in workers config. Available workers: ${Object.keys(config.workers).join(", ")}`
+    );
+  }
+  return worker.queueUrl;
+}
+function clearWorkersConfigCache() {
+  cachedConfig = null;
+  cacheExpiry = 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  clearWorkersConfigCache,
+  getWorkersConfig,
+  resolveQueueUrl
+});
+//# sourceMappingURL=config.js.map

package/dist/config.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/config.ts"],"sourcesContent":["/**\n * Workers-config client for resolving queue URLs from the workers-config API Lambda.\n */\n\nexport interface WorkersConfig {\n  version: string;\n  stage: string;\n  region: string;\n  workers: Record<\n    string,\n    {\n      queueUrl: string;\n      region: string;\n    }\n  >;\n}\n\nlet cachedConfig: WorkersConfig | null = null;\nlet cacheExpiry: number = 0;\nconst CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes\n\n/**\n * Fetches the workers configuration from the workers-config API.\n * Results are cached for 5 minutes to reduce API calls.\n *\n * @param apiUrl - The URL of the workers-config API endpoint\n * @param apiKey - Optional API key for authentication (sent as x-workers-config-key header)\n * @returns The workers configuration mapping worker IDs to queue URLs\n */\nexport async function getWorkersConfig(\n  apiUrl: string,\n  apiKey?: string\n): Promise<WorkersConfig> {\n  const now = Date.now();\n\n  // Return cached config if still valid\n  if (cachedConfig && now < cacheExpiry) {\n    return cachedConfig;\n  }\n\n  const headers: Record<string, string> = {\n    'Content-Type': 'application/json',\n  };\n\n  if (apiKey) {\n    headers['x-workers-config-key'] = apiKey;\n  }\n\n  const response = await fetch(apiUrl, {\n    method: 'GET',\n    headers,\n  });\n\n  if (!response.ok) {\n    throw new Error(\n      `Failed to fetch workers config: ${response.status} ${response.statusText}`\n    );\n  }\n\n  const config = (await response.json()) as WorkersConfig;\n  cachedConfig = config;\n  cacheExpiry = now + CACHE_TTL_MS;\n\n  return config;\n}\n\n/**\n * Resolves the queue URL for a specific worker ID.\n * Throws an error if the worker ID is not found in the configuration.\n *\n * @param workerId - The ID of the worker\n * @param apiUrl - The URL of the workers-config API endpoint\n * @param apiKey - Optional API key for authentication\n * @returns The queue URL for the worker\n */\nexport async function resolveQueueUrl(\n  workerId: string,\n  apiUrl: string,\n  apiKey?: string\n): Promise<string> {\n  const config = await getWorkersConfig(apiUrl, apiKey);\n  const worker = config.workers[workerId];\n\n  if (!worker) {\n    throw new Error(\n      `Worker \"${workerId}\" not found in workers config. Available workers: ${Object.keys(config.workers).join(', ')}`\n    );\n  }\n\n  return worker.queueUrl;\n}\n\n/**\n * Clears the cached workers configuration.\n * Useful for testing or when you need to force a refresh.\n */\nexport function clearWorkersConfigCache(): void {\n  cachedConfig = null;\n  cacheExpiry = 0;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAiBA,IAAI,eAAqC;AACzC,IAAI,cAAsB;AAC1B,IAAM,eAAe,IAAI,KAAK;AAU9B,eAAsB,iBACpB,QACA,QACwB;AACxB,QAAM,MAAM,KAAK,IAAI;AAGrB,MAAI,gBAAgB,MAAM,aAAa;AACrC,WAAO;AAAA,EACT;AAEA,QAAM,UAAkC;AAAA,IACtC,gBAAgB;AAAA,EAClB;AAEA,MAAI,QAAQ;AACV,YAAQ,sBAAsB,IAAI;AAAA,EACpC;AAEA,QAAM,WAAW,MAAM,MAAM,QAAQ;AAAA,IACnC,QAAQ;AAAA,IACR;AAAA,EACF,CAAC;AAED,MAAI,CAAC,SAAS,IAAI;AAChB,UAAM,IAAI;AAAA,MACR,mCAAmC,SAAS,MAAM,IAAI,SAAS,UAAU;AAAA,IAC3E;AAAA,EACF;AAEA,QAAM,SAAU,MAAM,SAAS,KAAK;AACpC,iBAAe;AACf,gBAAc,MAAM;AAEpB,SAAO;AACT;AAWA,eAAsB,gBACpB,UACA,QACA,QACiB;AACjB,QAAM,SAAS,MAAM,iBAAiB,QAAQ,MAAM;AACpD,QAAM,SAAS,OAAO,QAAQ,QAAQ;AAEtC,MAAI,CAAC,QAAQ;AACX,UAAM,IAAI;AAAA,MACR,WAAW,QAAQ,qDAAqD,OAAO,KAAK,OAAO,OAAO,EAAE,KAAK,IAAI,CAAC;AAAA,IAChH;AAAA,EACF;AAEA,SAAO,OAAO;AAChB;AAMO,SAAS,0BAAgC;AAC9C,iBAAe;AACf,gBAAc;AAChB;","names":[]}

package/dist/config.mjs

@@ -0,0 +1,12 @@
+import {
+  clearWorkersConfigCache,
+  getWorkersConfig,
+  resolveQueueUrl
+} from "./chunk-ZYYWZ3PR.mjs";
+import "./chunk-BJTO5JO5.mjs";
+export {
+  clearWorkersConfigCache,
+  getWorkersConfig,
+  resolveQueueUrl
+};
+//# sourceMappingURL=config.mjs.map

package/dist/config.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/handler.d.mts

@@ -0,0 +1,96 @@
+import { SQSEvent, Context } from 'aws-lambda';
+import { ZodType } from 'zod';
+
+/**
+ * Generic Lambda handler wrapper for worker agents.
+ * Handles SQS events, executes user handlers, and sends webhook callbacks.
+ * Job store: MongoDB only. Never uses HTTP/origin URL for job updates.
+ */
+
+interface JobStoreUpdate {
+    status?: 'queued' | 'running' | 'completed' | 'failed';
+    metadata?: Record<string, any>;
+    progress?: number;
+    progressMessage?: string;
+    output?: any;
+    error?: {
+        message: string;
+        stack?: string;
+        name?: string;
+    };
+}
+interface JobStore {
+    /**
+     * Update job in job store.
+     * @param update - Update object with status, metadata, progress, output, or error
+     */
+    update(update: JobStoreUpdate): Promise<void>;
+    /**
+     * Get current job record from job store.
+     * @returns Job record or null if not found
+     */
+    get(): Promise<{
+        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>;
+}
+interface WorkerHandlerParams<INPUT, OUTPUT> {
+    input: INPUT;
+    ctx: {
+        jobId: string;
+        workerId: string;
+        requestId?: string;
+        /**
+         * Job store interface for updating and retrieving job state.
+         * Uses MongoDB directly when configured; never HTTP/origin URL.
+         */
+        jobStore?: JobStore;
+        [key: string]: any;
+    };
+}
+type WorkerHandler<INPUT, OUTPUT> = (params: WorkerHandlerParams<INPUT, OUTPUT>) => Promise<OUTPUT>;
+interface SQSMessageBody {
+    workerId: string;
+    jobId: string;
+    input: any;
+    context: Record<string, any>;
+    webhookUrl?: string;
+    /** @deprecated Never use. Job updates use MongoDB only. */
+    jobStoreUrl?: string;
+    metadata?: Record<string, any>;
+    timestamp: string;
+}
+interface WebhookPayload {
+    jobId: string;
+    workerId: string;
+    status: 'success' | 'error';
+    output?: any;
+    error?: {
+        message: string;
+        stack?: string;
+        name?: string;
+    };
+    metadata?: Record<string, any>;
+}
+/**
+ * Creates a Lambda handler function that processes SQS events for workers.
+ * Job store: MongoDB only. Never uses HTTP/origin URL for job updates.
+ *
+ * @param handler - The user's worker handler function
+ * @param outputSchema - Optional Zod schema for output validation
+ * @returns A Lambda handler function
+ */
+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 };