@agents24/client 0.1.0

package/dist/chunk-45ITVMX3.js

@@ -0,0 +1,977 @@
+import { createSseParser, Agents24ProtocolError, parseRuntimeSsePayload, parseThreadSummarySsePayload } from './chunk-VVLMMNXI.js';
+
+// src/errors.ts
+var Agents24ClientError = class extends Error {
+  kind;
+  code;
+  status;
+  requestId;
+  retryable;
+  cause;
+  constructor(message, options) {
+    super(message);
+    this.name = "Agents24ClientError";
+    this.kind = options.kind;
+    this.code = options.code ?? "CLIENT_ERROR";
+    this.status = options.status;
+    this.requestId = options.requestId;
+    this.retryable = options.retryable ?? false;
+    this.cause = options.cause;
+  }
+};
+function missingCapability(name) {
+  return new Agents24ClientError(`Required capability is unavailable: ${name}.`, {
+    kind: "missing_capability",
+    code: "MISSING_CAPABILITY"
+  });
+}
+function errorKindForStatus(status) {
+  if (status === 401) return "authentication";
+  if (status === 403) return "authorization";
+  if (status === 404) return "not_found";
+  if (status === 409) return "conflict";
+  if (status === 422 || status === 400) return "validation";
+  if (status === 429) return "rate_limit";
+  return "server";
+}
+
+// src/capabilities.ts
+function globals() {
+  return globalThis;
+}
+function resolveFetch(injected) {
+  if (injected) return injected;
+  const implementation = globals().fetch;
+  if (!implementation) throw missingCapability("fetch");
+  return implementation.bind(globalThis);
+}
+function resolveDecoderFactory(injected) {
+  if (injected) return injected;
+  const Constructor = globals().TextDecoder;
+  if (!Constructor) throw missingCapability("TextDecoder");
+  return () => new Constructor("utf-8", { fatal: true });
+}
+function resolveEncoder(injected) {
+  if (injected) return injected;
+  const Constructor = globals().TextEncoder;
+  if (!Constructor) throw missingCapability("TextEncoder");
+  return new Constructor();
+}
+function defaultClock() {
+  return { now: () => Date.now() };
+}
+function randomHex(bytes) {
+  const target = new Uint8Array(bytes);
+  const crypto = globals().crypto;
+  const getRandomValues = crypto?.getRandomValues?.bind(crypto);
+  if (!getRandomValues) throw missingCapability("crypto.getRandomValues");
+  getRandomValues(target);
+  return Array.from(target, (value) => value.toString(16).padStart(2, "0")).join("");
+}
+function defaultIds() {
+  return {
+    createId() {
+      const crypto = globals().crypto;
+      const randomUUID = crypto?.randomUUID?.bind(crypto);
+      return randomUUID ? randomUUID() : randomHex(16);
+    }
+  };
+}
+function secureRandomBytes(length) {
+  const target = new Uint8Array(length);
+  const crypto = globals().crypto;
+  const getRandomValues = crypto?.getRandomValues?.bind(crypto);
+  if (!getRandomValues) throw missingCapability("crypto.getRandomValues");
+  return getRandomValues(target);
+}
+
+// src/multipart.ts
+function isBlobLike(value) {
+  return typeof value.arrayBuffer === "function";
+}
+async function toBytes(value) {
+  if (value instanceof Uint8Array) return value;
+  if (value instanceof ArrayBuffer) return new Uint8Array(value);
+  if (isBlobLike(value)) return new Uint8Array(await value.arrayBuffer());
+  throw new Agents24ClientError("Upload data must be bytes, an ArrayBuffer, or a compatible blob-like value.", {
+    kind: "validation",
+    code: "INVALID_UPLOAD_DATA"
+  });
+}
+function safeToken(value, field) {
+  if (!value || /[\r\n\0]/.test(value)) {
+    throw new Agents24ClientError(`${field} contains invalid characters.`, {
+      kind: "validation",
+      code: "INVALID_MULTIPART_METADATA"
+    });
+  }
+  return value.replace(/["\\]/g, "_");
+}
+function concat(chunks) {
+  const length = chunks.reduce((total, chunk) => total + chunk.byteLength, 0);
+  const output = new Uint8Array(length);
+  let offset = 0;
+  for (const chunk of chunks) {
+    output.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return output;
+}
+async function encodePart(part, boundary, encoder) {
+  const field = safeToken(part.field, "Multipart field");
+  if (typeof part.value === "string") {
+    return [encoder.encode(`--${boundary}\r
+Content-Disposition: form-data; name="${field}"\r
+\r
+${part.value}\r
+`)];
+  }
+  const upload = part.value;
+  const filename = safeToken(upload.name, "Upload filename");
+  const mediaType = safeToken(upload.mediaType, "Upload media type");
+  return [
+    encoder.encode(
+      `--${boundary}\r
+Content-Disposition: form-data; name="${field}"; filename="${filename}"\r
+Content-Type: ${mediaType}\r
+\r
+`
+    ),
+    await toBytes(upload.data),
+    encoder.encode("\r\n")
+  ];
+}
+function createByteMultipartEncoder(encoder) {
+  return {
+    async encode(parts) {
+      const boundary = `agents24-${Array.from(secureRandomBytes(18), (value) => value.toString(16).padStart(2, "0")).join("")}`;
+      const chunks = [];
+      for (const part of parts) chunks.push(...await encodePart(part, boundary, encoder));
+      chunks.push(encoder.encode(`--${boundary}--\r
+`));
+      return {
+        body: concat(chunks),
+        contentType: `multipart/form-data; boundary=${boundary}`
+      };
+    }
+  };
+}
+
+// src/url.ts
+function urlConstructor() {
+  const Constructor = globalThis.URL;
+  if (!Constructor) throw missingCapability("URL");
+  return Constructor;
+}
+function normalizeBaseUrl(input) {
+  let parsed;
+  try {
+    parsed = new (urlConstructor())(input);
+  } catch (cause) {
+    throw new Agents24ClientError("baseUrl must be an absolute HTTP(S) URL.", {
+      kind: "configuration",
+      code: "INVALID_BASE_URL",
+      cause
+    });
+  }
+  if (!/^https?:$/.test(parsed.protocol) || parsed.username || parsed.password || parsed.hash) {
+    throw new Agents24ClientError("baseUrl must be an absolute HTTP(S) origin without credentials or a fragment.", {
+      kind: "configuration",
+      code: "INVALID_BASE_URL"
+    });
+  }
+  return `${parsed.origin}${parsed.pathname.replace(/\/+$/, "")}`;
+}
+function absoluteUrl(baseUrl, path) {
+  return new (urlConstructor())(path, `${baseUrl}/`).toString();
+}
+function canonicalHtu(input) {
+  const parsed = new (urlConstructor())(input);
+  parsed.hash = "";
+  return parsed.toString();
+}
+function encodePath(value) {
+  return encodeURIComponent(value);
+}
+function appendQuery(path, values) {
+  const query = Object.entries(values).filter((entry) => entry[1] !== void 0).map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`).join("&");
+  return query ? `${path}?${query}` : path;
+}
+
+// src/http.ts
+var RESERVED_REQUEST_HEADERS = /* @__PURE__ */ new Set([
+  "accept",
+  "authorization",
+  "cache-control",
+  "content-type",
+  "cookie",
+  "dpop",
+  "host",
+  "idempotency-key",
+  "origin",
+  "pragma",
+  "proxy-authorization"
+]);
+function safeToken2(value, field) {
+  if (!value || /[\r\n\0]/.test(value)) {
+    throw new Agents24ClientError(`${field} is invalid.`, {
+      kind: "configuration",
+      code: "INVALID_CREDENTIAL"
+    });
+  }
+  return value;
+}
+function appendAdditionalHeaders(target, additional) {
+  for (const [name, value] of Object.entries(additional ?? {})) {
+    const normalized = name.toLowerCase();
+    if (!/^[a-z0-9!#$%&'*+.^_`|~-]+$/.test(normalized) || RESERVED_REQUEST_HEADERS.has(normalized)) {
+      throw new Agents24ClientError(`Reserved or invalid request header: ${name}.`, {
+        kind: "configuration",
+        code: "RESERVED_REQUEST_HEADER"
+      });
+    }
+    target[name] = safeToken2(value, `Request header ${name}`);
+  }
+}
+function isPublicError(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const candidate = value;
+  return typeof candidate.code === "string" && typeof candidate.message === "string" && typeof candidate.request_id === "string" && typeof candidate.retryable === "boolean";
+}
+async function responseError(response) {
+  let body;
+  try {
+    body = await response.json();
+  } catch {
+    body = void 0;
+  }
+  if (isPublicError(body)) {
+    return new Agents24ClientError(body.message, {
+      kind: errorKindForStatus(response.status),
+      code: body.code,
+      status: response.status,
+      requestId: body.request_id,
+      retryable: body.retryable
+    });
+  }
+  return new Agents24ClientError("The Agents24 runtime request failed.", {
+    kind: errorKindForStatus(response.status),
+    code: `HTTP_${response.status}`,
+    status: response.status,
+    retryable: response.status >= 500
+  });
+}
+async function responseJson(response) {
+  try {
+    return await response.json();
+  } catch (cause) {
+    throw new Agents24ClientError("The runtime returned invalid JSON.", {
+      kind: "protocol",
+      code: "INVALID_JSON_RESPONSE",
+      cause
+    });
+  }
+}
+function assertPrivateResponse(response) {
+  if (response.redirected || response.status >= 300 && response.status < 400) {
+    throw new Agents24ClientError("Authenticated redirects are not allowed.", {
+      kind: "network",
+      code: "REDIRECT_REJECTED",
+      status: response.status
+    });
+  }
+}
+var AuthenticatedHttp = class {
+  #baseUrl;
+  #provider;
+  #fetch;
+  #clock;
+  #telemetry;
+  #nonces = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.#baseUrl = options.baseUrl;
+    this.#provider = options.sessionProvider;
+    this.#fetch = options.fetch;
+    this.#clock = options.clock ?? defaultClock();
+    this.#telemetry = options.telemetry;
+  }
+  async #emit(event) {
+    try {
+      await this.#telemetry?.emit(event);
+    } catch {
+    }
+  }
+  async #access(signal) {
+    let access = await this.#provider.getAccess({ reason: "request", ...signal ? { signal } : {} });
+    if (access.expiresAt <= this.#clock.now() + 3e4 && this.#provider.refresh) {
+      access = await this.#provider.refresh({ reason: "expired", ...signal ? { signal } : {} });
+    }
+    return access;
+  }
+  async request(method, path, options) {
+    const url = absoluteUrl(this.#baseUrl, path);
+    const startedAt = this.#clock.now();
+    let access = await this.#access(options.signal);
+    let nonceRetried = false;
+    let refreshRetried = false;
+    let retryCount = 0;
+    await this.#emit({ type: "request.started", operation: options.operation, method, retryCount });
+    while (true) {
+      const token = safeToken2(access.accessToken, "Access token");
+      if (access.tokenType === "DPoP" && !access.dpopKeyProvider) {
+        throw new Agents24ClientError("A DPoP-bound session requires a DPoP key provider.", {
+          kind: "configuration",
+          code: "MISSING_DPOP_PROVIDER"
+        });
+      }
+      const headers = {
+        Accept: options.accept ?? "application/json",
+        Authorization: `${access.tokenType} ${token}`,
+        "Cache-Control": "no-store",
+        Pragma: "no-cache"
+      };
+      appendAdditionalHeaders(headers, options.headers);
+      if (options.body !== void 0) headers["Content-Type"] = "application/json";
+      if (options.contentType) headers["Content-Type"] = options.contentType;
+      if (options.idempotencyKey) headers["Idempotency-Key"] = safeToken2(options.idempotencyKey, "Idempotency key");
+      if (access.dpopKeyProvider) {
+        headers.DPoP = await access.dpopKeyProvider.signProof({
+          method,
+          url,
+          accessToken: token,
+          nonce: this.#nonces.get(access.sessionId ?? "default") ?? access.dpopNonce
+        });
+      }
+      let response;
+      try {
+        response = await this.#fetch(url, {
+          method,
+          headers,
+          body: options.rawBody ?? (options.body === void 0 ? void 0 : JSON.stringify(options.body)),
+          ...options.signal ? { signal: options.signal } : {},
+          redirect: "error",
+          cache: "no-store",
+          credentials: "omit"
+        });
+      } catch (cause) {
+        if (options.signal?.aborted) {
+          throw new Agents24ClientError("The operation was locally detached.", {
+            kind: "aborted",
+            code: "ABORTED",
+            cause
+          });
+        }
+        throw new Agents24ClientError("The Agents24 runtime could not be reached.", {
+          kind: "network",
+          code: "NETWORK_ERROR",
+          retryable: true,
+          cause
+        });
+      }
+      assertPrivateResponse(response);
+      const challengedNonce = response.headers.get("DPoP-Nonce");
+      if (response.status === 401 && challengedNonce && access.dpopKeyProvider && !nonceRetried) {
+        this.#nonces.set(access.sessionId ?? "default", safeToken2(challengedNonce, "DPoP nonce"));
+        nonceRetried = true;
+        retryCount += 1;
+        continue;
+      }
+      if (response.status === 401 && this.#provider.refresh && !refreshRetried) {
+        access = await this.#provider.refresh({
+          reason: "unauthorized",
+          ...options.signal ? { signal: options.signal } : {}
+        });
+        refreshRetried = true;
+        nonceRetried = false;
+        retryCount += 1;
+        continue;
+      }
+      await this.#emit({
+        type: "request.completed",
+        operation: options.operation,
+        method,
+        status: response.status,
+        durationMs: this.#clock.now() - startedAt,
+        retryCount
+      });
+      return response;
+    }
+  }
+  async json(method, path, options) {
+    const response = await this.request(method, path, options);
+    if (!response.ok) throw await responseError(response);
+    return await responseJson(response);
+  }
+};
+async function dpopTokenRequest(input) {
+  const method = input.method ?? "POST";
+  let nonce = input.nonce;
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    const headers = {
+      Accept: "application/json",
+      "Content-Type": "application/json",
+      "Cache-Control": "no-store",
+      Pragma: "no-cache"
+    };
+    if (input.idempotencyKey) headers["Idempotency-Key"] = safeToken2(input.idempotencyKey, "Idempotency key");
+    if (input.dpopKeyProvider && !(input.prooflessInitialRequest && attempt === 0)) {
+      headers.DPoP = await input.dpopKeyProvider.signProof({ method, url: input.url, nonce });
+    }
+    let response;
+    try {
+      response = await input.fetch(input.url, {
+        method,
+        headers,
+        body: JSON.stringify(input.body),
+        ...input.signal ? { signal: input.signal } : {},
+        redirect: "error",
+        cache: "no-store",
+        credentials: "omit"
+      });
+    } catch (cause) {
+      if (input.signal?.aborted) {
+        throw new Agents24ClientError("The operation was locally detached.", {
+          kind: "aborted",
+          code: "ABORTED",
+          cause
+        });
+      }
+      throw new Agents24ClientError("The Agents24 session endpoint could not be reached.", {
+        kind: "network",
+        code: "NETWORK_ERROR",
+        retryable: true,
+        cause
+      });
+    }
+    assertPrivateResponse(response);
+    const challenge = response.headers.get("DPoP-Nonce");
+    if (response.status === 401 && challenge && input.dpopKeyProvider && attempt === 0) {
+      nonce = safeToken2(challenge, "DPoP nonce");
+      continue;
+    }
+    if (input.prooflessInitialRequest && input.dpopKeyProvider && attempt === 0 && response.ok) {
+      throw new Agents24ClientError("DPoP enrollment succeeded without the required nonce challenge.", {
+        kind: "authentication",
+        code: "DPOP_ENROLLMENT_FAILED"
+      });
+    }
+    return response;
+  }
+  throw new Agents24ClientError("DPoP enrollment failed.", {
+    kind: "authentication",
+    code: "DPOP_ENROLLMENT_FAILED"
+  });
+}
+
+// src/stream.ts
+function detachReason(event) {
+  if (event.event !== "run.detached") return void 0;
+  const reason = event.payload.reason;
+  if (reason === "token_expired" || reason === "revoked" || reason === "policy_changed") return reason;
+  return "server_detach";
+}
+function threadId(event) {
+  const value = event.payload.thread_id;
+  return typeof value === "string" && value ? value : void 0;
+}
+async function consumeBody(input) {
+  if (!input.response.ok) throw await responseError(input.response);
+  if (!input.response.body) {
+    throw new Agents24ClientError("The stream response did not include a readable body.", {
+      kind: "protocol",
+      code: "MISSING_STREAM_BODY"
+    });
+  }
+  const reader = input.response.body.getReader();
+  let locallyAborted = input.signal?.aborted ?? false;
+  const onAbort = () => {
+    locallyAborted = true;
+    void reader.cancel(input.signal?.reason).catch(() => void 0);
+  };
+  input.signal?.addEventListener("abort", onAbort, { once: true });
+  const parser = createSseParser({
+    decoder: input.decoder,
+    onPayload: input.onPayload,
+    ...input.signal ? { signal: input.signal } : {}
+  });
+  try {
+    while (!locallyAborted) {
+      const chunk = await reader.read();
+      if (chunk.value) await parser.push(chunk.value);
+      if (chunk.done) break;
+    }
+    if (!locallyAborted) await parser.finish();
+  } catch (cause) {
+    if (!locallyAborted) {
+      if (cause instanceof Agents24ProtocolError) throw cause;
+      throw new Agents24ClientError("The runtime stream was interrupted.", {
+        kind: "network",
+        code: "STREAM_INTERRUPTED",
+        retryable: true,
+        cause
+      });
+    }
+  } finally {
+    input.signal?.removeEventListener("abort", onAbort);
+    reader.releaseLock?.();
+  }
+  if (locallyAborted) {
+    throw new Agents24ClientError("The runtime stream was locally detached.", {
+      kind: "aborted",
+      code: "ABORTED",
+      retryable: false
+    });
+  }
+}
+async function consumeRuntimeStream(input) {
+  let cursor = input.afterCursor ?? null;
+  let runId = null;
+  let resolvedThreadId = null;
+  let detached = false;
+  let terminal = false;
+  let reason;
+  await consumeBody({
+    response: input.response,
+    ...input.signal ? { signal: input.signal } : {},
+    decoder: input.decoder,
+    async onPayload(payload) {
+      const event = parseRuntimeSsePayload(payload);
+      if (cursor !== null && event.seq <= cursor) return;
+      if (cursor !== null && event.seq !== cursor + 1) {
+        throw new Agents24ProtocolError("invalid_envelope", "Runtime stream sequence is not contiguous.", {
+          expected: cursor + 1,
+          received: event.seq
+        });
+      }
+      cursor = event.seq;
+      runId = event.run_id;
+      resolvedThreadId = threadId(event) ?? resolvedThreadId;
+      reason = detachReason(event);
+      detached = reason !== void 0;
+      terminal = event.event === "run.completed" || event.event === "run.failed" || event.event === "run.cancelled";
+      await input.onEvent(event);
+      input.onProgress?.({
+        runId,
+        threadId: resolvedThreadId,
+        cursor,
+        detached,
+        ...reason ? { detachReason: reason } : {}
+      });
+    }
+  });
+  if (runId && !terminal && !detached && !input.signal?.aborted) {
+    throw new Agents24ClientError("The runtime stream ended before a terminal or detach event.", {
+      kind: "network",
+      code: "STREAM_ENDED_BEFORE_TERMINAL",
+      retryable: true
+    });
+  }
+  return {
+    runId,
+    threadId: resolvedThreadId,
+    cursor,
+    detached,
+    ...reason ? { detachReason: reason } : {}
+  };
+}
+async function consumeThreadSummaryStream(input) {
+  let cursor = input.afterCursor ?? null;
+  await consumeBody({
+    response: input.response,
+    ...input.signal ? { signal: input.signal } : {},
+    decoder: input.decoder,
+    async onPayload(payload) {
+      const event = parseThreadSummarySsePayload(payload);
+      if (event.event !== "snapshot_required" && cursor !== null && event.cursor <= cursor) return;
+      cursor = cursor === null ? event.cursor : Math.max(cursor, event.cursor);
+      await input.onEvent(event);
+      input.onCursor?.(cursor);
+    }
+  });
+  return cursor;
+}
+
+// src/client.ts
+function objectResult(value, operation) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Agents24ClientError(`${operation} returned an invalid response.`, {
+      kind: "protocol",
+      code: "INVALID_JSON_RESPONSE"
+    });
+  }
+  return value;
+}
+function deploymentPath(deploymentId, suffix) {
+  return `/public/client-runtime/deployments/${encodePath(deploymentId)}${suffix}`;
+}
+function shouldReconnect(error) {
+  return error instanceof Agents24ClientError && error.kind === "network" && error.retryable;
+}
+function createAgents24Client(options) {
+  if (!options.deploymentId || /[\r\n\0/]/.test(options.deploymentId)) {
+    throw new Agents24ClientError("deploymentId is invalid.", {
+      kind: "configuration",
+      code: "INVALID_DEPLOYMENT_ID"
+    });
+  }
+  if (options.transport !== void 0 && options.transport !== "auto" && options.transport !== "fetch") {
+    throw new Agents24ClientError("The requested transport is unavailable.", {
+      kind: "missing_capability",
+      code: "MISSING_TRANSPORT"
+    });
+  }
+  const baseUrl = normalizeBaseUrl(options.baseUrl);
+  const fetch = resolveFetch(options.fetch);
+  const decoder = resolveDecoderFactory(options.decoder);
+  const clock = options.clock ?? defaultClock();
+  const ids = options.ids ?? defaultIds();
+  const maxReconnectAttempts = Math.max(0, Math.min(options.maxReconnectAttempts ?? 3, 10));
+  const http = new AuthenticatedHttp({
+    baseUrl,
+    sessionProvider: options.sessionProvider,
+    fetch,
+    clock,
+    ...options.telemetry ? { telemetry: options.telemetry } : {}
+  });
+  const emit = async (event) => {
+    try {
+      await options.telemetry?.emit(event);
+    } catch {
+    }
+  };
+  const attach = async (runId, cursor, headers, signal, onEvent, onProgress) => {
+    const response = await http.request(
+      "POST",
+      deploymentPath(options.deploymentId, `/runs/${encodePath(runId)}/attach`),
+      {
+        operation: "runs.attach",
+        accept: "text/event-stream",
+        body: cursor === void 0 ? {} : { cursor },
+        ...headers ? { headers } : {},
+        ...signal ? { signal } : {}
+      }
+    );
+    return consumeRuntimeStream({
+      response,
+      decoder: decoder(),
+      onEvent,
+      ...signal ? { signal } : {},
+      ...cursor === void 0 ? {} : { afterCursor: cursor },
+      ...onProgress ? { onProgress } : {}
+    });
+  };
+  const reconnect = async (initial, signal, onEvent, operation, headers) => {
+    let state;
+    let attempt = 0;
+    const onProgress = (next) => {
+      if (!state) {
+        void emit({
+          type: "stream.connected",
+          operation,
+          ...next.runId ? { runId: next.runId } : {},
+          ...next.cursor === null ? {} : { cursor: next.cursor },
+          attempt
+        });
+      }
+      state = next;
+    };
+    while (true) {
+      try {
+        state = state?.runId ? await attach(state.runId, state.cursor ?? void 0, headers, signal, onEvent, onProgress) : await initial(onProgress);
+      } catch (error) {
+        if (signal?.aborted || !shouldReconnect(error) || attempt >= maxReconnectAttempts) throw error;
+        attempt += 1;
+        await emit({
+          type: "stream.reconnecting",
+          operation,
+          ...state?.runId ? { runId: state.runId } : {},
+          ...state?.cursor == null ? {} : { cursor: state.cursor },
+          attempt,
+          reason: "network"
+        });
+        continue;
+      }
+      if (!state.detached || signal?.aborted) {
+        await emit({
+          type: "stream.completed",
+          operation,
+          ...state.runId ? { runId: state.runId } : {},
+          ...state.cursor === null ? {} : { cursor: state.cursor },
+          attempt
+        });
+        return state;
+      }
+      await emit({
+        type: "stream.detached",
+        operation,
+        ...state.runId ? { runId: state.runId } : {},
+        ...state.cursor === null ? {} : { cursor: state.cursor },
+        attempt,
+        reason: state.detachReason ?? "server_detach"
+      });
+      if (attempt >= maxReconnectAttempts || state.detachReason === "revoked" || state.detachReason === "policy_changed") {
+        return state;
+      }
+      if (state.detachReason === "token_expired" && options.sessionProvider.refresh) {
+        await options.sessionProvider.refresh({ reason: "stream_detached", ...signal ? { signal } : {} });
+      }
+      attempt += 1;
+    }
+  };
+  return {
+    async bootstrap(input) {
+      let response;
+      try {
+        response = await fetch(
+          `${baseUrl}${deploymentPath(options.deploymentId, "/bootstrap")}`,
+          {
+            method: "GET",
+            headers: { Accept: "application/json", "Cache-Control": "no-store", Pragma: "no-cache" },
+            redirect: "error",
+            cache: "no-store",
+            credentials: "omit",
+            ...input?.signal ? { signal: input.signal } : {}
+          }
+        );
+      } catch (cause) {
+        throw new Agents24ClientError("The Agents24 deployment bootstrap could not be reached.", {
+          kind: input?.signal?.aborted ? "aborted" : "network",
+          code: input?.signal?.aborted ? "ABORTED" : "NETWORK_ERROR",
+          retryable: !input?.signal?.aborted,
+          cause
+        });
+      }
+      if (response.redirected || response.status >= 300 && response.status < 400) {
+        throw new Agents24ClientError("Client-runtime redirects are not allowed.", {
+          kind: "network",
+          code: "REDIRECT_REJECTED",
+          status: response.status
+        });
+      }
+      if (!response.ok) throw await responseError(response);
+      return objectResult(await responseJson(response), "Bootstrap");
+    },
+    chat: {
+      async stream(input, onEvent) {
+        const initial = async (onProgress) => {
+          const response = await http.request(
+            "POST",
+            deploymentPath(options.deploymentId, "/chat/stream"),
+            {
+              operation: "chat.stream",
+              accept: "text/event-stream",
+              idempotencyKey: input.idempotencyKey,
+              ...input.headers ? { headers: input.headers } : {},
+              body: {
+                input: input.input,
+                attachment_ids: [...input.attachmentIds ?? []],
+                ...input.threadId ? { thread_id: input.threadId } : {},
+                ...input.requestedModelId ? { requested_model_id: input.requestedModelId } : {},
+                tool_inputs: input.toolInputs ?? {},
+                metadata: input.metadata ?? {},
+                client: input.client ?? { sdk_name: "@agents24/client", sdk_version: "0.1.0" }
+              },
+              ...input.signal ? { signal: input.signal } : {}
+            }
+          );
+          return consumeRuntimeStream({
+            response,
+            decoder: decoder(),
+            onEvent,
+            ...input.signal ? { signal: input.signal } : {},
+            onProgress
+          });
+        };
+        return reconnect(initial, input.signal, onEvent, "chat.stream", input.headers);
+      }
+    },
+    runs: {
+      async attach(input, onEvent) {
+        const initial = (onProgress) => attach(input.runId, input.cursor, input.headers, input.signal, onEvent, onProgress);
+        return reconnect(initial, input.signal, onEvent, "runs.attach", input.headers);
+      },
+      async cancel(input) {
+        const result = await http.json(
+          "POST",
+          deploymentPath(options.deploymentId, `/runs/${encodePath(input.runId)}/cancel`),
+          {
+            operation: "runs.cancel",
+            body: {},
+            idempotencyKey: input.idempotencyKey,
+            ...input.signal ? { signal: input.signal } : {}
+          }
+        );
+        return objectResult(result, "Run cancellation");
+      }
+    },
+    threads: {
+      async list(input) {
+        const path = appendQuery(deploymentPath(options.deploymentId, "/threads"), {
+          skip: input?.skip,
+          limit: input?.limit
+        });
+        const result = await http.json("GET", path, {
+          operation: "threads.list",
+          ...input?.signal ? { signal: input.signal } : {}
+        });
+        return objectResult(result, "Thread listing");
+      },
+      async get(input) {
+        const path = appendQuery(
+          deploymentPath(options.deploymentId, `/threads/${encodePath(input.threadId)}`),
+          {
+            limit: input.limit,
+            before_turn_index: input.beforeTurnIndex,
+            include_run_events: input.includeRunEvents
+          }
+        );
+        const result = await http.json("GET", path, {
+          operation: "threads.get",
+          ...input.signal ? { signal: input.signal } : {}
+        });
+        return objectResult(result, "Thread detail");
+      },
+      async events(input, onEvent) {
+        let cursor = input.cursor;
+        let attempts = 0;
+        while (!input.signal?.aborted) {
+          try {
+            const path = appendQuery(deploymentPath(options.deploymentId, "/threads/events"), { cursor });
+            const response = await http.request("GET", path, {
+              operation: "threads.events",
+              accept: "text/event-stream",
+              ...input.signal ? { signal: input.signal } : {}
+            });
+            cursor = await consumeThreadSummaryStream({
+              response,
+              decoder: decoder(),
+              onEvent,
+              ...input.signal ? { signal: input.signal } : {},
+              ...cursor === void 0 ? {} : { afterCursor: cursor },
+              onCursor(next) {
+                cursor = next;
+              }
+            }) ?? void 0;
+            return;
+          } catch (error) {
+            if (input.signal?.aborted || !shouldReconnect(error) || attempts >= maxReconnectAttempts) throw error;
+            attempts += 1;
+          }
+        }
+      },
+      async delete(input) {
+        const result = await http.json(
+          "DELETE",
+          deploymentPath(options.deploymentId, `/threads/${encodePath(input.threadId)}`),
+          {
+            operation: "threads.delete",
+            idempotencyKey: input.idempotencyKey,
+            ...input.signal ? { signal: input.signal } : {}
+          }
+        );
+        return objectResult(result, "Thread deletion");
+      }
+    },
+    attachments: {
+      async upload(input) {
+        const multipart = options.multipart ?? createByteMultipartEncoder(resolveEncoder(options.encoder));
+        const encoded = await multipart.encode([
+          ...input.threadId ? [{ field: "thread_id", value: input.threadId }] : [],
+          { field: "files", value: input.upload }
+        ]);
+        const result = await http.json(
+          "POST",
+          deploymentPath(options.deploymentId, "/attachments/upload"),
+          {
+            operation: "attachments.upload",
+            rawBody: encoded.body,
+            contentType: encoded.contentType,
+            idempotencyKey: input.idempotencyKey,
+            ...input.signal ? { signal: input.signal } : {}
+          }
+        );
+        const body = objectResult(result, "Attachment upload");
+        const item = Array.isArray(body.items) ? body.items[0] : body;
+        return objectResult(item, "Attachment upload");
+      }
+    },
+    hitl: {
+      async resume(input) {
+        const result = await http.json(
+          "POST",
+          deploymentPath(
+            options.deploymentId,
+            `/runs/${encodePath(input.runId)}/hitl/${encodePath(input.interruptId)}/resume`
+          ),
+          {
+            operation: "hitl.resume",
+            idempotencyKey: input.idempotencyKey,
+            body: {
+              schema_version: "agents24.hitl.resume.v2",
+              interrupt_id: input.interruptId,
+              action: input.action,
+              ...input.comment ? { comment: input.comment } : {}
+            },
+            ...input.signal ? { signal: input.signal } : {}
+          }
+        );
+        return objectResult(result, "HITL resume");
+      }
+    },
+    mcp: {
+      async startAuthorization(input) {
+        const result = await http.json(
+          "POST",
+          deploymentPath(
+            options.deploymentId,
+            `/runs/${encodePath(input.runId)}/mcp/servers/${encodePath(input.serverId)}/auth/start`
+          ),
+          {
+            operation: "mcp.startAuthorization",
+            idempotencyKey: input.idempotencyKey,
+            body: {
+              interrupt_id: input.interruptId,
+              redirect_uri: input.redirectUri,
+              popup_nonce: input.popupNonce,
+              code_challenge: input.codeChallenge,
+              code_challenge_method: "S256"
+            },
+            ...input.signal ? { signal: input.signal } : {}
+          }
+        );
+        return objectResult(result, "MCP authorization start");
+      },
+      async redeemCallback(input) {
+        const result = await http.json(
+          "POST",
+          deploymentPath(options.deploymentId, "/mcp/callback/redeem"),
+          {
+            operation: "mcp.redeemCallback",
+            idempotencyKey: input.idempotencyKey,
+            body: { code: input.code, code_verifier: input.codeVerifier },
+            ...input.signal ? { signal: input.signal } : {}
+          }
+        );
+        return objectResult(result, "MCP callback redemption");
+      }
+    },
+    sessions: {
+      async revoke(input) {
+        if (!options.sessionProvider.revoke) {
+          throw new Agents24ClientError("The configured session provider cannot revoke sessions.", {
+            kind: "missing_capability",
+            code: "SESSION_REVOKE_UNAVAILABLE"
+          });
+        }
+        await options.sessionProvider.revoke({
+          idempotencyKey: input?.idempotencyKey ?? ids.createId(),
+          ...input?.signal ? { signal: input.signal } : {}
+        });
+      }
+    }
+  };
+}
+
+export { Agents24ClientError, AuthenticatedHttp, absoluteUrl, canonicalHtu, createAgents24Client, createByteMultipartEncoder, defaultClock, defaultIds, dpopTokenRequest, encodePath, missingCapability, normalizeBaseUrl, resolveEncoder, resolveFetch, responseError, responseJson };
+//# sourceMappingURL=chunk-45ITVMX3.js.map
+//# sourceMappingURL=chunk-45ITVMX3.js.map