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

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

@@ -2,45 +2,72 @@
 
 import { APIResource } from '../../resource';
 import * as Core from '../../core';
-import * as PostTrainingAPI from './post-training';
-import * as DatasetsAPI from '../datasets';
-import * as JobsAPI from './jobs';
+import * as JobAPI from './job';
+import {
+  Job,
+  JobArtifactsParams,
+  JobArtifactsResponse,
+  JobCancelParams,
+  JobListResponse,
+  JobStatusParams,
+  JobStatusResponse,
+} from './job';
 
 export class PostTraining extends APIResource {
-  jobs: JobsAPI.Jobs = new JobsAPI.Jobs(this._client);
+  job: JobAPI.Job = new JobAPI.Job(this._client);
 
   preferenceOptimize(
-    params: PostTrainingPreferenceOptimizeParams,
+    body: PostTrainingPreferenceOptimizeParams,
     options?: Core.RequestOptions,
   ): Core.APIPromise<PostTrainingJob> {
-    const { 'X-LlamaStack-ProviderData': xLlamaStackProviderData, ...body } = params;
-    return this._client.post('/post_training/preference_optimize', {
-      body,
-      ...options,
-      headers: {
-        ...(xLlamaStackProviderData != null ?
-          { 'X-LlamaStack-ProviderData': xLlamaStackProviderData }
-        : undefined),
-        ...options?.headers,
-      },
-    });
+    return this._client.post('/v1/post-training/preference-optimize', { body, ...options });
   }
 
   supervisedFineTune(
-    params: PostTrainingSupervisedFineTuneParams,
+    body: PostTrainingSupervisedFineTuneParams,
     options?: Core.RequestOptions,
   ): Core.APIPromise<PostTrainingJob> {
-    const { 'X-LlamaStack-ProviderData': xLlamaStackProviderData, ...body } = params;
-    return this._client.post('/post_training/supervised_fine_tune', {
-      body,
-      ...options,
-      headers: {
-        ...(xLlamaStackProviderData != null ?
-          { 'X-LlamaStack-ProviderData': xLlamaStackProviderData }
-        : undefined),
-        ...options?.headers,
-      },
-    });
+    return this._client.post('/v1/post-training/supervised-fine-tune', { body, ...options });
+  }
+}
+
+export type AlgorithmConfig = AlgorithmConfig.LoraFinetuningConfig | AlgorithmConfig.QatFinetuningConfig;
+
+export namespace AlgorithmConfig {
+  export interface LoraFinetuningConfig {
+    alpha: number;
+
+    apply_lora_to_mlp: boolean;
+
+    apply_lora_to_output: boolean;
+
+    lora_attn_modules: Array<string>;
+
+    rank: number;
+
+    type: 'LoRA';
+
+    quantize_base?: boolean;
+
+    use_dora?: boolean;
+  }
+
+  export interface QatFinetuningConfig {
+    group_size: number;
+
+    quantizer_name: string;
+
+    type: 'QAT';
+  }
+}
+
+export interface ListPostTrainingJobsResponse {
+  data: Array<ListPostTrainingJobsResponse.Data>;
+}
+
+export namespace ListPostTrainingJobsResponse {
+  export interface Data {
+    job_uuid: string;
   }
 }
 
@@ -49,61 +76,17 @@ export interface PostTrainingJob {
 }
 
 export interface PostTrainingPreferenceOptimizeParams {
-  /**
-   * Body param:
-   */
-  algorithm: 'dpo';
-
-  /**
-   * Body param:
-   */
   algorithm_config: PostTrainingPreferenceOptimizeParams.AlgorithmConfig;
 
-  /**
-   * Body param:
-   */
-  dataset: DatasetsAPI.TrainEvalDataset;
-
-  /**
-   * Body param:
-   */
   finetuned_model: string;
 
-  /**
-   * Body param:
-   */
   hyperparam_search_config: Record<string, boolean | number | string | Array<unknown> | unknown | null>;
 
-  /**
-   * Body param:
-   */
   job_uuid: string;
 
-  /**
-   * Body param:
-   */
   logger_config: Record<string, boolean | number | string | Array<unknown> | unknown | null>;
 
-  /**
-   * Body param:
-   */
-  optimizer_config: PostTrainingPreferenceOptimizeParams.OptimizerConfig;
-
-  /**
-   * Body param:
-   */
   training_config: PostTrainingPreferenceOptimizeParams.TrainingConfig;
-
-  /**
-   * Body param:
-   */
-  validation_dataset: DatasetsAPI.TrainEvalDataset;
-
-  /**
-   * Header param: JSON-encoded provider data which will be made available to the
-   * adapter servicing the API
-   */
-  'X-LlamaStack-ProviderData'?: string;
 }
 
 export namespace PostTrainingPreferenceOptimizeParams {
@@ -117,169 +100,155 @@ export namespace PostTrainingPreferenceOptimizeParams {
     reward_scale: number;
   }
 
-  export interface OptimizerConfig {
-    lr: number;
+  export interface TrainingConfig {
+    data_config: TrainingConfig.DataConfig;
 
-    lr_min: number;
+    gradient_accumulation_steps: number;
 
-    optimizer_type: 'adam' | 'adamw' | 'sgd';
+    max_steps_per_epoch: number;
 
-    weight_decay: number;
+    max_validation_steps: number;
+
+    n_epochs: number;
+
+    optimizer_config: TrainingConfig.OptimizerConfig;
+
+    dtype?: string;
+
+    efficiency_config?: TrainingConfig.EfficiencyConfig;
   }
 
-  export interface TrainingConfig {
-    batch_size: number;
+  export namespace TrainingConfig {
+    export interface DataConfig {
+      batch_size: number;
 
-    enable_activation_checkpointing: boolean;
+      data_format: 'instruct' | 'dialog';
 
-    fsdp_cpu_offload: boolean;
+      dataset_id: string;
 
-    memory_efficient_fsdp_wrap: boolean;
+      shuffle: boolean;
 
-    n_epochs: number;
+      packed?: boolean;
+
+      train_on_input?: boolean;
+
+      validation_dataset_id?: string;
+    }
+
+    export interface OptimizerConfig {
+      lr: number;
+
+      num_warmup_steps: number;
+
+      optimizer_type: 'adam' | 'adamw' | 'sgd';
+
+      weight_decay: number;
+    }
+
+    export interface EfficiencyConfig {
+      enable_activation_checkpointing?: boolean;
+
+      enable_activation_offloading?: boolean;
 
-    n_iters: number;
+      fsdp_cpu_offload?: boolean;
 
-    shuffle: boolean;
+      memory_efficient_fsdp_wrap?: boolean;
+    }
   }
 }
 
 export interface PostTrainingSupervisedFineTuneParams {
-  /**
-   * Body param:
-   */
-  algorithm: 'full' | 'lora' | 'qlora' | 'dora';
-
-  /**
-   * Body param:
-   */
-  algorithm_config:
-    | PostTrainingSupervisedFineTuneParams.LoraFinetuningConfig
-    | PostTrainingSupervisedFineTuneParams.QLoraFinetuningConfig
-    | PostTrainingSupervisedFineTuneParams.DoraFinetuningConfig;
-
-  /**
-   * Body param:
-   */
-  dataset: DatasetsAPI.TrainEvalDataset;
-
-  /**
-   * Body param:
-   */
   hyperparam_search_config: Record<string, boolean | number | string | Array<unknown> | unknown | null>;
 
-  /**
-   * Body param:
-   */
   job_uuid: string;
 
-  /**
-   * Body param:
-   */
   logger_config: Record<string, boolean | number | string | Array<unknown> | unknown | null>;
 
-  /**
-   * Body param:
-   */
   model: string;
 
-  /**
-   * Body param:
-   */
-  optimizer_config: PostTrainingSupervisedFineTuneParams.OptimizerConfig;
-
-  /**
-   * Body param:
-   */
   training_config: PostTrainingSupervisedFineTuneParams.TrainingConfig;
 
-  /**
-   * Body param:
-   */
-  validation_dataset: DatasetsAPI.TrainEvalDataset;
+  algorithm_config?: AlgorithmConfig;
 
-  /**
-   * Header param: JSON-encoded provider data which will be made available to the
-   * adapter servicing the API
-   */
-  'X-LlamaStack-ProviderData'?: string;
+  checkpoint_dir?: string;
 }
 
 export namespace PostTrainingSupervisedFineTuneParams {
-  export interface LoraFinetuningConfig {
-    alpha: number;
-
-    apply_lora_to_mlp: boolean;
-
-    apply_lora_to_output: boolean;
+  export interface TrainingConfig {
+    data_config: TrainingConfig.DataConfig;
 
-    lora_attn_modules: Array<string>;
+    gradient_accumulation_steps: number;
 
-    rank: number;
-  }
+    max_steps_per_epoch: number;
 
-  export interface QLoraFinetuningConfig {
-    alpha: number;
+    max_validation_steps: number;
 
-    apply_lora_to_mlp: boolean;
+    n_epochs: number;
 
-    apply_lora_to_output: boolean;
+    optimizer_config: TrainingConfig.OptimizerConfig;
 
-    lora_attn_modules: Array<string>;
+    dtype?: string;
 
-    rank: number;
+    efficiency_config?: TrainingConfig.EfficiencyConfig;
   }
 
-  export interface DoraFinetuningConfig {
-    alpha: number;
-
-    apply_lora_to_mlp: boolean;
+  export namespace TrainingConfig {
+    export interface DataConfig {
+      batch_size: number;
 
-    apply_lora_to_output: boolean;
+      data_format: 'instruct' | 'dialog';
 
-    lora_attn_modules: Array<string>;
+      dataset_id: string;
 
-    rank: number;
-  }
+      shuffle: boolean;
 
-  export interface OptimizerConfig {
-    lr: number;
+      packed?: boolean;
 
-    lr_min: number;
+      train_on_input?: boolean;
 
-    optimizer_type: 'adam' | 'adamw' | 'sgd';
+      validation_dataset_id?: string;
+    }
 
-    weight_decay: number;
-  }
+    export interface OptimizerConfig {
+      lr: number;
 
-  export interface TrainingConfig {
-    batch_size: number;
+      num_warmup_steps: number;
 
-    enable_activation_checkpointing: boolean;
+      optimizer_type: 'adam' | 'adamw' | 'sgd';
 
-    fsdp_cpu_offload: boolean;
+      weight_decay: number;
+    }
 
-    memory_efficient_fsdp_wrap: boolean;
+    export interface EfficiencyConfig {
+      enable_activation_checkpointing?: boolean;
 
-    n_epochs: number;
+      enable_activation_offloading?: boolean;
 
-    n_iters: number;
+      fsdp_cpu_offload?: boolean;
 
-    shuffle: boolean;
+      memory_efficient_fsdp_wrap?: boolean;
+    }
   }
 }
 
-export namespace PostTraining {
-  export import PostTrainingJob = PostTrainingAPI.PostTrainingJob;
-  export import PostTrainingPreferenceOptimizeParams = PostTrainingAPI.PostTrainingPreferenceOptimizeParams;
-  export import PostTrainingSupervisedFineTuneParams = PostTrainingAPI.PostTrainingSupervisedFineTuneParams;
-  export import Jobs = JobsAPI.Jobs;
-  export import PostTrainingJobArtifacts = JobsAPI.PostTrainingJobArtifacts;
-  export import PostTrainingJobLogStream = JobsAPI.PostTrainingJobLogStream;
-  export import PostTrainingJobStatus = JobsAPI.PostTrainingJobStatus;
-  export import JobListParams = JobsAPI.JobListParams;
-  export import JobArtifactsParams = JobsAPI.JobArtifactsParams;
-  export import JobCancelParams = JobsAPI.JobCancelParams;
-  export import JobLogsParams = JobsAPI.JobLogsParams;
-  export import JobStatusParams = JobsAPI.JobStatusParams;
+PostTraining.Job = Job;
+
+export declare namespace PostTraining {
+  export {
+    type AlgorithmConfig as AlgorithmConfig,
+    type ListPostTrainingJobsResponse as ListPostTrainingJobsResponse,
+    type PostTrainingJob as PostTrainingJob,
+    type PostTrainingPreferenceOptimizeParams as PostTrainingPreferenceOptimizeParams,
+    type PostTrainingSupervisedFineTuneParams as PostTrainingSupervisedFineTuneParams,
+  };
+
+  export {
+    Job as Job,
+    type JobListResponse as JobListResponse,
+    type JobArtifactsResponse as JobArtifactsResponse,
+    type JobStatusResponse as JobStatusResponse,
+    type JobArtifactsParams as JobArtifactsParams,
+    type JobCancelParams as JobCancelParams,
+    type JobStatusParams as JobStatusParams,
+  };
 }

package/src/resources/providers.ts

@@ -0,0 +1,26 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../resource';
+import * as Core from '../core';
+import * as InspectAPI from './inspect';
+
+export class Providers extends APIResource {
+  list(options?: Core.RequestOptions): Core.APIPromise<ProviderListResponse> {
+    return (
+      this._client.get('/v1/inspect/providers', options) as Core.APIPromise<{ data: ProviderListResponse }>
+    )._thenUnwrap((obj) => obj.data);
+  }
+}
+
+export interface ListProvidersResponse {
+  data: Array<InspectAPI.ProviderInfo>;
+}
+
+export type ProviderListResponse = Array<InspectAPI.ProviderInfo>;
+
+export declare namespace Providers {
+  export {
+    type ListProvidersResponse as ListProvidersResponse,
+    type ProviderListResponse as ProviderListResponse,
+  };
+}

package/src/resources/routes.ts

@@ -0,0 +1,23 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../resource';
+import * as Core from '../core';
+import * as InspectAPI from './inspect';
+
+export class Routes extends APIResource {
+  list(options?: Core.RequestOptions): Core.APIPromise<RouteListResponse> {
+    return (
+      this._client.get('/v1/inspect/routes', options) as Core.APIPromise<{ data: RouteListResponse }>
+    )._thenUnwrap((obj) => obj.data);
+  }
+}
+
+export interface ListRoutesResponse {
+  data: Array<InspectAPI.RouteInfo>;
+}
+
+export type RouteListResponse = Array<InspectAPI.RouteInfo>;
+
+export declare namespace Routes {
+  export { type ListRoutesResponse as ListRoutesResponse, type RouteListResponse as RouteListResponse };
+}

package/src/resources/safety.ts

@@ -2,65 +2,26 @@
 
 import { APIResource } from '../resource';
 import * as Core from '../core';
-import * as SafetyAPI from './safety';
 import * as Shared from './shared';
 
 export class Safety extends APIResource {
-  runShield(params: SafetyRunShieldParams, options?: Core.RequestOptions): Core.APIPromise<RunSheidResponse> {
-    const { 'X-LlamaStack-ProviderData': xLlamaStackProviderData, ...body } = params;
-    return this._client.post('/safety/run_shield', {
-      body,
-      ...options,
-      headers: {
-        ...(xLlamaStackProviderData != null ?
-          { 'X-LlamaStack-ProviderData': xLlamaStackProviderData }
-        : undefined),
-        ...options?.headers,
-      },
-    });
+  runShield(body: SafetyRunShieldParams, options?: Core.RequestOptions): Core.APIPromise<RunShieldResponse> {
+    return this._client.post('/v1/safety/run-shield', { body, ...options });
   }
 }
 
-export interface RunSheidResponse {
-  violation?: RunSheidResponse.Violation;
-}
-
-export namespace RunSheidResponse {
-  export interface Violation {
-    metadata: Record<string, boolean | number | string | Array<unknown> | unknown | null>;
-
-    violation_level: 'info' | 'warn' | 'error';
-
-    user_message?: string;
-  }
+export interface RunShieldResponse {
+  violation?: Shared.SafetyViolation;
 }
 
 export interface SafetyRunShieldParams {
-  /**
-   * Body param:
-   */
-  messages: Array<
-    Shared.UserMessage | Shared.SystemMessage | Shared.ToolResponseMessage | Shared.CompletionMessage
-  >;
+  messages: Array<Shared.Message>;
 
-  /**
-   * Body param:
-   */
   params: Record<string, boolean | number | string | Array<unknown> | unknown | null>;
 
-  /**
-   * Body param:
-   */
-  shield_type: string;
-
-  /**
-   * Header param: JSON-encoded provider data which will be made available to the
-   * adapter servicing the API
-   */
-  'X-LlamaStack-ProviderData'?: string;
+  shield_id: string;
 }
 
-export namespace Safety {
-  export import RunSheidResponse = SafetyAPI.RunSheidResponse;
-  export import SafetyRunShieldParams = SafetyAPI.SafetyRunShieldParams;
+export declare namespace Safety {
+  export { type RunShieldResponse as RunShieldResponse, type SafetyRunShieldParams as SafetyRunShieldParams };
 }

package/src/resources/scoring-functions.ts

@@ -0,0 +1,108 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../resource';
+import * as Core from '../core';
+import * as Shared from './shared';
+
+export class ScoringFunctions extends APIResource {
+  retrieve(scoringFnId: string, options?: Core.RequestOptions): Core.APIPromise<ScoringFn | null> {
+    return this._client.get(`/v1/scoring-functions/${scoringFnId}`, options);
+  }
+
+  list(options?: Core.RequestOptions): Core.APIPromise<ScoringFunctionListResponse> {
+    return (
+      this._client.get('/v1/scoring-functions', options) as Core.APIPromise<{
+        data: ScoringFunctionListResponse;
+      }>
+    )._thenUnwrap((obj) => obj.data);
+  }
+
+  register(body: ScoringFunctionRegisterParams, options?: Core.RequestOptions): Core.APIPromise<void> {
+    return this._client.post('/v1/scoring-functions', {
+      body,
+      ...options,
+      headers: { Accept: '*/*', ...options?.headers },
+    });
+  }
+}
+
+export interface ListScoringFunctionsResponse {
+  data: Array<ScoringFn>;
+}
+
+export interface ScoringFn {
+  identifier: string;
+
+  metadata: Record<string, boolean | number | string | Array<unknown> | unknown | null>;
+
+  provider_id: string;
+
+  provider_resource_id: string;
+
+  return_type: Shared.ReturnType;
+
+  type: 'scoring_function';
+
+  description?: string;
+
+  params?: ScoringFnParams;
+}
+
+export type ScoringFnParams =
+  | ScoringFnParams.LlmAsJudgeScoringFnParams
+  | ScoringFnParams.RegexParserScoringFnParams
+  | ScoringFnParams.BasicScoringFnParams;
+
+export namespace ScoringFnParams {
+  export interface LlmAsJudgeScoringFnParams {
+    judge_model: string;
+
+    type: 'llm_as_judge';
+
+    aggregation_functions?: Array<'average' | 'median' | 'categorical_count' | 'accuracy'>;
+
+    judge_score_regexes?: Array<string>;
+
+    prompt_template?: string;
+  }
+
+  export interface RegexParserScoringFnParams {
+    type: 'regex_parser';
+
+    aggregation_functions?: Array<'average' | 'median' | 'categorical_count' | 'accuracy'>;
+
+    parsing_regexes?: Array<string>;
+  }
+
+  export interface BasicScoringFnParams {
+    type: 'basic';
+
+    aggregation_functions?: Array<'average' | 'median' | 'categorical_count' | 'accuracy'>;
+  }
+}
+
+export type ScoringFunctionListResponse = Array<ScoringFn>;
+
+export interface ScoringFunctionRegisterParams {
+  description: string;
+
+  return_type: Shared.ReturnType;
+
+  scoring_fn_id: string;
+
+  params?: ScoringFnParams;
+
+  provider_id?: string;
+
+  provider_scoring_fn_id?: string;
+}
+
+export declare namespace ScoringFunctions {
+  export {
+    type ListScoringFunctionsResponse as ListScoringFunctionsResponse,
+    type ScoringFn as ScoringFn,
+    type ScoringFnParams as ScoringFnParams,
+    type ScoringFunctionListResponse as ScoringFunctionListResponse,
+    type ScoringFunctionRegisterParams as ScoringFunctionRegisterParams,
+  };
+}