@depup/ai 6.0.116-depup.0

package/src/generate-text/run-tools-transformation.ts

@@ -0,0 +1,442 @@
+import { LanguageModelV3StreamPart, SharedV3Warning } from '@ai-sdk/provider';
+import {
+  getErrorMessage,
+  IdGenerator,
+  ModelMessage,
+  SystemModelMessage,
+} from '@ai-sdk/provider-utils';
+import { Tracer } from '@opentelemetry/api';
+import { ToolCallNotFoundForApprovalError } from '../error/tool-call-not-found-for-approval-error';
+import { TelemetrySettings } from '../telemetry/telemetry-settings';
+import { FinishReason, LanguageModelUsage, ProviderMetadata } from '../types';
+import { Source } from '../types/language-model';
+import { asLanguageModelUsage } from '../types/usage';
+import { executeToolCall } from './execute-tool-call';
+import {
+  StreamTextOnToolCallFinishCallback,
+  StreamTextOnToolCallStartCallback,
+} from './stream-text';
+import { DefaultGeneratedFileWithType, GeneratedFile } from './generated-file';
+import { isApprovalNeeded } from './is-approval-needed';
+import { parseToolCall } from './parse-tool-call';
+import { ToolApprovalRequestOutput } from './tool-approval-request-output';
+import { TypedToolCall } from './tool-call';
+import { ToolCallRepairFunction } from './tool-call-repair-function';
+import { TypedToolError } from './tool-error';
+import { TypedToolResult } from './tool-result';
+import { ToolSet } from './tool-set';
+
+export type SingleRequestTextStreamPart<TOOLS extends ToolSet> =
+  // Text blocks:
+  | {
+      type: 'text-start';
+      providerMetadata?: ProviderMetadata;
+      id: string;
+    }
+  | {
+      type: 'text-delta';
+      id: string;
+      providerMetadata?: ProviderMetadata;
+      delta: string;
+    }
+  | {
+      type: 'text-end';
+      providerMetadata?: ProviderMetadata;
+      id: string;
+    }
+
+  // Reasoning blocks:
+  | {
+      type: 'reasoning-start';
+      providerMetadata?: ProviderMetadata;
+      id: string;
+    }
+  | {
+      type: 'reasoning-delta';
+      id: string;
+      providerMetadata?: ProviderMetadata;
+      delta: string;
+    }
+  | {
+      type: 'reasoning-end';
+      id: string;
+      providerMetadata?: ProviderMetadata;
+    }
+
+  // Tool calls:
+  | {
+      type: 'tool-input-start';
+      id: string;
+      toolName: string;
+      providerMetadata?: ProviderMetadata;
+      dynamic?: boolean;
+      title?: string;
+    }
+  | {
+      type: 'tool-input-delta';
+      id: string;
+      delta: string;
+      providerMetadata?: ProviderMetadata;
+    }
+  | {
+      type: 'tool-input-end';
+      id: string;
+      providerMetadata?: ProviderMetadata;
+    }
+  | ToolApprovalRequestOutput<TOOLS>
+
+  // Other types:
+  | ({ type: 'source' } & Source)
+  | { type: 'file'; file: GeneratedFile; providerMetadata?: ProviderMetadata } // different because of GeneratedFile object
+  | ({ type: 'tool-call' } & TypedToolCall<TOOLS>)
+  | ({ type: 'tool-result' } & TypedToolResult<TOOLS>)
+  | ({ type: 'tool-error' } & TypedToolError<TOOLS>)
+  | { type: 'stream-start'; warnings: SharedV3Warning[] }
+  | {
+      type: 'response-metadata';
+      id?: string;
+      timestamp?: Date;
+      modelId?: string;
+    }
+  | {
+      type: 'finish';
+      finishReason: FinishReason;
+      rawFinishReason: string | undefined;
+      usage: LanguageModelUsage;
+      providerMetadata?: ProviderMetadata;
+    }
+  | { type: 'error'; error: unknown }
+  | { type: 'raw'; rawValue: unknown };
+
+export function runToolsTransformation<TOOLS extends ToolSet>({
+  tools,
+  generatorStream,
+  tracer,
+  telemetry,
+  system,
+  messages,
+  abortSignal,
+  repairToolCall,
+  experimental_context,
+  generateId,
+  stepNumber,
+  model,
+  onToolCallStart,
+  onToolCallFinish,
+}: {
+  tools: TOOLS | undefined;
+  generatorStream: ReadableStream<LanguageModelV3StreamPart>;
+  tracer: Tracer;
+  telemetry: TelemetrySettings | undefined;
+  system: string | SystemModelMessage | Array<SystemModelMessage> | undefined;
+  messages: ModelMessage[];
+  abortSignal: AbortSignal | undefined;
+  repairToolCall: ToolCallRepairFunction<TOOLS> | undefined;
+  experimental_context: unknown;
+  generateId: IdGenerator;
+  stepNumber?: number;
+  model?: { provider: string; modelId: string };
+  onToolCallStart?:
+    | StreamTextOnToolCallStartCallback<TOOLS>
+    | Array<StreamTextOnToolCallStartCallback<TOOLS> | undefined | null>;
+  onToolCallFinish?:
+    | StreamTextOnToolCallFinishCallback<TOOLS>
+    | Array<StreamTextOnToolCallFinishCallback<TOOLS> | undefined | null>;
+}): ReadableStream<SingleRequestTextStreamPart<TOOLS>> {
+  // tool results stream
+  let toolResultsStreamController: ReadableStreamDefaultController<
+    SingleRequestTextStreamPart<TOOLS>
+  > | null = null;
+  const toolResultsStream = new ReadableStream<
+    SingleRequestTextStreamPart<TOOLS>
+  >({
+    start(controller) {
+      toolResultsStreamController = controller;
+    },
+  });
+
+  // keep track of outstanding tool results for stream closing:
+  const outstandingToolResults = new Set<string>();
+
+  // keep track of tool inputs for provider-side tool results
+  const toolInputs = new Map<string, unknown>();
+
+  // keep track of parsed tool calls so provider-emitted approval requests can reference them
+  const toolCallsByToolCallId = new Map<string, TypedToolCall<TOOLS>>();
+
+  let canClose = false;
+  let finishChunk:
+    | (SingleRequestTextStreamPart<TOOLS> & { type: 'finish' })
+    | undefined = undefined;
+
+  function attemptClose() {
+    // close the tool results controller if no more outstanding tool calls
+    if (canClose && outstandingToolResults.size === 0) {
+      // we delay sending the finish chunk until all tool results (incl. delayed ones)
+      // are received to ensure that the frontend receives tool results before a message
+      // finish event arrives.
+      if (finishChunk != null) {
+        toolResultsStreamController!.enqueue(finishChunk);
+      }
+
+      toolResultsStreamController!.close();
+    }
+  }
+
+  // forward stream
+  const forwardStream = new TransformStream<
+    LanguageModelV3StreamPart,
+    SingleRequestTextStreamPart<TOOLS>
+  >({
+    async transform(
+      chunk: LanguageModelV3StreamPart,
+      controller: TransformStreamDefaultController<
+        SingleRequestTextStreamPart<TOOLS>
+      >,
+    ) {
+      const chunkType = chunk.type;
+
+      switch (chunkType) {
+        // forward:
+        case 'stream-start':
+        case 'text-start':
+        case 'text-delta':
+        case 'text-end':
+        case 'reasoning-start':
+        case 'reasoning-delta':
+        case 'reasoning-end':
+        case 'tool-input-start':
+        case 'tool-input-delta':
+        case 'tool-input-end':
+        case 'source':
+        case 'response-metadata':
+        case 'error':
+        case 'raw': {
+          controller.enqueue(chunk);
+          break;
+        }
+
+        case 'file': {
+          controller.enqueue({
+            type: 'file',
+            file: new DefaultGeneratedFileWithType({
+              data: chunk.data,
+              mediaType: chunk.mediaType,
+            }),
+            ...(chunk.providerMetadata != null
+              ? { providerMetadata: chunk.providerMetadata }
+              : {}),
+          });
+          break;
+        }
+
+        case 'finish': {
+          finishChunk = {
+            type: 'finish',
+            finishReason: chunk.finishReason.unified,
+            rawFinishReason: chunk.finishReason.raw,
+            usage: asLanguageModelUsage(chunk.usage),
+            providerMetadata: chunk.providerMetadata,
+          };
+          break;
+        }
+
+        case 'tool-approval-request': {
+          const toolCall = toolCallsByToolCallId.get(chunk.toolCallId);
+          if (toolCall == null) {
+            toolResultsStreamController!.enqueue({
+              type: 'error',
+              error: new ToolCallNotFoundForApprovalError({
+                toolCallId: chunk.toolCallId,
+                approvalId: chunk.approvalId,
+              }),
+            });
+            break;
+          }
+
+          controller.enqueue({
+            type: 'tool-approval-request',
+            approvalId: chunk.approvalId,
+            toolCall,
+          });
+          break;
+        }
+
+        // process tool call:
+        case 'tool-call': {
+          try {
+            const toolCall = await parseToolCall({
+              toolCall: chunk,
+              tools,
+              repairToolCall,
+              system,
+              messages,
+            });
+
+            toolCallsByToolCallId.set(toolCall.toolCallId, toolCall);
+            controller.enqueue(toolCall);
+
+            if (toolCall.invalid) {
+              toolResultsStreamController!.enqueue({
+                type: 'tool-error',
+                toolCallId: toolCall.toolCallId,
+                toolName: toolCall.toolName,
+                input: toolCall.input,
+                error: getErrorMessage(toolCall.error!),
+                dynamic: true,
+                title: toolCall.title,
+              });
+              break;
+            }
+
+            const tool = tools?.[toolCall.toolName];
+
+            if (tool == null) {
+              // ignore tool calls for tools that are not available,
+              // e.g. provider-executed dynamic tools
+              break;
+            }
+
+            if (tool.onInputAvailable != null) {
+              await tool.onInputAvailable({
+                input: toolCall.input,
+                toolCallId: toolCall.toolCallId,
+                messages,
+                abortSignal,
+                experimental_context,
+              });
+            }
+
+            if (
+              await isApprovalNeeded({
+                tool,
+                toolCall,
+                messages,
+                experimental_context,
+              })
+            ) {
+              toolResultsStreamController!.enqueue({
+                type: 'tool-approval-request',
+                approvalId: generateId(),
+                toolCall,
+              });
+              break;
+            }
+
+            toolInputs.set(toolCall.toolCallId, toolCall.input);
+
+            // Only execute tools that are not provider-executed:
+            if (tool.execute != null && toolCall.providerExecuted !== true) {
+              const toolExecutionId = generateId(); // use our own id to guarantee uniqueness
+              outstandingToolResults.add(toolExecutionId);
+
+              // Note: we don't await the tool execution here (by leaving out 'await' on recordSpan),
+              // because we want to process the next chunk as soon as possible.
+              // This is important for the case where the tool execution takes a long time.
+              executeToolCall({
+                toolCall,
+                tools,
+                tracer,
+                telemetry,
+                messages,
+                abortSignal,
+                experimental_context,
+                stepNumber,
+                model,
+                onToolCallStart,
+                onToolCallFinish,
+                onPreliminaryToolResult: result => {
+                  toolResultsStreamController!.enqueue(result);
+                },
+              })
+                .then(result => {
+                  toolResultsStreamController!.enqueue(result);
+                })
+                .catch(error => {
+                  toolResultsStreamController!.enqueue({
+                    type: 'error',
+                    error,
+                  });
+                })
+                .finally(() => {
+                  outstandingToolResults.delete(toolExecutionId);
+                  attemptClose();
+                });
+            }
+          } catch (error) {
+            toolResultsStreamController!.enqueue({ type: 'error', error });
+          }
+
+          break;
+        }
+
+        case 'tool-result': {
+          const toolName = chunk.toolName as keyof TOOLS & string;
+
+          if (chunk.isError) {
+            toolResultsStreamController!.enqueue({
+              type: 'tool-error',
+              toolCallId: chunk.toolCallId,
+              toolName,
+              input: toolInputs.get(chunk.toolCallId),
+              providerExecuted: true,
+              error: chunk.result,
+              dynamic: chunk.dynamic,
+            } as TypedToolError<TOOLS>);
+          } else {
+            controller.enqueue({
+              type: 'tool-result',
+              toolCallId: chunk.toolCallId,
+              toolName,
+              input: toolInputs.get(chunk.toolCallId),
+              output: chunk.result,
+              providerExecuted: true,
+              dynamic: chunk.dynamic,
+            } as TypedToolResult<TOOLS>);
+          }
+          break;
+        }
+
+        default: {
+          const _exhaustiveCheck: never = chunkType;
+          throw new Error(`Unhandled chunk type: ${_exhaustiveCheck}`);
+        }
+      }
+    },
+
+    flush() {
+      canClose = true;
+      attemptClose();
+    },
+  });
+
+  // combine the generator stream and the tool results stream
+  return new ReadableStream<SingleRequestTextStreamPart<TOOLS>>({
+    async start(controller) {
+      // need to wait for both pipes so there are no dangling promises that
+      // can cause uncaught promise rejections when the stream is aborted
+      return Promise.all([
+        generatorStream.pipeThrough(forwardStream).pipeTo(
+          new WritableStream({
+            write(chunk) {
+              controller.enqueue(chunk);
+            },
+            close() {
+              // the generator stream controller is automatically closed when it's consumed
+            },
+          }),
+        ),
+        toolResultsStream.pipeTo(
+          new WritableStream({
+            write(chunk) {
+              controller.enqueue(chunk);
+            },
+            close() {
+              controller.close();
+            },
+          }),
+        ),
+      ]);
+    },
+  });
+}

package/src/generate-text/smooth-stream.ts

@@ -0,0 +1,162 @@
+import { delay as originalDelay } from '@ai-sdk/provider-utils';
+import { SharedV3ProviderMetadata } from '@ai-sdk/provider';
+import { TextStreamPart } from './stream-text-result';
+import { ToolSet } from './tool-set';
+import { InvalidArgumentError } from '@ai-sdk/provider';
+
+const CHUNKING_REGEXPS = {
+  word: /\S+\s+/m,
+  line: /\n+/m,
+};
+
+/**
+ * Detects the first chunk in a buffer.
+ *
+ * @param buffer - The buffer to detect the first chunk in.
+ *
+ * @returns The first detected chunk, or `undefined` if no chunk was detected.
+ */
+export type ChunkDetector = (buffer: string) => string | undefined | null;
+
+/**
+ * Smooths text and reasoning streaming output.
+ *
+ * @param delayInMs - The delay in milliseconds between each chunk. Defaults to 10ms. Can be set to `null` to skip the delay.
+ * @param chunking - Controls how the text is chunked for streaming. Use "word" to stream word by word (default), "line" to stream line by line, provide a custom RegExp pattern for custom chunking, provide an Intl.Segmenter for locale-aware word segmentation (recommended for CJK languages), or provide a custom ChunkDetector function.
+ *
+ * @returns A transform stream that smooths text streaming output.
+ */
+export function smoothStream<TOOLS extends ToolSet>({
+  delayInMs = 10,
+  chunking = 'word',
+  _internal: { delay = originalDelay } = {},
+}: {
+  delayInMs?: number | null;
+  chunking?: 'word' | 'line' | RegExp | ChunkDetector | Intl.Segmenter;
+  /**
+   * Internal. For test use only. May change without notice.
+   */
+  _internal?: {
+    delay?: (delayInMs: number | null) => Promise<void>;
+  };
+} = {}): (options: {
+  tools: TOOLS;
+}) => TransformStream<TextStreamPart<TOOLS>, TextStreamPart<TOOLS>> {
+  let detectChunk: ChunkDetector;
+
+  // Check if chunking is an Intl.Segmenter (duck-typing for segment method)
+  if (
+    chunking != null &&
+    typeof chunking === 'object' &&
+    'segment' in chunking &&
+    typeof chunking.segment === 'function'
+  ) {
+    const segmenter = chunking as Intl.Segmenter;
+    detectChunk = (buffer: string) => {
+      if (buffer.length === 0) return null;
+      const iterator = segmenter.segment(buffer)[Symbol.iterator]();
+      const first = iterator.next().value;
+      return first?.segment || null;
+    };
+  } else if (typeof chunking === 'function') {
+    detectChunk = buffer => {
+      const match = chunking(buffer);
+
+      if (match == null) {
+        return null;
+      }
+
+      if (!match.length) {
+        throw new Error(`Chunking function must return a non-empty string.`);
+      }
+
+      if (!buffer.startsWith(match)) {
+        throw new Error(
+          `Chunking function must return a match that is a prefix of the buffer. Received: "${match}" expected to start with "${buffer}"`,
+        );
+      }
+
+      return match;
+    };
+  } else {
+    const chunkingRegex =
+      typeof chunking === 'string'
+        ? CHUNKING_REGEXPS[chunking]
+        : chunking instanceof RegExp
+          ? chunking
+          : undefined;
+
+    if (chunkingRegex == null) {
+      throw new InvalidArgumentError({
+        argument: 'chunking',
+        message: `Chunking must be "word", "line", a RegExp, an Intl.Segmenter, or a ChunkDetector function. Received: ${chunking}`,
+      });
+    }
+
+    detectChunk = buffer => {
+      const match = chunkingRegex.exec(buffer);
+
+      if (!match) {
+        return null;
+      }
+
+      return buffer.slice(0, match.index) + match?.[0];
+    };
+  }
+
+  return () => {
+    let buffer = '';
+    let id = '';
+    let type: 'text-delta' | 'reasoning-delta' | undefined = undefined;
+    let providerMetadata: SharedV3ProviderMetadata | undefined = undefined;
+
+    function flushBuffer(
+      controller: TransformStreamDefaultController<TextStreamPart<TOOLS>>,
+    ) {
+      if (buffer.length > 0 && type !== undefined) {
+        controller.enqueue({
+          type,
+          text: buffer,
+          id,
+          ...(providerMetadata != null ? { providerMetadata } : {}),
+        });
+        buffer = '';
+        providerMetadata = undefined;
+      }
+    }
+
+    return new TransformStream<TextStreamPart<TOOLS>, TextStreamPart<TOOLS>>({
+      async transform(chunk, controller) {
+        // Handle non-smoothable chunks: flush buffer and pass through
+        if (chunk.type !== 'text-delta' && chunk.type !== 'reasoning-delta') {
+          flushBuffer(controller);
+          controller.enqueue(chunk);
+          return;
+        }
+
+        // Flush buffer when type or id changes
+        if ((chunk.type !== type || chunk.id !== id) && buffer.length > 0) {
+          flushBuffer(controller);
+        }
+
+        buffer += chunk.text;
+        id = chunk.id;
+        type = chunk.type;
+
+        // Preserve providerMetadata (e.g., Anthropic thinking signatures)
+        if (chunk.providerMetadata != null) {
+          providerMetadata = chunk.providerMetadata;
+        }
+
+        let match;
+
+        while ((match = detectChunk(buffer)) != null) {
+          controller.enqueue({ type, text: match, id });
+          buffer = buffer.slice(match.length);
+
+          await delay(delayInMs);
+        }
+      },
+    });
+  };
+}