@decocms/runtime 0.25.0 → 0.26.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decocms/runtime",
-  "version": "0.25.0",
+  "version": "0.26.0",
   "type": "module",
   "scripts": {
     "build": "tsup",
@@ -9,9 +9,11 @@
   "dependencies": {
     "@cloudflare/workers-types": "^4.20250617.0",
     "@deco/mcp": "npm:@jsr/deco__mcp@0.5.5",
+    "@decocms/bindings": "workspace:*",
     "@mastra/cloudflare-d1": "^0.13.4",
     "@mastra/core": "^0.20.2",
     "@modelcontextprotocol/sdk": "^1.19.1",
+    "@ai-sdk/provider": "^2.0.0",
     "bidc": "0.0.3",
     "drizzle-orm": "^0.44.5",
     "jose": "^6.0.11",
@@ -101,4 +103,4 @@
   "publishConfig": {
     "access": "public"
   }
-}
+}

package/src/bindings/binder.ts

@@ -1,14 +1,14 @@
 /* oxlint-disable no-explicit-any */
 import { z } from "zod";
 import type { MCPConnection } from "../connection.ts";
-import { createPrivateTool } from "../mastra.ts";
+import { createPrivateTool, createStreamableTool } from "../mastra.ts";
 import {
   createMCPFetchStub,
   type MCPClientFetchStub,
   type ToolBinder,
 } from "../mcp.ts";
-import { CHANNEL_BINDING_SCHEMA } from "./channels.ts";
-import { VIEW_BINDING_SCHEMA } from "./views.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<
@@ -75,27 +75,16 @@ export const bindingClient = <TDefinition extends readonly ToolBinder[]>(
     forConnection: (
       mcpConnection: MCPConnection,
     ): MCPClientFetchStub<TDefinition> => {
-      const stub = createMCPFetchStub<TDefinition>({
+      return createMCPFetchStub<TDefinition>({
         connection: mcpConnection,
-      });
-      return new Proxy<MCPClientFetchStub<TDefinition>>(
-        {} as MCPClientFetchStub<TDefinition>,
-        {
-          get(_, name) {
-            if (typeof name !== "string") {
-              throw new Error("Name must be a string");
-            }
-
-            return (args: Record<string, unknown>) => {
-              return (
-                stub[name as keyof MCPClientFetchStub<TDefinition>] as (
-                  args: Record<string, unknown>,
-                ) => Promise<unknown>
-              )(args);
-            };
+        streamable: binder.reduce(
+          (acc, tool) => {
+            acc[tool.name] = tool.streamable === true;
+            return acc;
           },
-        },
-      );
+          {} as Record<string, boolean>,
+        ),
+      });
     },
   };
 };
@@ -103,9 +92,8 @@ export const bindingClient = <TDefinition extends readonly ToolBinder[]>(
 export type MCPBindingClient<T extends ReturnType<typeof bindingClient>> =
   ReturnType<T["forConnection"]>;
 
-export const ChannelBinding = bindingClient(CHANNEL_BINDING_SCHEMA);
-
-export const ViewBinding = bindingClient(VIEW_BINDING_SCHEMA);
+export const ChannelBinding = bindingClient(CHANNEL_BINDING);
+export const ViewBinding = bindingClient(VIEW_BINDING);
 
 export type { Callbacks } from "./channels.ts";
 
@@ -113,8 +101,12 @@ export const impl = <TBinder extends Binder>(
   schema: TBinder,
   implementation: BinderImplementation<TBinder>,
   createToolFn = createPrivateTool,
+  createStreamableToolFn = createStreamableTool,
 ) => {
-  const impl: ReturnType<typeof createToolFn>[] = [];
+  const impl: (
+    | ReturnType<typeof createToolFn>
+    | ReturnType<typeof createStreamableToolFn>
+  )[] = [];
   for (const key in schema) {
     const toolSchema = schema[key];
     const toolImplementation = implementation[key];
@@ -127,17 +119,28 @@ export const impl = <TBinder extends Binder>(
       throw new Error(`Implementation for ${key} is required`);
     }
 
-    const { name, handler, ...toolLike }: ToolLike = {
+    const { name, handler, streamable, ...toolLike } = {
       ...toolSchema,
       ...toolImplementation,
     };
-    impl.push(
-      createToolFn({
-        ...toolLike,
-        id: name,
-        execute: ({ context }) => Promise.resolve(handler(context)),
-      }),
-    );
+    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)),
+        }),
+      );
+    }
   }
   return impl;
 };

package/src/bindings/channels.ts

@@ -34,7 +34,7 @@ const listChannelsSchema = z.object({
 export type Callbacks = z.infer<typeof callbacksSchema>;
 export type JoinedChannelPayload = z.infer<typeof joinChannelSchema>;
 export type ListChannelsSchema = z.infer<typeof listChannelsSchema>;
-export const CHANNEL_BINDING_SCHEMA = [
+export const CHANNEL_BINDING = [
   {
     name: "DECO_CHAT_CHANNELS_JOIN" as const,
     inputSchema: joinChannelSchema,

package/src/bindings/index.ts

@@ -1,7 +1,8 @@
-import { CHANNEL_BINDING_SCHEMA } from "./channels.ts";
-import { VIEW_BINDING_SCHEMA } from "./views.ts";
+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
@@ -35,11 +36,11 @@ export * from "./resources/schemas.ts";
 
 // Export deconfig helpers and types
 export {
-  ResourcePath,
-  ResourceUri,
   getMetadataString as deconfigGetMetadataString,
   getMetadataValue as deconfigGetMetadataValue,
   normalizeDirectory as deconfigNormalizeDirectory,
+  ResourcePath,
+  ResourceUri,
 } from "./deconfig/helpers.ts";
 export { createDeconfigResource } from "./deconfig/index.ts";
 export type {
@@ -52,8 +53,9 @@ export type {
 export { deconfigTools } from "./deconfig/types.ts";
 
 export const WellKnownBindings = {
-  Channel: CHANNEL_BINDING_SCHEMA,
-  View: VIEW_BINDING_SCHEMA,
+  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
 } as const;

package/src/bindings/language-model/ai-sdk.ts

@@ -0,0 +1,87 @@
+import type {
+  LanguageModelV2,
+  LanguageModelV2CallOptions,
+  ProviderV2,
+} from "@ai-sdk/provider";
+import { LanguageModelBinding } from "@decocms/bindings/llm";
+import { lazy, responseToStream } from "./utils";
+
+const toRegExp = (supportedUrls: Record<string, string[]>) => {
+  return Object.fromEntries(
+    Object.entries(supportedUrls).map(([key, values]) => [
+      key,
+      values.map((v) => new RegExp(v)),
+    ]),
+  );
+};
+
+type LLMBindingClient = ReturnType<
+  (typeof LanguageModelBinding)["forConnection"]
+>;
+
+export interface Provider extends ProviderV2 {
+  listModels: LLMBindingClient["COLLECTION_MODELS_LIST"];
+}
+
+/**
+ * Creates a ai-sdk compatible provider for the given binding
+ * @param binding - The binding to create the provider from
+ * @returns The provider
+ */
+export const createProvider = (binding: LLMBindingClient): Provider => {
+  return {
+    imageModel: () => {
+      throw new Error("Image models are not supported by this provider");
+    },
+    textEmbeddingModel: () => {
+      throw new Error(
+        "Text embedding models are not supported by this provider",
+      );
+    },
+    listModels: async () => {
+      return await binding.COLLECTION_MODELS_LIST({});
+    },
+    languageModel: (modelId: string): LanguageModelV2 => {
+      const supportedUrls = lazy(() =>
+        binding
+          .LLM_METADATA({ modelId })
+          .then((metadata) => toRegExp(metadata.supportedUrls)),
+      );
+
+      return {
+        specificationVersion: "v2" as const,
+        provider: "llm-binding",
+        modelId,
+        supportedUrls,
+        doGenerate: async (options: LanguageModelV2CallOptions) => {
+          const response = await binding.LLM_DO_GENERATE({
+            callOptions: options,
+            modelId,
+          });
+          // Ensure usage fields are always present as required by LanguageModelV2
+          return {
+            ...response,
+            usage: {
+              inputTokens: response.usage.inputTokens ?? undefined,
+              outputTokens: response.usage.outputTokens ?? undefined,
+              totalTokens: response.usage.totalTokens ?? undefined,
+              reasoningTokens: response.usage.reasoningTokens ?? undefined,
+            },
+          };
+        },
+        doStream: async (options: LanguageModelV2CallOptions) => {
+          const response = await binding.LLM_DO_STREAM({
+            callOptions: options,
+            modelId,
+          });
+          return {
+            stream: responseToStream(response),
+            response: {
+              headers: Object.fromEntries(response.headers?.entries() ?? []),
+            },
+          };
+        },
+      };
+    },
+  };
+};

package/src/bindings/language-model/index.ts

@@ -0,0 +1,4 @@
+export * from "@decocms/bindings";
+export { LanguageModelBinding } from "@decocms/bindings/llm";
+export * from "./ai-sdk.ts";
+export * from "./utils.ts";

package/src/bindings/language-model/utils.ts

@@ -0,0 +1,118 @@
+import { LanguageModelV2StreamPart } from "@ai-sdk/provider";
+
+// Helper to convert the AI SDK stream to a Response
+export function streamToResponse(
+  stream: ReadableStream<LanguageModelV2StreamPart>,
+  headers?: Record<string, string>,
+): Response {
+  // Transform LanguageModelV2StreamPart objects to newline-delimited JSON
+  const encodedStream = stream.pipeThrough(
+    new TransformStream<LanguageModelV2StreamPart, Uint8Array>({
+      transform(chunk, controller) {
+        // Serialize each chunk as JSON with newline delimiter
+        const line = JSON.stringify(chunk) + "\n";
+        controller.enqueue(new TextEncoder().encode(line));
+      },
+    }),
+  );
+
+  return new Response(encodedStream, {
+    headers: {
+      "Content-Type": "application/x-ndjson", // newline-delimited JSON
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive",
+      ...headers,
+    },
+  });
+}
+
+export function responseToStream(
+  response: Response,
+): ReadableStream<LanguageModelV2StreamPart> {
+  if (!response.body) {
+    throw new Error("Response body is null");
+  }
+
+  return response.body.pipeThrough(new TextDecoderStream()).pipeThrough(
+    new TransformStream<string, LanguageModelV2StreamPart>({
+      transform(chunk, controller) {
+        // Split by newlines and parse each line
+        const lines = chunk.split("\n");
+
+        for (const line of lines) {
+          if (line.trim()) {
+            try {
+              const parsed = JSON.parse(line) as LanguageModelV2StreamPart;
+              controller.enqueue(parsed);
+            } catch (error) {
+              console.error("Failed to parse stream chunk:", error);
+            }
+          }
+        }
+      },
+    }),
+  );
+}
+
+/**
+ * Lazy promise wrapper that defers execution until the promise is awaited.
+ * The factory function is only called when .then() is invoked for the first time.
+ */
+class Lazy<T> implements PromiseLike<T> {
+  private promise: Promise<T> | null = null;
+
+  constructor(private factory: () => Promise<T>) {}
+
+  private getOrCreatePromise(): Promise<T> {
+    if (!this.promise) {
+      this.promise = this.factory();
+    }
+    return this.promise;
+  }
+
+  // eslint-disable-next-line no-thenable
+  then<TResult1 = T, TResult2 = never>(
+    onfulfilled?:
+      | ((value: T) => TResult1 | PromiseLike<TResult1>)
+      | null
+      | undefined,
+    onrejected?:
+      | ((reason: unknown) => TResult2 | PromiseLike<TResult2>)
+      | null
+      | undefined,
+  ): PromiseLike<TResult1 | TResult2> {
+    return this.getOrCreatePromise().then(onfulfilled, onrejected);
+  }
+
+  catch<TResult = never>(
+    onrejected?:
+      | ((reason: unknown) => TResult | PromiseLike<TResult>)
+      | null
+      | undefined,
+  ): Promise<T | TResult> {
+    return this.getOrCreatePromise().catch(onrejected);
+  }
+
+  finally(onfinally?: (() => void) | null | undefined): Promise<T> {
+    return this.getOrCreatePromise().finally(onfinally);
+  }
+}
+
+/**
+ * Creates a lazy promise that only executes when awaited.
+ *
+ * @param factory - A function that returns a Promise<T>
+ * @returns A Promise-like object that defers execution until .then() is called
+ *
+ * @example
+ * ```ts
+ * const lazyData = lazy(() => fetchExpensiveData());
+ * // fetchExpensiveData() is NOT called yet
+ *
+ * const result = await lazyData;
+ * // fetchExpensiveData() is called NOW
+ * ```
+ */
+export function lazy<T>(factory: () => Promise<T>): Promise<T> {
+  return new Lazy(factory) as unknown as Promise<T>;
+}

package/src/bindings/views.ts

@@ -2,7 +2,7 @@ import { ViewsListOutputSchema } from "../views.ts";
 import { z } from "zod";
 import type { ToolBinder } from "../mcp.ts";
 
-export const VIEW_BINDING_SCHEMA = [
+export const VIEW_BINDING = [
   {
     name: "DECO_CHAT_VIEWS_LIST" as const,
     inputSchema: z.any(),

package/src/connection.ts

@@ -1,53 +1,8 @@
-export type SSEConnection = {
-  type: "SSE";
-  url: string;
-  token?: string;
-  headers?: Record<string, string>;
-};
-
-export type WebsocketConnection = {
-  type: "Websocket";
-  url: string;
-  token?: string;
-};
-
-export type DecoConnection = {
-  type: "Deco";
-  tenant: string;
-  token?: string;
-};
-
-export type InnateConnection = {
-  type: "INNATE";
-  name: string;
-  workspace?: string;
-};
-
-export type HTTPConnection = {
-  type: "HTTP";
-  url: string;
-  headers?: Record<string, string>;
-  token?: string;
-};
-
-export type MCPConnection =
-  | SSEConnection
-  | WebsocketConnection
-  | InnateConnection
-  | DecoConnection
-  | HTTPConnection;
-
-export type Integration = {
-  /** Unique identifier for the MCP */
-  id: string;
-  /** Human-readable name of the integration */
-  name: string;
-  /** Brief description of the integration's functionality */
-  description?: string;
-  /** URL to the integration's icon */
-  icon?: string;
-  /** Access level of the integration */
-  access?: string | null;
-  /** Connection configuration */
-  connection: MCPConnection;
-};
+export type {
+  DecoConnection,
+  HTTPConnection,
+  InnateConnection,
+  MCPConnection,
+  SSEConnection,
+  WebsocketConnection,
+} from "@decocms/bindings/connection";

package/src/http-client-transport.ts

@@ -1,66 +1 @@
-import type { JSONRPCMessage } from "@modelcontextprotocol/sdk/types.js";
-import {
-  StreamableHTTPClientTransport,
-  type StreamableHTTPClientTransportOptions,
-} from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-
-export class HTTPClientTransport extends StreamableHTTPClientTransport {
-  constructor(url: URL, opts?: StreamableHTTPClientTransportOptions) {
-    super(url, opts);
-  }
-
-  override send(
-    message: JSONRPCMessage,
-    options?: {
-      resumptionToken?: string;
-      onresumptiontoken?: (token: string) => void;
-    },
-  ): Promise<void> {
-    const mockAction = getMockActionFor(message);
-    if (mockAction?.type === "emit") {
-      this.onmessage?.(mockAction.message);
-      return Promise.resolve();
-    }
-    if (mockAction?.type === "suppress") {
-      return Promise.resolve();
-    }
-    return super.send(message, options);
-  }
-}
-
-type MockAction =
-  | { type: "emit"; message: JSONRPCMessage }
-  | { type: "suppress" };
-
-function getMockActionFor(message: JSONRPCMessage): MockAction | null {
-  const m = message;
-  if (!m || typeof m !== "object" || !("method" in m)) return null;
-
-  switch (m.method) {
-    case "initialize": {
-      const protocolVersion = m?.params?.protocolVersion;
-      if (!protocolVersion) return null;
-      return {
-        type: "emit",
-        message: {
-          result: {
-            protocolVersion,
-            capabilities: { tools: {} },
-            serverInfo: { name: "deco-chat-server", version: "1.0.0" },
-          },
-          jsonrpc: m.jsonrpc ?? "2.0",
-          // @ts-expect-error - id is not typed
-          id: m.id,
-        } as JSONRPCMessage,
-      };
-    }
-    case "notifications/roots/list_changed":
-    case "notifications/initialized":
-    case "notifications/cancelled":
-    case "notifications/progress": {
-      return { type: "suppress" };
-    }
-    default:
-      return null;
-  }
-}
+export { HTTPClientTransport } from "@decocms/bindings/client";

package/src/index.ts

@@ -337,6 +337,10 @@ export const withRuntime = <TEnv, TSchema extends z.ZodTypeAny = never>(
         toolCallInput,
       });
 
+      if (result instanceof Response) {
+        return result;
+      }
+
       return new Response(JSON.stringify(result), {
         headers: {
           "Content-Type": "application/json",

package/src/mastra.ts

@@ -128,6 +128,10 @@ export function createStreamableTool<
   return {
     ...streamableTool,
     execute: (input: ToolExecutionContext<TSchemaIn>) => {
+      const env = input.runtimeContext.get("env") as DefaultEnv;
+      if (env) {
+        env.DECO_REQUEST_CONTEXT.ensureAuthenticated();
+      }
       return streamableTool.execute({
         ...input,
         runtimeContext: createRuntimeContext(input.runtimeContext),

package/src/mcp-client.ts

@@ -42,11 +42,15 @@ class Client extends BaseClient {
   }
 }
 
+export interface ServerClient {
+  client: Client;
+  callStreamableTool: (tool: string, args: unknown) => Promise<Response>;
+}
 export const createServerClient = async (
   mcpServer: { connection: MCPConnection; name?: string },
   signal?: AbortSignal,
   extraHeaders?: Record<string, string>,
-): Promise<Client> => {
+): Promise<ServerClient> => {
   const transport = createTransport(mcpServer.connection, signal, extraHeaders);
 
   if (!transport) {
@@ -60,7 +64,23 @@ export const createServerClient = async (
 
   await client.connect(transport);
 
-  return client;
+  return {
+    client,
+    callStreamableTool: (tool, args) => {
+      if (mcpServer.connection.type !== "HTTP") {
+        throw new Error("HTTP connection required");
+      }
+      return fetch(mcpServer.connection.url + `/call-tool/${tool}`, {
+        method: "POST",
+        redirect: "manual",
+        body: JSON.stringify(args),
+        headers: {
+          ...extraHeaders,
+          Authorization: `Bearer ${mcpServer.connection.token}`,
+        },
+      });
+    },
+  };
 };
 
 export const createTransport = (

package/src/mcp.ts

@@ -4,6 +4,7 @@ import { z } from "zod";
 import type { MCPConnection } from "./connection.ts";
 import type { DefaultEnv } from "./index.ts";
 import { createMCPClientProxy } from "./proxy.ts";
+import type { ToolBinder } from "@decocms/bindings";
 
 export interface FetchOptions extends RequestInit {
   path?: string;
@@ -101,16 +102,13 @@ export const MCPClient = new Proxy(
   },
 );
 
-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 { ToolBinder };
+
+export const isStreamableToolBinder = (
+  toolBinder: ToolBinder,
+): toolBinder is ToolBinder<string, any, any, true> => {
+  return toolBinder.streamable === true;
+};
 export type MCPClientStub<TDefinition extends readonly ToolBinder[]> = {
   [K in TDefinition[number] as K["name"]]: K extends ToolBinder<
     string,
@@ -122,13 +120,13 @@ export type MCPClientStub<TDefinition extends readonly ToolBinder[]> = {
 };
 
 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;
+  [K in TDefinition[number] as K["name"]]: K["streamable"] extends true
+    ? K extends ToolBinder<string, infer TInput, any, true>
+      ? (params: TInput, init?: RequestInit) => Promise<Response>
+      : never
+    : K extends ToolBinder<string, infer TInput, infer TReturn, any>
+      ? (params: TInput, init?: RequestInit) => Promise<Awaited<TReturn>>
+      : never;
 };
 
 export type MCPConnectionProvider = MCPConnection;
@@ -151,6 +149,7 @@ export interface CreateStubAPIOptions {
   workspace?: string;
   token?: string;
   connection?: MCPConnectionProvider;
+  streamable?: Record<string, boolean>;
   debugId?: () => string;
   getErrorByStatusCode?: (
     statusCode: number,