orcaq 1.0.26 → 1.0.28

package/.output/server/node_modules/@ai-sdk/provider-utils/dist/index.mjs

@@ -50,25 +50,30 @@ function convertAsyncIteratorToReadableStream(iterator) {
 // src/create-tool-name-mapping.ts
 function createToolNameMapping({
   tools = [],
-  providerToolNames
+  providerToolNames,
+  resolveProviderToolName
 }) {
+  var _a2;
   const customToolNameToProviderToolName = {};
   const providerToolNameToCustomToolName = {};
   for (const tool2 of tools) {
-    if (tool2.type === "provider" && tool2.id in providerToolNames) {
-      const providerToolName = providerToolNames[tool2.id];
+    if (tool2.type === "provider") {
+      const providerToolName = (_a2 = resolveProviderToolName == null ? void 0 : resolveProviderToolName(tool2)) != null ? _a2 : tool2.id in providerToolNames ? providerToolNames[tool2.id] : void 0;
+      if (providerToolName == null) {
+        continue;
+      }
       customToolNameToProviderToolName[tool2.name] = providerToolName;
       providerToolNameToCustomToolName[providerToolName] = tool2.name;
     }
   }
   return {
     toProviderToolName: (customToolName) => {
-      var _a2;
-      return (_a2 = customToolNameToProviderToolName[customToolName]) != null ? _a2 : customToolName;
+      var _a3;
+      return (_a3 = customToolNameToProviderToolName[customToolName]) != null ? _a3 : customToolName;
     },
     toCustomToolName: (providerToolName) => {
-      var _a2;
-      return (_a2 = providerToolNameToCustomToolName[providerToolName]) != null ? _a2 : providerToolName;
+      var _a3;
+      return (_a3 = providerToolNameToCustomToolName[providerToolName]) != null ? _a3 : providerToolName;
     }
   };
 }
@@ -228,10 +233,165 @@ var DownloadError = class extends (_b = AISDKError, _a = symbol, _b) {
   }
 };
 
+// src/read-response-with-size-limit.ts
+var DEFAULT_MAX_DOWNLOAD_SIZE = 2 * 1024 * 1024 * 1024;
+async function readResponseWithSizeLimit({
+  response,
+  url,
+  maxBytes = DEFAULT_MAX_DOWNLOAD_SIZE
+}) {
+  const contentLength = response.headers.get("content-length");
+  if (contentLength != null) {
+    const length = parseInt(contentLength, 10);
+    if (!isNaN(length) && length > maxBytes) {
+      throw new DownloadError({
+        url,
+        message: `Download of ${url} exceeded maximum size of ${maxBytes} bytes (Content-Length: ${length}).`
+      });
+    }
+  }
+  const body = response.body;
+  if (body == null) {
+    return new Uint8Array(0);
+  }
+  const reader = body.getReader();
+  const chunks = [];
+  let totalBytes = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        break;
+      }
+      totalBytes += value.length;
+      if (totalBytes > maxBytes) {
+        throw new DownloadError({
+          url,
+          message: `Download of ${url} exceeded maximum size of ${maxBytes} bytes.`
+        });
+      }
+      chunks.push(value);
+    }
+  } finally {
+    try {
+      await reader.cancel();
+    } finally {
+      reader.releaseLock();
+    }
+  }
+  const result = new Uint8Array(totalBytes);
+  let offset = 0;
+  for (const chunk of chunks) {
+    result.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return result;
+}
+
+// src/validate-download-url.ts
+function validateDownloadUrl(url) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch (e) {
+    throw new DownloadError({
+      url,
+      message: `Invalid URL: ${url}`
+    });
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new DownloadError({
+      url,
+      message: `URL scheme must be http or https, got ${parsed.protocol}`
+    });
+  }
+  const hostname = parsed.hostname;
+  if (!hostname) {
+    throw new DownloadError({
+      url,
+      message: `URL must have a hostname`
+    });
+  }
+  if (hostname === "localhost" || hostname.endsWith(".local") || hostname.endsWith(".localhost")) {
+    throw new DownloadError({
+      url,
+      message: `URL with hostname ${hostname} is not allowed`
+    });
+  }
+  if (hostname.startsWith("[") && hostname.endsWith("]")) {
+    const ipv6 = hostname.slice(1, -1);
+    if (isPrivateIPv6(ipv6)) {
+      throw new DownloadError({
+        url,
+        message: `URL with IPv6 address ${hostname} is not allowed`
+      });
+    }
+    return;
+  }
+  if (isIPv4(hostname)) {
+    if (isPrivateIPv4(hostname)) {
+      throw new DownloadError({
+        url,
+        message: `URL with IP address ${hostname} is not allowed`
+      });
+    }
+    return;
+  }
+}
+function isIPv4(hostname) {
+  const parts = hostname.split(".");
+  if (parts.length !== 4) return false;
+  return parts.every((part) => {
+    const num = Number(part);
+    return Number.isInteger(num) && num >= 0 && num <= 255 && String(num) === part;
+  });
+}
+function isPrivateIPv4(ip) {
+  const parts = ip.split(".").map(Number);
+  const [a, b] = parts;
+  if (a === 0) return true;
+  if (a === 10) return true;
+  if (a === 127) return true;
+  if (a === 169 && b === 254) return true;
+  if (a === 172 && b >= 16 && b <= 31) return true;
+  if (a === 192 && b === 168) return true;
+  return false;
+}
+function isPrivateIPv6(ip) {
+  const normalized = ip.toLowerCase();
+  if (normalized === "::1") return true;
+  if (normalized === "::") return true;
+  if (normalized.startsWith("::ffff:")) {
+    const mappedPart = normalized.slice(7);
+    if (isIPv4(mappedPart)) {
+      return isPrivateIPv4(mappedPart);
+    }
+    const hexParts = mappedPart.split(":");
+    if (hexParts.length === 2) {
+      const high = parseInt(hexParts[0], 16);
+      const low = parseInt(hexParts[1], 16);
+      if (!isNaN(high) && !isNaN(low)) {
+        const a = high >> 8 & 255;
+        const b = high & 255;
+        const c = low >> 8 & 255;
+        const d = low & 255;
+        return isPrivateIPv4(`${a}.${b}.${c}.${d}`);
+      }
+    }
+  }
+  if (normalized.startsWith("fc") || normalized.startsWith("fd")) return true;
+  if (normalized.startsWith("fe80")) return true;
+  return false;
+}
+
 // src/download-blob.ts
-async function downloadBlob(url) {
+async function downloadBlob(url, options) {
+  var _a2, _b2;
+  validateDownloadUrl(url);
   try {
-    const response = await fetch(url);
+    const response = await fetch(url, {
+      signal: options == null ? void 0 : options.abortSignal
+    });
     if (!response.ok) {
       throw new DownloadError({
         url,
@@ -239,7 +399,13 @@ async function downloadBlob(url) {
         statusText: response.statusText
       });
     }
-    return await response.blob();
+    const data = await readResponseWithSizeLimit({
+      response,
+      url,
+      maxBytes: (_a2 = options == null ? void 0 : options.maxBytes) != null ? _a2 : DEFAULT_MAX_DOWNLOAD_SIZE
+    });
+    const contentType = (_b2 = response.headers.get("content-type")) != null ? _b2 : void 0;
+    return new Blob([data], contentType ? { type: contentType } : void 0);
   } catch (error) {
     if (DownloadError.isInstance(error)) {
       throw error;
@@ -305,6 +471,25 @@ function isAbortError(error) {
 
 // src/handle-fetch-error.ts
 var FETCH_FAILED_ERROR_MESSAGES = ["fetch failed", "failed to fetch"];
+var BUN_ERROR_CODES = [
+  "ConnectionRefused",
+  "ConnectionClosed",
+  "FailedToOpenSocket",
+  "ECONNRESET",
+  "ECONNREFUSED",
+  "ETIMEDOUT",
+  "EPIPE"
+];
+function isBunNetworkError(error) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  const code = error.code;
+  if (typeof code === "string" && BUN_ERROR_CODES.includes(code)) {
+    return true;
+  }
+  return false;
+}
 function handleFetchError({
   error,
   url,
@@ -326,6 +511,15 @@ function handleFetchError({
       });
     }
   }
+  if (isBunNetworkError(error)) {
+    return new APICallError({
+      message: `Cannot connect to API: ${error.message}`,
+      cause: error,
+      url,
+      requestBodyValues,
+      isRetryable: true
+    });
+  }
   return error;
 }
 
@@ -382,7 +576,7 @@ function withUserAgentSuffix(headers, ...userAgentSuffixParts) {
 }
 
 // src/version.ts
-var VERSION = true ? "4.0.4" : "0.0.0-test";
+var VERSION = true ? "4.0.19" : "0.0.0-test";
 
 // src/get-from-api.ts
 var getOriginalFetch = () => globalThis.fetch;
@@ -620,8 +814,8 @@ import {
 } from "@ai-sdk/provider";
 
 // src/secure-json-parse.ts
-var suspectProtoRx = /"__proto__"\s*:/;
-var suspectConstructorRx = /"constructor"\s*:/;
+var suspectProtoRx = /"(?:_|\\u005[Ff])(?:_|\\u005[Ff])(?:p|\\u0070)(?:r|\\u0072)(?:o|\\u006[Ff])(?:t|\\u0074)(?:o|\\u006[Ff])(?:_|\\u005[Ff])(?:_|\\u005[Ff])"\s*:/;
+var suspectConstructorRx = /"(?:c|\\u0063)(?:o|\\u006[Ff])(?:n|\\u006[Ee])(?:s|\\u0073)(?:t|\\u0074)(?:r|\\u0072)(?:u|\\u0075)(?:c|\\u0063)(?:t|\\u0074)(?:o|\\u006[Ff])(?:r|\\u0072)"\s*:/;
 function _parse(text) {
   const obj = JSON.parse(text);
   if (obj === null || typeof obj !== "object") {
@@ -641,7 +835,7 @@ function filter(obj) {
       if (Object.prototype.hasOwnProperty.call(node, "__proto__")) {
         throw new SyntaxError("Object contains forbidden prototype property");
       }
-      if (Object.prototype.hasOwnProperty.call(node, "constructor") && Object.prototype.hasOwnProperty.call(node.constructor, "prototype")) {
+      if (Object.prototype.hasOwnProperty.call(node, "constructor") && node.constructor !== null && typeof node.constructor === "object" && Object.prototype.hasOwnProperty.call(node.constructor, "prototype")) {
         throw new SyntaxError("Object contains forbidden prototype property");
       }
       for (const key in node) {
@@ -1926,9 +2120,11 @@ function asSchema(schema) {
 }
 function standardSchema(standardSchema2) {
   return jsonSchema(
-    () => standardSchema2["~standard"].jsonSchema.input({
-      target: "draft-07"
-    }),
+    () => addAdditionalPropertiesToJsonSchema(
+      standardSchema2["~standard"].jsonSchema.input({
+        target: "draft-07"
+      })
+    ),
     {
       validate: async (value) => {
         const result = await standardSchema2["~standard"].validate(value);
@@ -1993,17 +2189,19 @@ function zodSchema(zodSchema2, options) {
 // src/validate-types.ts
 async function validateTypes({
   value,
-  schema
+  schema,
+  context
 }) {
-  const result = await safeValidateTypes({ value, schema });
+  const result = await safeValidateTypes({ value, schema, context });
   if (!result.success) {
-    throw TypeValidationError2.wrap({ value, cause: result.error });
+    throw TypeValidationError2.wrap({ value, cause: result.error, context });
   }
   return result.value;
 }
 async function safeValidateTypes({
   value,
-  schema
+  schema,
+  context
 }) {
   const actualSchema = asSchema(schema);
   try {
@@ -2016,13 +2214,13 @@ async function safeValidateTypes({
     }
     return {
       success: false,
-      error: TypeValidationError2.wrap({ value, cause: result.error }),
+      error: TypeValidationError2.wrap({ value, cause: result.error, context }),
       rawValue: value
     };
   } catch (error) {
     return {
       success: false,
-      error: TypeValidationError2.wrap({ value, cause: error }),
+      error: TypeValidationError2.wrap({ value, cause: error, context }),
       rawValue: value
     };
   }
@@ -2453,6 +2651,12 @@ var createStatusCodeErrorResponseHandler = () => async ({ response, url, request
   };
 };
 
+// src/strip-file-extension.ts
+function stripFileExtension(filename) {
+  const firstDotIndex = filename.indexOf(".");
+  return firstDotIndex === -1 ? filename : filename.slice(0, firstDotIndex);
+}
+
 // src/without-trailing-slash.ts
 function withoutTrailingSlash(url) {
   return url == null ? void 0 : url.replace(/\/$/, "");
@@ -2483,11 +2687,11 @@ async function* executeTool({
 }
 
 // src/index.ts
-export * from "@standard-schema/spec";
 import {
   EventSourceParserStream as EventSourceParserStream2
 } from "eventsource-parser/stream";
 export {
+  DEFAULT_MAX_DOWNLOAD_SIZE,
   DelayedPromise,
   DownloadError,
   EventSourceParserStream2 as EventSourceParserStream,
@@ -2536,11 +2740,14 @@ export {
   postFormDataToApi,
   postJsonToApi,
   postToApi,
+  readResponseWithSizeLimit,
   removeUndefinedEntries,
   resolve,
   safeParseJSON,
   safeValidateTypes,
+  stripFileExtension,
   tool,
+  validateDownloadUrl,
   validateTypes,
   withUserAgentSuffix,
   withoutTrailingSlash,