@aikirun/client 0.9.2 → 0.10.0

package/dist/index.d.ts

@@ -44,9 +44,15 @@ export { AdaptivePollingSubscriberStrategy, ApiClient, Client, ClientParams, Log
  */
 declare function client<AppContext = null>(params: ClientParams<AppContext>): Promise<Client<AppContext>>;
 
+type LogLevel = "TRACE" | "DEBUG" | "INFO" | "WARN" | "ERROR";
+interface ConsoleLoggerOptions {
+    level?: LogLevel;
+    context?: Record<string, unknown>;
+}
 declare class ConsoleLogger implements Logger {
+    private readonly level;
     private readonly context;
-    constructor(context?: Record<string, unknown>);
+    constructor(options?: ConsoleLoggerOptions);
     trace(message: string, metadata?: Record<string, unknown>): void;
     debug(message: string, metadata?: Record<string, unknown>): void;
     info(message: string, metadata?: Record<string, unknown>): void;

package/dist/index.js

@@ -5,50 +5,84 @@ import { RPCLink } from "@orpc/client/fetch";
 import { Redis } from "ioredis";
 
 // logger/console-logger.ts
+var colors = {
+  reset: "\x1B[0m",
+  dim: "\x1B[2m",
+  bold: "\x1B[1m",
+  gray: "\x1B[90m",
+  blue: "\x1B[94m",
+  cyan: "\x1B[36m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  red: "\x1B[31m",
+  magenta: "\x1B[35m"
+};
+var logLevelConfig = {
+  TRACE: { level: 10, color: colors.gray },
+  DEBUG: { level: 20, color: colors.blue },
+  INFO: { level: 30, color: colors.green },
+  WARN: { level: 40, color: colors.yellow },
+  ERROR: { level: 50, color: colors.red }
+};
 var ConsoleLogger = class _ConsoleLogger {
-  constructor(context = {}) {
-    this.context = context;
+  level;
+  context;
+  constructor(options = {}) {
+    this.level = logLevelConfig[options.level ?? "INFO"].level;
+    this.context = options.context ?? {};
   }
   trace(message, metadata) {
-    console.debug(this.format("TRACE", message, metadata));
+    if (this.level <= logLevelConfig.TRACE.level) {
+      console.debug(this.format("TRACE", message, metadata));
+    }
   }
   debug(message, metadata) {
-    console.debug(this.format("DEBUG", message, metadata));
+    if (this.level <= logLevelConfig.DEBUG.level) {
+      console.debug(this.format("DEBUG", message, metadata));
+    }
   }
   info(message, metadata) {
-    console.info(this.format("INFO", message, metadata));
+    if (this.level <= logLevelConfig.INFO.level) {
+      console.info(this.format("INFO", message, metadata));
+    }
   }
   warn(message, metadata) {
-    console.warn(this.format("WARN", message, metadata));
+    if (this.level <= logLevelConfig.WARN.level) {
+      console.warn(this.format("WARN", message, metadata));
+    }
   }
   error(message, metadata) {
-    console.error(this.format("ERROR", message, metadata));
+    if (this.level <= logLevelConfig.ERROR.level) {
+      console.error(this.format("ERROR", message, metadata));
+    }
   }
   child(bindings) {
-    return new _ConsoleLogger({ ...this.context, ...bindings });
+    return new _ConsoleLogger({
+      level: Object.entries(logLevelConfig).find(([, v]) => v.level === this.level)?.[0],
+      context: { ...this.context, ...bindings }
+    });
   }
   format(level, message, metadata) {
     const timestamp = (/* @__PURE__ */ new Date()).toISOString();
     const mergedContext = { ...this.context, ...metadata };
-    const contextStr = Object.keys(mergedContext).length > 0 ? ` ${JSON.stringify(mergedContext)}` : "";
-    return `[${timestamp}] ${level}: ${message}${contextStr}`;
+    const levelColor = logLevelConfig[level].color ?? colors.reset;
+    const timestampStr = `${colors.dim}${timestamp}${colors.reset}`;
+    const levelStr = `${levelColor}${colors.bold}${level.padEnd(5)}${colors.reset}`;
+    const messageStr = `${colors.cyan}${message}${colors.reset}`;
+    let output = `${timestampStr} ${levelStr} ${messageStr}`;
+    if (Object.keys(mergedContext).length > 0) {
+      const entries = Object.entries(mergedContext).map(([key, value]) => {
+        const valueStr = typeof value === "object" ? JSON.stringify(value) : String(value);
+        return `${colors.magenta}${key}:${colors.reset} ${valueStr}`;
+      }).join("\n  ");
+      output += `
+  ${entries}`;
+    }
+    return output;
   }
 };
 
 // ../../lib/array/utils.ts
-function groupBy(items, unwrap) {
-  const result = /* @__PURE__ */ new Map();
-  for (const item of items) {
-    const [key, value] = unwrap(item);
-    const valuesWithSameKey = result.get(key);
-    if (valuesWithSameKey === void 0) {
-      result.set(key, [value]);
-    } else {
-      valuesWithSameKey.push(value);
-    }
-  }
-  return result;
-}
 function isNonEmptyArray(value) {
   return value.length > 0;
 }
@@ -127,13 +161,9 @@ function getRetryParams(attempts, strategy) {
 
 // subscribers/redis-streams.ts
 import { INTERNAL } from "@aikirun/types/symbols";
-import { z } from "zod";
-var WorkflowRunReadyMessageDataSchema = z.object({
-  type: z.literal("workflow_run_ready"),
-  workflowRunId: z.string().transform((id) => id)
-});
-var RedisMessageDataSchema = z.discriminatedUnion("type", [WorkflowRunReadyMessageDataSchema]);
-var RedisMessageRawDataSchema = z.array(z.unknown()).transform((rawFields) => {
+import { type } from "arktype";
+var streamEntriesSchema = type(["string", type(["string", "unknown[]"]).array()]).array();
+var rawStreamMessageFieldsToRecord = (rawFields) => {
   const data = {};
   for (let i = 0; i < rawFields.length; i += 2) {
     if (i + 1 < rawFields.length) {
@@ -144,20 +174,12 @@ var RedisMessageRawDataSchema = z.array(z.unknown()).transform((rawFields) => {
     }
   }
   return data;
+};
+var streamMessageDataSchema = type({
+  type: "'workflow_run_ready'",
+  workflowRunId: "string > 0"
 });
-var RedisStreamMessageSchema = z.tuple([
-  z.string(),
-  // message-id
-  RedisMessageRawDataSchema
-]);
-var RedisStreamEntrySchema = z.tuple([
-  z.string(),
-  // stream
-  z.array(RedisStreamMessageSchema)
-]);
-var RedisStreamEntriesSchema = z.array(RedisStreamEntrySchema);
-var RedisStreamPendingMessageSchema = z.tuple([z.string(), z.string(), z.number(), z.number()]);
-var RedisStreamPendingMessagesSchema = z.array(RedisStreamPendingMessageSchema);
+var streamPendingMessagesSchema = type(["string", "string", "number", "number"]).array();
 function createRedisStreamsStrategy(client2, strategy, workflows, workerShards) {
   const redis = client2[INTERNAL].redis.getConnection();
   const logger = client2.logger.child({
@@ -169,7 +191,7 @@ function createRedisStreamsStrategy(client2, strategy, workflows, workerShards)
   const maxRetryIntervalMs = strategy.maxRetryIntervalMs ?? 3e4;
   const atCapacityIntervalMs = strategy.atCapacityIntervalMs ?? 50;
   const blockTimeMs = strategy.blockTimeMs ?? 1e3;
-  const claimMinIdleTimeMs = strategy.claimMinIdleTimeMs ?? 18e4;
+  const claimMinIdleTimeMs = strategy.claimMinIdleTimeMs ?? 9e4;
   const getNextDelay = (params) => {
     switch (params.type) {
       case "polled":
@@ -197,31 +219,40 @@ function createRedisStreamsStrategy(client2, strategy, workflows, workerShards)
     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 (workflowRunId, meta) => {
+  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.error": error instanceof Error ? error.message : String(error),
+        "aiki.workerId": workerId,
         "aiki.workflowRunId": workflowRunId,
-        "aiki.messageId": meta.messageId
+        "aiki.messageId": meta.messageId,
+        "aiki.error": error instanceof Error ? error.message : String(error)
       });
       throw error;
     }
@@ -242,7 +273,7 @@ function createRedisStreamsStrategy(client2, strategy, workflows, workerShards)
         getNextDelay,
         getNextBatch: (size) => fetchRedisStreamMessages(
           redis,
-          logger,
+          logger.child({ "aiki.workerId": workerId }),
           streams,
           streamConsumerGroupMap,
           workerId,
@@ -278,9 +309,10 @@ async function fetchRedisStreamMessages(redis, logger, streams, streamConsumerGr
   if (!isNonEmptyArray(streams)) {
     return [];
   }
+  const perStreamBlockTimeMs = Math.max(50, Math.floor(blockTimeMs / streams.length));
   const batchSizePerStream = distributeRoundRobin(size, streams.length);
   const shuffledStreams = shuffleArray(streams);
-  const readPromises = [];
+  const streamEntries = [];
   for (let i = 0; i < shuffledStreams.length; i++) {
     const stream = shuffledStreams[i];
     if (!stream) {
@@ -294,25 +326,27 @@ async function fetchRedisStreamMessages(redis, logger, streams, streamConsumerGr
     if (!consumerGroup) {
       continue;
     }
-    const readPromise = redis.xreadgroup(
-      "GROUP",
-      consumerGroup,
-      workerId,
-      "COUNT",
-      streamBatchSize,
-      "BLOCK",
-      blockTimeMs,
-      "STREAMS",
-      stream,
-      ">"
-    );
-    readPromises.push(readPromise);
-  }
-  const readResults = await Promise.allSettled(readPromises);
-  const streamEntries = [];
-  for (const result of readResults) {
-    if (result.status === "fulfilled" && result.value) {
-      streamEntries.push(result.value);
+    try {
+      const result = await redis.xreadgroup(
+        "GROUP",
+        consumerGroup,
+        workerId,
+        "COUNT",
+        streamBatchSize,
+        "BLOCK",
+        perStreamBlockTimeMs,
+        "STREAMS",
+        stream,
+        ">"
+      );
+      if (result) {
+        streamEntries.push(result);
+      }
+    } catch (error) {
+      logger.error("XREADGROUP failed", {
+        "aiki.stream": stream,
+        "aiki.error": error instanceof Error ? error.message : String(error)
+      });
     }
   }
   const workflowRuns = isNonEmptyArray(streamEntries) ? await processRedisStreamMessages(redis, logger, streamConsumerGroupMap, streamEntries) : [];
@@ -336,14 +370,15 @@ async function fetchRedisStreamMessages(redis, logger, streams, streamConsumerGr
 async function processRedisStreamMessages(redis, logger, streamConsumerGroupMap, streamsEntries) {
   const workflowRuns = [];
   for (const streamEntriesRaw of streamsEntries) {
-    const streamEntriesResult = RedisStreamEntriesSchema.safeParse(streamEntriesRaw);
-    if (!streamEntriesResult.success) {
+    logger.debug("Raw stream entries", { "aiki.entries": streamEntriesRaw });
+    const streamEntriesResult = streamEntriesSchema(streamEntriesRaw);
+    if (streamEntriesResult instanceof type.errors) {
       logger.error("Invalid stream entries format", {
-        "aiki.error": z.treeifyError(streamEntriesResult.error)
+        "aiki.error": streamEntriesResult.summary
       });
       continue;
     }
-    for (const streamEntry of streamEntriesResult.data) {
+    for (const streamEntry of streamEntriesResult) {
       const [stream, messages] = streamEntry;
       const consumerGroup = streamConsumerGroupMap.get(stream);
       if (!consumerGroup) {
@@ -352,20 +387,21 @@ async function processRedisStreamMessages(redis, logger, streamConsumerGroupMap,
         });
         continue;
       }
-      for (const [messageId, rawMessageData] of messages) {
-        const messageData = RedisMessageDataSchema.safeParse(rawMessageData);
-        if (!messageData.success) {
+      for (const [messageId, rawFields] of messages) {
+        const rawMessageData = rawStreamMessageFieldsToRecord(rawFields);
+        const messageData = streamMessageDataSchema(rawMessageData);
+        if (messageData instanceof type.errors) {
           logger.warn("Invalid message structure", {
             "aiki.stream": stream,
             "aiki.messageId": messageId,
-            "aiki.error": z.treeifyError(messageData.error)
+            "aiki.error": messageData.summary
           });
           await redis.xack(stream, consumerGroup, messageId);
           continue;
         }
-        switch (messageData.data.type) {
+        switch (messageData.type) {
           case "workflow_run_ready": {
-            const { workflowRunId } = messageData.data;
+            const workflowRunId = messageData.workflowRunId;
             workflowRuns.push({
               data: { workflowRunId },
               meta: {
@@ -377,7 +413,7 @@ async function processRedisStreamMessages(redis, logger, streamConsumerGroupMap,
             break;
           }
           default:
-            messageData.data.type;
+            messageData.type;
             continue;
         }
       }
@@ -389,7 +425,7 @@ async function claimStuckRedisStreamMessages(redis, logger, shuffledStreams, str
   if (maxClaim <= 0 || minIdleMs <= 0) {
     return [];
   }
-  const claimableMessages = await findClaimableRedisStreamMessages(
+  const claimaibleMessagesByStream = await findClaimableMessagesByStream(
     redis,
     logger,
     shuffledStreams,
@@ -398,16 +434,17 @@ async function claimStuckRedisStreamMessages(redis, logger, shuffledStreams, str
     maxClaim,
     minIdleMs
   );
-  if (!isNonEmptyArray(claimableMessages)) {
+  if (!claimaibleMessagesByStream.size) {
     return [];
   }
-  const claimaibleMessagesByStream = groupBy(claimableMessages, (message) => [message.stream, message]);
-  const claimPromises = Array.from(claimaibleMessagesByStream.entries()).map(async ([stream, messages]) => {
+  const claimPromises = Array.from(claimaibleMessagesByStream.entries()).map(async ([stream, messageIds]) => {
+    if (!messageIds.length) {
+      return null;
+    }
     const consumerGroup = streamConsumerGroupMap.get(stream);
     if (!consumerGroup) {
       return null;
     }
-    const messageIds = messages.map((message) => message.messageId);
     try {
       const claimedMessages = await redis.xclaim(stream, consumerGroup, workerId, minIdleMs, ...messageIds);
       return { stream, claimedMessages };
@@ -415,23 +452,25 @@ async function claimStuckRedisStreamMessages(redis, logger, shuffledStreams, str
       const errorMessage = error instanceof Error ? error.message : String(error);
       if (errorMessage.includes("NOGROUP")) {
         logger.warn("Consumer group does not exist for stream, skipping claim operation", {
-          "aiki.stream": stream
+          "aiki.stream": stream,
+          "aiki.consumerGroup": consumerGroup
         });
       } else if (errorMessage.includes("BUSYGROUP")) {
         logger.warn("Consumer group busy for stream, skipping claim operation", {
-          "aiki.stream": stream
+          "aiki.stream": stream,
+          "aiki.consumerGroup": consumerGroup
         });
       } else if (errorMessage.includes("NOSCRIPT")) {
         logger.warn("Redis script not loaded for stream, skipping claim operation", {
-          "aiki.stream": stream
+          "aiki.stream": stream,
+          "aiki.consumerGroup": consumerGroup
         });
       } else {
         logger.error("Failed to claim messages from stream", {
-          "aiki.error": errorMessage,
-          "aiki.messageIds": messageIds.length,
-          "aiki.workerId": workerId,
+          "aiki.stream": stream,
           "aiki.consumerGroup": consumerGroup,
-          "aiki.stream": stream
+          "aiki.messageIds": messageIds.length,
+          "aiki.error": errorMessage
         });
       }
       return null;
@@ -448,10 +487,9 @@ async function claimStuckRedisStreamMessages(redis, logger, shuffledStreams, str
   if (!isNonEmptyArray(claimedStreamEntries)) {
     return [];
   }
-  return processRedisStreamMessages(redis, logger, streamConsumerGroupMap, claimedStreamEntries);
+  return processRedisStreamMessages(redis, logger, streamConsumerGroupMap, [claimedStreamEntries]);
 }
-async function findClaimableRedisStreamMessages(redis, logger, shuffledStreams, streamConsumerGroupMap, workerId, maxClaim, minIdleMs) {
-  const claimableMessages = [];
+async function findClaimableMessagesByStream(redis, logger, shuffledStreams, streamConsumerGroupMap, workerId, maxClaim, minIdleMs) {
   const claimSizePerStream = distributeRoundRobin(maxClaim, shuffledStreams.length);
   const pendingPromises = [];
   for (let i = 0; i < shuffledStreams.length; i++) {
@@ -467,31 +505,35 @@ async function findClaimableRedisStreamMessages(redis, logger, shuffledStreams,
     if (!consumerGroup) {
       continue;
     }
-    const pendingPromise = redis.xpending(stream, consumerGroup, "IDLE", minIdleMs, "-", "+", claimSize).then((result) => ({ stream, result }));
-    pendingPromises.push(pendingPromise);
+    const readPromise = redis.xpending(stream, consumerGroup, "IDLE", minIdleMs, "-", "+", claimSize).then((result) => ({ stream, result }));
+    pendingPromises.push(readPromise);
   }
   const pendingResults = await Promise.allSettled(pendingPromises);
+  const claimableMessagesByStream = /* @__PURE__ */ new Map();
   for (const pendingResult of pendingResults) {
     if (pendingResult.status !== "fulfilled") {
       continue;
     }
     const { stream, result } = pendingResult.value;
-    const parsedResult = RedisStreamPendingMessagesSchema.safeParse(result);
-    if (!parsedResult.success) {
+    const parsedResult = streamPendingMessagesSchema(result);
+    if (parsedResult instanceof type.errors) {
       logger.error("Invalid XPENDING response", {
         "aiki.stream": stream,
-        "aiki.error": z.treeifyError(parsedResult.error)
+        "aiki.error": parsedResult.summary
       });
       continue;
     }
-    for (const [messageId, consumerName, _idleTimeMs, _deliveryCount] of parsedResult.data) {
-      if (consumerName === workerId) {
-        continue;
+    const claimableStreamMessages = claimableMessagesByStream.get(stream) ?? [];
+    for (const [messageId, consumerName, _idleTimeMs, _deliveryCount] of parsedResult) {
+      if (consumerName !== workerId) {
+        claimableStreamMessages.push(messageId);
       }
-      claimableMessages.push({ stream, messageId });
+    }
+    if (claimableStreamMessages.length) {
+      claimableMessagesByStream.set(stream, claimableStreamMessages);
     }
   }
-  return claimableMessages;
+  return claimableMessagesByStream;
 }
 
 // subscribers/strategy-resolver.ts

package/package.json

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