@agentium/queue 4.1.0 → 4.5.0

package/dist/connection.d.cts

@@ -0,0 +1,27 @@
+export declare function queueConnection(value: string | {
+    host: string;
+    port: number;
+    password?: string;
+    db?: number;
+    tls?: boolean;
+}): {
+    tls: {};
+    host: string;
+    port: number;
+    password?: string;
+    db?: number;
+} | {
+    tls: undefined;
+    host: string;
+    port: number;
+    password?: string;
+    db?: number;
+} | {
+    tls?: {} | undefined;
+    password?: string | undefined;
+    username?: string | undefined;
+    host: string;
+    port: number;
+    db: number;
+};
+//# sourceMappingURL=connection.d.ts.map

package/dist/durable.d.cts

@@ -0,0 +1,58 @@
+import { type DurableTaskHandler, type DurableTaskInput, type DurableTaskKey, type DurableTaskRecord, type DurableTaskSupervisor } from "@agentium/core";
+import type { QueueConfig } from "./job-producer.cjs";
+export interface DurableJobEnvelope {
+    schemaVersion: 1;
+    type: "durable";
+    tenantId: string;
+    taskId: string;
+    inputDigest: string;
+}
+export interface DurableDriverRegistration {
+    id: string;
+    version: number;
+    /** Explicit host assertion: resumes use stable action IDs and reconcile uncertain effects. */
+    recoverable: true;
+    execute: DurableTaskHandler;
+}
+export interface DurableQueueConfig extends QueueConfig {
+    supervisor: DurableTaskSupervisor;
+    /** Verify identity, definition, policy and grants before writing any task/queue record. */
+    admit: (task: Readonly<DurableTaskInput>) => Promise<void>;
+}
+/** Queue delivery is a hint; Mongo/another atomic task store owns authoritative state.
+ * Persistence precedes enqueue. If Redis fails, call wake() after retrying admission.
+ * The stable task key prevents a delivery retry from creating a second execution.
+ */
+export declare class DurableAgentQueue {
+    private readonly config;
+    private queue;
+    constructor(config: DurableQueueConfig);
+    enqueue(task: DurableTaskInput): Promise<{
+        taskId: string;
+        deliveryId: string;
+    }>;
+    /** Explicit re-delivery after approval, reconciliation, or a failed initial enqueue. */
+    wake(key: DurableTaskKey): Promise<{
+        taskId: string;
+        deliveryId: string;
+    }>;
+    cancel(key: DurableTaskKey, reason?: string): Promise<void>;
+    close(): Promise<void>;
+}
+export interface DurableWorkerConfig extends Omit<QueueConfig, "defaultJobOptions"> {
+    supervisor: DurableTaskSupervisor;
+    workerId?: string;
+    concurrency?: number;
+    drivers: readonly DurableDriverRegistration[];
+    /** Revalidate policy/grants from authoritative host state; a payload is not authentication. */
+    admit: (task: Readonly<DurableTaskRecord>) => Promise<void>;
+    /** Observe delivery failures; durable task outcome remains available from the store. */
+    onError?: (error: Error) => void;
+}
+export declare class DurableAgentWorker {
+    private worker;
+    constructor(config: DurableWorkerConfig);
+    /** Drains owned work. Active durable cancellation is explicit through queue.cancel(). */
+    stop(): Promise<void>;
+}
+//# sourceMappingURL=durable.d.ts.map

package/dist/index.d.cts

@@ -0,0 +1,9 @@
+export type { DurableDriverRegistration, DurableJobEnvelope, DurableQueueConfig, DurableWorkerConfig, } from "./durable.cjs";
+export { DurableAgentQueue, DurableAgentWorker } from "./durable.cjs";
+export type { QueueConfig, ScheduleOptions } from "./job-producer.cjs";
+export { AgentQueue } from "./job-producer.cjs";
+export type { AgentJobPayload, JobPayload, JobStatus, ScheduleInfo, TeamJobPayload, WorkflowJobPayload, } from "./job-types.cjs";
+export type { WorkerConfig } from "./job-worker.cjs";
+export { AgentWorker } from "./job-worker.cjs";
+export { bridgeEventBusToJob } from "./progress.cjs";
+//# sourceMappingURL=index.d.ts.map

package/dist/job-producer.d.cts

@@ -0,0 +1,132 @@
+import type { RunOutput } from "@agentium/core";
+import type { JobStatus, ScheduleInfo } from "./job-types.cjs";
+export interface ScheduleOptions {
+    id: string;
+    cron: string;
+    timezone?: string;
+    agent?: {
+        name: string;
+        input: string;
+        sessionId?: string;
+        userId?: string;
+        tenantId?: string;
+    };
+    workflow?: {
+        name: string;
+        initialState?: Record<string, unknown>;
+        sessionId?: string;
+        userId?: string;
+        tenantId?: string;
+    };
+    team?: {
+        name: string;
+        input: string;
+        sessionId?: string;
+        userId?: string;
+        tenantId?: string;
+    };
+}
+export interface QueueConfig {
+    connection: {
+        host: string;
+        port: number;
+        password?: string;
+        db?: number;
+        tls?: boolean;
+    } | string;
+    queueName?: string;
+    defaultJobOptions?: Record<string, unknown>;
+}
+export declare class AgentQueue {
+    private queue;
+    private queueEvents;
+    private queueName;
+    constructor(config: QueueConfig);
+    enqueueAgentRun(opts: {
+        agentName: string;
+        input: string;
+        sessionId?: string;
+        tenantId?: string;
+        userId?: string;
+        priority?: number;
+        delay?: number;
+        attempts?: number;
+        backoff?: {
+            type: "exponential" | "fixed";
+            delay: number;
+        };
+        repeat?: {
+            pattern: string;
+            timezone?: string;
+        };
+    }): Promise<{
+        jobId: string;
+    }>;
+    enqueueWorkflow(opts: {
+        workflowName: string;
+        userId?: string;
+        initialState?: Record<string, unknown>;
+        sessionId?: string;
+        tenantId?: string;
+        priority?: number;
+        delay?: number;
+        attempts?: number;
+        backoff?: {
+            type: "exponential" | "fixed";
+            delay: number;
+        };
+        repeat?: {
+            pattern: string;
+            timezone?: string;
+        };
+    }): Promise<{
+        jobId: string;
+    }>;
+    enqueueTeamRun(opts: {
+        teamName: string;
+        input: string;
+        sessionId?: string;
+        tenantId?: string;
+        userId?: string;
+        priority?: number;
+        delay?: number;
+        attempts?: number;
+        backoff?: {
+            type: "exponential" | "fixed";
+            delay: number;
+        };
+        repeat?: {
+            pattern: string;
+            timezone?: string;
+        };
+    }): 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;
+    private enqueueRecurring;
+    private schedulerRecords;
+    private hasLegacyMaintenance;
+    private assertNoLegacySchedule;
+    schedule(opts: ScheduleOptions): Promise<{
+        jobId: string;
+    }>;
+    unschedule(id: string): Promise<void>;
+    listSchedules(): Promise<ScheduleInfo[]>;
+    /** BullMQ v5 maintenance only. Never silently converts persisted legacy repeat records. */
+    listLegacySchedules(): Promise<Array<{
+        key: string;
+        name: string;
+        pattern?: string;
+        timezone?: string;
+        next: number;
+    }>>;
+    pause(): Promise<void>;
+    resume(): Promise<void>;
+    /** Maintenance-only removal: callers retain inventory/payload backups and stop concurrent schedule writers. */
+    removeLegacySchedule(key: string): Promise<void>;
+    close(): Promise<void>;
+}
+//# sourceMappingURL=job-producer.d.ts.map

package/dist/job-types.d.cts

@@ -0,0 +1,43 @@
+import type { RunOutput } from "@agentium/core";
+export type AgentJobPayload = {
+    type: "agent";
+    agentName: string;
+    input: string;
+    sessionId?: string;
+    tenantId?: string;
+    userId?: string;
+};
+export type WorkflowJobPayload = {
+    type: "workflow";
+    workflowName: string;
+    initialState?: Record<string, unknown>;
+    userId?: string;
+    sessionId?: string;
+    tenantId?: string;
+};
+export type TeamJobPayload = {
+    type: "team";
+    teamName: string;
+    input: string;
+    sessionId?: string;
+    tenantId?: string;
+    userId?: string;
+};
+export type JobPayload = AgentJobPayload | WorkflowJobPayload | TeamJobPayload;
+export type ScheduleInfo = {
+    id: string;
+    pattern: string;
+    timezone?: string;
+    next: Date;
+};
+export type JobStatus = {
+    jobId: string;
+    state: "waiting" | "active" | "completed" | "failed" | "delayed";
+    progress?: number;
+    result?: RunOutput;
+    error?: string;
+    createdAt: Date;
+    processedAt?: Date;
+    finishedAt?: Date;
+};
+//# sourceMappingURL=job-types.d.ts.map

package/dist/job-worker.d.cts

@@ -0,0 +1,22 @@
+import type { Agent, Workflow } from "@agentium/core";
+export interface WorkerConfig {
+    connection: {
+        host: string;
+        port: number;
+        password?: string;
+        db?: number;
+        tls?: boolean;
+    } | string;
+    queueName?: string;
+    concurrency?: number;
+    agentRegistry: Record<string, Agent>;
+    workflowRegistry?: Record<string, Workflow<any>>;
+    teamRegistry?: Record<string, import("@agentium/core").Team>;
+}
+export declare class AgentWorker {
+    private worker;
+    constructor(config: WorkerConfig);
+    start(): void;
+    stop(timeoutMs?: number): Promise<void>;
+}
+//# sourceMappingURL=job-worker.d.ts.map

package/dist/progress.d.cts

@@ -0,0 +1,3 @@
+import type { EventBus } from "@agentium/core";
+export declare function bridgeEventBusToJob(eventBus: EventBus, job: any, runId: string): () => void;
+//# sourceMappingURL=progress.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentium/queue",
-  "version": "4.1.0",
+  "version": "4.5.0",
   "description": "Background job processing for Agentium agents using BullMQ",
   "license": "MIT",
   "publishConfig": {
@@ -25,9 +25,14 @@
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
-      "require": "./dist/index.cjs",
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      },
       "default": "./dist/index.js"
     }
   },
@@ -35,7 +40,7 @@
     "dist"
   ],
   "scripts": {
-    "build": "tsdown --config ../../tsdown.config.ts && tsc -p tsconfig.build.json --emitDeclarationOnly --declaration --pretty false",
+    "build": "tsdown --config ../../tsdown.config.ts && tsc -p tsconfig.build.json --emitDeclarationOnly --declaration --pretty false && node ../../scripts/cjs-declarations.mjs",
     "dev": "tsdown --config ../../tsdown.config.ts --watch",
     "prepublishOnly": "npm run build"
   },
@@ -45,7 +50,7 @@
     "tsdown": "0.23.0"
   },
   "peerDependencies": {
-    "@agentium/core": "^4.1.0",
+    "@agentium/core": "^4.5.0",
     "bullmq": "^5.81.5 || ^6.3.11",
     "ioredis": "^5.0.0"
   },