@microfox/ai-worker 1.0.1 → 1.0.3

package/dist/handler.js

@@ -20,9 +20,13 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/handler.ts
 var handler_exports = {};
 __export(handler_exports, {
-  createLambdaHandler: () => createLambdaHandler
+  SQS_MAX_DELAY_SECONDS: () => SQS_MAX_DELAY_SECONDS,
+  createLambdaHandler: () => createLambdaHandler,
+  createWorkerLogger: () => createWorkerLogger,
+  wrapHandlerForQueue: () => wrapHandlerForQueue
 });
 module.exports = __toCommonJS(handler_exports);
+var import_client_sqs = require("@aws-sdk/client-sqs");
 
 // src/mongoJobStore.ts
 var import_mongodb = require("mongodb");
@@ -49,6 +53,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) => {
@@ -120,6 +139,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;
+      }
     }
   };
 }
@@ -147,7 +196,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, {
@@ -187,24 +925,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:", {
@@ -214,6 +991,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({
@@ -253,6 +1057,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);
           }
@@ -306,6 +1120,9 @@ function createLambdaHandler(handler, outputSchema) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  createLambdaHandler
+  SQS_MAX_DELAY_SECONDS,
+  createLambdaHandler,
+  createWorkerLogger,
+  wrapHandlerForQueue
 });
 //# sourceMappingURL=handler.js.map