llama-stack-client 0.0.35 → 0.1.0

package/src/resources/agents/agents.ts

@@ -2,43 +2,42 @@
 
 import { APIResource } from '../../resource';
 import * as Core from '../../core';
-import * as AgentsAPI from './agents';
 import * as Shared from '../shared';
-import * as SessionsAPI from './sessions';
+import * as SessionAPI from './session';
+import {
+  Session,
+  SessionCreateParams,
+  SessionCreateResponse,
+  SessionResource,
+  SessionRetrieveParams,
+} from './session';
 import * as StepsAPI from './steps';
-import * as TurnsAPI from './turns';
+import { StepRetrieveResponse, Steps } from './steps';
+import * as TurnAPI from './turn';
+import {
+  AgentTurnResponseStreamChunk,
+  Turn,
+  TurnCreateParams,
+  TurnCreateParamsNonStreaming,
+  TurnCreateParamsStreaming,
+  TurnResource,
+  TurnResponseEvent,
+  TurnResponseEventPayload,
+} from './turn';
 
 export class Agents extends APIResource {
-  sessions: SessionsAPI.Sessions = new SessionsAPI.Sessions(this._client);
+  session: SessionAPI.SessionResource = new SessionAPI.SessionResource(this._client);
   steps: StepsAPI.Steps = new StepsAPI.Steps(this._client);
-  turns: TurnsAPI.Turns = new TurnsAPI.Turns(this._client);
+  turn: TurnAPI.TurnResource = new TurnAPI.TurnResource(this._client);
 
-  create(params: AgentCreateParams, options?: Core.RequestOptions): Core.APIPromise<AgentCreateResponse> {
-    const { 'X-LlamaStack-ProviderData': xLlamaStackProviderData, ...body } = params;
-    return this._client.post('/agents/create', {
-      body,
-      ...options,
-      headers: {
-        ...(xLlamaStackProviderData != null ?
-          { 'X-LlamaStack-ProviderData': xLlamaStackProviderData }
-        : undefined),
-        ...options?.headers,
-      },
-    });
+  create(body: AgentCreateParams, options?: Core.RequestOptions): Core.APIPromise<AgentCreateResponse> {
+    return this._client.post('/v1/agents', { body, ...options });
   }
 
-  delete(params: AgentDeleteParams, options?: Core.RequestOptions): Core.APIPromise<void> {
-    const { 'X-LlamaStack-ProviderData': xLlamaStackProviderData, ...body } = params;
-    return this._client.post('/agents/delete', {
-      body,
+  delete(agentId: string, options?: Core.RequestOptions): Core.APIPromise<void> {
+    return this._client.delete(`/v1/agents/${agentId}`, {
       ...options,
-      headers: {
-        Accept: '*/*',
-        ...(xLlamaStackProviderData != null ?
-          { 'X-LlamaStack-ProviderData': xLlamaStackProviderData }
-        : undefined),
-        ...options?.headers,
-      },
+      headers: { Accept: '*/*', ...options?.headers },
     });
   }
 }
@@ -58,9 +57,7 @@ export interface InferenceStep {
 }
 
 export interface MemoryRetrievalStep {
-  inserted_context: string | Array<string>;
-
-  memory_bank_ids: Array<string>;
+  inserted_context: Shared.InterleavedContent;
 
   step_id: string;
 
@@ -68,23 +65,13 @@ export interface MemoryRetrievalStep {
 
   turn_id: string;
 
+  vector_db_ids: string;
+
   completed_at?: string;
 
   started_at?: string;
 }
 
-export interface RestAPIExecutionConfig {
-  method: 'GET' | 'POST' | 'PUT' | 'DELETE';
-
-  url: string;
-
-  body?: Record<string, boolean | number | string | Array<unknown> | unknown | null>;
-
-  headers?: Record<string, boolean | number | string | Array<unknown> | unknown | null>;
-
-  params?: Record<string, boolean | number | string | Array<unknown> | unknown | null>;
-}
-
 export interface ShieldCallStep {
   step_id: string;
 
@@ -96,17 +83,7 @@ export interface ShieldCallStep {
 
   started_at?: string;
 
-  violation?: ShieldCallStep.Violation;
-}
-
-export namespace ShieldCallStep {
-  export interface Violation {
-    metadata: Record<string, boolean | number | string | Array<unknown> | unknown | null>;
-
-    violation_level: 'info' | 'warn' | 'error';
-
-    user_message?: string;
-  }
+  violation?: Shared.SafetyViolation;
 }
 
 export interface ToolExecutionStep {
@@ -116,7 +93,7 @@ export interface ToolExecutionStep {
 
   tool_calls: Array<Shared.ToolCall>;
 
-  tool_responses: Array<ToolExecutionStep.ToolResponse>;
+  tool_responses: Array<ToolResponse>;
 
   turn_id: string;
 
@@ -125,22 +102,12 @@ export interface ToolExecutionStep {
   started_at?: string;
 }
 
-export namespace ToolExecutionStep {
-  export interface ToolResponse {
-    call_id: string;
+export interface ToolResponse {
+  call_id: string;
 
-    content: string | Array<string>;
+  content: Shared.InterleavedContent;
 
-    tool_name: 'brave_search' | 'wolfram_alpha' | 'photogen' | 'code_interpreter' | (string & {});
-  }
-}
-
-export interface ToolParamDefinition {
-  param_type: string;
-
-  description?: string;
-
-  required?: boolean;
+  tool_name: 'brave_search' | 'wolfram_alpha' | 'photogen' | 'code_interpreter' | (string & {});
 }
 
 export interface AgentCreateResponse {
@@ -148,236 +115,42 @@ export interface AgentCreateResponse {
 }
 
 export interface AgentCreateParams {
-  /**
-   * Body param:
-   */
-  agent_config: AgentCreateParams.AgentConfig;
-
-  /**
-   * Header param: JSON-encoded provider data which will be made available to the
-   * adapter servicing the API
-   */
-  'X-LlamaStack-ProviderData'?: string;
-}
-
-export namespace AgentCreateParams {
-  export interface AgentConfig {
-    enable_session_persistence: boolean;
-
-    instructions: string;
-
-    max_infer_iters: number;
-
-    model: string;
-
-    input_shields?: Array<string>;
-
-    output_shields?: Array<string>;
-
-    sampling_params?: Shared.SamplingParams;
-
-    tool_choice?: 'auto' | 'required';
-
-    /**
-     * `json` -- Refers to the json format for calling tools. The json format takes the
-     * form like { "type": "function", "function" : { "name": "function_name",
-     * "description": "function_description", "parameters": {...} } }
-     *
-     * `function_tag` -- This is an example of how you could define your own user
-     * defined format for making tool calls. The function_tag format looks like this,
-     * <function=function_name>(parameters)</function>
-     *
-     * The detailed prompts for each of these formats are added to llama cli
-     */
-    tool_prompt_format?: 'json' | 'function_tag';
-
-    tools?: Array<
-      | AgentConfig.SearchToolDefinition
-      | AgentConfig.WolframAlphaToolDefinition
-      | AgentConfig.PhotogenToolDefinition
-      | AgentConfig.CodeInterpreterToolDefinition
-      | AgentConfig.FunctionCallToolDefinition
-      | AgentConfig.MemoryToolDefinition
-    >;
-  }
-
-  export namespace AgentConfig {
-    export interface SearchToolDefinition {
-      api_key: string;
-
-      engine: 'bing' | 'brave';
-
-      type: 'brave_search';
-
-      input_shields?: Array<string>;
-
-      output_shields?: Array<string>;
-
-      remote_execution?: AgentsAPI.RestAPIExecutionConfig;
-    }
-
-    export interface WolframAlphaToolDefinition {
-      api_key: string;
-
-      type: 'wolfram_alpha';
-
-      input_shields?: Array<string>;
-
-      output_shields?: Array<string>;
-
-      remote_execution?: AgentsAPI.RestAPIExecutionConfig;
-    }
-
-    export interface PhotogenToolDefinition {
-      type: 'photogen';
-
-      input_shields?: Array<string>;
-
-      output_shields?: Array<string>;
-
-      remote_execution?: AgentsAPI.RestAPIExecutionConfig;
-    }
-
-    export interface CodeInterpreterToolDefinition {
-      enable_inline_code_execution: boolean;
-
-      type: 'code_interpreter';
-
-      input_shields?: Array<string>;
-
-      output_shields?: Array<string>;
-
-      remote_execution?: AgentsAPI.RestAPIExecutionConfig;
-    }
-
-    export interface FunctionCallToolDefinition {
-      description: string;
-
-      function_name: string;
-
-      parameters: Record<string, AgentsAPI.ToolParamDefinition>;
-
-      type: 'function_call';
-
-      input_shields?: Array<string>;
-
-      output_shields?: Array<string>;
-
-      remote_execution?: AgentsAPI.RestAPIExecutionConfig;
-    }
-
-    export interface MemoryToolDefinition {
-      max_chunks: number;
-
-      max_tokens_in_context: number;
-
-      memory_bank_configs: Array<
-        | MemoryToolDefinition.UnionMember0
-        | MemoryToolDefinition.UnionMember1
-        | MemoryToolDefinition.UnionMember2
-        | MemoryToolDefinition.UnionMember3
-      >;
-
-      query_generator_config:
-        | MemoryToolDefinition.UnionMember0
-        | MemoryToolDefinition.UnionMember1
-        | MemoryToolDefinition.Type;
-
-      type: 'memory';
-
-      input_shields?: Array<string>;
-
-      output_shields?: Array<string>;
-    }
-
-    export namespace MemoryToolDefinition {
-      export interface UnionMember0 {
-        bank_id: string;
-
-        type: 'vector';
-      }
-
-      export interface UnionMember1 {
-        bank_id: string;
-
-        keys: Array<string>;
-
-        type: 'keyvalue';
-      }
-
-      export interface UnionMember2 {
-        bank_id: string;
-
-        type: 'keyword';
-      }
-
-      export interface UnionMember3 {
-        bank_id: string;
-
-        entities: Array<string>;
-
-        type: 'graph';
-      }
-
-      export interface UnionMember4 {
-        sep: string;
-
-        type: 'default';
-      }
-
-      export interface UnionMember5 {
-        model: string;
-
-        template: string;
-
-        type: 'llm';
-      }
-
-      export interface Type {
-        type: 'custom';
-      }
-    }
-  }
-}
-
-export interface AgentDeleteParams {
-  /**
-   * Body param:
-   */
-  agent_id: string;
-
-  /**
-   * Header param: JSON-encoded provider data which will be made available to the
-   * adapter servicing the API
-   */
-  'X-LlamaStack-ProviderData'?: string;
+  agent_config: Shared.AgentConfig;
 }
 
-export namespace Agents {
-  export import InferenceStep = AgentsAPI.InferenceStep;
-  export import MemoryRetrievalStep = AgentsAPI.MemoryRetrievalStep;
-  export import RestAPIExecutionConfig = AgentsAPI.RestAPIExecutionConfig;
-  export import ShieldCallStep = AgentsAPI.ShieldCallStep;
-  export import ToolExecutionStep = AgentsAPI.ToolExecutionStep;
-  export import ToolParamDefinition = AgentsAPI.ToolParamDefinition;
-  export import AgentCreateResponse = AgentsAPI.AgentCreateResponse;
-  export import AgentCreateParams = AgentsAPI.AgentCreateParams;
-  export import AgentDeleteParams = AgentsAPI.AgentDeleteParams;
-  export import Sessions = SessionsAPI.Sessions;
-  export import Session = SessionsAPI.Session;
-  export import SessionCreateResponse = SessionsAPI.SessionCreateResponse;
-  export import SessionCreateParams = SessionsAPI.SessionCreateParams;
-  export import SessionRetrieveParams = SessionsAPI.SessionRetrieveParams;
-  export import SessionDeleteParams = SessionsAPI.SessionDeleteParams;
-  export import Steps = StepsAPI.Steps;
-  export import AgentsStep = StepsAPI.AgentsStep;
-  export import StepRetrieveParams = StepsAPI.StepRetrieveParams;
-  export import Turns = TurnsAPI.Turns;
-  export import AgentsTurnStreamChunk = TurnsAPI.AgentsTurnStreamChunk;
-  export import Turn = TurnsAPI.Turn;
-  export import TurnStreamEvent = TurnsAPI.TurnStreamEvent;
-  export import TurnCreateParams = TurnsAPI.TurnCreateParams;
-  export import TurnCreateParamsNonStreaming = TurnsAPI.TurnCreateParamsNonStreaming;
-  export import TurnCreateParamsStreaming = TurnsAPI.TurnCreateParamsStreaming;
-  export import TurnRetrieveParams = TurnsAPI.TurnRetrieveParams;
+Agents.SessionResource = SessionResource;
+Agents.Steps = Steps;
+Agents.TurnResource = TurnResource;
+
+export declare namespace Agents {
+  export {
+    type InferenceStep as InferenceStep,
+    type MemoryRetrievalStep as MemoryRetrievalStep,
+    type ShieldCallStep as ShieldCallStep,
+    type ToolExecutionStep as ToolExecutionStep,
+    type ToolResponse as ToolResponse,
+    type AgentCreateResponse as AgentCreateResponse,
+    type AgentCreateParams as AgentCreateParams,
+  };
+
+  export {
+    SessionResource as SessionResource,
+    type Session as Session,
+    type SessionCreateResponse as SessionCreateResponse,
+    type SessionCreateParams as SessionCreateParams,
+    type SessionRetrieveParams as SessionRetrieveParams,
+  };
+
+  export { Steps as Steps, type StepRetrieveResponse as StepRetrieveResponse };
+
+  export {
+    TurnResource as TurnResource,
+    type AgentTurnResponseStreamChunk as AgentTurnResponseStreamChunk,
+    type Turn as Turn,
+    type TurnResponseEvent as TurnResponseEvent,
+    type TurnResponseEventPayload as TurnResponseEventPayload,
+    type TurnCreateParams as TurnCreateParams,
+    type TurnCreateParamsNonStreaming as TurnCreateParamsNonStreaming,
+    type TurnCreateParamsStreaming as TurnCreateParamsStreaming,
+  };
 }

package/src/resources/agents/index.ts

@@ -1,33 +1,30 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-export { AgentsStep, StepRetrieveParams, Steps } from './steps';
 export {
-  AgentsTurnStreamChunk,
-  Turn,
-  TurnStreamEvent,
-  TurnCreateParams,
-  TurnCreateParamsNonStreaming,
-  TurnCreateParamsStreaming,
-  TurnRetrieveParams,
-  Turns,
-} from './turns';
-export {
-  InferenceStep,
-  MemoryRetrievalStep,
-  RestAPIExecutionConfig,
-  ShieldCallStep,
-  ToolExecutionStep,
-  ToolParamDefinition,
-  AgentCreateResponse,
-  AgentCreateParams,
-  AgentDeleteParams,
   Agents,
+  type InferenceStep,
+  type MemoryRetrievalStep,
+  type ShieldCallStep,
+  type ToolExecutionStep,
+  type ToolResponse,
+  type AgentCreateResponse,
+  type AgentCreateParams,
 } from './agents';
 export {
-  Session,
-  SessionCreateResponse,
-  SessionCreateParams,
-  SessionRetrieveParams,
-  SessionDeleteParams,
-  Sessions,
-} from './sessions';
+  SessionResource,
+  type Session,
+  type SessionCreateResponse,
+  type SessionCreateParams,
+  type SessionRetrieveParams,
+} from './session';
+export { Steps, type StepRetrieveResponse } from './steps';
+export {
+  TurnResource,
+  type AgentTurnResponseStreamChunk,
+  type Turn,
+  type TurnResponseEvent,
+  type TurnResponseEventPayload,
+  type TurnCreateParams,
+  type TurnCreateParamsNonStreaming,
+  type TurnCreateParamsStreaming,
+} from './turn';

package/src/resources/agents/session.ts

@@ -0,0 +1,73 @@
+// 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 TurnAPI from './turn';
+
+export class SessionResource extends APIResource {
+  create(
+    agentId: string,
+    body: SessionCreateParams,
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<SessionCreateResponse> {
+    return this._client.post(`/v1/agents/${agentId}/session`, { body, ...options });
+  }
+
+  retrieve(
+    agentId: string,
+    sessionId: string,
+    query?: SessionRetrieveParams,
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<Session>;
+  retrieve(agentId: string, sessionId: string, options?: Core.RequestOptions): Core.APIPromise<Session>;
+  retrieve(
+    agentId: string,
+    sessionId: string,
+    query: SessionRetrieveParams | Core.RequestOptions = {},
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<Session> {
+    if (isRequestOptions(query)) {
+      return this.retrieve(agentId, sessionId, {}, query);
+    }
+    return this._client.get(`/v1/agents/${agentId}/session/${sessionId}`, { query, ...options });
+  }
+
+  delete(agentId: string, sessionId: string, options?: Core.RequestOptions): Core.APIPromise<void> {
+    return this._client.delete(`/v1/agents/${agentId}/session/${sessionId}`, {
+      ...options,
+      headers: { Accept: '*/*', ...options?.headers },
+    });
+  }
+}
+
+export interface Session {
+  session_id: string;
+
+  session_name: string;
+
+  started_at: string;
+
+  turns: Array<TurnAPI.Turn>;
+}
+
+export interface SessionCreateResponse {
+  session_id: string;
+}
+
+export interface SessionCreateParams {
+  session_name: string;
+}
+
+export interface SessionRetrieveParams {
+  turn_ids?: Array<string>;
+}
+
+export declare namespace SessionResource {
+  export {
+    type Session as Session,
+    type SessionCreateResponse as SessionCreateResponse,
+    type SessionCreateParams as SessionCreateParams,
+    type SessionRetrieveParams as SessionRetrieveParams,
+  };
+}

package/src/resources/agents/steps.ts

@@ -2,26 +2,24 @@
 
 import { APIResource } from '../../resource';
 import * as Core from '../../core';
-import * as StepsAPI from './steps';
 import * as AgentsAPI from './agents';
 
 export class Steps extends APIResource {
-  retrieve(params: StepRetrieveParams, options?: Core.RequestOptions): Core.APIPromise<AgentsStep> {
-    const { 'X-LlamaStack-ProviderData': xLlamaStackProviderData, ...query } = params;
-    return this._client.get('/agents/step/get', {
-      query,
-      ...options,
-      headers: {
-        ...(xLlamaStackProviderData != null ?
-          { 'X-LlamaStack-ProviderData': xLlamaStackProviderData }
-        : undefined),
-        ...options?.headers,
-      },
-    });
+  retrieve(
+    agentId: string,
+    sessionId: string,
+    turnId: string,
+    stepId: string,
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<StepRetrieveResponse> {
+    return this._client.get(
+      `/v1/agents/${agentId}/session/${sessionId}/turn/${turnId}/step/${stepId}`,
+      options,
+    );
   }
 }
 
-export interface AgentsStep {
+export interface StepRetrieveResponse {
   step:
     | AgentsAPI.InferenceStep
     | AgentsAPI.ToolExecutionStep
@@ -29,30 +27,6 @@ export interface AgentsStep {
     | AgentsAPI.MemoryRetrievalStep;
 }
 
-export interface StepRetrieveParams {
-  /**
-   * Query param:
-   */
-  agent_id: string;
-
-  /**
-   * Query param:
-   */
-  step_id: string;
-
-  /**
-   * Query param:
-   */
-  turn_id: string;
-
-  /**
-   * Header param: JSON-encoded provider data which will be made available to the
-   * adapter servicing the API
-   */
-  'X-LlamaStack-ProviderData'?: string;
-}
-
-export namespace Steps {
-  export import AgentsStep = StepsAPI.AgentsStep;
-  export import StepRetrieveParams = StepsAPI.StepRetrieveParams;
+export declare namespace Steps {
+  export { type StepRetrieveResponse as StepRetrieveResponse };
 }