llama-stack-client 0.4.3 → 0.4.4

package/dist/src/resources/chat/index.ts

@@ -0,0 +1,19 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+// All rights reserved.
+//
+// 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.
+
+export { Chat, type ChatCompletionChunk } from './chat';
+export {
+  Completions,
+  type CompletionCreateResponse,
+  type CompletionRetrieveResponse,
+  type CompletionListResponse,
+  type CompletionCreateParams,
+  type CompletionCreateParamsNonStreaming,
+  type CompletionCreateParamsStreaming,
+  type CompletionListParams,
+} from './completions';

package/dist/src/resources/chat.ts

@@ -0,0 +1,9 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+// All rights reserved.
+//
+// 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.
+
+export * from './chat/index';

package/dist/src/resources/completions.ts

@@ -0,0 +1,235 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+// All rights reserved.
+//
+// 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';
+import { APIPromise } from '../core';
+import * as Core from '../core';
+import * as CompletionsAPI from './completions';
+import { Stream } from '../streaming';
+
+export class Completions extends APIResource {
+  /**
+   * Create completion.
+   *
+   * Generate an OpenAI-compatible completion for the given prompt using the
+   * specified model.
+   */
+  create(
+    body: CompletionCreateParamsNonStreaming,
+    options?: Core.RequestOptions,
+  ): APIPromise<CompletionCreateResponse>;
+  create(
+    body: CompletionCreateParamsStreaming,
+    options?: Core.RequestOptions,
+  ): APIPromise<Stream<CompletionCreateResponse>>;
+  create(
+    body: CompletionCreateParamsBase,
+    options?: Core.RequestOptions,
+  ): APIPromise<Stream<CompletionCreateResponse> | CompletionCreateResponse>;
+  create(
+    body: CompletionCreateParams,
+    options?: Core.RequestOptions,
+  ): APIPromise<CompletionCreateResponse> | APIPromise<Stream<CompletionCreateResponse>> {
+    return this._client.post('/v1/completions', { body, ...options, stream: body.stream ?? false }) as
+      | APIPromise<CompletionCreateResponse>
+      | APIPromise<Stream<CompletionCreateResponse>>;
+  }
+}
+
+/**
+ * Response from an OpenAI-compatible completion request.
+ *
+ * :id: The ID of the completion :choices: List of choices :created: The Unix
+ * timestamp in seconds when the completion was created :model: The model that was
+ * used to generate the completion :object: The object type, which will be
+ * "text_completion"
+ */
+export interface CompletionCreateResponse {
+  id: string;
+
+  choices: Array<CompletionCreateResponse.Choice>;
+
+  created: number;
+
+  model: string;
+
+  object?: 'text_completion';
+}
+
+export namespace CompletionCreateResponse {
+  /**
+   * A choice from an OpenAI-compatible completion response.
+   *
+   * :finish_reason: The reason the model stopped generating :text: The text of the
+   * choice :index: The index of the choice :logprobs: (Optional) The log
+   * probabilities for the tokens in the choice
+   */
+  export interface Choice {
+    finish_reason: string;
+
+    index: number;
+
+    text: string;
+
+    /**
+     * The log probabilities for the tokens in the message from an OpenAI-compatible
+     * chat completion response.
+     */
+    logprobs?: Choice.Logprobs | null;
+  }
+
+  export namespace Choice {
+    /**
+     * The log probabilities for the tokens in the message from an OpenAI-compatible
+     * chat completion response.
+     */
+    export interface Logprobs {
+      content?: Array<Logprobs.Content> | null;
+
+      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;
+      }
+
+      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> | 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;
+      }
+
+      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> | null;
+        }
+      }
+    }
+  }
+}
+
+export type CompletionCreateParams = CompletionCreateParamsNonStreaming | CompletionCreateParamsStreaming;
+
+export interface CompletionCreateParamsBase {
+  model: string;
+
+  prompt: string | Array<string> | Array<number> | Array<Array<number>>;
+
+  best_of?: number | null;
+
+  echo?: boolean | null;
+
+  frequency_penalty?: number | null;
+
+  logit_bias?: { [key: string]: number } | null;
+
+  logprobs?: boolean | null;
+
+  max_tokens?: number | null;
+
+  n?: number | null;
+
+  presence_penalty?: number | null;
+
+  seed?: number | null;
+
+  stop?: string | Array<string> | null;
+
+  stream?: boolean | null;
+
+  stream_options?: { [key: string]: unknown } | null;
+
+  suffix?: string | null;
+
+  temperature?: number | null;
+
+  top_p?: number | null;
+
+  user?: string | null;
+
+  [k: string]: unknown;
+}
+
+export namespace CompletionCreateParams {
+  export type CompletionCreateParamsNonStreaming = CompletionsAPI.CompletionCreateParamsNonStreaming;
+  export type CompletionCreateParamsStreaming = CompletionsAPI.CompletionCreateParamsStreaming;
+}
+
+export interface CompletionCreateParamsNonStreaming extends CompletionCreateParamsBase {
+  stream?: false | null;
+
+  [k: string]: unknown;
+}
+
+export interface CompletionCreateParamsStreaming extends CompletionCreateParamsBase {
+  stream: true;
+
+  [k: string]: unknown;
+}
+
+export declare namespace Completions {
+  export {
+    type CompletionCreateResponse as CompletionCreateResponse,
+    type CompletionCreateParams as CompletionCreateParams,
+    type CompletionCreateParamsNonStreaming as CompletionCreateParamsNonStreaming,
+    type CompletionCreateParamsStreaming as CompletionCreateParamsStreaming,
+  };
+}

package/dist/src/resources/conversations/conversations.ts

@@ -0,0 +1,455 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+// All rights reserved.
+//
+// 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';
+import * as Core from '../../core';
+import * as ItemsAPI from './items';
+import {
+  ItemCreateParams,
+  ItemCreateResponse,
+  ItemDeleteResponse,
+  ItemGetResponse,
+  ItemListParams,
+  ItemListResponse,
+  ItemListResponsesOpenAICursorPage,
+  Items,
+} from './items';
+
+export class Conversations extends APIResource {
+  items: ItemsAPI.Items = new ItemsAPI.Items(this._client);
+
+  /**
+   * Create a conversation.
+   *
+   * Create a conversation.
+   */
+  create(body: ConversationCreateParams, options?: Core.RequestOptions): Core.APIPromise<ConversationObject> {
+    return this._client.post('/v1/conversations', { body, ...options });
+  }
+
+  /**
+   * Retrieve a conversation.
+   *
+   * Get a conversation with the given ID.
+   */
+  retrieve(conversationId: string, options?: Core.RequestOptions): Core.APIPromise<ConversationObject> {
+    return this._client.get(`/v1/conversations/${conversationId}`, options);
+  }
+
+  /**
+   * Update a conversation.
+   *
+   * Update a conversation's metadata with the given ID.
+   */
+  update(
+    conversationId: string,
+    body: ConversationUpdateParams,
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<ConversationObject> {
+    return this._client.post(`/v1/conversations/${conversationId}`, { body, ...options });
+  }
+
+  /**
+   * Delete a conversation.
+   *
+   * Delete a conversation with the given ID.
+   */
+  delete(conversationId: string, options?: Core.RequestOptions): Core.APIPromise<ConversationDeleteResponse> {
+    return this._client.delete(`/v1/conversations/${conversationId}`, options);
+  }
+}
+
+/**
+ * OpenAI-compatible conversation object.
+ */
+export interface ConversationObject {
+  /**
+   * The unique ID of the conversation.
+   */
+  id: string;
+
+  /**
+   * The time at which the conversation was created, measured in seconds since the
+   * Unix epoch.
+   */
+  created_at: number;
+
+  /**
+   * Initial items to include in the conversation context. You may add up to 20 items
+   * at a time.
+   */
+  items?: Array<{ [key: string]: unknown }> | null;
+
+  /**
+   * Set of 16 key-value pairs that can be attached to an object. This can be useful
+   * for storing additional information about the object in a structured format, and
+   * querying for objects via API or the dashboard.
+   */
+  metadata?: { [key: string]: string } | null;
+
+  /**
+   * The object type, which is always conversation.
+   */
+  object?: 'conversation';
+}
+
+/**
+ * Response for deleted conversation.
+ */
+export interface ConversationDeleteResponse {
+  /**
+   * The deleted conversation identifier
+   */
+  id: string;
+
+  /**
+   * Whether the object was deleted
+   */
+  deleted?: boolean;
+
+  /**
+   * Object type
+   */
+  object?: string;
+}
+
+export interface ConversationCreateParams {
+  items?: Array<
+    | ConversationCreateParams.OpenAIResponseMessageInput
+    | ConversationCreateParams.OpenAIResponseOutputMessageWebSearchToolCall
+    | ConversationCreateParams.OpenAIResponseOutputMessageFileSearchToolCall
+    | ConversationCreateParams.OpenAIResponseOutputMessageFunctionToolCall
+    | ConversationCreateParams.OpenAIResponseInputFunctionToolCallOutput
+    | ConversationCreateParams.OpenAIResponseMcpApprovalRequest
+    | ConversationCreateParams.OpenAIResponseMcpApprovalResponse
+    | ConversationCreateParams.OpenAIResponseOutputMessageMcpCall
+    | ConversationCreateParams.OpenAIResponseOutputMessageMcpListTools
+  > | null;
+
+  metadata?: { [key: string]: string } | null;
+}
+
+export namespace ConversationCreateParams {
+  /**
+   * Corresponds to the various Message types in the Responses API. They are all
+   * under one type because the Responses API gives them all the same "type" value,
+   * and there is no way to tell them apart in certain scenarios.
+   */
+  export interface OpenAIResponseMessageInput {
+    content:
+      | string
+      | Array<
+          | OpenAIResponseMessageInput.OpenAIResponseInputMessageContentText
+          | OpenAIResponseMessageInput.OpenAIResponseInputMessageContentImage
+          | OpenAIResponseMessageInput.OpenAIResponseInputMessageContentFile
+        >
+      | Array<
+          | OpenAIResponseMessageInput.OpenAIResponseOutputMessageContentOutputText
+          | OpenAIResponseMessageInput.OpenAIResponseContentPartRefusal
+        >;
+
+    role: 'system' | 'developer' | 'user' | 'assistant';
+
+    id?: string | null;
+
+    status?: string | null;
+
+    type?: 'message';
+  }
+
+  export namespace OpenAIResponseMessageInput {
+    /**
+     * Text content for input messages in OpenAI response format.
+     */
+    export interface OpenAIResponseInputMessageContentText {
+      text: string;
+
+      type?: 'input_text';
+    }
+
+    /**
+     * Image content for input messages in OpenAI response format.
+     */
+    export interface OpenAIResponseInputMessageContentImage {
+      detail?: 'low' | 'high' | 'auto';
+
+      file_id?: string | null;
+
+      image_url?: string | null;
+
+      type?: 'input_image';
+    }
+
+    /**
+     * File content for input messages in OpenAI response format.
+     */
+    export interface OpenAIResponseInputMessageContentFile {
+      file_data?: string | null;
+
+      file_id?: string | null;
+
+      file_url?: string | null;
+
+      filename?: string | null;
+
+      type?: 'input_file';
+    }
+
+    export interface OpenAIResponseOutputMessageContentOutputText {
+      text: string;
+
+      annotations?: Array<
+        | OpenAIResponseOutputMessageContentOutputText.OpenAIResponseAnnotationFileCitation
+        | OpenAIResponseOutputMessageContentOutputText.OpenAIResponseAnnotationCitation
+        | OpenAIResponseOutputMessageContentOutputText.OpenAIResponseAnnotationContainerFileCitation
+        | OpenAIResponseOutputMessageContentOutputText.OpenAIResponseAnnotationFilePath
+      >;
+
+      type?: 'output_text';
+    }
+
+    export namespace OpenAIResponseOutputMessageContentOutputText {
+      /**
+       * File citation annotation for referencing specific files in response content.
+       */
+      export interface OpenAIResponseAnnotationFileCitation {
+        file_id: string;
+
+        filename: string;
+
+        index: number;
+
+        type?: 'file_citation';
+      }
+
+      /**
+       * URL citation annotation for referencing external web resources.
+       */
+      export interface OpenAIResponseAnnotationCitation {
+        end_index: number;
+
+        start_index: number;
+
+        title: string;
+
+        url: string;
+
+        type?: 'url_citation';
+      }
+
+      export interface OpenAIResponseAnnotationContainerFileCitation {
+        container_id: string;
+
+        end_index: number;
+
+        file_id: string;
+
+        filename: string;
+
+        start_index: number;
+
+        type?: 'container_file_citation';
+      }
+
+      export interface OpenAIResponseAnnotationFilePath {
+        file_id: string;
+
+        index: number;
+
+        type?: 'file_path';
+      }
+    }
+
+    /**
+     * Refusal content within a streamed response part.
+     */
+    export interface OpenAIResponseContentPartRefusal {
+      refusal: string;
+
+      type?: 'refusal';
+    }
+  }
+
+  /**
+   * Web search tool call output message for OpenAI responses.
+   */
+  export interface OpenAIResponseOutputMessageWebSearchToolCall {
+    id: string;
+
+    status: string;
+
+    type?: 'web_search_call';
+  }
+
+  /**
+   * File search tool call output message for OpenAI responses.
+   */
+  export interface OpenAIResponseOutputMessageFileSearchToolCall {
+    id: string;
+
+    queries: Array<string>;
+
+    status: string;
+
+    results?: Array<OpenAIResponseOutputMessageFileSearchToolCall.Result> | null;
+
+    type?: 'file_search_call';
+  }
+
+  export namespace OpenAIResponseOutputMessageFileSearchToolCall {
+    /**
+     * Search results returned by the file search operation.
+     */
+    export interface Result {
+      attributes: { [key: string]: unknown };
+
+      file_id: string;
+
+      filename: string;
+
+      score: number;
+
+      text: string;
+    }
+  }
+
+  /**
+   * Function tool call output message for OpenAI responses.
+   */
+  export interface OpenAIResponseOutputMessageFunctionToolCall {
+    arguments: string;
+
+    call_id: string;
+
+    name: string;
+
+    id?: string | null;
+
+    status?: string | null;
+
+    type?: 'function_call';
+  }
+
+  /**
+   * This represents the output of a function call that gets passed back to the
+   * model.
+   */
+  export interface OpenAIResponseInputFunctionToolCallOutput {
+    call_id: string;
+
+    output: string;
+
+    id?: string | null;
+
+    status?: string | null;
+
+    type?: 'function_call_output';
+  }
+
+  /**
+   * A request for human approval of a tool invocation.
+   */
+  export interface OpenAIResponseMcpApprovalRequest {
+    id: string;
+
+    arguments: string;
+
+    name: string;
+
+    server_label: string;
+
+    type?: 'mcp_approval_request';
+  }
+
+  /**
+   * A response to an MCP approval request.
+   */
+  export interface OpenAIResponseMcpApprovalResponse {
+    approval_request_id: string;
+
+    approve: boolean;
+
+    id?: string | null;
+
+    reason?: string | null;
+
+    type?: 'mcp_approval_response';
+  }
+
+  /**
+   * Model Context Protocol (MCP) call output message for OpenAI responses.
+   */
+  export interface OpenAIResponseOutputMessageMcpCall {
+    id: string;
+
+    arguments: string;
+
+    name: string;
+
+    server_label: string;
+
+    error?: string | null;
+
+    output?: string | null;
+
+    type?: 'mcp_call';
+  }
+
+  /**
+   * MCP list tools output message containing available tools from an MCP server.
+   */
+  export interface OpenAIResponseOutputMessageMcpListTools {
+    id: string;
+
+    server_label: string;
+
+    tools: Array<OpenAIResponseOutputMessageMcpListTools.Tool>;
+
+    type?: 'mcp_list_tools';
+  }
+
+  export namespace OpenAIResponseOutputMessageMcpListTools {
+    /**
+     * Tool definition returned by MCP list tools operation.
+     */
+    export interface Tool {
+      input_schema: { [key: string]: unknown };
+
+      name: string;
+
+      description?: string | null;
+    }
+  }
+}
+
+export interface ConversationUpdateParams {
+  metadata: { [key: string]: string };
+}
+
+Conversations.Items = Items;
+Conversations.ItemListResponsesOpenAICursorPage = ItemListResponsesOpenAICursorPage;
+
+export declare namespace Conversations {
+  export {
+    type ConversationObject as ConversationObject,
+    type ConversationDeleteResponse as ConversationDeleteResponse,
+    type ConversationCreateParams as ConversationCreateParams,
+    type ConversationUpdateParams as ConversationUpdateParams,
+  };
+
+  export {
+    Items as Items,
+    type ItemCreateResponse as ItemCreateResponse,
+    type ItemListResponse as ItemListResponse,
+    type ItemDeleteResponse as ItemDeleteResponse,
+    type ItemGetResponse as ItemGetResponse,
+    ItemListResponsesOpenAICursorPage as ItemListResponsesOpenAICursorPage,
+    type ItemCreateParams as ItemCreateParams,
+    type ItemListParams as ItemListParams,
+  };
+}