llama-stack-client 0.0.35 → 0.1.0

package/src/resources/synthetic-data-generation.ts

@@ -2,61 +2,34 @@
 
 import { APIResource } from '../resource';
 import * as Core from '../core';
-import * as SyntheticDataGenerationAPI from './synthetic-data-generation';
-import * as RewardScoringAPI from './reward-scoring';
 import * as Shared from './shared';
 
-export class SyntheticDataGenerationResource extends APIResource {
+export class SyntheticDataGeneration extends APIResource {
   generate(
-    params: SyntheticDataGenerationGenerateParams,
+    body: SyntheticDataGenerationGenerateParams,
     options?: Core.RequestOptions,
-  ): Core.APIPromise<SyntheticDataGeneration> {
-    const { 'X-LlamaStack-ProviderData': xLlamaStackProviderData, ...body } = params;
-    return this._client.post('/synthetic_data_generation/generate', {
-      body,
-      ...options,
-      headers: {
-        ...(xLlamaStackProviderData != null ?
-          { 'X-LlamaStack-ProviderData': xLlamaStackProviderData }
-        : undefined),
-        ...options?.headers,
-      },
-    });
+  ): Core.APIPromise<SyntheticDataGenerationResponse> {
+    return this._client.post('/v1/synthetic-data-generation/generate', { body, ...options });
   }
 }
 
-export interface SyntheticDataGeneration {
-  synthetic_data: Array<RewardScoringAPI.ScoredDialogGenerations>;
+export interface SyntheticDataGenerationResponse {
+  synthetic_data: Array<Record<string, boolean | number | string | Array<unknown> | unknown | null>>;
 
   statistics?: Record<string, boolean | number | string | Array<unknown> | unknown | null>;
 }
 
 export interface SyntheticDataGenerationGenerateParams {
-  /**
-   * Body param:
-   */
-  dialogs: Array<
-    Shared.UserMessage | Shared.SystemMessage | Shared.ToolResponseMessage | Shared.CompletionMessage
-  >;
-
-  /**
-   * Body param:
-   */
+  dialogs: Array<Shared.Message>;
+
   filtering_function: 'none' | 'random' | 'top_k' | 'top_p' | 'top_k_top_p' | 'sigmoid';
 
-  /**
-   * Body param:
-   */
   model?: string;
-
-  /**
-   * Header param: JSON-encoded provider data which will be made available to the
-   * adapter servicing the API
-   */
-  'X-LlamaStack-ProviderData'?: string;
 }
 
-export namespace SyntheticDataGenerationResource {
-  export import SyntheticDataGeneration = SyntheticDataGenerationAPI.SyntheticDataGeneration;
-  export import SyntheticDataGenerationGenerateParams = SyntheticDataGenerationAPI.SyntheticDataGenerationGenerateParams;
+export declare namespace SyntheticDataGeneration {
+  export {
+    type SyntheticDataGenerationResponse as SyntheticDataGenerationResponse,
+    type SyntheticDataGenerationGenerateParams as SyntheticDataGenerationGenerateParams,
+  };
 }

package/src/resources/telemetry.ts

@@ -1,83 +1,96 @@
 // 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 TelemetryAPI from './telemetry';
 
 export class Telemetry extends APIResource {
-  getTrace(
-    params: TelemetryGetTraceParams,
+  getSpan(
+    traceId: string,
+    spanId: string,
     options?: Core.RequestOptions,
-  ): Core.APIPromise<TelemetryGetTraceResponse> {
-    const { 'X-LlamaStack-ProviderData': xLlamaStackProviderData, ...query } = params;
-    return this._client.get('/telemetry/get_trace', {
-      query,
-      ...options,
-      headers: {
-        ...(xLlamaStackProviderData != null ?
-          { 'X-LlamaStack-ProviderData': xLlamaStackProviderData }
-        : undefined),
-        ...options?.headers,
-      },
-    });
+  ): Core.APIPromise<TelemetryGetSpanResponse> {
+    return this._client.get(`/v1/telemetry/traces/${traceId}/spans/${spanId}`, options);
+  }
+
+  getSpanTree(
+    spanId: string,
+    query?: TelemetryGetSpanTreeParams,
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<TelemetryGetSpanTreeResponse>;
+  getSpanTree(spanId: string, options?: Core.RequestOptions): Core.APIPromise<TelemetryGetSpanTreeResponse>;
+  getSpanTree(
+    spanId: string,
+    query: TelemetryGetSpanTreeParams | Core.RequestOptions = {},
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<TelemetryGetSpanTreeResponse> {
+    if (isRequestOptions(query)) {
+      return this.getSpanTree(spanId, {}, query);
+    }
+    return (
+      this._client.get(`/v1/telemetry/spans/${spanId}/tree`, { query, ...options }) as Core.APIPromise<{
+        data: TelemetryGetSpanTreeResponse;
+      }>
+    )._thenUnwrap((obj) => obj.data);
   }
 
-  log(params: TelemetryLogParams, options?: Core.RequestOptions): Core.APIPromise<void> {
-    const { 'X-LlamaStack-ProviderData': xLlamaStackProviderData, ...body } = params;
-    return this._client.post('/telemetry/log_event', {
+  getTrace(traceId: string, options?: Core.RequestOptions): Core.APIPromise<Trace> {
+    return this._client.get(`/v1/telemetry/traces/${traceId}`, options);
+  }
+
+  logEvent(body: TelemetryLogEventParams, options?: Core.RequestOptions): Core.APIPromise<void> {
+    return this._client.post('/v1/telemetry/events', {
       body,
       ...options,
-      headers: {
-        Accept: '*/*',
-        ...(xLlamaStackProviderData != null ?
-          { 'X-LlamaStack-ProviderData': xLlamaStackProviderData }
-        : undefined),
-        ...options?.headers,
-      },
+      headers: { Accept: '*/*', ...options?.headers },
     });
   }
-}
-
-export interface TelemetryGetTraceResponse {
-  root_span_id: string;
 
-  start_time: string;
-
-  trace_id: string;
-
-  end_time?: string;
-}
+  querySpans(
+    query: TelemetryQuerySpansParams,
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<TelemetryQuerySpansResponse> {
+    return (
+      this._client.get('/v1/telemetry/spans', { query, ...options }) as Core.APIPromise<{
+        data: TelemetryQuerySpansResponse;
+      }>
+    )._thenUnwrap((obj) => obj.data);
+  }
 
-export interface TelemetryGetTraceParams {
-  /**
-   * Query param:
-   */
-  trace_id: string;
+  queryTraces(
+    query?: TelemetryQueryTracesParams,
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<TelemetryQueryTracesResponse>;
+  queryTraces(options?: Core.RequestOptions): Core.APIPromise<TelemetryQueryTracesResponse>;
+  queryTraces(
+    query: TelemetryQueryTracesParams | Core.RequestOptions = {},
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<TelemetryQueryTracesResponse> {
+    if (isRequestOptions(query)) {
+      return this.queryTraces({}, query);
+    }
+    return (
+      this._client.get('/v1/telemetry/traces', { query, ...options }) as Core.APIPromise<{
+        data: TelemetryQueryTracesResponse;
+      }>
+    )._thenUnwrap((obj) => obj.data);
+  }
 
-  /**
-   * Header param: JSON-encoded provider data which will be made available to the
-   * adapter servicing the API
-   */
-  'X-LlamaStack-ProviderData'?: string;
+  saveSpansToDataset(
+    body: TelemetrySaveSpansToDatasetParams,
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<void> {
+    return this._client.post('/v1/telemetry/spans/export', {
+      body,
+      ...options,
+      headers: { Accept: '*/*', ...options?.headers },
+    });
+  }
 }
 
-export interface TelemetryLogParams {
-  /**
-   * Body param:
-   */
-  event:
-    | TelemetryLogParams.UnstructuredLogEvent
-    | TelemetryLogParams.MetricEvent
-    | TelemetryLogParams.StructuredLogEvent;
-
-  /**
-   * Header param: JSON-encoded provider data which will be made available to the
-   * adapter servicing the API
-   */
-  'X-LlamaStack-ProviderData'?: string;
-}
+export type Event = Event.UnstructuredLogEvent | Event.MetricEvent | Event.StructuredLogEvent;
 
-export namespace TelemetryLogParams {
+export namespace Event {
   export interface UnstructuredLogEvent {
     message: string;
 
@@ -143,8 +156,159 @@ export namespace TelemetryLogParams {
   }
 }
 
-export namespace Telemetry {
-  export import TelemetryGetTraceResponse = TelemetryAPI.TelemetryGetTraceResponse;
-  export import TelemetryGetTraceParams = TelemetryAPI.TelemetryGetTraceParams;
-  export import TelemetryLogParams = TelemetryAPI.TelemetryLogParams;
+export interface QueryCondition {
+  key: string;
+
+  op: 'eq' | 'ne' | 'gt' | 'lt';
+
+  value: boolean | number | string | Array<unknown> | unknown | null;
+}
+
+export interface QuerySpansResponse {
+  data: Array<QuerySpansResponse.Data>;
+}
+
+export namespace QuerySpansResponse {
+  export interface Data {
+    name: string;
+
+    span_id: string;
+
+    start_time: string;
+
+    trace_id: string;
+
+    attributes?: Record<string, boolean | number | string | Array<unknown> | unknown | null>;
+
+    end_time?: string;
+
+    parent_span_id?: string;
+  }
+}
+
+export interface SpanWithStatus {
+  name: string;
+
+  span_id: string;
+
+  start_time: string;
+
+  trace_id: string;
+
+  attributes?: Record<string, boolean | number | string | Array<unknown> | unknown | null>;
+
+  end_time?: string;
+
+  parent_span_id?: string;
+
+  status?: 'ok' | 'error';
+}
+
+export interface Trace {
+  root_span_id: string;
+
+  start_time: string;
+
+  trace_id: string;
+
+  end_time?: string;
+}
+
+export interface TelemetryGetSpanResponse {
+  name: string;
+
+  span_id: string;
+
+  start_time: string;
+
+  trace_id: string;
+
+  attributes?: Record<string, boolean | number | string | Array<unknown> | unknown | null>;
+
+  end_time?: string;
+
+  parent_span_id?: string;
+}
+
+export type TelemetryGetSpanTreeResponse = Record<string, SpanWithStatus>;
+
+export type TelemetryQuerySpansResponse = Array<TelemetryQuerySpansResponse.TelemetryQuerySpansResponseItem>;
+
+export namespace TelemetryQuerySpansResponse {
+  export interface TelemetryQuerySpansResponseItem {
+    name: string;
+
+    span_id: string;
+
+    start_time: string;
+
+    trace_id: string;
+
+    attributes?: Record<string, boolean | number | string | Array<unknown> | unknown | null>;
+
+    end_time?: string;
+
+    parent_span_id?: string;
+  }
+}
+
+export type TelemetryQueryTracesResponse = Array<Trace>;
+
+export interface TelemetryGetSpanTreeParams {
+  attributes_to_return?: Array<string>;
+
+  max_depth?: number;
+}
+
+export interface TelemetryLogEventParams {
+  event: Event;
+
+  ttl_seconds: number;
+}
+
+export interface TelemetryQuerySpansParams {
+  attribute_filters: Array<QueryCondition>;
+
+  attributes_to_return: Array<string>;
+
+  max_depth?: number;
+}
+
+export interface TelemetryQueryTracesParams {
+  attribute_filters?: Array<QueryCondition>;
+
+  limit?: number;
+
+  offset?: number;
+
+  order_by?: Array<string>;
+}
+
+export interface TelemetrySaveSpansToDatasetParams {
+  attribute_filters: Array<QueryCondition>;
+
+  attributes_to_save: Array<string>;
+
+  dataset_id: string;
+
+  max_depth?: number;
+}
+
+export declare namespace Telemetry {
+  export {
+    type Event as Event,
+    type QueryCondition as QueryCondition,
+    type QuerySpansResponse as QuerySpansResponse,
+    type SpanWithStatus as SpanWithStatus,
+    type Trace as Trace,
+    type TelemetryGetSpanResponse as TelemetryGetSpanResponse,
+    type TelemetryGetSpanTreeResponse as TelemetryGetSpanTreeResponse,
+    type TelemetryQuerySpansResponse as TelemetryQuerySpansResponse,
+    type TelemetryQueryTracesResponse as TelemetryQueryTracesResponse,
+    type TelemetryGetSpanTreeParams as TelemetryGetSpanTreeParams,
+    type TelemetryLogEventParams as TelemetryLogEventParams,
+    type TelemetryQuerySpansParams as TelemetryQuerySpansParams,
+    type TelemetryQueryTracesParams as TelemetryQueryTracesParams,
+    type TelemetrySaveSpansToDatasetParams as TelemetrySaveSpansToDatasetParams,
+  };
 }

package/src/resources/tool-runtime/index.ts

@@ -0,0 +1,10 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export { RagTool, type RagToolInsertParams, type RagToolQueryParams } from './rag-tool';
+export {
+  ToolRuntime,
+  type ToolDef,
+  type ToolInvocationResult,
+  type ToolRuntimeInvokeToolParams,
+  type ToolRuntimeListToolsParams,
+} from './tool-runtime';

package/src/resources/tool-runtime/rag-tool.ts

@@ -0,0 +1,45 @@
+// 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 RagTool extends APIResource {
+  /**
+   * Index documents so they can be used by the RAG system
+   */
+  insert(body: RagToolInsertParams, options?: Core.RequestOptions): Core.APIPromise<void> {
+    return this._client.post('/v1/tool-runtime/rag-tool/insert', {
+      body,
+      ...options,
+      headers: { Accept: '*/*', ...options?.headers },
+    });
+  }
+
+  /**
+   * Query the RAG system for context; typically invoked by the agent
+   */
+  query(body: RagToolQueryParams, options?: Core.RequestOptions): Core.APIPromise<Shared.QueryResult> {
+    return this._client.post('/v1/tool-runtime/rag-tool/query', { body, ...options });
+  }
+}
+
+export interface RagToolInsertParams {
+  chunk_size_in_tokens: number;
+
+  documents: Array<Shared.Document>;
+
+  vector_db_id: string;
+}
+
+export interface RagToolQueryParams {
+  content: Shared.InterleavedContent;
+
+  vector_db_ids: Array<string>;
+
+  query_config?: Shared.QueryConfig;
+}
+
+export declare namespace RagTool {
+  export { type RagToolInsertParams as RagToolInsertParams, type RagToolQueryParams as RagToolQueryParams };
+}

package/src/resources/tool-runtime/tool-runtime.ts

@@ -0,0 +1,106 @@
+// 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 Shared from '../shared';
+import * as RagToolAPI from './rag-tool';
+import { RagTool, RagToolInsertParams, RagToolQueryParams } from './rag-tool';
+import { JSONLDecoder } from '../../internal/decoders/jsonl';
+
+export class ToolRuntime extends APIResource {
+  ragTool: RagToolAPI.RagTool = new RagToolAPI.RagTool(this._client);
+
+  /**
+   * Run a tool with the given arguments
+   */
+  invokeTool(
+    body: ToolRuntimeInvokeToolParams,
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<ToolInvocationResult> {
+    return this._client.post('/v1/tool-runtime/invoke', { body, ...options });
+  }
+
+  listTools(
+    query?: ToolRuntimeListToolsParams,
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<JSONLDecoder<ToolDef>>;
+  listTools(options?: Core.RequestOptions): Core.APIPromise<JSONLDecoder<ToolDef>>;
+  listTools(
+    query: ToolRuntimeListToolsParams | Core.RequestOptions = {},
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<JSONLDecoder<ToolDef>> {
+    if (isRequestOptions(query)) {
+      return this.listTools({}, query);
+    }
+    return this._client
+      .get('/v1/tool-runtime/list-tools', {
+        query,
+        ...options,
+        headers: { Accept: 'application/jsonl', ...options?.headers },
+        __binaryResponse: true,
+      })
+      ._thenUnwrap((_, props) => JSONLDecoder.fromResponse(props.response, props.controller));
+  }
+}
+
+export interface ToolDef {
+  name: string;
+
+  description?: string;
+
+  metadata?: Record<string, boolean | number | string | Array<unknown> | unknown | null>;
+
+  parameters?: Array<ToolDef.Parameter>;
+}
+
+export namespace ToolDef {
+  export interface Parameter {
+    description: string;
+
+    name: string;
+
+    parameter_type: string;
+
+    required: boolean;
+
+    default?: boolean | number | string | Array<unknown> | unknown | null;
+  }
+}
+
+export interface ToolInvocationResult {
+  content: Shared.InterleavedContent;
+
+  error_code?: number;
+
+  error_message?: string;
+}
+
+export interface ToolRuntimeInvokeToolParams {
+  kwargs: Record<string, boolean | number | string | Array<unknown> | unknown | null>;
+
+  tool_name: string;
+}
+
+export interface ToolRuntimeListToolsParams {
+  mcp_endpoint?: Shared.URL;
+
+  tool_group_id?: string;
+}
+
+ToolRuntime.RagTool = RagTool;
+
+export declare namespace ToolRuntime {
+  export {
+    type ToolDef as ToolDef,
+    type ToolInvocationResult as ToolInvocationResult,
+    type ToolRuntimeInvokeToolParams as ToolRuntimeInvokeToolParams,
+    type ToolRuntimeListToolsParams as ToolRuntimeListToolsParams,
+  };
+
+  export {
+    RagTool as RagTool,
+    type RagToolInsertParams as RagToolInsertParams,
+    type RagToolQueryParams as RagToolQueryParams,
+  };
+}

package/src/resources/toolgroups.ts

@@ -0,0 +1,80 @@
+// 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 Toolgroups extends APIResource {
+  /**
+   * List tool groups with optional provider
+   */
+  list(options?: Core.RequestOptions): Core.APIPromise<ToolgroupListResponse> {
+    return (
+      this._client.get('/v1/toolgroups', options) as Core.APIPromise<{ data: ToolgroupListResponse }>
+    )._thenUnwrap((obj) => obj.data);
+  }
+
+  get(toolgroupId: string, options?: Core.RequestOptions): Core.APIPromise<ToolGroup> {
+    return this._client.get(`/v1/toolgroups/${toolgroupId}`, options);
+  }
+
+  /**
+   * Register a tool group
+   */
+  register(body: ToolgroupRegisterParams, options?: Core.RequestOptions): Core.APIPromise<void> {
+    return this._client.post('/v1/toolgroups', {
+      body,
+      ...options,
+      headers: { Accept: '*/*', ...options?.headers },
+    });
+  }
+
+  /**
+   * Unregister a tool group
+   */
+  unregister(toolgroupId: string, options?: Core.RequestOptions): Core.APIPromise<void> {
+    return this._client.delete(`/v1/toolgroups/${toolgroupId}`, {
+      ...options,
+      headers: { Accept: '*/*', ...options?.headers },
+    });
+  }
+}
+
+export interface ListToolGroupsResponse {
+  data: Array<ToolGroup>;
+}
+
+export interface ToolGroup {
+  identifier: string;
+
+  provider_id: string;
+
+  provider_resource_id: string;
+
+  type: 'tool_group';
+
+  args?: Record<string, boolean | number | string | Array<unknown> | unknown | null>;
+
+  mcp_endpoint?: Shared.URL;
+}
+
+export type ToolgroupListResponse = Array<ToolGroup>;
+
+export interface ToolgroupRegisterParams {
+  provider_id: string;
+
+  toolgroup_id: string;
+
+  args?: Record<string, boolean | number | string | Array<unknown> | unknown | null>;
+
+  mcp_endpoint?: Shared.URL;
+}
+
+export declare namespace Toolgroups {
+  export {
+    type ListToolGroupsResponse as ListToolGroupsResponse,
+    type ToolGroup as ToolGroup,
+    type ToolgroupListResponse as ToolgroupListResponse,
+    type ToolgroupRegisterParams as ToolgroupRegisterParams,
+  };
+}