@agents24/client 0.1.0 → 0.2.1

package/dist/{chunk-45ITVMX3.js → chunk-GXISGBVW.js}

@@ -1,23 +1,40 @@
-import { createSseParser, Agents24ProtocolError, parseRuntimeSsePayload, parseThreadSummarySsePayload } from './chunk-VVLMMNXI.js';
+import { createSseParser, Agents24ProtocolError, parseRuntimeSsePayload, parseThreadSummarySsePayload } from './chunk-IOVCURGW.js';
 
 // src/errors.ts
 var Agents24ClientError = class extends Error {
   kind;
   code;
   status;
+  failure;
   requestId;
   retryable;
+  violations;
   cause;
   constructor(message, options) {
     super(message);
     this.name = "Agents24ClientError";
     this.kind = options.kind;
-    this.code = options.code ?? "CLIENT_ERROR";
+    this.code = options.failure?.code ?? options.code ?? "CLIENT_ERROR";
     this.status = options.status;
-    this.requestId = options.requestId;
-    this.retryable = options.retryable ?? false;
+    this.failure = options.failure;
+    this.requestId = options.failure?.request_id ?? options.requestId;
+    this.retryable = options.failure?.retryable ?? options.retryable ?? false;
+    const violations = options.failure?.details.violations;
+    this.violations = Array.isArray(violations) ? violations : options.violations ?? [];
     this.cause = options.cause;
   }
+  get failureId() {
+    return this.failure?.failure_id;
+  }
+  get category() {
+    return this.failure?.category;
+  }
+  get retryAfterMs() {
+    return this.failure?.retry_after_ms ?? void 0;
+  }
+  get details() {
+    return this.failure?.details ?? {};
+  }
 };
 function missingCapability(name) {
   return new Agents24ClientError(`Required capability is unavailable: ${name}.`, {
@@ -85,78 +102,6 @@ function secureRandomBytes(length) {
   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;
@@ -187,6 +132,7 @@ function absoluteUrl(baseUrl, path) {
 }
 function canonicalHtu(input) {
   const parsed = new (urlConstructor())(input);
+  parsed.search = "";
   parsed.hash = "";
   return parsed.toString();
 }
@@ -212,7 +158,7 @@ var RESERVED_REQUEST_HEADERS = /* @__PURE__ */ new Set([
   "pragma",
   "proxy-authorization"
 ]);
-function safeToken2(value, field) {
+function safeToken(value, field) {
   if (!value || /[\r\n\0]/.test(value)) {
     throw new Agents24ClientError(`${field} is invalid.`, {
       kind: "configuration",
@@ -230,13 +176,13 @@ function appendAdditionalHeaders(target, additional) {
         code: "RESERVED_REQUEST_HEADER"
       });
     }
-    target[name] = safeToken2(value, `Request header ${name}`);
+    target[name] = safeToken(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";
+  return candidate.schema_version === "agents24.failure.v1" && typeof candidate.failure_id === "string" && typeof candidate.code === "string" && typeof candidate.category === "string" && typeof candidate.message === "string" && typeof candidate.retryable === "boolean" && Boolean(candidate.details && typeof candidate.details === "object" && !Array.isArray(candidate.details));
 }
 async function responseError(response) {
   let body;
@@ -247,11 +193,10 @@ async function responseError(response) {
   }
   if (isPublicError(body)) {
     return new Agents24ClientError(body.message, {
-      kind: errorKindForStatus(response.status),
+      kind: body.code === "RESOURCE_POLICY_QUOTA_EXCEEDED" ? "quota" : errorKindForStatus(response.status),
       code: body.code,
       status: response.status,
-      requestId: body.request_id,
-      retryable: body.retryable
+      failure: body
     });
   }
   return new Agents24ClientError("The Agents24 runtime request failed.", {
@@ -288,6 +233,7 @@ var AuthenticatedHttp = class {
   #clock;
   #telemetry;
   #nonces = /* @__PURE__ */ new Map();
+  #requestQueue = Promise.resolve();
   constructor(options) {
     this.#baseUrl = options.baseUrl;
     this.#provider = options.sessionProvider;
@@ -309,6 +255,19 @@ var AuthenticatedHttp = class {
     return access;
   }
   async request(method, path, options) {
+    let releaseQueue;
+    const previousRequest = this.#requestQueue;
+    this.#requestQueue = new Promise((resolve) => {
+      releaseQueue = resolve;
+    });
+    await previousRequest;
+    try {
+      return await this.#requestUnlocked(method, path, options);
+    } finally {
+      releaseQueue();
+    }
+  }
+  async #requestUnlocked(method, path, options) {
     const url = absoluteUrl(this.#baseUrl, path);
     const startedAt = this.#clock.now();
     let access = await this.#access(options.signal);
@@ -317,7 +276,7 @@ var AuthenticatedHttp = class {
     let retryCount = 0;
     await this.#emit({ type: "request.started", operation: options.operation, method, retryCount });
     while (true) {
-      const token = safeToken2(access.accessToken, "Access token");
+      const token = safeToken(access.accessToken, "Access token");
       if (access.tokenType === "DPoP" && !access.dpopKeyProvider) {
         throw new Agents24ClientError("A DPoP-bound session requires a DPoP key provider.", {
           kind: "configuration",
@@ -333,7 +292,7 @@ var AuthenticatedHttp = class {
       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 (options.idempotencyKey) headers["Idempotency-Key"] = safeToken(options.idempotencyKey, "Idempotency key");
       if (access.dpopKeyProvider) {
         headers.DPoP = await access.dpopKeyProvider.signProof({
           method,
@@ -370,8 +329,10 @@ var AuthenticatedHttp = class {
       }
       assertPrivateResponse(response);
       const challengedNonce = response.headers.get("DPoP-Nonce");
+      if (challengedNonce && access.dpopKeyProvider) {
+        this.#nonces.set(access.sessionId ?? "default", safeToken(challengedNonce, "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;
@@ -413,7 +374,7 @@ async function dpopTokenRequest(input) {
       "Cache-Control": "no-store",
       Pragma: "no-cache"
     };
-    if (input.idempotencyKey) headers["Idempotency-Key"] = safeToken2(input.idempotencyKey, "Idempotency key");
+    if (input.idempotencyKey) headers["Idempotency-Key"] = safeToken(input.idempotencyKey, "Idempotency key");
     if (input.dpopKeyProvider && !(input.prooflessInitialRequest && attempt === 0)) {
       headers.DPoP = await input.dpopKeyProvider.signProof({ method, url: input.url, nonce });
     }
@@ -446,7 +407,7 @@ async function dpopTokenRequest(input) {
     assertPrivateResponse(response);
     const challenge = response.headers.get("DPoP-Nonce");
     if (response.status === 401 && challenge && input.dpopKeyProvider && attempt === 0) {
-      nonce = safeToken2(challenge, "DPoP nonce");
+      nonce = safeToken(challenge, "DPoP nonce");
       continue;
     }
     if (input.prooflessInitialRequest && input.dpopKeyProvider && attempt === 0 && response.ok) {
@@ -463,6 +424,78 @@ async function dpopTokenRequest(input) {
   });
 }
 
+// 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 safeToken2(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 = safeToken2(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 = safeToken2(upload.name, "Upload filename");
+  const mediaType = safeToken2(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/stream.ts
 function detachReason(event) {
   if (event.event !== "run.detached") return void 0;
@@ -528,7 +561,7 @@ async function consumeRuntimeStream(input) {
   let runId = null;
   let resolvedThreadId = null;
   let detached = false;
-  let terminal = false;
+  let streamComplete = false;
   let reason;
   await consumeBody({
     response: input.response,
@@ -537,18 +570,12 @@ async function consumeRuntimeStream(input) {
     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";
+      streamComplete = event.event === "run.completed" || event.event === "run.failed" || event.event === "run.cancelled" || event.event === "run.paused";
       await input.onEvent(event);
       input.onProgress?.({
         runId,
@@ -559,7 +586,7 @@ async function consumeRuntimeStream(input) {
       });
     }
   });
-  if (runId && !terminal && !detached && !input.signal?.aborted) {
+  if (runId && !streamComplete && !detached && !input.signal?.aborted) {
     throw new Agents24ClientError("The runtime stream ended before a terminal or detach event.", {
       kind: "network",
       code: "STREAM_ENDED_BEFORE_TERMINAL",
@@ -591,387 +618,6 @@ async function consumeThreadSummaryStream(input) {
   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
+export { Agents24ClientError, AuthenticatedHttp, absoluteUrl, appendQuery, canonicalHtu, consumeRuntimeStream, consumeThreadSummaryStream, createByteMultipartEncoder, defaultClock, defaultIds, dpopTokenRequest, encodePath, missingCapability, normalizeBaseUrl, resolveDecoderFactory, resolveEncoder, resolveFetch, responseError, responseJson };
+//# sourceMappingURL=chunk-GXISGBVW.js.map
+//# sourceMappingURL=chunk-GXISGBVW.js.map