@ai-sdk/openai 4.0.109 → 4.0.111

package/docs/03-openai.mdx

@@ -2005,6 +2005,47 @@ message into `result.output`. This prevents commentary or repeated final answers
 from being joined into invalid JSON. The returned `text`, `content`, response
 messages, and token usage still include the complete response as before.
 
+#### Refusals
+
+The Responses API can answer a request with a `refusal` content part instead of
+`output_text`. The provider surfaces the refusal explanation as text, and
+reports a `content-filter` finish reason in both `generateText` and
+`streamText`. When the same response also contains a client-side function call,
+the finish reason is `tool-calls` instead, so the tools are still executed; the
+refusal text remains part of the content.
+
+Refusal content parts mainly appear with structured outputs (`Output.object` or
+a JSON schema passed to the model). With structured output, a refusal means no
+object can be generated: `generateText` throws `NoObjectGeneratedError` with the
+refusal text on `error.text` and `error.finishReason` set to `'content-filter'`.
+
+```ts
+import { NoObjectGeneratedError, Output, generateText } from 'ai';
+import { openai } from '@ai-sdk/openai';
+import { z } from 'zod';
+
+try {
+  await generateText({
+    model: openai.responses('gpt-4o'),
+    output: Output.object({
+      schema: z.object({ steps: z.array(z.string()) }),
+    }),
+    prompt: '...',
+  });
+} catch (error) {
+  if (NoObjectGeneratedError.isInstance(error)) {
+    // the model's refusal explanation
+    console.log(error.text);
+    // 'content-filter'
+    console.log(error.finishReason);
+  }
+}
+```
+
+Without structured output, the model may still decline in plain text. Such a
+response arrives as ordinary text with a `stop` finish reason, so check the text
+in your application if you need to detect declines.
+
 #### Typed providerMetadata in Text Parts
 
 When using the OpenAI Responses API, the SDK attaches OpenAI-specific metadata to output parts via `providerMetadata`.
@@ -2705,6 +2746,33 @@ You need to change Zod `.nullish()` and `.optional()` to `.nullable()`.
 
 </Note>
 
+#### Refusals
+
+Refusals mainly happen when you request structured outputs. When OpenAI declines
+a request, the provider surfaces the refusal explanation as text and reports a
+`content-filter` finish reason in both `generateText` and `streamText`:
+
+```ts
+const { text, finishReason } = await generateText({
+  model: openai.chat('gpt-4o'),
+  prompt: '...',
+});
+
+if (finishReason === 'content-filter') {
+  // `text` contains the model's refusal explanation
+}
+```
+
+When you request structured output, a refusal means that no object can be
+generated: `generateText` throws `NoObjectGeneratedError` with the refusal text
+on `error.text`.
+
+When you request logprobs, `providerMetadata.openai.logprobs` contains the
+logprobs of all emitted tokens: the content logprobs first, followed by the
+refusal logprobs. This is the same for `generateText` and `streamText`; with
+`streamText`, the logprobs of all streamed tokens are reported when the stream
+finishes.
+
 #### Logprobs
 
 OpenAI provides logprobs information for completion/chat models.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/openai",
-  "version": "4.0.109",
+  "version": "4.0.111",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -35,8 +35,8 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/provider": "4.0.36",
-    "@ai-sdk/provider-utils": "5.0.75"
+    "@ai-sdk/provider": "4.0.37",
+    "@ai-sdk/provider-utils": "5.0.76"
   },
   "devDependencies": {
     "@ai-sdk/test-server": "2.0.4",

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

@@ -1,11 +1,18 @@
 import type { LanguageModelV4FinishReason } from '@ai-sdk/provider';
 
-export function mapOpenAIFinishReason(
-  finishReason: string | null | undefined,
-): LanguageModelV4FinishReason['unified'] {
+export function mapOpenAIFinishReason({
+  finishReason,
+  hasRefusal = false,
+}: {
+  finishReason: string | null | undefined;
+  // flag that checks if the model refused to answer:
+  hasRefusal?: boolean;
+}): LanguageModelV4FinishReason['unified'] {
   switch (finishReason) {
     case 'stop':
-      return 'stop';
+      // OpenAI reports a completed response for refusals, so the refusal is
+      // the reason the response ended:
+      return hasRefusal ? 'content-filter' : 'stop';
     case 'length':
       return 'length';
     case 'content_filter':

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

@@ -36,6 +36,8 @@ export const openaiChatResponseSchema = lazySchema(() =>
           message: z.object({
             role: z.literal('assistant').nullish(),
             content: z.string().nullish(),
+            // set instead of `content` when the model refuses to answer:
+            refusal: z.string().nullish(),
             audio: z
               .object({
                 transcript: z.string().nullish(),
@@ -84,6 +86,22 @@ export const openaiChatResponseSchema = lazySchema(() =>
                   }),
                 )
                 .nullish(),
+              // logprobs of the refusal tokens (set instead of `content` when
+              // the model refuses to answer):
+              refusal: z
+                .array(
+                  z.object({
+                    token: z.string(),
+                    logprob: z.number(),
+                    top_logprobs: z.array(
+                      z.object({
+                        token: z.string(),
+                        logprob: z.number(),
+                      }),
+                    ),
+                  }),
+                )
+                .nullish(),
             })
             .nullish(),
           finish_reason: z.string().nullish(),
@@ -128,6 +146,8 @@ export const openaiChatChunkSchema = lazySchema(() =>
               .object({
                 role: z.enum(['assistant']).nullish(),
                 content: z.string().nullish(),
+                // set instead of `content` when the model refuses to answer:
+                refusal: z.string().nullish(),
                 tool_calls: z
                   .array(
                     z.object({
@@ -172,6 +192,22 @@ export const openaiChatChunkSchema = lazySchema(() =>
                     }),
                   )
                   .nullish(),
+                // logprobs of the refusal tokens (set instead of `content` when
+                // the model refuses to answer):
+                refusal: z
+                  .array(
+                    z.object({
+                      token: z.string(),
+                      logprob: z.number(),
+                      top_logprobs: z.array(
+                        z.object({
+                          token: z.string(),
+                          logprob: z.number(),
+                        }),
+                      ),
+                    }),
+                  )
+                  .nullish(),
               })
               .nullish(),
             finish_reason: z.string().nullish(),

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

@@ -19,8 +19,8 @@ import {
   createJsonResponseHandler,
   generateId,
   isCustomReasoning,
-  parseProviderOptions,
   postJsonToApi,
+  resolveProviderOptions,
   serializeModelOptions,
   WORKFLOW_DESERIALIZE,
   WORKFLOW_SERIALIZE,
@@ -53,6 +53,15 @@ import {
 import { prepareChatTools } from './openai-chat-prepare-tools';
 import { normalizeOpenAIJsonSchema } from '../normalize-openai-json-schema';
 
+type OpenAIChatLogprob = NonNullable<
+  NonNullable<
+    Extract<
+      OpenAIChatChunk,
+      { choices: unknown }
+    >['choices'][number]['logprobs']
+  >['content']
+>[number];
+
 type OpenAIChatConfig = {
   provider: string;
   /** Model ID sent to the API. Defaults to the model's reported ID. */
@@ -114,13 +123,20 @@ export class OpenAIChatLanguageModel implements LanguageModelV4 {
   }: LanguageModelV4CallOptions) {
     const warnings: SharedV4Warning[] = [];
 
-    // Parse provider options
+    // `openai` and the Azure key are merged; the Azure key wins (like Azure
+    // completion models).
+    const providerOptionsNames = this.config.provider.includes('azure')
+      ? (['openai', 'azure'] as const)
+      : (['openai'] as const);
     const openaiOptions =
-      (await parseProviderOptions({
-        provider: 'openai',
-        providerOptions,
-        schema: openaiLanguageModelChatOptions,
-      })) ?? {};
+      (
+        await resolveProviderOptions({
+          providerOptions,
+          namespaces: providerOptionsNames,
+          resolution: 'merge',
+          schema: openaiLanguageModelChatOptions,
+        })
+      ).options ?? {};
 
     const {
       capabilities: { language: modelCapabilities },
@@ -169,7 +185,11 @@ export class OpenAIChatLanguageModel implements LanguageModelV4 {
 
     // reasoningSummary is a Responses API option that the chat options schema strips,
     // so check the raw provider options to avoid silently ignoring it:
-    if (providerOptions?.openai?.reasoningSummary != null) {
+    if (
+      providerOptionsNames.some(
+        name => providerOptions?.[name]?.reasoningSummary != null,
+      )
+    ) {
       warnings.push({
         type: 'unsupported',
         feature: 'reasoningSummary',
@@ -447,7 +467,10 @@ export class OpenAIChatLanguageModel implements LanguageModelV4 {
 
     const content: Array<LanguageModelV4Content> = [];
 
-    // text content:
+    // text content. When the model refuses to answer, the API returns the
+    // refusal in `refusal` and sets `content` to null, so surface it as text
+    // instead of dropping it. Content and refusal are both returned when the
+    // model refuses after answering, so keep both:
     const text =
       choice.message.content != null && choice.message.content.length > 0
         ? choice.message.content
@@ -456,6 +479,12 @@ export class OpenAIChatLanguageModel implements LanguageModelV4 {
       content.push({ type: 'text', text });
     }
 
+    const refusal = choice.message.refusal;
+    const hasRefusal = refusal != null && refusal.length > 0;
+    if (hasRefusal) {
+      content.push({ type: 'text', text: refusal });
+    }
+
     // tool calls:
     for (const toolCall of choice.message.tool_calls ?? []) {
       content.push({
@@ -488,14 +517,25 @@ export class OpenAIChatLanguageModel implements LanguageModelV4 {
       providerMetadata.openai.rejectedPredictionTokens =
         completionTokenDetails?.rejected_prediction_tokens;
     }
-    if (choice.logprobs?.content != null) {
-      providerMetadata.openai.logprobs = choice.logprobs.content;
+    // logprobs either follow the text content (content) or the refusal, so
+    // combine them in the order the text is emitted above. Explicitly empty
+    // logprobs are reported as an empty array, as before:
+    const contentLogprobs = choice.logprobs?.content;
+    const refusalLogprobs = choice.logprobs?.refusal;
+    if (contentLogprobs != null || refusalLogprobs != null) {
+      providerMetadata.openai.logprobs = [
+        ...(contentLogprobs ?? []),
+        ...(refusalLogprobs ?? []),
+      ];
     }
 
     return {
       content,
       finishReason: {
-        unified: mapOpenAIFinishReason(choice.finish_reason),
+        unified: mapOpenAIFinishReason({
+          finishReason: choice.finish_reason,
+          hasRefusal,
+        }),
         raw: choice.finish_reason ?? undefined,
       },
       usage: convertOpenAIChatUsage(response.usage),
@@ -562,6 +602,13 @@ export class OpenAIChatLanguageModel implements LanguageModelV4 {
     let usage: OpenAIChatUsage | undefined = undefined;
     let metadataExtracted = false;
     let isActiveText = false;
+    let hasRefusal = false;
+    let rawFinishReason: string | undefined = undefined;
+    let hasLogprobs = false;
+
+    // logprobs of all streamed chunks (content token logprobs followed by
+    // refusal token logprobs), collected across chunks:
+    const streamedLogprobs: OpenAIChatLogprob[] = [];
 
     const providerMetadata: SharedV4ProviderMetadata = { openai: {} };
 
@@ -587,6 +634,7 @@ export class OpenAIChatLanguageModel implements LanguageModelV4 {
             // handle failed chunk parsing / validation:
             if (!chunk.success) {
               finishReason = { unified: 'error', raw: undefined };
+              rawFinishReason = undefined;
               controller.enqueue({ type: 'error', error: chunk.error });
               return;
             }
@@ -596,6 +644,7 @@ export class OpenAIChatLanguageModel implements LanguageModelV4 {
             // handle error chunks:
             if ('error' in value) {
               finishReason = { unified: 'error', raw: undefined };
+              rawFinishReason = undefined;
               controller.enqueue({
                 type: 'error',
                 error:
@@ -639,15 +688,29 @@ export class OpenAIChatLanguageModel implements LanguageModelV4 {
 
             const choice = value.choices[0];
 
+            // store the raw finish reason and map it in `flush`, after all
+            // chunks have been read: some servers send the last delta (which
+            // can contain a refusal) in the same chunk as the finish reason,
+            // and a refusal turns `stop` into `content-filter`:
             if (choice?.finish_reason != null) {
-              finishReason = {
-                unified: mapOpenAIFinishReason(choice.finish_reason),
-                raw: choice.finish_reason,
-              };
+              rawFinishReason = choice.finish_reason;
             }
 
-            if (choice?.logprobs?.content != null) {
-              providerMetadata.openai.logprobs = choice.logprobs.content;
+            // logprobs either follow the text content (content) or the refusal.
+            // They are streamed token by token, so collect the logprobs of all
+            // chunks (content logprobs followed by refusal logprobs) and report
+            // the complete list at the end of the stream:
+            if (choice?.logprobs != null) {
+              const contentLogprobs = choice.logprobs.content;
+              const refusalLogprobs = choice.logprobs.refusal;
+
+              if (contentLogprobs != null || refusalLogprobs != null) {
+                hasLogprobs = true;
+                streamedLogprobs.push(
+                  ...(contentLogprobs ?? []),
+                  ...(refusalLogprobs ?? []),
+                );
+              }
             }
 
             if (choice?.delta == null) {
@@ -656,7 +719,24 @@ export class OpenAIChatLanguageModel implements LanguageModelV4 {
 
             const delta = choice.delta;
 
-            if (delta.content != null) {
+            // When the model refuses to answer, the API streams the refusal in
+            // `refusal` instead of `content`. Content and refusal deltas can
+            // both occur, so append each to the same text part instead of
+            // dropping one:
+            const textDeltas: string[] = [];
+            if (delta.content != null && delta.content.length > 0) {
+              textDeltas.push(delta.content);
+            }
+            if (delta.refusal != null && delta.refusal.length > 0) {
+              hasRefusal = true;
+              textDeltas.push(delta.refusal);
+            }
+            // empty `content: ""` deltas keep their previous behavior:
+            if (textDeltas.length === 0 && delta.content === '') {
+              textDeltas.push(delta.content);
+            }
+
+            for (const textDelta of textDeltas) {
               if (!isActiveText) {
                 controller.enqueue({ type: 'text-start', id: '0' });
                 isActiveText = true;
@@ -665,7 +745,7 @@ export class OpenAIChatLanguageModel implements LanguageModelV4 {
               controller.enqueue({
                 type: 'text-delta',
                 id: '0',
-                delta: delta.content,
+                delta: textDelta,
               });
             }
 
@@ -696,6 +776,25 @@ export class OpenAIChatLanguageModel implements LanguageModelV4 {
 
             toolCallTracker.flush();
 
+            // map the stored finish reason now that all deltas (including
+            // refusals that arrived in the same chunk as the finish reason)
+            // have been read:
+            if (rawFinishReason != null) {
+              finishReason = {
+                unified: mapOpenAIFinishReason({
+                  finishReason: rawFinishReason,
+                  hasRefusal,
+                }),
+                raw: rawFinishReason,
+              };
+            }
+
+            // report the logprobs of all streamed chunks (content logprobs
+            // followed by refusal logprobs), not only the last chunk:
+            if (hasLogprobs) {
+              providerMetadata.openai.logprobs = streamedLogprobs;
+            }
+
             controller.enqueue({
               type: 'finish',
               finishReason,
@@ -723,6 +822,7 @@ function isOpenAIChatOutputChunk(chunk: OpenAIChatChunk): boolean {
 
     return (
       (delta?.content != null && delta.content.length > 0) ||
+      (delta?.refusal != null && delta.refusal.length > 0) ||
       (delta?.tool_calls != null && delta.tool_calls.length > 0) ||
       (delta?.annotations != null && delta.annotations.length > 0)
     );

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

@@ -14,8 +14,8 @@ import {
   combineHeaders,
   createEventSourceResponseHandler,
   createJsonResponseHandler,
-  parseProviderOptions,
   postJsonToApi,
+  resolveProviderOptions,
   serializeModelOptions,
   WORKFLOW_DESERIALIZE,
   WORKFLOW_SERIALIZE,
@@ -111,18 +111,16 @@ export class OpenAICompletionLanguageModel implements LanguageModelV4 {
     const warnings: SharedV4Warning[] = [];
 
     // Parse provider options
-    const openaiOptions = {
-      ...(await parseProviderOptions({
-        provider: 'openai',
-        providerOptions,
-        schema: openaiLanguageModelCompletionOptions,
-      })),
-      ...(await parseProviderOptions({
-        provider: this.providerOptionsName,
-        providerOptions,
-        schema: openaiLanguageModelCompletionOptions,
-      })),
-    };
+    // `openai` and the provider key are merged; the provider key wins.
+    const openaiOptions =
+      (
+        await resolveProviderOptions({
+          providerOptions,
+          namespaces: ['openai', this.providerOptionsName],
+          resolution: 'merge',
+          schema: openaiLanguageModelCompletionOptions,
+        })
+      ).options ?? {};
 
     if (topK != null) {
       warnings.push({ type: 'unsupported', feature: 'topK' });

package/src/image/openai-image-model-options.ts

@@ -100,71 +100,82 @@ export type OpenAIImageModelOptions = InferSchema<
   typeof openaiImageModelOptions
 >;
 
+/**
+ * Shape of the OpenAI image generation options. Exported so that routers
+ * that also call the OpenAI image API (e.g. Azure) can accept these options
+ * under their own providerOptions key.
+ */
+export const openaiImageModelGenerationOptionsShape = () =>
+  baseImageModelOptionsObject().extend({
+    /**
+     * Style of the generated image. `vivid` produces hyper-real and
+     * dramatic images; `natural` produces more subdued, less hyper-real
+     * looking images.
+     */
+    style: z.enum(['vivid', 'natural']).optional(),
+
+    /**
+     * Format in which the generated image(s) are returned. `gif` produces
+     * an animated GIF and is supported by GPT Image 2.6 models.
+     */
+    outputFormat: z.enum(['png', 'jpeg', 'webp', 'gif']).optional(),
+
+    /**
+     * Number of frames (2-64) of an animated GIF. Only applies to the `gif`
+     * output format. The API defaults to 9.
+     */
+    frameCount: z.number().int().min(2).max(64).optional(),
+
+    /**
+     * Duration of each frame in milliseconds (20-2000) of an animated GIF.
+     * The API rounds it to the nearest 10 ms. Only applies to the `gif`
+     * output format. The API defaults to 200.
+     */
+    frameDurationMs: z.number().int().min(20).max(2000).optional(),
+
+    /**
+     * Content moderation level for the generated image(s). `low` applies
+     * less restrictive filtering.
+     */
+    moderation: z.enum(['auto', 'low']).optional(),
+  }).shape;
+
 export const openaiImageModelGenerationOptions = lazySchema(() =>
-  zodSchema(
-    baseImageModelOptionsObject().extend({
-      /**
-       * Style of the generated image. `vivid` produces hyper-real and
-       * dramatic images; `natural` produces more subdued, less hyper-real
-       * looking images.
-       */
-      style: z.enum(['vivid', 'natural']).optional(),
-
-      /**
-       * Format in which the generated image(s) are returned. `gif` produces
-       * an animated GIF and is supported by GPT Image 2.6 models.
-       */
-      outputFormat: z.enum(['png', 'jpeg', 'webp', 'gif']).optional(),
-
-      /**
-       * Number of frames (2-64) of an animated GIF. Only applies to the `gif`
-       * output format. The API defaults to 9.
-       */
-      frameCount: z.number().int().min(2).max(64).optional(),
-
-      /**
-       * Duration of each frame in milliseconds (20-2000) of an animated GIF.
-       * The API rounds it to the nearest 10 ms. Only applies to the `gif`
-       * output format. The API defaults to 200.
-       */
-      frameDurationMs: z.number().int().min(20).max(2000).optional(),
-
-      /**
-       * Content moderation level for the generated image(s). `low` applies
-       * less restrictive filtering.
-       */
-      moderation: z.enum(['auto', 'low']).optional(),
-    }),
-  ),
+  zodSchema(z.object(openaiImageModelGenerationOptionsShape())),
 );
 
 export type OpenAIImageModelGenerationOptions = InferSchema<
   typeof openaiImageModelGenerationOptions
 >;
 
+/**
+ * Shape of the OpenAI image edit options. Exported so that routers can accept
+ * these options under their own providerOptions key.
+ */
+export const openaiImageModelEditOptionsShape = () =>
+  baseImageModelOptionsObject().extend({
+    /**
+     * Fidelity of the output image(s) to the input image(s).
+     */
+    inputFidelity: z.enum(['high', 'low']).optional(),
+
+    /**
+     * A transparent PNG overlaid on the first input image to mark up the
+     * regions to change, as an HTTPS URL or a base64 data URL. It must match
+     * the dimensions of the first image. Supported by GPT Image 2.5 and 2.6
+     * models. Cannot be combined with a `mask`.
+     */
+    markup: z.string().optional(),
+
+    /**
+     * Content moderation level for the edited image(s). `low` applies
+     * less restrictive filtering. Supported by GPT Image models.
+     */
+    moderation: z.enum(['auto', 'low']).optional(),
+  }).shape;
+
 export const openaiImageModelEditOptions = lazySchema(() =>
-  zodSchema(
-    baseImageModelOptionsObject().extend({
-      /**
-       * Fidelity of the output image(s) to the input image(s).
-       */
-      inputFidelity: z.enum(['high', 'low']).optional(),
-
-      /**
-       * A transparent PNG overlaid on the first input image to mark up the
-       * regions to change, as an HTTPS URL or a base64 data URL. It must match
-       * the dimensions of the first image. Supported by GPT Image 2.5 and 2.6
-       * models. Cannot be combined with a `mask`.
-       */
-      markup: z.string().optional(),
-
-      /**
-       * Content moderation level for the edited image(s). `low` applies
-       * less restrictive filtering. Supported by GPT Image models.
-       */
-      moderation: z.enum(['auto', 'low']).optional(),
-    }),
-  ),
+  zodSchema(z.object(openaiImageModelEditOptionsShape())),
 );
 
 export type OpenAIImageModelEditOptions = InferSchema<

package/src/internal/index.ts

@@ -22,3 +22,5 @@ export * from '../tool/shell';
 export * from '../tool/tool-search';
 export * from '../tool/web-search';
 export * from '../tool/web-search-preview';
+
+export { openaiModelCatalog } from '../openai-model-catalog';

package/src/openai-batch.ts

@@ -748,6 +748,7 @@ async function convertOpenAIBatchResult(
   const content: LanguageModelV4GenerateResult['content'] = [];
   const logprobs: Array<NonNullable<OpenAIResponsesLogprobs>> = [];
   let hasFunctionCall = false;
+  let hasRefusal = false;
 
   for (const part of response.output) {
     switch (part.type) {
@@ -774,6 +775,12 @@ async function convertOpenAIBatchResult(
 
       case 'message': {
         for (const contentPart of part.content) {
+          if (contentPart.type === 'refusal') {
+            hasRefusal = true;
+            content.push({ type: 'text', text: contentPart.refusal });
+            continue;
+          }
+
           content.push({ type: 'text', text: contentPart.text });
           if (contentPart.logprobs != null) {
             logprobs.push(contentPart.logprobs);
@@ -916,6 +923,7 @@ async function convertOpenAIBatchResult(
         unified: mapOpenAIResponseFinishReason({
           finishReason: response.incomplete_details?.reason,
           hasFunctionCall,
+          hasRefusal,
         }),
         raw: response.incomplete_details?.reason ?? undefined,
       },

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

@@ -3,15 +3,21 @@ import type { LanguageModelV4FinishReason } from '@ai-sdk/provider';
 export function mapOpenAIResponseFinishReason({
   finishReason,
   hasFunctionCall,
+  hasRefusal = false,
 }: {
   finishReason: string | null | undefined;
   // flag that checks if there have been client-side tool calls (not executed by openai)
   hasFunctionCall: boolean;
+  // flag that checks if the model refused to answer:
+  hasRefusal?: boolean;
 }): LanguageModelV4FinishReason['unified'] {
   switch (finishReason) {
     case undefined:
     case null:
-      return hasFunctionCall ? 'tool-calls' : 'stop';
+      // A client-side function call must win over a refusal so that the tools
+      // are still executed. The refusal text remains part of the content.
+      if (hasFunctionCall) return 'tool-calls';
+      return hasRefusal ? 'content-filter' : 'stop';
     case 'max_output_tokens':
       return 'length';
     case 'content_filter':