@ai-sdk/openai 3.0.14 → 3.0.15

package/src/completion/convert-to-openai-completion-prompt.ts

@@ -0,0 +1,93 @@
+import {
+  InvalidPromptError,
+  LanguageModelV3Prompt,
+  UnsupportedFunctionalityError,
+} from '@ai-sdk/provider';
+
+export function convertToOpenAICompletionPrompt({
+  prompt,
+  user = 'user',
+  assistant = 'assistant',
+}: {
+  prompt: LanguageModelV3Prompt;
+  user?: string;
+  assistant?: string;
+}): {
+  prompt: string;
+  stopSequences?: string[];
+} {
+  // transform to a chat message format:
+  let text = '';
+
+  // if first message is a system message, add it to the text:
+  if (prompt[0].role === 'system') {
+    text += `${prompt[0].content}\n\n`;
+    prompt = prompt.slice(1);
+  }
+
+  for (const { role, content } of prompt) {
+    switch (role) {
+      case 'system': {
+        throw new InvalidPromptError({
+          message: 'Unexpected system message in prompt: ${content}',
+          prompt,
+        });
+      }
+
+      case 'user': {
+        const userMessage = content
+          .map(part => {
+            switch (part.type) {
+              case 'text': {
+                return part.text;
+              }
+            }
+          })
+          .filter(Boolean)
+          .join('');
+
+        text += `${user}:\n${userMessage}\n\n`;
+        break;
+      }
+
+      case 'assistant': {
+        const assistantMessage = content
+          .map(part => {
+            switch (part.type) {
+              case 'text': {
+                return part.text;
+              }
+              case 'tool-call': {
+                throw new UnsupportedFunctionalityError({
+                  functionality: 'tool-call messages',
+                });
+              }
+            }
+          })
+          .join('');
+
+        text += `${assistant}:\n${assistantMessage}\n\n`;
+        break;
+      }
+
+      case 'tool': {
+        throw new UnsupportedFunctionalityError({
+          functionality: 'tool messages',
+        });
+      }
+
+      default: {
+        const _exhaustiveCheck: never = role;
+        throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
+      }
+    }
+  }
+
+  // Assistant message prefix:
+  text += `${assistant}:\n`;
+
+  return {
+    prompt: text,
+    stopSequences: [`\n${user}:`],
+  };
+}

package/src/completion/get-response-metadata.ts

@@ -0,0 +1,15 @@
+export function getResponseMetadata({
+  id,
+  model,
+  created,
+}: {
+  id?: string | undefined | null;
+  created?: number | undefined | null;
+  model?: string | undefined | null;
+}) {
+  return {
+    id: id ?? undefined,
+    modelId: model ?? undefined,
+    timestamp: created != null ? new Date(created * 1000) : undefined,
+  };
+}

package/src/completion/map-openai-finish-reason.ts

@@ -0,0 +1,19 @@
+import { LanguageModelV3FinishReason } from '@ai-sdk/provider';
+
+export function mapOpenAIFinishReason(
+  finishReason: string | null | undefined,
+): LanguageModelV3FinishReason['unified'] {
+  switch (finishReason) {
+    case 'stop':
+      return 'stop';
+    case 'length':
+      return 'length';
+    case 'content_filter':
+      return 'content-filter';
+    case 'function_call':
+    case 'tool_calls':
+      return 'tool-calls';
+    default:
+      return 'other';
+  }
+}

package/src/completion/openai-completion-api.ts

@@ -0,0 +1,81 @@
+import { z } from 'zod/v4';
+import { openaiErrorDataSchema } from '../openai-error';
+import { InferSchema, lazySchema, zodSchema } from '@ai-sdk/provider-utils';
+
+// limited version of the schema, focussed on what is needed for the implementation
+// this approach limits breakages when the API changes and increases efficiency
+export const openaiCompletionResponseSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      id: z.string().nullish(),
+      created: z.number().nullish(),
+      model: z.string().nullish(),
+      choices: z.array(
+        z.object({
+          text: z.string(),
+          finish_reason: z.string(),
+          logprobs: z
+            .object({
+              tokens: z.array(z.string()),
+              token_logprobs: z.array(z.number()),
+              top_logprobs: z.array(z.record(z.string(), z.number())).nullish(),
+            })
+            .nullish(),
+        }),
+      ),
+      usage: z
+        .object({
+          prompt_tokens: z.number(),
+          completion_tokens: z.number(),
+          total_tokens: z.number(),
+        })
+        .nullish(),
+    }),
+  ),
+);
+
+// limited version of the schema, focussed on what is needed for the implementation
+// this approach limits breakages when the API changes and increases efficiency
+export const openaiCompletionChunkSchema = lazySchema(() =>
+  zodSchema(
+    z.union([
+      z.object({
+        id: z.string().nullish(),
+        created: z.number().nullish(),
+        model: z.string().nullish(),
+        choices: z.array(
+          z.object({
+            text: z.string(),
+            finish_reason: z.string().nullish(),
+            index: z.number(),
+            logprobs: z
+              .object({
+                tokens: z.array(z.string()),
+                token_logprobs: z.array(z.number()),
+                top_logprobs: z
+                  .array(z.record(z.string(), z.number()))
+                  .nullish(),
+              })
+              .nullish(),
+          }),
+        ),
+        usage: z
+          .object({
+            prompt_tokens: z.number(),
+            completion_tokens: z.number(),
+            total_tokens: z.number(),
+          })
+          .nullish(),
+      }),
+      openaiErrorDataSchema,
+    ]),
+  ),
+);
+
+export type OpenAICompletionChunk = InferSchema<
+  typeof openaiCompletionChunkSchema
+>;
+
+export type OpenAICompletionResponse = InferSchema<
+  typeof openaiCompletionResponseSchema
+>;