Add doRawStream

.changeset/clean-brooms-fold.md

@@ -0,0 +1,8 @@
+---
+'@ai-sdk/provider-utils': patch
+'@ai-sdk/provider': patch
+'@ai-sdk/openai': patch
+'ai': patch
+---
+
+Prototype Raw Response

packages/core/core/generate-text/stream-text.ts

@@ -21,6 +21,7 @@ import { runToolsTransformation } from './run-tools-transformation';
 import { TokenUsage } from './token-usage';
 import { ToToolCall } from './tool-call';
 import { ToToolResult } from './tool-result';
+import { LanguageModelV1CallWarning } from '@ai-sdk/provider';
 
 /**
 Generate a text and call tools for a given prompt using a language model.
@@ -110,6 +111,64 @@ The tools that the model can call. The model needs to support calling tools.
   });
 }
 
+export async function streamResponse<TOOLS extends Record<string, CoreTool>>({
+  model,
+  tools,
+  system,
+  prompt,
+  messages,
+  maxRetries,
+  abortSignal,
+  ...settings
+}: CallSettings &
+  Prompt & {
+    /**
+The language model to use.
+     */
+    model: LanguageModel;
+
+    /**
+The tools that the model can call. The model needs to support calling tools.
+    */
+    tools?: TOOLS;
+  }): Promise<{
+  stream: ReadableStream;
+  warnings: LanguageModelV1CallWarning[] | undefined;
+  rawResponse:
+    | {
+        headers?: Record<string, string>;
+      }
+    | undefined;
+}> {
+  const retry = retryWithExponentialBackoff({ maxRetries });
+  const validatedPrompt = getValidatedPrompt({ system, prompt, messages });
+  const { stream, warnings, rawResponse } = await retry(() => {
+    if (!model.doRawStream) {
+      throw new Error('The model does not support raw streaming.');
+    }
+    return model.doRawStream({
+      mode: {
+        type: 'regular',
+        tools:
+          tools == null
+            ? undefined
+            : Object.entries(tools).map(([name, tool]) => ({
+                type: 'function',
+                name,
+                description: tool.description,
+                parameters: convertZodToJSONSchema(tool.parameters),
+              })),
+      },
+      ...prepareCallSettings(settings),
+      inputFormat: validatedPrompt.type,
+      prompt: convertToLanguageModelPrompt(validatedPrompt),
+      abortSignal,
+    });
+  });
+
+  return { stream, warnings, rawResponse };
+}
+
 export type TextStreamPart<TOOLS extends Record<string, CoreTool>> =
   | {
       type: 'text-delta';

packages/openai/src/openai-chat-language-model.ts

@@ -8,6 +8,7 @@ import {
 } from '@ai-sdk/provider';
 import {
   ParseResult,
+  createEventSourcePassThroughHandler,
   createEventSourceResponseHandler,
   createJsonResponseHandler,
   generateId,
@@ -188,6 +189,45 @@ export class OpenAIChatLanguageModel implements LanguageModelV1 {
     };
   }
 
+  async doRawStream(
+    options: Parameters<LanguageModelV1['doStream']>[0],
+  ): Promise<
+    Omit<Awaited<ReturnType<LanguageModelV1['doStream']>>, 'stream'> & {
+      stream: ReadableStream<Uint8Array>;
+    }
+  > {
+    const args = this.getArgs(options);
+
+    const { responseHeaders, value: responseBody } = await postJsonToApi({
+      url: `${this.config.baseURL}/chat/completions`,
+      headers: this.config.headers(),
+      body: {
+        ...args,
+        stream: true,
+
+        // only include stream_options when in strict compatibility mode:
+        stream_options:
+          this.config.compatibility === 'strict'
+            ? { include_usage: true }
+            : undefined,
+      },
+      failedResponseHandler: openaiFailedResponseHandler,
+      successfulResponseHandler: createEventSourcePassThroughHandler(
+        openaiChatChunkSchema,
+      ),
+      abortSignal: options.abortSignal,
+    });
+
+    const { messages: rawPrompt, ...rawSettings } = args;
+
+    return {
+      stream: responseBody,
+      rawCall: { rawPrompt, rawSettings },
+      rawResponse: { headers: responseHeaders },
+      warnings: [],
+    };
+  }
+
   async doStream(
     options: Parameters<LanguageModelV1['doStream']>[0],
   ): Promise<Awaited<ReturnType<LanguageModelV1['doStream']>>> {

packages/provider-utils/src/response-handler.ts

@@ -118,6 +118,21 @@ export const createEventSourceResponseHandler =
     };
   };
 
+export const createEventSourcePassThroughHandler =
+  <T>(chunkSchema: ZodSchema<T>): ResponseHandler<ReadableStream<Uint8Array>> =>
+  async ({ response }: { response: Response }) => {
+    const responseHeaders = extractResponseHeaders(response);
+
+    if (response.body == null) {
+      throw new EmptyResponseBodyError({});
+    }
+
+    return {
+      responseHeaders,
+      value: response.body,
+    };
+  };
+
 export const createJsonResponseHandler =
   <T>(responseSchema: ZodSchema<T>): ResponseHandler<T> =>
   async ({ response, url, requestBodyValues }) => {

packages/provider/src/language-model/v1/language-model-v1.ts

@@ -145,6 +145,39 @@ Response headers.
 
     warnings?: LanguageModelV1CallWarning[];
   }>;
+
+  doRawStream?: (options: LanguageModelV1CallOptions) => PromiseLike<{
+    stream: ReadableStream<Uint8Array>;
+
+    /**
+Raw prompt and setting information for observability provider integration.
+     */
+    rawCall: {
+      /**
+Raw prompt after expansion and conversion to the format that the
+provider uses to send the information to their API.
+       */
+      rawPrompt: unknown;
+
+      /**
+Raw settings that are used for the API call. Includes provider-specific
+settings.
+       */
+      rawSettings: Record<string, unknown>;
+    };
+
+    /**
+Optional raw response data.
+     */
+    rawResponse?: {
+      /**
+Response headers.
+       */
+      headers?: Record<string, string>;
+    };
+
+    warnings?: LanguageModelV1CallWarning[];
+  }>;
 };
 
 export type LanguageModelV1StreamPart =