@aikirun/client 0.17.0 → 0.19.0

package/README.md

@@ -14,6 +14,7 @@ npm install @aikirun/client
 import { client } from "@aikirun/client";
 import { orderWorkflowV1 } from "./workflows.ts";
 
+// Set AIKI_API_KEY env variable or pass apiKey option
 const aikiClient = client({
 	url: "http://localhost:9850",
 	redis: { host: "localhost", port: 6379 },

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { ClientParams, Client, Logger } from '@aikirun/types/client';
-export { AdaptivePollingSubscriberStrategy, ApiClient, Client, ClientParams, Logger, PollingSubscriberStrategy, RedisConfig, RedisStreamsSubscriberStrategy, ResolvedSubscriberStrategy, SubscriberMessageMeta, SubscriberStrategy, WorkflowRunBatch } from '@aikirun/types/client';
+export { ApiClient, Client, ClientParams, DbSubscriberStrategy, Logger, RedisConfig, RedisStreamsSubscriberStrategy, ResolvedSubscriberStrategy, SubscriberStrategy, WorkflowRunBatch } from '@aikirun/types/client';
 
 /**
  * Creates an Aiki client for starting and managing workflows.

package/dist/index.js

@@ -83,17 +83,9 @@ var ConsoleLogger = class _ConsoleLogger {
   }
 };
 
-// ../../lib/address/index.ts
-function getWorkflowStreamName(name, versionId, shard) {
-  return shard ? `workflow:${name}:${versionId}:${shard}` : `workflow:${name}:${versionId}`;
-}
-function getWorkerConsumerGroupName(workflowName, workflowVersionId, shard) {
-  return shard ? `worker:${workflowName}:${workflowVersionId}:${shard}` : `worker:${workflowName}:${workflowVersionId}`;
-}
-
 // ../../lib/array/utils.ts
 function isNonEmptyArray(value) {
-  return value.length > 0;
+  return value !== void 0 && value.length > 0;
 }
 function shuffleArray(array) {
   const shuffledArray = Array.from(array);
@@ -112,6 +104,15 @@ function distributeRoundRobin(totalSize, itemCount) {
   return distribution;
 }
 
+// ../../lib/crypto/hash.ts
+import { createHash } from "crypto";
+
+// ../../lib/duration/convert.ts
+var MS_PER_SECOND = 1e3;
+var MS_PER_MINUTE = 60 * MS_PER_SECOND;
+var MS_PER_HOUR = 60 * MS_PER_MINUTE;
+var MS_PER_DAY = 24 * MS_PER_HOUR;
+
 // ../../lib/retry/strategy.ts
 function getRetryParams(attempts, strategy) {
   const strategyType = strategy.type;
@@ -160,6 +161,87 @@ function getRetryParams(attempts, strategy) {
   }
 }
 
+// subscribers/db.ts
+function createDbStrategy(client2, strategy, workflows, workerShards) {
+  const logger = client2.logger.child({
+    "aiki.component": "db-subscriber"
+  });
+  const intervalMs = strategy.intervalMs ?? 1e3;
+  const maxRetryIntervalMs = strategy.maxRetryIntervalMs ?? 3e4;
+  const atCapacityIntervalMs = strategy.atCapacityIntervalMs ?? 500;
+  const claimMinIdleTimeMs = strategy.claimMinIdleTimeMs ?? 9e4;
+  const workflowFilters = !isNonEmptyArray(workerShards) ? workflows.map((workflow) => ({ name: workflow.name, versionId: workflow.versionId })) : workflows.flatMap(
+    (workflow) => workerShards.map((shard) => ({ name: workflow.name, versionId: workflow.versionId, shard }))
+  );
+  const getNextDelay = (params) => {
+    switch (params.type) {
+      case "polled":
+      case "heartbeat":
+        return intervalMs;
+      case "at_capacity":
+        return atCapacityIntervalMs;
+      case "retry": {
+        const retryParams = getRetryParams(params.attemptNumber, {
+          type: "jittered",
+          maxAttempts: Number.POSITIVE_INFINITY,
+          baseDelayMs: intervalMs,
+          maxDelayMs: maxRetryIntervalMs
+        });
+        if (!retryParams.retriesLeft) {
+          return maxRetryIntervalMs;
+        }
+        return retryParams.delayMs;
+      }
+      default:
+        return params;
+    }
+  };
+  return {
+    async init(workerId, _callbacks) {
+      return {
+        type: strategy.type,
+        getNextDelay,
+        getNextBatch: async (size) => {
+          const response = await client2.api.workflowRun.claimReadyV1({
+            workerId,
+            workflows: workflowFilters,
+            limit: size,
+            claimMinIdleTimeMs
+          });
+          return response.runs.map((run) => ({
+            data: { workflowRunId: run.id }
+          }));
+        },
+        heartbeat: async (workflowRunId) => {
+          try {
+            await client2.api.workflowRun.heartbeatV1({ id: workflowRunId });
+            logger.debug("Heartbeat sent", {
+              "aiki.workerId": workerId,
+              "aiki.workflowRunId": workflowRunId
+            });
+          } catch (error) {
+            logger.warn("Heartbeat failed", {
+              "aiki.workerId": workerId,
+              "aiki.workflowRunId": workflowRunId,
+              "aiki.error": error instanceof Error ? error.message : String(error)
+            });
+          }
+        },
+        acknowledge: async () => {
+        }
+      };
+    }
+  };
+}
+
+// ../../lib/address/index.ts
+function getWorkflowStreamName(name, versionId, shard) {
+  return shard ? `workflow:${name}:${versionId}:${shard}` : `workflow:${name}:${versionId}`;
+}
+function getWorkerConsumerGroupName(workflowName, workflowVersionId, shard) {
+  return shard ? `worker:${workflowName}:${workflowVersionId}:${shard}` : `worker:${workflowName}:${workflowVersionId}`;
+}
+
 // subscribers/redis-streams.ts
 import { INTERNAL } from "@aikirun/types/symbols";
 import { type } from "arktype";
@@ -216,48 +298,6 @@ function createRedisStreamsStrategy(client2, strategy, workflows, workerShards)
         return params;
     }
   };
-  const getHeartbeat = (workerId) => async (workflowRunId, meta) => {
-    try {
-      await redis.xclaim(meta.stream, meta.consumerGroup, workerId, 0, meta.messageId, "JUSTID");
-      logger.debug("Heartbeat sent", {
-        "aiki.workerId": workerId,
-        "aiki.workflowRunId": workflowRunId,
-        "aiki.messageId": meta.messageId
-      });
-    } catch (error) {
-      logger.warn("Heartbeat failed", {
-        "aiki.workerId": workerId,
-        "aiki.workflowRunId": workflowRunId,
-        "aiki.error": error instanceof Error ? error.message : String(error)
-      });
-    }
-  };
-  const acknowledge = async (workerId, workflowRunId, meta) => {
-    try {
-      const result = await redis.xack(meta.stream, meta.consumerGroup, meta.messageId);
-      if (result === 0) {
-        logger.warn("Message already acknowledged", {
-          "aiki.workerId": workerId,
-          "aiki.workflowRunId": workflowRunId,
-          "aiki.messageId": meta.messageId
-        });
-      } else {
-        logger.debug("Message acknowledged", {
-          "aiki.workerId": workerId,
-          "aiki.workflowRunId": workflowRunId,
-          "aiki.messageId": meta.messageId
-        });
-      }
-    } catch (error) {
-      logger.error("Failed to acknowledge message", {
-        "aiki.workerId": workerId,
-        "aiki.workflowRunId": workflowRunId,
-        "aiki.messageId": meta.messageId,
-        "aiki.error": error instanceof Error ? error.message : String(error)
-      });
-      throw error;
-    }
-  };
   return {
     async init(workerId, _callbacks) {
       for (const [stream, consumerGroup] of streamConsumerGroupMap) {
@@ -269,21 +309,80 @@ function createRedisStreamsStrategy(client2, strategy, workflows, workerShards)
           }
         }
       }
+      const pendingMessageMetaByWorkflowRunId = /* @__PURE__ */ new Map();
       return {
         type: strategy.type,
         getNextDelay,
-        getNextBatch: (size) => fetchRedisStreamMessages(
-          redis,
-          logger.child({ "aiki.workerId": workerId }),
-          streams,
-          streamConsumerGroupMap,
-          workerId,
-          size,
-          blockTimeMs,
-          claimMinIdleTimeMs
-        ),
-        heartbeat: getHeartbeat(workerId),
-        acknowledge
+        getNextBatch: async (size) => {
+          const messages = await fetchRedisStreamMessages(
+            redis,
+            logger.child({ "aiki.workerId": workerId }),
+            streams,
+            streamConsumerGroupMap,
+            workerId,
+            size,
+            blockTimeMs,
+            claimMinIdleTimeMs
+          );
+          const batches = [];
+          for (const message of messages) {
+            pendingMessageMetaByWorkflowRunId.set(message.data.workflowRunId, message.meta);
+            batches.push({ data: message.data });
+          }
+          return batches;
+        },
+        heartbeat: async (workflowRunId) => {
+          const meta = pendingMessageMetaByWorkflowRunId.get(workflowRunId);
+          if (!meta) {
+            return;
+          }
+          try {
+            await redis.xclaim(meta.stream, meta.consumerGroup, workerId, 0, meta.messageId, "JUSTID");
+            logger.debug("Heartbeat sent", {
+              "aiki.workerId": workerId,
+              "aiki.workflowRunId": workflowRunId,
+              "aiki.messageId": meta.messageId
+            });
+          } catch (error) {
+            logger.warn("Heartbeat failed", {
+              "aiki.workerId": workerId,
+              "aiki.workflowRunId": workflowRunId,
+              "aiki.error": error instanceof Error ? error.message : String(error)
+            });
+          }
+        },
+        acknowledge: async (workflowRunId) => {
+          const meta = pendingMessageMetaByWorkflowRunId.get(workflowRunId);
+          if (!meta) {
+            return;
+          }
+          try {
+            const result = await redis.xack(meta.stream, meta.consumerGroup, meta.messageId);
+            if (result === 0) {
+              logger.warn("Message already acknowledged", {
+                "aiki.workerId": workerId,
+                "aiki.workflowRunId": workflowRunId,
+                "aiki.messageId": meta.messageId
+              });
+            } else {
+              logger.debug("Message acknowledged", {
+                "aiki.workerId": workerId,
+                "aiki.workflowRunId": workflowRunId,
+                "aiki.messageId": meta.messageId
+              });
+            }
+          } catch (error) {
+            logger.error("Failed to acknowledge message", {
+              "aiki.workerId": workerId,
+              "aiki.workflowRunId": workflowRunId,
+              "aiki.messageId": meta.messageId,
+              "aiki.error": error instanceof Error ? error.message : String(error)
+            });
+            throw error;
+          } finally {
+            pendingMessageMetaByWorkflowRunId.delete(workflowRunId);
+          }
+        }
       };
     }
   };
@@ -540,19 +639,16 @@ async function findClaimableMessagesByStream(redis, logger, shuffledStreams, str
 // subscribers/strategy-resolver.ts
 function resolveSubscriberStrategy(client2, strategy, workflows, workerShards) {
   switch (strategy.type) {
-    // case "polling":
-    // 	return createPollingStrategy(client, strategy);
-    // case "adaptive_polling":
-    // 	return createAdaptivePollingStrategy(client, strategy);
     case "redis":
       return createRedisStreamsStrategy(client2, strategy, workflows, workerShards);
+    case "db":
+      return createDbStrategy(client2, strategy, workflows, workerShards);
     default:
-      return strategy.type;
+      return strategy;
   }
 }
 
 // client.ts
-var AIKI_API_KEY_ENV_NAME = "AIKI_API_KEY";
 function client(params) {
   return new ClientImpl(params);
 }
@@ -560,9 +656,9 @@ var ClientImpl = class {
   constructor(params) {
     this.params = params;
     this.logger = params.logger ?? new ConsoleLogger();
-    const apiKey = params.apiKey ?? process.env[AIKI_API_KEY_ENV_NAME];
+    const apiKey = params.apiKey ?? process.env.AIKI_API_KEY;
     if (!apiKey) {
-      throw new Error(`API key is required. Provide it via 'apiKey' param or ${AIKI_API_KEY_ENV_NAME} env variable`);
+      throw new Error(`API key is required. Provide it via 'apiKey' param or AIKI_API_KEY env variable`);
     }
     const rpcLink = new RPCLink({
       url: `${params.url}/api`,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@aikirun/client",
-	"version": "0.17.0",
+	"version": "0.19.0",
 	"description": "Client SDK for Aiki - connect to the server, start workflows, and manage execution",
 	"type": "module",
 	"main": "./dist/index.js",
@@ -18,7 +18,7 @@
 		"build": "tsup"
 	},
 	"dependencies": {
-		"@aikirun/types": "0.17.0",
+		"@aikirun/types": "0.19.0",
 		"@orpc/client": "^1.9.3",
 		"ioredis": "^5.4.1",
 		"arktype": "^2.1.29"