@decocms/runtime 1.2.12 → 1.2.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decocms/runtime",
-  "version": "1.2.12",
+  "version": "1.2.14",
   "type": "module",
   "scripts": {
     "check": "tsc --noEmit",
@@ -9,7 +9,7 @@
   "dependencies": {
     "@cloudflare/workers-types": "^4.20250617.0",
     "@decocms/bindings": "^1.0.7",
-    "@modelcontextprotocol/sdk": "1.26.0",
+    "@modelcontextprotocol/sdk": "1.27.1",
     "@ai-sdk/provider": "^3.0.0",
     "hono": "^4.10.7",
     "jose": "^6.0.11",
@@ -21,11 +21,16 @@
     "./client": "./src/client.ts",
     "./bindings": "./src/bindings/index.ts",
     "./asset-server": "./src/asset-server/index.ts",
-    "./tools": "./src/tools.ts"
+    "./tools": "./src/tools.ts",
+    "./decopilot": "./src/decopilot.ts"
+  },
+  "peerDependencies": {
+    "ai": ">=6.0.0"
   },
   "devDependencies": {
     "@types/bun": "^1.3.5",
     "@types/mime-db": "^1.43.6",
+    "ai": "^6.0.116",
     "ts-json-schema-generator": "^2.4.0"
   },
   "engines": {
@@ -33,7 +38,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/decocms/mesh.git",
+    "url": "git+https://github.com/decocms/studio.git",
     "directory": "packages/runtime"
   },
   "publishConfig": {

package/src/bindings.ts

@@ -1,5 +1,6 @@
 import type { CollectionBinding } from "@decocms/bindings/collections";
 import type { MCPConnection } from "./connection.ts";
+import type { AgentBindingConfig, ResolvedAgentClient } from "./decopilot.ts";
 import type { RequestContext } from "./index.ts";
 import { type MCPClientFetchStub, MCPClient, type ToolBinder } from "./mcp.ts";
 import { z } from "zod";
@@ -29,18 +30,147 @@ export interface Binding<TType extends string = string> {
 export type BindingRegistry = Record<string, readonly ToolBinder[]>;
 
 /**
- * Function that returns Zod Schema
+ * Maps binding type names (e.g. "@deco/cms-admin") to their ToolBinder definitions.
+ * Populated by BindingOf() when a binding argument is provided.
+ * Consumed by injectBindingSchemas() to embed __binding in the JSON Schema
+ * without polluting the Zod schema (which becomes saved state → JWT).
+ */
+const _bindingMetadata = new Map<string, readonly ToolBinder[]>();
+
+/**
+ * Post-processes a JSON Schema to inject `__binding` metadata for binding fields.
+ * Call this on the output of `z.toJSONSchema(stateSchema)` before returning it
+ * from MCP_CONFIGURATION.
+ */
+export function injectBindingSchemas(
+  jsonSchema: Record<string, unknown>,
+): Record<string, unknown> {
+  const properties = jsonSchema.properties as
+    | Record<string, Record<string, unknown>>
+    | undefined;
+  if (!properties) return jsonSchema;
+
+  for (const prop of Object.values(properties)) {
+    const innerProps = prop.properties as
+      | Record<string, Record<string, unknown>>
+      | undefined;
+    if (!innerProps?.__type?.const) continue;
+
+    const typeName = innerProps.__type.const as string;
+    const binding = _bindingMetadata.get(typeName);
+    if (!binding) continue;
+
+    const jsonBinding = binding.map((t) => ({
+      name: String(t.name),
+      ...(t.inputSchema && { inputSchema: z.toJSONSchema(t.inputSchema) }),
+      ...(t.outputSchema && { outputSchema: z.toJSONSchema(t.outputSchema) }),
+    }));
+
+    innerProps.__binding = { const: jsonBinding };
+  }
+
+  return jsonSchema;
+}
+
+/**
+ * Function that returns Zod Schema for a binding field.
+ *
+ * When `binding` is provided, the tool definitions are embedded as `__binding`
+ * in the JSON Schema so the Mesh UI can filter connections by tool capabilities.
+ *
+ * @example
+ * ```ts
+ * // Without inline binding (UI resolves via registry or builtin mapping)
+ * BindingOf<Bindings, "@deco/llm">("@deco/llm")
+ *
+ * // With inline binding (UI filters connections by tool name match)
+ * BindingOf<Bindings, "@deco/cms-admin">("@deco/cms-admin", DECO_CMS_ADMIN_BINDING)
+ * ```
  */
 export const BindingOf = <
   TRegistry extends BindingRegistry,
   TName extends (keyof TRegistry | "*") & z.util.Literal,
 >(
   name: TName,
+  binding?: TName extends keyof TRegistry
+    ? TRegistry[TName]
+    : readonly ToolBinder[],
 ) => {
-  return z.object({
+  const schema = z.object({
     __type: z.literal(name).default(name as any),
     value: z.string(),
   });
+
+  if (binding) {
+    // Store binding metadata for JSON Schema injection (via injectBindingSchemas).
+    // We don't add __binding to the Zod schema itself because it would leak into
+    // the saved configuration_state → JWT token, causing 431 header-too-large errors.
+    _bindingMetadata.set(name as string, binding as readonly ToolBinder[]);
+  }
+
+  return schema;
+};
+
+// ============================================================================
+// Agent Bindings
+// ============================================================================
+
+const AgentModelInfoSchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  capabilities: z
+    .object({
+      vision: z.boolean().optional(),
+      text: z.boolean().optional(),
+      tools: z.boolean().optional(),
+      reasoning: z.boolean().optional(),
+    })
+    .passthrough()
+    .optional(),
+  provider: z.string().optional().nullable(),
+  limits: z
+    .object({
+      contextWindow: z.number().optional(),
+      maxOutputTokens: z.number().optional(),
+    })
+    .passthrough()
+    .optional(),
+});
+
+/**
+ * Zod schema for agent bindings in the StateSchema.
+ * Defines an AI agent with its model config, approval level, and temperature.
+ *
+ * @example
+ * ```ts
+ * const stateSchema = z.object({
+ *   MY_AGENT: AgentOf(),
+ * });
+ *
+ * // In tools:
+ * const stream = await state.MY_AGENT.STREAM({ messages: [...] });
+ * for await (const message of stream) { ... }
+ * ```
+ */
+export const AgentOf = () =>
+  z.object({
+    __type: z.literal("@deco/agent" as const).default("@deco/agent" as const),
+    value: z.string(),
+    id: z.string().optional(),
+    credentialId: z.string().optional(),
+    thinking: AgentModelInfoSchema.optional(),
+    coding: AgentModelInfoSchema.optional(),
+    fast: AgentModelInfoSchema.optional(),
+    toolApprovalLevel: z.enum(["auto", "readonly", "plan"]).default("readonly"),
+    temperature: z.number().default(0.5),
+  });
+
+const isAgent = (v: unknown): v is AgentBindingConfig => {
+  return (
+    typeof v === "object" &&
+    v !== null &&
+    (v as { __type: string }).__type === "@deco/agent"
+  );
 };
 
 /**
@@ -73,21 +203,24 @@ export const BindingOf = <
 export type ResolvedBindings<
   T,
   TBindings extends BindingRegistry,
-> = T extends Binding<infer TType>
-  ? TType extends keyof TBindings
-    ? MCPClientFetchStub<TBindings[TType]> & { __type: TType; value: string }
-    : MCPClientFetchStub<[]> & { __type: string; value: string }
-  : T extends Array<infer U>
-    ? Array<ResolvedBindings<U, TBindings>>
-    : T extends object
-      ? { [K in keyof T]: ResolvedBindings<T[K], TBindings> }
-      : T;
+> = T extends AgentBindingConfig
+  ? ResolvedAgentClient
+  : T extends Binding<infer TType>
+    ? TType extends keyof TBindings
+      ? MCPClientFetchStub<TBindings[TType]> & { __type: TType; value: string }
+      : MCPClientFetchStub<[]> & { __type: string; value: string }
+    : T extends Array<infer U>
+      ? Array<ResolvedBindings<U, TBindings>>
+      : T extends object
+        ? { [K in keyof T]: ResolvedBindings<T[K], TBindings> }
+        : T;
 
 export const isBinding = (v: unknown): v is Binding => {
   return (
     typeof v === "object" &&
     v !== null &&
     typeof (v as { __type: string }).__type === "string" &&
+    (v as { __type: string }).__type !== "@deco/agent" &&
     typeof (v as { value: string }).value === "string"
   );
 };
@@ -141,6 +274,24 @@ const mcpClientForConnectionId = (
   });
 };
 
+const createAgentProxy = (
+  config: AgentBindingConfig,
+  ctx: ClientContext,
+): ResolvedAgentClient => {
+  const orgSlug = ctx.organizationSlug;
+  if (!orgSlug) {
+    throw new Error("organizationSlug is required for agent bindings");
+  }
+  const streamUrl = `${ctx.meshUrl}/api/${orgSlug}/decopilot/runtime/stream`;
+
+  return {
+    STREAM: async (params, opts) => {
+      const { streamAgent } = await import("./decopilot.ts");
+      return streamAgent(streamUrl, ctx.token, config, params, opts);
+    },
+  };
+};
+
 const traverseAndReplace = (obj: unknown, ctx: ClientContext): unknown => {
   // Handle null/undefined
   if (obj === null || obj === undefined) {
@@ -154,7 +305,12 @@ const traverseAndReplace = (obj: unknown, ctx: ClientContext): unknown => {
 
   // Handle objects
   if (typeof obj === "object") {
-    // Check if this is a binding
+    // Check if this is an agent binding (before connection binding check)
+    if (isAgent(obj)) {
+      return createAgentProxy(obj, ctx);
+    }
+
+    // Check if this is a connection binding
     if (isBinding(obj)) {
       return mcpClientForConnectionId(obj.value, ctx, obj.__type);
     }

package/src/decopilot.ts

@@ -0,0 +1,196 @@
+import type { UIMessage } from "ai";
+
+// ============================================================================
+// Agent Model Types
+// ============================================================================
+
+export interface AgentModelInfo {
+  id: string;
+  title: string;
+  capabilities?: {
+    vision?: boolean;
+    text?: boolean;
+    tools?: boolean;
+    reasoning?: boolean;
+  };
+  provider?: string | null;
+  limits?: { contextWindow?: number; maxOutputTokens?: number };
+}
+
+// ============================================================================
+// Agent Binding Config (lives in StateSchema)
+// ============================================================================
+
+export interface AgentBindingConfig {
+  __type: "@deco/agent";
+  /** Virtual MCP connection ID (binding pointer) */
+  value?: string;
+  /** Agent ID — may be absent when state only stores a binding reference */
+  id?: string;
+  credentialId?: string;
+  thinking?: AgentModelInfo;
+  coding?: AgentModelInfo;
+  fast?: AgentModelInfo;
+  toolApprovalLevel?: "auto" | "readonly" | "plan";
+  temperature?: number;
+}
+
+// ============================================================================
+// STREAM() params — messages + optional overrides
+// ============================================================================
+
+export interface AgentStreamParams {
+  messages: Omit<UIMessage, "id">[];
+  credentialId?: string;
+  thinking?: AgentModelInfo;
+  coding?: AgentModelInfo;
+  fast?: AgentModelInfo;
+  toolApprovalLevel?: "auto" | "readonly" | "plan";
+  temperature?: number;
+  memory?: { windowSize: number; thread_id: string };
+  thread_id?: string;
+}
+
+// ============================================================================
+// Resolved agent client — what env.MY_AGENT becomes after binding resolution
+// ============================================================================
+
+export interface ResolvedAgentClient {
+  STREAM: (
+    params: AgentStreamParams,
+    opts?: { signal?: AbortSignal },
+  ) => Promise<AsyncIterable<UIMessage> & ReadableStream<UIMessage>>;
+}
+
+// ============================================================================
+// SSE → UIMessageChunk parsing (mirrors DefaultChatTransport.processResponseStream)
+// ============================================================================
+
+async function parseResponseStream(
+  body: ReadableStream<Uint8Array>,
+): Promise<ReadableStream> {
+  const { parseJsonEventStream, uiMessageChunkSchema } = await import("ai");
+  return parseJsonEventStream({
+    stream: body,
+    schema: uiMessageChunkSchema,
+  }).pipeThrough(
+    new TransformStream({
+      transform(result, controller) {
+        if (!result.success) {
+          throw result.error;
+        }
+        controller.enqueue(result.value);
+      },
+    }),
+  );
+}
+
+// ============================================================================
+// Core stream function (used by binding proxy and standalone client)
+// ============================================================================
+
+export async function streamAgent(
+  streamUrl: string,
+  token: string,
+  config: AgentBindingConfig,
+  params: AgentStreamParams,
+  opts?: { signal?: AbortSignal },
+) {
+  const { readUIMessageStream } = await import("ai");
+
+  const agentId = config.value ?? config.id;
+  if (!agentId) {
+    throw new Error("Agent binding has no id or value — cannot resolve agent");
+  }
+
+  const credentialId = params.credentialId ?? config.credentialId;
+  const thinking = params.thinking ?? config.thinking;
+  const hasModels = credentialId && thinking?.id;
+
+  const request = {
+    messages: params.messages,
+    ...(hasModels
+      ? {
+          models: {
+            credentialId,
+            thinking,
+            ...((params.coding ?? config.coding)
+              ? { coding: params.coding ?? config.coding }
+              : {}),
+            ...((params.fast ?? config.fast)
+              ? { fast: params.fast ?? config.fast }
+              : {}),
+          },
+        }
+      : {}),
+    agent: { id: agentId },
+    temperature: params.temperature ?? config.temperature,
+    toolApprovalLevel: params.toolApprovalLevel ?? config.toolApprovalLevel,
+    ...(params.memory ? { memory: params.memory } : {}),
+    ...(params.thread_id ? { thread_id: params.thread_id } : {}),
+  };
+
+  const response = await fetch(streamUrl, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "x-mesh-token": token,
+      Authorization: `Bearer ${token}`,
+    },
+    body: JSON.stringify(request),
+    signal: opts?.signal,
+  });
+
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    let message = `HTTP ${response.status}`;
+    try {
+      const body = JSON.parse(text);
+      if (body?.error) message = body.error;
+    } catch {
+      if (text) message = text;
+    }
+    throw new Error(message);
+  }
+
+  if (!response.body) {
+    throw new Error("Empty response body from decopilot stream");
+  }
+
+  const chunkStream = await parseResponseStream(response.body);
+  return readUIMessageStream({ stream: chunkStream });
+}
+
+// ============================================================================
+// Standalone client factory (for direct usage outside binding system)
+// ============================================================================
+
+export interface DecopilotClientOptions {
+  baseUrl: string;
+  orgSlug: string;
+  token: string;
+}
+
+export function createDecopilotClient(options: DecopilotClientOptions) {
+  const { baseUrl, orgSlug, token } = options;
+  const streamUrl = `${baseUrl}/${orgSlug}/decopilot/runtime/stream`;
+
+  return {
+    stream(
+      request: AgentStreamParams & { agent: { id: string } },
+      opts?: { signal?: AbortSignal },
+    ) {
+      const config: AgentBindingConfig = {
+        __type: "@deco/agent",
+        id: request.agent.id,
+        credentialId: request.credentialId ?? "",
+        thinking: request.thinking ?? { id: "", title: "" },
+        coding: request.coding,
+        fast: request.fast,
+        toolApprovalLevel: request.toolApprovalLevel,
+        temperature: request.temperature,
+      };
+      return streamAgent(streamUrl, token, config, request, opts);
+    },
+  };
+}

package/src/index.ts

@@ -32,7 +32,7 @@ export {
 } from "./tools.ts";
 export { createWorkflow } from "./workflows.ts";
 import type { Binding } from "./wrangler.ts";
-export { proxyConnectionForId, BindingOf } from "./bindings.ts";
+export { proxyConnectionForId, BindingOf, AgentOf } from "./bindings.ts";
 export { type CORSOptions, type CORSOrigin } from "./cors.ts";
 export {
   createMCPFetchStub,

package/src/tools.ts

@@ -13,7 +13,7 @@ import type {
 } from "@modelcontextprotocol/sdk/types.js";
 import { z } from "zod";
 import type { ZodRawShape, ZodSchema, ZodTypeAny } from "zod";
-import { BindingRegistry } from "./bindings.ts";
+import { BindingRegistry, injectBindingSchemas } from "./bindings.ts";
 import { Event, type EventHandlers } from "./events.ts";
 import type { DefaultEnv } from "./index.ts";
 import { State } from "./state.ts";
@@ -579,7 +579,7 @@ const toolsFor = <TSchema extends ZodTypeAny = never>({
   configuration: { state: schema, scopes, onChange } = {},
 }: ResolvedMCPServerOptions<TSchema> = {}): CreatedTool[] => {
   const jsonSchema = schema
-    ? z.toJSONSchema(schema)
+    ? injectBindingSchemas(z.toJSONSchema(schema) as Record<string, unknown>)
     : { type: "object", properties: {} };
   const busProp = String(events?.bus ?? "EVENT_BUS");
   return [
@@ -1058,11 +1058,6 @@ export const createMCPServer = <
         } catch {
           // Ignore close errors
         }
-      } else {
-        console.debug(
-          "[MCP Transport] Keeping transport open for streaming response (Content-Type: %s)",
-          contentType,
-        );
       }
 
       return response;