@decocms/runtime 0.28.0 → 1.0.0-alpha-candy.1

package/src/proxy.ts

@@ -1,17 +1,8 @@
 /* oxlint-disable no-explicit-any */
-import type { ToolExecutionContext as _ToolExecutionContext } from "@mastra/core";
 import { convertJsonSchemaToZod } from "zod-from-json-schema";
 import { MCPConnection } from "./connection.ts";
 import { createServerClient } from "./mcp-client.ts";
 import type { CreateStubAPIOptions } from "./mcp.ts";
-import { WELL_KNOWN_API_HOSTNAMES } from "./well-known.ts";
-
-const getWorkspace = (workspace?: string) => {
-  if (workspace && workspace.length > 0 && !workspace.includes("/")) {
-    return `/shared/${workspace}`;
-  }
-  return workspace ?? "";
-};
 
 const safeParse = (content: string) => {
   try {
@@ -33,44 +24,13 @@ const toolsMap = new Map<
   >
 >();
 
-/**
- * Determines if a given URL supports tool names in the path.
- * Our APIs (api.decocms.com, api.deco.chat, localhost) support /tool/${toolName} routing.
- * Third-party APIs typically don't support this pattern.
- */
-function supportsToolNameInPath(url: string): boolean {
-  try {
-    // Our main APIs that support /tool/${toolName} routing
-    return WELL_KNOWN_API_HOSTNAMES.includes(new URL(url).hostname);
-  } catch {
-    return false;
-  }
-}
-
 /**
  * The base fetcher used to fetch the MCP from API.
  */
 export function createMCPClientProxy<T extends Record<string, unknown>>(
-  options?: CreateStubAPIOptions,
+  options: CreateStubAPIOptions,
 ): T {
-  if (typeof options?.connection === "function") {
-    // [DEPRECATED] Passing a function as 'connection' is deprecated and will be removed in a future release.
-    // Please provide a connection object instead.
-    throw new Error(
-      "Deprecation Notice: Passing a function as 'connection' is deprecated and will be removed in a future release. Please provide a connection object instead.",
-    );
-  }
-
-  const mcpPath = options?.mcpPath ?? "/mcp";
-
-  const connection: MCPConnection = options?.connection || {
-    type: "HTTP",
-    token: options?.token,
-    url: new URL(
-      `${getWorkspace(options?.workspace)}${mcpPath}`,
-      options?.decoCmsApiUrl ?? `https://api.decocms.com`,
-    ).href,
-  };
+  const connection: MCPConnection = options.connection;
 
   return new Proxy<T>({} as T, {
     get(_, name) {
@@ -89,28 +49,9 @@ export function createMCPClientProxy<T extends Record<string, unknown>>(
         // Create a connection with the tool name in the URL path for better logging
         // Only modify connections that have a URL property (HTTP, SSE, Websocket)
         // Use automatic detection based on URL, with optional override
-        let toolConnection = connection;
-        const shouldAddToolName =
-          options?.supportsToolName ??
-          ("url" in connection &&
-            typeof connection.url === "string" &&
-            supportsToolNameInPath(connection.url));
-
-        if (
-          shouldAddToolName &&
-          "url" in connection &&
-          typeof connection.url === "string"
-        ) {
-          toolConnection = {
-            ...connection,
-            url: connection.url.endsWith("/")
-              ? `${connection.url}tool/${String(name)}`
-              : `${connection.url}/tool/${String(name)}`,
-          };
-        }
 
         const { client, callStreamableTool } = await createServerClient(
-          { connection: toolConnection },
+          { connection },
           undefined,
           extraHeaders,
         );

package/src/state.ts

@@ -1,7 +1,5 @@
 import { AsyncLocalStorage } from "node:async_hooks";
-import { z } from "zod/v3";
-import type { AppContext } from "./mastra.ts";
-import { createTool } from "./mastra.ts";
+import type { AppContext } from "./tools.ts";
 
 const asyncLocalStorage = new AsyncLocalStorage<AppContext | undefined>();
 
@@ -15,30 +13,3 @@ export const State = {
     ...args: TArgs
   ): R => asyncLocalStorage.run(ctx, f, ...args),
 };
-
-export interface ValidationPayload {
-  state: unknown;
-}
-
-export const createStateValidationTool = (stateSchema?: z.ZodTypeAny) => {
-  return createTool({
-    id: "DECO_CHAT_STATE_VALIDATION",
-    description: "Validate the state of the OAuth flow",
-    inputSchema: z.object({
-      state: z.unknown(),
-    }),
-    outputSchema: z.object({
-      valid: z.boolean(),
-    }),
-    execute: (ctx) => {
-      if (!stateSchema) {
-        return Promise.resolve({ valid: true });
-      }
-      const parsed = stateSchema.safeParse(ctx.context.state);
-      return Promise.resolve({
-        valid: parsed.success,
-        reason: parsed.error?.message,
-      });
-    },
-  });
-};

package/src/tools.ts

@@ -0,0 +1,336 @@
+/* oxlint-disable no-explicit-any */
+/* oxlint-disable ban-types */
+import { HttpServerTransport } from "@deco/mcp/http";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { zodToJsonSchema } from "zod-to-json-schema";
+import type { DefaultEnv } from "./index.ts";
+import { State } from "./state.ts";
+
+export const createRuntimeContext = (prev?: AppContext) => {
+  const store = State.getStore();
+  if (!store) {
+    if (prev) {
+      return prev;
+    }
+    throw new Error("Missing context, did you forget to call State.bind?");
+  }
+  return store;
+};
+
+export interface ToolExecutionContext<
+  TSchemaIn extends z.ZodTypeAny = z.ZodTypeAny,
+> {
+  context: z.infer<TSchemaIn>;
+  runtimeContext: AppContext;
+}
+
+/**
+ * Tool interface with generic schema types for type-safe tool creation.
+ */
+export interface Tool<
+  TSchemaIn extends z.ZodTypeAny = z.ZodTypeAny,
+  TSchemaOut extends z.ZodTypeAny | undefined = undefined,
+> {
+  id: string;
+  description?: string;
+  inputSchema: TSchemaIn;
+  outputSchema?: TSchemaOut;
+  execute(
+    context: ToolExecutionContext<TSchemaIn>,
+  ): TSchemaOut extends z.ZodSchema
+    ? Promise<z.infer<TSchemaOut>>
+    : Promise<unknown>;
+}
+
+/**
+ * Streamable tool interface for tools that return Response streams.
+ */
+export interface StreamableTool<TSchemaIn extends z.ZodSchema = z.ZodSchema> {
+  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.
+ * Uses a structural type with relaxed execute signature to allow tools with any schema.
+ */
+export type CreatedTool = {
+  id: string;
+  description?: string;
+  inputSchema: z.ZodTypeAny;
+  outputSchema?: z.ZodTypeAny;
+  streamable?: true;
+  // Use a permissive execute signature - accepts any context shape
+  execute(context: { context: unknown; runtimeContext: AppContext }): Promise<unknown>;
+};
+
+/**
+ * creates a private tool that always ensure for athentication before being executed
+ */
+export function createPrivateTool<
+  TSchemaIn extends z.ZodSchema = z.ZodSchema,
+  TSchemaOut extends z.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.DECO_REQUEST_CONTEXT.ensureAuthenticated();
+      }
+      return execute(input);
+    };
+  }
+  return createTool(opts);
+}
+
+export function createStreamableTool<
+  TSchemaIn extends z.ZodSchema = z.ZodSchema,
+>(streamableTool: StreamableTool<TSchemaIn>): StreamableTool<TSchemaIn> {
+  return {
+    ...streamableTool,
+    execute: (input: ToolExecutionContext<TSchemaIn>) => {
+      const env = input.runtimeContext.env;
+      if (env) {
+        env.DECO_REQUEST_CONTEXT.ensureAuthenticated();
+      }
+      return streamableTool.execute({
+        ...input,
+        runtimeContext: createRuntimeContext(input.runtimeContext),
+      });
+    },
+  };
+}
+
+export function createTool<
+  TSchemaIn extends z.ZodSchema = z.ZodSchema,
+  TSchemaOut extends z.ZodSchema | undefined = undefined,
+>(opts: Tool<TSchemaIn, TSchemaOut>): Tool<TSchemaIn, TSchemaOut> {
+  return {
+    ...opts,
+    execute: (input: ToolExecutionContext<TSchemaIn>) => {
+      return opts.execute({
+        ...input,
+        runtimeContext: createRuntimeContext(input.runtimeContext),
+      });
+    },
+  };
+}
+
+export interface ViewExport {
+  title: string;
+  icon: string;
+  url: string;
+  tools?: string[];
+  rules?: string[];
+  installBehavior?: "none" | "open" | "autoPin";
+}
+
+export interface Integration {
+  id: string;
+  appId: string;
+}
+
+export function isStreamableTool(
+  tool: CreatedTool,
+): tool is StreamableTool & CreatedTool {
+  return tool && "streamable" in tool && tool.streamable === true;
+}
+
+export interface CreateMCPServerOptions<
+  Env = unknown,
+  TSchema extends z.ZodTypeAny = never,
+> {
+  before?: (env: Env & DefaultEnv<TSchema>) => Promise<void> | void;
+  configuration?: {
+    state?: TSchema;
+    scopes?: string[];
+  };
+  tools?:
+    | Array<
+        (
+          env: Env & DefaultEnv<TSchema>,
+        ) =>
+          | Promise<CreatedTool>
+          | CreatedTool
+          | CreatedTool[]
+          | Promise<CreatedTool[]>
+      >
+    | ((
+        env: Env & DefaultEnv<TSchema>,
+      ) => CreatedTool[] | Promise<CreatedTool[]>);
+}
+
+export type Fetch<TEnv = unknown> = (
+  req: Request,
+  env: TEnv,
+  ctx: ExecutionContext,
+) => Promise<Response> | Response;
+
+export interface AppContext<TEnv = unknown> {
+  env: TEnv;
+  ctx: { waitUntil: (promise: Promise<unknown>) => void };
+  req?: Request;
+}
+
+const decoChatOAuthToolsFor = <TSchema extends z.ZodTypeAny = never>({
+  state: schema,
+  scopes,
+}: CreateMCPServerOptions<unknown, TSchema>["configuration"] = {}): CreatedTool[] => {
+  const jsonSchema = schema
+    ? zodToJsonSchema(schema)
+    : { type: "object", properties: {} };
+  return [
+    // MESH API support
+    createTool({
+      id: "MCP_CONFIGURATION",
+      description: "MCP Configuration",
+      inputSchema: z.object({}),
+      outputSchema: z.object({
+        stateSchema: z.unknown(),
+        scopes: z.array(z.string()).optional(),
+      }),
+      execute: () => {
+        return Promise.resolve({
+          stateSchema: jsonSchema,
+          scopes,
+        });
+      },
+    }),
+  ];
+};
+
+type CallTool = (opts: {
+  toolCallId: string;
+  toolCallInput: unknown;
+}) => Promise<unknown>;
+
+export type MCPServer<TEnv = unknown, TSchema extends z.ZodTypeAny = never> = {
+  fetch: Fetch<TEnv & DefaultEnv<TSchema>>;
+  callTool: CallTool;
+};
+
+export const createMCPServer = <
+  TEnv = unknown,
+  TSchema extends z.ZodTypeAny = never,
+>(
+  options: CreateMCPServerOptions<TEnv, TSchema>,
+): MCPServer<TEnv, TSchema> => {
+  const createServer = async (bindings: TEnv & DefaultEnv<TSchema>) => {
+    await options.before?.(bindings);
+
+    const server = new McpServer(
+      { name: "@deco/mcp-api", version: "1.0.0" },
+      { capabilities: { tools: {} } },
+    );
+
+    const toolsFn =
+      typeof options.tools === "function"
+        ? options.tools
+        : async (bindings: TEnv & DefaultEnv<TSchema>) => {
+            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);
+
+    tools.push(...decoChatOAuthToolsFor<TSchema>(options.configuration));
+
+    for (const tool of tools) {
+      server.registerTool(
+        tool.id,
+        {
+          _meta: {
+            streamable: isStreamableTool(tool),
+          },
+          description: tool.description,
+          inputSchema:
+            tool.inputSchema && "shape" in tool.inputSchema
+              ? (tool.inputSchema.shape as z.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
+              ? (tool.outputSchema.shape as z.ZodRawShape)
+              : z.object({}).shape,
+        },
+        async (args) => {
+          let result = await tool.execute({
+            context: args,
+            runtimeContext: createRuntimeContext(),
+          });
+
+          if (isStreamableTool(tool) && result instanceof Response) {
+            result = { bytes: await result.bytes() };
+          }
+          return {
+            structuredContent: result,
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify(result),
+              },
+            ],
+          };
+        },
+      );
+    }
+
+    return { server, tools };
+  };
+
+  const fetch = async (
+    req: Request,
+    env: TEnv & DefaultEnv<TSchema>,
+    _ctx: ExecutionContext,
+  ) => {
+    const { server } = await createServer(env);
+    const transport = new HttpServerTransport();
+
+    await server.connect(transport);
+
+    return await transport.handleMessage(req);
+  };
+
+  const callTool: CallTool = async ({ toolCallId, toolCallInput }) => {
+    const currentState = State.getStore();
+    if (!currentState) {
+      throw new Error("Missing state, did you forget to call State.bind?");
+    }
+    const env = currentState?.env;
+    const { tools } = await createServer(env);
+    const tool = tools.find((t) => t.id === toolCallId);
+    const execute = tool?.execute;
+    if (!execute) {
+      throw new Error(
+        `Tool ${toolCallId} not found or does not have an execute function`,
+      );
+    }
+
+    return execute({
+      context: toolCallInput,
+      runtimeContext: createRuntimeContext(),
+    });
+  };
+
+  return {
+    fetch,
+    callTool,
+  };
+};

package/src/wrangler.ts

@@ -2,20 +2,20 @@ export interface BindingBase {
   name: string;
 }
 
-export interface MCPIntegrationIdBinding extends BindingBase {
+export interface MCPConnectionBinding extends BindingBase {
   type: "mcp";
   /**
    * If not provided, will return a function that takes the integration id and return the binding implementation..
    */
-  integration_id: string;
+  connection_id: string;
 }
 
-export interface MCPIntegrationNameBinding extends BindingBase {
+export interface MCPAppBinding extends BindingBase {
   type: "mcp";
   /**
    * The name of the integration to bind.
    */
-  integration_name: string;
+  app_name: string;
 }
 export interface ContractClause {
   id: string;
@@ -36,7 +36,7 @@ export interface ContractBinding extends BindingBase {
   contract: Contract;
 }
 
-export type MCPBinding = MCPIntegrationIdBinding | MCPIntegrationNameBinding;
+export type MCPBinding = MCPConnectionBinding | MCPAppBinding;
 
 export type Binding = MCPBinding | ContractBinding;
 

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "types": ["@cloudflare/workers-types", "@types/node"]
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "scripts/**/*"]
+}

package/dist/admin.d.ts

@@ -1,5 +0,0 @@
-declare const requestMissingScopes: ({ scopes }: {
-    scopes: string[];
-}) => void;
-
-export { requestMissingScopes };

package/dist/admin.js

@@ -1,21 +0,0 @@
-import './chunk-I7BWSAN6.js';
-import { createChannel } from 'bidc';
-
-var requestMissingScopes = ({ scopes }) => {
-  try {
-    const channel = createChannel();
-    channel.send({
-      type: "request_missing_scopes",
-      payload: {
-        scopes
-      }
-    });
-    channel.cleanup();
-  } catch (error) {
-    console.error("Failed to request missing scopes", error);
-  }
-};
-
-export { requestMissingScopes };
-//# sourceMappingURL=admin.js.map
-//# sourceMappingURL=admin.js.map

package/dist/admin.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/admin.ts"],"names":[],"mappings":";;;AAEO,IAAM,oBAAA,GAAuB,CAAC,EAAE,MAAA,EAAO,KAA4B;AACxE,EAAA,IAAI;AACF,IAAA,MAAM,UAAU,aAAA,EAAc;AAC9B,IAAA,OAAA,CAAQ,IAAA,CAAK;AAAA,MACX,IAAA,EAAM,wBAAA;AAAA,MACN,OAAA,EAAS;AAAA,QACP;AAAA;AACF,KACD,CAAA;AACD,IAAA,OAAA,CAAQ,OAAA,EAAQ;AAAA,EAClB,SAAS,KAAA,EAAO;AACd,IAAA,OAAA,CAAQ,KAAA,CAAM,oCAAoC,KAAK,CAAA;AAAA,EACzD;AACF","file":"admin.js","sourcesContent":["import { createChannel } from \"bidc\";\n\nexport const requestMissingScopes = ({ scopes }: { scopes: string[] }) => {\n  try {\n    const channel = createChannel();\n    channel.send({\n      type: \"request_missing_scopes\",\n      payload: {\n        scopes,\n      },\n    });\n    channel.cleanup();\n  } catch (error) {\n    console.error(\"Failed to request missing scopes\", error);\n  }\n};\n"]}

package/dist/bindings/deconfig/index.d.ts

@@ -1,12 +0,0 @@
-export { D as DeconfigClient, i as DeconfigResource, b as DeconfigResourceOptions, E as EnhancedResourcesTools, N as NotFoundError, h as RESOURCE_WATCH_BASE_PATHNAME, R as ResourcesBinding, d as ResourcesTools, U as UserInputError, W as WatchOptions, a as createDeconfigResource } from '../../index-B7U9jXW4.js';
-import '@mastra/core';
-import '../../index-uCMd27hU.js';
-import '@cloudflare/workers-types';
-import 'zod/v3';
-import '@mastra/core/di';
-import '@mastra/core/workflows';
-import '../../resources.js';
-import '../../mcp-DYmQ2RQf.js';
-import '@decocms/bindings/connection';
-import '@decocms/bindings';
-import 'zod';

package/dist/bindings/deconfig/index.js

@@ -1,10 +0,0 @@
-export { DeconfigResource, NotFoundError, RESOURCE_WATCH_BASE_PATHNAME, UserInputError, createDeconfigResource } from '../../chunk-SHQSNOFL.js';
-import '../../chunk-5EYZ2LVM.js';
-import '../../chunk-3AWMDSOH.js';
-import '../../chunk-UHR3BLMF.js';
-import '../../chunk-UIJGM3NV.js';
-import '../../chunk-L4OT2YDO.js';
-import '../../chunk-7ITSLORK.js';
-import '../../chunk-I7BWSAN6.js';
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map

package/dist/bindings/deconfig/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}