@radaros/queue 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,89 @@
+import { RunOutput, Agent, Workflow, EventBus } from '@radaros/core';
+
+type AgentJobPayload = {
+    type: "agent";
+    agentName: string;
+    input: string;
+    sessionId?: string;
+    userId?: string;
+};
+type WorkflowJobPayload = {
+    type: "workflow";
+    workflowName: string;
+    initialState?: Record<string, unknown>;
+    sessionId?: string;
+};
+type JobPayload = AgentJobPayload | WorkflowJobPayload;
+type JobStatus = {
+    jobId: string;
+    state: "waiting" | "active" | "completed" | "failed" | "delayed";
+    progress?: number;
+    result?: RunOutput;
+    error?: string;
+    createdAt: Date;
+    processedAt?: Date;
+    finishedAt?: Date;
+};
+
+interface QueueConfig {
+    connection: {
+        host: string;
+        port: number;
+    };
+    queueName?: string;
+    defaultJobOptions?: Record<string, unknown>;
+}
+declare class AgentQueue {
+    private queue;
+    private queueEvents;
+    private queueName;
+    constructor(config: QueueConfig);
+    enqueueAgentRun(opts: {
+        agentName: string;
+        input: string;
+        sessionId?: string;
+        userId?: string;
+        priority?: number;
+        delay?: number;
+        attempts?: number;
+        repeat?: {
+            pattern: string;
+        };
+    }): Promise<{
+        jobId: string;
+    }>;
+    enqueueWorkflow(opts: {
+        workflowName: string;
+        initialState?: Record<string, unknown>;
+        sessionId?: string;
+        priority?: number;
+    }): Promise<{
+        jobId: string;
+    }>;
+    getJobStatus(jobId: string): Promise<JobStatus>;
+    cancelJob(jobId: string): Promise<void>;
+    onCompleted(handler: (jobId: string, result: RunOutput) => void): void;
+    onFailed(handler: (jobId: string, error: Error) => void): void;
+    close(): Promise<void>;
+}
+
+interface WorkerConfig {
+    connection: {
+        host: string;
+        port: number;
+    };
+    queueName?: string;
+    concurrency?: number;
+    agentRegistry: Record<string, Agent>;
+    workflowRegistry?: Record<string, Workflow<any>>;
+}
+declare class AgentWorker {
+    private worker;
+    constructor(config: WorkerConfig);
+    start(): void;
+    stop(): Promise<void>;
+}
+
+declare function bridgeEventBusToJob(eventBus: EventBus, job: any, runId: string): () => void;
+
+export { type AgentJobPayload, AgentQueue, AgentWorker, type JobPayload, type JobStatus, type QueueConfig, type WorkerConfig, type WorkflowJobPayload, bridgeEventBusToJob };

package/dist/index.js

@@ -0,0 +1,197 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/job-producer.ts
+var AgentQueue = class {
+  queue;
+  queueEvents;
+  queueName;
+  constructor(config) {
+    this.queueName = config.queueName ?? "radaros:jobs";
+    try {
+      const { Queue, QueueEvents } = __require("bullmq");
+      this.queue = new Queue(this.queueName, {
+        connection: config.connection,
+        defaultJobOptions: config.defaultJobOptions
+      });
+      this.queueEvents = new QueueEvents(this.queueName, {
+        connection: config.connection
+      });
+    } catch {
+      throw new Error(
+        "bullmq and ioredis are required for AgentQueue. Install them: npm install bullmq ioredis"
+      );
+    }
+  }
+  async enqueueAgentRun(opts) {
+    const payload = {
+      type: "agent",
+      agentName: opts.agentName,
+      input: opts.input,
+      sessionId: opts.sessionId,
+      userId: opts.userId
+    };
+    const jobOpts = {};
+    if (opts.priority !== void 0) jobOpts.priority = opts.priority;
+    if (opts.delay !== void 0) jobOpts.delay = opts.delay;
+    if (opts.attempts !== void 0) jobOpts.attempts = opts.attempts;
+    if (opts.repeat) jobOpts.repeat = opts.repeat;
+    const job = await this.queue.add(
+      `agent:${opts.agentName}`,
+      payload,
+      jobOpts
+    );
+    return { jobId: job.id };
+  }
+  async enqueueWorkflow(opts) {
+    const payload = {
+      type: "workflow",
+      workflowName: opts.workflowName,
+      initialState: opts.initialState,
+      sessionId: opts.sessionId
+    };
+    const jobOpts = {};
+    if (opts.priority !== void 0) jobOpts.priority = opts.priority;
+    const job = await this.queue.add(
+      `workflow:${opts.workflowName}`,
+      payload,
+      jobOpts
+    );
+    return { jobId: job.id };
+  }
+  async getJobStatus(jobId) {
+    const job = await this.queue.getJob(jobId);
+    if (!job) {
+      throw new Error(`Job ${jobId} not found`);
+    }
+    const state = await job.getState();
+    return {
+      jobId: job.id,
+      state,
+      progress: typeof job.progress === "number" ? job.progress : void 0,
+      result: job.returnvalue,
+      error: job.failedReason,
+      createdAt: new Date(job.timestamp),
+      processedAt: job.processedOn ? new Date(job.processedOn) : void 0,
+      finishedAt: job.finishedOn ? new Date(job.finishedOn) : void 0
+    };
+  }
+  async cancelJob(jobId) {
+    const job = await this.queue.getJob(jobId);
+    if (job) {
+      await job.remove();
+    }
+  }
+  onCompleted(handler) {
+    this.queueEvents.on("completed", ({ jobId, returnvalue }) => {
+      handler(jobId, returnvalue);
+    });
+  }
+  onFailed(handler) {
+    this.queueEvents.on("failed", ({ jobId, failedReason }) => {
+      handler(jobId, new Error(failedReason));
+    });
+  }
+  async close() {
+    await this.queue.close();
+    await this.queueEvents.close();
+  }
+};
+
+// src/job-worker.ts
+var AgentWorker = class {
+  worker;
+  constructor(config) {
+    const queueName = config.queueName ?? "radaros:jobs";
+    const concurrency = config.concurrency ?? 5;
+    try {
+      const { Worker } = __require("bullmq");
+      this.worker = new Worker(
+        queueName,
+        async (job) => {
+          const payload = job.data;
+          if (payload.type === "agent") {
+            const agent = config.agentRegistry[payload.agentName];
+            if (!agent) {
+              throw new Error(
+                `Agent "${payload.agentName}" not found in registry`
+              );
+            }
+            const onChunk = (evt) => {
+              job.updateProgress(
+                typeof job.progress === "number" ? job.progress + 1 : 1
+              );
+            };
+            agent.eventBus.on("run.stream.chunk", onChunk);
+            try {
+              const result = await agent.run(payload.input, {
+                sessionId: payload.sessionId,
+                userId: payload.userId
+              });
+              return result;
+            } finally {
+              agent.eventBus.off("run.stream.chunk", onChunk);
+            }
+          }
+          if (payload.type === "workflow") {
+            const workflow = config.workflowRegistry?.[payload.workflowName];
+            if (!workflow) {
+              throw new Error(
+                `Workflow "${payload.workflowName}" not found in registry`
+              );
+            }
+            const result = await workflow.run({
+              sessionId: payload.sessionId
+            });
+            return result;
+          }
+          throw new Error(`Unknown job type: ${payload.type}`);
+        },
+        {
+          connection: config.connection,
+          concurrency
+        }
+      );
+    } catch {
+      throw new Error(
+        "bullmq and ioredis are required for AgentWorker. Install them: npm install bullmq ioredis"
+      );
+    }
+  }
+  start() {
+  }
+  async stop() {
+    await this.worker.close();
+  }
+};
+
+// src/progress.ts
+function bridgeEventBusToJob(eventBus, job, runId) {
+  let progressCount = 0;
+  const onChunk = (evt) => {
+    if (evt.runId !== runId) return;
+    progressCount++;
+    job.updateProgress(progressCount).catch(() => {
+    });
+  };
+  const onToolCall = (evt) => {
+    if (evt.runId !== runId) return;
+    job.log(`Tool call: ${evt.toolName}`).catch(() => {
+    });
+  };
+  eventBus.on("run.stream.chunk", onChunk);
+  eventBus.on("tool.call", onToolCall);
+  return () => {
+    eventBus.off("run.stream.chunk", onChunk);
+    eventBus.off("tool.call", onToolCall);
+  };
+}
+export {
+  AgentQueue,
+  AgentWorker,
+  bridgeEventBusToJob
+};

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@radaros/queue",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "dev": "tsup src/index.ts --format esm --dts --watch"
+  },
+  "devDependencies": {
+    "@types/node": "^25.3.1",
+    "tsup": "^8.0.0",
+    "typescript": "^5.6.0"
+  },
+  "peerDependencies": {
+    "@radaros/core": "^0.1.0",
+    "bullmq": "^5.0.0",
+    "ioredis": "^5.0.0"
+  },
+  "peerDependenciesMeta": {
+    "bullmq": {
+      "optional": true
+    },
+    "ioredis": {
+      "optional": true
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,14 @@
+export { AgentQueue } from "./job-producer.js";
+export type { QueueConfig } from "./job-producer.js";
+
+export { AgentWorker } from "./job-worker.js";
+export type { WorkerConfig } from "./job-worker.js";
+
+export { bridgeEventBusToJob } from "./progress.js";
+
+export type {
+  AgentJobPayload,
+  WorkflowJobPayload,
+  JobPayload,
+  JobStatus,
+} from "./job-types.js";

package/src/job-producer.ts

@@ -0,0 +1,137 @@
+import type { RunOutput } from "@radaros/core";
+import type { AgentJobPayload, WorkflowJobPayload, JobStatus } from "./job-types.js";
+
+export interface QueueConfig {
+  connection: { host: string; port: number };
+  queueName?: string;
+  defaultJobOptions?: Record<string, unknown>;
+}
+
+export class AgentQueue {
+  private queue: any;
+  private queueEvents: any;
+  private queueName: string;
+
+  constructor(config: QueueConfig) {
+    this.queueName = config.queueName ?? "radaros:jobs";
+    try {
+      const { Queue, QueueEvents } = require("bullmq");
+      this.queue = new Queue(this.queueName, {
+        connection: config.connection,
+        defaultJobOptions: config.defaultJobOptions,
+      });
+      this.queueEvents = new QueueEvents(this.queueName, {
+        connection: config.connection,
+      });
+    } catch {
+      throw new Error(
+        "bullmq and ioredis are required for AgentQueue. Install them: npm install bullmq ioredis"
+      );
+    }
+  }
+
+  async enqueueAgentRun(opts: {
+    agentName: string;
+    input: string;
+    sessionId?: string;
+    userId?: string;
+    priority?: number;
+    delay?: number;
+    attempts?: number;
+    repeat?: { pattern: string };
+  }): Promise<{ jobId: string }> {
+    const payload: AgentJobPayload = {
+      type: "agent",
+      agentName: opts.agentName,
+      input: opts.input,
+      sessionId: opts.sessionId,
+      userId: opts.userId,
+    };
+
+    const jobOpts: Record<string, unknown> = {};
+    if (opts.priority !== undefined) jobOpts.priority = opts.priority;
+    if (opts.delay !== undefined) jobOpts.delay = opts.delay;
+    if (opts.attempts !== undefined) jobOpts.attempts = opts.attempts;
+    if (opts.repeat) jobOpts.repeat = opts.repeat;
+
+    const job = await this.queue.add(
+      `agent:${opts.agentName}`,
+      payload,
+      jobOpts
+    );
+
+    return { jobId: job.id };
+  }
+
+  async enqueueWorkflow(opts: {
+    workflowName: string;
+    initialState?: Record<string, unknown>;
+    sessionId?: string;
+    priority?: number;
+  }): Promise<{ jobId: string }> {
+    const payload: WorkflowJobPayload = {
+      type: "workflow",
+      workflowName: opts.workflowName,
+      initialState: opts.initialState,
+      sessionId: opts.sessionId,
+    };
+
+    const jobOpts: Record<string, unknown> = {};
+    if (opts.priority !== undefined) jobOpts.priority = opts.priority;
+
+    const job = await this.queue.add(
+      `workflow:${opts.workflowName}`,
+      payload,
+      jobOpts
+    );
+
+    return { jobId: job.id };
+  }
+
+  async getJobStatus(jobId: string): Promise<JobStatus> {
+    const job = await this.queue.getJob(jobId);
+    if (!job) {
+      throw new Error(`Job ${jobId} not found`);
+    }
+
+    const state = await job.getState();
+
+    return {
+      jobId: job.id,
+      state: state as JobStatus["state"],
+      progress:
+        typeof job.progress === "number" ? job.progress : undefined,
+      result: job.returnvalue,
+      error: job.failedReason,
+      createdAt: new Date(job.timestamp),
+      processedAt: job.processedOn ? new Date(job.processedOn) : undefined,
+      finishedAt: job.finishedOn ? new Date(job.finishedOn) : undefined,
+    };
+  }
+
+  async cancelJob(jobId: string): Promise<void> {
+    const job = await this.queue.getJob(jobId);
+    if (job) {
+      await job.remove();
+    }
+  }
+
+  onCompleted(
+    handler: (jobId: string, result: RunOutput) => void
+  ): void {
+    this.queueEvents.on("completed", ({ jobId, returnvalue }: any) => {
+      handler(jobId, returnvalue);
+    });
+  }
+
+  onFailed(handler: (jobId: string, error: Error) => void): void {
+    this.queueEvents.on("failed", ({ jobId, failedReason }: any) => {
+      handler(jobId, new Error(failedReason));
+    });
+  }
+
+  async close(): Promise<void> {
+    await this.queue.close();
+    await this.queueEvents.close();
+  }
+}

package/src/job-types.ts

@@ -0,0 +1,29 @@
+import type { RunOutput } from "@radaros/core";
+
+export type AgentJobPayload = {
+  type: "agent";
+  agentName: string;
+  input: string;
+  sessionId?: string;
+  userId?: string;
+};
+
+export type WorkflowJobPayload = {
+  type: "workflow";
+  workflowName: string;
+  initialState?: Record<string, unknown>;
+  sessionId?: string;
+};
+
+export type JobPayload = AgentJobPayload | WorkflowJobPayload;
+
+export type JobStatus = {
+  jobId: string;
+  state: "waiting" | "active" | "completed" | "failed" | "delayed";
+  progress?: number;
+  result?: RunOutput;
+  error?: string;
+  createdAt: Date;
+  processedAt?: Date;
+  finishedAt?: Date;
+};

package/src/job-worker.ts

@@ -0,0 +1,89 @@
+import type { Agent, Workflow } from "@radaros/core";
+import type { JobPayload } from "./job-types.js";
+
+export interface WorkerConfig {
+  connection: { host: string; port: number };
+  queueName?: string;
+  concurrency?: number;
+  agentRegistry: Record<string, Agent>;
+  workflowRegistry?: Record<string, Workflow<any>>;
+}
+
+export class AgentWorker {
+  private worker: any;
+
+  constructor(config: WorkerConfig) {
+    const queueName = config.queueName ?? "radaros:jobs";
+    const concurrency = config.concurrency ?? 5;
+
+    try {
+      const { Worker } = require("bullmq");
+
+      this.worker = new Worker(
+        queueName,
+        async (job: any) => {
+          const payload = job.data as JobPayload;
+
+          if (payload.type === "agent") {
+            const agent = config.agentRegistry[payload.agentName];
+            if (!agent) {
+              throw new Error(
+                `Agent "${payload.agentName}" not found in registry`
+              );
+            }
+
+            const onChunk = (evt: any) => {
+              job.updateProgress(
+                typeof job.progress === "number" ? job.progress + 1 : 1
+              );
+            };
+            agent.eventBus.on("run.stream.chunk", onChunk);
+
+            try {
+              const result = await agent.run(payload.input, {
+                sessionId: payload.sessionId,
+                userId: payload.userId,
+              });
+              return result;
+            } finally {
+              agent.eventBus.off("run.stream.chunk", onChunk);
+            }
+          }
+
+          if (payload.type === "workflow") {
+            const workflow =
+              config.workflowRegistry?.[payload.workflowName];
+            if (!workflow) {
+              throw new Error(
+                `Workflow "${payload.workflowName}" not found in registry`
+              );
+            }
+
+            const result = await workflow.run({
+              sessionId: payload.sessionId,
+            });
+            return result;
+          }
+
+          throw new Error(`Unknown job type: ${(payload as any).type}`);
+        },
+        {
+          connection: config.connection,
+          concurrency,
+        }
+      );
+    } catch {
+      throw new Error(
+        "bullmq and ioredis are required for AgentWorker. Install them: npm install bullmq ioredis"
+      );
+    }
+  }
+
+  start(): void {
+    // Worker starts automatically on construction in BullMQ
+  }
+
+  async stop(): Promise<void> {
+    await this.worker.close();
+  }
+}

package/src/progress.ts

@@ -0,0 +1,28 @@
+import type { EventBus } from "@radaros/core";
+
+export function bridgeEventBusToJob(
+  eventBus: EventBus,
+  job: any,
+  runId: string
+): () => void {
+  let progressCount = 0;
+
+  const onChunk = (evt: { runId: string; chunk: string }) => {
+    if (evt.runId !== runId) return;
+    progressCount++;
+    job.updateProgress(progressCount).catch(() => {});
+  };
+
+  const onToolCall = (evt: { runId: string; toolName: string }) => {
+    if (evt.runId !== runId) return;
+    job.log(`Tool call: ${evt.toolName}`).catch(() => {});
+  };
+
+  eventBus.on("run.stream.chunk", onChunk);
+  eventBus.on("tool.call", onToolCall);
+
+  return () => {
+    eventBus.off("run.stream.chunk", onChunk);
+    eventBus.off("tool.call", onToolCall);
+  };
+}

package/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "paths": {
+      "@radaros/core": ["../core/dist/index.d.ts"]
+    }
+  },
+  "include": ["src"]
+}