@eigenpal/sdk 0.7.2 → 0.9.0

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

package/src/resources/agents.ts

@@ -1,221 +0,0 @@
-import type { OperationResult } from '../client';
-import type { Client } from '../generated/client';
-import {
-  agentsCreate,
-  agentsFilesListOrGet,
-  agentsFilesPut,
-  agentsFilesUploadBatch,
-  agentsGet,
-  agentsList,
-  agentsTriggersEmailCreateAlias,
-  agentsTriggersEmailDeleteAlias,
-  agentsTriggersEmailGet,
-  agentsTriggersEmailList,
-  agentsTriggersEmailUpdate,
-  agentsTriggersEmailUpdateAlias,
-  agentsUpdate,
-  agentsVersionsList,
-} from '../generated/sdk.gen';
-import type {
-  AgentsTriggersEmailCreateAliasData,
-  AgentsTriggersEmailCreateAliasResponse,
-  AgentsTriggersEmailDeleteAliasResponse,
-  AgentsTriggersEmailGetResponse,
-  AgentsTriggersEmailListResponse,
-  AgentsTriggersEmailUpdateAliasData,
-  AgentsTriggersEmailUpdateAliasResponse,
-  AgentsTriggersEmailUpdateData,
-  AgentsTriggersEmailUpdateResponse,
-  CreateAgentBody,
-  CreateAgentResponse,
-  GetAgentResponse,
-  ListAgentVersionsResponse,
-  ListAgentsResponse,
-  PatchAgentBody,
-  PatchAgentResponse,
-} from '../generated/types.gen';
-
-type Dispatch = <T>(call: () => Promise<OperationResult<T>>) => Promise<T>;
-
-export interface ListAgentsOptions {
-  search?: string;
-  limit?: number;
-  offset?: number;
-  signal?: AbortSignal;
-}
-
-export class AgentEmailTriggersResource {
-  constructor(
-    private readonly client: Client,
-    private readonly dispatch: Dispatch
-  ) {}
-
-  async list(options: { signal?: AbortSignal } = {}): Promise<AgentsTriggersEmailListResponse> {
-    return this.dispatch(() =>
-      agentsTriggersEmailList({ client: this.client, signal: options.signal })
-    );
-  }
-
-  async get(
-    agentId: string,
-    options: { signal?: AbortSignal } = {}
-  ): Promise<AgentsTriggersEmailGetResponse> {
-    return this.dispatch(() =>
-      agentsTriggersEmailGet({
-        client: this.client,
-        path: { agentId },
-        signal: options.signal,
-      })
-    );
-  }
-
-  async update(
-    agentId: string,
-    body: AgentsTriggersEmailUpdateData['body'],
-    options: { signal?: AbortSignal } = {}
-  ): Promise<AgentsTriggersEmailUpdateResponse> {
-    return this.dispatch(() =>
-      agentsTriggersEmailUpdate({
-        client: this.client,
-        path: { agentId },
-        body,
-        signal: options.signal,
-      })
-    );
-  }
-
-  async createAlias(
-    agentId: string,
-    body: AgentsTriggersEmailCreateAliasData['body'],
-    options: { signal?: AbortSignal } = {}
-  ): Promise<AgentsTriggersEmailCreateAliasResponse> {
-    return this.dispatch(() =>
-      agentsTriggersEmailCreateAlias({
-        client: this.client,
-        path: { agentId },
-        body,
-        signal: options.signal,
-      })
-    );
-  }
-
-  async updateAlias(
-    agentId: string,
-    emailId: string,
-    body: AgentsTriggersEmailUpdateAliasData['body'],
-    options: { signal?: AbortSignal } = {}
-  ): Promise<AgentsTriggersEmailUpdateAliasResponse> {
-    return this.dispatch(() =>
-      agentsTriggersEmailUpdateAlias({
-        client: this.client,
-        path: { agentId, emailId },
-        body,
-        signal: options.signal,
-      })
-    );
-  }
-
-  async deleteAlias(
-    agentId: string,
-    emailId: string,
-    options: { signal?: AbortSignal } = {}
-  ): Promise<AgentsTriggersEmailDeleteAliasResponse> {
-    return this.dispatch(() =>
-      agentsTriggersEmailDeleteAlias({
-        client: this.client,
-        path: { agentId, emailId },
-        signal: options.signal,
-      })
-    );
-  }
-}
-
-export class AgentsResource {
-  public readonly emailTriggers: AgentEmailTriggersResource;
-
-  constructor(
-    private readonly client: Client,
-    private readonly dispatch: Dispatch
-  ) {
-    this.emailTriggers = new AgentEmailTriggersResource(client, dispatch);
-  }
-
-  async list(options: ListAgentsOptions = {}): Promise<ListAgentsResponse> {
-    const { signal, ...query } = options;
-    return this.dispatch(() => agentsList({ client: this.client, query, signal }));
-  }
-
-  async get(agentId: string, options: { signal?: AbortSignal } = {}): Promise<GetAgentResponse> {
-    return this.dispatch(() =>
-      agentsGet({ client: this.client, path: { agentId }, signal: options.signal })
-    );
-  }
-
-  async listFiles(
-    agentId: string,
-    options: { path?: string; prefix?: string; signal?: AbortSignal } = {}
-  ): Promise<unknown> {
-    const { signal, ...query } = options;
-    return this.dispatch(() =>
-      agentsFilesListOrGet({ client: this.client, path: { agentId }, query, signal })
-    );
-  }
-
-  async putFile(
-    agentId: string,
-    path: string,
-    body: Record<string, unknown>,
-    options: { signal?: AbortSignal } = {}
-  ): Promise<unknown> {
-    return this.dispatch(() =>
-      agentsFilesPut({
-        client: this.client,
-        path: { agentId },
-        query: { path },
-        body,
-        signal: options.signal,
-      })
-    );
-  }
-
-  async uploadFiles(
-    agentId: string,
-    body: Record<string, unknown>,
-    options: { signal?: AbortSignal } = {}
-  ): Promise<unknown> {
-    return this.dispatch(() =>
-      agentsFilesUploadBatch({
-        client: this.client,
-        path: { agentId },
-        body,
-        signal: options.signal,
-      })
-    );
-  }
-
-  async versions(
-    agentId: string,
-    options: { signal?: AbortSignal } = {}
-  ): Promise<ListAgentVersionsResponse> {
-    return this.dispatch(() =>
-      agentsVersionsList({ client: this.client, path: { agentId }, signal: options.signal })
-    );
-  }
-
-  async create(
-    body: CreateAgentBody,
-    options: { signal?: AbortSignal } = {}
-  ): Promise<CreateAgentResponse> {
-    return this.dispatch(() => agentsCreate({ client: this.client, body, signal: options.signal }));
-  }
-
-  async update(
-    agentId: string,
-    body: PatchAgentBody,
-    options: { signal?: AbortSignal } = {}
-  ): Promise<PatchAgentResponse> {
-    return this.dispatch(() =>
-      agentsUpdate({ client: this.client, path: { agentId }, body, signal: options.signal })
-    );
-  }
-}

package/src/resources/executions.ts

@@ -1,142 +0,0 @@
-import type { OperationResult } from '../client';
-import { EigenpalTimeoutError } from '../errors';
-import type { Client } from '../generated/client';
-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 {
-  /** Workflow version. Default: `"latest"`. */
-  version?: string;
-  /** Per-step output overrides for replay. */
-  overrides?: { steps?: Record<string, Record<string, unknown>> };
-  /** Polling interval in milliseconds. Default: 2_000. */
-  pollIntervalMs?: number;
-  /**
-   * Total client-side timeout in milliseconds. Default: 5 minutes. Throws
-   * `EigenpalTimeoutError` if the run hasn't reached a terminal state by then.
-   */
-  timeoutMs?: number;
-  /** AbortSignal to cancel the entire poll loop. */
-  signal?: AbortSignal;
-}
-
-export type WorkflowRunAndWaitResponse = {
-  id: string;
-  status?: ExecutionStatus;
-  output?: unknown;
-  error?: string;
-};
-
-const DEFAULT_POLL_INTERVAL_MS = 2_000;
-const DEFAULT_RUN_AND_WAIT_TIMEOUT_MS = 5 * 60 * 1000;
-
-type Dispatch = <T>(call: () => Promise<OperationResult<T>>) => Promise<T>;
-
-/**
- * Workflow execution helper namespace. Retrieval and mutation of existing runs
- * lives on `client.runs`; this namespace only keeps `runAndWait` because it
- * triggers a workflow before polling.
- */
-export class WorkflowExecutionsResource {
-  constructor(
-    private readonly client: Client,
-    private readonly dispatch: Dispatch
-  ) {}
-
-  /**
-   * Trigger a workflow and poll for completion client-side.
-   *
-   * Unlike `client.run(target, input, { 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`/`output`/`error` populated.
-   */
-  async runAndWait(
-    workflowId: string,
-    input?: WorkflowInput,
-    options: RunAndWaitOptions = {}
-  ): 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;
-
-    const target = `workflows.${workflowId}`;
-    const runUrl = '/api/v1/runs';
-    const runQuery =
-      options.version && options.version !== 'latest' ? { version: options.version } : undefined;
-    let runResult: { id: 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 buildRunMultipart({
-        target,
-        input,
-        overrides: options.overrides,
-      });
-      runResult = await this.dispatch<{ id: string }>(
-        () =>
-          this.client.post({
-            url: runUrl,
-            query: runQuery,
-            body: formData,
-            bodySerializer: null,
-            headers: { 'Content-Type': null },
-            signal: options.signal,
-          }) as Promise<OperationResult<{ id: string }>>
-      );
-    } else {
-      const body = buildRunJsonBody(target, input, options.overrides);
-      runResult = await this.dispatch<{ id: string }>(
-        () =>
-          this.client.post({
-            url: runUrl,
-            query: runQuery,
-            body,
-            signal: options.signal,
-          }) as Promise<OperationResult<{ id: string }>>
-      );
-    }
-
-    const runId = runResult.id;
-
-    while (true) {
-      if (options.signal?.aborted) {
-        throw new EigenpalTimeoutError('runAndWait aborted');
-      }
-      if (Date.now() >= deadline) {
-        throw new EigenpalTimeoutError(
-          `runAndWait timed out after ${timeoutMs}ms (runId=${runId})`
-        );
-      }
-
-      const run = (await this.dispatch<RunsGetResponse>(
-        () =>
-          runsGet({
-            client: this.client,
-            path: { id: runId },
-            query: { expand: 'execution' },
-            signal: options.signal,
-          }) as Promise<OperationResult<RunsGetResponse>>
-      )) as {
-        finished?: boolean;
-        output?: unknown;
-        error?: string | null;
-        execution?: { status?: ExecutionStatus | null } | null;
-      };
-
-      const status = run.execution?.status;
-      if (run.finished) {
-        return {
-          id: runId,
-          status: status ?? 'completed',
-          ...(run.output != null ? { output: run.output } : {}),
-          ...(run.error != null ? { error: run.error } : {}),
-        };
-      }
-
-      await new Promise((resolve) => setTimeout(resolve, pollInterval));
-    }
-  }
-}

package/src/resources/source.ts

@@ -1,101 +0,0 @@
-import type { OperationResult } from '../client';
-import type { Client } from '../generated/client';
-import {
-  sourceLockfilePreview,
-  sourceRaw,
-  sourceReleases,
-  sourceRepository,
-  sourceSecretsDecrypt,
-  sourceSecretsEncrypt,
-} from '../generated/sdk.gen';
-import type {
-  RawSourceResponse,
-  SourceLockfileResponse,
-  SourceReleasesResponse,
-  SourceRepositoryResponse,
-  SourceSecretsDecryptBody,
-  SourceSecretsDecryptResponse,
-  SourceSecretsEncryptBody,
-  SourceSecretsEncryptResponse,
-} from '../generated/types.gen';
-
-type Dispatch = <T>(call: () => Promise<OperationResult<T>>) => Promise<T>;
-
-export interface SourceRawOptions {
-  ref?: string;
-  signal?: AbortSignal;
-}
-
-export interface SourceReleasesOptions {
-  version?: string;
-  signal?: AbortSignal;
-}
-
-export class SourceResource {
-  constructor(
-    private readonly client: Client,
-    private readonly dispatch: Dispatch
-  ) {}
-
-  async repository(options: { signal?: AbortSignal } = {}): Promise<SourceRepositoryResponse> {
-    return this.dispatch(() => sourceRepository({ client: this.client, signal: options.signal }));
-  }
-
-  async raw(path: string, options: SourceRawOptions = {}): Promise<RawSourceResponse> {
-    const { signal, ref = 'main' } = options;
-    return this.dispatch(() => sourceRaw({ client: this.client, query: { path, ref }, signal }));
-  }
-
-  async releases(
-    packagePath: string,
-    options: SourceReleasesOptions = {}
-  ): Promise<SourceReleasesResponse> {
-    const { signal, version } = options;
-    return this.dispatch(() =>
-      sourceReleases({
-        client: this.client,
-        query: { packagePath, ...(version !== undefined ? { version } : {}) },
-        signal,
-      })
-    );
-  }
-
-  async lockfile(
-    packageRef: string,
-    options: { signal?: AbortSignal } = {}
-  ): Promise<SourceLockfileResponse> {
-    return this.dispatch(() =>
-      sourceLockfilePreview({
-        client: this.client,
-        query: { packageRef },
-        signal: options.signal,
-      })
-    );
-  }
-
-  async decryptSecrets(
-    body: SourceSecretsDecryptBody,
-    options: { signal?: AbortSignal } = {}
-  ): Promise<SourceSecretsDecryptResponse> {
-    return this.dispatch(() =>
-      sourceSecretsDecrypt({
-        client: this.client,
-        body,
-        signal: options.signal,
-      })
-    );
-  }
-
-  async encryptSecrets(
-    body: SourceSecretsEncryptBody,
-    options: { signal?: AbortSignal } = {}
-  ): Promise<SourceSecretsEncryptResponse> {
-    return this.dispatch(() =>
-      sourceSecretsEncrypt({
-        client: this.client,
-        body,
-        signal: options.signal,
-      })
-    );
-  }
-}

package/src/resources/workflows.ts

@@ -1,82 +0,0 @@
-import type { OperationResult } from '../client';
-import type { Client } from '../generated/client';
-import { workflowsGet, workflowsList, workflowsVersionsList } from '../generated/sdk.gen';
-import type {
-  ListVersionsResponse,
-  ListWorkflowsResponse,
-  WorkflowDetail,
-} from '../generated/types.gen';
-import { WorkflowExecutionsResource } from './executions';
-
-/**
- * Workflow inputs keyed by name as declared in the workflow YAML.
- *
- * File values (`File`, `Blob`, or `{ content, filename, mimeType }`) are
- * detected automatically and uploaded as `multipart/form-data` — same as
- * `curl -F`. No base64 round-trip required.
- */
-export type WorkflowInput = Record<string, unknown>;
-
-export interface ListWorkflowsOptions {
-  /** Substring match against workflow name. */
-  search?: string;
-  /** Exact-match by workflow name (slug). */
-  name?: string;
-  kind?: 'workflow' | 'block';
-  limit?: number;
-  offset?: number;
-  signal?: AbortSignal;
-}
-
-export interface ListVersionsOptions {
-  limit?: number;
-  offset?: number;
-  signal?: AbortSignal;
-}
-
-type Dispatch = <T>(call: () => Promise<OperationResult<T>>) => Promise<T>;
-
-/**
- * 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;
-
-  constructor(
-    private readonly client: Client,
-    private readonly dispatch: Dispatch
-  ) {
-    this.executions = new WorkflowExecutionsResource(client, dispatch);
-  }
-
-  /** List workflows, paginated. */
-  async list(options: ListWorkflowsOptions = {}): Promise<ListWorkflowsResponse> {
-    const { signal, ...query } = options;
-    return this.dispatch(() => workflowsList({ client: this.client, query, signal }));
-  }
-
-  /** Get a single workflow by id. Includes the current version's YAML. */
-  async get(workflowId: string, options: { signal?: AbortSignal } = {}): Promise<WorkflowDetail> {
-    return this.dispatch(() =>
-      workflowsGet({ client: this.client, path: { id: workflowId }, signal: options.signal })
-    );
-  }
-
-  /** List tagged versions for a workflow, paginated. */
-  async versions(
-    workflowId: string,
-    options: ListVersionsOptions = {}
-  ): Promise<ListVersionsResponse> {
-    const { signal, ...query } = options;
-    return this.dispatch(() =>
-      workflowsVersionsList({
-        client: this.client,
-        path: { id: workflowId },
-        query,
-        signal,
-      })
-    );
-  }
-}