@decocms/runtime 0.0.1-testing-beta.1

package/src/mcp-client.ts

@@ -0,0 +1,119 @@
+import {
+  Client as BaseClient,
+  ClientOptions,
+} from "@modelcontextprotocol/sdk/client/index.js";
+import {
+  SSEClientTransport,
+  SSEClientTransportOptions,
+} from "@modelcontextprotocol/sdk/client/sse.js";
+import { WebSocketClientTransport } from "@modelcontextprotocol/sdk/client/websocket.js";
+import { RequestOptions } from "@modelcontextprotocol/sdk/shared/protocol.js";
+import {
+  Implementation,
+  ListToolsRequest,
+  ListToolsResultSchema,
+} from "@modelcontextprotocol/sdk/types.js";
+import { MCPConnection } from "./connection.ts";
+import { HTTPClientTransport } from "./http-client-transport.ts";
+
+/**
+ * WARNNING: This is a hack to prevent schema compilation errors.
+ * More info at: https://github.com/modelcontextprotocol/typescript-sdk/issues/923
+ *
+ * Make sure to keep this updated with the right version of the SDK.
+ * https://github.com/modelcontextprotocol/typescript-sdk/blob/bf817939917277a4c59f2e19e7b44b8dd7ff140c/src/client/index.ts#L480
+ */
+class Client extends BaseClient {
+  constructor(_clientInfo: Implementation, options?: ClientOptions) {
+    super(_clientInfo, options);
+  }
+
+  override async listTools(
+    params?: ListToolsRequest["params"],
+    options?: RequestOptions,
+  ) {
+    const result = await this.request(
+      { method: "tools/list", params },
+      ListToolsResultSchema,
+      options,
+    );
+
+    return result;
+  }
+}
+
+export const createServerClient = async (
+  mcpServer: { connection: MCPConnection; name?: string },
+  signal?: AbortSignal,
+  extraHeaders?: Record<string, string>,
+): Promise<Client> => {
+  const transport = createTransport(mcpServer.connection, signal, extraHeaders);
+
+  if (!transport) {
+    throw new Error("Unknown MCP connection type");
+  }
+
+  const client = new Client({
+    name: mcpServer?.name ?? "MCP Client",
+    version: "1.0.0",
+  });
+
+  await client.connect(transport);
+
+  return client;
+};
+
+export const createTransport = (
+  connection: MCPConnection,
+  signal?: AbortSignal,
+  extraHeaders?: Record<string, string>,
+) => {
+  if (connection.type === "Websocket") {
+    return new WebSocketClientTransport(new URL(connection.url));
+  }
+
+  if (connection.type !== "SSE" && connection.type !== "HTTP") {
+    return null;
+  }
+
+  const authHeaders: Record<string, string> = connection.token
+    ? { authorization: `Bearer ${connection.token}` }
+    : {};
+
+  const headers: Record<string, string> = {
+    ...authHeaders,
+    ...(extraHeaders ?? {}),
+    ...("headers" in connection ? connection.headers || {} : {}),
+  };
+
+  if (connection.type === "SSE") {
+    const config: SSEClientTransportOptions = {
+      requestInit: { headers, signal },
+    };
+
+    if (connection.token) {
+      config.eventSourceInit = {
+        fetch: (req, init) => {
+          return fetch(req, {
+            ...init,
+            headers: {
+              ...headers,
+              Accept: "text/event-stream",
+            },
+            signal,
+          });
+        },
+      };
+    }
+
+    return new SSEClientTransport(new URL(connection.url), config);
+  }
+  return new HTTPClientTransport(new URL(connection.url), {
+    requestInit: {
+      headers,
+      signal,
+      // @ts-ignore - this is a valid option for fetch
+      credentials: "include",
+    },
+  });
+};

package/src/mcp.ts

@@ -0,0 +1,171 @@
+/* oxlint-disable no-explicit-any */
+import { z } from "zod";
+import type { MCPConnection } from "./connection.ts";
+import { createMCPClientProxy } from "./proxy.ts";
+
+export interface FetchOptions extends RequestInit {
+  path?: string;
+  segments?: string[];
+}
+
+const Timings = z.object({
+  sql_duration_ms: z.number().optional(),
+});
+
+const Meta = z.object({
+  changed_db: z.boolean().optional(),
+  changes: z.number().optional(),
+  duration: z.number().optional(),
+  last_row_id: z.number().optional(),
+  rows_read: z.number().optional(),
+  rows_written: z.number().optional(),
+  served_by_primary: z.boolean().optional(),
+  served_by_region: z
+    .enum(["WNAM", "ENAM", "WEUR", "EEUR", "APAC", "OC"])
+    .optional(),
+  size_after: z.number().optional(),
+  timings: Timings.optional(),
+});
+
+const QueryResult = z.object({
+  meta: Meta.optional(),
+  results: z.array(z.unknown()).optional(),
+  success: z.boolean().optional(),
+});
+
+export type QueryResult = z.infer<typeof QueryResult>;
+
+const workspaceTools = [
+  {
+    name: "INTEGRATIONS_GET" as const,
+    inputSchema: z.object({
+      id: z.string(),
+    }),
+    outputSchema: z.object({
+      connection: z.object({}),
+    }),
+  },
+  {
+    name: "DATABASES_RUN_SQL" as const,
+    inputSchema: z.object({
+      sql: z.string().describe("The SQL query to run"),
+      params: z
+        .array(z.string())
+        .describe("The parameters to pass to the SQL query"),
+    }),
+    outputSchema: z.object({
+      result: z.array(QueryResult),
+    }),
+  },
+] satisfies ToolBinder<string, unknown, object>[];
+
+// Default fetcher instance with API_SERVER_URL and API_HEADERS
+const global = createMCPFetchStub<[]>({});
+export const MCPClient = new Proxy(
+  {} as typeof global & {
+    forWorkspace: (
+      workspace: string,
+      token?: string,
+      decoCmsApiUrl?: string,
+    ) => MCPClientFetchStub<typeof workspaceTools>;
+    forConnection: <TDefinition extends readonly ToolBinder[]>(
+      connection: MCPConnectionProvider,
+      decoCmsApiUrl?: string,
+    ) => MCPClientFetchStub<TDefinition>;
+  },
+  {
+    get(_, name) {
+      if (name === "toJSON") {
+        return null;
+      }
+
+      if (name === "forWorkspace") {
+        return (workspace: string, token?: string, decoCmsApiUrl?: string) =>
+          createMCPFetchStub<[]>({
+            workspace,
+            token,
+            decoCmsApiUrl,
+          });
+      }
+      if (name === "forConnection") {
+        return <TDefinition extends readonly ToolBinder[]>(
+          connection: MCPConnectionProvider,
+          decoCmsApiUrl?: string,
+        ) =>
+          createMCPFetchStub<TDefinition>({
+            connection,
+            decoCmsApiUrl,
+          });
+      }
+      return global[name as keyof typeof global];
+    },
+  },
+);
+
+export interface ToolBinder<
+  TName extends string = string,
+  TInput = any,
+  TReturn extends object | null | boolean = object,
+> {
+  name: TName;
+  inputSchema: z.ZodType<TInput>;
+  outputSchema?: z.ZodType<TReturn>;
+  opt?: true;
+}
+export type MCPClientStub<TDefinition extends readonly ToolBinder[]> = {
+  [K in TDefinition[number] as K["name"]]: K extends ToolBinder<
+    string,
+    infer TInput,
+    infer TReturn
+  >
+    ? (params: TInput, init?: RequestInit) => Promise<TReturn>
+    : never;
+};
+
+export type MCPClientFetchStub<TDefinition extends readonly ToolBinder[]> = {
+  [K in TDefinition[number] as K["name"]]: K extends ToolBinder<
+    string,
+    infer TInput,
+    infer TReturn
+  >
+    ? (params: TInput, init?: RequestInit) => Promise<Awaited<TReturn>>
+    : never;
+};
+
+export type MCPConnectionProvider = MCPConnection;
+
+export interface MCPClientRaw {
+  callTool: (tool: string, args: unknown) => Promise<unknown>;
+  listTools: () => Promise<
+    {
+      name: string;
+      inputSchema: any;
+      outputSchema?: any;
+      description: string;
+    }[]
+  >;
+}
+export type JSONSchemaToZodConverter = (jsonSchema: any) => z.ZodTypeAny;
+export interface CreateStubAPIOptions {
+  mcpPath?: string;
+  decoCmsApiUrl?: string;
+  workspace?: string;
+  token?: string;
+  connection?: MCPConnectionProvider;
+  debugId?: () => string;
+  getErrorByStatusCode?: (
+    statusCode: number,
+    message?: string,
+    traceId?: string,
+    errorObject?: unknown,
+  ) => Error;
+  supportsToolName?: boolean;
+}
+
+export function createMCPFetchStub<TDefinition extends readonly ToolBinder[]>(
+  options?: CreateStubAPIOptions,
+): MCPClientFetchStub<TDefinition> {
+  return createMCPClientProxy<MCPClientFetchStub<TDefinition>>({
+    ...(options ?? {}),
+  });
+}

package/src/proxy.ts

@@ -0,0 +1,204 @@
+/* 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 {
+    return JSON.parse(content as string);
+  } catch {
+    return content;
+  }
+};
+
+const toolsMap = new Map<
+  string,
+  Promise<
+    Array<{
+      name: string;
+      inputSchema: any;
+      outputSchema?: any;
+      description: string;
+    }>
+  >
+>();
+
+/**
+ * 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,
+): T {
+  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,
+  };
+
+  return new Proxy<T>({} as T, {
+    get(_, name) {
+      if (name === "toJSON") {
+        return null;
+      }
+      if (typeof name !== "string") {
+        throw new Error("Name must be a string");
+      }
+      async function callToolFn(args: unknown) {
+        const debugId = options?.debugId?.();
+        const extraHeaders = debugId
+          ? { "x-trace-debug-id": debugId }
+          : undefined;
+
+        // 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 = await createServerClient(
+          { connection: toolConnection },
+          undefined,
+          extraHeaders,
+        );
+
+        const { structuredContent, isError, content } = await client.callTool(
+          {
+            name: String(name),
+            arguments: args as Record<string, unknown>,
+          },
+          undefined,
+          {
+            timeout: 3000000,
+          },
+        );
+
+        if (isError) {
+          // @ts-expect-error - content is not typed
+          const maybeErrorMessage = content?.[0]?.text;
+          const error =
+            typeof maybeErrorMessage === "string"
+              ? safeParse(maybeErrorMessage)
+              : null;
+
+          const throwableError =
+            error?.code && typeof options?.getErrorByStatusCode === "function"
+              ? options.getErrorByStatusCode(
+                  error.code,
+                  error.message,
+                  error.traceId,
+                )
+              : null;
+
+          if (throwableError) {
+            throw throwableError;
+          }
+
+          throw new Error(
+            `Tool ${String(name)} returned an error: ${JSON.stringify(
+              structuredContent ?? content,
+            )}`,
+          );
+        }
+        return structuredContent;
+      }
+
+      const listToolsFn = async () => {
+        const client = await createServerClient({ connection });
+        const { tools } = await client.listTools();
+
+        return tools as {
+          name: string;
+          inputSchema: any;
+          outputSchema?: any;
+          description: string;
+        }[];
+      };
+
+      async function listToolsOnce() {
+        const conn = connection;
+        const key = JSON.stringify(conn);
+
+        try {
+          if (!toolsMap.has(key)) {
+            toolsMap.set(key, listToolsFn());
+          }
+
+          return await toolsMap.get(key)!;
+        } catch (error) {
+          console.error("Failed to list tools", error);
+
+          toolsMap.delete(key);
+          return;
+        }
+      }
+      callToolFn.asTool = async () => {
+        const tools = (await listToolsOnce()) ?? [];
+        const tool = tools.find((t) => t.name === name);
+        if (!tool) {
+          throw new Error(`Tool ${name} not found`);
+        }
+
+        return {
+          ...tool,
+          id: tool.name,
+          inputSchema: tool.inputSchema
+            ? convertJsonSchemaToZod(tool.inputSchema)
+            : undefined,
+          outputSchema: tool.outputSchema
+            ? convertJsonSchemaToZod(tool.outputSchema)
+            : undefined,
+          execute: (input: any) => {
+            return callToolFn(input.context);
+          },
+        };
+      };
+      return callToolFn;
+    },
+  });
+}

package/src/resources.ts

@@ -0,0 +1,168 @@
+import { z } from "zod";
+import mimeDb from "mime-db";
+
+type MimeDb = Record<string, { extensions?: string[] }>;
+
+const EXTENSION_TO_MIME = (() => {
+  const map = new Map<string, string>();
+  Object.entries(mimeDb as MimeDb).forEach(([type, meta]) => {
+    meta.extensions?.forEach((ext) => {
+      if (!map.has(ext)) {
+        map.set(ext, type);
+      }
+    });
+  });
+  return map;
+})();
+
+function extractExtension(value: string): string | undefined {
+  if (!value) return undefined;
+  const trimmed = value.trim();
+  if (!trimmed) return undefined;
+
+  const sanitized = trimmed.replace(/^[^?#]*/g, (match) => match);
+  const withoutQuery = sanitized.split(/[?#]/)[0];
+
+  if (withoutQuery.startsWith(".")) {
+    return withoutQuery.slice(1).toLowerCase();
+  }
+
+  if (!withoutQuery.includes(".")) {
+    if (!withoutQuery.includes("/") && !withoutQuery.includes("\\")) {
+      return withoutQuery.toLowerCase();
+    }
+    return undefined;
+  }
+
+  const lastDot = withoutQuery.lastIndexOf(".");
+  if (lastDot === -1 || lastDot === withoutQuery.length - 1) return undefined;
+  return withoutQuery.slice(lastDot + 1).toLowerCase();
+}
+
+// Base Resource Schema (enhanced)
+const ResourceSchema = z.object({
+  name: z.string(),
+  title: z.string().optional(),
+  description: z.string().optional(),
+  uri: z.string().url(),
+  mimeType: z.string().optional(),
+  thumbnail: z.string().url().optional(),
+  timestamp: z.string().datetime().optional(),
+  size: z.number().positive().optional(),
+  annotations: z.record(z.string(), z.string()).optional(),
+});
+
+// Tool Input/Output Schemas (unified)
+export const ResourcesReadInputSchema = z.object({
+  name: z.string().describe("Resource type name (e.g., 'Page', 'GoogleDrive')"),
+  uri: z
+    .string()
+    .url()
+    .describe(
+      "The URI of the resource to read. It's important to add the url scheme. Use file:// for files. Use https:// or http:// for remote files",
+    ),
+});
+
+export const ResourcesReadOutputSchema = ResourceSchema.extend({
+  data: z.string().describe("The resource content as a string"),
+  type: z
+    .enum(["text", "blob"])
+    .describe(
+      "Type of data: 'text' for plain text, 'blob' for base64-encoded binary",
+    ),
+});
+
+export const ResourceSearchInputSchema = z.object({
+  name: z.string().describe("Resource type name (e.g., 'Page', 'GoogleDrive')"),
+  term: z.string().describe("The term to search for"),
+  cursor: z.string().optional(),
+  limit: z.number().positive().optional(),
+});
+
+export const ResourceSearchOutputSchema = z.object({
+  items: z.array(ResourceSchema),
+  hasMore: z.boolean(),
+  nextCursor: z.string().optional(),
+});
+
+export const ResourceCreateInputSchema = z.object({
+  name: z.string().describe("Resource type name (e.g., 'Page', 'GoogleDrive')"),
+  resourceName: z
+    .string()
+    .describe(
+      "Name of the specific resource instance. DO NOT ADD EXTENSIONS TO THE NAME",
+    ),
+  title: z.string().optional(),
+  description: z.string().optional(),
+  content: z
+    .object({
+      data: z.string(),
+      type: z.enum(["text", "blob"]),
+      mimeType: z.string().optional(),
+    })
+    .describe("Content to create the resource with"),
+  metadata: z.record(z.string(), z.any()).optional(),
+});
+export const ResourceCreateOutputSchema = ResourceSchema;
+
+export const ResourceUpdateInputSchema = z.object({
+  name: z.string().describe("Resource type name (e.g., 'Page', 'GoogleDrive')"),
+  uri: z.string().url().describe("URI of the resource to update"),
+  resourceName: z.string().optional(),
+  title: z.string().optional(),
+  description: z.string().optional(),
+  content: z
+    .object({
+      data: z.string(),
+      type: z.enum(["text", "blob"]),
+      mimeType: z.string().optional(),
+    })
+    .optional(),
+  metadata: z.record(z.string(), z.any()).optional(),
+});
+export const ResourceUpdateOutputSchema = ResourceSchema;
+
+export const ResourceDeleteInputSchema = z.object({
+  name: z.string().describe("Resource type name (e.g., 'Page', 'GoogleDrive')"),
+  uri: z.string().url().describe("URI of the resource to delete"),
+  force: z.boolean().optional(),
+});
+export const ResourceDeleteOutputSchema = z.object({
+  deletedUri: z.string().url(),
+});
+
+export const ResourcesListInputSchema = z.object({});
+export const ResourcesListOutputSchema = z.object({
+  resources: z.array(
+    z.object({
+      name: z.string(),
+      icon: z.string(),
+      title: z.string(),
+      description: z.string(),
+      hasCreate: z.boolean().optional(),
+      hasUpdate: z.boolean().optional(),
+      hasDelete: z.boolean().optional(),
+    }),
+  ),
+});
+
+// Export Types
+export type Resource = z.infer<typeof ResourceCreateOutputSchema>;
+export type ResourcesReadInput = z.infer<typeof ResourcesReadInputSchema>;
+export type ResourcesReadOutput = z.infer<typeof ResourcesReadOutputSchema>;
+export type ResourcesSearchInput = z.infer<typeof ResourceSearchInputSchema>;
+export type ResourcesSearchOutput = z.infer<typeof ResourceSearchOutputSchema>;
+export type ResourceCreateInput = z.infer<typeof ResourceCreateInputSchema>;
+export type ResourceCreateOutput = z.infer<typeof ResourceCreateOutputSchema>;
+export type ResourceUpdateInput = z.infer<typeof ResourceUpdateInputSchema>;
+export type ResourceUpdateOutput = z.infer<typeof ResourceUpdateOutputSchema>;
+export type ResourceDeleteInput = z.infer<typeof ResourceDeleteInputSchema>;
+export type ResourceDeleteOutput = z.infer<typeof ResourceDeleteOutputSchema>;
+export type ResourcesListInput = z.infer<typeof ResourcesListInputSchema>;
+export type ResourcesListOutput = z.infer<typeof ResourcesListOutputSchema>;
+
+export const mimeType = (filePathOrExtension: string) => {
+  const ext = extractExtension(filePathOrExtension);
+  if (!ext) return "text/plain";
+  return EXTENSION_TO_MIME.get(ext) ?? "text/plain";
+};

package/src/state.ts

@@ -0,0 +1,44 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { z } from "zod";
+import type { AppContext } from "./mastra.ts";
+import { createTool } from "./mastra.ts";
+
+const asyncLocalStorage = new AsyncLocalStorage<AppContext | undefined>();
+
+export const State = {
+  getStore: () => {
+    return asyncLocalStorage.getStore();
+  },
+  run: <TEnv, R, TArgs extends unknown[]>(
+    ctx: AppContext<TEnv>,
+    f: (...args: TArgs) => R,
+    ...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,
+      });
+    },
+  });
+};