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

package/src/resources/agents/turn.ts

@@ -0,0 +1,292 @@
+// 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 TurnAPI from './turn';
+import * as Shared from '../shared';
+import * as AgentsAPI from './agents';
+import { Stream } from '../../streaming';
+
+export class TurnResource extends APIResource {
+  create(
+    agentId: string,
+    sessionId: string,
+    body: TurnCreateParamsNonStreaming,
+    options?: Core.RequestOptions,
+  ): APIPromise<Turn>;
+  create(
+    agentId: string,
+    sessionId: string,
+    body: TurnCreateParamsStreaming,
+    options?: Core.RequestOptions,
+  ): APIPromise<Stream<AgentTurnResponseStreamChunk>>;
+  create(
+    agentId: string,
+    sessionId: string,
+    body: TurnCreateParamsBase,
+    options?: Core.RequestOptions,
+  ): APIPromise<Stream<AgentTurnResponseStreamChunk> | Turn>;
+  create(
+    agentId: string,
+    sessionId: string,
+    body: TurnCreateParams,
+    options?: Core.RequestOptions,
+  ): APIPromise<Turn> | APIPromise<Stream<AgentTurnResponseStreamChunk>> {
+    return this._client.post(`/v1/agents/${agentId}/session/${sessionId}/turn`, {
+      body,
+      ...options,
+      stream: body.stream ?? false,
+    }) as APIPromise<Turn> | APIPromise<Stream<AgentTurnResponseStreamChunk>>;
+  }
+
+  retrieve(
+    agentId: string,
+    sessionId: string,
+    turnId: string,
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<Turn> {
+    return this._client.get(`/v1/agents/${agentId}/session/${sessionId}/turn/${turnId}`, options);
+  }
+}
+
+export interface AgentTurnResponseStreamChunk {
+  event: TurnResponseEvent;
+}
+
+export interface Turn {
+  input_messages: Array<Shared.UserMessage | Shared.ToolResponseMessage>;
+
+  output_attachments: Array<Turn.OutputAttachment>;
+
+  output_message: Shared.CompletionMessage;
+
+  session_id: string;
+
+  started_at: string;
+
+  steps: Array<
+    | AgentsAPI.InferenceStep
+    | AgentsAPI.ToolExecutionStep
+    | AgentsAPI.ShieldCallStep
+    | AgentsAPI.MemoryRetrievalStep
+  >;
+
+  turn_id: string;
+
+  completed_at?: string;
+}
+
+export namespace Turn {
+  export interface OutputAttachment {
+    content:
+      | string
+      | OutputAttachment.ImageContentItem
+      | OutputAttachment.TextContentItem
+      | Array<Shared.InterleavedContentItem>
+      | Shared.URL;
+
+    mime_type: string;
+  }
+
+  export namespace OutputAttachment {
+    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 interface TurnResponseEvent {
+  payload: TurnResponseEventPayload;
+}
+
+export type TurnResponseEventPayload =
+  | TurnResponseEventPayload.AgentTurnResponseStepStartPayload
+  | TurnResponseEventPayload.AgentTurnResponseStepProgressPayload
+  | TurnResponseEventPayload.AgentTurnResponseStepCompletePayload
+  | TurnResponseEventPayload.AgentTurnResponseTurnStartPayload
+  | TurnResponseEventPayload.AgentTurnResponseTurnCompletePayload;
+
+export namespace TurnResponseEventPayload {
+  export interface AgentTurnResponseStepStartPayload {
+    event_type: 'step_start';
+
+    step_id: string;
+
+    step_type: 'inference' | 'tool_execution' | 'shield_call' | 'memory_retrieval';
+
+    metadata?: Record<string, boolean | number | string | Array<unknown> | unknown | null>;
+  }
+
+  export interface AgentTurnResponseStepProgressPayload {
+    delta: Shared.ContentDelta;
+
+    event_type: 'step_progress';
+
+    step_id: string;
+
+    step_type: 'inference' | 'tool_execution' | 'shield_call' | 'memory_retrieval';
+  }
+
+  export interface AgentTurnResponseStepCompletePayload {
+    event_type: 'step_complete';
+
+    step_details:
+      | AgentsAPI.InferenceStep
+      | AgentsAPI.ToolExecutionStep
+      | AgentsAPI.ShieldCallStep
+      | AgentsAPI.MemoryRetrievalStep;
+
+    step_id: string;
+
+    step_type: 'inference' | 'tool_execution' | 'shield_call' | 'memory_retrieval';
+  }
+
+  export interface AgentTurnResponseTurnStartPayload {
+    event_type: 'turn_start';
+
+    turn_id: string;
+  }
+
+  export interface AgentTurnResponseTurnCompletePayload {
+    event_type: 'turn_complete';
+
+    turn: TurnAPI.Turn;
+  }
+}
+
+export type TurnCreateParams = TurnCreateParamsNonStreaming | TurnCreateParamsStreaming;
+
+export interface TurnCreateParamsBase {
+  messages: Array<Shared.UserMessage | Shared.ToolResponseMessage>;
+
+  documents?: Array<TurnCreateParams.Document>;
+
+  stream?: boolean;
+
+  toolgroups?: Array<string | TurnCreateParams.UnionMember1>;
+}
+
+export namespace TurnCreateParams {
+  export interface Document {
+    content:
+      | string
+      | Document.ImageContentItem
+      | Document.TextContentItem
+      | Array<Shared.InterleavedContentItem>
+      | Shared.URL;
+
+    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 interface UnionMember1 {
+    args: Record<string, boolean | number | string | Array<unknown> | unknown | null>;
+
+    name: string;
+  }
+
+  export type TurnCreateParamsNonStreaming = TurnAPI.TurnCreateParamsNonStreaming;
+  export type TurnCreateParamsStreaming = TurnAPI.TurnCreateParamsStreaming;
+}
+
+export interface TurnCreateParamsNonStreaming extends TurnCreateParamsBase {
+  stream?: false;
+}
+
+export interface TurnCreateParamsStreaming extends TurnCreateParamsBase {
+  stream: true;
+}
+
+export declare namespace TurnResource {
+  export {
+    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/batch-inference.ts

@@ -2,105 +2,51 @@
 
 import { APIResource } from '../resource';
 import * as Core from '../core';
-import * as BatchInferenceAPI from './batch-inference';
 import * as Shared from './shared';
-import * as AgentsAPI from './agents/agents';
 
 export class BatchInference extends APIResource {
   chatCompletion(
-    params: BatchInferenceChatCompletionParams,
+    body: BatchInferenceChatCompletionParams,
     options?: Core.RequestOptions,
-  ): Core.APIPromise<BatchChatCompletion> {
-    const { 'X-LlamaStack-ProviderData': xLlamaStackProviderData, ...body } = params;
-    return this._client.post('/batch_inference/chat_completion', {
-      body,
-      ...options,
-      headers: {
-        ...(xLlamaStackProviderData != null ?
-          { 'X-LlamaStack-ProviderData': xLlamaStackProviderData }
-        : undefined),
-        ...options?.headers,
-      },
-    });
+  ): Core.APIPromise<BatchInferenceChatCompletionResponse> {
+    return this._client.post('/v1/batch-inference/chat-completion', { body, ...options });
   }
 
   completion(
-    params: BatchInferenceCompletionParams,
+    body: BatchInferenceCompletionParams,
     options?: Core.RequestOptions,
   ): Core.APIPromise<Shared.BatchCompletion> {
-    const { 'X-LlamaStack-ProviderData': xLlamaStackProviderData, ...body } = params;
-    return this._client.post('/batch_inference/completion', {
-      body,
-      ...options,
-      headers: {
-        ...(xLlamaStackProviderData != null ?
-          { 'X-LlamaStack-ProviderData': xLlamaStackProviderData }
-        : undefined),
-        ...options?.headers,
-      },
-    });
+    return this._client.post('/v1/batch-inference/completion', { body, ...options });
   }
 }
 
-export interface BatchChatCompletion {
-  completion_message_batch: Array<Shared.CompletionMessage>;
+export interface BatchInferenceChatCompletionResponse {
+  batch: Array<Shared.ChatCompletionResponse>;
 }
 
 export interface BatchInferenceChatCompletionParams {
-  /**
-   * Body param:
-   */
-  messages_batch: Array<
-    Array<Shared.UserMessage | Shared.SystemMessage | Shared.ToolResponseMessage | Shared.CompletionMessage>
-  >;
-
-  /**
-   * Body param:
-   */
+  messages_batch: Array<Array<Shared.Message>>;
+
   model: string;
 
-  /**
-   * Body param:
-   */
   logprobs?: BatchInferenceChatCompletionParams.Logprobs;
 
-  /**
-   * Body param:
-   */
+  response_format?: Shared.ResponseFormat;
+
   sampling_params?: Shared.SamplingParams;
 
-  /**
-   * Body param:
-   */
   tool_choice?: 'auto' | 'required';
 
-  /**
-   * Body param: `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';
-
-  /**
-   * Body param:
-   */
-  tools?: Array<BatchInferenceChatCompletionParams.Tool>;
+  tool_prompt_format?: 'json' | 'function_tag' | 'python_list';
 
-  /**
-   * Header param: JSON-encoded provider data which will be made available to the
-   * adapter servicing the API
-   */
-  'X-LlamaStack-ProviderData'?: string;
+  tools?: Array<BatchInferenceChatCompletionParams.Tool>;
 }
 
 export namespace BatchInferenceChatCompletionParams {
   export interface Logprobs {
+    /**
+     * How many tokens (for each position) to return log probabilities for.
+     */
     top_k?: number;
   }
 
@@ -109,46 +55,35 @@ export namespace BatchInferenceChatCompletionParams {
 
     description?: string;
 
-    parameters?: Record<string, AgentsAPI.ToolParamDefinition>;
+    parameters?: Record<string, Shared.ToolParamDefinition>;
   }
 }
 
 export interface BatchInferenceCompletionParams {
-  /**
-   * Body param:
-   */
-  content_batch: Array<string | Array<string>>;
-
-  /**
-   * Body param:
-   */
+  content_batch: Array<Shared.InterleavedContent>;
+
   model: string;
 
-  /**
-   * Body param:
-   */
   logprobs?: BatchInferenceCompletionParams.Logprobs;
 
-  /**
-   * Body param:
-   */
-  sampling_params?: Shared.SamplingParams;
+  response_format?: Shared.ResponseFormat;
 
-  /**
-   * Header param: JSON-encoded provider data which will be made available to the
-   * adapter servicing the API
-   */
-  'X-LlamaStack-ProviderData'?: string;
+  sampling_params?: Shared.SamplingParams;
 }
 
 export namespace BatchInferenceCompletionParams {
   export interface Logprobs {
+    /**
+     * How many tokens (for each position) to return log probabilities for.
+     */
     top_k?: number;
   }
 }
 
-export namespace BatchInference {
-  export import BatchChatCompletion = BatchInferenceAPI.BatchChatCompletion;
-  export import BatchInferenceChatCompletionParams = BatchInferenceAPI.BatchInferenceChatCompletionParams;
-  export import BatchInferenceCompletionParams = BatchInferenceAPI.BatchInferenceCompletionParams;
+export declare namespace BatchInference {
+  export {
+    type BatchInferenceChatCompletionResponse as BatchInferenceChatCompletionResponse,
+    type BatchInferenceChatCompletionParams as BatchInferenceChatCompletionParams,
+    type BatchInferenceCompletionParams as BatchInferenceCompletionParams,
+  };
 }

package/src/resources/datasetio.ts

@@ -0,0 +1,53 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../resource';
+import * as Core from '../core';
+
+export class Datasetio extends APIResource {
+  appendRows(body: DatasetioAppendRowsParams, options?: Core.RequestOptions): Core.APIPromise<void> {
+    return this._client.post('/v1/datasetio/rows', {
+      body,
+      ...options,
+      headers: { Accept: '*/*', ...options?.headers },
+    });
+  }
+
+  getRowsPaginated(
+    query: DatasetioGetRowsPaginatedParams,
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<PaginatedRowsResult> {
+    return this._client.get('/v1/datasetio/rows', { query, ...options });
+  }
+}
+
+export interface PaginatedRowsResult {
+  rows: Array<Record<string, boolean | number | string | Array<unknown> | unknown | null>>;
+
+  total_count: number;
+
+  next_page_token?: string;
+}
+
+export interface DatasetioAppendRowsParams {
+  dataset_id: string;
+
+  rows: Array<Record<string, boolean | number | string | Array<unknown> | unknown | null>>;
+}
+
+export interface DatasetioGetRowsPaginatedParams {
+  dataset_id: string;
+
+  rows_in_page: number;
+
+  filter_condition?: string;
+
+  page_token?: string;
+}
+
+export declare namespace Datasetio {
+  export {
+    type PaginatedRowsResult as PaginatedRowsResult,
+    type DatasetioAppendRowsParams as DatasetioAppendRowsParams,
+    type DatasetioGetRowsPaginatedParams as DatasetioGetRowsPaginatedParams,
+  };
+}