llama-stack-client 0.4.3 → 0.4.4

package/src/resources/routes.ts

@@ -9,10 +9,12 @@
 import { APIResource } from '../resource';
 import { isRequestOptions } from '../core';
 import * as Core from '../core';
-import * as Shared from './shared';
+import * as InspectAPI from './inspect';
 
 export class Routes extends APIResource {
   /**
+   * List routes.
+   *
    * List all available API routes with their methods and implementing providers.
    */
   list(query?: RouteListParams, options?: Core.RequestOptions): Core.APIPromise<RouteListResponse>;
@@ -33,20 +35,22 @@ export class Routes extends APIResource {
 }
 
 /**
- * List of available API routes
+ * Response containing a list of all available API routes.
  */
-export type RouteListResponse = Array<Shared.RouteInfo>;
+export interface ListRoutesResponse {
+  data: RouteListResponse;
+}
+
+export type RouteListResponse = Array<InspectAPI.RouteInfo>;
 
 export interface RouteListParams {
-  /**
-   * Optional filter to control which routes are returned. Can be an API level ('v1',
-   * 'v1alpha', 'v1beta') to show non-deprecated routes at that level, or
-   * 'deprecated' to show deprecated routes across all levels. If not specified,
-   * returns all non-deprecated routes.
-   */
   api_filter?: 'v1' | 'v1alpha' | 'v1beta' | 'deprecated' | null;
 }
 
 export declare namespace Routes {
-  export { type RouteListResponse as RouteListResponse, type RouteListParams as RouteListParams };
+  export {
+    type ListRoutesResponse as ListRoutesResponse,
+    type RouteListResponse as RouteListResponse,
+    type RouteListParams as RouteListParams,
+  };
 }

package/src/resources/shared.ts

@@ -6,19 +6,6 @@
 //
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-import * as ProvidersAPI from './providers';
-import * as RoutesAPI from './routes';
-
-/**
- * Health status information for the service.
- */
-export interface HealthInfo {
-  /**
-   * The health status of the service
-   */
-  status: 'OK' | 'Error' | 'Not Implemented';
-}
-
 /**
  * A image content item
  */
@@ -171,26 +158,6 @@ export namespace InterleavedContentItem {
   }
 }
 
-/**
- * Response containing a list of all available providers.
- */
-export interface ListProvidersResponse {
-  /**
-   * List of provider information objects
-   */
-  data: ProvidersAPI.ProviderListResponse;
-}
-
-/**
- * Response containing a list of all available API routes.
- */
-export interface ListRoutesResponse {
-  /**
-   * List of available API routes
-   */
-  data: RoutesAPI.RouteListResponse;
-}
-
 /**
  * Parameter type for string values.
  */
@@ -270,58 +237,6 @@ export namespace ParamType {
   }
 }
 
-/**
- * Information about a registered provider including its configuration and health
- * status.
- */
-export interface ProviderInfo {
-  /**
-   * The API name this provider implements
-   */
-  api: string;
-
-  /**
-   * Configuration parameters for the provider
-   */
-  config: { [key: string]: unknown };
-
-  /**
-   * Current health status of the provider
-   */
-  health: { [key: string]: unknown };
-
-  /**
-   * Unique identifier for the provider
-   */
-  provider_id: string;
-
-  /**
-   * The type of provider implementation
-   */
-  provider_type: string;
-}
-
-/**
- * Information about an API route including its path, method, and implementing
- * providers.
- */
-export interface RouteInfo {
-  /**
-   * The HTTP method for the route
-   */
-  method: string;
-
-  /**
-   * List of provider types implementing this route
-   */
-  provider_types: Array<string>;
-
-  /**
-   * The API route path
-   */
-  route: string;
-}
-
 /**
  * Details of a safety violation detected by content moderation.
  */
@@ -501,13 +416,3 @@ export namespace SystemMessage {
     type?: 'text';
   }
 }
-
-/**
- * Version information for the service.
- */
-export interface VersionInfo {
-  /**
-   * The version string of the service
-   */
-  version: string;
-}

package/src/version.ts

@@ -4,4 +4,4 @@
 // This source code is licensed under the terms described in the LICENSE file in
 // the root directory of this source tree.
 
-export const VERSION = '0.4.3'; // x-release-please-version
+export const VERSION = '0.4.4'; // x-release-please-version

package/tests/api-resources/alpha/benchmarks.test.ts

@@ -0,0 +1,94 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+// All rights reserved.
+//
+// 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 LlamaStackClient from 'llama-stack-client';
+import { Response } from 'node-fetch';
+
+const client = new LlamaStackClient({ baseURL: process.env['TEST_API_BASE_URL'] ?? 'http://127.0.0.1:4010' });
+
+describe('resource benchmarks', () => {
+  test('retrieve', async () => {
+    const responsePromise = client.alpha.benchmarks.retrieve('benchmark_id');
+    const rawResponse = await responsePromise.asResponse();
+    expect(rawResponse).toBeInstanceOf(Response);
+    const response = await responsePromise;
+    expect(response).not.toBeInstanceOf(Response);
+    const dataAndResponse = await responsePromise.withResponse();
+    expect(dataAndResponse.data).toBe(response);
+    expect(dataAndResponse.response).toBe(rawResponse);
+  });
+
+  test('retrieve: request options instead of params are passed correctly', async () => {
+    // ensure the request options are being passed correctly by passing an invalid HTTP method in order to cause an error
+    await expect(
+      client.alpha.benchmarks.retrieve('benchmark_id', { path: '/_stainless_unknown_path' }),
+    ).rejects.toThrow(LlamaStackClient.NotFoundError);
+  });
+
+  test('list', async () => {
+    const responsePromise = client.alpha.benchmarks.list();
+    const rawResponse = await responsePromise.asResponse();
+    expect(rawResponse).toBeInstanceOf(Response);
+    const response = await responsePromise;
+    expect(response).not.toBeInstanceOf(Response);
+    const dataAndResponse = await responsePromise.withResponse();
+    expect(dataAndResponse.data).toBe(response);
+    expect(dataAndResponse.response).toBe(rawResponse);
+  });
+
+  test('list: request options instead of params are passed correctly', async () => {
+    // ensure the request options are being passed correctly by passing an invalid HTTP method in order to cause an error
+    await expect(client.alpha.benchmarks.list({ path: '/_stainless_unknown_path' })).rejects.toThrow(
+      LlamaStackClient.NotFoundError,
+    );
+  });
+
+  test('register: only required params', async () => {
+    const responsePromise = client.alpha.benchmarks.register({
+      benchmark_id: 'benchmark_id',
+      dataset_id: 'dataset_id',
+      scoring_functions: ['string'],
+    });
+    const rawResponse = await responsePromise.asResponse();
+    expect(rawResponse).toBeInstanceOf(Response);
+    const response = await responsePromise;
+    expect(response).not.toBeInstanceOf(Response);
+    const dataAndResponse = await responsePromise.withResponse();
+    expect(dataAndResponse.data).toBe(response);
+    expect(dataAndResponse.response).toBe(rawResponse);
+  });
+
+  test('register: required and optional params', async () => {
+    const response = await client.alpha.benchmarks.register({
+      benchmark_id: 'benchmark_id',
+      dataset_id: 'dataset_id',
+      scoring_functions: ['string'],
+      metadata: { foo: 'bar' },
+      provider_benchmark_id: 'provider_benchmark_id',
+      provider_id: 'provider_id',
+    });
+  });
+
+  test('unregister', async () => {
+    const responsePromise = client.alpha.benchmarks.unregister('benchmark_id');
+    const rawResponse = await responsePromise.asResponse();
+    expect(rawResponse).toBeInstanceOf(Response);
+    const response = await responsePromise;
+    expect(response).not.toBeInstanceOf(Response);
+    const dataAndResponse = await responsePromise.withResponse();
+    expect(dataAndResponse.data).toBe(response);
+    expect(dataAndResponse.response).toBe(rawResponse);
+  });
+
+  test('unregister: request options instead of params are passed correctly', async () => {
+    // ensure the request options are being passed correctly by passing an invalid HTTP method in order to cause an error
+    await expect(
+      client.alpha.benchmarks.unregister('benchmark_id', { path: '/_stainless_unknown_path' }),
+    ).rejects.toThrow(LlamaStackClient.NotFoundError);
+  });
+});

package/tests/api-resources/alpha/eval/eval.test.ts

@@ -0,0 +1,186 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+// All rights reserved.
+//
+// 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 LlamaStackClient from 'llama-stack-client';
+import { Response } from 'node-fetch';
+
+const client = new LlamaStackClient({ baseURL: process.env['TEST_API_BASE_URL'] ?? 'http://127.0.0.1:4010' });
+
+describe('resource eval', () => {
+  test('evaluateRows: only required params', async () => {
+    const responsePromise = client.alpha.eval.evaluateRows('benchmark_id', {
+      benchmark_config: { eval_candidate: { model: 'model', sampling_params: {} } },
+      input_rows: [{ foo: 'bar' }],
+      scoring_functions: ['string'],
+    });
+    const rawResponse = await responsePromise.asResponse();
+    expect(rawResponse).toBeInstanceOf(Response);
+    const response = await responsePromise;
+    expect(response).not.toBeInstanceOf(Response);
+    const dataAndResponse = await responsePromise.withResponse();
+    expect(dataAndResponse.data).toBe(response);
+    expect(dataAndResponse.response).toBe(rawResponse);
+  });
+
+  test('evaluateRows: required and optional params', async () => {
+    const response = await client.alpha.eval.evaluateRows('benchmark_id', {
+      benchmark_config: {
+        eval_candidate: {
+          model: 'model',
+          sampling_params: {
+            max_tokens: 0,
+            repetition_penalty: 0,
+            stop: ['string'],
+            strategy: { type: 'greedy' },
+          },
+          system_message: { content: 'string', role: 'system' },
+          type: 'model',
+        },
+        num_examples: 0,
+        scoring_params: {
+          foo: {
+            judge_model: 'judge_model',
+            aggregation_functions: ['average'],
+            judge_score_regexes: ['string'],
+            prompt_template: 'prompt_template',
+            type: 'llm_as_judge',
+          },
+        },
+      },
+      input_rows: [{ foo: 'bar' }],
+      scoring_functions: ['string'],
+    });
+  });
+
+  test('evaluateRowsAlpha: only required params', async () => {
+    const responsePromise = client.alpha.eval.evaluateRowsAlpha('benchmark_id', {
+      benchmark_config: { eval_candidate: { model: 'model', sampling_params: {} } },
+      input_rows: [{ foo: 'bar' }],
+      scoring_functions: ['string'],
+    });
+    const rawResponse = await responsePromise.asResponse();
+    expect(rawResponse).toBeInstanceOf(Response);
+    const response = await responsePromise;
+    expect(response).not.toBeInstanceOf(Response);
+    const dataAndResponse = await responsePromise.withResponse();
+    expect(dataAndResponse.data).toBe(response);
+    expect(dataAndResponse.response).toBe(rawResponse);
+  });
+
+  test('evaluateRowsAlpha: required and optional params', async () => {
+    const response = await client.alpha.eval.evaluateRowsAlpha('benchmark_id', {
+      benchmark_config: {
+        eval_candidate: {
+          model: 'model',
+          sampling_params: {
+            max_tokens: 0,
+            repetition_penalty: 0,
+            stop: ['string'],
+            strategy: { type: 'greedy' },
+          },
+          system_message: { content: 'string', role: 'system' },
+          type: 'model',
+        },
+        num_examples: 0,
+        scoring_params: {
+          foo: {
+            judge_model: 'judge_model',
+            aggregation_functions: ['average'],
+            judge_score_regexes: ['string'],
+            prompt_template: 'prompt_template',
+            type: 'llm_as_judge',
+          },
+        },
+      },
+      input_rows: [{ foo: 'bar' }],
+      scoring_functions: ['string'],
+    });
+  });
+
+  test('runEval: only required params', async () => {
+    const responsePromise = client.alpha.eval.runEval('benchmark_id', {
+      benchmark_config: { eval_candidate: { model: 'model', sampling_params: {} } },
+    });
+    const rawResponse = await responsePromise.asResponse();
+    expect(rawResponse).toBeInstanceOf(Response);
+    const response = await responsePromise;
+    expect(response).not.toBeInstanceOf(Response);
+    const dataAndResponse = await responsePromise.withResponse();
+    expect(dataAndResponse.data).toBe(response);
+    expect(dataAndResponse.response).toBe(rawResponse);
+  });
+
+  test('runEval: required and optional params', async () => {
+    const response = await client.alpha.eval.runEval('benchmark_id', {
+      benchmark_config: {
+        eval_candidate: {
+          model: 'model',
+          sampling_params: {
+            max_tokens: 0,
+            repetition_penalty: 0,
+            stop: ['string'],
+            strategy: { type: 'greedy' },
+          },
+          system_message: { content: 'string', role: 'system' },
+          type: 'model',
+        },
+        num_examples: 0,
+        scoring_params: {
+          foo: {
+            judge_model: 'judge_model',
+            aggregation_functions: ['average'],
+            judge_score_regexes: ['string'],
+            prompt_template: 'prompt_template',
+            type: 'llm_as_judge',
+          },
+        },
+      },
+    });
+  });
+
+  test('runEvalAlpha: only required params', async () => {
+    const responsePromise = client.alpha.eval.runEvalAlpha('benchmark_id', {
+      benchmark_config: { eval_candidate: { model: 'model', sampling_params: {} } },
+    });
+    const rawResponse = await responsePromise.asResponse();
+    expect(rawResponse).toBeInstanceOf(Response);
+    const response = await responsePromise;
+    expect(response).not.toBeInstanceOf(Response);
+    const dataAndResponse = await responsePromise.withResponse();
+    expect(dataAndResponse.data).toBe(response);
+    expect(dataAndResponse.response).toBe(rawResponse);
+  });
+
+  test('runEvalAlpha: required and optional params', async () => {
+    const response = await client.alpha.eval.runEvalAlpha('benchmark_id', {
+      benchmark_config: {
+        eval_candidate: {
+          model: 'model',
+          sampling_params: {
+            max_tokens: 0,
+            repetition_penalty: 0,
+            stop: ['string'],
+            strategy: { type: 'greedy' },
+          },
+          system_message: { content: 'string', role: 'system' },
+          type: 'model',
+        },
+        num_examples: 0,
+        scoring_params: {
+          foo: {
+            judge_model: 'judge_model',
+            aggregation_functions: ['average'],
+            judge_score_regexes: ['string'],
+            prompt_template: 'prompt_template',
+            type: 'llm_as_judge',
+          },
+        },
+      },
+    });
+  });
+});

package/tests/api-resources/alpha/eval/jobs.test.ts

@@ -0,0 +1,68 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+// All rights reserved.
+//
+// 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 LlamaStackClient from 'llama-stack-client';
+import { Response } from 'node-fetch';
+
+const client = new LlamaStackClient({ baseURL: process.env['TEST_API_BASE_URL'] ?? 'http://127.0.0.1:4010' });
+
+describe('resource jobs', () => {
+  test('retrieve', async () => {
+    const responsePromise = client.alpha.eval.jobs.retrieve('benchmark_id', 'job_id');
+    const rawResponse = await responsePromise.asResponse();
+    expect(rawResponse).toBeInstanceOf(Response);
+    const response = await responsePromise;
+    expect(response).not.toBeInstanceOf(Response);
+    const dataAndResponse = await responsePromise.withResponse();
+    expect(dataAndResponse.data).toBe(response);
+    expect(dataAndResponse.response).toBe(rawResponse);
+  });
+
+  test('retrieve: request options instead of params are passed correctly', async () => {
+    // ensure the request options are being passed correctly by passing an invalid HTTP method in order to cause an error
+    await expect(
+      client.alpha.eval.jobs.retrieve('benchmark_id', 'job_id', { path: '/_stainless_unknown_path' }),
+    ).rejects.toThrow(LlamaStackClient.NotFoundError);
+  });
+
+  test('cancel', async () => {
+    const responsePromise = client.alpha.eval.jobs.cancel('benchmark_id', 'job_id');
+    const rawResponse = await responsePromise.asResponse();
+    expect(rawResponse).toBeInstanceOf(Response);
+    const response = await responsePromise;
+    expect(response).not.toBeInstanceOf(Response);
+    const dataAndResponse = await responsePromise.withResponse();
+    expect(dataAndResponse.data).toBe(response);
+    expect(dataAndResponse.response).toBe(rawResponse);
+  });
+
+  test('cancel: request options instead of params are passed correctly', async () => {
+    // ensure the request options are being passed correctly by passing an invalid HTTP method in order to cause an error
+    await expect(
+      client.alpha.eval.jobs.cancel('benchmark_id', 'job_id', { path: '/_stainless_unknown_path' }),
+    ).rejects.toThrow(LlamaStackClient.NotFoundError);
+  });
+
+  test('status', async () => {
+    const responsePromise = client.alpha.eval.jobs.status('benchmark_id', 'job_id');
+    const rawResponse = await responsePromise.asResponse();
+    expect(rawResponse).toBeInstanceOf(Response);
+    const response = await responsePromise;
+    expect(response).not.toBeInstanceOf(Response);
+    const dataAndResponse = await responsePromise.withResponse();
+    expect(dataAndResponse.data).toBe(response);
+    expect(dataAndResponse.response).toBe(rawResponse);
+  });
+
+  test('status: request options instead of params are passed correctly', async () => {
+    // ensure the request options are being passed correctly by passing an invalid HTTP method in order to cause an error
+    await expect(
+      client.alpha.eval.jobs.status('benchmark_id', 'job_id', { path: '/_stainless_unknown_path' }),
+    ).rejects.toThrow(LlamaStackClient.NotFoundError);
+  });
+});

package/tests/api-resources/alpha/inference.test.ts

@@ -0,0 +1,38 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+// All rights reserved.
+//
+// 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 LlamaStackClient from 'llama-stack-client';
+import { Response } from 'node-fetch';
+
+const client = new LlamaStackClient({ baseURL: process.env['TEST_API_BASE_URL'] ?? 'http://127.0.0.1:4010' });
+
+describe('resource inference', () => {
+  test('rerank: only required params', async () => {
+    const responsePromise = client.alpha.inference.rerank({
+      items: ['string'],
+      model: 'model',
+      query: 'string',
+    });
+    const rawResponse = await responsePromise.asResponse();
+    expect(rawResponse).toBeInstanceOf(Response);
+    const response = await responsePromise;
+    expect(response).not.toBeInstanceOf(Response);
+    const dataAndResponse = await responsePromise.withResponse();
+    expect(dataAndResponse.data).toBe(response);
+    expect(dataAndResponse.response).toBe(rawResponse);
+  });
+
+  test('rerank: required and optional params', async () => {
+    const response = await client.alpha.inference.rerank({
+      items: ['string'],
+      model: 'model',
+      query: 'string',
+      max_num_results: 0,
+    });
+  });
+});

package/tests/api-resources/alpha/post-training/job.test.ts

@@ -0,0 +1,77 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+// All rights reserved.
+//
+// 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 LlamaStackClient from 'llama-stack-client';
+import { Response } from 'node-fetch';
+
+const client = new LlamaStackClient({ baseURL: process.env['TEST_API_BASE_URL'] ?? 'http://127.0.0.1:4010' });
+
+describe('resource job', () => {
+  test('list', async () => {
+    const responsePromise = client.alpha.postTraining.job.list();
+    const rawResponse = await responsePromise.asResponse();
+    expect(rawResponse).toBeInstanceOf(Response);
+    const response = await responsePromise;
+    expect(response).not.toBeInstanceOf(Response);
+    const dataAndResponse = await responsePromise.withResponse();
+    expect(dataAndResponse.data).toBe(response);
+    expect(dataAndResponse.response).toBe(rawResponse);
+  });
+
+  test('list: request options instead of params are passed correctly', async () => {
+    // ensure the request options are being passed correctly by passing an invalid HTTP method in order to cause an error
+    await expect(client.alpha.postTraining.job.list({ path: '/_stainless_unknown_path' })).rejects.toThrow(
+      LlamaStackClient.NotFoundError,
+    );
+  });
+
+  test('artifacts: only required params', async () => {
+    const responsePromise = client.alpha.postTraining.job.artifacts({ job_uuid: 'job_uuid' });
+    const rawResponse = await responsePromise.asResponse();
+    expect(rawResponse).toBeInstanceOf(Response);
+    const response = await responsePromise;
+    expect(response).not.toBeInstanceOf(Response);
+    const dataAndResponse = await responsePromise.withResponse();
+    expect(dataAndResponse.data).toBe(response);
+    expect(dataAndResponse.response).toBe(rawResponse);
+  });
+
+  test('artifacts: required and optional params', async () => {
+    const response = await client.alpha.postTraining.job.artifacts({ job_uuid: 'job_uuid' });
+  });
+
+  test('cancel: only required params', async () => {
+    const responsePromise = client.alpha.postTraining.job.cancel({ job_uuid: 'job_uuid' });
+    const rawResponse = await responsePromise.asResponse();
+    expect(rawResponse).toBeInstanceOf(Response);
+    const response = await responsePromise;
+    expect(response).not.toBeInstanceOf(Response);
+    const dataAndResponse = await responsePromise.withResponse();
+    expect(dataAndResponse.data).toBe(response);
+    expect(dataAndResponse.response).toBe(rawResponse);
+  });
+
+  test('cancel: required and optional params', async () => {
+    const response = await client.alpha.postTraining.job.cancel({ job_uuid: 'job_uuid' });
+  });
+
+  test('status: only required params', async () => {
+    const responsePromise = client.alpha.postTraining.job.status({ job_uuid: 'job_uuid' });
+    const rawResponse = await responsePromise.asResponse();
+    expect(rawResponse).toBeInstanceOf(Response);
+    const response = await responsePromise;
+    expect(response).not.toBeInstanceOf(Response);
+    const dataAndResponse = await responsePromise.withResponse();
+    expect(dataAndResponse.data).toBe(response);
+    expect(dataAndResponse.response).toBe(rawResponse);
+  });
+
+  test('status: required and optional params', async () => {
+    const response = await client.alpha.postTraining.job.status({ job_uuid: 'job_uuid' });
+  });
+});