ogx-client 0.7.2-rc1 → 0.7.2

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

@@ -0,0 +1,100 @@
+// Copyright (c) The OGX Contributors.
+// 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 OgxClient from 'ogx-client';
+import { Response } from 'node-fetch';
+
+const client = new OgxClient({ 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(
+      OgxClient.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(
+      OgxClient.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(OgxClient.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(
+      OgxClient.NotFoundError,
+    );
+  });
+});

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

@@ -0,0 +1,117 @@
+// Copyright (c) The OGX Contributors.
+// 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 OgxClient from 'ogx-client';
+import { Response } from 'node-fetch';
+
+const client = new OgxClient({ 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: -2,
+      function_call: 'string',
+      functions: [{ foo: 'bar' }],
+      logit_bias: { foo: 0 },
+      logprobs: true,
+      max_completion_tokens: 1,
+      max_tokens: 1,
+      n: 1,
+      parallel_tool_calls: true,
+      presence_penalty: -2,
+      prompt_cache_key: 'prompt_cache_key',
+      reasoning_effort: 'none',
+      response_format: { type: 'text' },
+      safety_identifier: 'safety_identifier',
+      seed: 0,
+      service_tier: 'auto',
+      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(OgxClient.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(
+      OgxClient.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(OgxClient.NotFoundError);
+  });
+});

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

@@ -0,0 +1,48 @@
+// Copyright (c) The OGX Contributors.
+// 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 OgxClient from 'ogx-client';
+import { Response } from 'node-fetch';
+
+const client = new OgxClient({ 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: 1,
+      echo: true,
+      frequency_penalty: -2,
+      logit_bias: { foo: 0 },
+      logprobs: true,
+      max_tokens: 1,
+      n: 1,
+      presence_penalty: -2,
+      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) The OGX Contributors.
+// 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 OgxClient from 'ogx-client';
+import { Response } from 'node-fetch';
+
+const client = new OgxClient({ 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(OgxClient.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(OgxClient.NotFoundError);
+  });
+});

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

@@ -0,0 +1,117 @@
+// Copyright (c) The OGX Contributors.
+// 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 OgxClient from 'ogx-client';
+import { Response } from 'node-fetch';
+
+const client = new OgxClient({ baseURL: process.env['TEST_API_BASE_URL'] ?? 'http://127.0.0.1:4010' });
+
+describe('resource items', () => {
+  test('create: only required params', async () => {
+    const responsePromise = client.conversations.items.create('conversation_id', {
+      items: [
+        {
+          content: 'string',
+          role: 'system',
+          type: 'message',
+        },
+      ],
+    });
+    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.conversations.items.create('conversation_id', {
+      items: [
+        {
+          content: 'string',
+          role: 'system',
+          id: 'id',
+          status: 'status',
+          type: 'message',
+        },
+      ],
+    });
+  });
+
+  test('list', async () => {
+    const responsePromise = client.conversations.items.list('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('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.conversations.items.list('conversation_id', { path: '/_stainless_unknown_path' }),
+    ).rejects.toThrow(OgxClient.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.conversations.items.list(
+        'conversation_id',
+        {
+          after: 'after',
+          include: ['web_search_call.action.sources'],
+          limit: 0,
+          order: 'asc',
+        },
+        { path: '/_stainless_unknown_path' },
+      ),
+    ).rejects.toThrow(OgxClient.NotFoundError);
+  });
+
+  test('delete', async () => {
+    const responsePromise = client.conversations.items.delete('conversation_id', 'item_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.items.delete('conversation_id', 'item_id', { path: '/_stainless_unknown_path' }),
+    ).rejects.toThrow(OgxClient.NotFoundError);
+  });
+
+  test('get', async () => {
+    const responsePromise = client.conversations.items.get('conversation_id', 'item_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('get: 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.items.get('conversation_id', 'item_id', { path: '/_stainless_unknown_path' }),
+    ).rejects.toThrow(OgxClient.NotFoundError);
+  });
+});

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

@@ -0,0 +1,35 @@
+// Copyright (c) The OGX Contributors.
+// 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 OgxClient from 'ogx-client';
+import { Response } from 'node-fetch';
+
+const client = new OgxClient({ baseURL: process.env['TEST_API_BASE_URL'] ?? 'http://127.0.0.1:4010' });
+
+describe('resource embeddings', () => {
+  test('create: only required params', async () => {
+    const responsePromise = client.embeddings.create({ input: 'string', 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.embeddings.create({
+      input: 'string',
+      model: 'model',
+      dimensions: 1,
+      encoding_format: 'float',
+      user: 'user',
+    });
+  });
+});

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

@@ -0,0 +1,123 @@
+// Copyright (c) The OGX Contributors.
+// 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 OgxClient, { toFile } from 'ogx-client';
+import { Response } from 'node-fetch';
+
+const client = new OgxClient({ baseURL: process.env['TEST_API_BASE_URL'] ?? 'http://127.0.0.1:4010' });
+
+describe('resource files', () => {
+  test('create: only required params', async () => {
+    const responsePromise = client.files.create({
+      file: await toFile(Buffer.from('Example data'), 'README.md'),
+      purpose: 'assistants',
+    });
+    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.files.create({
+      file: await toFile(Buffer.from('Example data'), 'README.md'),
+      purpose: 'assistants',
+      expires_after: { anchor: 'created_at', seconds: 3600 },
+    });
+  });
+
+  test('retrieve', async () => {
+    const responsePromise = client.files.retrieve('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('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.files.retrieve('file_id', { path: '/_stainless_unknown_path' })).rejects.toThrow(
+      OgxClient.NotFoundError,
+    );
+  });
+
+  test('list', async () => {
+    const responsePromise = client.files.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.files.list({ path: '/_stainless_unknown_path' })).rejects.toThrow(
+      OgxClient.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.files.list(
+        {
+          after: 'after',
+          limit: 0,
+          order: 'asc',
+          purpose: 'assistants',
+        },
+        { path: '/_stainless_unknown_path' },
+      ),
+    ).rejects.toThrow(OgxClient.NotFoundError);
+  });
+
+  test('delete', async () => {
+    const responsePromise = client.files.delete('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('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.files.delete('file_id', { path: '/_stainless_unknown_path' })).rejects.toThrow(
+      OgxClient.NotFoundError,
+    );
+  });
+
+  test('content', async () => {
+    const responsePromise = client.files.content('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('content: 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.files.content('file_id', { path: '/_stainless_unknown_path' })).rejects.toThrow(
+      OgxClient.NotFoundError,
+    );
+  });
+});

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

@@ -0,0 +1,50 @@
+// Copyright (c) The OGX Contributors.
+// 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 OgxClient from 'ogx-client';
+import { Response } from 'node-fetch';
+
+const client = new OgxClient({ baseURL: process.env['TEST_API_BASE_URL'] ?? 'http://127.0.0.1:4010' });
+
+describe('resource inspect', () => {
+  test('health', async () => {
+    const responsePromise = client.inspect.health();
+    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('health: 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.inspect.health({ path: '/_stainless_unknown_path' })).rejects.toThrow(
+      OgxClient.NotFoundError,
+    );
+  });
+
+  test('version', async () => {
+    const responsePromise = client.inspect.version();
+    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('version: 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.inspect.version({ path: '/_stainless_unknown_path' })).rejects.toThrow(
+      OgxClient.NotFoundError,
+    );
+  });
+});