zeitlich 0.2.22 → 0.2.23

package/src/lib/session/session.integration.test.ts

@@ -38,7 +38,11 @@ vi.mock("@temporalio/workflow", () => {
     condition: async (fn: () => boolean) => fn(),
     defineUpdate: (name: string) => ({ __type: "update", name }),
     defineQuery: (name: string) => ({ __type: "query", name }),
+    defineSignal: (name: string) => ({ __type: "signal", name }),
     setHandler: (_def: unknown, _handler: unknown) => {},
+    startChild: async () => ({ result: () => Promise.resolve(null) }),
+    workflowInfo: () => ({ taskQueue: "default-queue" }),
+    getExternalWorkflowHandle: () => ({ signal: async () => {} }),
     uuid4: () =>
       `00000000-0000-0000-0000-${String(++idCounter).padStart(12, "0")}`,
     ApplicationFailure: MockApplicationFailure,
@@ -150,7 +154,7 @@ describe("createSession integration", () => {
 
     const session = await createSession({
       agentName: "TestAgent",
-      threadId: "thread-1",
+      thread: { mode: "new", threadId: "thread-1" },
       runAgent: createScriptedRunAgent([{ message: "Hello!", toolCalls: [] }]),
       threadOps: ops,
       buildContextMessage: () => "What is 2+2?",
@@ -182,7 +186,7 @@ describe("createSession integration", () => {
 
     const session = await createSession({
       agentName: "TestAgent",
-      threadId: "thread-1",
+      thread: { mode: "new", threadId: "thread-1" },
       runAgent: createScriptedRunAgent([
         {
           message: "Let me echo that.",
@@ -221,7 +225,7 @@ describe("createSession integration", () => {
 
     const session = await createSession({
       agentName: "TestAgent",
-      threadId: "thread-1",
+      thread: { mode: "new", threadId: "thread-1" },
       runAgent: createScriptedRunAgent([
         {
           message: "turn 1",
@@ -270,7 +274,7 @@ describe("createSession integration", () => {
 
     const session = await createSession({
       agentName: "TestAgent",
-      threadId: "thread-1",
+      thread: { mode: "new", threadId: "thread-1" },
       maxTurns: 3,
       runAgent: infiniteAgent,
       threadOps: ops,
@@ -297,7 +301,7 @@ describe("createSession integration", () => {
 
     const session = await createSession({
       agentName: "TestAgent",
-      threadId: "thread-1",
+      thread: { mode: "new", threadId: "thread-1" },
       runAgent: createScriptedRunAgent([{ message: "done", toolCalls: [] }]),
       threadOps: ops,
       buildContextMessage: () => "hi",
@@ -330,7 +334,7 @@ describe("createSession integration", () => {
 
     const session = await createSession({
       agentName: "TestAgent",
-      threadId: "thread-1",
+      thread: { mode: "new", threadId: "thread-1" },
       runAgent: createScriptedRunAgent([]),
       threadOps: ops,
       buildContextMessage: () => "hi",
@@ -350,7 +354,7 @@ describe("createSession integration", () => {
 
     const session = await createSession({
       agentName: "TestAgent",
-      threadId: "thread-1",
+      thread: { mode: "new", threadId: "thread-1" },
       appendSystemPrompt: false,
       runAgent: createScriptedRunAgent([{ message: "ok", toolCalls: [] }]),
       threadOps: ops,
@@ -377,7 +381,7 @@ describe("createSession integration", () => {
 
     const session = await createSession({
       agentName: "TestAgent",
-      threadId: "thread-1",
+      thread: { mode: "new", threadId: "thread-1" },
       runAgent: createScriptedRunAgent([
         {
           message: "turn 1",
@@ -413,7 +417,7 @@ describe("createSession integration", () => {
 
     const session = await createSession({
       agentName: "TestAgent",
-      threadId: "thread-1",
+      thread: { mode: "new", threadId: "thread-1" },
       runAgent: createScriptedRunAgent([
         {
           message: "bad call",
@@ -451,15 +455,14 @@ describe("createSession integration", () => {
     expect(errorConfig?.content).toContain("Invalid tool call");
   });
 
-  // --- continueThread ---
+  // --- Thread fork mode ---
 
-  it("forks thread when continueThread is set", async () => {
+  it("forks thread when thread mode is fork", async () => {
     const { ops, log } = createMockThreadOps();
 
     const session = await createSession({
       agentName: "TestAgent",
-      threadId: "source-thread",
-      continueThread: true,
+      thread: { mode: "fork", threadId: "source-thread" },
       runAgent: createScriptedRunAgent([
         { message: "continued", toolCalls: [] },
       ]),
@@ -490,9 +493,9 @@ describe("createSession integration", () => {
     const sandboxLog: string[] = [];
 
     const sandboxOps: SandboxOps = {
-      createSandbox: async (options) => {
-        sandboxLog.push(`create:${options?.id ?? "unknown"}`);
-        return { sandboxId: `sb-${options?.id ?? "unknown"}` };
+      createSandbox: async () => {
+        sandboxLog.push("create");
+        return { sandboxId: "sb-1" };
       },
       destroySandbox: async (sandboxId: string) => {
         sandboxLog.push(`destroy:${sandboxId}`);
@@ -504,15 +507,16 @@ describe("createSession integration", () => {
         createdAt: new Date().toISOString(),
       }),
       forkSandbox: async () => "forked-sandbox-id",
+      pauseSandbox: async () => {},
     };
 
     const session = await createSession({
       agentName: "TestAgent",
-      threadId: "thread-1",
+      thread: { mode: "new", threadId: "thread-1" },
       runAgent: createScriptedRunAgent([{ message: "done", toolCalls: [] }]),
       threadOps: ops,
       buildContextMessage: () => "go",
-      sandbox: sandboxOps,
+      sandboxOps,
     });
 
     const stateManager = createAgentStateManager({
@@ -521,8 +525,8 @@ describe("createSession integration", () => {
 
     await session.runSession({ stateManager });
 
-    expect(sandboxLog).toContain("create:thread-1");
-    expect(sandboxLog).toContain("destroy:sb-thread-1");
+    expect(sandboxLog).toContain("create");
+    expect(sandboxLog).toContain("destroy:sb-1");
   });
 
   it("does not create or destroy sandbox when sandboxId is inherited", async () => {
@@ -544,16 +548,17 @@ describe("createSession integration", () => {
         createdAt: new Date().toISOString(),
       }),
       forkSandbox: async () => "forked-sandbox-id",
+      pauseSandbox: async () => {},
     };
 
     const session = await createSession({
       agentName: "TestAgent",
-      threadId: "thread-1",
+      thread: { mode: "new", threadId: "thread-1" },
       runAgent: createScriptedRunAgent([{ message: "done", toolCalls: [] }]),
       threadOps: ops,
       buildContextMessage: () => "go",
-      sandbox: sandboxOps,
-      sandboxId: "inherited-sb",
+      sandboxOps,
+      sandbox: { mode: "inherit", sandboxId: "inherited-sb" },
     });
 
     const stateManager = createAgentStateManager({
@@ -581,9 +586,22 @@ describe("createSession integration", () => {
       },
     });
 
+    const sandboxOps: SandboxOps = {
+      createSandbox: async () => ({ sandboxId: "sb" }),
+      destroySandbox: async () => {},
+      pauseSandbox: async () => {},
+      snapshotSandbox: async () => ({
+        sandboxId: "sb",
+        providerId: "test",
+        data: null,
+        createdAt: new Date().toISOString(),
+      }),
+      forkSandbox: async () => "forked-sb",
+    };
+
     const session = await createSession({
       agentName: "TestAgent",
-      threadId: "thread-1",
+      thread: { mode: "new", threadId: "thread-1" },
       runAgent: createScriptedRunAgent([
         {
           message: "spy",
@@ -594,7 +612,8 @@ describe("createSession integration", () => {
       threadOps: ops,
       tools: { Spy: spyTool },
       buildContextMessage: () => "go",
-      sandboxId: "my-sandbox",
+      sandbox: { mode: "inherit", sandboxId: "my-sandbox" },
+      sandboxOps,
     });
 
     const stateManager = createAgentStateManager({
@@ -614,7 +633,7 @@ describe("createSession integration", () => {
 
     const session = await createSession({
       agentName: "TestAgent",
-      threadId: "thread-1",
+      thread: { mode: "new", threadId: "thread-1" },
       runAgent: async () => {
         throw new Error("LLM went down");
       },
@@ -646,7 +665,7 @@ describe("createSession integration", () => {
 
     const session = await createSession({
       agentName: "TestAgent",
-      threadId: "thread-1",
+      thread: { mode: "new", threadId: "thread-1" },
       runAgent: createScriptedRunAgent([
         {
           message: "call echo",
@@ -716,7 +735,7 @@ describe("createSession integration", () => {
 
     const session = await createSession({
       agentName: "TestAgent",
-      threadId: "thread-1",
+      thread: { mode: "new", threadId: "thread-1" },
       runAgent: createScriptedRunAgent([
         {
           message: "computing",
@@ -752,7 +771,7 @@ describe("createSession integration", () => {
 
     const session = await createSession({
       agentName: "TestAgent",
-      threadId: "thread-1",
+      thread: { mode: "new", threadId: "thread-1" },
       runAgent: createScriptedRunAgent([{ message: "done", toolCalls: [] }]),
       threadOps: ops,
       buildContextMessage: async () => {
@@ -789,15 +808,16 @@ describe("createSession integration", () => {
         createdAt: new Date().toISOString(),
       }),
       forkSandbox: async () => "forked-sandbox-id",
+      pauseSandbox: async () => {},
     };
 
     const session = await createSession({
       agentName: "TestAgent",
-      threadId: "thread-1",
+      thread: { mode: "new", threadId: "thread-1" },
       runAgent: createScriptedRunAgent([{ message: "done", toolCalls: [] }]),
       threadOps: ops,
       buildContextMessage: () => "go",
-      sandbox: sandboxOps,
+      sandboxOps,
     });
 
     const stateManager = createAgentStateManager<{ customField: string }>({
@@ -827,7 +847,7 @@ describe("createSession integration", () => {
 
     const session = await createSession({
       agentName: "TestAgent",
-      threadId: "thread-1",
+      thread: { mode: "new", threadId: "thread-1" },
       runAgent: createScriptedRunAgent([
         {
           message: "t1",

package/src/lib/session/session.ts

@@ -6,6 +6,7 @@ import {
 } from "@temporalio/workflow";
 import type { SessionExitReason, MessageContent } from "../types";
 import type { SessionConfig, ZeitlichSession } from "./types";
+import type { SandboxOps } from "../sandbox/types";
 import { type AgentStateManager, type JsonSerializable } from "../state/types";
 import { createToolRouter } from "../tool-router/router";
 import type { ParsedToolCallUnion, ToolMap } from "../tool-router/types";
@@ -18,6 +19,9 @@ import { uuid4 } from "@temporalio/workflow";
  * Creates an agent session that manages the agent loop: LLM invocation,
  * tool routing, subagent coordination, and lifecycle hooks.
  *
+ * When `sandboxOps` is provided the returned session result is guaranteed to
+ * include `sandboxId: string`. Without it, `sandboxId` is `undefined`.
+ *
  * @param config - Session and agent configuration (merged `SessionConfig` and `AgentConfig`)
  * @returns A session object with `runSession()` to start the agent loop
  *
@@ -29,8 +33,8 @@ import { uuid4 } from "@temporalio/workflow";
  * const session = await createSession({
  *   agentName: "my-agent",
  *   maxTurns: 20,
- *   threadId: runId,
- *   threadOps: proxyGoogleGenAIThreadOps(), // auto-scoped to current workflow
+ *   thread: { mode: "new" },
+ *   threadOps: proxyGoogleGenAIThreadOps(),
  *   runAgent: runAgentActivity,
  *   buildContextMessage: () => [{ type: "text", text: prompt }],
  *   subagents: [researcherSubagent],
@@ -42,8 +46,13 @@ import { uuid4 } from "@temporalio/workflow";
  * const { finalMessage, exitReason } = await session.runSession({ stateManager });
  * ```
  */
-export const createSession = async <T extends ToolMap, M = unknown>({
-  threadId: providedThreadId,
+export async function createSession<T extends ToolMap, M = unknown>(
+  config: SessionConfig<T, M> & { sandboxOps: SandboxOps }
+): Promise<ZeitlichSession<M, true>>;
+export async function createSession<T extends ToolMap, M = unknown>(
+  config: SessionConfig<T, M>
+): Promise<ZeitlichSession<M, false>>;
+export async function createSession<T extends ToolMap, M = unknown>({
   agentName,
   maxTurns = 50,
   metadata = {},
@@ -56,16 +65,33 @@ export const createSession = async <T extends ToolMap, M = unknown>({
   processToolsInParallel = true,
   hooks = {},
   appendSystemPrompt = true,
-  continueThread = false,
   waitForInputTimeout = "48h",
-  sandbox: sandboxOps,
-  sandboxId: inheritedSandboxId,
-}: SessionConfig<T, M>): Promise<ZeitlichSession<M>> => {
-  const sourceThreadId = continueThread ? providedThreadId : undefined;
-  const threadId =
-    continueThread && providedThreadId
-      ? getShortId()
-      : (providedThreadId ?? getShortId());
+  sandboxOps,
+  thread: threadInit,
+  sandbox: sandboxInit,
+  sandboxShutdown = "destroy",
+}: SessionConfig<T, M>): Promise<ZeitlichSession<M, boolean>> {
+  // ---------------------------------------------------------------------------
+  // Thread resolution
+  // ---------------------------------------------------------------------------
+  const threadMode = threadInit?.mode ?? "new";
+  let threadId: string;
+  let sourceThreadId: string | undefined;
+
+  switch (threadMode) {
+    case "new":
+      threadId = threadInit?.mode === "new" && threadInit.threadId
+        ? threadInit.threadId
+        : getShortId();
+      break;
+    case "continue":
+      threadId = (threadInit as { mode: "continue"; threadId: string }).threadId;
+      break;
+    case "fork":
+      sourceThreadId = (threadInit as { mode: "fork"; threadId: string }).threadId;
+      threadId = getShortId();
+      break;
+  }
 
   const {
     appendToolResult,
@@ -76,9 +102,13 @@ export const createSession = async <T extends ToolMap, M = unknown>({
   } = threadOps;
 
   const plugins: ToolMap[string][] = [];
+  let destroySubagentSandboxes: (() => Promise<void>) | undefined;
   if (subagents) {
-    const reg = buildSubagentRegistration(subagents);
-    if (reg) plugins.push(reg);
+    const result = buildSubagentRegistration(subagents);
+    if (result) {
+      plugins.push(result.registration);
+      destroySubagentSandboxes = result.destroySubagentSandboxes;
+    }
   }
   if (skills) {
     const reg = buildSkillRegistration(skills);
@@ -114,12 +144,7 @@ export const createSession = async <T extends ToolMap, M = unknown>({
       stateManager,
     }: {
       stateManager: AgentStateManager<TState>;
-    }): Promise<{
-      threadId: string;
-      finalMessage: M | null;
-      exitReason: SessionExitReason;
-      usage: ReturnType<AgentStateManager<TState>["getTotalUsage"]>;
-    }> => {
+    }) => {
       setHandler(
         defineUpdate<unknown, [MessageContent]>(`add${agentName}Message`),
         async (message: MessageContent) => {
@@ -140,12 +165,43 @@ export const createSession = async <T extends ToolMap, M = unknown>({
         }
       );
 
-      // --- Sandbox lifecycle: create or inherit ---
-      let sandboxId: string | undefined = inheritedSandboxId;
-      const ownsSandbox = !sandboxId && !!sandboxOps;
-      if (ownsSandbox) {
-        const result = await sandboxOps.createSandbox({ id: threadId });
+      // --- Sandbox lifecycle: create, continue, fork, or inherit ----------
+      const sandboxMode = sandboxInit?.mode;
+      let sandboxId: string | undefined;
+      let sandboxOwned = false;
+
+      if (sandboxMode === "inherit") {
+        sandboxId = (sandboxInit as { mode: "inherit"; sandboxId: string }).sandboxId;
+        if (!sandboxOps) {
+          throw ApplicationFailure.create({
+            message: "sandboxId provided but no sandboxOps — cannot manage sandbox lifecycle",
+            nonRetryable: true,
+          });
+        }
+      } else if (sandboxMode === "continue") {
+        if (!sandboxOps) {
+          throw ApplicationFailure.create({
+            message: "No sandboxOps provided — cannot continue sandbox",
+            nonRetryable: true,
+          });
+        }
+        sandboxId = (sandboxInit as { mode: "continue"; sandboxId: string }).sandboxId;
+        sandboxOwned = true;
+      } else if (sandboxMode === "fork") {
+        if (!sandboxOps) {
+          throw ApplicationFailure.create({
+            message: "No sandboxOps provided — cannot fork sandbox",
+            nonRetryable: true,
+          });
+        }
+        sandboxId = await sandboxOps.forkSandbox(
+          (sandboxInit as { mode: "fork"; sandboxId: string }).sandboxId
+        );
+        sandboxOwned = true;
+      } else if (sandboxOps) {
+        const result = await sandboxOps.createSandbox();
         sandboxId = result.sandboxId;
+        sandboxOwned = true;
         if (result.stateUpdate) {
           stateManager.mergeUpdate(result.stateUpdate as Partial<TState>);
         }
@@ -161,8 +217,11 @@ export const createSession = async <T extends ToolMap, M = unknown>({
 
       const systemPrompt = stateManager.getSystemPrompt();
 
-      if (continueThread && sourceThreadId) {
+      // --- Thread lifecycle: new, continue, or fork ----------------------
+      if (threadMode === "fork" && sourceThreadId) {
         await forkThread(sourceThreadId, threadId);
+      } else if (threadMode === "continue") {
+        // "continue" — thread already exists, just append the new message
       } else {
         if (appendSystemPrompt) {
           if (!systemPrompt || systemPrompt.trim() === "") {
@@ -209,7 +268,8 @@ export const createSession = async <T extends ToolMap, M = unknown>({
               finalMessage: message,
               exitReason,
               usage: stateManager.getTotalUsage(),
-            };
+              sandboxId,
+            } as Awaited<ReturnType<ZeitlichSession<M, boolean>["runSession"]>>;
           }
 
           const parsedToolCalls: ParsedToolCallUnion<T>[] = [];
@@ -265,8 +325,22 @@ export const createSession = async <T extends ToolMap, M = unknown>({
       } finally {
         await callSessionEnd(exitReason, stateManager.getTurns());
 
-        if (ownsSandbox && sandboxId && sandboxOps) {
-          await sandboxOps.destroySandbox(sandboxId);
+        if (sandboxOwned && sandboxId && sandboxOps) {
+          switch (sandboxShutdown) {
+            case "destroy":
+              await sandboxOps.destroySandbox(sandboxId);
+              break;
+            case "pause":
+            case "pause-until-parent-close":
+              await sandboxOps.pauseSandbox(sandboxId);
+              break;
+            case "keep":
+              break;
+          }
+        }
+
+        if (destroySubagentSandboxes) {
+          await destroySubagentSandboxes();
         }
       }
 
@@ -275,8 +349,8 @@ export const createSession = async <T extends ToolMap, M = unknown>({
         finalMessage: null,
         exitReason,
         usage: stateManager.getTotalUsage(),
-      };
+        sandboxId,
+      } as Awaited<ReturnType<ZeitlichSession<M, boolean>["runSession"]>>;
     },
   };
-};
-
+}

package/src/lib/session/types.ts

@@ -16,6 +16,7 @@ import type { SandboxOps } from "../sandbox/types";
 import type { RunAgentActivity } from "../model/types";
 import type { AgentStateManager, JsonSerializable } from "../state/types";
 import type { ActivityInterfaceFor } from "@temporalio/workflow";
+import type { ThreadInit, SandboxInit, SubagentSandboxShutdown } from "../lifecycle";
 
 /**
  * Thread operations required by a session.
@@ -79,8 +80,6 @@ export type PrefixedThreadOps<TPrefix extends string> = {
 export interface SessionConfig<T extends ToolMap, M = unknown> {
   /** The name of the agent, should be unique within the workflows */
   agentName: string;
-  /** The thread ID to use for the session (defaults to a short generated ID) */
-  threadId?: string;
   /** Metadata for the session */
   metadata?: Record<string, unknown>;
   /** Whether to append the system prompt as message to the thread */
@@ -106,27 +105,67 @@ export interface SessionConfig<T extends ToolMap, M = unknown> {
    * Returns MessageContent array for the initial HumanMessage.
    */
   buildContextMessage: () => MessageContent | Promise<MessageContent>;
-  /** When true, skip thread initialization and system prompt — append only the new human message to the existing thread. */
-  continueThread?: boolean;
   /** How long to wait for input before cancelling the workflow */
   waitForInputTimeout?: Duration;
+
+  // ---------------------------------------------------------------------------
+  // Thread lifecycle
+  // ---------------------------------------------------------------------------
+
+  /**
+   * Thread initialization strategy (default: `{ mode: "new" }`).
+   *
+   * - `{ mode: "new" }` — start a fresh thread.
+   * - `{ mode: "new", threadId: "..." }` — start a fresh thread with a specific ID.
+   * - `{ mode: "continue", threadId: "..." }` — append to an existing thread in-place.
+   * - `{ mode: "fork", threadId: "..." }` — fork an existing thread and continue in the copy.
+   */
+  thread?: ThreadInit;
+
+  // ---------------------------------------------------------------------------
+  // Sandbox lifecycle
+  // ---------------------------------------------------------------------------
+
   /** Sandbox lifecycle operations (optional — omit for agents that don't need a sandbox) */
-  sandbox?: SandboxOps;
+  sandboxOps?: SandboxOps;
+  /**
+   * Sandbox initialization strategy.
+   *
+   * - `{ mode: "new" }` — create a fresh sandbox.
+   * - `{ mode: "continue", sandboxId: "..." }` — resume a paused sandbox (session owns it).
+   * - `{ mode: "fork", sandboxId: "..." }` — fork from an existing sandbox.
+   * - `{ mode: "inherit", sandboxId: "..." }` — use a parent's sandbox without ownership.
+   *
+   * When omitted and `sandboxOps` is provided, defaults to `{ mode: "new" }`.
+   */
+  sandbox?: SandboxInit;
   /**
-   * Pre-existing sandbox ID to reuse (e.g. inherited from a parent agent).
-   * When set, the session skips `createSandbox` and will not destroy the
-   * sandbox on exit (the owner is responsible for cleanup).
+   * What to do with the sandbox when this session exits.
+   *
+   * Defaults to `"destroy"` when omitted.
+   * Has no effect when the sandbox is inherited (`sandbox.mode === "inherit"`).
    */
-  sandboxId?: string;
+  sandboxShutdown?: SubagentSandboxShutdown;
 }
 
-export interface ZeitlichSession<M = unknown> {
+export type SessionResult<
+  M,
+  TState extends JsonSerializable<TState>,
+  HasSandbox extends boolean = boolean,
+> = {
+  threadId: string;
+  finalMessage: M | null;
+  exitReason: SessionExitReason;
+  usage: ReturnType<AgentStateManager<TState>["getTotalUsage"]>;
+} & (HasSandbox extends true
+  ? { sandboxId: string }
+  : { sandboxId?: undefined });
+
+export interface ZeitlichSession<
+  M = unknown,
+  HasSandbox extends boolean = boolean,
+> {
   runSession<T extends JsonSerializable<T>>(args: {
     stateManager: AgentStateManager<T>;
-  }): Promise<{
-    threadId: string;
-    finalMessage: M | null;
-    exitReason: SessionExitReason;
-    usage: ReturnType<AgentStateManager<T>["getTotalUsage"]>;
-  }>;
+  }): Promise<SessionResult<M, T, HasSandbox>>;
 }

package/src/lib/subagent/define.ts

@@ -3,6 +3,7 @@ import type {
   SubagentConfig,
   SubagentDefinition,
   SubagentHooks,
+  SubagentSandboxConfig,
   SubagentWorkflow,
 } from "./types";
 import type { SubagentArgs } from "./tool";
@@ -19,8 +20,8 @@ import type { SubagentArgs } from "./tool";
  *
  * // With parent-specific overrides
  * export const researcher = defineSubagent(researcherWorkflow, {
- *   allowThreadContinuation: true,
- *   sandbox: "own",
+ *   thread: "fork",
+ *   sandbox: { source: "own", shutdown: "pause" },
  *   hooks: {
  *     onPostExecution: ({ result }) => console.log(result),
  *   },
@@ -42,8 +43,8 @@ export function defineSubagent<
     hooks?: SubagentHooks<SubagentArgs, z.infer<TResult>>;
     enabled?: boolean | (() => boolean);
     taskQueue?: string;
-    allowThreadContinuation?: boolean;
-    sandbox?: "inherit" | "own";
+    thread?: "new" | "fork" | "continue";
+    sandbox?: SubagentSandboxConfig;
   },
 ): SubagentConfig<TResult> {
   return {