llama-stack-client 0.0.35 → 0.1.0

package/src/resources/scoring.ts

@@ -0,0 +1,52 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../resource';
+import * as Core from '../core';
+import * as ScoringFunctionsAPI from './scoring-functions';
+import * as Shared from './shared';
+
+export class Scoring extends APIResource {
+  score(body: ScoringScoreParams, options?: Core.RequestOptions): Core.APIPromise<ScoringScoreResponse> {
+    return this._client.post('/v1/scoring/score', { body, ...options });
+  }
+
+  scoreBatch(
+    body: ScoringScoreBatchParams,
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<ScoringScoreBatchResponse> {
+    return this._client.post('/v1/scoring/score-batch', { body, ...options });
+  }
+}
+
+export interface ScoringScoreResponse {
+  results: Record<string, Shared.ScoringResult>;
+}
+
+export interface ScoringScoreBatchResponse {
+  results: Record<string, Shared.ScoringResult>;
+
+  dataset_id?: string;
+}
+
+export interface ScoringScoreParams {
+  input_rows: Array<Record<string, boolean | number | string | Array<unknown> | unknown | null>>;
+
+  scoring_functions: Record<string, ScoringFunctionsAPI.ScoringFnParams | null>;
+}
+
+export interface ScoringScoreBatchParams {
+  dataset_id: string;
+
+  save_results_dataset: boolean;
+
+  scoring_functions: Record<string, ScoringFunctionsAPI.ScoringFnParams | null>;
+}
+
+export declare namespace Scoring {
+  export {
+    type ScoringScoreResponse as ScoringScoreResponse,
+    type ScoringScoreBatchResponse as ScoringScoreBatchResponse,
+    type ScoringScoreParams as ScoringScoreParams,
+    type ScoringScoreBatchParams as ScoringScoreBatchParams,
+  };
+}

package/src/resources/shared.ts

@@ -1,42 +1,454 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-export interface Attachment {
-  content: string | Array<string>;
+import * as Shared from './shared';
+import * as InferenceAPI from './inference';
+import * as ToolRuntimeAPI from './tool-runtime/tool-runtime';
 
-  mime_type: string;
+export interface AgentConfig {
+  enable_session_persistence: boolean;
+
+  instructions: string;
+
+  max_infer_iters: number;
+
+  model: string;
+
+  client_tools?: Array<ToolRuntimeAPI.ToolDef>;
+
+  input_shields?: Array<string>;
+
+  output_shields?: Array<string>;
+
+  response_format?: ResponseFormat;
+
+  sampling_params?: SamplingParams;
+
+  tool_choice?: 'auto' | 'required';
+
+  tool_prompt_format?: 'json' | 'function_tag' | 'python_list';
+
+  toolgroups?: Array<string | AgentConfig.UnionMember1>;
+}
+
+export namespace AgentConfig {
+  export interface UnionMember1 {
+    args: Record<string, boolean | number | string | Array<unknown> | unknown | null>;
+
+    name: string;
+  }
 }
 
 export interface BatchCompletion {
-  completion_message_batch: Array<CompletionMessage>;
+  batch: Array<InferenceAPI.CompletionResponse>;
+}
+
+export interface ChatCompletionResponse {
+  /**
+   * The complete response message
+   */
+  completion_message: CompletionMessage;
+
+  /**
+   * Optional log probabilities for generated tokens
+   */
+  logprobs?: Array<InferenceAPI.TokenLogProbs>;
 }
 
 export interface CompletionMessage {
-  content: string | Array<string>;
+  /**
+   * The content of the model's response
+   */
+  content: InterleavedContent;
 
+  /**
+   * Must be "assistant" to identify this as the model's response
+   */
   role: 'assistant';
 
+  /**
+   * Reason why the model stopped generating. Options are: -
+   * `StopReason.end_of_turn`: The model finished generating the entire response. -
+   * `StopReason.end_of_message`: The model finished generating but generated a
+   * partial response -- usually, a tool call. The user may call the tool and
+   * continue the conversation with the tool's response. -
+   * `StopReason.out_of_tokens`: The model ran out of token budget.
+   */
   stop_reason: 'end_of_turn' | 'end_of_message' | 'out_of_tokens';
 
+  /**
+   * List of tool calls. Each tool call is a ToolCall object.
+   */
   tool_calls: Array<ToolCall>;
 }
 
+export type ContentDelta = ContentDelta.TextDelta | ContentDelta.ImageDelta | ContentDelta.ToolCallDelta;
+
+export namespace ContentDelta {
+  export interface TextDelta {
+    text: string;
+
+    type: 'text';
+  }
+
+  export interface ImageDelta {
+    image: string;
+
+    type: 'image';
+  }
+
+  export interface ToolCallDelta {
+    parse_status: 'started' | 'in_progress' | 'failed' | 'succeeded';
+
+    tool_call: string | Shared.ToolCall;
+
+    type: 'tool_call';
+  }
+}
+
+export interface Document {
+  content:
+    | string
+    | Document.ImageContentItem
+    | Document.TextContentItem
+    | Array<InterleavedContentItem>
+    | URL;
+
+  document_id: string;
+
+  metadata: Record<string, boolean | number | string | Array<unknown> | unknown | null>;
+
+  mime_type?: string;
+}
+
+export namespace Document {
+  export interface ImageContentItem {
+    /**
+     * Image as a base64 encoded string or an URL
+     */
+    image: ImageContentItem.Image;
+
+    /**
+     * Discriminator type of the content item. Always "image"
+     */
+    type: 'image';
+  }
+
+  export namespace ImageContentItem {
+    /**
+     * Image as a base64 encoded string or an URL
+     */
+    export interface Image {
+      /**
+       * base64 encoded image data as string
+       */
+      data?: string;
+
+      /**
+       * A URL of the image or data URL in the format of data:image/{type};base64,{data}.
+       * Note that URL could have length limits.
+       */
+      url?: Shared.URL;
+    }
+  }
+
+  export interface TextContentItem {
+    /**
+     * Text content
+     */
+    text: string;
+
+    /**
+     * Discriminator type of the content item. Always "text"
+     */
+    type: 'text';
+  }
+}
+
+export type InterleavedContent =
+  | string
+  | InterleavedContent.ImageContentItem
+  | InterleavedContent.TextContentItem
+  | Array<InterleavedContentItem>;
+
+export namespace InterleavedContent {
+  export interface ImageContentItem {
+    /**
+     * Image as a base64 encoded string or an URL
+     */
+    image: ImageContentItem.Image;
+
+    /**
+     * Discriminator type of the content item. Always "image"
+     */
+    type: 'image';
+  }
+
+  export namespace ImageContentItem {
+    /**
+     * Image as a base64 encoded string or an URL
+     */
+    export interface Image {
+      /**
+       * base64 encoded image data as string
+       */
+      data?: string;
+
+      /**
+       * A URL of the image or data URL in the format of data:image/{type};base64,{data}.
+       * Note that URL could have length limits.
+       */
+      url?: Shared.URL;
+    }
+  }
+
+  export interface TextContentItem {
+    /**
+     * Text content
+     */
+    text: string;
+
+    /**
+     * Discriminator type of the content item. Always "text"
+     */
+    type: 'text';
+  }
+}
+
+export type InterleavedContentItem =
+  | InterleavedContentItem.ImageContentItem
+  | InterleavedContentItem.TextContentItem;
+
+export namespace InterleavedContentItem {
+  export interface ImageContentItem {
+    /**
+     * Image as a base64 encoded string or an URL
+     */
+    image: ImageContentItem.Image;
+
+    /**
+     * Discriminator type of the content item. Always "image"
+     */
+    type: 'image';
+  }
+
+  export namespace ImageContentItem {
+    /**
+     * Image as a base64 encoded string or an URL
+     */
+    export interface Image {
+      /**
+       * base64 encoded image data as string
+       */
+      data?: string;
+
+      /**
+       * A URL of the image or data URL in the format of data:image/{type};base64,{data}.
+       * Note that URL could have length limits.
+       */
+      url?: Shared.URL;
+    }
+  }
+
+  export interface TextContentItem {
+    /**
+     * Text content
+     */
+    text: string;
+
+    /**
+     * Discriminator type of the content item. Always "text"
+     */
+    type: 'text';
+  }
+}
+
+export type Message = UserMessage | SystemMessage | ToolResponseMessage | CompletionMessage;
+
+export type ParamType =
+  | ParamType.StringType
+  | ParamType.NumberType
+  | ParamType.BooleanType
+  | ParamType.ArrayType
+  | ParamType.ObjectType
+  | ParamType.JsonType
+  | ParamType.UnionType
+  | ParamType.ChatCompletionInputType
+  | ParamType.CompletionInputType
+  | ParamType.AgentTurnInputType;
+
+export namespace ParamType {
+  export interface StringType {
+    type: 'string';
+  }
+
+  export interface NumberType {
+    type: 'number';
+  }
+
+  export interface BooleanType {
+    type: 'boolean';
+  }
+
+  export interface ArrayType {
+    type: 'array';
+  }
+
+  export interface ObjectType {
+    type: 'object';
+  }
+
+  export interface JsonType {
+    type: 'json';
+  }
+
+  export interface UnionType {
+    type: 'union';
+  }
+
+  export interface ChatCompletionInputType {
+    type: 'chat_completion_input';
+  }
+
+  export interface CompletionInputType {
+    type: 'completion_input';
+  }
+
+  export interface AgentTurnInputType {
+    type: 'agent_turn_input';
+  }
+}
+
+export interface QueryConfig {
+  max_chunks: number;
+
+  max_tokens_in_context: number;
+
+  query_generator_config: QueryGeneratorConfig;
+}
+
+export type QueryGeneratorConfig =
+  | QueryGeneratorConfig.DefaultRagQueryGeneratorConfig
+  | QueryGeneratorConfig.LlmragQueryGeneratorConfig;
+
+export namespace QueryGeneratorConfig {
+  export interface DefaultRagQueryGeneratorConfig {
+    separator: string;
+
+    type: 'default';
+  }
+
+  export interface LlmragQueryGeneratorConfig {
+    model: string;
+
+    template: string;
+
+    type: 'llm';
+  }
+}
+
+export interface QueryResult {
+  content?: InterleavedContent;
+}
+
+export type ResponseFormat = ResponseFormat.JsonSchemaResponseFormat | ResponseFormat.GrammarResponseFormat;
+
+export namespace ResponseFormat {
+  export interface JsonSchemaResponseFormat {
+    /**
+     * The JSON schema the response should conform to. In a Python SDK, this is often a
+     * `pydantic` model.
+     */
+    json_schema: Record<string, boolean | number | string | Array<unknown> | unknown | null>;
+
+    /**
+     * Must be "json_schema" to identify this format type
+     */
+    type: 'json_schema';
+  }
+
+  export interface GrammarResponseFormat {
+    /**
+     * The BNF grammar specification the response should conform to
+     */
+    bnf: Record<string, boolean | number | string | Array<unknown> | unknown | null>;
+
+    /**
+     * Must be "grammar" to identify this format type
+     */
+    type: 'grammar';
+  }
+}
+
+export interface ReturnType {
+  type:
+    | 'string'
+    | 'number'
+    | 'boolean'
+    | 'array'
+    | 'object'
+    | 'json'
+    | 'union'
+    | 'chat_completion_input'
+    | 'completion_input'
+    | 'agent_turn_input';
+}
+
+export interface SafetyViolation {
+  metadata: Record<string, boolean | number | string | Array<unknown> | unknown | null>;
+
+  violation_level: 'info' | 'warn' | 'error';
+
+  user_message?: string;
+}
+
 export interface SamplingParams {
-  strategy: 'greedy' | 'top_p' | 'top_k';
+  strategy:
+    | SamplingParams.GreedySamplingStrategy
+    | SamplingParams.TopPSamplingStrategy
+    | SamplingParams.TopKSamplingStrategy;
 
   max_tokens?: number;
 
   repetition_penalty?: number;
+}
 
-  temperature?: number;
+export namespace SamplingParams {
+  export interface GreedySamplingStrategy {
+    type: 'greedy';
+  }
 
-  top_k?: number;
+  export interface TopPSamplingStrategy {
+    type: 'top_p';
 
-  top_p?: number;
+    temperature?: number;
+
+    top_p?: number;
+  }
+
+  export interface TopKSamplingStrategy {
+    top_k: number;
+
+    type: 'top_k';
+  }
+}
+
+export interface ScoringResult {
+  aggregated_results: Record<string, boolean | number | string | Array<unknown> | unknown | null>;
+
+  score_rows: Array<Record<string, boolean | number | string | Array<unknown> | unknown | null>>;
 }
 
 export interface SystemMessage {
-  content: string | Array<string>;
+  /**
+   * 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: InterleavedContent;
 
+  /**
+   * Must be "system" to identify this as a system message
+   */
   role: 'system';
 }
 
@@ -56,20 +468,56 @@ export interface ToolCall {
   tool_name: 'brave_search' | 'wolfram_alpha' | 'photogen' | 'code_interpreter' | (string & {});
 }
 
+export interface ToolParamDefinition {
+  param_type: string;
+
+  default?: boolean | number | string | Array<unknown> | unknown | null;
+
+  description?: string;
+
+  required?: boolean;
+}
+
 export interface ToolResponseMessage {
+  /**
+   * Unique identifier for the tool call this response is for
+   */
   call_id: string;
 
-  content: string | Array<string>;
+  /**
+   * The response content from the tool
+   */
+  content: InterleavedContent;
 
-  role: 'ipython';
+  /**
+   * Must be "tool" to identify this as a tool response
+   */
+  role: 'tool';
 
+  /**
+   * Name of the tool that was called
+   */
   tool_name: 'brave_search' | 'wolfram_alpha' | 'photogen' | 'code_interpreter' | (string & {});
 }
 
+export interface URL {
+  uri: string;
+}
+
 export interface UserMessage {
-  content: string | Array<string>;
+  /**
+   * The content of the message, which can include text and other media
+   */
+  content: InterleavedContent;
 
+  /**
+   * Must be "user" to identify this as a user message
+   */
   role: 'user';
 
-  context?: string | Array<string>;
+  /**
+   * (Optional) This field is used internally by Llama Stack to pass RAG context.
+   * This field may be removed in the API in the future.
+   */
+  context?: InterleavedContent;
 }

package/src/resources/shields.ts

@@ -1,84 +1,57 @@
 // 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 ShieldsAPI from './shields';
 
 export class Shields extends APIResource {
-  list(params?: ShieldListParams, options?: Core.RequestOptions): Core.APIPromise<ShieldSpec>;
-  list(options?: Core.RequestOptions): Core.APIPromise<ShieldSpec>;
-  list(
-    params: ShieldListParams | Core.RequestOptions = {},
-    options?: Core.RequestOptions,
-  ): Core.APIPromise<ShieldSpec> {
-    if (isRequestOptions(params)) {
-      return this.list({}, params);
-    }
-    const { 'X-LlamaStack-ProviderData': xLlamaStackProviderData } = params;
-    return this._client.get('/shields/list', {
-      ...options,
-      headers: {
-        ...(xLlamaStackProviderData != null ?
-          { 'X-LlamaStack-ProviderData': xLlamaStackProviderData }
-        : undefined),
-        ...options?.headers,
-      },
-    });
+  retrieve(identifier: string, options?: Core.RequestOptions): Core.APIPromise<Shield | null> {
+    return this._client.get(`/v1/shields/${identifier}`, options);
   }
 
-  get(params: ShieldGetParams, options?: Core.RequestOptions): Core.APIPromise<ShieldSpec | null> {
-    const { 'X-LlamaStack-ProviderData': xLlamaStackProviderData, ...query } = params;
-    return this._client.get('/shields/get', {
-      query,
-      ...options,
-      headers: {
-        ...(xLlamaStackProviderData != null ?
-          { 'X-LlamaStack-ProviderData': xLlamaStackProviderData }
-        : undefined),
-        ...options?.headers,
-      },
-    });
+  list(options?: Core.RequestOptions): Core.APIPromise<ShieldListResponse> {
+    return (
+      this._client.get('/v1/shields', options) as Core.APIPromise<{ data: ShieldListResponse }>
+    )._thenUnwrap((obj) => obj.data);
   }
-}
 
-export interface ShieldSpec {
-  provider_config: ShieldSpec.ProviderConfig;
+  register(body: ShieldRegisterParams, options?: Core.RequestOptions): Core.APIPromise<Shield> {
+    return this._client.post('/v1/shields', { body, ...options });
+  }
+}
 
-  shield_type: string;
+export interface ListShieldsResponse {
+  data: Array<Shield>;
 }
 
-export namespace ShieldSpec {
-  export interface ProviderConfig {
-    config: Record<string, boolean | number | string | Array<unknown> | unknown | null>;
+export interface Shield {
+  identifier: string;
 
-    provider_id: string;
-  }
-}
+  provider_id: string;
+
+  provider_resource_id: string;
 
-export interface ShieldListParams {
-  /**
-   * JSON-encoded provider data which will be made available to the adapter servicing
-   * the API
-   */
-  'X-LlamaStack-ProviderData'?: string;
+  type: 'shield';
+
+  params?: Record<string, boolean | number | string | Array<unknown> | unknown | null>;
 }
 
-export interface ShieldGetParams {
-  /**
-   * Query 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;
+export type ShieldListResponse = Array<Shield>;
+
+export interface ShieldRegisterParams {
+  shield_id: string;
+
+  params?: Record<string, boolean | number | string | Array<unknown> | unknown | null>;
+
+  provider_id?: string;
+
+  provider_shield_id?: string;
 }
 
-export namespace Shields {
-  export import ShieldSpec = ShieldsAPI.ShieldSpec;
-  export import ShieldListParams = ShieldsAPI.ShieldListParams;
-  export import ShieldGetParams = ShieldsAPI.ShieldGetParams;
+export declare namespace Shields {
+  export {
+    type ListShieldsResponse as ListShieldsResponse,
+    type Shield as Shield,
+    type ShieldListResponse as ShieldListResponse,
+    type ShieldRegisterParams as ShieldRegisterParams,
+  };
 }