ai 7.0.127 → 7.0.129

package/src/registry/provider-registry.ts

@@ -1,5 +1,5 @@
 import {
-  type Experimental_EvaluationModelV4 as EvaluationModelV4,
+  type Experimental_DecisionModelV4 as DecisionModelV4,
   type EmbeddingModelV4,
   type Experimental_VideoModelV3,
   type Experimental_VideoModelV4,
@@ -14,8 +14,12 @@ import {
   type SpeechModelV4,
   type TranscriptionModelV4,
 } from '@ai-sdk/provider';
-import type { EvaluationProvider } from '../evaluate/evaluation-provider';
-import { resolveEvaluationModel } from '../model/resolve-model';
+import type { DecisionModel } from '../decide/decision-result';
+import type { DecisionProvider } from '../decide/decision-provider';
+import {
+  resolveDecisionModel,
+  asEvaluationModel,
+} from '../model/resolve-model';
 import { wrapImageModel } from '../middleware/wrap-image-model';
 import { wrapLanguageModel } from '../middleware/wrap-language-model';
 import { asProviderV4 } from '../model/as-provider-v4';
@@ -38,7 +42,7 @@ type RegistryModelType =
   | 'speechModel'
   | 'rerankingModel'
   | 'videoModel'
-  | 'evaluationModel';
+  | 'decisionModel';
 
 type ProviderVideoModelIdentifier<PROVIDER> = PROVIDER extends {
   videoModel: (...args: infer ARGS) => unknown;
@@ -46,28 +50,40 @@ type ProviderVideoModelIdentifier<PROVIDER> = PROVIDER extends {
   ? ExtractLiteralUnion<ARGS[0]>
   : never;
 
-type ProviderEvaluationModelIdentifier<PROVIDER> = PROVIDER extends {
-  evaluationModel: (...args: infer ARGS) => unknown;
+type ProviderDecisionModelIdentifier<PROVIDER> = PROVIDER extends {
+  decisionModel: (...args: infer ARGS) => unknown;
 }
   ? ExtractLiteralUnion<ARGS[0]>
-  : never;
+  : PROVIDER extends { evaluationModel: (...args: infer ARGS) => unknown }
+    ? ExtractLiteralUnion<ARGS[0]>
+    : never;
 
-/** Registry with experimental evaluation access, separate from the stable interface. */
-export type EvaluationProviderRegistry<
+/** Registry with experimental decision access, separate from the stable interface. */
+export type DecisionProviderRegistry<
   PROVIDERS extends Record<string, ProviderV4 | ProviderV3> = Record<
     string,
     ProviderV4 | ProviderV3
   >,
   SEPARATOR extends string = ':',
 > = ProviderRegistryProvider<PROVIDERS, SEPARATOR> & {
+  decisionModel<KEY extends keyof PROVIDERS>(
+    id: KEY extends string
+      ? `${KEY & string}${SEPARATOR}${ProviderDecisionModelIdentifier<PROVIDERS[KEY]>}`
+      : never,
+  ): DecisionModelV4;
+  decisionModel<KEY extends keyof PROVIDERS>(
+    id: KEY extends string ? `${KEY & string}${SEPARATOR}${string}` : never,
+  ): DecisionModelV4;
+  /** @deprecated Use `decisionModel` instead. */
   evaluationModel<KEY extends keyof PROVIDERS>(
     id: KEY extends string
-      ? `${KEY & string}${SEPARATOR}${ProviderEvaluationModelIdentifier<PROVIDERS[KEY]>}`
+      ? `${KEY & string}${SEPARATOR}${ProviderDecisionModelIdentifier<PROVIDERS[KEY]>}`
       : never,
-  ): EvaluationModelV4;
+  ): DecisionModelV4 & { doEvaluate: DecisionModelV4['doDecide'] };
+  /** @deprecated Use `decisionModel` instead. */
   evaluationModel<KEY extends keyof PROVIDERS>(
     id: KEY extends string ? `${KEY & string}${SEPARATOR}${string}` : never,
-  ): EvaluationModelV4;
+  ): DecisionModelV4 & { doEvaluate: DecisionModelV4['doDecide'] };
 };
 
 export interface ProviderRegistryProvider<
@@ -178,7 +194,7 @@ export function createProviderRegistry<
       | LanguageModelMiddleware[];
     imageModelMiddleware?: ImageModelMiddleware | ImageModelMiddleware[];
   } = {},
-): EvaluationProviderRegistry<PROVIDERS, SEPARATOR> {
+): DecisionProviderRegistry<PROVIDERS, SEPARATOR> {
   const registry = new DefaultProviderRegistry<PROVIDERS, SEPARATOR>({
     separator,
     languageModelMiddleware,
@@ -206,12 +222,12 @@ class DefaultProviderRegistry<
 >
   implements
     ProviderRegistryProvider<PROVIDERS, SEPARATOR>,
-    EvaluationProviderRegistry<PROVIDERS, SEPARATOR>
+    DecisionProviderRegistry<PROVIDERS, SEPARATOR>
 {
   private providers: Partial<
     Record<
       keyof PROVIDERS,
-      ProviderV4 & ProviderWithOptionalVideoModel & EvaluationProvider
+      ProviderV4 & ProviderWithOptionalVideoModel & DecisionProvider
     >
   > = Object.create(null);
   private separator: SEPARATOR;
@@ -248,9 +264,10 @@ class DefaultProviderRegistry<
       provider as ProviderWithOptionalVideoModel
     ).videoModel?.bind(provider);
 
-    const evaluationModel = (
-      provider as EvaluationProvider
-    ).evaluationModel?.bind(provider);
+    const decisionProvider = provider as DecisionProvider;
+    const decisionModel = (
+      decisionProvider.decisionModel ?? decisionProvider.evaluationModel
+    )?.bind(provider);
 
     const registeredProvider =
       videoModel == null
@@ -261,9 +278,9 @@ class DefaultProviderRegistry<
               asVideoModelV4(videoModel(modelId)),
           });
 
-    // Keep v4 instances intact. Adapted providers need the original evaluation receiver.
-    if (registeredProvider !== provider && evaluationModel != null) {
-      Object.assign(registeredProvider, { evaluationModel });
+    // Keep v4 instances intact. Adapted providers need the original decision receiver.
+    if (registeredProvider !== provider && decisionModel != null) {
+      Object.assign(registeredProvider, { decisionModel });
     }
     this.providers[id] = registeredProvider;
   }
@@ -271,7 +288,7 @@ class DefaultProviderRegistry<
   private getProvider(
     id: string,
     modelType: RegistryModelType,
-  ): ProviderV4 & ProviderWithOptionalVideoModel & EvaluationProvider {
+  ): ProviderV4 & ProviderWithOptionalVideoModel & DecisionProvider {
     const provider = this.providers[id as keyof PROVIDERS];
 
     if (provider == null) {
@@ -427,18 +444,28 @@ class DefaultProviderRegistry<
     return asVideoModelV4(model);
   }
 
-  evaluationModel<KEY extends keyof PROVIDERS>(
+  decisionModel<KEY extends keyof PROVIDERS>(
     id: `${KEY & string}${SEPARATOR}${string}`,
-  ): EvaluationModelV4 {
-    const [providerId, modelId] = this.splitId(id, 'evaluationModel');
-    const provider = this.getProvider(providerId, 'evaluationModel');
-    const model = provider.evaluationModel?.(modelId);
+  ): DecisionModelV4 {
+    const [providerId, modelId] = this.splitId(id, 'decisionModel');
+    const provider = this.getProvider(providerId, 'decisionModel');
+    const factory:
+      | ((modelId: string) => Exclude<DecisionModel, string>)
+      | undefined = provider.decisionModel ?? provider.evaluationModel;
+    const model = factory?.call(provider, modelId);
 
     if (model == null) {
-      throw new NoSuchModelError({ modelId: id, modelType: 'evaluationModel' });
+      throw new NoSuchModelError({ modelId: id, modelType: 'decisionModel' });
     }
 
-    return resolveEvaluationModel(model);
+    return resolveDecisionModel(model);
+  }
+
+  /** @deprecated Use `decisionModel` instead. */
+  evaluationModel<KEY extends keyof PROVIDERS>(
+    id: `${KEY & string}${SEPARATOR}${string}`,
+  ) {
+    return asEvaluationModel(this.decisionModel(id));
   }
 
   files<KEY extends keyof PROVIDERS>(id: KEY & string): FilesV4 {

package/src/telemetry/create-telemetry-dispatcher.ts

@@ -142,10 +142,18 @@ export function createTelemetryDispatcher({
 
   const mergeTelemetryCallback = <KEY extends TelemetryCallbackKey>(
     key: KEY,
+    deprecatedKey?: keyof Telemetry,
   ): Callback<TelemetryEvent<KEY>> | undefined => {
     const integrationCallbacks = (
       integrations
-        .map(integration => integration[key]?.bind(integration))
+        .map(integration => {
+          const callback =
+            integration[key] ??
+            (deprecatedKey == null ? undefined : integration[deprecatedKey]);
+          return typeof callback === 'function'
+            ? callback.bind(integration)
+            : undefined;
+        })
         .filter(Boolean) as Array<
         Callback<InferTelemetryEvent<TelemetryEvent<KEY>>>
       >
@@ -222,16 +230,20 @@ export function createTelemetryDispatcher({
     onEmbedEnd: mergeTelemetryCallback('onEmbedEnd'),
     onRerankStart: mergeTelemetryCallback('onRerankStart'),
     onRerankEnd: mergeTelemetryCallback('onRerankEnd'),
-    experimental_onEvaluateStart: mergeTelemetryCallback(
+    experimental_onDecideStart: mergeTelemetryCallback(
+      'experimental_onDecideStart',
       'experimental_onEvaluateStart',
     ),
-    experimental_onEvaluationModelCallStart: mergeTelemetryCallback(
+    experimental_onDecisionModelCallStart: mergeTelemetryCallback(
+      'experimental_onDecisionModelCallStart',
       'experimental_onEvaluationModelCallStart',
     ),
-    experimental_onEvaluationModelCallEnd: mergeTelemetryCallback(
+    experimental_onDecisionModelCallEnd: mergeTelemetryCallback(
+      'experimental_onDecisionModelCallEnd',
       'experimental_onEvaluationModelCallEnd',
     ),
-    experimental_onEvaluateEnd: mergeTelemetryCallback(
+    experimental_onDecideEnd: mergeTelemetryCallback(
+      'experimental_onDecideEnd',
       'experimental_onEvaluateEnd',
     ),
     experimental_onStreamTranscriptionStart: mergeTelemetryCallback(

package/src/telemetry/telemetry.ts

@@ -6,11 +6,11 @@ import type {
   EmbeddingModelCallStartEvent,
 } from '../embed/embed-events';
 import type {
-  EvaluateEndEvent,
-  EvaluateStartEvent,
-  EvaluationModelCallEndEvent,
-  EvaluationModelCallStartEvent,
-} from '../evaluate/evaluate-events';
+  DecideEndEvent,
+  DecideStartEvent,
+  DecisionModelCallEndEvent,
+  DecisionModelCallStartEvent,
+} from '../decide/decide-events';
 import type {
   GenerateObjectEndEvent,
   GenerateObjectStartEvent,
@@ -116,10 +116,10 @@ export interface TelemetryDispatcher {
   onEmbedEnd?: Callback<EmbeddingModelCallEndEvent>;
   onRerankStart?: Callback<RerankingModelCallStartEvent>;
   onRerankEnd?: Callback<RerankingModelCallEndEvent>;
-  experimental_onEvaluateStart?: Callback<EvaluateStartEvent>;
-  experimental_onEvaluationModelCallStart?: Callback<EvaluationModelCallStartEvent>;
-  experimental_onEvaluationModelCallEnd?: Callback<EvaluationModelCallEndEvent>;
-  experimental_onEvaluateEnd?: Callback<EvaluateEndEvent>;
+  experimental_onDecideStart?: Callback<DecideStartEvent>;
+  experimental_onDecisionModelCallStart?: Callback<DecisionModelCallStartEvent>;
+  experimental_onDecisionModelCallEnd?: Callback<DecisionModelCallEndEvent>;
+  experimental_onDecideEnd?: Callback<DecideEndEvent>;
   experimental_onStreamTranscriptionStart?: Callback<StreamTranscriptionStartEvent>;
   experimental_onStreamTranscriptionEnd?: Callback<StreamTranscriptionEndEvent>;
   onEnd?: Callback<OperationEndEvent>;
@@ -245,29 +245,45 @@ export interface Telemetry {
    */
   onRerankEnd?: Callback<InferTelemetryEvent<RerankingModelCallEndEvent>>;
 
-  /** Called when an experimental evaluation operation begins. */
+  /** @deprecated Use `experimental_onDecideStart` instead. */
   experimental_onEvaluateStart?: Callback<
-    InferTelemetryEvent<EvaluateStartEvent>
+    InferTelemetryEvent<DecideStartEvent>
   >;
 
+  /** @deprecated Use `experimental_onDecisionModelCallStart` instead. */
+  experimental_onEvaluationModelCallStart?: Callback<
+    InferTelemetryEvent<DecisionModelCallStartEvent>
+  >;
+
+  /** @deprecated Use `experimental_onDecisionModelCallEnd` instead. */
+  experimental_onEvaluationModelCallEnd?: Callback<
+    InferTelemetryEvent<DecisionModelCallEndEvent>
+  >;
+
+  /** @deprecated Use `experimental_onDecideEnd` instead. */
+  experimental_onEvaluateEnd?: Callback<InferTelemetryEvent<DecideEndEvent>>;
+
+  /** Called when an experimental decision operation begins. */
+  experimental_onDecideStart?: Callback<InferTelemetryEvent<DecideStartEvent>>;
+
   /**
-   * Called immediately before an experimental evaluation model call begins.
+   * Called immediately before an experimental decision model call begins.
    * The logical model call includes any provider retries.
    */
-  experimental_onEvaluationModelCallStart?: Callback<
-    InferTelemetryEvent<EvaluationModelCallStartEvent>
+  experimental_onDecisionModelCallStart?: Callback<
+    InferTelemetryEvent<DecisionModelCallStartEvent>
   >;
 
   /**
-   * Called after an experimental evaluation model response has been validated.
+   * Called after an experimental decision model response has been validated.
    * The logical model call includes any provider retries.
    */
-  experimental_onEvaluationModelCallEnd?: Callback<
-    InferTelemetryEvent<EvaluationModelCallEndEvent>
+  experimental_onDecisionModelCallEnd?: Callback<
+    InferTelemetryEvent<DecisionModelCallEndEvent>
   >;
 
-  /** Called when an experimental evaluation operation completes. */
-  experimental_onEvaluateEnd?: Callback<InferTelemetryEvent<EvaluateEndEvent>>;
+  /** Called when an experimental decision operation completes. */
+  experimental_onDecideEnd?: Callback<InferTelemetryEvent<DecideEndEvent>>;
 
   /** Called when an experimental streaming transcription operation begins. */
   experimental_onStreamTranscriptionStart?: Callback<

package/src/telemetry/tracing-channel.ts

@@ -12,7 +12,7 @@ export type TelemetryTracingEventType =
   | 'generateSpeech'
   | 'transcribe'
   | 'streamTranscribe'
-  | 'experimental_evaluate';
+  | 'experimental_decide';
 
 export type TelemetryTracingChannelMessage<EVENT = unknown> = {
   readonly type: TelemetryTracingEventType;

package/src/test/decision-mock-model-v4.ts

@@ -0,0 +1,35 @@
+import type { Experimental_DecisionModelV4 as DecisionModelV4 } from '@ai-sdk/provider';
+import { notImplemented } from './not-implemented';
+
+export class DecisionMockModelV4 implements DecisionModelV4 {
+  readonly specificationVersion = 'v4';
+  readonly provider: string;
+  readonly modelId: string;
+  readonly supportedQuestionTypes: DecisionModelV4['supportedQuestionTypes'];
+  doDecide: DecisionModelV4['doDecide'];
+
+  /** @deprecated Use `doDecide` instead. */
+  doEvaluate(options: Parameters<DecisionModelV4['doDecide']>[0]) {
+    return this.doDecide(options);
+  }
+
+  constructor({
+    provider = 'mock-provider',
+    modelId = 'mock-model-id',
+    supportedQuestionTypes = ['choice', 'score', 'boolean'],
+    doDecide,
+    doEvaluate,
+  }: {
+    provider?: string;
+    modelId?: string;
+    supportedQuestionTypes?: DecisionModelV4['supportedQuestionTypes'];
+    doDecide?: DecisionModelV4['doDecide'];
+    /** @deprecated Use `doDecide` instead. */
+    doEvaluate?: DecisionModelV4['doDecide'];
+  } = {}) {
+    this.provider = provider;
+    this.modelId = modelId;
+    this.supportedQuestionTypes = supportedQuestionTypes;
+    this.doDecide = doDecide ?? doEvaluate ?? notImplemented;
+  }
+}

package/src/transcribe/index.ts

@@ -1,5 +1,6 @@
 import type { TranscriptionResult } from './transcribe-result';
 import { transcribe } from './transcribe';
+import { logWarnings } from '../logger/log-warnings';
 
 export { transcribe } from './transcribe';
 export { streamTranscribe as experimental_streamTranscribe } from './stream-transcribe';
@@ -20,7 +21,18 @@ export type {
 /**
  * @deprecated Use `transcribe` instead.
  */
-const experimental_transcribe = transcribe;
+const experimental_transcribe: typeof transcribe = options => {
+  logWarnings({
+    warnings: [
+      {
+        type: 'deprecated',
+        setting: 'experimental_transcribe',
+        message: 'Use transcribe instead.',
+      },
+    ],
+  });
+  return transcribe(options);
+};
 export { experimental_transcribe };
 
 /**

package/src/transcribe/transcribe.ts

@@ -256,7 +256,7 @@ export async function transcribe({
           model: resolvedModel.modelId,
         });
 
-        if (!result.text) {
+        if (result.text == null) {
           throw new NoTranscriptGeneratedError({
             responses: [result.response],
           });

package/src/types/index.ts

@@ -7,6 +7,7 @@ export type { ImageModelResponseMetadata } from './image-model-response-metadata
 export type { JSONValue } from './json-value';
 export type {
   CallWarning,
+  CallWarningRegistry,
   FinishReason,
   LanguageModel,
   ToolChoice,

package/src/types/language-model.ts

@@ -80,11 +80,19 @@ export type FinishReason =
   | 'error'
   | 'other';
 
+/**
+ * Registry for call warning variants. Packages that expose additional warning
+ * protocols can augment this interface.
+ */
+export interface CallWarningRegistry {
+  sharedV4: SharedV4Warning;
+}
+
 /**
  * Warning from the model provider for this call. The call will proceed, but e.g.
  * some settings might not be supported, which can lead to suboptimal results.
  */
-export type CallWarning = SharedV4Warning;
+export type CallWarning = CallWarningRegistry[keyof CallWarningRegistry];
 
 /**
  * A source that has been used as input to generate the response.

package/src/types/usage.ts

@@ -123,6 +123,12 @@ export function addLanguageModelUsage(
   usage1: LanguageModelUsage,
   usage2: LanguageModelUsage,
 ): LanguageModelUsage {
+  const raw = isNullLanguageModelUsage(usage1)
+    ? usage2.raw
+    : isNullLanguageModelUsage(usage2)
+      ? usage1.raw
+      : undefined;
+
   return {
     inputTokens: addTokenCounts(usage1.inputTokens, usage2.inputTokens),
     inputTokenDetails: {
@@ -151,9 +157,24 @@ export function addLanguageModelUsage(
       ),
     },
     totalTokens: addTokenCounts(usage1.totalTokens, usage2.totalTokens),
+    ...(raw == null ? {} : { raw }),
   };
 }
 
+function isNullLanguageModelUsage(usage: LanguageModelUsage): boolean {
+  return (
+    usage.inputTokens == null &&
+    usage.inputTokenDetails?.noCacheTokens == null &&
+    usage.inputTokenDetails?.cacheReadTokens == null &&
+    usage.inputTokenDetails?.cacheWriteTokens == null &&
+    usage.outputTokens == null &&
+    usage.outputTokenDetails?.textTokens == null &&
+    usage.outputTokenDetails?.reasoningTokens == null &&
+    usage.totalTokens == null &&
+    usage.raw == null
+  );
+}
+
 function addTokenCounts(
   tokenCount1: number | undefined,
   tokenCount2: number | undefined,

package/src/ui/chat.ts

@@ -315,7 +315,12 @@ export abstract class AbstractChat<UI_MESSAGE extends UIMessage> {
     status: ChatStatus;
     error?: Error;
   }) {
-    if (this.status === status) return;
+    if (this.status === status) {
+      if (this.error !== error) {
+        this.state.error = error;
+      }
+      return;
+    }
 
     this.state.status = status;
     this.state.error = error;
@@ -849,11 +854,18 @@ export abstract class AbstractChat<UI_MESSAGE extends UIMessage> {
       responseMessageIndex === -1
         ? lastMessage
         : this.state.messages[responseMessageIndex];
+    // the continued stream can start with either
+    // 1) input deltas
+    // 2) or the result of an answered tool approval request
+    // Keep the tool part so in case 2, those chunks can find their tool call
     const resumableResponseMessage =
       trigger === 'resume-stream' &&
       responseMessage?.role === 'assistant' &&
       responseMessage.parts.some(
-        part => isToolUIPart(part) && part.state === 'input-streaming',
+        part =>
+          isToolUIPart(part) &&
+          (part.state === 'input-streaming' ||
+            part.state === 'approval-responded'),
       )
         ? this.state.snapshot(responseMessage)
         : undefined;
@@ -952,6 +964,7 @@ export abstract class AbstractChat<UI_MESSAGE extends UIMessage> {
       await consumeStream({
         stream: processUIMessageStream({
           stream,
+          resetStateOnMessageIdChange: trigger === 'resume-stream',
           onToolCall: this.onToolCall,
           onData: this.onData,
           messageMetadataSchema: this.messageMetadataSchema,
@@ -1002,13 +1015,16 @@ export abstract class AbstractChat<UI_MESSAGE extends UIMessage> {
 
       isError = true;
 
-      // Network errors such as disconnected, timeout, etc.
-      if (
-        err instanceof TypeError &&
-        (err.message.toLowerCase().includes('fetch') ||
-          err.message.toLowerCase().includes('network'))
-      ) {
-        isDisconnect = true;
+      if (err instanceof TypeError) {
+        const message = err.message.toLowerCase();
+
+        isDisconnect =
+          // Chromium request failures; Node.js fetch failures.
+          message.includes('fetch') ||
+          // Firefox request failures; Chromium response-body failures.
+          message.includes('network') ||
+          // Safari/WebKit request and response-body failures.
+          message === 'load failed';
       }
 
       if (isDisconnect) {

package/src/ui/convert-to-model-messages.ts

@@ -33,6 +33,7 @@ import {
   type ToolUIPart,
   type UIMessage,
 } from './ui-messages';
+import { isToolPartFromUnavailableTool } from './unavailable-tool';
 import { warnIfUIMessageHasDeprecatedRawInput } from './warn-if-ui-message-has-deprecated-raw-input';
 /**
  * Converts an array of UI messages from useChat into an array of ModelMessages that can be used
@@ -85,6 +86,39 @@ export async function convertToModelMessages<UI_MESSAGE extends UIMessage>(
     }));
   }
 
+  async function createModelOutput({
+    toolPart,
+    toolName,
+    output,
+    errorMode,
+  }: {
+    toolPart: ToolUIPart<InferUIMessageTools<UI_MESSAGE>> | DynamicToolUIPart;
+    toolName: string;
+    output: unknown;
+    errorMode: 'none' | 'text' | 'json';
+  }) {
+    const tool = getOwn(options?.tools, toolName);
+
+    if (
+      errorMode === 'none' &&
+      tool == null &&
+      isToolPartFromUnavailableTool(toolPart)
+    ) {
+      return {
+        type: 'text' as const,
+        value: 'Tool output omitted because the tool is no longer available.',
+      };
+    }
+
+    return createToolModelOutput({
+      toolCallId: toolPart.toolCallId,
+      input: toolPart.input,
+      output,
+      tool,
+      errorMode,
+    });
+  }
+
   for (const message of messages) {
     switch (message.role) {
       case 'system': {
@@ -284,14 +318,13 @@ export async function convertToModelMessages<UI_MESSAGE extends UIMessage>(
                       type: 'tool-result',
                       toolCallId: part.toolCallId,
                       toolName,
-                      output: await createToolModelOutput({
-                        toolCallId: part.toolCallId,
-                        input: part.input,
+                      output: await createModelOutput({
+                        toolPart: part,
+                        toolName,
                         output:
                           part.state === 'output-error'
                             ? part.errorText
                             : part.output,
-                        tool: getOwn(options?.tools, toolName),
                         errorMode:
                           part.state === 'output-error' ? 'json' : 'none',
                       }),
@@ -403,14 +436,13 @@ export async function convertToModelMessages<UI_MESSAGE extends UIMessage>(
                         type: 'tool-result',
                         toolCallId: toolPart.toolCallId,
                         toolName,
-                        output: await createToolModelOutput({
-                          toolCallId: toolPart.toolCallId,
-                          input: toolPart.input,
+                        output: await createModelOutput({
+                          toolPart,
+                          toolName,
                           output:
                             toolPart.state === 'output-error'
                               ? toolPart.errorText
                               : toolPart.output,
-                          tool: getOwn(options?.tools, toolName),
                           errorMode:
                             toolPart.state === 'output-error' ? 'text' : 'none',
                         }),

package/src/ui/http-chat-transport.ts

@@ -13,10 +13,12 @@ import type { UIMessage } from './ui-messages';
 
 function appendPathToUrl(url: string, path: string): string {
   const queryOrFragmentStart = url.search(/[?#]/);
+  const urlPath =
+    queryOrFragmentStart === -1 ? url : url.slice(0, queryOrFragmentStart);
+  const suffix =
+    queryOrFragmentStart === -1 ? '' : url.slice(queryOrFragmentStart);
 
-  return queryOrFragmentStart === -1
-    ? `${url}${path}`
-    : `${url.slice(0, queryOrFragmentStart)}${path}${url.slice(queryOrFragmentStart)}`;
+  return `${urlPath.endsWith('/') && path.startsWith('/') ? urlPath.slice(0, -1) : urlPath}${path}${suffix}`;
 }
 
 export type PrepareSendMessagesRequest<UI_MESSAGE extends UIMessage> = (

package/src/ui/process-text-stream.ts

@@ -5,7 +5,11 @@ export async function processTextStream({
   stream: ReadableStream<Uint8Array>;
   onTextPart: (chunk: string) => Promise<void> | void;
 }): Promise<void> {
-  const reader = stream.pipeThrough(new TextDecoderStream()).getReader();
+  const reader = stream
+    .pipeThrough(
+      new TextDecoderStream() as ReadableWritablePair<string, Uint8Array>,
+    )
+    .getReader();
   while (true) {
     const { done, value } = await reader.read();
     if (done) {