@aikirun/client 0.23.1 → 0.24.1

package/README.md

@@ -14,10 +14,9 @@ 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 },
+	apiKey: "your-api-key",
 });
 
 // Start a workflow
@@ -27,16 +26,12 @@ const handle = await orderWorkflowV1.start(aikiClient, {
 
 // Wait for completion
 const result = await handle.waitForStatus("completed");
-
-// Close when done
-await aikiClient.close();
 ```
 
 ## Features
 
 - **Server Connection** - Connect to the Aiki server via HTTP
 - **Workflow Management** - Start workflows with type-safe inputs
-- **Redis Integration** - Distributed state and message streaming
 - **Context Injection** - Pass application context to workflows
 - **Custom Logging** - Plug in your own logger
 

package/dist/index.d.ts

@@ -1,20 +1,15 @@
-import { ClientParams, Client, Logger } from '@aikirun/types/client';
-export { ApiClient, Client, ClientParams, DbSubscriberStrategy, Logger, RedisConfig, RedisStreamsSubscriberStrategy, ResolvedSubscriberStrategy, SubscriberStrategy, WorkflowRunBatch } from '@aikirun/types/client';
+import { ClientParams, Client } from '@aikirun/types/client';
 
 /**
  * Creates an Aiki client for starting and managing workflows.
  *
- * The client connects to the Aiki server via HTTP and Redis for state management.
+ * The client connects to the Aiki server via HTTP.
  * It provides methods to start workflows and monitor their execution.
  *
  * @template AppContext - Type of application context passed to workflows (default: null)
  * @param params - Client configuration parameters
  * @param params.url - HTTP URL of the Aiki server (e.g., "http://localhost:9850")
- * @param params.apiKey - API key for authentication. Falls back to AIKI_API_KEY env variable if not provided.
- * @param params.redis - Redis connection configuration
- * @param params.redis.host - Redis server hostname
- * @param params.redis.port - Redis server port
- * @param params.redis.password - Optional Redis password
+ * @param params.apiKey - API key for authentication
  * @param params.createContext - Optional function to create context for each workflow run
  * @param params.logger - Optional custom logger (defaults to ConsoleLogger)
  * @returns Promise resolving to a configured Client instance
@@ -23,8 +18,7 @@ export { ApiClient, Client, ClientParams, DbSubscriberStrategy, Logger, RedisCon
  * ```typescript
  * const aikiClient = client({
  *   url: "http://localhost:9850",
- *   apiKey: "yourApiKey", // or omit to use AIKI_API_KEY env variable
- *   redis: { host: "localhost", port: 6379 },
+ *   apiKey: "yourApiKey",
  *   createContext: (run) => ({
  *     traceId: generateTraceId(),
  *     userId: extractUserId(run),
@@ -39,29 +33,8 @@ export { ApiClient, Client, ClientParams, DbSubscriberStrategy, Logger, RedisCon
  *   { type: "status", status: "completed" },
  *   { maxDurationMs: 60_000 }
  * );
- *
- * // Cleanup
- * await aikiClient.close();
  * ```
  */
 declare function client<AppContext = null>(params: ClientParams<AppContext>): 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(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;
-    warn(message: string, metadata?: Record<string, unknown>): void;
-    error(message: string, metadata?: Record<string, unknown>): void;
-    child(bindings: Record<string, unknown>): Logger;
-    private format;
-}
-
-export { ConsoleLogger, client };
+export { client };

package/dist/index.js

@@ -1,11 +1,4 @@
-// client.ts
-import process from "process";
-import { INTERNAL as INTERNAL2 } from "@aikirun/types/symbols";
-import { createORPCClient } from "@orpc/client";
-import { RPCLink } from "@orpc/client/fetch";
-import { Redis } from "ioredis";
-
-// logger/console-logger.ts
+// ../../lib/logger/console-logger.ts
 var colors = {
   reset: "\x1B[0m",
   dim: "\x1B[2m",
@@ -83,572 +76,10 @@ var ConsoleLogger = class _ConsoleLogger {
   }
 };
 
-// ../../lib/array/utils.ts
-function isNonEmptyArray(value) {
-  return value !== void 0 && value.length > 0;
-}
-function shuffleArray(array) {
-  const shuffledArray = Array.from(array);
-  for (let i = shuffledArray.length - 1; i > 0; i--) {
-    const j = Math.floor(Math.random() * (i + 1));
-    [shuffledArray[i], shuffledArray[j]] = [shuffledArray[j], shuffledArray[i]];
-  }
-  return shuffledArray;
-}
-function distributeRoundRobin(totalSize, itemCount) {
-  if (itemCount <= 0) return [];
-  const distribution = Array(itemCount).fill(0);
-  for (let i = 0; i < totalSize; i++) {
-    distribution[i % 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;
-  switch (strategyType) {
-    case "never":
-      return {
-        retriesLeft: false
-      };
-    case "fixed":
-      if (attempts >= strategy.maxAttempts) {
-        return {
-          retriesLeft: false
-        };
-      }
-      return {
-        retriesLeft: true,
-        delayMs: strategy.delayMs
-      };
-    case "exponential": {
-      if (attempts >= strategy.maxAttempts) {
-        return {
-          retriesLeft: false
-        };
-      }
-      const delayMs = strategy.baseDelayMs * (strategy.factor ?? 2) ** (attempts - 1);
-      return {
-        retriesLeft: true,
-        delayMs: Math.min(delayMs, strategy.maxDelayMs ?? Number.POSITIVE_INFINITY)
-      };
-    }
-    case "jittered": {
-      if (attempts >= strategy.maxAttempts) {
-        return {
-          retriesLeft: false
-        };
-      }
-      const base = strategy.baseDelayMs * (strategy.jitterFactor ?? 2) ** (attempts - 1);
-      const delayMs = Math.random() * base;
-      return {
-        retriesLeft: true,
-        delayMs: Math.min(delayMs, strategy.maxDelayMs ?? Number.POSITIVE_INFINITY)
-      };
-    }
-    default:
-      return strategyType;
-  }
-}
-
-// 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";
-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) {
-      const key = rawFields[i];
-      if (typeof key === "string") {
-        data[key] = rawFields[i + 1];
-      }
-    }
-  }
-  return data;
-};
-var streamMessageDataSchema = type({
-  type: "'workflow_run_ready'",
-  workflowRunId: "string > 0"
-});
-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({
-    "aiki.component": "redis-subscriber"
-  });
-  const streamConsumerGroupMap = getRedisStreamConsumerGroupMap(workflows, workerShards);
-  const streams = Array.from(streamConsumerGroupMap.keys());
-  const intervalMs = strategy.intervalMs ?? 50;
-  const maxRetryIntervalMs = strategy.maxRetryIntervalMs ?? 3e4;
-  const atCapacityIntervalMs = strategy.atCapacityIntervalMs ?? 50;
-  const blockTimeMs = strategy.blockTimeMs ?? 1e3;
-  const claimMinIdleTimeMs = strategy.claimMinIdleTimeMs ?? 9e4;
-  const getNextDelay = (params) => {
-    switch (params.type) {
-      case "polled":
-      case "heartbeat":
-        return intervalMs;
-      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;
-      }
-      case "at_capacity":
-        return atCapacityIntervalMs;
-      default:
-        return params;
-    }
-  };
-  return {
-    async init(workerId, _callbacks) {
-      for (const [stream, consumerGroup] of streamConsumerGroupMap) {
-        try {
-          await redis.xgroup("CREATE", stream, consumerGroup, "0", "MKSTREAM");
-        } catch (error) {
-          if (!error.message?.includes("BUSYGROUP")) {
-            throw error;
-          }
-        }
-      }
-      const pendingMessageMetaByWorkflowRunId = /* @__PURE__ */ new Map();
-      return {
-        type: strategy.type,
-        getNextDelay,
-        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);
-          }
-        }
-      };
-    }
-  };
-}
-function getRedisStreamConsumerGroupMap(workflows, shards) {
-  if (!shards || !isNonEmptyArray(shards)) {
-    return new Map(
-      workflows.map((workflow) => [
-        getWorkflowStreamName(workflow.name, workflow.versionId),
-        getWorkerConsumerGroupName(workflow.name, workflow.versionId)
-      ])
-    );
-  }
-  return new Map(
-    workflows.flatMap(
-      (workflow) => shards.map((shard) => [
-        getWorkflowStreamName(workflow.name, workflow.versionId, shard),
-        getWorkerConsumerGroupName(workflow.name, workflow.versionId, shard)
-      ])
-    )
-  );
-}
-async function fetchRedisStreamMessages(redis, logger, streams, streamConsumerGroupMap, workerId, size, blockTimeMs, claimMinIdleTimeMs) {
-  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 streamEntries = [];
-  for (let i = 0; i < shuffledStreams.length; i++) {
-    const stream = shuffledStreams[i];
-    if (!stream) {
-      continue;
-    }
-    const streamBatchSize = batchSizePerStream[i];
-    if (!streamBatchSize || streamBatchSize === 0) {
-      continue;
-    }
-    const consumerGroup = streamConsumerGroupMap.get(stream);
-    if (!consumerGroup) {
-      continue;
-    }
-    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) : [];
-  const remainingCapacity = size - workflowRuns.length;
-  if (remainingCapacity > 0 && claimMinIdleTimeMs > 0) {
-    const claimedWorkflowRuns = await claimStuckRedisStreamMessages(
-      redis,
-      logger,
-      shuffledStreams,
-      streamConsumerGroupMap,
-      workerId,
-      remainingCapacity,
-      claimMinIdleTimeMs
-    );
-    for (const workflowRun of claimedWorkflowRuns) {
-      workflowRuns.push(workflowRun);
-    }
-  }
-  return workflowRuns;
-}
-async function processRedisStreamMessages(redis, logger, streamConsumerGroupMap, streamsEntries) {
-  const workflowRuns = [];
-  for (const streamEntriesRaw of streamsEntries) {
-    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": streamEntriesResult.summary
-      });
-      continue;
-    }
-    for (const streamEntry of streamEntriesResult) {
-      const [stream, messages] = streamEntry;
-      const consumerGroup = streamConsumerGroupMap.get(stream);
-      if (!consumerGroup) {
-        logger.error("No consumer group found for stream", {
-          "aiki.stream": stream
-        });
-        continue;
-      }
-      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": messageData.summary
-          });
-          await redis.xack(stream, consumerGroup, messageId);
-          continue;
-        }
-        switch (messageData.type) {
-          case "workflow_run_ready": {
-            const workflowRunId = messageData.workflowRunId;
-            workflowRuns.push({
-              data: { workflowRunId },
-              meta: {
-                stream,
-                messageId,
-                consumerGroup
-              }
-            });
-            break;
-          }
-          default:
-            messageData.type;
-            continue;
-        }
-      }
-    }
-  }
-  return workflowRuns;
-}
-async function claimStuckRedisStreamMessages(redis, logger, shuffledStreams, streamConsumerGroupMap, workerId, maxClaim, minIdleMs) {
-  if (maxClaim <= 0 || minIdleMs <= 0) {
-    return [];
-  }
-  const claimaibleMessagesByStream = await findClaimableMessagesByStream(
-    redis,
-    logger,
-    shuffledStreams,
-    streamConsumerGroupMap,
-    workerId,
-    maxClaim,
-    minIdleMs
-  );
-  if (!claimaibleMessagesByStream.size) {
-    return [];
-  }
-  const claimPromises = Array.from(claimaibleMessagesByStream.entries()).map(async ([stream, messageIds]) => {
-    if (!messageIds.length) {
-      return null;
-    }
-    const consumerGroup = streamConsumerGroupMap.get(stream);
-    if (!consumerGroup) {
-      return null;
-    }
-    try {
-      const claimedMessages = await redis.xclaim(stream, consumerGroup, workerId, minIdleMs, ...messageIds);
-      return { stream, claimedMessages };
-    } catch (error) {
-      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.consumerGroup": consumerGroup
-        });
-      } else if (errorMessage.includes("BUSYGROUP")) {
-        logger.warn("Consumer group busy for stream, skipping claim operation", {
-          "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.consumerGroup": consumerGroup
-        });
-      } else {
-        logger.error("Failed to claim messages from stream", {
-          "aiki.stream": stream,
-          "aiki.consumerGroup": consumerGroup,
-          "aiki.messageIds": messageIds.length,
-          "aiki.error": errorMessage
-        });
-      }
-      return null;
-    }
-  });
-  const claimResults = await Promise.allSettled(claimPromises);
-  const claimedStreamEntries = [];
-  for (const result of claimResults) {
-    if (result.status === "fulfilled" && result.value !== null) {
-      const { stream, claimedMessages } = result.value;
-      claimedStreamEntries.push([stream, claimedMessages]);
-    }
-  }
-  if (!isNonEmptyArray(claimedStreamEntries)) {
-    return [];
-  }
-  return processRedisStreamMessages(redis, logger, streamConsumerGroupMap, [claimedStreamEntries]);
-}
-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++) {
-    const stream = shuffledStreams[i];
-    if (!stream) {
-      continue;
-    }
-    const claimSize = claimSizePerStream[i];
-    if (!claimSize || claimSize === 0) {
-      continue;
-    }
-    const consumerGroup = streamConsumerGroupMap.get(stream);
-    if (!consumerGroup) {
-      continue;
-    }
-    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 = streamPendingMessagesSchema(result);
-    if (parsedResult instanceof type.errors) {
-      logger.error("Invalid XPENDING response", {
-        "aiki.stream": stream,
-        "aiki.error": parsedResult.summary
-      });
-      continue;
-    }
-    const claimableStreamMessages = claimableMessagesByStream.get(stream) ?? [];
-    for (const [messageId, consumerName, _idleTimeMs, _deliveryCount] of parsedResult) {
-      if (consumerName !== workerId) {
-        claimableStreamMessages.push(messageId);
-      }
-    }
-    if (claimableStreamMessages.length) {
-      claimableMessagesByStream.set(stream, claimableStreamMessages);
-    }
-  }
-  return claimableMessagesByStream;
-}
-
-// subscribers/strategy-resolver.ts
-function resolveSubscriberStrategy(client2, strategy, workflows, workerShards) {
-  switch (strategy.type) {
-    case "redis":
-      return createRedisStreamsStrategy(client2, strategy, workflows, workerShards);
-    case "db":
-      return createDbStrategy(client2, strategy, workflows, workerShards);
-    default:
-      return strategy;
-  }
-}
-
 // client.ts
+import { INTERNAL } from "@aikirun/types/symbols";
+import { createORPCClient } from "@orpc/client";
+import { RPCLink } from "@orpc/client/fetch";
 function client(params) {
   return new ClientImpl(params);
 }
@@ -656,10 +87,7 @@ var ClientImpl = class {
   constructor(params) {
     this.params = params;
     this.logger = params.logger ?? new ConsoleLogger();
-    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 variable`);
-    }
+    const { apiKey } = params;
     const rpcLink = new RPCLink({
       url: `${params.url}/api`,
       headers: () => ({
@@ -670,42 +98,14 @@ var ClientImpl = class {
     this.logger.info("Aiki client initialized", {
       "aiki.url": params.url
     });
-    this[INTERNAL2] = {
-      subscriber: {
-        create: (strategy, workflows, workerShards) => resolveSubscriberStrategy(this, strategy, workflows, workerShards)
-      },
-      redis: {
-        getConnection: () => this.getRedisConnection(),
-        closeConnection: () => this.closeRedisConnection()
-      },
+    this[INTERNAL] = {
       createContext: this.params.createContext
     };
   }
   api;
-  [INTERNAL2];
+  [INTERNAL];
   logger;
-  redisConnection;
-  async close() {
-    this.logger.info("Closing Aiki client");
-    await this.closeRedisConnection();
-  }
-  getRedisConnection() {
-    if (!this.redisConnection) {
-      if (!this.params.redis) {
-        throw new Error("Redis configuration not provided to client. Add 'redis' to ClientParams.");
-      }
-      this.redisConnection = new Redis(this.params.redis);
-    }
-    return this.redisConnection;
-  }
-  async closeRedisConnection() {
-    if (this.redisConnection) {
-      this.redisConnection.disconnect();
-      this.redisConnection = void 0;
-    }
-  }
 };
 export {
-  ConsoleLogger,
   client
 };

package/package.json

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