@eigenpal/sdk 0.12.2 → 0.13.1

package/src/index.ts

@@ -54,8 +54,14 @@ export type {
   AutomationTriggerState,
   AutomationTriggersResponse,
   AutomationVersion,
+  CreateAutomationVersionRequest,
   ExecutionStatus,
   File,
+  ListModelsResponse,
+  PublicModel,
+  PublicModelCost,
+  PublicModelLimits,
+  RestoreAutomationVersionRequest,
   Run,
   RunAccepted,
   RunArtifact,
@@ -79,4 +85,6 @@ export type {
   RunsReviewsGetResponse,
   RunsReviewsUpdateResponse,
   RunsTraceGetResponse,
+  Template,
+  TemplateRevision,
 } from './generated/types.gen';

package/src/resources/automations.ts

@@ -23,9 +23,15 @@ import {
   automationsReviewsHealth,
   automationsSync,
   automationsTriggersGet,
+  automationsVersionsCreate,
   automationsVersionsList,
+  automationsVersionsPromote,
+  automationsVersionsRestore,
 } from '../generated/sdk.gen';
-import type { AutomationsReviewsHealthData } from '../generated/types.gen';
+import type {
+  AutomationsReviewsHealthData,
+  CreateAutomationVersionRequest,
+} from '../generated/types.gen';
 
 type Dispatch = <T>(call: () => Promise<OperationResult<T>>) => Promise<T>;
 type SignalOptions = { signal?: AbortSignal };
@@ -74,6 +80,51 @@ export class AutomationsResource {
     );
   }
 
+  async createVersion(
+    id: string,
+    body: CreateAutomationVersionRequest,
+    options: SignalOptions = {}
+  ): Promise<AnyResponse> {
+    return this.dispatch(() =>
+      automationsVersionsCreate({
+        client: this.client,
+        path: { id },
+        body,
+        signal: options.signal,
+      })
+    );
+  }
+
+  async restoreVersion(
+    id: string,
+    versionId: string,
+    body: { message?: string } = {},
+    options: SignalOptions = {}
+  ): Promise<AnyResponse> {
+    return this.dispatch(() =>
+      automationsVersionsRestore({
+        client: this.client,
+        path: { id, versionId },
+        body,
+        signal: options.signal,
+      })
+    );
+  }
+
+  async promoteVersion(
+    id: string,
+    versionId: string,
+    options: SignalOptions = {}
+  ): Promise<AnyResponse> {
+    return this.dispatch(() =>
+      automationsVersionsPromote({
+        client: this.client,
+        path: { id, versionId },
+        signal: options.signal,
+      })
+    );
+  }
+
   async triggers(id: string, options: SignalOptions = {}): Promise<AnyResponse> {
     return this.dispatch(() =>
       automationsTriggersGet({ client: this.client, path: { id }, signal: options.signal })
@@ -163,7 +214,12 @@ export class AutomationExamplesResource {
 
   async list(
     automationId: string,
-    options: { limit?: number; offset?: number; signal?: AbortSignal } = {}
+    options: {
+      limit?: number;
+      offset?: number;
+      include?: 'full' | 'metadata';
+      signal?: AbortSignal;
+    } = {}
   ): Promise<AnyResponse> {
     const { signal, ...query } = options;
     return this.dispatch(() =>

package/src/resources/files.ts

@@ -32,6 +32,12 @@ type UploadOptions = SignalOptions & {
   onProgress?: (uploadedBytes: number, totalBytes: number) => void;
 };
 
+const UPLOAD_ABORT_CLEANUP_TIMEOUT_MS = 10_000;
+
+function uploadAbortCleanupSignal(): AbortSignal {
+  return AbortSignal.timeout(UPLOAD_ABORT_CLEANUP_TIMEOUT_MS);
+}
+
 export type CreateUploadInput = {
   filename: string;
   contentType: string;
@@ -72,22 +78,30 @@ export class FilesResource {
     );
 
     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`);
+      try {
+        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) {
+          throw new Error(`Storage upload failed (${response.status}); retry the upload`);
+        }
+        options.onProgress?.(file.size, file.size);
+        return await this.completeUpload(negotiation.uploadId, options);
+      } catch (error) {
+        // Caller cancellation and response-loss also reach here. Cleanup must
+        // not inherit the failed/aborted signal, and must remain bounded.
+        await this.abortUpload(negotiation.uploadId, {
+          signal: uploadAbortCleanupSignal(),
+        }).catch(() => undefined);
+        throw error;
       }
-      options.onProgress?.(file.size, file.size);
-      return this.completeUpload(negotiation.uploadId, options);
     }
 
     const form = new FormData();

package/src/resources/models.ts

@@ -0,0 +1,30 @@
+import type { OperationResult } from '../client';
+import type { Client } from '../generated/client';
+import { modelsList } from '../generated/sdk.gen';
+import type { ListModelsResponse } from '../generated/types.gen';
+
+type Dispatch = <T>(call: () => Promise<OperationResult<T>>) => Promise<T>;
+type SignalOptions = { signal?: AbortSignal };
+
+export class ModelsResource {
+  constructor(
+    private readonly client: Client,
+    private readonly dispatch: Dispatch
+  ) {}
+
+  /**
+   * List text, vision, and OCR models configured for this tenant environment.
+   * Catalog inventory only — not a live provider health probe.
+   */
+  async list(
+    options: SignalOptions & { capability?: 'text' | 'vision' | 'ocr' } = {}
+  ): Promise<ListModelsResponse> {
+    return this.dispatch(() =>
+      modelsList({
+        client: this.client,
+        query: { capability: options.capability },
+        signal: options.signal,
+      })
+    );
+  }
+}

package/src/resources/templates.ts

@@ -0,0 +1,153 @@
+import type { OperationResult, RequestDispatchOptions } from '../client';
+import type { Client } from '../generated/client';
+import {
+  templatesContentGet,
+  templatesDelete,
+  templatesGet,
+  templatesList,
+} from '../generated/sdk.gen';
+import type { ListTemplatesResponse, Template } from '../generated/types.gen';
+import type { FilesResource } from './files';
+
+type Dispatch = <T>(
+  call: () => Promise<OperationResult<T>>,
+  options?: RequestDispatchOptions
+) => Promise<T>;
+type SignalOptions = { signal?: AbortSignal };
+type UploadOptions = SignalOptions & {
+  /** Required only when `file` is a nameless Blob. */
+  filename?: string;
+  name?: string;
+  description?: string;
+};
+type FileIdOptions = SignalOptions & {
+  name?: string;
+  description?: string;
+};
+
+const TEMPORARY_UPLOAD_CLEANUP_TIMEOUT_MS = 10_000;
+
+function temporaryUploadCleanupSignal(): AbortSignal {
+  return AbortSignal.timeout(TEMPORARY_UPLOAD_CLEANUP_TIMEOUT_MS);
+}
+
+function filenameFor(file: Blob | File, filename?: string): string {
+  const resolved =
+    filename ?? (typeof File !== 'undefined' && file instanceof File ? file.name : undefined);
+  if (!resolved) throw new Error('filename is required when uploading a Blob');
+  return resolved;
+}
+
+export class TemplatesResource {
+  constructor(
+    private readonly client: Client,
+    private readonly dispatch: Dispatch,
+    private readonly files: FilesResource
+  ) {}
+
+  async list(
+    options: SignalOptions & { limit?: number; offset?: number } = {}
+  ): Promise<ListTemplatesResponse> {
+    return this.dispatch(() =>
+      templatesList({
+        client: this.client,
+        query: { limit: options.limit, offset: options.offset },
+        signal: options.signal,
+      })
+    );
+  }
+
+  async get(templateId: string, options: SignalOptions = {}): Promise<Template> {
+    return this.dispatch(() =>
+      templatesGet({ client: this.client, path: { id: templateId }, signal: options.signal })
+    );
+  }
+
+  async create(file: Blob | File, options: UploadOptions = {}): Promise<Template> {
+    const uploaded = await this.files.upload(file, {
+      filename: filenameFor(file, options.filename),
+      signal: options.signal,
+    });
+    try {
+      return await this.createFromFileId(uploaded.id, options);
+    } finally {
+      await this.files
+        .delete(uploaded.id, { signal: temporaryUploadCleanupSignal() })
+        .catch(() => undefined);
+    }
+  }
+
+  /** Create a template from an existing reusable `file_…` resource. */
+  async createFromFileId(fileId: string, options: FileIdOptions = {}): Promise<Template> {
+    return this.dispatch(
+      () =>
+        this.client.post({
+          url: '/v1/templates',
+          body: {
+            fileId,
+            name: options.name,
+            description: options.description,
+          },
+          signal: options.signal,
+        }) as Promise<OperationResult<Template>>
+    );
+  }
+
+  async replace(
+    templateId: string,
+    file: Blob | File,
+    options: Pick<UploadOptions, 'filename' | 'signal'> = {}
+  ): Promise<Template> {
+    const uploaded = await this.files.upload(file, {
+      filename: filenameFor(file, options.filename),
+      signal: options.signal,
+    });
+    try {
+      return await this.replaceFromFileId(templateId, uploaded.id, options);
+    } finally {
+      await this.files
+        .delete(uploaded.id, { signal: temporaryUploadCleanupSignal() })
+        .catch(() => undefined);
+    }
+  }
+
+  /** Append a revision from an existing reusable `file_…` resource. */
+  async replaceFromFileId(
+    templateId: string,
+    fileId: string,
+    options: SignalOptions = {}
+  ): Promise<Template> {
+    return this.dispatch(
+      () =>
+        this.client.put({
+          url: '/v1/templates/{id}',
+          path: { id: templateId },
+          body: { fileId },
+          signal: options.signal,
+        }) as Promise<OperationResult<Template>>
+    );
+  }
+
+  async download(
+    templateId: string,
+    options: SignalOptions & { revisionId?: string } = {}
+  ): Promise<Blob> {
+    return this.dispatch(
+      async () =>
+        (await templatesContentGet({
+          client: this.client,
+          path: { id: templateId },
+          query: { revisionId: options.revisionId },
+          parseAs: 'blob',
+          signal: options.signal,
+        })) as OperationResult<Blob>,
+      { responseKind: 'binary' }
+    );
+  }
+
+  async delete(templateId: string, options: SignalOptions = {}): Promise<{ deleted: boolean }> {
+    return this.dispatch(() =>
+      templatesDelete({ client: this.client, path: { id: templateId }, signal: options.signal })
+    );
+  }
+}

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.12.2';
+export const SDK_VERSION = '0.13.1';
 
 function detectRuntime(): string {
   const g = globalThis as unknown as {