@ai-sdk/provider-utils 2.2.0 → 2.2.2
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +12 -0
- package/dist/index.d.mts +15 -7
- package/dist/index.d.ts +15 -7
- package/dist/index.js +135 -42
- package/dist/index.js.map +1 -1
- package/dist/index.mjs +118 -28
- package/dist/index.mjs.map +1 -1
- package/package.json +1 -2
- package/test/dist/index.d.mts +49 -60
- package/test/dist/index.d.ts +49 -60
- package/test/dist/index.js +32 -10
- package/test/dist/index.js.map +1 -1
- package/test/dist/index.mjs +31 -10
- package/test/dist/index.mjs.map +1 -1
    
        package/CHANGELOG.md
    CHANGED
    
    | @@ -1,5 +1,17 @@ | |
| 1 1 | 
             
            # @ai-sdk/provider-utils
         | 
| 2 2 |  | 
| 3 | 
            +
            ## 2.2.2
         | 
| 4 | 
            +
             | 
| 5 | 
            +
            ### Patch Changes
         | 
| 6 | 
            +
             | 
| 7 | 
            +
            - b01120e: chore (provider-utils): update unified test server
         | 
| 8 | 
            +
             | 
| 9 | 
            +
            ## 2.2.1
         | 
| 10 | 
            +
             | 
| 11 | 
            +
            ### Patch Changes
         | 
| 12 | 
            +
             | 
| 13 | 
            +
            - f10f0fa: fix (provider-utils): improve event source stream parsing performance
         | 
| 14 | 
            +
             | 
| 3 15 | 
             
            ## 2.2.0
         | 
| 4 16 |  | 
| 5 17 | 
             
            ### Minor Changes
         | 
    
        package/dist/index.d.mts
    CHANGED
    
    | @@ -19,6 +19,14 @@ declare function convertAsyncIteratorToReadableStream<T>(iterator: AsyncIterator | |
| 19 19 | 
             
             */
         | 
| 20 20 | 
             
            declare function delay(delayInMs?: number | null): Promise<void>;
         | 
| 21 21 |  | 
| 22 | 
            +
            type EventSourceChunk = {
         | 
| 23 | 
            +
                event: string | undefined;
         | 
| 24 | 
            +
                data: string;
         | 
| 25 | 
            +
                id?: string;
         | 
| 26 | 
            +
                retry?: number;
         | 
| 27 | 
            +
            };
         | 
| 28 | 
            +
            declare function createEventSourceParserStream(): TransformStream<string, EventSourceChunk>;
         | 
| 29 | 
            +
             | 
| 22 30 | 
             
            /**
         | 
| 23 31 | 
             
            Extracts the headers from a response object and returns them as a key-value object.
         | 
| 24 32 |  | 
| @@ -217,6 +225,12 @@ declare function loadSetting({ settingValue, environmentVariableName, settingNam | |
| 217 225 | 
             
                description: string;
         | 
| 218 226 | 
             
            }): string;
         | 
| 219 227 |  | 
| 228 | 
            +
            declare function parseProviderOptions<T>({ provider, providerOptions, schema, }: {
         | 
| 229 | 
            +
                provider: string;
         | 
| 230 | 
            +
                providerOptions: Record<string, unknown> | undefined;
         | 
| 231 | 
            +
                schema: z.ZodSchema<T>;
         | 
| 232 | 
            +
            }): T | undefined;
         | 
| 233 | 
            +
             | 
| 220 234 | 
             
            declare const postJsonToApi: <T>({ url, headers, body, failedResponseHandler, successfulResponseHandler, abortSignal, fetch, }: {
         | 
| 221 235 | 
             
                url: string;
         | 
| 222 236 | 
             
                headers?: Record<string, string | undefined>;
         | 
| @@ -299,12 +313,6 @@ declare function safeValidateTypes<T>({ value, schema, }: { | |
| 299 313 |  | 
| 300 314 | 
             
            declare function withoutTrailingSlash(url: string | undefined): string | undefined;
         | 
| 301 315 |  | 
| 302 | 
            -
            declare function parseProviderOptions<T>({ provider, providerOptions, schema, }: {
         | 
| 303 | 
            -
                provider: string;
         | 
| 304 | 
            -
                providerOptions: Record<string, unknown> | undefined;
         | 
| 305 | 
            -
                schema: z.ZodSchema<T>;
         | 
| 306 | 
            -
            }): T | undefined;
         | 
| 307 | 
            -
             | 
| 308 316 | 
             
            /**
         | 
| 309 317 | 
             
            Typed tool call that is returned by generateText and streamText.
         | 
| 310 318 | 
             
            It contains the tool call ID, the tool name, and the tool arguments.
         | 
| @@ -355,4 +363,4 @@ interface ToolResult<NAME extends string, ARGS, RESULT> { | |
| 355 363 | 
             
             */
         | 
| 356 364 | 
             
            type CoreToolResult<NAME extends string, ARGS, RESULT> = ToolResult<NAME, ARGS, RESULT>;
         | 
| 357 365 |  | 
| 358 | 
            -
            export { type CoreToolCall, type CoreToolResult, type FetchFunction, type IDGenerator, type ParseResult, type Resolvable, type ResponseHandler, type ToolCall, type ToolResult, type ValidationResult, type Validator, asValidator, combineHeaders, convertAsyncIteratorToReadableStream, convertBase64ToUint8Array, convertUint8ArrayToBase64, createBinaryResponseHandler, createEventSourceResponseHandler, createIdGenerator, createJsonErrorResponseHandler, createJsonResponseHandler, createJsonStreamResponseHandler, createStatusCodeErrorResponseHandler, delay, extractResponseHeaders, generateId, getErrorMessage, getFromApi, isAbortError, isParsableJson, isValidator, loadApiKey, loadOptionalSetting, loadSetting, parseJSON, parseProviderOptions, postJsonToApi, postToApi, removeUndefinedEntries, resolve, safeParseJSON, safeValidateTypes, validateTypes, validator, validatorSymbol, withoutTrailingSlash, zodValidator };
         | 
| 366 | 
            +
            export { type CoreToolCall, type CoreToolResult, type EventSourceChunk, type FetchFunction, type IDGenerator, type ParseResult, type Resolvable, type ResponseHandler, type ToolCall, type ToolResult, type ValidationResult, type Validator, asValidator, combineHeaders, convertAsyncIteratorToReadableStream, convertBase64ToUint8Array, convertUint8ArrayToBase64, createBinaryResponseHandler, createEventSourceParserStream, createEventSourceResponseHandler, createIdGenerator, createJsonErrorResponseHandler, createJsonResponseHandler, createJsonStreamResponseHandler, createStatusCodeErrorResponseHandler, delay, extractResponseHeaders, generateId, getErrorMessage, getFromApi, isAbortError, isParsableJson, isValidator, loadApiKey, loadOptionalSetting, loadSetting, parseJSON, parseProviderOptions, postJsonToApi, postToApi, removeUndefinedEntries, resolve, safeParseJSON, safeValidateTypes, validateTypes, validator, validatorSymbol, withoutTrailingSlash, zodValidator };
         | 
    
        package/dist/index.d.ts
    CHANGED
    
    | @@ -19,6 +19,14 @@ declare function convertAsyncIteratorToReadableStream<T>(iterator: AsyncIterator | |
| 19 19 | 
             
             */
         | 
| 20 20 | 
             
            declare function delay(delayInMs?: number | null): Promise<void>;
         | 
| 21 21 |  | 
| 22 | 
            +
            type EventSourceChunk = {
         | 
| 23 | 
            +
                event: string | undefined;
         | 
| 24 | 
            +
                data: string;
         | 
| 25 | 
            +
                id?: string;
         | 
| 26 | 
            +
                retry?: number;
         | 
| 27 | 
            +
            };
         | 
| 28 | 
            +
            declare function createEventSourceParserStream(): TransformStream<string, EventSourceChunk>;
         | 
| 29 | 
            +
             | 
| 22 30 | 
             
            /**
         | 
| 23 31 | 
             
            Extracts the headers from a response object and returns them as a key-value object.
         | 
| 24 32 |  | 
| @@ -217,6 +225,12 @@ declare function loadSetting({ settingValue, environmentVariableName, settingNam | |
| 217 225 | 
             
                description: string;
         | 
| 218 226 | 
             
            }): string;
         | 
| 219 227 |  | 
| 228 | 
            +
            declare function parseProviderOptions<T>({ provider, providerOptions, schema, }: {
         | 
| 229 | 
            +
                provider: string;
         | 
| 230 | 
            +
                providerOptions: Record<string, unknown> | undefined;
         | 
| 231 | 
            +
                schema: z.ZodSchema<T>;
         | 
| 232 | 
            +
            }): T | undefined;
         | 
| 233 | 
            +
             | 
| 220 234 | 
             
            declare const postJsonToApi: <T>({ url, headers, body, failedResponseHandler, successfulResponseHandler, abortSignal, fetch, }: {
         | 
| 221 235 | 
             
                url: string;
         | 
| 222 236 | 
             
                headers?: Record<string, string | undefined>;
         | 
| @@ -299,12 +313,6 @@ declare function safeValidateTypes<T>({ value, schema, }: { | |
| 299 313 |  | 
| 300 314 | 
             
            declare function withoutTrailingSlash(url: string | undefined): string | undefined;
         | 
| 301 315 |  | 
| 302 | 
            -
            declare function parseProviderOptions<T>({ provider, providerOptions, schema, }: {
         | 
| 303 | 
            -
                provider: string;
         | 
| 304 | 
            -
                providerOptions: Record<string, unknown> | undefined;
         | 
| 305 | 
            -
                schema: z.ZodSchema<T>;
         | 
| 306 | 
            -
            }): T | undefined;
         | 
| 307 | 
            -
             | 
| 308 316 | 
             
            /**
         | 
| 309 317 | 
             
            Typed tool call that is returned by generateText and streamText.
         | 
| 310 318 | 
             
            It contains the tool call ID, the tool name, and the tool arguments.
         | 
| @@ -355,4 +363,4 @@ interface ToolResult<NAME extends string, ARGS, RESULT> { | |
| 355 363 | 
             
             */
         | 
| 356 364 | 
             
            type CoreToolResult<NAME extends string, ARGS, RESULT> = ToolResult<NAME, ARGS, RESULT>;
         | 
| 357 365 |  | 
| 358 | 
            -
            export { type CoreToolCall, type CoreToolResult, type FetchFunction, type IDGenerator, type ParseResult, type Resolvable, type ResponseHandler, type ToolCall, type ToolResult, type ValidationResult, type Validator, asValidator, combineHeaders, convertAsyncIteratorToReadableStream, convertBase64ToUint8Array, convertUint8ArrayToBase64, createBinaryResponseHandler, createEventSourceResponseHandler, createIdGenerator, createJsonErrorResponseHandler, createJsonResponseHandler, createJsonStreamResponseHandler, createStatusCodeErrorResponseHandler, delay, extractResponseHeaders, generateId, getErrorMessage, getFromApi, isAbortError, isParsableJson, isValidator, loadApiKey, loadOptionalSetting, loadSetting, parseJSON, parseProviderOptions, postJsonToApi, postToApi, removeUndefinedEntries, resolve, safeParseJSON, safeValidateTypes, validateTypes, validator, validatorSymbol, withoutTrailingSlash, zodValidator };
         | 
| 366 | 
            +
            export { type CoreToolCall, type CoreToolResult, type EventSourceChunk, type FetchFunction, type IDGenerator, type ParseResult, type Resolvable, type ResponseHandler, type ToolCall, type ToolResult, type ValidationResult, type Validator, asValidator, combineHeaders, convertAsyncIteratorToReadableStream, convertBase64ToUint8Array, convertUint8ArrayToBase64, createBinaryResponseHandler, createEventSourceParserStream, createEventSourceResponseHandler, createIdGenerator, createJsonErrorResponseHandler, createJsonResponseHandler, createJsonStreamResponseHandler, createStatusCodeErrorResponseHandler, delay, extractResponseHeaders, generateId, getErrorMessage, getFromApi, isAbortError, isParsableJson, isValidator, loadApiKey, loadOptionalSetting, loadSetting, parseJSON, parseProviderOptions, postJsonToApi, postToApi, removeUndefinedEntries, resolve, safeParseJSON, safeValidateTypes, validateTypes, validator, validatorSymbol, withoutTrailingSlash, zodValidator };
         | 
    
        package/dist/index.js
    CHANGED
    
    | @@ -36,6 +36,7 @@ __export(src_exports, { | |
| 36 36 | 
             
              convertBase64ToUint8Array: () => convertBase64ToUint8Array,
         | 
| 37 37 | 
             
              convertUint8ArrayToBase64: () => convertUint8ArrayToBase64,
         | 
| 38 38 | 
             
              createBinaryResponseHandler: () => createBinaryResponseHandler,
         | 
| 39 | 
            +
              createEventSourceParserStream: () => createEventSourceParserStream,
         | 
| 39 40 | 
             
              createEventSourceResponseHandler: () => createEventSourceResponseHandler,
         | 
| 40 41 | 
             
              createIdGenerator: () => createIdGenerator,
         | 
| 41 42 | 
             
              createJsonErrorResponseHandler: () => createJsonErrorResponseHandler,
         | 
| @@ -114,6 +115,98 @@ async function delay(delayInMs) { | |
| 114 115 | 
             
              return delayInMs == null ? Promise.resolve() : new Promise((resolve2) => setTimeout(resolve2, delayInMs));
         | 
| 115 116 | 
             
            }
         | 
| 116 117 |  | 
| 118 | 
            +
            // src/event-source-parser-stream.ts
         | 
| 119 | 
            +
            function createEventSourceParserStream() {
         | 
| 120 | 
            +
              let buffer = "";
         | 
| 121 | 
            +
              let event = void 0;
         | 
| 122 | 
            +
              let data = [];
         | 
| 123 | 
            +
              let lastEventId = void 0;
         | 
| 124 | 
            +
              let retry = void 0;
         | 
| 125 | 
            +
              function parseLine(line, controller) {
         | 
| 126 | 
            +
                if (line === "") {
         | 
| 127 | 
            +
                  dispatchEvent(controller);
         | 
| 128 | 
            +
                  return;
         | 
| 129 | 
            +
                }
         | 
| 130 | 
            +
                if (line.startsWith(":")) {
         | 
| 131 | 
            +
                  return;
         | 
| 132 | 
            +
                }
         | 
| 133 | 
            +
                const colonIndex = line.indexOf(":");
         | 
| 134 | 
            +
                if (colonIndex === -1) {
         | 
| 135 | 
            +
                  handleField(line, "");
         | 
| 136 | 
            +
                  return;
         | 
| 137 | 
            +
                }
         | 
| 138 | 
            +
                const field = line.slice(0, colonIndex);
         | 
| 139 | 
            +
                const valueStart = colonIndex + 1;
         | 
| 140 | 
            +
                const value = valueStart < line.length && line[valueStart] === " " ? line.slice(valueStart + 1) : line.slice(valueStart);
         | 
| 141 | 
            +
                handleField(field, value);
         | 
| 142 | 
            +
              }
         | 
| 143 | 
            +
              function dispatchEvent(controller) {
         | 
| 144 | 
            +
                if (data.length > 0) {
         | 
| 145 | 
            +
                  controller.enqueue({
         | 
| 146 | 
            +
                    event,
         | 
| 147 | 
            +
                    data: data.join("\n"),
         | 
| 148 | 
            +
                    id: lastEventId,
         | 
| 149 | 
            +
                    retry
         | 
| 150 | 
            +
                  });
         | 
| 151 | 
            +
                  data = [];
         | 
| 152 | 
            +
                  event = void 0;
         | 
| 153 | 
            +
                  retry = void 0;
         | 
| 154 | 
            +
                }
         | 
| 155 | 
            +
              }
         | 
| 156 | 
            +
              function handleField(field, value) {
         | 
| 157 | 
            +
                switch (field) {
         | 
| 158 | 
            +
                  case "event":
         | 
| 159 | 
            +
                    event = value;
         | 
| 160 | 
            +
                    break;
         | 
| 161 | 
            +
                  case "data":
         | 
| 162 | 
            +
                    data.push(value);
         | 
| 163 | 
            +
                    break;
         | 
| 164 | 
            +
                  case "id":
         | 
| 165 | 
            +
                    lastEventId = value;
         | 
| 166 | 
            +
                    break;
         | 
| 167 | 
            +
                  case "retry":
         | 
| 168 | 
            +
                    const parsedRetry = parseInt(value, 10);
         | 
| 169 | 
            +
                    if (!isNaN(parsedRetry)) {
         | 
| 170 | 
            +
                      retry = parsedRetry;
         | 
| 171 | 
            +
                    }
         | 
| 172 | 
            +
                    break;
         | 
| 173 | 
            +
                }
         | 
| 174 | 
            +
              }
         | 
| 175 | 
            +
              return new TransformStream({
         | 
| 176 | 
            +
                transform(chunk, controller) {
         | 
| 177 | 
            +
                  const { lines, incompleteLine } = splitLines(buffer, chunk);
         | 
| 178 | 
            +
                  buffer = incompleteLine;
         | 
| 179 | 
            +
                  for (let i = 0; i < lines.length; i++) {
         | 
| 180 | 
            +
                    parseLine(lines[i], controller);
         | 
| 181 | 
            +
                  }
         | 
| 182 | 
            +
                },
         | 
| 183 | 
            +
                flush(controller) {
         | 
| 184 | 
            +
                  parseLine(buffer, controller);
         | 
| 185 | 
            +
                  dispatchEvent(controller);
         | 
| 186 | 
            +
                }
         | 
| 187 | 
            +
              });
         | 
| 188 | 
            +
            }
         | 
| 189 | 
            +
            function splitLines(buffer, chunk) {
         | 
| 190 | 
            +
              const lines = [];
         | 
| 191 | 
            +
              let currentLine = buffer;
         | 
| 192 | 
            +
              for (let i = 0; i < chunk.length; ) {
         | 
| 193 | 
            +
                const char = chunk[i++];
         | 
| 194 | 
            +
                if (char === "\n") {
         | 
| 195 | 
            +
                  lines.push(currentLine);
         | 
| 196 | 
            +
                  currentLine = "";
         | 
| 197 | 
            +
                } else if (char === "\r") {
         | 
| 198 | 
            +
                  lines.push(currentLine);
         | 
| 199 | 
            +
                  currentLine = "";
         | 
| 200 | 
            +
                  if (chunk[i + 1] === "\n") {
         | 
| 201 | 
            +
                    i++;
         | 
| 202 | 
            +
                  }
         | 
| 203 | 
            +
                } else {
         | 
| 204 | 
            +
                  currentLine += char;
         | 
| 205 | 
            +
                }
         | 
| 206 | 
            +
              }
         | 
| 207 | 
            +
              return { lines, incompleteLine: currentLine };
         | 
| 208 | 
            +
            }
         | 
| 209 | 
            +
             | 
| 117 210 | 
             
            // src/extract-response-headers.ts
         | 
| 118 211 | 
             
            function extractResponseHeaders(response) {
         | 
| 119 212 | 
             
              const headers = {};
         | 
| @@ -450,8 +543,32 @@ function isParsableJson(input) { | |
| 450 543 | 
             
              }
         | 
| 451 544 | 
             
            }
         | 
| 452 545 |  | 
| 453 | 
            -
            // src/ | 
| 546 | 
            +
            // src/parse-provider-options.ts
         | 
| 454 547 | 
             
            var import_provider7 = require("@ai-sdk/provider");
         | 
| 548 | 
            +
            function parseProviderOptions({
         | 
| 549 | 
            +
              provider,
         | 
| 550 | 
            +
              providerOptions,
         | 
| 551 | 
            +
              schema
         | 
| 552 | 
            +
            }) {
         | 
| 553 | 
            +
              if ((providerOptions == null ? void 0 : providerOptions[provider]) == null) {
         | 
| 554 | 
            +
                return void 0;
         | 
| 555 | 
            +
              }
         | 
| 556 | 
            +
              const parsedProviderOptions = safeValidateTypes({
         | 
| 557 | 
            +
                value: providerOptions[provider],
         | 
| 558 | 
            +
                schema
         | 
| 559 | 
            +
              });
         | 
| 560 | 
            +
              if (!parsedProviderOptions.success) {
         | 
| 561 | 
            +
                throw new import_provider7.InvalidArgumentError({
         | 
| 562 | 
            +
                  argument: "providerOptions",
         | 
| 563 | 
            +
                  message: `invalid ${provider} provider options`,
         | 
| 564 | 
            +
                  cause: parsedProviderOptions.error
         | 
| 565 | 
            +
                });
         | 
| 566 | 
            +
              }
         | 
| 567 | 
            +
              return parsedProviderOptions.value;
         | 
| 568 | 
            +
            }
         | 
| 569 | 
            +
             | 
| 570 | 
            +
            // src/post-to-api.ts
         | 
| 571 | 
            +
            var import_provider8 = require("@ai-sdk/provider");
         | 
| 455 572 | 
             
            var getOriginalFetch2 = () => globalThis.fetch;
         | 
| 456 573 | 
             
            var postJsonToApi = async ({
         | 
| 457 574 | 
             
              url,
         | 
| @@ -502,10 +619,10 @@ var postToApi = async ({ | |
| 502 619 | 
             
                      requestBodyValues: body.values
         | 
| 503 620 | 
             
                    });
         | 
| 504 621 | 
             
                  } catch (error) {
         | 
| 505 | 
            -
                    if (isAbortError(error) ||  | 
| 622 | 
            +
                    if (isAbortError(error) || import_provider8.APICallError.isInstance(error)) {
         | 
| 506 623 | 
             
                      throw error;
         | 
| 507 624 | 
             
                    }
         | 
| 508 | 
            -
                    throw new  | 
| 625 | 
            +
                    throw new import_provider8.APICallError({
         | 
| 509 626 | 
             
                      message: "Failed to process error response",
         | 
| 510 627 | 
             
                      cause: error,
         | 
| 511 628 | 
             
                      statusCode: response.status,
         | 
| @@ -524,11 +641,11 @@ var postToApi = async ({ | |
| 524 641 | 
             
                  });
         | 
| 525 642 | 
             
                } catch (error) {
         | 
| 526 643 | 
             
                  if (error instanceof Error) {
         | 
| 527 | 
            -
                    if (isAbortError(error) ||  | 
| 644 | 
            +
                    if (isAbortError(error) || import_provider8.APICallError.isInstance(error)) {
         | 
| 528 645 | 
             
                      throw error;
         | 
| 529 646 | 
             
                    }
         | 
| 530 647 | 
             
                  }
         | 
| 531 | 
            -
                  throw new  | 
| 648 | 
            +
                  throw new import_provider8.APICallError({
         | 
| 532 649 | 
             
                    message: "Failed to process successful response",
         | 
| 533 650 | 
             
                    cause: error,
         | 
| 534 651 | 
             
                    statusCode: response.status,
         | 
| @@ -544,7 +661,7 @@ var postToApi = async ({ | |
| 544 661 | 
             
                if (error instanceof TypeError && error.message === "fetch failed") {
         | 
| 545 662 | 
             
                  const cause = error.cause;
         | 
| 546 663 | 
             
                  if (cause != null) {
         | 
| 547 | 
            -
                    throw new  | 
| 664 | 
            +
                    throw new import_provider8.APICallError({
         | 
| 548 665 | 
             
                      message: `Cannot connect to API: ${cause.message}`,
         | 
| 549 666 | 
             
                      cause,
         | 
| 550 667 | 
             
                      url,
         | 
| @@ -567,8 +684,7 @@ async function resolve(value) { | |
| 567 684 | 
             
            }
         | 
| 568 685 |  | 
| 569 686 | 
             
            // src/response-handler.ts
         | 
| 570 | 
            -
            var  | 
| 571 | 
            -
            var import_stream = require("eventsource-parser/stream");
         | 
| 687 | 
            +
            var import_provider9 = require("@ai-sdk/provider");
         | 
| 572 688 | 
             
            var createJsonErrorResponseHandler = ({
         | 
| 573 689 | 
             
              errorSchema,
         | 
| 574 690 | 
             
              errorToMessage,
         | 
| @@ -579,7 +695,7 @@ var createJsonErrorResponseHandler = ({ | |
| 579 695 | 
             
              if (responseBody.trim() === "") {
         | 
| 580 696 | 
             
                return {
         | 
| 581 697 | 
             
                  responseHeaders,
         | 
| 582 | 
            -
                  value: new  | 
| 698 | 
            +
                  value: new import_provider9.APICallError({
         | 
| 583 699 | 
             
                    message: response.statusText,
         | 
| 584 700 | 
             
                    url,
         | 
| 585 701 | 
             
                    requestBodyValues,
         | 
| @@ -597,7 +713,7 @@ var createJsonErrorResponseHandler = ({ | |
| 597 713 | 
             
                });
         | 
| 598 714 | 
             
                return {
         | 
| 599 715 | 
             
                  responseHeaders,
         | 
| 600 | 
            -
                  value: new  | 
| 716 | 
            +
                  value: new import_provider9.APICallError({
         | 
| 601 717 | 
             
                    message: errorToMessage(parsedError),
         | 
| 602 718 | 
             
                    url,
         | 
| 603 719 | 
             
                    requestBodyValues,
         | 
| @@ -611,7 +727,7 @@ var createJsonErrorResponseHandler = ({ | |
| 611 727 | 
             
              } catch (parseError) {
         | 
| 612 728 | 
             
                return {
         | 
| 613 729 | 
             
                  responseHeaders,
         | 
| 614 | 
            -
                  value: new  | 
| 730 | 
            +
                  value: new import_provider9.APICallError({
         | 
| 615 731 | 
             
                    message: response.statusText,
         | 
| 616 732 | 
             
                    url,
         | 
| 617 733 | 
             
                    requestBodyValues,
         | 
| @@ -626,11 +742,11 @@ var createJsonErrorResponseHandler = ({ | |
| 626 742 | 
             
            var createEventSourceResponseHandler = (chunkSchema) => async ({ response }) => {
         | 
| 627 743 | 
             
              const responseHeaders = extractResponseHeaders(response);
         | 
| 628 744 | 
             
              if (response.body == null) {
         | 
| 629 | 
            -
                throw new  | 
| 745 | 
            +
                throw new import_provider9.EmptyResponseBodyError({});
         | 
| 630 746 | 
             
              }
         | 
| 631 747 | 
             
              return {
         | 
| 632 748 | 
             
                responseHeaders,
         | 
| 633 | 
            -
                value: response.body.pipeThrough(new TextDecoderStream()).pipeThrough( | 
| 749 | 
            +
                value: response.body.pipeThrough(new TextDecoderStream()).pipeThrough(createEventSourceParserStream()).pipeThrough(
         | 
| 634 750 | 
             
                  new TransformStream({
         | 
| 635 751 | 
             
                    transform({ data }, controller) {
         | 
| 636 752 | 
             
                      if (data === "[DONE]") {
         | 
| @@ -650,7 +766,7 @@ var createEventSourceResponseHandler = (chunkSchema) => async ({ response }) => | |
| 650 766 | 
             
            var createJsonStreamResponseHandler = (chunkSchema) => async ({ response }) => {
         | 
| 651 767 | 
             
              const responseHeaders = extractResponseHeaders(response);
         | 
| 652 768 | 
             
              if (response.body == null) {
         | 
| 653 | 
            -
                throw new  | 
| 769 | 
            +
                throw new import_provider9.EmptyResponseBodyError({});
         | 
| 654 770 | 
             
              }
         | 
| 655 771 | 
             
              let buffer = "";
         | 
| 656 772 | 
             
              return {
         | 
| @@ -682,7 +798,7 @@ var createJsonResponseHandler = (responseSchema) => async ({ response, url, requ | |
| 682 798 | 
             
              });
         | 
| 683 799 | 
             
              const responseHeaders = extractResponseHeaders(response);
         | 
| 684 800 | 
             
              if (!parsedResult.success) {
         | 
| 685 | 
            -
                throw new  | 
| 801 | 
            +
                throw new import_provider9.APICallError({
         | 
| 686 802 | 
             
                  message: "Invalid JSON response",
         | 
| 687 803 | 
             
                  cause: parsedResult.error,
         | 
| 688 804 | 
             
                  statusCode: response.status,
         | 
| @@ -701,7 +817,7 @@ var createJsonResponseHandler = (responseSchema) => async ({ response, url, requ | |
| 701 817 | 
             
            var createBinaryResponseHandler = () => async ({ response, url, requestBodyValues }) => {
         | 
| 702 818 | 
             
              const responseHeaders = extractResponseHeaders(response);
         | 
| 703 819 | 
             
              if (!response.body) {
         | 
| 704 | 
            -
                throw new  | 
| 820 | 
            +
                throw new import_provider9.APICallError({
         | 
| 705 821 | 
             
                  message: "Response body is empty",
         | 
| 706 822 | 
             
                  url,
         | 
| 707 823 | 
             
                  requestBodyValues,
         | 
| @@ -717,7 +833,7 @@ var createBinaryResponseHandler = () => async ({ response, url, requestBodyValue | |
| 717 833 | 
             
                  value: new Uint8Array(buffer)
         | 
| 718 834 | 
             
                };
         | 
| 719 835 | 
             
              } catch (error) {
         | 
| 720 | 
            -
                throw new  | 
| 836 | 
            +
                throw new import_provider9.APICallError({
         | 
| 721 837 | 
             
                  message: "Failed to read response as array buffer",
         | 
| 722 838 | 
             
                  url,
         | 
| 723 839 | 
             
                  requestBodyValues,
         | 
| @@ -733,7 +849,7 @@ var createStatusCodeErrorResponseHandler = () => async ({ response, url, request | |
| 733 849 | 
             
              const responseBody = await response.text();
         | 
| 734 850 | 
             
              return {
         | 
| 735 851 | 
             
                responseHeaders,
         | 
| 736 | 
            -
                value: new  | 
| 852 | 
            +
                value: new import_provider9.APICallError({
         | 
| 737 853 | 
             
                  message: response.statusText,
         | 
| 738 854 | 
             
                  url,
         | 
| 739 855 | 
             
                  requestBodyValues,
         | 
| @@ -763,30 +879,6 @@ function convertUint8ArrayToBase64(array) { | |
| 763 879 | 
             
            function withoutTrailingSlash(url) {
         | 
| 764 880 | 
             
              return url == null ? void 0 : url.replace(/\/$/, "");
         | 
| 765 881 | 
             
            }
         | 
| 766 | 
            -
             | 
| 767 | 
            -
            // src/parse-provider-options.ts
         | 
| 768 | 
            -
            var import_provider9 = require("@ai-sdk/provider");
         | 
| 769 | 
            -
            function parseProviderOptions({
         | 
| 770 | 
            -
              provider,
         | 
| 771 | 
            -
              providerOptions,
         | 
| 772 | 
            -
              schema
         | 
| 773 | 
            -
            }) {
         | 
| 774 | 
            -
              if ((providerOptions == null ? void 0 : providerOptions[provider]) == null) {
         | 
| 775 | 
            -
                return void 0;
         | 
| 776 | 
            -
              }
         | 
| 777 | 
            -
              const parsedProviderOptions = safeValidateTypes({
         | 
| 778 | 
            -
                value: providerOptions[provider],
         | 
| 779 | 
            -
                schema
         | 
| 780 | 
            -
              });
         | 
| 781 | 
            -
              if (!parsedProviderOptions.success) {
         | 
| 782 | 
            -
                throw new import_provider9.InvalidArgumentError({
         | 
| 783 | 
            -
                  argument: "providerOptions",
         | 
| 784 | 
            -
                  message: `invalid ${provider} provider options`,
         | 
| 785 | 
            -
                  cause: parsedProviderOptions.error
         | 
| 786 | 
            -
                });
         | 
| 787 | 
            -
              }
         | 
| 788 | 
            -
              return parsedProviderOptions.value;
         | 
| 789 | 
            -
            }
         | 
| 790 882 | 
             
            // Annotate the CommonJS export names for ESM import in node:
         | 
| 791 883 | 
             
            0 && (module.exports = {
         | 
| 792 884 | 
             
              asValidator,
         | 
| @@ -795,6 +887,7 @@ function parseProviderOptions({ | |
| 795 887 | 
             
              convertBase64ToUint8Array,
         | 
| 796 888 | 
             
              convertUint8ArrayToBase64,
         | 
| 797 889 | 
             
              createBinaryResponseHandler,
         | 
| 890 | 
            +
              createEventSourceParserStream,
         | 
| 798 891 | 
             
              createEventSourceResponseHandler,
         | 
| 799 892 | 
             
              createIdGenerator,
         | 
| 800 893 | 
             
              createJsonErrorResponseHandler,
         |