@gitterm/sdk 0.8.0 → 0.10.0

package/README.md

@@ -12,8 +12,8 @@ bun add @gitterm/sdk
 npm install @gitterm/sdk
 ```
 
-Requires Node 22.12+ or Bun. Create an API token in the dashboard under
-**Settings → Account → API tokens**, or with `gitterm login`.
+Requires Node 22.12+ or Bun. Create an API token under **API tokens** in the dashboard, or with
+`gitterm login`.
 
 ## Quick start
 
@@ -23,12 +23,10 @@ Create a workspace, run a prompt, and get the final result:
 import { createGittermClient } from "@gitterm/sdk";
 
 const client = createGittermClient({ token: process.env.GITTERM_API_TOKEN });
-const [github] = await client.integrations.connections.list({ integration: "github" });
-if (!github) throw new Error("Connect GitHub in the Gitterm dashboard first");
 
 const { workspace } = await client.workspaces.create({
   repo: "https://github.com/acme/product",
-  connections: [github.id],
+  connections: ["github"], // the GitHub connection that covers acme
   autoTerminateAfterMs: 2 * 60 * 60 * 1000,
 });
 
@@ -48,19 +46,24 @@ try {
 ```
 
 Every integration you can attach, personal or admin-provided, is a **connection** with one shape.
-Attach any number by id (at most one per integration):
+Reference each one the way you remember it:
 
 ```ts
-const connections = await client.integrations.connections.list();
-const github = connections.find((c) => c.integration === "github");
-const google = connections.find((c) => c.integration === "google");
-
 await client.workspaces.create({
   repo: "https://github.com/acme/product",
-  connections: [github!.id, google!.id],
+  connections: [
+    "github", // integration key: the GitHub connection that covers acme, or the shared one
+    "Linear", // a connection name, as shown under Integrations (case-insensitive)
+    "3f7d0c2e-…", // or an id from connections.list()
+  ],
 });
 ```
 
+An integration key works when it is unambiguous: `github` picks by the repository's owner;
+`google`, `mcp`, and `executor` need exactly one connection of that kind. Names are not unique, so
+a name shared by two connections is rejected with both ids; use the id or rename one. At most one
+GitHub and one Google connection can be attached; MCP and Executor connections are unlimited.
+
 GitHub tokens and Google workload credentials are issued inside the workspace; the SDK caller does
 not receive or forward them.
 
@@ -168,6 +171,7 @@ client.credentials.listProviders();
 client.integrations.catalog();         // integrations the admin enabled: key, category, personal/shared
 client.integrations.connections.list(filter?); // what you can attach; personal + shared, one shape
 client.integrations.connections.get(id);
+client.integrations.connections.resolve(references, { repo }); // what ids/keys/names attach
 client.integrations.connections.create(input); // integrations:write; may return a browser step
 client.integrations.connections.remove(id);
 client.integrations.connections.waitFor({ integration, since }); // after a `pending` create
@@ -300,6 +304,11 @@ running `gh auth login`:
 - Without repository credentials or an integration, GitTerm leaves CLI authentication
   to the environment or the CLI's existing configuration.
 
+Commit attribution is separate from these push credentials. By default the workspace owner
+is the author (their GitHub noreply address when GitHub is linked) and GitTerm is the
+committer: the GitHub App's bot account when the deployment uses an app. **Settings →
+Account → Commit attribution** makes the owner both instead, for new workspaces.
+
 GitTerm supplies `GH_TOKEN` only to the invoked CLI process, so there is no stale
 installation token exported into the agent's long-running environment. Explicit
 `GH_TOKEN` or `GITHUB_TOKEN` environment variables override this CLI authentication;
@@ -482,8 +491,10 @@ await client.workspaces.create({
 
 `provider` is a discriminated union, so TypeScript only offers `region` for providers
 where GitTerm supports caller-selected placement. Machine keys are configured by admins
-and returned by `client.catalog.workspaceOptions()`; raw CPU, memory, credentials, and
-provider account configuration are never supplied by SDK callers.
+and returned by `client.catalog.workspaceOptions()` with their `vcpus` and `memoryGb`;
+raw CPU, memory, credentials, and provider account configuration are never supplied by SDK
+callers. The catalog lists only the sizes you may use: an admin can pin a provider to its
+default size, and on managed GitTerm the Free plan gets each provider's smallest size.
 
 This makes release automation a normal workspace task: create an OpenCode workspace,
 run UI review or browser capture tools in the sandbox, upload the resulting media, update
@@ -502,7 +513,7 @@ A workspace has one of four statuses:
 | `terminated` | Gone for good.                                                                            |
 
 Whether `create()` returns `running` or `pending` depends on the provider. Sandbox providers
-(E2B, Daytona, Vercel, Ascii, exe.dev, Cloudflare) settle immediately and return `running`.
+(E2B, Daytona, Vercel, boat, exe.dev, Cloudflare) settle immediately and return `running`.
 Railway settles by webhook and returns `pending` until its deployment reports success, usually
 within a minute. Code that only ever ran against a sandbox provider will see `pending` for the
 first time when it moves to Railway.
@@ -726,7 +737,7 @@ const { workspace } = await client.workspaces.create({
 
 const run = await client.runs.create({
   workspace,
-  model: "anthropic/claude-sonnet-4-20250514",
+  model: "anthropic/claude-sonnet-5-5",
   prompt: "Record before/after videos of the changes in PR #42",
 });
 ```
@@ -840,7 +851,7 @@ await saveConfig({
 ```
 
 Device-code logins produce the same revocable `gt_...` API token as the dashboard;
-they appear in **Settings → Account → API tokens** and can be revoked there.
+they appear under **API tokens** in the dashboard and can be revoked there.
 
 ## Direct provider mode
 
@@ -853,7 +864,7 @@ All built-in compute providers use the same provisioning plan and workspace/run
 | E2B      | OpenCode-compatible template                                   | Yes              | Yes        |
 | Daytona  | Public Gitterm OpenCode server image by default                | Yes              | Yes        |
 | Vercel   | Vercel Sandbox project                                         | Yes              | Yes        |
-| Ascii    | Box API key                                                    | Yes              | Yes        |
+| boat     | boat API key (provider type `ascii`)                           | Yes              | Yes        |
 | exe.dev  | Lifecycle token, or an existing VM with `ls,ssh,share,ssh-key` | Yes              | No         |
 | Railway  | Project/environment and public service domains                 | With a volume    | No         |
 

package/dist/client.d.ts

@@ -1,4 +1,4 @@
-import type { AgentType, AgentRun, AgentRunCreateInput, AgentRunListOptions, AgentRunListResult, AgentRunMessage, AgentRunReply, AuthStatus, CloudProvider, RunRef, RunWaitOptions, RunWatchOptions, WaitOptions, Workspace, WorkspaceCreateInput, WorkspaceCreateResult, WorkspaceEnsureRunningResult, WorkspaceListOptions, WorkspaceListResult, WorkspaceRef, WorkspaceRestartResult, WorkspaceRuntimeAccess, WorkspacePauseResult, WorkspaceTerminateResult, WorkspaceCatalog, WorkspaceSetupStatus, ModelCredential, ModelProviderInfo, Integration, IntegrationKey, Connection, ConnectionKind, CreateConnectionInput, CreateConnectionResult, GitHubRepository, GitHubBranch, GoogleSetup } from "./types.js";
+import type { AgentType, AgentRun, AgentRunCreateInput, AgentRunListOptions, AgentRunListResult, AgentRunMessage, AgentRunReply, AuthStatus, CloudProvider, RunRef, RunWaitOptions, RunWatchOptions, WaitOptions, Workspace, WorkspaceCreateInput, WorkspaceCreateResult, WorkspaceEnsureRunningResult, WorkspaceListOptions, WorkspaceListResult, WorkspaceRef, WorkspaceRestartResult, WorkspaceRuntimeAccess, WorkspacePauseResult, WorkspaceTerminateResult, WorkspaceCatalog, WorkspaceSetupStatus, ModelCredential, ModelProviderInfo, Integration, IntegrationKey, Connection, SavedBot, ConnectionKind, CreateConnectionInput, CreateConnectionResult, GitHubRepository, GitHubBranch, GoogleSetup, McpConnectionTestResult, UpdateMcpConnectionInput } from "./types.js";
 import type { AgentRunEvent, AgentRunResult, RunResultOptions, WorkspaceModelAccess } from "./types.js";
 export type GittermClientOptions = {
     serverUrl?: string;
@@ -69,6 +69,17 @@ export type GittermClient = {
         list(): Promise<ModelCredential[]>;
         listProviders(): Promise<ModelProviderInfo[]>;
     };
+    bots: {
+        /** Claims (or renews) the right to run this saved bot; one process at a time. */
+        acquireLease(leaseId: string): Promise<{
+            success: true;
+        }>;
+        releaseLease(leaseId: string): Promise<{
+            success: true;
+        }>;
+        /** The settings saved for this client's token in the dashboard; null if it isn't a bot's. */
+        self(): Promise<SavedBot | null>;
+    };
     integrations: {
         /** Integrations the admin has enabled for this deployment. */
         catalog(): Promise<Integration[]>;
@@ -79,6 +90,14 @@ export type GittermClient = {
                 kind?: ConnectionKind;
             }): Promise<Connection[]>;
             get(id: string): Promise<Connection>;
+            /**
+             * The connections `workspaces.create({ connections })` would attach for these references
+             * (ids, integration keys, or names), without creating anything. Rejects with the same
+             * message creation would, e.g. for an ambiguous name. Pass `repo` to resolve `"github"`.
+             */
+            resolve(references: string[], options?: {
+                repo?: string;
+            }): Promise<Connection[]>;
             /** Requires the `integrations:write` scope. */
             create(input: CreateConnectionInput): Promise<CreateConnectionResult>;
             /** Removes a personal connection. Shared connections are managed by the admin. */
@@ -92,6 +111,7 @@ export type GittermClient = {
                 since?: Date | string;
                 timeoutMs?: number;
                 intervalMs?: number;
+                connectionId?: string;
             }): Promise<Connection>;
         };
         github: {
@@ -103,6 +123,10 @@ export type GittermClient = {
             /** Issuer and attribute mapping to configure the Google provider before connecting. */
             setup(): Promise<GoogleSetup>;
         };
+        mcp: {
+            test(id: string): Promise<McpConnectionTestResult>;
+            update(input: UpdateMcpConnectionInput): Promise<Connection>;
+        };
     };
 };
 export declare function createGittermClient(options?: GittermClientOptions): GittermClient;

package/dist/direct/index.js

@@ -2177,12 +2177,12 @@ var WORKSPACE_LIFECYCLE_ERROR_CODES = [
 
 class GittermError extends Error {
   code;
-  cause;
+  status;
   constructor(code, message, options = {}) {
-    super(message);
+    super(message, "cause" in options ? { cause: options.cause } : undefined);
     this.name = "GittermError";
     this.code = code;
-    this.cause = options.cause;
+    this.status = options.status;
   }
 }
 
@@ -3341,7 +3341,7 @@ function createAsciiDirectProvider(config) {
   async function deleteBox(boxId) {
     const response = await fetch(`https://ascii.dev/api/box/v1/boxes/${boxId}`, {
       method: "DELETE",
-      headers: { Authorization: `Bearer ${config.apiKey}` }
+      headers: { Authorization: `Bearer ${config.apiKey}`, "X-Ascii-Confirm-Delete": boxId }
     });
     if (!response.ok && response.status !== 404) {
       throw new Error(`Ascii Box deletion failed (${response.status})`);

package/dist/errors.d.ts

@@ -5,15 +5,18 @@ export type WorkspaceLifecycleErrorCode = "WORKSPACE_NOT_RUNNING" | "WORKSPACE_T
 export declare const WORKSPACE_LIFECYCLE_ERROR_CODES: readonly WorkspaceLifecycleErrorCode[];
 export declare class GittermError extends Error {
     readonly code: GittermErrorCode;
-    readonly cause?: unknown;
+    /** HTTP status of the API response; undefined when the server never answered. */
+    readonly status: number | undefined;
     constructor(code: GittermErrorCode, message: string, options?: {
         cause?: unknown;
+        status?: number;
     });
 }
 export declare class WorkspaceLifecycleError extends GittermError {
     readonly code: WorkspaceLifecycleErrorCode;
     constructor(code: WorkspaceLifecycleErrorCode, message: string, options?: {
         cause?: unknown;
+        status?: number;
     });
 }
 /** result() could not produce a successful result. The run remains inspectable. */

package/dist/index.d.ts

@@ -6,4 +6,4 @@ export type { DeviceCodeInfo, LoginWithDeviceCodeOptions } from "./device-login.
 export { AgentRunError, GittermError, WorkspaceLifecycleError } from "./errors.js";
 export { createGittermWorkspaceClient, getWorkspaceEnvironment, type GittermWorkspaceClient, type WorkspaceClientOptions, type WorkspaceEnvironment, type WorkspacePort, type WorkspacePortVisibility, type WorkspaceSelf, } from "./workspace-client.js";
 export type { CredentialErrorCode, GittermErrorCode, WorkspaceLifecycleErrorCode, } from "./errors.js";
-export type { AgentPermissionRequest, AgentQuestion, AgentQuestionOption, AgentQuestionRequest, AgentRun, AgentRunAttachment, AgentRunCreateInput, AgentRunInputRequest, AgentRunMessage, AgentRunMessagePart, AgentRunReply, AgentRunStatus, AgentRunEvent, AgentRunResult, AgentRunReplyPermission, AgentRunReplyQuestion, RunResultOptions, RunRef, RunWaitOptions, RunWatchOptions, AgentType, AgentKey, AuthStatus, BuiltInAgentKey, CloudProvider, ProviderKey, Workspace, WorkspaceCreateInput, WorkspaceCreateResult, WorkspaceCatalog, WorkspaceEnsureRunningResult, WorkspaceHostingType, WorkspaceListOptions, WorkspaceListResult, WorkspaceRestartResult, WorkspaceRuntimeAccess, WorkspaceStatus, WorkspaceSetupStatus, ModelCredential, ModelProviderInfo, ModelCredentialSource, WorkspaceModelsInput, WorkspaceModelAccess, WorkspacePauseResult, WorkspaceTerminateResult, WorkspaceProviderSelection, Integration, IntegrationKey, IntegrationCategory, Connection, ConnectionKind, ConnectionStatus, ConnectionDetails, GitHubConnectionDetails, GoogleConnectionDetails, CreateConnectionInput, CreateConnectionResult, GitHubRepository, GitHubBranch, GoogleSetup, } from "./types.js";
+export type { AgentPermissionRequest, AgentQuestion, AgentQuestionOption, AgentQuestionRequest, AgentRun, AgentRunAttachment, AgentRunCreateInput, AgentRunInputRequest, AgentRunMessage, AgentRunMessagePart, AgentRunReply, AgentRunStatus, AgentRunEvent, AgentRunResult, AgentRunReplyPermission, AgentRunReplyQuestion, RunResultOptions, RunRef, RunWaitOptions, RunWatchOptions, AgentType, AgentKey, AuthStatus, BuiltInAgentKey, CloudProvider, ProviderKey, Workspace, WorkspaceCreateInput, WorkspaceCreateResult, WorkspaceCatalog, WorkspaceEnsureRunningResult, WorkspaceHostingType, WorkspaceListOptions, WorkspaceListResult, WorkspaceRestartResult, WorkspaceRuntimeAccess, WorkspaceStatus, WorkspaceSetupStatus, ModelCredential, ModelProviderInfo, ModelCredentialSource, WorkspaceModelsInput, WorkspaceModelAccess, WorkspacePauseResult, WorkspaceTerminateResult, WorkspaceProviderSelection, Integration, IntegrationKey, IntegrationCategory, Connection, SavedBot, ConnectionKind, ConnectionStatus, ConnectionDetails, GitHubConnectionDetails, GoogleConnectionDetails, McpConnectionDetails, McpAuthentication, CreateMcpConnectionInput, UpdateMcpConnectionInput, McpConnectionTestResult, CreateConnectionInput, CreateConnectionResult, GitHubRepository, GitHubBranch, GoogleSetup, } from "./types.js";

package/dist/index.js

@@ -68,12 +68,12 @@ var WORKSPACE_LIFECYCLE_ERROR_CODES = [
 
 class GittermError extends Error {
   code;
-  cause;
+  status;
   constructor(code, message, options = {}) {
-    super(message);
+    super(message, "cause" in options ? { cause: options.cause } : undefined);
     this.name = "GittermError";
     this.code = code;
-    this.cause = options.cause;
+    this.status = options.status;
   }
 }
 
@@ -288,7 +288,12 @@ function runHelpers(operations) {
 
 // src/client.ts
 function toConnection(connection) {
-  return { ...connection, connectedAt: toIso(connection.connectedAt) };
+  const details = connection.details;
+  return {
+    ...connection,
+    connectedAt: toIso(connection.connectedAt),
+    details: "lastCheckedAt" in details ? { ...details, lastCheckedAt: toIso(details.lastCheckedAt) } : details
+  };
 }
 function envValue(name) {
   const value = typeof process !== "undefined" ? process.env[name] : undefined;
@@ -421,27 +426,26 @@ function toGittermError(serverUrl, error) {
     return error;
   if (error instanceof TRPCClientError) {
     const data = error.data;
-    const trpcCode = data?.code;
-    if (!error.data) {
+    if (!data) {
       return new GittermError("NETWORK", `Could not reach the GitTerm server at ${serverUrl}`, {
-        cause: error
+        cause: error.cause ?? error
       });
     }
-    const code = mapTrpcCode(trpcCode);
-    const structuredLifecycleCode = WORKSPACE_LIFECYCLE_ERROR_CODES.find((candidate) => candidate === data?.workspaceLifecycleCode);
+    const status = { status: data.httpStatus };
+    const structuredLifecycleCode = WORKSPACE_LIFECYCLE_ERROR_CODES.find((candidate) => candidate === data.workspaceLifecycleCode);
     if (structuredLifecycleCode) {
-      return new WorkspaceLifecycleError(structuredLifecycleCode, error.message, { cause: error });
+      return new WorkspaceLifecycleError(structuredLifecycleCode, error.message, status);
     }
     if (error.message.startsWith("INPUT_NOT_PENDING:"))
-      return new GittermError("INPUT_NOT_PENDING", error.message, { cause: error });
+      return new GittermError("INPUT_NOT_PENDING", error.message, status);
     const credentialCode = credentialErrorCode(error.message);
     if (credentialCode)
-      return new GittermError(credentialCode, error.message, { cause: error });
+      return new GittermError(credentialCode, error.message, status);
     const lifecycleCode = WORKSPACE_LIFECYCLE_ERROR_CODES.find((candidate) => error.message.startsWith(`${candidate}:`));
-    if (lifecycleCode) {
-      return new WorkspaceLifecycleError(lifecycleCode, error.message, { cause: error });
-    }
-    return new GittermError(code, code === "UNAUTHORIZED" ? `Authentication failed: ${error.message}. Check that the API token is valid and has not expired.` : error.message, { cause: error });
+    if (lifecycleCode)
+      return new WorkspaceLifecycleError(lifecycleCode, error.message, status);
+    const code = mapTrpcCode(data.code);
+    return new GittermError(code, code === "UNAUTHORIZED" ? `${error.message}. Check your GitTerm API token, or create a new one in the dashboard.` : error.message, status);
   }
   return new GittermError("NETWORK", error instanceof Error ? error.message : "Network request failed", { cause: error });
 }
@@ -698,14 +702,27 @@ ${log}` : ""}`);
           return result.map(toConnection);
         }),
         get: (id) => run(async () => toConnection(await trpc.integrations.connections.get.query({ id }))),
+        resolve: (references, options) => run(async () => {
+          const result = await trpc.integrations.connections.resolve.query({
+            references,
+            ...options?.repo ? { repo: options.repo } : {}
+          });
+          return result.map(toConnection);
+        }),
         create: (input) => run(async () => {
           const result = await trpc.integrations.connections.create.mutate(input);
-          return result.status === "connected" ? { ...result, connection: toConnection(result.connection) } : result;
+          return result.status !== "pending" ? { ...result, connection: toConnection(result.connection) } : result;
         }),
         remove: (id) => run(async () => {
           await trpc.integrations.connections.remove.mutate({ id });
         }),
-        waitFor: ({ integration, since, timeoutMs = 5 * 60000, intervalMs = 3000 }) => run(async () => {
+        waitFor: ({
+          integration,
+          since,
+          connectionId,
+          timeoutMs = 5 * 60000,
+          intervalMs = 3000
+        }) => run(async () => {
           const sinceMs = since ? new Date(since).getTime() : 0;
           const deadline = Date.now() + timeoutMs;
           while (Date.now() < deadline) {
@@ -713,7 +730,7 @@ ${log}` : ""}`);
               integration,
               kind: "personal"
             });
-            const match = result.map(toConnection).filter((c) => c.status === "connected" && new Date(c.connectedAt).getTime() >= sinceMs).sort((a, b) => b.connectedAt.localeCompare(a.connectedAt))[0];
+            const match = result.map(toConnection).filter((c) => c.status === "connected" && (connectionId ? c.id === connectionId : new Date(c.connectedAt).getTime() >= sinceMs)).sort((a, b) => b.connectedAt.localeCompare(a.connectedAt))[0];
             if (match)
               return match;
             await new Promise((resolve) => setTimeout(resolve, intervalMs));
@@ -727,8 +744,20 @@ ${log}` : ""}`);
       },
       google: {
         setup: () => run(async () => trpc.integrations.google.setup.query())
+      },
+      mcp: {
+        test: (id) => run(async () => {
+          const result = await trpc.integrations.mcp.test.mutate({ id });
+          return { ...result, connection: toConnection(result.connection) };
+        }),
+        update: (input) => run(async () => toConnection(await trpc.integrations.mcp.update.mutate(input)))
       }
     },
+    bots: {
+      acquireLease: (leaseId) => run(() => trpc.bots.acquireLease.mutate({ leaseId })),
+      releaseLease: (leaseId) => run(() => trpc.bots.releaseLease.mutate({ leaseId })),
+      self: () => run(async () => trpc.bots.self.query())
+    },
     credentials: {
       list: () => run(async () => {
         const result = await trpc.modelCredentials.listMyCredentials.query();

package/dist/types.d.ts

@@ -62,6 +62,7 @@ export type RunRef = {
     id: string;
 };
 export type WaitOptions = {
+    /** For `ensureRunning` the server maximum is 240000 (4 minutes). */
     timeoutMs?: number;
     pollIntervalMs?: number;
     /** Abort the wait early; the promise rejects with code `ABORTED`. */
@@ -106,50 +107,12 @@ export type ProviderKey = "railway" | "aws" | "e2b" | "daytona" | "cloudflare" |
 type ProviderSelectionBase = {
     /** Select a specific provider installation. Usually omitted. */
     providerId?: string;
-    /** An admin-defined profile or flexible resources within the provider's allowed limits. */
+    /** An admin-defined machine size, by key. */
     machine?: {
         type: "profile";
         key: string;
     };
 };
-type FlexibleMachine<T> = {
-    type: "profile";
-    key: string;
-} | {
-    type: "custom";
-    resources: T;
-};
-type AwsResources = {
-    cpu?: number;
-    memory?: number;
-    ephemeralStorageGiB?: number;
-    architecture?: "X86_64" | "ARM64";
-};
-type DaytonaResources = {
-    resources?: {
-        cpu?: number;
-        memory?: number;
-        disk?: number;
-    };
-    editorResources?: {
-        cpu?: number;
-        memory?: number;
-        disk?: number;
-    };
-};
-type VercelResources = {
-    vcpus?: number;
-};
-type ExeDevResources = {
-    cpu?: number;
-    memory?: string;
-    disk?: string;
-};
-/** E2B fixes CPU/RAM per template, so resources select a template build. */
-type E2bResources = {
-    templateId?: string;
-    sshTemplateId?: string;
-};
 export type WorkspaceProviderSelection = {
     type: "railway";
     providerId?: string;
@@ -158,26 +121,8 @@ export type WorkspaceProviderSelection = {
     type: "aws";
     region?: string;
     accessProfile?: string;
-} & Omit<ProviderSelectionBase, "machine"> & {
-    machine?: FlexibleMachine<AwsResources>;
-}) | ({
-    type: "daytona";
-} & Omit<ProviderSelectionBase, "machine"> & {
-    machine?: FlexibleMachine<DaytonaResources>;
-}) | ({
-    type: "vercel";
-} & Omit<ProviderSelectionBase, "machine"> & {
-    machine?: FlexibleMachine<VercelResources>;
-}) | ({
-    type: "exedev";
-} & Omit<ProviderSelectionBase, "machine"> & {
-    machine?: FlexibleMachine<ExeDevResources>;
-}) | ({
-    type: "e2b";
-} & Omit<ProviderSelectionBase, "machine"> & {
-    machine?: FlexibleMachine<E2bResources>;
-}) | ({
-    type: "ascii";
+} & ProviderSelectionBase) | ({
+    type: "daytona" | "vercel" | "exedev" | "e2b" | "ascii";
 } & ProviderSelectionBase) | {
     type: "cloudflare";
     providerId?: string;
@@ -185,6 +130,7 @@ export type WorkspaceProviderSelection = {
 export type BuiltInAgentKey = "opencode-ttyd" | "opencode" | "t3code";
 export type AgentKey = BuiltInAgentKey | (string & {});
 export type WorkspaceCreateInput = {
+    provisioningProfile?: "personal" | "bot";
     idempotencyKey?: string;
     name?: string;
     /**
@@ -225,13 +171,21 @@ export type WorkspaceCreateInput = {
         token: string;
     };
     /**
-     * Connection ids to attach, from `client.integrations.connections.list()`. At most one per
-     * integration. A GitHub connection renews Git/gh credentials automatically; a Google connection
-     * injects keyless ADC/gcloud auth. Cannot be combined with `repositoryCredentials` for GitHub.
+     * Connections to attach. Each is a connection id from `client.integrations.connections.list()`,
+     * an integration key, or a connection name (case-insensitive; ambiguous names are rejected).
+     * `"github"` attaches the connection that covers the repository's owner, or the deployment's
+     * shared one. At most one GitHub and one Google connection; any number of MCP/Executor ones.
+     * A GitHub connection renews Git/gh credentials automatically; a Google connection injects
+     * keyless ADC/gcloud auth. Cannot be combined with `repositoryCredentials` for GitHub.
      */
     connections?: string[];
     /** Defaults from the selected provider. */
     persistent?: boolean;
+    /**
+     * Keep the workspace running while idle instead of pausing it. On managed
+     * GitTerm this needs a paid plan, and spending limits still pause it.
+     */
+    alwaysOn?: boolean;
     workspaceProfile?: "standard" | "ssh-enabled";
     /** Omit to use dashboard defaults. An explicit block inherits nothing unless requested. */
     models?: WorkspaceModelsInput;
@@ -283,7 +237,7 @@ export type Integration = {
     allowShared: boolean;
 };
 export type ConnectionKind = "personal" | "shared";
-export type ConnectionStatus = "connected" | "suspended";
+export type ConnectionStatus = "connected" | "suspended" | "untested" | "needs_auth" | "error";
 export type GitHubConnectionDetails = {
     integration: "github";
     mode: "app" | "pat";
@@ -305,7 +259,42 @@ export type GoogleConnectionDetails = {
         attributeMapping: Record<string, string>;
     };
 };
-export type ConnectionDetails = GitHubConnectionDetails | GoogleConnectionDetails;
+export type McpConnectionDetails = {
+    revision?: number;
+    integration: "mcp" | "executor";
+    url: string;
+    authType: "none" | "bearer" | "headers";
+    codemode: boolean;
+    toolCount: number | null;
+    serverInfo: {
+        name: string;
+        version: string;
+    } | null;
+    lastCheckedAt: string | null;
+};
+export type McpAuthentication = {
+    type: "none";
+} | {
+    type: "headers";
+    headers: Record<string, string>;
+};
+export type CreateMcpConnectionInput = {
+    integration: "mcp" | "executor";
+    name: string;
+    url: string;
+    authentication: McpAuthentication;
+    codemode?: boolean;
+};
+export type UpdateMcpConnectionInput = Omit<CreateMcpConnectionInput, "integration" | "authentication"> & {
+    id: string;
+    authentication?: McpAuthentication;
+};
+export type McpConnectionTestResult = {
+    status: "connected" | "needs_auth" | "error";
+    message: string;
+    connection: Connection;
+};
+export type ConnectionDetails = GitHubConnectionDetails | GoogleConnectionDetails | McpConnectionDetails;
 /**
  * Something you can attach to a workspace via `connections: [id]`. Personal connections are
  * owned by you; shared ones are provided by the admin and have stable ids like `github:shared`.
@@ -328,15 +317,16 @@ export type CreateConnectionInput = {
     serviceAccountEmail: string;
 } | {
     integration: "github";
-};
+} | CreateMcpConnectionInput;
 export type CreateConnectionResult = {
-    status: "connected";
+    status: "connected" | "saved";
     connection: Connection;
     /** Commands you still need to run outside GitTerm, e.g. the Google IAM binding. */
     nextSteps: Array<{
         label: string;
         command: string;
     }>;
+    message?: string;
 } | {
     /** Finish in a browser at `authorizeUrl`, then `connections.waitFor()` the new connection. */
     status: "pending";
@@ -440,6 +430,8 @@ export type AgentRunReply = {
     reject: true;
 };
 export type AgentRun = {
+    /** A runtime snapshot was read successfully, even if it contained no final text. */
+    outputAvailable?: boolean;
     id: string;
     workspaceId: string;
     title: string;
@@ -488,6 +480,8 @@ export type AgentRunAttachment = {
     data: string;
 };
 export type AgentRunCreateInput = {
+    /** Absolute execution deadline enforced by the server, even if the client disconnects. */
+    deadlineAt?: string;
     workspace: WorkspaceRef;
     /**
      * Stable key used to return the same run when a request is retried.
@@ -730,11 +724,18 @@ export type WorkspaceCatalog = {
             description: string;
             roleArn: string;
         }>;
+        /** Where the provider runs workspaces (e.g. "EU", "US"); null when not set. */
+        location: string | null;
+        /** Sizes you may pick on this provider; `isDefault` is used when none is requested. */
         machines: Array<{
             id: string;
             key: string;
             name: string;
             description: string | null;
+            vcpus: number | null;
+            memoryGb: number | null;
+            /** Hourly price in millionths of a dollar on managed GitTerm; null when unpriced. */
+            priceMicrosPerHour: number | null;
             isDefault: boolean;
         }>;
         agentKeys: string[];
@@ -748,4 +749,30 @@ export type WorkspaceCatalog = {
         workspaceApiAccess: boolean;
     }>;
 };
+/** A chat bot's settings, saved in the dashboard (Bots). Secrets stay in the bot's .env. */
+export type SavedBot = {
+    id: string;
+    name: string;
+    platform: "slack" | "discord";
+    /** Repository URL, with `#branch` when one is picked. */
+    repo: string;
+    /** OpenCode `provider/model`. */
+    model: string;
+    /** Saved credential label; null uses the provider's default credential. */
+    credential: string | null;
+    /** Tool connection references besides GitHub. */
+    connections: string[];
+    /** Compute provider key; null uses your default. */
+    provider: string | null;
+    /** "token": the bot brings its own GITTERM_BOT_GITHUB_TOKEN. */
+    githubAccess: "connection" | "token";
+    /** Channel ids it answers in; empty answers in every channel it's in. */
+    channels: string[];
+    /** User ids allowed to use it; empty allows everyone in the channel. */
+    allowedUsers: string[];
+    allowGuests: boolean;
+    instructions: string | null;
+    /** A command run in the checkout before the agent starts in a new sandbox. */
+    setup: string | null;
+};
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gitterm/sdk",
-  "version": "0.8.0",
+  "version": "0.10.0",
   "files": [
     "dist"
   ],