@eigenpal/sdk 0.10.56 → 0.11.1

package/src/lib/files.ts

@@ -132,7 +132,7 @@ function basename(path: string): string {
  * so the body can be replayed if the SDK retries the request. (A consumed
  * stream cannot be re-read; a Blob can.)
  */
-async function resolveFileBlob(file: FileInput): Promise<{ blob: Blob; filename: string }> {
+export async function resolveFileBlob(file: FileInput): Promise<{ blob: Blob; filename: string }> {
   // `File` extends `Blob`, so this branch covers both.
   if (typeof Blob !== 'undefined' && file instanceof Blob) {
     return { blob: file, filename: (file as File).name || 'file' };

package/src/lib/upload-limits.ts

@@ -0,0 +1,61 @@
+/**
+ * Default to Vercel's ~4.5 MiB function body limit. Operators with a different
+ * ingress limit can override it; `null` keeps every run file on multipart.
+ */
+export const DEFAULT_MULTIPART_MAX_BYTES = Math.floor(4.5 * 1024 * 1024);
+/** @deprecated Use {@link DEFAULT_MULTIPART_MAX_BYTES}. */
+export const DIRECT_UPLOAD_BYTE_THRESHOLD = DEFAULT_MULTIPART_MAX_BYTES;
+
+/**
+ * Conservative allowance for multipart boundaries, `target` / `input` /
+ * `overrides` / `metadata` parts, and Content-Disposition headers.
+ */
+export const MULTIPART_ENVELOPE_HEADROOM_BYTES = 256 * 1024;
+
+/** Max aggregate file-content bytes that may ride in one multipart run request. */
+export function multipartFileByteBudget(
+  multipartMaxBytes: number | null = DEFAULT_MULTIPART_MAX_BYTES
+): number | null {
+  if (multipartMaxBytes === null) return null;
+  return Math.max(0, multipartMaxBytes - MULTIPART_ENVELOPE_HEADROOM_BYTES);
+}
+
+/**
+ * Choose which file keys must be pre-uploaded so remaining multipart file
+ * bytes plus envelope headroom stay under the configured multipart maximum.
+ *
+ * Prefers shedding the largest files first so smaller ones can stay on the
+ * single multipart round-trip when the aggregate still fits.
+ */
+export function keysRequiringPreUpload(
+  files: ReadonlyArray<{ key: string; size: number }>,
+  multipartMaxBytes: number | null = DEFAULT_MULTIPART_MAX_BYTES
+): Set<string> {
+  const budget = multipartFileByteBudget(multipartMaxBytes);
+  const toPreUpload = new Set<string>();
+  if (budget === null) return toPreUpload;
+
+  for (const file of files) {
+    if (file.size > budget) {
+      toPreUpload.add(file.key);
+    }
+  }
+
+  let multipartTotal = 0;
+  for (const file of files) {
+    if (!toPreUpload.has(file.key)) multipartTotal += file.size;
+  }
+
+  const candidates = files
+    .filter((file) => !toPreUpload.has(file.key))
+    .slice()
+    .sort((a, b) => b.size - a.size || a.key.localeCompare(b.key));
+
+  for (const file of candidates) {
+    if (multipartTotal <= budget) break;
+    toPreUpload.add(file.key);
+    multipartTotal -= file.size;
+  }
+
+  return toPreUpload;
+}

package/src/resources/files.ts

@@ -1,10 +1,52 @@
-import type { OperationResult } from '../client';
+import type { OperationResult, RequestDispatchOptions } from '../client';
 import type { Client } from '../generated/client';
-import { filesContentGet, filesCreate, filesDelete, filesGet } from '../generated/sdk.gen';
+import {
+  filesContentGet,
+  filesDelete,
+  filesGet,
+  filesUploadsAbort,
+  filesUploadsComplete,
+  filesUploadsCreate,
+} from '../generated/sdk.gen';
 
-type Dispatch = <T>(call: () => Promise<OperationResult<T>>) => Promise<T>;
+type Dispatch = <T>(
+  call: () => Promise<OperationResult<T>>,
+  options?: RequestDispatchOptions
+) => Promise<T>;
 type AnyResponse = any;
 type SignalOptions = { signal?: AbortSignal };
+type UploadOptions = SignalOptions & {
+  /** Required only when `file` is a nameless Blob. */
+  filename?: string;
+  /**
+   * Tenant-scoped idempotency key for upload-session creation. Generated when
+   * omitted so SDK retries of a lost create response reuse the same reservation.
+   */
+  idempotencyKey?: string;
+  /**
+   * Optional lifecycle marker. Pass `run-input` for automatic `client.run`
+   * pre-uploads so the server can retain them for retries and reap them after 24 hours.
+   * Explicit `files.upload` callers should omit this (durable reusable file).
+   */
+  purpose?: 'run-input';
+  onProgress?: (uploadedBytes: number, totalBytes: number) => void;
+};
+
+export type CreateUploadInput = {
+  filename: string;
+  contentType: string;
+  size: number;
+  /** Compatible with server `CreateFileUploadSessionRequest.idempotencyKey`. */
+  idempotencyKey?: string;
+  purpose?: 'run-input';
+};
+
+function newIdempotencyKey(): string {
+  if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
+    return crypto.randomUUID();
+  }
+  return `upload_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`;
+}
 
 export class FilesResource {
   constructor(
@@ -12,15 +54,92 @@ export class FilesResource {
     private readonly dispatch: Dispatch
   ) {}
 
-  async upload(file: Blob | File, options: SignalOptions = {}): Promise<AnyResponse> {
+  async upload(file: Blob | File, options: UploadOptions = {}): Promise<AnyResponse> {
+    const filename =
+      options.filename ??
+      (typeof File !== 'undefined' && file instanceof File ? file.name : undefined);
+    if (!filename) throw new Error('filename is required when uploading a Blob');
+    const idempotencyKey = options.idempotencyKey ?? newIdempotencyKey();
+    const negotiation = await this.createUpload(
+      {
+        filename,
+        contentType: file.type || 'application/octet-stream',
+        size: file.size,
+        idempotencyKey,
+        ...(options.purpose ? { purpose: options.purpose } : {}),
+      },
+      options
+    );
+
+    if (negotiation.transport === 'presigned-put') {
+      const response = await fetch(negotiation.url, {
+        method: 'PUT',
+        headers: Object.fromEntries(
+          Object.entries((negotiation.headers ?? {}) as Record<string, string>).filter(
+            ([name]) => name.toLowerCase() !== 'content-length'
+          )
+        ),
+        body: file,
+        signal: options.signal,
+      });
+      if (!response.ok) {
+        await this.abortUpload(negotiation.uploadId).catch(() => undefined);
+        throw new Error(`Storage upload failed (${response.status}); retry the upload`);
+      }
+      options.onProgress?.(file.size, file.size);
+      return this.completeUpload(negotiation.uploadId, options);
+    }
+
     const form = new FormData();
-    form.append('file', file);
+    form.append('file', file, filename);
+    if (options.purpose) form.append('purpose', options.purpose);
+    const uploaded = await this.dispatch(
+      () =>
+        this.client.post({
+          url: negotiation.url,
+          body: form as never,
+          bodySerializer: null,
+          headers: { 'Content-Type': null },
+          signal: options.signal,
+        }) as Promise<OperationResult<AnyResponse>>
+    );
+    options.onProgress?.(file.size, file.size);
+    return uploaded;
+  }
+
+  async createUpload(input: CreateUploadInput, options: SignalOptions = {}): Promise<AnyResponse> {
+    const body = {
+      filename: input.filename,
+      contentType: input.contentType,
+      size: input.size,
+      ...(input.idempotencyKey ? { idempotencyKey: input.idempotencyKey } : {}),
+      ...(input.purpose ? { purpose: input.purpose } : {}),
+    };
+    return this.dispatch(() =>
+      filesUploadsCreate({
+        client: this.client,
+        // Server accepts optional idempotencyKey; generated types may lag the schema.
+        body: body as never,
+        signal: options.signal,
+      })
+    );
+  }
+
+  async completeUpload(uploadId: string, options: SignalOptions = {}): Promise<AnyResponse> {
     return this.dispatch(() =>
-      filesCreate({
+      filesUploadsComplete({
         client: this.client,
-        body: form as never,
-        bodySerializer: null,
-        headers: { 'Content-Type': null },
+        path: { uploadId },
+        signal: options.signal,
+      })
+    );
+  }
+
+  async abortUpload(uploadId: string, options: SignalOptions = {}): Promise<AnyResponse> {
+    return this.dispatch(() =>
+      filesUploadsAbort({
+        client: this.client,
+        path: { uploadId },
         signal: options.signal,
       })
     );
@@ -33,14 +152,18 @@ export class FilesResource {
   }
 
   async download(fileId: string, options: SignalOptions = {}): Promise<Blob> {
-    return this.dispatch(async () => {
-      const response = await filesContentGet({
-        client: this.client,
-        path: { id: fileId },
-        signal: options.signal,
-      });
-      return response as OperationResult<Blob>;
-    });
+    return this.dispatch(
+      async () => {
+        const response = await filesContentGet({
+          client: this.client,
+          path: { id: fileId },
+          parseAs: 'blob',
+          signal: options.signal,
+        });
+        return response as OperationResult<Blob>;
+      },
+      { responseKind: 'binary' }
+    );
   }
 
   async delete(fileId: string, options: SignalOptions = {}): Promise<AnyResponse> {

package/src/resources/runs.ts

@@ -250,7 +250,7 @@ export class RunsReviewsResource {
     return this.dispatch(
       () =>
         this.client.post({
-          url: '/api/v1/runs/{id}/reviews/expected',
+          url: '/v1/runs/{id}/reviews/expected',
           path: { id: runId },
           body: formData,
           bodySerializer: null,

package/src/runtime-config.ts

@@ -11,5 +11,5 @@ import type { CreateClientConfig } from './generated/client.gen';
  */
 export const createClientConfig: CreateClientConfig = (config) => ({
   ...config,
-  baseUrl: config?.baseUrl ?? 'https://studio.eigenpal.com',
+  baseUrl: config?.baseUrl ?? 'https://api.eigenpal.com',
 });

package/src/telemetry.ts

@@ -19,7 +19,7 @@
 export const SDK_LANGUAGE = 'typescript';
 // Rewritten at publish time by scripts/release/platform/render-sdk-versions.sh.
 // Keep this string literal exactly stable — sed matches on it.
-export const SDK_VERSION = '0.10.56';
+export const SDK_VERSION = '0.11.1';
 
 function detectRuntime(): string {
   const g = globalThis as unknown as {