happy-coder 0.1.9 → 0.1.11

package/dist/types-tLWMaptR.mjs

@@ -0,0 +1,879 @@
+import axios from 'axios';
+import chalk from 'chalk';
+import { appendFileSync } from 'fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { mkdir } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { EventEmitter } from 'node:events';
+import { io } from 'socket.io-client';
+import { z } from 'zod';
+import { randomBytes } from 'node:crypto';
+import tweetnacl from 'tweetnacl';
+import { Expo } from 'expo-server-sdk';
+
+class Configuration {
+  serverUrl;
+  // Directories and paths (from persistence)
+  happyDir;
+  logsDir;
+  settingsFile;
+  privateKeyFile;
+  constructor(location) {
+    this.serverUrl = process.env.HANDY_SERVER_URL || "https://handy-api.korshakov.org";
+    if (location === "local") {
+      this.happyDir = join(process.cwd(), ".happy");
+    } else {
+      this.happyDir = join(homedir(), ".happy");
+    }
+    this.logsDir = join(this.happyDir, "logs");
+    this.settingsFile = join(this.happyDir, "settings.json");
+    this.privateKeyFile = join(this.happyDir, "access.key");
+  }
+}
+let configuration = void 0;
+function initializeConfiguration(location) {
+  configuration = new Configuration(location);
+}
+
+async function getSessionLogPath() {
+  if (!existsSync(configuration.logsDir)) {
+    await mkdir(configuration.logsDir, { recursive: true });
+  }
+  const now = /* @__PURE__ */ new Date();
+  const timestamp = now.toLocaleString("sv-SE", {
+    timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit"
+  }).replace(/[: ]/g, "-").replace(/,/g, "");
+  return join(configuration.logsDir, `${timestamp}.log`);
+}
+class Logger {
+  constructor(logFilePathPromise = getSessionLogPath()) {
+    this.logFilePathPromise = logFilePathPromise;
+  }
+  // Use local timezone for simplicity of locating the logs,
+  // in practice you will not need absolute timestamps
+  localTimezoneTimestamp() {
+    return (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", {
+      timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+      hour12: false,
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit",
+      fractionalSecondDigits: 3
+    });
+  }
+  debug(message, ...args) {
+    this.logToFile(`[${this.localTimezoneTimestamp()}]`, message, ...args);
+  }
+  debugLargeJson(message, object, maxStringLength = 100, maxArrayLength = 10) {
+    if (!process.env.DEBUG) {
+      this.debug(`In production, skipping message inspection`);
+    }
+    const truncateStrings = (obj) => {
+      if (typeof obj === "string") {
+        return obj.length > maxStringLength ? obj.substring(0, maxStringLength) + "... [truncated for logs]" : obj;
+      }
+      if (Array.isArray(obj)) {
+        const truncatedArray = obj.map((item) => truncateStrings(item)).slice(0, maxArrayLength);
+        if (obj.length > maxArrayLength) {
+          truncatedArray.push(`... [truncated array for logs up to ${maxArrayLength} items]`);
+        }
+        return truncatedArray;
+      }
+      if (obj && typeof obj === "object") {
+        const result = {};
+        for (const [key, value] of Object.entries(obj)) {
+          if (key === "usage") {
+            continue;
+          }
+          result[key] = truncateStrings(value);
+        }
+        return result;
+      }
+      return obj;
+    };
+    const truncatedObject = truncateStrings(object);
+    const json = JSON.stringify(truncatedObject, null, 2);
+    this.logToFile(`[${this.localTimezoneTimestamp()}]`, message, "\n", json);
+  }
+  info(message, ...args) {
+    this.logToConsole("info", "", message, ...args);
+    this.debug(message, args);
+  }
+  infoDeveloper(message, ...args) {
+    this.debug(message, ...args);
+    if (process.env.DEBUG) {
+      this.logToConsole("info", "[DEV]", message, ...args);
+    }
+  }
+  logToConsole(level, prefix, message, ...args) {
+    switch (level) {
+      case "debug": {
+        console.log(chalk.gray(prefix), message, ...args);
+        break;
+      }
+      case "error": {
+        console.error(chalk.red(prefix), message, ...args);
+        break;
+      }
+      case "info": {
+        console.log(chalk.blue(prefix), message, ...args);
+        break;
+      }
+      case "warn": {
+        console.log(chalk.yellow(prefix), message, ...args);
+        break;
+      }
+      default: {
+        this.debug("Unknown log level:", level);
+        console.log(chalk.blue(prefix), message, ...args);
+        break;
+      }
+    }
+  }
+  logToFile(prefix, message, ...args) {
+    const logLine = `${prefix} ${message} ${args.map(
+      (arg) => typeof arg === "string" ? arg : JSON.stringify(arg)
+    ).join(" ")}
+`;
+    this.logFilePathPromise.then((logFilePath) => {
+      try {
+        appendFileSync(logFilePath, logLine);
+      } catch (appendError) {
+        if (process.env.DEBUG) {
+          console.error("Failed to append to log file:", appendError);
+          throw appendError;
+        }
+      }
+    }).catch((error) => {
+      if (process.env.DEBUG) {
+        console.log("This message only visible in DEBUG mode, not in production");
+        console.error("Failed to resolve log file path:", error);
+        console.log(prefix, message, ...args);
+      }
+    });
+  }
+}
+let logger;
+function initLoggerWithGlobalConfiguration() {
+  logger = new Logger();
+  if (process.env.DEBUG) {
+    logger.logFilePathPromise.then((logPath) => {
+      logger.info(chalk.yellow("[DEBUG MODE] Debug logging enabled"));
+      logger.info(chalk.gray(`Log file: ${logPath}`));
+    });
+  }
+}
+
+const SessionMessageContentSchema = z.object({
+  c: z.string(),
+  // Base64 encoded encrypted content
+  t: z.literal("encrypted")
+});
+const UpdateBodySchema = z.object({
+  message: z.object({
+    id: z.string(),
+    seq: z.number(),
+    content: SessionMessageContentSchema
+  }),
+  sid: z.string(),
+  // Session ID
+  t: z.literal("new-message")
+});
+const UpdateSessionBodySchema = z.object({
+  t: z.literal("update-session"),
+  sid: z.string(),
+  metadata: z.object({
+    version: z.number(),
+    metadata: z.string()
+  }).nullish(),
+  agentState: z.object({
+    version: z.number(),
+    agentState: z.string()
+  }).nullish()
+});
+z.object({
+  id: z.string(),
+  seq: z.number(),
+  body: z.union([UpdateBodySchema, UpdateSessionBodySchema]),
+  createdAt: z.number()
+});
+z.object({
+  createdAt: z.number(),
+  id: z.string(),
+  seq: z.number(),
+  updatedAt: z.number(),
+  metadata: z.any(),
+  metadataVersion: z.number(),
+  agentState: z.any().nullable(),
+  agentStateVersion: z.number()
+});
+z.object({
+  content: SessionMessageContentSchema,
+  createdAt: z.number(),
+  id: z.string(),
+  seq: z.number(),
+  updatedAt: z.number()
+});
+z.object({
+  session: z.object({
+    id: z.string(),
+    tag: z.string(),
+    seq: z.number(),
+    createdAt: z.number(),
+    updatedAt: z.number(),
+    metadata: z.string(),
+    metadataVersion: z.number(),
+    agentState: z.string().nullable(),
+    agentStateVersion: z.number()
+  })
+});
+const UserMessageSchema$1 = z.object({
+  role: z.literal("user"),
+  content: z.object({
+    type: z.literal("text"),
+    text: z.string()
+  }),
+  localKey: z.string().optional(),
+  // Mobile messages include this
+  sentFrom: z.enum(["mobile", "cli"]).optional()
+  // Source identifier
+});
+const AgentMessageSchema = z.object({
+  role: z.literal("agent"),
+  content: z.object({
+    type: z.literal("output"),
+    data: z.any()
+  })
+});
+z.union([UserMessageSchema$1, AgentMessageSchema]);
+
+function encodeBase64(buffer, variant = "base64") {
+  if (variant === "base64url") {
+    return encodeBase64Url(buffer);
+  }
+  return Buffer.from(buffer).toString("base64");
+}
+function encodeBase64Url(buffer) {
+  return Buffer.from(buffer).toString("base64").replaceAll("+", "-").replaceAll("/", "_").replaceAll("=", "");
+}
+function decodeBase64(base64, variant = "base64") {
+  if (variant === "base64url") {
+    const base64Standard = base64.replaceAll("-", "+").replaceAll("_", "/") + "=".repeat((4 - base64.length % 4) % 4);
+    return new Uint8Array(Buffer.from(base64Standard, "base64"));
+  }
+  return new Uint8Array(Buffer.from(base64, "base64"));
+}
+function getRandomBytes(size) {
+  return new Uint8Array(randomBytes(size));
+}
+function encrypt(data, secret) {
+  const nonce = getRandomBytes(tweetnacl.secretbox.nonceLength);
+  const encrypted = tweetnacl.secretbox(new TextEncoder().encode(JSON.stringify(data)), nonce, secret);
+  const result = new Uint8Array(nonce.length + encrypted.length);
+  result.set(nonce);
+  result.set(encrypted, nonce.length);
+  return result;
+}
+function decrypt(data, secret) {
+  const nonce = data.slice(0, tweetnacl.secretbox.nonceLength);
+  const encrypted = data.slice(tweetnacl.secretbox.nonceLength);
+  const decrypted = tweetnacl.secretbox.open(encrypted, nonce, secret);
+  if (!decrypted) {
+    return null;
+  }
+  return JSON.parse(new TextDecoder().decode(decrypted));
+}
+
+async function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function exponentialBackoffDelay(currentFailureCount, minDelay, maxDelay, maxFailureCount) {
+  let maxDelayRet = minDelay + (maxDelay - minDelay) / maxFailureCount * Math.max(currentFailureCount, maxFailureCount);
+  return Math.round(Math.random() * maxDelayRet);
+}
+function createBackoff(opts) {
+  return async (callback) => {
+    let currentFailureCount = 0;
+    const minDelay = 250;
+    const maxDelay = 1e3;
+    const maxFailureCount = 50;
+    while (true) {
+      try {
+        return await callback();
+      } catch (e) {
+        if (currentFailureCount < maxFailureCount) {
+          currentFailureCount++;
+        }
+        let waitForRequest = exponentialBackoffDelay(currentFailureCount, minDelay, maxDelay, maxFailureCount);
+        await delay(waitForRequest);
+      }
+    }
+  };
+}
+let backoff = createBackoff();
+
+class ApiSessionClient extends EventEmitter {
+  token;
+  secret;
+  sessionId;
+  metadata;
+  metadataVersion;
+  agentState;
+  agentStateVersion;
+  socket;
+  pendingMessages = [];
+  pendingMessageCallback = null;
+  rpcHandlers = /* @__PURE__ */ new Map();
+  constructor(token, secret, session) {
+    super();
+    this.token = token;
+    this.secret = secret;
+    this.sessionId = session.id;
+    this.metadata = session.metadata;
+    this.metadataVersion = session.metadataVersion;
+    this.agentState = session.agentState;
+    this.agentStateVersion = session.agentStateVersion;
+    this.socket = io(configuration.serverUrl, {
+      auth: {
+        token: this.token,
+        clientType: "session-scoped",
+        sessionId: this.sessionId
+      },
+      path: "/v1/updates",
+      reconnection: true,
+      reconnectionAttempts: Infinity,
+      reconnectionDelay: 1e3,
+      reconnectionDelayMax: 5e3,
+      transports: ["websocket"],
+      withCredentials: true,
+      autoConnect: false
+    });
+    this.socket.on("connect", () => {
+      logger.debug("Socket connected successfully");
+      this.reregisterHandlers();
+    });
+    this.socket.on("rpc-request", async (data, callback) => {
+      try {
+        const method = data.method;
+        const handler = this.rpcHandlers.get(method);
+        if (!handler) {
+          logger.debug("[SOCKET] [RPC] [ERROR] method not found", { method });
+          const errorResponse = { error: "Method not found" };
+          const encryptedError = encodeBase64(encrypt(errorResponse, this.secret));
+          callback(encryptedError);
+          return;
+        }
+        const decryptedParams = decrypt(decodeBase64(data.params), this.secret);
+        const result = await handler(decryptedParams);
+        const encryptedResponse = encodeBase64(encrypt(result, this.secret));
+        callback(encryptedResponse);
+      } catch (error) {
+        logger.debug("[SOCKET] [RPC] [ERROR] Error handling RPC request", { error });
+        const errorResponse = { error: error instanceof Error ? error.message : "Unknown error" };
+        const encryptedError = encodeBase64(encrypt(errorResponse, this.secret));
+        callback(encryptedError);
+      }
+    });
+    this.socket.on("disconnect", (reason) => {
+      logger.debug("[API] Socket disconnected:", reason);
+    });
+    this.socket.on("connect_error", (error) => {
+      logger.debug("[API] Socket connection error:", error);
+    });
+    this.socket.on("update", (data) => {
+      try {
+        logger.debugLargeJson("[SOCKET] [UPDATE] Received update:", data);
+        if (!data.body) {
+          logger.debug("[SOCKET] [UPDATE] [ERROR] No body in update!");
+          return;
+        }
+        if (data.body.t === "new-message" && data.body.message.content.t === "encrypted") {
+          const body = decrypt(decodeBase64(data.body.message.content.c), this.secret);
+          logger.debugLargeJson("[SOCKET] [UPDATE] Received update:", body);
+          const userResult = UserMessageSchema$1.safeParse(body);
+          if (userResult.success) {
+            if (this.pendingMessageCallback) {
+              this.pendingMessageCallback(userResult.data);
+            } else {
+              this.pendingMessages.push(userResult.data);
+            }
+          } else {
+            this.emit("message", body);
+          }
+        } else if (data.body.t === "update-session") {
+          if (data.body.metadata && data.body.metadata.version > this.metadataVersion) {
+            this.metadata = decrypt(decodeBase64(data.body.metadata.metadata), this.secret);
+            this.metadataVersion = data.body.metadata.version;
+          }
+          if (data.body.agentState && data.body.agentState.version > this.agentStateVersion) {
+            this.agentState = data.body.agentState.agentState ? decrypt(decodeBase64(data.body.agentState.agentState), this.secret) : null;
+            this.agentStateVersion = data.body.agentState.version;
+          }
+        }
+      } catch (error) {
+        logger.debug("[SOCKET] [UPDATE] [ERROR] Error handling update", { error });
+      }
+    });
+    this.socket.on("error", (error) => {
+      logger.debug("[API] Socket error:", error);
+    });
+    this.socket.connect();
+  }
+  onUserMessage(callback) {
+    this.pendingMessageCallback = callback;
+    while (this.pendingMessages.length > 0) {
+      callback(this.pendingMessages.shift());
+    }
+  }
+  /**
+   * Send message to session
+   * @param body - Message body (can be MessageContent or raw content for agent messages)
+   */
+  sendClaudeSessionMessage(body) {
+    let content;
+    if (body.type === "user" && typeof body.message.content === "string") {
+      content = {
+        role: "user",
+        content: {
+          type: "text",
+          text: body.message.content
+        }
+      };
+    } else {
+      content = {
+        role: "agent",
+        content: {
+          type: "output",
+          data: body
+          // This wraps the entire Claude message
+        }
+      };
+    }
+    logger.debugLargeJson("[SOCKET] Sending message through socket:", content);
+    const encrypted = encodeBase64(encrypt(content, this.secret));
+    this.socket.emit("message", {
+      sid: this.sessionId,
+      message: encrypted
+    });
+    if (body.type === "assistant" && body.message.usage) {
+      try {
+        this.sendUsageData(body.message.usage);
+      } catch (error) {
+        logger.debug("[SOCKET] Failed to send usage data:", error);
+      }
+    }
+    if (body.type === "summary" && "summary" in body && "leafUuid" in body) {
+      this.updateMetadata((metadata) => ({
+        ...metadata,
+        summary: {
+          text: body.summary,
+          updatedAt: Date.now()
+        }
+      }));
+    }
+  }
+  /**
+   * Send a ping message to keep the connection alive
+   */
+  keepAlive(thinking) {
+    this.socket.volatile.emit("session-alive", {
+      sid: this.sessionId,
+      time: Date.now(),
+      thinking
+    });
+  }
+  /**
+   * Send session death message
+   */
+  sendSessionDeath() {
+    this.socket.emit("session-end", { sid: this.sessionId, time: Date.now() });
+  }
+  /**
+   * Send usage data to the server
+   */
+  sendUsageData(usage) {
+    const totalTokens = usage.input_tokens + usage.output_tokens + (usage.cache_creation_input_tokens || 0) + (usage.cache_read_input_tokens || 0);
+    const usageReport = {
+      key: "claude-session",
+      sessionId: this.sessionId,
+      tokens: {
+        total: totalTokens,
+        input: usage.input_tokens,
+        output: usage.output_tokens,
+        cache_creation: usage.cache_creation_input_tokens || 0,
+        cache_read: usage.cache_read_input_tokens || 0
+      },
+      cost: {
+        // TODO: Calculate actual costs based on pricing
+        // For now, using placeholder values
+        total: 0,
+        input: 0,
+        output: 0
+      }
+    };
+    logger.debugLargeJson("[SOCKET] Sending usage data:", usageReport);
+    this.socket.emit("usage-report", usageReport);
+  }
+  /**
+   * Update session metadata
+   * @param handler - Handler function that returns the updated metadata
+   */
+  updateMetadata(handler) {
+    backoff(async () => {
+      let updated = handler(this.metadata);
+      const answer = await this.socket.emitWithAck("update-metadata", { sid: this.sessionId, expectedVersion: this.metadataVersion, metadata: encodeBase64(encrypt(updated, this.secret)) });
+      if (answer.result === "success") {
+        this.metadata = decrypt(decodeBase64(answer.metadata), this.secret);
+        this.metadataVersion = answer.version;
+      } else if (answer.result === "version-mismatch") {
+        if (answer.version > this.metadataVersion) {
+          this.metadataVersion = answer.version;
+          this.metadata = decrypt(decodeBase64(answer.metadata), this.secret);
+        }
+        throw new Error("Metadata version mismatch");
+      } else if (answer.result === "error") ;
+    });
+  }
+  /**
+   * Update session agent state
+   * @param handler - Handler function that returns the updated agent state
+   */
+  updateAgentState(handler) {
+    console.log("Updating agent state", this.agentState);
+    backoff(async () => {
+      let updated = handler(this.agentState || {});
+      const answer = await this.socket.emitWithAck("update-state", { sid: this.sessionId, expectedVersion: this.agentStateVersion, agentState: updated ? encodeBase64(encrypt(updated, this.secret)) : null });
+      if (answer.result === "success") {
+        this.agentState = answer.agentState ? decrypt(decodeBase64(answer.agentState), this.secret) : null;
+        this.agentStateVersion = answer.version;
+        console.log("Agent state updated", this.agentState);
+      } else if (answer.result === "version-mismatch") {
+        if (answer.version > this.agentStateVersion) {
+          this.agentStateVersion = answer.version;
+          this.agentState = answer.agentState ? decrypt(decodeBase64(answer.agentState), this.secret) : null;
+        }
+        throw new Error("Agent state version mismatch");
+      } else if (answer.result === "error") {
+        console.error("Agent state update error", answer);
+      }
+    });
+  }
+  /**
+   * Set a custom RPC handler for a specific method with encrypted arguments and responses
+   * @param method - The method name to handle
+   * @param handler - The handler function to call when the method is invoked
+   */
+  setHandler(method, handler) {
+    const prefixedMethod = `${this.sessionId}:${method}`;
+    this.rpcHandlers.set(prefixedMethod, handler);
+    this.socket.emit("rpc-register", { method: prefixedMethod });
+    logger.debug("Registered RPC handler", { method, prefixedMethod });
+  }
+  /**
+   * Re-register all RPC handlers after reconnection
+   */
+  reregisterHandlers() {
+    logger.debug("Re-registering RPC handlers after reconnection", {
+      totalMethods: this.rpcHandlers.size
+    });
+    for (const [prefixedMethod] of this.rpcHandlers) {
+      this.socket.emit("rpc-register", { method: prefixedMethod });
+      logger.debug("Re-registered method", { prefixedMethod });
+    }
+  }
+  /**
+   * Wait for socket buffer to flush
+   */
+  async flush() {
+    if (!this.socket.connected) {
+      return;
+    }
+    return new Promise((resolve) => {
+      this.socket.emit("ping", () => {
+        resolve();
+      });
+      setTimeout(() => {
+        resolve();
+      }, 1e4);
+    });
+  }
+  async close() {
+    this.socket.close();
+  }
+}
+
+class PushNotificationClient {
+  token;
+  baseUrl;
+  expo;
+  constructor(token, baseUrl = "https://handy-api.korshakov.org") {
+    this.token = token;
+    this.baseUrl = baseUrl;
+    this.expo = new Expo();
+  }
+  /**
+   * Fetch all push tokens for the authenticated user
+   */
+  async fetchPushTokens() {
+    try {
+      const response = await axios.get(
+        `${this.baseUrl}/v1/push-tokens`,
+        {
+          headers: {
+            "Authorization": `Bearer ${this.token}`,
+            "Content-Type": "application/json"
+          }
+        }
+      );
+      logger.info(`Fetched ${response.data.tokens.length} push tokens`);
+      return response.data.tokens;
+    } catch (error) {
+      logger.debug("[PUSH] [ERROR] Failed to fetch push tokens:", error);
+      throw new Error(`Failed to fetch push tokens: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  /**
+   * Send push notification via Expo Push API with retry
+   * @param messages - Array of push messages to send
+   */
+  async sendPushNotifications(messages) {
+    logger.info(`Sending ${messages.length} push notifications`);
+    const validMessages = messages.filter((message) => {
+      if (Array.isArray(message.to)) {
+        return message.to.every((token) => Expo.isExpoPushToken(token));
+      }
+      return Expo.isExpoPushToken(message.to);
+    });
+    if (validMessages.length === 0) {
+      logger.info("No valid Expo push tokens found");
+      return;
+    }
+    const chunks = this.expo.chunkPushNotifications(validMessages);
+    for (const chunk of chunks) {
+      const startTime = Date.now();
+      const timeout = 3e5;
+      let attempt = 0;
+      while (true) {
+        try {
+          const ticketChunk = await this.expo.sendPushNotificationsAsync(chunk);
+          const errors = ticketChunk.filter((ticket) => ticket.status === "error");
+          if (errors.length > 0) {
+            logger.debug("[PUSH] Some notifications failed:", errors);
+          }
+          if (errors.length === ticketChunk.length) {
+            throw new Error("All push notifications in chunk failed");
+          }
+          break;
+        } catch (error) {
+          const elapsed = Date.now() - startTime;
+          if (elapsed >= timeout) {
+            logger.debug("[PUSH] Timeout reached after 5 minutes, giving up on chunk");
+            break;
+          }
+          attempt++;
+          const delay = Math.min(1e3 * Math.pow(2, attempt), 3e4);
+          const remainingTime = timeout - elapsed;
+          const waitTime = Math.min(delay, remainingTime);
+          if (waitTime > 0) {
+            logger.debug(`[PUSH] Retrying in ${waitTime}ms (attempt ${attempt})`);
+            await new Promise((resolve) => setTimeout(resolve, waitTime));
+          }
+        }
+      }
+    }
+    logger.info(`Push notifications sent successfully`);
+  }
+  /**
+   * Send a push notification to all registered devices for the user
+   * @param title - Notification title
+   * @param body - Notification body
+   * @param data - Additional data to send with the notification
+   */
+  async sendToAllDevices(title, body, data) {
+    const tokens = await this.fetchPushTokens();
+    if (tokens.length === 0) {
+      logger.info("No push tokens found for user");
+      return;
+    }
+    const messages = tokens.map((token) => ({
+      to: token.token,
+      title,
+      body,
+      data,
+      sound: "default",
+      priority: "high"
+    }));
+    await this.sendPushNotifications(messages);
+  }
+}
+
+class ApiClient {
+  token;
+  secret;
+  pushClient;
+  constructor(token, secret) {
+    this.token = token;
+    this.secret = secret;
+    this.pushClient = new PushNotificationClient(token);
+  }
+  /**
+   * Create a new session or load existing one with the given tag
+   */
+  async getOrCreateSession(opts) {
+    try {
+      const response = await axios.post(
+        `${configuration.serverUrl}/v1/sessions`,
+        {
+          tag: opts.tag,
+          metadata: encodeBase64(encrypt(opts.metadata, this.secret)),
+          agentState: opts.state ? encodeBase64(encrypt(opts.state, this.secret)) : null
+        },
+        {
+          headers: {
+            "Authorization": `Bearer ${this.token}`,
+            "Content-Type": "application/json"
+          }
+        }
+      );
+      logger.debug(`Session created/loaded: ${response.data.session.id} (tag: ${opts.tag})`);
+      let raw = response.data.session;
+      let session = {
+        id: raw.id,
+        createdAt: raw.createdAt,
+        updatedAt: raw.updatedAt,
+        seq: raw.seq,
+        metadata: decrypt(decodeBase64(raw.metadata), this.secret),
+        metadataVersion: raw.metadataVersion,
+        agentState: raw.agentState ? decrypt(decodeBase64(raw.agentState), this.secret) : null,
+        agentStateVersion: raw.agentStateVersion
+      };
+      return session;
+    } catch (error) {
+      logger.debug("[API] [ERROR] Failed to get or create session:", error);
+      throw new Error(`Failed to get or create session: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  /**
+   * Start realtime session client
+   * @param id - Session ID
+   * @returns Session client
+   */
+  session(session) {
+    return new ApiSessionClient(this.token, this.secret, session);
+  }
+  /**
+   * Get push notification client
+   * @returns Push notification client
+   */
+  push() {
+    return this.pushClient;
+  }
+}
+
+const UsageSchema = z.object({
+  input_tokens: z.number().int().nonnegative(),
+  cache_creation_input_tokens: z.number().int().nonnegative().optional(),
+  cache_read_input_tokens: z.number().int().nonnegative().optional(),
+  output_tokens: z.number().int().nonnegative(),
+  service_tier: z.string().optional()
+});
+const TextContentSchema = z.object({
+  type: z.literal("text"),
+  text: z.string()
+});
+const ThinkingContentSchema = z.object({
+  type: z.literal("thinking"),
+  thinking: z.string(),
+  signature: z.string()
+});
+const ToolUseContentSchema = z.object({
+  type: z.literal("tool_use"),
+  id: z.string(),
+  name: z.string(),
+  input: z.unknown()
+  // Tool-specific input parameters
+});
+const ToolResultContentSchema = z.object({
+  tool_use_id: z.string(),
+  type: z.literal("tool_result"),
+  content: z.union([
+    z.string(),
+    // For simple string responses
+    z.array(TextContentSchema)
+    // For structured content blocks (typically text)
+  ]),
+  is_error: z.boolean().optional()
+});
+const ContentSchema = z.union([
+  TextContentSchema,
+  ThinkingContentSchema,
+  ToolUseContentSchema,
+  ToolResultContentSchema
+]);
+const UserMessageSchema = z.object({
+  role: z.literal("user"),
+  content: z.union([
+    z.string(),
+    // Simple string content
+    z.array(z.union([ToolResultContentSchema, TextContentSchema]))
+  ])
+});
+const AssistantMessageSchema = z.object({
+  id: z.string(),
+  type: z.literal("message"),
+  role: z.literal("assistant"),
+  model: z.string(),
+  content: z.array(ContentSchema),
+  stop_reason: z.string().nullable(),
+  stop_sequence: z.string().nullable(),
+  usage: UsageSchema
+});
+const BaseEntrySchema = z.object({
+  cwd: z.string(),
+  sessionId: z.string(),
+  version: z.string(),
+  uuid: z.string(),
+  timestamp: z.string().datetime(),
+  parent_tool_use_id: z.string().nullable().optional()
+});
+const SummaryEntrySchema = z.object({
+  type: z.literal("summary"),
+  summary: z.string(),
+  leafUuid: z.string()
+});
+const UserEntrySchema = BaseEntrySchema.extend({
+  type: z.literal("user"),
+  message: UserMessageSchema,
+  isMeta: z.boolean().optional(),
+  toolUseResult: z.unknown().optional()
+  // Present when user responds to tool use
+});
+const AssistantEntrySchema = BaseEntrySchema.extend({
+  type: z.literal("assistant"),
+  message: AssistantMessageSchema,
+  requestId: z.string().optional()
+});
+const SystemEntrySchema = BaseEntrySchema.extend({
+  type: z.literal("system"),
+  content: z.string(),
+  isMeta: z.boolean().optional(),
+  level: z.string().optional(),
+  parentUuid: z.string().optional(),
+  isSidechain: z.boolean().optional(),
+  userType: z.string().optional()
+});
+const RawJSONLinesSchema = z.discriminatedUnion("type", [
+  UserEntrySchema,
+  AssistantEntrySchema,
+  SummaryEntrySchema,
+  SystemEntrySchema
+]);
+
+export { ApiClient as A, RawJSONLinesSchema as R, ApiSessionClient as a, initializeConfiguration as b, configuration as c, backoff as d, encodeBase64 as e, encodeBase64Url as f, decodeBase64 as g, delay as h, initLoggerWithGlobalConfiguration as i, encrypt as j, decrypt as k, logger as l };