@microfox/ai-worker 1.0.1 → 1.0.2

package/dist/chunk-4WU5ZCHS.mjs

@@ -0,0 +1,1053 @@
+// src/handler.ts
+import { SQSClient, SendMessageCommand } from "@aws-sdk/client-sqs";
+
+// src/mongoJobStore.ts
+import { MongoClient } from "mongodb";
+var uri = process.env.MONGODB_WORKER_URI || process.env.DATABASE_MONGODB_URI || process.env.MONGODB_URI;
+var dbName = process.env.MONGODB_WORKER_DB || process.env.MONGODB_DB || "worker";
+var collectionName = process.env.MONGODB_WORKER_JOBS_COLLECTION || "worker_jobs";
+var clientPromise = null;
+function getClient() {
+  if (!uri) {
+    throw new Error(
+      "MongoDB URI required for job store. Set DATABASE_MONGODB_URI or MONGODB_URI."
+    );
+  }
+  if (!clientPromise) {
+    clientPromise = new MongoClient(uri, {
+      maxPoolSize: 10,
+      minPoolSize: 0,
+      serverSelectionTimeoutMS: 1e4
+    }).connect();
+  }
+  return clientPromise;
+}
+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) => {
+      try {
+        const coll = await getCollection();
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const existing = await coll.findOne({ _id: jobId });
+        let metadataUpdate = { ...existing?.metadata ?? {} };
+        if (update.metadata) {
+          Object.assign(metadataUpdate, update.metadata);
+        }
+        if (update.progress !== void 0 || update.progressMessage !== void 0) {
+          metadataUpdate.progress = update.progress;
+          metadataUpdate.progressMessage = update.progressMessage;
+        }
+        const set = {
+          updatedAt: now,
+          metadata: metadataUpdate
+        };
+        if (update.status !== void 0) {
+          set.status = update.status;
+          if (["completed", "failed"].includes(update.status) && !existing?.completedAt) {
+            set.completedAt = now;
+          }
+        }
+        if (update.output !== void 0) set.output = update.output;
+        if (update.error !== void 0) set.error = update.error;
+        if (existing) {
+          await coll.updateOne({ _id: jobId }, { $set: set });
+        } else {
+          const doc = {
+            _id: jobId,
+            jobId,
+            workerId,
+            status: update.status ?? "queued",
+            input: input ?? {},
+            output: update.output,
+            error: update.error,
+            metadata: metadataUpdate,
+            createdAt: now,
+            updatedAt: now,
+            completedAt: set.completedAt
+          };
+          if (doc.status === "completed" || doc.status === "failed") {
+            doc.completedAt = doc.completedAt ?? now;
+          }
+          await coll.updateOne({ _id: jobId }, { $set: doc }, { upsert: true });
+        }
+      } catch (e) {
+        console.error("[Worker] MongoDB job store update failed:", {
+          jobId,
+          workerId,
+          error: e?.message ?? String(e)
+        });
+      }
+    },
+    get: async () => {
+      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 job store get failed:", {
+          jobId,
+          workerId,
+          error: e?.message ?? String(e)
+        });
+        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;
+      }
+    }
+  };
+}
+async function upsertJob(jobId, workerId, input, metadata) {
+  const coll = await getCollection();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  await coll.updateOne(
+    { _id: jobId },
+    {
+      $set: {
+        _id: jobId,
+        jobId,
+        workerId,
+        status: "queued",
+        input: input ?? {},
+        metadata: metadata ?? {},
+        createdAt: now,
+        updatedAt: now
+      }
+    },
+    { upsert: true }
+  );
+}
+function isMongoJobStoreConfigured() {
+  return Boolean(uri?.trim());
+}
+
+// src/redisJobStore.ts
+import { Redis } from "@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 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
+import { Redis as UpstashRedis } from "@upstash/redis";
+import { MongoClient as MongoClient2 } from "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 MongoClient2(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 UpstashRedis({
+      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;
+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
+    });
+    if (process.env.DEBUG_WORKER_QUEUES === "1") {
+      console.log("[Worker] Queue job step updated", {
+        queueJobId,
+        action,
+        stepIndex: params.stepIndex,
+        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 next = queueRuntime.getNextStep(queueId, stepIndex);
+    if (!next) {
+      return output;
+    }
+    const childJobId = `job-${Date.now()}-${Math.random().toString(36).slice(2, 11)}`;
+    if (queueJobId) {
+      await notifyQueueJobStep(queueJobId, "append", {
+        workerJobId: childJobId,
+        workerId: next.workerId
+      });
+    }
+    let nextInput = output;
+    if (next.mapInputFromPrev && typeof queueRuntime.invokeMapInput === "function") {
+      nextInput = await queueRuntime.invokeMapInput(queueId, stepIndex + 1, output, initialInput);
+    }
+    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 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 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, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "User-Agent": "ai-router-worker/1.0"
+      },
+      body: JSON.stringify(payload)
+    });
+    if (!response.ok) {
+      const errorText = await response.text().catch(() => "");
+      console.error("[Worker] Webhook callback failed:", {
+        url: webhookUrl,
+        status: response.status,
+        statusText: response.statusText,
+        errorText
+      });
+    } else {
+      console.log("[Worker] Webhook callback successful:", {
+        url: webhookUrl,
+        status: response.status
+      });
+    }
+  } catch (error) {
+    console.error("[Worker] Webhook callback error:", {
+      url: webhookUrl,
+      error: error?.message || String(error),
+      stack: error?.stack
+    });
+  }
+}
+function createLambdaHandler(handler, outputSchema) {
+  return async (event, lambdaContext) => {
+    const promises = event.Records.map(async (record) => {
+      let messageBody = null;
+      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 (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 baseContext = {
+          jobId,
+          workerId,
+          requestId: context.requestId || lambdaContext.awsRequestId,
+          ...context
+        };
+        const handlerContext = {
+          ...baseContext,
+          ...jobStore ? { jobStore } : {},
+          dispatchWorker: createDispatchWorker(
+            jobId,
+            workerId,
+            baseContext,
+            jobStore
+          )
+        };
+        if (jobStore) {
+          try {
+            await jobStore.update({ status: "running" });
+            console.log("[Worker] Job status updated to running:", {
+              jobId,
+              workerId
+            });
+          } catch (error) {
+            console.warn("[Worker] Failed to update status to running:", {
+              jobId,
+              workerId,
+              error: error?.message || String(error)
+            });
+          }
+        }
+        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", {
+            stepIndex: queueCtx.stepIndex,
+            workerJobId: jobId,
+            workerId,
+            input
+          });
+        }
+        let output;
+        try {
+          output = await handler({
+            input,
+            ctx: handlerContext
+          });
+          if (outputSchema) {
+            output = outputSchema.parse(output);
+          }
+        } catch (error) {
+          const errorPayload = {
+            jobId,
+            workerId,
+            status: "error",
+            error: {
+              message: error.message || "Unknown error",
+              stack: error.stack,
+              name: error.name || "Error"
+            },
+            metadata
+          };
+          if (jobStore) {
+            try {
+              await jobStore.update({
+                status: "failed",
+                error: errorPayload.error
+              });
+              console.log("[Worker] Job status updated to failed:", {
+                jobId,
+                workerId
+              });
+            } catch (updateError) {
+              console.warn("[Worker] Failed to update job store on error:", {
+                jobId,
+                workerId,
+                error: updateError?.message || String(updateError)
+              });
+            }
+          }
+          const queueCtxFail = input?.__workerQueue ?? metadata?.__workerQueue;
+          if (queueCtxFail?.queueJobId && typeof queueCtxFail.stepIndex === "number") {
+            await notifyQueueJobStep(queueCtxFail.queueJobId, "fail", {
+              stepIndex: queueCtxFail.stepIndex,
+              workerJobId: jobId,
+              workerId,
+              error: errorPayload.error
+            });
+          }
+          if (webhookUrl) {
+            await sendWebhook(webhookUrl, errorPayload);
+          }
+          throw error;
+        }
+        if (jobStore) {
+          try {
+            await jobStore.update({
+              status: "completed",
+              output
+            });
+            console.log("[Worker] Job status updated to completed:", {
+              jobId,
+              workerId
+            });
+          } catch (updateError) {
+            console.warn("[Worker] Failed to update job store on success:", {
+              jobId,
+              workerId,
+              error: updateError?.message || String(updateError)
+            });
+          }
+        }
+        const queueCtxSuccess = input?.__workerQueue ?? metadata?.__workerQueue;
+        if (queueCtxSuccess?.queueJobId && typeof queueCtxSuccess.stepIndex === "number") {
+          await notifyQueueJobStep(queueCtxSuccess.queueJobId, "complete", {
+            stepIndex: queueCtxSuccess.stepIndex,
+            workerJobId: jobId,
+            workerId,
+            output
+          });
+        }
+        console.log("[Worker] Job completed:", {
+          jobId,
+          workerId,
+          output
+        });
+        const successPayload = {
+          jobId,
+          workerId,
+          status: "success",
+          output,
+          metadata
+        };
+        if (webhookUrl) {
+          await sendWebhook(webhookUrl, successPayload);
+        }
+      } catch (error) {
+        console.error("[Worker] Error processing SQS record:", {
+          jobId: messageBody?.jobId ?? "(parse failed)",
+          workerId: messageBody?.workerId ?? "(parse failed)",
+          error: error?.message || String(error),
+          stack: error?.stack
+        });
+        throw error;
+      }
+    });
+    await Promise.all(promises);
+  };
+}
+
+export {
+  SQS_MAX_DELAY_SECONDS,
+  wrapHandlerForQueue,
+  createLambdaHandler
+};
+//# sourceMappingURL=chunk-4WU5ZCHS.mjs.map