@ai-matrx/api 0.0.0-stage → 0.1.1

package/dist/chunk-HER22VVH.cjs

@@ -0,0 +1,1047 @@
+'use strict';
+
+var chunk2SXAAKGV_cjs = require('./chunk-2SXAAKGV.cjs');
+var chunk5WJLKYH6_cjs = require('./chunk-5WJLKYH6.cjs');
+var uuid = require('@ai-matrx/kit/uuid');
+
+// src/core/backend-errors.ts
+var BackendApiError = class extends Error {
+  /** Machine-readable error code */
+  code;
+  /** Developer-facing detail */
+  detail;
+  /** Safe to display directly in the UI */
+  userMessage;
+  /** Extra info (validation errors, etc.) */
+  details;
+  /** Unique request ID for support/debugging */
+  requestId;
+  /** HTTP status code (if from an HTTP response) */
+  status;
+  constructor(data) {
+    super(data.userMessage);
+    this.name = "BackendApiError";
+    this.code = data.code;
+    this.detail = data.detail;
+    this.userMessage = data.userMessage;
+    this.details = data.details ?? null;
+    this.requestId = data.requestId ?? "";
+    this.status = data.status ?? null;
+  }
+  /** Convert to the wire format for logging */
+  toJSON() {
+    return {
+      error: this.code,
+      message: this.detail,
+      user_message: this.userMessage,
+      details: this.details,
+      request_id: this.requestId
+    };
+  }
+};
+var StreamTransportError = class extends BackendApiError {
+  /** Always true — reattach and let the server settle the outcome. */
+  resumable = true;
+  constructor(data) {
+    super({
+      code: "stream_transport_lost",
+      detail: data.detail,
+      userMessage: "The connection dropped. Your run is still going on the server \u2014 reconnecting to it now.",
+      details: data.details ?? null,
+      ...data.requestId !== void 0 ? { requestId: data.requestId } : {}
+    });
+    this.name = "StreamTransportError";
+  }
+};
+function isStreamTransportLost(error) {
+  if (error instanceof StreamTransportError) return true;
+  if (error instanceof BackendApiError) {
+    return error.code === "stream_transport_lost";
+  }
+  if (error && typeof error === "object") {
+    const code = error.code;
+    if (code === "stream_transport_lost") return true;
+    const errorType = error.error_type;
+    if (errorType === "transport_lost") return true;
+  }
+  return false;
+}
+async function parseHttpError(response) {
+  const status = response.status;
+  let text;
+  try {
+    text = await response.text();
+  } catch {
+    return new BackendApiError({
+      code: statusToCode(status),
+      detail: `HTTP ${status}`,
+      userMessage: `Request failed (${status})`,
+      status
+    });
+  }
+  let body;
+  try {
+    body = JSON.parse(text);
+  } catch {
+    return new BackendApiError({
+      code: statusToCode(status),
+      detail: text || `HTTP ${status}`,
+      userMessage: text || `Request failed (${status})`,
+      status
+    });
+  }
+  return parseHttpErrorBody(body, status);
+}
+function parseHttpErrorBody(body, status) {
+  if (!body) {
+    return new BackendApiError({
+      code: statusToCode(status),
+      detail: `HTTP ${status}`,
+      userMessage: `Request failed (${status})`,
+      status
+    });
+  }
+  if (typeof body.error === "string" && typeof body.user_message === "string") {
+    return new BackendApiError({
+      code: body.error,
+      detail: body.message || `HTTP ${status}`,
+      userMessage: body.user_message,
+      details: body.details ?? null,
+      requestId: typeof body.request_id === "string" ? body.request_id : void 0,
+      status
+    });
+  }
+  if (typeof body.error === "object" && body.error !== null) {
+    const errorObj = body.error;
+    return new BackendApiError({
+      code: errorObj.type || errorObj.error || statusToCode(status),
+      detail: errorObj.message || `HTTP ${status}`,
+      userMessage: errorObj.user_message || errorObj.user_visible_message || errorObj.message || `Request failed (${status})`,
+      details: errorObj.details ?? null,
+      requestId: typeof errorObj.request_id === "string" ? errorObj.request_id : void 0,
+      status
+    });
+  }
+  if (Array.isArray(body.detail)) {
+    const first = body.detail[0];
+    const firstMsg = first && typeof first.msg === "string" ? first.msg : null;
+    return new BackendApiError({
+      code: statusToCode(status),
+      detail: firstMsg ? `Validation error: ${firstMsg}` : JSON.stringify(body.detail),
+      userMessage: firstMsg || `Request failed (${status})`,
+      details: body.detail,
+      status
+    });
+  }
+  if (typeof body.detail === "object" && body.detail !== null && !Array.isArray(body.detail)) {
+    const d = body.detail;
+    const code = typeof d.code === "string" && d.code || typeof d.error === "string" && d.error || statusToCode(status);
+    const message = typeof d.message === "string" && d.message || typeof d.detail === "string" && d.detail || `HTTP ${status}`;
+    return new BackendApiError({
+      code,
+      detail: message,
+      userMessage: typeof d.user_message === "string" && d.user_message || typeof d.user_visible_message === "string" && d.user_visible_message || message,
+      details: d.details ?? d,
+      requestId: typeof d.request_id === "string" ? d.request_id : void 0,
+      status
+    });
+  }
+  return new BackendApiError({
+    code: typeof body.error === "string" ? body.error : statusToCode(status),
+    detail: body.message || body.detail || body.error || `HTTP ${status}`,
+    userMessage: body.user_message || body.user_visible_message || body.message || body.detail || `Request failed (${status})`,
+    details: body.details ?? null,
+    requestId: typeof body.request_id === "string" ? body.request_id : void 0,
+    status
+  });
+}
+function parseCallApiError(error) {
+  const status = error.status ?? 500;
+  const body = error.serverDetail && typeof error.serverDetail === "object" && !Array.isArray(error.serverDetail) ? error.serverDetail : { message: error.message };
+  return parseHttpErrorBody(body, status);
+}
+function parseStreamError(data) {
+  if (!data || typeof data !== "object") {
+    return new BackendApiError({
+      code: "internal_error",
+      detail: typeof data === "string" ? data : "Unknown streaming error",
+      userMessage: typeof data === "string" ? data : "Something went wrong"
+    });
+  }
+  const obj = data;
+  const details = typeof obj.details === "object" && obj.details !== null ? obj.details : null;
+  return new BackendApiError({
+    code: obj.code || obj.error_type || obj.error || "internal_error",
+    detail: obj.message || "Streaming error",
+    userMessage: obj.user_message || obj.message || "Something went wrong",
+    details,
+    requestId: typeof obj.request_id === "string" ? obj.request_id : typeof details?.request_id === "string" ? details.request_id : void 0
+  });
+}
+function parsePersistedBackendError(data, requestId = "") {
+  if (!data || typeof data !== "object") return null;
+  const error = data;
+  const failures = Array.isArray(error.failures) ? error.failures : [];
+  const firstSpecific = failures.find(
+    (failure) => typeof failure === "object" && failure !== null && typeof failure.message === "string"
+  );
+  const summary = typeof error.message === "string" ? error.message : "Backend operation failed";
+  const specific = typeof firstSpecific?.message === "string" ? firstSpecific.message : summary;
+  const detail = specific === summary ? summary : `${summary}: ${specific}`;
+  const code = typeof error.type === "string" ? error.type : "internal_error";
+  const userMessage = typeof error.user_message === "string" && error.user_message ? error.user_message : detail;
+  return new BackendApiError({
+    code,
+    detail,
+    userMessage,
+    details: error,
+    requestId
+  });
+}
+var GENERIC_MESSAGE_PATTERNS = [
+  /failed unexpectedly/i,
+  /^\s*something went wrong/i,
+  /please try again(\s+later)?\.?\s*$/i,
+  /^\s*request failed\b/i,
+  /^\s*unknown (streaming )?error/i,
+  /^\s*internal server error\.?\s*$/i
+];
+function isGenericUserMessage(message) {
+  const value = (message ?? "").trim();
+  if (!value) return true;
+  return GENERIC_MESSAGE_PATTERNS.some((pattern) => pattern.test(value));
+}
+function unwrapUpstreamError(message) {
+  const start = message.indexOf("{");
+  const end = message.lastIndexOf("}");
+  if (start < 0 || end <= start) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(message.slice(start, end + 1));
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null) return null;
+  const body = parsed;
+  const inner = typeof body.message === "string" && body.message || typeof body.detail === "string" && body.detail || "";
+  if (!inner) return null;
+  const statusMatch = /\bHTTP (\d{3})\b/.exec(message.slice(0, start));
+  return {
+    message: inner,
+    code: typeof body.error_type === "string" && body.error_type || typeof body.error === "string" && body.error || null,
+    userMessage: typeof body.user_message === "string" ? body.user_message : null,
+    requestId: typeof body.request_id === "string" ? body.request_id : null,
+    status: statusMatch ? Number(statusMatch[1]) : null
+  };
+}
+function describeBackendFailure(error) {
+  const chain = [];
+  let code = "internal_error";
+  let requestId = "";
+  let status = null;
+  let userFacing = null;
+  if (error instanceof BackendApiError) {
+    code = error.code;
+    requestId = error.requestId;
+    status = error.status;
+    userFacing = error.userMessage;
+    if (error.detail) chain.push(error.detail);
+    if (error.userMessage && error.userMessage !== error.detail) {
+      chain.push(error.userMessage);
+    }
+  } else if (error instanceof Error) {
+    chain.push(error.message);
+    userFacing = error.message;
+  } else if (typeof error === "string") {
+    chain.push(error);
+    userFacing = error;
+  } else {
+    chain.push("Unknown error");
+  }
+  for (let cursor = 0; cursor < chain.length && cursor < 12; cursor += 1) {
+    const upstream = unwrapUpstreamError(chain[cursor] ?? "");
+    if (!upstream || chain.includes(upstream.message)) continue;
+    chain.push(upstream.message);
+    if (upstream.code) code = upstream.code;
+    if (upstream.requestId) requestId = upstream.requestId;
+    if (upstream.status !== null) status = upstream.status;
+  }
+  const specific = [...chain].reverse().find((message) => !isGenericUserMessage(message));
+  const cause = specific ?? chain[0] ?? "Unknown error";
+  const headlineWasGeneric = isGenericUserMessage(userFacing);
+  return {
+    code,
+    cause,
+    headline: headlineWasGeneric ? cause : userFacing ?? cause,
+    headlineWasGeneric,
+    chain,
+    requestId,
+    status
+  };
+}
+function getUserMessage(error) {
+  if (error instanceof BackendApiError) {
+    return error.userMessage;
+  }
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  if (typeof error === "object" && error !== null && typeof error.message === "string" && error.message) {
+    return error.message;
+  }
+  return "Something went wrong";
+}
+function statusToCode(status) {
+  switch (status) {
+    case 401:
+      return "auth_required";
+    case 403:
+      return "admin_required";
+    case 404:
+      return "not_found";
+    case 422:
+      return "validation_error";
+    default:
+      return "internal_error";
+  }
+}
+
+// src/core/transport.ts
+var MatrxApiError = class extends Error {
+  name = "MatrxApiError";
+  /** HTTP status of the failed response. */
+  status;
+  /** Machine code from the server body (`code`, or `detail.code`), when present. */
+  code;
+  /** The parsed server error body, verbatim (undefined when unparsable). */
+  serverDetail;
+  /** The request path the failure came from (server-relative). */
+  path;
+  constructor(args) {
+    super(
+      args.message ?? extractMatrxErrorMessage(args.serverDetail) ?? `HTTP ${args.status}`
+    );
+    this.status = args.status;
+    this.path = args.path;
+    this.serverDetail = args.serverDetail;
+    this.code = extractMatrxErrorCode(args.serverDetail);
+  }
+};
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function nonBlankString(value) {
+  return typeof value === "string" && value.trim() ? value : void 0;
+}
+function extractMatrxErrorMessage(serverDetail) {
+  if (!isRecord(serverDetail)) return void 0;
+  const candidates = [];
+  const push = (value) => {
+    if (value) candidates.push(value);
+  };
+  push(nonBlankString(serverDetail.user_message));
+  push(nonBlankString(serverDetail.message));
+  if (Array.isArray(serverDetail.details)) {
+    const messages = serverDetail.details.map((entry) => {
+      if (!isRecord(entry)) return void 0;
+      const detailMessage = nonBlankString(entry.message);
+      if (!detailMessage) return void 0;
+      const field = nonBlankString(entry.field);
+      return field ? `${field}: ${detailMessage}` : detailMessage;
+    }).filter((m) => typeof m === "string");
+    if (messages.length > 0) push(messages.join("; "));
+  }
+  const detail = serverDetail.detail;
+  if (isRecord(detail)) {
+    push(nonBlankString(detail.message) ?? nonBlankString(detail.user_message));
+  }
+  if (typeof detail === "string" && detail.trim()) push(detail);
+  if (Array.isArray(detail)) {
+    const messages = detail.map(
+      (entry) => isRecord(entry) ? nonBlankString(entry.msg) : void 0
+    ).filter((m) => typeof m === "string");
+    if (messages.length > 0) push(messages.join("; "));
+  }
+  return candidates.find((c) => !isGenericUserMessage(c)) ?? candidates[0];
+}
+function extractMatrxErrorCode(serverDetail) {
+  if (!isRecord(serverDetail)) return null;
+  const topLevel = nonBlankString(serverDetail.code);
+  if (topLevel) return topLevel;
+  const detail = serverDetail.detail;
+  if (isRecord(detail)) {
+    const nested = nonBlankString(detail.code);
+    if (nested) return nested;
+  }
+  return null;
+}
+var OrganizationContextError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "OrganizationContextError";
+    this.code = code;
+  }
+};
+function createOrganizationOperation(organizationId) {
+  const organization_id = requireOrganizationContext(organizationId);
+  return Object.freeze({ organization_id });
+}
+function assertOrganizationMatchesOperation(operation, organizationId) {
+  if (operation.organization_id !== requireOrganizationContext(organizationId)) {
+    throw new OrganizationContextError(
+      "organization_context_mismatch",
+      "Organization ID must match the request operation."
+    );
+  }
+}
+function requireOrganizationContext(selectedOrganizationId, overrideOrganizationId) {
+  const candidate = overrideOrganizationId ?? selectedOrganizationId;
+  if (typeof candidate !== "string" || candidate.trim().length === 0) {
+    throw new OrganizationContextError(
+      "organization_context_required",
+      "Select an organization before sending this request."
+    );
+  }
+  const normalized = candidate.trim();
+  if (!uuid.isUuidShape(normalized)) {
+    throw new OrganizationContextError(
+      "organization_context_invalid",
+      "The selected organization ID is invalid."
+    );
+  }
+  return normalized.toLowerCase();
+}
+function applyOrganizationContextHeader(headers, organizationId) {
+  const normalizedOrganizationId = requireOrganizationContext(organizationId);
+  for (const [name, value] of Object.entries(headers)) {
+    if (name.toLowerCase() === "x-organization-id" && value.trim().toLowerCase() !== normalizedOrganizationId) {
+      throw new OrganizationContextError(
+        "organization_context_mismatch",
+        "X-Organization-Id must match the request context organization."
+      );
+    }
+  }
+  const withoutOrganizationHeader = Object.fromEntries(
+    Object.entries(headers).filter(
+      ([name]) => name.toLowerCase() !== "x-organization-id"
+    )
+  );
+  return {
+    ...withoutOrganizationHeader,
+    "X-Organization-Id": normalizedOrganizationId
+  };
+}
+function assertQueryOrganizationMatchesContext(queryParams, organizationId) {
+  if (!queryParams || queryParams.organization_id === void 0) return;
+  const queryOrganizationId = requireOrganizationContext(
+    String(queryParams.organization_id)
+  );
+  if (queryOrganizationId !== requireOrganizationContext(organizationId)) {
+    throw new OrganizationContextError(
+      "organization_context_mismatch",
+      "Query organization_id must match the request context organization."
+    );
+  }
+}
+
+// src/stream/ndjson.ts
+var DEFAULT_MATRX_NDJSON_READ_AHEAD = 64;
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeMatrxStreamEnvelope(value) {
+  if (!isRecord2(value)) return null;
+  if (typeof value.event === "string") {
+    const streamSeq = typeof value.stream_seq === "number" && Number.isFinite(value.stream_seq) ? value.stream_seq : void 0;
+    const streamId = typeof value.stream_id === "string" ? value.stream_id : void 0;
+    return {
+      event: value.event,
+      data: value.data,
+      ...streamId === void 0 ? {} : { stream_id: streamId },
+      ...streamSeq === void 0 ? {} : { stream_seq: streamSeq }
+    };
+  }
+  if (value.e === "c" && typeof value.t === "string") {
+    const streamId = typeof value.stream_id === "string" ? value.stream_id : void 0;
+    const streamSeq = typeof value.stream_seq === "number" && Number.isFinite(value.stream_seq) ? value.stream_seq : void 0;
+    return {
+      event: "chunk",
+      data: { text: value.t },
+      ...streamId === void 0 ? {} : { stream_id: streamId },
+      ...streamSeq === void 0 ? {} : { stream_seq: streamSeq }
+    };
+  }
+  if (value.e === "r" && typeof value.t === "string") {
+    const streamId = typeof value.stream_id === "string" ? value.stream_id : void 0;
+    const streamSeq = typeof value.stream_seq === "number" && Number.isFinite(value.stream_seq) ? value.stream_seq : void 0;
+    return {
+      event: "reasoning_chunk",
+      data: { text: value.t },
+      ...streamId === void 0 ? {} : { stream_id: streamId },
+      ...streamSeq === void 0 ? {} : { stream_seq: streamSeq }
+    };
+  }
+  return null;
+}
+function createMatrxNdjsonFramer(options = {}) {
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let lineNumber = 0;
+  let finished = false;
+  const assertOpen = () => {
+    if (finished) throw new Error("Matrx NDJSON framer is already finished");
+  };
+  const parseLine = (line, atCompletion) => {
+    const currentLineNumber = ++lineNumber;
+    const trimmed = line.trim();
+    if (!trimmed) return null;
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch (error) {
+      options.onMalformedLine?.({
+        line: trimmed,
+        error,
+        lineNumber: currentLineNumber,
+        atCompletion
+      });
+      return null;
+    }
+    const envelope = normalizeMatrxStreamEnvelope(parsed);
+    if (!envelope) {
+      options.onUnknownEnvelope?.(parsed);
+      return null;
+    }
+    options.onValidEnvelope?.({
+      raw: parsed,
+      envelope,
+      line: trimmed,
+      lineNumber: currentLineNumber,
+      atCompletion
+    });
+    return envelope;
+  };
+  const pushDecodedText = (fragment) => {
+    buffer += fragment;
+    const lines = buffer.split("\n");
+    buffer = lines.pop() ?? "";
+    const envelopes = [];
+    for (const line of lines) {
+      const envelope = parseLine(line, false);
+      if (envelope) envelopes.push(envelope);
+    }
+    return envelopes;
+  };
+  return {
+    pushText(fragment) {
+      assertOpen();
+      return pushDecodedText(decoder.decode() + fragment);
+    },
+    pushBytes(fragment) {
+      assertOpen();
+      return pushDecodedText(decoder.decode(fragment, { stream: true }));
+    },
+    finish() {
+      assertOpen();
+      finished = true;
+      const envelopes = pushDecodedText(decoder.decode());
+      if (buffer.length > 0) {
+        const envelope = parseLine(buffer, true);
+        buffer = "";
+        if (envelope) envelopes.push(envelope);
+      }
+      return envelopes;
+    }
+  };
+}
+function readAheadLimit(value) {
+  const limit = value ?? DEFAULT_MATRX_NDJSON_READ_AHEAD;
+  if (!Number.isSafeInteger(limit) || limit < 1) {
+    throw new RangeError("maxReadAhead must be a positive safe integer");
+  }
+  return limit;
+}
+async function* readMatrxNdjsonStream(body, options = {}) {
+  const maxReadAhead = readAheadLimit(options.maxReadAhead);
+  const queue = [];
+  let queuedEventCount = 0;
+  let wakeConsumer = null;
+  let wakeProducer = null;
+  let readerFinished = false;
+  let consumerClosed = false;
+  const wakeWaitingConsumer = () => {
+    const wake = wakeConsumer;
+    wakeConsumer = null;
+    wake?.();
+  };
+  const wakeWaitingProducer = () => {
+    const wake = wakeProducer;
+    wakeProducer = null;
+    wake?.();
+  };
+  const enqueueTerminal = (item) => {
+    if (consumerClosed) return;
+    queue.push(item);
+    wakeWaitingConsumer();
+  };
+  const enqueueEvent = async (value) => {
+    while (queuedEventCount >= maxReadAhead && !consumerClosed && !options.signal?.aborted) {
+      await new Promise((resolve) => {
+        wakeProducer = resolve;
+      });
+    }
+    if (consumerClosed || options.signal?.aborted) return false;
+    queue.push({ kind: "event", value });
+    queuedEventCount += 1;
+    wakeWaitingConsumer();
+    return true;
+  };
+  const waitForReadCapacity = async () => {
+    while (queuedEventCount >= maxReadAhead && !consumerClosed && !options.signal?.aborted) {
+      await new Promise((resolve) => {
+        wakeProducer = resolve;
+      });
+    }
+    return !consumerClosed && !options.signal?.aborted;
+  };
+  const reader = body.getReader();
+  const framer = createMatrxNdjsonFramer(options);
+  const onAbort = () => {
+    wakeWaitingProducer();
+    wakeWaitingConsumer();
+    void reader.cancel(options.signal?.reason).catch(() => void 0);
+  };
+  options.signal?.addEventListener("abort", onAbort, { once: true });
+  if (options.signal?.aborted) onAbort();
+  const readerPromise = (async () => {
+    try {
+      while (!options.signal?.aborted && !consumerClosed) {
+        if (!await waitForReadCapacity()) return;
+        const { value, done } = await reader.read();
+        if (done) break;
+        for (const envelope of framer.pushBytes(value)) {
+          if (!await enqueueEvent(envelope)) return;
+        }
+      }
+      if (!options.signal?.aborted && !consumerClosed) {
+        for (const envelope of framer.finish()) {
+          if (!await enqueueEvent(envelope)) return;
+        }
+      }
+    } catch (error) {
+      const aborted = options.signal?.aborted || consumerClosed || error instanceof Error && error.name === "AbortError";
+      if (!aborted) enqueueTerminal({ kind: "error", error });
+    } finally {
+      readerFinished = true;
+      reader.releaseLock();
+      enqueueTerminal({ kind: "done" });
+    }
+  })();
+  try {
+    while (true) {
+      if (queue.length === 0) {
+        if (options.signal?.aborted || readerFinished) return;
+        await new Promise((resolve) => {
+          wakeConsumer = resolve;
+        });
+      }
+      const item = queue.shift();
+      if (item?.kind === "event") queuedEventCount -= 1;
+      wakeWaitingProducer();
+      if (!item || item.kind === "done") return;
+      if (item.kind === "error") throw item.error;
+      yield item.value;
+    }
+  } finally {
+    consumerClosed = true;
+    wakeWaitingProducer();
+    wakeWaitingConsumer();
+    options.signal?.removeEventListener("abort", onAbort);
+    if (!readerFinished) {
+      await reader.cancel().catch(() => void 0);
+    }
+    await readerPromise;
+  }
+}
+
+// src/stream/sse.ts
+var FRAME_SEPARATOR = /\r\n\r\n|\n\n|\r\r/;
+var LINE_SEPARATOR = /\r\n|\n|\r/;
+function parseMatrxSseFrame(frame) {
+  let event = "message";
+  let id = null;
+  const dataLines = [];
+  let sawData = false;
+  for (const line of frame.split(LINE_SEPARATOR)) {
+    if (line.startsWith(":")) continue;
+    if (line.startsWith("event:")) event = line.slice(6).trim();
+    else if (line.startsWith("data:")) {
+      sawData = true;
+      dataLines.push(line.slice(5).replace(/^ /, ""));
+    } else if (line.startsWith("id:")) id = line.slice(3).trim();
+  }
+  const seqCandidate = id !== null && id !== "" ? Number(id) : NaN;
+  const seq = Number.isSafeInteger(seqCandidate) && seqCandidate >= 0 ? seqCandidate : null;
+  return { event, id, seq, data: sawData ? dataLines.join("\n") : null };
+}
+function createMatrxSseFramer() {
+  let buffer = "";
+  return {
+    push(chunk) {
+      buffer += chunk;
+      const frames = [];
+      for (; ; ) {
+        const sep = FRAME_SEPARATOR.exec(buffer);
+        if (sep === null) break;
+        const frame = buffer.slice(0, sep.index);
+        buffer = buffer.slice(sep.index + sep[0].length);
+        frames.push(parseMatrxSseFrame(frame));
+      }
+      return frames;
+    },
+    flush() {
+      const rest = buffer;
+      buffer = "";
+      return { incomplete: rest.length > 0 ? rest : null };
+    }
+  };
+}
+async function* readMatrxSseStream(stream, options = {}) {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  const framer = createMatrxSseFramer();
+  try {
+    for (; ; ) {
+      const { value, done } = await reader.read();
+      if (done) break;
+      const frames = framer.push(decoder.decode(value, { stream: true }));
+      for (const frame of frames) yield frame;
+    }
+    const tail = framer.push(decoder.decode());
+    for (const frame of tail) yield frame;
+    const { incomplete } = framer.flush();
+    if (incomplete !== null) options.onIncomplete?.(incomplete);
+  } finally {
+    reader.releaseLock();
+  }
+}
+
+// src/deployments.generated.ts
+var CONTRACT_SHA256 = "50a790edb39e682b46e0fa9e674faf5ce2a0ba7de2cd01930a497fca4c47844a";
+var DEPLOYMENTS = {
+  "files": {
+    "app": "files-standalone",
+    "baseUrl": {
+      "production": "https://files.matrxserver.com",
+      "localhost": "http://127.0.0.1:8090"
+    },
+    "env": {
+      "browser": "NEXT_PUBLIC_FILES_URL",
+      "browser_local": "NEXT_PUBLIC_FILES_URL_LOCAL",
+      "server": "MATRX_FILES_URL"
+    }
+  },
+  "scraper": {
+    "app": "scraper-server",
+    "baseUrl": {
+      "production": "https://scraper.app.matrxserver.com",
+      "localhost": "http://localhost:8001"
+    },
+    "env": {
+      "browser": "NEXT_PUBLIC_SCRAPER_URL",
+      "browser_local": "NEXT_PUBLIC_SCRAPER_URL_LOCAL",
+      "server": "MATRX_SCRAPER_URL",
+      "service_token": "MATRX_SCRAPER_TOKEN"
+    }
+  },
+  "seo": {
+    "app": "seo-standalone",
+    "baseUrl": {
+      "production": "https://seo.matrxserver.com",
+      "localhost": "http://127.0.0.1:8081"
+    },
+    "env": {
+      "browser": "NEXT_PUBLIC_SEO_URL",
+      "browser_local": "NEXT_PUBLIC_SEO_URL_LOCAL"
+    }
+  },
+  "sandbox-orchestrator": {
+    "app": "sandbox-orchestrator",
+    "baseUrl": {
+      "production": "https://orchestrator.dev.codematrx.com"
+    },
+    "env": {
+      "server": "SANDBOX_ORCHESTRATOR_URL",
+      "service_token": "SANDBOX_ORCHESTRATOR_API_KEY"
+    }
+  },
+  "matrx-local": {
+    "app": "matrx-local",
+    "baseUrl": {
+      "localhost": "http://127.0.0.1:22140"
+    },
+    "env": {
+      "port_base": "MATRX_PORT_BASE"
+    }
+  },
+  "cloud-browser-streaming": {
+    "app": "cloud-browser-streaming",
+    "baseUrl": {},
+    "env": {}
+  },
+  "cloud-browser-worker": {
+    "app": "cloud-browser-worker",
+    "baseUrl": {},
+    "env": {}
+  },
+  "hosted-box": {
+    "app": "hosted-box",
+    "baseUrl": {},
+    "env": {}
+  },
+  "aidream": {
+    "app": "aidream-main",
+    "baseUrl": {
+      "production": "https://server.app.matrxserver.com",
+      "localhost": "http://localhost:8000"
+    },
+    "env": {
+      "browser": "NEXT_PUBLIC_BACKEND_URL_PROD",
+      "server": "MATRX_AIDREAM_URL",
+      "service_token": "MATRX_AIDREAM_SERVICE_TOKEN",
+      "sandbox_service_token": "AIDREAM_SANDBOX_SERVICE_TOKEN"
+    }
+  }
+};
+var DOMAINS = ["account", "agents", "ai", "apps", "architecture", "audio", "chat", "code", "commerce", "communications", "computer", "content", "crm", "data", "education", "files", "human-resources", "integrations", "intelligence", "knowledge", "legal", "marketing", "masterwork", "media", "platform", "publish", "web", "workflows"];
+
+// src/api.ts
+var DEFAULT_CONNECT_TIMEOUT_MS = 15e3;
+function defaultRequestId() {
+  const c = globalThis.crypto;
+  if (c?.randomUUID) return c.randomUUID();
+  return `req-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+function interpolate(template, params) {
+  return template.replace(/\{([^}]+)\}/g, (_, name) => {
+    const value = params?.[name];
+    if (value === void 0 || value === null || String(value).length === 0) {
+      throw new TypeError(`Missing path parameter "${name}" for ${template}`);
+    }
+    return encodeURIComponent(String(value));
+  });
+}
+function queryString(query) {
+  if (!query) return "";
+  const parts = [];
+  for (const [key, raw] of Object.entries(query)) {
+    if (raw === void 0 || raw === null) continue;
+    const values = Array.isArray(raw) ? raw : [raw];
+    for (const v of values) {
+      if (v === void 0 || v === null) continue;
+      const text = typeof v === "object" ? JSON.stringify(v) : String(v);
+      parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(text)}`);
+    }
+  }
+  return parts.length ? `?${parts.join("&")}` : "";
+}
+function isBodyInit(body) {
+  return typeof body === "string" || typeof Blob !== "undefined" && body instanceof Blob || typeof FormData !== "undefined" && body instanceof FormData || typeof URLSearchParams !== "undefined" && body instanceof URLSearchParams || body instanceof ArrayBuffer || ArrayBuffer.isView(body) || typeof ReadableStream !== "undefined" && body instanceof ReadableStream;
+}
+function acceptFor(stream) {
+  switch (stream) {
+    case "ndjson":
+      return "application/x-ndjson";
+    case "sse":
+      return "text/event-stream";
+    case "ndjson_or_json":
+      return "application/x-ndjson, application/json";
+    case "sse_or_json":
+      return "text/event-stream, application/json";
+    case "bytes":
+      return "*/*";
+    case "bytes_or_json":
+      return "*/*, application/json";
+    default:
+      return "application/json";
+  }
+}
+async function errorFrom(response, path) {
+  const text = await response.text().catch(() => "");
+  let serverDetail = void 0;
+  try {
+    serverDetail = text ? JSON.parse(text) : void 0;
+  } catch {
+    serverDetail = text || void 0;
+  }
+  return new MatrxApiError({ status: response.status, path, serverDetail });
+}
+function createApi(options = {}) {
+  const credentials = chunk5WJLKYH6_cjs.toCredentialsPort(options.credentials);
+  const environment = options.environment ?? "production";
+  const mintRequestId = options.requestId ?? defaultRequestId;
+  const retryAttempts = Math.max(1, options.retryAttempts ?? 3);
+  const baseFor = (op) => {
+    const dynamic = options.resolveBaseUrl?.(op.d, op);
+    if (dynamic) return dynamic.replace(/\/+$/, "");
+    const override = options.baseUrls?.[op.d];
+    if (override) return override.replace(/\/+$/, "");
+    const deployment = DEPLOYMENTS[op.d];
+    const fallback = deployment.baseUrl[environment];
+    if (!fallback) {
+      throw new Error(
+        `@ai-matrx/api: no base URL for deployment "${op.d}" in ${environment} (operation ${op.n}). Pass createApi({ baseUrls: { "${op.d}": "https://\u2026" } })` + (deployment.env.server ? ` \u2014 servers read it from ${deployment.env.server}.` : ".")
+      );
+    }
+    return fallback;
+  };
+  const urlOf = (op, args) => `${baseFor(op)}${interpolate(op.p, args?.path)}${queryString(args?.query)}`;
+  const organizationFor = (op, call) => {
+    if (op.o === "exempt") return null;
+    const bound = options.organizationId;
+    const selected = call?.organizationId ?? (typeof bound === "function" ? bound() : bound) ?? null;
+    if (op.o === "required") return requireOrganizationContext(selected);
+    return selected && selected.trim() ? selected.trim() : null;
+  };
+  const send = async (op, args, call) => {
+    const url = urlOf(op, args);
+    const requestId = mintRequestId();
+    const orgId = organizationFor(op, call);
+    const headers = {
+      ...options.headers,
+      ...call?.headers,
+      Accept: acceptFor(op.s),
+      [chunk5WJLKYH6_cjs.MATRX_HEADERS.requestId]: requestId
+    };
+    let body;
+    if (args?.body !== void 0 && op.m !== "GET" && op.m !== "HEAD") {
+      if (isBodyInit(args.body)) {
+        body = args.body;
+      } else {
+        body = JSON.stringify(args.body);
+        headers["Content-Type"] = "application/json";
+      }
+    }
+    Object.assign(headers, chunk5WJLKYH6_cjs.credentialToHeaders(await credentials.get()));
+    if (orgId !== null) headers[chunk5WJLKYH6_cjs.MATRX_HEADERS.organization] = orgId;
+    options.onRequest?.({ operation: op.n, method: op.m, url, requestId, deployment: op.d });
+    const attempt = () => chunk2SXAAKGV_cjs.resilientFetch(
+      url,
+      { method: op.m, headers, ...body !== void 0 ? { body } : {} },
+      {
+        ...call?.signal ? { signal: call.signal } : {},
+        connectTimeoutMs: call?.connectTimeoutMs ?? options.connectTimeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS,
+        totalTimeoutMs: call?.totalTimeoutMs !== void 0 ? call.totalTimeoutMs : options.totalTimeoutMs ?? null,
+        throwOnHttpError: false
+      }
+    );
+    const idempotent = op.m === "GET" || op.m === "HEAD";
+    const { response, controller } = idempotent && retryAttempts > 1 && !op.s ? await chunk2SXAAKGV_cjs.withRetry(attempt, {
+      attempts: retryAttempts,
+      retryOn: chunk2SXAAKGV_cjs.isTransportFailure,
+      ...call?.signal ? { signal: call.signal } : {}
+    }) : await attempt();
+    if (!response.ok) throw await errorFrom(response, interpolate(op.p, args?.path));
+    return { response, requestId, controller };
+  };
+  return {
+    url: urlOf,
+    send,
+    async call(op, args, call) {
+      const { response } = await send(op, args, call);
+      if (response.status === 204 || op.m === "HEAD") return void 0;
+      const type = response.headers.get("content-type") ?? "";
+      if (type.includes("json")) return await response.json();
+      const text = await response.text();
+      try {
+        return JSON.parse(text);
+      } catch {
+        return text;
+      }
+    }
+  };
+}
+function wrapStream(response, requestId, controller, iterate) {
+  return {
+    response,
+    requestId,
+    cancel: () => controller.abort(),
+    [Symbol.asyncIterator]() {
+      if (!response.body) throw new Error("@ai-matrx/api: the stream response has no body");
+      return iterate(response.body)[Symbol.asyncIterator]();
+    }
+  };
+}
+async function openStream(api, op, args, options) {
+  const { response, requestId, controller } = await api.send(op, args, options);
+  return toStream(op, response, requestId, controller);
+}
+function toStream(op, response, requestId, controller) {
+  const kind = op.s ?? "none";
+  if (kind.startsWith("sse")) {
+    return wrapStream(response, requestId, controller, (b) => readMatrxSseStream(b));
+  }
+  if (kind.startsWith("ndjson")) {
+    return wrapStream(response, requestId, controller, (b) => readMatrxNdjsonStream(b));
+  }
+  return wrapStream(response, requestId, controller, (b) => streamChunks(b));
+}
+async function* streamChunks(body) {
+  const reader = body.getReader();
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) return;
+      if (value) yield value;
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+async function openJsonOrStream(api, op, args, options) {
+  const { response, requestId, controller } = await api.send(op, args, options);
+  const type = response.headers.get("content-type") ?? "";
+  if (type.includes("application/json")) {
+    return { kind: "json", data: await response.json() };
+  }
+  return { kind: "stream", stream: toStream(op, response, requestId, controller) };
+}
+
+exports.BackendApiError = BackendApiError;
+exports.CONTRACT_SHA256 = CONTRACT_SHA256;
+exports.DEFAULT_MATRX_NDJSON_READ_AHEAD = DEFAULT_MATRX_NDJSON_READ_AHEAD;
+exports.DEPLOYMENTS = DEPLOYMENTS;
+exports.DOMAINS = DOMAINS;
+exports.MatrxApiError = MatrxApiError;
+exports.OrganizationContextError = OrganizationContextError;
+exports.StreamTransportError = StreamTransportError;
+exports.applyOrganizationContextHeader = applyOrganizationContextHeader;
+exports.assertOrganizationMatchesOperation = assertOrganizationMatchesOperation;
+exports.assertQueryOrganizationMatchesContext = assertQueryOrganizationMatchesContext;
+exports.createApi = createApi;
+exports.createMatrxNdjsonFramer = createMatrxNdjsonFramer;
+exports.createMatrxSseFramer = createMatrxSseFramer;
+exports.createOrganizationOperation = createOrganizationOperation;
+exports.describeBackendFailure = describeBackendFailure;
+exports.extractMatrxErrorCode = extractMatrxErrorCode;
+exports.extractMatrxErrorMessage = extractMatrxErrorMessage;
+exports.getUserMessage = getUserMessage;
+exports.isGenericUserMessage = isGenericUserMessage;
+exports.isStreamTransportLost = isStreamTransportLost;
+exports.normalizeMatrxStreamEnvelope = normalizeMatrxStreamEnvelope;
+exports.openJsonOrStream = openJsonOrStream;
+exports.openStream = openStream;
+exports.parseCallApiError = parseCallApiError;
+exports.parseHttpError = parseHttpError;
+exports.parseHttpErrorBody = parseHttpErrorBody;
+exports.parseMatrxSseFrame = parseMatrxSseFrame;
+exports.parsePersistedBackendError = parsePersistedBackendError;
+exports.parseStreamError = parseStreamError;
+exports.readMatrxNdjsonStream = readMatrxNdjsonStream;
+exports.readMatrxSseStream = readMatrxSseStream;
+exports.requireOrganizationContext = requireOrganizationContext;
+exports.unwrapUpstreamError = unwrapUpstreamError;