@decocms/runtime 1.3.1 → 1.4.0

package/README.md

@@ -152,37 +152,6 @@ const getUserDataTool = createPrivateTool({
 });
 ```
 
-### Streamable Tools
-
-For tools that return streaming responses:
-
-```typescript
-import { createStreamableTool } from "@decocms/runtime";
-
-const streamDataTool = createStreamableTool({
-  id: "streamData",
-  description: "Streams data as a response",
-  inputSchema: z.object({
-    query: z.string(),
-  }),
-  streamable: true,
-  execute: async ({ context }) => {
-    // Return a streaming Response
-    const stream = new ReadableStream({
-      async start(controller) {
-        controller.enqueue(new TextEncoder().encode("Chunk 1\n"));
-        controller.enqueue(new TextEncoder().encode("Chunk 2\n"));
-        controller.close();
-      },
-    });
-    
-    return new Response(stream, {
-      headers: { "Content-Type": "text/plain" },
-    });
-  },
-});
-```
-
 ### Registering Tools
 
 Tools can be registered in multiple ways:
@@ -701,7 +670,6 @@ export default withRuntime({
 ### Types
 
 - `Tool<TSchemaIn, TSchemaOut>` - Tool definition with typed input/output
-- `StreamableTool<TSchemaIn>` - Tool that returns streaming Response
 - `Prompt<TArgs>` - Prompt definition with typed arguments
 - `Resource` - Resource definition
 - `OAuthConfig` - OAuth configuration
@@ -714,7 +682,6 @@ export default withRuntime({
 - `withRuntime(options)` - Create an MCP server
 - `createTool(opts)` - Create a public tool
 - `createPrivateTool(opts)` - Create an authenticated tool
-- `createStreamableTool(opts)` - Create a streaming tool
 - `createPrompt(opts)` - Create an authenticated prompt
 - `createPublicPrompt(opts)` - Create a public prompt
 - `createResource(opts)` - Create an authenticated resource

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decocms/runtime",
-  "version": "1.3.1",
+  "version": "1.4.0",
   "type": "module",
   "scripts": {
     "check": "tsc --noEmit",

package/src/bindings/binder.ts

@@ -7,7 +7,7 @@ import {
   type MCPClientFetchStub,
   type ToolBinder,
 } from "../mcp.ts";
-import { createPrivateTool, createStreamableTool } from "../tools.ts";
+import { createPrivateTool } from "../tools.ts";
 import { CHANNEL_BINDING } from "./channels.ts";
 
 // ToolLike is a simplified version of the Tool interface that matches what we need for bindings
@@ -77,13 +77,6 @@ export const bindingClient = <TDefinition extends readonly ToolBinder[]>(
     ): MCPClientFetchStub<TDefinition> => {
       return createMCPFetchStub<TDefinition>({
         connection: mcpConnection,
-        streamable: binder.reduce(
-          (acc, tool) => {
-            acc[tool.name] = tool.streamable === true;
-            return acc;
-          },
-          {} as Record<string, boolean>,
-        ),
       });
     },
   };
@@ -99,12 +92,8 @@ export const impl = <TBinder extends Binder>(
   schema: TBinder,
   implementation: BinderImplementation<TBinder>,
   createToolFn = createPrivateTool,
-  createStreamableToolFn = createStreamableTool,
 ) => {
-  const impl: (
-    | ReturnType<typeof createToolFn>
-    | ReturnType<typeof createStreamableToolFn>
-  )[] = [];
+  const impl: ReturnType<typeof createToolFn>[] = [];
   for (const key in schema) {
     const toolSchema = schema[key];
     const toolImplementation = implementation[key];
@@ -117,28 +106,17 @@ export const impl = <TBinder extends Binder>(
       throw new Error(`Implementation for ${key} is required`);
     }
 
-    const { name, handler, streamable, ...toolLike } = {
+    const { name, handler, ...toolLike } = {
       ...toolSchema,
       ...toolImplementation,
     };
-    if (streamable) {
-      impl.push(
-        createStreamableToolFn({
-          ...toolLike,
-          streamable,
-          id: name,
-          execute: ({ context }) => Promise.resolve(handler(context)),
-        }),
-      );
-    } else {
-      impl.push(
-        createToolFn({
-          ...toolLike,
-          id: name,
-          execute: ({ context }) => Promise.resolve(handler(context)),
-        }),
-      );
-    }
+    impl.push(
+      createToolFn({
+        ...toolLike,
+        id: name,
+        execute: ({ context }) => Promise.resolve(handler(context)),
+      }),
+    );
   }
   return impl;
 };

package/src/bindings.ts

@@ -161,7 +161,7 @@ export const AgentOf = () =>
     thinking: AgentModelInfoSchema.optional(),
     coding: AgentModelInfoSchema.optional(),
     fast: AgentModelInfoSchema.optional(),
-    toolApprovalLevel: z.enum(["auto", "readonly", "plan"]).default("readonly"),
+    toolApprovalLevel: z.enum(["auto", "readonly", "plan"]).default("auto"),
     temperature: z.number().default(0.5),
   });
 

package/src/index.ts

@@ -29,6 +29,7 @@ export {
   type ResourceContents,
   type CreatedResource,
   type WorkflowDefinition,
+  ensureAuthenticated,
 } from "./tools.ts";
 export { createWorkflow } from "./workflows.ts";
 import type { Binding } from "./wrangler.ts";

package/src/tools.ts

@@ -16,7 +16,7 @@ import { z } from "zod";
 import type { ZodRawShape, ZodSchema, ZodTypeAny } from "zod";
 import { BindingRegistry, injectBindingSchemas } from "./bindings.ts";
 import { Event, type EventHandlers } from "./events.ts";
-import type { DefaultEnv } from "./index.ts";
+import type { DefaultEnv, User } from "./index.ts";
 import { State } from "./state.ts";
 import {
   type WorkflowDefinition,
@@ -67,25 +67,14 @@ export interface Tool<
   outputSchema?: TSchemaOut;
   execute(
     context: ToolExecutionContext<TSchemaIn>,
+    ctx?: AppContext,
   ): TSchemaOut extends ZodSchema
     ? Promise<z.infer<TSchemaOut>>
     : Promise<unknown>;
 }
 
 /**
- * Streamable tool interface for tools that return Response streams.
- */
-export interface StreamableTool<TSchemaIn extends ZodSchema = ZodSchema> {
-  _meta?: Record<string, unknown>;
-  id: string;
-  inputSchema: TSchemaIn;
-  streamable?: true;
-  description?: string;
-  execute(input: ToolExecutionContext<TSchemaIn>): Promise<Response>;
-}
-
-/**
- * CreatedTool is a permissive type that any Tool or StreamableTool can be assigned to.
+ * CreatedTool is a permissive type that any Tool can be assigned to.
  * Uses a structural type with relaxed execute signature to allow tools with any schema.
  */
 export type CreatedTool = {
@@ -95,12 +84,14 @@ export type CreatedTool = {
   annotations?: ToolAnnotations;
   inputSchema: ZodTypeAny;
   outputSchema?: ZodTypeAny;
-  streamable?: true;
   // Use a permissive execute signature - accepts any context shape
-  execute(context: {
-    context: unknown;
-    runtimeContext: AppContext;
-  }): Promise<unknown>;
+  execute(
+    context: {
+      context: unknown;
+      runtimeContext: AppContext;
+    },
+    ctx?: AppContext,
+  ): Promise<unknown>;
 };
 
 // Re-export types for external use
@@ -137,6 +128,7 @@ export interface Prompt<TArgs extends PromptArgsRawShape = PromptArgsRawShape> {
   argsSchema?: TArgs;
   execute(
     context: PromptExecutionContext<TArgs>,
+    ctx?: AppContext,
   ): Promise<GetPromptResult> | GetPromptResult;
 }
 
@@ -150,10 +142,13 @@ export type CreatedPrompt = {
   description?: string;
   argsSchema?: PromptArgsRawShape;
   // Use a permissive execute signature - accepts any args shape
-  execute(context: {
-    args: Record<string, string | undefined>;
-    runtimeContext: AppContext;
-  }): Promise<GetPromptResult> | GetPromptResult;
+  execute(
+    context: {
+      args: Record<string, string | undefined>;
+      runtimeContext: AppContext;
+    },
+    ctx?: AppContext,
+  ): Promise<GetPromptResult> | GetPromptResult;
 };
 
 // ============================================================================
@@ -199,6 +194,7 @@ export interface Resource {
   /** Handler function to read the resource content */
   read(
     context: ResourceExecutionContext,
+    ctx?: AppContext,
   ): Promise<ResourceContents> | ResourceContents;
 }
 
@@ -211,48 +207,58 @@ export type CreatedResource = {
   name: string;
   description?: string;
   mimeType?: string;
-  read(context: {
-    uri: URL;
-    runtimeContext: AppContext;
-  }): Promise<ResourceContents> | ResourceContents;
+  read(
+    context: {
+      uri: URL;
+      runtimeContext: AppContext;
+    },
+    ctx?: AppContext,
+  ): Promise<ResourceContents> | ResourceContents;
 };
 
 /**
- * creates a private tool that always ensure for athentication before being executed
+ * Ensure the current request is authenticated.
+ * Reads from the per-request AppContext (AsyncLocalStorage), not from a cached env.
+ *
+ * @param ctx - Per-request AppContext from the second arg of execute/read handlers
+ * @returns The authenticated User
+ * @throws Error if no request context or user is not authenticated
+ */
+export function ensureAuthenticated(ctx: AppContext): User {
+  const reqCtx = ctx?.env?.MESH_REQUEST_CONTEXT;
+  if (!reqCtx) {
+    throw new Error("Unauthorized: missing request context");
+  }
+  const user = reqCtx.ensureAuthenticated();
+  if (!user) {
+    throw new Error("Unauthorized");
+  }
+  return user;
+}
+
+let _warnedPrivateTool = false;
+
+/**
+ * @deprecated Use `createTool` with `ensureAuthenticated(ctx)` instead.
+ *
+ * Creates a private tool that ensures authentication before execution.
  */
 export function createPrivateTool<
   TSchemaIn extends ZodSchema = ZodSchema,
   TSchemaOut extends ZodSchema | undefined = undefined,
 >(opts: Tool<TSchemaIn, TSchemaOut>): Tool<TSchemaIn, TSchemaOut> {
-  const execute = opts.execute;
-  if (typeof execute === "function") {
-    opts.execute = (input: ToolExecutionContext<TSchemaIn>) => {
-      const env = input.runtimeContext.env;
-      if (env) {
-        env.MESH_REQUEST_CONTEXT?.ensureAuthenticated();
-      }
-      return execute(input);
-    };
+  if (!_warnedPrivateTool) {
+    console.warn(
+      "[runtime] createPrivateTool is deprecated. Use createTool with ensureAuthenticated(ctx) instead.",
+    );
+    _warnedPrivateTool = true;
   }
-  return createTool(opts);
-}
-
-export function createStreamableTool<TSchemaIn extends ZodSchema = ZodSchema>(
-  streamableTool: StreamableTool<TSchemaIn>,
-): StreamableTool<TSchemaIn> {
-  return {
-    ...streamableTool,
-    execute: (input: ToolExecutionContext<TSchemaIn>) => {
-      const env = input.runtimeContext.env;
-      if (env) {
-        env.MESH_REQUEST_CONTEXT?.ensureAuthenticated();
-      }
-      return streamableTool.execute({
-        ...input,
-        runtimeContext: createRuntimeContext(input.runtimeContext),
-      });
-    },
+  const execute = opts.execute;
+  opts.execute = (input: ToolExecutionContext<TSchemaIn>, ctx: AppContext) => {
+    ensureAuthenticated(ctx);
+    return execute(input, ctx);
   };
+  return createTool(opts);
 }
 
 export function createTool<
@@ -263,10 +269,8 @@ export function createTool<
   return {
     ...opts,
     execute: (input: ToolExecutionContext<TSchemaIn>) => {
-      return opts.execute({
-        ...input,
-        runtimeContext: createRuntimeContext(input.runtimeContext),
-      });
+      const ctx = createRuntimeContext(input.runtimeContext);
+      return opts.execute({ ...input, runtimeContext: ctx }, ctx);
     },
   };
 }
@@ -280,10 +284,8 @@ export function createPublicPrompt<TArgs extends PromptArgsRawShape>(
   return {
     ...opts,
     execute: (input: PromptExecutionContext<TArgs>) => {
-      return opts.execute({
-        ...input,
-        runtimeContext: createRuntimeContext(input.runtimeContext),
-      });
+      const ctx = createRuntimeContext(input.runtimeContext);
+      return opts.execute({ ...input, runtimeContext: ctx }, ctx);
     },
   };
 }
@@ -298,12 +300,9 @@ export function createPrompt<TArgs extends PromptArgsRawShape>(
   const execute = opts.execute;
   return createPublicPrompt({
     ...opts,
-    execute: (input: PromptExecutionContext<TArgs>) => {
-      const env = input.runtimeContext.env;
-      if (env) {
-        env.MESH_REQUEST_CONTEXT?.ensureAuthenticated();
-      }
-      return execute(input);
+    execute: (input: PromptExecutionContext<TArgs>, ctx: AppContext) => {
+      ensureAuthenticated(ctx);
+      return execute(input, ctx);
     },
   });
 }
@@ -315,10 +314,8 @@ export function createPublicResource(opts: Resource): Resource {
   return {
     ...opts,
     read: (input: ResourceExecutionContext) => {
-      return opts.read({
-        ...input,
-        runtimeContext: createRuntimeContext(input.runtimeContext),
-      });
+      const ctx = createRuntimeContext(input.runtimeContext);
+      return opts.read({ ...input, runtimeContext: ctx }, ctx);
     },
   };
 }
@@ -331,12 +328,9 @@ export function createResource(opts: Resource): Resource {
   const read = opts.read;
   return createPublicResource({
     ...opts,
-    read: (input: ResourceExecutionContext) => {
-      const env = input.runtimeContext.env;
-      if (env) {
-        env.MESH_REQUEST_CONTEXT?.ensureAuthenticated();
-      }
-      return read(input);
+    read: (input: ResourceExecutionContext, ctx: AppContext) => {
+      ensureAuthenticated(ctx);
+      return read(input, ctx);
     },
   });
 }
@@ -355,12 +349,6 @@ export interface Integration {
   appId: string;
 }
 
-export function isStreamableTool(
-  tool: CreatedTool,
-): tool is StreamableTool & CreatedTool {
-  return tool && "streamable" in tool && tool.streamable === true;
-}
-
 export interface OnChangeCallback<TState> {
   state: TState;
   scopes: string[];
@@ -500,35 +488,38 @@ export interface CreateMCPServerOptions<
   };
   tools?:
     | Array<
-        (
-          env: TEnv,
-        ) =>
-          | Promise<CreatedTool>
-          | CreatedTool
-          | CreatedTool[]
-          | Promise<CreatedTool[]>
+        | CreatedTool
+        | ((
+            env: TEnv,
+          ) =>
+            | Promise<CreatedTool>
+            | CreatedTool
+            | CreatedTool[]
+            | Promise<CreatedTool[]>)
       >
     | ((env: TEnv) => CreatedTool[] | Promise<CreatedTool[]>);
   prompts?:
     | Array<
-        (
-          env: TEnv,
-        ) =>
-          | Promise<CreatedPrompt>
-          | CreatedPrompt
-          | CreatedPrompt[]
-          | Promise<CreatedPrompt[]>
+        | CreatedPrompt
+        | ((
+            env: TEnv,
+          ) =>
+            | Promise<CreatedPrompt>
+            | CreatedPrompt
+            | CreatedPrompt[]
+            | Promise<CreatedPrompt[]>)
       >
     | ((env: TEnv) => CreatedPrompt[] | Promise<CreatedPrompt[]>);
   resources?:
     | Array<
-        (
-          env: TEnv,
-        ) =>
-          | Promise<CreatedResource>
-          | CreatedResource
-          | CreatedResource[]
-          | Promise<CreatedResource[]>
+        | CreatedResource
+        | ((
+            env: TEnv,
+          ) =>
+            | Promise<CreatedResource>
+            | CreatedResource
+            | CreatedResource[]
+            | Promise<CreatedResource[]>)
       >
     | ((env: TEnv) => CreatedResource[] | Promise<CreatedResource[]>);
   workflows?:
@@ -819,7 +810,8 @@ export const createMCPServer = <
 ): MCPServer<TEnv, TSchema, TBindings> => {
   // Tool/prompt/resource definitions are resolved once on first request and
   // cached for the lifetime of the process. Tool *execution* reads per-request
-  // context from State (AsyncLocalStorage), so reusing definitions is safe.
+  // context from State (AsyncLocalStorage) via the second `ctx` argument, so
+  // reusing definitions is safe.
   type Registrations = {
     tools: CreatedTool[];
     prompts: CreatedPrompt[];
@@ -830,6 +822,51 @@ export const createMCPServer = <
   let cached: Registrations | null = null;
   let inflightResolve: Promise<Registrations> | null = null;
 
+  let _warnedFactoryDeprecation = false;
+  const warnFactoryDeprecation = () => {
+    if (!_warnedFactoryDeprecation) {
+      console.warn(
+        "[runtime] Passing factory functions to tools/prompts/resources is deprecated. " +
+          "Pass createTool()/createPrompt()/createResource() instances directly.",
+      );
+      _warnedFactoryDeprecation = true;
+    }
+  };
+
+  /**
+   * Check whether a value is an already-created instance (has an `id` or `name` property)
+   * rather than a factory function.
+   */
+  const isInstance = (v: unknown): boolean =>
+    typeof v === "object" &&
+    v !== null &&
+    ("id" in v || "name" in v || "uri" in v);
+
+  /**
+   * Resolve an array that may contain both direct instances and factory functions.
+   * Factories are called with `bindings` and trigger a deprecation warning.
+   */
+  async function resolveArray<T>(
+    items: Array<unknown> | undefined,
+    bindings: TEnv,
+  ): Promise<T[]> {
+    if (!items) return [];
+    return (
+      await Promise.all(
+        items.flatMap(async (item) => {
+          if (isInstance(item)) {
+            return [item as T];
+          }
+          // Factory function — deprecated path
+          warnFactoryDeprecation();
+          const result = await (item as (env: TEnv) => unknown)(bindings);
+          if (Array.isArray(result)) return result as T[];
+          return [result as T];
+        }),
+      )
+    ).flat();
+  }
+
   const resolveRegistrations = async (
     bindings: TEnv,
   ): Promise<Registrations> => {
@@ -838,25 +875,13 @@ export const createMCPServer = <
 
     inflightResolve = (async (): Promise<Registrations> => {
       try {
-        const toolsFn =
-          typeof options.tools === "function"
-            ? options.tools
-            : async (bindings: TEnv) => {
-                if (typeof options.tools === "function") {
-                  return await options.tools(bindings);
-                }
-                return await Promise.all(
-                  options.tools?.flatMap(async (tool) => {
-                    const toolResult = tool(bindings);
-                    const awaited = await toolResult;
-                    if (Array.isArray(awaited)) {
-                      return awaited;
-                    }
-                    return [awaited];
-                  }) ?? [],
-                ).then((t) => t.flat());
-              };
-        const tools = await toolsFn(bindings);
+        let tools: CreatedTool[];
+        if (typeof options.tools === "function") {
+          warnFactoryDeprecation();
+          tools = await options.tools(bindings);
+        } else {
+          tools = await resolveArray<CreatedTool>(options.tools, bindings);
+        }
 
         const resolvedWorkflows =
           typeof options.workflows === "function"
@@ -867,45 +892,27 @@ export const createMCPServer = <
           ...toolsFor<TSchema>({ ...options, workflows: resolvedWorkflows }),
         );
 
-        const promptsFn =
-          typeof options.prompts === "function"
-            ? options.prompts
-            : async (bindings: TEnv) => {
-                if (typeof options.prompts === "function") {
-                  return await options.prompts(bindings);
-                }
-                return await Promise.all(
-                  options.prompts?.flatMap(async (prompt) => {
-                    const promptResult = prompt(bindings);
-                    const awaited = await promptResult;
-                    if (Array.isArray(awaited)) {
-                      return awaited;
-                    }
-                    return [awaited];
-                  }) ?? [],
-                ).then((p) => p.flat());
-              };
-        const prompts = await promptsFn(bindings);
-
-        const resourcesFn =
-          typeof options.resources === "function"
-            ? options.resources
-            : async (bindings: TEnv) => {
-                if (typeof options.resources === "function") {
-                  return await options.resources(bindings);
-                }
-                return await Promise.all(
-                  options.resources?.flatMap(async (resource) => {
-                    const resourceResult = resource(bindings);
-                    const awaited = await resourceResult;
-                    if (Array.isArray(awaited)) {
-                      return awaited;
-                    }
-                    return [awaited];
-                  }) ?? [],
-                ).then((r) => r.flat());
-              };
-        const resources = await resourcesFn(bindings);
+        let prompts: CreatedPrompt[];
+        if (typeof options.prompts === "function") {
+          warnFactoryDeprecation();
+          prompts = await options.prompts(bindings);
+        } else {
+          prompts = await resolveArray<CreatedPrompt>(
+            options.prompts,
+            bindings,
+          );
+        }
+
+        let resources: CreatedResource[];
+        if (typeof options.resources === "function") {
+          warnFactoryDeprecation();
+          resources = await options.resources(bindings);
+        } else {
+          resources = await resolveArray<CreatedResource>(
+            options.resources,
+            bindings,
+          );
+        }
 
         const result = {
           tools,
@@ -924,55 +931,32 @@ export const createMCPServer = <
     return inflightResolve;
   };
 
-  const registerAll = (
-    server: McpServer,
-    registrations: Registrations,
-  ) => {
+  const registerAll = (server: McpServer, registrations: Registrations) => {
     for (const tool of registrations.tools) {
       server.registerTool(
         tool.id,
         {
-          _meta: {
-            streamable: isStreamableTool(tool),
-            ...(tool._meta ?? {}),
-          },
+          _meta: tool._meta,
           description: tool.description,
           annotations: tool.annotations,
           inputSchema:
             tool.inputSchema && "shape" in tool.inputSchema
               ? (tool.inputSchema.shape as ZodRawShape)
               : z.object({}).shape,
-          outputSchema: isStreamableTool(tool)
-            ? z.object({ bytes: z.record(z.string(), z.number()) }).shape
-            : tool.outputSchema &&
-                typeof tool.outputSchema === "object" &&
-                "shape" in tool.outputSchema
+          outputSchema:
+            tool.outputSchema &&
+            typeof tool.outputSchema === "object" &&
+            "shape" in tool.outputSchema
               ? (tool.outputSchema.shape as ZodRawShape)
               : undefined,
         },
         async (args) => {
-          const result = await tool.execute({
-            context: args,
-            runtimeContext: createRuntimeContext(),
-          });
+          const ctx = createRuntimeContext();
+          const result = await tool.execute(
+            { context: args, runtimeContext: ctx },
+            ctx,
+          );
 
-          // For streamable tools, the Response is handled at the transport layer.
-          // Do NOT call result.bytes() — it buffers the entire body in memory.
-          if (isStreamableTool(tool) && result instanceof Response) {
-            return {
-              structuredContent: {
-                streamable: true,
-                status: result.status,
-                statusText: result.statusText,
-              },
-              content: [
-                {
-                  type: "text",
-                  text: `Streaming response: ${result.status} ${result.statusText}`,
-                },
-              ],
-            };
-          }
           return {
             structuredContent: result as Record<string, unknown>,
             content: [
@@ -997,10 +981,14 @@ export const createMCPServer = <
             : z.object({}).shape,
         },
         async (args) => {
-          return await prompt.execute({
-            args: args as Record<string, string | undefined>,
-            runtimeContext: createRuntimeContext(),
-          });
+          const ctx = createRuntimeContext();
+          return await prompt.execute(
+            {
+              args: args as Record<string, string | undefined>,
+              runtimeContext: ctx,
+            },
+            ctx,
+          );
         },
       );
     }
@@ -1014,10 +1002,8 @@ export const createMCPServer = <
           mimeType: resource.mimeType,
         },
         async (uri) => {
-          const result = await resource.read({
-            uri,
-            runtimeContext: createRuntimeContext(),
-          });
+          const ctx = createRuntimeContext();
+          const result = await resource.read({ uri, runtimeContext: ctx }, ctx);
 
           const meta =
             (result as { _meta?: Record<string, unknown> | null })._meta ??
@@ -1114,7 +1100,10 @@ export const createMCPServer = <
       // finishes (server sent the response) or the client disconnects
       // (cancel), the server and transport are always cleaned up.
       const { readable, writable } = new TransformStream();
-      response.body.pipeTo(writable).catch(() => {}).finally(cleanup);
+      response.body
+        .pipeTo(writable)
+        .catch(() => {})
+        .finally(cleanup);
 
       return new Response(readable, {
         status: response.status,
@@ -1144,10 +1133,8 @@ export const createMCPServer = <
       );
     }
 
-    return execute({
-      context: toolCallInput,
-      runtimeContext: createRuntimeContext(),
-    });
+    const ctx = createRuntimeContext();
+    return execute({ context: toolCallInput, runtimeContext: ctx }, ctx);
   };
 
   return {