@sealant/sdk-next 0.40.0-next.772 → 0.40.0-next.774

package/dist/client.d.ts

@@ -54,7 +54,7 @@ export declare class Sealant {
          * create that already committed answers `found` — stop that workspace instead.
          */
         cancelCreate: (idempotencyKey: string) => Promise<WorkspaceCreateState>;
-        list: (options?: ListOptions | undefined) => Promise<readonly Workspace[]>;
+        list: (options?: ListOptions) => Promise<readonly Workspace[]>;
     };
     /**
      * Inference on connected accounts — server-side via the official agent SDKs, never raw model-API

package/dist/effect/api-client.d.ts

@@ -4130,5 +4130,5 @@ declare const SealantApiClient_base: Context.ServiceClass<SealantApiClient, "@se
 export declare class SealantApiClient extends SealantApiClient_base {
 }
 /** Live layer: derives the client over the global-fetch `HttpClient`, with an optional bearer token. */
-export declare const sealantApiClientLayer: (config: SealantInternalConfig) => Layer.Layer<SealantApiClient, never, never>;
+export declare const sealantApiClientLayer: (config: SealantInternalConfig) => Layer.Layer<SealantApiClient>;
 export {};

package/dist/effect/exec-workspace.d.ts

@@ -4,4 +4,4 @@ import type { WorkspaceExecOptions, WorkspaceExecResult } from "../types.js";
 /** The wait before the next read, given the last wait and the time since the run was registered. */
 export declare const nextExecPollMs: (lastWaitMs: number | undefined, elapsedMs: number) => number;
 /** The `workspace.exec()` implementation (Promise boundary over the Effect above). */
-export declare const execWorkspace: (ctx: SdkContext, init: WorkspaceInit, argv: readonly string[], options?: WorkspaceExecOptions | undefined) => Promise<WorkspaceExecResult>;
+export declare const execWorkspace: (ctx: SdkContext, init: WorkspaceInit, argv: readonly string[], options?: WorkspaceExecOptions) => Promise<WorkspaceExecResult>;

package/dist/effect/operations.d.ts

@@ -1,39 +1,13 @@
+/**
+ * Effect operations over the derived control-plane client. Thin: each yields the client and calls one
+ * contract endpoint, returning the WIRE type. The facade maps wire -> public types and the runtime
+ * maps the typed Effect failure -> a plain `SealantError`. Keeping these here (rather than inline in
+ * the facade) keeps the wire surface in one place and unit-testable.
+ */
+import type { ApplyWorkspaceDotfilesRequest, BindWorkspaceRequest, CancelWorkspaceCreateRequest, FlushWorkspaceCaptureRequest, GetWorkspaceCaptureStatusQuery, CloseSessionRequest, CreateAccessTokenRequest, ConnectedAccountProvider, CreateConnectedAccountRequest, CreateSshKeyRequest, EnsureUserRequest, PersonBindingWire, CreateRunRequest, CreateSessionAsUserRequest, CreateSessionRequest, CreateWorkspaceRequest, ExecWorkspaceAsUserRequest, ExecWorkspaceRequest, ExpireWorkspaceRequest, ClearWorkspaceSshUserQuery, GetRunScrollbackQuery, GetRunTimelineQuery, GetSessionOutputQuery, InferenceRespondRequest, ListResourceDomainMembersQuery, ResourceDomainBudgetLimits, SetResourceDomainBudgetRequest, ListRunsQuery, ListSessionsQuery, ListWorkspacesQuery, MarkConnectedAccountInvalidRequest, ReplanWorkspaceCaptureRequest, RecoverWorkspaceRequest, RestartWorkspaceRequest, SessionInputRequest, InspectWorkspaceImageRequest, PutWorkspaceCredentialsRequest, ResourceDomainMemberDecisionRequest, PruneWorkspaceCredentialsRequest, ReleaseWorkspaceCredentialsQuery, ListWorkspaceCredentialsQuery, SessionResizeRequest, SessionSignalRequest, SetConnectedAccountDefaultRequest, StopWorkspaceRequest, UpdateRunRequest } from "@sealant/api-contracts";
 import { Effect } from "effect";
 import { SealantApiClient } from "./api-client.js";
-export declare const createWorkspaceOp: (payload: {
-    readonly ownerUserId: string;
-    readonly registryId: string;
-    readonly repository: string;
-    readonly tag: string;
-    readonly name?: string | undefined;
-    readonly sourceSelection?: {
-        readonly provider: "github";
-        readonly installationId: string;
-        readonly installationRepositoryId: string;
-        readonly ref?: string | undefined;
-    } | undefined;
-    readonly dotfilesSelection?: {
-        readonly provider: "github";
-        readonly installationId: string;
-        readonly installationRepositoryId: string;
-        readonly ref?: string | undefined;
-    } | undefined;
-    readonly credentials?: {
-        readonly profileId?: string | undefined;
-        readonly claude?: string | undefined;
-        readonly codex?: string | undefined;
-        readonly github?: string | undefined;
-    } | undefined;
-    readonly spec: unknown;
-    readonly secretEnv?: {
-        readonly [x: string]: string;
-    } | undefined;
-    readonly captureToken?: string | undefined;
-    readonly ttlSeconds?: number | undefined;
-    readonly idempotencyKey?: string | undefined;
-    readonly launchId?: string | undefined;
-    readonly sshAsOwner?: boolean | undefined;
-}, idempotencyKey?: string | undefined) => Effect.Effect<{
+export declare const createWorkspaceOp: (payload: CreateWorkspaceRequest, idempotencyKey?: string) => Effect.Effect<{
     readonly workspaceId: string;
     readonly name: string;
     readonly status: "cancelled" | "failed" | "queued" | "ready" | "retained" | "running" | "stopped";
@@ -54,7 +28,7 @@ export declare const createWorkspaceOp: (payload: {
     readonly replayed?: boolean | undefined;
     readonly launchId?: string | undefined;
 }, import("@sealant/api-contracts").BudgetExceededError | import("effect/http/HttpClientError").HttpClientError | import("@sealant/api-contracts").RequestRefusedError | import("effect/Schema").SchemaError | import("@sealant/api-contracts").WorkspaceBadGatewayError | import("@sealant/api-contracts").WorkspaceBadRequestError | import("@sealant/api-contracts").WorkspaceConflictError | import("@sealant/api-contracts").WorkspaceDockerServiceUnsupportedError | import("@sealant/api-contracts").WorkspaceForbiddenError | import("@sealant/api-contracts").WorkspaceInternalServerError | import("@sealant/api-contracts").WorkspaceNotFoundError | import("@sealant/api-contracts").WorkspaceRuntimeEnvReferencesUnsupportedError | import("@sealant/api-contracts").WorkspaceServiceUnavailableError | import("@sealant/api-contracts").WorkspaceSshOwnerRefusedError, SealantApiClient>;
-export declare const getWorkspaceOp: (workspaceId: string, ownerUserId?: string | undefined) => Effect.Effect<{
+export declare const getWorkspaceOp: (workspaceId: string, ownerUserId?: string) => Effect.Effect<{
     readonly workspaceId: string;
     readonly name: string;
     readonly ownerUserId: string;
@@ -155,21 +129,14 @@ export declare const getWorkspaceCreateOp: (idempotencyKey: string, ownerUserId:
     readonly runId?: string | undefined;
     readonly launchId?: string | undefined;
 }, import("effect/http/HttpClientError").HttpClientError | import("@sealant/api-contracts").RequestRefusedError | import("effect/Schema").SchemaError | import("@sealant/api-contracts").WorkspaceBadRequestError | import("@sealant/api-contracts").WorkspaceInternalServerError, SealantApiClient>;
-export declare const cancelWorkspaceCreateOp: (idempotencyKey: string, payload: {
-    readonly ownerUserId: string;
-}) => Effect.Effect<{
+export declare const cancelWorkspaceCreateOp: (idempotencyKey: string, payload: CancelWorkspaceCreateRequest) => Effect.Effect<{
     readonly idempotencyKey: string;
     readonly state: "cancelled" | "found" | "none" | "pending";
     readonly workspaceId?: string | undefined;
     readonly runId?: string | undefined;
     readonly launchId?: string | undefined;
 }, import("effect/http/HttpClientError").HttpClientError | import("@sealant/api-contracts").RequestRefusedError | import("effect/Schema").SchemaError | import("@sealant/api-contracts").WorkspaceBadRequestError | import("@sealant/api-contracts").WorkspaceInternalServerError, SealantApiClient>;
-export declare const listWorkspacesOp: (query: {
-    readonly ownerUserId: string;
-    readonly status?: "cancelled" | "failed" | "queued" | "ready" | "retained" | "running" | "stopped" | undefined;
-    readonly limit?: string | undefined;
-    readonly idempotencyKey?: string | undefined;
-}) => Effect.Effect<{
+export declare const listWorkspacesOp: (query: ListWorkspacesQuery) => Effect.Effect<{
     readonly items: readonly {
         readonly workspaceId: string;
         readonly name: string;
@@ -223,15 +190,7 @@ export declare const listWorkspacesOp: (query: {
         readonly expiresAt?: string | undefined;
     }[];
 }, import("effect/http/HttpClientError").HttpClientError | import("@sealant/api-contracts").RequestRefusedError | import("effect/Schema").SchemaError | import("@sealant/api-contracts").WorkspaceBadRequestError | import("@sealant/api-contracts").WorkspaceInternalServerError, SealantApiClient>;
-export declare const execWorkspaceOp: (workspaceId: string, payload: {
-    readonly ownerUserId: string;
-    readonly commands: readonly {
-        readonly executable: string;
-        readonly args: readonly string[];
-        readonly cwd?: string | undefined;
-    }[];
-    readonly user?: string | undefined;
-}) => Effect.Effect<{
+export declare const execWorkspaceOp: (workspaceId: string, payload: ExecWorkspaceRequest) => Effect.Effect<{
     readonly runId: string;
     readonly workspaceId: string;
     readonly attemptId?: string | undefined;
@@ -260,15 +219,7 @@ export declare const execWorkspaceOp: (workspaceId: string, payload: {
     readonly updatedAt: string;
 }, import("effect/http/HttpClientError").HttpClientError | import("@sealant/api-contracts").RequestRefusedError | import("effect/Schema").SchemaError | import("@sealant/api-contracts").WorkspaceBadGatewayError | import("@sealant/api-contracts").WorkspaceBadRequestError | import("@sealant/api-contracts").WorkspaceConflictError | import("@sealant/api-contracts").WorkspaceInternalServerError | import("@sealant/api-contracts").WorkspaceNotFoundError, SealantApiClient>;
 /** An exec as a Linux user: its own route, which a control plane that cannot run one answers 404. */
-export declare const execWorkspaceAsUserOp: (workspaceId: string, payload: {
-    readonly ownerUserId: string;
-    readonly commands: readonly {
-        readonly executable: string;
-        readonly args: readonly string[];
-        readonly cwd?: string | undefined;
-    }[];
-    readonly user: string;
-}) => Effect.Effect<{
+export declare const execWorkspaceAsUserOp: (workspaceId: string, payload: ExecWorkspaceAsUserRequest) => Effect.Effect<{
     readonly runId: string;
     readonly workspaceId: string;
     readonly attemptId?: string | undefined;
@@ -296,26 +247,7 @@ export declare const execWorkspaceAsUserOp: (workspaceId: string, payload: {
     readonly createdAt: string;
     readonly updatedAt: string;
 }, import("effect/http/HttpClientError").HttpClientError | import("@sealant/api-contracts").RequestRefusedError | import("effect/Schema").SchemaError | import("@sealant/api-contracts").WorkspaceBadGatewayError | import("@sealant/api-contracts").WorkspaceBadRequestError | import("@sealant/api-contracts").WorkspaceConflictError | import("@sealant/api-contracts").WorkspaceInternalServerError | import("@sealant/api-contracts").WorkspaceNotFoundError, SealantApiClient>;
-export declare const applyWorkspaceDotfilesOp: (workspaceId: string, payload: {
-    readonly ownerUserId: string;
-    readonly onBehalfOfUserId: string;
-    readonly user: string;
-    readonly home: string;
-    readonly repository?: {
-        readonly url: string;
-        readonly ref?: string | undefined;
-        readonly manager?: "auto" | "chezmoi" | "copy" | "stow" | undefined;
-        readonly bootstrap?: boolean | undefined;
-        readonly bootstrapCommand?: string | undefined;
-    } | undefined;
-    readonly archives?: readonly {
-        readonly data: string;
-        readonly manager?: "auto" | "chezmoi" | "copy" | "stow" | undefined;
-        readonly target?: "config" | "home" | undefined;
-        readonly bootstrap?: boolean | undefined;
-        readonly bootstrapCommand?: string | undefined;
-    }[] | undefined;
-}) => Effect.Effect<{
+export declare const applyWorkspaceDotfilesOp: (workspaceId: string, payload: ApplyWorkspaceDotfilesRequest) => Effect.Effect<{
     readonly runId: string;
     readonly workspaceId: string;
     readonly attemptId?: string | undefined;
@@ -343,22 +275,13 @@ export declare const applyWorkspaceDotfilesOp: (workspaceId: string, payload: {
     readonly createdAt: string;
     readonly updatedAt: string;
 }, import("effect/http/HttpClientError").HttpClientError | import("@sealant/api-contracts").RequestRefusedError | import("effect/Schema").SchemaError | import("@sealant/api-contracts").WorkspaceBadGatewayError | import("@sealant/api-contracts").WorkspaceBadRequestError | import("@sealant/api-contracts").WorkspaceConflictError | import("@sealant/api-contracts").WorkspaceForbiddenError | import("@sealant/api-contracts").WorkspaceInternalServerError | import("@sealant/api-contracts").WorkspaceNotFoundError | import("@sealant/api-contracts").WorkspaceServiceUnavailableError, SealantApiClient>;
-export declare const bindWorkspaceOp: (workspaceId: string, payload: {
-    readonly ownerUserId: string;
-    readonly mountPath?: string | undefined;
-    readonly subpath: string;
-}) => Effect.Effect<{
+export declare const bindWorkspaceOp: (workspaceId: string, payload: BindWorkspaceRequest) => Effect.Effect<{
     readonly binds: readonly {
         readonly mountPath: string;
         readonly subpath: string;
     }[];
 }, import("effect/http/HttpClientError").HttpClientError | import("@sealant/api-contracts").RequestRefusedError | import("effect/Schema").SchemaError | import("@sealant/api-contracts").WorkspaceBadRequestError | import("@sealant/api-contracts").WorkspaceConflictError | import("@sealant/api-contracts").WorkspaceInternalServerError | import("@sealant/api-contracts").WorkspaceNotFoundError, SealantApiClient>;
-export declare const flushWorkspaceCaptureOp: (workspaceId: string, payload: {
-    readonly ownerUserId: string;
-    readonly kind?: "final" | "suspend" | undefined;
-    readonly deadlineMs?: number | undefined;
-    readonly graceMs?: number | undefined;
-}) => Effect.Effect<{
+export declare const flushWorkspaceCaptureOp: (workspaceId: string, payload: FlushWorkspaceCaptureRequest) => Effect.Effect<{
     readonly epoch: number;
     readonly worktreeId: string;
     readonly headN?: number | undefined;
@@ -409,9 +332,7 @@ export declare const flushWorkspaceCaptureOp: (workspaceId: string, payload: {
     } | undefined;
     readonly ownerMap?: boolean | undefined;
 }, import("effect/http/HttpClientError").HttpClientError | import("@sealant/api-contracts").RequestRefusedError | import("effect/Schema").SchemaError | import("@sealant/api-contracts").WorkspaceBadRequestError | import("@sealant/api-contracts").WorkspaceConflictError | import("@sealant/api-contracts").WorkspaceInternalServerError | import("@sealant/api-contracts").WorkspaceNotFoundError, SealantApiClient>;
-export declare const getWorkspaceCaptureStatusOp: (workspaceId: string, query: {
-    readonly ownerUserId: string;
-}) => Effect.Effect<{
+export declare const getWorkspaceCaptureStatusOp: (workspaceId: string, query: GetWorkspaceCaptureStatusQuery) => Effect.Effect<{
     readonly epoch: number;
     readonly worktreeId: string;
     readonly headN?: number | undefined;
@@ -462,17 +383,7 @@ export declare const getWorkspaceCaptureStatusOp: (workspaceId: string, query: {
     } | undefined;
     readonly ownerMap?: boolean | undefined;
 }, import("effect/http/HttpClientError").HttpClientError | import("@sealant/api-contracts").RequestRefusedError | import("effect/Schema").SchemaError | import("@sealant/api-contracts").WorkspaceBadRequestError | import("@sealant/api-contracts").WorkspaceConflictError | import("@sealant/api-contracts").WorkspaceInternalServerError | import("@sealant/api-contracts").WorkspaceNotFoundError, SealantApiClient>;
-export declare const replanWorkspaceCaptureOp: (workspaceId: string, payload: {
-    readonly ownerUserId: string;
-    readonly expectedOwnerMap?: {
-        readonly gid: number;
-        readonly worktreeUid: number;
-        readonly people: readonly {
-            readonly id: string;
-            readonly uid: number;
-        }[];
-    } | null | undefined;
-}) => Effect.Effect<{
+export declare const replanWorkspaceCaptureOp: (workspaceId: string, payload: ReplanWorkspaceCaptureRequest) => Effect.Effect<{
     readonly worktreeId: string;
     readonly epoch: number;
     readonly headN?: number | undefined;
@@ -484,25 +395,7 @@ export declare const replanWorkspaceCaptureOp: (workspaceId: string, payload: {
     readonly removed: number;
     readonly unchanged: boolean;
 }, import("effect/http/HttpClientError").HttpClientError | import("@sealant/api-contracts").RequestRefusedError | import("effect/Schema").SchemaError | import("@sealant/api-contracts").WorkspaceBadRequestError | import("@sealant/api-contracts").WorkspaceConflictError | import("@sealant/api-contracts").WorkspaceInternalServerError | import("@sealant/api-contracts").WorkspaceNotFoundError, SealantApiClient>;
-export declare const stopWorkspaceOp: (workspaceId: string, payload: {
-    readonly ownerUserId: string;
-    readonly discardUnsaved?: boolean | undefined;
-    readonly completion?: {
-        readonly captureN: number;
-        readonly epoch: number;
-        readonly executorId: string;
-        readonly launchId?: string | undefined;
-        readonly sealedAt?: string | undefined;
-        readonly origin?: {
-            readonly epoch: number;
-            readonly launch: string;
-            readonly bootId: string;
-            readonly bootGeneration: number;
-            readonly observation: number;
-            readonly headN?: number | undefined;
-        } | undefined;
-    } | undefined;
-}) => Effect.Effect<{
+export declare const stopWorkspaceOp: (workspaceId: string, payload: StopWorkspaceRequest) => Effect.Effect<{
     readonly workspaceId: string;
     readonly status: "cancelled" | "failed" | "queued" | "ready" | "retained" | "running" | "stopped";
     readonly completion?: {
@@ -510,25 +403,17 @@ export declare const stopWorkspaceOp: (workspaceId: string, payload: {
         readonly detail?: string | undefined;
     } | undefined;
 }, import("effect/http/HttpClientError").HttpClientError | import("@sealant/api-contracts").RequestRefusedError | import("effect/Schema").SchemaError | import("@sealant/api-contracts").WorkspaceBadGatewayError | import("@sealant/api-contracts").WorkspaceBadRequestError | import("@sealant/api-contracts").WorkspaceConflictError | import("@sealant/api-contracts").WorkspaceInternalServerError | import("@sealant/api-contracts").WorkspaceNotFoundError, SealantApiClient>;
-export declare const recoverWorkspaceOp: (workspaceId: string, payload: {
-    readonly ownerUserId: string;
-}) => Effect.Effect<{
+export declare const recoverWorkspaceOp: (workspaceId: string, payload: RecoverWorkspaceRequest) => Effect.Effect<{
     readonly workspaceId: string;
     readonly state: "not-retained" | "requested";
     readonly recoverable?: boolean | undefined;
 }, import("effect/http/HttpClientError").HttpClientError | import("@sealant/api-contracts").RequestRefusedError | import("effect/Schema").SchemaError | import("@sealant/api-contracts").WorkspaceBadRequestError | import("@sealant/api-contracts").WorkspaceConflictError | import("@sealant/api-contracts").WorkspaceInternalServerError | import("@sealant/api-contracts").WorkspaceNotFoundError, SealantApiClient>;
-export declare const restartWorkspaceOp: (workspaceId: string, payload: {
-    readonly ownerUserId: string;
-}) => Effect.Effect<{
+export declare const restartWorkspaceOp: (workspaceId: string, payload: RestartWorkspaceRequest) => Effect.Effect<{
     readonly workspaceId: string;
     readonly runId: string;
     readonly status: "cancelled" | "failed" | "queued" | "ready" | "retained" | "running" | "stopped";
 }, import("@sealant/api-contracts").BudgetExceededError | import("effect/http/HttpClientError").HttpClientError | import("@sealant/api-contracts").RequestRefusedError | import("effect/Schema").SchemaError | import("@sealant/api-contracts").WorkspaceBadGatewayError | import("@sealant/api-contracts").WorkspaceBadRequestError | import("@sealant/api-contracts").WorkspaceConflictError | import("@sealant/api-contracts").WorkspaceInternalServerError | import("@sealant/api-contracts").WorkspaceNotFoundError, SealantApiClient>;
-export declare const inspectWorkspaceImageOp: (payload: {
-    readonly ownerUserId: string;
-    readonly registryId: string;
-    readonly spec: unknown;
-}) => Effect.Effect<{
+export declare const inspectWorkspaceImageOp: (payload: InspectWorkspaceImageRequest) => Effect.Effect<{
     readonly planHash: string;
     readonly publishedImage?: {
         readonly reference: string;
@@ -550,20 +435,7 @@ export declare const inspectWorkspaceImageOp: (payload: {
         readonly acl: "supported" | "unknown" | "unsupported";
     };
 }, import("effect/http/HttpClientError").HttpClientError | import("@sealant/api-contracts").RequestRefusedError | import("effect/Schema").SchemaError | import("@sealant/api-contracts").WorkspaceBadRequestError | import("@sealant/api-contracts").WorkspaceInternalServerError | import("@sealant/api-contracts").WorkspaceNotFoundError, SealantApiClient>;
-export declare const putWorkspaceCredentialsOp: (workspaceId: string, payload: {
-    readonly ownerUserId: string;
-    readonly onBehalfOfUserId: string;
-    readonly home: string;
-    readonly uid?: number | undefined;
-    readonly gid?: number | undefined;
-    readonly claude?: string | null | undefined;
-    readonly codex?: string | null | undefined;
-    readonly github?: string | null | undefined;
-    readonly pi?: string | null | undefined;
-    readonly opencode?: string | null | undefined;
-    readonly partial?: boolean | undefined;
-    readonly live?: readonly string[] | undefined;
-}) => Effect.Effect<{
+export declare const putWorkspaceCredentialsOp: (workspaceId: string, payload: PutWorkspaceCredentialsRequest) => Effect.Effect<{
     readonly workspaceId: string;
     readonly runId: string;
     readonly home: {
@@ -613,11 +485,7 @@ export declare const putWorkspaceCredentialsOp: (workspaceId: string, payload: {
     }[] | undefined;
 }, import("effect/http/HttpClientError").HttpClientError | import("@sealant/api-contracts").RequestRefusedError | import("effect/Schema").SchemaError | import("@sealant/api-contracts").WorkspaceBadGatewayError | import("@sealant/api-contracts").WorkspaceBadRequestError | import("@sealant/api-contracts").WorkspaceConflictError | import("@sealant/api-contracts").WorkspaceForbiddenError | import("@sealant/api-contracts").WorkspaceInternalServerError | import("@sealant/api-contracts").WorkspaceNotFoundError | import("@sealant/api-contracts").WorkspaceServiceUnavailableError, SealantApiClient>;
 /** Remove unused credential placements in one home. */
-export declare const pruneWorkspaceCredentialsOp: (workspaceId: string, payload: {
-    readonly ownerUserId: string;
-    readonly home: string;
-    readonly live: readonly string[];
-}) => Effect.Effect<{
+export declare const pruneWorkspaceCredentialsOp: (workspaceId: string, payload: PruneWorkspaceCredentialsRequest) => Effect.Effect<{
     readonly workspaceId: string;
     readonly runId: string;
     readonly home?: {
@@ -661,18 +529,13 @@ export declare const pruneWorkspaceCredentialsOp: (workspaceId: string, payload:
         };
     } | undefined;
 }, import("effect/http/HttpClientError").HttpClientError | import("@sealant/api-contracts").RequestRefusedError | import("effect/Schema").SchemaError | import("@sealant/api-contracts").WorkspaceBadGatewayError | import("@sealant/api-contracts").WorkspaceBadRequestError | import("@sealant/api-contracts").WorkspaceConflictError | import("@sealant/api-contracts").WorkspaceForbiddenError | import("@sealant/api-contracts").WorkspaceInternalServerError | import("@sealant/api-contracts").WorkspaceNotFoundError | import("@sealant/api-contracts").WorkspaceServiceUnavailableError, SealantApiClient>;
-export declare const releaseWorkspaceCredentialsOp: (workspaceId: string, query: {
-    readonly ownerUserId: string;
-    readonly home: string;
-}) => Effect.Effect<{
+export declare const releaseWorkspaceCredentialsOp: (workspaceId: string, query: ReleaseWorkspaceCredentialsQuery) => Effect.Effect<{
     readonly workspaceId: string;
     readonly runId: string;
     readonly home: string;
     readonly released: boolean;
 }, import("effect/http/HttpClientError").HttpClientError | import("@sealant/api-contracts").RequestRefusedError | import("effect/Schema").SchemaError | import("@sealant/api-contracts").WorkspaceBadGatewayError | import("@sealant/api-contracts").WorkspaceBadRequestError | import("@sealant/api-contracts").WorkspaceConflictError | import("@sealant/api-contracts").WorkspaceForbiddenError | import("@sealant/api-contracts").WorkspaceInternalServerError | import("@sealant/api-contracts").WorkspaceNotFoundError | import("@sealant/api-contracts").WorkspaceServiceUnavailableError, SealantApiClient>;
-export declare const listWorkspaceCredentialsOp: (workspaceId: string, query: {
-    readonly ownerUserId: string;
-}) => Effect.Effect<{
+export declare const listWorkspaceCredentialsOp: (workspaceId: string, query: ListWorkspaceCredentialsQuery) => Effect.Effect<{
     readonly workspaceId: string;
     readonly runId: string;
     readonly homes: readonly {
@@ -716,35 +579,15 @@ export declare const listWorkspaceCredentialsOp: (workspaceId: string, query: {
         };
     }[];
 }, import("effect/http/HttpClientError").HttpClientError | import("@sealant/api-contracts").RequestRefusedError | import("effect/Schema").SchemaError | import("@sealant/api-contracts").WorkspaceConflictError | import("@sealant/api-contracts").WorkspaceForbiddenError | import("@sealant/api-contracts").WorkspaceInternalServerError | import("@sealant/api-contracts").WorkspaceNotFoundError, SealantApiClient>;
-export declare const expireWorkspaceOp: (workspaceId: string, payload: {
-    readonly ownerUserId: string;
-    readonly ttlSeconds?: number | null | undefined;
-}) => Effect.Effect<{
+export declare const expireWorkspaceOp: (workspaceId: string, payload: ExpireWorkspaceRequest) => Effect.Effect<{
     readonly workspaceId: string;
     readonly expiresAt: string | null;
 }, import("effect/http/HttpClientError").HttpClientError | import("@sealant/api-contracts").RequestRefusedError | import("effect/Schema").SchemaError | import("@sealant/api-contracts").WorkspaceBadRequestError | import("@sealant/api-contracts").WorkspaceInternalServerError | import("@sealant/api-contracts").WorkspaceNotFoundError, SealantApiClient>;
-export declare const clearWorkspaceSshUserOp: (workspaceId: string, query: {
-    readonly ownerUserId?: string | undefined;
-}) => Effect.Effect<{
+export declare const clearWorkspaceSshUserOp: (workspaceId: string, query: ClearWorkspaceSshUserQuery) => Effect.Effect<{
     readonly workspaceId: string;
     readonly sshUser: null;
 }, import("effect/http/HttpClientError").HttpClientError | import("@sealant/api-contracts").RequestRefusedError | import("effect/Schema").SchemaError | import("@sealant/api-contracts").WorkspaceInternalServerError | import("@sealant/api-contracts").WorkspaceNotFoundError, SealantApiClient>;
-export declare const createRunOp: (payload: {
-    readonly workspaceId: string;
-    readonly harnessId: string;
-    readonly ownerUserId: string;
-    readonly mode?: "interactive" | "one-shot" | undefined;
-    readonly prompt?: string | undefined;
-    readonly attemptId?: string | undefined;
-    readonly command?: {
-        readonly executable: string;
-        readonly args: readonly string[];
-        readonly cwd?: string | undefined;
-    } | undefined;
-    readonly metadata?: {
-        readonly [x: string]: unknown;
-    } | undefined;
-}) => Effect.Effect<{
+export declare const createRunOp: (payload: CreateRunRequest) => Effect.Effect<{
     readonly runId: string;
     readonly workspaceId: string;
     readonly attemptId?: string | undefined;
@@ -772,7 +615,7 @@ export declare const createRunOp: (payload: {
     readonly createdAt: string;
     readonly updatedAt: string;
 }, import("@sealant/api-contracts").BudgetExceededError | import("effect/http/HttpClientError").HttpClientError | import("@sealant/api-contracts").RequestRefusedError | import("@sealant/api-contracts").RunBadRequestError | import("@sealant/api-contracts").RunInternalServerError | import("@sealant/api-contracts").RunNotFoundError | import("effect/Schema").SchemaError, SealantApiClient>;
-export declare const getRunOp: (runId: string, ownerUserId?: string | undefined) => Effect.Effect<{
+export declare const getRunOp: (runId: string, ownerUserId?: string) => Effect.Effect<{
     readonly runId: string;
     readonly workspaceId: string;
     readonly attemptId?: string | undefined;
@@ -800,12 +643,7 @@ export declare const getRunOp: (runId: string, ownerUserId?: string | undefined)
     readonly createdAt: string;
     readonly updatedAt: string;
 }, import("@sealant/api-contracts").BudgetExceededError | import("effect/http/HttpClientError").HttpClientError | import("@sealant/api-contracts").RequestRefusedError | import("@sealant/api-contracts").RunInternalServerError | import("@sealant/api-contracts").RunNotFoundError | import("effect/Schema").SchemaError, SealantApiClient>;
-export declare const listRunsOp: (query: {
-    readonly workspaceId?: string | undefined;
-    readonly ownerUserId?: string | undefined;
-    readonly status?: "cancelled" | "completed" | "failed" | "queued" | "running" | undefined;
-    readonly limit?: string | undefined;
-}) => Effect.Effect<{
+export declare const listRunsOp: (query: ListRunsQuery) => Effect.Effect<{
     readonly items: readonly {
         readonly runId: string;
         readonly workspaceId: string;
@@ -835,19 +673,7 @@ export declare const listRunsOp: (query: {
         readonly updatedAt: string;
     }[];
 }, import("effect/http/HttpClientError").HttpClientError | import("@sealant/api-contracts").RequestRefusedError | import("@sealant/api-contracts").RunBadRequestError | import("@sealant/api-contracts").RunInternalServerError | import("effect/Schema").SchemaError, SealantApiClient>;
-export declare const updateRunOp: (runId: string, payload: {
-    readonly ownerUserId?: string | undefined;
-    readonly status?: "cancelled" | "completed" | "failed" | "queued" | "running" | undefined;
-    readonly exitCode?: number | undefined;
-    readonly errorMessage?: string | undefined;
-    readonly diff?: string | undefined;
-    readonly changedFiles?: readonly {
-        readonly path: string;
-        readonly change: "added" | "deleted" | "modified" | "renamed";
-        readonly oldPath?: string | undefined;
-    }[] | undefined;
-    readonly changesReadFailed?: boolean | undefined;
-}) => Effect.Effect<{
+export declare const updateRunOp: (runId: string, payload: UpdateRunRequest) => Effect.Effect<{
     readonly runId: string;
     readonly workspaceId: string;
     readonly attemptId?: string | undefined;
@@ -875,13 +701,7 @@ export declare const updateRunOp: (runId: string, payload: {
     readonly createdAt: string;
     readonly updatedAt: string;
 }, import("effect/http/HttpClientError").HttpClientError | import("@sealant/api-contracts").RequestRefusedError | import("@sealant/api-contracts").RunBadRequestError | import("@sealant/api-contracts").RunInternalServerError | import("@sealant/api-contracts").RunNotFoundError | import("effect/Schema").SchemaError, SealantApiClient>;
-export declare const getRunTimelineOp: (runId: string, query: {
-    readonly ownerUserId?: string | undefined;
-    readonly fromSequence?: string | undefined;
-    readonly toSequence?: string | undefined;
-    readonly limit?: string | undefined;
-    readonly kinds?: string | undefined;
-}) => Effect.Effect<readonly {
+export declare const getRunTimelineOp: (runId: string, query: GetRunTimelineQuery) => Effect.Effect<readonly {
     readonly eventId: string;
     readonly sequence: string;
     readonly kind: string;
@@ -892,20 +712,13 @@ export declare const getRunTimelineOp: (runId: string, query: {
     readonly captureMethod: number;
     readonly confidence: number;
 }[], import("effect/http/HttpClientError").HttpClientError | import("@sealant/api-contracts").RequestRefusedError | import("@sealant/api-contracts").RunBadRequestError | import("@sealant/api-contracts").RunInternalServerError | import("@sealant/api-contracts").RunNotFoundError | import("effect/Schema").SchemaError, SealantApiClient>;
-export declare const getRunScrollbackOp: (runId: string, query: {
-    readonly ownerUserId?: string | undefined;
-    readonly processId: string;
-    readonly stream: "pty" | "stderr" | "stdout";
-    readonly atSequence?: string | undefined;
-    readonly fromSequence?: string | undefined;
-    readonly limit?: string | undefined;
-}) => Effect.Effect<{
+export declare const getRunScrollbackOp: (runId: string, query: GetRunScrollbackQuery) => Effect.Effect<{
     readonly processId: string;
     readonly stream: "pty" | "stderr" | "stdout";
     readonly byteCount: number;
     readonly contentBase64: string;
 }, import("effect/http/HttpClientError").HttpClientError | import("@sealant/api-contracts").RequestRefusedError | import("@sealant/api-contracts").RunBadRequestError | import("@sealant/api-contracts").RunInternalServerError | import("@sealant/api-contracts").RunNotFoundError | import("effect/Schema").SchemaError, SealantApiClient>;
-export declare const getRunLossOp: (runId: string, ownerUserId?: string | undefined) => Effect.Effect<{
+export declare const getRunLossOp: (runId: string, ownerUserId?: string) => Effect.Effect<{
     readonly runId: string;
     readonly droppedEventCount: string;
     readonly sequenceGapCount: number;
@@ -920,7 +733,7 @@ export declare const getRunLossOp: (runId: string, ownerUserId?: string | undefi
         readonly reason?: string | undefined;
     }[];
 }, import("effect/http/HttpClientError").HttpClientError | import("@sealant/api-contracts").RequestRefusedError | import("@sealant/api-contracts").RunInternalServerError | import("@sealant/api-contracts").RunNotFoundError | import("effect/Schema").SchemaError, SealantApiClient>;
-export declare const getRunChangesOp: (runId: string, ownerUserId?: string | undefined) => Effect.Effect<{
+export declare const getRunChangesOp: (runId: string, ownerUserId?: string) => Effect.Effect<{
     readonly files: readonly {
         readonly path: string;
         readonly change: "added" | "deleted" | "modified" | "renamed";
@@ -930,23 +743,7 @@ export declare const getRunChangesOp: (runId: string, ownerUserId?: string | und
     readonly available?: boolean | undefined;
     readonly unavailableReason?: string | undefined;
 }, import("effect/http/HttpClientError").HttpClientError | import("@sealant/api-contracts").RequestRefusedError | import("@sealant/api-contracts").RunInternalServerError | import("@sealant/api-contracts").RunNotFoundError | import("effect/Schema").SchemaError, SealantApiClient>;
-export declare const createSessionOp: (payload: {
-    readonly workspaceId: string;
-    readonly ownerUserId: string;
-    readonly argv: readonly string[];
-    readonly cwd?: string | undefined;
-    readonly env?: {
-        readonly [x: string]: string;
-    } | undefined;
-    readonly cols?: number | undefined;
-    readonly rows?: number | undefined;
-    readonly term?: string | undefined;
-    readonly mode?: "pipe" | "pty" | undefined;
-    readonly metadata?: {
-        readonly [x: string]: unknown;
-    } | undefined;
-    readonly user?: string | undefined;
-}) => Effect.Effect<{
+export declare const createSessionOp: (payload: CreateSessionRequest) => Effect.Effect<{
     readonly sessionId: string;
     readonly workspaceId: string;
     readonly runId: string;
@@ -970,23 +767,7 @@ export declare const createSessionOp: (payload: {
     readonly endedAt?: string | undefined;
 }, import("effect/http/HttpClientError").HttpClientError | import("@sealant/api-contracts").RequestRefusedError | import("effect/Schema").SchemaError | import("@sealant/api-contracts").SessionBadGatewayError | import("@sealant/api-contracts").SessionBadRequestError | import("@sealant/api-contracts").SessionConflictError | import("@sealant/api-contracts").SessionForbiddenError | import("@sealant/api-contracts").SessionInternalServerError | import("@sealant/api-contracts").SessionNotFoundError | import("@sealant/api-contracts").SessionUnauthorizedError, SealantApiClient>;
 /** A session as a Linux user: its own route, which a control plane that cannot open one answers 404. */
-export declare const createSessionAsUserOp: (payload: {
-    readonly workspaceId: string;
-    readonly ownerUserId: string;
-    readonly argv: readonly string[];
-    readonly cwd?: string | undefined;
-    readonly env?: {
-        readonly [x: string]: string;
-    } | undefined;
-    readonly cols?: number | undefined;
-    readonly rows?: number | undefined;
-    readonly term?: string | undefined;
-    readonly mode?: "pipe" | "pty" | undefined;
-    readonly metadata?: {
-        readonly [x: string]: unknown;
-    } | undefined;
-    readonly user: string;
-}) => Effect.Effect<{
+export declare const createSessionAsUserOp: (payload: CreateSessionAsUserRequest) => Effect.Effect<{
     readonly sessionId: string;
     readonly workspaceId: string;
     readonly runId: string;
@@ -1009,7 +790,7 @@ export declare const createSessionAsUserOp: (payload: {
     readonly createdAt: string;
     readonly endedAt?: string | undefined;
 }, import("effect/http/HttpClientError").HttpClientError | import("@sealant/api-contracts").RequestRefusedError | import("effect/Schema").SchemaError | import("@sealant/api-contracts").SessionBadGatewayError | import("@sealant/api-contracts").SessionBadRequestError | import("@sealant/api-contracts").SessionConflictError | import("@sealant/api-contracts").SessionForbiddenError | import("@sealant/api-contracts").SessionInternalServerError | import("@sealant/api-contracts").SessionNotFoundError | import("@sealant/api-contracts").SessionUnauthorizedError, SealantApiClient>;
-export declare const getSessionOp: (sessionId: string, ownerUserId?: string | undefined) => Effect.Effect<{
+export declare const getSessionOp: (sessionId: string, ownerUserId?: string) => Effect.Effect<{
     readonly sessionId: string;
     readonly workspaceId: string;
     readonly runId: string;
@@ -1032,12 +813,7 @@ export declare const getSessionOp: (sessionId: string, ownerUserId?: string | un
     readonly createdAt: string;
     readonly endedAt?: string | undefined;
 }, import("effect/http/HttpClientError").HttpClientError | import("@sealant/api-contracts").RequestRefusedError | import("effect/Schema").SchemaError | import("@sealant/api-contracts").SessionBadRequestError | import("@sealant/api-contracts").SessionForbiddenError | import("@sealant/api-contracts").SessionInternalServerError | import("@sealant/api-contracts").SessionNotFoundError | import("@sealant/api-contracts").SessionUnauthorizedError, SealantApiClient>;
-export declare const listSessionsOp: (query: {
-    readonly ownerUserId: string;
-    readonly workspaceId?: string | undefined;
-    readonly status?: "exited" | "failed" | "running" | "starting" | undefined;
-    readonly limit?: string | undefined;
-}) => Effect.Effect<{
+export declare const listSessionsOp: (query: ListSessionsQuery) => Effect.Effect<{
     readonly items: readonly {
         readonly sessionId: string;
         readonly workspaceId: string;
@@ -1062,11 +838,7 @@ export declare const listSessionsOp: (query: {
         readonly endedAt?: string | undefined;
     }[];
 }, import("effect/http/HttpClientError").HttpClientError | import("@sealant/api-contracts").RequestRefusedError | import("effect/Schema").SchemaError | import("@sealant/api-contracts").SessionBadRequestError | import("@sealant/api-contracts").SessionForbiddenError | import("@sealant/api-contracts").SessionInternalServerError | import("@sealant/api-contracts").SessionUnauthorizedError, SealantApiClient>;
-export declare const getSessionOutputOp: (sessionId: string, query: {
-    readonly ownerUserId?: string | undefined;
-    readonly from?: string | undefined;
-    readonly limit?: string | undefined;
-}) => Effect.Effect<{
+export declare const getSessionOutputOp: (sessionId: string, query: GetSessionOutputQuery) => Effect.Effect<{
     readonly sessionId: string;
     readonly chunks: readonly {
         readonly sequence: string;
@@ -1075,28 +847,16 @@ export declare const getSessionOutputOp: (sessionId: string, query: {
     readonly nextFrom: string;
     readonly status: "exited" | "failed" | "running" | "starting";
 }, import("effect/http/HttpClientError").HttpClientError | import("@sealant/api-contracts").RequestRefusedError | import("effect/Schema").SchemaError | import("@sealant/api-contracts").SessionBadRequestError | import("@sealant/api-contracts").SessionForbiddenError | import("@sealant/api-contracts").SessionInternalServerError | import("@sealant/api-contracts").SessionNotFoundError | import("@sealant/api-contracts").SessionUnauthorizedError, SealantApiClient>;
-export declare const sendSessionInputOp: (sessionId: string, payload: {
-    readonly ownerUserId?: string | undefined;
-    readonly dataBase64: string;
-}) => Effect.Effect<{
+export declare const sendSessionInputOp: (sessionId: string, payload: SessionInputRequest) => Effect.Effect<{
     readonly ok: boolean;
 }, import("effect/http/HttpClientError").HttpClientError | import("@sealant/api-contracts").RequestRefusedError | import("effect/Schema").SchemaError | import("@sealant/api-contracts").SessionBadGatewayError | import("@sealant/api-contracts").SessionBadRequestError | import("@sealant/api-contracts").SessionConflictError | import("@sealant/api-contracts").SessionForbiddenError | import("@sealant/api-contracts").SessionInternalServerError | import("@sealant/api-contracts").SessionNotFoundError | import("@sealant/api-contracts").SessionUnauthorizedError, SealantApiClient>;
-export declare const resizeSessionOp: (sessionId: string, payload: {
-    readonly ownerUserId?: string | undefined;
-    readonly cols: number;
-    readonly rows: number;
-}) => Effect.Effect<{
+export declare const resizeSessionOp: (sessionId: string, payload: SessionResizeRequest) => Effect.Effect<{
     readonly ok: boolean;
 }, import("effect/http/HttpClientError").HttpClientError | import("@sealant/api-contracts").RequestRefusedError | import("effect/Schema").SchemaError | import("@sealant/api-contracts").SessionBadGatewayError | import("@sealant/api-contracts").SessionBadRequestError | import("@sealant/api-contracts").SessionConflictError | import("@sealant/api-contracts").SessionForbiddenError | import("@sealant/api-contracts").SessionInternalServerError | import("@sealant/api-contracts").SessionNotFoundError | import("@sealant/api-contracts").SessionUnauthorizedError, SealantApiClient>;
-export declare const signalSessionOp: (sessionId: string, payload: {
-    readonly ownerUserId?: string | undefined;
-    readonly signal: number;
-}) => Effect.Effect<{
+export declare const signalSessionOp: (sessionId: string, payload: SessionSignalRequest) => Effect.Effect<{
     readonly ok: boolean;
 }, import("effect/http/HttpClientError").HttpClientError | import("@sealant/api-contracts").RequestRefusedError | import("effect/Schema").SchemaError | import("@sealant/api-contracts").SessionBadGatewayError | import("@sealant/api-contracts").SessionBadRequestError | import("@sealant/api-contracts").SessionConflictError | import("@sealant/api-contracts").SessionForbiddenError | import("@sealant/api-contracts").SessionInternalServerError | import("@sealant/api-contracts").SessionNotFoundError | import("@sealant/api-contracts").SessionUnauthorizedError, SealantApiClient>;
-export declare const closeSessionOp: (sessionId: string, payload: {
-    readonly ownerUserId?: string | undefined;
-}) => Effect.Effect<{
+export declare const closeSessionOp: (sessionId: string, payload: CloseSessionRequest) => Effect.Effect<{
     readonly sessionId: string;
     readonly workspaceId: string;
     readonly runId: string;
@@ -1119,13 +879,7 @@ export declare const closeSessionOp: (sessionId: string, payload: {
     readonly createdAt: string;
     readonly endedAt?: string | undefined;
 }, import("effect/http/HttpClientError").HttpClientError | import("@sealant/api-contracts").RequestRefusedError | import("effect/Schema").SchemaError | import("@sealant/api-contracts").SessionBadGatewayError | import("@sealant/api-contracts").SessionBadRequestError | import("@sealant/api-contracts").SessionForbiddenError | import("@sealant/api-contracts").SessionInternalServerError | import("@sealant/api-contracts").SessionNotFoundError | import("@sealant/api-contracts").SessionUnauthorizedError, SealantApiClient>;
-export declare const createAccessTokenOp: (payload: {
-    readonly ownerUserId: string;
-    readonly scopes: readonly ("session:input" | "session:read" | "workspace:exec")[];
-    readonly name?: string | undefined;
-    readonly workspaceId?: string | undefined;
-    readonly ttlSeconds?: number | undefined;
-}) => Effect.Effect<{
+export declare const createAccessTokenOp: (payload: CreateAccessTokenRequest) => Effect.Effect<{
     readonly tokenId: string;
     readonly ownerUserId: string;
     readonly name?: string | undefined;
@@ -1136,22 +890,14 @@ export declare const createAccessTokenOp: (payload: {
     readonly createdAt: string;
     readonly token: string;
 }, import("@sealant/api-contracts").AccessTokenBadRequestError | import("@sealant/api-contracts").AccessTokenInternalServerError | import("@sealant/api-contracts").AccessTokenNotFoundError | import("effect/http/HttpClientError").HttpClientError | import("@sealant/api-contracts").RequestRefusedError | import("effect/Schema").SchemaError, SealantApiClient>;
-export declare const ensureUserOp: (payload: {
-    readonly email: string;
-    readonly name: string;
-    readonly userId?: string | undefined;
-}) => Effect.Effect<{
+export declare const ensureUserOp: (payload: EnsureUserRequest) => Effect.Effect<{
     readonly userId: string;
     readonly email: string;
     readonly name: string;
     readonly createdAt: string;
     readonly created: boolean;
 }, import("effect/http/HttpClientError").HttpClientError | import("@sealant/api-contracts").RequestRefusedError | import("effect/Schema").SchemaError | import("@sealant/api-contracts").UserBadRequestError | import("@sealant/api-contracts").UserInternalServerError, SealantApiClient>;
-export declare const bindUserPersonOp: (userId: string, payload: {
-    readonly id: string;
-    readonly uid: number;
-    readonly home: string;
-}) => Effect.Effect<{
+export declare const bindUserPersonOp: (userId: string, payload: PersonBindingWire) => Effect.Effect<{
     readonly userId: string;
     readonly person: {
         readonly id: string;
@@ -1198,15 +944,7 @@ export declare const listConnectedAccountsOp: (ownerUserId: string) => Effect.Ef
     }[];
     readonly hasApiKeyHistory?: boolean | undefined;
 }, import("@sealant/api-contracts").ConnectedAccountInternalServerError | import("effect/http/HttpClientError").HttpClientError | import("@sealant/api-contracts").RequestRefusedError | import("effect/Schema").SchemaError, SealantApiClient>;
-export declare const createConnectedAccountOp: (payload: {
-    readonly ownerUserId: string;
-    readonly provider: "claude" | "codex" | "github";
-    readonly name?: string | undefined;
-    readonly accountId?: string | undefined;
-    readonly makeDefault?: boolean | undefined;
-    readonly login?: "api-key" | "subscription" | undefined;
-    readonly secret: string;
-}) => Effect.Effect<{
+export declare const createConnectedAccountOp: (payload: CreateConnectedAccountRequest) => Effect.Effect<{
     readonly connectedAccountId: string;
     readonly ownerUserId: string;
     readonly provider: "claude" | "codex" | "github";
@@ -1264,10 +1002,7 @@ export declare const archiveConnectedAccountOp: (connectedAccountId: string, own
         readonly suffix: string;
     } | undefined;
 }, import("@sealant/api-contracts").ConnectedAccountInternalServerError | import("@sealant/api-contracts").ConnectedAccountNotFoundError | import("effect/http/HttpClientError").HttpClientError | import("@sealant/api-contracts").RequestRefusedError | import("effect/Schema").SchemaError, SealantApiClient>;
-export declare const setConnectedAccountDefaultOp: (provider: "claude" | "codex" | "github", payload: {
-    readonly ownerUserId: string;
-    readonly connectedAccountId: string;
-}) => Effect.Effect<{
+export declare const setConnectedAccountDefaultOp: (provider: ConnectedAccountProvider, payload: SetConnectedAccountDefaultRequest) => Effect.Effect<{
     readonly connectedAccountId: string;
     readonly ownerUserId: string;
     readonly provider: "claude" | "codex" | "github";
@@ -1296,10 +1031,7 @@ export declare const setConnectedAccountDefaultOp: (provider: "claude" | "codex"
         readonly suffix: string;
     } | undefined;
 }, import("@sealant/api-contracts").ConnectedAccountConflictError | import("@sealant/api-contracts").ConnectedAccountInternalServerError | import("@sealant/api-contracts").ConnectedAccountNotFoundError | import("effect/http/HttpClientError").HttpClientError | import("@sealant/api-contracts").RequestRefusedError | import("effect/Schema").SchemaError, SealantApiClient>;
-export declare const markConnectedAccountInvalidOp: (connectedAccountId: string, payload: {
-    readonly ownerUserId: string;
-    readonly revision?: number | undefined;
-}) => Effect.Effect<{
+export declare const markConnectedAccountInvalidOp: (connectedAccountId: string, payload: MarkConnectedAccountInvalidRequest) => Effect.Effect<{
     readonly connectedAccountId: string;
     readonly ownerUserId: string;
     readonly provider: "claude" | "codex" | "github";
@@ -1329,33 +1061,7 @@ export declare const markConnectedAccountInvalidOp: (connectedAccountId: string,
     } | undefined;
     readonly outcome?: "marked" | "superseded" | undefined;
 }, import("@sealant/api-contracts").ConnectedAccountInternalServerError | import("@sealant/api-contracts").ConnectedAccountNotFoundError | import("effect/http/HttpClientError").HttpClientError | import("@sealant/api-contracts").RequestRefusedError | import("effect/Schema").SchemaError, SealantApiClient>;
-export declare const inferenceRespondOp: (payload: {
-    readonly ownerUserId: string;
-    readonly credentials?: {
-        readonly profileId?: string | undefined;
-        readonly claude?: string | undefined;
-        readonly codex?: string | undefined;
-    } | undefined;
-    readonly prompt?: string | undefined;
-    readonly system?: string | undefined;
-    readonly model?: string | undefined;
-    readonly maxTurns?: number | undefined;
-    readonly tools?: readonly {
-        readonly name: string;
-        readonly description?: string | undefined;
-        readonly inputSchema: unknown;
-    }[] | undefined;
-    readonly responseFormat?: {
-        readonly type: "json";
-        readonly schema?: unknown;
-    } | undefined;
-    readonly sessionId?: string | undefined;
-    readonly toolResults?: readonly {
-        readonly toolCallId: string;
-        readonly content: string;
-        readonly isError?: boolean | undefined;
-    }[] | undefined;
-}) => Effect.Effect<{
+export declare const inferenceRespondOp: (payload: InferenceRespondRequest) => Effect.Effect<{
     readonly sessionId: string;
     readonly turn: {
         readonly type: "text";
@@ -1404,11 +1110,7 @@ export declare const getSetupStateOp: () => Effect.Effect<{
         readonly usernamePrefix: string;
     } | null;
 }, import("effect/http/HttpClientError").HttpClientError | import("@sealant/api-contracts").RequestRefusedError | import("effect/Schema").SchemaError | import("@sealant/api-contracts").SystemInternalServerError, SealantApiClient>;
-export declare const createSshKeyOp: (payload: {
-    readonly ownerUserId: string;
-    readonly name?: string | undefined;
-    readonly publicKey: string;
-}) => Effect.Effect<{
+export declare const createSshKeyOp: (payload: CreateSshKeyRequest) => Effect.Effect<{
     readonly sshKeyId: string;
     readonly ownerUserId: string;
     readonly name: string;
@@ -1434,11 +1136,7 @@ export declare const archiveSshKeyOp: (sshKeyId: string, ownerUserId: string) =>
     readonly fingerprint: string;
     readonly createdAt: string;
 }, import("effect/http/HttpClientError").HttpClientError | import("@sealant/api-contracts").RequestRefusedError | import("effect/Schema").SchemaError | import("@sealant/api-contracts").SshKeyInternalServerError | import("@sealant/api-contracts").SshKeyNotFoundError, SealantApiClient>;
-export declare const ensureResourceDomainOp: (key: string, budget?: {
-    readonly cpuMillicores: number;
-    readonly memoryBytes: number;
-    readonly storageBytes: number;
-} | undefined) => Effect.Effect<{
+export declare const ensureResourceDomainOp: (key: string, budget?: ResourceDomainBudgetLimits) => Effect.Effect<{
     readonly resourceDomainId: string;
     readonly key: string;
     readonly createdAt: string;
@@ -1449,17 +1147,13 @@ export declare const getResourceDomainOp: (resourceDomainId: string) => Effect.E
     readonly key: string;
     readonly createdAt: string;
 }, import("effect/http/HttpClientError").HttpClientError | import("@sealant/api-contracts").RequestRefusedError | import("@sealant/api-contracts").ResourceDomainForbiddenError | import("@sealant/api-contracts").ResourceDomainInternalServerError | import("@sealant/api-contracts").ResourceDomainNotFoundError | import("effect/Schema").SchemaError, SealantApiClient>;
-export declare const grantResourceDomainMemberOp: (resourceDomainId: string, userId: string, payload: {
-    readonly version: number;
-}) => Effect.Effect<{
+export declare const grantResourceDomainMemberOp: (resourceDomainId: string, userId: string, payload: ResourceDomainMemberDecisionRequest) => Effect.Effect<{
     readonly userId: string;
     readonly state: "member" | "revoked";
     readonly version: number;
     readonly updatedAt: string;
 }, import("effect/http/HttpClientError").HttpClientError | import("@sealant/api-contracts").RequestRefusedError | import("@sealant/api-contracts").ResourceDomainForbiddenError | import("@sealant/api-contracts").ResourceDomainInternalServerError | import("@sealant/api-contracts").ResourceDomainMemberVersionConflictError | import("@sealant/api-contracts").ResourceDomainNotFoundError | import("@sealant/api-contracts").ResourceDomainPersonNotFoundError | import("effect/Schema").SchemaError, SealantApiClient>;
-export declare const revokeResourceDomainMemberOp: (resourceDomainId: string, userId: string, payload: {
-    readonly version: number;
-}) => Effect.Effect<{
+export declare const revokeResourceDomainMemberOp: (resourceDomainId: string, userId: string, payload: ResourceDomainMemberDecisionRequest) => Effect.Effect<{
     readonly userId: string;
     readonly state: "member" | "revoked";
     readonly version: number;
@@ -1471,10 +1165,7 @@ export declare const getResourceDomainMemberOp: (resourceDomainId: string, userI
     readonly version: number;
     readonly updatedAt: string;
 }, import("effect/http/HttpClientError").HttpClientError | import("@sealant/api-contracts").RequestRefusedError | import("@sealant/api-contracts").ResourceDomainForbiddenError | import("@sealant/api-contracts").ResourceDomainInternalServerError | import("@sealant/api-contracts").ResourceDomainMemberNotFoundError | import("@sealant/api-contracts").ResourceDomainNotFoundError | import("@sealant/api-contracts").ResourceDomainPersonNotFoundError | import("effect/Schema").SchemaError, SealantApiClient>;
-export declare const listResourceDomainMembersOp: (resourceDomainId: string, query: {
-    readonly limit?: number | undefined;
-    readonly cursor?: string | undefined;
-}) => Effect.Effect<{
+export declare const listResourceDomainMembersOp: (resourceDomainId: string, query: ListResourceDomainMembersQuery) => Effect.Effect<{
     readonly items: readonly {
         readonly userId: string;
         readonly state: "member" | "revoked";
@@ -1506,12 +1197,7 @@ export declare const getResourceDomainBudgetOp: (resourceDomainId: string) => Ef
         readonly warning: "80-percent" | "95-percent" | "full" | "none";
     };
 }, import("effect/http/HttpClientError").HttpClientError | import("@sealant/api-contracts").RequestRefusedError | import("@sealant/api-contracts").ResourceDomainForbiddenError | import("@sealant/api-contracts").ResourceDomainInternalServerError | import("@sealant/api-contracts").ResourceDomainNotFoundError | import("effect/Schema").SchemaError, SealantApiClient>;
-export declare const setResourceDomainBudgetOp: (resourceDomainId: string, payload: {
-    readonly revision: number;
-    readonly cpuMillicores: number;
-    readonly memoryBytes: number;
-    readonly storageBytes: number;
-}) => Effect.Effect<{
+export declare const setResourceDomainBudgetOp: (resourceDomainId: string, payload: SetResourceDomainBudgetRequest) => Effect.Effect<{
     readonly revision: number;
     readonly storageBytes: {
         readonly limit: number;

package/dist/facade/bounded-forward.d.ts

@@ -1,7 +1,3 @@
+import { type ForwardBinding } from "@sealant/api-contracts";
 import type { BoundedWorkspaceForward } from "../types.js";
-export declare const boundedForward: (ws: WebSocket, binding: {
-    readonly kind: "port";
-} | {
-    readonly kind: "session";
-    readonly session: string;
-}, onWindowOpen: () => void) => BoundedWorkspaceForward;
+export declare const boundedForward: (ws: WebSocket, binding: ForwardBinding, onWindowOpen: () => void) => BoundedWorkspaceForward;

package/dist/facade/forward.d.ts

@@ -4,6 +4,6 @@ export interface ForwardEndpoint {
     readonly apiKey: string | undefined;
     readonly ownerUserId: string;
 }
-export declare const openForward: (endpoint: ForwardEndpoint, workspaceId: string, port: number, options?: WorkspaceForwardOptions | undefined) => Promise<WorkspaceForward>;
+export declare const openForward: (endpoint: ForwardEndpoint, workspaceId: string, port: number, options?: WorkspaceForwardOptions) => Promise<WorkspaceForward>;
 export type ForwardV2Options = BoundedForwardTarget & Pick<BoundedWorkspaceForwardOptions, "signal" | "deadlineMs">;
-export declare const openForwardV2: (endpoint: ForwardEndpoint, workspaceId: string, port: number, options?: ForwardV2Options | undefined) => Promise<BoundedWorkspaceForward>;
+export declare const openForwardV2: (endpoint: ForwardEndpoint, workspaceId: string, port: number, options?: ForwardV2Options) => Promise<BoundedWorkspaceForward>;

package/dist/facade/record.d.ts

@@ -1,3 +1,11 @@
+/**
+ * The `RunRecord` facade — the execution record as the SDK exposes it. Backed by the run/record
+ * contract endpoints (`client.runs.*`), it maps the wire shapes to the public types: decimal-string
+ * sequences become `bigint`, base64 scrollback becomes `Uint8Array`. `replay()`/`timeline()`/
+ * `scrollback()`/`loss()`/`summary()`/`stream()` are live; the time-travel folds are typed but
+ * reject until their read models land (Phase 1).
+ */
+import { type TimelineEntry as WireTimelineEntry } from "@sealant/api-contracts";
 import type { RunCommand, RunRecord, TimelineEntry } from "../types.js";
 import type { SdkContext } from "./context.js";
 /**
@@ -5,32 +13,12 @@ import type { SdkContext } from "./context.js";
  * `(kind, ref)` into typed `data`, degrading to the `unknown` case (raw kind + payload preserved)
  * for kinds newer than this SDK or payloads that fail their schema. Exported for tests.
  */
-export declare const toTimelineEntry: (wire: {
-    readonly eventId: string;
-    readonly sequence: string;
-    readonly kind: string;
-    readonly occurredAt: string;
-    readonly summary: string;
-    readonly ref?: unknown;
-    readonly processId?: string | undefined;
-    readonly captureMethod: number;
-    readonly confidence: number;
-}) => TimelineEntry;
+export declare const toTimelineEntry: (wire: WireTimelineEntry) => TimelineEntry;
 /**
  * Folds the timeline into the ordered list of terminal commands. Process boundaries are
  * `processStarted`/`processExited`; `ioChunk` byte counts accrue to the current command. Daemon noise
  * (`runtimeStateChanged`, and the boot foreground we never `processStarted`) is skipped naturally.
  */
-export declare const reconstructCommands: (entries: readonly {
-    readonly eventId: string;
-    readonly sequence: string;
-    readonly kind: string;
-    readonly occurredAt: string;
-    readonly summary: string;
-    readonly ref?: unknown;
-    readonly processId?: string | undefined;
-    readonly captureMethod: number;
-    readonly confidence: number;
-}[]) => RunCommand[];
+export declare const reconstructCommands: (entries: readonly WireTimelineEntry[]) => RunCommand[];
 export declare const renderTranscript: (commands: readonly RunCommand[]) => string;
 export declare const makeRunRecord: (ctx: SdkContext, runId: string) => RunRecord;

package/dist/facade/run.d.ts

@@ -7,7 +7,7 @@
  * `artifacts` is empty until the artifact store is exposed; `record` reads via the run/record
  * endpoints.
  */
-import type { Run as WireRun } from "@sealant/api-contracts";
+import type { Run as WireRun, RunChangesResponse } from "@sealant/api-contracts";
 import type { Run, RunFileChange } from "../types.js";
 import type { SdkContext } from "./context.js";
 export interface RunChangesData {
@@ -21,14 +21,5 @@ export interface RunInit {
     readonly changes?: RunChangesData;
 }
 /** Maps the wire changes shape to the facade data (shared with the run-harness execution path). */
-export declare const toRunChangesData: (wire: {
-    readonly files: readonly {
-        readonly path: string;
-        readonly change: "added" | "deleted" | "modified" | "renamed";
-        readonly oldPath?: string | undefined;
-    }[];
-    readonly diff: string;
-    readonly available?: boolean | undefined;
-    readonly unavailableReason?: string | undefined;
-}) => RunChangesData;
+export declare const toRunChangesData: (wire: RunChangesResponse) => RunChangesData;
 export declare const makeRun: (ctx: SdkContext, init: RunInit) => Run;

package/dist/facade/session.d.ts

@@ -1,25 +1,14 @@
+/**
+ * The `InteractiveSession` facade — a durable PTY session as the SDK exposes it.
+ *
+ * Sessions are platform resources: the PTY lives daemon-side and every verb here is a plain HTTP
+ * call, so a handle can be dropped, the process restarted, and the session re-fetched by id from
+ * any workspace handle. `output()` is the resumable read: it streams the session's RECORDED output
+ * (byte-exact, redacted, sequence-keyed) over the SSE endpoint, falling back to polling the range
+ * endpoint if the SSE transport is unavailable. The SSE `id` is the durable telemetry sequence, so
+ * `from: lastChunk.sequence + 1n` resumes with no gap after any disconnect.
+ */
+import type { SessionWire } from "@sealant/api-contracts";
 import type { InteractiveSession } from "../types.js";
 import type { SdkContext } from "./context.js";
-export declare const makeInteractiveSession: (ctx: SdkContext, wire: {
-    readonly sessionId: string;
-    readonly workspaceId: string;
-    readonly runId: string;
-    readonly ownerUserId: string;
-    readonly status: "exited" | "failed" | "running" | "starting";
-    readonly argv: readonly string[];
-    readonly argCount?: number | undefined;
-    readonly argLengths?: readonly number[] | undefined;
-    readonly cwd?: string | undefined;
-    readonly cols: number;
-    readonly rows: number;
-    readonly mode?: "pipe" | "pty" | undefined;
-    readonly exitCode?: number | undefined;
-    readonly exitSignal?: number | undefined;
-    readonly errorMessage?: string | undefined;
-    readonly metadata?: {
-        readonly [x: string]: unknown;
-    } | undefined;
-    readonly outputHighWater: string;
-    readonly createdAt: string;
-    readonly endedAt?: string | undefined;
-}) => InteractiveSession;
+export declare const makeInteractiveSession: (ctx: SdkContext, wire: SessionWire) => InteractiveSession;

package/dist/facade/workspace.d.ts

@@ -1,3 +1,10 @@
+/**
+ * The `Workspace` facade — a live, disposable environment as the SDK exposes it. `status()`/`ready()`/
+ * `events()` poll the control-plane workspace endpoint; `harness.run()`/`harness.start()` are the
+ * server-side execution paths (filled in by the run-execution module). `harness.session()` and the
+ * lifecycle verbs are typed now and reject until their endpoints land (Phase 3).
+ */
+import type { WorkspaceRuntime as WireWorkspaceRuntime, WorkspaceDetails as WireWorkspaceDetails } from "@sealant/api-contracts";
 import type { Harness, Workspace, WorkspaceLaunch, WorkspaceRuntimeInfo, WorkspaceImage, WorkspacePhase, WorkspaceStatus } from "../types.js";
 import type { SdkContext } from "./context.js";
 export interface WorkspaceInit {
@@ -18,16 +25,7 @@ export interface WorkspaceInit {
     readonly imageBuildTimeoutMs?: number;
 }
 /** The wire runtime as the SDK reports it. */
-export declare const toRuntimeInfo: (runtime: {
-    readonly adapter: "cloudflare" | "docker" | "k3s" | "k8s" | "microvm";
-    readonly resourceId: string;
-    readonly reference: string;
-    readonly status: "failed" | "pending" | "ready" | "retained" | "running" | "stopped";
-    readonly endpoint?: string | undefined;
-    readonly deadline?: string | null | undefined;
-    readonly runId?: string | undefined;
-    readonly launchId?: string | undefined;
-}) => WorkspaceRuntimeInfo;
+export declare const toRuntimeInfo: (runtime: WireWorkspaceRuntime) => WorkspaceRuntimeInfo;
 /** `ready()`'s default readiness bound: the launch outside an image build (queued, booting). */
 export declare const READY_TIMEOUT_MS: number;
 /**
@@ -52,31 +50,15 @@ export interface HarnessExecutors {
     readonly start: RunHarnessFn;
 }
 export declare const registerHarnessExecutors: (executors: HarnessExecutors) => void;
+/** The wire's launch phase. */
+type WirePhase = NonNullable<WireWorkspaceDetails["phase"]>;
+/** The wire's published image. */
+type WirePublishedImage = NonNullable<WireWorkspaceDetails["publishedImage"]>;
 /** Wire → public launch phase. */
-export declare const toWorkspacePhase: (phase: {
-    readonly name: "boot" | "image-build" | "queued";
-    readonly since?: string | undefined;
-    readonly imageBuild?: {
-        readonly step?: number | undefined;
-        readonly steps?: number | undefined;
-        readonly stepName?: string | undefined;
-        readonly progressAt: string;
-        readonly stallTimeoutMs?: number | undefined;
-    } | undefined;
-}) => WorkspacePhase;
+export declare const toWorkspacePhase: (phase: WirePhase) => WorkspacePhase;
 /** `Building the workspace image (step 2/12: RUN apt-get …)`, `Booting the workspace`. */
 export declare const describeWorkspacePhase: (phase: WorkspacePhase) => string;
 /** Wire → public published image. */
-export declare const toWorkspaceImage: (image: {
-    readonly reference: string;
-    readonly digestReference: string;
-    readonly digest: string;
-    readonly personLayout?: {
-        readonly status: "supported" | "unknown" | "unsupported";
-        readonly missing: readonly string[];
-        readonly unknown: readonly string[];
-        readonly runtime: string;
-        readonly acl: "supported" | "unknown" | "unsupported";
-    } | undefined;
-}) => WorkspaceImage;
+export declare const toWorkspaceImage: (image: WirePublishedImage) => WorkspaceImage;
 export declare const makeWorkspace: (ctx: SdkContext, init: WorkspaceInit) => Workspace;
+export {};

package/dist/harness.d.ts

@@ -16,7 +16,7 @@ export declare const codex: () => Harness;
 /** Anthropic Claude Code. */
 export declare const claudeCode: (options?: {
     readonly profile?: string;
-} | undefined) => Harness;
+}) => Harness;
 /** pi, the coding agent from earendil-works/pi. */
 export declare const pi: () => Harness;
 /**

package/dist/internal/blueprint.d.ts

@@ -1,39 +1,7 @@
+import { type CreateWorkspaceRequest } from "@sealant/api-contracts";
 import type { CreateOptions } from "../types.js";
 import type { SealantInternalConfig } from "./config.js";
 export declare const toGitUrl: (repository: string) => string;
 export declare const buildCreateWorkspaceRequest: (options: CreateOptions, config: SealantInternalConfig) => {
-    readonly payload: {
-        readonly ownerUserId: string;
-        readonly registryId: string;
-        readonly repository: string;
-        readonly tag: string;
-        readonly name?: string | undefined;
-        readonly sourceSelection?: {
-            readonly provider: "github";
-            readonly installationId: string;
-            readonly installationRepositoryId: string;
-            readonly ref?: string | undefined;
-        } | undefined;
-        readonly dotfilesSelection?: {
-            readonly provider: "github";
-            readonly installationId: string;
-            readonly installationRepositoryId: string;
-            readonly ref?: string | undefined;
-        } | undefined;
-        readonly credentials?: {
-            readonly profileId?: string | undefined;
-            readonly claude?: string | undefined;
-            readonly codex?: string | undefined;
-            readonly github?: string | undefined;
-        } | undefined;
-        readonly spec: unknown;
-        readonly secretEnv?: {
-            readonly [x: string]: string;
-        } | undefined;
-        readonly captureToken?: string | undefined;
-        readonly ttlSeconds?: number | undefined;
-        readonly idempotencyKey?: string | undefined;
-        readonly launchId?: string | undefined;
-        readonly sshAsOwner?: boolean | undefined;
-    };
+    readonly payload: CreateWorkspaceRequest;
 };

package/dist/internal/credentials.d.ts

@@ -14,7 +14,7 @@ export interface WorkspaceCredentialsPayload {
     readonly codex?: string;
     readonly github?: string;
 }
-export declare const mapAccountRef: (value: string | boolean | undefined) => string | undefined;
+export declare const mapAccountRef: (value: boolean | string | undefined) => string | undefined;
 /**
  * Maps `WorkspaceCredentialsOptions` to the API payload shape, or `undefined` when no credentials were
  * requested (omitted entirely, rather than serialized as an empty object).

package/dist/internal/features.d.ts

@@ -1,28 +1,13 @@
+/**
+ * What the control plane says it can do (its index, `features`), read once per client and kept a
+ * few minutes, so a client feature-detects instead of reading a version (a self-built control
+ * plane reports `0.0.0`). A control plane from before a feature does not name it: `false`.
+ */
+import type { SystemIndexResponse } from "@sealant/api-contracts";
 import type { SdkContext } from "../facade/context.js";
 import type { SealantFeatures } from "../types.js";
 /** The index's `features` as the SDK reports them: every flag named, absent ones `false`. */
-export declare const toFeatures: (index: {
-    readonly name: string;
-    readonly version: string;
-    readonly docsPath: string;
-    readonly openApiPath: string;
-    readonly features?: {
-        readonly processUser: boolean;
-        readonly processUserRoutes?: boolean | undefined;
-        readonly dotfilesApply?: boolean | undefined;
-        readonly credentialsPartialPut?: boolean | undefined;
-        readonly credentialsPiOpencode?: boolean | undefined;
-        readonly captureOwnerMap?: boolean | undefined;
-        readonly workspaceSshUser?: boolean | undefined;
-        readonly personBinding?: boolean | undefined;
-        readonly sshKeyRemovalEndsConnections?: boolean | undefined;
-        readonly connectedAccountDefaults?: boolean | undefined;
-        readonly connectedAccountLoginClass?: boolean | undefined;
-        readonly kubernetesPersonLayout?: boolean | undefined;
-        readonly credentialPlacements?: boolean | undefined;
-        readonly connectedAccountApiKeys?: boolean | undefined;
-    } | undefined;
-}) => SealantFeatures;
+export declare const toFeatures: (index: SystemIndexResponse) => SealantFeatures;
 /**
  * The control plane's features, from this client's kept answer or a fresh read. Rejects when the
  * index could not be read; the failure is kept briefly, then the index is asked again.

package/dist/internal/inference.d.ts

@@ -1,47 +1,12 @@
+/**
+ * Lowers the public inference options onto the control-plane's `/v1/inference/respond` payload and
+ * maps the wire response back onto the public types. Pure and side-effect free — unit-testable on
+ * its own; the client calls these around `inferenceRespondOp`.
+ *
+ * SECURITY: only account **references** cross here;
+ * token material never appears on either side of this mapping.
+ */
+import type { InferenceRespondRequest, InferenceRespondResponse } from "@sealant/api-contracts";
 import type { InferenceContinueOptions, InferenceRespondOptions, InferenceResponse } from "../types.js";
-export declare const buildInferenceRespondRequest: (options: InferenceContinueOptions | InferenceRespondOptions, ownerUserId: string) => {
-    readonly ownerUserId: string;
-    readonly credentials?: {
-        readonly profileId?: string | undefined;
-        readonly claude?: string | undefined;
-        readonly codex?: string | undefined;
-    } | undefined;
-    readonly prompt?: string | undefined;
-    readonly system?: string | undefined;
-    readonly model?: string | undefined;
-    readonly maxTurns?: number | undefined;
-    readonly tools?: readonly {
-        readonly name: string;
-        readonly description?: string | undefined;
-        readonly inputSchema: unknown;
-    }[] | undefined;
-    readonly responseFormat?: {
-        readonly type: "json";
-        readonly schema?: unknown;
-    } | undefined;
-    readonly sessionId?: string | undefined;
-    readonly toolResults?: readonly {
-        readonly toolCallId: string;
-        readonly content: string;
-        readonly isError?: boolean | undefined;
-    }[] | undefined;
-};
-export declare const mapInferenceResponse: (wire: {
-    readonly sessionId: string;
-    readonly turn: {
-        readonly type: "text";
-        readonly text: string;
-        readonly json?: unknown;
-    } | {
-        readonly type: "toolCalls";
-        readonly calls: readonly {
-            readonly toolCallId: string;
-            readonly name: string;
-            readonly input: unknown;
-        }[];
-    };
-    readonly usage?: {
-        readonly inputTokens: number;
-        readonly outputTokens: number;
-    } | undefined;
-}) => InferenceResponse;
+export declare const buildInferenceRespondRequest: (options: InferenceRespondOptions | InferenceContinueOptions, ownerUserId: string) => InferenceRespondRequest;
+export declare const mapInferenceResponse: (wire: InferenceRespondResponse) => InferenceResponse;

package/dist/internal/ssh.d.ts

@@ -1,17 +1,5 @@
+/** Wire → public mapping for the workspace-SSH surface (gateway coordinates and SSH keys). */
+import type { SetupStateResponse, SshKeySummary } from "@sealant/api-contracts";
 import type { SshKey, WorkspaceSshInfo } from "../types.js";
-export declare const mapWorkspaceSshInfo: (wire: {
-    readonly needsSetup: boolean;
-    readonly sshGateway: {
-        readonly host: string;
-        readonly port: number;
-        readonly usernamePrefix: string;
-    } | null;
-}) => WorkspaceSshInfo | null;
-export declare const mapSshKey: (wire: {
-    readonly sshKeyId: string;
-    readonly ownerUserId: string;
-    readonly name: string;
-    readonly algorithm: string;
-    readonly fingerprint: string;
-    readonly createdAt: string;
-}) => SshKey;
+export declare const mapWorkspaceSshInfo: (wire: SetupStateResponse) => WorkspaceSshInfo | null;
+export declare const mapSshKey: (wire: SshKeySummary) => SshKey;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sealant/sdk-next",
-  "version": "0.40.0-next.772",
+  "version": "0.40.0-next.774",
   "description": "The fluent public SDK for Sealant — create a workspace, run a harness, replay the record.",
   "license": "Apache-2.0",
   "repository": {
@@ -26,12 +26,12 @@
     "node": ">=20"
   },
   "dependencies": {
-    "@sealant/api-contracts": "npm:@sealant/api-contracts-next@0.40.0-next.772"
+    "@sealant/api-contracts": "npm:@sealant/api-contracts-next@0.40.0-next.774"
   },
   "peerDependencies": {
     "effect": "^4.0.5"
   },
-  "gitHead": "722ef7c7d08581db5c9c4de770d5630329063a97",
+  "gitHead": "343ccbc0c9ce40194a64f7fedc586cad3f54c4cb",
   "publishConfig": {
     "access": "public"
   }