ogx-client 0.7.2-rc1 → 0.7.2

package/scripts/utils/postprocess-files.cjs

@@ -0,0 +1,172 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { parse } = require('@typescript-eslint/parser');
+
+const pkgImportPath = process.env['PKG_IMPORT_PATH'] ?? 'ogx-client/';
+
+const distDir =
+  process.env['DIST_PATH'] ?
+    path.resolve(process.env['DIST_PATH'])
+  : path.resolve(__dirname, '..', '..', 'dist');
+const distSrcDir = path.join(distDir, 'src');
+
+/**
+ * Quick and dirty AST traversal
+ */
+function traverse(node, visitor) {
+  if (!node || typeof node.type !== 'string') return;
+  visitor.node?.(node);
+  visitor[node.type]?.(node);
+  for (const key in node) {
+    const value = node[key];
+    if (Array.isArray(value)) {
+      for (const elem of value) traverse(elem, visitor);
+    } else if (value instanceof Object) {
+      traverse(value, visitor);
+    }
+  }
+}
+
+/**
+ * Helper method for replacing arbitrary ranges of text in input code.
+ *
+ * The `replacer` is a function that will be called with a mini-api.  For example:
+ *
+ * replaceRanges('foobar', ({ replace }) => replace([0, 3], 'baz')) // 'bazbar'
+ *
+ * The replaced ranges must not be overlapping.
+ */
+function replaceRanges(code, replacer) {
+  const replacements = [];
+  replacer({ replace: (range, replacement) => replacements.push({ range, replacement }) });
+
+  if (!replacements.length) return code;
+  replacements.sort((a, b) => a.range[0] - b.range[0]);
+  const overlapIndex = replacements.findIndex(
+    (r, index) => index > 0 && replacements[index - 1].range[1] > r.range[0],
+  );
+  if (overlapIndex >= 0) {
+    throw new Error(
+      `replacements overlap: ${JSON.stringify(replacements[overlapIndex - 1])} and ${JSON.stringify(
+        replacements[overlapIndex],
+      )}`,
+    );
+  }
+
+  const parts = [];
+  let end = 0;
+  for (const {
+    range: [from, to],
+    replacement,
+  } of replacements) {
+    if (from > end) parts.push(code.substring(end, from));
+    parts.push(replacement);
+    end = to;
+  }
+  if (end < code.length) parts.push(code.substring(end));
+  return parts.join('');
+}
+
+/**
+ * Like calling .map(), where the iteratee is called on the path in every import or export from statement.
+ * @returns the transformed code
+ */
+function mapModulePaths(code, iteratee) {
+  const ast = parse(code, { range: true });
+  return replaceRanges(code, ({ replace }) =>
+    traverse(ast, {
+      node(node) {
+        switch (node.type) {
+          case 'ImportDeclaration':
+          case 'ExportNamedDeclaration':
+          case 'ExportAllDeclaration':
+          case 'ImportExpression':
+            if (node.source) {
+              const { range, value } = node.source;
+              const transformed = iteratee(value);
+              if (transformed !== value) {
+                replace(range, JSON.stringify(transformed));
+              }
+            }
+        }
+      },
+    }),
+  );
+}
+
+async function* walk(dir) {
+  for await (const d of await fs.promises.opendir(dir)) {
+    const entry = path.join(dir, d.name);
+    if (d.isDirectory()) yield* walk(entry);
+    else if (d.isFile()) yield entry;
+  }
+}
+
+async function postprocess() {
+  for await (const file of walk(path.resolve(__dirname, '..', '..', 'dist'))) {
+    if (!/\.([cm]?js|(\.d)?[cm]?ts)$/.test(file)) continue;
+
+    const code = await fs.promises.readFile(file, 'utf8');
+
+    let transformed = mapModulePaths(code, (importPath) => {
+      if (file.startsWith(distSrcDir)) {
+        if (importPath.startsWith(pkgImportPath)) {
+          // convert self-references in dist/src to relative paths
+          let relativePath = path.relative(
+            path.dirname(file),
+            path.join(distSrcDir, importPath.substring(pkgImportPath.length)),
+          );
+          if (!relativePath.startsWith('.')) relativePath = `./${relativePath}`;
+          return relativePath;
+        }
+        return importPath;
+      }
+      if (importPath.startsWith('.')) {
+        // add explicit file extensions to relative imports
+        const { dir, name } = path.parse(importPath);
+        const ext = /\.mjs$/.test(file) ? '.mjs' : '.js';
+        return `${dir}/${name}${ext}`;
+      }
+      return importPath;
+    });
+
+    if (file.startsWith(distSrcDir) && !file.endsWith('_shims/index.d.ts')) {
+      // strip out `unknown extends Foo ? never :` shim guards in dist/src
+      // to prevent errors from appearing in Go To Source
+      transformed = transformed.replace(
+        new RegExp('unknown extends (typeof )?\\S+ \\? \\S+ :\\s*'.replace(/\s+/, '\\s+'), 'gm'),
+        // replace with same number of characters to avoid breaking source maps
+        (match) => ' '.repeat(match.length),
+      );
+    }
+
+    if (file.endsWith('.d.ts')) {
+      // work around bad tsc behavior
+      // if we have `import { type Readable } from 'ogx-client/_shims/index'`,
+      // tsc sometimes replaces `Readable` with `import("stream").Readable` inline
+      // in the output .d.ts
+      transformed = transformed.replace(/import\("stream"\).Readable/g, 'Readable');
+    }
+
+    // strip out lib="dom" and types="node" references; these are needed at build time,
+    // but would pollute the user's TS environment
+    transformed = transformed.replace(
+      /^ *\/\/\/ *<reference +(lib="dom"|types="node").*?\n/gm,
+      // replace with same number of characters to avoid breaking source maps
+      (match) => ' '.repeat(match.length - 1) + '\n',
+    );
+
+    if (transformed !== code) {
+      await fs.promises.writeFile(file, transformed, 'utf8');
+      console.error(`wrote ${path.relative(process.cwd(), file)}`);
+    }
+  }
+}
+postprocess();

package/scripts/utils/upload-artifact.sh

@@ -0,0 +1,33 @@
+#!/usr/bin/env bash
+# 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.
+
+set -exuo pipefail
+
+RESPONSE=$(curl -X POST "$URL" \
+  -H "Authorization: Bearer $AUTH" \
+  -H "Content-Type: application/json")
+
+SIGNED_URL=$(echo "$RESPONSE" | jq -r '.url')
+
+if [[ "$SIGNED_URL" == "null" ]]; then
+  echo -e "\033[31mFailed to get signed URL.\033[0m"
+  exit 1
+fi
+
+TARBALL=$(cd dist && npm pack --silent)
+
+UPLOAD_RESPONSE=$(curl -v -X PUT \
+  -H "Content-Type: application/gzip" \
+  --data-binary "@dist/$TARBALL" "$SIGNED_URL" 2>&1)
+
+if echo "$UPLOAD_RESPONSE" | grep -q "HTTP/[0-9.]* 200"; then
+  echo -e "\033[32mUploaded build to Stainless storage.\033[0m"
+  echo -e "\033[32mInstallation: npm install 'https://pkg.stainless.com/s/llama-stack-client-node/$SHA'\033[0m"
+else
+  echo -e "\033[31mFailed to upload artifact.\033[0m"
+  exit 1
+fi

package/src/_shims/auto/runtime-deno.ts

@@ -0,0 +1,10 @@
+// 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.
+
+/**
+ * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
+ */
+export * from '../web-runtime';

package/src/_shims/auto/types-deno.ts

@@ -0,0 +1,10 @@
+// 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.
+
+/**
+ * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
+ */
+export * from '../web-types';

package/src/_shims/auto/types.d.ts

@@ -10,43 +10,43 @@
 export type Agent = any;
 
 // @ts-ignore
-declare const _fetch:                                        typeof fetch;
+declare const _fetch: unknown extends typeof fetch ? never : typeof fetch;
 export { _fetch as fetch };
 
 // @ts-ignore
-type _Request =                                   Request;
+type _Request = unknown extends Request ? never : Request;
 export { _Request as Request };
 
 // @ts-ignore
-type _RequestInfo =                                       RequestInfo;
+type _RequestInfo = unknown extends RequestInfo ? never : RequestInfo;
 export { type _RequestInfo as RequestInfo };
 
 // @ts-ignore
-type _RequestInit =                                       RequestInit;
+type _RequestInit = unknown extends RequestInit ? never : RequestInit;
 export { type _RequestInit as RequestInit };
 
 // @ts-ignore
-type _Response =                                    Response;
+type _Response = unknown extends Response ? never : Response;
 export { _Response as Response };
 
 // @ts-ignore
-type _ResponseInit =                                        ResponseInit;
+type _ResponseInit = unknown extends ResponseInit ? never : ResponseInit;
 export { type _ResponseInit as ResponseInit };
 
 // @ts-ignore
-type _ResponseType =                                        ResponseType;
+type _ResponseType = unknown extends ResponseType ? never : ResponseType;
 export { type _ResponseType as ResponseType };
 
 // @ts-ignore
-type _BodyInit =                                    BodyInit;
+type _BodyInit = unknown extends BodyInit ? never : BodyInit;
 export { type _BodyInit as BodyInit };
 
 // @ts-ignore
-type _Headers =                                   Headers;
+type _Headers = unknown extends Headers ? never : Headers;
 export { _Headers as Headers };
 
 // @ts-ignore
-type _HeadersInit =                                       HeadersInit;
+type _HeadersInit = unknown extends HeadersInit ? never : HeadersInit;
 export { type _HeadersInit as HeadersInit };
 
 type EndingType = 'native' | 'transparent';
@@ -63,21 +63,21 @@ export interface FilePropertyBag extends BlobPropertyBag {
 export type FileFromPathOptions = Omit<FilePropertyBag, 'lastModified'>;
 
 // @ts-ignore
-type _FormData =                                    FormData;
+type _FormData = unknown extends FormData ? never : FormData;
 // @ts-ignore
-declare const _FormData:                                           typeof FormData;
+declare const _FormData: unknown extends typeof FormData ? never : typeof FormData;
 export { _FormData as FormData };
 
 // @ts-ignore
-type _File =                                File;
+type _File = unknown extends File ? never : File;
 // @ts-ignore
-declare const _File:                                       typeof File;
+declare const _File: unknown extends typeof File ? never : typeof File;
 export { _File as File };
 
 // @ts-ignore
-type _Blob =                                Blob;
+type _Blob = unknown extends Blob ? never : Blob;
 // @ts-ignore
-declare const _Blob:                                       typeof Blob;
+declare const _Blob: unknown extends typeof Blob ? never : typeof Blob;
 export { _Blob as Blob };
 
 export declare class Readable {
@@ -101,7 +101,7 @@ export declare class FsReadStream extends Readable {
 }
 
 // @ts-ignore
-type _ReadableStream<R = any> =                                             ReadableStream<R>;
+type _ReadableStream<R = any> = unknown extends ReadableStream<R> ? never : ReadableStream<R>;
 // @ts-ignore
-declare const _ReadableStream:                                                 typeof ReadableStream;
+declare const _ReadableStream: unknown extends typeof ReadableStream ? never : typeof ReadableStream;
 export { _ReadableStream as ReadableStream };

package/src/_shims/index-deno.ts

@@ -0,0 +1,118 @@
+// 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.
+
+import { MultipartBody } from './MultipartBody';
+import { type RequestOptions } from '../core';
+
+export const kind: string = 'web';
+
+export type Agent = any;
+
+const _fetch = fetch;
+type _fetch = typeof fetch;
+export { _fetch as fetch };
+
+const _Request = Request;
+type _Request = Request;
+export { _Request as Request };
+
+type _RequestInfo = RequestInfo;
+export { type _RequestInfo as RequestInfo };
+
+type _RequestInit = RequestInit;
+export { type _RequestInit as RequestInit };
+
+const _Response = Response;
+type _Response = Response;
+export { _Response as Response };
+
+type _ResponseInit = ResponseInit;
+export { type _ResponseInit as ResponseInit };
+
+type _ResponseType = ResponseType;
+export { type _ResponseType as ResponseType };
+
+type _BodyInit = BodyInit;
+export { type _BodyInit as BodyInit };
+
+const _Headers = Headers;
+type _Headers = Headers;
+export { _Headers as Headers };
+
+type _HeadersInit = HeadersInit;
+export { type _HeadersInit as HeadersInit };
+
+type EndingType = 'native' | 'transparent';
+
+export interface BlobPropertyBag {
+  endings?: EndingType;
+  type?: string;
+}
+
+export interface FilePropertyBag extends BlobPropertyBag {
+  lastModified?: number;
+}
+
+export type FileFromPathOptions = Omit<FilePropertyBag, 'lastModified'>;
+
+const _FormData = FormData;
+type _FormData = FormData;
+export { _FormData as FormData };
+
+const _File = File;
+type _File = File;
+export { _File as File };
+
+const _Blob = Blob;
+type _Blob = Blob;
+export { _Blob as Blob };
+
+export async function getMultipartRequestOptions<T = Record<string, unknown>>(
+  form: FormData,
+  opts: RequestOptions<T>,
+): Promise<RequestOptions<T>> {
+  return {
+    ...opts,
+    body: new MultipartBody(form) as any,
+  };
+}
+
+export function getDefaultAgent(url: string) {
+  return undefined;
+}
+export function fileFromPath() {
+  throw new Error(
+    'The `fileFromPath` function is only supported in Node. See the README for more details: https://www.github.com/ogx-ai/ogx-client-typescript#file-uploads',
+  );
+}
+
+export const isFsReadStream = (value: any) => false;
+
+export declare class Readable {
+  readable: boolean;
+  readonly readableEnded: boolean;
+  readonly readableFlowing: boolean | null;
+  readonly readableHighWaterMark: number;
+  readonly readableLength: number;
+  readonly readableObjectMode: boolean;
+  destroyed: boolean;
+  read(size?: number): any;
+  pause(): this;
+  resume(): this;
+  isPaused(): boolean;
+  destroy(error?: Error): this;
+  [Symbol.asyncIterator](): AsyncIterableIterator<any>;
+}
+
+export declare class FsReadStream extends Readable {
+  path: {}; // node type is string | Buffer
+}
+
+const _ReadableStream = ReadableStream;
+type _ReadableStream = ReadableStream;
+export { _ReadableStream as ReadableStream };
+
+export const init = () => {};

package/src/_shims/index.d.ts

@@ -8,7 +8,7 @@
  * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
  */
 import { manual } from './manual-types';
-import * as auto from "./auto/types";
+import * as auto from 'ogx-client/_shims/auto/types';
 import { type RequestOptions } from '../core';
 
 type SelectType<Manual, Auto> = unknown extends Manual ? Auto : Manual;

package/src/_shims/index.mjs

@@ -9,7 +9,7 @@
  * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
  */
 import * as shims from './registry.mjs';
-import * as auto from "./auto/runtime";
+import * as auto from 'ogx-client/_shims/auto/runtime';
 export const init = () => {
   if (!shims.kind) shims.setShims(auto.getRuntime(), { auto: true });
 };

package/src/lib/.keep

@@ -0,0 +1,4 @@
+File generated from our OpenAPI spec by Stainless.
+
+This directory can be used to store custom files to expand the SDK.
+It is ignored by Stainless code generation and its content (other than this keep file) won't be touched.

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.7.2-rc1'; // x-release-please-version
+export const VERSION = '0.7.2'; // x-release-please-version

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

@@ -0,0 +1,111 @@
+// 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 admin', () => {
+  test('health', async () => {
+    const responsePromise = client.alpha.admin.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.alpha.admin.health({ path: '/_stainless_unknown_path' })).rejects.toThrow(
+      OgxClient.NotFoundError,
+    );
+  });
+
+  test('inspectProvider', async () => {
+    const responsePromise = client.alpha.admin.inspectProvider('provider_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('inspectProvider: 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.admin.inspectProvider('provider_id', { path: '/_stainless_unknown_path' }),
+    ).rejects.toThrow(OgxClient.NotFoundError);
+  });
+
+  test('listProviders', async () => {
+    const responsePromise = client.alpha.admin.listProviders();
+    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('listProviders: 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.admin.listProviders({ path: '/_stainless_unknown_path' })).rejects.toThrow(
+      OgxClient.NotFoundError,
+    );
+  });
+
+  test('listRoutes', async () => {
+    const responsePromise = client.alpha.admin.listRoutes();
+    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('listRoutes: 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.admin.listRoutes({ path: '/_stainless_unknown_path' })).rejects.toThrow(
+      OgxClient.NotFoundError,
+    );
+  });
+
+  test('listRoutes: 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.alpha.admin.listRoutes({ api_filter: 'v1' }, { path: '/_stainless_unknown_path' }),
+    ).rejects.toThrow(OgxClient.NotFoundError);
+  });
+
+  test('version', async () => {
+    const responsePromise = client.alpha.admin.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.alpha.admin.version({ path: '/_stainless_unknown_path' })).rejects.toThrow(
+      OgxClient.NotFoundError,
+    );
+  });
+});

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

@@ -0,0 +1,38 @@
+// 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 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: 1,
+    });
+  });
+});