@decocms/runtime 1.0.0-alpha.10 → 1.0.0-alpha.11

package/config-schema.json

@@ -434,14 +434,14 @@
     "MCPBinding": {
       "anyOf": [
         {
-          "$ref": "#/definitions/MCPIntegrationIdBinding"
+          "$ref": "#/definitions/MCPConnectionBinding"
         },
         {
-          "$ref": "#/definitions/MCPIntegrationNameBinding"
+          "$ref": "#/definitions/MCPAppBinding"
         }
       ]
     },
-    "MCPIntegrationIdBinding": {
+    "MCPConnectionBinding": {
       "type": "object",
       "properties": {
         "name": {
@@ -451,19 +451,19 @@
           "type": "string",
           "const": "mcp"
         },
-        "integration_id": {
+        "connection_id": {
           "type": "string",
           "description": "If not provided, will return a function that takes the integration id and return the binding implementation.."
         }
       },
       "required": [
-        "integration_id",
+        "connection_id",
         "name",
         "type"
       ],
       "additionalProperties": false
     },
-    "MCPIntegrationNameBinding": {
+    "MCPAppBinding": {
       "type": "object",
       "properties": {
         "name": {
@@ -473,13 +473,13 @@
           "type": "string",
           "const": "mcp"
         },
-        "integration_name": {
+        "app_name": {
           "type": "string",
           "description": "The name of the integration to bind."
         }
       },
       "required": [
-        "integration_name",
+        "app_name",
         "name",
         "type"
       ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decocms/runtime",
-  "version": "1.0.0-alpha.10",
+  "version": "1.0.0-alpha.11",
   "type": "module",
   "dependencies": {
     "@cloudflare/workers-types": "^4.20250617.0",
@@ -21,16 +21,11 @@
   "exports": {
     ".": "./src/index.ts",
     "./proxy": "./src/proxy.ts",
-    "./admin": "./src/admin.ts",
     "./client": "./src/client.ts",
-    "./mastra": "./src/mastra.ts",
-    "./drizzle": "./src/drizzle.ts",
-    "./resources": "./src/resources.ts",
-    "./views": "./src/views.ts",
     "./mcp-client": "./src/mcp-client.ts",
     "./bindings": "./src/bindings/index.ts",
-    "./deconfig": "./src/bindings/deconfig/index.ts",
-    "./asset-server": "./src/asset-server/index.ts"
+    "./asset-server": "./src/asset-server/index.ts",
+    "./tools": "./src/tools.ts"
   },
   "devDependencies": {
     "@types/mime-db": "^1.43.6",

package/src/bindings/binder.ts

@@ -1,14 +1,13 @@
 /* oxlint-disable no-explicit-any */
 import { z } from "zod";
 import type { MCPConnection } from "../connection.ts";
-import { createPrivateTool, createStreamableTool } from "../mastra.ts";
 import {
   createMCPFetchStub,
   type MCPClientFetchStub,
   type ToolBinder,
 } from "../mcp.ts";
+import { createPrivateTool, createStreamableTool } from "../tools.ts";
 import { CHANNEL_BINDING } from "./channels.ts";
-import { VIEW_BINDING } from "./views.ts";
 
 // ToolLike is a simplified version of the Tool interface that matches what we need for bindings
 export interface ToolLike<
@@ -93,8 +92,6 @@ export type MCPBindingClient<T extends ReturnType<typeof bindingClient>> =
   ReturnType<T["forConnection"]>;
 
 export const ChannelBinding = bindingClient(CHANNEL_BINDING);
-export const ViewBinding = bindingClient(VIEW_BINDING);
-
 export type { Callbacks } from "./channels.ts";
 
 export const impl = <TBinder extends Binder>(

package/src/bindings/index.ts

@@ -1,16 +1,13 @@
 import { CHANNEL_BINDING } from "./channels.ts";
-import { VIEW_BINDING as VIEWS_BINDING } from "./views.ts";
 
 // Import new Resources 2.0 bindings function
 import { LANGUAGE_MODEL_BINDING } from "@decocms/bindings/llm";
-import { createResourceBindings } from "./resources/bindings.ts";
 
 // Export types and utilities from binder
 export {
   bindingClient,
   ChannelBinding,
   impl,
-  ViewBinding,
   type Binder,
   type BinderImplementation,
   type MCPBindingClient,
@@ -23,40 +20,10 @@ export * from "./channels.ts";
 // Export binding utilities
 export * from "./utils.ts";
 
-// Export views schemas
-export * from "./views.ts";
-
-// Re-export Resources bindings function for convenience
-export { createResourceBindings };
-
-// Export resources types and schemas
-export * from "./resources/bindings.ts";
-export * from "./resources/helpers.ts";
-export * from "./resources/schemas.ts";
-
-// Export deconfig helpers and types
-export {
-  getMetadataString as deconfigGetMetadataString,
-  getMetadataValue as deconfigGetMetadataValue,
-  normalizeDirectory as deconfigNormalizeDirectory,
-  ResourcePath,
-  ResourceUri,
-} from "./deconfig/helpers.ts";
-export { createDeconfigResource } from "./deconfig/index.ts";
-export type {
-  DeconfigClient,
-  DeconfigResourceOptions,
-  EnhancedResourcesTools,
-  ResourcesBinding,
-  ResourcesTools,
-} from "./deconfig/index.ts";
-export { deconfigTools } from "./deconfig/types.ts";
-
 export { streamToResponse } from "./language-model/utils.ts";
 
 export const WellKnownBindings = {
   Channel: CHANNEL_BINDING,
-  View: VIEWS_BINDING,
   LanguageModel: LANGUAGE_MODEL_BINDING,
   // Note: Resources is not included here since it's a generic function
   // Use createResourceBindings(dataSchema) directly for Resources 2.0

package/src/bindings.ts

@@ -4,89 +4,22 @@ import { MCPClient } from "./mcp.ts";
 import type {
   BindingBase,
   ContractBinding,
+  MCPAppBinding,
   MCPBinding,
-  MCPIntegrationNameBinding,
 } from "./wrangler.ts";
 
-interface IntegrationContext {
-  integrationId: string;
-  workspace: string;
-  branch?: string;
-  decoCmsApiUrl?: string;
-}
-
-const normalizeWorkspace = (workspace: string) => {
-  if (workspace.startsWith("/users")) {
-    return workspace;
-  }
-  if (workspace.startsWith("/shared")) {
-    return workspace;
-  }
-  if (workspace.includes("/")) {
-    return workspace;
-  }
-  return `/shared/${workspace}`;
-};
-
-/**
- * Url: /apps/mcp?appName=$appName
- */
-const createAppsUrl = ({
-  appName,
-  decoChatApiUrl,
-}: {
-  appName: string;
-  decoChatApiUrl?: string;
-}) =>
-  new URL(
-    `/apps/mcp?appName=${appName}`,
-    decoChatApiUrl ?? "https://api.decocms.com",
-  ).href;
-/**
- * Url: /:workspace.root/:workspace.slug/:integrationId/mcp
- */
-const createIntegrationsUrl = ({
-  integrationId,
-  workspace,
-  decoCmsApiUrl,
-  branch,
-}: IntegrationContext) => {
-  const base = `${normalizeWorkspace(workspace)}/${integrationId}/mcp`;
-  const url = new URL(base, decoCmsApiUrl ?? "https://api.decocms.com");
-  branch && url.searchParams.set("branch", branch);
-  return url.href;
-};
-
-type WorkspaceClientContext = Omit<
+type ClientContext = Omit<
   RequestContext,
   "ensureAuthenticated" | "state" | "fetchIntegrationMetadata"
 >;
-export const workspaceClient = (
-  ctx: WorkspaceClientContext,
-  decocmsApiUrl?: string,
-): ReturnType<(typeof MCPClient)["forWorkspace"]> => {
-  return MCPClient.forWorkspace(ctx.workspace, ctx.token, decocmsApiUrl);
-};
-
-const mcpClientForAppName = (appName: string, decoChatApiUrl?: string) => {
-  const mcpConnection: MCPConnection = {
-    type: "HTTP",
-    url: createAppsUrl({
-      appName,
-      decoChatApiUrl,
-    }),
-  };
-
-  return MCPClient.forConnection(mcpConnection, decoChatApiUrl);
-};
 
 export const proxyConnectionForId = (
-  integrationId: string,
-  ctx: Omit<WorkspaceClientContext, "token"> & {
+  connectionId: string,
+  ctx: Omit<ClientContext, "token"> & {
     token?: string;
     cookie?: string;
+    meshUrl: string;
   },
-  decocmsApiUrl?: string,
   appName?: string,
 ): MCPConnection => {
   let headers: Record<string, string> | undefined = appName
@@ -98,55 +31,39 @@ export const proxyConnectionForId = (
   }
   return {
     type: "HTTP",
-    url: createIntegrationsUrl({
-      integrationId,
-      workspace: ctx.workspace,
-      decoCmsApiUrl: decocmsApiUrl,
-      branch: ctx.branch,
-    }),
+    url: new URL(`/mcp/${connectionId}`, ctx.meshUrl).href,
     token: ctx.token,
     headers,
   };
 };
-const mcpClientForIntegrationId = (
-  integrationId: string,
-  ctx: WorkspaceClientContext,
-  decocmsApiUrl?: string,
+const mcpClientForConnectionId = (
+  connectionId: string,
+  ctx: ClientContext,
   appName?: string,
 ) => {
-  const mcpConnection = proxyConnectionForId(
-    integrationId,
-    ctx,
-    decocmsApiUrl,
-    appName,
-  );
+  const mcpConnection = proxyConnectionForId(connectionId, ctx, appName);
 
   // TODO(@igorbrasileiro): Switch this proxy to be a proxy that call MCP Client.toolCall from @modelcontextprotocol
-  return MCPClient.forConnection(mcpConnection, decocmsApiUrl);
+  return MCPClient.forConnection(mcpConnection);
 };
 
 function mcpClientFromState(
-  binding: BindingBase | MCPIntegrationNameBinding,
+  binding: BindingBase | MCPAppBinding,
   env: DefaultEnv,
 ) {
-  const ctx = env.DECO_REQUEST_CONTEXT;
+  const ctx = env.MESH_REQUEST_CONTEXT;
   const bindingFromState = ctx?.state?.[binding.name];
-  const integrationId =
+  const connectionId =
     bindingFromState &&
     typeof bindingFromState === "object" &&
     "value" in bindingFromState
       ? bindingFromState.value
       : undefined;
-  if (typeof integrationId !== "string" && "integration_name" in binding) {
+  if (typeof connectionId !== "string" && "app_name" in binding) {
     // in case of a binding to an app name, we need to use the new apps/mcp endpoint which will proxy the request to the app but without any token
-    return mcpClientForAppName(binding.integration_name, env.DECO_API_URL);
+    throw new Error("Binding to an app name is not supported");
   }
-  return mcpClientForIntegrationId(
-    integrationId,
-    ctx,
-    env.DECO_API_URL,
-    env.DECO_APP_NAME,
-  );
+  return mcpClientForConnectionId(connectionId, ctx);
 }
 
 export const createContractBinding = (
@@ -160,20 +77,24 @@ export const createIntegrationBinding = (
   binding: MCPBinding,
   env: DefaultEnv,
 ) => {
-  const integrationId =
-    "integration_id" in binding ? binding.integration_id : undefined;
-  if (!integrationId) {
+  const connectionId =
+    "connection_id" in binding ? binding.connection_id : undefined;
+  if (!connectionId) {
     return mcpClientFromState(binding, env);
   }
+  if (!env.MESH_RUNTIME_TOKEN) {
+    throw new Error("MESH_RUNTIME_TOKEN is required");
+  }
+  if (!env.MESH_URL) {
+    throw new Error("MESH_URL is required");
+  }
   // bindings pointed to an specific integration id are binded using the app deployment workspace
-  return mcpClientForIntegrationId(
-    integrationId,
+  return mcpClientForConnectionId(
+    connectionId,
     {
-      workspace: env.DECO_WORKSPACE,
-      token: env.DECO_API_TOKEN,
-      branch: env.DECO_REQUEST_CONTEXT?.branch,
+      token: env.MESH_RUNTIME_TOKEN,
+      meshUrl: env.MESH_URL,
     },
-    env.DECO_API_URL,
-    env.DECO_APP_NAME,
+    env.MESH_APP_NAME,
   );
 };

package/src/client.ts

@@ -1,35 +1,3 @@
-import { toAsyncIterator } from "./bindings/deconfig/helpers.ts";
-// Extract resource name from DECO_RESOURCE_${NAME}_READ pattern
-type ExtractResourceName<K> = K extends `DECO_RESOURCE_${infer Name}_READ`
-  ? Name
-  : never;
-
-// Generate SUBSCRIBE method name from resource name
-type SubscribeMethodName<Name extends string> =
-  `DECO_RESOURCE_${Name}_SUBSCRIBE`;
-
-// Extract data type from READ method return type
-type ExtractReadData<T> = T extends Promise<{ data: infer D }>
-  ? D
-  : T extends { data: infer D }
-    ? D
-    : never;
-
-// Generate all SUBSCRIBE method names for a given type
-type SubscribeMethods<T> = {
-  [K in keyof T as K extends `DECO_RESOURCE_${string}_READ`
-    ? SubscribeMethodName<ExtractResourceName<K>>
-    : never]: K extends `DECO_RESOURCE_${string}_READ`
-    ? // oxlint-disable-next-line no-explicit-any
-      T[K] extends (...args: any) => any
-      ? (args: { id: string } | { uri: string }) => AsyncIterableIterator<{
-          uri: string;
-          data: ExtractReadData<Awaited<ReturnType<T[K]>>>;
-        }>
-      : never
-    : never;
-};
-
 export type MCPClient<T> = {
   // oxlint-disable-next-line no-explicit-any
   [K in keyof T]: T[K] extends (...args: any) => any
@@ -38,7 +6,7 @@ export type MCPClient<T> = {
         init?: CustomInit,
       ) => Promise<Awaited<ReturnType<T[K]>>>
     : never;
-} & SubscribeMethods<T>;
+};
 
 export type CustomInit = RequestInit & {
   handleResponse?: (response: Response) => Promise<unknown>;
@@ -53,123 +21,11 @@ export const DEFAULT_INIT: CustomInit = {
   },
 };
 
-/**
- * Helper function to call an MCP tool via fetch
- */
-async function callMCPTool<T = unknown>(
-  methodName: string,
-  args: unknown,
-  init?: CustomInit,
-): Promise<T> {
-  const mergedInit: CustomInit = {
-    ...init,
-    headers: {
-      ...DEFAULT_INIT.headers,
-      ...init?.headers,
-    },
-  };
-
-  const response = await fetch(`/mcp/call-tool/${methodName}`, {
-    method: "POST",
-    body: JSON.stringify(args),
-    credentials: "include",
-    ...mergedInit,
-  });
-
-  if (!response.ok) {
-    throw new Error(`Failed to call ${methodName}: ${response.statusText}`);
-  }
-
-  return response.json() as Promise<T>;
-}
-
-/**
- * Creates a subscribe method for a resource that returns an async iterator
- * yielding {uri, data} objects as resources are updated.
- */
-function createSubscribeMethod(
-  resourceName: string,
-  init?: CustomInit,
-): (args: { id: string }) => AsyncIterableIterator<{
-  uri: string;
-  data: unknown;
-}> {
-  return async function* (args: { id: string } | { uri: string }) {
-    // Step 1: Call DESCRIBE to get watch endpoint configuration and URI template
-    const describeMethodName = `DECO_RESOURCE_${resourceName}_DESCRIBE`;
-    const readMethodName = `DECO_RESOURCE_${resourceName}_READ`;
-
-    // Get describe information
-    const describeData = await callMCPTool<{
-      uriTemplate?: string;
-      features?: {
-        watch?: {
-          pathname?: string;
-        };
-      };
-    }>(describeMethodName, {}, init);
-
-    const watchPathname = describeData?.features?.watch?.pathname;
-    const uriTemplate = describeData?.uriTemplate;
-
-    if (!watchPathname) {
-      throw new Error(
-        `Resource ${resourceName} does not support watch functionality`,
-      );
-    }
-
-    if (!uriTemplate) {
-      throw new Error(`Resource ${resourceName} does not provide uriTemplate`);
-    }
-
-    // Step 2: Construct URI from template by replacing * with id
-    const resourceUri =
-      "uri" in args ? args.uri : uriTemplate.replace("*", args.id);
-
-    // Step 3: Construct watch URL and create EventSource
-    const watchUrl = new URL(watchPathname, globalThis.location.origin);
-    watchUrl.searchParams.set("uri", resourceUri);
-
-    const eventSource = new EventSource(watchUrl.href);
-
-    // Step 4: Use toAsyncIterator to consume SSE events and enrich with READ data
-    const eventStream = toAsyncIterator<{ uri: string }>(
-      eventSource,
-      "message",
-    );
-
-    // Iterate over SSE events and enrich with full data
-    for await (const event of eventStream) {
-      const uri = event.uri;
-
-      if (uri) {
-        // Call READ to get full resource data
-        const readData = await callMCPTool<{ data: unknown }>(
-          readMethodName,
-          { uri },
-          init,
-        );
-
-        yield { uri, data: readData.data };
-      }
-    }
-  };
-}
-
 export const createClient = <T>(init?: CustomInit): MCPClient<T> => {
   return new Proxy(
     {},
     {
       get: (_, prop) => {
-        const propStr = String(prop);
-
-        // Check if this is a SUBSCRIBE method call
-        const subscribeMatch = propStr.match(/^DECO_RESOURCE_(.+)_SUBSCRIBE$/);
-        if (subscribeMatch) {
-          const resourceName = subscribeMatch[1];
-          return createSubscribeMethod(resourceName, init);
-        }
-
         // Regular method call
         return async (args: unknown, innerInit?: CustomInit) => {
           const mergedInit: CustomInit = {