ai 6.0.32 → 6.0.34

package/src/generate-text/execute-tool-call.ts

@@ -0,0 +1,129 @@
+import { executeTool, ModelMessage } from '@ai-sdk/provider-utils';
+import { Tracer } from '@opentelemetry/api';
+import { assembleOperationName } from '../telemetry/assemble-operation-name';
+import { recordErrorOnSpan, recordSpan } from '../telemetry/record-span';
+import { selectTelemetryAttributes } from '../telemetry/select-telemetry-attributes';
+import { TelemetrySettings } from '../telemetry/telemetry-settings';
+import { TypedToolCall } from './tool-call';
+import { ToolOutput } from './tool-output';
+import { ToolSet } from './tool-set';
+import { TypedToolResult } from './tool-result';
+import { TypedToolError } from './tool-error';
+
+export async function executeToolCall<TOOLS extends ToolSet>({
+  toolCall,
+  tools,
+  tracer,
+  telemetry,
+  messages,
+  abortSignal,
+  experimental_context,
+  onPreliminaryToolResult,
+}: {
+  toolCall: TypedToolCall<TOOLS>;
+  tools: TOOLS | undefined;
+  tracer: Tracer;
+  telemetry: TelemetrySettings | undefined;
+  messages: ModelMessage[];
+  abortSignal: AbortSignal | undefined;
+  experimental_context: unknown;
+  onPreliminaryToolResult?: (result: TypedToolResult<TOOLS>) => void;
+}): Promise<ToolOutput<TOOLS> | undefined> {
+  const { toolName, toolCallId, input } = toolCall;
+  const tool = tools?.[toolName];
+
+  if (tool?.execute == null) {
+    return undefined;
+  }
+
+  return 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(input),
+        },
+      },
+    }),
+    tracer,
+    fn: async span => {
+      let output: unknown;
+
+      try {
+        const stream = executeTool({
+          execute: tool.execute!.bind(tool),
+          input,
+          options: {
+            toolCallId,
+            messages,
+            abortSignal,
+            experimental_context,
+          },
+        });
+
+        for await (const part of stream) {
+          if (part.type === 'preliminary') {
+            onPreliminaryToolResult?.({
+              ...toolCall,
+              type: 'tool-result',
+              output: part.output,
+              preliminary: true,
+            });
+          } else {
+            output = part.output;
+          }
+        }
+      } catch (error) {
+        recordErrorOnSpan(span, error);
+        return {
+          type: 'tool-error',
+          toolCallId,
+          toolName,
+          input,
+          error,
+          dynamic: tool.type === 'dynamic',
+          ...(toolCall.providerMetadata != null
+            ? { providerMetadata: toolCall.providerMetadata }
+            : {}),
+        } as TypedToolError<TOOLS>;
+      }
+
+      try {
+        span.setAttributes(
+          await selectTelemetryAttributes({
+            telemetry,
+            attributes: {
+              'ai.toolCall.result': {
+                output: () => JSON.stringify(output),
+              },
+            },
+          }),
+        );
+      } catch (ignored) {
+        // JSON stringify might fail if the result is not serializable,
+        // in which case we just ignore it. In the future we might want to
+        // add an optional serialize method to the tool interface and warn
+        // if the result is not serializable.
+      }
+
+      return {
+        type: 'tool-result',
+        toolCallId,
+        toolName,
+        input,
+        output,
+        dynamic: tool.type === 'dynamic',
+        ...(toolCall.providerMetadata != null
+          ? { providerMetadata: toolCall.providerMetadata }
+          : {}),
+      } as TypedToolResult<TOOLS>;
+    },
+  });
+}

package/src/generate-text/extract-reasoning-content.ts

@@ -0,0 +1,17 @@
+import {
+  LanguageModelV3Content,
+  LanguageModelV3Reasoning,
+} from '@ai-sdk/provider';
+
+export function extractReasoningContent(
+  content: LanguageModelV3Content[],
+): string | undefined {
+  const parts = content.filter(
+    (content): content is LanguageModelV3Reasoning =>
+      content.type === 'reasoning',
+  );
+
+  return parts.length === 0
+    ? undefined
+    : parts.map(content => content.text).join('\n');
+}

package/src/generate-text/extract-text-content.ts

@@ -0,0 +1,15 @@
+import { LanguageModelV3Content, LanguageModelV3Text } from '@ai-sdk/provider';
+
+export function extractTextContent(
+  content: LanguageModelV3Content[],
+): string | undefined {
+  const parts = content.filter(
+    (content): content is LanguageModelV3Text => content.type === 'text',
+  );
+
+  if (parts.length === 0) {
+    return undefined;
+  }
+
+  return parts.map(content => content.text).join('');
+}

package/src/generate-text/generate-text-result.ts

@@ -0,0 +1,168 @@
+import { CallWarning, FinishReason, ProviderMetadata } from '../types';
+import { Source } from '../types/language-model';
+import { LanguageModelRequestMetadata } from '../types/language-model-request-metadata';
+import { LanguageModelResponseMetadata } from '../types/language-model-response-metadata';
+import { LanguageModelUsage } from '../types/usage';
+import { ContentPart } from './content-part';
+import { GeneratedFile } from './generated-file';
+import { Output } from './output';
+import { InferCompleteOutput } from './output-utils';
+import { ReasoningOutput } from './reasoning-output';
+import { ResponseMessage } from './response-message';
+import { StepResult } from './step-result';
+import { DynamicToolCall, StaticToolCall, TypedToolCall } from './tool-call';
+import {
+  DynamicToolResult,
+  StaticToolResult,
+  TypedToolResult,
+} from './tool-result';
+import { ToolSet } from './tool-set';
+
+/**
+The result of a `generateText` call.
+It contains the generated text, the tool calls that were made during the generation, and the results of the tool calls.
+ */
+export interface GenerateTextResult<
+  TOOLS extends ToolSet,
+  OUTPUT extends Output,
+> {
+  /**
+The content that was generated in the last step.
+   */
+  readonly content: Array<ContentPart<TOOLS>>;
+
+  /**
+The text that was generated in the last step.
+     */
+  readonly text: string;
+
+  /**
+The full reasoning that the model has generated in the last step.
+   */
+  readonly reasoning: Array<ReasoningOutput>;
+
+  /**
+The reasoning text that the model has generated in the last step. Can be undefined if the model
+has only generated text.
+   */
+  readonly reasoningText: string | undefined;
+
+  /**
+The files that were generated in the last step.
+Empty array if no files were generated.
+     */
+  readonly files: Array<GeneratedFile>;
+
+  /**
+Sources that have been used as references in the last step.
+   */
+  readonly sources: Array<Source>;
+
+  /**
+The tool calls that were made in the last step.
+   */
+  readonly toolCalls: Array<TypedToolCall<TOOLS>>;
+
+  /**
+The static tool calls that were made in the last step.
+   */
+  readonly staticToolCalls: Array<StaticToolCall<TOOLS>>;
+
+  /**
+The dynamic tool calls that were made in the last step.
+   */
+  readonly dynamicToolCalls: Array<DynamicToolCall>;
+
+  /**
+The results of the tool calls from the last step.
+   */
+  readonly toolResults: Array<TypedToolResult<TOOLS>>;
+
+  /**
+The static tool results that were made in the last step.
+   */
+  readonly staticToolResults: Array<StaticToolResult<TOOLS>>;
+
+  /**
+The dynamic tool results that were made in the last step.
+   */
+  readonly dynamicToolResults: Array<DynamicToolResult>;
+
+  /**
+   * The unified reason why the generation finished.
+   */
+  readonly finishReason: FinishReason;
+
+  /**
+   * The raw reason why the generation finished (from the provider).
+   */
+  readonly rawFinishReason: string | undefined;
+
+  /**
+The token usage of the last step.
+   */
+  readonly usage: LanguageModelUsage;
+
+  /**
+The total token usage of all steps.
+When there are multiple steps, the usage is the sum of all step usages.
+   */
+  readonly totalUsage: LanguageModelUsage;
+
+  /**
+Warnings from the model provider (e.g. unsupported settings)
+   */
+  readonly warnings: CallWarning[] | undefined;
+
+  /**
+Additional request information.
+   */
+  readonly request: LanguageModelRequestMetadata;
+
+  /**
+Additional response information.
+   */
+  readonly response: LanguageModelResponseMetadata & {
+    /**
+The response messages that were generated during the call. It consists of an assistant message,
+potentially containing tool calls.
+
+When there are tool results, there is an additional tool message with the tool results that are available.
+If there are tools that do not have execute functions, they are not included in the tool results and
+need to be added separately.
+       */
+    messages: Array<ResponseMessage>;
+
+    /**
+Response body (available only for providers that use HTTP requests).
+     */
+    body?: unknown;
+  };
+
+  /**
+Additional provider-specific metadata. They are passed through
+from the provider to the AI SDK and enable provider-specific
+results that can be fully encapsulated in the provider.
+   */
+  readonly providerMetadata: ProviderMetadata | undefined;
+
+  /**
+Details for all steps.
+You can use this to get information about intermediate steps,
+such as the tool calls or the response headers.
+   */
+  readonly steps: Array<StepResult<TOOLS>>;
+
+  /**
+The generated structured output. It uses the `output` specification.
+
+@deprecated Use `output` instead.
+   */
+  readonly experimental_output: InferCompleteOutput<OUTPUT>;
+
+  /**
+The generated structured output. It uses the `output` specification.
+
+   */
+  readonly output: InferCompleteOutput<OUTPUT>;
+}

package/src/generate-text/generate-text.test-d.ts

@@ -0,0 +1,68 @@
+import { JSONValue } from '@ai-sdk/provider';
+import { describe, expectTypeOf, it } from 'vitest';
+import { z } from 'zod';
+import { generateText, Output } from '../generate-text';
+import { MockLanguageModelV3 } from '../test/mock-language-model-v3';
+
+describe('generateText types', () => {
+  describe('output', () => {
+    it('should infer text output type (default)', async () => {
+      const result = await generateText({
+        model: new MockLanguageModelV3(),
+        prompt: 'Hello, world!',
+      });
+
+      expectTypeOf<typeof result.output>().toEqualTypeOf<string>();
+    });
+
+    it('should infer text output type', async () => {
+      const result = await generateText({
+        model: new MockLanguageModelV3(),
+        prompt: 'Hello, world!',
+        output: Output.text(),
+      });
+
+      expectTypeOf<typeof result.output>().toEqualTypeOf<string>();
+    });
+
+    it('should infer object output type', async () => {
+      const result = await generateText({
+        model: new MockLanguageModelV3(),
+        prompt: 'Hello, world!',
+        output: Output.object({ schema: z.object({ value: z.string() }) }),
+      });
+
+      expectTypeOf<typeof result.output>().toEqualTypeOf<{ value: string }>();
+    });
+
+    it('should infer array output type', async () => {
+      const result = await generateText({
+        model: new MockLanguageModelV3(),
+        prompt: 'Hello, world!',
+        output: Output.array({ element: z.string() }),
+      });
+
+      expectTypeOf<typeof result.output>().toEqualTypeOf<string[]>();
+    });
+
+    it('should infer choice output type', async () => {
+      const result = await generateText({
+        model: new MockLanguageModelV3(),
+        prompt: 'Hello, world!',
+        output: Output.choice({ options: ['a', 'b', 'c'] as const }),
+      });
+
+      expectTypeOf<typeof result.output>().toEqualTypeOf<'a' | 'b' | 'c'>();
+    });
+
+    it('should infer json output type', async () => {
+      const result = await generateText({
+        model: new MockLanguageModelV3(),
+        prompt: 'Hello, world!',
+        output: Output.json(),
+      });
+
+      expectTypeOf<typeof result.output>().toEqualTypeOf<JSONValue>();
+    });
+  });
+});