@raisindb/client 0.1.0 → 0.1.1

package/dist/chunk-TPZNJNZR.mjs

@@ -0,0 +1,866 @@
+import {
+  ReconnectManager,
+  logger
+} from "./chunk-NOPZAMIV.mjs";
+
+// src/errors.ts
+var RaisinError = class extends Error {
+  constructor(message, code, details) {
+    super(message);
+    this.name = "RaisinError";
+    this.code = code;
+    this.details = details;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+};
+var RaisinConnectionError = class extends RaisinError {
+  constructor(message, code, options) {
+    super(message, code, options?.details);
+    this.name = "RaisinConnectionError";
+    this.status = options?.status;
+  }
+};
+var RaisinAuthError = class extends RaisinError {
+  constructor(message, code, status, details) {
+    super(message, code, details);
+    this.name = "RaisinAuthError";
+    this.status = status;
+  }
+};
+var RaisinFlowError = class extends RaisinError {
+  constructor(message, code, instanceId, details) {
+    super(message, code, details);
+    this.name = "RaisinFlowError";
+    this.instanceId = instanceId;
+  }
+};
+var RaisinTimeoutError = class extends RaisinError {
+  constructor(message, code, timeoutMs, details) {
+    super(message, code, details);
+    this.name = "RaisinTimeoutError";
+    this.timeoutMs = timeoutMs;
+  }
+};
+var RaisinAbortError = class extends RaisinError {
+  constructor(message = "Operation was aborted") {
+    super(message, "ABORTED");
+    this.name = "RaisinAbortError";
+  }
+};
+function classifyHttpError(status, message, details) {
+  if (status === 401) {
+    return new RaisinAuthError(message, "AUTH_UNAUTHORIZED", status, details);
+  }
+  if (status === 403) {
+    return new RaisinAuthError(message, "AUTH_FORBIDDEN", status, details);
+  }
+  if (status === 404) {
+    return new RaisinFlowError(message, "FLOW_NOT_FOUND", void 0, details);
+  }
+  return new RaisinConnectionError(message, "CONNECTION_FAILED", { status, details });
+}
+
+// src/streaming/sse-client.ts
+function parseSSEBlock(block) {
+  let event = "message";
+  let data = "";
+  let id;
+  const lines = block.split("\n");
+  for (const line of lines) {
+    if (line.startsWith("event:")) {
+      event = line.slice(6).trim();
+    } else if (line.startsWith("data:")) {
+      if (data) data += "\n";
+      data += line.slice(5).trim();
+    } else if (line.startsWith("id:")) {
+      id = line.slice(3).trim();
+    }
+  }
+  if (!data) return null;
+  return { event, data, id };
+}
+var SSEClient = class {
+  constructor(url, options = {}) {
+    this.abortController = null;
+    this._state = "disconnected";
+    this.url = url;
+    this.options = options;
+    this.fetchImpl = options.fetch ?? globalThis.fetch.bind(globalThis);
+    this._lastEventId = options.lastEventId;
+    this.autoReconnect = options.reconnect?.enabled ?? true;
+    this.externalSignal = options.signal;
+    this.inactivityTimeoutMs = options.inactivityTimeoutMs;
+    this.eventTypeSet = options.eventTypes?.length ? new Set(options.eventTypes) : null;
+    this.reconnectManager = new ReconnectManager({
+      initialDelay: options.reconnect?.initialDelay ?? 1e3,
+      maxDelay: options.reconnect?.maxDelay ?? 3e4,
+      backoffMultiplier: options.reconnect?.backoffMultiplier ?? 2,
+      maxAttempts: options.reconnect?.maxAttempts ?? Infinity
+    });
+  }
+  /** Current connection state */
+  get state() {
+    return this._state;
+  }
+  /**
+   * Returns a promise that resolves once the SSE connection is established.
+   *
+   * Useful for ensuring the connection is ready before triggering events
+   * on the server side (e.g., calling resume before consuming the stream).
+   * If the client is already connected, resolves immediately.
+   */
+  waitUntilConnected() {
+    if (this._state === "connected") return Promise.resolve();
+    return new Promise((resolve, reject) => {
+      const originalOnState = this.options.onStateChange;
+      this.options.onStateChange = (state) => {
+        originalOnState?.(state);
+        if (state === "connected") {
+          this.options.onStateChange = originalOnState;
+          resolve();
+        } else if (state === "disconnected") {
+          this.options.onStateChange = originalOnState;
+          reject(new Error("SSE connection failed"));
+        }
+      };
+    });
+  }
+  /** Last received event ID */
+  get lastEventId() {
+    return this._lastEventId;
+  }
+  setState(state) {
+    if (this._state !== state) {
+      this._state = state;
+      this.options.onStateChange?.(state);
+    }
+  }
+  /**
+   * Connect and consume events via callback.
+   *
+   * @param onEvent - Called for each matching SSE event
+   * @param onError - Called when an error occurs (optional)
+   */
+  async connect(onEvent, onError) {
+    this.close();
+    await this.startStream(onEvent, onError);
+  }
+  /**
+   * Close the SSE connection and stop reconnection attempts.
+   */
+  close() {
+    this.reconnectManager.cancelReconnect();
+    if (this.abortController) {
+      this.abortController.abort();
+      this.abortController = null;
+    }
+    this.setState("disconnected");
+  }
+  /**
+   * AsyncIterable interface: allows `for await (const event of sseClient)`.
+   *
+   * The iterator ends when close() is called or the server closes the stream
+   * (and auto-reconnect is disabled or max attempts are exhausted).
+   */
+  async *[Symbol.asyncIterator]() {
+    const queue = [];
+    let resolve = null;
+    let finished = false;
+    const push = (item) => {
+      if (finished) return;
+      if (resolve) {
+        const r = resolve;
+        resolve = null;
+        r(item);
+      } else {
+        queue.push(item);
+      }
+    };
+    const pull = () => {
+      const queued = queue.shift();
+      if (queued) return Promise.resolve(queued);
+      return new Promise((r) => {
+        resolve = r;
+      });
+    };
+    this.startStream(
+      (event) => push({ done: false, value: event }),
+      (error) => push({ done: true, error })
+    ).then(() => {
+      push({ done: true });
+    }).catch((error) => {
+      push({ done: true, error });
+    });
+    try {
+      while (!finished) {
+        const item = await pull();
+        if (item.done) {
+          finished = true;
+          if (item.error) {
+            throw item.error;
+          }
+          return;
+        }
+        yield item.value;
+      }
+    } finally {
+      finished = true;
+      this.close();
+    }
+  }
+  /**
+   * Core streaming loop: connects, reads the SSE stream, and handles reconnection.
+   */
+  async startStream(onEvent, onError) {
+    while (true) {
+      try {
+        await this.readStream(onEvent);
+        if (!this.autoReconnect || this._state === "disconnected") {
+          return;
+        }
+        this.setState("reconnecting");
+        const scheduled = await this.waitForReconnect();
+        if (!scheduled) {
+          logger.warn("SSE max reconnection attempts reached");
+          this.setState("disconnected");
+          return;
+        }
+      } catch (error) {
+        if (this._state === "disconnected") {
+          return;
+        }
+        const err = error instanceof Error ? error : new Error(String(error));
+        if (err.name === "AbortError" || err instanceof RaisinAbortError) {
+          return;
+        }
+        if (err instanceof RaisinTimeoutError && err.code === "SSE_INACTIVITY_TIMEOUT") {
+          logger.warn("SSE inactivity timeout:", err.message);
+          if (!this.autoReconnect) {
+            this.setState("disconnected");
+            onError?.(err);
+            throw err;
+          }
+          this.setState("reconnecting");
+          const scheduled2 = await this.waitForReconnect();
+          if (!scheduled2) {
+            logger.warn("SSE max reconnection attempts reached");
+            this.setState("disconnected");
+            onError?.(err);
+            throw err;
+          }
+          continue;
+        }
+        logger.error("SSE connection error:", err.message);
+        onError?.(err);
+        if (!this.autoReconnect) {
+          this.setState("disconnected");
+          throw err;
+        }
+        this.setState("reconnecting");
+        const scheduled = await this.waitForReconnect();
+        if (!scheduled) {
+          logger.warn("SSE max reconnection attempts reached");
+          this.setState("disconnected");
+          throw err;
+        }
+      }
+    }
+  }
+  /**
+   * Perform a single fetch and read the response body as SSE stream.
+   */
+  async readStream(onEvent) {
+    this.abortController = new AbortController();
+    this.setState("connecting");
+    if (this.externalSignal) {
+      if (this.externalSignal.aborted) {
+        this.abortController.abort();
+      } else {
+        const ctrl = this.abortController;
+        this.externalSignal.addEventListener("abort", () => ctrl.abort(), { once: true });
+      }
+    }
+    const headers = {
+      Accept: "text/event-stream",
+      "Cache-Control": "no-cache",
+      ...this.options.headers
+    };
+    if (this._lastEventId) {
+      headers["Last-Event-ID"] = this._lastEventId;
+    }
+    const method = this.options.method ?? "GET";
+    const fetchOptions = {
+      method,
+      headers,
+      signal: this.abortController.signal
+    };
+    if (method === "POST" && this.options.body !== void 0) {
+      fetchOptions.headers["Content-Type"] = "application/json";
+      fetchOptions.body = JSON.stringify(this.options.body);
+    }
+    const response = await this.withInactivityTimeout(
+      this.fetchImpl(this.url, fetchOptions)
+    );
+    if (!response.ok) {
+      const text = await response.text().catch(() => "");
+      const msg = `SSE connection failed: ${response.status} ${response.statusText}${text ? ` - ${text}` : ""}`;
+      if (response.status === 401 || response.status === 403) {
+        throw new RaisinAuthError(
+          msg,
+          response.status === 401 ? "AUTH_UNAUTHORIZED" : "AUTH_FORBIDDEN",
+          response.status
+        );
+      }
+      throw new RaisinConnectionError(msg, "SSE_STREAM_ERROR", { status: response.status });
+    }
+    if (!response.body) {
+      throw new RaisinConnectionError("SSE response has no body", "SSE_STREAM_ERROR");
+    }
+    this.setState("connected");
+    this.reconnectManager.reset();
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    try {
+      while (true) {
+        const { done, value } = await this.withInactivityTimeout(reader.read());
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const blocks = buffer.split("\n\n");
+        buffer = blocks.pop() ?? "";
+        for (const block of blocks) {
+          const trimmed = block.trim();
+          if (!trimmed) continue;
+          const parsed = parseSSEBlock(trimmed);
+          if (!parsed) continue;
+          if (parsed.id) {
+            this._lastEventId = parsed.id;
+          }
+          if (this.eventTypeSet && !this.eventTypeSet.has(parsed.event)) {
+            continue;
+          }
+          let data;
+          try {
+            data = JSON.parse(parsed.data);
+          } catch {
+            data = parsed.data;
+          }
+          const sseEvent = {
+            type: parsed.event,
+            data,
+            id: parsed.id
+          };
+          onEvent(sseEvent);
+        }
+      }
+    } finally {
+      try {
+        reader.releaseLock();
+      } catch {
+      }
+    }
+  }
+  /**
+   * Race a stream operation against the inactivity timeout.
+   *
+   * If no bytes (or response) arrive within `inactivityTimeoutMs`, the
+   * internal connection is aborted and the operation rejects with a
+   * `RaisinTimeoutError` (code `SSE_INACTIVITY_TIMEOUT`). The timer is
+   * effectively reset on every chunk because each `reader.read()` is
+   * wrapped individually.
+   */
+  withInactivityTimeout(promise) {
+    const timeoutMs = this.inactivityTimeoutMs;
+    if (!timeoutMs || timeoutMs <= 0) return promise;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        promise.catch(() => void 0);
+        this.abortController?.abort();
+        reject(
+          new RaisinTimeoutError(
+            `SSE stream inactive for ${timeoutMs}ms`,
+            "SSE_INACTIVITY_TIMEOUT",
+            timeoutMs
+          )
+        );
+      }, timeoutMs);
+      promise.then(
+        (value) => {
+          clearTimeout(timer);
+          resolve(value);
+        },
+        (error) => {
+          clearTimeout(timer);
+          reject(error);
+        }
+      );
+    });
+  }
+  /**
+   * Wait for the reconnect manager to schedule a reconnection attempt.
+   * Returns true if reconnection was scheduled, false if max attempts reached.
+   */
+  waitForReconnect() {
+    return new Promise((resolve) => {
+      const scheduled = this.reconnectManager.scheduleReconnect(() => {
+        resolve(true);
+      });
+      if (!scheduled) {
+        resolve(false);
+      }
+    });
+  }
+};
+
+// src/flow-client.ts
+var FlowClient = class _FlowClient {
+  /**
+   * Create a new FlowClient.
+   *
+   * @param baseUrl - Base HTTP URL of the RaisinDB server (e.g., "http://localhost:8081")
+   * @param repository - Repository name
+   * @param authManager - Auth manager for token access
+   * @param options - Additional options
+   * @param flowsApi - Optional FlowsApi for WebSocket-based flow operations
+   */
+  constructor(baseUrl, repository, authManager, options = {}, flowsApi) {
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+    this.repository = repository;
+    this.authManager = authManager;
+    this.fetchImpl = options.fetch ?? fetch;
+    this.requestTimeout = options.requestTimeout ?? 6e4;
+    this.flowsApi = flowsApi;
+  }
+  /**
+   * Create a FlowClient from an existing RaisinHttpClient.
+   *
+   * @param httpClient - An authenticated RaisinHttpClient instance
+   * @param baseUrl - Base HTTP URL (same as the one used for the HTTP client)
+   * @param repository - Repository name
+   * @param options - Additional options
+   */
+  static fromHttpClient(httpClient, baseUrl, repository, options = {}, flowsApi) {
+    return new _FlowClient(
+      baseUrl,
+      repository,
+      httpClient.getAuthManager(),
+      options,
+      flowsApi
+    );
+  }
+  // ==========================================================================
+  // Flow Execution
+  // ==========================================================================
+  /**
+   * Execute a flow by path.
+   *
+   * Creates a FlowInstance and queues it for execution. Returns immediately
+   * with the instance ID - use `streamEvents()` to monitor progress.
+   *
+   * @param flowPath - Path to the raisin:Flow node (e.g., "/flows/my-flow")
+   * @param input - Input data passed to the flow
+   * @returns Flow run response with instance_id and job_id
+   *
+   * @example
+   * ```typescript
+   * const result = await flows.run('/flows/process-order', {
+   *   orderId: 'ord-123',
+   *   items: [{ sku: 'ABC', qty: 2 }],
+   * });
+   * console.log('Instance:', result.instance_id);
+   * ```
+   */
+  async run(flowPath, input = {}, options) {
+    if (this.flowsApi) {
+      return this.flowsApi.run(flowPath, input);
+    }
+    const response = await this.request({
+      method: "POST",
+      path: `/api/flows/${this.repository}/run`,
+      body: { flow_path: flowPath, input },
+      signal: options?.signal
+    });
+    return response;
+  }
+  // ==========================================================================
+  // Instance Status
+  // ==========================================================================
+  /**
+   * Get the current status of a flow instance.
+   *
+   * Returns the instance status, variables, and metadata. Useful for
+   * polling-based approaches where SSE is not reliable (e.g., initial
+   * flow execution where events may be missed).
+   *
+   * @param instanceId - Flow instance ID (from `run()`)
+   * @returns Instance status including variables and flow path
+   *
+   * @example
+   * ```typescript
+   * const status = await flows.getInstanceStatus('instance-123');
+   * console.log('Status:', status.status); // 'waiting', 'completed', etc.
+   * ```
+   */
+  async getInstanceStatus(instanceId, options) {
+    if (this.flowsApi) {
+      return this.flowsApi.getInstanceStatus(instanceId);
+    }
+    return this.request({
+      method: "GET",
+      path: `/api/flows/${this.repository}/instances/${instanceId}`,
+      signal: options?.signal
+    });
+  }
+  // ==========================================================================
+  // Event Streaming (SSE)
+  // ==========================================================================
+  /**
+   * Stream real-time execution events for a flow instance via SSE.
+   *
+   * Returns an async iterable that yields FlowExecutionEvent objects.
+   * The stream automatically closes when a terminal event is received
+   * (flow_completed or flow_failed).
+   *
+   * @param instanceId - Flow instance ID (from `run()`)
+   * @returns Async iterable of flow execution events
+   *
+   * @example
+   * ```typescript
+   * const { instance_id } = await flows.run('/flows/my-flow', { key: 'value' });
+   *
+   * for await (const event of flows.streamEvents(instance_id)) {
+   *   switch (event.type) {
+   *     case 'step_started':
+   *       console.log(`Step ${event.node_id} started`);
+   *       break;
+   *     case 'step_completed':
+   *       console.log(`Step ${event.node_id} completed in ${event.duration_ms}ms`);
+   *       break;
+   *     case 'text_chunk':
+   *       process.stdout.write(event.text);
+   *       break;
+   *     case 'flow_completed':
+   *       console.log('Flow done:', event.output);
+   *       break;
+   *     case 'flow_failed':
+   *       console.error('Flow failed:', event.error);
+   *       break;
+   *   }
+   * }
+   * ```
+   */
+  async *streamEvents(instanceId, options) {
+    if (this.flowsApi) {
+      const sub = await this.flowsApi.subscribeEvents(instanceId);
+      try {
+        for await (const event of sub.events) {
+          if (options?.signal?.aborted) throw new RaisinAbortError();
+          yield event;
+          if (event.type === "flow_completed" || event.type === "flow_failed") {
+            return;
+          }
+        }
+      } finally {
+        await sub.unsubscribe();
+      }
+      return;
+    }
+    const url = `${this.baseUrl}/api/flows/${this.repository}/instances/${instanceId}/events`;
+    const headers = {};
+    const token = this.authManager.getAccessToken();
+    if (token) {
+      headers["Authorization"] = `Bearer ${token}`;
+    }
+    const sse = new SSEClient(url, {
+      headers,
+      eventTypes: ["flow-event", "message"],
+      reconnect: { enabled: false },
+      fetch: this.fetchImpl,
+      signal: options?.signal
+    });
+    try {
+      for await (const sseEvent of sse) {
+        const event = sseEvent.data;
+        yield event;
+        if (event.type === "flow_completed" || event.type === "flow_failed") {
+          return;
+        }
+      }
+    } finally {
+      sse.close();
+    }
+  }
+  /**
+   * Create an eagerly-connected event stream for a flow instance.
+   *
+   * Unlike `streamEvents()` (a lazy async generator), this method opens the
+   * SSE connection immediately and waits until it is established before
+   * returning. This is critical for resume flows: you must subscribe to
+   * events BEFORE calling `resume()`, otherwise events emitted between
+   * the resume and the SSE connection are lost.
+   *
+   * @param instanceId - Flow instance ID
+   * @returns Object with an async iterable `events` and a `close()` method
+   */
+  async createEventStream(instanceId, options) {
+    if (this.flowsApi) {
+      const sub = await this.flowsApi.subscribeEvents(instanceId);
+      return {
+        events: sub.events,
+        close: () => {
+          sub.unsubscribe();
+        }
+      };
+    }
+    const url = `${this.baseUrl}/api/flows/${this.repository}/instances/${instanceId}/events`;
+    const headers = {};
+    const token = this.authManager.getAccessToken();
+    if (token) {
+      headers["Authorization"] = `Bearer ${token}`;
+    }
+    const sse = new SSEClient(url, {
+      headers,
+      eventTypes: ["flow-event", "message"],
+      reconnect: { enabled: false },
+      fetch: this.fetchImpl,
+      signal: options?.signal
+    });
+    const iterator = sse[Symbol.asyncIterator]();
+    let pendingFirst = iterator.next();
+    await sse.waitUntilConnected();
+    const events = {
+      [Symbol.asyncIterator]() {
+        return {
+          async next() {
+            let result;
+            if (pendingFirst) {
+              result = await pendingFirst;
+              pendingFirst = null;
+            } else {
+              result = await iterator.next();
+            }
+            if (result.done) return { done: true, value: void 0 };
+            const event = result.value.data;
+            return { done: false, value: event };
+          },
+          async return() {
+            await iterator.return?.();
+            sse.close();
+            return { done: true, value: void 0 };
+          }
+        };
+      }
+    };
+    return { events, close: () => sse.close() };
+  }
+  // ==========================================================================
+  // Flow Resume & Human Task
+  // ==========================================================================
+  /**
+   * Resume a flow instance that is in a waiting state.
+   *
+   * Use this when a flow is waiting for external input (tool results,
+   * external events, etc.). The resume data is passed to the waiting step.
+   *
+   * @param instanceId - Flow instance ID
+   * @param data - Resume data to pass to the waiting step
+   *
+   * @example
+   * ```typescript
+   * await flows.resume('instance-123', {
+   *   tool_name: 'get_weather',
+   *   result: { temperature: 72, conditions: 'sunny' },
+   * });
+   * ```
+   */
+  async resume(instanceId, data, options) {
+    if (this.flowsApi) {
+      await this.flowsApi.resume(instanceId, data);
+      return;
+    }
+    await this.request({
+      method: "POST",
+      path: `/api/flows/${this.repository}/instances/${instanceId}/resume`,
+      body: { resume_data: data },
+      signal: options?.signal
+    });
+  }
+  /**
+   * Respond to a human task within a flow.
+   *
+   * When a flow is waiting on a human_task step (approval, input, review),
+   * use this method to submit the response. Completion is validated
+   * (caller must be the task's assignee or an admin) and resumes the flow.
+   *
+   * Note: prefer `InboxApi` for full inbox functionality (listing tasks,
+   * task details); this is a convenience passthrough to the same endpoint.
+   *
+   * @param instanceId - Flow instance ID (unused; kept for API stability)
+   * @param taskId - The inbox task node ID (or path)
+   * @param response - The response data
+   *
+   * @example
+   * ```typescript
+   * // Approve a task
+   * await flows.respondToHumanTask('instance-123', 'task-abc', {
+   *   action: 'approve',
+   *   comment: 'Looks good!',
+   * });
+   * ```
+   */
+  async respondToHumanTask(_instanceId, taskId, response, options) {
+    await this.request({
+      method: "POST",
+      path: `/api/inbox/${this.repository}/tasks/${encodeURIComponent(taskId)}/complete`,
+      body: { response },
+      signal: options?.signal
+    });
+  }
+  // ==========================================================================
+  // Convenience Methods
+  // ==========================================================================
+  /**
+   * Run a flow and wait for the final result.
+   *
+   * Starts the flow, streams all events, and returns the terminal outcome.
+   * This is a one-shot helper for fire-and-forget flows where you only
+   * care about the final output.
+   *
+   * @param flowPath - Path to the raisin:Flow node
+   * @param input - Input data passed to the flow
+   * @param options - Optional abort signal
+   * @returns The flow outcome including output or error
+   *
+   * @example
+   * ```typescript
+   * const result = await flows.runAndWait('/flows/process-order', { orderId: '123' });
+   * if (result.status === 'completed') {
+   *   console.log('Output:', result.output);
+   * }
+   * ```
+   */
+  async runAndWait(flowPath, input = {}, options) {
+    const { instance_id } = await this.run(flowPath, input, options);
+    for await (const event of this.streamEvents(instance_id, options)) {
+      if (event.type === "flow_completed") {
+        return {
+          instanceId: instance_id,
+          status: "completed",
+          output: event.output
+        };
+      }
+      if (event.type === "flow_failed") {
+        return {
+          instanceId: instance_id,
+          status: "failed",
+          error: event.error
+        };
+      }
+    }
+    return { instanceId: instance_id, status: "failed", error: "Stream ended without terminal event" };
+  }
+  /**
+   * Run a flow and collect all events into an array.
+   *
+   * Starts the flow, streams all events, and returns them as a collected array.
+   * Useful for testing, logging, or post-processing all flow events.
+   *
+   * @param flowPath - Path to the raisin:Flow node
+   * @param input - Input data passed to the flow
+   * @param options - Optional abort signal
+   * @returns The instance ID and all collected events
+   *
+   * @example
+   * ```typescript
+   * const { events } = await flows.runAndCollect('/flows/etl-pipeline', { source: 'db' });
+   * const steps = events.filter(e => e.type === 'step_completed');
+   * console.log(`Completed ${steps.length} steps`);
+   * ```
+   */
+  async runAndCollect(flowPath, input = {}, options) {
+    const { instance_id } = await this.run(flowPath, input, options);
+    const events = [];
+    for await (const event of this.streamEvents(instance_id, options)) {
+      events.push(event);
+    }
+    return { instanceId: instance_id, events };
+  }
+  // ==========================================================================
+  // Internal HTTP request helper
+  // ==========================================================================
+  async request(options) {
+    const url = `${this.baseUrl}${options.path}`;
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    const token = this.authManager.getAccessToken();
+    if (token) {
+      headers["Authorization"] = `Bearer ${token}`;
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.requestTimeout);
+    if (options.signal) {
+      if (options.signal.aborted) {
+        clearTimeout(timeoutId);
+        throw new RaisinAbortError();
+      }
+      options.signal.addEventListener("abort", () => controller.abort(), { once: true });
+    }
+    try {
+      const response = await this.fetchImpl(url, {
+        method: options.method,
+        headers,
+        body: options.body ? JSON.stringify(options.body) : void 0,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorText = await response.text();
+        let errorMessage;
+        try {
+          const errorJson = JSON.parse(errorText);
+          errorMessage = errorJson.message || errorJson.error || errorText;
+        } catch {
+          errorMessage = errorText || `HTTP ${response.status}: ${response.statusText}`;
+        }
+        throw classifyHttpError(response.status, errorMessage);
+      }
+      const contentType = response.headers.get("content-type");
+      if (contentType?.includes("application/json")) {
+        return await response.json();
+      }
+      return void 0;
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof RaisinAbortError || error instanceof RaisinTimeoutError) {
+        throw error;
+      }
+      if (error instanceof Error && error.name === "AbortError") {
+        if (options.signal?.aborted) {
+          throw new RaisinAbortError();
+        }
+        throw new RaisinTimeoutError(
+          `Request timeout after ${this.requestTimeout}ms`,
+          "REQUEST_TIMEOUT",
+          this.requestTimeout
+        );
+      }
+      throw error;
+    }
+  }
+};
+
+export {
+  RaisinError,
+  RaisinConnectionError,
+  RaisinAuthError,
+  RaisinFlowError,
+  RaisinTimeoutError,
+  RaisinAbortError,
+  classifyHttpError,
+  SSEClient,
+  FlowClient
+};
+//# sourceMappingURL=chunk-TPZNJNZR.mjs.map