zeitlich 0.2.41 → 0.2.42

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zeitlich",
-  "version": "0.2.41",
+  "version": "0.2.42",
   "description": "[EXPERIMENTAL] An opinionated AI agent implementation for Temporal",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -156,26 +156,6 @@
         "types": "./dist/adapters/sandbox/e2b/workflow.d.ts",
         "default": "./dist/adapters/sandbox/e2b/workflow.js"
       }
-    },
-    "./adapters/sandbox/bedrock": {
-      "import": {
-        "types": "./dist/adapters/sandbox/bedrock/index.d.ts",
-        "default": "./dist/adapters/sandbox/bedrock/index.js"
-      },
-      "require": {
-        "types": "./dist/adapters/sandbox/bedrock/index.d.ts",
-        "default": "./dist/adapters/sandbox/bedrock/index.js"
-      }
-    },
-    "./adapters/sandbox/bedrock/workflow": {
-      "import": {
-        "types": "./dist/adapters/sandbox/bedrock/workflow.d.ts",
-        "default": "./dist/adapters/sandbox/bedrock/workflow.js"
-      },
-      "require": {
-        "types": "./dist/adapters/sandbox/bedrock/workflow.d.ts",
-        "default": "./dist/adapters/sandbox/bedrock/workflow.js"
-      }
     }
   },
   "files": [
@@ -220,17 +200,16 @@
     "node": ">=18"
   },
   "devDependencies": {
-    "@anthropic-ai/sdk": "^0.81.0",
-    "@aws-sdk/client-bedrock-agentcore": "^3.900.0",
-    "@daytonaio/sdk": "^0.158.1",
+    "@anthropic-ai/sdk": "^0.93.0",
+    "@daytonaio/sdk": "^0.171.0",
     "@e2b/code-interpreter": "^2.3.3",
     "@eslint/js": "^10.0.1",
     "@google/genai": "^1.44.0",
     "@langchain/core": "^1.1.30",
-    "@temporalio/common": "1.16.0",
-    "@temporalio/envconfig": "1.16.0",
-    "@temporalio/worker": "1.16.0",
-    "@temporalio/workflow": "1.16.0",
+    "@temporalio/common": "^1.17.0",
+    "@temporalio/envconfig": "^1.17.0",
+    "@temporalio/worker": "^1.17.0",
+    "@temporalio/workflow": "^1.17.0",
     "@types/node": "^25.3.3",
     "eslint": "^10.0.2",
     "husky": "^9.1.7",
@@ -244,7 +223,6 @@
   },
   "peerDependencies": {
     "@anthropic-ai/sdk": ">=0.50.0",
-    "@aws-sdk/client-bedrock-agentcore": "^3.900.0",
     "@daytonaio/sdk": ">=0.153.0",
     "@e2b/code-interpreter": "^2.3.3",
     "@google/genai": "^1.43.0",
@@ -257,9 +235,6 @@
     "just-bash": ">=2.0.0"
   },
   "peerDependenciesMeta": {
-    "@aws-sdk/client-bedrock-agentcore": {
-      "optional": true
-    },
     "@daytonaio/sdk": {
       "optional": true
     },

package/src/adapters/sandbox/daytona/index.ts

@@ -2,16 +2,13 @@ import { Daytona, type Sandbox as DaytonaSdkSandbox } from "@daytonaio/sdk";
 import type {
   Sandbox,
   SandboxCapabilities,
+  SandboxCapability,
   SandboxCreateResult,
   SandboxProvider,
-  SandboxSnapshot,
   ExecOptions,
   ExecResult,
 } from "../../../lib/sandbox/types";
-import {
-  SandboxNotFoundError,
-  SandboxNotSupportedError,
-} from "../../../lib/sandbox/types";
+import { SandboxNotFoundError } from "../../../lib/sandbox/types";
 import { DaytonaSandboxFileSystem } from "./filesystem";
 import type {
   DaytonaSandbox,
@@ -64,16 +61,35 @@ class DaytonaSandboxImpl implements Sandbox {
 // DaytonaSandboxProvider
 // ============================================================================
 
-export class DaytonaSandboxProvider implements SandboxProvider<
-  DaytonaSandboxCreateOptions,
-  DaytonaSandbox
-> {
+/**
+ * Single source of truth for the Daytona adapter's capability set. Daytona
+ * implements only base lifecycle (`create` / `get` / `destroy`); both the
+ * type-level `TCaps` (`never`) and the runtime `supportedCapabilities`
+ * set fall out of this empty array, so the two surfaces cannot drift.
+ */
+const DAYTONA_CAPS = [] as const satisfies readonly SandboxCapability[];
+type DaytonaCaps = (typeof DAYTONA_CAPS)[number]; // → never
+
+/**
+ * Daytona implements only base sandbox lifecycle (`create` / `get` /
+ * `destroy`). Snapshot, restore, fork, pause, and resume are not supported
+ * — the type-level capability set is `never`, so calling any of those
+ * methods on a Daytona provider, manager, or `SandboxOps` proxy is a
+ * compile-time TypeScript error.
+ */
+export class DaytonaSandboxProvider
+  implements
+    SandboxProvider<DaytonaSandboxCreateOptions, DaytonaSandbox, DaytonaCaps>
+{
   readonly id = "daytona";
   readonly capabilities: SandboxCapabilities = {
     filesystem: true,
     execution: true,
     persistence: false,
   };
+  readonly supportedCapabilities: ReadonlySet<DaytonaCaps> = new Set(
+    DAYTONA_CAPS
+  );
 
   private client: Daytona;
   private readonly defaultWorkspaceBase: string;
@@ -140,45 +156,6 @@ export class DaytonaSandboxProvider implements SandboxProvider<
       // Already gone
     }
   }
-
-  async pause(_sandboxId: string, _ttlSeconds?: number): Promise<void> {
-    throw new SandboxNotSupportedError("pause");
-  }
-
-  async resume(_sandboxId: string): Promise<void> {
-    // Daytona sandboxes don't support pause, so resume is a no-op
-  }
-
-  async fork(
-    _sandboxId: string,
-    _options?: DaytonaSandboxCreateOptions
-  ): Promise<Sandbox> {
-    throw new Error("Not implemented");
-  }
-
-  async snapshot(
-    _sandboxId: string,
-    _options?: DaytonaSandboxCreateOptions
-  ): Promise<SandboxSnapshot> {
-    throw new SandboxNotSupportedError(
-      "snapshot (use Daytona's native snapshot API directly)"
-    );
-  }
-
-  async restore(
-    _snapshot: SandboxSnapshot,
-    _options?: DaytonaSandboxCreateOptions
-  ): Promise<never> {
-    throw new SandboxNotSupportedError(
-      "restore (use Daytona's native snapshot API directly)"
-    );
-  }
-
-  async deleteSnapshot(_snapshot: SandboxSnapshot): Promise<void> {
-    throw new SandboxNotSupportedError(
-      "deleteSnapshot (use Daytona's native snapshot API directly)"
-    );
-  }
 }
 
 // Re-exports

package/src/adapters/sandbox/daytona/proxy.ts

@@ -10,6 +10,11 @@
  * By default the scope is derived from `workflowInfo().workflowType`,
  * so activities are automatically namespaced per workflow.
  *
+ * Daytona only exposes base sandbox lifecycle (`create`/`destroy`) — the
+ * returned proxy is typed with `TCaps = never`, so calling
+ * `pauseSandbox` / `snapshotSandbox` / `forkSandbox` / etc. on it is a
+ * TypeScript error rather than a runtime throw.
+ *
  * @example
  * ```typescript
  * import { proxyDaytonaSandboxOps } from 'zeitlich/adapters/sandbox/daytona/workflow';
@@ -26,7 +31,7 @@ const ADAPTER_PREFIX = "daytona";
 export function proxyDaytonaSandboxOps(
   scope?: string,
   options?: Parameters<typeof proxyActivities>[0]
-): SandboxOps {
+): SandboxOps<DaytonaSandboxCreateOptions, unknown, never> {
   const resolvedScope = scope ?? workflowInfo().workflowType;
 
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -49,11 +54,5 @@ export function proxyDaytonaSandboxOps(
   return {
     createSandbox: acts[p("createSandbox")],
     destroySandbox: acts[p("destroySandbox")],
-    pauseSandbox: acts[p("pauseSandbox")],
-    resumeSandbox: acts[p("resumeSandbox")],
-    snapshotSandbox: acts[p("snapshotSandbox")],
-    restoreSandbox: acts[p("restoreSandbox")],
-    deleteSandboxSnapshot: acts[p("deleteSandboxSnapshot")],
-    forkSandbox: acts[p("forkSandbox")],
-  } as SandboxOps<DaytonaSandboxCreateOptions>;
+  } as SandboxOps<DaytonaSandboxCreateOptions, unknown, never>;
 }

package/src/adapters/sandbox/e2b/index.ts

@@ -6,6 +6,7 @@ import {
 import type {
   Sandbox,
   SandboxCapabilities,
+  SandboxCapability,
   SandboxCreateResult,
   SandboxProvider,
   SandboxSnapshot,
@@ -80,16 +81,30 @@ class E2bSandboxImpl implements Sandbox {
 // E2bSandboxProvider
 // ============================================================================
 
-export class E2bSandboxProvider implements SandboxProvider<
-  E2bSandboxCreateOptions,
-  E2bSandbox
-> {
+/**
+ * Single source of truth for the E2B adapter's capability set. Both the
+ * runtime `supportedCapabilities` set and the type-level `TCaps` flow
+ * out of this array, so the two surfaces cannot drift.
+ */
+export const E2B_CAPS = [
+  "pause",
+  "resume",
+  "snapshot",
+  "restore",
+  "fork",
+] as const satisfies readonly SandboxCapability[];
+export type E2bCaps = (typeof E2B_CAPS)[number];
+
+export class E2bSandboxProvider
+  implements SandboxProvider<E2bSandboxCreateOptions, E2bSandbox, E2bCaps>
+{
   readonly id = "e2b";
   readonly capabilities: SandboxCapabilities = {
     filesystem: true,
     execution: true,
     persistence: true,
   };
+  readonly supportedCapabilities: ReadonlySet<E2bCaps> = new Set(E2B_CAPS);
 
   private readonly defaultTemplate?: string;
   private readonly defaultWorkspaceBase: string;
@@ -193,7 +208,7 @@ export class E2bSandboxProvider implements SandboxProvider<
   async restore(
     snapshot: SandboxSnapshot,
     options?: E2bSandboxCreateOptions
-  ): Promise<Sandbox> {
+  ): Promise<E2bSandbox> {
     const data = snapshot.data as { snapshotId?: string } | null;
     if (!data?.snapshotId) {
       throw new SandboxNotSupportedError(
@@ -222,7 +237,7 @@ export class E2bSandboxProvider implements SandboxProvider<
   async fork(
     sandboxId: string,
     options?: E2bSandboxCreateOptions
-  ): Promise<Sandbox> {
+  ): Promise<E2bSandbox> {
     const { snapshotId } = await E2bSdkSandbox.createSnapshot(sandboxId);
     const sdkOpts = this.buildSdkCreateOpts(options);
     const sdkSandbox = await E2bSdkSandbox.create(snapshotId, sdkOpts);

package/src/adapters/sandbox/e2b/proxy.ts

@@ -19,6 +19,7 @@
  */
 import { proxyActivities, workflowInfo } from "@temporalio/workflow";
 import type { SandboxOps } from "../../../lib/sandbox/types";
+import type { E2bCaps } from "./index";
 import type { E2bSandboxCreateOptions } from "./types";
 
 const ADAPTER_PREFIX = "e2b";
@@ -26,7 +27,7 @@ const ADAPTER_PREFIX = "e2b";
 export function proxyE2bSandboxOps(
   scope?: string,
   options?: Parameters<typeof proxyActivities>[0]
-): SandboxOps {
+): SandboxOps<E2bSandboxCreateOptions, unknown, E2bCaps> {
   const resolvedScope = scope ?? workflowInfo().workflowType;
 
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -55,5 +56,5 @@ export function proxyE2bSandboxOps(
     restoreSandbox: acts[p("restoreSandbox")],
     deleteSandboxSnapshot: acts[p("deleteSandboxSnapshot")],
     forkSandbox: acts[p("forkSandbox")],
-  } as SandboxOps<E2bSandboxCreateOptions>;
+  } as SandboxOps<E2bSandboxCreateOptions, unknown, E2bCaps>;
 }

package/src/adapters/sandbox/inmemory/index.ts

@@ -8,6 +8,7 @@ import {
 import type {
   Sandbox,
   SandboxCapabilities,
+  SandboxCapability,
   SandboxCreateOptions,
   SandboxCreateResult,
   SandboxFileSystem,
@@ -133,13 +134,32 @@ class InMemorySandboxImpl implements Sandbox {
 // InMemorySandboxProvider
 // ============================================================================
 
-export class InMemorySandboxProvider implements SandboxProvider {
+/**
+ * Single source of truth for the in-memory adapter's capability set. The
+ * runtime `supportedCapabilities` set and the type-level `TCaps` are both
+ * derived from this array, so the two surfaces cannot drift.
+ */
+export const IN_MEMORY_CAPS = [
+  "pause",
+  "resume",
+  "snapshot",
+  "restore",
+  "fork",
+] as const satisfies readonly SandboxCapability[];
+export type InMemoryCaps = (typeof IN_MEMORY_CAPS)[number];
+
+export class InMemorySandboxProvider
+  implements SandboxProvider<SandboxCreateOptions, Sandbox, InMemoryCaps>
+{
   readonly id = "inMemory";
   readonly capabilities: SandboxCapabilities = {
     filesystem: true,
     execution: true,
     persistence: true,
   };
+  readonly supportedCapabilities: ReadonlySet<InMemoryCaps> = new Set(
+    IN_MEMORY_CAPS
+  );
 
   private sandboxes = new Map<string, InMemorySandboxImpl>();
 

package/src/adapters/sandbox/inmemory/proxy.ts

@@ -16,14 +16,18 @@
  * ```
  */
 import { proxyActivities, workflowInfo } from "@temporalio/workflow";
-import type { SandboxOps } from "../../../lib/sandbox/types";
+import type {
+  SandboxCreateOptions,
+  SandboxOps,
+} from "../../../lib/sandbox/types";
+import type { InMemoryCaps } from "./index";
 
 const ADAPTER_PREFIX = "inMemory";
 
 export function proxyInMemorySandboxOps(
   scope?: string,
   options?: Parameters<typeof proxyActivities>[0]
-): SandboxOps {
+): SandboxOps<SandboxCreateOptions, unknown, InMemoryCaps> {
   const resolvedScope = scope ?? workflowInfo().workflowType;
 
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -52,5 +56,5 @@ export function proxyInMemorySandboxOps(
     restoreSandbox: acts[p("restoreSandbox")],
     deleteSandboxSnapshot: acts[p("deleteSandboxSnapshot")],
     forkSandbox: acts[p("forkSandbox")],
-  } as SandboxOps;
+  } as SandboxOps<SandboxCreateOptions, unknown, InMemoryCaps>;
 }

package/src/lib/activity.ts

@@ -32,6 +32,11 @@ export async function queryParentWorkflowState<T>(
   client: WorkflowClient
 ): Promise<T> {
   const { workflowExecution } = Context.current().info;
+
+  if (!workflowExecution) {
+    throw new Error("No workflow execution found");
+  }
+
   const handle = client.getHandle(
     workflowExecution.workflowId,
     workflowExecution.runId