@tangle-network/agent-app 0.21.0 → 0.23.0

package/dist/sandbox/index.d.ts

@@ -1,8 +1,191 @@
-import { AgentProfileFileMount, AgentProfileMcpServer, AgentProfile, ScopedTokenScope, SandboxInstance, Sandbox } from '@tangle-network/sandbox';
+import { AgentProfileFileMount, AgentProfileMcpServer, AgentProfile, StorageConfig, SandboxInstance, ScopedTokenScope, PromptResult, Sandbox } from '@tangle-network/sandbox';
+export { StorageConfig } from '@tangle-network/sandbox';
 import { a as AppToolName, c as ToolHeaderNames } from '../auth-BlS9GWfL.js';
 import { b as AppToolContext } from '../types-2rOJo8Hc.js';
 import { Harness } from '../harness/index.js';
 
+interface WorkspaceSandboxInstanceLike {
+    id: string;
+    name?: string;
+    status?: string;
+    connection?: {
+        runtimeUrl?: string;
+        sidecarUrl?: string;
+        authToken?: string;
+        sidecarToken?: string;
+        authTokenExpiresAt?: string;
+    } | null;
+}
+interface WorkspaceSandboxEnsureContext {
+    workspaceId: string;
+    userId: string;
+}
+interface WorkspaceSandboxManagerOptions<TClient, TBox extends WorkspaceSandboxInstanceLike, TEnsureOptions = void> {
+    getClient: (ctx: WorkspaceSandboxEnsureContext) => Promise<TClient> | TClient;
+    nameForWorkspace: (workspaceId: string, ctx: WorkspaceSandboxEnsureContext) => string;
+    listSandboxes: (client: TClient, ctx: WorkspaceSandboxEnsureContext) => Promise<TBox[]>;
+    createSandbox: (args: {
+        client: TClient;
+        ctx: WorkspaceSandboxEnsureContext;
+        name: string;
+        options: TEnsureOptions;
+        listError?: unknown;
+    }) => Promise<TBox>;
+    waitForRunning?: (box: TBox, ctx: WorkspaceSandboxEnsureContext) => Promise<void>;
+    prepareExisting?: (box: TBox, ctx: WorkspaceSandboxEnsureContext, options: TEnsureOptions) => Promise<TBox | void>;
+    prepareCreated?: (box: TBox, ctx: WorkspaceSandboxEnsureContext, options: TEnsureOptions) => Promise<TBox | void>;
+    onListError?: (error: unknown, ctx: WorkspaceSandboxEnsureContext) => void;
+}
+interface WorkspaceSandboxManager<TBox extends WorkspaceSandboxInstanceLike, TEnsureOptions = void> {
+    ensureWorkspaceSandbox: (workspaceId: string, userId: string, options?: TEnsureOptions) => Promise<TBox>;
+}
+declare function createWorkspaceSandboxManager<TClient, TBox extends WorkspaceSandboxInstanceLike, TEnsureOptions = void>(opts: WorkspaceSandboxManagerOptions<TClient, TBox, TEnsureOptions>): WorkspaceSandboxManager<TBox, TEnsureOptions>;
+interface SandboxTerminalTokenOptions {
+    secret?: string;
+    prefix?: string;
+    expiresInMs?: number;
+    now?: () => number;
+}
+interface SandboxTerminalTokenSubject {
+    userId: string;
+    workspaceId: string;
+    sandboxId: string;
+}
+interface SandboxTerminalTokenResult {
+    token: string;
+    expiresAt: Date;
+}
+declare function createSandboxTerminalToken(subject: SandboxTerminalTokenSubject, opts: SandboxTerminalTokenOptions): Promise<SandboxTerminalTokenResult>;
+declare function verifySandboxTerminalToken(token: string, expected: SandboxTerminalTokenSubject, opts: SandboxTerminalTokenOptions): Promise<boolean>;
+interface AuthenticatedSandboxUser {
+    id: string;
+}
+interface WorkspaceSandboxConnectionHandlerOptions<TBox extends WorkspaceSandboxInstanceLike> {
+    requireUser: (request: Request) => Promise<AuthenticatedSandboxUser>;
+    requireWorkspaceAccess: (args: {
+        request: Request;
+        userId: string;
+        workspaceId: string;
+    }) => Promise<void>;
+    ensureWorkspaceSandbox: (workspaceId: string, userId: string) => Promise<TBox>;
+    tokenSecret: string | (() => string | undefined);
+    tokenExpiresInMs?: number;
+    tokenPrefix?: string;
+    proxyRuntimeUrl?: (args: {
+        request: Request;
+        workspaceId: string;
+        sandboxId: string;
+        box: TBox;
+    }) => string;
+    exposeDirectSidecar?: boolean;
+}
+interface WorkspaceSandboxConnectionArgs {
+    request: Request;
+    params: {
+        workspaceId?: string;
+    };
+}
+declare function createWorkspaceSandboxConnectionHandler<TBox extends WorkspaceSandboxInstanceLike>(opts: WorkspaceSandboxConnectionHandlerOptions<TBox>): ({ request, params }: WorkspaceSandboxConnectionArgs) => Promise<Response>;
+interface SandboxApiCredentials {
+    baseUrl: string;
+    apiKey: string;
+}
+interface SandboxRuntimeConnection {
+    runtimeUrl: string;
+    authToken?: string;
+}
+interface WorkspaceSandboxRuntimeProxyHandlerOptions {
+    requireUser: (request: Request) => Promise<AuthenticatedSandboxUser>;
+    requireWorkspaceAccess: (args: {
+        request: Request;
+        userId: string;
+        workspaceId: string;
+        sandboxId: string;
+    }) => Promise<void>;
+    getSandboxApiCredentials: (args: {
+        request: Request;
+        userId: string;
+        workspaceId: string;
+        sandboxId: string;
+    }) => Promise<SandboxApiCredentials>;
+    getSandboxRuntimeConnection?: (args: {
+        request: Request;
+        userId: string;
+        workspaceId: string;
+        sandboxId: string;
+    }) => Promise<SandboxRuntimeConnection | null | undefined>;
+    tokenSecret: string | (() => string | undefined);
+    tokenPrefix?: string;
+    fetch?: typeof fetch;
+    forwardHeaders?: string[];
+}
+interface WorkspaceSandboxRuntimeProxyArgs {
+    request: Request;
+    params: {
+        workspaceId?: string;
+        sandboxId?: string;
+        '*'?: string;
+    };
+}
+declare function createWorkspaceSandboxRuntimeProxyHandler(opts: WorkspaceSandboxRuntimeProxyHandlerOptions): ({ request, params }: WorkspaceSandboxRuntimeProxyArgs) => Promise<Response>;
+interface SandboxTerminalWsMatch {
+    workspaceId: string;
+    sandboxId: string;
+    subPath: string;
+}
+/**
+ * Parse a same-origin terminal-WS pathname into its parts, or `null` when the
+ * path is not a sandbox terminal WebSocket. Matches the default `runtimeUrl`
+ * convention emitted by {@link createWorkspaceSandboxConnectionHandler}
+ * (`/api/workspaces/:workspaceId/sandbox/runtime/:sandboxId`) with a canonical
+ * `terminals/:id/ws` sub-path. `subPath` is left URL-encoded for re-use in the
+ * upstream URL; the ids are decoded for auth checks.
+ */
+declare function matchSandboxTerminalWsPath(pathname: string): SandboxTerminalWsMatch | null;
+/** True when `request` is a WebSocket upgrade for a sandbox terminal path. */
+declare function isSandboxTerminalWsUpgrade(request: Request): boolean;
+interface WorkspaceSandboxTerminalUpgradeHandlerOptions {
+    requireUser: (request: Request) => Promise<AuthenticatedSandboxUser>;
+    requireWorkspaceAccess: (args: {
+        request: Request;
+        userId: string;
+        workspaceId: string;
+        sandboxId: string;
+    }) => Promise<void>;
+    getSandboxApiCredentials: (args: {
+        request: Request;
+        userId: string;
+        workspaceId: string;
+        sandboxId: string;
+    }) => Promise<SandboxApiCredentials>;
+    getSandboxRuntimeConnection?: (args: {
+        request: Request;
+        userId: string;
+        workspaceId: string;
+        sandboxId: string;
+    }) => Promise<SandboxRuntimeConnection | null | undefined>;
+    tokenSecret: string | (() => string | undefined);
+    tokenPrefix?: string;
+    fetch?: typeof fetch;
+}
+/**
+ * Build a Worker-entry handler that proxies a sandbox terminal WebSocket
+ * upgrade to the sandbox API runtime proxy. Returns `null` when the request is
+ * not a terminal WS upgrade, so the caller can fall through to its normal
+ * request handler:
+ *
+ * ```ts
+ * const handled = await handleSandboxTerminalUpgrade(request)
+ * if (handled) return handled
+ * ```
+ */
+declare function createWorkspaceSandboxTerminalUpgradeHandler(opts: WorkspaceSandboxTerminalUpgradeHandlerOptions): (request: Request) => Promise<Response | null>;
+declare function buildSandboxRuntimeProxyHeaders(source: Headers, sandboxApiKey: string, forwardHeaders?: string[]): Headers;
+declare function encodeSandboxRuntimePath(runtimePath: string): string | null;
+declare function bearerToken(value: string | null): string | null;
+declare function bearerSubprotocolToken(value: string | null): string | null;
+declare function terminalTokenFromRequest(headers: Headers): string | null;
+
 type Outcome<T> = {
     succeeded: true;
     value: T;
@@ -33,6 +216,21 @@ interface ProviderResolutionConfig {
 interface SandboxBuildContext {
     workspaceId: string;
     connectedIntegrationIds: string[];
+    userId?: string;
+}
+
+interface SandboxScope {
+    workspaceId: string;
+    userId?: string;
+}
+interface SandboxRestoreSpec {
+    fromSnapshot: string;
+    fromSandboxId: string;
+}
+interface LivenessProbeConfig {
+    sidecarProcessPattern: (harness: Harness) => string;
+    execTimeoutMs?: number;
+    psTimeoutMs?: number;
 }
 interface ProfileComposeOptions {
     systemPrompt?: string;
@@ -41,7 +239,7 @@ interface ProfileComposeOptions {
     name?: string;
 }
 interface SandboxRuntimeConfig {
-    credentials: () => SandboxClientCredentials | null;
+    credentials: (scope?: SandboxScope) => SandboxClientCredentials | null | Promise<SandboxClientCredentials | null>;
     name: (workspaceId: string) => string;
     metadata: (harness: Harness) => Record<string, unknown>;
     connectedIntegrationIds: (workspaceId: string) => Promise<string[]>;
@@ -52,6 +250,14 @@ interface SandboxRuntimeConfig {
     permissionRole?: (workspaceRole: string) => SandboxPermissionLevel;
     resources?: SandboxResourceConfig;
     provider?: ProviderResolutionConfig;
+    storage?: (ctx: SandboxBuildContext) => StorageConfig | undefined;
+    restore?: (ctx: SandboxBuildContext) => SandboxRestoreSpec | undefined;
+    boxKey?: (scope: SandboxScope) => string;
+    childKeyMint?: (scope: SandboxScope) => Promise<Outcome<string>>;
+    bootstrap?: (box: SandboxInstance, scope: SandboxScope) => Promise<Outcome<void>>;
+    livenessProbe?: LivenessProbeConfig;
+    resumeStopped?: boolean;
+    backendModelAtCreate?: boolean;
 }
 declare const DEFAULT_SANDBOX_RESOURCES: SandboxResourceConfig;
 declare function getClient(shell: SandboxRuntimeConfig): Sandbox;
@@ -73,6 +279,7 @@ interface EnsureWorkspaceSandboxOptions {
     workspaceId: string;
     userId?: string;
     harness: Harness;
+    forceNew?: boolean;
 }
 declare function ensureWorkspaceSandbox(shell: SandboxRuntimeConfig, options: EnsureWorkspaceSandboxOptions): Promise<SandboxInstance>;
 interface ResolvedModel {
@@ -107,6 +314,9 @@ interface StreamSandboxPromptOptions {
     appToolMcp?: Record<string, AgentProfileMcpServer>;
     baseProfileMcp?: Record<string, AgentProfileMcpServer>;
     extraMcp?: Record<string, AgentProfileMcpServer>;
+    signal?: AbortSignal;
+    timeoutMs?: number;
+    disallowQuestions?: boolean;
 }
 declare function streamSandboxPrompt(shell: SandboxRuntimeConfig, box: SandboxInstance, message: string, options?: StreamSandboxPromptOptions): AsyncGenerator<unknown>;
 declare function runSandboxPrompt(shell: SandboxRuntimeConfig, box: SandboxInstance, message: string, options?: StreamSandboxPromptOptions): Promise<string>;
@@ -142,5 +352,28 @@ declare function mintSandboxScopedToken(box: SandboxInstance, options: {
     sessionId?: string;
     ttlMinutes?: number;
 }): Promise<Outcome<ScopedTokenResult>>;
+declare function driveSandboxTurn(shell: SandboxRuntimeConfig, box: SandboxInstance, message: string, options: StreamSandboxPromptOptions & {
+    sessionId: string;
+}): Promise<Outcome<PromptResult>>;
+interface TerminalProxyIdentity {
+    userId: string;
+    workspaceId: string;
+    sandboxId: string;
+}
+declare function mintTerminalProxyToken(secret: string, identity: TerminalProxyIdentity, ttlMs?: number): Promise<Outcome<{
+    token: string;
+    expiresAt: Date;
+}>>;
+declare function verifyTerminalProxyToken(secret: string, token: string, expected: TerminalProxyIdentity): Promise<boolean>;
+type SandboxStepTransition = {
+    kind: 'step-start';
+} | {
+    kind: 'step-finish';
+    reason: string;
+    severed: boolean;
+};
+declare function classifySeveredStream(event: unknown): SandboxStepTransition | null;
+declare function isTerminalPromptEvent(event: unknown): boolean;
+declare function detectInteractiveQuestion(event: unknown): string | null;
 
-export { type AppToolDescriptor, type BuildAppToolMcpServersOptions, DEFAULT_SANDBOX_RESOURCES, type EnsureWorkspaceSandboxOptions, type MemberSyncSeam, type Outcome, type ProfileComposeOptions, type ProviderResolutionConfig, type ResolvedModel, type SandboxBuildContext, type SandboxClientCredentials, type SandboxPermissionLevel, type SandboxResourceConfig, type SandboxRuntimeConfig, type ScopedTokenResult, type SecretStore, type StreamSandboxPromptOptions, attachReasoningEffort, buildAppToolMcpServers, deleteSecret, ensureWorkspaceSandbox, flattenHistory, getClient, mergeExtraMcp, mintSandboxScopedToken, readSecret, resetClientCache, resolveModel, runSandboxPrompt, secretStoreFromClient, storeSecret, streamSandboxPrompt, syncSandboxMemberAdd, syncSandboxMemberRemove, syncSandboxMemberRole };
+export { type AppToolDescriptor, type AuthenticatedSandboxUser, type BuildAppToolMcpServersOptions, DEFAULT_SANDBOX_RESOURCES, type EnsureWorkspaceSandboxOptions, type LivenessProbeConfig, type MemberSyncSeam, type Outcome, type ProfileComposeOptions, type ProviderResolutionConfig, type ResolvedModel, type SandboxApiCredentials, type SandboxBuildContext, type SandboxClientCredentials, type SandboxPermissionLevel, type SandboxResourceConfig, type SandboxRestoreSpec, type SandboxRuntimeConfig, type SandboxRuntimeConnection, type SandboxScope, type SandboxStepTransition, type SandboxTerminalTokenOptions, type SandboxTerminalTokenResult, type SandboxTerminalTokenSubject, type SandboxTerminalWsMatch, type ScopedTokenResult, type SecretStore, type StreamSandboxPromptOptions, type TerminalProxyIdentity, type WorkspaceSandboxConnectionArgs, type WorkspaceSandboxConnectionHandlerOptions, type WorkspaceSandboxEnsureContext, type WorkspaceSandboxInstanceLike, type WorkspaceSandboxManager, type WorkspaceSandboxManagerOptions, type WorkspaceSandboxRuntimeProxyArgs, type WorkspaceSandboxRuntimeProxyHandlerOptions, type WorkspaceSandboxTerminalUpgradeHandlerOptions, attachReasoningEffort, bearerSubprotocolToken, bearerToken, buildAppToolMcpServers, buildSandboxRuntimeProxyHeaders, classifySeveredStream, createSandboxTerminalToken, createWorkspaceSandboxConnectionHandler, createWorkspaceSandboxManager, createWorkspaceSandboxRuntimeProxyHandler, createWorkspaceSandboxTerminalUpgradeHandler, deleteSecret, detectInteractiveQuestion, driveSandboxTurn, encodeSandboxRuntimePath, ensureWorkspaceSandbox, flattenHistory, getClient, isSandboxTerminalWsUpgrade, isTerminalPromptEvent, matchSandboxTerminalWsPath, mergeExtraMcp, mintSandboxScopedToken, mintTerminalProxyToken, readSecret, resetClientCache, resolveModel, runSandboxPrompt, secretStoreFromClient, storeSecret, streamSandboxPrompt, syncSandboxMemberAdd, syncSandboxMemberRemove, syncSandboxMemberRole, terminalTokenFromRequest, verifySandboxTerminalToken, verifyTerminalProxyToken };

package/dist/sandbox/index.js

@@ -1,299 +1,73 @@
 import {
-  assertHarnessModelCompatible
-} from "../chunk-5VXPDXZJ.js";
+  DEFAULT_SANDBOX_RESOURCES,
+  attachReasoningEffort,
+  bearerSubprotocolToken,
+  bearerToken,
+  buildAppToolMcpServers,
+  buildSandboxRuntimeProxyHeaders,
+  classifySeveredStream,
+  createSandboxTerminalToken,
+  createWorkspaceSandboxConnectionHandler,
+  createWorkspaceSandboxManager,
+  createWorkspaceSandboxRuntimeProxyHandler,
+  createWorkspaceSandboxTerminalUpgradeHandler,
+  deleteSecret,
+  detectInteractiveQuestion,
+  driveSandboxTurn,
+  encodeSandboxRuntimePath,
+  ensureWorkspaceSandbox,
+  flattenHistory,
+  getClient,
+  isSandboxTerminalWsUpgrade,
+  isTerminalPromptEvent,
+  matchSandboxTerminalWsPath,
+  mergeExtraMcp,
+  mintSandboxScopedToken,
+  mintTerminalProxyToken,
+  readSecret,
+  resetClientCache,
+  resolveModel,
+  runSandboxPrompt,
+  secretStoreFromClient,
+  storeSecret,
+  streamSandboxPrompt,
+  syncSandboxMemberAdd,
+  syncSandboxMemberRemove,
+  syncSandboxMemberRole,
+  terminalTokenFromRequest,
+  verifySandboxTerminalToken,
+  verifyTerminalProxyToken
+} from "../chunk-XDCHKFBX.js";
+import "../chunk-5VXPDXZJ.js";
 import "../chunk-MH6AVXQ7.js";
-import {
-  buildAppToolMcpServer
-} from "../chunk-A76ZHWNF.js";
+import "../chunk-A76ZHWNF.js";
 import "../chunk-JZZ6AWF4.js";
-
-// src/sandbox/index.ts
-import {
-  Sandbox
-} from "@tangle-network/sandbox";
-var ok = (value) => ({ succeeded: true, value });
-var fail = (error) => ({
-  succeeded: false,
-  error: error instanceof Error ? error : new Error(String(error))
-});
-var DEFAULT_SANDBOX_RESOURCES = {
-  image: "universal",
-  cpuCores: 2,
-  memoryMB: 4096,
-  diskGB: 10,
-  maxLifetimeSeconds: 86400,
-  idleTimeoutSeconds: 3600
-};
-var _cached = null;
-function getClient(shell) {
-  const creds = shell.credentials();
-  if (!creds) throw new Error("sandbox credentials are required (apiKey/baseUrl)");
-  const fingerprint = `${creds.apiKey} ${creds.baseUrl}`;
-  if (_cached && _cached.fingerprint === fingerprint) return _cached.client;
-  const client = new Sandbox({ apiKey: creds.apiKey, baseUrl: creds.baseUrl });
-  _cached = { client, fingerprint };
-  return client;
-}
-function resetClientCache() {
-  _cached = null;
-}
-function buildAppToolMcpServers(options) {
-  const entries = {};
-  for (const { tool, key, description } of options.tools) {
-    entries[key] = buildAppToolMcpServer({
-      tool,
-      baseUrl: options.baseUrl,
-      token: options.token,
-      ctx: options.ctx,
-      description,
-      headerNames: options.headerNames
-    });
-  }
-  return entries;
-}
-async function listRunning(client, name) {
-  try {
-    const running = await client.list({ status: "running" });
-    return ok(running.find((s) => s.name === name) ?? null);
-  } catch (err) {
-    return fail(err);
-  }
-}
-async function deleteBox(box) {
-  try {
-    await box.delete();
-    return ok(void 0);
-  } catch (err) {
-    return fail(err);
-  }
-}
-async function ensureWorkspaceSandbox(shell, options) {
-  const { workspaceId, userId, harness } = options;
-  const client = getClient(shell);
-  const name = shell.name(workspaceId);
-  const resources = shell.resources ?? DEFAULT_SANDBOX_RESOURCES;
-  const existing = await listRunning(client, name);
-  if (existing.succeeded && existing.value) {
-    const found = existing.value;
-    if (found.metadata?.harness === harness) return found;
-    const dropped = await deleteBox(found);
-    if (!dropped.succeeded) {
-      throw new Error(
-        `harness-mismatched sandbox ${name} (was ${String(found.metadata?.harness ?? "unknown")}, want ${harness}) could not be deleted`,
-        { cause: dropped.error }
-      );
-    }
-  }
-  const connectedIntegrationIds = await shell.connectedIntegrationIds(workspaceId);
-  const buildCtx = { workspaceId, connectedIntegrationIds };
-  const [secrets, env, files] = await Promise.all([
-    shell.secrets(workspaceId),
-    shell.env(buildCtx),
-    shell.files(buildCtx)
-  ]);
-  const profile = shell.profile({ extraFiles: files });
-  const role = userId && shell.permissionRole ? shell.permissionRole("developer") : void 0;
-  const payload = {
-    name,
-    image: resources.image,
-    metadata: shell.metadata(harness),
-    ...userId ? { permissions: { initialUsers: [{ userId, role }] } } : {},
-    env,
-    secrets,
-    backend: { type: harness, profile },
-    maxLifetimeSeconds: resources.maxLifetimeSeconds,
-    idleTimeoutSeconds: resources.idleTimeoutSeconds,
-    resources: {
-      cpuCores: resources.cpuCores,
-      memoryMB: resources.memoryMB,
-      diskGB: resources.diskGB
-    }
-  };
-  const box = await client.create(payload);
-  await box.waitFor("running", { timeoutMs: 12e4 });
-  if (!box.connection?.runtimeUrl) await box.refresh();
-  return box;
-}
-function resolveModel(config, override) {
-  const c = config ?? {};
-  const explicitBaseUrl = c.routerBaseUrl;
-  const explicitApiKey = override?.modelApiKey ?? c.apiKey;
-  const provider = c.providerName ?? (explicitApiKey ? "openai-compat" : c.openaiApiKey ? "openai" : void 0);
-  const modelName = override?.model ?? c.modelName ?? (provider === "openai" || provider === "openai-compat" ? c.defaultModel : void 0);
-  const apiKey = explicitApiKey ?? (provider === "openai" ? c.openaiApiKey : void 0);
-  if (!provider || !modelName || !apiKey) return void 0;
-  return {
-    model: modelName,
-    provider,
-    apiKey,
-    ...explicitBaseUrl ? { baseUrl: explicitBaseUrl } : {}
-  };
-}
-function flattenHistory(message, history) {
-  if (!history?.length) return message;
-  const transcript = history.map((entry) => `${entry.role === "assistant" ? "Assistant" : "User"}: ${entry.content}`).join("\n\n");
-  return `${transcript}
-
-User: ${message}`;
-}
-function mergeExtraMcp(appToolMcp, baseProfileMcp, extra) {
-  for (const key of Object.keys(extra ?? {})) {
-    if (key in appToolMcp || key in baseProfileMcp) {
-      throw new Error(`extraMcp key '${key}' collides with an existing profile MCP server`);
-    }
-  }
-  return { ...appToolMcp, ...extra ?? {} };
-}
-function attachReasoningEffort(profile, harness, effort) {
-  if (!effort || effort === "auto") return profile;
-  return {
-    ...profile,
-    extensions: {
-      ...profile.extensions ?? {},
-      [harness]: {
-        ...profile.extensions?.[harness] ?? {},
-        reasoningEffort: effort
-      }
-    }
-  };
-}
-async function* streamSandboxPrompt(shell, box, message, options) {
-  const harness = options?.harness ?? "opencode";
-  const model = resolveModel(shell.provider, {
-    model: options?.model,
-    modelApiKey: options?.modelApiKey
-  });
-  if (model?.model) assertHarnessModelCompatible(harness, model.model);
-  const prompt = flattenHistory(message, options?.history);
-  const appToolMcp = options?.appToolMcp ?? {};
-  const extraMcp = mergeExtraMcp(appToolMcp, options?.baseProfileMcp ?? {}, options?.extraMcp);
-  const profile = shell.profile({ systemPrompt: options?.systemPrompt, extraMcp });
-  const profileWithEffort = attachReasoningEffort(profile, harness, options?.effort);
-  const stream = box.streamPrompt(prompt, {
-    sessionId: options?.sessionId,
-    executionId: options?.executionId,
-    lastEventId: options?.lastEventId,
-    backend: {
-      type: harness,
-      profile: profileWithEffort,
-      ...model ? { model } : {}
-    }
-  });
-  for await (const event of stream) yield event;
-}
-async function runSandboxPrompt(shell, box, message, options) {
-  let fullText = "";
-  let firstTextSeen = false;
-  for await (const rawEvent of streamSandboxPrompt(shell, box, message, options)) {
-    const event = rawEvent;
-    if (!event.type) continue;
-    if (event.type === "message.part.updated") {
-      const part = event.data?.part;
-      const delta = typeof event.data?.delta === "string" ? event.data.delta : null;
-      if (String(part?.type ?? "") === "text") {
-        if (!firstTextSeen) {
-          firstTextSeen = true;
-          continue;
-        }
-        if (delta) fullText += delta;
-        else if (typeof part?.text === "string") fullText = part.text;
-      }
-    } else if (event.type === "result") {
-      const finalText = typeof event.data?.finalText === "string" ? event.data.finalText : null;
-      if (finalText) fullText = finalText;
-    }
-  }
-  return fullText;
-}
-async function syncSandboxMemberAdd(box, seam, userId, role) {
-  try {
-    await box.permissions.add({ userId, role: seam.roleToSandboxRole(role) });
-    return ok(void 0);
-  } catch (err) {
-    return fail(err);
-  }
-}
-async function syncSandboxMemberRemove(box, userId) {
-  try {
-    await box.permissions.remove(userId, { preserveHomeDir: true });
-    return ok(void 0);
-  } catch (err) {
-    return fail(err);
-  }
-}
-async function syncSandboxMemberRole(box, seam, userId, role) {
-  try {
-    await box.permissions.update(userId, { role: seam.roleToSandboxRole(role) });
-    return ok(void 0);
-  } catch (err) {
-    return fail(err);
-  }
-}
-function secretStoreFromClient(shell) {
-  const client = getClient(shell);
-  return {
-    create: async (name, value) => {
-      await client.secrets.create(name, value);
-    },
-    update: async (name, value) => {
-      await client.secrets.update(name, value);
-    },
-    get: (name) => client.secrets.get(name),
-    delete: async (name) => {
-      await client.secrets.delete(name);
-    }
-  };
-}
-async function storeSecret(store, name, value) {
-  try {
-    await store.create(name, value);
-    return ok(void 0);
-  } catch {
-    try {
-      await store.update(name, value);
-      return ok(void 0);
-    } catch (err) {
-      return fail(new Error(`Failed to store sandbox secret ${name}`, { cause: err }));
-    }
-  }
-}
-async function readSecret(store, name) {
-  try {
-    return ok(await store.get(name));
-  } catch (err) {
-    return fail(err);
-  }
-}
-async function deleteSecret(store, name) {
-  try {
-    await store.delete(name);
-    return ok(void 0);
-  } catch (err) {
-    return fail(err);
-  }
-}
-async function mintSandboxScopedToken(box, options) {
-  try {
-    const token = await box.mintScopedToken({
-      scope: options.scope,
-      ...options.sessionId ? { sessionId: options.sessionId } : {},
-      ...options.ttlMinutes ? { ttlMinutes: options.ttlMinutes } : {}
-    });
-    return ok({ token: token.token, expiresAt: token.expiresAt, scope: token.scope });
-  } catch (err) {
-    return fail(err);
-  }
-}
 export {
   DEFAULT_SANDBOX_RESOURCES,
   attachReasoningEffort,
+  bearerSubprotocolToken,
+  bearerToken,
   buildAppToolMcpServers,
+  buildSandboxRuntimeProxyHeaders,
+  classifySeveredStream,
+  createSandboxTerminalToken,
+  createWorkspaceSandboxConnectionHandler,
+  createWorkspaceSandboxManager,
+  createWorkspaceSandboxRuntimeProxyHandler,
+  createWorkspaceSandboxTerminalUpgradeHandler,
   deleteSecret,
+  detectInteractiveQuestion,
+  driveSandboxTurn,
+  encodeSandboxRuntimePath,
   ensureWorkspaceSandbox,
   flattenHistory,
   getClient,
+  isSandboxTerminalWsUpgrade,
+  isTerminalPromptEvent,
+  matchSandboxTerminalWsPath,
   mergeExtraMcp,
   mintSandboxScopedToken,
+  mintTerminalProxyToken,
   readSecret,
   resetClientCache,
   resolveModel,
@@ -303,6 +77,9 @@ export {
   streamSandboxPrompt,
   syncSandboxMemberAdd,
   syncSandboxMemberRemove,
-  syncSandboxMemberRole
+  syncSandboxMemberRole,
+  terminalTokenFromRequest,
+  verifySandboxTerminalToken,
+  verifyTerminalProxyToken
 };
 //# sourceMappingURL=index.js.map