llama-stack-client 0.4.3 → 0.4.4

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

@@ -0,0 +1,124 @@
+// 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 postTraining', () => {
+  test('preferenceOptimize: only required params', async () => {
+    const responsePromise = client.alpha.postTraining.preferenceOptimize({
+      algorithm_config: { beta: 0 },
+      finetuned_model: 'finetuned_model',
+      hyperparam_search_config: { foo: 'bar' },
+      job_uuid: 'job_uuid',
+      logger_config: { foo: 'bar' },
+      training_config: { n_epochs: 0 },
+    });
+    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('preferenceOptimize: required and optional params', async () => {
+    const response = await client.alpha.postTraining.preferenceOptimize({
+      algorithm_config: { beta: 0, loss_type: 'sigmoid' },
+      finetuned_model: 'finetuned_model',
+      hyperparam_search_config: { foo: 'bar' },
+      job_uuid: 'job_uuid',
+      logger_config: { foo: 'bar' },
+      training_config: {
+        n_epochs: 0,
+        data_config: {
+          batch_size: 0,
+          data_format: 'instruct',
+          dataset_id: 'dataset_id',
+          shuffle: true,
+          packed: true,
+          train_on_input: true,
+          validation_dataset_id: 'validation_dataset_id',
+        },
+        dtype: 'dtype',
+        efficiency_config: {
+          enable_activation_checkpointing: true,
+          enable_activation_offloading: true,
+          fsdp_cpu_offload: true,
+          memory_efficient_fsdp_wrap: true,
+        },
+        gradient_accumulation_steps: 0,
+        max_steps_per_epoch: 0,
+        max_validation_steps: 0,
+        optimizer_config: { lr: 0, num_warmup_steps: 0, optimizer_type: 'adam', weight_decay: 0 },
+      },
+    });
+  });
+
+  test('supervisedFineTune: only required params', async () => {
+    const responsePromise = client.alpha.postTraining.supervisedFineTune({
+      hyperparam_search_config: { foo: 'bar' },
+      job_uuid: 'job_uuid',
+      logger_config: { foo: 'bar' },
+      training_config: { n_epochs: 0 },
+    });
+    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('supervisedFineTune: required and optional params', async () => {
+    const response = await client.alpha.postTraining.supervisedFineTune({
+      hyperparam_search_config: { foo: 'bar' },
+      job_uuid: 'job_uuid',
+      logger_config: { foo: 'bar' },
+      training_config: {
+        n_epochs: 0,
+        data_config: {
+          batch_size: 0,
+          data_format: 'instruct',
+          dataset_id: 'dataset_id',
+          shuffle: true,
+          packed: true,
+          train_on_input: true,
+          validation_dataset_id: 'validation_dataset_id',
+        },
+        dtype: 'dtype',
+        efficiency_config: {
+          enable_activation_checkpointing: true,
+          enable_activation_offloading: true,
+          fsdp_cpu_offload: true,
+          memory_efficient_fsdp_wrap: true,
+        },
+        gradient_accumulation_steps: 0,
+        max_steps_per_epoch: 0,
+        max_validation_steps: 0,
+        optimizer_config: { lr: 0, num_warmup_steps: 0, optimizer_type: 'adam', weight_decay: 0 },
+      },
+      algorithm_config: {
+        alpha: 0,
+        apply_lora_to_mlp: true,
+        apply_lora_to_output: true,
+        lora_attn_modules: ['string'],
+        rank: 0,
+        quantize_base: true,
+        type: 'LoRA',
+        use_dora: true,
+      },
+      checkpoint_dir: 'checkpoint_dir',
+      model: 'model',
+    });
+  });
+});

package/tests/api-resources/batches.test.ts

@@ -0,0 +1,100 @@
+// 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 batches', () => {
+  test('create: only required params', async () => {
+    const responsePromise = client.batches.create({
+      completion_window: '24h',
+      endpoint: 'endpoint',
+      input_file_id: 'input_file_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('create: required and optional params', async () => {
+    const response = await client.batches.create({
+      completion_window: '24h',
+      endpoint: 'endpoint',
+      input_file_id: 'input_file_id',
+      idempotency_key: 'idempotency_key',
+      metadata: { foo: 'string' },
+    });
+  });
+
+  test('retrieve', async () => {
+    const responsePromise = client.batches.retrieve('batch_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.batches.retrieve('batch_id', { path: '/_stainless_unknown_path' })).rejects.toThrow(
+      LlamaStackClient.NotFoundError,
+    );
+  });
+
+  test('list', async () => {
+    const responsePromise = client.batches.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.batches.list({ path: '/_stainless_unknown_path' })).rejects.toThrow(
+      LlamaStackClient.NotFoundError,
+    );
+  });
+
+  test('list: request options and 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.batches.list({ after: 'after', limit: 0 }, { path: '/_stainless_unknown_path' }),
+    ).rejects.toThrow(LlamaStackClient.NotFoundError);
+  });
+
+  test('cancel', async () => {
+    const responsePromise = client.batches.cancel('batch_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.batches.cancel('batch_id', { path: '/_stainless_unknown_path' })).rejects.toThrow(
+      LlamaStackClient.NotFoundError,
+    );
+  });
+});

package/tests/api-resources/beta/datasets.test.ts

@@ -0,0 +1,135 @@
+// 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 datasets', () => {
+  test('retrieve', async () => {
+    const responsePromise = client.beta.datasets.retrieve('dataset_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.beta.datasets.retrieve('dataset_id', { path: '/_stainless_unknown_path' }),
+    ).rejects.toThrow(LlamaStackClient.NotFoundError);
+  });
+
+  test('list', async () => {
+    const responsePromise = client.beta.datasets.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.beta.datasets.list({ path: '/_stainless_unknown_path' })).rejects.toThrow(
+      LlamaStackClient.NotFoundError,
+    );
+  });
+
+  test('appendrows: only required params', async () => {
+    const responsePromise = client.beta.datasets.appendrows('dataset_id', { rows: [{ foo: 'bar' }] });
+    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('appendrows: required and optional params', async () => {
+    const response = await client.beta.datasets.appendrows('dataset_id', { rows: [{ foo: 'bar' }] });
+  });
+
+  test('iterrows', async () => {
+    const responsePromise = client.beta.datasets.iterrows('dataset_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('iterrows: 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.beta.datasets.iterrows('dataset_id', { path: '/_stainless_unknown_path' }),
+    ).rejects.toThrow(LlamaStackClient.NotFoundError);
+  });
+
+  test('iterrows: request options and 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.beta.datasets.iterrows(
+        'dataset_id',
+        { limit: 0, start_index: 0 },
+        { path: '/_stainless_unknown_path' },
+      ),
+    ).rejects.toThrow(LlamaStackClient.NotFoundError);
+  });
+
+  test('register: only required params', async () => {
+    const responsePromise = client.beta.datasets.register({
+      purpose: 'post-training/messages',
+      source: { uri: 'uri' },
+    });
+    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.beta.datasets.register({
+      purpose: 'post-training/messages',
+      source: { uri: 'uri', type: 'uri' },
+      dataset_id: 'dataset_id',
+      metadata: { foo: 'bar' },
+    });
+  });
+
+  test('unregister', async () => {
+    const responsePromise = client.beta.datasets.unregister('dataset_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.beta.datasets.unregister('dataset_id', { path: '/_stainless_unknown_path' }),
+    ).rejects.toThrow(LlamaStackClient.NotFoundError);
+  });
+});

package/tests/api-resources/chat/completions.test.ts

@@ -0,0 +1,102 @@
+// 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 completions', () => {
+  test('create: only required params', async () => {
+    const responsePromise = client.chat.completions.create({
+      messages: [{ content: 'string', role: 'user' }],
+      model: 'model',
+    });
+    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('create: required and optional params', async () => {
+    const response = await client.chat.completions.create({
+      messages: [{ content: 'string', name: 'name', role: 'user' }],
+      model: 'model',
+      frequency_penalty: 0,
+      function_call: 'string',
+      functions: [{ foo: 'bar' }],
+      logit_bias: { foo: 0 },
+      logprobs: true,
+      max_completion_tokens: 0,
+      max_tokens: 0,
+      n: 0,
+      parallel_tool_calls: true,
+      presence_penalty: 0,
+      response_format: { type: 'text' },
+      seed: 0,
+      stop: 'string',
+      stream: false,
+      stream_options: { foo: 'bar' },
+      temperature: 0,
+      tool_choice: 'string',
+      tools: [{ foo: 'bar' }],
+      top_logprobs: 0,
+      top_p: 0,
+      user: 'user',
+    });
+  });
+
+  test('retrieve', async () => {
+    const responsePromise = client.chat.completions.retrieve('completion_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.chat.completions.retrieve('completion_id', { path: '/_stainless_unknown_path' }),
+    ).rejects.toThrow(LlamaStackClient.NotFoundError);
+  });
+
+  test('list', async () => {
+    const responsePromise = client.chat.completions.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.chat.completions.list({ path: '/_stainless_unknown_path' })).rejects.toThrow(
+      LlamaStackClient.NotFoundError,
+    );
+  });
+
+  test('list: request options and 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.chat.completions.list(
+        { after: 'after', limit: 0, model: 'model', order: 'asc' },
+        { path: '/_stainless_unknown_path' },
+      ),
+    ).rejects.toThrow(LlamaStackClient.NotFoundError);
+  });
+});

package/tests/api-resources/completions.test.ts

@@ -0,0 +1,48 @@
+// 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 completions', () => {
+  test('create: only required params', async () => {
+    const responsePromise = client.completions.create({ model: 'model', prompt: '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('create: required and optional params', async () => {
+    const response = await client.completions.create({
+      model: 'model',
+      prompt: 'string',
+      best_of: 0,
+      echo: true,
+      frequency_penalty: 0,
+      logit_bias: { foo: 0 },
+      logprobs: true,
+      max_tokens: 0,
+      n: 0,
+      presence_penalty: 0,
+      seed: 0,
+      stop: 'string',
+      stream: false,
+      stream_options: { foo: 'bar' },
+      suffix: 'suffix',
+      temperature: 0,
+      top_p: 0,
+      user: 'user',
+    });
+  });
+});

package/tests/api-resources/conversations/conversations.test.ts

@@ -0,0 +1,76 @@
+// 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 conversations', () => {
+  test('create', async () => {
+    const responsePromise = client.conversations.create({});
+    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', async () => {
+    const responsePromise = client.conversations.retrieve('conversation_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.conversations.retrieve('conversation_id', { path: '/_stainless_unknown_path' }),
+    ).rejects.toThrow(LlamaStackClient.NotFoundError);
+  });
+
+  test('update: only required params', async () => {
+    const responsePromise = client.conversations.update('conversation_id', { metadata: { foo: '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('update: required and optional params', async () => {
+    const response = await client.conversations.update('conversation_id', { metadata: { foo: 'string' } });
+  });
+
+  test('delete', async () => {
+    const responsePromise = client.conversations.delete('conversation_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('delete: 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.conversations.delete('conversation_id', { path: '/_stainless_unknown_path' }),
+    ).rejects.toThrow(LlamaStackClient.NotFoundError);
+  });
+});