@mirasoth/soothe-client 0.1.0 → 0.2.1

package/dist/chunk-AQZACDIC.js

@@ -0,0 +1,1399 @@
+// src/client.ts
+import { EventEmitter } from "events";
+import WebSocket from "ws";
+
+// src/config.ts
+function defaultConfig() {
+  return {
+    daemonURL: "ws://localhost:8765",
+    verbosityLevel: "normal",
+    maxRetries: 5,
+    reconnectDelay: 2e3,
+    heartbeatInterval: 3e4,
+    daemonReadyTimeout: 2e4,
+    loopStatusTimeout: 6e4,
+    subscriptionTimeout: 1e4,
+    reconnectMaxAttempts: 10,
+    reconnectInitialDelay: 500,
+    reconnectMaxDelay: 1e4,
+    reattachProbeTimeout: 5e3
+  };
+}
+function loadConfigFromEnv() {
+  const config = defaultConfig();
+  if (typeof process === "undefined") return config;
+  const url = process.env.SOOTHE_DAEMON_URL;
+  if (url) config.daemonURL = url;
+  const verbosity = process.env.SOOTHE_VERBOSITY;
+  if (verbosity) config.verbosityLevel = verbosity;
+  const retries = process.env.SOOTHE_MAX_RETRIES;
+  if (retries) {
+    const val = parseInt(retries, 10);
+    if (!isNaN(val)) config.maxRetries = val;
+  }
+  const readyTimeout = process.env.SOOTHE_DAEMON_READY_TIMEOUT_SEC;
+  if (readyTimeout) {
+    const val = parseInt(readyTimeout, 10);
+    if (val > 0) config.daemonReadyTimeout = val * 1e3;
+  }
+  const statusTimeout = process.env.SOOTHE_LOOP_STATUS_TIMEOUT_SEC;
+  if (statusTimeout) {
+    const val = parseInt(statusTimeout, 10);
+    if (val > 0) config.loopStatusTimeout = val * 1e3;
+  }
+  const subTimeout = process.env.SOOTHE_SUBSCRIPTION_TIMEOUT_SEC;
+  if (subTimeout) {
+    const val = parseInt(subTimeout, 10);
+    if (val > 0) config.subscriptionTimeout = val * 1e3;
+  }
+  return config;
+}
+
+// src/errors.ts
+var ConnectionError = class extends Error {
+  url;
+  attempt;
+  cause;
+  constructor(url, attempt, cause) {
+    super(`connection error to ${url} (attempt ${attempt}): ${cause.message}`);
+    this.name = "ConnectionError";
+    this.url = url;
+    this.attempt = attempt;
+    this.cause = cause;
+  }
+};
+var DaemonError = class extends Error {
+  /** Numeric error code from the RFC-450 §7.3 registry. */
+  code;
+  /** The daemon's error message text. */
+  daemonMessage;
+  /** Optional machine-parseable error details. */
+  data;
+  constructor(code, message, data) {
+    super(`daemon error [${code}]: ${message}`);
+    this.name = "DaemonError";
+    this.code = code;
+    this.daemonMessage = message;
+    this.data = data;
+  }
+};
+var TimeoutError = class extends Error {
+  operation;
+  duration;
+  constructor(operation, duration) {
+    super(`timeout after ${duration} waiting for ${operation}`);
+    this.name = "TimeoutError";
+    this.operation = operation;
+    this.duration = duration;
+  }
+};
+var DisconnectCause = /* @__PURE__ */ ((DisconnectCause2) => {
+  DisconnectCause2[DisconnectCause2["Unclean"] = 0] = "Unclean";
+  DisconnectCause2[DisconnectCause2["Clean"] = 1] = "Clean";
+  return DisconnectCause2;
+})(DisconnectCause || {});
+function disconnectCauseName(cause) {
+  return cause === 1 /* Clean */ ? "clean" : "unclean";
+}
+var ReconnectError = class extends Error {
+  url;
+  attempts;
+  cause;
+  constructor(url, attempts, cause) {
+    super(`reconnect to ${url} failed after ${attempts} attempts: ${cause.message}`);
+    this.name = "ReconnectError";
+    this.url = url;
+    this.attempts = attempts;
+    this.cause = cause;
+  }
+};
+var StaleLoopError = class extends Error {
+  loopID;
+  cause;
+  constructor(loopID, cause) {
+    const detail = cause ? `: ${cause.message}` : "";
+    super(`stale loop ${loopID}: reattach accepted but liveness probe failed${detail}`);
+    this.name = "StaleLoopError";
+    this.loopID = loopID;
+    this.cause = cause;
+  }
+};
+
+// src/multiplexer.ts
+var Multiplexer = class {
+  rpcs = /* @__PURE__ */ new Map();
+  subs = /* @__PURE__ */ new Map();
+  receipts = /* @__PURE__ */ new Map();
+  /**
+   * Installs a pending RPC wait keyed by `id`. Returns the pending call and an
+   * unregister function that MUST be called when the wait ends (success,
+   * timeout, or cancel) to avoid leaks. If a late response arrives after the
+   * caller has unregistered, it is dropped (log-and-drop) — no leak.
+   */
+  registerRPC(id) {
+    let callResolve;
+    let callReject;
+    const call = new Promise((resolve, reject) => {
+      callResolve = resolve;
+      callReject = reject;
+    });
+    const pending = { resolve: callResolve, reject: callReject };
+    this.rpcs.set(id, pending);
+    const unregister = () => {
+      if (this.rpcs.get(id) === pending) {
+        this.rpcs.delete(id);
+      }
+    };
+    return { call, unregister };
+  }
+  /**
+   * Installs a pending subscription stream keyed by `id`. Returns the stream
+   * channel (an async-iterable-like push sink), a `done` signal, and an
+   * unregister function. The Client pushes `next`/`complete` frames via
+   * `push`; the application reads from the channel.
+   */
+  registerSubscription(id) {
+    let resolveDone;
+    const done = new Promise((resolve) => {
+      resolveDone = resolve;
+    });
+    const pending = {
+      push: () => {
+      },
+      done,
+      resolveDone,
+      settled: false
+    };
+    const push = (frame) => {
+      if (pending.settled) return;
+      pending.push(frame);
+    };
+    pending.push = () => {
+    };
+    this.subs.set(id, pending);
+    const unregister = () => {
+      if (this.subs.get(id) === pending) {
+        pending.settled = true;
+        this.subs.delete(id);
+        resolveDone();
+      }
+    };
+    return { push, done, unregister };
+  }
+  /**
+   * Installs a pending receipt wait keyed by `receipt`. Returns an unregister
+   * function.
+   */
+  registerReceipt(receipt) {
+    let resolveWait;
+    const wait = new Promise((resolve) => {
+      resolveWait = resolve;
+    });
+    this.receipts.set(receipt, resolveWait);
+    const unregister = () => {
+      this.receipts.delete(receipt);
+    };
+    return { wait, unregister };
+  }
+  /**
+   * Wires a real sink for a registered subscription's `push`. Called by the
+   * Client right after `registerSubscription` to install the channel/queue the
+   * application reads from.
+   */
+  setSubscriptionSink(id, sink) {
+    const sub = this.subs.get(id);
+    if (sub) sub.push = sink;
+  }
+  /**
+   * Inspects one decoded frame, delivers it to a matching waiter if one
+   * exists, and returns `true` (consumed). Returns `false` for frames with no
+   * matching waiter — these flow on to the resolver queue / event stream.
+   * Safe to call from the message handler.
+   */
+  route(frame) {
+    if (!frame || typeof frame !== "object") return false;
+    const typ = frame.type;
+    const id = frame.id;
+    if (typ === "response" || typ === "error") {
+      if (!id) return false;
+      const pc = this.rpcs.get(id);
+      if (!pc) return false;
+      if (typ === "error") {
+        const errObj = frame.error ?? {};
+        const code = typeof errObj.code === "number" ? errObj.code : -32603;
+        const message = errObj.message ?? "daemon error";
+        pc.reject(new DaemonError(code, message, errObj.data));
+      } else {
+        const result = frame.result ?? frame;
+        pc.resolve(result);
+      }
+      this.rpcs.delete(id);
+      return true;
+    }
+    if (typ === "next" || typ === "complete") {
+      if (!id) return false;
+      const ps = this.subs.get(id);
+      if (!ps) return false;
+      if (ps.settled) return true;
+      ps.push(frame);
+      return true;
+    }
+    if (typ === "receipt_response") {
+      const rid = frame.receipt;
+      if (!rid) return false;
+      const ch = this.receipts.get(rid);
+      if (!ch) return false;
+      ch(frame);
+      this.receipts.delete(rid);
+      return true;
+    }
+    return false;
+  }
+  /** Reports whether an RPC waiter is registered for `id`. */
+  hasRPCWaiter(id) {
+    return this.rpcs.has(id);
+  }
+};
+
+// src/intent_hints.ts
+var INTENT_HINT_TEXT_COMPLETION = "text_completion";
+var INTENT_HINT_IMAGE_TO_TEXT = "image_to_text";
+var INTENT_HINT_OCR = "ocr";
+var INTENT_HINT_EMBED = "embed";
+var REMOVED_INTENT_HINTS = ["direct_llm", "quiz"];
+var REMOVED_INTENT_HINT_MESSAGES = {
+  direct_llm: "intent_hint direct_llm is removed; use text_completion (text-only) or image_to_text (with attachments)",
+  quiz: "intent_hint quiz is removed; omit intent_hint and let intake classify the turn"
+};
+function validateLoopInputIntentHint(hint) {
+  const key = hint.trim().toLowerCase();
+  if (key === "direct_llm" || key === "quiz") {
+    return REMOVED_INTENT_HINT_MESSAGES[key];
+  }
+  return null;
+}
+var LOOP_ASSISTANT_OUTPUT_PHASES = [
+  "goal_completion",
+  "quiz",
+  "autonomous_goal",
+  "direct_model",
+  "text_completion",
+  "image_to_text",
+  "ocr",
+  "embed",
+  "plan_direct"
+];
+var DEFAULT_DELIVERABLE_PHASES = /* @__PURE__ */ new Set([
+  "quiz",
+  "goal_completion",
+  "direct_model",
+  "text_completion",
+  "image_to_text",
+  "ocr",
+  "embed"
+]);
+
+// src/protocol.ts
+import { randomUUID } from "crypto";
+var PROTO_VERSION = "1";
+var DEFAULT_CLIENT_CAPABILITIES = ["streaming", "batch", "heartbeat", "receipts"];
+var CLIENT_VERSION = "0.1.0";
+function encodeMessage(msg) {
+  return JSON.stringify(msg) + "\n";
+}
+function decodeMessage(data) {
+  if (!data || data.length === 0) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(data);
+  } catch {
+    throw new Error(`invalid JSON: ${data}`);
+  }
+  if (!parsed || typeof parsed !== "object") return parsed;
+  const type = parsed.type;
+  if (!type) return parsed;
+  switch (type) {
+    case "connection_init":
+      return { ...parsed };
+    case "connection_ack":
+      return { ...parsed };
+    case "request":
+      return { ...parsed };
+    case "response":
+      return { ...parsed };
+    case "notification":
+      return { ...parsed };
+    case "subscribe":
+      return { ...parsed };
+    case "next":
+      return { ...parsed };
+    case "error":
+      return { ...parsed };
+    case "complete":
+      return { ...parsed };
+    case "unsubscribe":
+      return { ...parsed };
+    case "ping":
+      return { ...parsed };
+    case "pong":
+      return { ...parsed };
+    case "receipt_response":
+      return { ...parsed };
+    case "disconnect":
+      return { ...parsed };
+    case "status":
+      return { ...parsed };
+    default:
+      return parsed;
+  }
+}
+function requestEnvelope(method, params, id) {
+  return {
+    proto: PROTO_VERSION,
+    type: "request",
+    method,
+    params,
+    id: id ?? newRequestID()
+  };
+}
+function notificationEnvelope(method, params) {
+  return { proto: PROTO_VERSION, type: "notification", method, params };
+}
+function subscribeEnvelope(method, params, id) {
+  return {
+    proto: PROTO_VERSION,
+    type: "subscribe",
+    method,
+    params,
+    id: id ?? newRequestID()
+  };
+}
+function unsubscribeEnvelope(id) {
+  return { proto: PROTO_VERSION, type: "unsubscribe", id };
+}
+function connectionInitEnvelope(opts) {
+  return {
+    proto: PROTO_VERSION,
+    type: "connection_init",
+    params: {
+      client_version: opts?.client_version ?? CLIENT_VERSION,
+      client_name: opts?.client_name ?? "soothe-client-ts",
+      accept_proto: opts?.accept_proto ?? [PROTO_VERSION],
+      capabilities: opts?.capabilities ?? DEFAULT_CLIENT_CAPABILITIES
+    }
+  };
+}
+function pingEnvelope() {
+  return { proto: PROTO_VERSION, type: "ping" };
+}
+function pongEnvelope() {
+  return { proto: PROTO_VERSION, type: "pong" };
+}
+function disconnectEnvelope() {
+  return { proto: PROTO_VERSION, type: "disconnect" };
+}
+function splitWirePayload(data) {
+  const trimmed = data.trim();
+  if (trimmed === "") return [];
+  const lines = trimmed.split("\n").map((l) => l.trim()).filter((l) => l !== "");
+  return lines.length > 0 ? lines : [data];
+}
+function extractSootheLoopID(msg) {
+  if (!msg || typeof msg !== "object") return ["", false];
+  const m = msg;
+  if (m.type === "next") {
+    const payload = m.payload;
+    if (payload && typeof payload === "object") {
+      const data = payload.data;
+      if (data && typeof data === "object") {
+        const id = data.loop_id;
+        if (id && id !== "") return [id, true];
+      }
+      const pid = payload.loop_id;
+      if (pid && pid !== "") return [pid, true];
+    }
+    return ["", false];
+  }
+  if (m.type === "status") {
+    const id = m.loop_id;
+    if (id && id !== "") return [id, true];
+    return ["", false];
+  }
+  const generic = m.loop_id;
+  if (generic && generic !== "") return [generic, true];
+  return ["", false];
+}
+function newRequestID() {
+  return randomUUID();
+}
+function newLoopInputMessage(loopID, content) {
+  return notificationEnvelope("loop_input", {
+    loop_id: loopID,
+    content,
+    autonomous: false
+  });
+}
+function newLoopNewMessage(opts) {
+  const options = typeof opts === "string" ? { client_workspace: opts } : opts ?? {};
+  const clientWorkspace = options.client_workspace ?? options.workspace;
+  const params = {};
+  if (clientWorkspace?.trim()) {
+    params.client_workspace = clientWorkspace.trim();
+  }
+  if (options.user_id?.trim()) {
+    params.user_id = options.user_id.trim();
+  }
+  if (options.client_workspace_id?.trim()) {
+    params.client_workspace_id = options.client_workspace_id.trim();
+  }
+  if (options.is_ephemeral) {
+    params.is_ephemeral = true;
+  }
+  return requestEnvelope("loop_new", params);
+}
+function newLoopSubscribeMessage(loopID, verbosity, streamDelivery) {
+  const params = { loop_id: loopID, verbosity };
+  if (streamDelivery) {
+    params.stream_delivery = streamDelivery;
+  }
+  return subscribeEnvelope("loop_events", params);
+}
+
+// src/client.ts
+var Client = class extends EventEmitter {
+  url;
+  config;
+  ws = null;
+  messageBuffer = [];
+  resolvers = [];
+  // Protocol-1 handshake state (RFC-450 §8.2)
+  handshakeComplete = false;
+  negotiatedCapabilities = /* @__PURE__ */ new Set();
+  protocolVersion = null;
+  readinessState = null;
+  heartbeatIntervalMs = 0;
+  heartbeatTimer = null;
+  lastPongMonotonic = 0;
+  // Mid-session drop signal (RFC-450 §8.3). The 'disconnected' event is
+  // emitted exactly once when the connection drops, carrying a DisconnectCause
+  // that distinguishes clean (peer `disconnect`) from unclean (read/write
+  // error or missed pong). `disconnFired` guards the once-only delivery.
+  disconnFired = false;
+  // Pending-request/subscription multiplexer (RFC-629 constraint #1). Routes
+  // inbound frames by (type, id) instead of discarding non-matching events.
+  mux = new Multiplexer();
+  constructor(url, config) {
+    super();
+    this.url = url;
+    this.config = config ?? defaultConfig();
+  }
+  // ---------------------------------------------------------------------------
+  // Connection lifecycle
+  // ---------------------------------------------------------------------------
+  /**
+   * Dials the Soothe daemon WebSocket and completes the protocol-1 handshake
+   * (connection_init → connection_ack with readiness_state "ready").
+   */
+  connect() {
+    return new Promise((resolve, reject) => {
+      const ws = new WebSocket(this.url, {
+        handshakeTimeout: 1e4
+      });
+      ws.on("open", () => {
+        this.ws = ws;
+        this.disconnFired = false;
+        this._lastCause = null;
+        this.mux = new Multiplexer();
+        this._performHandshake().then((ack) => {
+          this.handshakeComplete = true;
+          this.readinessState = ack.result?.readiness_state ?? "ready";
+          this._startHeartbeat();
+          resolve();
+        }).catch((err) => {
+          this._stopHeartbeat();
+          this.ws = null;
+          this.handshakeComplete = false;
+          try {
+            ws.close(1011, "handshake failed");
+          } catch {
+          }
+          reject(err);
+        });
+      });
+      ws.on("error", (err) => {
+        this._signalDisconnect(0 /* Unclean */);
+        if (!this.ws) {
+          reject(new Error(`soothe dial: ${err.message}`));
+        }
+      });
+      ws.on("message", (data) => {
+        const text = data.toString();
+        for (const frame of splitWirePayload(text)) {
+          let msg;
+          try {
+            msg = decodeMessage(frame);
+          } catch {
+            continue;
+          }
+          if (msg === null) continue;
+          const m = msg;
+          if (m.type === "ping") {
+            this._sendRaw(pongEnvelope());
+            continue;
+          }
+          if (m.type === "pong") {
+            this.lastPongMonotonic = Date.now();
+            continue;
+          }
+          if (m.type === "disconnect") {
+            this._signalDisconnect(1 /* Clean */);
+          }
+          if (this.mux.route(m)) {
+            continue;
+          }
+          const resolver = this.resolvers.shift();
+          if (resolver) {
+            resolver(msg);
+          } else {
+            this.messageBuffer.push(msg);
+          }
+          this.emit("message", msg);
+        }
+      });
+      ws.on("close", () => {
+        this.ws = null;
+        this._stopHeartbeat();
+        this.handshakeComplete = false;
+        this._signalDisconnect(0 /* Unclean */);
+        this.emit("close");
+        for (const resolver of this.resolvers) {
+          resolver(null);
+        }
+        this.resolvers = [];
+      });
+    });
+  }
+  /** Sends a `disconnect` notification and closes the WebSocket. */
+  close() {
+    this._stopHeartbeat();
+    if (!this.ws) return;
+    try {
+      if (this.ws.readyState === WebSocket.OPEN) {
+        this.ws.send(JSON.stringify(disconnectEnvelope()));
+      }
+      this.ws.close(1e3, "");
+    } catch {
+    }
+    this.ws = null;
+    this.handshakeComplete = false;
+  }
+  /** Returns whether the client has an active, handshaked WebSocket connection. */
+  isConnected() {
+    return this.ws !== null && this.ws.readyState === WebSocket.OPEN && this.handshakeComplete;
+  }
+  // ---------------------------------------------------------------------------
+  // Mid-session drop signal + reconnect/reattach (RFC-450 §8.3, RFC-629 L0)
+  // ---------------------------------------------------------------------------
+  /**
+   * Returns whether the connection has dropped (the `'disconnected'` event has
+   * fired). Pair with the `'disconnected'` event for the signal. Use
+   * `disconnectCause()` to read the cause.
+   */
+  isDisconnected() {
+    return this.disconnFired;
+  }
+  /**
+   * Returns the cause of the most recent drop, or `null` if the connection has
+   * not dropped. Clean follows a `disconnect` notification (loops keep running
+   * server-side); unclean is a read/write error or missed pong.
+   */
+  disconnectCause() {
+    if (!this.disconnFired) return null;
+    return this._lastCause ?? 0 /* Unclean */;
+  }
+  _lastCause = null;
+  /**
+   * Delivers the disconnect cause exactly once via the `'disconnected'` event.
+   * Safe to call from any path; subsequent calls are no-ops. Listeners receive
+   * the cause as the event argument.
+   */
+  _signalDisconnect(cause) {
+    if (this.disconnFired) return;
+    this.disconnFired = true;
+    this._lastCause = cause;
+    try {
+      this.emit("disconnected", cause);
+    } catch {
+    }
+  }
+  /**
+   * Re-dials the daemon and re-handshakes after a connection drop (RFC-450
+   * §8.3). Does not re-establish loop subscriptions; follow with
+   * `reattachAndProbe()` to resume a loop session. The caller should invoke
+   * this after the `'disconnected'` event fires. Reuses the same Client,
+   * resetting the drop signal and multiplexer.
+   *
+   * Performs bounded-retry backoff using the configured reconnect knobs.
+   */
+  async reconnect() {
+    const maxAttempts = this.config.reconnectMaxAttempts || 10;
+    const initialDelay = this.config.reconnectInitialDelay || 500;
+    const maxDelay = this.config.reconnectMaxDelay || 1e4;
+    let lastErr = null;
+    let delay = initialDelay;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      try {
+        await this.connect();
+        return;
+      } catch (err) {
+        lastErr = err;
+      }
+      if (attempt < maxAttempts) {
+        await new Promise((resolve) => setTimeout(resolve, delay));
+        delay = Math.min(delay * 2, maxDelay);
+      }
+    }
+    throw new ReconnectError(this.url, maxAttempts, lastErr ?? new Error("unknown error"));
+  }
+  /**
+   * Resumes an existing loop after a reconnect: issues `loop_reattach`,
+   * re-subscribes to `loop_events`, then runs a `loop_get` liveness probe to
+   * detect stale loops that accept the handshake but silently drop input.
+   * Returns a `StaleLoopError` when the probe fails; callers should fall back
+   * to a fresh `loop_new` bootstrap.
+   *
+   * Per RFC-629: connection-level readiness is the handshake's readiness_state
+   * (+ daemon_status); loop_get is a loop-scoped probe only, not a readiness
+   * probe.
+   */
+  async reattachAndProbe(loopID) {
+    if (!loopID || !loopID.trim()) {
+      throw new Error("soothe: reattachAndProbe requires a loop id");
+    }
+    const lid = loopID.trim();
+    const reattachTimeout = this.config.loopStatusTimeout || 15e3;
+    try {
+      await this.requestResponse(
+        "loop_reattach",
+        { loop_id: lid },
+        "loop_reattach",
+        reattachTimeout
+      );
+    } catch (err) {
+      throw new Error(`loop_reattach: ${err.message}`);
+    }
+    const subTimeout = this.config.subscriptionTimeout || 1e4;
+    try {
+      await this.subscribe(
+        "loop_events",
+        { loop_id: lid, verbosity: this.config.verbosityLevel },
+        subTimeout
+      );
+    } catch (err) {
+      throw new Error(`loop events subscription failed: ${err.message}`);
+    }
+    const probeTimeout = this.config.reattachProbeTimeout || 5e3;
+    try {
+      await this.getLoop(lid, probeTimeout);
+    } catch (err) {
+      if (err instanceof DaemonError && err.code === -32200) {
+        throw new StaleLoopError(lid, err);
+      }
+      throw new StaleLoopError(lid, err);
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Protocol-1 handshake (RFC-450 §8.2)
+  // ---------------------------------------------------------------------------
+  /** Send connection_init and wait for connection_ack with readiness "ready". */
+  async _performHandshake() {
+    const init = connectionInitEnvelope({
+      client_version: CLIENT_VERSION,
+      client_name: "soothe-client-ts",
+      accept_proto: [PROTO_VERSION],
+      capabilities: DEFAULT_CLIENT_CAPABILITIES
+    });
+    await this.sendMessage(init);
+    const deadline = Date.now() + this.config.daemonReadyTimeout;
+    while (Date.now() < deadline) {
+      const remaining = deadline - Date.now();
+      if (remaining <= 0) break;
+      const ev = await this.readEventWithTimeout(remaining);
+      if (ev === null) {
+        throw new Error("connection closed during handshake");
+      }
+      if (ev.type === "status") {
+        continue;
+      }
+      if (ev.type !== "connection_ack") {
+        continue;
+      }
+      const ack = ev;
+      const result = ack.result ?? {};
+      const state = result.readiness_state ?? "ready";
+      this.protocolVersion = result.protocol_version ?? PROTO_VERSION;
+      this.negotiatedCapabilities = new Set(result.capabilities ?? []);
+      this.heartbeatIntervalMs = result.heartbeat_interval_ms ?? 0;
+      if (state === "incompatible") {
+        throw new Error(`protocol version incompatible: daemon returned ${this.protocolVersion}`);
+      }
+      if (state === "ready") {
+        return ack;
+      }
+      if (state === "error") {
+        throw new Error("daemon startup failed");
+      }
+      if (state === "degraded") {
+        throw new Error("daemon is degraded");
+      }
+      await this._sleep(50);
+      await this.sendMessage(init);
+    }
+    throw new Error(`timeout after ${this.config.daemonReadyTimeout}ms waiting for connection_ack`);
+  }
+  // ---------------------------------------------------------------------------
+  // Heartbeat (RFC-450 §8.3)
+  // ---------------------------------------------------------------------------
+  _startHeartbeat() {
+    if (!this.negotiatedCapabilities.has("heartbeat")) return;
+    const interval = this.heartbeatIntervalMs;
+    if (interval <= 0) return;
+    this.lastPongMonotonic = Date.now();
+    this.heartbeatTimer = setInterval(() => this._heartbeatTick(interval), interval);
+  }
+  _stopHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+  _heartbeatTick(intervalMs) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) return;
+    const timeoutMs = Math.max(1e4, intervalMs * 2);
+    const now = Date.now();
+    if (now - (this.lastPongMonotonic || now) > intervalMs + timeoutMs) {
+      this._signalDisconnect(0 /* Unclean */);
+      try {
+        this.ws.close(1001, "heartbeat timeout");
+      } catch {
+      }
+      return;
+    }
+    try {
+      this.ws.send(JSON.stringify(pingEnvelope()));
+    } catch {
+    }
+  }
+  _sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  // ---------------------------------------------------------------------------
+  // Core messaging
+  // ---------------------------------------------------------------------------
+  /** Serializes msg as JSON and sends it as a WebSocket text frame. */
+  sendMessage(msg) {
+    return new Promise((resolve, reject) => {
+      if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+        reject(new Error("soothe: not connected"));
+        return;
+      }
+      const payload = JSON.stringify(msg);
+      this.ws.send(payload, (err) => {
+        if (err) {
+          this._signalDisconnect(0 /* Unclean */);
+          reject(err);
+        } else {
+          resolve();
+        }
+      });
+    });
+  }
+  /** Low-level send that does not reject on a missing connection (best-effort). */
+  _sendRaw(msg) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) return;
+    try {
+      this.ws.send(JSON.stringify(msg));
+    } catch {
+    }
+  }
+  /** Returns an async iterable of decoded messages. Ends when connection closes. */
+  async *receiveMessages(signal) {
+    while (true) {
+      if (signal?.aborted) return;
+      while (this.messageBuffer.length > 0) {
+        const msg2 = this.messageBuffer.shift();
+        yield msg2;
+      }
+      const msg = await new Promise((resolve) => {
+        if (!this.ws) {
+          resolve(null);
+          return;
+        }
+        this.resolvers.push(resolve);
+      });
+      if (msg === null) return;
+      yield msg;
+    }
+  }
+  /** Reads a single event from the daemon. Returns null on connection close. */
+  async readEvent() {
+    if (this.messageBuffer.length > 0) {
+      const msg2 = this.messageBuffer.shift();
+      return msg2;
+    }
+    if (!this.ws) return null;
+    const msg = await new Promise((resolve) => {
+      this.resolvers.push(resolve);
+    });
+    if (msg === null) return null;
+    return msg;
+  }
+  /** Reads a single event with a timeout. Returns null on timeout or close. */
+  readEventWithTimeout(timeout) {
+    if (this.messageBuffer.length > 0) {
+      const msg = this.messageBuffer.shift();
+      return Promise.resolve(msg);
+    }
+    if (!this.ws) return Promise.resolve(null);
+    return new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        const idx = this.resolvers.indexOf(resolver);
+        if (idx >= 0) this.resolvers.splice(idx, 1);
+        resolve(null);
+      }, timeout);
+      const resolver = (val) => {
+        clearTimeout(timer);
+        resolve(val);
+      };
+      this.resolvers.push(resolver);
+    });
+  }
+  // ---------------------------------------------------------------------------
+  // Protocol-1 RPC primitives (RFC-450 §5/§9)
+  // ---------------------------------------------------------------------------
+  /**
+   * Reads the next frame directly from the live socket (via a resolver),
+   * bypassing `messageBuffer`. Used by RPC waits so that stream events
+   * previously buffered for `readEvent()`/`receiveMessages()` consumers are
+   * not re-cycled through the RPC wait loop (which would stall behind a
+   * continuous subscription stream). Non-RPC frames read here are pushed to
+   * `messageBuffer` for the stream readers.
+   */
+  readLiveEventWithTimeout(timeout) {
+    if (!this.ws) return Promise.resolve(null);
+    return new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        const idx = this.resolvers.indexOf(resolver);
+        if (idx >= 0) this.resolvers.splice(idx, 1);
+        resolve(null);
+      }, timeout);
+      const resolver = (val) => {
+        clearTimeout(timer);
+        resolve(val);
+      };
+      this.resolvers.push(resolver);
+    });
+  }
+  /**
+   * Sends a `request` envelope and waits for the matching `response` (or
+   * `error`) correlated by `id` (RFC-450 §5/§9). Returns the `result` object.
+   *
+   * Multiplexer-aware (RFC-629 constraint #1): registers a pending RPC wait
+   * keyed by the request id so that, even when a `receiveMessages()` reader
+   * is concurrently active, the matching `response`/`error` is routed to
+   * this caller instead of being discarded or buffered behind a stream.
+   * Non-matching frames are routed to their own waiters by the multiplexer
+   * or flow on to the resolver queue for stream readers.
+   */
+  async requestResponse(method, params, responseType, timeout = 15e3) {
+    const req = requestEnvelope(method, params);
+    const rid = req.id;
+    const { call, unregister } = this.mux.registerRPC(rid);
+    const label = responseType ?? method;
+    try {
+      await this.sendMessage(req);
+      const result = await this._raceRPC(call, timeout, label);
+      return result;
+    } finally {
+      unregister();
+    }
+  }
+  /**
+   * Races the multiplexer's RPC promise against a timeout and the connection
+   * drop signal. Resolves with the `result` on `response`; rejects with a
+   * `DaemonError` on `error`; rejects with a timeout/close error otherwise.
+   * The disconnect listener is always removed to avoid accumulating handlers.
+   */
+  async _raceRPC(call, timeout, label) {
+    let timer;
+    let cleanupDisconnect = () => {
+    };
+    const timeoutP = new Promise((_, reject) => {
+      timer = setTimeout(
+        () => reject(new Error(`timeout after ${timeout}ms waiting for ${label}`)),
+        timeout
+      );
+    });
+    const closedP = new Promise((_, reject) => {
+      if (this.disconnFired) {
+        reject(new Error(`connection closed waiting for ${label}`));
+        return;
+      }
+      const onDisconnect = () => {
+        reject(new Error(`connection closed waiting for ${label}`));
+      };
+      this.once("disconnected", onDisconnect);
+      cleanupDisconnect = () => this.removeListener("disconnected", onDisconnect);
+    });
+    try {
+      return await Promise.race([call, timeoutP, closedP]);
+    } finally {
+      if (timer) clearTimeout(timer);
+      cleanupDisconnect();
+    }
+  }
+  /**
+   * Sends a pre-built envelope (e.g. `unsubscribe`) that carries an `id` and
+   * waits for the matching `response`/`error`. Used for envelope types that
+   * are not `request` (e.g. `unsubscribe` → `autopilot_unsubscribe`) but still
+   * expect a correlated response from the daemon.
+   */
+  async _requestResponseForEnvelope(env, label, timeout) {
+    const rid = env.id;
+    const { call, unregister } = this.mux.registerRPC(rid);
+    try {
+      await this.sendMessage(env);
+      return await this._raceRPC(call, timeout, label);
+    } finally {
+      unregister();
+    }
+  }
+  /** Sends a fire-and-forget `notification` envelope (no response expected). */
+  notify(method, params) {
+    return this.sendMessage(notificationEnvelope(method, params));
+  }
+  /**
+   * Starts a subscription stream. Returns the subscription `id` for later
+   * correlation and `unsubscribe()`. Stream events arrive as `next` frames
+   * carrying the same `id`.
+   */
+  async subscribe(method, params, timeout = 5e3) {
+    const req = subscribeEnvelope(method, params);
+    const subId = req.id;
+    await this.sendMessage(req);
+    const deadline = Date.now() + timeout;
+    while (Date.now() < deadline) {
+      const remaining = deadline - Date.now();
+      if (remaining <= 0) break;
+      const ev = await this.readLiveEventWithTimeout(remaining);
+      if (ev === null) break;
+      const evId = ev.id;
+      if (evId !== subId) {
+        this.messageBuffer.push(ev);
+        continue;
+      }
+      const typ = ev.type;
+      if (typ === "error") {
+        const errObj = ev.error ?? {};
+        throw new DaemonError(
+          errObj.code ?? -32603,
+          errObj.message ?? "subscription rejected",
+          errObj.data
+        );
+      }
+      if (typ === "next" || typ === "complete") {
+        this.messageBuffer.unshift(ev);
+        break;
+      }
+    }
+    return subId;
+  }
+  /** Cancels an active subscription by id. */
+  unsubscribe(subscriptionId) {
+    return this.sendMessage(unsubscribeEnvelope(subscriptionId));
+  }
+  /**
+   * Reads the next stream event from a subscription. For `next` frames the
+   * `payload` is returned; for `complete`/`error` the full envelope is
+   * returned so the caller can inspect termination.
+   */
+  async next() {
+    const ev = await this.readEvent();
+    if (ev === null) return null;
+    if (ev.type === "next") {
+      return ev.payload ?? {};
+    }
+    return ev;
+  }
+  // ---------------------------------------------------------------------------
+  // High-level API methods (Loop-first, RFC-503)
+  // ---------------------------------------------------------------------------
+  /** Sends user input to the daemon (loop_input notification; requires loopID). */
+  sendInput(text, options) {
+    const loopId = (options?.loopID ?? "").trim();
+    if (!loopId) {
+      return Promise.reject(new Error("sendInput requires options.loopID"));
+    }
+    const params = {
+      loop_id: loopId,
+      content: text,
+      autonomous: options?.autonomous ?? false
+    };
+    if (options?.maxIterations !== void 0) params.max_iterations = options.maxIterations;
+    if (options?.subagent) params.preferred_subagent = options.subagent;
+    if (options?.model) params.model = options.model;
+    if (options?.modelParams) params.model_params = options.modelParams;
+    if (options?.attachments) params.attachments = options.attachments;
+    if (options?.intentHint) {
+      const hintError = validateLoopInputIntentHint(options.intentHint);
+      if (hintError) {
+        return Promise.reject(new Error(hintError));
+      }
+      params.intent_hint = options.intentHint;
+    }
+    if (options?.responseSchema) params.response_schema = options.responseSchema;
+    if (options?.responseSchemaName) params.response_schema_name = options.responseSchemaName;
+    if (options?.responseSchemaStrict !== void 0)
+      params.response_schema_strict = options.responseSchemaStrict;
+    if (options?.clarificationMode) params.clarification_mode = options.clarificationMode;
+    if (options?.clarificationAnswer) params.clarification_answer = true;
+    if (options?.clarificationAnswers) params.clarification_answers = options.clarificationAnswers;
+    return this.notify("loop_input", params);
+  }
+  /** Sends a slash command to the daemon (slash_command notification). */
+  sendCommand(cmd) {
+    return this.notify("slash_command", { cmd });
+  }
+  // ---------------------------------------------------------------------------
+  // Loop lifecycle methods (RFC-503)
+  // ---------------------------------------------------------------------------
+  /** Requests the daemon to create a new StrangeLoop and waits for the response. */
+  sendLoopNew(opts) {
+    return this.sendMessage(newLoopNewMessage(opts));
+  }
+  /** Subscribes to events for a loop (subscribe → loop_events). */
+  async sendLoopSubscribe(loopID, verbosity, streamDelivery) {
+    await this.subscribe("loop_events", {
+      loop_id: loopID,
+      verbosity,
+      stream_delivery: streamDelivery
+    });
+  }
+  /** Detaches from a loop (unsubscribe by subscription id). */
+  sendLoopDetach(loopID) {
+    return this.sendMessage(unsubscribeEnvelope(loopID));
+  }
+  /** Notifies the daemon that this client is leaving (disconnect notification). */
+  sendDetach() {
+    return this.sendMessage(disconnectEnvelope());
+  }
+  /** Requests daemon status check. */
+  sendDaemonStatus() {
+    return this.sendMessage(requestEnvelope("daemon_status", {}));
+  }
+  /** Requests daemon shutdown. */
+  sendDaemonShutdown() {
+    return this.sendMessage(requestEnvelope("daemon_shutdown", {}));
+  }
+  /** Requests a config section from the daemon. */
+  sendConfigGet(section) {
+    return this.sendMessage(requestEnvelope("config_get", { section }));
+  }
+  // ---------------------------------------------------------------------------
+  // Convenience RPC methods (blocking request/response)
+  // ---------------------------------------------------------------------------
+  /** Requests the skills catalog and waits for the response. */
+  listSkills(timeout) {
+    return this.requestResponse("skills_list", {}, "skills_list", timeout ?? 15e3);
+  }
+  /** Requests the models catalog and waits for the response. */
+  listModels(timeout) {
+    return this.requestResponse("models_list", {}, "models_list", timeout ?? 15e3);
+  }
+  /** Invokes a skill on the daemon host and receives echo. */
+  invokeSkill(skill, args, timeout) {
+    const params = { skill, args: args ?? "" };
+    return this.requestResponse("invoke_skill", params, "invoke_skill", timeout ?? 12e4);
+  }
+  /** Requests loop list and waits for response. */
+  listLoops(timeout, workspace) {
+    const params = {};
+    if (workspace) params.filter = { workspace };
+    return this.requestResponse("loop_list", params, "loop_list", timeout ?? 15e3);
+  }
+  /** Requests loop details and waits for response. */
+  getLoop(loopID, timeout) {
+    return this.requestResponse("loop_get", { loop_id: loopID }, "loop_get", timeout ?? 15e3);
+  }
+  /** Requests loop tree and waits for response. */
+  getLoopTree(loopID, timeout) {
+    return this.requestResponse("loop_tree", { loop_id: loopID }, "loop_tree", timeout ?? 15e3);
+  }
+  /** Requests loop deletion and waits for response. */
+  deleteLoop(loopID, timeout) {
+    return this.requestResponse(
+      "loop_delete",
+      { loop_id: loopID },
+      "loop_delete",
+      timeout ?? 15e3
+    );
+  }
+  /** Requests persisted conversation/activity rows. */
+  sendLoopMessages(loopID, limit, offset, includeEvents) {
+    const params = { loop_id: loopID };
+    if (limit !== void 0) params.limit = limit;
+    if (offset !== void 0) params.offset = offset;
+    if (includeEvents) params.include_events = true;
+    return this.sendMessage(requestEnvelope("loop_messages", params));
+  }
+  /** Requests LangGraph checkpoint channel values. */
+  sendLoopStateGet(loopID) {
+    return this.sendMessage(requestEnvelope("loop_state_get", { loop_id: loopID }));
+  }
+  /** Applies partial checkpoint values. */
+  sendLoopStateUpdate(loopID, values, asNode) {
+    const params = { loop_id: loopID, values };
+    if (asNode) params.as_node = asNode;
+    return this.sendMessage(requestEnvelope("loop_state_update", params));
+  }
+  /** Requests display card ledger snapshot. */
+  sendLoopCardsFetch(loopID) {
+    return this.sendMessage(requestEnvelope("loop_cards_fetch", { loop_id: loopID }));
+  }
+  /** Requests the full loop history (RFC-631). */
+  sendLoopHistoryFetch(loopID) {
+    return this.sendMessage(requestEnvelope("loop_history_fetch", { loop_id: loopID }));
+  }
+  /** Requests MCP server status. */
+  sendMCPStatus() {
+    return this.sendMessage(requestEnvelope("mcp_status", {}));
+  }
+  /** Requests daemon config reload. */
+  sendConfigReload() {
+    return this.sendMessage(requestEnvelope("config_reload", {}));
+  }
+  /** Submits credentials for daemon-side authentication. */
+  sendAuth(accessKey, secretKey) {
+    return this.sendMessage(
+      requestEnvelope("auth", { access_key: accessKey, secret_key: secretKey })
+    );
+  }
+  /** Refreshes the daemon-side auth token. */
+  sendAuthRefresh(refreshToken) {
+    return this.sendMessage(requestEnvelope("auth_refresh", { refresh_token: refreshToken }));
+  }
+  /** Requests persisted messages and waits for response. */
+  getLoopMessages(loopID, limit, offset, includeEvents, timeout) {
+    const params = { loop_id: loopID };
+    if (limit !== void 0) params.limit = limit;
+    if (offset !== void 0) params.offset = offset;
+    if (includeEvents) params.include_events = true;
+    return this.requestResponse("loop_messages", params, "loop_messages", timeout ?? 15e3);
+  }
+  /** Requests loop state and waits for response. */
+  getLoopState(loopID, timeout) {
+    return this.requestResponse(
+      "loop_state_get",
+      { loop_id: loopID },
+      "loop_state_get",
+      timeout ?? 15e3
+    );
+  }
+  /** Updates loop state and waits for response. */
+  updateLoopState(loopID, values, asNode, timeout) {
+    const params = { loop_id: loopID, values };
+    if (asNode) params.as_node = asNode;
+    return this.requestResponse(
+      "loop_state_update",
+      params,
+      "loop_state_update",
+      timeout ?? 15e3
+    );
+  }
+  /** Requests display cards and waits for response. */
+  fetchLoopCards(loopID, timeout) {
+    return this.requestResponse(
+      "loop_cards_fetch",
+      { loop_id: loopID },
+      "loop_cards_fetch",
+      timeout ?? 15e3
+    );
+  }
+  /** Requests MCP status and waits for response. */
+  getMCPStatus(timeout) {
+    return this.requestResponse("mcp_status", {}, "mcp_status", timeout ?? 15e3);
+  }
+  /** Requests loop history and waits for response. */
+  fetchLoopHistory(loopID, timeout) {
+    return this.requestResponse(
+      "loop_history_fetch",
+      { loop_id: loopID },
+      "loop_history_fetch",
+      timeout ?? 15e3
+    );
+  }
+  /** Requests daemon config reload and waits for response. */
+  reloadConfig(timeout) {
+    return this.requestResponse("config_reload", {}, "config_reload", timeout ?? 15e3);
+  }
+  /** Submits credentials for daemon-side authentication and waits for response. */
+  authenticate(accessKey, secretKey, timeout) {
+    return this.requestResponse(
+      "auth",
+      { access_key: accessKey, secret_key: secretKey },
+      "auth",
+      timeout ?? 15e3
+    );
+  }
+  /** Refreshes the daemon-side auth token and waits for response. */
+  refreshAuthToken(refreshToken, timeout) {
+    return this.requestResponse(
+      "auth_refresh",
+      { refresh_token: refreshToken },
+      "auth_refresh",
+      timeout ?? 15e3
+    );
+  }
+  // ---------------------------------------------------------------------------
+  // RFC-228 Job IPC methods
+  // ---------------------------------------------------------------------------
+  /** Creates an autopilot job and waits for the response. */
+  createJob(goal, verificationRules, workspace, timeout) {
+    const params = { goal };
+    if (verificationRules) params.verification_rules = verificationRules;
+    if (workspace) params.workspace = workspace;
+    return this.requestResponse("job_create", params, "job_create", timeout ?? 15e3);
+  }
+  /** Queries job status and waits for the response. */
+  getJobStatus(jobId, timeout) {
+    return this.requestResponse("job_status", { job_id: jobId }, "job_status", timeout ?? 15e3);
+  }
+  /** Pauses a running job. */
+  pauseJob(jobId, timeout) {
+    return this.requestResponse("job_pause", { job_id: jobId }, "job_pause", timeout ?? 15e3);
+  }
+  /** Resumes a paused job. */
+  resumeJob(jobId, timeout) {
+    return this.requestResponse("job_resume", { job_id: jobId }, "job_resume", timeout ?? 15e3);
+  }
+  /** Cancels a job. */
+  cancelJob(jobId, timeout) {
+    return this.requestResponse("job_cancel", { job_id: jobId }, "job_cancel", timeout ?? 15e3);
+  }
+  /** Requests the DAG visualization for a job. */
+  getJobDag(jobId, timeout) {
+    return this.requestResponse("job_dag", { job_id: jobId }, "job_dag", timeout ?? 15e3);
+  }
+  /** Sends guidance to a job or specific goal. */
+  sendJobGuidance(jobId, text, goalId, timeout) {
+    const params = { job_id: jobId, content: text };
+    if (goalId) params.goal_id = goalId;
+    return this.requestResponse("job_guidance", params, "job_guidance", timeout ?? 3e4);
+  }
+  /** Subscribes to autopilot worker events. */
+  autopilotSubscribe(timeout) {
+    return this.subscribe("autopilot_events", {}, timeout ?? 15e3);
+  }
+  /** Unsubscribes from autopilot worker events. */
+  autopilotUnsubscribe(timeout) {
+    const req = unsubscribeEnvelope(newRequestID());
+    return this._requestResponseForEnvelope(req, "autopilot_unsubscribe", timeout ?? 15e3);
+  }
+  // ---------------------------------------------------------------------------
+  // RFC-229 Cron IPC methods
+  // ---------------------------------------------------------------------------
+  /** Creates a scheduled job from natural language. */
+  cronAdd(text, priority, timeout) {
+    const params = { text };
+    if (priority !== void 0) params.priority = priority;
+    return this.requestResponse(
+      "cron_add",
+      params,
+      "cron_add",
+      timeout ?? 3e4
+      // Longer timeout for NL extraction
+    );
+  }
+  /** Lists scheduled jobs. */
+  cronList(status, timeout) {
+    const params = {};
+    if (status !== void 0) params.status = status;
+    return this.requestResponse("cron_list", params, "cron_list", timeout ?? 15e3);
+  }
+  /** Shows a specific scheduled job. */
+  cronShow(jobId, timeout) {
+    return this.requestResponse("cron_show", { job_id: jobId }, "cron_show", timeout ?? 15e3);
+  }
+  /** Cancels a scheduled job. */
+  cronCancel(jobId, timeout) {
+    return this.requestResponse("cron_cancel", { job_id: jobId }, "cron_cancel", timeout ?? 15e3);
+  }
+  // ---------------------------------------------------------------------------
+  // Wait helpers
+  /**
+   * Waits for the connection_ack to report readiness (already done in
+   * connect(); kept for callers that reconnect manually). Resolves
+   * immediately if the handshake is already complete.
+   */
+  async waitForDaemonReady(timeout) {
+    if (this.handshakeComplete) {
+      return { readiness_state: this.readinessState ?? "ready" };
+    }
+    const t = timeout ?? 1e4;
+    const deadline = Date.now() + t;
+    while (Date.now() < deadline) {
+      const remaining = deadline - Date.now();
+      if (remaining <= 0) break;
+      const ev = await this.readEventWithTimeout(remaining);
+      if (ev === null) break;
+      if (ev.type !== "connection_ack") continue;
+      const result = ev.result ?? {};
+      const state = result.readiness_state;
+      if (state === "ready") return ev;
+      throw new Error(`daemon not ready: state=${state ?? "unknown"}`);
+    }
+    throw new Error(`timeout after ${t}ms waiting for connection_ack`);
+  }
+};
+
+export {
+  ConnectionError,
+  DaemonError,
+  TimeoutError,
+  DisconnectCause,
+  disconnectCauseName,
+  ReconnectError,
+  StaleLoopError,
+  defaultConfig,
+  loadConfigFromEnv,
+  PROTO_VERSION,
+  DEFAULT_CLIENT_CAPABILITIES,
+  CLIENT_VERSION,
+  encodeMessage,
+  decodeMessage,
+  requestEnvelope,
+  notificationEnvelope,
+  subscribeEnvelope,
+  unsubscribeEnvelope,
+  connectionInitEnvelope,
+  pingEnvelope,
+  pongEnvelope,
+  disconnectEnvelope,
+  splitWirePayload,
+  extractSootheLoopID,
+  newRequestID,
+  newLoopInputMessage,
+  newLoopNewMessage,
+  newLoopSubscribeMessage,
+  INTENT_HINT_TEXT_COMPLETION,
+  INTENT_HINT_IMAGE_TO_TEXT,
+  INTENT_HINT_OCR,
+  INTENT_HINT_EMBED,
+  REMOVED_INTENT_HINTS,
+  validateLoopInputIntentHint,
+  LOOP_ASSISTANT_OUTPUT_PHASES,
+  DEFAULT_DELIVERABLE_PHASES,
+  Multiplexer,
+  Client
+};
+//# sourceMappingURL=chunk-AQZACDIC.js.map