From 752dabd015c92c26789d2f937c67f76a9d1e83f1 Mon Sep 17 00:00:00 2001 From: Primakov Alexandr Alexandrovich Date: Mon, 10 Feb 2025 22:13:55 +0300 Subject: [PATCH] fix eslint --- .../kfu-m-24-1/eng-it-lean/gigachat/ai.js | 3147 +++++++++-------- .../eng-it-lean/gigachat/gigachat.js | 5 +- .../kfu-m-24-1/eng-it-lean/gigachat/index.js | 2 +- 3 files changed, 1579 insertions(+), 1575 deletions(-) diff --git a/server/routers/kfu-m-24-1/eng-it-lean/gigachat/ai.js b/server/routers/kfu-m-24-1/eng-it-lean/gigachat/ai.js index 6b77ac3..ac0faa5 100644 --- a/server/routers/kfu-m-24-1/eng-it-lean/gigachat/ai.js +++ b/server/routers/kfu-m-24-1/eng-it-lean/gigachat/ai.js @@ -1,24 +1,27 @@ -"use strict"; -var __defProp = Object.defineProperty; -var __getOwnPropDesc = Object.getOwnPropertyDescriptor; -var __getOwnPropNames = Object.getOwnPropertyNames; -var __hasOwnProp = Object.prototype.hasOwnProperty; +/* eslint-disable no-undef */ +/* eslint-disable no-empty */ +/* eslint-disable no-async-promise-executor */ +"use strict" +var __defProp = Object.defineProperty +var __getOwnPropDesc = Object.getOwnPropertyDescriptor +var __getOwnPropNames = Object.getOwnPropertyNames +var __hasOwnProp = Object.prototype.hasOwnProperty var __export = (target, all) => { for (var name14 in all) - __defProp(target, name14, { get: all[name14], enumerable: true }); -}; + __defProp(target, name14, { get: all[name14], enumerable: true }) +} var __copyProps = (to, from, except, desc) => { if (from && typeof from === "object" || typeof from === "function") { for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) - __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); + __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }) } - return to; -}; -var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); + return to +} +var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod) // streams/index.ts -var streams_exports = {}; +var streams_exports = {} __export(streams_exports, { AISDKError: () => import_provider16.AISDKError, APICallError: () => import_provider16.APICallError, @@ -77,81 +80,83 @@ __export(streams_exports, { streamObject: () => streamObject, streamText: () => streamText, tool: () => tool -}); -module.exports = __toCommonJS(streams_exports); +}) +module.exports = __toCommonJS(streams_exports) // core/index.ts -var import_provider_utils12 = require("@ai-sdk/provider-utils"); -var import_ui_utils9 = require("@ai-sdk/ui-utils"); +var import_provider_utils12 = require("@ai-sdk/provider-utils") +var import_ui_utils9 = require("@ai-sdk/ui-utils") // core/data-stream/create-data-stream.ts -var import_ui_utils = require("@ai-sdk/ui-utils"); +var import_ui_utils = require("@ai-sdk/ui-utils") function createDataStream({ execute, onError = () => "An error occurred." // mask error messages for safety by default }) { - let controller; - const ongoingStreamPromises = []; + let controller + const ongoingStreamPromises = [] const stream = new ReadableStream({ start(controllerArg) { - controller = controllerArg; + controller = controllerArg } - }); + }) function safeEnqueue(data) { try { - controller.enqueue(data); + controller.enqueue(data) } catch (error) { + console.error(error) } } try { const result = execute({ writeData(data) { - safeEnqueue((0, import_ui_utils.formatDataStreamPart)("data", [data])); + safeEnqueue((0, import_ui_utils.formatDataStreamPart)("data", [data])) }, writeMessageAnnotation(annotation) { - safeEnqueue((0, import_ui_utils.formatDataStreamPart)("message_annotations", [annotation])); + safeEnqueue((0, import_ui_utils.formatDataStreamPart)("message_annotations", [annotation])) }, merge(streamArg) { ongoingStreamPromises.push( (async () => { - const reader = streamArg.getReader(); + const reader = streamArg.getReader() while (true) { - const { done, value } = await reader.read(); + const { done, value } = await reader.read() if (done) - break; - safeEnqueue(value); + break + safeEnqueue(value) } })().catch((error) => { - safeEnqueue((0, import_ui_utils.formatDataStreamPart)("error", onError(error))); + safeEnqueue((0, import_ui_utils.formatDataStreamPart)("error", onError(error))) }) - ); + ) }, onError - }); + }) if (result) { ongoingStreamPromises.push( result.catch((error) => { - safeEnqueue((0, import_ui_utils.formatDataStreamPart)("error", onError(error))); + safeEnqueue((0, import_ui_utils.formatDataStreamPart)("error", onError(error))) }) - ); + ) } } catch (error) { - safeEnqueue((0, import_ui_utils.formatDataStreamPart)("error", onError(error))); + safeEnqueue((0, import_ui_utils.formatDataStreamPart)("error", onError(error))) } const waitForStreams = new Promise(async (resolve) => { while (ongoingStreamPromises.length > 0) { - await ongoingStreamPromises.shift(); + await ongoingStreamPromises.shift() } - resolve(); - }); + resolve() + }) waitForStreams.finally(() => { try { - controller.close(); + controller.close() } catch (error) { + console.error(error) } - }); - return stream; + }) + return stream } // core/util/prepare-response-headers.ts @@ -159,14 +164,14 @@ function prepareResponseHeaders(headers, { contentType, dataStreamVersion }) { - const responseHeaders = new Headers(headers != null ? headers : {}); + const responseHeaders = new Headers(headers != null ? headers : {}) if (!responseHeaders.has("Content-Type")) { - responseHeaders.set("Content-Type", contentType); + responseHeaders.set("Content-Type", contentType) } if (dataStreamVersion !== void 0) { - responseHeaders.set("X-Vercel-AI-Data-Stream", dataStreamVersion); + responseHeaders.set("X-Vercel-AI-Data-Stream", dataStreamVersion) } - return responseHeaders; + return responseHeaders } // core/data-stream/create-data-stream-response.ts @@ -187,7 +192,7 @@ function createDataStreamResponse({ dataStreamVersion: "v1" }) } - ); + ) } // core/util/prepare-outgoing-http-headers.ts @@ -195,19 +200,19 @@ function prepareOutgoingHttpHeaders(headers, { contentType, dataStreamVersion }) { - const outgoingHeaders = {}; + const outgoingHeaders = {} if (headers != null) { for (const [key, value] of Object.entries(headers)) { - outgoingHeaders[key] = value; + outgoingHeaders[key] = value } } if (outgoingHeaders["Content-Type"] == null) { - outgoingHeaders["Content-Type"] = contentType; + outgoingHeaders["Content-Type"] = contentType } if (dataStreamVersion !== void 0) { - outgoingHeaders["X-Vercel-AI-Data-Stream"] = dataStreamVersion; + outgoingHeaders["X-Vercel-AI-Data-Stream"] = dataStreamVersion } - return outgoingHeaders; + return outgoingHeaders } // core/util/write-to-server-response.ts @@ -218,23 +223,23 @@ function writeToServerResponse({ headers, stream }) { - response.writeHead(status != null ? status : 200, statusText, headers); - const reader = stream.getReader(); + response.writeHead(status != null ? status : 200, statusText, headers) + const reader = stream.getReader() const read = async () => { try { while (true) { - const { done, value } = await reader.read(); + const { done, value } = await reader.read() if (done) - break; - response.write(value); + break + response.write(value) } } catch (error) { - throw error; + console.error(error) } finally { - response.end(); + response.end() } - }; - read(); + } + read() } // core/data-stream/pipe-data-stream-to-response.ts @@ -256,15 +261,15 @@ function pipeDataStreamToResponse(response, { stream: createDataStream({ execute, onError }).pipeThrough( new TextEncoderStream() ) - }); + }) } // errors/invalid-argument-error.ts -var import_provider = require("@ai-sdk/provider"); -var name = "AI_InvalidArgumentError"; -var marker = `vercel.ai.error.${name}`; -var symbol = Symbol.for(marker); -var _a; +var import_provider = require("@ai-sdk/provider") +var name = "AI_InvalidArgumentError" +var marker = `vercel.ai.error.${name}` +var symbol = Symbol.for(marker) +var _a var InvalidArgumentError = class extends import_provider.AISDKError { constructor({ parameter, @@ -274,49 +279,49 @@ var InvalidArgumentError = class extends import_provider.AISDKError { super({ name, message: `Invalid argument for parameter ${parameter}: ${message}` - }); - this[_a] = true; - this.parameter = parameter; - this.value = value; + }) + this[_a] = true + this.parameter = parameter + this.value = value } static isInstance(error) { - return import_provider.AISDKError.hasMarker(error, marker); + return import_provider.AISDKError.hasMarker(error, marker) } -}; -_a = symbol; +} +_a = symbol // util/retry-with-exponential-backoff.ts -var import_provider3 = require("@ai-sdk/provider"); -var import_provider_utils = require("@ai-sdk/provider-utils"); +var import_provider3 = require("@ai-sdk/provider") +var import_provider_utils = require("@ai-sdk/provider-utils") // util/delay.ts async function delay(delayInMs) { - return delayInMs == null ? Promise.resolve() : new Promise((resolve) => setTimeout(resolve, delayInMs)); + return delayInMs == null ? Promise.resolve() : new Promise((resolve) => setTimeout(resolve, delayInMs)) } // util/retry-error.ts -var import_provider2 = require("@ai-sdk/provider"); -var name2 = "AI_RetryError"; -var marker2 = `vercel.ai.error.${name2}`; -var symbol2 = Symbol.for(marker2); -var _a2; +var import_provider2 = require("@ai-sdk/provider") +var name2 = "AI_RetryError" +var marker2 = `vercel.ai.error.${name2}` +var symbol2 = Symbol.for(marker2) +var _a2 var RetryError = class extends import_provider2.AISDKError { constructor({ message, reason, errors }) { - super({ name: name2, message }); - this[_a2] = true; - this.reason = reason; - this.errors = errors; - this.lastError = errors[errors.length - 1]; + super({ name: name2, message }) + this[_a2] = true + this.reason = reason + this.errors = errors + this.lastError = errors[errors.length - 1] } static isInstance(error) { - return import_provider2.AISDKError.hasMarker(error, marker2); + return import_provider2.AISDKError.hasMarker(error, marker2) } -}; -_a2 = symbol2; +} +_a2 = symbol2 // util/retry-with-exponential-backoff.ts var retryWithExponentialBackoff = ({ @@ -327,47 +332,47 @@ var retryWithExponentialBackoff = ({ maxRetries, delayInMs: initialDelayInMs, backoffFactor -}); +}) async function _retryWithExponentialBackoff(f, { maxRetries, delayInMs, backoffFactor }, errors = []) { try { - return await f(); + return await f() } catch (error) { if ((0, import_provider_utils.isAbortError)(error)) { - throw error; + throw error } if (maxRetries === 0) { - throw error; + throw error } - const errorMessage = (0, import_provider_utils.getErrorMessage)(error); - const newErrors = [...errors, error]; - const tryNumber = newErrors.length; + const errorMessage = (0, import_provider_utils.getErrorMessage)(error) + const newErrors = [...errors, error] + const tryNumber = newErrors.length if (tryNumber > maxRetries) { throw new RetryError({ message: `Failed after ${tryNumber} attempts. Last error: ${errorMessage}`, reason: "maxRetriesExceeded", errors: newErrors - }); + }) } if (error instanceof Error && import_provider3.APICallError.isInstance(error) && error.isRetryable === true && tryNumber <= maxRetries) { - await delay(delayInMs); + await delay(delayInMs) return _retryWithExponentialBackoff( f, { maxRetries, delayInMs: backoffFactor * delayInMs, backoffFactor }, newErrors - ); + ) } if (tryNumber === 1) { - throw error; + throw error } throw new RetryError({ message: `Failed after ${tryNumber} attempts with non-retryable error: '${errorMessage}'`, reason: "errorNotRetryable", errors: newErrors - }); + }) } } @@ -381,21 +386,21 @@ function prepareRetries({ parameter: "maxRetries", value: maxRetries, message: "maxRetries must be an integer" - }); + }) } if (maxRetries < 0) { throw new InvalidArgumentError({ parameter: "maxRetries", value: maxRetries, message: "maxRetries must be >= 0" - }); + }) } } - const maxRetriesResult = maxRetries != null ? maxRetries : 2; + const maxRetriesResult = maxRetries != null ? maxRetries : 2 return { maxRetries: maxRetriesResult, retry: retryWithExponentialBackoff({ maxRetries: maxRetriesResult }) - }; + } } // core/telemetry/assemble-operation-name.ts @@ -410,7 +415,7 @@ function assembleOperationName({ // detailed, AI SDK specific data: "ai.operationId": operationId, "ai.telemetry.functionId": telemetry == null ? void 0 : telemetry.functionId - }; + } } // core/telemetry/get-base-telemetry-attributes.ts @@ -420,93 +425,93 @@ function getBaseTelemetryAttributes({ telemetry, headers }) { - var _a14; + var _a14 return { "ai.model.provider": model.provider, "ai.model.id": model.modelId, // settings: ...Object.entries(settings).reduce((attributes, [key, value]) => { - attributes[`ai.settings.${key}`] = value; - return attributes; + attributes[`ai.settings.${key}`] = value + return attributes }, {}), // add metadata as attributes: ...Object.entries((_a14 = telemetry == null ? void 0 : telemetry.metadata) != null ? _a14 : {}).reduce( (attributes, [key, value]) => { - attributes[`ai.telemetry.metadata.${key}`] = value; - return attributes; + attributes[`ai.telemetry.metadata.${key}`] = value + return attributes }, {} ), // request headers ...Object.entries(headers != null ? headers : {}).reduce((attributes, [key, value]) => { if (value !== void 0) { - attributes[`ai.request.headers.${key}`] = value; + attributes[`ai.request.headers.${key}`] = value } - return attributes; + return attributes }, {}) - }; + } } // core/telemetry/get-tracer.ts -var import_api = require("@opentelemetry/api"); +var import_api = require("@opentelemetry/api") // core/telemetry/noop-tracer.ts var noopTracer = { startSpan() { - return noopSpan; + return noopSpan }, startActiveSpan(name14, arg1, arg2, arg3) { if (typeof arg1 === "function") { - return arg1(noopSpan); + return arg1(noopSpan) } if (typeof arg2 === "function") { - return arg2(noopSpan); + return arg2(noopSpan) } if (typeof arg3 === "function") { - return arg3(noopSpan); + return arg3(noopSpan) } } -}; +} var noopSpan = { spanContext() { - return noopSpanContext; + return noopSpanContext }, setAttribute() { - return this; + return this }, setAttributes() { - return this; + return this }, addEvent() { - return this; + return this }, addLink() { - return this; + return this }, addLinks() { - return this; + return this }, setStatus() { - return this; + return this }, updateName() { - return this; + return this }, end() { - return this; + return this }, isRecording() { - return false; + return false }, recordException() { - return this; + return this } -}; +} var noopSpanContext = { traceId: "", spanId: "", traceFlags: 0 -}; +} // core/telemetry/get-tracer.ts function getTracer({ @@ -514,16 +519,16 @@ function getTracer({ tracer } = {}) { if (!isEnabled) { - return noopTracer; + return noopTracer } if (tracer) { - return tracer; + return tracer } - return import_api.trace.getTracer("ai"); + return import_api.trace.getTracer("ai") } // core/telemetry/record-span.ts -var import_api2 = require("@opentelemetry/api"); +var import_api2 = require("@opentelemetry/api") function recordSpan({ name: name14, tracer, @@ -533,11 +538,11 @@ function recordSpan({ }) { return tracer.startActiveSpan(name14, { attributes }, async (span) => { try { - const result = await fn(span); + const result = await fn(span) if (endWhenDone) { - span.end(); + span.end() } - return result; + return result } catch (error) { try { if (error instanceof Error) { @@ -545,20 +550,20 @@ function recordSpan({ name: error.name, message: error.message, stack: error.stack - }); + }) span.setStatus({ code: import_api2.SpanStatusCode.ERROR, message: error.message - }); + }) } else { - span.setStatus({ code: import_api2.SpanStatusCode.ERROR }); + span.setStatus({ code: import_api2.SpanStatusCode.ERROR }) } } finally { - span.end(); + span.end() } - throw error; + throw error } - }); + }) } // core/telemetry/select-telemetry-attributes.ts @@ -567,28 +572,28 @@ function selectTelemetryAttributes({ attributes }) { if ((telemetry == null ? void 0 : telemetry.isEnabled) !== true) { - return {}; + return {} } return Object.entries(attributes).reduce((attributes2, [key, value]) => { if (value === void 0) { - return attributes2; + return attributes2 } if (typeof value === "object" && "input" in value && typeof value.input === "function") { if ((telemetry == null ? void 0 : telemetry.recordInputs) === false) { - return attributes2; + return attributes2 } - const result = value.input(); - return result === void 0 ? attributes2 : { ...attributes2, [key]: result }; + const result = value.input() + return result === void 0 ? attributes2 : { ...attributes2, [key]: result } } if (typeof value === "object" && "output" in value && typeof value.output === "function") { if ((telemetry == null ? void 0 : telemetry.recordOutputs) === false) { - return attributes2; + return attributes2 } - const result = value.output(); - return result === void 0 ? attributes2 : { ...attributes2, [key]: result }; + const result = value.output() + return result === void 0 ? attributes2 : { ...attributes2, [key]: result } } - return { ...attributes2, [key]: value }; - }, {}); + return { ...attributes2, [key]: value } + }, {}) } // core/embed/embed.ts @@ -600,14 +605,14 @@ async function embed({ headers, experimental_telemetry: telemetry }) { - const { maxRetries, retry } = prepareRetries({ maxRetries: maxRetriesArg }); + const { maxRetries, retry } = prepareRetries({ maxRetries: maxRetriesArg }) const baseTelemetryAttributes = getBaseTelemetryAttributes({ model, telemetry, headers, settings: { maxRetries } - }); - const tracer = getTracer(telemetry); + }) + const tracer = getTracer(telemetry) return recordSpan({ name: "ai.embed", attributes: selectTelemetryAttributes({ @@ -639,14 +644,14 @@ async function embed({ }), tracer, fn: async (doEmbedSpan) => { - var _a14; + var _a14 const modelResponse = await model.doEmbed({ values: [value], abortSignal, headers - }); - const embedding2 = modelResponse.embeddings[0]; - const usage2 = (_a14 = modelResponse.usage) != null ? _a14 : { tokens: NaN }; + }) + const embedding2 = modelResponse.embeddings[0] + const usage2 = (_a14 = modelResponse.usage) != null ? _a14 : { tokens: NaN } doEmbedSpan.setAttributes( selectTelemetryAttributes({ telemetry, @@ -659,16 +664,16 @@ async function embed({ "ai.usage.tokens": usage2.tokens } }) - ); + ) return { embedding: embedding2, usage: usage2, rawResponse: modelResponse.rawResponse - }; + } } }) ) - ); + ) span.setAttributes( selectTelemetryAttributes({ telemetry, @@ -677,30 +682,30 @@ async function embed({ "ai.usage.tokens": usage.tokens } }) - ); - return new DefaultEmbedResult({ value, embedding, usage, rawResponse }); + ) + return new DefaultEmbedResult({ value, embedding, usage, rawResponse }) } - }); + }) } var DefaultEmbedResult = class { constructor(options) { - this.value = options.value; - this.embedding = options.embedding; - this.usage = options.usage; - this.rawResponse = options.rawResponse; + this.value = options.value + this.embedding = options.embedding + this.usage = options.usage + this.rawResponse = options.rawResponse } -}; +} // core/util/split-array.ts function splitArray(array, chunkSize) { if (chunkSize <= 0) { - throw new Error("chunkSize must be greater than 0"); + throw new Error("chunkSize must be greater than 0") } - const result = []; + const result = [] for (let i = 0; i < array.length; i += chunkSize) { - result.push(array.slice(i, i + chunkSize)); + result.push(array.slice(i, i + chunkSize)) } - return result; + return result } // core/embed/embed-many.ts @@ -712,14 +717,14 @@ async function embedMany({ headers, experimental_telemetry: telemetry }) { - const { maxRetries, retry } = prepareRetries({ maxRetries: maxRetriesArg }); + const { maxRetries, retry } = prepareRetries({ maxRetries: maxRetriesArg }) const baseTelemetryAttributes = getBaseTelemetryAttributes({ model, telemetry, headers, settings: { maxRetries } - }); - const tracer = getTracer(telemetry); + }) + const tracer = getTracer(telemetry) return recordSpan({ name: "ai.embedMany", attributes: selectTelemetryAttributes({ @@ -735,7 +740,7 @@ async function embedMany({ }), tracer, fn: async (span) => { - const maxEmbeddingsPerCall = model.maxEmbeddingsPerCall; + const maxEmbeddingsPerCall = model.maxEmbeddingsPerCall if (maxEmbeddingsPerCall == null) { const { embeddings: embeddings2, usage } = await retry(() => { return recordSpan({ @@ -756,14 +761,14 @@ async function embedMany({ }), tracer, fn: async (doEmbedSpan) => { - var _a14; + var _a14 const modelResponse = await model.doEmbed({ values, abortSignal, headers - }); - const embeddings3 = modelResponse.embeddings; - const usage2 = (_a14 = modelResponse.usage) != null ? _a14 : { tokens: NaN }; + }) + const embeddings3 = modelResponse.embeddings + const usage2 = (_a14 = modelResponse.usage) != null ? _a14 : { tokens: NaN } doEmbedSpan.setAttributes( selectTelemetryAttributes({ telemetry, @@ -774,11 +779,11 @@ async function embedMany({ "ai.usage.tokens": usage2.tokens } }) - ); - return { embeddings: embeddings3, usage: usage2 }; + ) + return { embeddings: embeddings3, usage: usage2 } } - }); - }); + }) + }) span.setAttributes( selectTelemetryAttributes({ telemetry, @@ -789,12 +794,12 @@ async function embedMany({ "ai.usage.tokens": usage.tokens } }) - ); - return new DefaultEmbedManyResult({ values, embeddings: embeddings2, usage }); + ) + return new DefaultEmbedManyResult({ values, embeddings: embeddings2, usage }) } - const valueChunks = splitArray(values, maxEmbeddingsPerCall); - const embeddings = []; - let tokens = 0; + const valueChunks = splitArray(values, maxEmbeddingsPerCall) + const embeddings = [] + let tokens = 0 for (const chunk of valueChunks) { const { embeddings: responseEmbeddings, usage } = await retry(() => { return recordSpan({ @@ -815,14 +820,14 @@ async function embedMany({ }), tracer, fn: async (doEmbedSpan) => { - var _a14; + var _a14 const modelResponse = await model.doEmbed({ values: chunk, abortSignal, headers - }); - const embeddings2 = modelResponse.embeddings; - const usage2 = (_a14 = modelResponse.usage) != null ? _a14 : { tokens: NaN }; + }) + const embeddings2 = modelResponse.embeddings + const usage2 = (_a14 = modelResponse.usage) != null ? _a14 : { tokens: NaN } doEmbedSpan.setAttributes( selectTelemetryAttributes({ telemetry, @@ -833,13 +838,13 @@ async function embedMany({ "ai.usage.tokens": usage2.tokens } }) - ); - return { embeddings: embeddings2, usage: usage2 }; + ) + return { embeddings: embeddings2, usage: usage2 } } - }); - }); - embeddings.push(...responseEmbeddings); - tokens += usage.tokens; + }) + }) + embeddings.push(...responseEmbeddings) + tokens += usage.tokens } span.setAttributes( selectTelemetryAttributes({ @@ -851,25 +856,25 @@ async function embedMany({ "ai.usage.tokens": tokens } }) - ); + ) return new DefaultEmbedManyResult({ values, embeddings, usage: { tokens } - }); + }) } - }); + }) } var DefaultEmbedManyResult = class { constructor(options) { - this.values = options.values; - this.embeddings = options.embeddings; - this.usage = options.usage; + this.values = options.values + this.embeddings = options.embeddings + this.usage = options.usage } -}; +} // core/generate-image/generate-image.ts -var import_provider_utils2 = require("@ai-sdk/provider-utils"); +var import_provider_utils2 = require("@ai-sdk/provider-utils") async function generateImage({ model, prompt, @@ -882,17 +887,17 @@ async function generateImage({ abortSignal, headers }) { - var _a14; - const { retry } = prepareRetries({ maxRetries: maxRetriesArg }); - const maxImagesPerCall = (_a14 = model.maxImagesPerCall) != null ? _a14 : 1; - const callCount = Math.ceil(n / maxImagesPerCall); + var _a14 + const { retry } = prepareRetries({ maxRetries: maxRetriesArg }) + const maxImagesPerCall = (_a14 = model.maxImagesPerCall) != null ? _a14 : 1 + const callCount = Math.ceil(n / maxImagesPerCall) const callImageCounts = Array.from({ length: callCount }, (_, i) => { if (i < callCount - 1) { - return maxImagesPerCall; + return maxImagesPerCall } - const remainder = n % maxImagesPerCall; - return remainder === 0 ? maxImagesPerCall : remainder; - }); + const remainder = n % maxImagesPerCall + return remainder === 0 ? maxImagesPerCall : remainder + }) const results = await Promise.all( callImageCounts.map( async (callImageCount) => retry( @@ -908,57 +913,57 @@ async function generateImage({ }) ) ) - ); - const images = []; - const warnings = []; + ) + const images = [] + const warnings = [] for (const result of results) { images.push( ...result.images.map((image) => new DefaultGeneratedImage({ image })) - ); - warnings.push(...result.warnings); + ) + warnings.push(...result.warnings) } - return new DefaultGenerateImageResult({ images, warnings }); + return new DefaultGenerateImageResult({ images, warnings }) } var DefaultGenerateImageResult = class { constructor(options) { - this.images = options.images; - this.warnings = options.warnings; + this.images = options.images + this.warnings = options.warnings } get image() { - return this.images[0]; + return this.images[0] } -}; +} var DefaultGeneratedImage = class { constructor({ image }) { - const isUint8Array = image instanceof Uint8Array; - this.base64Data = isUint8Array ? void 0 : image; - this.uint8ArrayData = isUint8Array ? image : void 0; + const isUint8Array = image instanceof Uint8Array + this.base64Data = isUint8Array ? void 0 : image + this.uint8ArrayData = isUint8Array ? image : void 0 } // lazy conversion with caching to avoid unnecessary conversion overhead: get base64() { if (this.base64Data == null) { - this.base64Data = (0, import_provider_utils2.convertUint8ArrayToBase64)(this.uint8ArrayData); + this.base64Data = (0, import_provider_utils2.convertUint8ArrayToBase64)(this.uint8ArrayData) } - return this.base64Data; + return this.base64Data } // lazy conversion with caching to avoid unnecessary conversion overhead: get uint8Array() { if (this.uint8ArrayData == null) { - this.uint8ArrayData = (0, import_provider_utils2.convertBase64ToUint8Array)(this.base64Data); + this.uint8ArrayData = (0, import_provider_utils2.convertBase64ToUint8Array)(this.base64Data) } - return this.uint8ArrayData; + return this.uint8ArrayData } -}; +} // core/generate-object/generate-object.ts -var import_provider_utils6 = require("@ai-sdk/provider-utils"); +var import_provider_utils6 = require("@ai-sdk/provider-utils") // errors/no-object-generated-error.ts -var import_provider4 = require("@ai-sdk/provider"); -var name3 = "AI_NoObjectGeneratedError"; -var marker3 = `vercel.ai.error.${name3}`; -var symbol3 = Symbol.for(marker3); -var _a3; +var import_provider4 = require("@ai-sdk/provider") +var name3 = "AI_NoObjectGeneratedError" +var marker3 = `vercel.ai.error.${name3}` +var symbol3 = Symbol.for(marker3) +var _a3 var NoObjectGeneratedError = class extends import_provider4.AISDKError { constructor({ message = "No object generated.", @@ -967,24 +972,24 @@ var NoObjectGeneratedError = class extends import_provider4.AISDKError { response, usage }) { - super({ name: name3, message, cause }); - this[_a3] = true; - this.text = text2; - this.response = response; - this.usage = usage; + super({ name: name3, message, cause }) + this[_a3] = true + this.text = text2 + this.response = response + this.usage = usage } static isInstance(error) { - return import_provider4.AISDKError.hasMarker(error, marker3); + return import_provider4.AISDKError.hasMarker(error, marker3) } -}; -_a3 = symbol3; +} +_a3 = symbol3 // util/download-error.ts -var import_provider5 = require("@ai-sdk/provider"); -var name4 = "AI_DownloadError"; -var marker4 = `vercel.ai.error.${name4}`; -var symbol4 = Symbol.for(marker4); -var _a4; +var import_provider5 = require("@ai-sdk/provider") +var name4 = "AI_DownloadError" +var marker4 = `vercel.ai.error.${name4}` +var symbol4 = Symbol.for(marker4) +var _a4 var DownloadError = class extends import_provider5.AISDKError { constructor({ url, @@ -993,43 +998,43 @@ var DownloadError = class extends import_provider5.AISDKError { cause, message = cause == null ? `Failed to download ${url}: ${statusCode} ${statusText}` : `Failed to download ${url}: ${cause}` }) { - super({ name: name4, message, cause }); - this[_a4] = true; - this.url = url; - this.statusCode = statusCode; - this.statusText = statusText; + super({ name: name4, message, cause }) + this[_a4] = true + this.url = url + this.statusCode = statusCode + this.statusText = statusText } static isInstance(error) { - return import_provider5.AISDKError.hasMarker(error, marker4); + return import_provider5.AISDKError.hasMarker(error, marker4) } -}; -_a4 = symbol4; +} +_a4 = symbol4 // util/download.ts async function download({ url, fetchImplementation = fetch }) { - var _a14; - const urlText = url.toString(); + var _a14 + const urlText = url.toString() try { - const response = await fetchImplementation(urlText); + const response = await fetchImplementation(urlText) if (!response.ok) { throw new DownloadError({ url: urlText, statusCode: response.status, statusText: response.statusText - }); + }) } return { data: new Uint8Array(await response.arrayBuffer()), mimeType: (_a14 = response.headers.get("content-type")) != null ? _a14 : void 0 - }; + } } catch (error) { if (DownloadError.isInstance(error)) { - throw error; + throw error } - throw new DownloadError({ url: urlText, cause: error }); + throw new DownloadError({ url: urlText, cause: error }) } } @@ -1039,43 +1044,43 @@ var mimeTypeSignatures = [ { mimeType: "image/png", bytes: [137, 80, 78, 71] }, { mimeType: "image/jpeg", bytes: [255, 216] }, { mimeType: "image/webp", bytes: [82, 73, 70, 70] } -]; +] function detectImageMimeType(image) { for (const { bytes, mimeType } of mimeTypeSignatures) { if (image.length >= bytes.length && bytes.every((byte, index) => image[index] === byte)) { - return mimeType; + return mimeType } } - return void 0; + return void 0 } // core/prompt/data-content.ts -var import_provider_utils3 = require("@ai-sdk/provider-utils"); +var import_provider_utils3 = require("@ai-sdk/provider-utils") // core/prompt/invalid-data-content-error.ts -var import_provider6 = require("@ai-sdk/provider"); -var name5 = "AI_InvalidDataContentError"; -var marker5 = `vercel.ai.error.${name5}`; -var symbol5 = Symbol.for(marker5); -var _a5; +var import_provider6 = require("@ai-sdk/provider") +var name5 = "AI_InvalidDataContentError" +var marker5 = `vercel.ai.error.${name5}` +var symbol5 = Symbol.for(marker5) +var _a5 var InvalidDataContentError = class extends import_provider6.AISDKError { constructor({ content, cause, message = `Invalid data content. Expected a base64 string, Uint8Array, ArrayBuffer, or Buffer, but got ${typeof content}.` }) { - super({ name: name5, message, cause }); - this[_a5] = true; - this.content = content; + super({ name: name5, message, cause }) + this[_a5] = true + this.content = content } static isInstance(error) { - return import_provider6.AISDKError.hasMarker(error, marker5); + return import_provider6.AISDKError.hasMarker(error, marker5) } -}; -_a5 = symbol5; +} +_a5 = symbol5 // core/prompt/data-content.ts -var import_zod = require("zod"); +var import_zod = require("zod") var dataContentSchema = import_zod.z.union([ import_zod.z.string(), import_zod.z.instanceof(Uint8Array), @@ -1083,83 +1088,83 @@ var dataContentSchema = import_zod.z.union([ import_zod.z.custom( // Buffer might not be available in some environments such as CloudFlare: (value) => { - var _a14, _b; - return (_b = (_a14 = globalThis.Buffer) == null ? void 0 : _a14.isBuffer(value)) != null ? _b : false; + var _a14, _b + return (_b = (_a14 = globalThis.Buffer) == null ? void 0 : _a14.isBuffer(value)) != null ? _b : false }, { message: "Must be a Buffer" } ) -]); +]) function convertDataContentToBase64String(content) { if (typeof content === "string") { - return content; + return content } if (content instanceof ArrayBuffer) { - return (0, import_provider_utils3.convertUint8ArrayToBase64)(new Uint8Array(content)); + return (0, import_provider_utils3.convertUint8ArrayToBase64)(new Uint8Array(content)) } - return (0, import_provider_utils3.convertUint8ArrayToBase64)(content); + return (0, import_provider_utils3.convertUint8ArrayToBase64)(content) } function convertDataContentToUint8Array(content) { if (content instanceof Uint8Array) { - return content; + return content } if (typeof content === "string") { try { - return (0, import_provider_utils3.convertBase64ToUint8Array)(content); + return (0, import_provider_utils3.convertBase64ToUint8Array)(content) } catch (error) { throw new InvalidDataContentError({ message: "Invalid data content. Content string is not a base64-encoded media.", content, cause: error - }); + }) } } if (content instanceof ArrayBuffer) { - return new Uint8Array(content); + return new Uint8Array(content) } - throw new InvalidDataContentError({ content }); + throw new InvalidDataContentError({ content }) } function convertUint8ArrayToText(uint8Array) { try { - return new TextDecoder().decode(uint8Array); + return new TextDecoder().decode(uint8Array) } catch (error) { - throw new Error("Error decoding Uint8Array to text"); + throw new Error("Error decoding Uint8Array to text") } } // core/prompt/invalid-message-role-error.ts -var import_provider7 = require("@ai-sdk/provider"); -var name6 = "AI_InvalidMessageRoleError"; -var marker6 = `vercel.ai.error.${name6}`; -var symbol6 = Symbol.for(marker6); -var _a6; +var import_provider7 = require("@ai-sdk/provider") +var name6 = "AI_InvalidMessageRoleError" +var marker6 = `vercel.ai.error.${name6}` +var symbol6 = Symbol.for(marker6) +var _a6 var InvalidMessageRoleError = class extends import_provider7.AISDKError { constructor({ role, message = `Invalid message role: '${role}'. Must be one of: "system", "user", "assistant", "tool".` }) { - super({ name: name6, message }); - this[_a6] = true; - this.role = role; + super({ name: name6, message }) + this[_a6] = true + this.role = role } static isInstance(error) { - return import_provider7.AISDKError.hasMarker(error, marker6); + return import_provider7.AISDKError.hasMarker(error, marker6) } -}; -_a6 = symbol6; +} +_a6 = symbol6 // core/prompt/split-data-url.ts function splitDataUrl(dataUrl) { try { - const [header, base64Content] = dataUrl.split(","); + const [header, base64Content] = dataUrl.split(",") return { mimeType: header.split(";")[0].split(":")[1], base64Content - }; + } } catch (error) { return { mimeType: void 0, base64Content: void 0 - }; + } } } @@ -1175,23 +1180,23 @@ async function convertToLanguageModelPrompt({ downloadImplementation, modelSupportsImageUrls, modelSupportsUrl - ); + ) return [ ...prompt.system != null ? [{ role: "system", content: prompt.system }] : [], ...prompt.messages.map( (message) => convertToLanguageModelMessage(message, downloadedAssets) ) - ]; + ] } function convertToLanguageModelMessage(message, downloadedAssets) { - const role = message.role; + const role = message.role switch (role) { case "system": { return { role: "system", content: message.content, providerMetadata: message.experimental_providerMetadata - }; + } } case "user": { if (typeof message.content === "string") { @@ -1199,13 +1204,13 @@ function convertToLanguageModelMessage(message, downloadedAssets) { role: "user", content: [{ type: "text", text: message.content }], providerMetadata: message.experimental_providerMetadata - }; + } } return { role: "user", content: message.content.map((part) => convertPartToLanguageModelPart(part, downloadedAssets)).filter((part) => part.type !== "text" || part.text !== ""), providerMetadata: message.experimental_providerMetadata - }; + } } case "assistant": { if (typeof message.content === "string") { @@ -1213,7 +1218,7 @@ function convertToLanguageModelMessage(message, downloadedAssets) { role: "assistant", content: [{ type: "text", text: message.content }], providerMetadata: message.experimental_providerMetadata - }; + } } return { role: "assistant", @@ -1221,14 +1226,14 @@ function convertToLanguageModelMessage(message, downloadedAssets) { // remove empty text parts: (part) => part.type !== "text" || part.text !== "" ).map((part) => { - const { experimental_providerMetadata, ...rest } = part; + const { experimental_providerMetadata, ...rest } = part return { ...rest, providerMetadata: experimental_providerMetadata - }; + } }), providerMetadata: message.experimental_providerMetadata - }; + } } case "tool": { return { @@ -1243,11 +1248,11 @@ function convertToLanguageModelMessage(message, downloadedAssets) { providerMetadata: part.experimental_providerMetadata })), providerMetadata: message.experimental_providerMetadata - }; + } } default: { - const _exhaustiveCheck = role; - throw new InvalidMessageRoleError({ role: _exhaustiveCheck }); + const _exhaustiveCheck = role + throw new InvalidMessageRoleError({ role: _exhaustiveCheck }) } } } @@ -1263,90 +1268,90 @@ async function downloadAssets(messages, downloadImplementation, modelSupportsIma // support string urls: typeof part === "string" && (part.startsWith("http:") || part.startsWith("https:")) ? new URL(part) : part ) - ).filter((image) => image instanceof URL).filter((url) => !modelSupportsUrl(url)); + ).filter((image) => image instanceof URL).filter((url) => !modelSupportsUrl(url)) const downloadedImages = await Promise.all( urls.map(async (url) => ({ url, data: await downloadImplementation({ url }) })) - ); + ) return Object.fromEntries( downloadedImages.map(({ url, data }) => [url.toString(), data]) - ); + ) } function convertPartToLanguageModelPart(part, downloadedAssets) { - var _a14; + var _a14 if (part.type === "text") { return { type: "text", text: part.text, providerMetadata: part.experimental_providerMetadata - }; + } } - let mimeType = part.mimeType; - let data; - let content; - let normalizedData; - const type = part.type; + let mimeType = part.mimeType + let data + let content + let normalizedData + const type = part.type switch (type) { case "image": - data = part.image; - break; + data = part.image + break case "file": - data = part.data; - break; + data = part.data + break default: - throw new Error(`Unsupported part type: ${type}`); + throw new Error(`Unsupported part type: ${type}`) } try { - content = typeof data === "string" ? new URL(data) : data; + content = typeof data === "string" ? new URL(data) : data } catch (error) { - content = data; + content = data } if (content instanceof URL) { if (content.protocol === "data:") { const { mimeType: dataUrlMimeType, base64Content } = splitDataUrl( content.toString() - ); + ) if (dataUrlMimeType == null || base64Content == null) { - throw new Error(`Invalid data URL format in part ${type}`); + throw new Error(`Invalid data URL format in part ${type}`) } - mimeType = dataUrlMimeType; - normalizedData = convertDataContentToUint8Array(base64Content); + mimeType = dataUrlMimeType + normalizedData = convertDataContentToUint8Array(base64Content) } else { - const downloadedFile = downloadedAssets[content.toString()]; + const downloadedFile = downloadedAssets[content.toString()] if (downloadedFile) { - normalizedData = downloadedFile.data; - mimeType != null ? mimeType : mimeType = downloadedFile.mimeType; + normalizedData = downloadedFile.data + mimeType != null ? mimeType : mimeType = downloadedFile.mimeType } else { - normalizedData = content; + normalizedData = content } } } else { - normalizedData = convertDataContentToUint8Array(content); + normalizedData = convertDataContentToUint8Array(content) } switch (type) { case "image": { if (normalizedData instanceof Uint8Array) { - mimeType = (_a14 = detectImageMimeType(normalizedData)) != null ? _a14 : mimeType; + mimeType = (_a14 = detectImageMimeType(normalizedData)) != null ? _a14 : mimeType } return { type: "image", image: normalizedData, mimeType, providerMetadata: part.experimental_providerMetadata - }; + } } case "file": { if (mimeType == null) { - throw new Error(`Mime type is missing for file part`); + throw new Error(`Mime type is missing for file part`) } return { type: "file", data: normalizedData instanceof Uint8Array ? convertDataContentToBase64String(normalizedData) : normalizedData, mimeType, providerMetadata: part.experimental_providerMetadata - }; + } } } } @@ -1368,14 +1373,14 @@ function prepareCallSettings({ parameter: "maxTokens", value: maxTokens, message: "maxTokens must be an integer" - }); + }) } if (maxTokens < 1) { throw new InvalidArgumentError({ parameter: "maxTokens", value: maxTokens, message: "maxTokens must be >= 1" - }); + }) } } if (temperature != null) { @@ -1384,7 +1389,7 @@ function prepareCallSettings({ parameter: "temperature", value: temperature, message: "temperature must be a number" - }); + }) } } if (topP != null) { @@ -1393,7 +1398,7 @@ function prepareCallSettings({ parameter: "topP", value: topP, message: "topP must be a number" - }); + }) } } if (topK != null) { @@ -1402,7 +1407,7 @@ function prepareCallSettings({ parameter: "topK", value: topK, message: "topK must be a number" - }); + }) } } if (presencePenalty != null) { @@ -1411,7 +1416,7 @@ function prepareCallSettings({ parameter: "presencePenalty", value: presencePenalty, message: "presencePenalty must be a number" - }); + }) } } if (frequencyPenalty != null) { @@ -1420,7 +1425,7 @@ function prepareCallSettings({ parameter: "frequencyPenalty", value: frequencyPenalty, message: "frequencyPenalty must be a number" - }); + }) } } if (seed != null) { @@ -1429,7 +1434,7 @@ function prepareCallSettings({ parameter: "seed", value: seed, message: "seed must be an integer" - }); + }) } } return { @@ -1441,22 +1446,22 @@ function prepareCallSettings({ frequencyPenalty, stopSequences: stopSequences != null && stopSequences.length > 0 ? stopSequences : void 0, seed - }; + } } // core/prompt/standardize-prompt.ts -var import_provider9 = require("@ai-sdk/provider"); -var import_provider_utils4 = require("@ai-sdk/provider-utils"); -var import_zod7 = require("zod"); +var import_provider9 = require("@ai-sdk/provider") +var import_provider_utils4 = require("@ai-sdk/provider-utils") +var import_zod7 = require("zod") // core/prompt/message.ts -var import_zod6 = require("zod"); +var import_zod6 = require("zod") // core/types/provider-metadata.ts -var import_zod3 = require("zod"); +var import_zod3 = require("zod") // core/types/json-value.ts -var import_zod2 = require("zod"); +var import_zod2 = require("zod") var jsonValueSchema = import_zod2.z.lazy( () => import_zod2.z.union([ import_zod2.z.null(), @@ -1466,19 +1471,19 @@ var jsonValueSchema = import_zod2.z.lazy( import_zod2.z.record(import_zod2.z.string(), jsonValueSchema), import_zod2.z.array(jsonValueSchema) ]) -); +) // core/types/provider-metadata.ts var providerMetadataSchema = import_zod3.z.record( import_zod3.z.string(), import_zod3.z.record(import_zod3.z.string(), jsonValueSchema) -); +) // core/prompt/content-part.ts -var import_zod5 = require("zod"); +var import_zod5 = require("zod") // core/prompt/tool-result-content.ts -var import_zod4 = require("zod"); +var import_zod4 = require("zod") var toolResultContentSchema = import_zod4.z.array( import_zod4.z.union([ import_zod4.z.object({ type: import_zod4.z.literal("text"), text: import_zod4.z.string() }), @@ -1488,32 +1493,32 @@ var toolResultContentSchema = import_zod4.z.array( mimeType: import_zod4.z.string().optional() }) ]) -); +) // core/prompt/content-part.ts var textPartSchema = import_zod5.z.object({ type: import_zod5.z.literal("text"), text: import_zod5.z.string(), experimental_providerMetadata: providerMetadataSchema.optional() -}); +}) var imagePartSchema = import_zod5.z.object({ type: import_zod5.z.literal("image"), image: import_zod5.z.union([dataContentSchema, import_zod5.z.instanceof(URL)]), mimeType: import_zod5.z.string().optional(), experimental_providerMetadata: providerMetadataSchema.optional() -}); +}) var filePartSchema = import_zod5.z.object({ type: import_zod5.z.literal("file"), data: import_zod5.z.union([dataContentSchema, import_zod5.z.instanceof(URL)]), mimeType: import_zod5.z.string(), experimental_providerMetadata: providerMetadataSchema.optional() -}); +}) var toolCallPartSchema = import_zod5.z.object({ type: import_zod5.z.literal("tool-call"), toolCallId: import_zod5.z.string(), toolName: import_zod5.z.string(), args: import_zod5.z.unknown() -}); +}) var toolResultPartSchema = import_zod5.z.object({ type: import_zod5.z.literal("tool-result"), toolCallId: import_zod5.z.string(), @@ -1522,14 +1527,14 @@ var toolResultPartSchema = import_zod5.z.object({ content: toolResultContentSchema.optional(), isError: import_zod5.z.boolean().optional(), experimental_providerMetadata: providerMetadataSchema.optional() -}); +}) // core/prompt/message.ts var coreSystemMessageSchema = import_zod6.z.object({ role: import_zod6.z.literal("system"), content: import_zod6.z.string(), experimental_providerMetadata: providerMetadataSchema.optional() -}); +}) var coreUserMessageSchema = import_zod6.z.object({ role: import_zod6.z.literal("user"), content: import_zod6.z.union([ @@ -1537,7 +1542,7 @@ var coreUserMessageSchema = import_zod6.z.object({ import_zod6.z.array(import_zod6.z.union([textPartSchema, imagePartSchema, filePartSchema])) ]), experimental_providerMetadata: providerMetadataSchema.optional() -}); +}) var coreAssistantMessageSchema = import_zod6.z.object({ role: import_zod6.z.literal("assistant"), content: import_zod6.z.union([ @@ -1545,36 +1550,36 @@ var coreAssistantMessageSchema = import_zod6.z.object({ import_zod6.z.array(import_zod6.z.union([textPartSchema, toolCallPartSchema])) ]), experimental_providerMetadata: providerMetadataSchema.optional() -}); +}) var coreToolMessageSchema = import_zod6.z.object({ role: import_zod6.z.literal("tool"), content: import_zod6.z.array(toolResultPartSchema), experimental_providerMetadata: providerMetadataSchema.optional() -}); +}) var coreMessageSchema = import_zod6.z.union([ coreSystemMessageSchema, coreUserMessageSchema, coreAssistantMessageSchema, coreToolMessageSchema -]); +]) // core/prompt/detect-prompt-type.ts function detectPromptType(prompt) { if (!Array.isArray(prompt)) { - return "other"; + return "other" } if (prompt.length === 0) { - return "messages"; + return "messages" } - const characteristics = prompt.map(detectSingleMessageCharacteristics); + const characteristics = prompt.map(detectSingleMessageCharacteristics) if (characteristics.some((c) => c === "has-ui-specific-parts")) { - return "ui-messages"; + return "ui-messages" } else if (characteristics.every( (c) => c === "has-core-specific-parts" || c === "message" )) { - return "messages"; + return "messages" } else { - return "other"; + return "other" } } function detectSingleMessageCharacteristics(message) { @@ -1582,129 +1587,129 @@ function detectSingleMessageCharacteristics(message) { message.role === "data" || // UI-only role "toolInvocations" in message || // UI-specific field "experimental_attachments" in message)) { - return "has-ui-specific-parts"; + return "has-ui-specific-parts" } else if (typeof message === "object" && message !== null && "content" in message && (Array.isArray(message.content) || // Core messages can have array content "experimental_providerMetadata" in message)) { - return "has-core-specific-parts"; + return "has-core-specific-parts" } else if (typeof message === "object" && message !== null && "role" in message && "content" in message && typeof message.content === "string" && ["system", "user", "assistant", "tool"].includes(message.role)) { - return "message"; + return "message" } else { - return "other"; + return "other" } } // core/prompt/attachments-to-parts.ts function attachmentsToParts(attachments) { - var _a14, _b, _c; - const parts = []; + var _a14, _b, _c + const parts = [] for (const attachment of attachments) { - let url; + let url try { - url = new URL(attachment.url); + url = new URL(attachment.url) } catch (error) { - throw new Error(`Invalid URL: ${attachment.url}`); + throw new Error(`Invalid URL: ${attachment.url}`) } switch (url.protocol) { case "http:": case "https:": { if ((_a14 = attachment.contentType) == null ? void 0 : _a14.startsWith("image/")) { - parts.push({ type: "image", image: url }); + parts.push({ type: "image", image: url }) } else { if (!attachment.contentType) { throw new Error( "If the attachment is not an image, it must specify a content type" - ); + ) } parts.push({ type: "file", data: url, mimeType: attachment.contentType - }); + }) } - break; + break } case "data:": { - let header; - let base64Content; - let mimeType; + let header + let base64Content + let mimeType try { - [header, base64Content] = attachment.url.split(","); - mimeType = header.split(";")[0].split(":")[1]; + [header, base64Content] = attachment.url.split(",") + mimeType = header.split(";")[0].split(":")[1] } catch (error) { - throw new Error(`Error processing data URL: ${attachment.url}`); + throw new Error(`Error processing data URL: ${attachment.url}`) } if (mimeType == null || base64Content == null) { - throw new Error(`Invalid data URL format: ${attachment.url}`); + throw new Error(`Invalid data URL format: ${attachment.url}`) } if ((_b = attachment.contentType) == null ? void 0 : _b.startsWith("image/")) { parts.push({ type: "image", image: convertDataContentToUint8Array(base64Content) - }); + }) } else if ((_c = attachment.contentType) == null ? void 0 : _c.startsWith("text/")) { parts.push({ type: "text", text: convertUint8ArrayToText( convertDataContentToUint8Array(base64Content) ) - }); + }) } else { if (!attachment.contentType) { throw new Error( "If the attachment is not an image or text, it must specify a content type" - ); + ) } parts.push({ type: "file", data: base64Content, mimeType: attachment.contentType - }); + }) } - break; + break } default: { - throw new Error(`Unsupported URL protocol: ${url.protocol}`); + throw new Error(`Unsupported URL protocol: ${url.protocol}`) } } } - return parts; + return parts } // core/prompt/message-conversion-error.ts -var import_provider8 = require("@ai-sdk/provider"); -var name7 = "AI_MessageConversionError"; -var marker7 = `vercel.ai.error.${name7}`; -var symbol7 = Symbol.for(marker7); -var _a7; +var import_provider8 = require("@ai-sdk/provider") +var name7 = "AI_MessageConversionError" +var marker7 = `vercel.ai.error.${name7}` +var symbol7 = Symbol.for(marker7) +var _a7 var MessageConversionError = class extends import_provider8.AISDKError { constructor({ originalMessage, message }) { - super({ name: name7, message }); - this[_a7] = true; - this.originalMessage = originalMessage; + super({ name: name7, message }) + this[_a7] = true + this.originalMessage = originalMessage } static isInstance(error) { - return import_provider8.AISDKError.hasMarker(error, marker7); + return import_provider8.AISDKError.hasMarker(error, marker7) } -}; -_a7 = symbol7; +} +_a7 = symbol7 // core/prompt/convert-to-core-messages.ts function convertToCoreMessages(messages, options) { - var _a14; - const tools = (_a14 = options == null ? void 0 : options.tools) != null ? _a14 : {}; - const coreMessages = []; + var _a14 + const tools = (_a14 = options == null ? void 0 : options.tools) != null ? _a14 : {} + const coreMessages = [] for (const message of messages) { - const { role, content, toolInvocations, experimental_attachments } = message; + const { role, content, toolInvocations, experimental_attachments } = message switch (role) { case "system": { coreMessages.push({ role: "system", content - }); - break; + }) + break } case "user": { coreMessages.push({ @@ -1713,13 +1718,13 @@ function convertToCoreMessages(messages, options) { { type: "text", text: content }, ...attachmentsToParts(experimental_attachments) ] : content - }); - break; + }) + break } case "assistant": { if (toolInvocations == null || toolInvocations.length === 0) { - coreMessages.push({ role: "assistant", content }); - break; + coreMessages.push({ role: "assistant", content }) + break } coreMessages.push({ role: "assistant", @@ -1734,7 +1739,7 @@ function convertToCoreMessages(messages, options) { }) ) ] - }); + }) coreMessages.push({ role: "tool", content: toolInvocations.map((toolInvocation) => { @@ -1742,10 +1747,10 @@ function convertToCoreMessages(messages, options) { throw new MessageConversionError({ originalMessage: message, message: "ToolInvocation must have a result: " + JSON.stringify(toolInvocation) - }); + }) } - const { toolCallId, toolName, result } = toolInvocation; - const tool2 = tools[toolName]; + const { toolCallId, toolName, result } = toolInvocation + const tool2 = tools[toolName] return (tool2 == null ? void 0 : tool2.experimental_toToolResultContent) != null ? { type: "tool-result", toolCallId, @@ -1757,24 +1762,24 @@ function convertToCoreMessages(messages, options) { toolCallId, toolName, result - }; + } }) - }); - break; + }) + break } case "data": { - break; + break } default: { - const _exhaustiveCheck = role; + const _exhaustiveCheck = role throw new MessageConversionError({ originalMessage: message, message: `Unsupported role: ${_exhaustiveCheck}` - }); + }) } } } - return coreMessages; + return coreMessages } // core/prompt/standardize-prompt.ts @@ -1786,26 +1791,26 @@ function standardizePrompt({ throw new import_provider9.InvalidPromptError({ prompt, message: "prompt or messages must be defined" - }); + }) } if (prompt.prompt != null && prompt.messages != null) { throw new import_provider9.InvalidPromptError({ prompt, message: "prompt and messages cannot be defined at the same time" - }); + }) } if (prompt.system != null && typeof prompt.system !== "string") { throw new import_provider9.InvalidPromptError({ prompt, message: "system must be a string" - }); + }) } if (prompt.prompt != null) { if (typeof prompt.prompt !== "string") { throw new import_provider9.InvalidPromptError({ prompt, message: "prompt must be a string" - }); + }) } return { type: "prompt", @@ -1816,37 +1821,37 @@ function standardizePrompt({ content: prompt.prompt } ] - }; + } } if (prompt.messages != null) { - const promptType = detectPromptType(prompt.messages); + const promptType = detectPromptType(prompt.messages) if (promptType === "other") { throw new import_provider9.InvalidPromptError({ prompt, message: "messages must be an array of CoreMessage or UIMessage" - }); + }) } const messages = promptType === "ui-messages" ? convertToCoreMessages(prompt.messages, { tools - }) : prompt.messages; + }) : prompt.messages const validationResult = (0, import_provider_utils4.safeValidateTypes)({ value: messages, schema: import_zod7.z.array(coreMessageSchema) - }); + }) if (!validationResult.success) { throw new import_provider9.InvalidPromptError({ prompt, message: "messages must be an array of CoreMessage or UIMessage", cause: validationResult.error - }); + }) } return { type: "messages", messages, system: prompt.system - }; + } } - throw new Error("unreachable"); + throw new Error("unreachable") } // core/types/usage.ts @@ -1858,20 +1863,20 @@ function calculateLanguageModelUsage({ promptTokens, completionTokens, totalTokens: promptTokens + completionTokens - }; + } } function addLanguageModelUsage(usage1, usage2) { return { promptTokens: usage1.promptTokens + usage2.promptTokens, completionTokens: usage1.completionTokens + usage2.completionTokens, totalTokens: usage1.totalTokens + usage2.totalTokens - }; + } } // core/generate-object/inject-json-instruction.ts -var DEFAULT_SCHEMA_PREFIX = "JSON schema:"; -var DEFAULT_SCHEMA_SUFFIX = "You MUST answer with a JSON object that matches the JSON schema above."; -var DEFAULT_GENERIC_SUFFIX = "You MUST answer with JSON."; +var DEFAULT_SCHEMA_PREFIX = "JSON schema:" +var DEFAULT_SCHEMA_SUFFIX = "You MUST answer with a JSON object that matches the JSON schema above." +var DEFAULT_GENERIC_SUFFIX = "You MUST answer with JSON." function injectJsonInstruction({ prompt, schema, @@ -1885,27 +1890,27 @@ function injectJsonInstruction({ schemaPrefix, schema != null ? JSON.stringify(schema) : void 0, schemaSuffix - ].filter((line) => line != null).join("\n"); + ].filter((line) => line != null).join("\n") } // core/generate-object/output-strategy.ts -var import_provider10 = require("@ai-sdk/provider"); -var import_provider_utils5 = require("@ai-sdk/provider-utils"); -var import_ui_utils2 = require("@ai-sdk/ui-utils"); +var import_provider10 = require("@ai-sdk/provider") +var import_provider_utils5 = require("@ai-sdk/provider-utils") +var import_ui_utils2 = require("@ai-sdk/ui-utils") // core/util/async-iterable-stream.ts function createAsyncIterableStream(source) { - const stream = source.pipeThrough(new TransformStream()); + const stream = source.pipeThrough(new TransformStream()) stream[Symbol.asyncIterator] = () => { - const reader = stream.getReader(); + const reader = stream.getReader() return { async next() { - const { done, value } = await reader.read(); - return done ? { done: true, value: void 0 } : { done: false, value }; + const { done, value } = await reader.read() + return done ? { done: true, value: void 0 } : { done: false, value } } - }; - }; - return stream; + } + } + return stream } // core/generate-object/output-strategy.ts @@ -1913,7 +1918,7 @@ var noSchemaOutputStrategy = { type: "no-schema", jsonSchema: void 0, validatePartialResult({ value, textDelta }) { - return { success: true, value: { partial: value, textDelta } }; + return { success: true, value: { partial: value, textDelta } } }, validateFinalResult(value, context) { return value === void 0 ? { @@ -1924,14 +1929,14 @@ var noSchemaOutputStrategy = { response: context.response, usage: context.usage }) - } : { success: true, value }; + } : { success: true, value } }, createElementStream() { throw new import_provider10.UnsupportedFunctionalityError({ functionality: "element streams in no-schema mode" - }); + }) } -}; +} var objectOutputStrategy = (schema) => ({ type: "object", jsonSchema: schema.jsonSchema, @@ -1943,19 +1948,19 @@ var objectOutputStrategy = (schema) => ({ partial: value, textDelta } - }; + } }, validateFinalResult(value) { - return (0, import_provider_utils5.safeValidateTypes)({ value, schema }); + return (0, import_provider_utils5.safeValidateTypes)({ value, schema }) }, createElementStream() { throw new import_provider10.UnsupportedFunctionalityError({ functionality: "element streams in object mode" - }); + }) } -}); +}) var arrayOutputStrategy = (schema) => { - const { $schema, ...itemSchema } = schema.jsonSchema; + const { $schema, ...itemSchema } = schema.jsonSchema return { type: "enum", // wrap in object that contains array of elements, since most LLMs will not @@ -1971,7 +1976,7 @@ var arrayOutputStrategy = (schema) => { additionalProperties: false }, validatePartialResult({ value, latestObject, isFirstDelta, isFinalDelta }) { - var _a14; + var _a14 if (!(0, import_provider10.isJSONObject)(value) || !(0, import_provider10.isJSONArray)(value.elements)) { return { success: false, @@ -1979,32 +1984,32 @@ var arrayOutputStrategy = (schema) => { value, cause: "value must be an object that contains an array of elements" }) - }; + } } - const inputArray = value.elements; - const resultArray = []; + const inputArray = value.elements + const resultArray = [] for (let i = 0; i < inputArray.length; i++) { - const element = inputArray[i]; - const result = (0, import_provider_utils5.safeValidateTypes)({ value: element, schema }); + const element = inputArray[i] + const result = (0, import_provider_utils5.safeValidateTypes)({ value: element, schema }) if (i === inputArray.length - 1 && !isFinalDelta) { - continue; + continue } if (!result.success) { - return result; + return result } - resultArray.push(result.value); + resultArray.push(result.value) } - const publishedElementCount = (_a14 = latestObject == null ? void 0 : latestObject.length) != null ? _a14 : 0; - let textDelta = ""; + const publishedElementCount = (_a14 = latestObject == null ? void 0 : latestObject.length) != null ? _a14 : 0 + let textDelta = "" if (isFirstDelta) { - textDelta += "["; + textDelta += "[" } if (publishedElementCount > 0) { - textDelta += ","; + textDelta += "," } - textDelta += resultArray.slice(publishedElementCount).map((element) => JSON.stringify(element)).join(","); + textDelta += resultArray.slice(publishedElementCount).map((element) => JSON.stringify(element)).join(",") if (isFinalDelta) { - textDelta += "]"; + textDelta += "]" } return { success: true, @@ -2012,7 +2017,7 @@ var arrayOutputStrategy = (schema) => { partial: resultArray, textDelta } - }; + } }, validateFinalResult(value) { if (!(0, import_provider10.isJSONObject)(value) || !(0, import_provider10.isJSONArray)(value.elements)) { @@ -2022,51 +2027,51 @@ var arrayOutputStrategy = (schema) => { value, cause: "value must be an object that contains an array of elements" }) - }; - } - const inputArray = value.elements; - for (const element of inputArray) { - const result = (0, import_provider_utils5.safeValidateTypes)({ value: element, schema }); - if (!result.success) { - return result; } } - return { success: true, value: inputArray }; + const inputArray = value.elements + for (const element of inputArray) { + const result = (0, import_provider_utils5.safeValidateTypes)({ value: element, schema }) + if (!result.success) { + return result + } + } + return { success: true, value: inputArray } }, createElementStream(originalStream) { - let publishedElements = 0; + let publishedElements = 0 return createAsyncIterableStream( originalStream.pipeThrough( new TransformStream({ transform(chunk, controller) { switch (chunk.type) { case "object": { - const array = chunk.object; + const array = chunk.object for (; publishedElements < array.length; publishedElements++) { - controller.enqueue(array[publishedElements]); + controller.enqueue(array[publishedElements]) } - break; + break } case "text-delta": case "finish": - break; + break case "error": - controller.error(chunk.error); - break; + controller.error(chunk.error) + break default: { - const _exhaustiveCheck = chunk; + const _exhaustiveCheck = chunk throw new Error( `Unsupported chunk type: ${_exhaustiveCheck}` - ); + ) } } } }) ) - ); + ) } - }; -}; + } +} var enumOutputStrategy = (enumValues) => { return { type: "enum", @@ -2090,29 +2095,29 @@ var enumOutputStrategy = (enumValues) => { value, cause: 'value must be an object that contains a string in the "result" property.' }) - }; + } } - const result = value.result; + const result = value.result return enumValues.includes(result) ? { success: true, value: result } : { success: false, error: new import_provider10.TypeValidationError({ value, cause: "value must be a string in the enum" }) - }; + } }, validatePartialResult() { throw new import_provider10.UnsupportedFunctionalityError({ functionality: "partial results in enum mode" - }); + }) }, createElementStream() { throw new import_provider10.UnsupportedFunctionalityError({ functionality: "element streams in enum mode" - }); + }) } - }; -}; + } +} function getOutputStrategy({ output, schema, @@ -2120,16 +2125,16 @@ function getOutputStrategy({ }) { switch (output) { case "object": - return objectOutputStrategy((0, import_ui_utils2.asSchema)(schema)); + return objectOutputStrategy((0, import_ui_utils2.asSchema)(schema)) case "array": - return arrayOutputStrategy((0, import_ui_utils2.asSchema)(schema)); + return arrayOutputStrategy((0, import_ui_utils2.asSchema)(schema)) case "enum": - return enumOutputStrategy(enumValues); + return enumOutputStrategy(enumValues) case "no-schema": - return noSchemaOutputStrategy; + return noSchemaOutputStrategy default: { - const _exhaustiveCheck = output; - throw new Error(`Unsupported output: ${_exhaustiveCheck}`); + const _exhaustiveCheck = output + throw new Error(`Unsupported output: ${_exhaustiveCheck}`) } } } @@ -2148,7 +2153,7 @@ function validateObjectGenerationInput({ parameter: "output", value: output, message: "Invalid output type." - }); + }) } if (output === "no-schema") { if (mode === "auto" || mode === "tool") { @@ -2156,35 +2161,35 @@ function validateObjectGenerationInput({ parameter: "mode", value: mode, message: 'Mode must be "json" for no-schema output.' - }); + }) } if (schema != null) { throw new InvalidArgumentError({ parameter: "schema", value: schema, message: "Schema is not supported for no-schema output." - }); + }) } if (schemaDescription != null) { throw new InvalidArgumentError({ parameter: "schemaDescription", value: schemaDescription, message: "Schema description is not supported for no-schema output." - }); + }) } if (schemaName != null) { throw new InvalidArgumentError({ parameter: "schemaName", value: schemaName, message: "Schema name is not supported for no-schema output." - }); + }) } if (enumValues != null) { throw new InvalidArgumentError({ parameter: "enumValues", value: enumValues, message: "Enum values are not supported for no-schema output." - }); + }) } } if (output === "object") { @@ -2193,14 +2198,14 @@ function validateObjectGenerationInput({ parameter: "schema", value: schema, message: "Schema is required for object output." - }); + }) } if (enumValues != null) { throw new InvalidArgumentError({ parameter: "enumValues", value: enumValues, message: "Enum values are not supported for object output." - }); + }) } } if (output === "array") { @@ -2209,14 +2214,14 @@ function validateObjectGenerationInput({ parameter: "schema", value: schema, message: "Element schema is required for array output." - }); + }) } if (enumValues != null) { throw new InvalidArgumentError({ parameter: "enumValues", value: enumValues, message: "Enum values are not supported for array output." - }); + }) } } if (output === "enum") { @@ -2225,28 +2230,28 @@ function validateObjectGenerationInput({ parameter: "schema", value: schema, message: "Schema is not supported for enum output." - }); + }) } if (schemaDescription != null) { throw new InvalidArgumentError({ parameter: "schemaDescription", value: schemaDescription, message: "Schema description is not supported for enum output." - }); + }) } if (schemaName != null) { throw new InvalidArgumentError({ parameter: "schemaName", value: schemaName, message: "Schema name is not supported for enum output." - }); + }) } if (enumValues == null) { throw new InvalidArgumentError({ parameter: "enumValues", value: enumValues, message: "Enum values are required for enum output." - }); + }) } for (const value of enumValues) { if (typeof value !== "string") { @@ -2254,14 +2259,14 @@ function validateObjectGenerationInput({ parameter: "enumValues", value, message: "Enum values must be strings." - }); + }) } } } } // core/generate-object/generate-object.ts -var originalGenerateId = (0, import_provider_utils6.createIdGenerator)({ prefix: "aiobj", size: 24 }); +var originalGenerateId = (0, import_provider_utils6.createIdGenerator)({ prefix: "aiobj", size: 24 }) async function generateObject({ model, enum: enumValues, @@ -2292,23 +2297,23 @@ async function generateObject({ schemaName, schemaDescription, enumValues - }); - const { maxRetries, retry } = prepareRetries({ maxRetries: maxRetriesArg }); + }) + const { maxRetries, retry } = prepareRetries({ maxRetries: maxRetriesArg }) const outputStrategy = getOutputStrategy({ output, schema: inputSchema, enumValues - }); + }) if (outputStrategy.type === "no-schema" && mode === void 0) { - mode = "json"; + mode = "json" } const baseTelemetryAttributes = getBaseTelemetryAttributes({ model, telemetry, headers, settings: { ...settings, maxRetries } - }); - const tracer = getTracer(telemetry); + }) + const tracer = getTracer(telemetry) return recordSpan({ name: "ai.generateObject", attributes: selectTelemetryAttributes({ @@ -2332,19 +2337,19 @@ async function generateObject({ }), tracer, fn: async (span) => { - var _a14, _b; + var _a14, _b if (mode === "auto" || mode == null) { - mode = model.defaultObjectGenerationMode; + mode = model.defaultObjectGenerationMode } - let result; - let finishReason; - let usage; - let warnings; - let rawResponse; - let response; - let request; - let logprobs; - let resultProviderMetadata; + let result + let finishReason + let usage + let warnings + let rawResponse + let response + let request + let logprobs + let resultProviderMetadata switch (mode) { case "json": { const standardizedPrompt = standardizePrompt({ @@ -2357,12 +2362,12 @@ async function generateObject({ messages }, tools: void 0 - }); + }) const promptMessages = await convertToLanguageModelPrompt({ prompt: standardizedPrompt, modelSupportsImageUrls: model.supportsImageUrls, modelSupportsUrl: model.supportsUrl - }); + }) const generateResult = await retry( () => recordSpan({ name: "ai.generateObject.doGenerate", @@ -2394,7 +2399,7 @@ async function generateObject({ }), tracer, fn: async (span2) => { - var _a15, _b2, _c, _d, _e, _f; + var _a15, _b2, _c, _d, _e, _f const result2 = await model.doGenerate({ mode: { type: "object-json", @@ -2408,18 +2413,18 @@ async function generateObject({ providerMetadata, abortSignal, headers - }); + }) const responseData = { id: (_b2 = (_a15 = result2.response) == null ? void 0 : _a15.id) != null ? _b2 : generateId3(), timestamp: (_d = (_c = result2.response) == null ? void 0 : _c.timestamp) != null ? _d : currentDate(), modelId: (_f = (_e = result2.response) == null ? void 0 : _e.modelId) != null ? _f : model.modelId - }; + } if (result2.text === void 0) { throw new NoObjectGeneratedError({ message: "No object generated: the model did not return a response.", response: responseData, usage: calculateLanguageModelUsage(result2.usage) - }); + }) } span2.setAttributes( selectTelemetryAttributes({ @@ -2440,33 +2445,33 @@ async function generateObject({ "gen_ai.usage.completion_tokens": result2.usage.completionTokens } }) - ); - return { ...result2, objectText: result2.text, responseData }; + ) + return { ...result2, objectText: result2.text, responseData } } }) - ); - result = generateResult.objectText; - finishReason = generateResult.finishReason; - usage = generateResult.usage; - warnings = generateResult.warnings; - rawResponse = generateResult.rawResponse; - logprobs = generateResult.logprobs; - resultProviderMetadata = generateResult.providerMetadata; - request = (_a14 = generateResult.request) != null ? _a14 : {}; - response = generateResult.responseData; - break; + ) + result = generateResult.objectText + finishReason = generateResult.finishReason + usage = generateResult.usage + warnings = generateResult.warnings + rawResponse = generateResult.rawResponse + logprobs = generateResult.logprobs + resultProviderMetadata = generateResult.providerMetadata + request = (_a14 = generateResult.request) != null ? _a14 : {} + response = generateResult.responseData + break } case "tool": { const standardizedPrompt = standardizePrompt({ prompt: { system, prompt, messages }, tools: void 0 - }); + }) const promptMessages = await convertToLanguageModelPrompt({ prompt: standardizedPrompt, modelSupportsImageUrls: model.supportsImageUrls, modelSupportsUrl: model.supportsUrl - }); - const inputFormat = standardizedPrompt.type; + }) + const inputFormat = standardizedPrompt.type const generateResult = await retry( () => recordSpan({ name: "ai.generateObject.doGenerate", @@ -2498,7 +2503,7 @@ async function generateObject({ }), tracer, fn: async (span2) => { - var _a15, _b2, _c, _d, _e, _f, _g, _h; + var _a15, _b2, _c, _d, _e, _f, _g, _h const result2 = await model.doGenerate({ mode: { type: "object-tool", @@ -2515,19 +2520,19 @@ async function generateObject({ providerMetadata, abortSignal, headers - }); - const objectText = (_b2 = (_a15 = result2.toolCalls) == null ? void 0 : _a15[0]) == null ? void 0 : _b2.args; + }) + const objectText = (_b2 = (_a15 = result2.toolCalls) == null ? void 0 : _a15[0]) == null ? void 0 : _b2.args const responseData = { id: (_d = (_c = result2.response) == null ? void 0 : _c.id) != null ? _d : generateId3(), timestamp: (_f = (_e = result2.response) == null ? void 0 : _e.timestamp) != null ? _f : currentDate(), modelId: (_h = (_g = result2.response) == null ? void 0 : _g.modelId) != null ? _h : model.modelId - }; + } if (objectText === void 0) { throw new NoObjectGeneratedError({ message: "No object generated: the tool was not called.", response: responseData, usage: calculateLanguageModelUsage(result2.usage) - }); + }) } span2.setAttributes( selectTelemetryAttributes({ @@ -2548,33 +2553,33 @@ async function generateObject({ "gen_ai.usage.output_tokens": result2.usage.completionTokens } }) - ); - return { ...result2, objectText, responseData }; + ) + return { ...result2, objectText, responseData } } }) - ); - result = generateResult.objectText; - finishReason = generateResult.finishReason; - usage = generateResult.usage; - warnings = generateResult.warnings; - rawResponse = generateResult.rawResponse; - logprobs = generateResult.logprobs; - resultProviderMetadata = generateResult.providerMetadata; - request = (_b = generateResult.request) != null ? _b : {}; - response = generateResult.responseData; - break; + ) + result = generateResult.objectText + finishReason = generateResult.finishReason + usage = generateResult.usage + warnings = generateResult.warnings + rawResponse = generateResult.rawResponse + logprobs = generateResult.logprobs + resultProviderMetadata = generateResult.providerMetadata + request = (_b = generateResult.request) != null ? _b : {} + response = generateResult.responseData + break } case void 0: { throw new Error( "Model does not have a default object generation mode." - ); + ) } default: { - const _exhaustiveCheck = mode; - throw new Error(`Unsupported mode: ${_exhaustiveCheck}`); + const _exhaustiveCheck = mode + throw new Error(`Unsupported mode: ${_exhaustiveCheck}`) } } - const parseResult = (0, import_provider_utils6.safeParseJSON)({ text: result }); + const parseResult = (0, import_provider_utils6.safeParseJSON)({ text: result }) if (!parseResult.success) { throw new NoObjectGeneratedError({ message: "No object generated: could not parse the response.", @@ -2582,7 +2587,7 @@ async function generateObject({ text: result, response, usage: calculateLanguageModelUsage(usage) - }); + }) } const validationResult = outputStrategy.validateFinalResult( parseResult.value, @@ -2591,7 +2596,7 @@ async function generateObject({ response, usage: calculateLanguageModelUsage(usage) } - ); + ) if (!validationResult.success) { throw new NoObjectGeneratedError({ message: "No object generated: response did not match schema.", @@ -2599,7 +2604,7 @@ async function generateObject({ text: result, response, usage: calculateLanguageModelUsage(usage) - }); + }) } span.setAttributes( selectTelemetryAttributes({ @@ -2613,7 +2618,7 @@ async function generateObject({ "ai.usage.completionTokens": usage.completionTokens } }) - ); + ) return new DefaultGenerateObjectResult({ object: validationResult.value, finishReason, @@ -2626,155 +2631,155 @@ async function generateObject({ }, logprobs, providerMetadata: resultProviderMetadata - }); + }) } - }); + }) } var DefaultGenerateObjectResult = class { constructor(options) { - this.object = options.object; - this.finishReason = options.finishReason; - this.usage = options.usage; - this.warnings = options.warnings; - this.experimental_providerMetadata = options.providerMetadata; - this.response = options.response; - this.request = options.request; - this.logprobs = options.logprobs; + this.object = options.object + this.finishReason = options.finishReason + this.usage = options.usage + this.warnings = options.warnings + this.experimental_providerMetadata = options.providerMetadata + this.response = options.response + this.request = options.request + this.logprobs = options.logprobs } toJsonResponse(init) { - var _a14; + var _a14 return new Response(JSON.stringify(this.object), { status: (_a14 = init == null ? void 0 : init.status) != null ? _a14 : 200, headers: prepareResponseHeaders(init == null ? void 0 : init.headers, { contentType: "application/json; charset=utf-8" }) - }); + }) } -}; +} // core/generate-object/stream-object.ts -var import_provider_utils7 = require("@ai-sdk/provider-utils"); -var import_ui_utils3 = require("@ai-sdk/ui-utils"); +var import_provider_utils7 = require("@ai-sdk/provider-utils") +var import_ui_utils3 = require("@ai-sdk/ui-utils") // util/delayed-promise.ts var DelayedPromise = class { constructor() { - this.status = { type: "pending" }; - this._resolve = void 0; - this._reject = void 0; + this.status = { type: "pending" } + this._resolve = void 0 + this._reject = void 0 } get value() { if (this.promise) { - return this.promise; + return this.promise } this.promise = new Promise((resolve, reject) => { if (this.status.type === "resolved") { - resolve(this.status.value); + resolve(this.status.value) } else if (this.status.type === "rejected") { - reject(this.status.error); + reject(this.status.error) } - this._resolve = resolve; - this._reject = reject; - }); - return this.promise; + this._resolve = resolve + this._reject = reject + }) + return this.promise } resolve(value) { - var _a14; - this.status = { type: "resolved", value }; + var _a14 + this.status = { type: "resolved", value } if (this.promise) { - (_a14 = this._resolve) == null ? void 0 : _a14.call(this, value); + (_a14 = this._resolve) == null ? void 0 : _a14.call(this, value) } } reject(error) { - var _a14; - this.status = { type: "rejected", error }; + var _a14 + this.status = { type: "rejected", error } if (this.promise) { - (_a14 = this._reject) == null ? void 0 : _a14.call(this, error); + (_a14 = this._reject) == null ? void 0 : _a14.call(this, error) } } -}; +} // util/create-resolvable-promise.ts function createResolvablePromise() { - let resolve; - let reject; + let resolve + let reject const promise = new Promise((res, rej) => { - resolve = res; - reject = rej; - }); + resolve = res + reject = rej + }) return { promise, resolve, reject - }; + } } // core/util/create-stitchable-stream.ts function createStitchableStream() { - let innerStreamReaders = []; - let controller = null; - let isClosed = false; - let waitForNewStream = createResolvablePromise(); + let innerStreamReaders = [] + let controller = null + let isClosed = false + let waitForNewStream = createResolvablePromise() const processPull = async () => { if (isClosed && innerStreamReaders.length === 0) { - controller == null ? void 0 : controller.close(); - return; + controller == null ? void 0 : controller.close() + return } if (innerStreamReaders.length === 0) { - waitForNewStream = createResolvablePromise(); - await waitForNewStream.promise; - return processPull(); + waitForNewStream = createResolvablePromise() + await waitForNewStream.promise + return processPull() } try { - const { value, done } = await innerStreamReaders[0].read(); + const { value, done } = await innerStreamReaders[0].read() if (done) { - innerStreamReaders.shift(); + innerStreamReaders.shift() if (innerStreamReaders.length > 0) { - await processPull(); + await processPull() } else if (isClosed) { - controller == null ? void 0 : controller.close(); + controller == null ? void 0 : controller.close() } } else { - controller == null ? void 0 : controller.enqueue(value); + controller == null ? void 0 : controller.enqueue(value) } } catch (error) { - controller == null ? void 0 : controller.error(error); - innerStreamReaders.shift(); + controller == null ? void 0 : controller.error(error) + innerStreamReaders.shift() if (isClosed && innerStreamReaders.length === 0) { - controller == null ? void 0 : controller.close(); + controller == null ? void 0 : controller.close() } } - }; + } return { stream: new ReadableStream({ start(controllerParam) { - controller = controllerParam; + controller = controllerParam }, pull: processPull, async cancel() { for (const reader of innerStreamReaders) { - await reader.cancel(); + await reader.cancel() } - innerStreamReaders = []; - isClosed = true; + innerStreamReaders = [] + isClosed = true } }), addStream: (innerStream) => { if (isClosed) { - throw new Error("Cannot add inner stream: outer stream is closed"); + throw new Error("Cannot add inner stream: outer stream is closed") } - innerStreamReaders.push(innerStream.getReader()); - waitForNewStream.resolve(); + innerStreamReaders.push(innerStream.getReader()) + waitForNewStream.resolve() }, /** * Gracefully close the outer stream. This will let the inner streams * finish processing and then close the outer stream. */ close: () => { - isClosed = true; - waitForNewStream.resolve(); + isClosed = true + waitForNewStream.resolve() if (innerStreamReaders.length === 0) { - controller == null ? void 0 : controller.close(); + controller == null ? void 0 : controller.close() } }, /** @@ -2782,23 +2787,23 @@ function createStitchableStream() { * and close the outer stream. */ terminate: () => { - isClosed = true; - waitForNewStream.resolve(); - innerStreamReaders.forEach((reader) => reader.cancel()); - innerStreamReaders = []; - controller == null ? void 0 : controller.close(); + isClosed = true + waitForNewStream.resolve() + innerStreamReaders.forEach((reader) => reader.cancel()) + innerStreamReaders = [] + controller == null ? void 0 : controller.close() } - }; + } } // core/util/now.ts function now() { - var _a14, _b; - return (_b = (_a14 = globalThis == null ? void 0 : globalThis.performance) == null ? void 0 : _a14.now()) != null ? _b : Date.now(); + var _a14, _b + return (_b = (_a14 = globalThis == null ? void 0 : globalThis.performance) == null ? void 0 : _a14.now()) != null ? _b : Date.now() } // core/generate-object/stream-object.ts -var originalGenerateId2 = (0, import_provider_utils7.createIdGenerator)({ prefix: "aiobj", size: 24 }); +var originalGenerateId2 = (0, import_provider_utils7.createIdGenerator)({ prefix: "aiobj", size: 24 }) function streamObject({ model, schema: inputSchema, @@ -2828,10 +2833,10 @@ function streamObject({ schema: inputSchema, schemaName, schemaDescription - }); - const outputStrategy = getOutputStrategy({ output, schema: inputSchema }); + }) + const outputStrategy = getOutputStrategy({ output, schema: inputSchema }) if (outputStrategy.type === "no-schema" && mode === void 0) { - mode = "json"; + mode = "json" } return new DefaultStreamObjectResult({ model, @@ -2852,7 +2857,7 @@ function streamObject({ generateId: generateId3, currentDate, now: now2 - }); + }) } var DefaultStreamObjectResult = class { constructor({ @@ -2875,24 +2880,24 @@ var DefaultStreamObjectResult = class { currentDate, now: now2 }) { - this.objectPromise = new DelayedPromise(); - this.usagePromise = new DelayedPromise(); - this.providerMetadataPromise = new DelayedPromise(); - this.warningsPromise = new DelayedPromise(); - this.requestPromise = new DelayedPromise(); - this.responsePromise = new DelayedPromise(); - this.stitchableStream = createStitchableStream(); + this.objectPromise = new DelayedPromise() + this.usagePromise = new DelayedPromise() + this.providerMetadataPromise = new DelayedPromise() + this.warningsPromise = new DelayedPromise() + this.requestPromise = new DelayedPromise() + this.responsePromise = new DelayedPromise() + this.stitchableStream = createStitchableStream() const { maxRetries, retry } = prepareRetries({ maxRetries: maxRetriesArg - }); + }) const baseTelemetryAttributes = getBaseTelemetryAttributes({ model, telemetry, headers, settings: { ...settings, maxRetries } - }); - const tracer = getTracer(telemetry); - const self = this; + }) + const tracer = getTracer(telemetry) + const self = this recordSpan({ name: "ai.streamObject", attributes: selectTelemetryAttributes({ @@ -2918,10 +2923,10 @@ var DefaultStreamObjectResult = class { endWhenDone: false, fn: async (rootSpan) => { if (mode === "auto" || mode == null) { - mode = model.defaultObjectGenerationMode; + mode = model.defaultObjectGenerationMode } - let callOptions; - let transformer; + let callOptions + let transformer switch (mode) { case "json": { const standardizedPrompt = standardizePrompt({ @@ -2934,7 +2939,7 @@ var DefaultStreamObjectResult = class { messages }, tools: void 0 - }); + }) callOptions = { mode: { type: "object-json", @@ -2952,28 +2957,28 @@ var DefaultStreamObjectResult = class { providerMetadata: inputProviderMetadata, abortSignal, headers - }; + } transformer = { transform: (chunk, controller) => { switch (chunk.type) { case "text-delta": - controller.enqueue(chunk.textDelta); - break; + controller.enqueue(chunk.textDelta) + break case "response-metadata": case "finish": case "error": - controller.enqueue(chunk); - break; + controller.enqueue(chunk) + break } } - }; - break; + } + break } case "tool": { const standardizedPrompt = standardizePrompt({ prompt: { system, prompt, messages }, tools: void 0 - }); + }) callOptions = { mode: { type: "object-tool", @@ -2994,31 +2999,31 @@ var DefaultStreamObjectResult = class { providerMetadata: inputProviderMetadata, abortSignal, headers - }; + } transformer = { transform(chunk, controller) { switch (chunk.type) { case "tool-call-delta": - controller.enqueue(chunk.argsTextDelta); - break; + controller.enqueue(chunk.argsTextDelta) + break case "response-metadata": case "finish": case "error": - controller.enqueue(chunk); - break; + controller.enqueue(chunk) + break } } - }; - break; + } + break } case void 0: { throw new Error( "Model does not have a default object generation mode." - ); + ) } default: { - const _exhaustiveCheck = mode; - throw new Error(`Unsupported mode: ${_exhaustiveCheck}`); + const _exhaustiveCheck = mode + throw new Error(`Unsupported mode: ${_exhaustiveCheck}`) } } const { @@ -3062,42 +3067,42 @@ var DefaultStreamObjectResult = class { result: await model.doStream(callOptions) }) }) - ); - self.requestPromise.resolve(request != null ? request : {}); - let usage; - let finishReason; - let providerMetadata; - let object2; - let error; - let accumulatedText = ""; - let textDelta = ""; + ) + self.requestPromise.resolve(request != null ? request : {}) + let usage + let finishReason + let providerMetadata + let object2 + let error + let accumulatedText = "" + let textDelta = "" let response = { id: generateId3(), timestamp: currentDate(), modelId: model.modelId - }; - let latestObjectJson = void 0; - let latestObject = void 0; - let isFirstChunk = true; - let isFirstDelta = true; + } + let latestObjectJson = void 0 + let latestObject = void 0 + let isFirstChunk = true + let isFirstDelta = true const transformedStream = stream.pipeThrough(new TransformStream(transformer)).pipeThrough( new TransformStream({ async transform(chunk, controller) { - var _a14, _b, _c; + var _a14, _b, _c if (isFirstChunk) { - const msToFirstChunk = now2() - startTimestampMs; - isFirstChunk = false; + const msToFirstChunk = now2() - startTimestampMs + isFirstChunk = false doStreamSpan.addEvent("ai.stream.firstChunk", { "ai.stream.msToFirstChunk": msToFirstChunk - }); + }) doStreamSpan.setAttributes({ "ai.stream.msToFirstChunk": msToFirstChunk - }); + }) } if (typeof chunk === "string") { - accumulatedText += chunk; - textDelta += chunk; - const { value: currentObjectJson, state: parseState } = (0, import_ui_utils3.parsePartialJson)(accumulatedText); + accumulatedText += chunk + textDelta += chunk + const { value: currentObjectJson, state: parseState } = (0, import_ui_utils3.parsePartialJson)(accumulatedText) if (currentObjectJson !== void 0 && !(0, import_ui_utils3.isDeepEqualData)(latestObjectJson, currentObjectJson)) { const validationResult = outputStrategy.validatePartialResult({ value: currentObjectJson, @@ -3105,26 +3110,26 @@ var DefaultStreamObjectResult = class { latestObject, isFirstDelta, isFinalDelta: parseState === "successful-parse" - }); + }) if (validationResult.success && !(0, import_ui_utils3.isDeepEqualData)( latestObject, validationResult.value.partial )) { - latestObjectJson = currentObjectJson; - latestObject = validationResult.value.partial; + latestObjectJson = currentObjectJson + latestObject = validationResult.value.partial controller.enqueue({ type: "object", object: latestObject - }); + }) controller.enqueue({ type: "text-delta", textDelta: validationResult.value.textDelta - }); - textDelta = ""; - isFirstDelta = false; + }) + textDelta = "" + isFirstDelta = false } } - return; + return } switch (chunk.type) { case "response-metadata": { @@ -3132,23 +3137,23 @@ var DefaultStreamObjectResult = class { id: (_a14 = chunk.id) != null ? _a14 : response.id, timestamp: (_b = chunk.timestamp) != null ? _b : response.timestamp, modelId: (_c = chunk.modelId) != null ? _c : response.modelId - }; - break; + } + break } case "finish": { if (textDelta !== "") { - controller.enqueue({ type: "text-delta", textDelta }); + controller.enqueue({ type: "text-delta", textDelta }) } - finishReason = chunk.finishReason; - usage = calculateLanguageModelUsage(chunk.usage); - providerMetadata = chunk.providerMetadata; - controller.enqueue({ ...chunk, usage, response }); - self.usagePromise.resolve(usage); - self.providerMetadataPromise.resolve(providerMetadata); + finishReason = chunk.finishReason + usage = calculateLanguageModelUsage(chunk.usage) + providerMetadata = chunk.providerMetadata + controller.enqueue({ ...chunk, usage, response }) + self.usagePromise.resolve(usage) + self.providerMetadataPromise.resolve(providerMetadata) self.responsePromise.resolve({ ...response, headers: rawResponse == null ? void 0 : rawResponse.headers - }); + }) const validationResult = outputStrategy.validateFinalResult( latestObjectJson, { @@ -3156,10 +3161,10 @@ var DefaultStreamObjectResult = class { response, usage } - ); + ) if (validationResult.success) { - object2 = validationResult.value; - self.objectPromise.resolve(object2); + object2 = validationResult.value + self.objectPromise.resolve(object2) } else { error = new NoObjectGeneratedError({ message: "No object generated: response did not match schema.", @@ -3167,14 +3172,14 @@ var DefaultStreamObjectResult = class { text: accumulatedText, response, usage - }); - self.objectPromise.reject(error); + }) + self.objectPromise.reject(error) } - break; + break } default: { - controller.enqueue(chunk); - break; + controller.enqueue(chunk) + break } } }, @@ -3185,7 +3190,7 @@ var DefaultStreamObjectResult = class { promptTokens: NaN, completionTokens: NaN, totalTokens: NaN - }; + } doStreamSpan.setAttributes( selectTelemetryAttributes({ telemetry, @@ -3207,8 +3212,8 @@ var DefaultStreamObjectResult = class { "gen_ai.usage.output_tokens": finalUsage.completionTokens } }) - ); - doStreamSpan.end(); + ) + doStreamSpan.end() rootSpan.setAttributes( selectTelemetryAttributes({ telemetry, @@ -3220,7 +3225,7 @@ var DefaultStreamObjectResult = class { } } }) - ); + ) await (onFinish == null ? void 0 : onFinish({ usage: finalUsage, object: object2, @@ -3231,47 +3236,47 @@ var DefaultStreamObjectResult = class { }, warnings, experimental_providerMetadata: providerMetadata - })); + })) } catch (error2) { - controller.error(error2); + controller.error(error2) } finally { - rootSpan.end(); + rootSpan.end() } } }) - ); - self.stitchableStream.addStream(transformedStream); + ) + self.stitchableStream.addStream(transformedStream) } }).catch((error) => { self.stitchableStream.addStream( new ReadableStream({ start(controller) { - controller.error(error); + controller.error(error) } }) - ); + ) }).finally(() => { - self.stitchableStream.close(); - }); - this.outputStrategy = outputStrategy; + self.stitchableStream.close() + }) + this.outputStrategy = outputStrategy } get object() { - return this.objectPromise.value; + return this.objectPromise.value } get usage() { - return this.usagePromise.value; + return this.usagePromise.value } get experimental_providerMetadata() { - return this.providerMetadataPromise.value; + return this.providerMetadataPromise.value } get warnings() { - return this.warningsPromise.value; + return this.warningsPromise.value } get request() { - return this.requestPromise.value; + return this.requestPromise.value } get response() { - return this.responsePromise.value; + return this.responsePromise.value } get partialObjectStream() { return createAsyncIterableStream( @@ -3280,28 +3285,28 @@ var DefaultStreamObjectResult = class { transform(chunk, controller) { switch (chunk.type) { case "object": - controller.enqueue(chunk.object); - break; + controller.enqueue(chunk.object) + break case "text-delta": case "finish": - break; + break case "error": - controller.error(chunk.error); - break; + controller.error(chunk.error) + break default: { - const _exhaustiveCheck = chunk; - throw new Error(`Unsupported chunk type: ${_exhaustiveCheck}`); + const _exhaustiveCheck = chunk + throw new Error(`Unsupported chunk type: ${_exhaustiveCheck}`) } } } }) ) - ); + ) } get elementStream() { return this.outputStrategy.createElementStream( this.stitchableStream.stream - ); + ) } get textStream() { return createAsyncIterableStream( @@ -3310,26 +3315,26 @@ var DefaultStreamObjectResult = class { transform(chunk, controller) { switch (chunk.type) { case "text-delta": - controller.enqueue(chunk.textDelta); - break; + controller.enqueue(chunk.textDelta) + break case "object": case "finish": - break; + break case "error": - controller.error(chunk.error); - break; + controller.error(chunk.error) + break default: { - const _exhaustiveCheck = chunk; - throw new Error(`Unsupported chunk type: ${_exhaustiveCheck}`); + const _exhaustiveCheck = chunk + throw new Error(`Unsupported chunk type: ${_exhaustiveCheck}`) } } } }) ) - ); + ) } get fullStream() { - return createAsyncIterableStream(this.stitchableStream.stream); + return createAsyncIterableStream(this.stitchableStream.stream) } pipeTextStreamToResponse(response, init) { writeToServerResponse({ @@ -3340,46 +3345,46 @@ var DefaultStreamObjectResult = class { contentType: "text/plain; charset=utf-8" }), stream: this.textStream.pipeThrough(new TextEncoderStream()) - }); + }) } toTextStreamResponse(init) { - var _a14; + var _a14 return new Response(this.textStream.pipeThrough(new TextEncoderStream()), { status: (_a14 = init == null ? void 0 : init.status) != null ? _a14 : 200, headers: prepareResponseHeaders(init == null ? void 0 : init.headers, { contentType: "text/plain; charset=utf-8" }) - }); + }) } -}; +} // core/generate-text/generate-text.ts -var import_provider_utils9 = require("@ai-sdk/provider-utils"); +var import_provider_utils9 = require("@ai-sdk/provider-utils") // errors/no-output-specified-error.ts -var import_provider11 = require("@ai-sdk/provider"); -var name8 = "AI_NoOutputSpecifiedError"; -var marker8 = `vercel.ai.error.${name8}`; -var symbol8 = Symbol.for(marker8); -var _a8; +var import_provider11 = require("@ai-sdk/provider") +var name8 = "AI_NoOutputSpecifiedError" +var marker8 = `vercel.ai.error.${name8}` +var symbol8 = Symbol.for(marker8) +var _a8 var NoOutputSpecifiedError = class extends import_provider11.AISDKError { // used in isInstance constructor({ message = "No output specified." } = {}) { - super({ name: name8, message }); - this[_a8] = true; + super({ name: name8, message }) + this[_a8] = true } static isInstance(error) { - return import_provider11.AISDKError.hasMarker(error, marker8); + return import_provider11.AISDKError.hasMarker(error, marker8) } -}; -_a8 = symbol8; +} +_a8 = symbol8 // errors/tool-execution-error.ts -var import_provider12 = require("@ai-sdk/provider"); -var name9 = "AI_ToolExecutionError"; -var marker9 = `vercel.ai.error.${name9}`; -var symbol9 = Symbol.for(marker9); -var _a9; +var import_provider12 = require("@ai-sdk/provider") +var name9 = "AI_ToolExecutionError" +var marker9 = `vercel.ai.error.${name9}` +var symbol9 = Symbol.for(marker9) +var _a9 var ToolExecutionError = class extends import_provider12.AISDKError { constructor({ toolArgs, @@ -3388,24 +3393,24 @@ var ToolExecutionError = class extends import_provider12.AISDKError { cause, message = `Error executing tool ${toolName}: ${(0, import_provider12.getErrorMessage)(cause)}` }) { - super({ name: name9, message, cause }); - this[_a9] = true; - this.toolArgs = toolArgs; - this.toolName = toolName; - this.toolCallId = toolCallId; + super({ name: name9, message, cause }) + this[_a9] = true + this.toolArgs = toolArgs + this.toolName = toolName + this.toolCallId = toolCallId } static isInstance(error) { - return import_provider12.AISDKError.hasMarker(error, marker9); + return import_provider12.AISDKError.hasMarker(error, marker9) } -}; -_a9 = symbol9; +} +_a9 = symbol9 // core/prompt/prepare-tools-and-tool-choice.ts -var import_ui_utils4 = require("@ai-sdk/ui-utils"); +var import_ui_utils4 = require("@ai-sdk/ui-utils") // core/util/is-non-empty-object.ts function isNonEmptyObject(object2) { - return object2 != null && Object.keys(object2).length > 0; + return object2 != null && Object.keys(object2).length > 0 } // core/prompt/prepare-tools-and-tool-choice.ts @@ -3418,14 +3423,14 @@ function prepareToolsAndToolChoice({ return { tools: void 0, toolChoice: void 0 - }; + } } const filteredTools = activeTools != null ? Object.entries(tools).filter( ([name14]) => activeTools.includes(name14) - ) : Object.entries(tools); + ) : Object.entries(tools) return { tools: filteredTools.map(([name14, tool2]) => { - const toolType = tool2.type; + const toolType = tool2.type switch (toolType) { case void 0: case "function": @@ -3434,47 +3439,47 @@ function prepareToolsAndToolChoice({ name: name14, description: tool2.description, parameters: (0, import_ui_utils4.asSchema)(tool2.parameters).jsonSchema - }; + } case "provider-defined": return { type: "provider-defined", name: name14, id: tool2.id, args: tool2.args - }; + } default: { - const exhaustiveCheck = toolType; - throw new Error(`Unsupported tool type: ${exhaustiveCheck}`); + const exhaustiveCheck = toolType + throw new Error(`Unsupported tool type: ${exhaustiveCheck}`) } } }), toolChoice: toolChoice == null ? { type: "auto" } : typeof toolChoice === "string" ? { type: toolChoice } : { type: "tool", toolName: toolChoice.toolName } - }; + } } // core/util/split-on-last-whitespace.ts -var lastWhitespaceRegexp = /^([\s\S]*?)(\s+)(\S*)$/; +var lastWhitespaceRegexp = /^([\s\S]*?)(\s+)(\S*)$/ function splitOnLastWhitespace(text2) { - const match = text2.match(lastWhitespaceRegexp); - return match ? { prefix: match[1], whitespace: match[2], suffix: match[3] } : void 0; + const match = text2.match(lastWhitespaceRegexp) + return match ? { prefix: match[1], whitespace: match[2], suffix: match[3] } : void 0 } // core/util/remove-text-after-last-whitespace.ts function removeTextAfterLastWhitespace(text2) { - const match = splitOnLastWhitespace(text2); - return match ? match.prefix + match.whitespace : text2; + const match = splitOnLastWhitespace(text2) + return match ? match.prefix + match.whitespace : text2 } // core/generate-text/parse-tool-call.ts -var import_provider_utils8 = require("@ai-sdk/provider-utils"); -var import_ui_utils5 = require("@ai-sdk/ui-utils"); +var import_provider_utils8 = require("@ai-sdk/provider-utils") +var import_ui_utils5 = require("@ai-sdk/ui-utils") // errors/invalid-tool-arguments-error.ts -var import_provider13 = require("@ai-sdk/provider"); -var name10 = "AI_InvalidToolArgumentsError"; -var marker10 = `vercel.ai.error.${name10}`; -var symbol10 = Symbol.for(marker10); -var _a10; +var import_provider13 = require("@ai-sdk/provider") +var name10 = "AI_InvalidToolArgumentsError" +var marker10 = `vercel.ai.error.${name10}` +var symbol10 = Symbol.for(marker10) +var _a10 var InvalidToolArgumentsError = class extends import_provider13.AISDKError { constructor({ toolArgs, @@ -3484,61 +3489,61 @@ var InvalidToolArgumentsError = class extends import_provider13.AISDKError { cause )}` }) { - super({ name: name10, message, cause }); - this[_a10] = true; - this.toolArgs = toolArgs; - this.toolName = toolName; + super({ name: name10, message, cause }) + this[_a10] = true + this.toolArgs = toolArgs + this.toolName = toolName } static isInstance(error) { - return import_provider13.AISDKError.hasMarker(error, marker10); + return import_provider13.AISDKError.hasMarker(error, marker10) } -}; -_a10 = symbol10; +} +_a10 = symbol10 // errors/no-such-tool-error.ts -var import_provider14 = require("@ai-sdk/provider"); -var name11 = "AI_NoSuchToolError"; -var marker11 = `vercel.ai.error.${name11}`; -var symbol11 = Symbol.for(marker11); -var _a11; +var import_provider14 = require("@ai-sdk/provider") +var name11 = "AI_NoSuchToolError" +var marker11 = `vercel.ai.error.${name11}` +var symbol11 = Symbol.for(marker11) +var _a11 var NoSuchToolError = class extends import_provider14.AISDKError { constructor({ toolName, availableTools = void 0, message = `Model tried to call unavailable tool '${toolName}'. ${availableTools === void 0 ? "No tools are available." : `Available tools: ${availableTools.join(", ")}.`}` }) { - super({ name: name11, message }); - this[_a11] = true; - this.toolName = toolName; - this.availableTools = availableTools; + super({ name: name11, message }) + this[_a11] = true + this.toolName = toolName + this.availableTools = availableTools } static isInstance(error) { - return import_provider14.AISDKError.hasMarker(error, marker11); + return import_provider14.AISDKError.hasMarker(error, marker11) } -}; -_a11 = symbol11; +} +_a11 = symbol11 // errors/tool-call-repair-error.ts -var import_provider15 = require("@ai-sdk/provider"); -var name12 = "AI_ToolCallRepairError"; -var marker12 = `vercel.ai.error.${name12}`; -var symbol12 = Symbol.for(marker12); -var _a12; +var import_provider15 = require("@ai-sdk/provider") +var name12 = "AI_ToolCallRepairError" +var marker12 = `vercel.ai.error.${name12}` +var symbol12 = Symbol.for(marker12) +var _a12 var ToolCallRepairError = class extends import_provider15.AISDKError { constructor({ cause, originalError, message = `Error repairing tool call: ${(0, import_provider15.getErrorMessage)(cause)}` }) { - super({ name: name12, message, cause }); - this[_a12] = true; - this.originalError = originalError; + super({ name: name12, message, cause }) + this[_a12] = true + this.originalError = originalError } static isInstance(error) { - return import_provider15.AISDKError.hasMarker(error, marker12); + return import_provider15.AISDKError.hasMarker(error, marker12) } -}; -_a12 = symbol12; +} +_a12 = symbol12 // core/generate-text/parse-tool-call.ts async function parseToolCall({ @@ -3549,15 +3554,15 @@ async function parseToolCall({ messages }) { if (tools == null) { - throw new NoSuchToolError({ toolName: toolCall.toolName }); + throw new NoSuchToolError({ toolName: toolCall.toolName }) } try { - return await doParseToolCall({ toolCall, tools }); + return await doParseToolCall({ toolCall, tools }) } catch (error) { if (repairToolCall == null || !(NoSuchToolError.isInstance(error) || InvalidToolArgumentsError.isInstance(error))) { - throw error; + throw error } - let repairedToolCall = null; + let repairedToolCall = null try { repairedToolCall = await repairToolCall({ toolCall, @@ -3566,46 +3571,46 @@ async function parseToolCall({ system, messages, error - }); + }) } catch (repairError) { throw new ToolCallRepairError({ cause: repairError, originalError: error - }); + }) } if (repairedToolCall == null) { - throw error; + throw error } - return await doParseToolCall({ toolCall: repairedToolCall, tools }); + return await doParseToolCall({ toolCall: repairedToolCall, tools }) } } async function doParseToolCall({ toolCall, tools }) { - const toolName = toolCall.toolName; - const tool2 = tools[toolName]; + const toolName = toolCall.toolName + const tool2 = tools[toolName] if (tool2 == null) { throw new NoSuchToolError({ toolName: toolCall.toolName, availableTools: Object.keys(tools) - }); + }) } - const schema = (0, import_ui_utils5.asSchema)(tool2.parameters); - const parseResult = toolCall.args.trim() === "" ? (0, import_provider_utils8.safeValidateTypes)({ value: {}, schema }) : (0, import_provider_utils8.safeParseJSON)({ text: toolCall.args, schema }); + const schema = (0, import_ui_utils5.asSchema)(tool2.parameters) + const parseResult = toolCall.args.trim() === "" ? (0, import_provider_utils8.safeValidateTypes)({ value: {}, schema }) : (0, import_provider_utils8.safeParseJSON)({ text: toolCall.args, schema }) if (parseResult.success === false) { throw new InvalidToolArgumentsError({ toolName, toolArgs: toolCall.args, cause: parseResult.error - }); + }) } return { type: "tool-call", toolCallId: toolCall.toolCallId, toolName, args: parseResult.value - }; + } } // core/generate-text/to-response-messages.ts @@ -3617,18 +3622,18 @@ function toResponseMessages({ messageId, generateMessageId }) { - const responseMessages = []; + const responseMessages = [] responseMessages.push({ role: "assistant", content: [{ type: "text", text: text2 }, ...toolCalls], id: messageId - }); + }) if (toolResults.length > 0) { responseMessages.push({ role: "tool", id: generateMessageId(), content: toolResults.map((toolResult) => { - const tool2 = tools[toolResult.toolName]; + const tool2 = tools[toolResult.toolName] return (tool2 == null ? void 0 : tool2.experimental_toToolResultContent) != null ? { type: "tool-result", toolCallId: toolResult.toolCallId, @@ -3642,22 +3647,22 @@ function toResponseMessages({ toolCallId: toolResult.toolCallId, toolName: toolResult.toolName, result: toolResult.result - }; + } }) - }); + }) } - return responseMessages; + return responseMessages } // core/generate-text/generate-text.ts var originalGenerateId3 = (0, import_provider_utils9.createIdGenerator)({ prefix: "aitxt", size: 24 -}); +}) var originalGenerateMessageId = (0, import_provider_utils9.createIdGenerator)({ prefix: "msg", size: 24 -}); +}) async function generateText({ model, tools, @@ -3683,21 +3688,21 @@ async function generateText({ onStepFinish, ...settings }) { - var _a14; + var _a14 if (maxSteps < 1) { throw new InvalidArgumentError({ parameter: "maxSteps", value: maxSteps, message: "maxSteps must be at least 1" - }); + }) } - const { maxRetries, retry } = prepareRetries({ maxRetries: maxRetriesArg }); + const { maxRetries, retry } = prepareRetries({ maxRetries: maxRetriesArg }) const baseTelemetryAttributes = getBaseTelemetryAttributes({ model, telemetry, headers, settings: { ...settings, maxRetries } - }); + }) const initialPrompt = standardizePrompt({ prompt: { system: (_a14 = output == null ? void 0 : output.injectIntoSystemPrompt({ system, model })) != null ? _a14 : system, @@ -3705,8 +3710,8 @@ async function generateText({ messages }, tools - }); - const tracer = getTracer(telemetry); + }) + const tracer = getTracer(telemetry) return recordSpan({ name: "ai.generateText", attributes: selectTelemetryAttributes({ @@ -3726,31 +3731,31 @@ async function generateText({ }), tracer, fn: async (span) => { - var _a15, _b, _c, _d, _e, _f; + var _a15, _b, _c, _d, _e, _f const mode = { type: "regular", ...prepareToolsAndToolChoice({ tools, toolChoice, activeTools }) - }; - const callSettings = prepareCallSettings(settings); - let currentModelResponse; - let currentToolCalls = []; - let currentToolResults = []; - let stepCount = 0; - const responseMessages = []; - let text2 = ""; - const steps = []; + } + const callSettings = prepareCallSettings(settings) + let currentModelResponse + let currentToolCalls = [] + let currentToolResults = [] + let stepCount = 0 + const responseMessages = [] + let text2 = "" + const steps = [] let usage = { completionTokens: 0, promptTokens: 0, totalTokens: 0 - }; - let stepType = "initial"; + } + let stepType = "initial" do { - const promptFormat = stepCount === 0 ? initialPrompt.type : "messages"; + const promptFormat = stepCount === 0 ? initialPrompt.type : "messages" const stepInputMessages = [ ...initialPrompt.messages, ...responseMessages - ]; + ] const promptMessages = await convertToLanguageModelPrompt({ prompt: { type: promptFormat, @@ -3759,7 +3764,7 @@ async function generateText({ }, modelSupportsImageUrls: model.supportsImageUrls, modelSupportsUrl: model.supportsUrl - }); + }) currentModelResponse = await retry( () => recordSpan({ name: "ai.generateText.doGenerate", @@ -3778,8 +3783,8 @@ async function generateText({ "ai.prompt.tools": { // convert the language model level tools: input: () => { - var _a16; - return (_a16 = mode.tools) == null ? void 0 : _a16.map((tool2) => JSON.stringify(tool2)); + var _a16 + return (_a16 = mode.tools) == null ? void 0 : _a16.map((tool2) => JSON.stringify(tool2)) } }, "ai.prompt.toolChoice": { @@ -3799,7 +3804,7 @@ async function generateText({ }), tracer, fn: async (span2) => { - var _a16, _b2, _c2, _d2, _e2, _f2; + var _a16, _b2, _c2, _d2, _e2, _f2 const result = await model.doGenerate({ mode, ...callSettings, @@ -3809,12 +3814,12 @@ async function generateText({ providerMetadata, abortSignal, headers - }); + }) const responseData = { id: (_b2 = (_a16 = result.response) == null ? void 0 : _a16.id) != null ? _b2 : generateId3(), timestamp: (_d2 = (_c2 = result.response) == null ? void 0 : _c2.timestamp) != null ? _d2 : currentDate(), modelId: (_f2 = (_e2 = result.response) == null ? void 0 : _e2.modelId) != null ? _f2 : model.modelId - }; + } span2.setAttributes( selectTelemetryAttributes({ telemetry, @@ -3839,11 +3844,11 @@ async function generateText({ "gen_ai.usage.output_tokens": result.usage.completionTokens } }) - ); - return { ...result, response: responseData }; + ) + return { ...result, response: responseData } } }) - ); + ) currentToolCalls = await Promise.all( ((_a15 = currentModelResponse.toolCalls) != null ? _a15 : []).map( (toolCall) => parseToolCall({ @@ -3854,7 +3859,7 @@ async function generateText({ messages: stepInputMessages }) ) - ); + ) currentToolResults = tools == null ? [] : await executeTools({ toolCalls: currentToolCalls, tools, @@ -3862,38 +3867,38 @@ async function generateText({ telemetry, messages: stepInputMessages, abortSignal - }); + }) const currentUsage = calculateLanguageModelUsage( currentModelResponse.usage - ); - usage = addLanguageModelUsage(usage, currentUsage); - let nextStepType = "done"; + ) + usage = addLanguageModelUsage(usage, currentUsage) + let nextStepType = "done" if (++stepCount < maxSteps) { if (continueSteps && currentModelResponse.finishReason === "length" && // only use continue when there are no tool calls: currentToolCalls.length === 0) { - nextStepType = "continue"; + nextStepType = "continue" } else if ( // there are tool calls: currentToolCalls.length > 0 && // all current tool calls have results: currentToolResults.length === currentToolCalls.length ) { - nextStepType = "tool-result"; + nextStepType = "tool-result" } } - const originalText = (_b = currentModelResponse.text) != null ? _b : ""; + const originalText = (_b = currentModelResponse.text) != null ? _b : "" const stepTextLeadingWhitespaceTrimmed = stepType === "continue" && // only for continue steps - text2.trimEnd() !== text2 ? originalText.trimStart() : originalText; - const stepText = nextStepType === "continue" ? removeTextAfterLastWhitespace(stepTextLeadingWhitespaceTrimmed) : stepTextLeadingWhitespaceTrimmed; - text2 = nextStepType === "continue" || stepType === "continue" ? text2 + stepText : stepText; + text2.trimEnd() !== text2 ? originalText.trimStart() : originalText + const stepText = nextStepType === "continue" ? removeTextAfterLastWhitespace(stepTextLeadingWhitespaceTrimmed) : stepTextLeadingWhitespaceTrimmed + text2 = nextStepType === "continue" || stepType === "continue" ? text2 + stepText : stepText if (stepType === "continue") { - const lastMessage = responseMessages[responseMessages.length - 1]; + const lastMessage = responseMessages[responseMessages.length - 1] if (typeof lastMessage.content === "string") { - lastMessage.content += stepText; + lastMessage.content += stepText } else { lastMessage.content.push({ text: stepText, type: "text" - }); + }) } } else { responseMessages.push( @@ -3905,7 +3910,7 @@ async function generateText({ messageId: generateMessageId(), generateMessageId }) - ); + ) } const currentStepResult = { stepType, @@ -3925,11 +3930,11 @@ async function generateText({ }, experimental_providerMetadata: currentModelResponse.providerMetadata, isContinued: nextStepType === "continue" - }; - steps.push(currentStepResult); - await (onStepFinish == null ? void 0 : onStepFinish(currentStepResult)); - stepType = nextStepType; - } while (stepType !== "done"); + } + steps.push(currentStepResult) + await (onStepFinish == null ? void 0 : onStepFinish(currentStepResult)) + stepType = nextStepType + } while (stepType !== "done") span.setAttributes( selectTelemetryAttributes({ telemetry, @@ -3945,17 +3950,17 @@ async function generateText({ "ai.usage.completionTokens": currentModelResponse.usage.completionTokens } }) - ); + ) return new DefaultGenerateTextResult({ text: text2, outputResolver: () => { if (output == null) { - throw new NoOutputSpecifiedError(); + throw new NoOutputSpecifiedError() } return output.parseOutput( { text: text2 }, { response: currentModelResponse.response, usage } - ); + ) }, toolCalls: currentToolCalls, toolResults: currentToolResults, @@ -3971,9 +3976,9 @@ async function generateText({ logprobs: currentModelResponse.logprobs, steps, providerMetadata: currentModelResponse.providerMetadata - }); + }) } - }); + }) } async function executeTools({ toolCalls, @@ -3985,9 +3990,9 @@ async function executeTools({ }) { const toolResults = await Promise.all( toolCalls.map(async ({ toolCallId, toolName, args }) => { - const tool2 = tools[toolName]; + const tool2 = tools[toolName] if ((tool2 == null ? void 0 : tool2.execute) == null) { - return void 0; + return void 0 } const result = await recordSpan({ name: "ai.toolCall", @@ -4012,7 +4017,7 @@ async function executeTools({ toolCallId, messages, abortSignal - }); + }) try { span.setAttributes( selectTelemetryAttributes({ @@ -4023,83 +4028,84 @@ async function executeTools({ } } }) - ); + ) } catch (ignored) { + console.error(ignored) } - return result2; + return result2 } catch (error) { throw new ToolExecutionError({ toolCallId, toolName, toolArgs: args, cause: error - }); + }) } } - }); + }) return { type: "tool-result", toolCallId, toolName, args, result - }; + } }) - ); + ) return toolResults.filter( (result) => result != null - ); + ) } var DefaultGenerateTextResult = class { constructor(options) { - this.text = options.text; - this.toolCalls = options.toolCalls; - this.toolResults = options.toolResults; - this.finishReason = options.finishReason; - this.usage = options.usage; - this.warnings = options.warnings; - this.request = options.request; - this.response = options.response; - this.steps = options.steps; - this.experimental_providerMetadata = options.providerMetadata; - this.logprobs = options.logprobs; - this.outputResolver = options.outputResolver; + this.text = options.text + this.toolCalls = options.toolCalls + this.toolResults = options.toolResults + this.finishReason = options.finishReason + this.usage = options.usage + this.warnings = options.warnings + this.request = options.request + this.response = options.response + this.steps = options.steps + this.experimental_providerMetadata = options.providerMetadata + this.logprobs = options.logprobs + this.outputResolver = options.outputResolver } get experimental_output() { - return this.outputResolver(); + return this.outputResolver() } -}; +} // core/generate-text/output.ts -var output_exports = {}; +var output_exports = {} __export(output_exports, { object: () => object, text: () => text -}); -var import_provider_utils10 = require("@ai-sdk/provider-utils"); -var import_ui_utils6 = require("@ai-sdk/ui-utils"); +}) +var import_provider_utils10 = require("@ai-sdk/provider-utils") +var import_ui_utils6 = require("@ai-sdk/ui-utils") // errors/index.ts -var import_provider16 = require("@ai-sdk/provider"); +var import_provider16 = require("@ai-sdk/provider") // core/generate-text/output.ts var text = () => ({ type: "text", responseFormat: () => ({ type: "text" }), injectIntoSystemPrompt({ system }) { - return system; + return system }, parsePartial({ text: text2 }) { - return { partial: text2 }; + return { partial: text2 } }, parseOutput({ text: text2 }) { - return text2; + return text2 } -}); +}) var object = ({ schema: inputSchema }) => { - const schema = (0, import_ui_utils6.asSchema)(inputSchema); + const schema = (0, import_ui_utils6.asSchema)(inputSchema) return { type: "object", responseFormat: ({ model }) => ({ @@ -4110,28 +4116,28 @@ var object = ({ return model.supportsStructuredOutputs ? system : injectJsonInstruction({ prompt: system, schema: schema.jsonSchema - }); + }) }, parsePartial({ text: text2 }) { - const result = (0, import_ui_utils6.parsePartialJson)(text2); + const result = (0, import_ui_utils6.parsePartialJson)(text2) switch (result.state) { case "failed-parse": case "undefined-input": - return void 0; + return void 0 case "repaired-parse": case "successful-parse": return { // Note: currently no validation of partial results: partial: result.value - }; + } default: { - const _exhaustiveCheck = result.state; - throw new Error(`Unsupported parse state: ${_exhaustiveCheck}`); + const _exhaustiveCheck = result.state + throw new Error(`Unsupported parse state: ${_exhaustiveCheck}`) } } }, parseOutput({ text: text2 }, context) { - const parseResult = (0, import_provider_utils10.safeParseJSON)({ text: text2 }); + const parseResult = (0, import_provider_utils10.safeParseJSON)({ text: text2 }) if (!parseResult.success) { throw new NoObjectGeneratedError({ message: "No object generated: could not parse the response.", @@ -4139,12 +4145,12 @@ var object = ({ text: text2, response: context.response, usage: context.usage - }); + }) } const validationResult = (0, import_provider_utils10.safeValidateTypes)({ value: parseResult.value, schema - }); + }) if (!validationResult.success) { throw new NoObjectGeneratedError({ message: "No object generated: response did not match schema.", @@ -4152,159 +4158,159 @@ var object = ({ text: text2, response: context.response, usage: context.usage - }); + }) } - return validationResult.value; + return validationResult.value } - }; -}; + } +} // core/generate-text/smooth-stream.ts -var import_provider17 = require("@ai-sdk/provider"); +var import_provider17 = require("@ai-sdk/provider") var CHUNKING_REGEXPS = { word: /\s*\S+\s+/m, line: /[^\n]*\n/m -}; +} function smoothStream({ delayInMs = 10, chunking = "word", _internal: { delay: delay2 = delay } = {} } = {}) { - const chunkingRegexp = typeof chunking === "string" ? CHUNKING_REGEXPS[chunking] : chunking; + const chunkingRegexp = typeof chunking === "string" ? CHUNKING_REGEXPS[chunking] : chunking if (chunkingRegexp == null) { throw new import_provider17.InvalidArgumentError({ argument: "chunking", message: `Chunking must be "word" or "line" or a RegExp. Received: ${chunking}` - }); + }) } return () => { - let buffer = ""; + let buffer = "" return new TransformStream({ async transform(chunk, controller) { if (chunk.type === "step-finish") { if (buffer.length > 0) { - controller.enqueue({ type: "text-delta", textDelta: buffer }); - buffer = ""; + controller.enqueue({ type: "text-delta", textDelta: buffer }) + buffer = "" } - controller.enqueue(chunk); - return; + controller.enqueue(chunk) + return } if (chunk.type !== "text-delta") { - controller.enqueue(chunk); - return; + controller.enqueue(chunk) + return } - buffer += chunk.textDelta; - let match; + buffer += chunk.textDelta + let match while ((match = chunkingRegexp.exec(buffer)) != null) { - const chunk2 = match[0]; - controller.enqueue({ type: "text-delta", textDelta: chunk2 }); - buffer = buffer.slice(chunk2.length); - await delay2(delayInMs); + const chunk2 = match[0] + controller.enqueue({ type: "text-delta", textDelta: chunk2 }) + buffer = buffer.slice(chunk2.length) + await delay2(delayInMs) } } - }); - }; + }) + } } // core/generate-text/stream-text.ts -var import_provider_utils11 = require("@ai-sdk/provider-utils"); -var import_ui_utils8 = require("@ai-sdk/ui-utils"); +var import_provider_utils11 = require("@ai-sdk/provider-utils") +var import_ui_utils8 = require("@ai-sdk/ui-utils") // util/as-array.ts function asArray(value) { - return value === void 0 ? [] : Array.isArray(value) ? value : [value]; + return value === void 0 ? [] : Array.isArray(value) ? value : [value] } // core/util/merge-streams.ts function mergeStreams(stream1, stream2) { - const reader1 = stream1.getReader(); - const reader2 = stream2.getReader(); - let lastRead1 = void 0; - let lastRead2 = void 0; - let stream1Done = false; - let stream2Done = false; + const reader1 = stream1.getReader() + const reader2 = stream2.getReader() + let lastRead1 = void 0 + let lastRead2 = void 0 + let stream1Done = false + let stream2Done = false async function readStream1(controller) { try { if (lastRead1 == null) { - lastRead1 = reader1.read(); + lastRead1 = reader1.read() } - const result = await lastRead1; - lastRead1 = void 0; + const result = await lastRead1 + lastRead1 = void 0 if (!result.done) { - controller.enqueue(result.value); + controller.enqueue(result.value) } else { - controller.close(); + controller.close() } } catch (error) { - controller.error(error); + controller.error(error) } } async function readStream2(controller) { try { if (lastRead2 == null) { - lastRead2 = reader2.read(); + lastRead2 = reader2.read() } - const result = await lastRead2; - lastRead2 = void 0; + const result = await lastRead2 + lastRead2 = void 0 if (!result.done) { - controller.enqueue(result.value); + controller.enqueue(result.value) } else { - controller.close(); + controller.close() } } catch (error) { - controller.error(error); + controller.error(error) } } return new ReadableStream({ async pull(controller) { try { if (stream1Done) { - await readStream2(controller); - return; + await readStream2(controller) + return } if (stream2Done) { - await readStream1(controller); - return; + await readStream1(controller) + return } if (lastRead1 == null) { - lastRead1 = reader1.read(); + lastRead1 = reader1.read() } if (lastRead2 == null) { - lastRead2 = reader2.read(); + lastRead2 = reader2.read() } const { result, reader } = await Promise.race([ lastRead1.then((result2) => ({ result: result2, reader: reader1 })), lastRead2.then((result2) => ({ result: result2, reader: reader2 })) - ]); + ]) if (!result.done) { - controller.enqueue(result.value); + controller.enqueue(result.value) } if (reader === reader1) { - lastRead1 = void 0; + lastRead1 = void 0 if (result.done) { - await readStream2(controller); - stream1Done = true; + await readStream2(controller) + stream1Done = true } } else { - lastRead2 = void 0; + lastRead2 = void 0 if (result.done) { - stream2Done = true; - await readStream1(controller); + stream2Done = true + await readStream1(controller) } } } catch (error) { - controller.error(error); + controller.error(error) } }, cancel() { - reader1.cancel(); - reader2.cancel(); + reader1.cancel() + reader2.cancel() } - }); + }) } // core/generate-text/run-tools-transformation.ts -var import_ui_utils7 = require("@ai-sdk/ui-utils"); +var import_ui_utils7 = require("@ai-sdk/ui-utils") function runToolsTransformation({ tools, generatorStream, @@ -4316,33 +4322,33 @@ function runToolsTransformation({ abortSignal, repairToolCall }) { - let toolResultsStreamController = null; + let toolResultsStreamController = null const toolResultsStream = new ReadableStream({ start(controller) { - toolResultsStreamController = controller; + toolResultsStreamController = controller } - }); - const activeToolCalls = {}; - const outstandingToolResults = /* @__PURE__ */ new Set(); - let canClose = false; - let finishChunk = void 0; + }) + const activeToolCalls = {} + const outstandingToolResults = /* @__PURE__ */ new Set() + let canClose = false + let finishChunk = void 0 function attemptClose() { if (canClose && outstandingToolResults.size === 0) { if (finishChunk != null) { - toolResultsStreamController.enqueue(finishChunk); + toolResultsStreamController.enqueue(finishChunk) } - toolResultsStreamController.close(); + toolResultsStreamController.close() } } const forwardStream = new TransformStream({ async transform(chunk, controller) { - const chunkType = chunk.type; + const chunkType = chunk.type switch (chunkType) { case "text-delta": case "response-metadata": case "error": { - controller.enqueue(chunk); - break; + controller.enqueue(chunk) + break } case "tool-call-delta": { if (toolCallStreaming) { @@ -4351,17 +4357,17 @@ function runToolsTransformation({ type: "tool-call-streaming-start", toolCallId: chunk.toolCallId, toolName: chunk.toolName - }); - activeToolCalls[chunk.toolCallId] = true; + }) + activeToolCalls[chunk.toolCallId] = true } controller.enqueue({ type: "tool-call-delta", toolCallId: chunk.toolCallId, toolName: chunk.toolName, argsTextDelta: chunk.argsTextDelta - }); + }) } - break; + break } case "tool-call": { try { @@ -4371,12 +4377,12 @@ function runToolsTransformation({ repairToolCall, system, messages - }); - controller.enqueue(toolCall); - const tool2 = tools[toolCall.toolName]; + }) + controller.enqueue(toolCall) + const tool2 = tools[toolCall.toolName] if (tool2.execute != null) { - const toolExecutionId = (0, import_ui_utils7.generateId)(); - outstandingToolResults.add(toolExecutionId); + const toolExecutionId = (0, import_ui_utils7.generateId)() + outstandingToolResults.add(toolExecutionId) recordSpan({ name: "ai.toolCall", attributes: selectTelemetryAttributes({ @@ -4404,9 +4410,9 @@ function runToolsTransformation({ ...toolCall, type: "tool-result", result - }); - outstandingToolResults.delete(toolExecutionId); - attemptClose(); + }) + outstandingToolResults.delete(toolExecutionId) + attemptClose() try { span.setAttributes( selectTelemetryAttributes({ @@ -4417,7 +4423,7 @@ function runToolsTransformation({ } } }) - ); + ) } catch (ignored) { } }, @@ -4430,20 +4436,20 @@ function runToolsTransformation({ toolArgs: toolCall.args, cause: error }) - }); - outstandingToolResults.delete(toolExecutionId); - attemptClose(); + }) + outstandingToolResults.delete(toolExecutionId) + attemptClose() } ) - }); + }) } } catch (error) { toolResultsStreamController.enqueue({ type: "error", error - }); + }) } - break; + break } case "finish": { finishChunk = { @@ -4452,27 +4458,27 @@ function runToolsTransformation({ logprobs: chunk.logprobs, usage: calculateLanguageModelUsage(chunk.usage), experimental_providerMetadata: chunk.providerMetadata - }; - break; + } + break } default: { - const _exhaustiveCheck = chunkType; - throw new Error(`Unhandled chunk type: ${_exhaustiveCheck}`); + const _exhaustiveCheck = chunkType + throw new Error(`Unhandled chunk type: ${_exhaustiveCheck}`) } } }, flush() { - canClose = true; - attemptClose(); + canClose = true + attemptClose() } - }); + }) return new ReadableStream({ async start(controller) { return Promise.all([ generatorStream.pipeThrough(forwardStream).pipeTo( new WritableStream({ write(chunk) { - controller.enqueue(chunk); + controller.enqueue(chunk) }, close() { } @@ -4481,27 +4487,27 @@ function runToolsTransformation({ toolResultsStream.pipeTo( new WritableStream({ write(chunk) { - controller.enqueue(chunk); + controller.enqueue(chunk) }, close() { - controller.close(); + controller.close() } }) ) - ]); + ]) } - }); + }) } // core/generate-text/stream-text.ts var originalGenerateId4 = (0, import_provider_utils11.createIdGenerator)({ prefix: "aitxt", size: 24 -}); +}) var originalGenerateMessageId2 = (0, import_provider_utils11.createIdGenerator)({ prefix: "msg", size: 24 -}); +}) function streamText({ model, tools, @@ -4559,33 +4565,33 @@ function streamText({ currentDate, generateId: generateId3, generateMessageId - }); + }) } function createOutputTransformStream(output) { if (!output) { return new TransformStream({ transform(chunk, controller) { - controller.enqueue({ part: chunk, partialOutput: void 0 }); + controller.enqueue({ part: chunk, partialOutput: void 0 }) } - }); + }) } - let text2 = ""; - let textChunk = ""; - let lastPublishedJson = ""; + let text2 = "" + let textChunk = "" + let lastPublishedJson = "" return new TransformStream({ transform(chunk, controller) { if (chunk.type !== "text-delta") { controller.enqueue({ part: chunk, partialOutput: void 0 - }); - return; + }) + return } - text2 += chunk.textDelta; - textChunk += chunk.textDelta; - const result = output.parsePartial({ text: text2 }); + text2 += chunk.textDelta + textChunk += chunk.textDelta + const result = output.parsePartial({ text: text2 }) if (result != null) { - const currentJson = JSON.stringify(result.partial); + const currentJson = JSON.stringify(result.partial) if (currentJson !== lastPublishedJson) { controller.enqueue({ part: { @@ -4593,9 +4599,9 @@ function createOutputTransformStream(output) { textDelta: textChunk }, partialOutput: result.partial - }); - lastPublishedJson = currentJson; - textChunk = ""; + }) + lastPublishedJson = currentJson + textChunk = "" } } }, @@ -4607,10 +4613,10 @@ function createOutputTransformStream(output) { textDelta: textChunk }, partialOutput: void 0 - }); + }) } } - }); + }) } var DefaultStreamTextResult = class { constructor({ @@ -4641,58 +4647,58 @@ var DefaultStreamTextResult = class { generateId: generateId3, generateMessageId }) { - this.warningsPromise = new DelayedPromise(); - this.usagePromise = new DelayedPromise(); - this.finishReasonPromise = new DelayedPromise(); - this.providerMetadataPromise = new DelayedPromise(); - this.textPromise = new DelayedPromise(); - this.toolCallsPromise = new DelayedPromise(); - this.toolResultsPromise = new DelayedPromise(); - this.requestPromise = new DelayedPromise(); - this.responsePromise = new DelayedPromise(); - this.stepsPromise = new DelayedPromise(); - var _a14; + this.warningsPromise = new DelayedPromise() + this.usagePromise = new DelayedPromise() + this.finishReasonPromise = new DelayedPromise() + this.providerMetadataPromise = new DelayedPromise() + this.textPromise = new DelayedPromise() + this.toolCallsPromise = new DelayedPromise() + this.toolResultsPromise = new DelayedPromise() + this.requestPromise = new DelayedPromise() + this.responsePromise = new DelayedPromise() + this.stepsPromise = new DelayedPromise() + var _a14 if (maxSteps < 1) { throw new InvalidArgumentError({ parameter: "maxSteps", value: maxSteps, message: "maxSteps must be at least 1" - }); + }) } - this.output = output; - let recordedStepText = ""; - let recordedContinuationText = ""; - let recordedFullText = ""; + this.output = output + let recordedStepText = "" + let recordedContinuationText = "" + let recordedFullText = "" const recordedResponse = { id: generateId3(), timestamp: currentDate(), modelId: model.modelId, messages: [] - }; - let recordedToolCalls = []; - let recordedToolResults = []; - let recordedFinishReason = void 0; - let recordedUsage = void 0; - let stepType = "initial"; - const recordedSteps = []; - let rootSpan; + } + let recordedToolCalls = [] + let recordedToolResults = [] + let recordedFinishReason = void 0 + let recordedUsage = void 0 + let stepType = "initial" + const recordedSteps = [] + let rootSpan const eventProcessor = new TransformStream({ async transform(chunk, controller) { - controller.enqueue(chunk); - const { part } = chunk; + controller.enqueue(chunk) + const { part } = chunk if (part.type === "text-delta" || part.type === "tool-call" || part.type === "tool-result" || part.type === "tool-call-streaming-start" || part.type === "tool-call-delta") { - await (onChunk == null ? void 0 : onChunk({ chunk: part })); + await (onChunk == null ? void 0 : onChunk({ chunk: part })) } if (part.type === "text-delta") { - recordedStepText += part.textDelta; - recordedContinuationText += part.textDelta; - recordedFullText += part.textDelta; + recordedStepText += part.textDelta + recordedContinuationText += part.textDelta + recordedFullText += part.textDelta } if (part.type === "tool-call") { - recordedToolCalls.push(part); + recordedToolCalls.push(part) } if (part.type === "tool-result") { - recordedToolResults.push(part); + recordedToolResults.push(part) } if (part.type === "step-finish") { const stepMessages = toResponseMessages({ @@ -4702,19 +4708,19 @@ var DefaultStreamTextResult = class { toolResults: recordedToolResults, messageId: part.messageId, generateMessageId - }); - const currentStep = recordedSteps.length; - let nextStepType = "done"; + }) + const currentStep = recordedSteps.length + let nextStepType = "done" if (currentStep + 1 < maxSteps) { if (continueSteps && part.finishReason === "length" && // only use continue when there are no tool calls: recordedToolCalls.length === 0) { - nextStepType = "continue"; + nextStepType = "continue" } else if ( // there are tool calls: recordedToolCalls.length > 0 && // all current tool calls have results: recordedToolResults.length === recordedToolCalls.length ) { - nextStepType = "tool-result"; + nextStepType = "tool-result" } } const currentStepResult = { @@ -4733,54 +4739,54 @@ var DefaultStreamTextResult = class { }, experimental_providerMetadata: part.experimental_providerMetadata, isContinued: part.isContinued - }; - await (onStepFinish == null ? void 0 : onStepFinish(currentStepResult)); - recordedSteps.push(currentStepResult); - recordedToolCalls = []; - recordedToolResults = []; - recordedStepText = ""; + } + await (onStepFinish == null ? void 0 : onStepFinish(currentStepResult)) + recordedSteps.push(currentStepResult) + recordedToolCalls = [] + recordedToolResults = [] + recordedStepText = "" if (nextStepType !== "done") { - stepType = nextStepType; + stepType = nextStepType } if (nextStepType !== "continue") { - recordedResponse.messages.push(...stepMessages); - recordedContinuationText = ""; + recordedResponse.messages.push(...stepMessages) + recordedContinuationText = "" } } if (part.type === "finish") { - recordedResponse.id = part.response.id; - recordedResponse.timestamp = part.response.timestamp; - recordedResponse.modelId = part.response.modelId; - recordedResponse.headers = part.response.headers; - recordedUsage = part.usage; - recordedFinishReason = part.finishReason; + recordedResponse.id = part.response.id + recordedResponse.timestamp = part.response.timestamp + recordedResponse.modelId = part.response.modelId + recordedResponse.headers = part.response.headers + recordedUsage = part.usage + recordedFinishReason = part.finishReason } }, async flush(controller) { - var _a15; + var _a15 try { if (recordedSteps.length === 0) { - return; + return } - const lastStep = recordedSteps[recordedSteps.length - 1]; - self.warningsPromise.resolve(lastStep.warnings); - self.requestPromise.resolve(lastStep.request); - self.responsePromise.resolve(lastStep.response); - self.toolCallsPromise.resolve(lastStep.toolCalls); - self.toolResultsPromise.resolve(lastStep.toolResults); + const lastStep = recordedSteps[recordedSteps.length - 1] + self.warningsPromise.resolve(lastStep.warnings) + self.requestPromise.resolve(lastStep.request) + self.responsePromise.resolve(lastStep.response) + self.toolCallsPromise.resolve(lastStep.toolCalls) + self.toolResultsPromise.resolve(lastStep.toolResults) self.providerMetadataPromise.resolve( lastStep.experimental_providerMetadata - ); - const finishReason = recordedFinishReason != null ? recordedFinishReason : "unknown"; + ) + const finishReason = recordedFinishReason != null ? recordedFinishReason : "unknown" const usage = recordedUsage != null ? recordedUsage : { completionTokens: NaN, promptTokens: NaN, totalTokens: NaN - }; - self.finishReasonPromise.resolve(finishReason); - self.usagePromise.resolve(usage); - self.textPromise.resolve(recordedFullText); - self.stepsPromise.resolve(recordedSteps); + } + self.finishReasonPromise.resolve(finishReason) + self.usagePromise.resolve(usage) + self.textPromise.resolve(recordedFullText) + self.stepsPromise.resolve(recordedSteps) await (onFinish == null ? void 0 : onFinish({ finishReason, logprobs: void 0, @@ -4793,7 +4799,7 @@ var DefaultStreamTextResult = class { warnings: lastStep.warnings, experimental_providerMetadata: lastStep.experimental_providerMetadata, steps: recordedSteps - })); + })) rootSpan.setAttributes( selectTelemetryAttributes({ telemetry, @@ -4802,47 +4808,47 @@ var DefaultStreamTextResult = class { "ai.response.text": { output: () => recordedFullText }, "ai.response.toolCalls": { output: () => { - var _a16; - return ((_a16 = lastStep.toolCalls) == null ? void 0 : _a16.length) ? JSON.stringify(lastStep.toolCalls) : void 0; + var _a16 + return ((_a16 = lastStep.toolCalls) == null ? void 0 : _a16.length) ? JSON.stringify(lastStep.toolCalls) : void 0 } }, "ai.usage.promptTokens": usage.promptTokens, "ai.usage.completionTokens": usage.completionTokens } }) - ); + ) } catch (error) { - controller.error(error); + controller.error(error) } finally { - rootSpan.end(); + rootSpan.end() } } - }); - const stitchableStream = createStitchableStream(); - this.addStream = stitchableStream.addStream; - this.closeStream = stitchableStream.close; - let stream = stitchableStream.stream; + }) + const stitchableStream = createStitchableStream() + this.addStream = stitchableStream.addStream + this.closeStream = stitchableStream.close + let stream = stitchableStream.stream for (const transform of transforms) { stream = stream.pipeThrough( transform({ tools, stopStream() { - stitchableStream.terminate(); + stitchableStream.terminate() } }) - ); + ) } - this.baseStream = stream.pipeThrough(createOutputTransformStream(output)).pipeThrough(eventProcessor); + this.baseStream = stream.pipeThrough(createOutputTransformStream(output)).pipeThrough(eventProcessor) const { maxRetries, retry } = prepareRetries({ maxRetries: maxRetriesArg - }); - const tracer = getTracer(telemetry); + }) + const tracer = getTracer(telemetry) const baseTelemetryAttributes = getBaseTelemetryAttributes({ model, telemetry, headers, settings: { ...settings, maxRetries } - }); + }) const initialPrompt = standardizePrompt({ prompt: { system: (_a14 = output == null ? void 0 : output.injectIntoSystemPrompt({ system, model })) != null ? _a14 : system, @@ -4850,8 +4856,8 @@ var DefaultStreamTextResult = class { messages }, tools - }); - const self = this; + }) + const self = this recordSpan({ name: "ai.streamText", attributes: selectTelemetryAttributes({ @@ -4869,7 +4875,7 @@ var DefaultStreamTextResult = class { tracer, endWhenDone: false, fn: async (rootSpanArg) => { - rootSpan = rootSpanArg; + rootSpan = rootSpanArg async function streamStep({ currentStep, responseMessages, @@ -4879,11 +4885,11 @@ var DefaultStreamTextResult = class { hasLeadingWhitespace, messageId }) { - const promptFormat = responseMessages.length === 0 ? initialPrompt.type : "messages"; + const promptFormat = responseMessages.length === 0 ? initialPrompt.type : "messages" const stepInputMessages = [ ...initialPrompt.messages, ...responseMessages - ]; + ] const promptMessages = await convertToLanguageModelPrompt({ prompt: { type: promptFormat, @@ -4892,11 +4898,11 @@ var DefaultStreamTextResult = class { }, modelSupportsImageUrls: model.supportsImageUrls, modelSupportsUrl: model.supportsUrl - }); + }) const mode = { type: "regular", ...prepareToolsAndToolChoice({ tools, toolChoice, activeTools }) - }; + } const { result: { stream: stream2, warnings, rawResponse, request }, doStreamSpan, @@ -4921,8 +4927,8 @@ var DefaultStreamTextResult = class { "ai.prompt.tools": { // convert the language model level tools: input: () => { - var _a15; - return (_a15 = mode.tools) == null ? void 0 : _a15.map((tool2) => JSON.stringify(tool2)); + var _a15 + return (_a15 = mode.tools) == null ? void 0 : _a15.map((tool2) => JSON.stringify(tool2)) } }, "ai.prompt.toolChoice": { @@ -4958,7 +4964,7 @@ var DefaultStreamTextResult = class { }) }) }) - ); + ) const transformedStream = runToolsTransformation({ tools, generatorStream: stream2, @@ -4969,151 +4975,151 @@ var DefaultStreamTextResult = class { messages: stepInputMessages, repairToolCall, abortSignal - }); - const stepRequest = request != null ? request : {}; - const stepToolCalls = []; - const stepToolResults = []; - let stepFinishReason = "unknown"; + }) + const stepRequest = request != null ? request : {} + const stepToolCalls = [] + const stepToolResults = [] + let stepFinishReason = "unknown" let stepUsage = { promptTokens: 0, completionTokens: 0, totalTokens: 0 - }; - let stepProviderMetadata; - let stepFirstChunk = true; - let stepText = ""; - let fullStepText = stepType2 === "continue" ? previousStepText : ""; - let stepLogProbs; + } + let stepProviderMetadata + let stepFirstChunk = true + let stepText = "" + let fullStepText = stepType2 === "continue" ? previousStepText : "" + let stepLogProbs let stepResponse = { id: generateId3(), timestamp: currentDate(), modelId: model.modelId - }; - let chunkBuffer = ""; - let chunkTextPublished = false; - let inWhitespacePrefix = true; - let hasWhitespaceSuffix = false; + } + let chunkBuffer = "" + let chunkTextPublished = false + let inWhitespacePrefix = true + let hasWhitespaceSuffix = false async function publishTextChunk({ controller, chunk }) { - controller.enqueue(chunk); - stepText += chunk.textDelta; - fullStepText += chunk.textDelta; - chunkTextPublished = true; - hasWhitespaceSuffix = chunk.textDelta.trimEnd() !== chunk.textDelta; + controller.enqueue(chunk) + stepText += chunk.textDelta + fullStepText += chunk.textDelta + chunkTextPublished = true + hasWhitespaceSuffix = chunk.textDelta.trimEnd() !== chunk.textDelta } self.addStream( transformedStream.pipeThrough( new TransformStream({ async transform(chunk, controller) { - var _a15, _b, _c; + var _a15, _b, _c if (stepFirstChunk) { - const msToFirstChunk = now2() - startTimestampMs; - stepFirstChunk = false; + const msToFirstChunk = now2() - startTimestampMs + stepFirstChunk = false doStreamSpan.addEvent("ai.stream.firstChunk", { "ai.response.msToFirstChunk": msToFirstChunk - }); + }) doStreamSpan.setAttributes({ "ai.response.msToFirstChunk": msToFirstChunk - }); + }) controller.enqueue({ type: "step-start", messageId, request: stepRequest, warnings: warnings != null ? warnings : [] - }); + }) } if (chunk.type === "text-delta" && chunk.textDelta.length === 0) { - return; + return } - const chunkType = chunk.type; + const chunkType = chunk.type switch (chunkType) { case "text-delta": { if (continueSteps) { - const trimmedChunkText = inWhitespacePrefix && hasLeadingWhitespace ? chunk.textDelta.trimStart() : chunk.textDelta; + const trimmedChunkText = inWhitespacePrefix && hasLeadingWhitespace ? chunk.textDelta.trimStart() : chunk.textDelta if (trimmedChunkText.length === 0) { - break; + break } - inWhitespacePrefix = false; - chunkBuffer += trimmedChunkText; - const split = splitOnLastWhitespace(chunkBuffer); + inWhitespacePrefix = false + chunkBuffer += trimmedChunkText + const split = splitOnLastWhitespace(chunkBuffer) if (split != null) { - chunkBuffer = split.suffix; + chunkBuffer = split.suffix await publishTextChunk({ controller, chunk: { type: "text-delta", textDelta: split.prefix + split.whitespace } - }); + }) } } else { - await publishTextChunk({ controller, chunk }); + await publishTextChunk({ controller, chunk }) } - break; + break } case "tool-call": { - controller.enqueue(chunk); - stepToolCalls.push(chunk); - break; + controller.enqueue(chunk) + stepToolCalls.push(chunk) + break } case "tool-result": { - controller.enqueue(chunk); - stepToolResults.push(chunk); - break; + controller.enqueue(chunk) + stepToolResults.push(chunk) + break } case "response-metadata": { stepResponse = { id: (_a15 = chunk.id) != null ? _a15 : stepResponse.id, timestamp: (_b = chunk.timestamp) != null ? _b : stepResponse.timestamp, modelId: (_c = chunk.modelId) != null ? _c : stepResponse.modelId - }; - break; + } + break } case "finish": { - stepUsage = chunk.usage; - stepFinishReason = chunk.finishReason; - stepProviderMetadata = chunk.experimental_providerMetadata; - stepLogProbs = chunk.logprobs; - const msToFinish = now2() - startTimestampMs; - doStreamSpan.addEvent("ai.stream.finish"); + stepUsage = chunk.usage + stepFinishReason = chunk.finishReason + stepProviderMetadata = chunk.experimental_providerMetadata + stepLogProbs = chunk.logprobs + const msToFinish = now2() - startTimestampMs + doStreamSpan.addEvent("ai.stream.finish") doStreamSpan.setAttributes({ "ai.response.msToFinish": msToFinish, "ai.response.avgCompletionTokensPerSecond": 1e3 * stepUsage.completionTokens / msToFinish - }); - break; + }) + break } case "tool-call-streaming-start": case "tool-call-delta": { - controller.enqueue(chunk); - break; + controller.enqueue(chunk) + break } case "error": { - controller.enqueue(chunk); - stepFinishReason = "error"; - break; + controller.enqueue(chunk) + stepFinishReason = "error" + break } default: { - const exhaustiveCheck = chunkType; - throw new Error(`Unknown chunk type: ${exhaustiveCheck}`); + const exhaustiveCheck = chunkType + throw new Error(`Unknown chunk type: ${exhaustiveCheck}`) } } }, // invoke onFinish callback and resolve toolResults promise when the stream is about to close: async flush(controller) { - const stepToolCallsJson = stepToolCalls.length > 0 ? JSON.stringify(stepToolCalls) : void 0; - let nextStepType = "done"; + const stepToolCallsJson = stepToolCalls.length > 0 ? JSON.stringify(stepToolCalls) : void 0 + let nextStepType = "done" if (currentStep + 1 < maxSteps) { if (continueSteps && stepFinishReason === "length" && // only use continue when there are no tool calls: stepToolCalls.length === 0) { - nextStepType = "continue"; + nextStepType = "continue" } else if ( // there are tool calls: stepToolCalls.length > 0 && // all current tool calls have results: stepToolResults.length === stepToolCalls.length ) { - nextStepType = "tool-result"; + nextStepType = "tool-result" } } if (continueSteps && chunkBuffer.length > 0 && (nextStepType !== "continue" || // when the next step is a regular step, publish the buffer @@ -5124,8 +5130,8 @@ var DefaultStreamTextResult = class { type: "text-delta", textDelta: chunkBuffer } - }); - chunkBuffer = ""; + }) + chunkBuffer = "" } try { doStreamSpan.setAttributes( @@ -5150,10 +5156,10 @@ var DefaultStreamTextResult = class { "gen_ai.usage.output_tokens": stepUsage.completionTokens } }) - ); + ) } catch (error) { } finally { - doStreamSpan.end(); + doStreamSpan.end() } controller.enqueue({ type: "step-finish", @@ -5169,8 +5175,8 @@ var DefaultStreamTextResult = class { warnings, isContinued: nextStepType === "continue", messageId - }); - const combinedUsage = addLanguageModelUsage(usage, stepUsage); + }) + const combinedUsage = addLanguageModelUsage(usage, stepUsage) if (nextStepType === "done") { controller.enqueue({ type: "finish", @@ -5182,18 +5188,18 @@ var DefaultStreamTextResult = class { ...stepResponse, headers: rawResponse == null ? void 0 : rawResponse.headers } - }); - self.closeStream(); + }) + self.closeStream() } else { if (stepType2 === "continue") { - const lastMessage = responseMessages[responseMessages.length - 1]; + const lastMessage = responseMessages[responseMessages.length - 1] if (typeof lastMessage.content === "string") { - lastMessage.content += stepText; + lastMessage.content += stepText } else { lastMessage.content.push({ text: stepText, type: "text" - }); + }) } } else { responseMessages.push( @@ -5205,7 +5211,7 @@ var DefaultStreamTextResult = class { messageId, generateMessageId }) - ); + ) } await streamStep({ currentStep: currentStep + 1, @@ -5218,12 +5224,12 @@ var DefaultStreamTextResult = class { // keep the same id when continuing a step: nextStepType === "continue" ? messageId : generateMessageId() ) - }); + }) } } }) ) - ); + ) } await streamStep({ currentStep: 0, @@ -5237,49 +5243,49 @@ var DefaultStreamTextResult = class { stepType: "initial", hasLeadingWhitespace: false, messageId: generateMessageId() - }); + }) } }).catch((error) => { self.addStream( new ReadableStream({ start(controller) { - controller.enqueue({ type: "error", error }); - controller.close(); + controller.enqueue({ type: "error", error }) + controller.close() } }) - ); - self.closeStream(); - }); + ) + self.closeStream() + }) } get warnings() { - return this.warningsPromise.value; + return this.warningsPromise.value } get usage() { - return this.usagePromise.value; + return this.usagePromise.value } get finishReason() { - return this.finishReasonPromise.value; + return this.finishReasonPromise.value } get experimental_providerMetadata() { - return this.providerMetadataPromise.value; + return this.providerMetadataPromise.value } get text() { - return this.textPromise.value; + return this.textPromise.value } get toolCalls() { - return this.toolCallsPromise.value; + return this.toolCallsPromise.value } get toolResults() { - return this.toolResultsPromise.value; + return this.toolResultsPromise.value } get request() { - return this.requestPromise.value; + return this.requestPromise.value } get response() { - return this.responsePromise.value; + return this.responsePromise.value } get steps() { - return this.stepsPromise.value; + return this.stepsPromise.value } /** Split out a new stream from the original stream. @@ -5290,9 +5296,9 @@ var DefaultStreamTextResult = class { However, the LLM results are expected to be small enough to not cause issues. */ teeStream() { - const [stream1, stream2] = this.baseStream.tee(); - this.baseStream = stream2; - return stream1; + const [stream1, stream2] = this.baseStream.tee() + this.baseStream = stream2 + return stream1 } get textStream() { return createAsyncIterableStream( @@ -5300,63 +5306,63 @@ var DefaultStreamTextResult = class { new TransformStream({ transform({ part }, controller) { if (part.type === "text-delta") { - controller.enqueue(part.textDelta); + controller.enqueue(part.textDelta) } else if (part.type === "error") { - controller.error(part.error); + controller.error(part.error) } } }) ) - ); + ) } get fullStream() { return createAsyncIterableStream( this.teeStream().pipeThrough( new TransformStream({ transform({ part }, controller) { - controller.enqueue(part); + controller.enqueue(part) } }) ) - ); + ) } get experimental_partialOutputStream() { if (this.output == null) { - throw new NoOutputSpecifiedError(); + throw new NoOutputSpecifiedError() } return createAsyncIterableStream( this.teeStream().pipeThrough( new TransformStream({ transform({ partialOutput }, controller) { if (partialOutput != null) { - controller.enqueue(partialOutput); + controller.enqueue(partialOutput) } } }) ) - ); + ) } toDataStreamInternal({ getErrorMessage: getErrorMessage5 = () => "An error occurred.", // mask error messages for safety by default sendUsage = true } = {}) { - let aggregatedResponse = ""; + let aggregatedResponse = "" const callbackTransformer = new TransformStream({ async transform(chunk, controller) { - controller.enqueue(chunk); + controller.enqueue(chunk) if (chunk.type === "text-delta") { - aggregatedResponse += chunk.textDelta; + aggregatedResponse += chunk.textDelta } } - }); + }) const streamPartsTransformer = new TransformStream({ transform: async (chunk, controller) => { - const chunkType = chunk.type; + const chunkType = chunk.type switch (chunkType) { case "text-delta": { - controller.enqueue((0, import_ui_utils8.formatDataStreamPart)("text", chunk.textDelta)); - break; + controller.enqueue((0, import_ui_utils8.formatDataStreamPart)("text", chunk.textDelta)) + break } case "tool-call-streaming-start": { controller.enqueue( @@ -5364,8 +5370,8 @@ var DefaultStreamTextResult = class { toolCallId: chunk.toolCallId, toolName: chunk.toolName }) - ); - break; + ) + break } case "tool-call-delta": { controller.enqueue( @@ -5373,8 +5379,8 @@ var DefaultStreamTextResult = class { toolCallId: chunk.toolCallId, argsTextDelta: chunk.argsTextDelta }) - ); - break; + ) + break } case "tool-call": { controller.enqueue( @@ -5383,8 +5389,8 @@ var DefaultStreamTextResult = class { toolName: chunk.toolName, args: chunk.args }) - ); - break; + ) + break } case "tool-result": { controller.enqueue( @@ -5392,22 +5398,22 @@ var DefaultStreamTextResult = class { toolCallId: chunk.toolCallId, result: chunk.result }) - ); - break; + ) + break } case "error": { controller.enqueue( (0, import_ui_utils8.formatDataStreamPart)("error", getErrorMessage5(chunk.error)) - ); - break; + ) + break } case "step-start": { controller.enqueue( (0, import_ui_utils8.formatDataStreamPart)("start_step", { messageId: chunk.messageId }) - ); - break; + ) + break } case "step-finish": { controller.enqueue( @@ -5419,8 +5425,8 @@ var DefaultStreamTextResult = class { } : void 0, isContinued: chunk.isContinued }) - ); - break; + ) + break } case "finish": { controller.enqueue( @@ -5431,17 +5437,17 @@ var DefaultStreamTextResult = class { completionTokens: chunk.usage.completionTokens } : void 0 }) - ); - break; + ) + break } default: { - const exhaustiveCheck = chunkType; - throw new Error(`Unknown chunk type: ${exhaustiveCheck}`); + const exhaustiveCheck = chunkType + throw new Error(`Unknown chunk type: ${exhaustiveCheck}`) } } } - }); - return this.fullStream.pipeThrough(callbackTransformer).pipeThrough(streamPartsTransformer); + }) + return this.fullStream.pipeThrough(callbackTransformer).pipeThrough(streamPartsTransformer) } pipeDataStreamToResponse(response, { status, @@ -5460,7 +5466,7 @@ var DefaultStreamTextResult = class { dataStreamVersion: "v1" }), stream: this.toDataStream({ data, getErrorMessage: getErrorMessage5, sendUsage }) - }); + }) } pipeTextStreamToResponse(response, init) { writeToServerResponse({ @@ -5471,22 +5477,22 @@ var DefaultStreamTextResult = class { contentType: "text/plain; charset=utf-8" }), stream: this.textStream.pipeThrough(new TextEncoderStream()) - }); + }) } // TODO breaking change 5.0: remove pipeThrough(new TextEncoderStream()) toDataStream(options) { const stream = this.toDataStreamInternal({ getErrorMessage: options == null ? void 0 : options.getErrorMessage, sendUsage: options == null ? void 0 : options.sendUsage - }).pipeThrough(new TextEncoderStream()); - return (options == null ? void 0 : options.data) ? mergeStreams(options == null ? void 0 : options.data.stream, stream) : stream; + }).pipeThrough(new TextEncoderStream()) + return (options == null ? void 0 : options.data) ? mergeStreams(options == null ? void 0 : options.data.stream, stream) : stream } mergeIntoDataStream(writer) { writer.merge( this.toDataStreamInternal({ getErrorMessage: writer.onError }) - ); + ) } toDataStreamResponse({ headers, @@ -5506,18 +5512,18 @@ var DefaultStreamTextResult = class { dataStreamVersion: "v1" }) } - ); + ) } toTextStreamResponse(init) { - var _a14; + var _a14 return new Response(this.textStream.pipeThrough(new TextEncoderStream()), { status: (_a14 = init == null ? void 0 : init.status) != null ? _a14 : 200, headers: prepareResponseHeaders(init == null ? void 0 : init.headers, { contentType: "text/plain; charset=utf-8" }) - }); + }) } -}; +} // core/middleware/wrap-language-model.ts var experimental_wrapLanguageModel = ({ @@ -5530,7 +5536,7 @@ var experimental_wrapLanguageModel = ({ params, type }) { - return transformParams ? await transformParams({ params, type }) : params; + return transformParams ? await transformParams({ params, type }) : params } return { specificationVersion: "v1", @@ -5541,27 +5547,27 @@ var experimental_wrapLanguageModel = ({ supportsUrl: model.supportsUrl, supportsStructuredOutputs: model.supportsStructuredOutputs, async doGenerate(params) { - const transformedParams = await doTransform({ params, type: "generate" }); - const doGenerate = async () => model.doGenerate(transformedParams); - return wrapGenerate ? wrapGenerate({ doGenerate, params: transformedParams, model }) : doGenerate(); + const transformedParams = await doTransform({ params, type: "generate" }) + const doGenerate = async () => model.doGenerate(transformedParams) + return wrapGenerate ? wrapGenerate({ doGenerate, params: transformedParams, model }) : doGenerate() }, async doStream(params) { - const transformedParams = await doTransform({ params, type: "stream" }); - const doStream = async () => model.doStream(transformedParams); - return wrapStream ? wrapStream({ doStream, params: transformedParams, model }) : doStream(); + const transformedParams = await doTransform({ params, type: "stream" }) + const doStream = async () => model.doStream(transformedParams) + return wrapStream ? wrapStream({ doStream, params: transformedParams, model }) : doStream() } - }; -}; + } +} // core/prompt/append-response-messages.ts function appendResponseMessages({ messages, responseMessages }) { - var _a14; - const clonedMessages = structuredClone(messages); + var _a14 + const clonedMessages = structuredClone(messages) for (const message of responseMessages) { - const role = message.role; + const role = message.role switch (role) { case "assistant": { clonedMessages.push({ @@ -5576,41 +5582,41 @@ function appendResponseMessages({ state: "call", ...call })) - }); - break; + }) + break } case "tool": { const previousMessage = clonedMessages[clonedMessages.length - 1]; - (_a14 = previousMessage.toolInvocations) != null ? _a14 : previousMessage.toolInvocations = []; + (_a14 = previousMessage.toolInvocations) != null ? _a14 : previousMessage.toolInvocations = [] if (previousMessage.role !== "assistant") { throw new Error( `Tool result must follow an assistant message: ${previousMessage.role}` - ); + ) } for (const part of message.content) { const toolCall = previousMessage.toolInvocations.find( (call) => call.toolCallId === part.toolCallId - ); + ) if (!toolCall) { - throw new Error("Tool call not found in previous message"); + throw new Error("Tool call not found in previous message") } - toolCall.state = "result"; - const toolResult = toolCall; - toolResult.result = part.result; + toolCall.state = "result" + const toolResult = toolCall + toolResult.result = part.result } - break; + break } default: { - const _exhaustiveCheck = role; - throw new Error(`Unsupported message role: ${_exhaustiveCheck}`); + const _exhaustiveCheck = role + throw new Error(`Unsupported message role: ${_exhaustiveCheck}`) } } } - return clonedMessages; + return clonedMessages } // core/registry/custom-provider.ts -var import_provider18 = require("@ai-sdk/provider"); +var import_provider18 = require("@ai-sdk/provider") function experimental_customProvider({ languageModels, textEmbeddingModels, @@ -5619,31 +5625,31 @@ function experimental_customProvider({ return { languageModel(modelId) { if (languageModels != null && modelId in languageModels) { - return languageModels[modelId]; + return languageModels[modelId] } if (fallbackProvider) { - return fallbackProvider.languageModel(modelId); + return fallbackProvider.languageModel(modelId) } - throw new import_provider18.NoSuchModelError({ modelId, modelType: "languageModel" }); + throw new import_provider18.NoSuchModelError({ modelId, modelType: "languageModel" }) }, textEmbeddingModel(modelId) { if (textEmbeddingModels != null && modelId in textEmbeddingModels) { - return textEmbeddingModels[modelId]; + return textEmbeddingModels[modelId] } if (fallbackProvider) { - return fallbackProvider.textEmbeddingModel(modelId); + return fallbackProvider.textEmbeddingModel(modelId) } - throw new import_provider18.NoSuchModelError({ modelId, modelType: "textEmbeddingModel" }); + throw new import_provider18.NoSuchModelError({ modelId, modelType: "textEmbeddingModel" }) } - }; + } } // core/registry/no-such-provider-error.ts -var import_provider19 = require("@ai-sdk/provider"); -var name13 = "AI_NoSuchProviderError"; -var marker13 = `vercel.ai.error.${name13}`; -var symbol13 = Symbol.for(marker13); -var _a13; +var import_provider19 = require("@ai-sdk/provider") +var name13 = "AI_NoSuchProviderError" +var marker13 = `vercel.ai.error.${name13}` +var symbol13 = Symbol.for(marker13) +var _a13 var NoSuchProviderError = class extends import_provider19.NoSuchModelError { constructor({ modelId, @@ -5652,123 +5658,123 @@ var NoSuchProviderError = class extends import_provider19.NoSuchModelError { availableProviders, message = `No such provider: ${providerId} (available providers: ${availableProviders.join()})` }) { - super({ errorName: name13, modelId, modelType, message }); - this[_a13] = true; - this.providerId = providerId; - this.availableProviders = availableProviders; + super({ errorName: name13, modelId, modelType, message }) + this[_a13] = true + this.providerId = providerId + this.availableProviders = availableProviders } static isInstance(error) { - return import_provider19.AISDKError.hasMarker(error, marker13); + return import_provider19.AISDKError.hasMarker(error, marker13) } -}; -_a13 = symbol13; +} +_a13 = symbol13 // core/registry/provider-registry.ts -var import_provider20 = require("@ai-sdk/provider"); +var import_provider20 = require("@ai-sdk/provider") function experimental_createProviderRegistry(providers) { - const registry = new DefaultProviderRegistry(); + const registry = new DefaultProviderRegistry() for (const [id, provider] of Object.entries(providers)) { - registry.registerProvider({ id, provider }); + registry.registerProvider({ id, provider }) } - return registry; + return registry } var DefaultProviderRegistry = class { constructor() { - this.providers = {}; + this.providers = {} } registerProvider({ id, provider }) { - this.providers[id] = provider; + this.providers[id] = provider } getProvider(id) { - const provider = this.providers[id]; + const provider = this.providers[id] if (provider == null) { throw new NoSuchProviderError({ modelId: id, modelType: "languageModel", providerId: id, availableProviders: Object.keys(this.providers) - }); + }) } - return provider; + return provider } splitId(id, modelType) { - const index = id.indexOf(":"); + const index = id.indexOf(":") if (index === -1) { throw new import_provider20.NoSuchModelError({ modelId: id, modelType, message: `Invalid ${modelType} id for registry: ${id} (must be in the format "providerId:modelId")` - }); + }) } - return [id.slice(0, index), id.slice(index + 1)]; + return [id.slice(0, index), id.slice(index + 1)] } languageModel(id) { - var _a14, _b; - const [providerId, modelId] = this.splitId(id, "languageModel"); - const model = (_b = (_a14 = this.getProvider(providerId)).languageModel) == null ? void 0 : _b.call(_a14, modelId); + var _a14, _b + const [providerId, modelId] = this.splitId(id, "languageModel") + const model = (_b = (_a14 = this.getProvider(providerId)).languageModel) == null ? void 0 : _b.call(_a14, modelId) if (model == null) { - throw new import_provider20.NoSuchModelError({ modelId: id, modelType: "languageModel" }); + throw new import_provider20.NoSuchModelError({ modelId: id, modelType: "languageModel" }) } - return model; + return model } textEmbeddingModel(id) { - var _a14; - const [providerId, modelId] = this.splitId(id, "textEmbeddingModel"); - const provider = this.getProvider(providerId); - const model = (_a14 = provider.textEmbeddingModel) == null ? void 0 : _a14.call(provider, modelId); + var _a14 + const [providerId, modelId] = this.splitId(id, "textEmbeddingModel") + const provider = this.getProvider(providerId) + const model = (_a14 = provider.textEmbeddingModel) == null ? void 0 : _a14.call(provider, modelId) if (model == null) { throw new import_provider20.NoSuchModelError({ modelId: id, modelType: "textEmbeddingModel" - }); + }) } - return model; + return model } /** * @deprecated Use `textEmbeddingModel` instead. */ textEmbedding(id) { - return this.textEmbeddingModel(id); + return this.textEmbeddingModel(id) } -}; +} // core/tool/tool.ts function tool(tool2) { - return tool2; + return tool2 } // core/util/cosine-similarity.ts function cosineSimilarity(vector1, vector2, options = { throwErrorForEmptyVectors: false }) { - const { throwErrorForEmptyVectors } = options; + const { throwErrorForEmptyVectors } = options if (vector1.length !== vector2.length) { throw new Error( `Vectors must have the same length (vector1: ${vector1.length} elements, vector2: ${vector2.length} elements)` - ); + ) } if (throwErrorForEmptyVectors && vector1.length === 0) { throw new InvalidArgumentError({ parameter: "vector1", value: vector1, message: "Vectors cannot be empty" - }); + }) } - const magnitude1 = magnitude(vector1); - const magnitude2 = magnitude(vector2); + const magnitude1 = magnitude(vector1) + const magnitude2 = magnitude(vector2) if (magnitude1 === 0 || magnitude2 === 0) { - return 0; + return 0 } - return dotProduct(vector1, vector2) / (magnitude1 * magnitude2); + return dotProduct(vector1, vector2) / (magnitude1 * magnitude2) } function dotProduct(vector1, vector2) { return vector1.reduce( (accumulator, value, index) => accumulator + value * vector2[index], 0 - ); + ) } function magnitude(vector) { - return Math.sqrt(dotProduct(vector, vector)); + return Math.sqrt(dotProduct(vector, vector)) } // core/util/simulate-readable-stream.ts @@ -5778,50 +5784,50 @@ function simulateReadableStream({ chunkDelayInMs = 0, _internal }) { - var _a14; - const delay2 = (_a14 = _internal == null ? void 0 : _internal.delay) != null ? _a14 : delay; - let index = 0; + var _a14 + const delay2 = (_a14 = _internal == null ? void 0 : _internal.delay) != null ? _a14 : delay + let index = 0 return new ReadableStream({ async pull(controller) { if (index < chunks.length) { - await delay2(index === 0 ? initialDelayInMs : chunkDelayInMs); - controller.enqueue(chunks[index++]); + await delay2(index === 0 ? initialDelayInMs : chunkDelayInMs) + controller.enqueue(chunks[index++]) } else { - controller.close(); + controller.close() } } - }); + }) } // streams/assistant-response.ts -var import_ui_utils10 = require("@ai-sdk/ui-utils"); +var import_ui_utils10 = require("@ai-sdk/ui-utils") function AssistantResponse({ threadId, messageId }, process2) { const stream = new ReadableStream({ async start(controller) { - var _a14; - const textEncoder = new TextEncoder(); + var _a14 + const textEncoder = new TextEncoder() const sendMessage = (message) => { controller.enqueue( textEncoder.encode( (0, import_ui_utils10.formatAssistantStreamPart)("assistant_message", message) ) - ); - }; + ) + } const sendDataMessage = (message) => { controller.enqueue( textEncoder.encode( (0, import_ui_utils10.formatAssistantStreamPart)("data_message", message) ) - ); - }; + ) + } const sendError = (errorMessage) => { controller.enqueue( textEncoder.encode((0, import_ui_utils10.formatAssistantStreamPart)("error", errorMessage)) - ); - }; + ) + } const forwardStream = async (stream2) => { - var _a15, _b; - let result = void 0; + var _a15, _b + let result = void 0 for await (const value of stream2) { switch (value.event) { case "thread.message.created": { @@ -5833,29 +5839,29 @@ function AssistantResponse({ threadId, messageId }, process2) { content: [{ type: "text", text: { value: "" } }] }) ) - ); - break; + ) + break } case "thread.message.delta": { - const content = (_a15 = value.data.delta.content) == null ? void 0 : _a15[0]; + const content = (_a15 = value.data.delta.content) == null ? void 0 : _a15[0] if ((content == null ? void 0 : content.type) === "text" && ((_b = content.text) == null ? void 0 : _b.value) != null) { controller.enqueue( textEncoder.encode( (0, import_ui_utils10.formatAssistantStreamPart)("text", content.text.value) ) - ); + ) } - break; + break } case "thread.run.completed": case "thread.run.requires_action": { - result = value.data; - break; + result = value.data + break } } } - return result; - }; + return result + } controller.enqueue( textEncoder.encode( (0, import_ui_utils10.formatAssistantStreamPart)("assistant_control_data", { @@ -5863,68 +5869,68 @@ function AssistantResponse({ threadId, messageId }, process2) { messageId }) ) - ); + ) try { await process2({ sendMessage, sendDataMessage, forwardStream - }); + }) } catch (error) { - sendError((_a14 = error.message) != null ? _a14 : `${error}`); + sendError((_a14 = error.message) != null ? _a14 : `${error}`) } finally { - controller.close(); + controller.close() } }, pull(controller) { }, cancel() { } - }); + }) return new Response(stream, { status: 200, headers: { "Content-Type": "text/plain; charset=utf-8" } - }); + }) } // streams/langchain-adapter.ts -var langchain_adapter_exports = {}; +var langchain_adapter_exports = {} __export(langchain_adapter_exports, { mergeIntoDataStream: () => mergeIntoDataStream, toDataStream: () => toDataStream, toDataStreamResponse: () => toDataStreamResponse -}); -var import_ui_utils11 = require("@ai-sdk/ui-utils"); +}) +var import_ui_utils11 = require("@ai-sdk/ui-utils") // streams/stream-callbacks.ts function createCallbacksTransformer(callbacks = {}) { - const textEncoder = new TextEncoder(); - let aggregatedResponse = ""; + const textEncoder = new TextEncoder() + let aggregatedResponse = "" return new TransformStream({ async start() { if (callbacks.onStart) - await callbacks.onStart(); + await callbacks.onStart() }, async transform(message, controller) { - controller.enqueue(textEncoder.encode(message)); - aggregatedResponse += message; + controller.enqueue(textEncoder.encode(message)) + aggregatedResponse += message if (callbacks.onToken) - await callbacks.onToken(message); + await callbacks.onToken(message) if (callbacks.onText && typeof message === "string") { - await callbacks.onText(message); + await callbacks.onText(message) } }, async flush() { if (callbacks.onCompletion) { - await callbacks.onCompletion(aggregatedResponse); + await callbacks.onCompletion(aggregatedResponse) } if (callbacks.onFinal) { - await callbacks.onFinal(aggregatedResponse); + await callbacks.onFinal(aggregatedResponse) } } - }); + }) } // streams/langchain-adapter.ts @@ -5932,45 +5938,45 @@ function toDataStreamInternal(stream, callbacks) { return stream.pipeThrough( new TransformStream({ transform: async (value, controller) => { - var _a14; + var _a14 if (typeof value === "string") { - controller.enqueue(value); - return; + controller.enqueue(value) + return } if ("event" in value) { if (value.event === "on_chat_model_stream") { forwardAIMessageChunk( (_a14 = value.data) == null ? void 0 : _a14.chunk, controller - ); + ) } - return; + return } - forwardAIMessageChunk(value, controller); + forwardAIMessageChunk(value, controller) } }) ).pipeThrough(createCallbacksTransformer(callbacks)).pipeThrough(new TextDecoderStream()).pipeThrough( new TransformStream({ transform: async (chunk, controller) => { - controller.enqueue((0, import_ui_utils11.formatDataStreamPart)("text", chunk)); + controller.enqueue((0, import_ui_utils11.formatDataStreamPart)("text", chunk)) } }) - ); + ) } function toDataStream(stream, callbacks) { return toDataStreamInternal(stream, callbacks).pipeThrough( new TextEncoderStream() - ); + ) } function toDataStreamResponse(stream, options) { - var _a14; + var _a14 const dataStream = toDataStreamInternal( stream, options == null ? void 0 : options.callbacks - ).pipeThrough(new TextEncoderStream()); - const data = options == null ? void 0 : options.data; - const init = options == null ? void 0 : options.init; - const responseStream = data ? mergeStreams(data.stream, dataStream) : dataStream; + ).pipeThrough(new TextEncoderStream()) + const data = options == null ? void 0 : options.data + const init = options == null ? void 0 : options.init + const responseStream = data ? mergeStreams(data.stream, dataStream) : dataStream return new Response(responseStream, { status: (_a14 = init == null ? void 0 : init.status) != null ? _a14 : 200, statusText: init == null ? void 0 : init.statusText, @@ -5978,61 +5984,61 @@ function toDataStreamResponse(stream, options) { contentType: "text/plain; charset=utf-8", dataStreamVersion: "v1" }) - }); + }) } function mergeIntoDataStream(stream, options) { - options.dataStream.merge(toDataStreamInternal(stream, options.callbacks)); + options.dataStream.merge(toDataStreamInternal(stream, options.callbacks)) } function forwardAIMessageChunk(chunk, controller) { if (typeof chunk.content === "string") { - controller.enqueue(chunk.content); + controller.enqueue(chunk.content) } else { - const content = chunk.content; + const content = chunk.content for (const item of content) { if (item.type === "text") { - controller.enqueue(item.text); + controller.enqueue(item.text) } } } } // streams/llamaindex-adapter.ts -var llamaindex_adapter_exports = {}; +var llamaindex_adapter_exports = {} __export(llamaindex_adapter_exports, { mergeIntoDataStream: () => mergeIntoDataStream2, toDataStream: () => toDataStream2, toDataStreamResponse: () => toDataStreamResponse2 -}); -var import_provider_utils13 = require("@ai-sdk/provider-utils"); -var import_ui_utils12 = require("@ai-sdk/ui-utils"); +}) +var import_provider_utils13 = require("@ai-sdk/provider-utils") +var import_ui_utils12 = require("@ai-sdk/ui-utils") function toDataStreamInternal2(stream, callbacks) { - const trimStart = trimStartOfStream(); + const trimStart = trimStartOfStream() return (0, import_provider_utils13.convertAsyncIteratorToReadableStream)(stream[Symbol.asyncIterator]()).pipeThrough( new TransformStream({ async transform(message, controller) { - controller.enqueue(trimStart(message.delta)); + controller.enqueue(trimStart(message.delta)) } }) ).pipeThrough(createCallbacksTransformer(callbacks)).pipeThrough(new TextDecoderStream()).pipeThrough( new TransformStream({ transform: async (chunk, controller) => { - controller.enqueue((0, import_ui_utils12.formatDataStreamPart)("text", chunk)); + controller.enqueue((0, import_ui_utils12.formatDataStreamPart)("text", chunk)) } }) - ); + ) } function toDataStream2(stream, callbacks) { return toDataStreamInternal2(stream, callbacks).pipeThrough( new TextEncoderStream() - ); + ) } function toDataStreamResponse2(stream, options = {}) { - var _a14; - const { init, data, callbacks } = options; + var _a14 + const { init, data, callbacks } = options const dataStream = toDataStreamInternal2(stream, callbacks).pipeThrough( new TextEncoderStream() - ); - const responseStream = data ? mergeStreams(data.stream, dataStream) : dataStream; + ) + const responseStream = data ? mergeStreams(data.stream, dataStream) : dataStream return new Response(responseStream, { status: (_a14 = init == null ? void 0 : init.status) != null ? _a14 : 200, statusText: init == null ? void 0 : init.statusText, @@ -6040,93 +6046,93 @@ function toDataStreamResponse2(stream, options = {}) { contentType: "text/plain; charset=utf-8", dataStreamVersion: "v1" }) - }); + }) } function mergeIntoDataStream2(stream, options) { - options.dataStream.merge(toDataStreamInternal2(stream, options.callbacks)); + options.dataStream.merge(toDataStreamInternal2(stream, options.callbacks)) } function trimStartOfStream() { - let isStreamStart = true; + let isStreamStart = true return (text2) => { if (isStreamStart) { - text2 = text2.trimStart(); + text2 = text2.trimStart() if (text2) - isStreamStart = false; + isStreamStart = false } - return text2; - }; + return text2 + } } // streams/stream-data.ts -var import_ui_utils13 = require("@ai-sdk/ui-utils"); +var import_ui_utils13 = require("@ai-sdk/ui-utils") // util/constants.ts -var HANGING_STREAM_WARNING_TIME_MS = 15 * 1e3; +var HANGING_STREAM_WARNING_TIME_MS = 15 * 1e3 // streams/stream-data.ts var StreamData = class { constructor() { - this.encoder = new TextEncoder(); - this.controller = null; - this.isClosed = false; - this.warningTimeout = null; - const self = this; + this.encoder = new TextEncoder() + this.controller = null + this.isClosed = false + this.warningTimeout = null + const self = this this.stream = new ReadableStream({ start: async (controller) => { - self.controller = controller; + self.controller = controller if (process.env.NODE_ENV === "development") { self.warningTimeout = setTimeout(() => { console.warn( "The data stream is hanging. Did you forget to close it with `data.close()`?" - ); - }, HANGING_STREAM_WARNING_TIME_MS); + ) + }, HANGING_STREAM_WARNING_TIME_MS) } }, pull: (controller) => { }, cancel: (reason) => { - this.isClosed = true; + this.isClosed = true } - }); + }) } async close() { if (this.isClosed) { - throw new Error("Data Stream has already been closed."); + throw new Error("Data Stream has already been closed.") } if (!this.controller) { - throw new Error("Stream controller is not initialized."); + throw new Error("Stream controller is not initialized.") } - this.controller.close(); - this.isClosed = true; + this.controller.close() + this.isClosed = true if (this.warningTimeout) { - clearTimeout(this.warningTimeout); + clearTimeout(this.warningTimeout) } } append(value) { if (this.isClosed) { - throw new Error("Data Stream has already been closed."); + throw new Error("Data Stream has already been closed.") } if (!this.controller) { - throw new Error("Stream controller is not initialized."); + throw new Error("Stream controller is not initialized.") } this.controller.enqueue( this.encoder.encode((0, import_ui_utils13.formatDataStreamPart)("data", [value])) - ); + ) } appendMessageAnnotation(value) { if (this.isClosed) { - throw new Error("Data Stream has already been closed."); + throw new Error("Data Stream has already been closed.") } if (!this.controller) { - throw new Error("Stream controller is not initialized."); + throw new Error("Stream controller is not initialized.") } this.controller.enqueue( this.encoder.encode((0, import_ui_utils13.formatDataStreamPart)("message_annotations", [value])) - ); + ) } -}; +} // Annotate the CommonJS export names for ESM import in node: -0 && (module.exports = { +module.exports = { AISDKError, APICallError, AssistantResponse, @@ -6184,5 +6190,4 @@ var StreamData = class { streamObject, streamText, tool -}); -//# sourceMappingURL=index.js.map \ No newline at end of file +} diff --git a/server/routers/kfu-m-24-1/eng-it-lean/gigachat/gigachat.js b/server/routers/kfu-m-24-1/eng-it-lean/gigachat/gigachat.js index 122b5ad..9be96ba 100644 --- a/server/routers/kfu-m-24-1/eng-it-lean/gigachat/gigachat.js +++ b/server/routers/kfu-m-24-1/eng-it-lean/gigachat/gigachat.js @@ -607,8 +607,7 @@ function createGigachat(options = {}) { } var gigachat = createGigachat(); // Annotate the CommonJS export names for ESM import in node: -0 && (module.exports = { +module.exports = { createGigachat, gigachat -}); -//# sourceMappingURL=index.js.map \ No newline at end of file +} diff --git a/server/routers/kfu-m-24-1/eng-it-lean/gigachat/index.js b/server/routers/kfu-m-24-1/eng-it-lean/gigachat/index.js index 50275f0..da21202 100644 --- a/server/routers/kfu-m-24-1/eng-it-lean/gigachat/index.js +++ b/server/routers/kfu-m-24-1/eng-it-lean/gigachat/index.js @@ -84,7 +84,7 @@ router.use(async (req, res, next) => { process.env.GIGACHAT_ACCESS_TOKEN = json.access_token; process.env.GIGACHAT_EXPIRES_AT = json.expires_at; console.log(JSON.stringify(response.data)); - } catch { + } catch (error) { console.log(error); } }