llama-stack-client 0.4.3 → 0.4.5

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'] ?? 'llama-stack-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 'llama-stack-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/llamastack/llama-stack-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 'llama-stack-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 'llama-stack-client/_shims/auto/runtime';
 export const init = () => {
   if (!shims.kind) shims.setShims(auto.getRuntime(), { auto: true });
 };

package/src/core.ts

@@ -90,6 +90,12 @@ async function defaultParseResponse<T>(props: APIResponseProps): Promise<T> {
   const mediaType = contentType?.split(';')[0]?.trim();
   const isJSON = mediaType?.includes('application/json') || mediaType?.endsWith('+json');
   if (isJSON) {
+    const contentLength = response.headers.get('content-length');
+    if (contentLength === '0') {
+      // if there is no content we can't do anything
+      return undefined as T;
+    }
+
     const json = await response.json();
 
     debug('response', response.status, response.url, response.headers, json);

package/src/resources/alpha/alpha.ts

@@ -41,26 +41,20 @@ import {
 } from './post-training/post-training';
 
 export class Alpha extends APIResource {
-  inference: InferenceAPI.Inference = new InferenceAPI.Inference(this._client);
   postTraining: PostTrainingAPI.PostTraining = new PostTrainingAPI.PostTraining(this._client);
   benchmarks: BenchmarksAPI.Benchmarks = new BenchmarksAPI.Benchmarks(this._client);
   eval: EvalAPI.Eval = new EvalAPI.Eval(this._client);
   admin: AdminAPI.Admin = new AdminAPI.Admin(this._client);
+  inference: InferenceAPI.Inference = new InferenceAPI.Inference(this._client);
 }
 
-Alpha.Inference = Inference;
 Alpha.PostTraining = PostTraining;
 Alpha.Benchmarks = Benchmarks;
 Alpha.Eval = Eval;
 Alpha.Admin = Admin;
+Alpha.Inference = Inference;
 
 export declare namespace Alpha {
-  export {
-    Inference as Inference,
-    type InferenceRerankResponse as InferenceRerankResponse,
-    type InferenceRerankParams as InferenceRerankParams,
-  };
-
   export {
     PostTraining as PostTraining,
     type AlgorithmConfig as AlgorithmConfig,
@@ -90,4 +84,10 @@ export declare namespace Alpha {
   };
 
   export { Admin as Admin, type AdminListRoutesParams as AdminListRoutesParams };
+
+  export {
+    Inference as Inference,
+    type InferenceRerankResponse as InferenceRerankResponse,
+    type InferenceRerankParams as InferenceRerankParams,
+  };
 }

package/src/resources/alpha/eval/eval.ts

@@ -61,7 +61,7 @@ export class Eval extends APIResource {
  */
 export interface BenchmarkConfig {
   /**
-   * A model candidate for evaluation.
+   * The candidate to evaluate
    */
   eval_candidate: BenchmarkConfig.EvalCandidate;
 
@@ -85,13 +85,16 @@ export interface BenchmarkConfig {
 
 export namespace BenchmarkConfig {
   /**
-   * A model candidate for evaluation.
+   * The candidate to evaluate
    */
   export interface EvalCandidate {
+    /**
+     * The model ID to evaluate
+     */
     model: string;
 
     /**
-     * Sampling parameters.
+     * The sampling parameters for the model
      */
     sampling_params: Shared.SamplingParams;
 
@@ -164,8 +167,14 @@ export namespace BenchmarkConfig {
  * The response from an evaluation.
  */
 export interface EvaluateResponse {
+  /**
+   * The generations from the evaluation
+   */
   generations: Array<{ [key: string]: unknown }>;
 
+  /**
+   * The scores from the evaluation. Each key in the dict is a scoring function name
+   */
   scores: { [key: string]: Shared.ScoringResult };
 }
 
@@ -183,36 +192,48 @@ export interface Job {
 
 export interface EvalEvaluateRowsParams {
   /**
-   * A benchmark configuration for evaluation.
+   * The configuration for the benchmark
    */
   benchmark_config: BenchmarkConfig;
 
+  /**
+   * The rows to evaluate
+   */
   input_rows: Array<{ [key: string]: unknown }>;
 
+  /**
+   * The scoring functions to use for the evaluation
+   */
   scoring_functions: Array<string>;
 }
 
 export interface EvalEvaluateRowsAlphaParams {
   /**
-   * A benchmark configuration for evaluation.
+   * The configuration for the benchmark
    */
   benchmark_config: BenchmarkConfig;
 
+  /**
+   * The rows to evaluate
+   */
   input_rows: Array<{ [key: string]: unknown }>;
 
+  /**
+   * The scoring functions to use for the evaluation
+   */
   scoring_functions: Array<string>;
 }
 
 export interface EvalRunEvalParams {
   /**
-   * A benchmark configuration for evaluation.
+   * The configuration for the benchmark
    */
   benchmark_config: BenchmarkConfig;
 }
 
 export interface EvalRunEvalAlphaParams {
   /**
-   * A benchmark configuration for evaluation.
+   * The configuration for the benchmark
    */
   benchmark_config: BenchmarkConfig;
 }