@ai-sdk/provider-utils 3.0.0-canary.8 → 3.0.0

package/dist/index.mjs

@@ -39,134 +39,56 @@ function convertAsyncIteratorToReadableStream(iterator) {
 }
 
 // src/delay.ts
-async function delay(delayInMs) {
-  return delayInMs == null ? Promise.resolve() : new Promise((resolve2) => setTimeout(resolve2, delayInMs));
-}
-
-// src/event-source-parser-stream.ts
-function createEventSourceParserStream() {
-  let buffer = "";
-  let event = void 0;
-  let data = [];
-  let lastEventId = void 0;
-  let retry = void 0;
-  function parseLine(line, controller) {
-    if (line === "") {
-      dispatchEvent(controller);
-      return;
-    }
-    if (line.startsWith(":")) {
-      return;
-    }
-    const colonIndex = line.indexOf(":");
-    if (colonIndex === -1) {
-      handleField(line, "");
-      return;
-    }
-    const field = line.slice(0, colonIndex);
-    const valueStart = colonIndex + 1;
-    const value = valueStart < line.length && line[valueStart] === " " ? line.slice(valueStart + 1) : line.slice(valueStart);
-    handleField(field, value);
-  }
-  function dispatchEvent(controller) {
-    if (data.length > 0) {
-      controller.enqueue({
-        event,
-        data: data.join("\n"),
-        id: lastEventId,
-        retry
-      });
-      data = [];
-      event = void 0;
-      retry = void 0;
-    }
-  }
-  function handleField(field, value) {
-    switch (field) {
-      case "event":
-        event = value;
-        break;
-      case "data":
-        data.push(value);
-        break;
-      case "id":
-        lastEventId = value;
-        break;
-      case "retry":
-        const parsedRetry = parseInt(value, 10);
-        if (!isNaN(parsedRetry)) {
-          retry = parsedRetry;
-        }
-        break;
-    }
+async function delay(delayInMs, options) {
+  if (delayInMs == null) {
+    return Promise.resolve();
   }
-  return new TransformStream({
-    transform(chunk, controller) {
-      const { lines, incompleteLine } = splitLines(buffer, chunk);
-      buffer = incompleteLine;
-      for (let i = 0; i < lines.length; i++) {
-        parseLine(lines[i], controller);
-      }
-    },
-    flush(controller) {
-      parseLine(buffer, controller);
-      dispatchEvent(controller);
+  const signal = options == null ? void 0 : options.abortSignal;
+  return new Promise((resolve2, reject) => {
+    if (signal == null ? void 0 : signal.aborted) {
+      reject(createAbortError());
+      return;
     }
+    const timeoutId = setTimeout(() => {
+      cleanup();
+      resolve2();
+    }, delayInMs);
+    const cleanup = () => {
+      clearTimeout(timeoutId);
+      signal == null ? void 0 : signal.removeEventListener("abort", onAbort);
+    };
+    const onAbort = () => {
+      cleanup();
+      reject(createAbortError());
+    };
+    signal == null ? void 0 : signal.addEventListener("abort", onAbort);
   });
 }
-function splitLines(buffer, chunk) {
-  const lines = [];
-  let currentLine = buffer;
-  for (let i = 0; i < chunk.length; ) {
-    const char = chunk[i++];
-    if (char === "\n") {
-      lines.push(currentLine);
-      currentLine = "";
-    } else if (char === "\r") {
-      lines.push(currentLine);
-      currentLine = "";
-      if (chunk[i + 1] === "\n") {
-        i++;
-      }
-    } else {
-      currentLine += char;
-    }
-  }
-  return { lines, incompleteLine: currentLine };
+function createAbortError() {
+  return new DOMException("Delay was aborted", "AbortError");
 }
 
 // src/extract-response-headers.ts
 function extractResponseHeaders(response) {
-  const headers = {};
-  response.headers.forEach((value, key) => {
-    headers[key] = value;
-  });
-  return headers;
+  return Object.fromEntries([...response.headers]);
 }
 
 // src/generate-id.ts
 import { InvalidArgumentError } from "@ai-sdk/provider";
-
-// src/generate-id-custom-alphabet.ts
-function customAlphabet(alphabet, defaultSize) {
-  return (size = defaultSize) => {
-    let id = "";
-    let i = size | 0;
-    while (i--) {
-      id += alphabet[Math.random() * alphabet.length | 0];
-    }
-    return id;
-  };
-}
-
-// src/generate-id.ts
 var createIdGenerator = ({
   prefix,
-  size: defaultSize = 16,
+  size = 16,
   alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
   separator = "-"
 } = {}) => {
-  const generator = customAlphabet(alphabet, defaultSize);
+  const generator = () => {
+    const alphabetLength = alphabet.length;
+    const chars = new Array(size);
+    for (let i = 0; i < size; i++) {
+      chars[i] = alphabet[Math.random() * alphabetLength | 0];
+    }
+    return chars.join("");
+  };
   if (prefix == null) {
     return generator;
   }
@@ -176,7 +98,7 @@ var createIdGenerator = ({
       message: `The separator "${separator}" must not be part of the alphabet "${alphabet}".`
     });
   }
-  return (size) => `${prefix}${separator}${generator(size)}`;
+  return () => `${prefix}${separator}${generator()}`;
 };
 var generateId = createIdGenerator();
 
@@ -195,8 +117,43 @@ function getErrorMessage(error) {
 }
 
 // src/get-from-api.ts
+import { APICallError as APICallError2 } from "@ai-sdk/provider";
+
+// src/handle-fetch-error.ts
 import { APICallError } from "@ai-sdk/provider";
 
+// src/is-abort-error.ts
+function isAbortError(error) {
+  return (error instanceof Error || error instanceof DOMException) && (error.name === "AbortError" || error.name === "ResponseAborted" || // Next.js
+  error.name === "TimeoutError");
+}
+
+// src/handle-fetch-error.ts
+var FETCH_FAILED_ERROR_MESSAGES = ["fetch failed", "failed to fetch"];
+function handleFetchError({
+  error,
+  url,
+  requestBodyValues
+}) {
+  if (isAbortError(error)) {
+    return error;
+  }
+  if (error instanceof TypeError && FETCH_FAILED_ERROR_MESSAGES.includes(error.message.toLowerCase())) {
+    const cause = error.cause;
+    if (cause != null) {
+      return new APICallError({
+        message: `Cannot connect to API: ${cause.message}`,
+        cause,
+        url,
+        requestBodyValues,
+        isRetryable: true
+        // retry when network error
+      });
+    }
+  }
+  return error;
+}
+
 // src/remove-undefined-entries.ts
 function removeUndefinedEntries(record) {
   return Object.fromEntries(
@@ -204,11 +161,6 @@ function removeUndefinedEntries(record) {
   );
 }
 
-// src/is-abort-error.ts
-function isAbortError(error) {
-  return error instanceof Error && (error.name === "AbortError" || error.name === "TimeoutError");
-}
-
 // src/get-from-api.ts
 var getOriginalFetch = () => globalThis.fetch;
 var getFromApi = async ({
@@ -235,10 +187,10 @@ var getFromApi = async ({
           requestBodyValues: {}
         });
       } catch (error) {
-        if (isAbortError(error) || APICallError.isInstance(error)) {
+        if (isAbortError(error) || APICallError2.isInstance(error)) {
           throw error;
         }
-        throw new APICallError({
+        throw new APICallError2({
           message: "Failed to process error response",
           cause: error,
           statusCode: response.status,
@@ -257,11 +209,11 @@ var getFromApi = async ({
       });
     } catch (error) {
       if (error instanceof Error) {
-        if (isAbortError(error) || APICallError.isInstance(error)) {
+        if (isAbortError(error) || APICallError2.isInstance(error)) {
           throw error;
         }
       }
-      throw new APICallError({
+      throw new APICallError2({
         message: "Failed to process successful response",
         cause: error,
         statusCode: response.status,
@@ -271,25 +223,24 @@ var getFromApi = async ({
       });
     }
   } catch (error) {
-    if (isAbortError(error)) {
-      throw error;
-    }
-    if (error instanceof TypeError && error.message === "fetch failed") {
-      const cause = error.cause;
-      if (cause != null) {
-        throw new APICallError({
-          message: `Cannot connect to API: ${cause.message}`,
-          cause,
-          url,
-          isRetryable: true,
-          requestBodyValues: {}
-        });
-      }
-    }
-    throw error;
+    throw handleFetchError({ error, url, requestBodyValues: {} });
   }
 };
 
+// src/is-url-supported.ts
+function isUrlSupported({
+  mediaType,
+  url,
+  supportedUrls
+}) {
+  url = url.toLowerCase();
+  mediaType = mediaType.toLowerCase();
+  return Object.entries(supportedUrls).map(([key, value]) => {
+    const mediaType2 = key.toLowerCase();
+    return mediaType2 === "*" || mediaType2 === "*/*" ? { mediaTypePrefix: "", regexes: value } : { mediaTypePrefix: mediaType2.replace(/\*/, ""), regexes: value };
+  }).filter(({ mediaTypePrefix }) => mediaType.startsWith(mediaTypePrefix)).flatMap(({ regexes }) => regexes).some((pattern) => pattern.test(url));
+}
+
 // src/load-api-key.ts
 import { LoadAPIKeyError } from "@ai-sdk/provider";
 function loadApiKey({
@@ -381,7 +332,7 @@ function loadSetting({
 // src/parse-json.ts
 import {
   JSONParseError,
-  TypeValidationError as TypeValidationError2
+  TypeValidationError as TypeValidationError3
 } from "@ai-sdk/provider";
 
 // src/secure-json-parse.ts
@@ -430,9 +381,10 @@ function secureJsonParse(text) {
 }
 
 // src/validate-types.ts
-import { TypeValidationError } from "@ai-sdk/provider";
+import { TypeValidationError as TypeValidationError2 } from "@ai-sdk/provider";
 
 // src/validator.ts
+import { TypeValidationError } from "@ai-sdk/provider";
 var validatorSymbol = Symbol.for("vercel.ai.validator");
 function validator(validate) {
   return { [validatorSymbol]: true, validate };
@@ -441,53 +393,61 @@ function isValidator(value) {
   return typeof value === "object" && value !== null && validatorSymbol in value && value[validatorSymbol] === true && "validate" in value;
 }
 function asValidator(value) {
-  return isValidator(value) ? value : zodValidator(value);
+  return isValidator(value) ? value : standardSchemaValidator(value);
 }
-function zodValidator(zodSchema) {
-  return validator((value) => {
-    const result = zodSchema.safeParse(value);
-    return result.success ? { success: true, value: result.data } : { success: false, error: result.error };
+function standardSchemaValidator(standardSchema) {
+  return validator(async (value) => {
+    const result = await standardSchema["~standard"].validate(value);
+    return result.issues == null ? { success: true, value: result.value } : {
+      success: false,
+      error: new TypeValidationError({
+        value,
+        cause: result.issues
+      })
+    };
   });
 }
 
 // src/validate-types.ts
-function validateTypes({
+async function validateTypes({
   value,
-  schema: inputSchema
+  schema
 }) {
-  const result = safeValidateTypes({ value, schema: inputSchema });
+  const result = await safeValidateTypes({ value, schema });
   if (!result.success) {
-    throw TypeValidationError.wrap({ value, cause: result.error });
+    throw TypeValidationError2.wrap({ value, cause: result.error });
   }
   return result.value;
 }
-function safeValidateTypes({
+async function safeValidateTypes({
   value,
   schema
 }) {
   const validator2 = asValidator(schema);
   try {
     if (validator2.validate == null) {
-      return { success: true, value };
+      return { success: true, value, rawValue: value };
     }
-    const result = validator2.validate(value);
+    const result = await validator2.validate(value);
     if (result.success) {
-      return result;
+      return { success: true, value: result.value, rawValue: value };
     }
     return {
       success: false,
-      error: TypeValidationError.wrap({ value, cause: result.error })
+      error: TypeValidationError2.wrap({ value, cause: result.error }),
+      rawValue: value
     };
   } catch (error) {
     return {
       success: false,
-      error: TypeValidationError.wrap({ value, cause: error })
+      error: TypeValidationError2.wrap({ value, cause: error }),
+      rawValue: value
     };
   }
 }
 
 // src/parse-json.ts
-function parseJSON({
+async function parseJSON({
   text,
   schema
 }) {
@@ -498,13 +458,13 @@ function parseJSON({
     }
     return validateTypes({ value, schema });
   } catch (error) {
-    if (JSONParseError.isInstance(error) || TypeValidationError2.isInstance(error)) {
+    if (JSONParseError.isInstance(error) || TypeValidationError3.isInstance(error)) {
       throw error;
     }
     throw new JSONParseError({ text, cause: error });
   }
 }
-function safeParseJSON({
+async function safeParseJSON({
   text,
   schema
 }) {
@@ -513,12 +473,12 @@ function safeParseJSON({
     if (schema == null) {
       return { success: true, value, rawValue: value };
     }
-    const validationResult = safeValidateTypes({ value, schema });
-    return validationResult.success ? { ...validationResult, rawValue: value } : validationResult;
+    return await safeValidateTypes({ value, schema });
   } catch (error) {
     return {
       success: false,
-      error: JSONParseError.isInstance(error) ? error : new JSONParseError({ text, cause: error })
+      error: JSONParseError.isInstance(error) ? error : new JSONParseError({ text, cause: error }),
+      rawValue: void 0
     };
   }
 }
@@ -531,9 +491,29 @@ function isParsableJson(input) {
   }
 }
 
+// src/parse-json-event-stream.ts
+import {
+  EventSourceParserStream
+} from "eventsource-parser/stream";
+function parseJsonEventStream({
+  stream,
+  schema
+}) {
+  return stream.pipeThrough(new TextDecoderStream()).pipeThrough(new EventSourceParserStream()).pipeThrough(
+    new TransformStream({
+      async transform({ data }, controller) {
+        if (data === "[DONE]") {
+          return;
+        }
+        controller.enqueue(await safeParseJSON({ text: data, schema }));
+      }
+    })
+  );
+}
+
 // src/parse-provider-options.ts
 import { InvalidArgumentError as InvalidArgumentError2 } from "@ai-sdk/provider";
-function parseProviderOptions({
+async function parseProviderOptions({
   provider,
   providerOptions,
   schema
@@ -541,7 +521,7 @@ function parseProviderOptions({
   if ((providerOptions == null ? void 0 : providerOptions[provider]) == null) {
     return void 0;
   }
-  const parsedProviderOptions = safeValidateTypes({
+  const parsedProviderOptions = await safeValidateTypes({
     value: providerOptions[provider],
     schema
   });
@@ -556,7 +536,7 @@ function parseProviderOptions({
 }
 
 // src/post-to-api.ts
-import { APICallError as APICallError2 } from "@ai-sdk/provider";
+import { APICallError as APICallError3 } from "@ai-sdk/provider";
 var getOriginalFetch2 = () => globalThis.fetch;
 var postJsonToApi = async ({
   url,
@@ -627,10 +607,10 @@ var postToApi = async ({
           requestBodyValues: body.values
         });
       } catch (error) {
-        if (isAbortError(error) || APICallError2.isInstance(error)) {
+        if (isAbortError(error) || APICallError3.isInstance(error)) {
           throw error;
         }
-        throw new APICallError2({
+        throw new APICallError3({
           message: "Failed to process error response",
           cause: error,
           statusCode: response.status,
@@ -649,11 +629,11 @@ var postToApi = async ({
       });
     } catch (error) {
       if (error instanceof Error) {
-        if (isAbortError(error) || APICallError2.isInstance(error)) {
+        if (isAbortError(error) || APICallError3.isInstance(error)) {
           throw error;
         }
       }
-      throw new APICallError2({
+      throw new APICallError3({
         message: "Failed to process successful response",
         cause: error,
         statusCode: response.status,
@@ -663,26 +643,74 @@ var postToApi = async ({
       });
     }
   } catch (error) {
-    if (isAbortError(error)) {
-      throw error;
-    }
-    if (error instanceof TypeError && error.message === "fetch failed") {
-      const cause = error.cause;
-      if (cause != null) {
-        throw new APICallError2({
-          message: `Cannot connect to API: ${cause.message}`,
-          cause,
-          url,
-          requestBodyValues: body.values,
-          isRetryable: true
-          // retry when network error
-        });
-      }
-    }
-    throw error;
+    throw handleFetchError({ error, url, requestBodyValues: body.values });
   }
 };
 
+// src/types/tool.ts
+function tool(tool2) {
+  return tool2;
+}
+function dynamicTool(tool2) {
+  return { ...tool2, type: "dynamic" };
+}
+
+// src/provider-defined-tool-factory.ts
+function createProviderDefinedToolFactory({
+  id,
+  name,
+  inputSchema
+}) {
+  return ({
+    execute,
+    outputSchema,
+    toModelOutput,
+    onInputStart,
+    onInputDelta,
+    onInputAvailable,
+    ...args
+  }) => tool({
+    type: "provider-defined",
+    id,
+    name,
+    args,
+    inputSchema,
+    outputSchema,
+    execute,
+    toModelOutput,
+    onInputStart,
+    onInputDelta,
+    onInputAvailable
+  });
+}
+function createProviderDefinedToolFactoryWithOutputSchema({
+  id,
+  name,
+  inputSchema,
+  outputSchema
+}) {
+  return ({
+    execute,
+    toModelOutput,
+    onInputStart,
+    onInputDelta,
+    onInputAvailable,
+    ...args
+  }) => tool({
+    type: "provider-defined",
+    id,
+    name,
+    args,
+    inputSchema,
+    outputSchema,
+    execute,
+    toModelOutput,
+    onInputStart,
+    onInputDelta,
+    onInputAvailable
+  });
+}
+
 // src/resolve.ts
 async function resolve(value) {
   if (typeof value === "function") {
@@ -692,7 +720,7 @@ async function resolve(value) {
 }
 
 // src/response-handler.ts
-import { APICallError as APICallError3, EmptyResponseBodyError } from "@ai-sdk/provider";
+import { APICallError as APICallError4, EmptyResponseBodyError } from "@ai-sdk/provider";
 var createJsonErrorResponseHandler = ({
   errorSchema,
   errorToMessage,
@@ -703,7 +731,7 @@ var createJsonErrorResponseHandler = ({
   if (responseBody.trim() === "") {
     return {
       responseHeaders,
-      value: new APICallError3({
+      value: new APICallError4({
         message: response.statusText,
         url,
         requestBodyValues,
@@ -715,13 +743,13 @@ var createJsonErrorResponseHandler = ({
     };
   }
   try {
-    const parsedError = parseJSON({
+    const parsedError = await parseJSON({
       text: responseBody,
       schema: errorSchema
     });
     return {
       responseHeaders,
-      value: new APICallError3({
+      value: new APICallError4({
         message: errorToMessage(parsedError),
         url,
         requestBodyValues,
@@ -735,7 +763,7 @@ var createJsonErrorResponseHandler = ({
   } catch (parseError) {
     return {
       responseHeaders,
-      value: new APICallError3({
+      value: new APICallError4({
         message: response.statusText,
         url,
         requestBodyValues,
@@ -754,21 +782,10 @@ var createEventSourceResponseHandler = (chunkSchema) => async ({ response }) =>
   }
   return {
     responseHeaders,
-    value: response.body.pipeThrough(new TextDecoderStream()).pipeThrough(createEventSourceParserStream()).pipeThrough(
-      new TransformStream({
-        transform({ data }, controller) {
-          if (data === "[DONE]") {
-            return;
-          }
-          controller.enqueue(
-            safeParseJSON({
-              text: data,
-              schema: chunkSchema
-            })
-          );
-        }
-      })
-    )
+    value: parseJsonEventStream({
+      stream: response.body,
+      schema: chunkSchema
+    })
   };
 };
 var createJsonStreamResponseHandler = (chunkSchema) => async ({ response }) => {
@@ -781,10 +798,10 @@ var createJsonStreamResponseHandler = (chunkSchema) => async ({ response }) => {
     responseHeaders,
     value: response.body.pipeThrough(new TextDecoderStream()).pipeThrough(
       new TransformStream({
-        transform(chunkText, controller) {
+        async transform(chunkText, controller) {
           if (chunkText.endsWith("\n")) {
             controller.enqueue(
-              safeParseJSON({
+              await safeParseJSON({
                 text: buffer + chunkText,
                 schema: chunkSchema
               })
@@ -800,13 +817,13 @@ var createJsonStreamResponseHandler = (chunkSchema) => async ({ response }) => {
 };
 var createJsonResponseHandler = (responseSchema) => async ({ response, url, requestBodyValues }) => {
   const responseBody = await response.text();
-  const parsedResult = safeParseJSON({
+  const parsedResult = await safeParseJSON({
     text: responseBody,
     schema: responseSchema
   });
   const responseHeaders = extractResponseHeaders(response);
   if (!parsedResult.success) {
-    throw new APICallError3({
+    throw new APICallError4({
       message: "Invalid JSON response",
       cause: parsedResult.error,
       statusCode: response.status,
@@ -825,7 +842,7 @@ var createJsonResponseHandler = (responseSchema) => async ({ response, url, requ
 var createBinaryResponseHandler = () => async ({ response, url, requestBodyValues }) => {
   const responseHeaders = extractResponseHeaders(response);
   if (!response.body) {
-    throw new APICallError3({
+    throw new APICallError4({
       message: "Response body is empty",
       url,
       requestBodyValues,
@@ -841,7 +858,7 @@ var createBinaryResponseHandler = () => async ({ response, url, requestBodyValue
       value: new Uint8Array(buffer)
     };
   } catch (error) {
-    throw new APICallError3({
+    throw new APICallError4({
       message: "Failed to read response as array buffer",
       url,
       requestBodyValues,
@@ -857,7 +874,7 @@ var createStatusCodeErrorResponseHandler = () => async ({ response, url, request
   const responseBody = await response.text();
   return {
     responseHeaders,
-    value: new APICallError3({
+    value: new APICallError4({
       message: response.statusText,
       url,
       requestBodyValues,
@@ -868,6 +885,76 @@ var createStatusCodeErrorResponseHandler = () => async ({ response, url, request
   };
 };
 
+// src/zod-schema.ts
+import * as z4 from "zod/v4";
+import zodToJsonSchema from "zod-to-json-schema";
+function zod3Schema(zodSchema2, options) {
+  var _a;
+  const useReferences = (_a = options == null ? void 0 : options.useReferences) != null ? _a : false;
+  return jsonSchema(
+    zodToJsonSchema(zodSchema2, {
+      $refStrategy: useReferences ? "root" : "none",
+      target: "jsonSchema7"
+      // note: openai mode breaks various gemini conversions
+    }),
+    {
+      validate: async (value) => {
+        const result = await zodSchema2.safeParseAsync(value);
+        return result.success ? { success: true, value: result.data } : { success: false, error: result.error };
+      }
+    }
+  );
+}
+function zod4Schema(zodSchema2, options) {
+  var _a;
+  const useReferences = (_a = options == null ? void 0 : options.useReferences) != null ? _a : false;
+  const z4JSONSchema = z4.toJSONSchema(zodSchema2, {
+    target: "draft-7",
+    io: "output",
+    reused: useReferences ? "ref" : "inline"
+  });
+  return jsonSchema(z4JSONSchema, {
+    validate: async (value) => {
+      const result = await z4.safeParseAsync(zodSchema2, value);
+      return result.success ? { success: true, value: result.data } : { success: false, error: result.error };
+    }
+  });
+}
+function isZod4Schema(zodSchema2) {
+  return "_zod" in zodSchema2;
+}
+function zodSchema(zodSchema2, options) {
+  if (isZod4Schema(zodSchema2)) {
+    return zod4Schema(zodSchema2, options);
+  } else {
+    return zod3Schema(zodSchema2, options);
+  }
+}
+
+// src/schema.ts
+var schemaSymbol = Symbol.for("vercel.ai.schema");
+function jsonSchema(jsonSchema2, {
+  validate
+} = {}) {
+  return {
+    [schemaSymbol]: true,
+    _type: void 0,
+    // should never be used directly
+    [validatorSymbol]: true,
+    jsonSchema: jsonSchema2,
+    validate
+  };
+}
+function isSchema(value) {
+  return typeof value === "object" && value !== null && schemaSymbol in value && value[schemaSymbol] === true && "jsonSchema" in value && "validate" in value;
+}
+function asSchema(schema) {
+  return schema == null ? jsonSchema({
+    properties: {},
+    additionalProperties: false
+  }) : isSchema(schema) ? schema : zodSchema(schema);
+}
+
 // src/uint8-utils.ts
 var { btoa, atob } = globalThis;
 function convertBase64ToUint8Array(base64String) {
@@ -890,7 +977,15 @@ function convertToBase64(value) {
 function withoutTrailingSlash(url) {
   return url == null ? void 0 : url.replace(/\/$/, "");
 }
+
+// src/index.ts
+export * from "@standard-schema/spec";
+import {
+  EventSourceParserStream as EventSourceParserStream2
+} from "eventsource-parser/stream";
 export {
+  EventSourceParserStream2 as EventSourceParserStream,
+  asSchema,
   asValidator,
   combineHeaders,
   convertAsyncIteratorToReadableStream,
@@ -898,25 +993,30 @@ export {
   convertToBase64,
   convertUint8ArrayToBase64,
   createBinaryResponseHandler,
-  createEventSourceParserStream,
   createEventSourceResponseHandler,
   createIdGenerator,
   createJsonErrorResponseHandler,
   createJsonResponseHandler,
   createJsonStreamResponseHandler,
+  createProviderDefinedToolFactory,
+  createProviderDefinedToolFactoryWithOutputSchema,
   createStatusCodeErrorResponseHandler,
   delay,
+  dynamicTool,
   extractResponseHeaders,
   generateId,
   getErrorMessage,
   getFromApi,
   isAbortError,
   isParsableJson,
+  isUrlSupported,
   isValidator,
+  jsonSchema,
   loadApiKey,
   loadOptionalSetting,
   loadSetting,
   parseJSON,
+  parseJsonEventStream,
   parseProviderOptions,
   postFormDataToApi,
   postJsonToApi,
@@ -925,10 +1025,12 @@ export {
   resolve,
   safeParseJSON,
   safeValidateTypes,
+  standardSchemaValidator,
+  tool,
   validateTypes,
   validator,
   validatorSymbol,
   withoutTrailingSlash,
-  zodValidator
+  zodSchema
 };
 //# sourceMappingURL=index.mjs.map