@aikirun/client 0.5.3

package/README.md

@@ -0,0 +1,120 @@
+# @aikirun/client
+
+Client SDK for Aiki durable execution platform - connect to the Aiki server, start workflows, and manage execution.
+
+## Installation
+
+```bash
+npm install @aikirun/client
+```
+
+## Quick Start
+
+### Initialize the Client
+
+```typescript
+import { client } from "@aikirun/client";
+
+const aikiClient = await client({
+	url: "http://localhost:9090",
+	redis: {
+		host: "localhost",
+		port: 6379,
+	},
+});
+```
+
+### Start a Workflow
+
+```typescript
+import { onboardingWorkflowV1 } from "./workflows.ts";
+
+const stateHandle = await onboardingWorkflowV1.start(aikiClient, {
+	email: "user@example.com",
+});
+```
+
+### Wait for Workflow Completion
+
+```typescript
+const result = await stateHandle.wait(
+	{ type: "status", status: "completed" },
+	{ maxDurationMs: 60_000, pollIntervalMs: 5_000 },
+);
+
+if (result.success) {
+	console.log("Workflow completed!");
+} else {
+	console.log("Workflow did not complete:", result.cause);
+}
+```
+
+### Get Workflow State
+
+```typescript
+const state = await stateHandle.getState();
+console.log("Current status:", state.status);
+```
+
+## Features
+
+- **Reliable Connection** - HTTP client with automatic retry and connection pooling
+- **Workflow Management** - Start workflows with type-safe inputs
+- **State Polling** - Wait for workflow completion with configurable polling
+- **Logger** - Built-in logging for debugging
+- **Context Factory** - Pass application context through workflow execution
+- **Redis Integration** - Connect to Redis for distributed state management
+
+## Configuration
+
+### Client Parameters
+
+```typescript
+interface ClientParams<AppContext> {
+	url: string; // Server URL
+	redis: {
+		host: string;
+		port: number;
+		password?: string;
+		db?: number;
+		maxRetriesPerRequest?: number;
+		retryDelayOnFailoverMs?: number;
+		connectTimeoutMs?: number;
+	};
+	contextFactory?: (run: WorkflowRun) => AppContext | Promise<AppContext>;
+	logger?: Logger;
+}
+```
+
+### Context Factory Example
+
+```typescript
+const aikiClient = await client({
+	url: "http://localhost:9090",
+	redis: { host: "localhost", port: 6379 },
+	contextFactory: (run) => ({
+		traceId: generateTraceId(),
+		workflowRunId: run.id,
+		userId: extractUserIdFromRun(run),
+	}),
+});
+```
+
+## API Reference
+
+See the [Aiki documentation](https://github.com/aikirun/aiki) for comprehensive API reference.
+
+## Related Packages
+
+- [@aikirun/workflow](https://www.npmjs.com/package/@aikirun/workflow) - Define workflows
+- [@aikirun/task](https://www.npmjs.com/package/@aikirun/task) - Define tasks
+- [@aikirun/worker](https://www.npmjs.com/package/@aikirun/worker) - Execute workflows
+- [@aikirun/types](https://www.npmjs.com/package/@aikirun/types) - Type definitions
+
+## Changelog
+
+See the [CHANGELOG](https://github.com/aikirun/aiki/blob/main/CHANGELOG.md) for version history.
+
+## License
+
+Apache-2.0

package/dist/index.d.ts

@@ -0,0 +1,59 @@
+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';
+
+/**
+ * Creates an Aiki client for starting and managing workflows.
+ *
+ * The client connects to the Aiki server via HTTP and Redis for state management.
+ * 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:9090")
+ * @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.contextFactory - 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
+ *
+ * @example
+ * ```typescript
+ * const aikiClient = await client({
+ *   url: "http://localhost:9090",
+ *   redis: { host: "localhost", port: 6379 },
+ *   contextFactory: (run) => ({
+ *     traceId: generateTraceId(),
+ *     userId: extractUserId(run),
+ *   }),
+ * });
+ *
+ * // Start a workflow
+ * const handle = await myWorkflow.start(aikiClient, { email: "user@example.com" });
+ *
+ * // Wait for completion
+ * const result = await handle.wait(
+ *   { type: "status", status: "completed" },
+ *   { maxDurationMs: 60_000 }
+ * );
+ *
+ * // Cleanup
+ * await aikiClient.close();
+ * ```
+ */
+declare function client<AppContext = null>(params: ClientParams<AppContext>): Promise<Client<AppContext>>;
+
+declare class ConsoleLogger implements Logger {
+    private readonly context;
+    constructor(context?: Record<string, unknown>);
+    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 };

package/dist/index.js

@@ -0,0 +1,559 @@
+// client.ts
+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
+var ConsoleLogger = class _ConsoleLogger {
+  constructor(context = {}) {
+    this.context = context;
+  }
+  trace(message, metadata) {
+    console.debug(this.format("TRACE", message, metadata));
+  }
+  debug(message, metadata) {
+    console.debug(this.format("DEBUG", message, metadata));
+  }
+  info(message, metadata) {
+    console.info(this.format("INFO", message, metadata));
+  }
+  warn(message, metadata) {
+    console.warn(this.format("WARN", message, metadata));
+  }
+  error(message, metadata) {
+    console.error(this.format("ERROR", message, metadata));
+  }
+  child(bindings) {
+    return new _ConsoleLogger({ ...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}`;
+  }
+};
+
+// ../../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;
+}
+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/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/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) => {
+  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 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);
+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 ?? 18e4;
+  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;
+    }
+  };
+  const getHeartbeat = (workerId) => async (workflowRunId, meta) => {
+    try {
+      await redis.xclaim(meta.stream, meta.consumerGroup, workerId, 0, meta.messageId, "JUSTID");
+      logger.debug("Heartbeat sent", {
+        "aiki.workflowRunId": workflowRunId,
+        "aiki.messageId": meta.messageId
+      });
+    } catch (error) {
+      logger.warn("Heartbeat failed", {
+        "aiki.workflowRunId": workflowRunId,
+        "aiki.error": error instanceof Error ? error.message : String(error)
+      });
+    }
+  };
+  const acknowledge = async (workflowRunId, meta) => {
+    try {
+      const result = await redis.xack(meta.stream, meta.consumerGroup, meta.messageId);
+      if (result === 0) {
+        logger.warn("Message already acknowledged", {
+          "aiki.workflowRunId": workflowRunId,
+          "aiki.messageId": meta.messageId
+        });
+      } else {
+        logger.debug("Message acknowledged", {
+          "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.workflowRunId": workflowRunId,
+        "aiki.messageId": meta.messageId
+      });
+      throw error;
+    }
+  };
+  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;
+          }
+        }
+      }
+      return {
+        type: strategy.type,
+        getNextDelay,
+        getNextBatch: (size) => fetchRedisStreamMessages(
+          redis,
+          logger,
+          streams,
+          streamConsumerGroupMap,
+          workerId,
+          size,
+          blockTimeMs,
+          claimMinIdleTimeMs
+        ),
+        heartbeat: getHeartbeat(workerId),
+        acknowledge
+      };
+    }
+  };
+}
+function getRedisStreamConsumerGroupMap(workflows, shardKeys) {
+  if (!shardKeys || !isNonEmptyArray(shardKeys)) {
+    return new Map(
+      workflows.map((workflow) => [
+        `workflow/${workflow.id}/${workflow.versionId}`,
+        `worker/${workflow.id}/${workflow.versionId}`
+      ])
+    );
+  }
+  return new Map(
+    workflows.flatMap(
+      (workflow) => shardKeys.map((shardKey) => [
+        `workflow/${workflow.id}/${workflow.versionId}/${shardKey}`,
+        `worker/${workflow.id}/${workflow.versionId}/${shardKey}`
+      ])
+    )
+  );
+}
+async function fetchRedisStreamMessages(redis, logger, streams, streamConsumerGroupMap, workerId, size, blockTimeMs, claimMinIdleTimeMs) {
+  if (!isNonEmptyArray(streams)) {
+    return [];
+  }
+  const batchSizePerStream = distributeRoundRobin(size, streams.length);
+  const shuffledStreams = shuffleArray(streams);
+  const readPromises = [];
+  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;
+    }
+    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);
+    }
+  }
+  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", { entries: streamEntriesRaw });
+    const streamEntriesResult = RedisStreamEntriesSchema.safeParse(streamEntriesRaw);
+    if (!streamEntriesResult.success) {
+      logger.error("Invalid stream entries format", {
+        "aiki.error": z.treeifyError(streamEntriesResult.error)
+      });
+      continue;
+    }
+    for (const streamEntry of streamEntriesResult.data) {
+      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, rawMessageData] of messages) {
+        const messageData = RedisMessageDataSchema.safeParse(rawMessageData);
+        if (!messageData.success) {
+          logger.warn("Invalid message structure", {
+            "aiki.stream": stream,
+            "aiki.messageId": messageId,
+            "aiki.error": z.treeifyError(messageData.error)
+          });
+          await redis.xack(stream, consumerGroup, messageId);
+          continue;
+        }
+        switch (messageData.data.type) {
+          case "workflow_run_ready": {
+            const { workflowRunId } = messageData.data;
+            workflowRuns.push({
+              data: { workflowRunId },
+              meta: {
+                stream,
+                messageId,
+                consumerGroup
+              }
+            });
+            break;
+          }
+          default:
+            messageData.data.type;
+            continue;
+        }
+      }
+    }
+  }
+  return workflowRuns;
+}
+async function claimStuckRedisStreamMessages(redis, logger, shuffledStreams, streamConsumerGroupMap, workerId, maxClaim, minIdleMs) {
+  if (maxClaim <= 0 || minIdleMs <= 0) {
+    return [];
+  }
+  const claimableMessages = await findClaimableRedisStreamMessages(
+    redis,
+    logger,
+    shuffledStreams,
+    streamConsumerGroupMap,
+    workerId,
+    maxClaim,
+    minIdleMs
+  );
+  if (!isNonEmptyArray(claimableMessages)) {
+    return [];
+  }
+  const claimaibleMessagesByStream = groupBy(claimableMessages, (message) => [message.stream, message]);
+  const claimPromises = Array.from(claimaibleMessagesByStream.entries()).map(async ([stream, messages]) => {
+    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 };
+    } 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
+        });
+      } else if (errorMessage.includes("BUSYGROUP")) {
+        logger.warn("Consumer group busy for stream, skipping claim operation", {
+          "aiki.stream": stream
+        });
+      } else if (errorMessage.includes("NOSCRIPT")) {
+        logger.warn("Redis script not loaded for stream, skipping claim operation", {
+          "aiki.stream": stream
+        });
+      } else {
+        logger.error("Failed to claim messages from stream", {
+          "aiki.error": errorMessage,
+          "aiki.messageIds": messageIds.length,
+          "aiki.workerId": workerId,
+          "aiki.consumerGroup": consumerGroup,
+          "aiki.stream": stream
+        });
+      }
+      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 findClaimableRedisStreamMessages(redis, logger, shuffledStreams, streamConsumerGroupMap, workerId, maxClaim, minIdleMs) {
+  const claimableMessages = [];
+  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 pendingPromise = redis.xpending(stream, consumerGroup, "IDLE", minIdleMs, "-", "+", claimSize).then((result) => ({ stream, result }));
+    pendingPromises.push(pendingPromise);
+  }
+  const pendingResults = await Promise.allSettled(pendingPromises);
+  for (const pendingResult of pendingResults) {
+    if (pendingResult.status !== "fulfilled") {
+      continue;
+    }
+    const { stream, result } = pendingResult.value;
+    const parsedResult = RedisStreamPendingMessagesSchema.safeParse(result);
+    if (!parsedResult.success) {
+      logger.error("Invalid XPENDING response", {
+        "aiki.stream": stream,
+        "aiki.error": z.treeifyError(parsedResult.error)
+      });
+      continue;
+    }
+    for (const [messageId, consumerName, _idleTimeMs, _deliveryCount] of parsedResult.data) {
+      if (consumerName === workerId) {
+        continue;
+      }
+      claimableMessages.push({ stream, messageId });
+    }
+  }
+  return claimableMessages;
+}
+
+// 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_streams":
+      return createRedisStreamsStrategy(client2, strategy, workflows, workerShards);
+    default:
+      return strategy.type;
+  }
+}
+
+// client.ts
+function client(params) {
+  return Promise.resolve(new ClientImpl(params));
+}
+var ClientImpl = class {
+  constructor(params) {
+    this.params = params;
+    this.logger = params.logger ?? new ConsoleLogger();
+    const rpcLink = new RPCLink({ url: `${params.url}` });
+    this.api = createORPCClient(rpcLink);
+    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()
+      },
+      contextFactory: this.params.contextFactory
+    };
+  }
+  api;
+  [INTERNAL2];
+  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) {
+      await this.redisConnection.quit();
+      this.redisConnection = void 0;
+    }
+  }
+};
+export {
+  ConsoleLogger,
+  client
+};

package/package.json

@@ -0,0 +1,30 @@
+{
+	"name": "@aikirun/client",
+	"version": "0.5.3",
+	"description": "Client SDK for Aiki - connect to the server, start workflows, and manage execution",
+	"type": "module",
+	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js"
+		}
+	},
+	"files": [
+		"dist"
+	],
+	"scripts": {
+		"build": "tsup"
+	},
+	"dependencies": {
+		"@aikirun/types": "0.5.3",
+		"@orpc/client": "^1.9.3",
+		"ioredis": "^5.4.1",
+		"zod": "^4.1.12"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"license": "Apache-2.0"
+}