@agents24/client 0.1.0 → 0.2.0

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

@@ -1,4 +1,4 @@
-import { createSseParser, Agents24ProtocolError, parseRuntimeSsePayload, parseThreadSummarySsePayload } from './chunk-VVLMMNXI.js';
+import { createSseParser, Agents24ProtocolError, parseRuntimeSsePayload, parseThreadSummarySsePayload } from './chunk-NGZUJ3YT.js';
 
 // src/errors.ts
 var Agents24ClientError = class extends Error {
@@ -85,78 +85,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;
@@ -212,7 +140,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,7 +158,7 @@ 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) {
@@ -317,7 +245,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 +261,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,
@@ -371,7 +299,7 @@ var AuthenticatedHttp = class {
       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"));
+        this.#nonces.set(access.sessionId ?? "default", safeToken(challengedNonce, "DPoP nonce"));
         nonceRetried = true;
         retryCount += 1;
         continue;
@@ -413,7 +341,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 +374,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 +391,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;
@@ -591,387 +591,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-SCZMUBXD.js.map
+//# sourceMappingURL=chunk-SCZMUBXD.js.map