@eigenpal/sdk 0.7.2 → 0.9.0

package/src/index.ts

@@ -13,12 +13,13 @@
  * // Sync (server holds the connection up to 60s).
  * const result = await client.run('workflows.extract-invoice', { ... }, { waitForCompletion: 60 });
  *
- * // Client-side poll (up to 5min by default).
- * const final = await client.workflows.executions.runAndWait('wf_abc', { ... });
+ * // Inspect or manage runs later.
+ * const final = await client.runs.get(id);
  * ```
  */
 export {
   EigenpalClient,
+  isRunFinished,
   type EigenpalOptions,
   type RerunOptions,
   type RunCallOptions,
@@ -40,62 +41,41 @@ export {
 
 export { toFile } from './lib/files';
 export type { FileDescriptor, FileInput, NodeReadableStream } from './lib/files';
-export type { ListAgentsOptions } from './resources/agents';
 export type { ListRunsOptions, RunExpand, RunExpandSection } from './resources/runs';
-export type { SourceRawOptions, SourceReleasesOptions } from './resources/source';
-export type {
-  ListVersionsOptions,
-  ListWorkflowsOptions,
-  WorkflowInput,
-} from './resources/workflows';
-// Note: FileReference (by fileId) is intentionally NOT exported. From the
-// SDK perspective you always upload a file; fileId is an internal wire id
-// the server creates after upload — not something users construct.
-
-export type { RunAndWaitOptions, WorkflowRunAndWaitResponse } from './resources/executions';
 
 // Re-export the canonical generated types so users can type their own
 // callbacks and helpers without reaching into `./generated`.
 export type {
-  AgentSummary,
-  AgentsTriggersEmailCreateAliasData,
-  AgentsTriggersEmailCreateAliasResponse,
-  AgentsTriggersEmailDeleteAliasResponse,
-  AgentsTriggersEmailGetResponse,
-  AgentsTriggersEmailListResponse,
-  AgentsTriggersEmailUpdateAliasData,
-  AgentsTriggersEmailUpdateAliasResponse,
-  AgentsTriggersEmailUpdateData,
-  AgentsTriggersEmailUpdateResponse,
   ApiErrorEnvelope,
   ApiErrorIssue,
-  AutomationSyncResponse,
+  AuthCheckResponse,
+  AutomationDetail,
+  AutomationSummary,
+  AutomationTriggerState,
+  AutomationTriggersResponse,
+  AutomationVersion,
   ExecutionStatus,
-  GetAgentResponse,
-  ListAgentsResponse,
-  ListVersionsResponse,
-  ListWorkflowsResponse,
-  RawSourceResponse,
+  File,
+  Run,
+  RunArtifact,
+  RunArtifactsResponse,
+  RunEvent,
+  RunEventsResponse,
   RunListItem,
   RunStartBody,
+  RunStepsResponse,
+  RunUsage,
+  RunUsageResponse,
   RunsCancelResponse,
-  RunsExpectedCreateResponse,
-  RunsExpectedFileDeleteResponse,
-  RunsExpectedFileUpdateResponse,
-  RunsExpectedGetResponse,
   RunsFeedbackClearResponse,
+  RunsFeedbackExpectedCreateResponse,
+  RunsFeedbackExpectedFileDeleteResponse,
+  RunsFeedbackExpectedFileUpdateResponse,
+  RunsFeedbackExpectedGetResponse,
+  RunsFeedbackGetResponse,
   RunsFeedbackUpdateResponse,
   RunsGetResponse,
   RunsListResponse,
   RunsRerunResponse,
-  SourceLockfileResponse,
-  SourceReleasesResponse,
-  SourceRepositoryResponse,
-  SourceSecretsDecryptBody,
-  SourceSecretsDecryptResponse,
-  SourceSecretsEncryptBody,
-  SourceSecretsEncryptResponse,
-  WorkflowDetail,
-  WorkflowSummary,
-  WorkflowVersion,
+  RunsTraceGetResponse,
 } from './generated/types.gen';

package/src/lib/files.ts

@@ -237,3 +237,12 @@ export async function buildRunMultipart(args: {
   }
   return { formData: fd, fileCount };
 }
+
+/** Build multipart for endpoints that accept one file field plus optional name. */
+export async function buildSingleFileMultipart(file: FileInput, name?: string): Promise<FormData> {
+  const fd = new FormData();
+  const { blob, filename } = await resolveFileBlob(file);
+  fd.append('file', blob, filename);
+  if (name) fd.append('name', name);
+  return fd;
+}

package/src/resources/auth.ts

@@ -0,0 +1,18 @@
+import type { OperationResult } from '../client';
+import type { Client } from '../generated/client';
+import { authCheck } from '../generated/sdk.gen';
+import type { AuthCheckResponse } from '../generated/types.gen';
+
+type Dispatch = <T>(call: () => Promise<OperationResult<T>>) => Promise<T>;
+type SignalOptions = { signal?: AbortSignal };
+
+export class AuthResource {
+  constructor(
+    private readonly client: Client,
+    private readonly dispatch: Dispatch
+  ) {}
+
+  async check(options: SignalOptions = {}): Promise<AuthCheckResponse> {
+    return this.dispatch(() => authCheck({ client: this.client, signal: options.signal }));
+  }
+}

package/src/resources/automations.ts

@@ -1,22 +1,357 @@
 import type { OperationResult } from '../client';
 import type { Client } from '../generated/client';
-import { automationsSync } from '../generated/sdk.gen';
-import type { AutomationSyncResponse } from '../generated/types.gen';
+import {
+  automationsDatasetExport,
+  automationsDatasetImport,
+  automationsEvaluatorsGet,
+  automationsEvaluatorsUpdate,
+  automationsExamplesCreate,
+  automationsExamplesDelete,
+  automationsExamplesGet,
+  automationsExamplesList,
+  automationsExamplesRun,
+  automationsExamplesUpdate,
+  automationsExperimentsCancel,
+  automationsExperimentsCreate,
+  automationsExperimentsCreateStream,
+  automationsExperimentsExport,
+  automationsExperimentsExportAll,
+  automationsExperimentsGet,
+  automationsExperimentsList,
+  automationsGet,
+  automationsList,
+  automationsSync,
+  automationsTriggersGet,
+  automationsVersionsList,
+} from '../generated/sdk.gen';
 
 type Dispatch = <T>(call: () => Promise<OperationResult<T>>) => Promise<T>;
+type SignalOptions = { signal?: AbortSignal };
+type AnyResponse = any;
 
 export class AutomationsResource {
+  public readonly dataset: AutomationDatasetResource;
+  public readonly examples: AutomationExamplesResource;
+  public readonly evaluators: AutomationEvaluatorsResource;
+  public readonly experiments: AutomationExperimentsResource;
+
+  constructor(
+    private readonly client: Client,
+    private readonly dispatch: Dispatch
+  ) {
+    this.dataset = new AutomationDatasetResource(client, dispatch);
+    this.examples = new AutomationExamplesResource(client, dispatch);
+    this.evaluators = new AutomationEvaluatorsResource(client, dispatch);
+    this.experiments = new AutomationExperimentsResource(client, dispatch);
+  }
+
+  async list(
+    options: {
+      search?: string;
+      type?: 'workflow' | 'agent';
+      limit?: number;
+      offset?: number;
+      signal?: AbortSignal;
+    } = {}
+  ): Promise<AnyResponse> {
+    const { signal, ...query } = options;
+    return this.dispatch(() => automationsList({ client: this.client, query, signal }));
+  }
+
+  async get(id: string, options: SignalOptions = {}): Promise<AnyResponse> {
+    return this.dispatch(() =>
+      automationsGet({ client: this.client, path: { id }, signal: options.signal })
+    );
+  }
+
+  async versions(id: string, options: SignalOptions = {}): Promise<AnyResponse> {
+    return this.dispatch(() =>
+      automationsVersionsList({ client: this.client, path: { id }, signal: options.signal })
+    );
+  }
+
+  async triggers(id: string, options: SignalOptions = {}): Promise<AnyResponse> {
+    return this.dispatch(() =>
+      automationsTriggersGet({ client: this.client, path: { id }, signal: options.signal })
+    );
+  }
+
+  async sync(id: string, options: SignalOptions = {}): Promise<AnyResponse> {
+    return this.dispatch(() =>
+      automationsSync({ client: this.client, path: { id }, signal: options.signal })
+    );
+  }
+}
+
+export class AutomationDatasetResource {
   constructor(
     private readonly client: Client,
     private readonly dispatch: Dispatch
   ) {}
 
-  async sync(
-    automation: string,
-    options: { signal?: AbortSignal } = {}
-  ): Promise<AutomationSyncResponse> {
+  async export(
+    automationId: string,
+    options: { exampleIds?: string[]; signal?: AbortSignal } = {}
+  ): Promise<Blob> {
+    const query = options.exampleIds?.length ? { exampleIds: options.exampleIds.join(',') } : {};
+    return this.dispatch(
+      () =>
+        automationsDatasetExport({
+          client: this.client,
+          path: { id: automationId },
+          query,
+          signal: options.signal,
+        }) as Promise<OperationResult<Blob>>
+    );
+  }
+
+  async import(
+    automationId: string,
+    file: Blob | File,
+    options: { mode?: 'append' | 'replace'; signal?: AbortSignal } = {}
+  ): Promise<AnyResponse> {
+    const formData = new FormData();
+    formData.set('file', file);
+    formData.set('mode', options.mode ?? 'append');
+    return this.dispatch(() =>
+      automationsDatasetImport({
+        client: this.client,
+        path: { id: automationId },
+        body: formData as never,
+        bodySerializer: null,
+        headers: { 'Content-Type': null },
+        signal: options.signal,
+      })
+    );
+  }
+}
+
+export class AutomationExamplesResource {
+  constructor(
+    private readonly client: Client,
+    private readonly dispatch: Dispatch
+  ) {}
+
+  async list(
+    automationId: string,
+    options: { limit?: number; offset?: number; signal?: AbortSignal } = {}
+  ): Promise<AnyResponse> {
+    const { signal, ...query } = options;
+    return this.dispatch(() =>
+      automationsExamplesList({ client: this.client, path: { id: automationId }, query, signal })
+    );
+  }
+
+  async create(
+    automationId: string,
+    body: Record<string, unknown>,
+    options: SignalOptions = {}
+  ): Promise<AnyResponse> {
     return this.dispatch(() =>
-      automationsSync({ client: this.client, path: { automation }, signal: options.signal })
+      automationsExamplesCreate({
+        client: this.client,
+        path: { id: automationId },
+        body: body as never,
+        signal: options.signal,
+      })
+    );
+  }
+
+  async get(
+    automationId: string,
+    exampleId: string,
+    options: SignalOptions = {}
+  ): Promise<AnyResponse> {
+    return this.dispatch(() =>
+      automationsExamplesGet({
+        client: this.client,
+        path: { id: automationId, exampleId },
+        signal: options.signal,
+      })
+    );
+  }
+
+  async update(
+    automationId: string,
+    exampleId: string,
+    body: Record<string, unknown>,
+    options: SignalOptions = {}
+  ): Promise<AnyResponse> {
+    return this.dispatch(() =>
+      automationsExamplesUpdate({
+        client: this.client,
+        path: { id: automationId, exampleId },
+        body: body as never,
+        signal: options.signal,
+      })
+    );
+  }
+
+  async delete(
+    automationId: string,
+    exampleId: string,
+    options: SignalOptions = {}
+  ): Promise<AnyResponse> {
+    return this.dispatch(() =>
+      automationsExamplesDelete({
+        client: this.client,
+        path: { id: automationId, exampleId },
+        signal: options.signal,
+      })
+    );
+  }
+
+  async run(
+    automationId: string,
+    exampleId: string,
+    options: SignalOptions = {}
+  ): Promise<AnyResponse> {
+    return this.dispatch(() =>
+      automationsExamplesRun({
+        client: this.client,
+        path: { id: automationId, exampleId },
+        signal: options.signal,
+      })
+    );
+  }
+}
+
+export class AutomationEvaluatorsResource {
+  constructor(
+    private readonly client: Client,
+    private readonly dispatch: Dispatch
+  ) {}
+
+  async get(automationId: string, options: SignalOptions = {}): Promise<AnyResponse> {
+    return this.dispatch(() =>
+      automationsEvaluatorsGet({
+        client: this.client,
+        path: { id: automationId },
+        signal: options.signal,
+      })
+    );
+  }
+
+  async update(
+    automationId: string,
+    yaml: string,
+    options: SignalOptions = {}
+  ): Promise<AnyResponse> {
+    return this.dispatch(() =>
+      automationsEvaluatorsUpdate({
+        client: this.client,
+        path: { id: automationId },
+        body: { yaml },
+        signal: options.signal,
+      })
+    );
+  }
+}
+
+export class AutomationExperimentsResource {
+  constructor(
+    private readonly client: Client,
+    private readonly dispatch: Dispatch
+  ) {}
+
+  async list(
+    automationId: string,
+    options: { limit?: number; offset?: number; signal?: AbortSignal } = {}
+  ): Promise<AnyResponse> {
+    const { signal, ...query } = options;
+    return this.dispatch(() =>
+      automationsExperimentsList({ client: this.client, path: { id: automationId }, query, signal })
+    );
+  }
+
+  async create(
+    automationId: string,
+    body: Record<string, unknown> = {},
+    options: SignalOptions = {}
+  ): Promise<AnyResponse> {
+    return this.dispatch(() =>
+      automationsExperimentsCreate({
+        client: this.client,
+        path: { id: automationId },
+        body: body as never,
+        signal: options.signal,
+      })
+    );
+  }
+
+  async get(
+    automationId: string,
+    experimentId: string,
+    options: SignalOptions = {}
+  ): Promise<AnyResponse> {
+    return this.dispatch(() =>
+      automationsExperimentsGet({
+        client: this.client,
+        path: { id: automationId, experimentId },
+        signal: options.signal,
+      })
+    );
+  }
+
+  async cancel(
+    automationId: string,
+    experimentId: string,
+    options: SignalOptions = {}
+  ): Promise<AnyResponse> {
+    return this.dispatch(() =>
+      automationsExperimentsCancel({
+        client: this.client,
+        path: { id: automationId, experimentId },
+        signal: options.signal,
+      })
+    );
+  }
+
+  async export(
+    automationId: string,
+    experimentId: string,
+    options: { format?: 'csv' | 'json'; signal?: AbortSignal } = {}
+  ): Promise<string> {
+    return this.dispatch(() =>
+      automationsExperimentsExport({
+        client: this.client,
+        path: { id: automationId, experimentId },
+        query: { format: options.format ?? 'csv' },
+        parseAs: 'text',
+        signal: options.signal,
+      })
+    );
+  }
+
+  async exportAll(
+    automationId: string,
+    options: { format?: 'csv' | 'json'; signal?: AbortSignal } = {}
+  ): Promise<string> {
+    return this.dispatch(() =>
+      automationsExperimentsExportAll({
+        client: this.client,
+        path: { id: automationId },
+        query: { format: options.format ?? 'csv' },
+        parseAs: 'text',
+        signal: options.signal,
+      })
+    );
+  }
+
+  async createStream(
+    automationId: string,
+    body: Record<string, unknown> = {},
+    options: SignalOptions = {}
+  ): Promise<ReadableStream<Uint8Array> | null> {
+    return this.dispatch(
+      () =>
+        automationsExperimentsCreateStream({
+          client: this.client,
+          path: { id: automationId },
+          body: body as never,
+          parseAs: 'stream',
+          signal: options.signal,
+        }) as Promise<OperationResult<ReadableStream<Uint8Array> | null>>
     );
   }
 }

package/src/resources/files.ts

@@ -0,0 +1,51 @@
+import type { OperationResult } from '../client';
+import type { Client } from '../generated/client';
+import { filesContentGet, filesCreate, filesDelete, filesGet } from '../generated/sdk.gen';
+
+type Dispatch = <T>(call: () => Promise<OperationResult<T>>) => Promise<T>;
+type AnyResponse = any;
+type SignalOptions = { signal?: AbortSignal };
+
+export class FilesResource {
+  constructor(
+    private readonly client: Client,
+    private readonly dispatch: Dispatch
+  ) {}
+
+  async upload(file: Blob | File, options: SignalOptions = {}): Promise<AnyResponse> {
+    const form = new FormData();
+    form.append('file', file);
+    return this.dispatch(() =>
+      filesCreate({
+        client: this.client,
+        body: form as never,
+        bodySerializer: null,
+        headers: { 'Content-Type': null },
+        signal: options.signal,
+      })
+    );
+  }
+
+  async get(fileId: string, options: SignalOptions = {}): Promise<AnyResponse> {
+    return this.dispatch(() =>
+      filesGet({ client: this.client, path: { id: fileId }, signal: options.signal })
+    );
+  }
+
+  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>;
+    });
+  }
+
+  async delete(fileId: string, options: SignalOptions = {}): Promise<AnyResponse> {
+    return this.dispatch(() =>
+      filesDelete({ client: this.client, path: { id: fileId }, signal: options.signal })
+    );
+  }
+}