llama-stack-client 0.0.1-alpha.0 → 0.1.0

package/src/resources/inference.ts

@@ -0,0 +1,346 @@
+// 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 InferenceAPI from './inference';
+import * as Shared from './shared';
+import { Stream } from '../streaming';
+
+export class Inference extends APIResource {
+  /**
+   * Generate a chat completion for the given messages using the specified model.
+   */
+  chatCompletion(
+    body: InferenceChatCompletionParamsNonStreaming,
+    options?: Core.RequestOptions,
+  ): APIPromise<Shared.ChatCompletionResponse>;
+  chatCompletion(
+    body: InferenceChatCompletionParamsStreaming,
+    options?: Core.RequestOptions,
+  ): APIPromise<Stream<ChatCompletionResponseStreamChunk>>;
+  chatCompletion(
+    body: InferenceChatCompletionParamsBase,
+    options?: Core.RequestOptions,
+  ): APIPromise<Stream<ChatCompletionResponseStreamChunk> | Shared.ChatCompletionResponse>;
+  chatCompletion(
+    body: InferenceChatCompletionParams,
+    options?: Core.RequestOptions,
+  ): APIPromise<Shared.ChatCompletionResponse> | APIPromise<Stream<ChatCompletionResponseStreamChunk>> {
+    return this._client.post('/v1/inference/chat-completion', {
+      body,
+      ...options,
+      stream: body.stream ?? false,
+    }) as APIPromise<Shared.ChatCompletionResponse> | APIPromise<Stream<ChatCompletionResponseStreamChunk>>;
+  }
+
+  /**
+   * Generate a completion for the given content using the specified model.
+   */
+  completion(
+    body: InferenceCompletionParamsNonStreaming,
+    options?: Core.RequestOptions,
+  ): APIPromise<CompletionResponse>;
+  completion(
+    body: InferenceCompletionParamsStreaming,
+    options?: Core.RequestOptions,
+  ): APIPromise<Stream<CompletionResponse>>;
+  completion(
+    body: InferenceCompletionParamsBase,
+    options?: Core.RequestOptions,
+  ): APIPromise<Stream<CompletionResponse> | CompletionResponse>;
+  completion(
+    body: InferenceCompletionParams,
+    options?: Core.RequestOptions,
+  ): APIPromise<CompletionResponse> | APIPromise<Stream<CompletionResponse>> {
+    return this._client.post('/v1/inference/completion', {
+      body,
+      ...options,
+      stream: body.stream ?? false,
+    }) as APIPromise<CompletionResponse> | APIPromise<Stream<CompletionResponse>>;
+  }
+
+  /**
+   * Generate embeddings for content pieces using the specified model.
+   */
+  embeddings(
+    body: InferenceEmbeddingsParams,
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<EmbeddingsResponse> {
+    return this._client.post('/v1/inference/embeddings', { body, ...options });
+  }
+}
+
+export interface ChatCompletionResponseStreamChunk {
+  /**
+   * The event containing the new content
+   */
+  event: ChatCompletionResponseStreamChunk.Event;
+}
+
+export namespace ChatCompletionResponseStreamChunk {
+  /**
+   * The event containing the new content
+   */
+  export interface Event {
+    /**
+     * Content generated since last event. This can be one or more tokens, or a tool
+     * call.
+     */
+    delta: Shared.ContentDelta;
+
+    /**
+     * Type of the event
+     */
+    event_type: 'start' | 'complete' | 'progress';
+
+    /**
+     * Optional log probabilities for generated tokens
+     */
+    logprobs?: Array<InferenceAPI.TokenLogProbs>;
+
+    /**
+     * Optional reason why generation stopped, if complete
+     */
+    stop_reason?: 'end_of_turn' | 'end_of_message' | 'out_of_tokens';
+  }
+}
+
+export interface CompletionResponse {
+  /**
+   * The generated completion text
+   */
+  content: string;
+
+  /**
+   * Reason why generation stopped
+   */
+  stop_reason: 'end_of_turn' | 'end_of_message' | 'out_of_tokens';
+
+  /**
+   * Optional log probabilities for generated tokens
+   */
+  logprobs?: Array<TokenLogProbs>;
+}
+
+export interface EmbeddingsResponse {
+  /**
+   * List of embedding vectors, one per input content. Each embedding is a list of
+   * floats. The dimensionality of the embedding is model-specific; you can check
+   * model metadata using /models/{model_id}
+   */
+  embeddings: Array<Array<number>>;
+}
+
+export interface TokenLogProbs {
+  /**
+   * Dictionary mapping tokens to their log probabilities
+   */
+  logprobs_by_token: Record<string, number>;
+}
+
+export type InferenceChatCompletionParams =
+  | InferenceChatCompletionParamsNonStreaming
+  | InferenceChatCompletionParamsStreaming;
+
+export interface InferenceChatCompletionParamsBase {
+  /**
+   * List of messages in the conversation
+   */
+  messages: Array<Shared.Message>;
+
+  /**
+   * The identifier of the model to use. The model must be registered with Llama
+   * Stack and available via the /models endpoint.
+   */
+  model_id: string;
+
+  /**
+   * (Optional) If specified, log probabilities for each token position will be
+   * returned.
+   */
+  logprobs?: InferenceChatCompletionParams.Logprobs;
+
+  /**
+   * (Optional) Grammar specification for guided (structured) decoding. There are two
+   * options: - `ResponseFormat.json_schema`: The grammar is a JSON schema. Most
+   * providers support this format. - `ResponseFormat.grammar`: The grammar is a BNF
+   * grammar. This format is more flexible, but not all providers support it.
+   */
+  response_format?: Shared.ResponseFormat;
+
+  /**
+   * Parameters to control the sampling strategy
+   */
+  sampling_params?: Shared.SamplingParams;
+
+  /**
+   * (Optional) If True, generate an SSE event stream of the response. Defaults to
+   * False.
+   */
+  stream?: boolean;
+
+  /**
+   * (Optional) Whether tool use is required or automatic. Defaults to
+   * ToolChoice.auto.
+   */
+  tool_choice?: 'auto' | 'required';
+
+  /**
+   * (Optional) Instructs the model how to format tool calls. By default, Llama Stack
+   * will attempt to use a format that is best adapted to the model. -
+   * `ToolPromptFormat.json`: The tool calls are formatted as a JSON object. -
+   * `ToolPromptFormat.function_tag`: The tool calls are enclosed in a
+   * <function=function_name> tag. - `ToolPromptFormat.python_list`: The tool calls
+   * are output as Python syntax -- a list of function calls.
+   */
+  tool_prompt_format?: 'json' | 'function_tag' | 'python_list';
+
+  /**
+   * (Optional) List of tool definitions available to the model
+   */
+  tools?: Array<InferenceChatCompletionParams.Tool>;
+}
+
+export namespace InferenceChatCompletionParams {
+  /**
+   * (Optional) If specified, log probabilities for each token position will be
+   * returned.
+   */
+  export interface Logprobs {
+    /**
+     * How many tokens (for each position) to return log probabilities for.
+     */
+    top_k?: number;
+  }
+
+  export interface Tool {
+    tool_name: 'brave_search' | 'wolfram_alpha' | 'photogen' | 'code_interpreter' | (string & {});
+
+    description?: string;
+
+    parameters?: Record<string, Shared.ToolParamDefinition>;
+  }
+
+  export type InferenceChatCompletionParamsNonStreaming =
+    InferenceAPI.InferenceChatCompletionParamsNonStreaming;
+  export type InferenceChatCompletionParamsStreaming = InferenceAPI.InferenceChatCompletionParamsStreaming;
+}
+
+export interface InferenceChatCompletionParamsNonStreaming extends InferenceChatCompletionParamsBase {
+  /**
+   * (Optional) If True, generate an SSE event stream of the response. Defaults to
+   * False.
+   */
+  stream?: false;
+}
+
+export interface InferenceChatCompletionParamsStreaming extends InferenceChatCompletionParamsBase {
+  /**
+   * (Optional) If True, generate an SSE event stream of the response. Defaults to
+   * False.
+   */
+  stream: true;
+}
+
+export type InferenceCompletionParams =
+  | InferenceCompletionParamsNonStreaming
+  | InferenceCompletionParamsStreaming;
+
+export interface InferenceCompletionParamsBase {
+  /**
+   * The content to generate a completion for
+   */
+  content: Shared.InterleavedContent;
+
+  /**
+   * The identifier of the model to use. The model must be registered with Llama
+   * Stack and available via the /models endpoint.
+   */
+  model_id: string;
+
+  /**
+   * (Optional) If specified, log probabilities for each token position will be
+   * returned.
+   */
+  logprobs?: InferenceCompletionParams.Logprobs;
+
+  /**
+   * (Optional) Grammar specification for guided (structured) decoding
+   */
+  response_format?: Shared.ResponseFormat;
+
+  /**
+   * (Optional) Parameters to control the sampling strategy
+   */
+  sampling_params?: Shared.SamplingParams;
+
+  /**
+   * (Optional) If True, generate an SSE event stream of the response. Defaults to
+   * False.
+   */
+  stream?: boolean;
+}
+
+export namespace InferenceCompletionParams {
+  /**
+   * (Optional) If specified, log probabilities for each token position will be
+   * returned.
+   */
+  export interface Logprobs {
+    /**
+     * How many tokens (for each position) to return log probabilities for.
+     */
+    top_k?: number;
+  }
+
+  export type InferenceCompletionParamsNonStreaming = InferenceAPI.InferenceCompletionParamsNonStreaming;
+  export type InferenceCompletionParamsStreaming = InferenceAPI.InferenceCompletionParamsStreaming;
+}
+
+export interface InferenceCompletionParamsNonStreaming extends InferenceCompletionParamsBase {
+  /**
+   * (Optional) If True, generate an SSE event stream of the response. Defaults to
+   * False.
+   */
+  stream?: false;
+}
+
+export interface InferenceCompletionParamsStreaming extends InferenceCompletionParamsBase {
+  /**
+   * (Optional) If True, generate an SSE event stream of the response. Defaults to
+   * False.
+   */
+  stream: true;
+}
+
+export interface InferenceEmbeddingsParams {
+  /**
+   * List of contents to generate embeddings for. Note that content can be
+   * multimodal. The behavior depends on the model and provider. Some models may only
+   * support text.
+   */
+  contents: Array<Shared.InterleavedContent>;
+
+  /**
+   * The identifier of the model to use. The model must be an embedding model
+   * registered with Llama Stack and available via the /models endpoint.
+   */
+  model_id: string;
+}
+
+export declare namespace Inference {
+  export {
+    type ChatCompletionResponseStreamChunk as ChatCompletionResponseStreamChunk,
+    type CompletionResponse as CompletionResponse,
+    type EmbeddingsResponse as EmbeddingsResponse,
+    type TokenLogProbs as TokenLogProbs,
+    type InferenceChatCompletionParams as InferenceChatCompletionParams,
+    type InferenceChatCompletionParamsNonStreaming as InferenceChatCompletionParamsNonStreaming,
+    type InferenceChatCompletionParamsStreaming as InferenceChatCompletionParamsStreaming,
+    type InferenceCompletionParams as InferenceCompletionParams,
+    type InferenceCompletionParamsNonStreaming as InferenceCompletionParamsNonStreaming,
+    type InferenceCompletionParamsStreaming as InferenceCompletionParamsStreaming,
+    type InferenceEmbeddingsParams as InferenceEmbeddingsParams,
+  };
+}

package/src/resources/inspect.ts

@@ -0,0 +1,47 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../resource';
+import * as Core from '../core';
+
+export class Inspect extends APIResource {
+  health(options?: Core.RequestOptions): Core.APIPromise<HealthInfo> {
+    return this._client.get('/v1/health', options);
+  }
+
+  version(options?: Core.RequestOptions): Core.APIPromise<VersionInfo> {
+    return this._client.get('/v1/version', options);
+  }
+}
+
+export interface HealthInfo {
+  status: string;
+}
+
+export interface ProviderInfo {
+  api: string;
+
+  provider_id: string;
+
+  provider_type: string;
+}
+
+export interface RouteInfo {
+  method: string;
+
+  provider_types: Array<string>;
+
+  route: string;
+}
+
+export interface VersionInfo {
+  version: string;
+}
+
+export declare namespace Inspect {
+  export {
+    type HealthInfo as HealthInfo,
+    type ProviderInfo as ProviderInfo,
+    type RouteInfo as RouteInfo,
+    type VersionInfo as VersionInfo,
+  };
+}

package/src/resources/models.ts

@@ -1,88 +1,68 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 import { APIResource } from '../resource';
-import { isRequestOptions } from '../core';
 import * as Core from '../core';
-import * as ModelsAPI from './models';
 
 export class Models extends APIResource {
-  list(params?: ModelListParams, options?: Core.RequestOptions): Core.APIPromise<ModelServingSpec>;
-  list(options?: Core.RequestOptions): Core.APIPromise<ModelServingSpec>;
-  list(
-    params: ModelListParams | Core.RequestOptions = {},
-    options?: Core.RequestOptions,
-  ): Core.APIPromise<ModelServingSpec> {
-    if (isRequestOptions(params)) {
-      return this.list({}, params);
-    }
-    const { 'X-LlamaStack-ProviderData': xLlamaStackProviderData } = params;
-    return this._client.get('/models/list', {
-      ...options,
-      headers: {
-        ...(xLlamaStackProviderData != null ?
-          { 'X-LlamaStack-ProviderData': xLlamaStackProviderData }
-        : undefined),
-        ...options?.headers,
-      },
-    });
+  retrieve(modelId: string, options?: Core.RequestOptions): Core.APIPromise<Model | null> {
+    return this._client.get(`/v1/models/${modelId}`, options);
   }
 
-  get(params: ModelGetParams, options?: Core.RequestOptions): Core.APIPromise<ModelServingSpec | null> {
-    const { 'X-LlamaStack-ProviderData': xLlamaStackProviderData, ...query } = params;
-    return this._client.get('/models/get', {
-      query,
+  list(options?: Core.RequestOptions): Core.APIPromise<ModelListResponse> {
+    return (
+      this._client.get('/v1/models', options) as Core.APIPromise<{ data: ModelListResponse }>
+    )._thenUnwrap((obj) => obj.data);
+  }
+
+  register(body: ModelRegisterParams, options?: Core.RequestOptions): Core.APIPromise<Model> {
+    return this._client.post('/v1/models', { body, ...options });
+  }
+
+  unregister(modelId: string, options?: Core.RequestOptions): Core.APIPromise<void> {
+    return this._client.delete(`/v1/models/${modelId}`, {
       ...options,
-      headers: {
-        ...(xLlamaStackProviderData != null ?
-          { 'X-LlamaStack-ProviderData': xLlamaStackProviderData }
-        : undefined),
-        ...options?.headers,
-      },
+      headers: { Accept: '*/*', ...options?.headers },
     });
   }
 }
 
-export interface ModelServingSpec {
-  /**
-   * The model family and SKU of the model along with other parameters corresponding
-   * to the model.
-   */
-  llama_model: unknown;
-
-  provider_config: ModelServingSpec.ProviderConfig;
+export interface ListModelsResponse {
+  data: Array<Model>;
 }
 
-export namespace ModelServingSpec {
-  export interface ProviderConfig {
-    config: Record<string, boolean | number | string | Array<unknown> | unknown | null>;
+export interface Model {
+  identifier: string;
 
-    provider_id: string;
-  }
-}
+  metadata: Record<string, boolean | number | string | Array<unknown> | unknown | null>;
 
-export interface ModelListParams {
-  /**
-   * JSON-encoded provider data which will be made available to the adapter servicing
-   * the API
-   */
-  'X-LlamaStack-ProviderData'?: string;
+  model_type: 'llm' | 'embedding';
+
+  provider_id: string;
+
+  provider_resource_id: string;
+
+  type: 'model';
 }
 
-export interface ModelGetParams {
-  /**
-   * Query param:
-   */
-  core_model_id: string;
-
-  /**
-   * Header param: JSON-encoded provider data which will be made available to the
-   * adapter servicing the API
-   */
-  'X-LlamaStack-ProviderData'?: string;
+export type ModelListResponse = Array<Model>;
+
+export interface ModelRegisterParams {
+  model_id: string;
+
+  metadata?: Record<string, boolean | number | string | Array<unknown> | unknown | null>;
+
+  model_type?: 'llm' | 'embedding';
+
+  provider_id?: string;
+
+  provider_model_id?: string;
 }
 
-export namespace Models {
-  export import ModelServingSpec = ModelsAPI.ModelServingSpec;
-  export import ModelListParams = ModelsAPI.ModelListParams;
-  export import ModelGetParams = ModelsAPI.ModelGetParams;
+export declare namespace Models {
+  export {
+    type ListModelsResponse as ListModelsResponse,
+    type Model as Model,
+    type ModelListResponse as ModelListResponse,
+    type ModelRegisterParams as ModelRegisterParams,
+  };
 }

package/src/resources/post-training/index.ts

@@ -1,19 +1,19 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 export {
-  PostTrainingJob,
-  PostTrainingPreferenceOptimizeParams,
-  PostTrainingSupervisedFineTuneParams,
+  Job,
+  type JobListResponse,
+  type JobArtifactsResponse,
+  type JobStatusResponse,
+  type JobArtifactsParams,
+  type JobCancelParams,
+  type JobStatusParams,
+} from './job';
+export {
   PostTraining,
+  type AlgorithmConfig,
+  type ListPostTrainingJobsResponse,
+  type PostTrainingJob,
+  type PostTrainingPreferenceOptimizeParams,
+  type PostTrainingSupervisedFineTuneParams,
 } from './post-training';
-export {
-  PostTrainingJobArtifacts,
-  PostTrainingJobLogStream,
-  PostTrainingJobStatus,
-  JobListParams,
-  JobArtifactsParams,
-  JobCancelParams,
-  JobLogsParams,
-  JobStatusParams,
-  Jobs,
-} from './jobs';

package/src/resources/post-training/job.ts

@@ -0,0 +1,84 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../resource';
+import * as Core from '../../core';
+
+export class Job extends APIResource {
+  list(options?: Core.RequestOptions): Core.APIPromise<JobListResponse> {
+    return (
+      this._client.get('/v1/post-training/jobs', options) as Core.APIPromise<{ data: JobListResponse }>
+    )._thenUnwrap((obj) => obj.data);
+  }
+
+  artifacts(
+    query: JobArtifactsParams,
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<JobArtifactsResponse | null> {
+    return this._client.get('/v1/post-training/job/artifacts', { query, ...options });
+  }
+
+  cancel(body: JobCancelParams, options?: Core.RequestOptions): Core.APIPromise<void> {
+    return this._client.post('/v1/post-training/job/cancel', {
+      body,
+      ...options,
+      headers: { Accept: '*/*', ...options?.headers },
+    });
+  }
+
+  status(query: JobStatusParams, options?: Core.RequestOptions): Core.APIPromise<JobStatusResponse | null> {
+    return this._client.get('/v1/post-training/job/status', { query, ...options });
+  }
+}
+
+export type JobListResponse = Array<JobListResponse.JobListResponseItem>;
+
+export namespace JobListResponse {
+  export interface JobListResponseItem {
+    job_uuid: string;
+  }
+}
+
+export interface JobArtifactsResponse {
+  checkpoints: Array<unknown>;
+
+  job_uuid: string;
+}
+
+export interface JobStatusResponse {
+  checkpoints: Array<unknown>;
+
+  job_uuid: string;
+
+  status: 'completed' | 'in_progress' | 'failed' | 'scheduled';
+
+  completed_at?: string;
+
+  resources_allocated?: Record<string, boolean | number | string | Array<unknown> | unknown | null>;
+
+  scheduled_at?: string;
+
+  started_at?: string;
+}
+
+export interface JobArtifactsParams {
+  job_uuid: string;
+}
+
+export interface JobCancelParams {
+  job_uuid: string;
+}
+
+export interface JobStatusParams {
+  job_uuid: string;
+}
+
+export declare namespace Job {
+  export {
+    type JobListResponse as JobListResponse,
+    type JobArtifactsResponse as JobArtifactsResponse,
+    type JobStatusResponse as JobStatusResponse,
+    type JobArtifactsParams as JobArtifactsParams,
+    type JobCancelParams as JobCancelParams,
+    type JobStatusParams as JobStatusParams,
+  };
+}