@runappsai/sdk 0.8.0 → 0.8.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runappsai/sdk",
-  "version": "0.8.0",
+  "version": "0.8.2",
   "description": "JavaScript / TypeScript client for the RunApps AI Gateway",
   "license": "MIT",
   "author": "RunApps",

package/src/files.ts

@@ -48,6 +48,14 @@ export interface FileRead {
   etag?: string;
 }
 
+export interface SignOptions {
+  /** How long the link stays valid, in seconds. Default 3600, at most 7 days. */
+  expiresIn?: number;
+  /** When true the link downloads instead of displaying inline. */
+  download?: boolean;
+  signal?: AbortSignal;
+}
+
 export interface ListOptions {
   prefix?: string;
   cursor?: string;
@@ -343,6 +351,37 @@ export class FilesService {
     return this.run("files.copy", async () => this.transport.postJSON<FileObject>((await this.base()) + "/copy", { from, to }, init));
   }
 
+  /**
+   * A time-limited link to a private file that needs no token: put it in
+   * `<img src>`, `<video src>` or `<a href download>`. The link is for
+   * this user's copy of the file in this app; it expires after
+   * `expiresIn` seconds (default one hour, at most seven days) and is
+   * never cached, so it always shows the current bytes. For a permanent
+   * public address use the FileObject's `url` instead.
+   */
+  async url(path: string, opts?: SignOptions): Promise<string> {
+    const urls = await this.urls([path], opts);
+    const u = urls[path];
+    if (!u) throw new Error("RunApps: no signed URL returned for " + path);
+    return u;
+  }
+
+  /** Signed links for several paths at once (up to 200): `{ path: url }`. */
+  async urls(paths: string[], opts?: SignOptions): Promise<Record<string, string>> {
+    const body: { paths: string[]; expires_in?: number } = { paths };
+    if (opts?.expiresIn) body.expires_in = Math.floor(opts.expiresIn);
+    const r = await this.run("files.sign", async () => this.transport.postJSON<{ urls: Record<string, string> }>(
+      (await this.base()) + "/sign",
+      body,
+      opts?.signal ? { signal: opts.signal } : undefined,
+    ));
+    const out: Record<string, string> = {};
+    for (const [p, u] of Object.entries(r.urls || {})) {
+      out[p] = opts?.download ? u + (u.includes("?") ? "&" : "?") + "download=1" : u;
+    }
+    return out;
+  }
+
   /**
    * Ask the gateway to fetch `srcURL` and store the body at `path`.
    * Saves a round trip vs downloading then re-uploading.  `srcURL`

package/src/index.ts

@@ -88,6 +88,7 @@ export {
   supportsVoiceClone,
   supportsInstructText,
   defaultVoice,
+  defaultModel,
 } from "./models.js";
 
 // Model options schema (input validation + capability introspection)
@@ -168,6 +169,7 @@ export type {
   FileObject,
   FileListResult,
   PutOptions as FilePutOptions,
+  SignOptions as FileSignOptions,
   ListOptions as FileListOptions,
   PutFromURLOptions as FilePutFromURLOptions,
   BatchOp as FileBatchOp,

package/src/models.ts

@@ -10,6 +10,15 @@ export interface Model {
   object: string;
   capability: string;
   provider?: string;
+  /**
+   * The model the platform uses for this capability when a request names
+   * none: the one the admin starred in the gateway settings, else the
+   * first of the capability. Exactly one model per capability carries it.
+   * Use `defaultModel` to pick it out of a list.
+   */
+  is_default?: boolean;
+  /** One or two sentences about the model, set on the gateway. */
+  description?: string;
   /**
    * Server-derived "what this model can actually do" tags
    * (e.g. {id:"t2v", label:"Text-to-Video"}, {id:"i2v", label:"Image-to-Video"}).
@@ -100,6 +109,18 @@ export const defaultVoice = (model: Model): string | null => {
   return typeof v === "string" ? v : null;
 };
 
+/**
+ * The platform's default model among `models` — the admin-starred one for
+ * the capability, else the first of the capability. With `capability`
+ * given, only that capability is considered; without it, the first
+ * default in list order (so pass a list from
+ * `client.models.list({ capability })`). Null when the list has none.
+ */
+export const defaultModel = (models: Model[], capability?: string): Model | null => {
+  const pool = capability ? models.filter((m) => m.capability === capability) : models;
+  return pool.find((m) => m.is_default) ?? null;
+};
+
 export class ModelsService {
   constructor(private readonly transport: Transport) {}
 
@@ -120,4 +141,14 @@ export class ModelsService {
     const resp = await this.transport.getPublicJSON<{ data: Model[] }>(path, init);
     return resp.data;
   }
+
+  /**
+   * The platform's default model for a capability (`"text"` unless given):
+   * the admin-starred one, else the first. What a request without `model`
+   * would use before the user's own preference. Null when the capability
+   * has no models.
+   */
+  async default(capability = "text", init?: { signal?: AbortSignal }): Promise<Model | null> {
+    return defaultModel(await this.list({ capability }, init), capability);
+  }
 }