@eigenpal/sdk 0.6.14 → 0.6.16

package/src/resources/executions.ts

@@ -1,9 +1,9 @@
 import type { OperationResult } from '../client';
 import { EigenpalTimeoutError } from '../errors';
 import type { Client } from '../generated/client';
-import { runsGet, workflowsRun } from '../generated/sdk.gen';
-import type { ExecutionStatus, RunsGetResponse, RunWorkflowResponse } from '../generated/types.gen';
-import { buildMultipart, hasFileInput } from '../lib/files';
+import { runsGet } from '../generated/sdk.gen';
+import type { ExecutionStatus, RunsGetResponse } from '../generated/types.gen';
+import { buildRunJsonBody, buildRunMultipart, hasFileInput } from '../lib/files';
 import type { WorkflowInput } from './workflows';
 
 export interface RunAndWaitOptions {
@@ -22,6 +22,13 @@ export interface RunAndWaitOptions {
   signal?: AbortSignal;
 }
 
+export type WorkflowRunAndWaitResponse = {
+  runId: string;
+  status?: ExecutionStatus;
+  output?: unknown;
+  error?: string;
+};
+
 const TERMINAL_STATUSES = new Set<ExecutionStatus>([
   'completed',
   'failed',
@@ -48,55 +55,54 @@ export class WorkflowExecutionsResource {
   /**
    * Trigger a workflow and poll for completion client-side.
    *
-   * Unlike `workflows.run({ waitForCompletion: 60 })`, this helper polls
+   * Unlike `client.run({ waitForCompletion: 60 })`, this helper polls
    * indefinitely (up to `timeoutMs`, default 5 min) so it works for runs
    * that exceed the server-side 60s sync window. Returns the final
-   * response with `status`/`result`/`error` populated.
+   * response with `status`/`output`/`error` populated.
    */
   async runAndWait(
     workflowId: string,
     input?: WorkflowInput,
     options: RunAndWaitOptions = {}
-  ): Promise<RunWorkflowResponse> {
+  ): Promise<WorkflowRunAndWaitResponse> {
     const pollInterval = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
     const timeoutMs = options.timeoutMs ?? DEFAULT_RUN_AND_WAIT_TIMEOUT_MS;
     const deadline = Date.now() + timeoutMs;
 
-    // Trigger async — we don't ask the server to wait, since we're polling.
-    const triggerQuery = options.version ? { version: options.version } : {};
-    let runResult: RunWorkflowResponse;
+    const target = `workflows.${workflowId}`;
+    const runUrl = `/api/v1/run/${encodeURIComponent(target)}`;
+    const runQuery =
+      options.version && options.version !== 'latest' ? { version: options.version } : undefined;
+    let runResult: { runId: string };
     if (hasFileInput(input)) {
       // Build the multipart body once, up front — `dispatch` may retry the
       // POST, and a drained stream cannot be replayed.
-      const { formData } = await buildMultipart({ input, overrides: options.overrides });
-      runResult = await this.dispatch<RunWorkflowResponse>(
+      const { formData } = await buildRunMultipart({ input, overrides: options.overrides });
+      runResult = await this.dispatch<{ runId: string }>(
         () =>
           this.client.post({
-            url: '/api/v1/workflows/{id}/run',
-            path: { id: workflowId },
-            query: triggerQuery,
+            url: runUrl,
+            query: runQuery,
             body: formData,
             bodySerializer: null,
             headers: { 'Content-Type': null },
             signal: options.signal,
-          }) as Promise<OperationResult<RunWorkflowResponse>>
+          }) as Promise<OperationResult<{ runId: string }>>
       );
     } else {
-      runResult = await this.dispatch<RunWorkflowResponse>(() =>
-        workflowsRun({
-          client: this.client,
-          path: { id: workflowId },
-          query: triggerQuery,
-          body: {
-            ...(input !== undefined ? { input } : {}),
-            ...(options.overrides ? { overrides: options.overrides } : {}),
-          },
-          signal: options.signal,
-        })
+      const body = buildRunJsonBody(input, options.overrides);
+      runResult = await this.dispatch<{ runId: string }>(
+        () =>
+          this.client.post({
+            url: runUrl,
+            query: runQuery,
+            body,
+            signal: options.signal,
+          }) as Promise<OperationResult<{ runId: string }>>
       );
     }
 
-    const { executionId } = runResult;
+    const runId = runResult.runId;
 
     while (true) {
       if (options.signal?.aborted) {
@@ -104,7 +110,7 @@ export class WorkflowExecutionsResource {
       }
       if (Date.now() >= deadline) {
         throw new EigenpalTimeoutError(
-          `runAndWait timed out after ${timeoutMs}ms (executionId=${executionId})`
+          `runAndWait timed out after ${timeoutMs}ms (runId=${runId})`
         );
       }
 
@@ -112,22 +118,22 @@ export class WorkflowExecutionsResource {
         () =>
           runsGet({
             client: this.client,
-            path: { id: executionId },
+            path: { id: runId },
             query: { include: 'detail' },
             signal: options.signal,
           }) as Promise<OperationResult<RunsGetResponse>>
       );
       const status = response.run as {
         status?: ExecutionStatus | null;
-        result?: unknown;
+        output?: unknown;
         error?: string | null;
       };
 
       if (status.status && TERMINAL_STATUSES.has(status.status)) {
         return {
-          executionId,
+          runId,
           status: status.status,
-          ...(status.result != null ? { result: status.result } : {}),
+          ...(status.output != null ? { output: status.output } : {}),
           ...(status.error != null ? { error: status.error } : {}),
         };
       }

package/src/resources/runs.ts

@@ -21,7 +21,6 @@ import {
   runsGet,
   runsList,
   runsRerun,
-  runsResume,
   runsTraceGet,
 } from '../generated/sdk.gen';
 import type {
@@ -47,7 +46,6 @@ import type {
   RunsListData,
   RunsListResponse,
   RunsRerunResponse,
-  RunsResumeResponse,
   RunsTraceGetResponse,
 } from '../generated/types.gen';
 
@@ -93,12 +91,6 @@ export class RunsResource {
     return response.run;
   }
 
-  async resume(runId: string, options: SignalOptions = {}): Promise<RunsResumeResponse> {
-    return this.dispatch(() =>
-      runsResume({ client: this.client, path: { id: runId }, signal: options.signal })
-    );
-  }
-
   async cancel(runId: string, options: SignalOptions = {}): Promise<RunsCancelResponse> {
     return this.dispatch(() =>
       runsCancel({ client: this.client, path: { id: runId }, signal: options.signal })

package/src/resources/workflows.ts

@@ -1,18 +1,11 @@
 import type { OperationResult } from '../client';
 import type { Client } from '../generated/client';
-import {
-  workflowsGet,
-  workflowsList,
-  workflowsRun,
-  workflowsVersionsList,
-} from '../generated/sdk.gen';
+import { workflowsGet, workflowsList, workflowsVersionsList } from '../generated/sdk.gen';
 import type {
   ListVersionsResponse,
   ListWorkflowsResponse,
-  RunWorkflowResponse,
   WorkflowDetail,
 } from '../generated/types.gen';
-import { buildMultipart, hasFileInput } from '../lib/files';
 import { WorkflowExecutionsResource } from './executions';
 
 /**
@@ -24,17 +17,6 @@ import { WorkflowExecutionsResource } from './executions';
  */
 export type WorkflowInput = Record<string, unknown>;
 
-export interface RunWorkflowOptions {
-  /** Specific version id, or `"latest"` (default). */
-  version?: string;
-  /** Hold the connection up to N seconds for completion (max 60). Omit for async. */
-  waitForCompletion?: number;
-  /** Per-step output overrides for replay. */
-  overrides?: { steps?: Record<string, Record<string, unknown>> };
-  /** AbortSignal to cancel the request. */
-  signal?: AbortSignal;
-}
-
 export interface ListWorkflowsOptions {
   /** Substring match against workflow name. */
   search?: string;
@@ -55,8 +37,9 @@ export interface ListVersionsOptions {
 type Dispatch = <T>(call: () => Promise<OperationResult<T>>) => Promise<T>;
 
 /**
- * Workflow resource — list, get, run, and inspect versions of saved workflows.
+ * Workflow resource — list, get, and inspect versions of saved workflows.
  * Existing run retrieval and mutation lives on `client.runs`.
+ * Starting runs lives on root `client.run(...)`.
  */
 export class WorkflowsResource {
   public readonly executions: WorkflowExecutionsResource;
@@ -68,66 +51,6 @@ export class WorkflowsResource {
     this.executions = new WorkflowExecutionsResource(client, dispatch);
   }
 
-  /**
-   * Execute a workflow.
-   *
-   * @param workflowId — id like `wf_abc123`.
-   * @param input — workflow inputs keyed by name. Pass `undefined` for inputs-less workflows.
-   * @param options — `version`, `waitForCompletion`, `overrides`.
-   *
-   * - With no `waitForCompletion`, returns immediately with `{ executionId }`.
-   *   Poll via `client.runs.get(id)` or use `client.workflows.executions.runAndWait`.
-   * - With `waitForCompletion: 60`, the server holds the connection up to 60
-   *   seconds. The response also includes `status`, `result`, and `error`
-   *   when the run finishes within the window.
-   */
-  async run(
-    workflowId: string,
-    input?: WorkflowInput,
-    options: RunWorkflowOptions = {}
-  ): Promise<RunWorkflowResponse> {
-    const query = {
-      ...(options.version ? { version: options.version } : {}),
-      ...(options.waitForCompletion !== undefined
-        ? { wait_for_completion: options.waitForCompletion }
-        : {}),
-    };
-
-    // File-bearing input → multipart/form-data (no base64 overhead).
-    if (hasFileInput(input)) {
-      const { formData } = await buildMultipart({ input, overrides: options.overrides });
-      return this.dispatch<RunWorkflowResponse>(
-        () =>
-          this.client.post({
-            url: '/api/v1/workflows/{id}/run',
-            path: { id: workflowId },
-            query,
-            body: formData,
-            // Skip JSON serialization; FormData passes through to fetch which
-            // sets the Content-Type header (with boundary) automatically.
-            bodySerializer: null,
-            // Explicitly null the JSON Content-Type header that the request
-            // pipeline would otherwise inherit.
-            headers: { 'Content-Type': null },
-            signal: options.signal,
-          }) as Promise<OperationResult<RunWorkflowResponse>>
-      );
-    }
-
-    return this.dispatch<RunWorkflowResponse>(() =>
-      workflowsRun({
-        client: this.client,
-        path: { id: workflowId },
-        query,
-        body: {
-          ...(input !== undefined ? { input } : {}),
-          ...(options.overrides ? { overrides: options.overrides } : {}),
-        },
-        signal: options.signal,
-      })
-    );
-  }
-
   /** List workflows, paginated. */
   async list(options: ListWorkflowsOptions = {}): Promise<ListWorkflowsResponse> {
     const { signal, ...query } = options;

package/src/telemetry.ts

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