@tangle-network/agent-app 0.43.56 → 0.43.57

package/dist/sandbox/index.d.ts

@@ -1,11 +1,12 @@
 import { SandboxInstance, AgentProfileMcpServer, ProvisionEvent, AgentProfileFileMount, AgentProfile, StorageConfig, ScopedTokenScope, TurnDriveResult, Sandbox } from '@tangle-network/sandbox';
 export { StorageConfig } from '@tangle-network/sandbox';
-import { a as ToolHeaderNames } from '../auth-DuptSkWh.js';
-import { f as AppToolName, c as AppToolContext } from '../types-BEOvc_ue.js';
+import { a as ToolHeaderNames } from '../auth-_FU8w01b.js';
+import { f as AppToolName, c as AppToolContext } from '../types-CBRyqijY.js';
 import { Harness } from '../harness/index.js';
-import { f as TangleExecutionEnvironment } from '../model-dF2h4xT9.js';
+import { f as TangleExecutionEnvironment } from '../model-DmdkIteM.js';
 import '@tangle-network/agent-interface';
 
+/** Represent success or failure of an operation with corresponding value or error information */
 type Outcome<T> = {
     succeeded: true;
     value: T;
@@ -40,10 +41,12 @@ interface SandboxExecChannel {
         exitCode: number;
     }>;
 }
+/** Define options to execute code within a sandbox environment with optional session control */
 interface SandboxExecOptions {
     /** Run inside a named session rather than the box's default one. */
     sessionId?: string;
 }
+/** Resolve the outcome of a sandbox file size check with success status and value or error message */
 type SandboxFileSizeOutcome = {
     succeeded: true;
     value: number;
@@ -51,6 +54,7 @@ type SandboxFileSizeOutcome = {
     succeeded: false;
     error: string;
 };
+/** Represent the outcome of reading sandbox file bytes with success status and corresponding data or error */
 type SandboxFileBytesOutcome = {
     succeeded: true;
     value: {
@@ -75,17 +79,21 @@ declare function statSandboxFileSize(box: SandboxExecChannel, absolutePath: stri
  *  mismatch is reported, never returned as a short buffer. */
 declare function readSandboxBinaryBytes(box: SandboxExecChannel, absolutePath: string, expectedSize: number, options?: SandboxExecOptions): Promise<SandboxFileBytesOutcome>;
 
+/** Define identity details for a terminal proxy including user, workspace, and sandbox identifiers */
 interface TerminalProxyIdentity {
     userId: string;
     workspaceId: string;
     sandboxId: string;
 }
+/** Generate a signed token for TerminalProxyIdentity with an expiration based on TTL milliseconds */
 declare function mintTerminalProxyToken(secret: string, identity: TerminalProxyIdentity, ttlMs?: number, now?: () => number): Promise<Outcome<{
     token: string;
     expiresAt: Date;
 }>>;
+/** Verify the authenticity and validity of a terminal proxy token against expected identity and timestamp */
 declare function verifyTerminalProxyToken(secret: string, token: string, expected: TerminalProxyIdentity, now?: () => number): Promise<boolean>;
 
+/** Define the shape of a workspace sandbox instance including its connection details and status */
 interface WorkspaceSandboxInstanceLike {
     id: string;
     name?: string;
@@ -98,10 +106,12 @@ interface WorkspaceSandboxInstanceLike {
         authTokenExpiresAt?: string;
     } | null;
 }
+/** Define the context containing workspace and user identifiers for sandbox environment operations */
 interface WorkspaceSandboxEnsureContext {
     workspaceId: string;
     userId: string;
 }
+/** Define configuration options for managing and interacting with workspace sandboxes */
 interface WorkspaceSandboxManagerOptions<TClient, TBox extends WorkspaceSandboxInstanceLike, TEnsureOptions = void> {
     getClient: (ctx: WorkspaceSandboxEnsureContext) => Promise<TClient> | TClient;
     nameForWorkspace: (workspaceId: string, ctx: WorkspaceSandboxEnsureContext) => string;
@@ -118,25 +128,34 @@ interface WorkspaceSandboxManagerOptions<TClient, TBox extends WorkspaceSandboxI
     prepareCreated?: (box: TBox, ctx: WorkspaceSandboxEnsureContext, options: TEnsureOptions) => Promise<TBox | void>;
     onListError?: (error: unknown, ctx: WorkspaceSandboxEnsureContext) => void;
 }
+/** Manage workspace sandboxes by ensuring their creation and retrieval for specified users */
 interface WorkspaceSandboxManager<TBox extends WorkspaceSandboxInstanceLike, TEnsureOptions = void> {
     ensureWorkspaceSandbox: (workspaceId: string, userId: string, options?: TEnsureOptions) => Promise<TBox>;
 }
+/** Create a manager to handle workspace sandbox instances with client and options configuration */
 declare function createWorkspaceSandboxManager<TClient, TBox extends WorkspaceSandboxInstanceLike, TEnsureOptions = void>(opts: WorkspaceSandboxManagerOptions<TClient, TBox, TEnsureOptions>): WorkspaceSandboxManager<TBox, TEnsureOptions>;
+/** Define options for generating a sandbox terminal token including secret and expiration settings */
 interface SandboxTerminalTokenOptions {
     secret?: string;
     expiresInMs?: number;
     now?: () => number;
 }
+/** Resolve the identity type used for sandbox terminal token subjects */
 type SandboxTerminalTokenSubject = TerminalProxyIdentity;
+/** Provide token and expiration details for a sandbox terminal session */
 interface SandboxTerminalTokenResult {
     token: string;
     expiresAt: Date;
 }
+/** Generate a sandbox terminal token for a given subject with specified options */
 declare function createSandboxTerminalToken(subject: SandboxTerminalTokenSubject, opts: SandboxTerminalTokenOptions): Promise<SandboxTerminalTokenResult>;
+/** Verify the validity of a sandbox terminal token against the expected identity and options */
 declare function verifySandboxTerminalToken(token: string, expected: SandboxTerminalTokenSubject, opts: SandboxTerminalTokenOptions): Promise<boolean>;
+/** Represent an authenticated user within a sandbox environment with a unique identifier */
 interface AuthenticatedSandboxUser {
     id: string;
 }
+/** Define options to handle workspace sandbox connections with user authentication and access control */
 interface WorkspaceSandboxConnectionHandlerOptions<TBox extends WorkspaceSandboxInstanceLike> {
     requireUser: (request: Request) => Promise<AuthenticatedSandboxUser>;
     requireWorkspaceAccess: (args: {
@@ -155,22 +174,27 @@ interface WorkspaceSandboxConnectionHandlerOptions<TBox extends WorkspaceSandbox
     }) => string;
     exposeDirectSidecar?: boolean;
 }
+/** Define arguments required to establish a workspace sandbox connection */
 interface WorkspaceSandboxConnectionArgs {
     request: Request;
     params: {
         workspaceId?: string;
     };
 }
+/** Create a handler to resolve workspace sandbox connections with user and access validation */
 declare function createWorkspaceSandboxConnectionHandler<TBox extends WorkspaceSandboxInstanceLike>(opts: WorkspaceSandboxConnectionHandlerOptions<TBox>): ({ request, params }: WorkspaceSandboxConnectionArgs) => Promise<Response>;
+/** Define credentials required to access the sandbox API environment */
 interface SandboxApiCredentials {
     baseUrl: string;
     apiKey: string;
 }
+/** Define a connection configuration for sandbox runtime including URL and optional server-side auth token */
 interface SandboxRuntimeConnection {
     runtimeUrl: string;
     /** Server-side sidecar bearer. Must authorize terminal routes; never expose it to browser code. */
     authToken?: string;
 }
+/** Define options for handling workspace sandbox runtime proxy including user, access, credentials, and connection retrieval */
 interface WorkspaceSandboxRuntimeProxyHandlerOptions {
     requireUser: (request: Request) => Promise<AuthenticatedSandboxUser>;
     requireWorkspaceAccess: (args: {
@@ -195,6 +219,7 @@ interface WorkspaceSandboxRuntimeProxyHandlerOptions {
     fetch?: typeof fetch;
     forwardHeaders?: string[];
 }
+/** Define arguments for proxying runtime requests within a workspace sandbox environment */
 interface WorkspaceSandboxRuntimeProxyArgs {
     request: Request;
     params: {
@@ -203,7 +228,9 @@ interface WorkspaceSandboxRuntimeProxyArgs {
         '*'?: string;
     };
 }
+/** Create a proxy handler to resolve sandbox runtime requests with user and workspace access validation */
 declare function createWorkspaceSandboxRuntimeProxyHandler(opts: WorkspaceSandboxRuntimeProxyHandlerOptions): ({ request, params }: WorkspaceSandboxRuntimeProxyArgs) => Promise<Response>;
+/** Define the structure for matching a sandbox terminal WebSocket with workspace and path details */
 interface SandboxTerminalWsMatch {
     workspaceId: string;
     sandboxId: string;
@@ -220,6 +247,7 @@ interface SandboxTerminalWsMatch {
 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;
+/** Define options to handle user authentication, workspace access, and sandbox API credential retrieval */
 interface WorkspaceSandboxTerminalUpgradeHandlerOptions {
     requireUser: (request: Request) => Promise<AuthenticatedSandboxUser>;
     requireWorkspaceAccess: (args: {
@@ -255,12 +283,18 @@ interface WorkspaceSandboxTerminalUpgradeHandlerOptions {
  * ```
  */
 declare function createWorkspaceSandboxTerminalUpgradeHandler(opts: WorkspaceSandboxTerminalUpgradeHandlerOptions): (request: Request) => Promise<Response | null>;
+/** Build proxy headers for sandbox runtime including authorization and forwarded headers */
 declare function buildSandboxRuntimeProxyHeaders(source: Headers, sandboxApiKey: string, forwardHeaders?: string[]): Headers;
+/** Encode a runtime path by URI-encoding each valid segment and returning null for invalid segments */
 declare function encodeSandboxRuntimePath(runtimePath: string): string | null;
+/** Extract the token from a bearer authorization string or return null if invalid or missing */
 declare function bearerToken(value: string | null): string | null;
+/** Resolve and decode a bearer token from a comma-separated subprotocol string or return null */
 declare function bearerSubprotocolToken(value: string | null): string | null;
+/** Resolve the terminal token from request headers using Authorization or Sec-WebSocket-Protocol fields */
 declare function terminalTokenFromRequest(headers: Headers): string | null;
 
+/** Define client credentials for accessing the sandbox environment with API key and base URL */
 interface SandboxClientCredentials {
     apiKey: string;
     baseUrl: string;
@@ -271,6 +305,7 @@ interface SandboxClientCredentials {
  * (see resolveTangleExecutionEnvironment in runtime/model).
  */
 type SandboxCredentialEnvironment = TangleExecutionEnvironment;
+/** Resolve options for obtaining sandbox client credentials from environment variables and classification */
 interface ResolveSandboxClientCredentialsOptions {
     /**
      * Environment object to read from. Defaults to process.env when available.
@@ -311,7 +346,9 @@ interface ResolveSandboxClientCredentialsOptions {
         env: Record<string, string | undefined>;
     }) => SandboxClientCredentials | null | undefined | Promise<SandboxClientCredentials | null | undefined>;
 }
+/** Resolve sandbox client credentials based on environment and provided options asynchronously */
 declare function resolveSandboxClientCredentials(options?: ResolveSandboxClientCredentialsOptions): Promise<SandboxClientCredentials>;
+/** Define configuration parameters for sandbox resource allocation and lifecycle management */
 interface SandboxResourceConfig {
     image: string;
     cpuCores: number;
@@ -320,6 +357,7 @@ interface SandboxResourceConfig {
     maxLifetimeSeconds: number;
     idleTimeoutSeconds: number;
 }
+/** Define configuration options for resolving a provider and its model with optional API keys and routing details */
 interface ProviderResolutionConfig {
     routerBaseUrl?: string;
     apiKey?: string;
@@ -329,41 +367,49 @@ interface ProviderResolutionConfig {
     openaiApiKey?: string;
     allowKeylessModel?: boolean;
 }
+/** Define the context for building a sandbox including workspace, integrations, and optional user ID */
 interface SandboxBuildContext {
     workspaceId: string;
     connectedIntegrationIds: string[];
     userId?: string;
 }
 
+/** Define a scope containing workspace and optional user identifiers for sandbox environments */
 interface SandboxScope {
     workspaceId: string;
     userId?: string;
 }
+/** Define the specification for restoring a sandbox from a snapshot or another sandbox ID */
 interface SandboxRestoreSpec {
     fromSnapshot: string;
     fromSandboxId: string;
 }
+/** Describe the failure details when resuming a stopped sandbox instance */
 interface StoppedSandboxResumeFailure {
     box: SandboxInstance;
     error: Error;
     scope: SandboxScope;
     boxKey: string;
 }
+/** Define the structure for resuming a stopped sandbox with replacement key and optional restore options */
 interface StoppedSandboxResumeRecovery {
     replacementBoxKey: string;
     restore?: SandboxRestoreSpec | null;
 }
+/** Define configuration for liveness probes including sidecar process pattern and optional timeouts */
 interface LivenessProbeConfig {
     sidecarProcessPattern: (harness: Harness) => string;
     execTimeoutMs?: number;
     psTimeoutMs?: number;
 }
+/** Define options for composing a user profile including prompts, files, servers, and name */
 interface ProfileComposeOptions {
     systemPrompt?: string;
     extraFiles?: AgentProfileFileMount[];
     extraMcp?: Record<string, AgentProfileMcpServer>;
     name?: string;
 }
+/** Define runtime configuration methods for sandbox environments including credentials, metadata, and permissions */
 interface SandboxRuntimeConfig {
     credentials: (scope?: SandboxScope) => SandboxClientCredentials | null | Promise<SandboxClientCredentials | null>;
     name: (workspaceId: string) => string;
@@ -388,14 +434,19 @@ interface SandboxRuntimeConfig {
     backendModelAtCreate?: boolean;
     deferProfileFiles?: boolean;
 }
+/** Define default resource limits and settings for sandbox environments */
 declare const DEFAULT_SANDBOX_RESOURCES: SandboxResourceConfig;
+/** Resolve a synchronous sandbox client from provided runtime configuration credentials */
 declare function getClient(shell: SandboxRuntimeConfig): Sandbox;
+/** Reset the client cache to clear stored data and force fresh retrieval */
 declare function resetClientCache(): void;
+/** Describe an application tool with its name, unique key, and description */
 interface AppToolDescriptor {
     tool: AppToolName;
     key: string;
     description: string;
 }
+/** Define options for building MCP server configurations in the app tool environment */
 interface BuildAppToolMcpServersOptions {
     tools: AppToolDescriptor[];
     baseUrl: string;
@@ -403,7 +454,9 @@ interface BuildAppToolMcpServersOptions {
     ctx: AppToolContext;
     headerNames?: ToolHeaderNames;
 }
+/** Build a mapping of MCP server profiles keyed by tool identifiers from provided options */
 declare function buildAppToolMcpServers(options: BuildAppToolMcpServersOptions): Record<string, AgentProfileMcpServer>;
+/** Define options for ensuring a workspace sandbox with provisioning and progress handling */
 interface EnsureWorkspaceSandboxOptions {
     workspaceId: string;
     userId?: string;
@@ -412,40 +465,53 @@ interface EnsureWorkspaceSandboxOptions {
     onProgress?: (event: ProvisionEvent) => void;
     billingOwnerId?: string;
 }
+/** Define the specification for a sandbox tool including its name, content, and optional executability */
 interface SandboxToolSpec {
     name: string;
     content: string;
     executable?: boolean;
 }
+/** Define options for resolving sandbox tool paths including appName, baseDir, and binDir */
 interface SandboxToolPathOptions {
     appName: string;
     baseDir?: string;
     binDir?: string;
 }
+/** Define options for building sandbox tool file mounts including tool specifications and paths */
 interface BuildSandboxToolFileMountsOptions extends SandboxToolPathOptions {
     tools: readonly SandboxToolSpec[];
 }
+/** Resolve the root directory path for a sandbox tool based on provided options */
 declare function sandboxToolRootDir(options: SandboxToolPathOptions): string;
+/** Resolve the binary directory path for a sandbox tool based on provided options */
 declare function sandboxToolBinDir(options: SandboxToolPathOptions): string;
+/** Resolve the file system path to a specified sandbox tool based on given options */
 declare function sandboxToolPath(options: SandboxToolPathOptions & {
     toolName: string;
 }): string;
+/** Build file mounts for sandbox tools based on provided options and tool configurations */
 declare function buildSandboxToolFileMounts(options: BuildSandboxToolFileMountsOptions): AgentProfileFileMount[];
+/** Build a shell script that sets up and exports the sandbox tool binary directory in user profiles */
 declare function buildSandboxToolPathSetupScript(options: SandboxToolPathOptions): string;
+/** Resolve the sandbox environment PATH setup by executing the configuration script with given options */
 declare function runSandboxToolPathSetup(box: SandboxInstance, options: SandboxToolPathOptions): Promise<Outcome<void>>;
+/** Split profile files into inline deferred files and a lean profile without them */
 declare function splitDeferredProfileFiles(profile: AgentProfile): {
     leanProfile: AgentProfile;
     deferredFiles: AgentProfileFileMount[];
 };
 type ExistingBoxStage = 'reused' | 'resumed';
+/** Represent an error thrown when sandbox runtime authentication refresh fails for a specific stage and name */
 declare class SandboxRuntimeAuthRefreshError extends Error {
     constructor(stage: ExistingBoxStage, name: string, detail: string, cause?: unknown);
 }
+/** Define options to control execution timeout, pacing, and retry behavior when writing profile files */
 interface WriteProfileFilesOptions {
     execTimeoutMs?: number;
     paceMs?: number;
     maxRetries?: number;
 }
+/** Write profile files to a sandbox with pacing, retries, and optional execution timeout handling */
 declare function writeProfileFilesToBox(box: SandboxInstance, files: AgentProfileFileMount[], options?: WriteProfileFilesOptions): Promise<Outcome<void>>;
 /** Stable content hash of the deferred file corpus (path + inline content).
  *  Unchanged corpus ⇒ same hash; a new/edited/removed skill ⇒ different hash.
@@ -545,18 +611,23 @@ declare function peekWorkspaceSandbox(shell: SandboxRuntimeConfig, options: {
     workspaceId: string;
     userId?: string;
 }): Promise<PeekWorkspaceSandboxOutcome>;
+/** Resolve or create a workspace sandbox instance with optional reuse and progress tracking */
 declare function ensureWorkspaceSandbox(shell: SandboxRuntimeConfig, options: EnsureWorkspaceSandboxOptions): Promise<SandboxInstance>;
+/** Represent a fully configured model with optional API key and base URL for sandbox platform integration */
 interface ResolvedModel {
     model: string;
     provider: string;
     apiKey?: string;
     baseUrl?: string;
 }
+/** Resolve and return the appropriate model configuration based on provider settings and optional overrides */
 declare function resolveModel(config: ProviderResolutionConfig | undefined, override?: {
     model?: string;
     modelApiKey?: string;
 }): ResolvedModel | undefined;
+/** Extract a single element type from the array parameter of SandboxInstance's streamPrompt method */
 type PromptInputPart = Extract<Parameters<SandboxInstance['streamPrompt']>[0], readonly unknown[]>[number];
+/** Build a single string combining conversation history and the current user message */
 declare function flattenHistory(message: string, history?: Array<{
     role: 'user' | 'assistant';
     content: string;
@@ -570,8 +641,11 @@ declare function mergeHistoryIntoParts(parts: PromptInputPart[], history?: Array
     role: 'user' | 'assistant';
     content: string;
 }>): PromptInputPart[];
+/** Resolve conflicts and merge extra MCP profiles into the app tool MCP without overwriting existing keys */
 declare function mergeExtraMcp(appToolMcp: Record<string, AgentProfileMcpServer>, baseProfileMcp: Record<string, AgentProfileMcpServer>, extra: Record<string, AgentProfileMcpServer> | undefined): Record<string, AgentProfileMcpServer>;
+/** Attach a specified reasoning effort level to an agent profile for a given harness */
 declare function attachReasoningEffort(profile: AgentProfile, harness: Harness, effort: 'auto' | 'low' | 'medium' | 'high' | undefined): AgentProfile;
+/** Define options for configuring and controlling a streaming sandbox prompt session */
 interface StreamSandboxPromptOptions {
     sessionId?: string;
     executionId?: string;
@@ -599,25 +673,38 @@ interface StreamSandboxPromptOptions {
     };
     detach?: boolean;
 }
+/** Resolve and stream AI-generated responses from a sandboxed environment based on input messages and options */
 declare function streamSandboxPrompt(shell: SandboxRuntimeConfig, box: SandboxInstance, message: string | PromptInputPart[], options?: StreamSandboxPromptOptions): AsyncGenerator<unknown>;
+/** Resolve a sandbox prompt by streaming and aggregating message parts into a complete string */
 declare function runSandboxPrompt(shell: SandboxRuntimeConfig, box: SandboxInstance, message: string | PromptInputPart[], options?: StreamSandboxPromptOptions): Promise<string>;
+/** Define permission levels for sandbox access and control */
 type SandboxPermissionLevel = 'owner' | 'admin' | 'developer' | 'viewer';
+/** Map workspace roles to corresponding sandbox permission levels */
 interface MemberSyncSeam {
     roleToSandboxRole: (workspaceRole: string) => SandboxPermissionLevel;
 }
+/** Resolve adding a user with a specific role to a sandbox and return the operation outcome */
 declare function syncSandboxMemberAdd(box: SandboxInstance, seam: MemberSyncSeam, userId: string, role: string): Promise<Outcome<void>>;
+/** Remove a member from the sandbox while preserving their home directory and handle the outcome */
 declare function syncSandboxMemberRemove(box: SandboxInstance, userId: string): Promise<Outcome<void>>;
+/** Synchronize a sandbox member's role by updating permissions based on the provided role mapping */
 declare function syncSandboxMemberRole(box: SandboxInstance, seam: MemberSyncSeam, userId: string, role: string): Promise<Outcome<void>>;
+/** Define methods to create, update, retrieve, and delete secrets asynchronously */
 interface SecretStore {
     create: (name: string, value: string) => Promise<void>;
     update: (name: string, value: string) => Promise<void>;
     get: (name: string) => Promise<string>;
     delete: (name: string) => Promise<void>;
 }
+/** Resolve a SecretStore interface using the provided SandboxRuntimeConfig shell */
 declare function secretStoreFromClient(shell: SandboxRuntimeConfig): SecretStore;
+/** Resolve storing a secret by creating or updating it in the given SecretStore */
 declare function storeSecret(store: SecretStore, name: string, value: string): Promise<Outcome<void>>;
+/** Resolve a secret value from the store by its name and return the outcome asynchronously */
 declare function readSecret(store: SecretStore, name: string): Promise<Outcome<string>>;
+/** Delete a secret by name from the given secret store and return the operation outcome */
 declare function deleteSecret(store: SecretStore, name: string): Promise<Outcome<void>>;
+/** Represent a token with its expiration date and associated scope */
 interface ScopedTokenResult {
     token: string;
     expiresAt: Date;
@@ -633,6 +720,7 @@ declare function mintSandboxScopedToken(box: SandboxInstance, options: {
     sessionId?: string;
     ttlMinutes?: number;
 }): Promise<Outcome<ScopedTokenResult>>;
+/** Define options to manage deterministic session resumption and turn idempotency in sandboxed drive turns */
 interface DriveSandboxTurnOptions extends StreamSandboxPromptOptions {
     /** Deterministic resume key — required. Every tick for the same logical turn
      * MUST reuse it so a crash + re-drive finds the in-flight session instead of
@@ -646,7 +734,9 @@ interface DriveSandboxTurnOptions extends StreamSandboxPromptOptions {
      * turn that stalled on an interactive question nothing will answer). Omit for no cap. */
     wallCapMs?: number;
 }
+/** Resolve a sandbox turn by processing a message with given configuration and options */
 declare function driveSandboxTurn(shell: SandboxRuntimeConfig, box: SandboxInstance, message: string | PromptInputPart[], options: DriveSandboxTurnOptions): Promise<Outcome<TurnDriveResult>>;
+/** Define transitions marking the start or finish of a sandbox step with associated details */
 type SandboxStepTransition = {
     kind: 'step-start';
 } | {
@@ -654,8 +744,11 @@ type SandboxStepTransition = {
     reason: string;
     severed: boolean;
 };
+/** Resolve the severed stream event to a corresponding sandbox step transition or null */
 declare function classifySeveredStream(event: unknown): SandboxStepTransition | null;
+/** Determine if an event is a terminal prompt event with type 'result' or 'done */
 declare function isTerminalPromptEvent(event: unknown): boolean;
+/** Resolve the interactive question text from a structured event or return null if none found */
 declare function detectInteractiveQuestion(event: unknown): string | null;
 
 export { type AppToolDescriptor, type AuthenticatedSandboxUser, type BuildAppToolMcpServersOptions, type BuildSandboxToolFileMountsOptions, DEFAULT_SANDBOX_RESOURCES, type DriveSandboxTurnOptions, ENV_TOTAL_MAX_BYTES, ENV_VALUE_MAX_BYTES, type EnsureWorkspaceSandboxOptions, type LivenessProbeConfig, type MemberSyncSeam, type Outcome, PROVISION_PAYLOAD_MAX_BYTES, type PeekWorkspaceSandboxOutcome, type ProfileComposeOptions, type PromptInputPart, type ProviderResolutionConfig, type ProvisionPayloadSections, type ProvisionProfileSection, type ResolveSandboxClientCredentialsOptions, type ResolvedModel, type SandboxApiCredentials, type SandboxBuildContext, type SandboxClientCredentials, type SandboxCredentialEnvironment, type SandboxExecChannel, type SandboxExecOptions, type SandboxFileBytesOutcome, type SandboxFileSizeOutcome, type SandboxPermissionLevel, type SandboxResourceConfig, type SandboxRestoreSpec, SandboxRuntimeAuthRefreshError, type SandboxRuntimeConfig, type SandboxRuntimeConnection, type SandboxScope, type SandboxStepTransition, type SandboxTerminalTokenOptions, type SandboxTerminalTokenResult, type SandboxTerminalTokenSubject, type SandboxTerminalWsMatch, type SandboxToolPathOptions, type SandboxToolSpec, type ScopedTokenResult, type SecretStore, type StoppedSandboxResumeFailure, type StoppedSandboxResumeRecovery, type StreamSandboxPromptOptions, type TerminalProxyIdentity, type WorkspaceSandboxConnectionArgs, type WorkspaceSandboxConnectionHandlerOptions, type WorkspaceSandboxEnsureContext, type WorkspaceSandboxInstanceLike, type WorkspaceSandboxManager, type WorkspaceSandboxManagerOptions, type WorkspaceSandboxRuntimeProxyArgs, type WorkspaceSandboxRuntimeProxyHandlerOptions, type WorkspaceSandboxTerminalUpgradeHandlerOptions, type WriteProfileFilesOptions, assertEnvWithinLimits, assertProvisionPayloadWithinCap, attachReasoningEffort, bearerSubprotocolToken, bearerToken, buildAppToolMcpServers, buildSandboxRuntimeProxyHeaders, buildSandboxToolFileMounts, buildSandboxToolPathSetupScript, classifySeveredStream, createSandboxTerminalToken, createWorkspaceSandboxConnectionHandler, createWorkspaceSandboxManager, createWorkspaceSandboxRuntimeProxyHandler, createWorkspaceSandboxTerminalUpgradeHandler, deferredCorpusHash, deleteSecret, detectInteractiveQuestion, driveSandboxTurn, encodeSandboxRuntimePath, ensureWorkspaceSandbox, flattenHistory, getClient, isSandboxTerminalWsUpgrade, isTerminalPromptEvent, matchSandboxTerminalWsPath, mergeExtraMcp, mergeHistoryIntoParts, mintSandboxScopedToken, mintTerminalProxyToken, peekWorkspaceSandbox, readSandboxBinaryBytes, readSecret, resetClientCache, resolveModel, resolveSandboxClientCredentials, runSandboxPrompt, runSandboxToolPathSetup, sandboxToolBinDir, sandboxToolPath, sandboxToolRootDir, secretStoreFromClient, shellQuote, splitDeferredProfileFiles, statSandboxFileSize, storeSecret, streamSandboxPrompt, syncSandboxMemberAdd, syncSandboxMemberRemove, syncSandboxMemberRole, terminalTokenFromRequest, verifySandboxTerminalToken, verifyTerminalProxyToken, writeProfileFilesToBox };

package/dist/sandbox/index.js

@@ -58,13 +58,13 @@ import {
   verifySandboxTerminalToken,
   verifyTerminalProxyToken,
   writeProfileFilesToBox
-} from "../chunk-HRJJH3RX.js";
-import "../chunk-MCJSS6SM.js";
-import "../chunk-PJC4NXPA.js";
-import "../chunk-7EVZUIHW.js";
+} from "../chunk-3OFQFW5K.js";
+import "../chunk-CQZSAR77.js";
+import "../chunk-YKBDH2UY.js";
+import "../chunk-3EJ6SFJI.js";
 import "../chunk-S5SRJJQG.js";
-import "../chunk-7W5XSTUF.js";
-import "../chunk-MFRCM32T.js";
+import "../chunk-JML7WKWU.js";
+import "../chunk-7CTIUCQ4.js";
 export {
   DEFAULT_SANDBOX_RESOURCES,
   ENV_TOTAL_MAX_BYTES,

package/dist/{sandbox-terminal-BIIC__CP.d.ts → sandbox-terminal-ChNEdHF8.d.ts}

@@ -1,3 +1,4 @@
+/** Define the connection details and status for a sandbox terminal session */
 interface SandboxTerminalConnection {
     runtimeUrl: string | null;
     sidecarUrl: string | null;
@@ -8,6 +9,7 @@ interface SandboxTerminalConnection {
     loading: boolean;
     sandboxId?: string;
 }
+/** Define the response structure for a sandbox terminal connection including URLs, token, status, and errors */
 interface SandboxTerminalConnectionResponse {
     runtimeUrl?: string;
     sidecarUrl?: string;
@@ -17,6 +19,7 @@ interface SandboxTerminalConnectionResponse {
     error?: string;
     sandboxId?: string;
 }
+/** Define options for configuring a sandbox terminal connection including workspace ID and connection parameters */
 interface UseSandboxTerminalConnectionOptions {
     workspaceId: string;
     connectionUrl?: string | ((workspaceId: string) => string);
@@ -25,9 +28,11 @@ interface UseSandboxTerminalConnectionOptions {
     provisionPollTimeoutMs?: number;
     tokenRefreshSkewMs?: number;
 }
+/** Resolve sandbox terminal connection status and provide a method to initiate the connection */
 interface UseSandboxTerminalConnectionResult extends SandboxTerminalConnection {
     connect: () => Promise<void>;
 }
+/** Manage and maintain a sandbox terminal connection with automatic polling and token refresh handling */
 declare function useSandboxTerminalConnection(opts: UseSandboxTerminalConnectionOptions): UseSandboxTerminalConnectionResult;
 /**
  * Stable-per-tab, unique-per-client terminal connection id.

package/dist/sequences/drizzle.d.ts

@@ -1,17 +1,19 @@
 import * as drizzle_orm_sqlite_core from 'drizzle-orm/sqlite-core';
 import { AnySQLiteTable, AnySQLiteColumn, BaseSQLiteDatabase } from 'drizzle-orm/sqlite-core';
-import { n as SequenceStoreScope, c as SequenceClipMedia, m as SequenceStore } from '../store-gckrNq-g.js';
+import { S as SequenceStoreScope, a as SequenceClipMedia, b as SequenceStore } from '../store-B7LLlk9p.js';
 
 /** A product table referenced by FK — only the `id` column is touched. */
 type SequenceParentTable = AnySQLiteTable & {
     id: AnySQLiteColumn;
 };
+/** Define options for creating sequence-related database tables including workspace and user tables */
 interface CreateSequenceTablesOptions {
     workspaceTable: SequenceParentTable;
     userTable: SequenceParentTable;
     generationTable?: SequenceParentTable;
     assetTable?: SequenceParentTable;
 }
+/** Build SQLite sequence tables with defined columns and relationships based on provided options */
 declare function createSequenceTables(opts: CreateSequenceTablesOptions): {
     sequences: drizzle_orm_sqlite_core.SQLiteTableWithColumns<{
         name: "sequence";
@@ -1202,11 +1204,17 @@ declare function createSequenceTables(opts: CreateSequenceTablesOptions): {
         dialect: "sqlite";
     }>;
 };
+/** Resolve sequence tables by invoking the createSequenceTables factory function */
 type SequenceTables = ReturnType<typeof createSequenceTables>;
+/** Resolve a sequence row by inferring the selected fields from the sequences table */
 type SequenceRow = SequenceTables['sequences']['$inferSelect'];
+/** Resolve the selected sequence track row from the sequenceTracks table */
 type SequenceTrackRow = SequenceTables['sequenceTracks']['$inferSelect'];
+/** Resolve the selected fields of sequence clips from the sequence tables data structure */
 type SequenceClipRow = SequenceTables['sequenceClips']['$inferSelect'];
+/** Resolve a sequence decision row from the sequenceDecisions table data */
 type SequenceDecisionRow = SequenceTables['sequenceDecisions']['$inferSelect'];
+/** Resolve a row type representing exported sequence data from sequenceExports table */
 type SequenceExportRow = SequenceTables['sequenceExports']['$inferSelect'];
 
 /**
@@ -1233,12 +1241,14 @@ type SequenceDatabase = BaseSQLiteDatabase<'sync' | 'async', any, any>;
 /** Resolves product-specific media (generation rows, asset rows) for a batch
  *  of clip rows. Keyed by clip id; clips absent from the map carry no media. */
 type SequenceMediaResolver = (clipRows: SequenceClipRow[]) => Promise<Map<string, SequenceClipMedia>>;
+/** Define options for creating a Drizzle sequence store including database, tables, scope, and media resolver */
 interface CreateDrizzleSequenceStoreOptions {
     db: SequenceDatabase;
     tables: SequenceTables;
     scope: SequenceStoreScope;
     resolveMedia?: SequenceMediaResolver;
 }
+/** Create a sequence store scoped to a specific sequence and workspace with database access and media resolution */
 declare function createDrizzleSequenceStore(options: CreateDrizzleSequenceStoreOptions): SequenceStore;
 
 export { type CreateDrizzleSequenceStoreOptions, type CreateSequenceTablesOptions, type SequenceClipRow, type SequenceDatabase, type SequenceDecisionRow, type SequenceExportRow, type SequenceMediaResolver, type SequenceParentTable, type SequenceRow, type SequenceTables, type SequenceTrackRow, createDrizzleSequenceStore, createSequenceTables };

package/dist/sequences/drizzle.js

@@ -1,6 +1,6 @@
 import {
   MIN_SEQUENCE_CLIP_FRAMES
-} from "../chunk-ZYBWGSAZ.js";
+} from "../chunk-BVKQKGRK.js";
 
 // src/sequences/schema.ts
 import { sql } from "drizzle-orm";