llama-stack-client 0.2.18-rc1 → 0.2.19-rc1

package/src/resources/chat/completions.ts

@@ -6,6 +6,7 @@ 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 {
@@ -46,19 +47,30 @@ export class Completions extends APIResource {
   /**
    * List all chat completions.
    */
-  list(query?: CompletionListParams, options?: Core.RequestOptions): Core.APIPromise<CompletionListResponse>;
-  list(options?: Core.RequestOptions): Core.APIPromise<CompletionListResponse>;
+  list(
+    query?: CompletionListParams,
+    options?: Core.RequestOptions,
+  ): Core.PagePromise<CompletionListResponsesOpenAICursorPage, CompletionListResponse>;
+  list(
+    options?: Core.RequestOptions,
+  ): Core.PagePromise<CompletionListResponsesOpenAICursorPage, CompletionListResponse>;
   list(
     query: CompletionListParams | Core.RequestOptions = {},
     options?: Core.RequestOptions,
-  ): Core.APIPromise<CompletionListResponse> {
+  ): Core.PagePromise<CompletionListResponsesOpenAICursorPage, CompletionListResponse> {
     if (isRequestOptions(query)) {
       return this.list({}, query);
     }
-    return this._client.get('/v1/openai/v1/chat/completions', { query, ...options });
+    return this._client.getAPIList(
+      '/v1/openai/v1/chat/completions',
+      CompletionListResponsesOpenAICursorPage,
+      { query, ...options },
+    );
   }
 }
 
+export class CompletionListResponsesOpenAICursorPage extends OpenAICursorPage<CompletionListResponse> {}
+
 /**
  * Response from an OpenAI-compatible chat completion request.
  */
@@ -1217,756 +1229,724 @@ export namespace CompletionRetrieveResponse {
   }
 }
 
-/**
- * Response from listing OpenAI-compatible chat completions.
- */
 export interface CompletionListResponse {
   /**
-   * List of chat completion objects with their input messages
+   * The ID of the chat completion
    */
-  data: Array<CompletionListResponse.Data>;
+  id: string;
 
   /**
-   * ID of the first completion in this list
+   * List of choices
    */
-  first_id: string;
+  choices: Array<CompletionListResponse.Choice>;
 
   /**
-   * Whether there are more completions available beyond this list
+   * The Unix timestamp in seconds when the chat completion was created
    */
-  has_more: boolean;
+  created: number;
+
+  input_messages: Array<
+    | CompletionListResponse.OpenAIUserMessageParam
+    | CompletionListResponse.OpenAISystemMessageParam
+    | CompletionListResponse.OpenAIAssistantMessageParam
+    | CompletionListResponse.OpenAIToolMessageParam
+    | CompletionListResponse.OpenAIDeveloperMessageParam
+  >;
 
   /**
-   * ID of the last completion in this list
+   * The model that was used to generate the chat completion
    */
-  last_id: string;
+  model: string;
 
   /**
-   * Must be "list" to identify this as a list response
+   * The object type, which will be "chat.completion"
    */
-  object: 'list';
+  object: 'chat.completion';
 }
 
 export namespace CompletionListResponse {
-  export interface Data {
-    /**
-     * The ID of the chat completion
-     */
-    id: string;
-
+  /**
+   * A choice from an OpenAI-compatible chat completion response.
+   */
+  export interface Choice {
     /**
-     * List of choices
+     * The reason the model stopped generating
      */
-    choices: Array<Data.Choice>;
+    finish_reason: string;
 
     /**
-     * The Unix timestamp in seconds when the chat completion was created
+     * The index of the choice
      */
-    created: number;
-
-    input_messages: Array<
-      | Data.OpenAIUserMessageParam
-      | Data.OpenAISystemMessageParam
-      | Data.OpenAIAssistantMessageParam
-      | Data.OpenAIToolMessageParam
-      | Data.OpenAIDeveloperMessageParam
-    >;
+    index: number;
 
     /**
-     * The model that was used to generate the chat completion
+     * The message from the model
      */
-    model: string;
+    message:
+      | Choice.OpenAIUserMessageParam
+      | Choice.OpenAISystemMessageParam
+      | Choice.OpenAIAssistantMessageParam
+      | Choice.OpenAIToolMessageParam
+      | Choice.OpenAIDeveloperMessageParam;
 
     /**
-     * The object type, which will be "chat.completion"
+     * (Optional) The log probabilities for the tokens in the message
      */
-    object: 'chat.completion';
+    logprobs?: Choice.Logprobs;
   }
 
-  export namespace Data {
+  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 OpenAIUserMessageParam {
       /**
-       * The index of the choice
+       * The content of the message, which can include text and other media
        */
-      index: number;
+      content:
+        | string
+        | Array<
+            | OpenAIUserMessageParam.OpenAIChatCompletionContentPartTextParam
+            | OpenAIUserMessageParam.OpenAIChatCompletionContentPartImageParam
+            | OpenAIUserMessageParam.OpenAIFile
+          >;
 
       /**
-       * The message from the model
+       * Must be "user" to identify this as a user message
        */
-      message:
-        | Choice.OpenAIUserMessageParam
-        | Choice.OpenAISystemMessageParam
-        | Choice.OpenAIAssistantMessageParam
-        | Choice.OpenAIToolMessageParam
-        | Choice.OpenAIDeveloperMessageParam;
+      role: 'user';
 
       /**
-       * (Optional) The log probabilities for the tokens in the message
+       * (Optional) The name of the user message participant.
        */
-      logprobs?: Choice.Logprobs;
+      name?: string;
     }
 
-    export namespace Choice {
+    export namespace OpenAIUserMessageParam {
       /**
-       * A message from the user in an OpenAI-compatible chat completion request.
+       * Text content part for OpenAI-compatible chat completion messages.
        */
-      export interface OpenAIUserMessageParam {
+      export interface OpenAIChatCompletionContentPartTextParam {
         /**
-         * The content of the message, which can include text and other media
+         * The text content of the message
          */
-        content:
-          | string
-          | Array<
-              | OpenAIUserMessageParam.OpenAIChatCompletionContentPartTextParam
-              | OpenAIUserMessageParam.OpenAIChatCompletionContentPartImageParam
-              | OpenAIUserMessageParam.OpenAIFile
-            >;
+        text: string;
 
         /**
-         * Must be "user" to identify this as a user message
+         * Must be "text" to identify this as text content
          */
-        role: 'user';
+        type: 'text';
+      }
 
+      /**
+       * Image content part for OpenAI-compatible chat completion messages.
+       */
+      export interface OpenAIChatCompletionContentPartImageParam {
         /**
-         * (Optional) The name of the user message participant.
+         * Image URL specification and processing details
          */
-        name?: string;
-      }
+        image_url: OpenAIChatCompletionContentPartImageParam.ImageURL;
 
-      export namespace OpenAIUserMessageParam {
         /**
-         * Text content part for OpenAI-compatible chat completion messages.
+         * Must be "image_url" to identify this as image content
          */
-        export interface OpenAIChatCompletionContentPartTextParam {
-          /**
-           * The text content of the message
-           */
-          text: string;
-
-          /**
-           * Must be "text" to identify this as text content
-           */
-          type: 'text';
-        }
+        type: 'image_url';
+      }
 
+      export namespace OpenAIChatCompletionContentPartImageParam {
         /**
-         * Image content part for OpenAI-compatible chat completion messages.
+         * Image URL specification and processing details
          */
-        export interface OpenAIChatCompletionContentPartImageParam {
-          /**
-           * Image URL specification and processing details
-           */
-          image_url: OpenAIChatCompletionContentPartImageParam.ImageURL;
-
+        export interface ImageURL {
           /**
-           * Must be "image_url" to identify this as image content
+           * URL of the image to include in the message
            */
-          type: 'image_url';
-        }
+          url: string;
 
-        export namespace OpenAIChatCompletionContentPartImageParam {
           /**
-           * Image URL specification and processing details
+           * (Optional) Level of detail for image processing. Can be "low", "high", or "auto"
            */
-          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;
         }
+      }
 
-        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;
 
-            file_id?: string;
+          file_id?: string;
 
-            filename?: string;
-          }
+          filename?: string;
         }
       }
+    }
 
+    /**
+     * A system message providing instructions or context to the model.
+     */
+    export interface OpenAISystemMessageParam {
       /**
-       * A system message providing instructions or context to the model.
+       * 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).
        */
-      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';
-
-        /**
-         * (Optional) The name of the system message participant.
-         */
-        name?: string;
-      }
-
-      export namespace OpenAISystemMessageParam {
-        /**
-         * Text content part for OpenAI-compatible chat completion messages.
-         */
-        export interface UnionMember1 {
-          /**
-           * The text content of the message
-           */
-          text: string;
-
-          /**
-           * Must be "text" to identify this as text content
-           */
-          type: 'text';
-        }
-      }
+      content: string | Array<OpenAISystemMessageParam.UnionMember1>;
 
       /**
-       * A message containing the model's (assistant) response in an OpenAI-compatible
-       * chat completion request.
+       * Must be "system" to identify this as a system message
        */
-      export interface OpenAIAssistantMessageParam {
-        /**
-         * Must be "assistant" to identify this as the model's response
-         */
-        role: 'assistant';
+      role: 'system';
 
-        /**
-         * The content of the model's response
-         */
-        content?: string | Array<OpenAIAssistantMessageParam.UnionMember1>;
+      /**
+       * (Optional) The name of the system message participant.
+       */
+      name?: string;
+    }
 
+    export namespace OpenAISystemMessageParam {
+      /**
+       * Text content part for OpenAI-compatible chat completion messages.
+       */
+      export interface UnionMember1 {
         /**
-         * (Optional) The name of the assistant message participant.
+         * The text content of the message
          */
-        name?: string;
+        text: string;
 
         /**
-         * List of tool calls. Each tool call is an OpenAIChatCompletionToolCall object.
+         * Must be "text" to identify this as text content
          */
-        tool_calls?: Array<OpenAIAssistantMessageParam.ToolCall>;
+        type: 'text';
       }
+    }
 
-      export namespace OpenAIAssistantMessageParam {
-        /**
-         * Text content part for OpenAI-compatible chat completion messages.
-         */
-        export interface UnionMember1 {
-          /**
-           * The text content of the message
-           */
-          text: string;
-
-          /**
-           * Must be "text" to identify this as text content
-           */
-          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';
+    /**
+     * 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';
 
-          /**
-           * (Optional) Unique identifier for the tool call
-           */
-          id?: string;
+      /**
+       * The content of the model's response
+       */
+      content?: string | Array<OpenAIAssistantMessageParam.UnionMember1>;
 
-          /**
-           * (Optional) Function call details
-           */
-          function?: ToolCall.Function;
+      /**
+       * (Optional) The name of the assistant message participant.
+       */
+      name?: string;
 
-          /**
-           * (Optional) Index of the tool call in the list
-           */
-          index?: number;
-        }
+      /**
+       * List of tool calls. Each tool call is an OpenAIChatCompletionToolCall object.
+       */
+      tool_calls?: Array<OpenAIAssistantMessageParam.ToolCall>;
+    }
 
-        export namespace ToolCall {
-          /**
-           * (Optional) Function call details
-           */
-          export interface Function {
-            /**
-             * (Optional) Arguments to pass to the function as a JSON string
-             */
-            arguments?: string;
+    export namespace OpenAIAssistantMessageParam {
+      /**
+       * Text content part for OpenAI-compatible chat completion messages.
+       */
+      export interface UnionMember1 {
+        /**
+         * The text content of the message
+         */
+        text: string;
 
-            /**
-             * (Optional) Name of the function to call
-             */
-            name?: string;
-          }
-        }
+        /**
+         * Must be "text" to identify this as text content
+         */
+        type: 'text';
       }
 
       /**
-       * A message representing the result of a tool invocation in an OpenAI-compatible
-       * chat completion request.
+       * Tool call specification for OpenAI-compatible chat completion responses.
        */
-      export interface OpenAIToolMessageParam {
+      export interface ToolCall {
         /**
-         * The response content from the tool
+         * Must be "function" to identify this as a function call
          */
-        content: string | Array<OpenAIToolMessageParam.UnionMember1>;
+        type: 'function';
 
         /**
-         * Must be "tool" to identify this as a tool response
+         * (Optional) Unique identifier for the tool call
          */
-        role: 'tool';
+        id?: string;
 
         /**
-         * Unique identifier for the tool call this response is for
+         * (Optional) Function call details
          */
-        tool_call_id: string;
+        function?: ToolCall.Function;
+
+        /**
+         * (Optional) Index of the tool call in the list
+         */
+        index?: number;
       }
 
-      export namespace OpenAIToolMessageParam {
+      export namespace ToolCall {
         /**
-         * Text content part for OpenAI-compatible chat completion messages.
+         * (Optional) Function call details
          */
-        export interface UnionMember1 {
+        export interface Function {
           /**
-           * The text content of the message
+           * (Optional) Arguments to pass to the function as a JSON string
            */
-          text: string;
+          arguments?: string;
 
           /**
-           * Must be "text" to identify this as text content
+           * (Optional) Name of the function to call
            */
-          type: 'text';
+          name?: string;
         }
       }
+    }
 
+    /**
+     * A message representing the result of a tool invocation in an OpenAI-compatible
+     * chat completion request.
+     */
+    export interface OpenAIToolMessageParam {
       /**
-       * A message from the developer in an OpenAI-compatible chat completion request.
+       * The response content from the tool
        */
-      export interface OpenAIDeveloperMessageParam {
-        /**
-         * The content of the developer message
-         */
-        content: string | Array<OpenAIDeveloperMessageParam.UnionMember1>;
+      content: string | Array<OpenAIToolMessageParam.UnionMember1>;
+
+      /**
+       * 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;
+    }
 
+    export namespace OpenAIToolMessageParam {
+      /**
+       * Text content part for OpenAI-compatible chat completion messages.
+       */
+      export interface UnionMember1 {
         /**
-         * Must be "developer" to identify this as a developer message
+         * The text content of the message
          */
-        role: 'developer';
+        text: string;
 
         /**
-         * (Optional) The name of the developer message participant.
+         * Must be "text" to identify this as text content
          */
-        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;
+    /**
+     * 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>;
 
-          /**
-           * Must be "text" to identify this as text content
-           */
-          type: 'text';
-        }
-      }
+      /**
+       * Must be "developer" to identify this as a developer message
+       */
+      role: 'developer';
 
       /**
-       * (Optional) The log probabilities for the tokens in the message
+       * (Optional) The name of the developer message participant.
        */
-      export interface Logprobs {
+      name?: string;
+    }
+
+    export namespace OpenAIDeveloperMessageParam {
+      /**
+       * Text content part for OpenAI-compatible chat completion messages.
+       */
+      export interface UnionMember1 {
         /**
-         * (Optional) The log probabilities for the tokens in the message
+         * The text content of the message
          */
-        content?: Array<Logprobs.Content>;
+        text: string;
 
         /**
-         * (Optional) The log probabilities for the tokens in the message
+         * Must be "text" to identify this as text content
          */
-        refusal?: Array<Logprobs.Refusal>;
+        type: 'text';
       }
+    }
 
-      export namespace Logprobs {
+    /**
+     * (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.
+       */
+      export interface Content {
+        token: string;
+
+        logprob: number;
+
+        top_logprobs: Array<Content.TopLogprob>;
+
+        bytes?: Array<number>;
+      }
+
+      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.
          */
-        export interface Content {
+        export interface TopLogprob {
           token: string;
 
           logprob: number;
 
-          top_logprobs: Array<Content.TopLogprob>;
-
           bytes?: Array<number>;
         }
+      }
 
-        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.
+       */
+      export interface Refusal {
+        token: string;
 
-            logprob: number;
+        logprob: number;
 
-            bytes?: Array<number>;
-          }
-        }
+        top_logprobs: Array<Refusal.TopLogprob>;
+
+        bytes?: Array<number>;
+      }
 
+      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.
          */
-        export interface Refusal {
+        export interface TopLogprob {
           token: string;
 
           logprob: number;
 
-          top_logprobs: Array<Refusal.TopLogprob>;
-
           bytes?: Array<number>;
         }
+      }
+    }
+  }
 
-        export namespace Refusal {
-          /**
-           * The top log probability for a token from an OpenAI-compatible chat completion
-           * response.
-           */
-          export interface TopLogprob {
-            token: string;
+  /**
+   * 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
+        >;
 
-            logprob: number;
+    /**
+     * Must be "user" to identify this as a user message
+     */
+    role: 'user';
 
-            bytes?: Array<number>;
-          }
-        }
-      }
-    }
+    /**
+     * (Optional) The name of the user message participant.
+     */
+    name?: string;
+  }
 
+  export namespace OpenAIUserMessageParam {
     /**
-     * A message from the user in an OpenAI-compatible chat completion request.
+     * Text content part for OpenAI-compatible chat completion messages.
      */
-    export interface OpenAIUserMessageParam {
+    export interface OpenAIChatCompletionContentPartTextParam {
       /**
-       * The content of the message, which can include text and other media
+       * The text content of the message
        */
-      content:
-        | string
-        | Array<
-            | OpenAIUserMessageParam.OpenAIChatCompletionContentPartTextParam
-            | OpenAIUserMessageParam.OpenAIChatCompletionContentPartImageParam
-            | OpenAIUserMessageParam.OpenAIFile
-          >;
+      text: string;
 
       /**
-       * Must be "user" to identify this as a user message
+       * Must be "text" to identify this as text content
        */
-      role: 'user';
+      type: 'text';
+    }
 
+    /**
+     * Image content part for OpenAI-compatible chat completion messages.
+     */
+    export interface OpenAIChatCompletionContentPartImageParam {
       /**
-       * (Optional) The name of the user message participant.
+       * Image URL specification and processing details
        */
-      name?: string;
-    }
+      image_url: OpenAIChatCompletionContentPartImageParam.ImageURL;
 
-    export namespace OpenAIUserMessageParam {
       /**
-       * Text content part for OpenAI-compatible chat completion messages.
+       * Must be "image_url" to identify this as image content
        */
-      export interface OpenAIChatCompletionContentPartTextParam {
-        /**
-         * The text content of the message
-         */
-        text: string;
-
-        /**
-         * Must be "text" to identify this as text content
-         */
-        type: 'text';
-      }
+      type: 'image_url';
+    }
 
+    export namespace OpenAIChatCompletionContentPartImageParam {
       /**
-       * Image content part for OpenAI-compatible chat completion messages.
+       * Image URL specification and processing details
        */
-      export interface OpenAIChatCompletionContentPartImageParam {
+      export interface ImageURL {
         /**
-         * Image URL specification and processing details
+         * URL of the image to include in the message
          */
-        image_url: OpenAIChatCompletionContentPartImageParam.ImageURL;
+        url: string;
 
         /**
-         * Must be "image_url" to identify this as image content
+         * (Optional) Level of detail for image processing. Can be "low", "high", or "auto"
          */
-        type: 'image_url';
+        detail?: string;
       }
+    }
 
-      export namespace OpenAIChatCompletionContentPartImageParam {
-        /**
-         * Image URL specification and processing details
-         */
-        export interface ImageURL {
-          /**
-           * URL of the image to include in the message
-           */
-          url: string;
+    export interface OpenAIFile {
+      file: OpenAIFile.File;
 
-          /**
-           * (Optional) Level of detail for image processing. Can be "low", "high", or "auto"
-           */
-          detail?: string;
-        }
-      }
+      type: 'file';
+    }
 
-      export interface OpenAIFile {
-        file: OpenAIFile.File;
+    export namespace OpenAIFile {
+      export interface File {
+        file_data?: string;
 
-        type: 'file';
+        file_id?: string;
+
+        filename?: string;
       }
+    }
+  }
 
-      export namespace OpenAIFile {
-        export interface File {
-          file_data?: string;
+  /**
+   * 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>;
 
-          file_id?: string;
+    /**
+     * Must be "system" to identify this as a system message
+     */
+    role: 'system';
 
-          filename?: string;
-        }
-      }
-    }
+    /**
+     * (Optional) The name of the system message participant.
+     */
+    name?: string;
+  }
 
+  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 {
+    export interface UnionMember1 {
       /**
-       * 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).
+       * The text content of the message
        */
-      content: string | Array<OpenAISystemMessageParam.UnionMember1>;
+      text: string;
 
       /**
-       * Must be "system" to identify this as a system message
+       * Must be "text" to identify this as text content
        */
-      role: 'system';
+      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.
+     */
+    name?: string;
+
+    /**
+     * List of tool calls. Each tool call is an OpenAIChatCompletionToolCall object.
+     */
+    tool_calls?: Array<OpenAIAssistantMessageParam.ToolCall>;
+  }
+
+  export namespace OpenAIAssistantMessageParam {
+    /**
+     * Text content part for OpenAI-compatible chat completion messages.
+     */
+    export interface UnionMember1 {
       /**
-       * (Optional) The name of the system message participant.
+       * The text content of the message
        */
-      name?: string;
-    }
+      text: string;
 
-    export namespace OpenAISystemMessageParam {
       /**
-       * Text content part for OpenAI-compatible chat completion messages.
+       * Must be "text" to identify this as text content
        */
-      export interface UnionMember1 {
-        /**
-         * The text content of the message
-         */
-        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.
+     * Tool call specification for OpenAI-compatible chat completion responses.
      */
-    export interface OpenAIAssistantMessageParam {
+    export interface ToolCall {
       /**
-       * Must be "assistant" to identify this as the model's response
+       * Must be "function" to identify this as a function call
        */
-      role: 'assistant';
+      type: 'function';
 
       /**
-       * The content of the model's response
+       * (Optional) Unique identifier for the tool call
        */
-      content?: string | Array<OpenAIAssistantMessageParam.UnionMember1>;
+      id?: string;
 
       /**
-       * (Optional) The name of the assistant message participant.
+       * (Optional) Function call details
        */
-      name?: string;
+      function?: ToolCall.Function;
 
       /**
-       * List of tool calls. Each tool call is an OpenAIChatCompletionToolCall object.
+       * (Optional) Index of the tool call in the list
        */
-      tool_calls?: Array<OpenAIAssistantMessageParam.ToolCall>;
+      index?: number;
     }
 
-    export namespace OpenAIAssistantMessageParam {
-      /**
-       * Text content part for OpenAI-compatible chat completion messages.
-       */
-      export interface UnionMember1 {
-        /**
-         * The text content of the message
-         */
-        text: string;
-
-        /**
-         * Must be "text" to identify this as text content
-         */
-        type: 'text';
-      }
-
+    export namespace ToolCall {
       /**
-       * Tool call specification for OpenAI-compatible chat completion responses.
+       * (Optional) Function call details
        */
-      export interface ToolCall {
-        /**
-         * Must be "function" to identify this as a function call
-         */
-        type: 'function';
-
-        /**
-         * (Optional) Unique identifier for the tool call
-         */
-        id?: string;
-
+      export interface Function {
         /**
-         * (Optional) Function call details
+         * (Optional) Arguments to pass to the function as a JSON string
          */
-        function?: ToolCall.Function;
+        arguments?: string;
 
         /**
-         * (Optional) Index of the tool call in the list
+         * (Optional) Name of the function to call
          */
-        index?: number;
+        name?: string;
       }
+    }
+  }
 
-      export namespace ToolCall {
-        /**
-         * (Optional) Function call details
-         */
-        export interface Function {
-          /**
-           * (Optional) Arguments to pass to the function as a JSON string
-           */
-          arguments?: string;
+  /**
+   * 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
+     */
+    content: string | Array<OpenAIToolMessageParam.UnionMember1>;
 
-          /**
-           * (Optional) Name of the function to call
-           */
-          name?: string;
-        }
-      }
-    }
+    /**
+     * Must be "tool" to identify this as a tool response
+     */
+    role: 'tool';
 
     /**
-     * A message representing the result of a tool invocation in an OpenAI-compatible
-     * chat completion request.
+     * Unique identifier for the tool call this response is for
      */
-    export interface OpenAIToolMessageParam {
-      /**
-       * The response content from the tool
-       */
-      content: string | Array<OpenAIToolMessageParam.UnionMember1>;
+    tool_call_id: string;
+  }
 
+  export namespace OpenAIToolMessageParam {
+    /**
+     * Text content part for OpenAI-compatible chat completion messages.
+     */
+    export interface UnionMember1 {
       /**
-       * Must be "tool" to identify this as a tool response
+       * The text content of the message
        */
-      role: 'tool';
+      text: string;
 
       /**
-       * Unique identifier for the tool call this response is for
+       * Must be "text" to identify this as text content
        */
-      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;
-
-        /**
-         * Must be "text" to identify this as text content
-         */
-        type: 'text';
-      }
-    }
+  /**
+   * 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>;
 
     /**
-     * A message from the developer in an OpenAI-compatible chat completion request.
+     * Must be "developer" to identify this as a developer message
      */
-    export interface OpenAIDeveloperMessageParam {
-      /**
-       * The content of the developer message
-       */
-      content: string | Array<OpenAIDeveloperMessageParam.UnionMember1>;
+    role: 'developer';
 
-      /**
-       * Must be "developer" to identify this as a developer message
-       */
-      role: 'developer';
+    /**
+     * (Optional) The name of the developer message participant.
+     */
+    name?: string;
+  }
 
+  export namespace OpenAIDeveloperMessageParam {
+    /**
+     * Text content part for OpenAI-compatible chat completion messages.
+     */
+    export interface UnionMember1 {
       /**
-       * (Optional) The name of the developer message participant.
+       * The text content of the message
        */
-      name?: string;
-    }
+      text: string;
 
-    export namespace OpenAIDeveloperMessageParam {
       /**
-       * Text content part for OpenAI-compatible chat completion messages.
+       * Must be "text" to identify this as text content
        */
-      export interface UnionMember1 {
-        /**
-         * The text content of the message
-         */
-        text: string;
-
-        /**
-         * Must be "text" to identify this as text content
-         */
-        type: 'text';
-      }
+      type: 'text';
     }
   }
 }
@@ -2471,17 +2451,7 @@ export interface CompletionCreateParamsStreaming extends CompletionCreateParamsB
   stream: true;
 }
 
-export interface CompletionListParams {
-  /**
-   * The ID of the last chat completion to return.
-   */
-  after?: string;
-
-  /**
-   * The maximum number of chat completions to return.
-   */
-  limit?: number;
-
+export interface CompletionListParams extends OpenAICursorPageParams {
   /**
    * The model to filter by.
    */
@@ -2493,11 +2463,14 @@ export interface CompletionListParams {
   order?: 'asc' | 'desc';
 }
 
+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,