@sealant/sdk 0.3.1 → 0.5.0

package/dist/index.d.ts

@@ -1,17 +1,17 @@
 /**
  * @sealant/sdk — the fluent public SDK for Sealant.
  *
- * Create a live sandbox around a real repository, run the harness you already use, stream progress
- * while it works, and keep the replayable execution record after the sandbox is gone:
+ * Create a live workspace around a real repository, run the harness you already use, stream progress
+ * while it works, and keep the replayable execution record after the workspace is gone:
  *
  *   import { Sealant, opencode } from "@sealant/sdk"
  *
  *   const sealant = new Sealant({ baseUrl: "http://localhost:8080" })
- *   const sandbox = await sealant.sandboxes.create({
+ *   const workspace = await sealant.workspaces.create({
  *     repository: "github.com/acme/billing-service",
  *     harness: opencode(),
  *   })
- *   const run = await sandbox.harness.run("Round invoice totals once, after applying the discount.")
+ *   const run = await workspace.harness.run("Round invoice totals once, after applying the discount.")
  *   await run.record.replay()
  */
 export { Sealant } from "./client.js";

package/dist/index.js

@@ -1,17 +1,17 @@
 /**
  * @sealant/sdk — the fluent public SDK for Sealant.
  *
- * Create a live sandbox around a real repository, run the harness you already use, stream progress
- * while it works, and keep the replayable execution record after the sandbox is gone:
+ * Create a live workspace around a real repository, run the harness you already use, stream progress
+ * while it works, and keep the replayable execution record after the workspace is gone:
  *
  *   import { Sealant, opencode } from "@sealant/sdk"
  *
  *   const sealant = new Sealant({ baseUrl: "http://localhost:8080" })
- *   const sandbox = await sealant.sandboxes.create({
+ *   const workspace = await sealant.workspaces.create({
  *     repository: "github.com/acme/billing-service",
  *     harness: opencode(),
  *   })
- *   const run = await sandbox.harness.run("Round invoice totals once, after applying the discount.")
+ *   const run = await workspace.harness.run("Round invoice totals once, after applying the discount.")
  *   await run.record.replay()
  */
 export { Sealant } from "./client.js";

package/dist/internal/blueprint.d.ts

@@ -1,6 +1,6 @@
 import type { CreateOptions } from "../types.js";
 import type { SealantInternalConfig } from "./config.js";
-export declare const buildCreateSandboxRequest: (options: CreateOptions, config: SealantInternalConfig) => {
+export declare const buildCreateWorkspaceRequest: (options: CreateOptions, config: SealantInternalConfig) => {
     readonly payload: {
         readonly ownerUserId: string;
         readonly registryId: string;

package/dist/internal/blueprint.js

@@ -1,17 +1,17 @@
 /**
  * Lowers the fluent `create({ repository, harness })` options into the existing
- * `createSandboxRequestSchema` the control plane accepts — entirely client-side, so the slice needs
+ * `createWorkspaceRequestSchema` the control plane accepts — entirely client-side, so the slice needs
  * no contract change. The public `repository` is the SOURCE git repo (it becomes
- * `spec.sources.sandbox.url`); the contract's `repository`/`tag` are the OCI push coordinates, which
+ * `spec.sources.workspace.url`); the contract's `repository`/`tag` are the OCI push coordinates, which
  * we derive. `customization.enableSealantd` is forced on (it bakes + launches the daemon the run path
  * connects to), the runtime target is pinned to docker (the only bridgeable adapter today), and the
- * foreground is a keepalive so the sandbox idles with the daemon up and the harness is exec'd on
+ * foreground is a keepalive so the workspace idles with the daemon up and the harness is exec'd on
  * demand by `run()` rather than launched at boot. `options.credentials`, if present, is lowered via
- * `mapSandboxCredentials` (see `./credentials.js`) and folded into `spec.credentials`; the control
+ * `mapWorkspaceCredentials` (see `./credentials.js`) and folded into `spec.credentials`; the control
  * plane resolves those account references server-side (never secret material over this path).
  */
 import { randomUUID } from "node:crypto";
-import { mapSandboxCredentials } from "./credentials.js";
+import { mapWorkspaceCredentials } from "./credentials.js";
 const sanitizeRepoSlug = (value) => {
     const slug = value
         .toLowerCase()
@@ -26,16 +26,16 @@ const toGitUrl = (repository) => {
     }
     return `https://${repository}.git`;
 };
-export const buildCreateSandboxRequest = (options, config) => {
+export const buildCreateWorkspaceRequest = (options, config) => {
     const tail = options.repository
         .split("/")
         .filter((s) => s.length > 0)
         .pop() ?? options.repository;
-    const credentials = mapSandboxCredentials(options.credentials);
+    const credentials = mapWorkspaceCredentials(options.credentials);
     const spec = {
         version: "1",
         sources: {
-            sandbox: {
+            workspace: {
                 kind: "git",
                 provider: "generic",
                 url: toGitUrl(options.repository),

package/dist/internal/config.d.ts

@@ -9,9 +9,9 @@
  */
 import type { SealantConfig } from "../types.js";
 export interface SealantHostLocalConfig {
-    /** Owner principal the control plane attributes sandboxes/runs to (pre-auth). */
+    /** Owner principal the control plane attributes workspaces/runs to (pre-auth). */
     readonly ownerUserId: string;
-    /** Registry the sandbox image is published to and launched from. */
+    /** Registry the workspace image is published to and launched from. */
     readonly registryId: string;
 }
 export interface SealantInternalConfig {

package/dist/internal/credentials.d.ts

@@ -1,22 +1,22 @@
 /**
- * Lowers the public `SandboxCredentialsOptions` onto the control-plane's sandbox-create payload
- * shape. Pure and side-effect free so it is unit-testable on its own; `buildCreateSandboxRequest`
+ * Lowers the public `WorkspaceCredentialsOptions` onto the control-plane's workspace-create payload
+ * shape. Pure and side-effect free so it is unit-testable on its own; `buildCreateWorkspaceRequest`
  * calls it and folds the result into the request it builds.
  *
  * SECURITY: this only ever moves account **references** (booleans/names/ids) — never token values or
  * other secret material. `true` resolves to the literal account name `"default"`; a string passes
  * through as the named account; `profile` becomes `profileId`.
  */
-import type { SandboxCredentialsOptions } from "../types.js";
-/** The control-plane's sandbox-create payload shape for connected-account credentials. */
-export interface SandboxCredentialsPayload {
+import type { WorkspaceCredentialsOptions } from "../types.js";
+/** The control-plane's workspace-create payload shape for connected-account credentials. */
+export interface WorkspaceCredentialsPayload {
     readonly profileId?: string;
     readonly claude?: string;
     readonly codex?: string;
     readonly github?: string;
 }
 /**
- * Maps `SandboxCredentialsOptions` to the API payload shape, or `undefined` when no credentials were
+ * Maps `WorkspaceCredentialsOptions` to the API payload shape, or `undefined` when no credentials were
  * requested (omitted entirely, rather than serialized as an empty object).
  */
-export declare const mapSandboxCredentials: (options: SandboxCredentialsOptions | undefined) => SandboxCredentialsPayload | undefined;
+export declare const mapWorkspaceCredentials: (options: WorkspaceCredentialsOptions | undefined) => WorkspaceCredentialsPayload | undefined;

package/dist/internal/credentials.js

@@ -6,10 +6,10 @@ const mapAccountRef = (value) => {
     return value === true ? DEFAULT_ACCOUNT_NAME : value;
 };
 /**
- * Maps `SandboxCredentialsOptions` to the API payload shape, or `undefined` when no credentials were
+ * Maps `WorkspaceCredentialsOptions` to the API payload shape, or `undefined` when no credentials were
  * requested (omitted entirely, rather than serialized as an empty object).
  */
-export const mapSandboxCredentials = (options) => {
+export const mapWorkspaceCredentials = (options) => {
     if (options === undefined) {
         return undefined;
     }

package/dist/internal/inference.d.ts

@@ -0,0 +1,47 @@
+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;

package/dist/internal/inference.js

@@ -0,0 +1,78 @@
+const DEFAULT_ACCOUNT_NAME = "default";
+const mapAccountRef = (value) => {
+    if (value === undefined || value === false) {
+        return undefined;
+    }
+    return value === true ? DEFAULT_ACCOUNT_NAME : value;
+};
+export const buildInferenceRespondRequest = (options, ownerUserId) => {
+    if ("sessionId" in options) {
+        return {
+            ownerUserId,
+            sessionId: options.sessionId,
+            toolResults: options.toolResults.map((result) => ({
+                toolCallId: result.toolCallId,
+                content: result.content,
+                ...(result.isError === undefined ? {} : { isError: result.isError }),
+            })),
+        };
+    }
+    const claude = mapAccountRef(options.credentials.claude);
+    const codex = mapAccountRef(options.credentials.codex);
+    return {
+        ownerUserId,
+        credentials: {
+            ...(options.credentials.profile === undefined
+                ? {}
+                : { profileId: options.credentials.profile }),
+            ...(claude === undefined ? {} : { claude }),
+            ...(codex === undefined ? {} : { codex }),
+        },
+        prompt: options.prompt,
+        ...(options.system === undefined ? {} : { system: options.system }),
+        ...(options.model === undefined ? {} : { model: options.model }),
+        ...(options.maxTurns === undefined ? {} : { maxTurns: options.maxTurns }),
+        ...(options.tools === undefined
+            ? {}
+            : {
+                tools: options.tools.map((tool) => ({
+                    name: tool.name,
+                    ...(tool.description === undefined ? {} : { description: tool.description }),
+                    inputSchema: tool.inputSchema,
+                })),
+            }),
+        ...(options.responseFormat === undefined
+            ? {}
+            : {
+                responseFormat: {
+                    type: options.responseFormat.type,
+                    ...(options.responseFormat.schema === undefined
+                        ? {}
+                        : { schema: options.responseFormat.schema }),
+                },
+            }),
+    };
+};
+export const mapInferenceResponse = (wire) => {
+    const turn = wire.turn.type === "text"
+        ? {
+            type: "text",
+            text: wire.turn.text,
+            ...(wire.turn.json === undefined ? {} : { json: wire.turn.json }),
+        }
+        : {
+            type: "toolCalls",
+            calls: wire.turn.calls.map((call) => ({
+                toolCallId: call.toolCallId,
+                name: call.name,
+                input: call.input,
+            })),
+        };
+    return {
+        sessionId: wire.sessionId,
+        turn,
+        ...(wire.usage === undefined
+            ? {}
+            : { usage: { inputTokens: wire.usage.inputTokens, outputTokens: wire.usage.outputTokens } }),
+    };
+};

package/dist/internal/map-error.d.ts

@@ -1,6 +1,6 @@
 /**
  * Maps any failure crossing the Effect boundary onto a plain public `SealantError`. The Effect core
- * fails with `@sealant/api-contracts` tagged errors (e.g. `SandboxNotFoundError`), Effect HTTP-client
+ * fails with `@sealant/api-contracts` tagged errors (e.g. `WorkspaceNotFoundError`), Effect HTTP-client
  * errors, or schema decode errors; the runtime squashes the `Cause` to its failure value and hands it
  * here. This is the single funnel that keeps Effect internals out of the public, Promise-based API.
  */

package/dist/internal/map-error.js

@@ -1,6 +1,6 @@
 /**
  * Maps any failure crossing the Effect boundary onto a plain public `SealantError`. The Effect core
- * fails with `@sealant/api-contracts` tagged errors (e.g. `SandboxNotFoundError`), Effect HTTP-client
+ * fails with `@sealant/api-contracts` tagged errors (e.g. `WorkspaceNotFoundError`), Effect HTTP-client
  * errors, or schema decode errors; the runtime squashes the `Cause` to its failure value and hands it
  * here. This is the single funnel that keeps Effect internals out of the public, Promise-based API.
  */