@microfox/ai-worker 1.0.1 → 1.0.3

package/dist/index.js

@@ -20,23 +20,31 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  SQS_MAX_DELAY_SECONDS: () => SQS_MAX_DELAY_SECONDS,
   clearWorkersConfigCache: () => clearWorkersConfigCache,
   createLambdaEntrypoint: () => createLambdaEntrypoint,
   createLambdaHandler: () => createLambdaHandler,
   createWorker: () => createWorker,
+  createWorkerLogger: () => createWorkerLogger,
+  defineWorkerQueue: () => defineWorkerQueue,
   dispatch: () => dispatch,
   dispatchLocal: () => dispatchLocal,
+  dispatchQueue: () => dispatchQueue,
+  dispatchWorker: () => dispatchWorker,
+  getQueueStartUrl: () => getQueueStartUrl,
   getWorkersConfig: () => getWorkersConfig,
-  resolveQueueUrl: () => resolveQueueUrl
+  getWorkersTriggerUrl: () => getWorkersTriggerUrl,
+  resolveQueueUrl: () => resolveQueueUrl,
+  wrapHandlerForQueue: () => wrapHandlerForQueue
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/client.ts
 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;
+  const raw = process.env.WORKER_BASE_URL || process.env.WORKERS_TRIGGER_API_URL || process.env.WORKERS_CONFIG_API_URL;
   if (!raw) {
     throw new Error(
-      "WORKER_BASE_URL (preferred) or NEXT_PUBLIC_WORKER_BASE_URL is required for background workers"
+      "WORKER_BASE_URL is required for background workers. Set it server-side only."
     );
   }
   const url = new URL(raw);
@@ -48,6 +56,23 @@ function getWorkersTriggerUrl() {
   url.pathname = `${basePath}/workers/trigger`.replace(/\/+$/, "");
   return url.toString();
 }
+function getQueueStartUrl(queueId) {
+  const raw = process.env.WORKER_BASE_URL || process.env.WORKERS_TRIGGER_API_URL || process.env.WORKERS_CONFIG_API_URL;
+  if (!raw) {
+    throw new Error(
+      "WORKER_BASE_URL is required for background workers. Set it server-side only."
+    );
+  }
+  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(/\/+$/, "");
+  const safeSegment = encodeURIComponent(queueId);
+  url.pathname = `${basePath}/queues/${safeSegment}/start`.replace(/\/+$/, "");
+  return url.toString();
+}
 function serializeContext(ctx) {
   const serialized = {};
   if (ctx.requestId) {
@@ -105,9 +130,71 @@ async function dispatch(workerId, input, inputSchema, options, ctx) {
     jobId
   };
 }
+async function dispatchWorker(workerId, input, options = {}, ctx) {
+  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: input ?? {},
+    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 || {} });
 }
+async function dispatchQueue(queueId, initialInput, options = {}, _ctx) {
+  const jobId = options.jobId || `job-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+  const queueStartUrl = getQueueStartUrl(queueId);
+  const normalizedInput = initialInput !== null && typeof initialInput === "object" ? initialInput : { value: initialInput };
+  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(queueStartUrl, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({
+      input: normalizedInput,
+      initialInput: normalizedInput,
+      metadata: options.metadata ?? {},
+      jobId,
+      ...options.webhookUrl ? { webhookUrl: options.webhookUrl } : {}
+    })
+  });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(
+      `Failed to start queue "${queueId}": ${response.status} ${response.statusText}${text ? ` - ${text}` : ""}`
+    );
+  }
+  const data = await response.json().catch(() => ({}));
+  const messageId = data?.messageId ?? data?.jobId ?? `queue-${jobId}`;
+  return { queueId, messageId, status: "queued", jobId };
+}
+
+// src/handler.ts
+var import_client_sqs = require("@aws-sdk/client-sqs");
 
 // src/mongoJobStore.ts
 var import_mongodb = require("mongodb");
@@ -134,6 +221,21 @@ async function getCollection() {
   const client = await getClient();
   return client.db(dbName).collection(collectionName);
 }
+async function getJobById(jobId) {
+  try {
+    const coll = await getCollection();
+    const doc = await coll.findOne({ _id: jobId });
+    if (!doc) return null;
+    const { _id, ...r } = doc;
+    return r;
+  } catch (e) {
+    console.error("[Worker] MongoDB getJobById failed:", {
+      jobId,
+      error: e?.message ?? String(e)
+    });
+    return null;
+  }
+}
 function createMongoJobStore(workerId, jobId, input, metadata) {
   return {
     update: async (update) => {
@@ -205,6 +307,36 @@ function createMongoJobStore(workerId, jobId, input, metadata) {
         });
         return null;
       }
+    },
+    appendInternalJob: async (entry) => {
+      try {
+        const coll = await getCollection();
+        await coll.updateOne(
+          { _id: jobId },
+          { $push: { internalJobs: entry } }
+        );
+      } catch (e) {
+        console.error("[Worker] MongoDB job store appendInternalJob failed:", {
+          jobId,
+          workerId,
+          error: e?.message ?? String(e)
+        });
+      }
+    },
+    getJob: async (otherJobId) => {
+      try {
+        const coll = await getCollection();
+        const doc = await coll.findOne({ _id: otherJobId });
+        if (!doc) return null;
+        const { _id, ...r } = doc;
+        return r;
+      } catch (e) {
+        console.error("[Worker] MongoDB job store getJob failed:", {
+          otherJobId,
+          error: e?.message ?? String(e)
+        });
+        return null;
+      }
     }
   };
 }
@@ -232,7 +364,696 @@ function isMongoJobStoreConfigured() {
   return Boolean(uri?.trim());
 }
 
+// src/redisJobStore.ts
+var import_redis = require("@upstash/redis");
+var redisUrl = process.env.WORKER_UPSTASH_REDIS_REST_URL || process.env.UPSTASH_REDIS_REST_URL || process.env.UPSTASH_REDIS_URL;
+var redisToken = process.env.WORKER_UPSTASH_REDIS_REST_TOKEN || process.env.UPSTASH_REDIS_REST_TOKEN || process.env.UPSTASH_REDIS_TOKEN;
+var jobKeyPrefix = process.env.WORKER_UPSTASH_REDIS_JOBS_PREFIX || process.env.UPSTASH_REDIS_KEY_PREFIX || process.env.REDIS_WORKER_JOB_PREFIX || "worker:jobs:";
+var defaultTtlSeconds = 60 * 60 * 24 * 7;
+var jobTtlSeconds = typeof process.env.WORKER_JOBS_TTL_SECONDS === "string" ? parseInt(process.env.WORKER_JOBS_TTL_SECONDS, 10) || defaultTtlSeconds : typeof process.env.REDIS_WORKER_JOB_TTL_SECONDS === "string" ? parseInt(process.env.REDIS_WORKER_JOB_TTL_SECONDS, 10) || defaultTtlSeconds : typeof process.env.WORKFLOW_JOBS_TTL_SECONDS === "string" ? parseInt(process.env.WORKFLOW_JOBS_TTL_SECONDS, 10) || defaultTtlSeconds : defaultTtlSeconds;
+var redisClient = null;
+function getRedis() {
+  if (!redisUrl || !redisToken) {
+    throw new Error(
+      "Upstash Redis configuration missing. Set WORKER_UPSTASH_REDIS_REST_URL and WORKER_UPSTASH_REDIS_REST_TOKEN (or UPSTASH_REDIS_REST_URL/UPSTASH_REDIS_REST_TOKEN)."
+    );
+  }
+  if (!redisClient) {
+    redisClient = new import_redis.Redis({
+      url: redisUrl,
+      token: redisToken
+    });
+  }
+  return redisClient;
+}
+function jobKey(jobId) {
+  return `${jobKeyPrefix}${jobId}`;
+}
+function internalListKey(jobId) {
+  return `${jobKeyPrefix}${jobId}:internal`;
+}
+function isRedisJobStoreConfigured() {
+  return Boolean((redisUrl || "").trim() && (redisToken || "").trim());
+}
+async function loadJob(jobId) {
+  const redis = getRedis();
+  const key = jobKey(jobId);
+  const data = await redis.hgetall(key);
+  if (!data || Object.keys(data).length === 0) return null;
+  const parseJson = (val) => {
+    if (!val) return void 0;
+    try {
+      return JSON.parse(val);
+    } catch {
+      return void 0;
+    }
+  };
+  const listKey = internalListKey(jobId);
+  const listItems = await redis.lrange(listKey, 0, -1);
+  let internalJobs;
+  if (listItems && listItems.length > 0) {
+    internalJobs = listItems.map((s) => {
+      try {
+        return JSON.parse(s);
+      } catch {
+        return null;
+      }
+    }).filter(Boolean);
+  } else {
+    internalJobs = parseJson(data.internalJobs);
+  }
+  const record = {
+    jobId: data.jobId,
+    workerId: data.workerId,
+    status: data.status || "queued",
+    input: parseJson(data.input) ?? {},
+    output: parseJson(data.output),
+    error: parseJson(data.error),
+    metadata: parseJson(data.metadata) ?? {},
+    internalJobs,
+    createdAt: data.createdAt,
+    updatedAt: data.updatedAt,
+    completedAt: data.completedAt
+  };
+  return record;
+}
+function createRedisJobStore(workerId, jobId, input, metadata) {
+  return {
+    update: async (update) => {
+      const redis = getRedis();
+      const key = jobKey(jobId);
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const existing = await loadJob(jobId);
+      const next = {};
+      const mergedMeta = { ...existing?.metadata ?? {} };
+      if (update.metadata) {
+        Object.assign(mergedMeta, update.metadata);
+      }
+      if (update.progress !== void 0 || update.progressMessage !== void 0) {
+        mergedMeta.progress = update.progress;
+        mergedMeta.progressMessage = update.progressMessage;
+      }
+      next.metadata = mergedMeta;
+      if (update.status !== void 0) {
+        next.status = update.error ? "failed" : update.status;
+        if ((update.status === "completed" || update.status === "failed") && !existing?.completedAt) {
+          next.completedAt = now;
+        }
+      }
+      if (update.output !== void 0) next.output = update.output;
+      if (update.error !== void 0) next.error = update.error;
+      const toSet = {};
+      if (next.status) toSet["status"] = String(next.status);
+      if (next.output !== void 0) toSet["output"] = JSON.stringify(next.output);
+      if (next.error !== void 0) toSet["error"] = JSON.stringify(next.error);
+      if (next.metadata !== void 0) toSet["metadata"] = JSON.stringify(next.metadata);
+      if (next.completedAt) {
+        toSet["completedAt"] = next.completedAt;
+      }
+      toSet["updatedAt"] = now;
+      await redis.hset(key, toSet);
+      if (jobTtlSeconds > 0) {
+        await redis.expire(key, jobTtlSeconds);
+      }
+    },
+    get: async () => {
+      return loadJob(jobId);
+    },
+    appendInternalJob: async (entry) => {
+      const redis = getRedis();
+      const listKey = internalListKey(jobId);
+      await redis.rpush(listKey, JSON.stringify(entry));
+      const mainKey = jobKey(jobId);
+      await redis.hset(mainKey, { updatedAt: (/* @__PURE__ */ new Date()).toISOString() });
+      if (jobTtlSeconds > 0) {
+        await redis.expire(listKey, jobTtlSeconds);
+        await redis.expire(mainKey, jobTtlSeconds);
+      }
+    },
+    getJob: async (otherJobId) => {
+      return loadJob(otherJobId);
+    }
+  };
+}
+async function upsertRedisJob(jobId, workerId, input, metadata) {
+  const redis = getRedis();
+  const key = jobKey(jobId);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const doc = {
+    jobId,
+    workerId,
+    status: "queued",
+    input,
+    metadata,
+    createdAt: now,
+    updatedAt: now
+  };
+  const toSet = {
+    jobId,
+    workerId,
+    status: doc.status,
+    input: JSON.stringify(doc.input ?? {}),
+    metadata: JSON.stringify(doc.metadata ?? {}),
+    createdAt: now,
+    updatedAt: now
+  };
+  await redis.hset(key, toSet);
+  if (jobTtlSeconds > 0) {
+    await redis.expire(key, jobTtlSeconds);
+  }
+}
+
+// src/queueJobStore.ts
+var import_redis2 = require("@upstash/redis");
+var import_mongodb2 = require("mongodb");
+var mongoUri = process.env.DATABASE_MONGODB_URI || process.env.MONGODB_URI;
+var mongoDbName = process.env.DATABASE_MONGODB_DB || process.env.MONGODB_DB || "mediamake";
+var mongoQueueCollectionName = process.env.MONGODB_QUEUE_JOBS_COLLECTION || "queue_jobs";
+var mongoClientPromise = null;
+async function getMongoClient() {
+  if (!mongoUri) {
+    throw new Error(
+      "MongoDB URI required for queue job store. Set DATABASE_MONGODB_URI or MONGODB_URI."
+    );
+  }
+  if (!mongoClientPromise) {
+    mongoClientPromise = new import_mongodb2.MongoClient(mongoUri, {
+      maxPoolSize: 10,
+      minPoolSize: 0,
+      serverSelectionTimeoutMS: 1e4
+    }).connect();
+  }
+  return mongoClientPromise;
+}
+async function getMongoQueueCollection() {
+  const client = await getMongoClient();
+  return client.db(mongoDbName).collection(mongoQueueCollectionName);
+}
+var redisUrl2 = process.env.WORKER_UPSTASH_REDIS_REST_URL || process.env.UPSTASH_REDIS_REST_URL || process.env.UPSTASH_REDIS_URL;
+var redisToken2 = process.env.WORKER_UPSTASH_REDIS_REST_TOKEN || process.env.UPSTASH_REDIS_REST_TOKEN || process.env.UPSTASH_REDIS_TOKEN;
+var queueKeyPrefix = process.env.WORKER_UPSTASH_REDIS_QUEUE_PREFIX || process.env.UPSTASH_REDIS_QUEUE_PREFIX || "worker:queue-jobs:";
+var defaultTtlSeconds2 = 60 * 60 * 24 * 7;
+var queueJobTtlSeconds = typeof process.env.WORKER_QUEUE_JOBS_TTL_SECONDS === "string" ? parseInt(process.env.WORKER_QUEUE_JOBS_TTL_SECONDS, 10) || defaultTtlSeconds2 : typeof process.env.WORKER_JOBS_TTL_SECONDS === "string" ? parseInt(process.env.WORKER_JOBS_TTL_SECONDS, 10) || defaultTtlSeconds2 : defaultTtlSeconds2;
+var redisClient2 = null;
+function getRedis2() {
+  if (!redisUrl2 || !redisToken2) {
+    throw new Error(
+      "Upstash Redis configuration missing for queue job store. Set WORKER_UPSTASH_REDIS_REST_URL and WORKER_UPSTASH_REDIS_REST_TOKEN (or UPSTASH_REDIS_REST_URL/UPSTASH_REDIS_REST_TOKEN)."
+    );
+  }
+  if (!redisClient2) {
+    redisClient2 = new import_redis2.Redis({
+      url: redisUrl2,
+      token: redisToken2
+    });
+  }
+  return redisClient2;
+}
+function queueKey(id) {
+  return `${queueKeyPrefix}${id}`;
+}
+function stepsFromHash(val) {
+  if (Array.isArray(val)) return val;
+  if (typeof val === "string") {
+    try {
+      const parsed = JSON.parse(val);
+      return Array.isArray(parsed) ? parsed : [];
+    } catch {
+      return [];
+    }
+  }
+  return [];
+}
+function metadataFromHash(val) {
+  if (val && typeof val === "object" && !Array.isArray(val)) return val;
+  if (typeof val === "string") {
+    try {
+      const parsed = JSON.parse(val);
+      return parsed && typeof parsed === "object" ? parsed : {};
+    } catch {
+      return {};
+    }
+  }
+  return {};
+}
+async function loadQueueJobRedis(queueJobId) {
+  const redis = getRedis2();
+  const key = queueKey(queueJobId);
+  const data = await redis.hgetall(key);
+  if (!data || typeof data !== "object" || Object.keys(data).length === 0) return null;
+  const d = data;
+  const record = {
+    id: d.id === void 0 ? queueJobId : String(d.id),
+    queueId: String(d.queueId ?? ""),
+    status: String(d.status ?? "running"),
+    steps: stepsFromHash(d.steps),
+    metadata: metadataFromHash(d.metadata),
+    createdAt: String(d.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()),
+    updatedAt: String(d.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString()),
+    completedAt: d.completedAt != null ? String(d.completedAt) : void 0
+  };
+  return record;
+}
+async function saveQueueJobRedis(record) {
+  const redis = getRedis2();
+  const key = queueKey(record.id);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const toSet = {
+    id: record.id,
+    queueId: record.queueId,
+    status: record.status,
+    steps: JSON.stringify(record.steps || []),
+    metadata: JSON.stringify(record.metadata || {}),
+    createdAt: record.createdAt || now,
+    updatedAt: record.updatedAt || now
+  };
+  if (record.completedAt) {
+    toSet.completedAt = record.completedAt;
+  }
+  await redis.hset(key, toSet);
+  if (queueJobTtlSeconds > 0) {
+    await redis.expire(key, queueJobTtlSeconds);
+  }
+}
+function getStoreType() {
+  const t = (process.env.WORKER_DATABASE_TYPE || "upstash-redis").toLowerCase();
+  return t === "mongodb" ? "mongodb" : "upstash-redis";
+}
+function preferMongo() {
+  return getStoreType() === "mongodb" && Boolean(mongoUri?.trim());
+}
+function preferRedis() {
+  return getStoreType() !== "mongodb" && Boolean((redisUrl2 || "").trim() && (redisToken2 || "").trim());
+}
+async function upsertInitialQueueJob(options) {
+  const { queueJobId, queueId, firstWorkerId, firstWorkerJobId, metadata } = options;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  if (preferMongo()) {
+    const coll = await getMongoQueueCollection();
+    const existing = await coll.findOne({ _id: queueJobId });
+    if (existing) {
+      const steps = existing.steps ?? [];
+      if (steps.length === 0) {
+        steps.push({
+          workerId: firstWorkerId,
+          workerJobId: firstWorkerJobId,
+          status: "queued"
+        });
+      }
+      await coll.updateOne(
+        { _id: queueJobId },
+        {
+          $set: {
+            steps,
+            updatedAt: now
+          }
+        }
+      );
+    } else {
+      const doc = {
+        _id: queueJobId,
+        id: queueJobId,
+        queueId,
+        status: "running",
+        steps: [
+          {
+            workerId: firstWorkerId,
+            workerJobId: firstWorkerJobId,
+            status: "queued"
+          }
+        ],
+        metadata: metadata ?? {},
+        createdAt: now,
+        updatedAt: now
+      };
+      await coll.updateOne(
+        { _id: queueJobId },
+        { $set: doc },
+        { upsert: true }
+      );
+    }
+    return;
+  }
+  if (preferRedis()) {
+    const existing = await loadQueueJobRedis(queueJobId);
+    if (existing) {
+      if (!existing.steps || existing.steps.length === 0) {
+        existing.steps = [
+          {
+            workerId: firstWorkerId,
+            workerJobId: firstWorkerJobId,
+            status: "queued"
+          }
+        ];
+      }
+      existing.updatedAt = now;
+      await saveQueueJobRedis(existing);
+    } else {
+      const record = {
+        id: queueJobId,
+        queueId,
+        status: "running",
+        steps: [
+          {
+            workerId: firstWorkerId,
+            workerJobId: firstWorkerJobId,
+            status: "queued"
+          }
+        ],
+        metadata: metadata ?? {},
+        createdAt: now,
+        updatedAt: now
+      };
+      await saveQueueJobRedis(record);
+    }
+  }
+}
+async function updateQueueJobStepInStore(options) {
+  const { queueJobId, stepIndex, status, input, output, error } = options;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  if (preferMongo()) {
+    const coll = await getMongoQueueCollection();
+    const existing = await coll.findOne({ _id: queueJobId });
+    if (!existing) return;
+    const step = existing.steps[stepIndex];
+    if (!step) return;
+    const mergedStep = {
+      ...step,
+      status,
+      ...input !== void 0 && { input },
+      ...output !== void 0 && { output },
+      ...error !== void 0 && { error },
+      startedAt: step.startedAt ?? (status === "running" ? now : step.startedAt),
+      completedAt: step.completedAt ?? (status === "completed" || status === "failed" ? now : step.completedAt)
+    };
+    const setDoc = {
+      steps: existing.steps,
+      updatedAt: now
+    };
+    setDoc.steps[stepIndex] = mergedStep;
+    if (status === "failed") {
+      setDoc.status = "failed";
+      if (!existing.completedAt) setDoc.completedAt = now;
+    } else if (status === "completed" && stepIndex === existing.steps.length - 1) {
+      setDoc.status = "completed";
+      if (!existing.completedAt) setDoc.completedAt = now;
+    }
+    await coll.updateOne(
+      { _id: queueJobId },
+      {
+        $set: setDoc
+      }
+    );
+    return;
+  }
+  if (preferRedis()) {
+    const existing = await loadQueueJobRedis(queueJobId);
+    if (!existing) {
+      return;
+    }
+    const steps = existing.steps || [];
+    const step = steps[stepIndex];
+    if (!step) {
+      return;
+    }
+    step.status = status;
+    if (input !== void 0) step.input = input;
+    if (output !== void 0) step.output = output;
+    if (error !== void 0) step.error = error;
+    if (status === "running") {
+      step.startedAt = step.startedAt ?? now;
+    }
+    if (status === "completed" || status === "failed") {
+      step.completedAt = step.completedAt ?? now;
+    }
+    existing.steps = steps;
+    existing.updatedAt = now;
+    if (status === "failed") {
+      existing.status = "failed";
+      existing.completedAt = existing.completedAt ?? now;
+    } else if (status === "completed" && stepIndex === steps.length - 1) {
+      existing.status = "completed";
+      existing.completedAt = existing.completedAt ?? now;
+    }
+    await saveQueueJobRedis(existing);
+  }
+}
+async function appendQueueJobStepInStore(options) {
+  const { queueJobId, workerId, workerJobId } = options;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  if (preferMongo()) {
+    const coll = await getMongoQueueCollection();
+    await coll.updateOne(
+      { _id: queueJobId },
+      {
+        $push: {
+          steps: {
+            workerId,
+            workerJobId,
+            status: "queued"
+          }
+        },
+        $set: { updatedAt: now }
+      }
+    );
+    return;
+  }
+  if (preferRedis()) {
+    const existing = await loadQueueJobRedis(queueJobId);
+    if (!existing) return;
+    const steps = existing.steps || [];
+    steps.push({
+      workerId,
+      workerJobId,
+      status: "queued"
+    });
+    existing.steps = steps;
+    existing.updatedAt = now;
+    await saveQueueJobRedis(existing);
+  }
+}
+
 // src/handler.ts
+var SQS_MAX_DELAY_SECONDS = 900;
+function createWorkerLogger(jobId, workerId) {
+  const prefix = (level) => `[${level}] [${workerId}] [${jobId}]`;
+  return {
+    info(msg, data) {
+      console.log(prefix("INFO"), msg, data !== void 0 ? JSON.stringify(data) : "");
+    },
+    warn(msg, data) {
+      console.warn(prefix("WARN"), msg, data !== void 0 ? JSON.stringify(data) : "");
+    },
+    error(msg, data) {
+      console.error(prefix("ERROR"), msg, data !== void 0 ? JSON.stringify(data) : "");
+    },
+    debug(msg, data) {
+      if (process.env.DEBUG || process.env.WORKER_DEBUG) {
+        console.debug(prefix("DEBUG"), msg, data !== void 0 ? JSON.stringify(data) : "");
+      }
+    }
+  };
+}
+var WORKER_QUEUE_KEY = "__workerQueue";
+async function notifyQueueJobStep(queueJobId, action, params) {
+  try {
+    if (action === "append") {
+      if (!params.workerId || !params.workerJobId) return;
+      await appendQueueJobStepInStore({
+        queueJobId,
+        workerId: params.workerId,
+        workerJobId: params.workerJobId
+      });
+      if (process.env.DEBUG_WORKER_QUEUES === "1") {
+        console.log("[Worker] Queue job step appended", {
+          queueJobId,
+          workerId: params.workerId,
+          workerJobId: params.workerJobId
+        });
+      }
+      return;
+    }
+    if (params.stepIndex === void 0) return;
+    const status = action === "start" ? "running" : action === "complete" ? "completed" : action === "fail" ? "failed" : void 0;
+    if (!status) return;
+    await updateQueueJobStepInStore({
+      queueJobId,
+      stepIndex: params.stepIndex,
+      workerId: params.workerId || "",
+      workerJobId: params.workerJobId,
+      status,
+      input: params.input,
+      output: params.output,
+      error: params.error
+    });
+    console.log("[Worker] Queue job step updated", {
+      queueId: params.queueId ?? queueJobId,
+      queueJobId,
+      stepIndex: params.stepIndex,
+      workerId: params.workerId,
+      status
+    });
+  } catch (err) {
+    console.warn("[Worker] Queue job update error:", {
+      queueJobId,
+      action,
+      error: err?.message ?? String(err)
+    });
+  }
+}
+function wrapHandlerForQueue(handler, queueRuntime) {
+  return async (params) => {
+    const queueContext = params.input?.[WORKER_QUEUE_KEY];
+    const output = await handler(params);
+    if (!queueContext || typeof queueContext !== "object" || !queueContext.id) {
+      return output;
+    }
+    const { id: queueId, stepIndex, initialInput, queueJobId } = queueContext;
+    const jobId = params.ctx?.jobId;
+    const workerId = params.ctx?.workerId ?? "";
+    const next = queueRuntime.getNextStep(queueId, stepIndex);
+    const childJobId = next ? `job-${Date.now()}-${Math.random().toString(36).slice(2, 11)}` : void 0;
+    if (next && queueJobId) {
+      await notifyQueueJobStep(queueJobId, "append", {
+        workerJobId: childJobId,
+        workerId: next.workerId
+      });
+    }
+    if (queueJobId && typeof stepIndex === "number") {
+      await notifyQueueJobStep(queueJobId, "complete", {
+        queueId,
+        stepIndex,
+        workerJobId: jobId,
+        workerId,
+        output
+      });
+    }
+    if (!next) {
+      return output;
+    }
+    let nextInput = output;
+    if (next.mapInputFromPrev && typeof queueRuntime.invokeMapInput === "function") {
+      let previousOutputs = [];
+      if (queueJobId && typeof queueRuntime.getQueueJob === "function") {
+        try {
+          const job = await queueRuntime.getQueueJob(queueJobId);
+          if (job?.steps) {
+            const fromStore = job.steps.slice(0, stepIndex).map((s, i) => ({ stepIndex: i, workerId: s.workerId, output: s.output }));
+            previousOutputs = fromStore.concat([
+              { stepIndex, workerId: params.ctx?.workerId ?? "", output }
+            ]);
+          }
+        } catch (e) {
+          if (process.env.AI_WORKER_QUEUES_DEBUG === "1") {
+            console.warn("[Worker] getQueueJob failed, mapping without previousOutputs:", e?.message ?? e);
+          }
+        }
+      }
+      nextInput = await queueRuntime.invokeMapInput(
+        queueId,
+        stepIndex + 1,
+        initialInput,
+        previousOutputs
+      );
+    }
+    const nextInputWithQueue = {
+      ...nextInput !== null && typeof nextInput === "object" ? nextInput : { value: nextInput },
+      [WORKER_QUEUE_KEY]: {
+        id: queueId,
+        stepIndex: stepIndex + 1,
+        initialInput,
+        queueJobId
+      }
+    };
+    const debug = process.env.AI_WORKER_QUEUES_DEBUG === "1";
+    if (debug) {
+      console.log("[Worker] Queue chain dispatching next:", {
+        queueId,
+        fromStep: stepIndex,
+        nextWorkerId: next.workerId,
+        delaySeconds: next.delaySeconds
+      });
+    }
+    await params.ctx.dispatchWorker(next.workerId, nextInputWithQueue, {
+      await: false,
+      delaySeconds: next.delaySeconds,
+      jobId: childJobId
+    });
+    return output;
+  };
+}
+var DEFAULT_POLL_INTERVAL_MS = 2e3;
+var DEFAULT_POLL_TIMEOUT_MS = 15 * 60 * 1e3;
+function sanitizeWorkerIdForEnv(workerId) {
+  return workerId.replace(/-/g, "_").toUpperCase();
+}
+function getQueueUrlForWorker(calleeWorkerId) {
+  const key = `WORKER_QUEUE_URL_${sanitizeWorkerIdForEnv(calleeWorkerId)}`;
+  return process.env[key]?.trim() || void 0;
+}
+function createDispatchWorker(parentJobId, parentWorkerId, parentContext, jobStore) {
+  return async (calleeWorkerId, input, options) => {
+    const childJobId = options?.jobId || `job-${Date.now()}-${Math.random().toString(36).slice(2, 11)}`;
+    const metadata = options?.metadata ?? {};
+    const serializedContext = {};
+    if (parentContext.requestId) serializedContext.requestId = parentContext.requestId;
+    const messageBody = {
+      workerId: calleeWorkerId,
+      jobId: childJobId,
+      input: input ?? {},
+      context: serializedContext,
+      webhookUrl: options?.webhookUrl,
+      metadata,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const queueUrl = getQueueUrlForWorker(calleeWorkerId);
+    if (queueUrl) {
+      const region = process.env.AWS_REGION || process.env.AWS_DEFAULT_REGION || "us-east-1";
+      const sqs = new import_client_sqs.SQSClient({ region });
+      const delaySeconds = options?.await !== true && options?.delaySeconds != null ? Math.min(SQS_MAX_DELAY_SECONDS, Math.max(0, Math.floor(options.delaySeconds))) : void 0;
+      const sendResult = await sqs.send(
+        new import_client_sqs.SendMessageCommand({
+          QueueUrl: queueUrl,
+          MessageBody: JSON.stringify(messageBody),
+          ...delaySeconds !== void 0 && delaySeconds > 0 ? { DelaySeconds: delaySeconds } : {}
+        })
+      );
+      const messageId = sendResult.MessageId ?? void 0;
+      if (jobStore?.appendInternalJob) {
+        await jobStore.appendInternalJob({ jobId: childJobId, workerId: calleeWorkerId });
+      }
+      if (options?.await && jobStore?.getJob) {
+        const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+        const pollTimeoutMs = options.pollTimeoutMs ?? DEFAULT_POLL_TIMEOUT_MS;
+        const deadline = Date.now() + pollTimeoutMs;
+        while (Date.now() < deadline) {
+          const child = await jobStore.getJob(childJobId);
+          if (!child) {
+            await new Promise((r) => setTimeout(r, pollIntervalMs));
+            continue;
+          }
+          if (child.status === "completed") {
+            return { jobId: childJobId, messageId, output: child.output };
+          }
+          if (child.status === "failed") {
+            const err = child.error;
+            throw new Error(
+              err?.message ?? `Child worker ${calleeWorkerId} failed`
+            );
+          }
+          await new Promise((r) => setTimeout(r, pollIntervalMs));
+        }
+        throw new Error(
+          `Child worker ${calleeWorkerId} (${childJobId}) did not complete within ${pollTimeoutMs}ms`
+        );
+      }
+      return { jobId: childJobId, messageId };
+    }
+    throw new Error(
+      `WORKER_QUEUE_URL_${sanitizeWorkerIdForEnv(calleeWorkerId)} is not set. Configure queue URL for worker-to-worker dispatch, or run in local mode.`
+    );
+  };
+}
 async function sendWebhook(webhookUrl, payload) {
   try {
     const response = await fetch(webhookUrl, {
@@ -272,24 +1093,63 @@ function createLambdaHandler(handler, outputSchema) {
       try {
         messageBody = JSON.parse(record.body);
         const { workerId, jobId, input, context, webhookUrl, metadata = {} } = messageBody;
+        const raw = (process.env.WORKER_DATABASE_TYPE || "upstash-redis").toLowerCase();
+        const jobStoreType = raw === "mongodb" ? "mongodb" : "upstash-redis";
+        if (jobStoreType === "upstash-redis" && isRedisJobStoreConfigured()) {
+          const existing = await loadJob(jobId);
+          if (existing && (existing.status === "completed" || existing.status === "failed")) {
+            console.log("[Worker] Skipping already terminal job (idempotent):", {
+              jobId,
+              workerId,
+              status: existing.status
+            });
+            return;
+          }
+        } else if (jobStoreType === "mongodb" || isMongoJobStoreConfigured()) {
+          const existing = await getJobById(jobId);
+          if (existing && (existing.status === "completed" || existing.status === "failed")) {
+            console.log("[Worker] Skipping already terminal job (idempotent):", {
+              jobId,
+              workerId,
+              status: existing.status
+            });
+            return;
+          }
+        }
         let jobStore;
-        if (isMongoJobStoreConfigured()) {
+        if (jobStoreType === "upstash-redis" && isRedisJobStoreConfigured()) {
+          await upsertRedisJob(jobId, workerId, input, metadata);
+          jobStore = createRedisJobStore(workerId, jobId, input, metadata);
+        } else if (jobStoreType === "mongodb" || isMongoJobStoreConfigured()) {
           await upsertJob(jobId, workerId, input, metadata);
           jobStore = createMongoJobStore(workerId, jobId, input, metadata);
         }
-        const handlerContext = {
+        const baseContext = {
           jobId,
           workerId,
           requestId: context.requestId || lambdaContext.awsRequestId,
-          ...jobStore ? { jobStore } : {},
           ...context
         };
+        const handlerContext = {
+          ...baseContext,
+          ...jobStore ? { jobStore } : {},
+          logger: createWorkerLogger(jobId, workerId),
+          dispatchWorker: createDispatchWorker(
+            jobId,
+            workerId,
+            baseContext,
+            jobStore
+          )
+        };
         if (jobStore) {
           try {
             await jobStore.update({ status: "running" });
+            const queueCtxForLog = input?.__workerQueue ?? metadata?.__workerQueue;
             console.log("[Worker] Job status updated to running:", {
               jobId,
-              workerId
+              workerId,
+              ...queueCtxForLog?.id && { queueId: queueCtxForLog.id },
+              ...queueCtxForLog?.queueJobId && { queueJobId: queueCtxForLog.queueJobId }
             });
           } catch (error) {
             console.warn("[Worker] Failed to update status to running:", {
@@ -299,6 +1159,33 @@ function createLambdaHandler(handler, outputSchema) {
             });
           }
         }
+        const queueCtx = input?.__workerQueue ?? metadata?.__workerQueue;
+        if (queueCtx?.queueJobId && typeof queueCtx.stepIndex === "number") {
+          if (queueCtx.stepIndex === 0) {
+            try {
+              await upsertInitialQueueJob({
+                queueJobId: queueCtx.queueJobId,
+                queueId: queueCtx.id,
+                firstWorkerId: workerId,
+                firstWorkerJobId: jobId,
+                metadata
+              });
+            } catch (e) {
+              console.warn("[Worker] Failed to upsert initial queue job:", {
+                queueJobId: queueCtx.queueJobId,
+                queueId: queueCtx.id,
+                error: e?.message ?? String(e)
+              });
+            }
+          }
+          await notifyQueueJobStep(queueCtx.queueJobId, "start", {
+            queueId: queueCtx.id,
+            stepIndex: queueCtx.stepIndex,
+            workerJobId: jobId,
+            workerId,
+            input
+          });
+        }
         let output;
         try {
           output = await handler({
@@ -338,6 +1225,16 @@ function createLambdaHandler(handler, outputSchema) {
               });
             }
           }
+          const queueCtxFail = input?.__workerQueue ?? metadata?.__workerQueue;
+          if (queueCtxFail?.queueJobId && typeof queueCtxFail.stepIndex === "number") {
+            await notifyQueueJobStep(queueCtxFail.queueJobId, "fail", {
+              queueId: queueCtxFail.id,
+              stepIndex: queueCtxFail.stepIndex,
+              workerJobId: jobId,
+              workerId,
+              error: errorPayload.error
+            });
+          }
           if (webhookUrl) {
             await sendWebhook(webhookUrl, errorPayload);
           }
@@ -434,6 +1331,11 @@ function clearWorkersConfigCache() {
   cacheExpiry = 0;
 }
 
+// src/queue.ts
+function defineWorkerQueue(config) {
+  return config;
+}
+
 // src/index.ts
 function createWorker(config) {
   const { id, inputSchema, outputSchema, handler } = config;
@@ -550,6 +1452,42 @@ function createWorker(config) {
                   });
                   return null;
                 }
+              },
+              appendInternalJob: async (entry) => {
+                try {
+                  const nextJsPath = "@/app/api/workflows/stores/jobStore";
+                  const explicitPath2 = process.env.WORKER_JOB_STORE_MODULE_PATH;
+                  for (const importPath of [nextJsPath, explicitPath2].filter(Boolean)) {
+                    try {
+                      const module2 = await import(importPath);
+                      if (typeof module2?.appendInternalJob === "function") {
+                        await module2.appendInternalJob(localJobId, entry);
+                        return;
+                      }
+                    } catch {
+                    }
+                  }
+                } catch (error) {
+                  console.warn("[Worker] Failed to appendInternalJob (direct DB):", { localJobId, error: error?.message || String(error) });
+                }
+              },
+              getJob: async (otherJobId) => {
+                try {
+                  const nextJsPath = "@/app/api/workflows/stores/jobStore";
+                  const explicitPath2 = process.env.WORKER_JOB_STORE_MODULE_PATH;
+                  for (const importPath of [nextJsPath, explicitPath2].filter(Boolean)) {
+                    try {
+                      const module2 = await import(importPath);
+                      if (typeof module2?.getJob === "function") {
+                        return await module2.getJob(otherJobId);
+                      }
+                    } catch {
+                    }
+                  }
+                } catch (error) {
+                  console.warn("[Worker] Failed to getJob (direct DB):", { otherJobId, error: error?.message || String(error) });
+                }
+                return null;
               }
             };
           }
@@ -625,6 +1563,101 @@ function createWorker(config) {
           };
         };
         const jobStore = createLocalJobStore(directJobStore, jobStoreUrl);
+        const DEFAULT_POLL_INTERVAL_MS2 = 2e3;
+        const DEFAULT_POLL_TIMEOUT_MS2 = 15 * 60 * 1e3;
+        const createLocalDispatchWorker = (parentJobId, parentWorkerId, parentContext, store) => {
+          return async (calleeWorkerId, input2, options2) => {
+            const childJobId = options2?.jobId || `job-${Date.now()}-${Math.random().toString(36).slice(2, 11)}`;
+            const metadata = options2?.metadata ?? {};
+            const serializedContext = {};
+            if (parentContext.requestId) serializedContext.requestId = parentContext.requestId;
+            const messageBody = {
+              workerId: calleeWorkerId,
+              jobId: childJobId,
+              input: input2 ?? {},
+              context: serializedContext,
+              webhookUrl: options2?.webhookUrl,
+              metadata,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            };
+            let triggerUrl;
+            try {
+              triggerUrl = getWorkersTriggerUrl();
+            } catch (e) {
+              throw new Error(
+                `Local dispatchWorker requires WORKER_BASE_URL (or similar) for worker "${calleeWorkerId}": ${e?.message ?? e}`
+              );
+            }
+            const headers = { "Content-Type": "application/json" };
+            const triggerKey = process.env.WORKERS_TRIGGER_API_KEY;
+            if (triggerKey) headers["x-workers-trigger-key"] = triggerKey;
+            if (options2?.await !== true && options2?.delaySeconds != null && options2.delaySeconds > 0) {
+              const sec = Math.min(SQS_MAX_DELAY_SECONDS, Math.max(0, Math.floor(options2.delaySeconds)));
+              const storeRef = store;
+              setTimeout(() => {
+                fetch(triggerUrl, {
+                  method: "POST",
+                  headers,
+                  body: JSON.stringify({ workerId: calleeWorkerId, body: messageBody })
+                }).then(async (response2) => {
+                  if (!response2.ok) {
+                    const text = await response2.text().catch(() => "");
+                    console.error(
+                      `[Worker] Delayed trigger failed for "${calleeWorkerId}": ${response2.status} ${response2.statusText}${text ? ` - ${text}` : ""}`
+                    );
+                    return;
+                  }
+                  if (storeRef?.appendInternalJob) {
+                    await storeRef.appendInternalJob({ jobId: childJobId, workerId: calleeWorkerId });
+                  }
+                }).catch((err) => {
+                  console.error("[Worker] Delayed trigger error:", { calleeWorkerId, jobId: childJobId, error: err?.message ?? err });
+                });
+              }, sec * 1e3);
+              return { jobId: childJobId, messageId: void 0 };
+            }
+            const response = await fetch(triggerUrl, {
+              method: "POST",
+              headers,
+              body: JSON.stringify({ workerId: calleeWorkerId, body: messageBody })
+            });
+            if (!response.ok) {
+              const text = await response.text().catch(() => "");
+              throw new Error(
+                `Failed to trigger worker "${calleeWorkerId}": ${response.status} ${response.statusText}${text ? ` - ${text}` : ""}`
+              );
+            }
+            const data = await response.json().catch(() => ({}));
+            const messageId = data?.messageId ? String(data.messageId) : `trigger-${childJobId}`;
+            if (store?.appendInternalJob) {
+              await store.appendInternalJob({ jobId: childJobId, workerId: calleeWorkerId });
+            }
+            if (options2?.await && store?.getJob) {
+              const pollIntervalMs = options2.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS2;
+              const pollTimeoutMs = options2.pollTimeoutMs ?? DEFAULT_POLL_TIMEOUT_MS2;
+              const deadline = Date.now() + pollTimeoutMs;
+              while (Date.now() < deadline) {
+                const child = await store.getJob(childJobId);
+                if (!child) {
+                  await new Promise((r) => setTimeout(r, pollIntervalMs));
+                  continue;
+                }
+                if (child.status === "completed") {
+                  return { jobId: childJobId, messageId, output: child.output };
+                }
+                if (child.status === "failed") {
+                  const err = child.error;
+                  throw new Error(err?.message ?? `Child worker ${calleeWorkerId} failed`);
+                }
+                await new Promise((r) => setTimeout(r, pollIntervalMs));
+              }
+              throw new Error(
+                `Child worker ${calleeWorkerId} (${childJobId}) did not complete within ${pollTimeoutMs}ms`
+              );
+            }
+            return { jobId: childJobId, messageId };
+          };
+        };
         if (directJobStore?.setJob) {
           try {
             await directJobStore.setJob(localJobId, {
@@ -642,10 +1675,17 @@ function createWorker(config) {
             });
           }
         }
+        const baseContext = { jobId: localJobId, workerId: id };
         const handlerContext = {
-          jobId: localJobId,
-          workerId: id,
-          ...jobStore ? { jobStore } : {}
+          ...baseContext,
+          ...jobStore ? { jobStore } : {},
+          logger: createWorkerLogger(localJobId, id),
+          dispatchWorker: createLocalDispatchWorker(
+            localJobId,
+            id,
+            baseContext,
+            jobStore
+          )
         };
         try {
           if (jobStore) {
@@ -722,13 +1762,21 @@ function createLambdaEntrypoint(agent) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  SQS_MAX_DELAY_SECONDS,
   clearWorkersConfigCache,
   createLambdaEntrypoint,
   createLambdaHandler,
   createWorker,
+  createWorkerLogger,
+  defineWorkerQueue,
   dispatch,
   dispatchLocal,
+  dispatchQueue,
+  dispatchWorker,
+  getQueueStartUrl,
   getWorkersConfig,
-  resolveQueueUrl
+  getWorkersTriggerUrl,
+  resolveQueueUrl,
+  wrapHandlerForQueue
 });
 //# sourceMappingURL=index.js.map