llama-stack-client 0.3.4 → 0.4.0-rc1

package/src/resources/responses.ts

@@ -3,7 +3,7 @@
 //
 // This source code is licensed under the terms described in the LICENSE file in
 // the root directory of this source tree.
-
+//
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 export * from './responses/index';

package/src/resources/routes.ts

@@ -3,20 +3,33 @@
 //
 // 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 { isRequestOptions } from '../core';
 import * as Core from '../core';
 import * as InspectAPI from './inspect';
 
 export class Routes extends APIResource {
   /**
+   * List routes.
+   *
    * List all available API routes with their methods and implementing providers.
    */
-  list(options?: Core.RequestOptions): Core.APIPromise<RouteListResponse> {
+  list(query?: RouteListParams, options?: Core.RequestOptions): Core.APIPromise<RouteListResponse>;
+  list(options?: Core.RequestOptions): Core.APIPromise<RouteListResponse>;
+  list(
+    query: RouteListParams | Core.RequestOptions = {},
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<RouteListResponse> {
+    if (isRequestOptions(query)) {
+      return this.list({}, query);
+    }
     return (
-      this._client.get('/v1/inspect/routes', options) as Core.APIPromise<{ data: RouteListResponse }>
+      this._client.get('/v1/inspect/routes', { query, ...options }) as Core.APIPromise<{
+        data: RouteListResponse;
+      }>
     )._thenUnwrap((obj) => obj.data);
   }
 }
@@ -25,17 +38,19 @@ export class Routes extends APIResource {
  * Response containing a list of all available API routes.
  */
 export interface ListRoutesResponse {
-  /**
-   * List of available route information objects
-   */
   data: RouteListResponse;
 }
 
-/**
- * List of available route information objects
- */
 export type RouteListResponse = Array<InspectAPI.RouteInfo>;
 
+export interface RouteListParams {
+  api_filter?: 'v1' | 'v1alpha' | 'v1beta' | 'deprecated' | null;
+}
+
 export declare namespace Routes {
-  export { type ListRoutesResponse as ListRoutesResponse, type RouteListResponse as RouteListResponse };
+  export {
+    type ListRoutesResponse as ListRoutesResponse,
+    type RouteListResponse as RouteListResponse,
+    type RouteListParams as RouteListParams,
+  };
 }

package/src/resources/safety.ts

@@ -3,7 +3,7 @@
 //
 // This source code is licensed under the terms described in the LICENSE file in
 // the root directory of this source tree.
-
+//
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 import { APIResource } from '../resource';
@@ -12,6 +12,8 @@ import * as Shared from './shared';
 
 export class Safety extends APIResource {
   /**
+   * Run shield.
+   *
    * Run a shield.
    */
   runShield(body: SafetyRunShieldParams, options?: Core.RequestOptions): Core.APIPromise<RunShieldResponse> {
@@ -24,26 +26,214 @@ export class Safety extends APIResource {
  */
 export interface RunShieldResponse {
   /**
-   * (Optional) Safety violation detected by the shield, if any
+   * Details of a safety violation detected by content moderation.
    */
-  violation?: Shared.SafetyViolation;
+  violation?: Shared.SafetyViolation | null;
 }
 
 export interface SafetyRunShieldParams {
+  messages: Array<
+    | SafetyRunShieldParams.OpenAIUserMessageParamInput
+    | SafetyRunShieldParams.OpenAISystemMessageParam
+    | SafetyRunShieldParams.OpenAIAssistantMessageParamInput
+    | SafetyRunShieldParams.OpenAIToolMessageParam
+    | SafetyRunShieldParams.OpenAIDeveloperMessageParam
+  >;
+
+  params: { [key: string]: unknown };
+
+  shield_id: string;
+}
+
+export namespace SafetyRunShieldParams {
   /**
-   * The messages to run the shield on.
+   * A message from the user in an OpenAI-compatible chat completion request.
    */
-  messages: Array<Shared.Message>;
+  export interface OpenAIUserMessageParamInput {
+    content:
+      | string
+      | Array<
+          | OpenAIUserMessageParamInput.OpenAIChatCompletionContentPartTextParam
+          | OpenAIUserMessageParamInput.OpenAIChatCompletionContentPartImageParam
+          | OpenAIUserMessageParamInput.OpenAIFile
+        >;
+
+    name?: string | null;
+
+    role?: 'user';
+  }
+
+  export namespace OpenAIUserMessageParamInput {
+    /**
+     * Text content part for OpenAI-compatible chat completion messages.
+     */
+    export interface OpenAIChatCompletionContentPartTextParam {
+      text: string;
+
+      type?: 'text';
+    }
+
+    /**
+     * Image content part for OpenAI-compatible chat completion messages.
+     */
+    export interface OpenAIChatCompletionContentPartImageParam {
+      /**
+       * Image URL specification for OpenAI-compatible chat completion messages.
+       */
+      image_url: OpenAIChatCompletionContentPartImageParam.ImageURL;
+
+      type?: 'image_url';
+    }
+
+    export namespace OpenAIChatCompletionContentPartImageParam {
+      /**
+       * Image URL specification for OpenAI-compatible chat completion messages.
+       */
+      export interface ImageURL {
+        url: string;
+
+        detail?: string | null;
+      }
+    }
+
+    export interface OpenAIFile {
+      file: OpenAIFile.File;
+
+      type?: 'file';
+    }
+
+    export namespace OpenAIFile {
+      export interface File {
+        file_data?: string | null;
+
+        file_id?: string | null;
+
+        filename?: string | null;
+      }
+    }
+  }
 
   /**
-   * The parameters of the shield.
+   * A system message providing instructions or context to the model.
    */
-  params: { [key: string]: boolean | number | string | Array<unknown> | unknown | null };
+  export interface OpenAISystemMessageParam {
+    content: string | Array<OpenAISystemMessageParam.ListOpenAIChatCompletionContentPartTextParam>;
+
+    name?: string | null;
+
+    role?: 'system';
+  }
+
+  export namespace OpenAISystemMessageParam {
+    /**
+     * Text content part for OpenAI-compatible chat completion messages.
+     */
+    export interface ListOpenAIChatCompletionContentPartTextParam {
+      text: string;
+
+      type?: 'text';
+    }
+  }
 
   /**
-   * The identifier of the shield to run.
+   * A message containing the model's (assistant) response in an OpenAI-compatible
+   * chat completion request.
    */
-  shield_id: string;
+  export interface OpenAIAssistantMessageParamInput {
+    content?:
+      | string
+      | Array<OpenAIAssistantMessageParamInput.ListOpenAIChatCompletionContentPartTextParam>
+      | null;
+
+    name?: string | null;
+
+    role?: 'assistant';
+
+    tool_calls?: Array<OpenAIAssistantMessageParamInput.ToolCall> | null;
+  }
+
+  export namespace OpenAIAssistantMessageParamInput {
+    /**
+     * Text content part for OpenAI-compatible chat completion messages.
+     */
+    export interface ListOpenAIChatCompletionContentPartTextParam {
+      text: string;
+
+      type?: 'text';
+    }
+
+    /**
+     * Tool call specification for OpenAI-compatible chat completion responses.
+     */
+    export interface ToolCall {
+      id?: string | null;
+
+      /**
+       * Function call details for OpenAI-compatible tool calls.
+       */
+      function?: ToolCall.Function | null;
+
+      index?: number | null;
+
+      type?: 'function';
+    }
+
+    export namespace ToolCall {
+      /**
+       * Function call details for OpenAI-compatible tool calls.
+       */
+      export interface Function {
+        arguments?: string | null;
+
+        name?: string | null;
+      }
+    }
+  }
+
+  /**
+   * A message representing the result of a tool invocation in an OpenAI-compatible
+   * chat completion request.
+   */
+  export interface OpenAIToolMessageParam {
+    content: string | Array<OpenAIToolMessageParam.ListOpenAIChatCompletionContentPartTextParam>;
+
+    tool_call_id: string;
+
+    role?: 'tool';
+  }
+
+  export namespace OpenAIToolMessageParam {
+    /**
+     * Text content part for OpenAI-compatible chat completion messages.
+     */
+    export interface ListOpenAIChatCompletionContentPartTextParam {
+      text: string;
+
+      type?: 'text';
+    }
+  }
+
+  /**
+   * A message from the developer in an OpenAI-compatible chat completion request.
+   */
+  export interface OpenAIDeveloperMessageParam {
+    content: string | Array<OpenAIDeveloperMessageParam.ListOpenAIChatCompletionContentPartTextParam>;
+
+    name?: string | null;
+
+    role?: 'developer';
+  }
+
+  export namespace OpenAIDeveloperMessageParam {
+    /**
+     * Text content part for OpenAI-compatible chat completion messages.
+     */
+    export interface ListOpenAIChatCompletionContentPartTextParam {
+      text: string;
+
+      type?: 'text';
+    }
+  }
 }
 
 export declare namespace Safety {

package/src/resources/scoring-functions.ts

@@ -3,7 +3,7 @@
 //
 // This source code is licensed under the terms described in the LICENSE file in
 // the root directory of this source tree.
-
+//
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 import { APIResource } from '../resource';
@@ -30,6 +30,8 @@ export class ScoringFunctions extends APIResource {
 
   /**
    * Register a scoring function.
+   *
+   * @deprecated
    */
   register(body: ScoringFunctionRegisterParams, options?: Core.RequestOptions): Core.APIPromise<void> {
     return this._client.post('/v1/scoring-functions', {
@@ -38,6 +40,18 @@ export class ScoringFunctions extends APIResource {
       headers: { Accept: '*/*', ...options?.headers },
     });
   }
+
+  /**
+   * Unregister a scoring function.
+   *
+   * @deprecated
+   */
+  unregister(scoringFnId: string, options?: Core.RequestOptions): Core.APIPromise<void> {
+    return this._client.delete(`/v1/scoring-functions/${scoringFnId}`, {
+      ...options,
+      headers: { Accept: '*/*', ...options?.headers },
+    });
+  }
 }
 
 export interface ListScoringFunctionsResponse {
@@ -48,27 +62,41 @@ export interface ListScoringFunctionsResponse {
  * A scoring function resource for evaluating model outputs.
  */
 export interface ScoringFn {
+  /**
+   * Unique identifier for this resource in llama stack
+   */
   identifier: string;
 
-  metadata: { [key: string]: boolean | number | string | Array<unknown> | unknown | null };
-
+  /**
+   * ID of the provider that owns this resource
+   */
   provider_id: string;
 
   return_type: ScoringFn.ReturnType;
 
+  description?: string | null;
+
   /**
-   * The resource type, always scoring_function
+   * Any additional metadata for this definition
    */
-  type: 'scoring_function';
+  metadata?: { [key: string]: unknown };
 
-  description?: string;
+  /**
+   * The parameters for the scoring function for benchmark eval, these can be
+   * overridden for app eval
+   */
+  params?:
+    | ScoringFn.LlmAsJudgeScoringFnParams
+    | ScoringFn.RegexParserScoringFnParams
+    | ScoringFn.BasicScoringFnParams
+    | null;
 
   /**
-   * Parameters for LLM-as-judge scoring function configuration.
+   * Unique identifier for this resource in the provider
    */
-  params?: ScoringFnParams;
+  provider_resource_id?: string | null;
 
-  provider_resource_id?: string;
+  type?: 'scoring_function';
 }
 
 export namespace ScoringFn {
@@ -85,6 +113,62 @@ export namespace ScoringFn {
       | 'completion_input'
       | 'agent_turn_input';
   }
+
+  /**
+   * Parameters for LLM-as-judge scoring function configuration.
+   */
+  export interface LlmAsJudgeScoringFnParams {
+    judge_model: string;
+
+    /**
+     * Aggregation functions to apply to the scores of each row
+     */
+    aggregation_functions?: Array<
+      'average' | 'weighted_average' | 'median' | 'categorical_count' | 'accuracy'
+    >;
+
+    /**
+     * Regexes to extract the answer from generated response
+     */
+    judge_score_regexes?: Array<string>;
+
+    prompt_template?: string | null;
+
+    type?: 'llm_as_judge';
+  }
+
+  /**
+   * Parameters for regex parser scoring function configuration.
+   */
+  export interface RegexParserScoringFnParams {
+    /**
+     * Aggregation functions to apply to the scores of each row
+     */
+    aggregation_functions?: Array<
+      'average' | 'weighted_average' | 'median' | 'categorical_count' | 'accuracy'
+    >;
+
+    /**
+     * Regex to extract the answer from generated response
+     */
+    parsing_regexes?: Array<string>;
+
+    type?: 'regex_parser';
+  }
+
+  /**
+   * Parameters for basic scoring function configuration.
+   */
+  export interface BasicScoringFnParams {
+    /**
+     * Aggregation functions to apply to the scores of each row
+     */
+    aggregation_functions?: Array<
+      'average' | 'weighted_average' | 'median' | 'categorical_count' | 'accuracy'
+    >;
+
+    type?: 'basic';
+  }
 }
 
 /**
@@ -100,32 +184,23 @@ export namespace ScoringFnParams {
    * Parameters for LLM-as-judge scoring function configuration.
    */
   export interface LlmAsJudgeScoringFnParams {
+    judge_model: string;
+
     /**
      * Aggregation functions to apply to the scores of each row
      */
-    aggregation_functions: Array<
+    aggregation_functions?: Array<
       'average' | 'weighted_average' | 'median' | 'categorical_count' | 'accuracy'
     >;
 
-    /**
-     * Identifier of the LLM model to use as a judge for scoring
-     */
-    judge_model: string;
-
     /**
      * Regexes to extract the answer from generated response
      */
-    judge_score_regexes: Array<string>;
+    judge_score_regexes?: Array<string>;
 
-    /**
-     * The type of scoring function parameters, always llm_as_judge
-     */
-    type: 'llm_as_judge';
+    prompt_template?: string | null;
 
-    /**
-     * (Optional) Custom prompt template for the judge model
-     */
-    prompt_template?: string;
+    type?: 'llm_as_judge';
   }
 
   /**
@@ -135,19 +210,16 @@ export namespace ScoringFnParams {
     /**
      * Aggregation functions to apply to the scores of each row
      */
-    aggregation_functions: Array<
+    aggregation_functions?: Array<
       'average' | 'weighted_average' | 'median' | 'categorical_count' | 'accuracy'
     >;
 
     /**
      * Regex to extract the answer from generated response
      */
-    parsing_regexes: Array<string>;
+    parsing_regexes?: Array<string>;
 
-    /**
-     * The type of scoring function parameters, always regex_parser
-     */
-    type: 'regex_parser';
+    type?: 'regex_parser';
   }
 
   /**
@@ -157,47 +229,35 @@ export namespace ScoringFnParams {
     /**
      * Aggregation functions to apply to the scores of each row
      */
-    aggregation_functions: Array<
+    aggregation_functions?: Array<
       'average' | 'weighted_average' | 'median' | 'categorical_count' | 'accuracy'
     >;
 
-    /**
-     * The type of scoring function parameters, always basic
-     */
-    type: 'basic';
+    type?: 'basic';
   }
 }
 
 export type ScoringFunctionListResponse = Array<ScoringFn>;
 
 export interface ScoringFunctionRegisterParams {
-  /**
-   * The description of the scoring function.
-   */
   description: string;
 
   return_type: ScoringFunctionRegisterParams.ReturnType;
 
-  /**
-   * The ID of the scoring function to register.
-   */
   scoring_fn_id: string;
 
   /**
-   * The parameters for the scoring function for benchmark eval, these can be
-   * overridden for app eval.
+   * Parameters for LLM-as-judge scoring function configuration.
    */
-  params?: ScoringFnParams;
+  params?:
+    | ScoringFunctionRegisterParams.LlmAsJudgeScoringFnParams
+    | ScoringFunctionRegisterParams.RegexParserScoringFnParams
+    | ScoringFunctionRegisterParams.BasicScoringFnParams
+    | null;
 
-  /**
-   * The ID of the provider to use for the scoring function.
-   */
-  provider_id?: string;
+  provider_id?: string | null;
 
-  /**
-   * The ID of the provider scoring function to use for the scoring function.
-   */
-  provider_scoring_fn_id?: string;
+  provider_scoring_fn_id?: string | null;
 }
 
 export namespace ScoringFunctionRegisterParams {
@@ -214,6 +274,62 @@ export namespace ScoringFunctionRegisterParams {
       | 'completion_input'
       | 'agent_turn_input';
   }
+
+  /**
+   * Parameters for LLM-as-judge scoring function configuration.
+   */
+  export interface LlmAsJudgeScoringFnParams {
+    judge_model: string;
+
+    /**
+     * Aggregation functions to apply to the scores of each row
+     */
+    aggregation_functions?: Array<
+      'average' | 'weighted_average' | 'median' | 'categorical_count' | 'accuracy'
+    >;
+
+    /**
+     * Regexes to extract the answer from generated response
+     */
+    judge_score_regexes?: Array<string>;
+
+    prompt_template?: string | null;
+
+    type?: 'llm_as_judge';
+  }
+
+  /**
+   * Parameters for regex parser scoring function configuration.
+   */
+  export interface RegexParserScoringFnParams {
+    /**
+     * Aggregation functions to apply to the scores of each row
+     */
+    aggregation_functions?: Array<
+      'average' | 'weighted_average' | 'median' | 'categorical_count' | 'accuracy'
+    >;
+
+    /**
+     * Regex to extract the answer from generated response
+     */
+    parsing_regexes?: Array<string>;
+
+    type?: 'regex_parser';
+  }
+
+  /**
+   * Parameters for basic scoring function configuration.
+   */
+  export interface BasicScoringFnParams {
+    /**
+     * Aggregation functions to apply to the scores of each row
+     */
+    aggregation_functions?: Array<
+      'average' | 'weighted_average' | 'median' | 'categorical_count' | 'accuracy'
+    >;
+
+    type?: 'basic';
+  }
 }
 
 export declare namespace ScoringFunctions {