llama-stack-client 0.3.5 → 0.4.0-rc2

package/src/resources/chat/completions.ts

@@ -3,7 +3,7 @@
 //
 // This source code is licensed under the terms described in the LICENSE file in
 // the root directory of this source tree.
-
+//
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 import { APIResource } from '../../resource';
@@ -12,11 +12,12 @@ import { APIPromise } from '../../core';
 import * as Core from '../../core';
 import * as CompletionsAPI from './completions';
 import * as ChatAPI from './chat';
-import { OpenAICursorPage, type OpenAICursorPageParams } from '../../pagination';
 import { Stream } from '../../streaming';
 
 export class Completions extends APIResource {
   /**
+   * Create chat completions.
+   *
    * Generate an OpenAI-compatible chat completion for the given messages using the
    * specified model.
    */
@@ -36,516 +37,414 @@ export class Completions extends APIResource {
     body: CompletionCreateParams,
     options?: Core.RequestOptions,
   ): APIPromise<CompletionCreateResponse> | APIPromise<Stream<ChatAPI.ChatCompletionChunk>> {
-    return this._client.post('/v1/openai/v1/chat/completions', {
-      body,
-      ...options,
-      stream: body.stream ?? false,
-    }) as APIPromise<CompletionCreateResponse> | APIPromise<Stream<ChatAPI.ChatCompletionChunk>>;
+    return this._client.post('/v1/chat/completions', { body, ...options, stream: body.stream ?? false }) as
+      | APIPromise<CompletionCreateResponse>
+      | APIPromise<Stream<ChatAPI.ChatCompletionChunk>>;
   }
 
   /**
+   * Get chat completion.
+   *
    * Describe a chat completion by its ID.
    */
   retrieve(completionId: string, options?: Core.RequestOptions): Core.APIPromise<CompletionRetrieveResponse> {
-    return this._client.get(`/v1/openai/v1/chat/completions/${completionId}`, options);
+    return this._client.get(`/v1/chat/completions/${completionId}`, options);
   }
 
   /**
-   * List all chat completions.
+   * List chat completions.
    */
-  list(
-    query?: CompletionListParams,
-    options?: Core.RequestOptions,
-  ): Core.PagePromise<CompletionListResponsesOpenAICursorPage, CompletionListResponse>;
-  list(
-    options?: Core.RequestOptions,
-  ): Core.PagePromise<CompletionListResponsesOpenAICursorPage, CompletionListResponse>;
+  list(query?: CompletionListParams, options?: Core.RequestOptions): Core.APIPromise<CompletionListResponse>;
+  list(options?: Core.RequestOptions): Core.APIPromise<CompletionListResponse>;
   list(
     query: CompletionListParams | Core.RequestOptions = {},
     options?: Core.RequestOptions,
-  ): Core.PagePromise<CompletionListResponsesOpenAICursorPage, CompletionListResponse> {
+  ): Core.APIPromise<CompletionListResponse> {
     if (isRequestOptions(query)) {
       return this.list({}, query);
     }
-    return this._client.getAPIList(
-      '/v1/openai/v1/chat/completions',
-      CompletionListResponsesOpenAICursorPage,
-      { query, ...options },
-    );
+    return this._client.get('/v1/chat/completions', { query, ...options });
   }
 }
 
-export class CompletionListResponsesOpenAICursorPage extends OpenAICursorPage<CompletionListResponse> {}
-
 /**
  * Response from an OpenAI-compatible chat completion request.
  */
-export type CompletionCreateResponse =
-  | CompletionCreateResponse.OpenAIChatCompletion
-  | ChatAPI.ChatCompletionChunk;
+export interface CompletionCreateResponse {
+  id: string;
+
+  choices: Array<CompletionCreateResponse.Choice>;
+
+  created: number;
+
+  model: string;
+
+  object?: 'chat.completion';
 
-export namespace CompletionCreateResponse {
   /**
-   * Response from an OpenAI-compatible chat completion request.
+   * Usage information for OpenAI chat completion.
    */
-  export interface OpenAIChatCompletion {
-    /**
-     * The ID of the chat completion
-     */
-    id: string;
+  usage?: CompletionCreateResponse.Usage | null;
+}
 
-    /**
-     * List of choices
-     */
-    choices: Array<OpenAIChatCompletion.Choice>;
+export namespace CompletionCreateResponse {
+  /**
+   * A choice from an OpenAI-compatible chat completion response.
+   */
+  export interface Choice {
+    finish_reason: string;
 
-    /**
-     * The Unix timestamp in seconds when the chat completion was created
-     */
-    created: number;
+    index: number;
 
     /**
-     * The model that was used to generate the chat completion
+     * A message from the user in an OpenAI-compatible chat completion request.
      */
-    model: string;
+    message:
+      | Choice.OpenAIUserMessageParamOutput
+      | Choice.OpenAISystemMessageParam
+      | Choice.OpenAIAssistantMessageParamOutput
+      | Choice.OpenAIToolMessageParam
+      | Choice.OpenAIDeveloperMessageParam;
 
     /**
-     * The object type, which will be "chat.completion"
+     * The log probabilities for the tokens in the message from an OpenAI-compatible
+     * chat completion response.
      */
-    object: 'chat.completion';
+    logprobs?: Choice.Logprobs | null;
   }
 
-  export namespace OpenAIChatCompletion {
+  export namespace Choice {
     /**
-     * A choice from an OpenAI-compatible chat completion response.
+     * A message from the user in an OpenAI-compatible chat completion request.
      */
-    export interface Choice {
-      /**
-       * The reason the model stopped generating
-       */
-      finish_reason: string;
+    export interface OpenAIUserMessageParamOutput {
+      content:
+        | string
+        | Array<
+            | OpenAIUserMessageParamOutput.OpenAIChatCompletionContentPartTextParam
+            | OpenAIUserMessageParamOutput.OpenAIChatCompletionContentPartImageParam
+            | OpenAIUserMessageParamOutput.OpenAIFile
+          >;
 
-      /**
-       * The index of the choice
-       */
-      index: number;
+      name?: string | null;
 
-      /**
-       * The message from the model
-       */
-      message:
-        | Choice.OpenAIUserMessageParam
-        | Choice.OpenAISystemMessageParam
-        | Choice.OpenAIAssistantMessageParam
-        | Choice.OpenAIToolMessageParam
-        | Choice.OpenAIDeveloperMessageParam;
+      role?: 'user';
+    }
 
+    export namespace OpenAIUserMessageParamOutput {
       /**
-       * (Optional) The log probabilities for the tokens in the message
+       * Text content part for OpenAI-compatible chat completion messages.
        */
-      logprobs?: Choice.Logprobs;
-    }
+      export interface OpenAIChatCompletionContentPartTextParam {
+        text: string;
+
+        type?: 'text';
+      }
 
-    export namespace Choice {
       /**
-       * A message from the user in an OpenAI-compatible chat completion request.
+       * Image content part for OpenAI-compatible chat completion messages.
        */
-      export interface OpenAIUserMessageParam {
-        /**
-         * The content of the message, which can include text and other media
-         */
-        content:
-          | string
-          | Array<
-              | OpenAIUserMessageParam.OpenAIChatCompletionContentPartTextParam
-              | OpenAIUserMessageParam.OpenAIChatCompletionContentPartImageParam
-              | OpenAIUserMessageParam.OpenAIFile
-            >;
-
+      export interface OpenAIChatCompletionContentPartImageParam {
         /**
-         * Must be "user" to identify this as a user message
+         * Image URL specification for OpenAI-compatible chat completion messages.
          */
-        role: 'user';
+        image_url: OpenAIChatCompletionContentPartImageParam.ImageURL;
 
-        /**
-         * (Optional) The name of the user message participant.
-         */
-        name?: string;
+        type?: 'image_url';
       }
 
-      export namespace OpenAIUserMessageParam {
+      export namespace OpenAIChatCompletionContentPartImageParam {
         /**
-         * Text content part for OpenAI-compatible chat completion messages.
+         * Image URL specification for OpenAI-compatible chat completion messages.
          */
-        export interface OpenAIChatCompletionContentPartTextParam {
-          /**
-           * The text content of the message
-           */
-          text: string;
+        export interface ImageURL {
+          url: string;
 
-          /**
-           * Must be "text" to identify this as text content
-           */
-          type: 'text';
+          detail?: string | null;
         }
+      }
 
-        /**
-         * Image content part for OpenAI-compatible chat completion messages.
-         */
-        export interface OpenAIChatCompletionContentPartImageParam {
-          /**
-           * Image URL specification and processing details
-           */
-          image_url: OpenAIChatCompletionContentPartImageParam.ImageURL;
-
-          /**
-           * Must be "image_url" to identify this as image content
-           */
-          type: 'image_url';
-        }
+      export interface OpenAIFile {
+        file: OpenAIFile.File;
 
-        export namespace OpenAIChatCompletionContentPartImageParam {
-          /**
-           * Image URL specification and processing details
-           */
-          export interface ImageURL {
-            /**
-             * URL of the image to include in the message
-             */
-            url: string;
+        type?: 'file';
+      }
 
-            /**
-             * (Optional) Level of detail for image processing. Can be "low", "high", or "auto"
-             */
-            detail?: string;
-          }
-        }
+      export namespace OpenAIFile {
+        export interface File {
+          file_data?: string | null;
 
-        export interface OpenAIFile {
-          file: OpenAIFile.File;
+          file_id?: string | null;
 
-          type: 'file';
+          filename?: string | null;
         }
+      }
+    }
 
-        export namespace OpenAIFile {
-          export interface File {
-            file_data?: string;
+    /**
+     * A system message providing instructions or context to the model.
+     */
+    export interface OpenAISystemMessageParam {
+      content: string | Array<OpenAISystemMessageParam.ListOpenAIChatCompletionContentPartTextParam>;
 
-            file_id?: string;
+      name?: string | null;
 
-            filename?: string;
-          }
-        }
-      }
+      role?: 'system';
+    }
 
+    export namespace OpenAISystemMessageParam {
       /**
-       * A system message providing instructions or context to the model.
+       * Text content part for OpenAI-compatible chat completion messages.
        */
-      export interface OpenAISystemMessageParam {
-        /**
-         * The content of the "system prompt". If multiple system messages are provided,
-         * they are concatenated. The underlying Llama Stack code may also add other system
-         * messages (for example, for formatting tool definitions).
-         */
-        content: string | Array<OpenAISystemMessageParam.UnionMember1>;
-
-        /**
-         * Must be "system" to identify this as a system message
-         */
-        role: 'system';
+      export interface ListOpenAIChatCompletionContentPartTextParam {
+        text: string;
 
-        /**
-         * (Optional) The name of the system message participant.
-         */
-        name?: string;
+        type?: 'text';
       }
+    }
 
-      export namespace OpenAISystemMessageParam {
-        /**
-         * Text content part for OpenAI-compatible chat completion messages.
-         */
-        export interface UnionMember1 {
-          /**
-           * The text content of the message
-           */
-          text: string;
+    /**
+     * A message containing the model's (assistant) response in an OpenAI-compatible
+     * chat completion request.
+     */
+    export interface OpenAIAssistantMessageParamOutput {
+      content?:
+        | string
+        | Array<OpenAIAssistantMessageParamOutput.ListOpenAIChatCompletionContentPartTextParam>
+        | null;
 
-          /**
-           * Must be "text" to identify this as text content
-           */
-          type: 'text';
-        }
+      name?: string | null;
+
+      role?: 'assistant';
+
+      tool_calls?: Array<OpenAIAssistantMessageParamOutput.ToolCall> | null;
+    }
+
+    export namespace OpenAIAssistantMessageParamOutput {
+      /**
+       * Text content part for OpenAI-compatible chat completion messages.
+       */
+      export interface ListOpenAIChatCompletionContentPartTextParam {
+        text: string;
+
+        type?: 'text';
       }
 
       /**
-       * A message containing the model's (assistant) response in an OpenAI-compatible
-       * chat completion request.
+       * Tool call specification for OpenAI-compatible chat completion responses.
        */
-      export interface OpenAIAssistantMessageParam {
-        /**
-         * Must be "assistant" to identify this as the model's response
-         */
-        role: 'assistant';
+      export interface ToolCall {
+        id?: string | null;
 
         /**
-         * The content of the model's response
+         * Function call details for OpenAI-compatible tool calls.
          */
-        content?: string | Array<OpenAIAssistantMessageParam.UnionMember1>;
+        function?: ToolCall.Function | null;
 
-        /**
-         * (Optional) The name of the assistant message participant.
-         */
-        name?: string;
+        index?: number | null;
 
-        /**
-         * List of tool calls. Each tool call is an OpenAIChatCompletionToolCall object.
-         */
-        tool_calls?: Array<OpenAIAssistantMessageParam.ToolCall>;
+        type?: 'function';
       }
 
-      export namespace OpenAIAssistantMessageParam {
+      export namespace ToolCall {
         /**
-         * Text content part for OpenAI-compatible chat completion messages.
+         * Function call details for OpenAI-compatible tool calls.
          */
-        export interface UnionMember1 {
-          /**
-           * The text content of the message
-           */
-          text: string;
+        export interface Function {
+          arguments?: string | null;
 
-          /**
-           * Must be "text" to identify this as text content
-           */
-          type: 'text';
+          name?: string | null;
         }
+      }
+    }
 
-        /**
-         * Tool call specification for OpenAI-compatible chat completion responses.
-         */
-        export interface ToolCall {
-          /**
-           * Must be "function" to identify this as a function call
-           */
-          type: 'function';
-
-          /**
-           * (Optional) Unique identifier for the tool call
-           */
-          id?: string;
-
-          /**
-           * (Optional) Function call details
-           */
-          function?: ToolCall.Function;
+    /**
+     * A message representing the result of a tool invocation in an OpenAI-compatible
+     * chat completion request.
+     */
+    export interface OpenAIToolMessageParam {
+      content: string | Array<OpenAIToolMessageParam.ListOpenAIChatCompletionContentPartTextParam>;
 
-          /**
-           * (Optional) Index of the tool call in the list
-           */
-          index?: number;
-        }
+      tool_call_id: string;
 
-        export namespace ToolCall {
-          /**
-           * (Optional) Function call details
-           */
-          export interface Function {
-            /**
-             * (Optional) Arguments to pass to the function as a JSON string
-             */
-            arguments?: string;
-
-            /**
-             * (Optional) Name of the function to call
-             */
-            name?: string;
-          }
-        }
-      }
+      role?: 'tool';
+    }
 
+    export namespace OpenAIToolMessageParam {
       /**
-       * A message representing the result of a tool invocation in an OpenAI-compatible
-       * chat completion request.
+       * Text content part for OpenAI-compatible chat completion messages.
        */
-      export interface OpenAIToolMessageParam {
-        /**
-         * The response content from the tool
-         */
-        content: string | Array<OpenAIToolMessageParam.UnionMember1>;
-
-        /**
-         * Must be "tool" to identify this as a tool response
-         */
-        role: 'tool';
+      export interface ListOpenAIChatCompletionContentPartTextParam {
+        text: string;
 
-        /**
-         * Unique identifier for the tool call this response is for
-         */
-        tool_call_id: string;
+        type?: 'text';
       }
+    }
 
-      export namespace OpenAIToolMessageParam {
-        /**
-         * Text content part for OpenAI-compatible chat completion messages.
-         */
-        export interface UnionMember1 {
-          /**
-           * The text content of the message
-           */
-          text: string;
+    /**
+     * A message from the developer in an OpenAI-compatible chat completion request.
+     */
+    export interface OpenAIDeveloperMessageParam {
+      content: string | Array<OpenAIDeveloperMessageParam.ListOpenAIChatCompletionContentPartTextParam>;
 
-          /**
-           * Must be "text" to identify this as text content
-           */
-          type: 'text';
-        }
-      }
+      name?: string | null;
+
+      role?: 'developer';
+    }
 
+    export namespace OpenAIDeveloperMessageParam {
       /**
-       * A message from the developer in an OpenAI-compatible chat completion request.
+       * Text content part for OpenAI-compatible chat completion messages.
        */
-      export interface OpenAIDeveloperMessageParam {
-        /**
-         * The content of the developer message
-         */
-        content: string | Array<OpenAIDeveloperMessageParam.UnionMember1>;
-
-        /**
-         * Must be "developer" to identify this as a developer message
-         */
-        role: 'developer';
+      export interface ListOpenAIChatCompletionContentPartTextParam {
+        text: string;
 
-        /**
-         * (Optional) The name of the developer message participant.
-         */
-        name?: string;
+        type?: 'text';
       }
+    }
 
-      export namespace OpenAIDeveloperMessageParam {
-        /**
-         * Text content part for OpenAI-compatible chat completion messages.
-         */
-        export interface UnionMember1 {
-          /**
-           * The text content of the message
-           */
-          text: string;
+    /**
+     * The log probabilities for the tokens in the message from an OpenAI-compatible
+     * chat completion response.
+     */
+    export interface Logprobs {
+      content?: Array<Logprobs.Content> | null;
 
-          /**
-           * Must be "text" to identify this as text content
-           */
-          type: 'text';
-        }
-      }
+      refusal?: Array<Logprobs.Refusal> | null;
+    }
 
+    export namespace Logprobs {
       /**
-       * (Optional) The log probabilities for the tokens in the message
+       * The log probability for a token from an OpenAI-compatible chat completion
+       * response.
+       *
+       * :token: The token :bytes: (Optional) The bytes for the token :logprob: The log
+       * probability of the token :top_logprobs: The top log probabilities for the token
        */
-      export interface Logprobs {
-        /**
-         * (Optional) The log probabilities for the tokens in the message
-         */
-        content?: Array<Logprobs.Content>;
+      export interface Content {
+        token: string;
 
-        /**
-         * (Optional) The log probabilities for the tokens in the message
-         */
-        refusal?: Array<Logprobs.Refusal>;
+        logprob: number;
+
+        bytes?: Array<number> | null;
+
+        top_logprobs?: Array<Content.TopLogprob> | null;
       }
 
-      export namespace Logprobs {
+      export namespace Content {
         /**
-         * The log probability for a token from an OpenAI-compatible chat completion
+         * The top log probability for a token from an OpenAI-compatible chat completion
          * response.
+         *
+         * :token: The token :bytes: (Optional) The bytes for the token :logprob: The log
+         * probability of the token
          */
-        export interface Content {
+        export interface TopLogprob {
           token: string;
 
           logprob: number;
 
-          top_logprobs: Array<Content.TopLogprob>;
-
-          bytes?: Array<number>;
+          bytes?: Array<number> | null;
         }
+      }
 
-        export namespace Content {
-          /**
-           * The top log probability for a token from an OpenAI-compatible chat completion
-           * response.
-           */
-          export interface TopLogprob {
-            token: string;
+      /**
+       * The log probability for a token from an OpenAI-compatible chat completion
+       * response.
+       *
+       * :token: The token :bytes: (Optional) The bytes for the token :logprob: The log
+       * probability of the token :top_logprobs: The top log probabilities for the token
+       */
+      export interface Refusal {
+        token: string;
 
-            logprob: number;
+        logprob: number;
 
-            bytes?: Array<number>;
-          }
-        }
+        bytes?: Array<number> | null;
+
+        top_logprobs?: Array<Refusal.TopLogprob> | null;
+      }
 
+      export namespace Refusal {
         /**
-         * The log probability for a token from an OpenAI-compatible chat completion
+         * The top log probability for a token from an OpenAI-compatible chat completion
          * response.
+         *
+         * :token: The token :bytes: (Optional) The bytes for the token :logprob: The log
+         * probability of the token
          */
-        export interface Refusal {
+        export interface TopLogprob {
           token: string;
 
           logprob: number;
 
-          top_logprobs: Array<Refusal.TopLogprob>;
-
-          bytes?: Array<number>;
+          bytes?: Array<number> | null;
         }
+      }
+    }
+  }
 
-        export namespace Refusal {
-          /**
-           * The top log probability for a token from an OpenAI-compatible chat completion
-           * response.
-           */
-          export interface TopLogprob {
-            token: string;
+  /**
+   * Usage information for OpenAI chat completion.
+   */
+  export interface Usage {
+    completion_tokens: number;
 
-            logprob: number;
+    prompt_tokens: number;
 
-            bytes?: Array<number>;
-          }
-        }
-      }
+    total_tokens: number;
+
+    /**
+     * Token details for output tokens in OpenAI chat completion usage.
+     */
+    completion_tokens_details?: Usage.CompletionTokensDetails | null;
+
+    /**
+     * Token details for prompt tokens in OpenAI chat completion usage.
+     */
+    prompt_tokens_details?: Usage.PromptTokensDetails | null;
+  }
+
+  export namespace Usage {
+    /**
+     * Token details for output tokens in OpenAI chat completion usage.
+     */
+    export interface CompletionTokensDetails {
+      reasoning_tokens?: number | null;
+    }
+
+    /**
+     * Token details for prompt tokens in OpenAI chat completion usage.
+     */
+    export interface PromptTokensDetails {
+      cached_tokens?: number | null;
     }
   }
 }
 
 export interface CompletionRetrieveResponse {
-  /**
-   * The ID of the chat completion
-   */
   id: string;
 
-  /**
-   * List of choices
-   */
   choices: Array<CompletionRetrieveResponse.Choice>;
 
-  /**
-   * The Unix timestamp in seconds when the chat completion was created
-   */
   created: number;
 
   input_messages: Array<
-    | CompletionRetrieveResponse.OpenAIUserMessageParam
+    | CompletionRetrieveResponse.OpenAIUserMessageParamOutput
     | CompletionRetrieveResponse.OpenAISystemMessageParam
-    | CompletionRetrieveResponse.OpenAIAssistantMessageParam
+    | CompletionRetrieveResponse.OpenAIAssistantMessageParamOutput
     | CompletionRetrieveResponse.OpenAIToolMessageParam
     | CompletionRetrieveResponse.OpenAIDeveloperMessageParam
   >;
 
-  /**
-   * The model that was used to generate the chat completion
-   */
   model: string;
 
+  object?: 'chat.completion';
+
   /**
-   * The object type, which will be "chat.completion"
+   * Usage information for OpenAI chat completion.
    */
-  object: 'chat.completion';
+  usage?: CompletionRetrieveResponse.Usage | null;
 }
 
 export namespace CompletionRetrieveResponse {
@@ -553,73 +452,53 @@ export namespace CompletionRetrieveResponse {
    * A choice from an OpenAI-compatible chat completion response.
    */
   export interface Choice {
-    /**
-     * The reason the model stopped generating
-     */
     finish_reason: string;
 
-    /**
-     * The index of the choice
-     */
     index: number;
 
     /**
-     * The message from the model
+     * A message from the user in an OpenAI-compatible chat completion request.
      */
     message:
-      | Choice.OpenAIUserMessageParam
+      | Choice.OpenAIUserMessageParamOutput
       | Choice.OpenAISystemMessageParam
-      | Choice.OpenAIAssistantMessageParam
+      | Choice.OpenAIAssistantMessageParamOutput
       | Choice.OpenAIToolMessageParam
       | Choice.OpenAIDeveloperMessageParam;
 
     /**
-     * (Optional) The log probabilities for the tokens in the message
+     * The log probabilities for the tokens in the message from an OpenAI-compatible
+     * chat completion response.
      */
-    logprobs?: Choice.Logprobs;
+    logprobs?: Choice.Logprobs | null;
   }
 
   export namespace Choice {
     /**
      * A message from the user in an OpenAI-compatible chat completion request.
      */
-    export interface OpenAIUserMessageParam {
-      /**
-       * The content of the message, which can include text and other media
-       */
+    export interface OpenAIUserMessageParamOutput {
       content:
         | string
         | Array<
-            | OpenAIUserMessageParam.OpenAIChatCompletionContentPartTextParam
-            | OpenAIUserMessageParam.OpenAIChatCompletionContentPartImageParam
-            | OpenAIUserMessageParam.OpenAIFile
+            | OpenAIUserMessageParamOutput.OpenAIChatCompletionContentPartTextParam
+            | OpenAIUserMessageParamOutput.OpenAIChatCompletionContentPartImageParam
+            | OpenAIUserMessageParamOutput.OpenAIFile
           >;
 
-      /**
-       * Must be "user" to identify this as a user message
-       */
-      role: 'user';
+      name?: string | null;
 
-      /**
-       * (Optional) The name of the user message participant.
-       */
-      name?: string;
+      role?: 'user';
     }
 
-    export namespace OpenAIUserMessageParam {
+    export namespace OpenAIUserMessageParamOutput {
       /**
        * Text content part for OpenAI-compatible chat completion messages.
        */
       export interface OpenAIChatCompletionContentPartTextParam {
-        /**
-         * The text content of the message
-         */
         text: string;
 
-        /**
-         * Must be "text" to identify this as text content
-         */
-        type: 'text';
+        type?: 'text';
       }
 
       /**
@@ -627,46 +506,37 @@ export namespace CompletionRetrieveResponse {
        */
       export interface OpenAIChatCompletionContentPartImageParam {
         /**
-         * Image URL specification and processing details
+         * Image URL specification for OpenAI-compatible chat completion messages.
          */
         image_url: OpenAIChatCompletionContentPartImageParam.ImageURL;
 
-        /**
-         * Must be "image_url" to identify this as image content
-         */
-        type: 'image_url';
+        type?: 'image_url';
       }
 
       export namespace OpenAIChatCompletionContentPartImageParam {
         /**
-         * Image URL specification and processing details
+         * Image URL specification for OpenAI-compatible chat completion messages.
          */
         export interface ImageURL {
-          /**
-           * URL of the image to include in the message
-           */
           url: string;
 
-          /**
-           * (Optional) Level of detail for image processing. Can be "low", "high", or "auto"
-           */
-          detail?: string;
+          detail?: string | null;
         }
       }
 
       export interface OpenAIFile {
         file: OpenAIFile.File;
 
-        type: 'file';
+        type?: 'file';
       }
 
       export namespace OpenAIFile {
         export interface File {
-          file_data?: string;
+          file_data?: string | null;
 
-          file_id?: string;
+          file_id?: string | null;
 
-          filename?: string;
+          filename?: string | null;
         }
       }
     }
@@ -675,38 +545,21 @@ export namespace CompletionRetrieveResponse {
      * A system message providing instructions or context to the model.
      */
     export interface OpenAISystemMessageParam {
-      /**
-       * The content of the "system prompt". If multiple system messages are provided,
-       * they are concatenated. The underlying Llama Stack code may also add other system
-       * messages (for example, for formatting tool definitions).
-       */
-      content: string | Array<OpenAISystemMessageParam.UnionMember1>;
+      content: string | Array<OpenAISystemMessageParam.ListOpenAIChatCompletionContentPartTextParam>;
 
-      /**
-       * Must be "system" to identify this as a system message
-       */
-      role: 'system';
+      name?: string | null;
 
-      /**
-       * (Optional) The name of the system message participant.
-       */
-      name?: string;
+      role?: 'system';
     }
 
     export namespace OpenAISystemMessageParam {
       /**
        * Text content part for OpenAI-compatible chat completion messages.
        */
-      export interface UnionMember1 {
-        /**
-         * The text content of the message
-         */
+      export interface ListOpenAIChatCompletionContentPartTextParam {
         text: string;
 
-        /**
-         * Must be "text" to identify this as text content
-         */
-        type: 'text';
+        type?: 'text';
       }
     }
 
@@ -714,83 +567,53 @@ export namespace CompletionRetrieveResponse {
      * A message containing the model's (assistant) response in an OpenAI-compatible
      * chat completion request.
      */
-    export interface OpenAIAssistantMessageParam {
-      /**
-       * Must be "assistant" to identify this as the model's response
-       */
-      role: 'assistant';
+    export interface OpenAIAssistantMessageParamOutput {
+      content?:
+        | string
+        | Array<OpenAIAssistantMessageParamOutput.ListOpenAIChatCompletionContentPartTextParam>
+        | null;
 
-      /**
-       * The content of the model's response
-       */
-      content?: string | Array<OpenAIAssistantMessageParam.UnionMember1>;
+      name?: string | null;
 
-      /**
-       * (Optional) The name of the assistant message participant.
-       */
-      name?: string;
+      role?: 'assistant';
 
-      /**
-       * List of tool calls. Each tool call is an OpenAIChatCompletionToolCall object.
-       */
-      tool_calls?: Array<OpenAIAssistantMessageParam.ToolCall>;
+      tool_calls?: Array<OpenAIAssistantMessageParamOutput.ToolCall> | null;
     }
 
-    export namespace OpenAIAssistantMessageParam {
+    export namespace OpenAIAssistantMessageParamOutput {
       /**
        * Text content part for OpenAI-compatible chat completion messages.
        */
-      export interface UnionMember1 {
-        /**
-         * The text content of the message
-         */
+      export interface ListOpenAIChatCompletionContentPartTextParam {
         text: string;
 
-        /**
-         * Must be "text" to identify this as text content
-         */
-        type: 'text';
+        type?: 'text';
       }
 
       /**
        * Tool call specification for OpenAI-compatible chat completion responses.
        */
       export interface ToolCall {
-        /**
-         * Must be "function" to identify this as a function call
-         */
-        type: 'function';
+        id?: string | null;
 
         /**
-         * (Optional) Unique identifier for the tool call
+         * Function call details for OpenAI-compatible tool calls.
          */
-        id?: string;
+        function?: ToolCall.Function | null;
 
-        /**
-         * (Optional) Function call details
-         */
-        function?: ToolCall.Function;
+        index?: number | null;
 
-        /**
-         * (Optional) Index of the tool call in the list
-         */
-        index?: number;
+        type?: 'function';
       }
 
       export namespace ToolCall {
         /**
-         * (Optional) Function call details
+         * Function call details for OpenAI-compatible tool calls.
          */
         export interface Function {
-          /**
-           * (Optional) Arguments to pass to the function as a JSON string
-           */
-          arguments?: string;
+          arguments?: string | null;
 
-          /**
-           * (Optional) Name of the function to call
-           */
-          name?: string;
+          name?: string | null;
         }
       }
     }
@@ -800,36 +623,21 @@ export namespace CompletionRetrieveResponse {
      * chat completion request.
      */
     export interface OpenAIToolMessageParam {
-      /**
-       * The response content from the tool
-       */
-      content: string | Array<OpenAIToolMessageParam.UnionMember1>;
+      content: string | Array<OpenAIToolMessageParam.ListOpenAIChatCompletionContentPartTextParam>;
 
-      /**
-       * Must be "tool" to identify this as a tool response
-       */
-      role: 'tool';
-
-      /**
-       * Unique identifier for the tool call this response is for
-       */
       tool_call_id: string;
+
+      role?: 'tool';
     }
 
     export namespace OpenAIToolMessageParam {
       /**
        * Text content part for OpenAI-compatible chat completion messages.
        */
-      export interface UnionMember1 {
-        /**
-         * The text content of the message
-         */
+      export interface ListOpenAIChatCompletionContentPartTextParam {
         text: string;
 
-        /**
-         * Must be "text" to identify this as text content
-         */
-        type: 'text';
+        type?: 'text';
       }
     }
 
@@ -837,108 +645,100 @@ export namespace CompletionRetrieveResponse {
      * A message from the developer in an OpenAI-compatible chat completion request.
      */
     export interface OpenAIDeveloperMessageParam {
-      /**
-       * The content of the developer message
-       */
-      content: string | Array<OpenAIDeveloperMessageParam.UnionMember1>;
+      content: string | Array<OpenAIDeveloperMessageParam.ListOpenAIChatCompletionContentPartTextParam>;
 
-      /**
-       * Must be "developer" to identify this as a developer message
-       */
-      role: 'developer';
+      name?: string | null;
 
-      /**
-       * (Optional) The name of the developer message participant.
-       */
-      name?: string;
+      role?: 'developer';
     }
 
     export namespace OpenAIDeveloperMessageParam {
       /**
        * Text content part for OpenAI-compatible chat completion messages.
        */
-      export interface UnionMember1 {
-        /**
-         * The text content of the message
-         */
+      export interface ListOpenAIChatCompletionContentPartTextParam {
         text: string;
 
-        /**
-         * Must be "text" to identify this as text content
-         */
-        type: 'text';
+        type?: 'text';
       }
     }
 
     /**
-     * (Optional) The log probabilities for the tokens in the message
+     * The log probabilities for the tokens in the message from an OpenAI-compatible
+     * chat completion response.
      */
     export interface Logprobs {
-      /**
-       * (Optional) The log probabilities for the tokens in the message
-       */
-      content?: Array<Logprobs.Content>;
+      content?: Array<Logprobs.Content> | null;
 
-      /**
-       * (Optional) The log probabilities for the tokens in the message
-       */
-      refusal?: Array<Logprobs.Refusal>;
+      refusal?: Array<Logprobs.Refusal> | null;
     }
 
     export namespace Logprobs {
       /**
        * The log probability for a token from an OpenAI-compatible chat completion
        * response.
+       *
+       * :token: The token :bytes: (Optional) The bytes for the token :logprob: The log
+       * probability of the token :top_logprobs: The top log probabilities for the token
        */
       export interface Content {
         token: string;
 
         logprob: number;
 
-        top_logprobs: Array<Content.TopLogprob>;
+        bytes?: Array<number> | null;
 
-        bytes?: Array<number>;
+        top_logprobs?: Array<Content.TopLogprob> | null;
       }
 
       export namespace Content {
         /**
          * The top log probability for a token from an OpenAI-compatible chat completion
          * response.
+         *
+         * :token: The token :bytes: (Optional) The bytes for the token :logprob: The log
+         * probability of the token
          */
         export interface TopLogprob {
           token: string;
 
           logprob: number;
 
-          bytes?: Array<number>;
+          bytes?: Array<number> | null;
         }
       }
 
       /**
        * The log probability for a token from an OpenAI-compatible chat completion
        * response.
+       *
+       * :token: The token :bytes: (Optional) The bytes for the token :logprob: The log
+       * probability of the token :top_logprobs: The top log probabilities for the token
        */
       export interface Refusal {
         token: string;
 
         logprob: number;
 
-        top_logprobs: Array<Refusal.TopLogprob>;
+        bytes?: Array<number> | null;
 
-        bytes?: Array<number>;
+        top_logprobs?: Array<Refusal.TopLogprob> | null;
       }
 
       export namespace Refusal {
         /**
          * The top log probability for a token from an OpenAI-compatible chat completion
          * response.
+         *
+         * :token: The token :bytes: (Optional) The bytes for the token :logprob: The log
+         * probability of the token
          */
         export interface TopLogprob {
           token: string;
 
           logprob: number;
 
-          bytes?: Array<number>;
+          bytes?: Array<number> | null;
         }
       }
     }
@@ -947,43 +747,28 @@ export namespace CompletionRetrieveResponse {
   /**
    * A message from the user in an OpenAI-compatible chat completion request.
    */
-  export interface OpenAIUserMessageParam {
-    /**
-     * The content of the message, which can include text and other media
-     */
+  export interface OpenAIUserMessageParamOutput {
     content:
       | string
       | Array<
-          | OpenAIUserMessageParam.OpenAIChatCompletionContentPartTextParam
-          | OpenAIUserMessageParam.OpenAIChatCompletionContentPartImageParam
-          | OpenAIUserMessageParam.OpenAIFile
+          | OpenAIUserMessageParamOutput.OpenAIChatCompletionContentPartTextParam
+          | OpenAIUserMessageParamOutput.OpenAIChatCompletionContentPartImageParam
+          | OpenAIUserMessageParamOutput.OpenAIFile
         >;
 
-    /**
-     * Must be "user" to identify this as a user message
-     */
-    role: 'user';
+    name?: string | null;
 
-    /**
-     * (Optional) The name of the user message participant.
-     */
-    name?: string;
+    role?: 'user';
   }
 
-  export namespace OpenAIUserMessageParam {
+  export namespace OpenAIUserMessageParamOutput {
     /**
      * Text content part for OpenAI-compatible chat completion messages.
      */
     export interface OpenAIChatCompletionContentPartTextParam {
-      /**
-       * The text content of the message
-       */
       text: string;
 
-      /**
-       * Must be "text" to identify this as text content
-       */
-      type: 'text';
+      type?: 'text';
     }
 
     /**
@@ -991,46 +776,37 @@ export namespace CompletionRetrieveResponse {
      */
     export interface OpenAIChatCompletionContentPartImageParam {
       /**
-       * Image URL specification and processing details
+       * Image URL specification for OpenAI-compatible chat completion messages.
        */
       image_url: OpenAIChatCompletionContentPartImageParam.ImageURL;
 
-      /**
-       * Must be "image_url" to identify this as image content
-       */
-      type: 'image_url';
+      type?: 'image_url';
     }
 
     export namespace OpenAIChatCompletionContentPartImageParam {
       /**
-       * Image URL specification and processing details
+       * Image URL specification for OpenAI-compatible chat completion messages.
        */
       export interface ImageURL {
-        /**
-         * URL of the image to include in the message
-         */
         url: string;
 
-        /**
-         * (Optional) Level of detail for image processing. Can be "low", "high", or "auto"
-         */
-        detail?: string;
+        detail?: string | null;
       }
     }
 
     export interface OpenAIFile {
       file: OpenAIFile.File;
 
-      type: 'file';
+      type?: 'file';
     }
 
     export namespace OpenAIFile {
       export interface File {
-        file_data?: string;
+        file_data?: string | null;
 
-        file_id?: string;
+        file_id?: string | null;
 
-        filename?: string;
+        filename?: string | null;
       }
     }
   }
@@ -1039,38 +815,21 @@ export namespace CompletionRetrieveResponse {
    * A system message providing instructions or context to the model.
    */
   export interface OpenAISystemMessageParam {
-    /**
-     * The content of the "system prompt". If multiple system messages are provided,
-     * they are concatenated. The underlying Llama Stack code may also add other system
-     * messages (for example, for formatting tool definitions).
-     */
-    content: string | Array<OpenAISystemMessageParam.UnionMember1>;
+    content: string | Array<OpenAISystemMessageParam.ListOpenAIChatCompletionContentPartTextParam>;
 
-    /**
-     * Must be "system" to identify this as a system message
-     */
-    role: 'system';
+    name?: string | null;
 
-    /**
-     * (Optional) The name of the system message participant.
-     */
-    name?: string;
+    role?: 'system';
   }
 
   export namespace OpenAISystemMessageParam {
     /**
      * Text content part for OpenAI-compatible chat completion messages.
      */
-    export interface UnionMember1 {
-      /**
-       * The text content of the message
-       */
+    export interface ListOpenAIChatCompletionContentPartTextParam {
       text: string;
 
-      /**
-       * Must be "text" to identify this as text content
-       */
-      type: 'text';
+      type?: 'text';
     }
   }
 
@@ -1078,83 +837,53 @@ export namespace CompletionRetrieveResponse {
    * A message containing the model's (assistant) response in an OpenAI-compatible
    * chat completion request.
    */
-  export interface OpenAIAssistantMessageParam {
-    /**
-     * Must be "assistant" to identify this as the model's response
-     */
-    role: 'assistant';
+  export interface OpenAIAssistantMessageParamOutput {
+    content?:
+      | string
+      | Array<OpenAIAssistantMessageParamOutput.ListOpenAIChatCompletionContentPartTextParam>
+      | null;
 
-    /**
-     * The content of the model's response
-     */
-    content?: string | Array<OpenAIAssistantMessageParam.UnionMember1>;
+    name?: string | null;
 
-    /**
-     * (Optional) The name of the assistant message participant.
-     */
-    name?: string;
+    role?: 'assistant';
 
-    /**
-     * List of tool calls. Each tool call is an OpenAIChatCompletionToolCall object.
-     */
-    tool_calls?: Array<OpenAIAssistantMessageParam.ToolCall>;
+    tool_calls?: Array<OpenAIAssistantMessageParamOutput.ToolCall> | null;
   }
 
-  export namespace OpenAIAssistantMessageParam {
+  export namespace OpenAIAssistantMessageParamOutput {
     /**
      * Text content part for OpenAI-compatible chat completion messages.
      */
-    export interface UnionMember1 {
-      /**
-       * The text content of the message
-       */
+    export interface ListOpenAIChatCompletionContentPartTextParam {
       text: string;
 
-      /**
-       * Must be "text" to identify this as text content
-       */
-      type: 'text';
+      type?: 'text';
     }
 
     /**
      * Tool call specification for OpenAI-compatible chat completion responses.
      */
     export interface ToolCall {
-      /**
-       * Must be "function" to identify this as a function call
-       */
-      type: 'function';
+      id?: string | null;
 
       /**
-       * (Optional) Unique identifier for the tool call
+       * Function call details for OpenAI-compatible tool calls.
        */
-      id?: string;
+      function?: ToolCall.Function | null;
 
-      /**
-       * (Optional) Function call details
-       */
-      function?: ToolCall.Function;
+      index?: number | null;
 
-      /**
-       * (Optional) Index of the tool call in the list
-       */
-      index?: number;
+      type?: 'function';
     }
 
     export namespace ToolCall {
       /**
-       * (Optional) Function call details
+       * Function call details for OpenAI-compatible tool calls.
        */
       export interface Function {
-        /**
-         * (Optional) Arguments to pass to the function as a JSON string
-         */
-        arguments?: string;
+        arguments?: string | null;
 
-        /**
-         * (Optional) Name of the function to call
-         */
-        name?: string;
+        name?: string | null;
       }
     }
   }
@@ -1164,36 +893,21 @@ export namespace CompletionRetrieveResponse {
    * chat completion request.
    */
   export interface OpenAIToolMessageParam {
-    /**
-     * The response content from the tool
-     */
-    content: string | Array<OpenAIToolMessageParam.UnionMember1>;
+    content: string | Array<OpenAIToolMessageParam.ListOpenAIChatCompletionContentPartTextParam>;
 
-    /**
-     * Must be "tool" to identify this as a tool response
-     */
-    role: 'tool';
-
-    /**
-     * Unique identifier for the tool call this response is for
-     */
     tool_call_id: string;
+
+    role?: 'tool';
   }
 
   export namespace OpenAIToolMessageParam {
     /**
      * Text content part for OpenAI-compatible chat completion messages.
      */
-    export interface UnionMember1 {
-      /**
-       * The text content of the message
-       */
+    export interface ListOpenAIChatCompletionContentPartTextParam {
       text: string;
 
-      /**
-       * Must be "text" to identify this as text content
-       */
-      type: 'text';
+      type?: 'text';
     }
   }
 
@@ -1201,758 +915,624 @@ export namespace CompletionRetrieveResponse {
    * A message from the developer in an OpenAI-compatible chat completion request.
    */
   export interface OpenAIDeveloperMessageParam {
-    /**
-     * The content of the developer message
-     */
-    content: string | Array<OpenAIDeveloperMessageParam.UnionMember1>;
+    content: string | Array<OpenAIDeveloperMessageParam.ListOpenAIChatCompletionContentPartTextParam>;
 
-    /**
-     * Must be "developer" to identify this as a developer message
-     */
-    role: 'developer';
+    name?: string | null;
 
-    /**
-     * (Optional) The name of the developer message participant.
-     */
-    name?: string;
+    role?: 'developer';
   }
 
   export namespace OpenAIDeveloperMessageParam {
     /**
      * Text content part for OpenAI-compatible chat completion messages.
      */
-    export interface UnionMember1 {
-      /**
-       * The text content of the message
-       */
+    export interface ListOpenAIChatCompletionContentPartTextParam {
       text: string;
 
-      /**
-       * Must be "text" to identify this as text content
-       */
-      type: 'text';
+      type?: 'text';
     }
   }
-}
 
-export interface CompletionListResponse {
   /**
-   * The ID of the chat completion
+   * Usage information for OpenAI chat completion.
    */
-  id: string;
+  export interface Usage {
+    completion_tokens: number;
 
-  /**
-   * List of choices
-   */
-  choices: Array<CompletionListResponse.Choice>;
-
-  /**
-   * The Unix timestamp in seconds when the chat completion was created
-   */
-  created: number;
+    prompt_tokens: number;
 
-  input_messages: Array<
-    | CompletionListResponse.OpenAIUserMessageParam
-    | CompletionListResponse.OpenAISystemMessageParam
-    | CompletionListResponse.OpenAIAssistantMessageParam
-    | CompletionListResponse.OpenAIToolMessageParam
-    | CompletionListResponse.OpenAIDeveloperMessageParam
-  >;
+    total_tokens: number;
 
-  /**
-   * The model that was used to generate the chat completion
-   */
-  model: string;
-
-  /**
-   * The object type, which will be "chat.completion"
-   */
-  object: 'chat.completion';
-}
+    /**
+     * Token details for output tokens in OpenAI chat completion usage.
+     */
+    completion_tokens_details?: Usage.CompletionTokensDetails | null;
 
-export namespace CompletionListResponse {
-  /**
-   * A choice from an OpenAI-compatible chat completion response.
-   */
-  export interface Choice {
     /**
-     * The reason the model stopped generating
+     * Token details for prompt tokens in OpenAI chat completion usage.
      */
-    finish_reason: string;
+    prompt_tokens_details?: Usage.PromptTokensDetails | null;
+  }
 
+  export namespace Usage {
     /**
-     * The index of the choice
+     * Token details for output tokens in OpenAI chat completion usage.
      */
-    index: number;
+    export interface CompletionTokensDetails {
+      reasoning_tokens?: number | null;
+    }
 
     /**
-     * The message from the model
+     * Token details for prompt tokens in OpenAI chat completion usage.
      */
-    message:
-      | Choice.OpenAIUserMessageParam
-      | Choice.OpenAISystemMessageParam
-      | Choice.OpenAIAssistantMessageParam
-      | Choice.OpenAIToolMessageParam
-      | Choice.OpenAIDeveloperMessageParam;
+    export interface PromptTokensDetails {
+      cached_tokens?: number | null;
+    }
+  }
+}
+
+/**
+ * Response from listing OpenAI-compatible chat completions.
+ */
+export interface CompletionListResponse {
+  data: Array<CompletionListResponse.Data>;
+
+  first_id: string;
+
+  has_more: boolean;
+
+  last_id: string;
+
+  object?: 'list';
+}
+
+export namespace CompletionListResponse {
+  export interface Data {
+    id: string;
+
+    choices: Array<Data.Choice>;
+
+    created: number;
+
+    input_messages: Array<
+      | Data.OpenAIUserMessageParamOutput
+      | Data.OpenAISystemMessageParam
+      | Data.OpenAIAssistantMessageParamOutput
+      | Data.OpenAIToolMessageParam
+      | Data.OpenAIDeveloperMessageParam
+    >;
+
+    model: string;
+
+    object?: 'chat.completion';
 
     /**
-     * (Optional) The log probabilities for the tokens in the message
+     * Usage information for OpenAI chat completion.
      */
-    logprobs?: Choice.Logprobs;
+    usage?: Data.Usage | null;
   }
 
-  export namespace Choice {
+  export namespace Data {
     /**
-     * A message from the user in an OpenAI-compatible chat completion request.
+     * A choice from an OpenAI-compatible chat completion response.
      */
-    export interface OpenAIUserMessageParam {
-      /**
-       * The content of the message, which can include text and other media
-       */
-      content:
-        | string
-        | Array<
-            | OpenAIUserMessageParam.OpenAIChatCompletionContentPartTextParam
-            | OpenAIUserMessageParam.OpenAIChatCompletionContentPartImageParam
-            | OpenAIUserMessageParam.OpenAIFile
-          >;
+    export interface Choice {
+      finish_reason: string;
+
+      index: number;
 
       /**
-       * Must be "user" to identify this as a user message
+       * A message from the user in an OpenAI-compatible chat completion request.
        */
-      role: 'user';
+      message:
+        | Choice.OpenAIUserMessageParamOutput
+        | Choice.OpenAISystemMessageParam
+        | Choice.OpenAIAssistantMessageParamOutput
+        | Choice.OpenAIToolMessageParam
+        | Choice.OpenAIDeveloperMessageParam;
 
       /**
-       * (Optional) The name of the user message participant.
+       * The log probabilities for the tokens in the message from an OpenAI-compatible
+       * chat completion response.
        */
-      name?: string;
+      logprobs?: Choice.Logprobs | null;
     }
 
-    export namespace OpenAIUserMessageParam {
+    export namespace Choice {
       /**
-       * Text content part for OpenAI-compatible chat completion messages.
+       * A message from the user in an OpenAI-compatible chat completion request.
        */
-      export interface OpenAIChatCompletionContentPartTextParam {
-        /**
-         * The text content of the message
-         */
-        text: string;
+      export interface OpenAIUserMessageParamOutput {
+        content:
+          | string
+          | Array<
+              | OpenAIUserMessageParamOutput.OpenAIChatCompletionContentPartTextParam
+              | OpenAIUserMessageParamOutput.OpenAIChatCompletionContentPartImageParam
+              | OpenAIUserMessageParamOutput.OpenAIFile
+            >;
 
-        /**
-         * Must be "text" to identify this as text content
-         */
-        type: 'text';
+        name?: string | null;
+
+        role?: 'user';
       }
 
-      /**
-       * Image content part for OpenAI-compatible chat completion messages.
-       */
-      export interface OpenAIChatCompletionContentPartImageParam {
+      export namespace OpenAIUserMessageParamOutput {
         /**
-         * Image URL specification and processing details
+         * Text content part for OpenAI-compatible chat completion messages.
          */
-        image_url: OpenAIChatCompletionContentPartImageParam.ImageURL;
+        export interface OpenAIChatCompletionContentPartTextParam {
+          text: string;
 
-        /**
-         * Must be "image_url" to identify this as image content
-         */
-        type: 'image_url';
-      }
+          type?: 'text';
+        }
 
-      export namespace OpenAIChatCompletionContentPartImageParam {
         /**
-         * Image URL specification and processing details
+         * Image content part for OpenAI-compatible chat completion messages.
          */
-        export interface ImageURL {
+        export interface OpenAIChatCompletionContentPartImageParam {
           /**
-           * URL of the image to include in the message
+           * Image URL specification for OpenAI-compatible chat completion messages.
            */
-          url: string;
+          image_url: OpenAIChatCompletionContentPartImageParam.ImageURL;
 
+          type?: 'image_url';
+        }
+
+        export namespace OpenAIChatCompletionContentPartImageParam {
           /**
-           * (Optional) Level of detail for image processing. Can be "low", "high", or "auto"
+           * Image URL specification for OpenAI-compatible chat completion messages.
            */
-          detail?: string;
+          export interface ImageURL {
+            url: string;
+
+            detail?: string | null;
+          }
         }
-      }
 
-      export interface OpenAIFile {
-        file: OpenAIFile.File;
+        export interface OpenAIFile {
+          file: OpenAIFile.File;
 
-        type: 'file';
-      }
+          type?: 'file';
+        }
 
-      export namespace OpenAIFile {
-        export interface File {
-          file_data?: string;
+        export namespace OpenAIFile {
+          export interface File {
+            file_data?: string | null;
 
-          file_id?: string;
+            file_id?: string | null;
 
-          filename?: string;
+            filename?: string | null;
+          }
         }
       }
-    }
 
-    /**
-     * A system message providing instructions or context to the model.
-     */
-    export interface OpenAISystemMessageParam {
       /**
-       * The content of the "system prompt". If multiple system messages are provided,
-       * they are concatenated. The underlying Llama Stack code may also add other system
-       * messages (for example, for formatting tool definitions).
+       * A system message providing instructions or context to the model.
        */
-      content: string | Array<OpenAISystemMessageParam.UnionMember1>;
+      export interface OpenAISystemMessageParam {
+        content: string | Array<OpenAISystemMessageParam.ListOpenAIChatCompletionContentPartTextParam>;
 
-      /**
-       * Must be "system" to identify this as a system message
-       */
-      role: 'system';
+        name?: string | null;
 
-      /**
-       * (Optional) The name of the system message participant.
-       */
-      name?: string;
-    }
+        role?: 'system';
+      }
 
-    export namespace OpenAISystemMessageParam {
-      /**
-       * Text content part for OpenAI-compatible chat completion messages.
-       */
-      export interface UnionMember1 {
+      export namespace OpenAISystemMessageParam {
         /**
-         * The text content of the message
+         * Text content part for OpenAI-compatible chat completion messages.
          */
-        text: string;
+        export interface ListOpenAIChatCompletionContentPartTextParam {
+          text: string;
 
-        /**
-         * Must be "text" to identify this as text content
-         */
-        type: 'text';
+          type?: 'text';
+        }
       }
-    }
-
-    /**
-     * A message containing the model's (assistant) response in an OpenAI-compatible
-     * chat completion request.
-     */
-    export interface OpenAIAssistantMessageParam {
-      /**
-       * Must be "assistant" to identify this as the model's response
-       */
-      role: 'assistant';
 
       /**
-       * The content of the model's response
-       */
-      content?: string | Array<OpenAIAssistantMessageParam.UnionMember1>;
-
-      /**
-       * (Optional) The name of the assistant message participant.
+       * A message containing the model's (assistant) response in an OpenAI-compatible
+       * chat completion request.
        */
-      name?: string;
+      export interface OpenAIAssistantMessageParamOutput {
+        content?:
+          | string
+          | Array<OpenAIAssistantMessageParamOutput.ListOpenAIChatCompletionContentPartTextParam>
+          | null;
 
-      /**
-       * List of tool calls. Each tool call is an OpenAIChatCompletionToolCall object.
-       */
-      tool_calls?: Array<OpenAIAssistantMessageParam.ToolCall>;
-    }
+        name?: string | null;
 
-    export namespace OpenAIAssistantMessageParam {
-      /**
-       * Text content part for OpenAI-compatible chat completion messages.
-       */
-      export interface UnionMember1 {
-        /**
-         * The text content of the message
-         */
-        text: string;
+        role?: 'assistant';
 
-        /**
-         * Must be "text" to identify this as text content
-         */
-        type: 'text';
+        tool_calls?: Array<OpenAIAssistantMessageParamOutput.ToolCall> | null;
       }
 
-      /**
-       * Tool call specification for OpenAI-compatible chat completion responses.
-       */
-      export interface ToolCall {
-        /**
-         * Must be "function" to identify this as a function call
-         */
-        type: 'function';
-
+      export namespace OpenAIAssistantMessageParamOutput {
         /**
-         * (Optional) Unique identifier for the tool call
+         * Text content part for OpenAI-compatible chat completion messages.
          */
-        id?: string;
+        export interface ListOpenAIChatCompletionContentPartTextParam {
+          text: string;
 
-        /**
-         * (Optional) Function call details
-         */
-        function?: ToolCall.Function;
+          type?: 'text';
+        }
 
         /**
-         * (Optional) Index of the tool call in the list
+         * Tool call specification for OpenAI-compatible chat completion responses.
          */
-        index?: number;
-      }
+        export interface ToolCall {
+          id?: string | null;
 
-      export namespace ToolCall {
-        /**
-         * (Optional) Function call details
-         */
-        export interface Function {
           /**
-           * (Optional) Arguments to pass to the function as a JSON string
+           * Function call details for OpenAI-compatible tool calls.
            */
-          arguments?: string;
+          function?: ToolCall.Function | null;
+
+          index?: number | null;
+
+          type?: 'function';
+        }
 
+        export namespace ToolCall {
           /**
-           * (Optional) Name of the function to call
+           * Function call details for OpenAI-compatible tool calls.
            */
-          name?: string;
+          export interface Function {
+            arguments?: string | null;
+
+            name?: string | null;
+          }
         }
       }
-    }
 
-    /**
-     * A message representing the result of a tool invocation in an OpenAI-compatible
-     * chat completion request.
-     */
-    export interface OpenAIToolMessageParam {
       /**
-       * The response content from the tool
+       * A message representing the result of a tool invocation in an OpenAI-compatible
+       * chat completion request.
        */
-      content: string | Array<OpenAIToolMessageParam.UnionMember1>;
+      export interface OpenAIToolMessageParam {
+        content: string | Array<OpenAIToolMessageParam.ListOpenAIChatCompletionContentPartTextParam>;
 
-      /**
-       * Must be "tool" to identify this as a tool response
-       */
-      role: 'tool';
+        tool_call_id: string;
 
-      /**
-       * Unique identifier for the tool call this response is for
-       */
-      tool_call_id: string;
-    }
+        role?: 'tool';
+      }
 
-    export namespace OpenAIToolMessageParam {
-      /**
-       * Text content part for OpenAI-compatible chat completion messages.
-       */
-      export interface UnionMember1 {
+      export namespace OpenAIToolMessageParam {
         /**
-         * The text content of the message
+         * Text content part for OpenAI-compatible chat completion messages.
          */
-        text: string;
+        export interface ListOpenAIChatCompletionContentPartTextParam {
+          text: string;
 
-        /**
-         * Must be "text" to identify this as text content
-         */
-        type: 'text';
+          type?: 'text';
+        }
       }
-    }
 
-    /**
-     * A message from the developer in an OpenAI-compatible chat completion request.
-     */
-    export interface OpenAIDeveloperMessageParam {
       /**
-       * The content of the developer message
+       * A message from the developer in an OpenAI-compatible chat completion request.
        */
-      content: string | Array<OpenAIDeveloperMessageParam.UnionMember1>;
+      export interface OpenAIDeveloperMessageParam {
+        content: string | Array<OpenAIDeveloperMessageParam.ListOpenAIChatCompletionContentPartTextParam>;
 
-      /**
-       * Must be "developer" to identify this as a developer message
-       */
-      role: 'developer';
+        name?: string | null;
 
-      /**
-       * (Optional) The name of the developer message participant.
-       */
-      name?: string;
-    }
+        role?: 'developer';
+      }
 
-    export namespace OpenAIDeveloperMessageParam {
-      /**
-       * Text content part for OpenAI-compatible chat completion messages.
-       */
-      export interface UnionMember1 {
+      export namespace OpenAIDeveloperMessageParam {
         /**
-         * The text content of the message
+         * Text content part for OpenAI-compatible chat completion messages.
          */
-        text: string;
+        export interface ListOpenAIChatCompletionContentPartTextParam {
+          text: string;
 
-        /**
-         * Must be "text" to identify this as text content
-         */
-        type: 'text';
+          type?: 'text';
+        }
       }
-    }
-
-    /**
-     * (Optional) The log probabilities for the tokens in the message
-     */
-    export interface Logprobs {
-      /**
-       * (Optional) The log probabilities for the tokens in the message
-       */
-      content?: Array<Logprobs.Content>;
-
-      /**
-       * (Optional) The log probabilities for the tokens in the message
-       */
-      refusal?: Array<Logprobs.Refusal>;
-    }
 
-    export namespace Logprobs {
       /**
-       * The log probability for a token from an OpenAI-compatible chat completion
-       * response.
+       * The log probabilities for the tokens in the message from an OpenAI-compatible
+       * chat completion response.
        */
-      export interface Content {
-        token: string;
-
-        logprob: number;
-
-        top_logprobs: Array<Content.TopLogprob>;
+      export interface Logprobs {
+        content?: Array<Logprobs.Content> | null;
 
-        bytes?: Array<number>;
+        refusal?: Array<Logprobs.Refusal> | null;
       }
 
-      export namespace Content {
+      export namespace Logprobs {
         /**
-         * The top log probability for a token from an OpenAI-compatible chat completion
+         * The log probability for a token from an OpenAI-compatible chat completion
          * response.
+         *
+         * :token: The token :bytes: (Optional) The bytes for the token :logprob: The log
+         * probability of the token :top_logprobs: The top log probabilities for the token
          */
-        export interface TopLogprob {
+        export interface Content {
           token: string;
 
           logprob: number;
 
-          bytes?: Array<number>;
-        }
-      }
+          bytes?: Array<number> | null;
 
-      /**
-       * The log probability for a token from an OpenAI-compatible chat completion
-       * response.
-       */
-      export interface Refusal {
-        token: string;
+          top_logprobs?: Array<Content.TopLogprob> | null;
+        }
 
-        logprob: number;
+        export namespace Content {
+          /**
+           * The top log probability for a token from an OpenAI-compatible chat completion
+           * response.
+           *
+           * :token: The token :bytes: (Optional) The bytes for the token :logprob: The log
+           * probability of the token
+           */
+          export interface TopLogprob {
+            token: string;
 
-        top_logprobs: Array<Refusal.TopLogprob>;
+            logprob: number;
 
-        bytes?: Array<number>;
-      }
+            bytes?: Array<number> | null;
+          }
+        }
 
-      export namespace Refusal {
         /**
-         * The top log probability for a token from an OpenAI-compatible chat completion
+         * The log probability for a token from an OpenAI-compatible chat completion
          * response.
+         *
+         * :token: The token :bytes: (Optional) The bytes for the token :logprob: The log
+         * probability of the token :top_logprobs: The top log probabilities for the token
          */
-        export interface TopLogprob {
+        export interface Refusal {
           token: string;
 
           logprob: number;
 
-          bytes?: Array<number>;
+          bytes?: Array<number> | null;
+
+          top_logprobs?: Array<Refusal.TopLogprob> | null;
         }
-      }
-    }
-  }
 
-  /**
-   * A message from the user in an OpenAI-compatible chat completion request.
-   */
-  export interface OpenAIUserMessageParam {
-    /**
-     * The content of the message, which can include text and other media
-     */
-    content:
-      | string
-      | Array<
-          | OpenAIUserMessageParam.OpenAIChatCompletionContentPartTextParam
-          | OpenAIUserMessageParam.OpenAIChatCompletionContentPartImageParam
-          | OpenAIUserMessageParam.OpenAIFile
-        >;
+        export namespace Refusal {
+          /**
+           * The top log probability for a token from an OpenAI-compatible chat completion
+           * response.
+           *
+           * :token: The token :bytes: (Optional) The bytes for the token :logprob: The log
+           * probability of the token
+           */
+          export interface TopLogprob {
+            token: string;
 
-    /**
-     * Must be "user" to identify this as a user message
-     */
-    role: 'user';
+            logprob: number;
 
-    /**
-     * (Optional) The name of the user message participant.
-     */
-    name?: string;
-  }
+            bytes?: Array<number> | null;
+          }
+        }
+      }
+    }
 
-  export namespace OpenAIUserMessageParam {
     /**
-     * Text content part for OpenAI-compatible chat completion messages.
+     * A message from the user in an OpenAI-compatible chat completion request.
      */
-    export interface OpenAIChatCompletionContentPartTextParam {
-      /**
-       * The text content of the message
-       */
-      text: string;
+    export interface OpenAIUserMessageParamOutput {
+      content:
+        | string
+        | Array<
+            | OpenAIUserMessageParamOutput.OpenAIChatCompletionContentPartTextParam
+            | OpenAIUserMessageParamOutput.OpenAIChatCompletionContentPartImageParam
+            | OpenAIUserMessageParamOutput.OpenAIFile
+          >;
 
-      /**
-       * Must be "text" to identify this as text content
-       */
-      type: 'text';
+      name?: string | null;
+
+      role?: 'user';
     }
 
-    /**
-     * Image content part for OpenAI-compatible chat completion messages.
-     */
-    export interface OpenAIChatCompletionContentPartImageParam {
+    export namespace OpenAIUserMessageParamOutput {
       /**
-       * Image URL specification and processing details
+       * Text content part for OpenAI-compatible chat completion messages.
        */
-      image_url: OpenAIChatCompletionContentPartImageParam.ImageURL;
+      export interface OpenAIChatCompletionContentPartTextParam {
+        text: string;
 
-      /**
-       * Must be "image_url" to identify this as image content
-       */
-      type: 'image_url';
-    }
+        type?: 'text';
+      }
 
-    export namespace OpenAIChatCompletionContentPartImageParam {
       /**
-       * Image URL specification and processing details
+       * Image content part for OpenAI-compatible chat completion messages.
        */
-      export interface ImageURL {
+      export interface OpenAIChatCompletionContentPartImageParam {
         /**
-         * URL of the image to include in the message
+         * Image URL specification for OpenAI-compatible chat completion messages.
          */
-        url: string;
+        image_url: OpenAIChatCompletionContentPartImageParam.ImageURL;
 
-        /**
-         * (Optional) Level of detail for image processing. Can be "low", "high", or "auto"
-         */
-        detail?: string;
+        type?: 'image_url';
       }
-    }
-
-    export interface OpenAIFile {
-      file: OpenAIFile.File;
 
-      type: 'file';
-    }
-
-    export namespace OpenAIFile {
-      export interface File {
-        file_data?: string;
-
-        file_id?: string;
+      export namespace OpenAIChatCompletionContentPartImageParam {
+        /**
+         * Image URL specification for OpenAI-compatible chat completion messages.
+         */
+        export interface ImageURL {
+          url: string;
 
-        filename?: string;
+          detail?: string | null;
+        }
       }
-    }
-  }
 
-  /**
-   * A system message providing instructions or context to the model.
-   */
-  export interface OpenAISystemMessageParam {
-    /**
-     * The content of the "system prompt". If multiple system messages are provided,
-     * they are concatenated. The underlying Llama Stack code may also add other system
-     * messages (for example, for formatting tool definitions).
-     */
-    content: string | Array<OpenAISystemMessageParam.UnionMember1>;
+      export interface OpenAIFile {
+        file: OpenAIFile.File;
 
-    /**
-     * Must be "system" to identify this as a system message
-     */
-    role: 'system';
+        type?: 'file';
+      }
 
-    /**
-     * (Optional) The name of the system message participant.
-     */
-    name?: string;
-  }
+      export namespace OpenAIFile {
+        export interface File {
+          file_data?: string | null;
 
-  export namespace OpenAISystemMessageParam {
-    /**
-     * Text content part for OpenAI-compatible chat completion messages.
-     */
-    export interface UnionMember1 {
-      /**
-       * The text content of the message
-       */
-      text: string;
+          file_id?: string | null;
 
-      /**
-       * Must be "text" to identify this as text content
-       */
-      type: 'text';
+          filename?: string | null;
+        }
+      }
     }
-  }
-
-  /**
-   * A message containing the model's (assistant) response in an OpenAI-compatible
-   * chat completion request.
-   */
-  export interface OpenAIAssistantMessageParam {
-    /**
-     * Must be "assistant" to identify this as the model's response
-     */
-    role: 'assistant';
 
     /**
-     * The content of the model's response
+     * A system message providing instructions or context to the model.
      */
-    content?: string | Array<OpenAIAssistantMessageParam.UnionMember1>;
+    export interface OpenAISystemMessageParam {
+      content: string | Array<OpenAISystemMessageParam.ListOpenAIChatCompletionContentPartTextParam>;
 
-    /**
-     * (Optional) The name of the assistant message participant.
-     */
-    name?: string;
+      name?: string | null;
 
-    /**
-     * List of tool calls. Each tool call is an OpenAIChatCompletionToolCall object.
-     */
-    tool_calls?: Array<OpenAIAssistantMessageParam.ToolCall>;
-  }
+      role?: 'system';
+    }
 
-  export namespace OpenAIAssistantMessageParam {
-    /**
-     * Text content part for OpenAI-compatible chat completion messages.
-     */
-    export interface UnionMember1 {
+    export namespace OpenAISystemMessageParam {
       /**
-       * The text content of the message
+       * Text content part for OpenAI-compatible chat completion messages.
        */
-      text: string;
+      export interface ListOpenAIChatCompletionContentPartTextParam {
+        text: string;
 
-      /**
-       * Must be "text" to identify this as text content
-       */
-      type: 'text';
+        type?: 'text';
+      }
     }
 
     /**
-     * Tool call specification for OpenAI-compatible chat completion responses.
+     * A message containing the model's (assistant) response in an OpenAI-compatible
+     * chat completion request.
      */
-    export interface ToolCall {
-      /**
-       * Must be "function" to identify this as a function call
-       */
-      type: 'function';
+    export interface OpenAIAssistantMessageParamOutput {
+      content?:
+        | string
+        | Array<OpenAIAssistantMessageParamOutput.ListOpenAIChatCompletionContentPartTextParam>
+        | null;
 
-      /**
-       * (Optional) Unique identifier for the tool call
-       */
-      id?: string;
+      name?: string | null;
 
-      /**
-       * (Optional) Function call details
-       */
-      function?: ToolCall.Function;
+      role?: 'assistant';
+
+      tool_calls?: Array<OpenAIAssistantMessageParamOutput.ToolCall> | null;
+    }
 
+    export namespace OpenAIAssistantMessageParamOutput {
       /**
-       * (Optional) Index of the tool call in the list
+       * Text content part for OpenAI-compatible chat completion messages.
        */
-      index?: number;
-    }
+      export interface ListOpenAIChatCompletionContentPartTextParam {
+        text: string;
+
+        type?: 'text';
+      }
 
-    export namespace ToolCall {
       /**
-       * (Optional) Function call details
+       * Tool call specification for OpenAI-compatible chat completion responses.
        */
-      export interface Function {
+      export interface ToolCall {
+        id?: string | null;
+
         /**
-         * (Optional) Arguments to pass to the function as a JSON string
+         * Function call details for OpenAI-compatible tool calls.
          */
-        arguments?: string;
+        function?: ToolCall.Function | null;
+
+        index?: number | null;
+
+        type?: 'function';
+      }
 
+      export namespace ToolCall {
         /**
-         * (Optional) Name of the function to call
+         * Function call details for OpenAI-compatible tool calls.
          */
-        name?: string;
+        export interface Function {
+          arguments?: string | null;
+
+          name?: string | null;
+        }
       }
     }
-  }
 
-  /**
-   * A message representing the result of a tool invocation in an OpenAI-compatible
-   * chat completion request.
-   */
-  export interface OpenAIToolMessageParam {
     /**
-     * The response content from the tool
+     * A message representing the result of a tool invocation in an OpenAI-compatible
+     * chat completion request.
      */
-    content: string | Array<OpenAIToolMessageParam.UnionMember1>;
+    export interface OpenAIToolMessageParam {
+      content: string | Array<OpenAIToolMessageParam.ListOpenAIChatCompletionContentPartTextParam>;
 
-    /**
-     * Must be "tool" to identify this as a tool response
-     */
-    role: 'tool';
+      tool_call_id: string;
 
-    /**
-     * Unique identifier for the tool call this response is for
-     */
-    tool_call_id: string;
-  }
+      role?: 'tool';
+    }
 
-  export namespace OpenAIToolMessageParam {
-    /**
-     * Text content part for OpenAI-compatible chat completion messages.
-     */
-    export interface UnionMember1 {
+    export namespace OpenAIToolMessageParam {
       /**
-       * The text content of the message
+       * Text content part for OpenAI-compatible chat completion messages.
        */
-      text: string;
+      export interface ListOpenAIChatCompletionContentPartTextParam {
+        text: string;
 
-      /**
-       * Must be "text" to identify this as text content
-       */
-      type: 'text';
+        type?: 'text';
+      }
     }
-  }
 
-  /**
-   * A message from the developer in an OpenAI-compatible chat completion request.
-   */
-  export interface OpenAIDeveloperMessageParam {
     /**
-     * The content of the developer message
+     * A message from the developer in an OpenAI-compatible chat completion request.
      */
-    content: string | Array<OpenAIDeveloperMessageParam.UnionMember1>;
+    export interface OpenAIDeveloperMessageParam {
+      content: string | Array<OpenAIDeveloperMessageParam.ListOpenAIChatCompletionContentPartTextParam>;
 
-    /**
-     * Must be "developer" to identify this as a developer message
-     */
-    role: 'developer';
+      name?: string | null;
 
-    /**
-     * (Optional) The name of the developer message participant.
-     */
-    name?: string;
-  }
+      role?: 'developer';
+    }
+
+    export namespace OpenAIDeveloperMessageParam {
+      /**
+       * Text content part for OpenAI-compatible chat completion messages.
+       */
+      export interface ListOpenAIChatCompletionContentPartTextParam {
+        text: string;
+
+        type?: 'text';
+      }
+    }
 
-  export namespace OpenAIDeveloperMessageParam {
     /**
-     * Text content part for OpenAI-compatible chat completion messages.
+     * Usage information for OpenAI chat completion.
      */
-    export interface UnionMember1 {
+    export interface Usage {
+      completion_tokens: number;
+
+      prompt_tokens: number;
+
+      total_tokens: number;
+
       /**
-       * The text content of the message
+       * Token details for output tokens in OpenAI chat completion usage.
        */
-      text: string;
+      completion_tokens_details?: Usage.CompletionTokensDetails | null;
+
+      /**
+       * Token details for prompt tokens in OpenAI chat completion usage.
+       */
+      prompt_tokens_details?: Usage.PromptTokensDetails | null;
+    }
+
+    export namespace Usage {
+      /**
+       * Token details for output tokens in OpenAI chat completion usage.
+       */
+      export interface CompletionTokensDetails {
+        reasoning_tokens?: number | null;
+      }
 
       /**
-       * Must be "text" to identify this as text content
+       * Token details for prompt tokens in OpenAI chat completion usage.
        */
-      type: 'text';
+      export interface PromptTokensDetails {
+        cached_tokens?: number | null;
+      }
     }
   }
 }
@@ -1960,173 +1540,94 @@ export namespace CompletionListResponse {
 export type CompletionCreateParams = CompletionCreateParamsNonStreaming | CompletionCreateParamsStreaming;
 
 export interface CompletionCreateParamsBase {
-  /**
-   * List of messages in the conversation.
-   */
   messages: Array<
-    | CompletionCreateParams.OpenAIUserMessageParam
+    | CompletionCreateParams.OpenAIUserMessageParamInput
     | CompletionCreateParams.OpenAISystemMessageParam
-    | CompletionCreateParams.OpenAIAssistantMessageParam
+    | CompletionCreateParams.OpenAIAssistantMessageParamInput
     | CompletionCreateParams.OpenAIToolMessageParam
     | CompletionCreateParams.OpenAIDeveloperMessageParam
   >;
 
-  /**
-   * The identifier of the model to use. The model must be registered with Llama
-   * Stack and available via the /models endpoint.
-   */
   model: string;
 
-  /**
-   * (Optional) The penalty for repeated tokens.
-   */
-  frequency_penalty?: number;
+  frequency_penalty?: number | null;
 
-  /**
-   * (Optional) The function call to use.
-   */
-  function_call?: string | { [key: string]: boolean | number | string | Array<unknown> | unknown | null };
+  function_call?: string | { [key: string]: unknown } | null;
 
-  /**
-   * (Optional) List of functions to use.
-   */
-  functions?: Array<{ [key: string]: boolean | number | string | Array<unknown> | unknown | null }>;
+  functions?: Array<{ [key: string]: unknown }> | null;
 
-  /**
-   * (Optional) The logit bias to use.
-   */
-  logit_bias?: { [key: string]: number };
+  logit_bias?: { [key: string]: number } | null;
 
-  /**
-   * (Optional) The log probabilities to use.
-   */
-  logprobs?: boolean;
+  logprobs?: boolean | null;
 
-  /**
-   * (Optional) The maximum number of tokens to generate.
-   */
-  max_completion_tokens?: number;
+  max_completion_tokens?: number | null;
 
-  /**
-   * (Optional) The maximum number of tokens to generate.
-   */
-  max_tokens?: number;
+  max_tokens?: number | null;
 
-  /**
-   * (Optional) The number of completions to generate.
-   */
-  n?: number;
+  n?: number | null;
 
-  /**
-   * (Optional) Whether to parallelize tool calls.
-   */
-  parallel_tool_calls?: boolean;
+  parallel_tool_calls?: boolean | null;
 
-  /**
-   * (Optional) The penalty for repeated tokens.
-   */
-  presence_penalty?: number;
+  presence_penalty?: number | null;
 
   /**
-   * (Optional) The response format to use.
+   * Text response format for OpenAI-compatible chat completion requests.
    */
   response_format?:
     | CompletionCreateParams.OpenAIResponseFormatText
     | CompletionCreateParams.OpenAIResponseFormatJsonSchema
-    | CompletionCreateParams.OpenAIResponseFormatJsonObject;
+    | CompletionCreateParams.OpenAIResponseFormatJsonObject
+    | null;
 
-  /**
-   * (Optional) The seed to use.
-   */
-  seed?: number;
+  seed?: number | null;
 
-  /**
-   * (Optional) The stop tokens to use.
-   */
-  stop?: string | Array<string>;
+  stop?: string | Array<string> | null;
 
-  /**
-   * (Optional) Whether to stream the response.
-   */
-  stream?: boolean;
+  stream?: boolean | null;
 
-  /**
-   * (Optional) The stream options to use.
-   */
-  stream_options?: { [key: string]: boolean | number | string | Array<unknown> | unknown | null };
+  stream_options?: { [key: string]: unknown } | null;
 
-  /**
-   * (Optional) The temperature to use.
-   */
-  temperature?: number;
+  temperature?: number | null;
 
-  /**
-   * (Optional) The tool choice to use.
-   */
-  tool_choice?: string | { [key: string]: boolean | number | string | Array<unknown> | unknown | null };
+  tool_choice?: string | { [key: string]: unknown } | null;
 
-  /**
-   * (Optional) The tools to use.
-   */
-  tools?: Array<{ [key: string]: boolean | number | string | Array<unknown> | unknown | null }>;
+  tools?: Array<{ [key: string]: unknown }> | null;
 
-  /**
-   * (Optional) The top log probabilities to use.
-   */
-  top_logprobs?: number;
+  top_logprobs?: number | null;
 
-  /**
-   * (Optional) The top p to use.
-   */
-  top_p?: number;
+  top_p?: number | null;
 
-  /**
-   * (Optional) The user to use.
-   */
-  user?: string;
+  user?: string | null;
+
+  [k: string]: unknown;
 }
 
 export namespace CompletionCreateParams {
   /**
    * A message from the user in an OpenAI-compatible chat completion request.
    */
-  export interface OpenAIUserMessageParam {
-    /**
-     * The content of the message, which can include text and other media
-     */
+  export interface OpenAIUserMessageParamInput {
     content:
       | string
       | Array<
-          | OpenAIUserMessageParam.OpenAIChatCompletionContentPartTextParam
-          | OpenAIUserMessageParam.OpenAIChatCompletionContentPartImageParam
-          | OpenAIUserMessageParam.OpenAIFile
+          | OpenAIUserMessageParamInput.OpenAIChatCompletionContentPartTextParam
+          | OpenAIUserMessageParamInput.OpenAIChatCompletionContentPartImageParam
+          | OpenAIUserMessageParamInput.OpenAIFile
         >;
 
-    /**
-     * Must be "user" to identify this as a user message
-     */
-    role: 'user';
+    name?: string | null;
 
-    /**
-     * (Optional) The name of the user message participant.
-     */
-    name?: string;
+    role?: 'user';
   }
 
-  export namespace OpenAIUserMessageParam {
+  export namespace OpenAIUserMessageParamInput {
     /**
      * Text content part for OpenAI-compatible chat completion messages.
      */
     export interface OpenAIChatCompletionContentPartTextParam {
-      /**
-       * The text content of the message
-       */
       text: string;
 
-      /**
-       * Must be "text" to identify this as text content
-       */
-      type: 'text';
+      type?: 'text';
     }
 
     /**
@@ -2134,46 +1635,37 @@ export namespace CompletionCreateParams {
      */
     export interface OpenAIChatCompletionContentPartImageParam {
       /**
-       * Image URL specification and processing details
+       * Image URL specification for OpenAI-compatible chat completion messages.
        */
       image_url: OpenAIChatCompletionContentPartImageParam.ImageURL;
 
-      /**
-       * Must be "image_url" to identify this as image content
-       */
-      type: 'image_url';
+      type?: 'image_url';
     }
 
     export namespace OpenAIChatCompletionContentPartImageParam {
       /**
-       * Image URL specification and processing details
+       * Image URL specification for OpenAI-compatible chat completion messages.
        */
       export interface ImageURL {
-        /**
-         * URL of the image to include in the message
-         */
         url: string;
 
-        /**
-         * (Optional) Level of detail for image processing. Can be "low", "high", or "auto"
-         */
-        detail?: string;
+        detail?: string | null;
       }
     }
 
     export interface OpenAIFile {
       file: OpenAIFile.File;
 
-      type: 'file';
+      type?: 'file';
     }
 
     export namespace OpenAIFile {
       export interface File {
-        file_data?: string;
+        file_data?: string | null;
 
-        file_id?: string;
+        file_id?: string | null;
 
-        filename?: string;
+        filename?: string | null;
       }
     }
   }
@@ -2182,38 +1674,21 @@ export namespace CompletionCreateParams {
    * A system message providing instructions or context to the model.
    */
   export interface OpenAISystemMessageParam {
-    /**
-     * The content of the "system prompt". If multiple system messages are provided,
-     * they are concatenated. The underlying Llama Stack code may also add other system
-     * messages (for example, for formatting tool definitions).
-     */
-    content: string | Array<OpenAISystemMessageParam.UnionMember1>;
+    content: string | Array<OpenAISystemMessageParam.ListOpenAIChatCompletionContentPartTextParam>;
 
-    /**
-     * Must be "system" to identify this as a system message
-     */
-    role: 'system';
+    name?: string | null;
 
-    /**
-     * (Optional) The name of the system message participant.
-     */
-    name?: string;
+    role?: 'system';
   }
 
   export namespace OpenAISystemMessageParam {
     /**
      * Text content part for OpenAI-compatible chat completion messages.
      */
-    export interface UnionMember1 {
-      /**
-       * The text content of the message
-       */
+    export interface ListOpenAIChatCompletionContentPartTextParam {
       text: string;
 
-      /**
-       * Must be "text" to identify this as text content
-       */
-      type: 'text';
+      type?: 'text';
     }
   }
 
@@ -2221,83 +1696,53 @@ export namespace CompletionCreateParams {
    * A message containing the model's (assistant) response in an OpenAI-compatible
    * chat completion request.
    */
-  export interface OpenAIAssistantMessageParam {
-    /**
-     * Must be "assistant" to identify this as the model's response
-     */
-    role: 'assistant';
+  export interface OpenAIAssistantMessageParamInput {
+    content?:
+      | string
+      | Array<OpenAIAssistantMessageParamInput.ListOpenAIChatCompletionContentPartTextParam>
+      | null;
 
-    /**
-     * The content of the model's response
-     */
-    content?: string | Array<OpenAIAssistantMessageParam.UnionMember1>;
+    name?: string | null;
 
-    /**
-     * (Optional) The name of the assistant message participant.
-     */
-    name?: string;
+    role?: 'assistant';
 
-    /**
-     * List of tool calls. Each tool call is an OpenAIChatCompletionToolCall object.
-     */
-    tool_calls?: Array<OpenAIAssistantMessageParam.ToolCall>;
+    tool_calls?: Array<OpenAIAssistantMessageParamInput.ToolCall> | null;
   }
 
-  export namespace OpenAIAssistantMessageParam {
+  export namespace OpenAIAssistantMessageParamInput {
     /**
      * Text content part for OpenAI-compatible chat completion messages.
      */
-    export interface UnionMember1 {
-      /**
-       * The text content of the message
-       */
+    export interface ListOpenAIChatCompletionContentPartTextParam {
       text: string;
 
-      /**
-       * Must be "text" to identify this as text content
-       */
-      type: 'text';
+      type?: 'text';
     }
 
     /**
      * Tool call specification for OpenAI-compatible chat completion responses.
      */
     export interface ToolCall {
-      /**
-       * Must be "function" to identify this as a function call
-       */
-      type: 'function';
+      id?: string | null;
 
       /**
-       * (Optional) Unique identifier for the tool call
+       * Function call details for OpenAI-compatible tool calls.
        */
-      id?: string;
+      function?: ToolCall.Function | null;
 
-      /**
-       * (Optional) Function call details
-       */
-      function?: ToolCall.Function;
+      index?: number | null;
 
-      /**
-       * (Optional) Index of the tool call in the list
-       */
-      index?: number;
+      type?: 'function';
     }
 
     export namespace ToolCall {
       /**
-       * (Optional) Function call details
+       * Function call details for OpenAI-compatible tool calls.
        */
       export interface Function {
-        /**
-         * (Optional) Arguments to pass to the function as a JSON string
-         */
-        arguments?: string;
+        arguments?: string | null;
 
-        /**
-         * (Optional) Name of the function to call
-         */
-        name?: string;
+        name?: string | null;
       }
     }
   }
@@ -2307,36 +1752,21 @@ export namespace CompletionCreateParams {
    * chat completion request.
    */
   export interface OpenAIToolMessageParam {
-    /**
-     * The response content from the tool
-     */
-    content: string | Array<OpenAIToolMessageParam.UnionMember1>;
-
-    /**
-     * Must be "tool" to identify this as a tool response
-     */
-    role: 'tool';
+    content: string | Array<OpenAIToolMessageParam.ListOpenAIChatCompletionContentPartTextParam>;
 
-    /**
-     * Unique identifier for the tool call this response is for
-     */
     tool_call_id: string;
+
+    role?: 'tool';
   }
 
   export namespace OpenAIToolMessageParam {
     /**
      * Text content part for OpenAI-compatible chat completion messages.
      */
-    export interface UnionMember1 {
-      /**
-       * The text content of the message
-       */
+    export interface ListOpenAIChatCompletionContentPartTextParam {
       text: string;
 
-      /**
-       * Must be "text" to identify this as text content
-       */
-      type: 'text';
+      type?: 'text';
     }
   }
 
@@ -2344,36 +1774,21 @@ export namespace CompletionCreateParams {
    * A message from the developer in an OpenAI-compatible chat completion request.
    */
   export interface OpenAIDeveloperMessageParam {
-    /**
-     * The content of the developer message
-     */
-    content: string | Array<OpenAIDeveloperMessageParam.UnionMember1>;
+    content: string | Array<OpenAIDeveloperMessageParam.ListOpenAIChatCompletionContentPartTextParam>;
 
-    /**
-     * Must be "developer" to identify this as a developer message
-     */
-    role: 'developer';
+    name?: string | null;
 
-    /**
-     * (Optional) The name of the developer message participant.
-     */
-    name?: string;
+    role?: 'developer';
   }
 
   export namespace OpenAIDeveloperMessageParam {
     /**
      * Text content part for OpenAI-compatible chat completion messages.
      */
-    export interface UnionMember1 {
-      /**
-       * The text content of the message
-       */
+    export interface ListOpenAIChatCompletionContentPartTextParam {
       text: string;
 
-      /**
-       * Must be "text" to identify this as text content
-       */
-      type: 'text';
+      type?: 'text';
     }
   }
 
@@ -2381,10 +1796,7 @@ export namespace CompletionCreateParams {
    * Text response format for OpenAI-compatible chat completion requests.
    */
   export interface OpenAIResponseFormatText {
-    /**
-     * Must be "text" to indicate plain text response format
-     */
-    type: 'text';
+    type?: 'text';
   }
 
   /**
@@ -2392,40 +1804,25 @@ export namespace CompletionCreateParams {
    */
   export interface OpenAIResponseFormatJsonSchema {
     /**
-     * The JSON schema specification for the response
+     * JSON schema specification for OpenAI-compatible structured response format.
      */
     json_schema: OpenAIResponseFormatJsonSchema.JsonSchema;
 
-    /**
-     * Must be "json_schema" to indicate structured JSON response format
-     */
-    type: 'json_schema';
+    type?: 'json_schema';
   }
 
   export namespace OpenAIResponseFormatJsonSchema {
     /**
-     * The JSON schema specification for the response
+     * JSON schema specification for OpenAI-compatible structured response format.
      */
     export interface JsonSchema {
-      /**
-       * Name of the schema
-       */
-      name: string;
+      description?: string | null;
 
-      /**
-       * (Optional) Description of the schema
-       */
-      description?: string;
+      name?: string;
 
-      /**
-       * (Optional) The JSON schema definition
-       */
-      schema?: { [key: string]: boolean | number | string | Array<unknown> | unknown | null };
+      schema?: { [key: string]: unknown } | null;
 
-      /**
-       * (Optional) Whether to enforce strict adherence to the schema
-       */
-      strict?: boolean;
+      strict?: boolean | null;
     }
   }
 
@@ -2433,10 +1830,7 @@ export namespace CompletionCreateParams {
    * JSON object response format for OpenAI-compatible chat completion requests.
    */
   export interface OpenAIResponseFormatJsonObject {
-    /**
-     * Must be "json_object" to indicate generic JSON object response format
-     */
-    type: 'json_object';
+    type?: 'json_object';
   }
 
   export type CompletionCreateParamsNonStreaming = CompletionsAPI.CompletionCreateParamsNonStreaming;
@@ -2444,39 +1838,35 @@ export namespace CompletionCreateParams {
 }
 
 export interface CompletionCreateParamsNonStreaming extends CompletionCreateParamsBase {
-  /**
-   * (Optional) Whether to stream the response.
-   */
-  stream?: false;
+  stream?: false | null;
+
+  [k: string]: unknown;
 }
 
 export interface CompletionCreateParamsStreaming extends CompletionCreateParamsBase {
-  /**
-   * (Optional) Whether to stream the response.
-   */
   stream: true;
+
+  [k: string]: unknown;
 }
 
-export interface CompletionListParams extends OpenAICursorPageParams {
-  /**
-   * The model to filter by.
-   */
-  model?: string;
+export interface CompletionListParams {
+  after?: string | null;
+
+  limit?: number | null;
+
+  model?: string | null;
 
   /**
-   * The order to sort the chat completions by: "asc" or "desc". Defaults to "desc".
+   * Sort order for paginated responses.
    */
-  order?: 'asc' | 'desc';
+  order?: 'asc' | 'desc' | null;
 }
 
-Completions.CompletionListResponsesOpenAICursorPage = CompletionListResponsesOpenAICursorPage;
-
 export declare namespace Completions {
   export {
     type CompletionCreateResponse as CompletionCreateResponse,
     type CompletionRetrieveResponse as CompletionRetrieveResponse,
     type CompletionListResponse as CompletionListResponse,
-    CompletionListResponsesOpenAICursorPage as CompletionListResponsesOpenAICursorPage,
     type CompletionCreateParams as CompletionCreateParams,
     type CompletionCreateParamsNonStreaming as CompletionCreateParamsNonStreaming,
     type CompletionCreateParamsStreaming as CompletionCreateParamsStreaming,