@ai-sdk/openai 3.0.136 → 3.0.138

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

@@ -681,6 +681,8 @@ const openaiResponsesModeledChunkTypes = new Set([
   'response.output_item.done',
   'response.output_text.annotation.added',
   'response.output_text.delta',
+  'response.refusal.delta',
+  'response.refusal.done',
   'response.reasoning_summary_part.added',
   'response.reasoning_summary_part.done',
   'response.reasoning_summary_text.delta',
@@ -756,6 +758,20 @@ export const openaiResponsesChunkSchema = lazySchema(() =>
           )
           .nullish(),
       }),
+      z.object({
+        type: z.literal('response.refusal.delta'),
+        item_id: z.string(),
+        output_index: z.number().nullish(),
+        content_index: z.number().nullish(),
+        delta: z.string(),
+      }),
+      z.object({
+        type: z.literal('response.refusal.done'),
+        item_id: z.string(),
+        output_index: z.number().nullish(),
+        content_index: z.number().nullish(),
+        refusal: z.string(),
+      }),
       z.object({
         type: z.enum(['response.completed', 'response.incomplete']),
         response: z.object({
@@ -1330,55 +1346,62 @@ export const openaiResponsesResponseSchema = lazySchema(() =>
               role: z.literal('assistant'),
               id: z.string(),
               phase: z.enum(['commentary', 'final_answer']).nullish(),
+              // the API returns either text or a refusal as content parts:
               content: z.array(
-                z.object({
-                  type: z.literal('output_text'),
-                  text: z.string(),
-                  logprobs: z
-                    .array(
-                      z.object({
-                        token: z.string(),
-                        logprob: z.number(),
-                        top_logprobs: z.array(
-                          z.object({
-                            token: z.string(),
-                            logprob: z.number(),
-                          }),
-                        ),
-                      }),
-                    )
-                    .nullish(),
-                  annotations: z.array(
-                    z.discriminatedUnion('type', [
-                      z.object({
-                        type: z.literal('url_citation'),
-                        start_index: z.number(),
-                        end_index: z.number(),
-                        url: z.string(),
-                        title: z.string(),
-                      }),
-                      z.object({
-                        type: z.literal('file_citation'),
-                        file_id: z.string(),
-                        filename: z.string(),
-                        index: z.number(),
-                      }),
-                      z.object({
-                        type: z.literal('container_file_citation'),
-                        container_id: z.string(),
-                        file_id: z.string(),
-                        filename: z.string(),
-                        start_index: z.number(),
-                        end_index: z.number(),
-                      }),
-                      z.object({
-                        type: z.literal('file_path'),
-                        file_id: z.string(),
-                        index: z.number(),
-                      }),
-                    ]),
-                  ),
-                }),
+                z.discriminatedUnion('type', [
+                  z.object({
+                    type: z.literal('output_text'),
+                    text: z.string(),
+                    logprobs: z
+                      .array(
+                        z.object({
+                          token: z.string(),
+                          logprob: z.number(),
+                          top_logprobs: z.array(
+                            z.object({
+                              token: z.string(),
+                              logprob: z.number(),
+                            }),
+                          ),
+                        }),
+                      )
+                      .nullish(),
+                    annotations: z.array(
+                      z.discriminatedUnion('type', [
+                        z.object({
+                          type: z.literal('url_citation'),
+                          start_index: z.number(),
+                          end_index: z.number(),
+                          url: z.string(),
+                          title: z.string(),
+                        }),
+                        z.object({
+                          type: z.literal('file_citation'),
+                          file_id: z.string(),
+                          filename: z.string(),
+                          index: z.number(),
+                        }),
+                        z.object({
+                          type: z.literal('container_file_citation'),
+                          container_id: z.string(),
+                          file_id: z.string(),
+                          filename: z.string(),
+                          start_index: z.number(),
+                          end_index: z.number(),
+                        }),
+                        z.object({
+                          type: z.literal('file_path'),
+                          file_id: z.string(),
+                          index: z.number(),
+                        }),
+                      ]),
+                    ),
+                  }),
+                  z.object({
+                    type: z.literal('refusal'),
+                    refusal: z.string(),
+                  }),
+                ]),
               ),
             }),
             z.object({

package/src/responses/openai-responses-language-model.ts

@@ -686,6 +686,9 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 {
     let hasFunctionCall = false;
     const hostedToolSearchCallIds: string[] = [];
 
+    // flag that checks if the model refused to answer:
+    let hasRefusal = false;
+
     // map response content to content array (defined when there is no error)
     for (const part of response.output!) {
       switch (part.type) {
@@ -842,6 +845,23 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 {
 
         case 'message': {
           for (const contentPart of part.content) {
+            if (contentPart.type === 'refusal') {
+              hasRefusal = true;
+
+              content.push({
+                type: 'text',
+                text: contentPart.refusal,
+                providerMetadata: {
+                  [providerOptionsName]: {
+                    itemId: part.id,
+                    ...(part.phase != null && { phase: part.phase }),
+                  } satisfies ResponsesTextProviderMetadata,
+                },
+              });
+
+              continue;
+            }
+
             if (
               options.providerOptions?.[providerOptionsName]?.logprobs &&
               contentPart.logprobs
@@ -1200,6 +1220,7 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 {
         unified: mapOpenAIResponseFinishReason({
           finishReason: response.incomplete_details?.reason,
           hasFunctionCall,
+          hasRefusal,
         }),
         raw: response.incomplete_details?.reason ?? undefined,
       },
@@ -1320,6 +1341,9 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 {
     // flag that checks if there have been client-side tool calls (not executed by openai)
     let hasFunctionCall = false;
 
+    // flag that checks if the model refused to answer:
+    let hasRefusal = false;
+
     const activeReasoning: Record<
       string,
       {
@@ -2265,6 +2289,16 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 {
               ) {
                 logprobs.push(value.logprobs);
               }
+            } else if (isRefusalDeltaChunk(value)) {
+              hasRefusal = true;
+
+              controller.enqueue({
+                type: 'text-delta',
+                id: value.item_id,
+                delta: value.delta,
+              });
+            } else if (isRefusalDoneChunk(value)) {
+              hasRefusal = true;
             } else if (value.type === 'response.reasoning_summary_part.added') {
               // the first reasoning start is pushed in isResponseOutputItemAddedReasoningChunk
               if (value.summary_index > 0) {
@@ -2350,6 +2384,7 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 {
                   unified: mapOpenAIResponseFinishReason({
                     finishReason: value.response.incomplete_details?.reason,
                     hasFunctionCall,
+                    hasRefusal,
                   }),
                   raw: value.response.incomplete_details?.reason ?? undefined,
                 };
@@ -2525,6 +2560,18 @@ function isTextDeltaChunk(
   return chunk.type === 'response.output_text.delta';
 }
 
+function isRefusalDeltaChunk(
+  chunk: OpenAIResponsesChunk,
+): chunk is OpenAIResponsesChunk & { type: 'response.refusal.delta' } {
+  return chunk.type === 'response.refusal.delta';
+}
+
+function isRefusalDoneChunk(
+  chunk: OpenAIResponsesChunk,
+): chunk is OpenAIResponsesChunk & { type: 'response.refusal.done' } {
+  return chunk.type === 'response.refusal.done';
+}
+
 function isOpenAIChatCompletionChunk(value: unknown): boolean {
   const chunk = asRecord(value);