zeitlich 0.2.29 → 0.2.30

package/dist/{proxy-78nc985d.d.ts → proxy-BgswT47M.d.ts}

@@ -1,5 +1,5 @@
 import { proxyActivities, ActivityInterfaceFor } from '@temporalio/workflow';
-import { T as ThreadOps } from './types-BkVoEyiH.js';
+import { T as ThreadOps } from './types-D90Q5aOh.js';
 
 /**
  * Shared proxy helper for thread operations.

package/dist/{proxy-Bm2UTiO_.d.cts → proxy-OJihshQF.d.cts}

@@ -1,5 +1,5 @@
 import { proxyActivities, ActivityInterfaceFor } from '@temporalio/workflow';
-import { T as ThreadOps } from './types-seDYom4M.cjs';
+import { T as ThreadOps } from './types-DVdT5ybA.cjs';
 
 /**
  * Shared proxy helper for thread operations.

package/dist/{thread-manager-07BaYu_z.d.ts → thread-manager-BS477gj8.d.ts}

@@ -1,6 +1,6 @@
 import Redis from 'ioredis';
 import Anthropic from '@anthropic-ai/sdk';
-import { T as ThreadManagerHooks, P as ProviderThreadManager } from './types-DAv_SLN8.js';
+import { T as ThreadManagerHooks, P as ProviderThreadManager } from './types-CCIc7Eam.js';
 
 /** SDK-native content type for Anthropic human messages */
 type AnthropicContent = string | Anthropic.Messages.ContentBlockParam[];

package/dist/{thread-manager-BRE5KkHB.d.cts → thread-manager-DH0zv05W.d.cts}

@@ -1,6 +1,6 @@
 import Redis from 'ioredis';
 import { MessageContent, StoredMessage, BaseMessage } from '@langchain/core/messages';
-import { T as ThreadManagerHooks, P as ProviderThreadManager } from './types-Dpz2gXLk.cjs';
+import { T as ThreadManagerHooks, P as ProviderThreadManager } from './types-DgIVPOa1.cjs';
 
 /** SDK-native content type for LangChain human messages */
 type LangChainContent = string | MessageContent;

package/dist/{thread-manager-CxbWo7q_.d.ts → thread-manager-iUplxEZt.d.ts}

@@ -1,6 +1,6 @@
 import Redis from 'ioredis';
 import { MessageContent, StoredMessage, BaseMessage } from '@langchain/core/messages';
-import { T as ThreadManagerHooks, P as ProviderThreadManager } from './types-DAv_SLN8.js';
+import { T as ThreadManagerHooks, P as ProviderThreadManager } from './types-CCIc7Eam.js';
 
 /** SDK-native content type for LangChain human messages */
 type LangChainContent = string | MessageContent;

package/dist/{thread-manager-CatBkarc.d.cts → thread-manager-lfN0V-gH.d.cts}

@@ -1,6 +1,6 @@
 import Redis from 'ioredis';
 import Anthropic from '@anthropic-ai/sdk';
-import { T as ThreadManagerHooks, P as ProviderThreadManager } from './types-Dpz2gXLk.cjs';
+import { T as ThreadManagerHooks, P as ProviderThreadManager } from './types-DgIVPOa1.cjs';
 
 /** SDK-native content type for Anthropic human messages */
 type AnthropicContent = string | Anthropic.Messages.ContentBlockParam[];

package/dist/{types-ChAMwU3q.d.ts → types-AujBIMMn.d.cts}

@@ -86,8 +86,6 @@ interface SandboxCreateOptions {
 }
 interface SandboxCreateResult {
     sandbox: Sandbox;
-    /** Optional state to merge into the workflow's `AgentState` via the session. */
-    stateUpdate?: Record<string, unknown>;
 }
 interface SandboxProvider<TOptions extends SandboxCreateOptions = SandboxCreateOptions, TSandbox extends Sandbox = Sandbox> {
     readonly id: string;
@@ -100,11 +98,10 @@ interface SandboxProvider<TOptions extends SandboxCreateOptions = SandboxCreateO
     restore(snapshot: SandboxSnapshot): Promise<Sandbox>;
     fork(sandboxId: string): Promise<Sandbox>;
 }
-interface SandboxOps<TOptions extends SandboxCreateOptions = SandboxCreateOptions> {
-    createSandbox(options?: TOptions): Promise<{
+interface SandboxOps<TOptions extends SandboxCreateOptions = SandboxCreateOptions, TCtx = unknown> {
+    createSandbox(options?: TOptions, ctx?: TCtx): Promise<{
         sandboxId: string;
-        stateUpdate?: Record<string, unknown>;
-    }>;
+    } | null>;
     destroySandbox(sandboxId: string): Promise<void>;
     pauseSandbox(sandboxId: string): Promise<void>;
     snapshotSandbox(sandboxId: string): Promise<SandboxSnapshot>;
@@ -119,8 +116,8 @@ interface SandboxOps<TOptions extends SandboxCreateOptions = SandboxCreateOption
  * // → { inMemoryCreateSandbox, inMemoryDestroySandbox, inMemorySnapshotSandbox }
  * ```
  */
-type PrefixedSandboxOps<TPrefix extends string, TOptions extends SandboxCreateOptions = SandboxCreateOptions> = {
-    [K in keyof SandboxOps<TOptions> as `${TPrefix}${Capitalize<K & string>}`]: SandboxOps<TOptions>[K];
+type PrefixedSandboxOps<TPrefix extends string, TOptions extends SandboxCreateOptions = SandboxCreateOptions, TCtx = unknown> = {
+    [K in keyof SandboxOps<TOptions, TCtx> as `${TPrefix}${Capitalize<K & string>}`]: SandboxOps<TOptions, TCtx>[K];
 };
 
 declare class SandboxNotSupportedError extends ApplicationFailure {

package/dist/{types-ChAMwU3q.d.cts → types-AujBIMMn.d.ts}

@@ -86,8 +86,6 @@ interface SandboxCreateOptions {
 }
 interface SandboxCreateResult {
     sandbox: Sandbox;
-    /** Optional state to merge into the workflow's `AgentState` via the session. */
-    stateUpdate?: Record<string, unknown>;
 }
 interface SandboxProvider<TOptions extends SandboxCreateOptions = SandboxCreateOptions, TSandbox extends Sandbox = Sandbox> {
     readonly id: string;
@@ -100,11 +98,10 @@ interface SandboxProvider<TOptions extends SandboxCreateOptions = SandboxCreateO
     restore(snapshot: SandboxSnapshot): Promise<Sandbox>;
     fork(sandboxId: string): Promise<Sandbox>;
 }
-interface SandboxOps<TOptions extends SandboxCreateOptions = SandboxCreateOptions> {
-    createSandbox(options?: TOptions): Promise<{
+interface SandboxOps<TOptions extends SandboxCreateOptions = SandboxCreateOptions, TCtx = unknown> {
+    createSandbox(options?: TOptions, ctx?: TCtx): Promise<{
         sandboxId: string;
-        stateUpdate?: Record<string, unknown>;
-    }>;
+    } | null>;
     destroySandbox(sandboxId: string): Promise<void>;
     pauseSandbox(sandboxId: string): Promise<void>;
     snapshotSandbox(sandboxId: string): Promise<SandboxSnapshot>;
@@ -119,8 +116,8 @@ interface SandboxOps<TOptions extends SandboxCreateOptions = SandboxCreateOption
  * // → { inMemoryCreateSandbox, inMemoryDestroySandbox, inMemorySnapshotSandbox }
  * ```
  */
-type PrefixedSandboxOps<TPrefix extends string, TOptions extends SandboxCreateOptions = SandboxCreateOptions> = {
-    [K in keyof SandboxOps<TOptions> as `${TPrefix}${Capitalize<K & string>}`]: SandboxOps<TOptions>[K];
+type PrefixedSandboxOps<TPrefix extends string, TOptions extends SandboxCreateOptions = SandboxCreateOptions, TCtx = unknown> = {
+    [K in keyof SandboxOps<TOptions, TCtx> as `${TPrefix}${Capitalize<K & string>}`]: SandboxOps<TOptions, TCtx>[K];
 };
 
 declare class SandboxNotSupportedError extends ApplicationFailure {

package/dist/{types-DAv_SLN8.d.ts → types-CCIc7Eam.d.ts}

@@ -1,5 +1,5 @@
 import Redis from 'ioredis';
-import { J as JsonValue } from './types-BkVoEyiH.js';
+import { J as JsonValue } from './types-D90Q5aOh.js';
 
 interface ThreadManagerConfig<T> {
     redis: Redis;

package/dist/{types-BkVoEyiH.d.ts → types-D90Q5aOh.d.ts}

@@ -2,7 +2,7 @@ import { Duration } from '@temporalio/common';
 import { ActivityFunctionWithOptions, QueryDefinition, ActivityInterfaceFor } from '@temporalio/workflow';
 import { UpdateDefinition } from '@temporalio/common/lib/interfaces';
 import { z } from 'zod';
-import { a as SandboxFileSystem, F as FileStat, D as DirentEntry, g as SandboxOps } from './types-ChAMwU3q.js';
+import { a as SandboxFileSystem, F as FileStat, D as DirentEntry, g as SandboxOps } from './types-AujBIMMn.js';
 
 /**
  * A tool definition with a name, description, and Zod schema for arguments.
@@ -431,8 +431,8 @@ interface AgentStateManager<TCustom extends JsonSerializable<TCustom>> {
     get<K extends keyof TCustom>(key: K): TCustom[K];
     /** Set a custom state value by key */
     set<K extends keyof TCustom>(key: K, value: TCustom[K]): void;
-    /** Bulk-merge a partial update into custom state (e.g. from sandbox stateUpdate) */
-    mergeUpdate(update: Partial<TCustom>): void;
+    /** Bulk-merge a partial update into custom state */
+    mergeUpdate(update: Partial<AgentState<TCustom>>): void;
     /** Get full state for query handler */
     getCurrentState(): AgentState<TCustom>;
     /** Check if should return from waitForStateChange */
@@ -460,6 +460,135 @@ interface AgentStateManager<TCustom extends JsonSerializable<TCustom>> {
     };
 }
 
+/**
+ * Ephemeral virtual filesystem backed by a {@link FileResolver}.
+ *
+ * Created fresh for each tool invocation from the current workflow file tree.
+ * Directory structure is inferred from file paths. All mutations are tracked
+ * and can be retrieved via {@link getMutations} after the handler completes.
+ */
+declare class VirtualFileSystem<TCtx = unknown, TMeta = FileEntryMetadata> implements SandboxFileSystem {
+    private resolver;
+    private ctx;
+    readonly workspaceBase: string;
+    private entries;
+    private directories;
+    private mutations;
+    constructor(tree: FileEntry<TMeta>[], resolver: FileResolver<TCtx, TMeta>, ctx: TCtx, workspaceBase?: string);
+    /** Return all mutations accumulated during this invocation. */
+    getMutations(): TreeMutation<TMeta>[];
+    /** Look up a file entry by virtual path. */
+    getEntry(path: string): FileEntry<TMeta> | undefined;
+    readFile(path: string): Promise<string>;
+    readFileBuffer(path: string): Promise<Uint8Array>;
+    exists(path: string): Promise<boolean>;
+    stat(path: string): Promise<FileStat>;
+    readdir(path: string): Promise<string[]>;
+    readdirWithFileTypes(path: string): Promise<DirentEntry[]>;
+    writeFile(path: string, content: string | Uint8Array): Promise<void>;
+    appendFile(path: string, content: string | Uint8Array): Promise<void>;
+    mkdir(_path: string, _options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    rm(path: string, options?: {
+        recursive?: boolean;
+        force?: boolean;
+    }): Promise<void>;
+    cp(src: string, dest: string, _options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    mv(src: string, dest: string): Promise<void>;
+    readlink(_path: string): Promise<string>;
+    resolvePath(base: string, path: string): string;
+    private addParentDirectories;
+}
+
+/** Allowed value types for file-entry metadata. */
+type FileEntryMetadata = Record<string, string | number | boolean | null>;
+/** JSON-serializable metadata for a single file in the virtual tree. */
+interface FileEntry<TMeta = FileEntryMetadata> {
+    id: string;
+    /** Virtual path, e.g. "/src/index.ts" */
+    path: string;
+    size: number;
+    /** ISO-8601 date string (JSON-safe) */
+    mtime: string;
+    metadata: TMeta;
+}
+/**
+ * Flat list of file entries.
+ * Directories are inferred from file paths at runtime.
+ */
+type VirtualFileTree<TMeta = FileEntryMetadata> = FileEntry<TMeta>[];
+type TreeMutation<TMeta = FileEntryMetadata> = {
+    type: "add";
+    entry: FileEntry<TMeta>;
+} | {
+    type: "remove";
+    path: string;
+} | {
+    type: "update";
+    path: string;
+    entry: Partial<FileEntry<TMeta>>;
+};
+/**
+ * Consumer-provided bridge to the existing DB / S3 / CRUD layer.
+ *
+ * Generic over `TCtx` so every call receives workflow-level context
+ * (e.g. `{ projectId: string }`) without the resolver holding state.
+ *
+ * Generic over `TMeta` so resolved entries carry typed metadata.
+ */
+interface FileResolver<TCtx = unknown, TMeta = FileEntryMetadata> {
+    resolveEntries(ctx: TCtx): Promise<FileEntry<TMeta>[]>;
+    readFile(id: string, ctx: TCtx, metadata: TMeta): Promise<string>;
+    readFileBuffer(id: string, ctx: TCtx, metadata: TMeta): Promise<Uint8Array>;
+    writeFile(id: string, content: string | Uint8Array, ctx: TCtx, metadata: TMeta): Promise<void>;
+    createFile(path: string, content: string | Uint8Array, ctx: TCtx): Promise<FileEntry<TMeta>>;
+    deleteFile(id: string, ctx: TCtx, metadata: TMeta): Promise<void>;
+}
+/**
+ * Workflow-side operations for the virtual filesystem.
+ *
+ * Unlike {@link SandboxOps}, this only exposes what is actually needed:
+ * resolving the initial file tree from the consumer's data layer.
+ */
+interface VirtualFsOps<TCtx = unknown, TMeta = FileEntryMetadata> {
+    resolveFileTree(ctx: TCtx): Promise<{
+        fileTree: FileEntry<TMeta>[];
+    }>;
+}
+/**
+ * Maps generic {@link VirtualFsOps} method names to scope-prefixed names.
+ *
+ * @example
+ * ```typescript
+ * type Ops = PrefixedVirtualFsOps<"codingAgent">;
+ * // → { codingAgentResolveFileTree: ... }
+ * ```
+ */
+type PrefixedVirtualFsOps<TPrefix extends string, TCtx = unknown, TMeta = FileEntryMetadata> = {
+    [K in keyof VirtualFsOps<TCtx, TMeta> as `${TPrefix}${Capitalize<K & string>}`]: VirtualFsOps<TCtx, TMeta>[K];
+};
+/**
+ * The portion of workflow `AgentState` that the virtual filesystem reads via
+ * {@link queryParentWorkflowState}. Populated automatically by the session
+ * when `virtualFs` config is provided.
+ */
+interface VirtualFsState<TCtx = unknown, TMeta = FileEntryMetadata> {
+    fileTree: FileEntry<TMeta>[];
+    ctx: TCtx;
+    workspaceBase?: string;
+}
+/**
+ * Extended router context injected by {@link withVirtualFs}.
+ * Guarantees a live (ephemeral) virtual filesystem built from the workflow
+ * file tree.
+ */
+interface VirtualFsContext<TCtx = unknown, TMeta = FileEntryMetadata> extends RouterContext {
+    virtualFs: VirtualFileSystem<TCtx, TMeta>;
+}
+
 /**
  * Agent execution status
  */
@@ -473,6 +602,7 @@ interface BaseAgentState {
     version: number;
     turns: number;
     tasks: Map<string, WorkflowTask>;
+    fileTree: FileEntry[];
     systemPrompt?: string;
     totalInputTokens: number;
     totalOutputTokens: number;
@@ -665,7 +795,9 @@ type ThreadInit = {
 /**
  * Sandbox initialization strategy.
  *
- * - `"new"` — create a fresh sandbox.
+ * - `"new"` — create a fresh sandbox. Optionally pass `ctx` to
+ *   have the {@link SandboxManager}'s resolver produce creation options
+ *   (e.g. initial files) from workflow arguments.
  * - `"continue"` — resume a previously-paused sandbox (this session takes
  *   ownership and the shutdown policy applies on exit).
  * - `"fork"` — fork from an existing (or paused) sandbox; a new sandbox is
@@ -675,6 +807,7 @@ type ThreadInit = {
  */
 type SandboxInit = {
     mode: "new";
+    ctx?: unknown;
 } | {
     mode: "continue";
     sandboxId: string;
@@ -684,7 +817,6 @@ type SandboxInit = {
 } | {
     mode: "inherit";
     sandboxId: string;
-    stateUpdate?: Record<string, unknown>;
 };
 /**
  * What to do with the sandbox when the session exits.
@@ -891,136 +1023,6 @@ interface SkillProvider {
     loadAll(): Promise<Skill[]>;
 }
 
-/**
- * Ephemeral virtual filesystem backed by a {@link FileResolver}.
- *
- * Created fresh for each tool invocation from the current workflow file tree.
- * Directory structure is inferred from file paths. All mutations are tracked
- * and can be retrieved via {@link getMutations} after the handler completes.
- */
-declare class VirtualFileSystem<TCtx = unknown, TMeta = FileEntryMetadata> implements SandboxFileSystem {
-    private resolver;
-    private ctx;
-    readonly workspaceBase: string;
-    private entries;
-    private directories;
-    private mutations;
-    constructor(tree: FileEntry<TMeta>[], resolver: FileResolver<TCtx, TMeta>, ctx: TCtx, workspaceBase?: string);
-    /** Return all mutations accumulated during this invocation. */
-    getMutations(): TreeMutation<TMeta>[];
-    /** Look up a file entry by virtual path. */
-    getEntry(path: string): FileEntry<TMeta> | undefined;
-    readFile(path: string): Promise<string>;
-    readFileBuffer(path: string): Promise<Uint8Array>;
-    exists(path: string): Promise<boolean>;
-    stat(path: string): Promise<FileStat>;
-    readdir(path: string): Promise<string[]>;
-    readdirWithFileTypes(path: string): Promise<DirentEntry[]>;
-    writeFile(path: string, content: string | Uint8Array): Promise<void>;
-    appendFile(path: string, content: string | Uint8Array): Promise<void>;
-    mkdir(_path: string, _options?: {
-        recursive?: boolean;
-    }): Promise<void>;
-    rm(path: string, options?: {
-        recursive?: boolean;
-        force?: boolean;
-    }): Promise<void>;
-    cp(src: string, dest: string, _options?: {
-        recursive?: boolean;
-    }): Promise<void>;
-    mv(src: string, dest: string): Promise<void>;
-    readlink(_path: string): Promise<string>;
-    resolvePath(base: string, path: string): string;
-    private addParentDirectories;
-}
-
-/** Allowed value types for file-entry metadata. */
-type FileEntryMetadata = Record<string, string | number | boolean | null>;
-/** JSON-serializable metadata for a single file in the virtual tree. */
-interface FileEntry<TMeta = FileEntryMetadata> {
-    id: string;
-    /** Virtual path, e.g. "/src/index.ts" */
-    path: string;
-    size: number;
-    /** ISO-8601 date string (JSON-safe) */
-    mtime: string;
-    metadata: TMeta;
-}
-/**
- * Flat list of file entries.
- * Directories are inferred from file paths at runtime.
- */
-type VirtualFileTree<TMeta = FileEntryMetadata> = FileEntry<TMeta>[];
-type TreeMutation<TMeta = FileEntryMetadata> = {
-    type: "add";
-    entry: FileEntry<TMeta>;
-} | {
-    type: "remove";
-    path: string;
-} | {
-    type: "update";
-    path: string;
-    entry: Partial<FileEntry<TMeta>>;
-};
-/**
- * Consumer-provided bridge to the existing DB / S3 / CRUD layer.
- *
- * Generic over `TCtx` so every call receives workflow-level context
- * (e.g. `{ projectId: string }`) without the resolver holding state.
- *
- * Generic over `TMeta` so resolved entries carry typed metadata.
- */
-interface FileResolver<TCtx = unknown, TMeta = FileEntryMetadata> {
-    resolveEntries(ctx: TCtx): Promise<FileEntry<TMeta>[]>;
-    readFile(id: string, ctx: TCtx, metadata: TMeta): Promise<string>;
-    readFileBuffer(id: string, ctx: TCtx, metadata: TMeta): Promise<Uint8Array>;
-    writeFile(id: string, content: string | Uint8Array, ctx: TCtx, metadata: TMeta): Promise<void>;
-    createFile(path: string, content: string | Uint8Array, ctx: TCtx): Promise<FileEntry<TMeta>>;
-    deleteFile(id: string, ctx: TCtx, metadata: TMeta): Promise<void>;
-}
-/**
- * Workflow-side operations for the virtual filesystem.
- *
- * Unlike {@link SandboxOps}, this only exposes what is actually needed:
- * resolving the initial file tree from the consumer's data layer.
- */
-interface VirtualFsOps<TCtx = unknown, TMeta = FileEntryMetadata> {
-    resolveFileTree(ctx: TCtx): Promise<{
-        fileTree: FileEntry<TMeta>[];
-        stateUpdate?: Record<string, unknown>;
-    }>;
-}
-/**
- * Maps generic {@link VirtualFsOps} method names to scope-prefixed names.
- *
- * @example
- * ```typescript
- * type Ops = PrefixedVirtualFsOps<"codingAgent">;
- * // → { codingAgentResolveFileTree: ... }
- * ```
- */
-type PrefixedVirtualFsOps<TPrefix extends string, TCtx = unknown, TMeta = FileEntryMetadata> = {
-    [K in keyof VirtualFsOps<TCtx, TMeta> as `${TPrefix}${Capitalize<K & string>}`]: VirtualFsOps<TCtx, TMeta>[K];
-};
-/**
- * The portion of workflow `AgentState` that the virtual filesystem reads via
- * {@link queryParentWorkflowState}. Populated automatically by the session
- * when `virtualFs` config is provided.
- */
-interface VirtualFsState<TCtx = unknown, TMeta = FileEntryMetadata> {
-    fileTree: FileEntry<TMeta>[];
-    resolverContext: TCtx;
-    workspaceBase?: string;
-}
-/**
- * Extended router context injected by {@link withVirtualFs}.
- * Guarantees a live (ephemeral) virtual filesystem built from the workflow
- * file tree.
- */
-interface VirtualFsContext<TCtx = unknown, TMeta = FileEntryMetadata> extends RouterContext {
-    virtualFs: VirtualFileSystem<TCtx, TMeta>;
-}
-
 /**
  * Agent response from LLM invocation
  */
@@ -1176,20 +1178,19 @@ interface SessionConfig<T extends ToolMap, M = unknown, TContent = string> {
      * Has no effect when the sandbox is inherited (`sandbox.mode === "inherit"`).
      */
     sandboxShutdown?: SubagentSandboxShutdown;
+    virtualFsOps?: VirtualFsOps;
     /**
      * Virtual filesystem configuration (optional — independent of sandbox).
      *
      * When provided, the session resolves the file tree on start and merges
-     * `fileTree`, `resolverContext`, and `workspaceBase` into `AgentState`.
+     * `fileTree`, `ctx`, and `workspaceBase` into `AgentState`.
      * Tool handlers wrapped with `withVirtualFs` can then read this state.
      *
      * Can be used alongside `sandboxOps` for agents that need both a real
      * sandbox (e.g. for execution) and a virtual filesystem.
      */
     virtualFs?: {
-        ops: VirtualFsOps;
-        resolverContext: unknown;
-        workspaceBase?: string;
+        ctx: unknown;
     };
 }
 type SessionResult<M, TState extends JsonSerializable<TState>, HasSandbox extends boolean = boolean> = {

package/dist/{types-BdCdR41N.d.ts → types-DBk-C8zM.d.ts}

@@ -1,4 +1,4 @@
-import { a as SandboxFileSystem, F as FileStat, D as DirentEntry, S as Sandbox, d as SandboxCreateOptions } from './types-ChAMwU3q.js';
+import { a as SandboxFileSystem, F as FileStat, D as DirentEntry, S as Sandbox, d as SandboxCreateOptions } from './types-AujBIMMn.js';
 import { BedrockAgentCoreClient, BedrockAgentCoreClientConfig } from '@aws-sdk/client-bedrock-agentcore';
 
 /**

package/dist/{types-ZHs2v9Ap.d.cts → types-DUvEZSDe.d.cts}

@@ -1,4 +1,4 @@
-import { a as SandboxFileSystem, F as FileStat, D as DirentEntry, S as Sandbox, d as SandboxCreateOptions } from './types-ChAMwU3q.cjs';
+import { a as SandboxFileSystem, F as FileStat, D as DirentEntry, S as Sandbox, d as SandboxCreateOptions } from './types-AujBIMMn.cjs';
 import { BedrockAgentCoreClient, BedrockAgentCoreClientConfig } from '@aws-sdk/client-bedrock-agentcore';
 
 /**