/* 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 })
}
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 })
  }
  return to
}
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod)

// streams/index.ts
var streams_exports = {}
__export(streams_exports, {
  AISDKError: () => import_provider16.AISDKError,
  APICallError: () => import_provider16.APICallError,
  AssistantResponse: () => AssistantResponse,
  DownloadError: () => DownloadError,
  EmptyResponseBodyError: () => import_provider16.EmptyResponseBodyError,
  InvalidArgumentError: () => InvalidArgumentError,
  InvalidDataContentError: () => InvalidDataContentError,
  InvalidMessageRoleError: () => InvalidMessageRoleError,
  InvalidPromptError: () => import_provider16.InvalidPromptError,
  InvalidResponseDataError: () => import_provider16.InvalidResponseDataError,
  InvalidToolArgumentsError: () => InvalidToolArgumentsError,
  JSONParseError: () => import_provider16.JSONParseError,
  LangChainAdapter: () => langchain_adapter_exports,
  LlamaIndexAdapter: () => llamaindex_adapter_exports,
  LoadAPIKeyError: () => import_provider16.LoadAPIKeyError,
  MessageConversionError: () => MessageConversionError,
  NoContentGeneratedError: () => import_provider16.NoContentGeneratedError,
  NoObjectGeneratedError: () => NoObjectGeneratedError,
  NoOutputSpecifiedError: () => NoOutputSpecifiedError,
  NoSuchModelError: () => import_provider16.NoSuchModelError,
  NoSuchProviderError: () => NoSuchProviderError,
  NoSuchToolError: () => NoSuchToolError,
  Output: () => output_exports,
  RetryError: () => RetryError,
  StreamData: () => StreamData,
  ToolCallRepairError: () => ToolCallRepairError,
  ToolExecutionError: () => ToolExecutionError,
  TypeValidationError: () => import_provider16.TypeValidationError,
  UnsupportedFunctionalityError: () => import_provider16.UnsupportedFunctionalityError,
  appendResponseMessages: () => appendResponseMessages,
  convertToCoreMessages: () => convertToCoreMessages,
  cosineSimilarity: () => cosineSimilarity,
  createDataStream: () => createDataStream,
  createDataStreamResponse: () => createDataStreamResponse,
  createIdGenerator: () => import_provider_utils12.createIdGenerator,
  embed: () => embed,
  embedMany: () => embedMany,
  experimental_createProviderRegistry: () => experimental_createProviderRegistry,
  experimental_customProvider: () => experimental_customProvider,
  experimental_generateImage: () => generateImage,
  experimental_wrapLanguageModel: () => experimental_wrapLanguageModel,
  formatAssistantStreamPart: () => import_ui_utils9.formatAssistantStreamPart,
  formatDataStreamPart: () => import_ui_utils9.formatDataStreamPart,
  generateId: () => import_provider_utils12.generateId,
  generateObject: () => generateObject,
  generateText: () => generateText,
  jsonSchema: () => import_ui_utils9.jsonSchema,
  parseAssistantStreamPart: () => import_ui_utils9.parseAssistantStreamPart,
  parseDataStreamPart: () => import_ui_utils9.parseDataStreamPart,
  pipeDataStreamToResponse: () => pipeDataStreamToResponse,
  processDataStream: () => import_ui_utils9.processDataStream,
  processTextStream: () => import_ui_utils9.processTextStream,
  simulateReadableStream: () => simulateReadableStream,
  smoothStream: () => smoothStream,
  streamObject: () => streamObject,
  streamText: () => streamText,
  tool: () => tool
})
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")

// core/data-stream/create-data-stream.ts
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 = []
  const stream = new ReadableStream({
    start(controllerArg) {
      controller = controllerArg
    }
  })
  function safeEnqueue(data) {
    try {
      controller.enqueue(data)
    } catch (error) {
      console.error(error)
    }
  }
  try {
    const result = execute({
      writeData(data) {
        safeEnqueue((0, import_ui_utils.formatDataStreamPart)("data", [data]))
      },
      writeMessageAnnotation(annotation) {
        safeEnqueue((0, import_ui_utils.formatDataStreamPart)("message_annotations", [annotation]))
      },
      merge(streamArg) {
        ongoingStreamPromises.push(
          (async () => {
            const reader = streamArg.getReader()
            while (true) {
              const { done, value } = await reader.read()
              if (done)
                break
              safeEnqueue(value)
            }
          })().catch((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)))
        })
      )
    }
  } catch (error) {
    safeEnqueue((0, import_ui_utils.formatDataStreamPart)("error", onError(error)))
  }
  const waitForStreams = new Promise(async (resolve) => {
    while (ongoingStreamPromises.length > 0) {
      await ongoingStreamPromises.shift()
    }
    resolve()
  })
  waitForStreams.finally(() => {
    try {
      controller.close()
    } catch (error) {
      console.error(error)
    }
  })
  return stream
}

// core/util/prepare-response-headers.ts
function prepareResponseHeaders(headers, {
  contentType,
  dataStreamVersion
}) {
  const responseHeaders = new Headers(headers != null ? headers : {})
  if (!responseHeaders.has("Content-Type")) {
    responseHeaders.set("Content-Type", contentType)
  }
  if (dataStreamVersion !== void 0) {
    responseHeaders.set("X-Vercel-AI-Data-Stream", dataStreamVersion)
  }
  return responseHeaders
}

// core/data-stream/create-data-stream-response.ts
function createDataStreamResponse({
  status,
  statusText,
  headers,
  execute,
  onError
}) {
  return new Response(
    createDataStream({ execute, onError }).pipeThrough(new TextEncoderStream()),
    {
      status,
      statusText,
      headers: prepareResponseHeaders(headers, {
        contentType: "text/plain; charset=utf-8",
        dataStreamVersion: "v1"
      })
    }
  )
}

// core/util/prepare-outgoing-http-headers.ts
function prepareOutgoingHttpHeaders(headers, {
  contentType,
  dataStreamVersion
}) {
  const outgoingHeaders = {}
  if (headers != null) {
    for (const [key, value] of Object.entries(headers)) {
      outgoingHeaders[key] = value
    }
  }
  if (outgoingHeaders["Content-Type"] == null) {
    outgoingHeaders["Content-Type"] = contentType
  }
  if (dataStreamVersion !== void 0) {
    outgoingHeaders["X-Vercel-AI-Data-Stream"] = dataStreamVersion
  }
  return outgoingHeaders
}

// core/util/write-to-server-response.ts
function writeToServerResponse({
  response,
  status,
  statusText,
  headers,
  stream
}) {
  response.writeHead(status != null ? status : 200, statusText, headers)
  const reader = stream.getReader()
  const read = async () => {
    try {
      while (true) {
        const { done, value } = await reader.read()
        if (done)
          break
        response.write(value)
      }
    } catch (error) {
      console.error(error)
    } finally {
      response.end()
    }
  }
  read()
}

// core/data-stream/pipe-data-stream-to-response.ts
function pipeDataStreamToResponse(response, {
  status,
  statusText,
  headers,
  execute,
  onError
}) {
  writeToServerResponse({
    response,
    status,
    statusText,
    headers: prepareOutgoingHttpHeaders(headers, {
      contentType: "text/plain; charset=utf-8",
      dataStreamVersion: "v1"
    }),
    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 InvalidArgumentError = class extends import_provider.AISDKError {
  constructor({
    parameter,
    value,
    message
  }) {
    super({
      name,
      message: `Invalid argument for parameter ${parameter}: ${message}`
    })
    this[_a] = true
    this.parameter = parameter
    this.value = value
  }
  static isInstance(error) {
    return import_provider.AISDKError.hasMarker(error, marker)
  }
}
_a = symbol

// util/retry-with-exponential-backoff.ts
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))
}

// 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 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]
  }
  static isInstance(error) {
    return import_provider2.AISDKError.hasMarker(error, marker2)
  }
}
_a2 = symbol2

// util/retry-with-exponential-backoff.ts
var retryWithExponentialBackoff = ({
  maxRetries = 2,
  initialDelayInMs = 2e3,
  backoffFactor = 2
} = {}) => async (f) => _retryWithExponentialBackoff(f, {
  maxRetries,
  delayInMs: initialDelayInMs,
  backoffFactor
})
async function _retryWithExponentialBackoff(f, {
  maxRetries,
  delayInMs,
  backoffFactor
}, errors = []) {
  try {
    return await f()
  } catch (error) {
    if ((0, import_provider_utils.isAbortError)(error)) {
      throw error
    }
    if (maxRetries === 0) {
      throw error
    }
    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)
      return _retryWithExponentialBackoff(
        f,
        { maxRetries, delayInMs: backoffFactor * delayInMs, backoffFactor },
        newErrors
      )
    }
    if (tryNumber === 1) {
      throw error
    }
    throw new RetryError({
      message: `Failed after ${tryNumber} attempts with non-retryable error: '${errorMessage}'`,
      reason: "errorNotRetryable",
      errors: newErrors
    })
  }
}

// core/prompt/prepare-retries.ts
function prepareRetries({
  maxRetries
}) {
  if (maxRetries != null) {
    if (!Number.isInteger(maxRetries)) {
      throw new InvalidArgumentError({
        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
  return {
    maxRetries: maxRetriesResult,
    retry: retryWithExponentialBackoff({ maxRetries: maxRetriesResult })
  }
}

// core/telemetry/assemble-operation-name.ts
function assembleOperationName({
  operationId,
  telemetry
}) {
  return {
    // standardized operation and resource name:
    "operation.name": `${operationId}${(telemetry == null ? void 0 : telemetry.functionId) != null ? ` ${telemetry.functionId}` : ""}`,
    "resource.name": telemetry == null ? void 0 : telemetry.functionId,
    // detailed, AI SDK specific data:
    "ai.operationId": operationId,
    "ai.telemetry.functionId": telemetry == null ? void 0 : telemetry.functionId
  }
}

// core/telemetry/get-base-telemetry-attributes.ts
function getBaseTelemetryAttributes({
  model,
  settings,
  telemetry,
  headers
}) {
  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
    }, {}),
    // 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
      },
      {}
    ),
    // request headers
    ...Object.entries(headers != null ? headers : {}).reduce((attributes, [key, value]) => {
      if (value !== void 0) {
        attributes[`ai.request.headers.${key}`] = value
      }
      return attributes
    }, {})
  }
}

// core/telemetry/get-tracer.ts
var import_api = require("@opentelemetry/api")

// core/telemetry/noop-tracer.ts
var noopTracer = {
  startSpan() {
    return noopSpan
  },
  startActiveSpan(name14, arg1, arg2, arg3) {
    if (typeof arg1 === "function") {
      return arg1(noopSpan)
    }
    if (typeof arg2 === "function") {
      return arg2(noopSpan)
    }
    if (typeof arg3 === "function") {
      return arg3(noopSpan)
    }
  }
}
var noopSpan = {
  spanContext() {
    return noopSpanContext
  },
  setAttribute() {
    return this
  },
  setAttributes() {
    return this
  },
  addEvent() {
    return this
  },
  addLink() {
    return this
  },
  addLinks() {
    return this
  },
  setStatus() {
    return this
  },
  updateName() {
    return this
  },
  end() {
    return this
  },
  isRecording() {
    return false
  },
  recordException() {
    return this
  }
}
var noopSpanContext = {
  traceId: "",
  spanId: "",
  traceFlags: 0
}

// core/telemetry/get-tracer.ts
function getTracer({
  isEnabled = false,
  tracer
} = {}) {
  if (!isEnabled) {
    return noopTracer
  }
  if (tracer) {
    return tracer
  }
  return import_api.trace.getTracer("ai")
}

// core/telemetry/record-span.ts
var import_api2 = require("@opentelemetry/api")
function recordSpan({
  name: name14,
  tracer,
  attributes,
  fn,
  endWhenDone = true
}) {
  return tracer.startActiveSpan(name14, { attributes }, async (span) => {
    try {
      const result = await fn(span)
      if (endWhenDone) {
        span.end()
      }
      return result
    } catch (error) {
      try {
        if (error instanceof Error) {
          span.recordException({
            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 })
        }
      } finally {
        span.end()
      }
      throw error
    }
  })
}

// core/telemetry/select-telemetry-attributes.ts
function selectTelemetryAttributes({
  telemetry,
  attributes
}) {
  if ((telemetry == null ? void 0 : telemetry.isEnabled) !== true) {
    return {}
  }
  return Object.entries(attributes).reduce((attributes2, [key, value]) => {
    if (value === void 0) {
      return attributes2
    }
    if (typeof value === "object" && "input" in value && typeof value.input === "function") {
      if ((telemetry == null ? void 0 : telemetry.recordInputs) === false) {
        return attributes2
      }
      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
      }
      const result = value.output()
      return result === void 0 ? attributes2 : { ...attributes2, [key]: result }
    }
    return { ...attributes2, [key]: value }
  }, {})
}

// core/embed/embed.ts
async function embed({
  model,
  value,
  maxRetries: maxRetriesArg,
  abortSignal,
  headers,
  experimental_telemetry: telemetry
}) {
  const { maxRetries, retry } = prepareRetries({ maxRetries: maxRetriesArg })
  const baseTelemetryAttributes = getBaseTelemetryAttributes({
    model,
    telemetry,
    headers,
    settings: { maxRetries }
  })
  const tracer = getTracer(telemetry)
  return recordSpan({
    name: "ai.embed",
    attributes: selectTelemetryAttributes({
      telemetry,
      attributes: {
        ...assembleOperationName({ operationId: "ai.embed", telemetry }),
        ...baseTelemetryAttributes,
        "ai.value": { input: () => JSON.stringify(value) }
      }
    }),
    tracer,
    fn: async (span) => {
      const { embedding, usage, rawResponse } = await retry(
        () => (
          // nested spans to align with the embedMany telemetry data:
          recordSpan({
            name: "ai.embed.doEmbed",
            attributes: selectTelemetryAttributes({
              telemetry,
              attributes: {
                ...assembleOperationName({
                  operationId: "ai.embed.doEmbed",
                  telemetry
                }),
                ...baseTelemetryAttributes,
                // specific settings that only make sense on the outer level:
                "ai.values": { input: () => [JSON.stringify(value)] }
              }
            }),
            tracer,
            fn: async (doEmbedSpan) => {
              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 }
              doEmbedSpan.setAttributes(
                selectTelemetryAttributes({
                  telemetry,
                  attributes: {
                    "ai.embeddings": {
                      output: () => modelResponse.embeddings.map(
                        (embedding3) => JSON.stringify(embedding3)
                      )
                    },
                    "ai.usage.tokens": usage2.tokens
                  }
                })
              )
              return {
                embedding: embedding2,
                usage: usage2,
                rawResponse: modelResponse.rawResponse
              }
            }
          })
        )
      )
      span.setAttributes(
        selectTelemetryAttributes({
          telemetry,
          attributes: {
            "ai.embedding": { output: () => JSON.stringify(embedding) },
            "ai.usage.tokens": usage.tokens
          }
        })
      )
      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
  }
}

// core/util/split-array.ts
function splitArray(array, chunkSize) {
  if (chunkSize <= 0) {
    throw new Error("chunkSize must be greater than 0")
  }
  const result = []
  for (let i = 0; i < array.length; i += chunkSize) {
    result.push(array.slice(i, i + chunkSize))
  }
  return result
}

// core/embed/embed-many.ts
async function embedMany({
  model,
  values,
  maxRetries: maxRetriesArg,
  abortSignal,
  headers,
  experimental_telemetry: telemetry
}) {
  const { maxRetries, retry } = prepareRetries({ maxRetries: maxRetriesArg })
  const baseTelemetryAttributes = getBaseTelemetryAttributes({
    model,
    telemetry,
    headers,
    settings: { maxRetries }
  })
  const tracer = getTracer(telemetry)
  return recordSpan({
    name: "ai.embedMany",
    attributes: selectTelemetryAttributes({
      telemetry,
      attributes: {
        ...assembleOperationName({ operationId: "ai.embedMany", telemetry }),
        ...baseTelemetryAttributes,
        // specific settings that only make sense on the outer level:
        "ai.values": {
          input: () => values.map((value) => JSON.stringify(value))
        }
      }
    }),
    tracer,
    fn: async (span) => {
      const maxEmbeddingsPerCall = model.maxEmbeddingsPerCall
      if (maxEmbeddingsPerCall == null) {
        const { embeddings: embeddings2, usage } = await retry(() => {
          return recordSpan({
            name: "ai.embedMany.doEmbed",
            attributes: selectTelemetryAttributes({
              telemetry,
              attributes: {
                ...assembleOperationName({
                  operationId: "ai.embedMany.doEmbed",
                  telemetry
                }),
                ...baseTelemetryAttributes,
                // specific settings that only make sense on the outer level:
                "ai.values": {
                  input: () => values.map((value) => JSON.stringify(value))
                }
              }
            }),
            tracer,
            fn: async (doEmbedSpan) => {
              var _a14
              const modelResponse = await model.doEmbed({
                values,
                abortSignal,
                headers
              })
              const embeddings3 = modelResponse.embeddings
              const usage2 = (_a14 = modelResponse.usage) != null ? _a14 : { tokens: NaN }
              doEmbedSpan.setAttributes(
                selectTelemetryAttributes({
                  telemetry,
                  attributes: {
                    "ai.embeddings": {
                      output: () => embeddings3.map((embedding) => JSON.stringify(embedding))
                    },
                    "ai.usage.tokens": usage2.tokens
                  }
                })
              )
              return { embeddings: embeddings3, usage: usage2 }
            }
          })
        })
        span.setAttributes(
          selectTelemetryAttributes({
            telemetry,
            attributes: {
              "ai.embeddings": {
                output: () => embeddings2.map((embedding) => JSON.stringify(embedding))
              },
              "ai.usage.tokens": usage.tokens
            }
          })
        )
        return new DefaultEmbedManyResult({ values, embeddings: embeddings2, usage })
      }
      const valueChunks = splitArray(values, maxEmbeddingsPerCall)
      const embeddings = []
      let tokens = 0
      for (const chunk of valueChunks) {
        const { embeddings: responseEmbeddings, usage } = await retry(() => {
          return recordSpan({
            name: "ai.embedMany.doEmbed",
            attributes: selectTelemetryAttributes({
              telemetry,
              attributes: {
                ...assembleOperationName({
                  operationId: "ai.embedMany.doEmbed",
                  telemetry
                }),
                ...baseTelemetryAttributes,
                // specific settings that only make sense on the outer level:
                "ai.values": {
                  input: () => chunk.map((value) => JSON.stringify(value))
                }
              }
            }),
            tracer,
            fn: async (doEmbedSpan) => {
              var _a14
              const modelResponse = await model.doEmbed({
                values: chunk,
                abortSignal,
                headers
              })
              const embeddings2 = modelResponse.embeddings
              const usage2 = (_a14 = modelResponse.usage) != null ? _a14 : { tokens: NaN }
              doEmbedSpan.setAttributes(
                selectTelemetryAttributes({
                  telemetry,
                  attributes: {
                    "ai.embeddings": {
                      output: () => embeddings2.map((embedding) => JSON.stringify(embedding))
                    },
                    "ai.usage.tokens": usage2.tokens
                  }
                })
              )
              return { embeddings: embeddings2, usage: usage2 }
            }
          })
        })
        embeddings.push(...responseEmbeddings)
        tokens += usage.tokens
      }
      span.setAttributes(
        selectTelemetryAttributes({
          telemetry,
          attributes: {
            "ai.embeddings": {
              output: () => embeddings.map((embedding) => JSON.stringify(embedding))
            },
            "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
  }
}

// core/generate-image/generate-image.ts
var import_provider_utils2 = require("@ai-sdk/provider-utils")
async function generateImage({
  model,
  prompt,
  n = 1,
  size,
  aspectRatio,
  seed,
  providerOptions,
  maxRetries: maxRetriesArg,
  abortSignal,
  headers
}) {
  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
    }
    const remainder = n % maxImagesPerCall
    return remainder === 0 ? maxImagesPerCall : remainder
  })
  const results = await Promise.all(
    callImageCounts.map(
      async (callImageCount) => retry(
        () => model.doGenerate({
          prompt,
          n: callImageCount,
          abortSignal,
          headers,
          size,
          aspectRatio,
          seed,
          providerOptions: providerOptions != null ? providerOptions : {}
        })
      )
    )
  )
  const images = []
  const warnings = []
  for (const result of results) {
    images.push(
      ...result.images.map((image) => new DefaultGeneratedImage({ image }))
    )
    warnings.push(...result.warnings)
  }
  return new DefaultGenerateImageResult({ images, warnings })
}
var DefaultGenerateImageResult = class {
  constructor(options) {
    this.images = options.images
    this.warnings = options.warnings
  }
  get image() {
    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
  }
  // lazy conversion with caching to avoid unnecessary conversion overhead:
  get base64() {
    if (this.base64Data == null) {
      this.base64Data = (0, import_provider_utils2.convertUint8ArrayToBase64)(this.uint8ArrayData)
    }
    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)
    }
    return this.uint8ArrayData
  }
}

// core/generate-object/generate-object.ts
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 NoObjectGeneratedError = class extends import_provider4.AISDKError {
  constructor({
    message = "No object generated.",
    cause,
    text: text2,
    response,
    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)
  }
}
_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 DownloadError = class extends import_provider5.AISDKError {
  constructor({
    url,
    statusCode,
    statusText,
    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
  }
  static isInstance(error) {
    return import_provider5.AISDKError.hasMarker(error, marker4)
  }
}
_a4 = symbol4

// util/download.ts
async function download({
  url,
  fetchImplementation = fetch
}) {
  var _a14
  const urlText = url.toString()
  try {
    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 new DownloadError({ url: urlText, cause: error })
  }
}

// core/util/detect-image-mimetype.ts
var mimeTypeSignatures = [
  { mimeType: "image/gif", bytes: [71, 73, 70] },
  { 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 void 0
}

// core/prompt/data-content.ts
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 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
  }
  static isInstance(error) {
    return import_provider6.AISDKError.hasMarker(error, marker5)
  }
}
_a5 = symbol5

// core/prompt/data-content.ts
var import_zod = require("zod")
var dataContentSchema = import_zod.z.union([
  import_zod.z.string(),
  import_zod.z.instanceof(Uint8Array),
  import_zod.z.instanceof(ArrayBuffer),
  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
    },
    { message: "Must be a Buffer" }
  )
])
function convertDataContentToBase64String(content) {
  if (typeof content === "string") {
    return content
  }
  if (content instanceof ArrayBuffer) {
    return (0, import_provider_utils3.convertUint8ArrayToBase64)(new Uint8Array(content))
  }
  return (0, import_provider_utils3.convertUint8ArrayToBase64)(content)
}
function convertDataContentToUint8Array(content) {
  if (content instanceof Uint8Array) {
    return content
  }
  if (typeof content === "string") {
    try {
      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)
  }
  throw new InvalidDataContentError({ content })
}
function convertUint8ArrayToText(uint8Array) {
  try {
    return new TextDecoder().decode(uint8Array)
  } catch (error) {
    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 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
  }
  static isInstance(error) {
    return import_provider7.AISDKError.hasMarker(error, marker6)
  }
}
_a6 = symbol6

// core/prompt/split-data-url.ts
function splitDataUrl(dataUrl) {
  try {
    const [header, base64Content] = dataUrl.split(",")
    return {
      mimeType: header.split(";")[0].split(":")[1],
      base64Content
    }
  } catch (error) {
    return {
      mimeType: void 0,
      base64Content: void 0
    }
  }
}

// core/prompt/convert-to-language-model-prompt.ts
async function convertToLanguageModelPrompt({
  prompt,
  modelSupportsImageUrls = true,
  modelSupportsUrl = () => false,
  downloadImplementation = download
}) {
  const downloadedAssets = await downloadAssets(
    prompt.messages,
    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
  switch (role) {
    case "system": {
      return {
        role: "system",
        content: message.content,
        providerMetadata: message.experimental_providerMetadata
      }
    }
    case "user": {
      if (typeof message.content === "string") {
        return {
          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") {
        return {
          role: "assistant",
          content: [{ type: "text", text: message.content }],
          providerMetadata: message.experimental_providerMetadata
        }
      }
      return {
        role: "assistant",
        content: message.content.filter(
          // remove empty text parts:
          (part) => part.type !== "text" || part.text !== ""
        ).map((part) => {
          const { experimental_providerMetadata, ...rest } = part
          return {
            ...rest,
            providerMetadata: experimental_providerMetadata
          }
        }),
        providerMetadata: message.experimental_providerMetadata
      }
    }
    case "tool": {
      return {
        role: "tool",
        content: message.content.map((part) => ({
          type: "tool-result",
          toolCallId: part.toolCallId,
          toolName: part.toolName,
          result: part.result,
          content: part.experimental_content,
          isError: part.isError,
          providerMetadata: part.experimental_providerMetadata
        })),
        providerMetadata: message.experimental_providerMetadata
      }
    }
    default: {
      const _exhaustiveCheck = role
      throw new InvalidMessageRoleError({ role: _exhaustiveCheck })
    }
  }
}
async function downloadAssets(messages, downloadImplementation, modelSupportsImageUrls, modelSupportsUrl) {
  const urls = messages.filter((message) => message.role === "user").map((message) => message.content).filter(
    (content) => Array.isArray(content)
  ).flat().filter(
    (part) => part.type === "image" || part.type === "file"
  ).filter(
    (part) => !(part.type === "image" && modelSupportsImageUrls === true)
  ).map((part) => part.type === "image" ? part.image : part.data).map(
    (part) => (
      // 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))
  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
  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
  switch (type) {
    case "image":
      data = part.image
      break
    case "file":
      data = part.data
      break
    default:
      throw new Error(`Unsupported part type: ${type}`)
  }
  try {
    content = typeof data === "string" ? new URL(data) : data
  } catch (error) {
    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}`)
      }
      mimeType = dataUrlMimeType
      normalizedData = convertDataContentToUint8Array(base64Content)
    } else {
      const downloadedFile = downloadedAssets[content.toString()]
      if (downloadedFile) {
        normalizedData = downloadedFile.data
        mimeType != null ? mimeType : mimeType = downloadedFile.mimeType
      } else {
        normalizedData = content
      }
    }
  } else {
    normalizedData = convertDataContentToUint8Array(content)
  }
  switch (type) {
    case "image": {
      if (normalizedData instanceof Uint8Array) {
        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`)
      }
      return {
        type: "file",
        data: normalizedData instanceof Uint8Array ? convertDataContentToBase64String(normalizedData) : normalizedData,
        mimeType,
        providerMetadata: part.experimental_providerMetadata
      }
    }
  }
}

// core/prompt/prepare-call-settings.ts
function prepareCallSettings({
  maxTokens,
  temperature,
  topP,
  topK,
  presencePenalty,
  frequencyPenalty,
  stopSequences,
  seed
}) {
  if (maxTokens != null) {
    if (!Number.isInteger(maxTokens)) {
      throw new InvalidArgumentError({
        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) {
    if (typeof temperature !== "number") {
      throw new InvalidArgumentError({
        parameter: "temperature",
        value: temperature,
        message: "temperature must be a number"
      })
    }
  }
  if (topP != null) {
    if (typeof topP !== "number") {
      throw new InvalidArgumentError({
        parameter: "topP",
        value: topP,
        message: "topP must be a number"
      })
    }
  }
  if (topK != null) {
    if (typeof topK !== "number") {
      throw new InvalidArgumentError({
        parameter: "topK",
        value: topK,
        message: "topK must be a number"
      })
    }
  }
  if (presencePenalty != null) {
    if (typeof presencePenalty !== "number") {
      throw new InvalidArgumentError({
        parameter: "presencePenalty",
        value: presencePenalty,
        message: "presencePenalty must be a number"
      })
    }
  }
  if (frequencyPenalty != null) {
    if (typeof frequencyPenalty !== "number") {
      throw new InvalidArgumentError({
        parameter: "frequencyPenalty",
        value: frequencyPenalty,
        message: "frequencyPenalty must be a number"
      })
    }
  }
  if (seed != null) {
    if (!Number.isInteger(seed)) {
      throw new InvalidArgumentError({
        parameter: "seed",
        value: seed,
        message: "seed must be an integer"
      })
    }
  }
  return {
    maxTokens,
    temperature: temperature != null ? temperature : 0,
    topP,
    topK,
    presencePenalty,
    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")

// core/prompt/message.ts
var import_zod6 = require("zod")

// core/types/provider-metadata.ts
var import_zod3 = require("zod")

// core/types/json-value.ts
var import_zod2 = require("zod")
var jsonValueSchema = import_zod2.z.lazy(
  () => import_zod2.z.union([
    import_zod2.z.null(),
    import_zod2.z.string(),
    import_zod2.z.number(),
    import_zod2.z.boolean(),
    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")

// core/prompt/tool-result-content.ts
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() }),
    import_zod4.z.object({
      type: import_zod4.z.literal("image"),
      data: import_zod4.z.string(),
      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(),
  toolName: import_zod5.z.string(),
  result: import_zod5.z.unknown(),
  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([
    import_zod6.z.string(),
    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([
    import_zod6.z.string(),
    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"
  }
  if (prompt.length === 0) {
    return "messages"
  }
  const characteristics = prompt.map(detectSingleMessageCharacteristics)
  if (characteristics.some((c) => c === "has-ui-specific-parts")) {
    return "ui-messages"
  } else if (characteristics.every(
    (c) => c === "has-core-specific-parts" || c === "message"
  )) {
    return "messages"
  } else {
    return "other"
  }
}
function detectSingleMessageCharacteristics(message) {
  if (typeof message === "object" && message !== null && (message.role === "function" || // UI-only role
  message.role === "data" || // UI-only role
  "toolInvocations" in message || // UI-specific field
  "experimental_attachments" in message)) {
    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"
  } 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"
  } else {
    return "other"
  }
}

// core/prompt/attachments-to-parts.ts
function attachmentsToParts(attachments) {
  var _a14, _b, _c
  const parts = []
  for (const attachment of attachments) {
    let url
    try {
      url = new URL(attachment.url)
    } catch (error) {
      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 })
        } 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
      }
      case "data:": {
        let header
        let base64Content
        let mimeType
        try {
          [header, base64Content] = attachment.url.split(",")
          mimeType = header.split(";")[0].split(":")[1]
        } catch (error) {
          throw new Error(`Error processing data URL: ${attachment.url}`)
        }
        if (mimeType == null || base64Content == null) {
          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
      }
      default: {
        throw new Error(`Unsupported URL protocol: ${url.protocol}`)
      }
    }
  }
  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 MessageConversionError = class extends import_provider8.AISDKError {
  constructor({
    originalMessage,
    message
  }) {
    super({ name: name7, message })
    this[_a7] = true
    this.originalMessage = originalMessage
  }
  static isInstance(error) {
    return import_provider8.AISDKError.hasMarker(error, marker7)
  }
}
_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 = []
  for (const message of messages) {
    const { role, content, toolInvocations, experimental_attachments } = message
    switch (role) {
      case "system": {
        coreMessages.push({
          role: "system",
          content
        })
        break
      }
      case "user": {
        coreMessages.push({
          role: "user",
          content: experimental_attachments ? [
            { type: "text", text: content },
            ...attachmentsToParts(experimental_attachments)
          ] : content
        })
        break
      }
      case "assistant": {
        if (toolInvocations == null || toolInvocations.length === 0) {
          coreMessages.push({ role: "assistant", content })
          break
        }
        coreMessages.push({
          role: "assistant",
          content: [
            { type: "text", text: content },
            ...toolInvocations.map(
              ({ toolCallId, toolName, args }) => ({
                type: "tool-call",
                toolCallId,
                toolName,
                args
              })
            )
          ]
        })
        coreMessages.push({
          role: "tool",
          content: toolInvocations.map((toolInvocation) => {
            if (!("result" in toolInvocation)) {
              throw new MessageConversionError({
                originalMessage: message,
                message: "ToolInvocation must have a result: " + JSON.stringify(toolInvocation)
              })
            }
            const { toolCallId, toolName, result } = toolInvocation
            const tool2 = tools[toolName]
            return (tool2 == null ? void 0 : tool2.experimental_toToolResultContent) != null ? {
              type: "tool-result",
              toolCallId,
              toolName,
              result: tool2.experimental_toToolResultContent(result),
              experimental_content: tool2.experimental_toToolResultContent(result)
            } : {
              type: "tool-result",
              toolCallId,
              toolName,
              result
            }
          })
        })
        break
      }
      case "data": {
        break
      }
      default: {
        const _exhaustiveCheck = role
        throw new MessageConversionError({
          originalMessage: message,
          message: `Unsupported role: ${_exhaustiveCheck}`
        })
      }
    }
  }
  return coreMessages
}

// core/prompt/standardize-prompt.ts
function standardizePrompt({
  prompt,
  tools
}) {
  if (prompt.prompt == null && prompt.messages == null) {
    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",
      system: prompt.system,
      messages: [
        {
          role: "user",
          content: prompt.prompt
        }
      ]
    }
  }
  if (prompt.messages != null) {
    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
    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")
}

// core/types/usage.ts
function calculateLanguageModelUsage({
  promptTokens,
  completionTokens
}) {
  return {
    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."
function injectJsonInstruction({
  prompt,
  schema,
  schemaPrefix = schema != null ? DEFAULT_SCHEMA_PREFIX : void 0,
  schemaSuffix = schema != null ? DEFAULT_SCHEMA_SUFFIX : DEFAULT_GENERIC_SUFFIX
}) {
  return [
    prompt != null && prompt.length > 0 ? prompt : void 0,
    prompt != null && prompt.length > 0 ? "" : void 0,
    // add a newline if prompt is not null
    schemaPrefix,
    schema != null ? JSON.stringify(schema) : void 0,
    schemaSuffix
  ].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")

// core/util/async-iterable-stream.ts
function createAsyncIterableStream(source) {
  const stream = source.pipeThrough(new TransformStream())
  stream[Symbol.asyncIterator] = () => {
    const reader = stream.getReader()
    return {
      async next() {
        const { done, value } = await reader.read()
        return done ? { done: true, value: void 0 } : { done: false, value }
      }
    }
  }
  return stream
}

// core/generate-object/output-strategy.ts
var noSchemaOutputStrategy = {
  type: "no-schema",
  jsonSchema: void 0,
  validatePartialResult({ value, textDelta }) {
    return { success: true, value: { partial: value, textDelta } }
  },
  validateFinalResult(value, context) {
    return value === void 0 ? {
      success: false,
      error: new NoObjectGeneratedError({
        message: "No object generated: response did not match schema.",
        text: context.text,
        response: context.response,
        usage: context.usage
      })
    } : { success: true, value }
  },
  createElementStream() {
    throw new import_provider10.UnsupportedFunctionalityError({
      functionality: "element streams in no-schema mode"
    })
  }
}
var objectOutputStrategy = (schema) => ({
  type: "object",
  jsonSchema: schema.jsonSchema,
  validatePartialResult({ value, textDelta }) {
    return {
      success: true,
      value: {
        // Note: currently no validation of partial results:
        partial: value,
        textDelta
      }
    }
  },
  validateFinalResult(value) {
    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
  return {
    type: "enum",
    // wrap in object that contains array of elements, since most LLMs will not
    // be able to generate an array directly:
    // possible future optimization: use arrays directly when model supports grammar-guided generation
    jsonSchema: {
      $schema: "https://json-schema.org/draft/2019-09/schema#",
      type: "object",
      properties: {
        elements: { type: "array", items: itemSchema }
      },
      required: ["elements"],
      additionalProperties: false
    },
    validatePartialResult({ value, latestObject, isFirstDelta, isFinalDelta }) {
      var _a14
      if (!(0, import_provider10.isJSONObject)(value) || !(0, import_provider10.isJSONArray)(value.elements)) {
        return {
          success: false,
          error: new import_provider10.TypeValidationError({
            value,
            cause: "value must be an object that contains an array of elements"
          })
        }
      }
      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 })
        if (i === inputArray.length - 1 && !isFinalDelta) {
          continue
        }
        if (!result.success) {
          return result
        }
        resultArray.push(result.value)
      }
      const publishedElementCount = (_a14 = latestObject == null ? void 0 : latestObject.length) != null ? _a14 : 0
      let textDelta = ""
      if (isFirstDelta) {
        textDelta += "["
      }
      if (publishedElementCount > 0) {
        textDelta += ","
      }
      textDelta += resultArray.slice(publishedElementCount).map((element) => JSON.stringify(element)).join(",")
      if (isFinalDelta) {
        textDelta += "]"
      }
      return {
        success: true,
        value: {
          partial: resultArray,
          textDelta
        }
      }
    },
    validateFinalResult(value) {
      if (!(0, import_provider10.isJSONObject)(value) || !(0, import_provider10.isJSONArray)(value.elements)) {
        return {
          success: false,
          error: new import_provider10.TypeValidationError({
            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 }
    },
    createElementStream(originalStream) {
      let publishedElements = 0
      return createAsyncIterableStream(
        originalStream.pipeThrough(
          new TransformStream({
            transform(chunk, controller) {
              switch (chunk.type) {
                case "object": {
                  const array = chunk.object
                  for (; publishedElements < array.length; publishedElements++) {
                    controller.enqueue(array[publishedElements])
                  }
                  break
                }
                case "text-delta":
                case "finish":
                  break
                case "error":
                  controller.error(chunk.error)
                  break
                default: {
                  const _exhaustiveCheck = chunk
                  throw new Error(
                    `Unsupported chunk type: ${_exhaustiveCheck}`
                  )
                }
              }
            }
          })
        )
      )
    }
  }
}
var enumOutputStrategy = (enumValues) => {
  return {
    type: "enum",
    // wrap in object that contains result, since most LLMs will not
    // be able to generate an enum value directly:
    // possible future optimization: use enums directly when model supports top-level enums
    jsonSchema: {
      $schema: "https://json-schema.org/draft/2019-09/schema#",
      type: "object",
      properties: {
        result: { type: "string", enum: enumValues }
      },
      required: ["result"],
      additionalProperties: false
    },
    validateFinalResult(value) {
      if (!(0, import_provider10.isJSONObject)(value) || typeof value.result !== "string") {
        return {
          success: false,
          error: new import_provider10.TypeValidationError({
            value,
            cause: 'value must be an object that contains a string in the "result" property.'
          })
        }
      }
      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,
  enumValues
}) {
  switch (output) {
    case "object":
      return objectOutputStrategy((0, import_ui_utils2.asSchema)(schema))
    case "array":
      return arrayOutputStrategy((0, import_ui_utils2.asSchema)(schema))
    case "enum":
      return enumOutputStrategy(enumValues)
    case "no-schema":
      return noSchemaOutputStrategy
    default: {
      const _exhaustiveCheck = output
      throw new Error(`Unsupported output: ${_exhaustiveCheck}`)
    }
  }
}

// core/generate-object/validate-object-generation-input.ts
function validateObjectGenerationInput({
  output,
  mode,
  schema,
  schemaName,
  schemaDescription,
  enumValues
}) {
  if (output != null && output !== "object" && output !== "array" && output !== "enum" && output !== "no-schema") {
    throw new InvalidArgumentError({
      parameter: "output",
      value: output,
      message: "Invalid output type."
    })
  }
  if (output === "no-schema") {
    if (mode === "auto" || mode === "tool") {
      throw new InvalidArgumentError({
        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") {
    if (schema == null) {
      throw new InvalidArgumentError({
        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") {
    if (schema == null) {
      throw new InvalidArgumentError({
        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") {
    if (schema != null) {
      throw new InvalidArgumentError({
        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") {
        throw new InvalidArgumentError({
          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 })
async function generateObject({
  model,
  enum: enumValues,
  // rename bc enum is reserved by typescript
  schema: inputSchema,
  schemaName,
  schemaDescription,
  mode,
  output = "object",
  system,
  prompt,
  messages,
  maxRetries: maxRetriesArg,
  abortSignal,
  headers,
  experimental_telemetry: telemetry,
  experimental_providerMetadata: providerMetadata,
  _internal: {
    generateId: generateId3 = originalGenerateId,
    currentDate = () => /* @__PURE__ */ new Date()
  } = {},
  ...settings
}) {
  validateObjectGenerationInput({
    output,
    mode,
    schema: inputSchema,
    schemaName,
    schemaDescription,
    enumValues
  })
  const { maxRetries, retry } = prepareRetries({ maxRetries: maxRetriesArg })
  const outputStrategy = getOutputStrategy({
    output,
    schema: inputSchema,
    enumValues
  })
  if (outputStrategy.type === "no-schema" && mode === void 0) {
    mode = "json"
  }
  const baseTelemetryAttributes = getBaseTelemetryAttributes({
    model,
    telemetry,
    headers,
    settings: { ...settings, maxRetries }
  })
  const tracer = getTracer(telemetry)
  return recordSpan({
    name: "ai.generateObject",
    attributes: selectTelemetryAttributes({
      telemetry,
      attributes: {
        ...assembleOperationName({
          operationId: "ai.generateObject",
          telemetry
        }),
        ...baseTelemetryAttributes,
        // specific settings that only make sense on the outer level:
        "ai.prompt": {
          input: () => JSON.stringify({ system, prompt, messages })
        },
        "ai.schema": outputStrategy.jsonSchema != null ? { input: () => JSON.stringify(outputStrategy.jsonSchema) } : void 0,
        "ai.schema.name": schemaName,
        "ai.schema.description": schemaDescription,
        "ai.settings.output": outputStrategy.type,
        "ai.settings.mode": mode
      }
    }),
    tracer,
    fn: async (span) => {
      var _a14, _b
      if (mode === "auto" || mode == null) {
        mode = model.defaultObjectGenerationMode
      }
      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({
            prompt: {
              system: outputStrategy.jsonSchema == null ? injectJsonInstruction({ prompt: system }) : model.supportsStructuredOutputs ? system : injectJsonInstruction({
                prompt: system,
                schema: outputStrategy.jsonSchema
              }),
              prompt,
              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",
              attributes: selectTelemetryAttributes({
                telemetry,
                attributes: {
                  ...assembleOperationName({
                    operationId: "ai.generateObject.doGenerate",
                    telemetry
                  }),
                  ...baseTelemetryAttributes,
                  "ai.prompt.format": {
                    input: () => standardizedPrompt.type
                  },
                  "ai.prompt.messages": {
                    input: () => JSON.stringify(promptMessages)
                  },
                  "ai.settings.mode": mode,
                  // standardized gen-ai llm span attributes:
                  "gen_ai.system": model.provider,
                  "gen_ai.request.model": model.modelId,
                  "gen_ai.request.frequency_penalty": settings.frequencyPenalty,
                  "gen_ai.request.max_tokens": settings.maxTokens,
                  "gen_ai.request.presence_penalty": settings.presencePenalty,
                  "gen_ai.request.temperature": settings.temperature,
                  "gen_ai.request.top_k": settings.topK,
                  "gen_ai.request.top_p": settings.topP
                }
              }),
              tracer,
              fn: async (span2) => {
                var _a15, _b2, _c, _d, _e, _f
                const result2 = await model.doGenerate({
                  mode: {
                    type: "object-json",
                    schema: outputStrategy.jsonSchema,
                    name: schemaName,
                    description: schemaDescription
                  },
                  ...prepareCallSettings(settings),
                  inputFormat: standardizedPrompt.type,
                  prompt: promptMessages,
                  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({
                    telemetry,
                    attributes: {
                      "ai.response.finishReason": result2.finishReason,
                      "ai.response.object": { output: () => result2.text },
                      "ai.response.id": responseData.id,
                      "ai.response.model": responseData.modelId,
                      "ai.response.timestamp": responseData.timestamp.toISOString(),
                      "ai.usage.promptTokens": result2.usage.promptTokens,
                      "ai.usage.completionTokens": result2.usage.completionTokens,
                      // standardized gen-ai llm span attributes:
                      "gen_ai.response.finish_reasons": [result2.finishReason],
                      "gen_ai.response.id": responseData.id,
                      "gen_ai.response.model": responseData.modelId,
                      "gen_ai.usage.prompt_tokens": result2.usage.promptTokens,
                      "gen_ai.usage.completion_tokens": result2.usage.completionTokens
                    }
                  })
                )
                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
        }
        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 generateResult = await retry(
            () => recordSpan({
              name: "ai.generateObject.doGenerate",
              attributes: selectTelemetryAttributes({
                telemetry,
                attributes: {
                  ...assembleOperationName({
                    operationId: "ai.generateObject.doGenerate",
                    telemetry
                  }),
                  ...baseTelemetryAttributes,
                  "ai.prompt.format": {
                    input: () => inputFormat
                  },
                  "ai.prompt.messages": {
                    input: () => JSON.stringify(promptMessages)
                  },
                  "ai.settings.mode": mode,
                  // standardized gen-ai llm span attributes:
                  "gen_ai.system": model.provider,
                  "gen_ai.request.model": model.modelId,
                  "gen_ai.request.frequency_penalty": settings.frequencyPenalty,
                  "gen_ai.request.max_tokens": settings.maxTokens,
                  "gen_ai.request.presence_penalty": settings.presencePenalty,
                  "gen_ai.request.temperature": settings.temperature,
                  "gen_ai.request.top_k": settings.topK,
                  "gen_ai.request.top_p": settings.topP
                }
              }),
              tracer,
              fn: async (span2) => {
                var _a15, _b2, _c, _d, _e, _f, _g, _h
                const result2 = await model.doGenerate({
                  mode: {
                    type: "object-tool",
                    tool: {
                      type: "function",
                      name: schemaName != null ? schemaName : "json",
                      description: schemaDescription != null ? schemaDescription : "Respond with a JSON object.",
                      parameters: outputStrategy.jsonSchema
                    }
                  },
                  ...prepareCallSettings(settings),
                  inputFormat,
                  prompt: promptMessages,
                  providerMetadata,
                  abortSignal,
                  headers
                })
                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({
                    telemetry,
                    attributes: {
                      "ai.response.finishReason": result2.finishReason,
                      "ai.response.object": { output: () => objectText },
                      "ai.response.id": responseData.id,
                      "ai.response.model": responseData.modelId,
                      "ai.response.timestamp": responseData.timestamp.toISOString(),
                      "ai.usage.promptTokens": result2.usage.promptTokens,
                      "ai.usage.completionTokens": result2.usage.completionTokens,
                      // standardized gen-ai llm span attributes:
                      "gen_ai.response.finish_reasons": [result2.finishReason],
                      "gen_ai.response.id": responseData.id,
                      "gen_ai.response.model": responseData.modelId,
                      "gen_ai.usage.input_tokens": result2.usage.promptTokens,
                      "gen_ai.usage.output_tokens": result2.usage.completionTokens
                    }
                  })
                )
                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
        }
        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 parseResult = (0, import_provider_utils6.safeParseJSON)({ text: result })
      if (!parseResult.success) {
        throw new NoObjectGeneratedError({
          message: "No object generated: could not parse the response.",
          cause: parseResult.error,
          text: result,
          response,
          usage: calculateLanguageModelUsage(usage)
        })
      }
      const validationResult = outputStrategy.validateFinalResult(
        parseResult.value,
        {
          text: result,
          response,
          usage: calculateLanguageModelUsage(usage)
        }
      )
      if (!validationResult.success) {
        throw new NoObjectGeneratedError({
          message: "No object generated: response did not match schema.",
          cause: validationResult.error,
          text: result,
          response,
          usage: calculateLanguageModelUsage(usage)
        })
      }
      span.setAttributes(
        selectTelemetryAttributes({
          telemetry,
          attributes: {
            "ai.response.finishReason": finishReason,
            "ai.response.object": {
              output: () => JSON.stringify(validationResult.value)
            },
            "ai.usage.promptTokens": usage.promptTokens,
            "ai.usage.completionTokens": usage.completionTokens
          }
        })
      )
      return new DefaultGenerateObjectResult({
        object: validationResult.value,
        finishReason,
        usage: calculateLanguageModelUsage(usage),
        warnings,
        request,
        response: {
          ...response,
          headers: rawResponse == null ? void 0 : rawResponse.headers
        },
        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
  }
  toJsonResponse(init) {
    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")

// util/delayed-promise.ts
var DelayedPromise = class {
  constructor() {
    this.status = { type: "pending" }
    this._resolve = void 0
    this._reject = void 0
  }
  get value() {
    if (this.promise) {
      return this.promise
    }
    this.promise = new Promise((resolve, reject) => {
      if (this.status.type === "resolved") {
        resolve(this.status.value)
      } else if (this.status.type === "rejected") {
        reject(this.status.error)
      }
      this._resolve = resolve
      this._reject = reject
    })
    return this.promise
  }
  resolve(value) {
    var _a14
    this.status = { type: "resolved", value }
    if (this.promise) {
      (_a14 = this._resolve) == null ? void 0 : _a14.call(this, value)
    }
  }
  reject(error) {
    var _a14
    this.status = { type: "rejected", error }
    if (this.promise) {
      (_a14 = this._reject) == null ? void 0 : _a14.call(this, error)
    }
  }
}

// util/create-resolvable-promise.ts
function createResolvablePromise() {
  let resolve
  let reject
  const promise = new Promise((res, 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()
  const processPull = async () => {
    if (isClosed && innerStreamReaders.length === 0) {
      controller == null ? void 0 : controller.close()
      return
    }
    if (innerStreamReaders.length === 0) {
      waitForNewStream = createResolvablePromise()
      await waitForNewStream.promise
      return processPull()
    }
    try {
      const { value, done } = await innerStreamReaders[0].read()
      if (done) {
        innerStreamReaders.shift()
        if (innerStreamReaders.length > 0) {
          await processPull()
        } else if (isClosed) {
          controller == null ? void 0 : controller.close()
        }
      } else {
        controller == null ? void 0 : controller.enqueue(value)
      }
    } catch (error) {
      controller == null ? void 0 : controller.error(error)
      innerStreamReaders.shift()
      if (isClosed && innerStreamReaders.length === 0) {
        controller == null ? void 0 : controller.close()
      }
    }
  }
  return {
    stream: new ReadableStream({
      start(controllerParam) {
        controller = controllerParam
      },
      pull: processPull,
      async cancel() {
        for (const reader of innerStreamReaders) {
          await reader.cancel()
        }
        innerStreamReaders = []
        isClosed = true
      }
    }),
    addStream: (innerStream) => {
      if (isClosed) {
        throw new Error("Cannot add inner stream: outer stream is closed")
      }
      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()
      if (innerStreamReaders.length === 0) {
        controller == null ? void 0 : controller.close()
      }
    },
    /**
     * Immediately close the outer stream. This will cancel all inner streams
     * and close the outer stream.
     */
    terminate: () => {
      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()
}

// core/generate-object/stream-object.ts
var originalGenerateId2 = (0, import_provider_utils7.createIdGenerator)({ prefix: "aiobj", size: 24 })
function streamObject({
  model,
  schema: inputSchema,
  schemaName,
  schemaDescription,
  mode,
  output = "object",
  system,
  prompt,
  messages,
  maxRetries,
  abortSignal,
  headers,
  experimental_telemetry: telemetry,
  experimental_providerMetadata: providerMetadata,
  onFinish,
  _internal: {
    generateId: generateId3 = originalGenerateId2,
    currentDate = () => /* @__PURE__ */ new Date(),
    now: now2 = now
  } = {},
  ...settings
}) {
  validateObjectGenerationInput({
    output,
    mode,
    schema: inputSchema,
    schemaName,
    schemaDescription
  })
  const outputStrategy = getOutputStrategy({ output, schema: inputSchema })
  if (outputStrategy.type === "no-schema" && mode === void 0) {
    mode = "json"
  }
  return new DefaultStreamObjectResult({
    model,
    telemetry,
    headers,
    settings,
    maxRetries,
    abortSignal,
    outputStrategy,
    system,
    prompt,
    messages,
    schemaName,
    schemaDescription,
    inputProviderMetadata: providerMetadata,
    mode,
    onFinish,
    generateId: generateId3,
    currentDate,
    now: now2
  })
}
var DefaultStreamObjectResult = class {
  constructor({
    model,
    headers,
    telemetry,
    settings,
    maxRetries: maxRetriesArg,
    abortSignal,
    outputStrategy,
    system,
    prompt,
    messages,
    schemaName,
    schemaDescription,
    inputProviderMetadata,
    mode,
    onFinish,
    generateId: generateId3,
    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()
    const { maxRetries, retry } = prepareRetries({
      maxRetries: maxRetriesArg
    })
    const baseTelemetryAttributes = getBaseTelemetryAttributes({
      model,
      telemetry,
      headers,
      settings: { ...settings, maxRetries }
    })
    const tracer = getTracer(telemetry)
    const self = this
    recordSpan({
      name: "ai.streamObject",
      attributes: selectTelemetryAttributes({
        telemetry,
        attributes: {
          ...assembleOperationName({
            operationId: "ai.streamObject",
            telemetry
          }),
          ...baseTelemetryAttributes,
          // specific settings that only make sense on the outer level:
          "ai.prompt": {
            input: () => JSON.stringify({ system, prompt, messages })
          },
          "ai.schema": outputStrategy.jsonSchema != null ? { input: () => JSON.stringify(outputStrategy.jsonSchema) } : void 0,
          "ai.schema.name": schemaName,
          "ai.schema.description": schemaDescription,
          "ai.settings.output": outputStrategy.type,
          "ai.settings.mode": mode
        }
      }),
      tracer,
      endWhenDone: false,
      fn: async (rootSpan) => {
        if (mode === "auto" || mode == null) {
          mode = model.defaultObjectGenerationMode
        }
        let callOptions
        let transformer
        switch (mode) {
          case "json": {
            const standardizedPrompt = standardizePrompt({
              prompt: {
                system: outputStrategy.jsonSchema == null ? injectJsonInstruction({ prompt: system }) : model.supportsStructuredOutputs ? system : injectJsonInstruction({
                  prompt: system,
                  schema: outputStrategy.jsonSchema
                }),
                prompt,
                messages
              },
              tools: void 0
            })
            callOptions = {
              mode: {
                type: "object-json",
                schema: outputStrategy.jsonSchema,
                name: schemaName,
                description: schemaDescription
              },
              ...prepareCallSettings(settings),
              inputFormat: standardizedPrompt.type,
              prompt: await convertToLanguageModelPrompt({
                prompt: standardizedPrompt,
                modelSupportsImageUrls: model.supportsImageUrls,
                modelSupportsUrl: model.supportsUrl
              }),
              providerMetadata: inputProviderMetadata,
              abortSignal,
              headers
            }
            transformer = {
              transform: (chunk, controller) => {
                switch (chunk.type) {
                  case "text-delta":
                    controller.enqueue(chunk.textDelta)
                    break
                  case "response-metadata":
                  case "finish":
                  case "error":
                    controller.enqueue(chunk)
                    break
                }
              }
            }
            break
          }
          case "tool": {
            const standardizedPrompt = standardizePrompt({
              prompt: { system, prompt, messages },
              tools: void 0
            })
            callOptions = {
              mode: {
                type: "object-tool",
                tool: {
                  type: "function",
                  name: schemaName != null ? schemaName : "json",
                  description: schemaDescription != null ? schemaDescription : "Respond with a JSON object.",
                  parameters: outputStrategy.jsonSchema
                }
              },
              ...prepareCallSettings(settings),
              inputFormat: standardizedPrompt.type,
              prompt: await convertToLanguageModelPrompt({
                prompt: standardizedPrompt,
                modelSupportsImageUrls: model.supportsImageUrls,
                modelSupportsUrl: model.supportsUrl
              }),
              providerMetadata: inputProviderMetadata,
              abortSignal,
              headers
            }
            transformer = {
              transform(chunk, controller) {
                switch (chunk.type) {
                  case "tool-call-delta":
                    controller.enqueue(chunk.argsTextDelta)
                    break
                  case "response-metadata":
                  case "finish":
                  case "error":
                    controller.enqueue(chunk)
                    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 {
          result: { stream, warnings, rawResponse, request },
          doStreamSpan,
          startTimestampMs
        } = await retry(
          () => recordSpan({
            name: "ai.streamObject.doStream",
            attributes: selectTelemetryAttributes({
              telemetry,
              attributes: {
                ...assembleOperationName({
                  operationId: "ai.streamObject.doStream",
                  telemetry
                }),
                ...baseTelemetryAttributes,
                "ai.prompt.format": {
                  input: () => callOptions.inputFormat
                },
                "ai.prompt.messages": {
                  input: () => JSON.stringify(callOptions.prompt)
                },
                "ai.settings.mode": mode,
                // standardized gen-ai llm span attributes:
                "gen_ai.system": model.provider,
                "gen_ai.request.model": model.modelId,
                "gen_ai.request.frequency_penalty": settings.frequencyPenalty,
                "gen_ai.request.max_tokens": settings.maxTokens,
                "gen_ai.request.presence_penalty": settings.presencePenalty,
                "gen_ai.request.temperature": settings.temperature,
                "gen_ai.request.top_k": settings.topK,
                "gen_ai.request.top_p": settings.topP
              }
            }),
            tracer,
            endWhenDone: false,
            fn: async (doStreamSpan2) => ({
              startTimestampMs: now2(),
              doStreamSpan: doStreamSpan2,
              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 = ""
        let response = {
          id: generateId3(),
          timestamp: currentDate(),
          modelId: model.modelId
        }
        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
              if (isFirstChunk) {
                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)
                if (currentObjectJson !== void 0 && !(0, import_ui_utils3.isDeepEqualData)(latestObjectJson, currentObjectJson)) {
                  const validationResult = outputStrategy.validatePartialResult({
                    value: currentObjectJson,
                    textDelta,
                    latestObject,
                    isFirstDelta,
                    isFinalDelta: parseState === "successful-parse"
                  })
                  if (validationResult.success && !(0, import_ui_utils3.isDeepEqualData)(
                    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
                  }
                }
                return
              }
              switch (chunk.type) {
                case "response-metadata": {
                  response = {
                    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
                }
                case "finish": {
                  if (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)
                  self.responsePromise.resolve({
                    ...response,
                    headers: rawResponse == null ? void 0 : rawResponse.headers
                  })
                  const validationResult = outputStrategy.validateFinalResult(
                    latestObjectJson,
                    {
                      text: accumulatedText,
                      response,
                      usage
                    }
                  )
                  if (validationResult.success) {
                    object2 = validationResult.value
                    self.objectPromise.resolve(object2)
                  } else {
                    error = new NoObjectGeneratedError({
                      message: "No object generated: response did not match schema.",
                      cause: validationResult.error,
                      text: accumulatedText,
                      response,
                      usage
                    })
                    self.objectPromise.reject(error)
                  }
                  break
                }
                default: {
                  controller.enqueue(chunk)
                  break
                }
              }
            },
            // invoke onFinish callback and resolve toolResults promise when the stream is about to close:
            async flush(controller) {
              try {
                const finalUsage = usage != null ? usage : {
                  promptTokens: NaN,
                  completionTokens: NaN,
                  totalTokens: NaN
                }
                doStreamSpan.setAttributes(
                  selectTelemetryAttributes({
                    telemetry,
                    attributes: {
                      "ai.response.finishReason": finishReason,
                      "ai.response.object": {
                        output: () => JSON.stringify(object2)
                      },
                      "ai.response.id": response.id,
                      "ai.response.model": response.modelId,
                      "ai.response.timestamp": response.timestamp.toISOString(),
                      "ai.usage.promptTokens": finalUsage.promptTokens,
                      "ai.usage.completionTokens": finalUsage.completionTokens,
                      // standardized gen-ai llm span attributes:
                      "gen_ai.response.finish_reasons": [finishReason],
                      "gen_ai.response.id": response.id,
                      "gen_ai.response.model": response.modelId,
                      "gen_ai.usage.input_tokens": finalUsage.promptTokens,
                      "gen_ai.usage.output_tokens": finalUsage.completionTokens
                    }
                  })
                )
                doStreamSpan.end()
                rootSpan.setAttributes(
                  selectTelemetryAttributes({
                    telemetry,
                    attributes: {
                      "ai.usage.promptTokens": finalUsage.promptTokens,
                      "ai.usage.completionTokens": finalUsage.completionTokens,
                      "ai.response.object": {
                        output: () => JSON.stringify(object2)
                      }
                    }
                  })
                )
                await (onFinish == null ? void 0 : onFinish({
                  usage: finalUsage,
                  object: object2,
                  error,
                  response: {
                    ...response,
                    headers: rawResponse == null ? void 0 : rawResponse.headers
                  },
                  warnings,
                  experimental_providerMetadata: providerMetadata
                }))
              } catch (error2) {
                controller.error(error2)
              } finally {
                rootSpan.end()
              }
            }
          })
        )
        self.stitchableStream.addStream(transformedStream)
      }
    }).catch((error) => {
      self.stitchableStream.addStream(
        new ReadableStream({
          start(controller) {
            controller.error(error)
          }
        })
      )
    }).finally(() => {
      self.stitchableStream.close()
    })
    this.outputStrategy = outputStrategy
  }
  get object() {
    return this.objectPromise.value
  }
  get usage() {
    return this.usagePromise.value
  }
  get experimental_providerMetadata() {
    return this.providerMetadataPromise.value
  }
  get warnings() {
    return this.warningsPromise.value
  }
  get request() {
    return this.requestPromise.value
  }
  get response() {
    return this.responsePromise.value
  }
  get partialObjectStream() {
    return createAsyncIterableStream(
      this.stitchableStream.stream.pipeThrough(
        new TransformStream({
          transform(chunk, controller) {
            switch (chunk.type) {
              case "object":
                controller.enqueue(chunk.object)
                break
              case "text-delta":
              case "finish":
                break
              case "error":
                controller.error(chunk.error)
                break
              default: {
                const _exhaustiveCheck = chunk
                throw new Error(`Unsupported chunk type: ${_exhaustiveCheck}`)
              }
            }
          }
        })
      )
    )
  }
  get elementStream() {
    return this.outputStrategy.createElementStream(
      this.stitchableStream.stream
    )
  }
  get textStream() {
    return createAsyncIterableStream(
      this.stitchableStream.stream.pipeThrough(
        new TransformStream({
          transform(chunk, controller) {
            switch (chunk.type) {
              case "text-delta":
                controller.enqueue(chunk.textDelta)
                break
              case "object":
              case "finish":
                break
              case "error":
                controller.error(chunk.error)
                break
              default: {
                const _exhaustiveCheck = chunk
                throw new Error(`Unsupported chunk type: ${_exhaustiveCheck}`)
              }
            }
          }
        })
      )
    )
  }
  get fullStream() {
    return createAsyncIterableStream(this.stitchableStream.stream)
  }
  pipeTextStreamToResponse(response, init) {
    writeToServerResponse({
      response,
      status: init == null ? void 0 : init.status,
      statusText: init == null ? void 0 : init.statusText,
      headers: prepareOutgoingHttpHeaders(init == null ? void 0 : init.headers, {
        contentType: "text/plain; charset=utf-8"
      }),
      stream: this.textStream.pipeThrough(new TextEncoderStream())
    })
  }
  toTextStreamResponse(init) {
    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")

// 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 NoOutputSpecifiedError = class extends import_provider11.AISDKError {
  // used in isInstance
  constructor({ message = "No output specified." } = {}) {
    super({ name: name8, message })
    this[_a8] = true
  }
  static isInstance(error) {
    return import_provider11.AISDKError.hasMarker(error, marker8)
  }
}
_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 ToolExecutionError = class extends import_provider12.AISDKError {
  constructor({
    toolArgs,
    toolName,
    toolCallId,
    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
  }
  static isInstance(error) {
    return import_provider12.AISDKError.hasMarker(error, marker9)
  }
}
_a9 = symbol9

// core/prompt/prepare-tools-and-tool-choice.ts
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
}

// core/prompt/prepare-tools-and-tool-choice.ts
function prepareToolsAndToolChoice({
  tools,
  toolChoice,
  activeTools
}) {
  if (!isNonEmptyObject(tools)) {
    return {
      tools: void 0,
      toolChoice: void 0
    }
  }
  const filteredTools = activeTools != null ? Object.entries(tools).filter(
    ([name14]) => activeTools.includes(name14)
  ) : Object.entries(tools)
  return {
    tools: filteredTools.map(([name14, tool2]) => {
      const toolType = tool2.type
      switch (toolType) {
        case void 0:
        case "function":
          return {
            type: "function",
            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}`)
        }
      }
    }),
    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*)$/
function splitOnLastWhitespace(text2) {
  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
}

// 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")

// 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 InvalidToolArgumentsError = class extends import_provider13.AISDKError {
  constructor({
    toolArgs,
    toolName,
    cause,
    message = `Invalid arguments for tool ${toolName}: ${(0, import_provider13.getErrorMessage)(
      cause
    )}`
  }) {
    super({ name: name10, message, cause })
    this[_a10] = true
    this.toolArgs = toolArgs
    this.toolName = toolName
  }
  static isInstance(error) {
    return import_provider13.AISDKError.hasMarker(error, marker10)
  }
}
_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 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
  }
  static isInstance(error) {
    return import_provider14.AISDKError.hasMarker(error, marker11)
  }
}
_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 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
  }
  static isInstance(error) {
    return import_provider15.AISDKError.hasMarker(error, marker12)
  }
}
_a12 = symbol12

// core/generate-text/parse-tool-call.ts
async function parseToolCall({
  toolCall,
  tools,
  repairToolCall,
  system,
  messages
}) {
  if (tools == null) {
    throw new NoSuchToolError({ toolName: toolCall.toolName })
  }
  try {
    return await doParseToolCall({ toolCall, tools })
  } catch (error) {
    if (repairToolCall == null || !(NoSuchToolError.isInstance(error) || InvalidToolArgumentsError.isInstance(error))) {
      throw error
    }
    let repairedToolCall = null
    try {
      repairedToolCall = await repairToolCall({
        toolCall,
        tools,
        parameterSchema: ({ toolName }) => (0, import_ui_utils5.asSchema)(tools[toolName].parameters).jsonSchema,
        system,
        messages,
        error
      })
    } catch (repairError) {
      throw new ToolCallRepairError({
        cause: repairError,
        originalError: error
      })
    }
    if (repairedToolCall == null) {
      throw error
    }
    return await doParseToolCall({ toolCall: repairedToolCall, tools })
  }
}
async function doParseToolCall({
  toolCall,
  tools
}) {
  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 })
  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
function toResponseMessages({
  text: text2 = "",
  tools,
  toolCalls,
  toolResults,
  messageId,
  generateMessageId
}) {
  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]
        return (tool2 == null ? void 0 : tool2.experimental_toToolResultContent) != null ? {
          type: "tool-result",
          toolCallId: toolResult.toolCallId,
          toolName: toolResult.toolName,
          result: tool2.experimental_toToolResultContent(toolResult.result),
          experimental_content: tool2.experimental_toToolResultContent(
            toolResult.result
          )
        } : {
          type: "tool-result",
          toolCallId: toolResult.toolCallId,
          toolName: toolResult.toolName,
          result: toolResult.result
        }
      })
    })
  }
  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,
  toolChoice,
  system,
  prompt,
  messages,
  maxRetries: maxRetriesArg,
  abortSignal,
  headers,
  maxSteps = 1,
  experimental_generateMessageId: generateMessageId = originalGenerateMessageId,
  experimental_output: output,
  experimental_continueSteps: continueSteps = false,
  experimental_telemetry: telemetry,
  experimental_providerMetadata: providerMetadata,
  experimental_activeTools: activeTools,
  experimental_repairToolCall: repairToolCall,
  _internal: {
    generateId: generateId3 = originalGenerateId3,
    currentDate = () => /* @__PURE__ */ new Date()
  } = {},
  onStepFinish,
  ...settings
}) {
  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 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,
      prompt,
      messages
    },
    tools
  })
  const tracer = getTracer(telemetry)
  return recordSpan({
    name: "ai.generateText",
    attributes: selectTelemetryAttributes({
      telemetry,
      attributes: {
        ...assembleOperationName({
          operationId: "ai.generateText",
          telemetry
        }),
        ...baseTelemetryAttributes,
        // specific settings that only make sense on the outer level:
        "ai.prompt": {
          input: () => JSON.stringify({ system, prompt, messages })
        },
        "ai.settings.maxSteps": maxSteps
      }
    }),
    tracer,
    fn: async (span) => {
      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 = []
      let usage = {
        completionTokens: 0,
        promptTokens: 0,
        totalTokens: 0
      }
      let stepType = "initial"
      do {
        const promptFormat = stepCount === 0 ? initialPrompt.type : "messages"
        const stepInputMessages = [
          ...initialPrompt.messages,
          ...responseMessages
        ]
        const promptMessages = await convertToLanguageModelPrompt({
          prompt: {
            type: promptFormat,
            system: initialPrompt.system,
            messages: stepInputMessages
          },
          modelSupportsImageUrls: model.supportsImageUrls,
          modelSupportsUrl: model.supportsUrl
        })
        currentModelResponse = await retry(
          () => recordSpan({
            name: "ai.generateText.doGenerate",
            attributes: selectTelemetryAttributes({
              telemetry,
              attributes: {
                ...assembleOperationName({
                  operationId: "ai.generateText.doGenerate",
                  telemetry
                }),
                ...baseTelemetryAttributes,
                "ai.prompt.format": { input: () => promptFormat },
                "ai.prompt.messages": {
                  input: () => JSON.stringify(promptMessages)
                },
                "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))
                  }
                },
                "ai.prompt.toolChoice": {
                  input: () => mode.toolChoice != null ? JSON.stringify(mode.toolChoice) : void 0
                },
                // standardized gen-ai llm span attributes:
                "gen_ai.system": model.provider,
                "gen_ai.request.model": model.modelId,
                "gen_ai.request.frequency_penalty": settings.frequencyPenalty,
                "gen_ai.request.max_tokens": settings.maxTokens,
                "gen_ai.request.presence_penalty": settings.presencePenalty,
                "gen_ai.request.stop_sequences": settings.stopSequences,
                "gen_ai.request.temperature": settings.temperature,
                "gen_ai.request.top_k": settings.topK,
                "gen_ai.request.top_p": settings.topP
              }
            }),
            tracer,
            fn: async (span2) => {
              var _a16, _b2, _c2, _d2, _e2, _f2
              const result = await model.doGenerate({
                mode,
                ...callSettings,
                inputFormat: promptFormat,
                responseFormat: output == null ? void 0 : output.responseFormat({ model }),
                prompt: promptMessages,
                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,
                  attributes: {
                    "ai.response.finishReason": result.finishReason,
                    "ai.response.text": {
                      output: () => result.text
                    },
                    "ai.response.toolCalls": {
                      output: () => JSON.stringify(result.toolCalls)
                    },
                    "ai.response.id": responseData.id,
                    "ai.response.model": responseData.modelId,
                    "ai.response.timestamp": responseData.timestamp.toISOString(),
                    "ai.usage.promptTokens": result.usage.promptTokens,
                    "ai.usage.completionTokens": result.usage.completionTokens,
                    // standardized gen-ai llm span attributes:
                    "gen_ai.response.finish_reasons": [result.finishReason],
                    "gen_ai.response.id": responseData.id,
                    "gen_ai.response.model": responseData.modelId,
                    "gen_ai.usage.input_tokens": result.usage.promptTokens,
                    "gen_ai.usage.output_tokens": result.usage.completionTokens
                  }
                })
              )
              return { ...result, response: responseData }
            }
          })
        )
        currentToolCalls = await Promise.all(
          ((_a15 = currentModelResponse.toolCalls) != null ? _a15 : []).map(
            (toolCall) => parseToolCall({
              toolCall,
              tools,
              repairToolCall,
              system,
              messages: stepInputMessages
            })
          )
        )
        currentToolResults = tools == null ? [] : await executeTools({
          toolCalls: currentToolCalls,
          tools,
          tracer,
          telemetry,
          messages: stepInputMessages,
          abortSignal
        })
        const currentUsage = calculateLanguageModelUsage(
          currentModelResponse.usage
        )
        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"
          } else if (
            // there are tool calls:
            currentToolCalls.length > 0 && // all current tool calls have results:
            currentToolResults.length === currentToolCalls.length
          ) {
            nextStepType = "tool-result"
          }
        }
        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
        if (stepType === "continue") {
          const lastMessage = responseMessages[responseMessages.length - 1]
          if (typeof lastMessage.content === "string") {
            lastMessage.content += stepText
          } else {
            lastMessage.content.push({
              text: stepText,
              type: "text"
            })
          }
        } else {
          responseMessages.push(
            ...toResponseMessages({
              text: text2,
              tools: tools != null ? tools : {},
              toolCalls: currentToolCalls,
              toolResults: currentToolResults,
              messageId: generateMessageId(),
              generateMessageId
            })
          )
        }
        const currentStepResult = {
          stepType,
          text: stepText,
          toolCalls: currentToolCalls,
          toolResults: currentToolResults,
          finishReason: currentModelResponse.finishReason,
          usage: currentUsage,
          warnings: currentModelResponse.warnings,
          logprobs: currentModelResponse.logprobs,
          request: (_c = currentModelResponse.request) != null ? _c : {},
          response: {
            ...currentModelResponse.response,
            headers: (_d = currentModelResponse.rawResponse) == null ? void 0 : _d.headers,
            // deep clone msgs to avoid mutating past messages in multi-step:
            messages: structuredClone(responseMessages)
          },
          experimental_providerMetadata: currentModelResponse.providerMetadata,
          isContinued: nextStepType === "continue"
        }
        steps.push(currentStepResult)
        await (onStepFinish == null ? void 0 : onStepFinish(currentStepResult))
        stepType = nextStepType
      } while (stepType !== "done")
      span.setAttributes(
        selectTelemetryAttributes({
          telemetry,
          attributes: {
            "ai.response.finishReason": currentModelResponse.finishReason,
            "ai.response.text": {
              output: () => currentModelResponse.text
            },
            "ai.response.toolCalls": {
              output: () => JSON.stringify(currentModelResponse.toolCalls)
            },
            "ai.usage.promptTokens": currentModelResponse.usage.promptTokens,
            "ai.usage.completionTokens": currentModelResponse.usage.completionTokens
          }
        })
      )
      return new DefaultGenerateTextResult({
        text: text2,
        outputResolver: () => {
          if (output == null) {
            throw new NoOutputSpecifiedError()
          }
          return output.parseOutput(
            { text: text2 },
            { response: currentModelResponse.response, usage }
          )
        },
        toolCalls: currentToolCalls,
        toolResults: currentToolResults,
        finishReason: currentModelResponse.finishReason,
        usage,
        warnings: currentModelResponse.warnings,
        request: (_e = currentModelResponse.request) != null ? _e : {},
        response: {
          ...currentModelResponse.response,
          headers: (_f = currentModelResponse.rawResponse) == null ? void 0 : _f.headers,
          messages: responseMessages
        },
        logprobs: currentModelResponse.logprobs,
        steps,
        providerMetadata: currentModelResponse.providerMetadata
      })
    }
  })
}
async function executeTools({
  toolCalls,
  tools,
  tracer,
  telemetry,
  messages,
  abortSignal
}) {
  const toolResults = await Promise.all(
    toolCalls.map(async ({ toolCallId, toolName, args }) => {
      const tool2 = tools[toolName]
      if ((tool2 == null ? void 0 : tool2.execute) == null) {
        return void 0
      }
      const result = await recordSpan({
        name: "ai.toolCall",
        attributes: selectTelemetryAttributes({
          telemetry,
          attributes: {
            ...assembleOperationName({
              operationId: "ai.toolCall",
              telemetry
            }),
            "ai.toolCall.name": toolName,
            "ai.toolCall.id": toolCallId,
            "ai.toolCall.args": {
              output: () => JSON.stringify(args)
            }
          }
        }),
        tracer,
        fn: async (span) => {
          try {
            const result2 = await tool2.execute(args, {
              toolCallId,
              messages,
              abortSignal
            })
            try {
              span.setAttributes(
                selectTelemetryAttributes({
                  telemetry,
                  attributes: {
                    "ai.toolCall.result": {
                      output: () => JSON.stringify(result2)
                    }
                  }
                })
              )
            } catch (ignored) {
              console.error(ignored)
            }
            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
  }
  get experimental_output() {
    return this.outputResolver()
  }
}

// core/generate-text/output.ts
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")

// errors/index.ts
var import_provider16 = require("@ai-sdk/provider")

// core/generate-text/output.ts
var text = () => ({
  type: "text",
  responseFormat: () => ({ type: "text" }),
  injectIntoSystemPrompt({ system }) {
    return system
  },
  parsePartial({ text: text2 }) {
    return { partial: text2 }
  },
  parseOutput({ text: text2 }) {
    return text2
  }
})
var object = ({
  schema: inputSchema
}) => {
  const schema = (0, import_ui_utils6.asSchema)(inputSchema)
  return {
    type: "object",
    responseFormat: ({ model }) => ({
      type: "json",
      schema: model.supportsStructuredOutputs ? schema.jsonSchema : void 0
    }),
    injectIntoSystemPrompt({ system, model }) {
      return model.supportsStructuredOutputs ? system : injectJsonInstruction({
        prompt: system,
        schema: schema.jsonSchema
      })
    },
    parsePartial({ text: text2 }) {
      const result = (0, import_ui_utils6.parsePartialJson)(text2)
      switch (result.state) {
        case "failed-parse":
        case "undefined-input":
          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}`)
        }
      }
    },
    parseOutput({ text: text2 }, context) {
      const parseResult = (0, import_provider_utils10.safeParseJSON)({ text: text2 })
      if (!parseResult.success) {
        throw new NoObjectGeneratedError({
          message: "No object generated: could not parse the response.",
          cause: parseResult.error,
          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.",
          cause: validationResult.error,
          text: text2,
          response: context.response,
          usage: context.usage
        })
      }
      return validationResult.value
    }
  }
}

// core/generate-text/smooth-stream.ts
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
  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 = ""
    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(chunk)
          return
        }
        if (chunk.type !== "text-delta") {
          controller.enqueue(chunk)
          return
        }
        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)
        }
      }
    })
  }
}

// core/generate-text/stream-text.ts
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]
}

// 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
  async function readStream1(controller) {
    try {
      if (lastRead1 == null) {
        lastRead1 = reader1.read()
      }
      const result = await lastRead1
      lastRead1 = void 0
      if (!result.done) {
        controller.enqueue(result.value)
      } else {
        controller.close()
      }
    } catch (error) {
      controller.error(error)
    }
  }
  async function readStream2(controller) {
    try {
      if (lastRead2 == null) {
        lastRead2 = reader2.read()
      }
      const result = await lastRead2
      lastRead2 = void 0
      if (!result.done) {
        controller.enqueue(result.value)
      } else {
        controller.close()
      }
    } catch (error) {
      controller.error(error)
    }
  }
  return new ReadableStream({
    async pull(controller) {
      try {
        if (stream1Done) {
          await readStream2(controller)
          return
        }
        if (stream2Done) {
          await readStream1(controller)
          return
        }
        if (lastRead1 == null) {
          lastRead1 = reader1.read()
        }
        if (lastRead2 == null) {
          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)
        }
        if (reader === reader1) {
          lastRead1 = void 0
          if (result.done) {
            await readStream2(controller)
            stream1Done = true
          }
        } else {
          lastRead2 = void 0
          if (result.done) {
            stream2Done = true
            await readStream1(controller)
          }
        }
      } catch (error) {
        controller.error(error)
      }
    },
    cancel() {
      reader1.cancel()
      reader2.cancel()
    }
  })
}

// core/generate-text/run-tools-transformation.ts
var import_ui_utils7 = require("@ai-sdk/ui-utils")
function runToolsTransformation({
  tools,
  generatorStream,
  toolCallStreaming,
  tracer,
  telemetry,
  system,
  messages,
  abortSignal,
  repairToolCall
}) {
  let toolResultsStreamController = null
  const toolResultsStream = new ReadableStream({
    start(controller) {
      toolResultsStreamController = controller
    }
  })
  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.close()
    }
  }
  const forwardStream = new TransformStream({
    async transform(chunk, controller) {
      const chunkType = chunk.type
      switch (chunkType) {
        case "text-delta":
        case "response-metadata":
        case "error": {
          controller.enqueue(chunk)
          break
        }
        case "tool-call-delta": {
          if (toolCallStreaming) {
            if (!activeToolCalls[chunk.toolCallId]) {
              controller.enqueue({
                type: "tool-call-streaming-start",
                toolCallId: chunk.toolCallId,
                toolName: chunk.toolName
              })
              activeToolCalls[chunk.toolCallId] = true
            }
            controller.enqueue({
              type: "tool-call-delta",
              toolCallId: chunk.toolCallId,
              toolName: chunk.toolName,
              argsTextDelta: chunk.argsTextDelta
            })
          }
          break
        }
        case "tool-call": {
          try {
            const toolCall = await parseToolCall({
              toolCall: chunk,
              tools,
              repairToolCall,
              system,
              messages
            })
            controller.enqueue(toolCall)
            const tool2 = tools[toolCall.toolName]
            if (tool2.execute != null) {
              const toolExecutionId = (0, import_ui_utils7.generateId)()
              outstandingToolResults.add(toolExecutionId)
              recordSpan({
                name: "ai.toolCall",
                attributes: selectTelemetryAttributes({
                  telemetry,
                  attributes: {
                    ...assembleOperationName({
                      operationId: "ai.toolCall",
                      telemetry
                    }),
                    "ai.toolCall.name": toolCall.toolName,
                    "ai.toolCall.id": toolCall.toolCallId,
                    "ai.toolCall.args": {
                      output: () => JSON.stringify(toolCall.args)
                    }
                  }
                }),
                tracer,
                fn: async (span) => tool2.execute(toolCall.args, {
                  toolCallId: toolCall.toolCallId,
                  messages,
                  abortSignal
                }).then(
                  (result) => {
                    toolResultsStreamController.enqueue({
                      ...toolCall,
                      type: "tool-result",
                      result
                    })
                    outstandingToolResults.delete(toolExecutionId)
                    attemptClose()
                    try {
                      span.setAttributes(
                        selectTelemetryAttributes({
                          telemetry,
                          attributes: {
                            "ai.toolCall.result": {
                              output: () => JSON.stringify(result)
                            }
                          }
                        })
                      )
                    } catch (ignored) {
                    }
                  },
                  (error) => {
                    toolResultsStreamController.enqueue({
                      type: "error",
                      error: new ToolExecutionError({
                        toolCallId: toolCall.toolCallId,
                        toolName: toolCall.toolName,
                        toolArgs: toolCall.args,
                        cause: error
                      })
                    })
                    outstandingToolResults.delete(toolExecutionId)
                    attemptClose()
                  }
                )
              })
            }
          } catch (error) {
            toolResultsStreamController.enqueue({
              type: "error",
              error
            })
          }
          break
        }
        case "finish": {
          finishChunk = {
            type: "finish",
            finishReason: chunk.finishReason,
            logprobs: chunk.logprobs,
            usage: calculateLanguageModelUsage(chunk.usage),
            experimental_providerMetadata: chunk.providerMetadata
          }
          break
        }
        default: {
          const _exhaustiveCheck = chunkType
          throw new Error(`Unhandled chunk type: ${_exhaustiveCheck}`)
        }
      }
    },
    flush() {
      canClose = true
      attemptClose()
    }
  })
  return new ReadableStream({
    async start(controller) {
      return Promise.all([
        generatorStream.pipeThrough(forwardStream).pipeTo(
          new WritableStream({
            write(chunk) {
              controller.enqueue(chunk)
            },
            close() {
            }
          })
        ),
        toolResultsStream.pipeTo(
          new WritableStream({
            write(chunk) {
              controller.enqueue(chunk)
            },
            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,
  toolChoice,
  system,
  prompt,
  messages,
  maxRetries,
  abortSignal,
  headers,
  maxSteps = 1,
  experimental_generateMessageId: generateMessageId = originalGenerateMessageId2,
  experimental_output: output,
  experimental_continueSteps: continueSteps = false,
  experimental_telemetry: telemetry,
  experimental_providerMetadata: providerMetadata,
  experimental_toolCallStreaming: toolCallStreaming = false,
  experimental_activeTools: activeTools,
  experimental_repairToolCall: repairToolCall,
  experimental_transform: transform,
  onChunk,
  onFinish,
  onStepFinish,
  _internal: {
    now: now2 = now,
    generateId: generateId3 = originalGenerateId4,
    currentDate = () => /* @__PURE__ */ new Date()
  } = {},
  ...settings
}) {
  return new DefaultStreamTextResult({
    model,
    telemetry,
    headers,
    settings,
    maxRetries,
    abortSignal,
    system,
    prompt,
    messages,
    tools,
    toolChoice,
    toolCallStreaming,
    transforms: asArray(transform),
    activeTools,
    repairToolCall,
    maxSteps,
    output,
    continueSteps,
    providerMetadata,
    onChunk,
    onFinish,
    onStepFinish,
    now: now2,
    currentDate,
    generateId: generateId3,
    generateMessageId
  })
}
function createOutputTransformStream(output) {
  if (!output) {
    return new TransformStream({
      transform(chunk, controller) {
        controller.enqueue({ part: chunk, partialOutput: void 0 })
      }
    })
  }
  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
      }
      text2 += chunk.textDelta
      textChunk += chunk.textDelta
      const result = output.parsePartial({ text: text2 })
      if (result != null) {
        const currentJson = JSON.stringify(result.partial)
        if (currentJson !== lastPublishedJson) {
          controller.enqueue({
            part: {
              type: "text-delta",
              textDelta: textChunk
            },
            partialOutput: result.partial
          })
          lastPublishedJson = currentJson
          textChunk = ""
        }
      }
    },
    flush(controller) {
      if (textChunk.length > 0) {
        controller.enqueue({
          part: {
            type: "text-delta",
            textDelta: textChunk
          },
          partialOutput: void 0
        })
      }
    }
  })
}
var DefaultStreamTextResult = class {
  constructor({
    model,
    telemetry,
    headers,
    settings,
    maxRetries: maxRetriesArg,
    abortSignal,
    system,
    prompt,
    messages,
    tools,
    toolChoice,
    toolCallStreaming,
    transforms,
    activeTools,
    repairToolCall,
    maxSteps,
    output,
    continueSteps,
    providerMetadata,
    onChunk,
    onFinish,
    onStepFinish,
    now: now2,
    currentDate,
    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
    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 = ""
    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
    const eventProcessor = new TransformStream({
      async transform(chunk, controller) {
        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 }))
        }
        if (part.type === "text-delta") {
          recordedStepText += part.textDelta
          recordedContinuationText += part.textDelta
          recordedFullText += part.textDelta
        }
        if (part.type === "tool-call") {
          recordedToolCalls.push(part)
        }
        if (part.type === "tool-result") {
          recordedToolResults.push(part)
        }
        if (part.type === "step-finish") {
          const stepMessages = toResponseMessages({
            text: recordedContinuationText,
            tools: tools != null ? tools : {},
            toolCalls: recordedToolCalls,
            toolResults: recordedToolResults,
            messageId: part.messageId,
            generateMessageId
          })
          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"
            } else if (
              // there are tool calls:
              recordedToolCalls.length > 0 && // all current tool calls have results:
              recordedToolResults.length === recordedToolCalls.length
            ) {
              nextStepType = "tool-result"
            }
          }
          const currentStepResult = {
            stepType,
            text: recordedStepText,
            toolCalls: recordedToolCalls,
            toolResults: recordedToolResults,
            finishReason: part.finishReason,
            usage: part.usage,
            warnings: part.warnings,
            logprobs: part.logprobs,
            request: part.request,
            response: {
              ...part.response,
              messages: [...recordedResponse.messages, ...stepMessages]
            },
            experimental_providerMetadata: part.experimental_providerMetadata,
            isContinued: part.isContinued
          }
          await (onStepFinish == null ? void 0 : onStepFinish(currentStepResult))
          recordedSteps.push(currentStepResult)
          recordedToolCalls = []
          recordedToolResults = []
          recordedStepText = ""
          if (nextStepType !== "done") {
            stepType = nextStepType
          }
          if (nextStepType !== "continue") {
            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
        }
      },
      async flush(controller) {
        var _a15
        try {
          if (recordedSteps.length === 0) {
            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)
          self.providerMetadataPromise.resolve(
            lastStep.experimental_providerMetadata
          )
          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)
          await (onFinish == null ? void 0 : onFinish({
            finishReason,
            logprobs: void 0,
            usage,
            text: recordedFullText,
            toolCalls: lastStep.toolCalls,
            toolResults: lastStep.toolResults,
            request: (_a15 = lastStep.request) != null ? _a15 : {},
            response: lastStep.response,
            warnings: lastStep.warnings,
            experimental_providerMetadata: lastStep.experimental_providerMetadata,
            steps: recordedSteps
          }))
          rootSpan.setAttributes(
            selectTelemetryAttributes({
              telemetry,
              attributes: {
                "ai.response.finishReason": finishReason,
                "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
                  }
                },
                "ai.usage.promptTokens": usage.promptTokens,
                "ai.usage.completionTokens": usage.completionTokens
              }
            })
          )
        } catch (error) {
          controller.error(error)
        } finally {
          rootSpan.end()
        }
      }
    })
    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()
          }
        })
      )
    }
    this.baseStream = stream.pipeThrough(createOutputTransformStream(output)).pipeThrough(eventProcessor)
    const { maxRetries, retry } = prepareRetries({
      maxRetries: maxRetriesArg
    })
    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,
        prompt,
        messages
      },
      tools
    })
    const self = this
    recordSpan({
      name: "ai.streamText",
      attributes: selectTelemetryAttributes({
        telemetry,
        attributes: {
          ...assembleOperationName({ operationId: "ai.streamText", telemetry }),
          ...baseTelemetryAttributes,
          // specific settings that only make sense on the outer level:
          "ai.prompt": {
            input: () => JSON.stringify({ system, prompt, messages })
          },
          "ai.settings.maxSteps": maxSteps
        }
      }),
      tracer,
      endWhenDone: false,
      fn: async (rootSpanArg) => {
        rootSpan = rootSpanArg
        async function streamStep({
          currentStep,
          responseMessages,
          usage,
          stepType: stepType2,
          previousStepText,
          hasLeadingWhitespace,
          messageId
        }) {
          const promptFormat = responseMessages.length === 0 ? initialPrompt.type : "messages"
          const stepInputMessages = [
            ...initialPrompt.messages,
            ...responseMessages
          ]
          const promptMessages = await convertToLanguageModelPrompt({
            prompt: {
              type: promptFormat,
              system: initialPrompt.system,
              messages: stepInputMessages
            },
            modelSupportsImageUrls: model.supportsImageUrls,
            modelSupportsUrl: model.supportsUrl
          })
          const mode = {
            type: "regular",
            ...prepareToolsAndToolChoice({ tools, toolChoice, activeTools })
          }
          const {
            result: { stream: stream2, warnings, rawResponse, request },
            doStreamSpan,
            startTimestampMs
          } = await retry(
            () => recordSpan({
              name: "ai.streamText.doStream",
              attributes: selectTelemetryAttributes({
                telemetry,
                attributes: {
                  ...assembleOperationName({
                    operationId: "ai.streamText.doStream",
                    telemetry
                  }),
                  ...baseTelemetryAttributes,
                  "ai.prompt.format": {
                    input: () => promptFormat
                  },
                  "ai.prompt.messages": {
                    input: () => JSON.stringify(promptMessages)
                  },
                  "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))
                    }
                  },
                  "ai.prompt.toolChoice": {
                    input: () => mode.toolChoice != null ? JSON.stringify(mode.toolChoice) : void 0
                  },
                  // standardized gen-ai llm span attributes:
                  "gen_ai.system": model.provider,
                  "gen_ai.request.model": model.modelId,
                  "gen_ai.request.frequency_penalty": settings.frequencyPenalty,
                  "gen_ai.request.max_tokens": settings.maxTokens,
                  "gen_ai.request.presence_penalty": settings.presencePenalty,
                  "gen_ai.request.stop_sequences": settings.stopSequences,
                  "gen_ai.request.temperature": settings.temperature,
                  "gen_ai.request.top_k": settings.topK,
                  "gen_ai.request.top_p": settings.topP
                }
              }),
              tracer,
              endWhenDone: false,
              fn: async (doStreamSpan2) => ({
                startTimestampMs: now2(),
                // get before the call
                doStreamSpan: doStreamSpan2,
                result: await model.doStream({
                  mode,
                  ...prepareCallSettings(settings),
                  inputFormat: promptFormat,
                  responseFormat: output == null ? void 0 : output.responseFormat({ model }),
                  prompt: promptMessages,
                  providerMetadata,
                  abortSignal,
                  headers
                })
              })
            })
          )
          const transformedStream = runToolsTransformation({
            tools,
            generatorStream: stream2,
            toolCallStreaming,
            tracer,
            telemetry,
            system,
            messages: stepInputMessages,
            repairToolCall,
            abortSignal
          })
          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 stepResponse = {
            id: generateId3(),
            timestamp: currentDate(),
            modelId: model.modelId
          }
          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
          }
          self.addStream(
            transformedStream.pipeThrough(
              new TransformStream({
                async transform(chunk, controller) {
                  var _a15, _b, _c
                  if (stepFirstChunk) {
                    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
                  }
                  const chunkType = chunk.type
                  switch (chunkType) {
                    case "text-delta": {
                      if (continueSteps) {
                        const trimmedChunkText = inWhitespacePrefix && hasLeadingWhitespace ? chunk.textDelta.trimStart() : chunk.textDelta
                        if (trimmedChunkText.length === 0) {
                          break
                        }
                        inWhitespacePrefix = false
                        chunkBuffer += trimmedChunkText
                        const split = splitOnLastWhitespace(chunkBuffer)
                        if (split != null) {
                          chunkBuffer = split.suffix
                          await publishTextChunk({
                            controller,
                            chunk: {
                              type: "text-delta",
                              textDelta: split.prefix + split.whitespace
                            }
                          })
                        }
                      } else {
                        await publishTextChunk({ controller, chunk })
                      }
                      break
                    }
                    case "tool-call": {
                      controller.enqueue(chunk)
                      stepToolCalls.push(chunk)
                      break
                    }
                    case "tool-result": {
                      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
                    }
                    case "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
                    }
                    case "tool-call-streaming-start":
                    case "tool-call-delta": {
                      controller.enqueue(chunk)
                      break
                    }
                    case "error": {
                      controller.enqueue(chunk)
                      stepFinishReason = "error"
                      break
                    }
                    default: {
                      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"
                  if (currentStep + 1 < maxSteps) {
                    if (continueSteps && stepFinishReason === "length" && // only use continue when there are no tool calls:
                    stepToolCalls.length === 0) {
                      nextStepType = "continue"
                    } else if (
                      // there are tool calls:
                      stepToolCalls.length > 0 && // all current tool calls have results:
                      stepToolResults.length === stepToolCalls.length
                    ) {
                      nextStepType = "tool-result"
                    }
                  }
                  if (continueSteps && chunkBuffer.length > 0 && (nextStepType !== "continue" || // when the next step is a regular step, publish the buffer
                  stepType2 === "continue" && !chunkTextPublished)) {
                    await publishTextChunk({
                      controller,
                      chunk: {
                        type: "text-delta",
                        textDelta: chunkBuffer
                      }
                    })
                    chunkBuffer = ""
                  }
                  try {
                    doStreamSpan.setAttributes(
                      selectTelemetryAttributes({
                        telemetry,
                        attributes: {
                          "ai.response.finishReason": stepFinishReason,
                          "ai.response.text": { output: () => stepText },
                          "ai.response.toolCalls": {
                            output: () => stepToolCallsJson
                          },
                          "ai.response.id": stepResponse.id,
                          "ai.response.model": stepResponse.modelId,
                          "ai.response.timestamp": stepResponse.timestamp.toISOString(),
                          "ai.usage.promptTokens": stepUsage.promptTokens,
                          "ai.usage.completionTokens": stepUsage.completionTokens,
                          // standardized gen-ai llm span attributes:
                          "gen_ai.response.finish_reasons": [stepFinishReason],
                          "gen_ai.response.id": stepResponse.id,
                          "gen_ai.response.model": stepResponse.modelId,
                          "gen_ai.usage.input_tokens": stepUsage.promptTokens,
                          "gen_ai.usage.output_tokens": stepUsage.completionTokens
                        }
                      })
                    )
                  } catch (error) {
                  } finally {
                    doStreamSpan.end()
                  }
                  controller.enqueue({
                    type: "step-finish",
                    finishReason: stepFinishReason,
                    usage: stepUsage,
                    experimental_providerMetadata: stepProviderMetadata,
                    logprobs: stepLogProbs,
                    request: stepRequest,
                    response: {
                      ...stepResponse,
                      headers: rawResponse == null ? void 0 : rawResponse.headers
                    },
                    warnings,
                    isContinued: nextStepType === "continue",
                    messageId
                  })
                  const combinedUsage = addLanguageModelUsage(usage, stepUsage)
                  if (nextStepType === "done") {
                    controller.enqueue({
                      type: "finish",
                      finishReason: stepFinishReason,
                      usage: combinedUsage,
                      experimental_providerMetadata: stepProviderMetadata,
                      logprobs: stepLogProbs,
                      response: {
                        ...stepResponse,
                        headers: rawResponse == null ? void 0 : rawResponse.headers
                      }
                    })
                    self.closeStream()
                  } else {
                    if (stepType2 === "continue") {
                      const lastMessage = responseMessages[responseMessages.length - 1]
                      if (typeof lastMessage.content === "string") {
                        lastMessage.content += stepText
                      } else {
                        lastMessage.content.push({
                          text: stepText,
                          type: "text"
                        })
                      }
                    } else {
                      responseMessages.push(
                        ...toResponseMessages({
                          text: stepText,
                          tools: tools != null ? tools : {},
                          toolCalls: stepToolCalls,
                          toolResults: stepToolResults,
                          messageId,
                          generateMessageId
                        })
                      )
                    }
                    await streamStep({
                      currentStep: currentStep + 1,
                      responseMessages,
                      usage: combinedUsage,
                      stepType: nextStepType,
                      previousStepText: fullStepText,
                      hasLeadingWhitespace: hasWhitespaceSuffix,
                      messageId: (
                        // keep the same id when continuing a step:
                        nextStepType === "continue" ? messageId : generateMessageId()
                      )
                    })
                  }
                }
              })
            )
          )
        }
        await streamStep({
          currentStep: 0,
          responseMessages: [],
          usage: {
            promptTokens: 0,
            completionTokens: 0,
            totalTokens: 0
          },
          previousStepText: "",
          stepType: "initial",
          hasLeadingWhitespace: false,
          messageId: generateMessageId()
        })
      }
    }).catch((error) => {
      self.addStream(
        new ReadableStream({
          start(controller) {
            controller.enqueue({ type: "error", error })
            controller.close()
          }
        })
      )
      self.closeStream()
    })
  }
  get warnings() {
    return this.warningsPromise.value
  }
  get usage() {
    return this.usagePromise.value
  }
  get finishReason() {
    return this.finishReasonPromise.value
  }
  get experimental_providerMetadata() {
    return this.providerMetadataPromise.value
  }
  get text() {
    return this.textPromise.value
  }
  get toolCalls() {
    return this.toolCallsPromise.value
  }
  get toolResults() {
    return this.toolResultsPromise.value
  }
  get request() {
    return this.requestPromise.value
  }
  get response() {
    return this.responsePromise.value
  }
  get steps() {
    return this.stepsPromise.value
  }
  /**
  Split out a new stream from the original stream.
  The original stream is replaced to allow for further splitting,
  since we do not know how many times the stream will be split.
  
  Note: this leads to buffering the stream content on the server.
  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
  }
  get textStream() {
    return createAsyncIterableStream(
      this.teeStream().pipeThrough(
        new TransformStream({
          transform({ part }, controller) {
            if (part.type === "text-delta") {
              controller.enqueue(part.textDelta)
            } else if (part.type === "error") {
              controller.error(part.error)
            }
          }
        })
      )
    )
  }
  get fullStream() {
    return createAsyncIterableStream(
      this.teeStream().pipeThrough(
        new TransformStream({
          transform({ part }, controller) {
            controller.enqueue(part)
          }
        })
      )
    )
  }
  get experimental_partialOutputStream() {
    if (this.output == null) {
      throw new NoOutputSpecifiedError()
    }
    return createAsyncIterableStream(
      this.teeStream().pipeThrough(
        new TransformStream({
          transform({ partialOutput }, controller) {
            if (partialOutput != null) {
              controller.enqueue(partialOutput)
            }
          }
        })
      )
    )
  }
  toDataStreamInternal({
    getErrorMessage: getErrorMessage5 = () => "An error occurred.",
    // mask error messages for safety by default
    sendUsage = true
  } = {}) {
    let aggregatedResponse = ""
    const callbackTransformer = new TransformStream({
      async transform(chunk, controller) {
        controller.enqueue(chunk)
        if (chunk.type === "text-delta") {
          aggregatedResponse += chunk.textDelta
        }
      }
    })
    const streamPartsTransformer = new TransformStream({
      transform: async (chunk, controller) => {
        const chunkType = chunk.type
        switch (chunkType) {
          case "text-delta": {
            controller.enqueue((0, import_ui_utils8.formatDataStreamPart)("text", chunk.textDelta))
            break
          }
          case "tool-call-streaming-start": {
            controller.enqueue(
              (0, import_ui_utils8.formatDataStreamPart)("tool_call_streaming_start", {
                toolCallId: chunk.toolCallId,
                toolName: chunk.toolName
              })
            )
            break
          }
          case "tool-call-delta": {
            controller.enqueue(
              (0, import_ui_utils8.formatDataStreamPart)("tool_call_delta", {
                toolCallId: chunk.toolCallId,
                argsTextDelta: chunk.argsTextDelta
              })
            )
            break
          }
          case "tool-call": {
            controller.enqueue(
              (0, import_ui_utils8.formatDataStreamPart)("tool_call", {
                toolCallId: chunk.toolCallId,
                toolName: chunk.toolName,
                args: chunk.args
              })
            )
            break
          }
          case "tool-result": {
            controller.enqueue(
              (0, import_ui_utils8.formatDataStreamPart)("tool_result", {
                toolCallId: chunk.toolCallId,
                result: chunk.result
              })
            )
            break
          }
          case "error": {
            controller.enqueue(
              (0, import_ui_utils8.formatDataStreamPart)("error", getErrorMessage5(chunk.error))
            )
            break
          }
          case "step-start": {
            controller.enqueue(
              (0, import_ui_utils8.formatDataStreamPart)("start_step", {
                messageId: chunk.messageId
              })
            )
            break
          }
          case "step-finish": {
            controller.enqueue(
              (0, import_ui_utils8.formatDataStreamPart)("finish_step", {
                finishReason: chunk.finishReason,
                usage: sendUsage ? {
                  promptTokens: chunk.usage.promptTokens,
                  completionTokens: chunk.usage.completionTokens
                } : void 0,
                isContinued: chunk.isContinued
              })
            )
            break
          }
          case "finish": {
            controller.enqueue(
              (0, import_ui_utils8.formatDataStreamPart)("finish_message", {
                finishReason: chunk.finishReason,
                usage: sendUsage ? {
                  promptTokens: chunk.usage.promptTokens,
                  completionTokens: chunk.usage.completionTokens
                } : void 0
              })
            )
            break
          }
          default: {
            const exhaustiveCheck = chunkType
            throw new Error(`Unknown chunk type: ${exhaustiveCheck}`)
          }
        }
      }
    })
    return this.fullStream.pipeThrough(callbackTransformer).pipeThrough(streamPartsTransformer)
  }
  pipeDataStreamToResponse(response, {
    status,
    statusText,
    headers,
    data,
    getErrorMessage: getErrorMessage5,
    sendUsage
  } = {}) {
    writeToServerResponse({
      response,
      status,
      statusText,
      headers: prepareOutgoingHttpHeaders(headers, {
        contentType: "text/plain; charset=utf-8",
        dataStreamVersion: "v1"
      }),
      stream: this.toDataStream({ data, getErrorMessage: getErrorMessage5, sendUsage })
    })
  }
  pipeTextStreamToResponse(response, init) {
    writeToServerResponse({
      response,
      status: init == null ? void 0 : init.status,
      statusText: init == null ? void 0 : init.statusText,
      headers: prepareOutgoingHttpHeaders(init == null ? void 0 : init.headers, {
        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
  }
  mergeIntoDataStream(writer) {
    writer.merge(
      this.toDataStreamInternal({
        getErrorMessage: writer.onError
      })
    )
  }
  toDataStreamResponse({
    headers,
    status,
    statusText,
    data,
    getErrorMessage: getErrorMessage5,
    sendUsage
  } = {}) {
    return new Response(
      this.toDataStream({ data, getErrorMessage: getErrorMessage5, sendUsage }),
      {
        status,
        statusText,
        headers: prepareResponseHeaders(headers, {
          contentType: "text/plain; charset=utf-8",
          dataStreamVersion: "v1"
        })
      }
    )
  }
  toTextStreamResponse(init) {
    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 = ({
  model,
  middleware: { transformParams, wrapGenerate, wrapStream },
  modelId,
  providerId
}) => {
  async function doTransform({
    params,
    type
  }) {
    return transformParams ? await transformParams({ params, type }) : params
  }
  return {
    specificationVersion: "v1",
    provider: providerId != null ? providerId : model.provider,
    modelId: modelId != null ? modelId : model.modelId,
    defaultObjectGenerationMode: model.defaultObjectGenerationMode,
    supportsImageUrls: model.supportsImageUrls,
    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()
    },
    async doStream(params) {
      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)
  for (const message of responseMessages) {
    const role = message.role
    switch (role) {
      case "assistant": {
        clonedMessages.push({
          role: "assistant",
          id: message.id,
          createdAt: /* @__PURE__ */ new Date(),
          // generate a createdAt date for the message, will be overridden by the client
          // only include text in the content:
          content: typeof message.content === "string" ? message.content : message.content.filter((part) => part.type === "text").map((part) => part.text).join(""),
          // separate tool calls from the content:
          toolInvocations: (typeof message.content === "string" ? [] : message.content.filter((part) => part.type === "tool-call")).map((call) => ({
            state: "call",
            ...call
          }))
        })
        break
      }
      case "tool": {
        const previousMessage = clonedMessages[clonedMessages.length - 1];
        (_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")
          }
          toolCall.state = "result"
          const toolResult = toolCall
          toolResult.result = part.result
        }
        break
      }
      default: {
        const _exhaustiveCheck = role
        throw new Error(`Unsupported message role: ${_exhaustiveCheck}`)
      }
    }
  }
  return clonedMessages
}

// core/registry/custom-provider.ts
var import_provider18 = require("@ai-sdk/provider")
function experimental_customProvider({
  languageModels,
  textEmbeddingModels,
  fallbackProvider
}) {
  return {
    languageModel(modelId) {
      if (languageModels != null && modelId in languageModels) {
        return languageModels[modelId]
      }
      if (fallbackProvider) {
        return fallbackProvider.languageModel(modelId)
      }
      throw new import_provider18.NoSuchModelError({ modelId, modelType: "languageModel" })
    },
    textEmbeddingModel(modelId) {
      if (textEmbeddingModels != null && modelId in textEmbeddingModels) {
        return textEmbeddingModels[modelId]
      }
      if (fallbackProvider) {
        return fallbackProvider.textEmbeddingModel(modelId)
      }
      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 NoSuchProviderError = class extends import_provider19.NoSuchModelError {
  constructor({
    modelId,
    modelType,
    providerId,
    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
  }
  static isInstance(error) {
    return import_provider19.AISDKError.hasMarker(error, marker13)
  }
}
_a13 = symbol13

// core/registry/provider-registry.ts
var import_provider20 = require("@ai-sdk/provider")
function experimental_createProviderRegistry(providers) {
  const registry = new DefaultProviderRegistry()
  for (const [id, provider] of Object.entries(providers)) {
    registry.registerProvider({ id, provider })
  }
  return registry
}
var DefaultProviderRegistry = class {
  constructor() {
    this.providers = {}
  }
  registerProvider({ id, provider }) {
    this.providers[id] = provider
  }
  getProvider(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
  }
  splitId(id, modelType) {
    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)]
  }
  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)
    if (model == null) {
      throw new import_provider20.NoSuchModelError({ modelId: id, modelType: "languageModel" })
    }
    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)
    if (model == null) {
      throw new import_provider20.NoSuchModelError({
        modelId: id,
        modelType: "textEmbeddingModel"
      })
    }
    return model
  }
  /**
   * @deprecated Use `textEmbeddingModel` instead.
   */
  textEmbedding(id) {
    return this.textEmbeddingModel(id)
  }
}

// core/tool/tool.ts
function tool(tool2) {
  return tool2
}

// core/util/cosine-similarity.ts
function cosineSimilarity(vector1, vector2, options = {
  throwErrorForEmptyVectors: false
}) {
  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)
  if (magnitude1 === 0 || magnitude2 === 0) {
    return 0
  }
  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))
}

// core/util/simulate-readable-stream.ts
function simulateReadableStream({
  chunks,
  initialDelayInMs = 0,
  chunkDelayInMs = 0,
  _internal
}) {
  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++])
      } else {
        controller.close()
      }
    }
  })
}

// streams/assistant-response.ts
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()
      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
        for await (const value of stream2) {
          switch (value.event) {
            case "thread.message.created": {
              controller.enqueue(
                textEncoder.encode(
                  (0, import_ui_utils10.formatAssistantStreamPart)("assistant_message", {
                    id: value.data.id,
                    role: "assistant",
                    content: [{ type: "text", text: { value: "" } }]
                  })
                )
              )
              break
            }
            case "thread.message.delta": {
              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
            }
            case "thread.run.completed":
            case "thread.run.requires_action": {
              result = value.data
              break
            }
          }
        }
        return result
      }
      controller.enqueue(
        textEncoder.encode(
          (0, import_ui_utils10.formatAssistantStreamPart)("assistant_control_data", {
            threadId,
            messageId
          })
        )
      )
      try {
        await process2({
          sendMessage,
          sendDataMessage,
          forwardStream
        })
      } catch (error) {
        sendError((_a14 = error.message) != null ? _a14 : `${error}`)
      } finally {
        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 = {}
__export(langchain_adapter_exports, {
  mergeIntoDataStream: () => mergeIntoDataStream,
  toDataStream: () => toDataStream,
  toDataStreamResponse: () => toDataStreamResponse
})
var import_ui_utils11 = require("@ai-sdk/ui-utils")

// streams/stream-callbacks.ts
function createCallbacksTransformer(callbacks = {}) {
  const textEncoder = new TextEncoder()
  let aggregatedResponse = ""
  return new TransformStream({
    async start() {
      if (callbacks.onStart)
        await callbacks.onStart()
    },
    async transform(message, controller) {
      controller.enqueue(textEncoder.encode(message))
      aggregatedResponse += message
      if (callbacks.onToken)
        await callbacks.onToken(message)
      if (callbacks.onText && typeof message === "string") {
        await callbacks.onText(message)
      }
    },
    async flush() {
      if (callbacks.onCompletion) {
        await callbacks.onCompletion(aggregatedResponse)
      }
      if (callbacks.onFinal) {
        await callbacks.onFinal(aggregatedResponse)
      }
    }
  })
}

// streams/langchain-adapter.ts
function toDataStreamInternal(stream, callbacks) {
  return stream.pipeThrough(
    new TransformStream({
      transform: async (value, controller) => {
        var _a14
        if (typeof value === "string") {
          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
        }
        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))
      }
    })
  )
}
function toDataStream(stream, callbacks) {
  return toDataStreamInternal(stream, callbacks).pipeThrough(
    new TextEncoderStream()
  )
}
function toDataStreamResponse(stream, options) {
  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
  return new Response(responseStream, {
    status: (_a14 = init == null ? void 0 : init.status) != null ? _a14 : 200,
    statusText: init == null ? void 0 : init.statusText,
    headers: prepareResponseHeaders(init == null ? void 0 : init.headers, {
      contentType: "text/plain; charset=utf-8",
      dataStreamVersion: "v1"
    })
  })
}
function mergeIntoDataStream(stream, options) {
  options.dataStream.merge(toDataStreamInternal(stream, options.callbacks))
}
function forwardAIMessageChunk(chunk, controller) {
  if (typeof chunk.content === "string") {
    controller.enqueue(chunk.content)
  } else {
    const content = chunk.content
    for (const item of content) {
      if (item.type === "text") {
        controller.enqueue(item.text)
      }
    }
  }
}

// streams/llamaindex-adapter.ts
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")
function toDataStreamInternal2(stream, callbacks) {
  const trimStart = trimStartOfStream()
  return (0, import_provider_utils13.convertAsyncIteratorToReadableStream)(stream[Symbol.asyncIterator]()).pipeThrough(
    new TransformStream({
      async transform(message, controller) {
        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))
      }
    })
  )
}
function toDataStream2(stream, callbacks) {
  return toDataStreamInternal2(stream, callbacks).pipeThrough(
    new TextEncoderStream()
  )
}
function toDataStreamResponse2(stream, options = {}) {
  var _a14
  const { init, data, callbacks } = options
  const dataStream = toDataStreamInternal2(stream, callbacks).pipeThrough(
    new TextEncoderStream()
  )
  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,
    headers: prepareResponseHeaders(init == null ? void 0 : init.headers, {
      contentType: "text/plain; charset=utf-8",
      dataStreamVersion: "v1"
    })
  })
}
function mergeIntoDataStream2(stream, options) {
  options.dataStream.merge(toDataStreamInternal2(stream, options.callbacks))
}
function trimStartOfStream() {
  let isStreamStart = true
  return (text2) => {
    if (isStreamStart) {
      text2 = text2.trimStart()
      if (text2)
        isStreamStart = false
    }
    return text2
  }
}

// streams/stream-data.ts
var import_ui_utils13 = require("@ai-sdk/ui-utils")

// util/constants.ts
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.stream = new ReadableStream({
      start: async (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)
        }
      },
      pull: (controller) => {
      },
      cancel: (reason) => {
        this.isClosed = true
      }
    })
  }
  async close() {
    if (this.isClosed) {
      throw new Error("Data Stream has already been closed.")
    }
    if (!this.controller) {
      throw new Error("Stream controller is not initialized.")
    }
    this.controller.close()
    this.isClosed = true
    if (this.warningTimeout) {
      clearTimeout(this.warningTimeout)
    }
  }
  append(value) {
    if (this.isClosed) {
      throw new Error("Data Stream has already been closed.")
    }
    if (!this.controller) {
      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.")
    }
    if (!this.controller) {
      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:
module.exports = {
  // AISDKError,
  // APICallError,
  AssistantResponse,
  DownloadError,
  // EmptyResponseBodyError,
  InvalidArgumentError,
  InvalidDataContentError,
  InvalidMessageRoleError,
  // InvalidPromptError,
  // InvalidResponseDataError,
  InvalidToolArgumentsError,
  // JSONParseError,
  // LangChainAdapter,
  // LlamaIndexAdapter,
  // LoadAPIKeyError,
  MessageConversionError,
  // NoContentGeneratedError,
  NoObjectGeneratedError,
  NoOutputSpecifiedError,
  // NoSuchModelError,
  NoSuchProviderError,
  NoSuchToolError,
  // Output,
  RetryError,
  StreamData,
  ToolCallRepairError,
  ToolExecutionError,
  // TypeValidationError,
  // UnsupportedFunctionalityError,
  appendResponseMessages,
  convertToCoreMessages,
  cosineSimilarity,
  createDataStream,
  createDataStreamResponse,
  // createIdGenerator,
  embed,
  embedMany,
  experimental_createProviderRegistry,
  experimental_customProvider,
  // experimental_generateImage,
  experimental_wrapLanguageModel,
  // formatAssistantStreamPart,
  // formatDataStreamPart,
  // generateId,
  generateObject,
  generateText,
  // jsonSchema,
  // parseAssistantStreamPart,
  // parseDataStreamPart,
  pipeDataStreamToResponse,
  // processDataStream,
  // processTextStream,
  simulateReadableStream,
  smoothStream,
  streamObject,
  streamText,
  tool
}