stitchkit 0.46.0 → 0.47.0

package/dist/tools.js

@@ -2,7 +2,7 @@ import {
   inputIsQuery,
   signJwt,
   verifyPkce
-} from "./index-w1s873ng.js";
+} from "./index-nrytvb30.js";
 import {
   DEFAULT_CORS_ALLOW_HEADERS
 } from "./index-r1qp4rve.js";
@@ -26,7 +26,7 @@ import {
   toolErrorFromResult,
   toolResultFromError,
   writeDownload
-} from "./index-62pqb23z.js";
+} from "./index-kp8xamqp.js";
 import {
   isWithinDir,
   realPathWithinDir,
@@ -34,7 +34,7 @@ import {
 } from "./index-yxpe3phd.js";
 import {
   redact
-} from "./index-c40tkxcd.js";
+} from "./index-8ekq6res.js";
 import {
   AppError,
   getRequestContext,
@@ -45,7 +45,7 @@ import {
   resolvePropagationContext,
   runWithRequestContext,
   typedEntries
-} from "./index-5s8b7z6q.js";
+} from "./index-ee621cmy.js";
 
 // src/tools/agent.ts
 import { jsonSchema, tool } from "ai";
@@ -2158,6 +2158,63 @@ function mountOAuthProvider(config) {
   };
   return dcrEnabled ? [metadataRoute, registerRoute, authorizeRoute, tokenRoute] : [metadataRoute, authorizeRoute, tokenRoute];
 }
+// src/browser/cancellation.ts
+class RequestCancellationError extends Error {
+  cause;
+  constructor(cause) {
+    super(cause === "caller" ? "Request was aborted" : "Request timed out");
+    this.cause = cause;
+    this.name = "RequestCancellationError";
+  }
+}
+function createRequestCancellation(caller, timeoutMs) {
+  if (!caller && timeoutMs === undefined) {
+    return { signal: undefined, run: (operation) => operation() };
+  }
+  const controller = new AbortController;
+  let cause;
+  let timer;
+  const abortFromCaller = () => {
+    if (cause)
+      return;
+    cause = "caller";
+    controller.abort(caller?.reason);
+  };
+  if (caller?.aborted)
+    abortFromCaller();
+  else
+    caller?.addEventListener("abort", abortFromCaller, { once: true });
+  if (timeoutMs !== undefined) {
+    timer = setTimeout(() => {
+      if (cause)
+        return;
+      cause = "timeout";
+      controller.abort(new DOMException("Request timed out", "TimeoutError"));
+    }, timeoutMs);
+  }
+  return {
+    signal: controller.signal,
+    async run(operation) {
+      try {
+        if (cause === "caller")
+          throw cancellationError(cause);
+        return await operation(controller.signal);
+      } catch (error) {
+        if (cause)
+          throw cancellationError(cause);
+        throw error;
+      } finally {
+        if (timer !== undefined)
+          clearTimeout(timer);
+        caller?.removeEventListener("abort", abortFromCaller);
+      }
+    }
+  };
+}
+function cancellationError(cause) {
+  return new RequestCancellationError(cause);
+}
+
 // src/browser/client-multipart.ts
 function isFileDescriptor(value) {
   return typeof value === "object" && value !== null && !(value instanceof Blob) && "uri" in value && typeof value.uri === "string" && "name" in value && typeof value.name === "string" && "type" in value && typeof value.type === "string";
@@ -2176,6 +2233,35 @@ function appendFormFields(formData, values, skipKeys) {
     formData.append(key, typeof value === "string" ? value : JSON.stringify(value));
   }
 }
+function buildMultipartForm(descriptor, values) {
+  const formData = new FormData;
+  const fileFields = new Set(Object.keys(descriptor.files));
+  for (const [field, policy] of Object.entries(descriptor.files)) {
+    const value = values[field];
+    if (value === undefined) {
+      if (policy.required !== false)
+        throw new Error(`Missing multipart file field: ${field}`);
+      continue;
+    }
+    if (policy.multiple === true) {
+      if (!Array.isArray(value) || value.length === 0) {
+        throw new Error(`Multipart file field "${field}" must be a non-empty array`);
+      }
+      for (const file of value) {
+        if (!isMultipartFile(file)) {
+          throw new Error(`Invalid multipart file field: ${field}`);
+        }
+        appendMultipartFile(formData, field, file);
+      }
+      continue;
+    }
+    if (!isMultipartFile(value))
+      throw new Error(`Invalid multipart file field: ${field}`);
+    appendMultipartFile(formData, field, value);
+  }
+  appendFormFields(formData, values, fileFields);
+  return formData;
+}
 
 // src/browser/client-url.ts
 function isParamArray(value) {
@@ -2379,95 +2465,108 @@ function setClientMethod(target, key, method) {
 function createHttpMethod(endpoint, prefix, client, config) {
   const httpMethod = endpoint.method.toLowerCase();
   return (...args) => {
-    const firstArg = args[0] ?? {};
+    const { requestArgs: firstArg, options } = splitClientCall(endpoint, args, config);
     const plan = planClientRequest(endpoint, prefix, firstArg, config);
     if (endpoint.multipart) {
-      const file = firstArg[endpoint.multipart];
-      if (!isMultipartFile(file)) {
-        throw new Error(`Missing multipart file field: ${endpoint.multipart}`);
-      }
       if (httpMethod === "get" || httpMethod === "head" || httpMethod === "delete") {
         throw new Error(`Multipart endpoint ${endpoint.method} ${endpoint.path} must be POST / PUT / PATCH`);
       }
-      const formData = new FormData;
-      appendMultipartFile(formData, endpoint.multipart, file);
-      appendFormFields(formData, plan.remainingArgs, new Set([endpoint.multipart]));
-      return withOutput(endpoint, client[httpMethod](plan.relativeUrl, formData, withTimeout(undefined, endpoint)));
+      const formData = buildMultipartForm(endpoint.multipart, plan.remainingArgs);
+      return withOutput(endpoint, client[httpMethod](plan.relativeUrl, formData, withTimeout(options, endpoint)));
     }
     if (httpMethod === "get" || httpMethod === "head") {
-      return withOutput(endpoint, client[httpMethod](plan.relativeUrl, withTimeout(undefined, endpoint)));
+      return withOutput(endpoint, client[httpMethod](plan.relativeUrl, withTimeout(options, endpoint)));
     }
     if (httpMethod === "delete") {
-      return withOutput(endpoint, client.delete(plan.relativeUrl, withTimeout(undefined, endpoint)));
+      return withOutput(endpoint, client.delete(plan.relativeUrl, withTimeout(options, endpoint)));
     }
-    return withOutput(endpoint, client[httpMethod](plan.relativeUrl, Object.keys(plan.remainingArgs).length > 0 ? plan.remainingArgs : undefined, withTimeout(undefined, endpoint)));
+    return withOutput(endpoint, client[httpMethod](plan.relativeUrl, Object.keys(plan.remainingArgs).length > 0 ? plan.remainingArgs : undefined, withTimeout(options, endpoint)));
   };
 }
 function createFetchMethod(endpoint, prefix, config, contractConfig) {
-  return async (args) => {
-    const plan = planClientRequest(endpoint, prefix, args ?? {}, contractConfig);
+  return async (...callArgs) => {
+    const { requestArgs, options } = splitClientCall(endpoint, callArgs, contractConfig);
+    const plan = planClientRequest(endpoint, prefix, requestArgs, contractConfig);
     const url = joinClientBaseUrl(config.baseUrl, plan.relativeUrl);
     const headers = {
       Accept: "application/json",
       ...typeof config.headers === "function" ? config.headers() : config.headers
     };
-    const signal = endpoint.timeout !== undefined ? AbortSignal.timeout(endpoint.timeout) : undefined;
-    const hasBody = endpoint.method !== "GET" && endpoint.method !== "HEAD" && endpoint.method !== "DELETE" && !endpoint.multipart && endpoint.input && args;
+    const cancellation = createRequestCancellation(options?.signal, endpoint.timeout ?? config.timeout ?? 30000);
+    const hasBody = endpoint.method !== "GET" && endpoint.method !== "HEAD" && endpoint.method !== "DELETE" && !endpoint.multipart && endpoint.input && Object.keys(plan.remainingArgs).length > 0;
     if (hasBody)
       headers["Content-Type"] = "application/json";
-    if (endpoint.multipart && args) {
-      const file = args[endpoint.multipart];
-      if (!isMultipartFile(file)) {
-        throw new Error(`Missing multipart file field: ${endpoint.multipart}`);
-      }
-      const formData = new FormData;
-      appendMultipartFile(formData, endpoint.multipart, file);
-      appendFormFields(formData, plan.remainingArgs, new Set([endpoint.multipart]));
-      const res2 = await fetch(url, {
-        method: endpoint.method,
-        headers,
-        credentials: config.credentials,
-        body: formData,
-        signal
-      });
-      if (!res2.ok) {
-        await throwForErrorResponse(res2, config, null);
-      }
-      if (endpoint.rawResponse)
-        return res2;
-      if (!endpoint.output) {
-        const text = await res2.text();
-        if (text.length > 0) {
-          throw new Error("Server returned data for an endpoint with no output contract");
+    try {
+      return await cancellation.run(async (signal) => {
+        const body = endpoint.multipart ? buildMultipartForm(endpoint.multipart, plan.remainingArgs) : hasBody ? JSON.stringify(plan.remainingArgs) : undefined;
+        const res = await fetch(url, {
+          method: endpoint.method,
+          headers,
+          credentials: config.credentials,
+          signal,
+          ...body !== undefined && { body }
+        });
+        if (!res.ok) {
+          await throwForErrorResponse(res, config, { error: res.statusText });
         }
-        return;
-      }
-      return endpoint.output.parse(await res2.json());
-    }
-    const res = await fetch(url, {
-      method: endpoint.method,
-      headers,
-      credentials: config.credentials,
-      signal,
-      ...hasBody && {
-        body: JSON.stringify(plan.remainingArgs)
-      }
-    });
-    if (!res.ok) {
-      await throwForErrorResponse(res, config, { error: res.statusText });
-    }
-    if (endpoint.rawResponse)
-      return res;
-    if (!endpoint.output) {
-      const text = await res.text();
-      if (text.length > 0) {
-        throw new Error("Server returned data for an endpoint with no output contract");
+        if (endpoint.rawResponse)
+          return res;
+        if (!endpoint.output) {
+          const text = await res.text();
+          if (text.length > 0) {
+            throw new Error("Server returned data for an endpoint with no output contract");
+          }
+          return;
+        }
+        return endpoint.output.parse(await res.json());
+      });
+    } catch (error) {
+      if (error instanceof RequestCancellationError) {
+        throw new ApiError(error.cause === "caller" ? "REQUEST_ABORTED" : "REQUEST_TIMEOUT", 0, undefined, error.message);
       }
-      return;
+      if (ApiError.is(error))
+        throw error;
+      const message = error instanceof Error ? error.message : undefined;
+      throw new ApiError("UNKNOWN_ERROR", 0, message ? { message } : undefined, message);
     }
-    return endpoint.output.parse(await res.json());
   };
 }
+function endpointHasArguments(endpoint) {
+  return Boolean(endpoint.params || endpoint.input || endpoint.multipart);
+}
+function splitClientCall(endpoint, args, contractConfig) {
+  const hasScopedArguments = (contractConfig?.stripPrefixKeys?.length ?? 0) > 0;
+  if (!endpointHasArguments(endpoint) && !hasScopedArguments) {
+    return {
+      requestArgs: {},
+      options: readClientRequestOptions(args[0])
+    };
+  }
+  const requestArgs = args[0];
+  if (requestArgs !== undefined && !isRecord(requestArgs)) {
+    throw new TypeError("Endpoint arguments must be an object");
+  }
+  return {
+    requestArgs: requestArgs ?? {},
+    options: readClientRequestOptions(args[1])
+  };
+}
+function readClientRequestOptions(value) {
+  if (value === undefined)
+    return;
+  if (!isRecord(value))
+    throw new TypeError("Client request options must be an object");
+  const signal = value.signal;
+  if (signal === undefined)
+    return {};
+  if (!isAbortSignal(signal)) {
+    throw new TypeError("Client request signal must be an AbortSignal");
+  }
+  return { signal };
+}
+function isAbortSignal(value) {
+  return typeof value === "object" && value !== null && "aborted" in value && typeof value.aborted === "boolean" && "addEventListener" in value && typeof value.addEventListener === "function" && "removeEventListener" in value && typeof value.removeEventListener === "function";
+}
 async function throwForErrorResponse(res, config, fallbackBody) {
   const body = await res.json().catch(() => fallbackBody);
   config.onError?.(res.status, body);