@ryuhq/sdk 0.1.13 → 0.2.0

package/dist/index.cjs

@@ -37,6 +37,10 @@ __export(src_exports, {
   CapabilityReqSchema: () => CapabilityReqSchema,
   CompanionSurfaceSchema: () => CompanionSurfaceSchema,
   DEFAULT_GATEWAY_URL: () => DEFAULT_GATEWAY_URL,
+  MCP_PROTOCOL_VERSION: () => MCP_PROTOCOL_VERSION,
+  McpServer: () => McpServer,
+  McpServerAuthSchema: () => McpServerAuthSchema,
+  McpServerDeclSchema: () => McpServerDeclSchema,
   ModelClient: () => ModelClient2,
   PRIMITIVE_BINDINGS: () => PRIMITIVE_BINDINGS,
   PluginBuilder: () => PluginBuilder,
@@ -54,6 +58,7 @@ __export(src_exports, {
   app: () => app,
   appToolId: () => appToolId,
   assertAllowedEgressUrl: () => assertAllowedEgressUrl,
+  callTool: () => callTool,
   coreManifestJsonSchema: () => coreManifestJsonSchema,
   createAgent: () => createAgent,
   createPrimitives: () => createPrimitives,
@@ -67,19 +72,22 @@ __export(src_exports, {
   defineWorkflow: () => defineWorkflow,
   httpPrimitiveTransport: () => httpPrimitiveTransport,
   inlineToolRunnable: () => inlineToolRunnable,
+  listTools: () => listTools,
   query: () => query,
   resolveGatewayToken: () => resolveGatewayToken2,
   resolveGatewayUrl: () => resolveGatewayUrl3,
   ryuTool: () => ryuTool,
   skill: () => skill,
+  toDisposable: () => toDisposable,
   tool: () => tool,
+  unwrapContent: () => unwrapContent,
   validateManifestStrict: () => validateManifestStrict,
   validatePluginId: () => validatePluginId,
   workflow: () => workflow
 });
 module.exports = __toCommonJS(src_exports);
 
-// ../../node_modules/.bun/tsup@8.5.1+7a7b737fa55947b7/node_modules/tsup/assets/cjs_shims.js
+// ../../node_modules/.bun/tsup@8.5.1+276f2dd5f44b8d39/node_modules/tsup/assets/cjs_shims.js
 var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.tagName.toUpperCase() === "SCRIPT" ? document.currentScript.src : new URL("main.js", document.baseURI).href;
 var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
 
@@ -317,6 +325,16 @@ var PRIMITIVE_BINDINGS = {
     method: "model.complete",
     grant: "hook:side-model"
   },
+  "background.list": {
+    transport: "bridge",
+    method: "background.list",
+    grant: "background:control"
+  },
+  "background.stop": {
+    transport: "bridge",
+    method: "background.stop",
+    grant: "background:control"
+  },
   // Host-direct media data-path (the host holds the node token; returns data: URLs).
   "image.generate": {
     transport: "direct",
@@ -350,6 +368,15 @@ function brokerCall(transport, cap, op, input) {
 }
 function createPrimitives(transport) {
   return {
+    background: {
+      list: (input) => transport.bridge("background.list", {
+        producer: input?.producer,
+        running_only: input?.runningOnly
+      }),
+      stop: (input) => transport.bridge("background.stop", {
+        process_id: input.processId
+      })
+    },
     rag: {
       retrieve: (input) => brokerCall(transport, "rag", "retrieve", input),
       embed: (input) => brokerCall(transport, "rag", "embed", input),
@@ -976,8 +1003,30 @@ var WidgetContributionSchema = import_zod.z.object({
   /** Default display mode (`inline` | `fullscreen` | `pip`). */
   default_display_mode: import_zod.z.string().default(DEFAULT_WIDGET_DISPLAY_MODE)
 });
+var ChatWidgetTemplateSchema = import_zod.z.object({
+  id: import_zod.z.string().regex(/^[a-z0-9][a-z0-9._:-]*$/),
+  title: import_zod.z.string().min(1),
+  description: import_zod.z.string().optional(),
+  triggers: import_zod.z.array(import_zod.z.string()).default([]),
+  examples: import_zod.z.array(import_zod.z.string()).default([]),
+  backing: import_zod.z.object({
+    tool_id: import_zod.z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:/-]*$/).optional(),
+    view_id: import_zod.z.string().regex(/^[a-z0-9][a-z0-9._:-]*$/).optional()
+  }),
+  display_mode: import_zod.z.string().min(1),
+  safe_action_ids: import_zod.z.array(import_zod.z.string().regex(/^[a-z0-9][a-z0-9._-]*$/)).default([]),
+  availability: import_zod.z.string().default("available")
+}).superRefine((value, ctx) => {
+  const count = Number(Boolean(value.backing.tool_id)) + Number(Boolean(value.backing.view_id));
+  if (count !== 1 && value.availability === "available") {
+    ctx.addIssue({ code: "custom", path: ["backing"], message: "available templates need exactly one backing tool_id or view_id" });
+  }
+  if (count > 1) {
+    ctx.addIssue({ code: "custom", path: ["backing"], message: "backing must declare at most one of tool_id or view_id" });
+  }
+});
 var ToolAppConfigSchema = import_zod.z.object({
-  /** MCP tool slug this runnable wraps — the fully-qualified `<server>__<name>` id. */
+  /** MCP tool slug this runnable wraps — the fully-qualified `<server>.<name>` id. */
   slug: import_zod.z.string().min(1),
   /** The tool description the model reads when choosing it. Carried here because a
    *  packed app's manifest is the only channel (there is no `generated.rs`); Core's
@@ -1004,6 +1053,11 @@ var ContributesSchema = import_zod.z.object({
    *  signing, leaving an app that emits events nothing is allowed to subscribe to. */
   hook_events: import_zod.z.array(HookEventContributionSchema).default([]),
   composer_controls: import_zod.z.array(import_zod.z.record(import_zod.z.string(), import_zod.z.unknown())).default([]),
+  /** Chat feature descriptors whose behavior is implemented by the host shell.
+   * Mirrors the Rust-side `Contributes.chat_features`; keeping this field in the
+   * authoring schema prevents `ryu pack` from silently deleting a plugin's chat
+   * feature declaration before signing. */
+  chat_features: import_zod.z.array(import_zod.z.record(import_zod.z.string(), import_zod.z.unknown())).default([]),
   settings_tabs: import_zod.z.array(import_zod.z.record(import_zod.z.string(), import_zod.z.unknown())).default([]),
   slash_commands: import_zod.z.array(import_zod.z.record(import_zod.z.string(), import_zod.z.unknown())).default([]),
   /** App widgets (Ryu Apps). Each binds a render tool id to its
@@ -1011,6 +1065,8 @@ var ContributesSchema = import_zod.z.object({
    *  `Contributes.widgets` field, without which the CLI's zod parse would strip
    *  every widget an app authored here declares. */
   widgets: import_zod.z.array(WidgetContributionSchema).default([]),
+  /** Metadata-only chat widget templates. */
+  chat_widget_templates: import_zod.z.array(ChatWidgetTemplateSchema).optional(),
   /** App-registered sidebar sections (header + live list) and buttons (single nav
    *  rows). Loosely typed here — the shell owns the spec vocabulary — matching how
    *  `composer_controls`/`settings_tabs` are declared. Mirrors the Rust-side
@@ -1023,6 +1079,13 @@ var ContributesSchema = import_zod.z.object({
    *  Rust-side `Contributes.dock_panels`; without it the CLI's zod parse would
    *  strip the dock panel an app declares here. */
   dock_panels: import_zod.z.array(import_zod.z.record(import_zod.z.string(), import_zod.z.unknown())).default([]),
+  /** App-registered live activities (the desktop "Dynamic Island" cards). Loosely
+   *  typed for the same reason as the surfaces above — the shell owns the
+   *  `spec` vocabulary. Mirrors the Rust-side `Contributes.live_activities`;
+   *  without it the CLI's zod parse would strip every live activity an app
+   *  declares here, so a packed bundle would ship a dock that silently stays
+   *  empty. */
+  live_activities: import_zod.z.array(import_zod.z.record(import_zod.z.string(), import_zod.z.unknown())).default([]),
   /** Deletable data categories the app owns — one "Delete all X" row in Settings
    *  → Danger Zone. Mirrors the Rust-side `Contributes.data_categories`; without
    *  it the CLI's zod parse would strip the declaration before signing, and the
@@ -1060,7 +1123,10 @@ var ContributesSchema = import_zod.z.object({
    *  bug: the styles' `.md` files are not carried by the bundle either, so there
    *  would be no residue to notice — the plugin would install clean and contribute
    *  nothing. */
-  output_styles: import_zod.z.array(OutputStyleContributionSchema).default([])
+  output_styles: import_zod.z.array(OutputStyleContributionSchema).default([]),
+  /** Per-message actions contributed by an enabled plugin. Kept as loose records
+   *  so renderer-specific `kind`/`args` payloads survive `ryu pack` unchanged. */
+  message_actions: import_zod.z.array(import_zod.z.record(import_zod.z.string(), import_zod.z.unknown())).default([])
 });
 var SetupStepSchema = import_zod.z.object({
   /** Card heading (e.g. the companion app name). */
@@ -1141,6 +1207,61 @@ var EnginesReqSchema = import_zod.z.object({
   /** Floor for the Next.js web app. */
   web: import_zod.z.string().optional()
 });
+var McpServerAuthSchema = import_zod.z.object({
+  client_id: import_zod.z.string().min(1).optional(),
+  type: import_zod.z.literal("oauth")
+}).strict();
+var McpServerDeclSchema = import_zod.z.object({
+  args: import_zod.z.array(import_zod.z.string()).default([]),
+  auth: McpServerAuthSchema.optional(),
+  command: import_zod.z.string().optional(),
+  command_env: import_zod.z.string().optional(),
+  description: import_zod.z.string().optional(),
+  enabled: import_zod.z.boolean().default(true),
+  env: import_zod.z.record(import_zod.z.string(), import_zod.z.string()).default({}),
+  headers: import_zod.z.record(import_zod.z.string(), import_zod.z.string()).default({}),
+  type: import_zod.z.enum(["stdio", "http", "streamable-http", "streamable_http", "sse"]).optional(),
+  url: import_zod.z.url().optional()
+}).superRefine((server, context) => {
+  if (!(server.command || server.url)) {
+    context.addIssue({
+      code: "custom",
+      message: "an MCP server requires command or url"
+    });
+  }
+  if (!server.auth) {
+    return;
+  }
+  if (server.command || server.type === "stdio" || !server.url) {
+    context.addIssue({
+      code: "custom",
+      message: "OAuth is supported only for remote HTTP MCP servers"
+    });
+    return;
+  }
+  if (Object.keys(server.headers).some(
+    (name) => name.toLowerCase() === "authorization"
+  )) {
+    context.addIssue({
+      code: "custom",
+      message: "OAuth cannot be combined with a static Authorization header"
+    });
+  }
+  const url = new URL(server.url);
+  const loopback = url.hostname === "localhost" || url.hostname.startsWith("127.") || url.hostname === "[::1]" || url.hostname === "::1";
+  if (url.username || url.password || url.hash) {
+    context.addIssue({
+      code: "custom",
+      message: "OAuth MCP URLs cannot contain credentials or fragments"
+    });
+  }
+  if (url.protocol !== "https:" && !(url.protocol === "http:" && loopback)) {
+    context.addIssue({
+      code: "custom",
+      message: "OAuth MCP URLs must use HTTPS except on loopback"
+    });
+  }
+});
 var PluginManifestSchema = import_zod.z.object({
   /** Reverse-domain unique identifier (e.g. `"com.example.my-plugin"`). */
   id: import_zod.z.string().min(1, "id is required"),
@@ -1172,6 +1293,8 @@ var PluginManifestSchema = import_zod.z.object({
    * Declarations only — grant enforcement is the Gateway's responsibility.
    */
   permission_grants: import_zod.z.array(import_zod.z.string()).default([]),
+  /** Remote or stdio MCP servers registered by this plugin. */
+  mcp_servers: import_zod.z.record(import_zod.z.string(), McpServerDeclSchema).optional(),
   /**
    * Optional Companion surface (an in-desktop overlay or sidebar panel).
    * Absent when the plugin has no Companion surface.
@@ -1265,10 +1388,16 @@ var PluginManifestSchema = import_zod.z.object({
       url: import_zod.z.string().optional()
     })
   ]).optional(),
+  /** Public source repository URL (Claude/Codex `repository`). */
+  repository: import_zod.z.string().url().optional(),
+  /** True when the provider operates outside the local Ryu runtime. */
+  external: import_zod.z.boolean().optional(),
   /** Project/marketing homepage — maps to the listing `website` (Claude field). */
   homepage: import_zod.z.string().optional(),
   /** Free-text search keywords (Claude field). */
   keywords: import_zod.z.array(import_zod.z.string()).optional(),
+  /** Stable Marketplace filter labels (Ryu extension). */
+  tags: import_zod.z.array(import_zod.z.string()).optional(),
   /** Taxonomy category beyond the runnable kinds (Claude field). */
   category: import_zod.z.string().optional(),
   /** SPDX-ish license identifier (Claude field). */
@@ -1282,6 +1411,8 @@ var PluginManifestSchema = import_zod.z.object({
    * from `iconUrl` (a raster logo). Falls back to `iconUrl` when omitted.
    */
   icon: import_zod.z.string().optional(),
+  /** Optional detail-page hero banner metadata forwarded to the marketplace. */
+  banner: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional(),
   /**
    * Dithered-gradient background for the card's icon square (Ryu extension),
    * mirroring dither-kit's `DitherGradient` props. `from`/`to` are a palette-colour
@@ -1313,6 +1444,22 @@ var PluginManifestSchema = import_zod.z.object({
    * array of steps guiding the user through post-install configuration.
    */
   setup: import_zod.z.union([SetupStepSchema, import_zod.z.array(SetupStepSchema)]).optional()
+}).superRefine((manifest, context) => {
+  const hasOAuthServer = Object.values(manifest.mcp_servers ?? {}).some(
+    (server) => server.auth?.type === "oauth"
+  );
+  if (!hasOAuthServer) {
+    return;
+  }
+  for (const grant of ["mcp:server", "identity.read"]) {
+    if (!manifest.permission_grants.includes(grant)) {
+      context.addIssue({
+        code: "custom",
+        message: `OAuth MCP servers require the ${grant} permission grant`,
+        path: ["permission_grants"]
+      });
+    }
+  }
 });
 function validatePluginId(id) {
   loadNative().validatePluginId(id);
@@ -1336,7 +1483,7 @@ function withWidgetRenderGrant(grants, widgets) {
   return out;
 }
 function appToolId(server, name) {
-  return `${server}__${name}`;
+  return `${server}.${name}`;
 }
 function defineApp(options) {
   const server = options.server ?? options.slug;
@@ -1376,6 +1523,7 @@ function defineApp(options) {
   }
   const contributes = {
     turn_hooks: [],
+    chat_features: [],
     // This builder synthesises an app from its runnables; an app that emits
     // events declares them in a hand-authored `manifest.json`, same as
     // `lsp_servers` below.
@@ -1386,6 +1534,7 @@ function defineApp(options) {
     sidebar_sections: [],
     sidebar_buttons: [],
     dock_panels: [],
+    live_activities: [],
     // Empty for the same reason as every sibling family above: this builder
     // synthesises `widgets` from the app's own runnables and nothing else, and
     // takes no `contributes` passthrough. An app that wants to declare language
@@ -1398,6 +1547,7 @@ function defineApp(options) {
     data_categories: [],
     pi_extensions: [],
     output_styles: [],
+    message_actions: [],
     widgets
   };
   const raw = {
@@ -1781,6 +1931,359 @@ var AppBuilder = class {
 };
 var app = () => new AppBuilder();
 
+// src/mcp/client.ts
+var import_node_child_process = require("child_process");
+var import_node_readline = require("readline");
+var MCP_PROTOCOL_VERSION = "2024-11-05";
+var RPC_TIMEOUT_MS = 6e4;
+var McpConnection = class _McpConnection {
+  proc;
+  nextId = 1;
+  closed = false;
+  waiters = [];
+  constructor(proc) {
+    this.proc = proc;
+  }
+  /** Spawn the server and complete the MCP `initialize` handshake. */
+  static async connect(cmd) {
+    const env2 = { ...process.env, ...cmd.env ?? {} };
+    const proc = (0, import_node_child_process.spawn)(cmd.command, cmd.args ?? [], {
+      stdio: ["pipe", "pipe", "pipe"],
+      env: env2
+    });
+    if (!(proc.stdin && proc.stdout)) {
+      proc.kill();
+      throw new Error(`MCP server '${cmd.command}' stdin/stdout unavailable`);
+    }
+    if (proc.stderr) {
+      proc.stderr.on("data", (chunk) => {
+        process.stderr.write(`[mcp-server] ${chunk.toString()}`);
+      });
+    }
+    const conn = new _McpConnection(proc);
+    const rl = (0, import_node_readline.createInterface)({
+      input: proc.stdout,
+      crlfDelay: Number.POSITIVE_INFINITY
+    });
+    rl.on("line", (rawLine) => {
+      const trimmed = rawLine.trim();
+      if (!trimmed) {
+        return;
+      }
+      let parsed;
+      try {
+        parsed = JSON.parse(trimmed);
+      } catch {
+        return;
+      }
+      if (parsed.id === void 0 || parsed.id === null) {
+        return;
+      }
+      const idx = conn.waiters.findIndex((w) => w.id === parsed.id);
+      if (idx === -1) {
+        return;
+      }
+      const [waiter] = conn.waiters.splice(idx, 1);
+      if (!waiter) {
+        return;
+      }
+      clearTimeout(waiter.timer);
+      if (parsed.error) {
+        waiter.reject(new Error(`MCP error: ${JSON.stringify(parsed.error)}`));
+      } else {
+        waiter.resolve(parsed.result ?? null);
+      }
+    });
+    rl.on("close", () => {
+      for (const waiter of conn.waiters.splice(0)) {
+        clearTimeout(waiter.timer);
+        waiter.reject(new Error("MCP server closed the connection"));
+      }
+    });
+    await conn.request("initialize", {
+      protocolVersion: MCP_PROTOCOL_VERSION,
+      capabilities: {},
+      clientInfo: { name: "ryu-sdk", version: "0.0.1" }
+    });
+    conn.notify("notifications/initialized", {});
+    return conn;
+  }
+  /** Send a JSON-RPC request and return the `result` field. */
+  request(method, params) {
+    const id = this.nextId++;
+    const frame = JSON.stringify({
+      jsonrpc: "2.0",
+      id,
+      method,
+      params
+    });
+    this.write(frame);
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(
+        () => reject(new Error(`MCP request '${method}' timed out`)),
+        RPC_TIMEOUT_MS
+      );
+      this.waiters.push({ id, resolve, reject, timer });
+    });
+  }
+  /** Send a JSON-RPC notification (no response expected). */
+  notify(method, params) {
+    const frame = JSON.stringify({ jsonrpc: "2.0", method, params });
+    this.write(frame);
+  }
+  write(frame) {
+    if (this.closed) {
+      return;
+    }
+    this.proc.stdin?.write(`${frame}
+`);
+  }
+  /** Graceful shutdown: close stdin, then kill. */
+  async shutdown() {
+    this.closed = true;
+    this.proc.stdin?.end();
+    await new Promise((resolve) => {
+      this.proc.once("exit", () => resolve());
+      this.proc.kill();
+      setTimeout(resolve, 500);
+    });
+  }
+};
+async function listTools(cmd) {
+  const conn = await McpConnection.connect(cmd);
+  let result;
+  try {
+    result = await conn.request("tools/list", {});
+  } finally {
+    await conn.shutdown();
+  }
+  const tools = result?.tools ?? [];
+  return tools.map((t) => {
+    const tool2 = t;
+    const name = tool2.name;
+    if (typeof name !== "string") {
+      return null;
+    }
+    return {
+      name,
+      description: typeof tool2.description === "string" ? tool2.description : void 0,
+      inputSchema: tool2.inputSchema
+    };
+  }).filter((t) => t !== null);
+}
+async function callTool(cmd, tool2, args) {
+  const conn = await McpConnection.connect(cmd);
+  try {
+    return await conn.request("tools/call", { name: tool2, arguments: args });
+  } finally {
+    await conn.shutdown();
+  }
+}
+
+// src/mcp/server.ts
+var import_node_readline2 = require("readline");
+function respond(id, result) {
+  return { jsonrpc: "2.0", id: id ?? null, result };
+}
+function respondError(id, code, message) {
+  return { jsonrpc: "2.0", id: id ?? null, error: { code, message } };
+}
+function wrapContent(value) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: typeof value === "string" ? value : JSON.stringify(value)
+      }
+    ]
+  };
+}
+function unwrapContent(raw) {
+  const r = raw;
+  const text = r?.content?.[0]?.text;
+  if (text === void 0) {
+    return raw;
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+var McpServer = class {
+  runnables = /* @__PURE__ */ new Map();
+  passthroughs = [];
+  /**
+   * Register an SDK Runnable as an MCP tool.
+   * Returns `this` for chaining.
+   */
+  register(runnable) {
+    this.runnables.set(runnable.name, runnable);
+    return this;
+  }
+  /**
+   * Register a passthrough to an external MCP stdio server (e.g. Ghost or
+   * Shadow).  Tools from that server are fetched lazily and re-advertised.
+   * Returns `this` for chaining.
+   */
+  passthrough(registration) {
+    this.passthroughs.push(registration);
+    return this;
+  }
+  /** Fetch all tools: local Runnables + passthrough tools. */
+  async allTools() {
+    const local = [...this.runnables.values()].map((r) => ({
+      name: r.name,
+      description: r.description,
+      inputSchema: r.inputSchema
+    }));
+    const remote = [];
+    for (const pt of this.passthroughs) {
+      try {
+        const tools = await listTools(pt.command);
+        remote.push(...tools);
+      } catch (err) {
+        process.stderr.write(
+          `[mcp-server] passthrough '${pt.label}' list_tools failed: ${err}
+`
+        );
+      }
+    }
+    return [...local, ...remote];
+  }
+  /** Handle a `tools/call` request. */
+  async handleCallTool(name, args) {
+    const local = this.runnables.get(name);
+    if (local) {
+      const result = await local.run(args);
+      return wrapContent(result);
+    }
+    for (const pt of this.passthroughs) {
+      try {
+        const tools = await listTools(pt.command);
+        if (tools.some((t) => t.name === name)) {
+          return await callTool(pt.command, name, args);
+        }
+      } catch {
+      }
+    }
+    throw new Error(`Unknown tool: ${name}`);
+  }
+  /**
+   * Handle a single parsed JSON-RPC request line. Returns the response to write
+   * (or null for notifications that require no response).
+   */
+  async handleRequest(req, initialized, write) {
+    const { id, method, params } = req;
+    if (method === "initialize") {
+      initialized.value = true;
+      write(
+        respond(id, {
+          protocolVersion: MCP_PROTOCOL_VERSION,
+          capabilities: { tools: {} },
+          serverInfo: { name: "ryu-sdk-server", version: "0.0.1" }
+        })
+      );
+      return;
+    }
+    if (method === "notifications/initialized") {
+      return;
+    }
+    if (!initialized.value) {
+      write(respondError(id, -32002, "Server not initialized"));
+      return;
+    }
+    if (method === "tools/list") {
+      try {
+        const tools = await this.allTools();
+        write(respond(id, { tools }));
+      } catch (err) {
+        write(respondError(id, -32603, String(err)));
+      }
+      return;
+    }
+    if (method === "tools/call") {
+      await this.handleToolsCall(id, params, write);
+      return;
+    }
+    write(respondError(id, -32601, `Method not found: ${method}`));
+  }
+  /** Handle a `tools/call` JSON-RPC request. */
+  async handleToolsCall(id, params, write) {
+    const p = params;
+    const toolName = p?.name;
+    const toolArgs = p?.arguments ?? {};
+    if (typeof toolName !== "string") {
+      write(respondError(id, -32602, "tools/call requires 'name'"));
+      return;
+    }
+    try {
+      const result = await this.handleCallTool(toolName, toolArgs);
+      write(respond(id, result));
+    } catch (err) {
+      write(
+        respond(id, {
+          content: [{ type: "text", text: String(err) }],
+          isError: true
+        })
+      );
+    }
+  }
+  /**
+   * Start reading JSON-RPC requests from the given readable stream and writing
+   * responses to the given writable stream.
+   *
+   * Defaults to `process.stdin` / `process.stdout`.  Passing explicit streams
+   * lets tests inject a pair of in-process pipes.
+   *
+   * Resolves when the input stream ends (EOF).
+   */
+  serve(input = process.stdin, output = process.stdout) {
+    const write = (obj) => {
+      output.write(`${JSON.stringify(obj)}
+`);
+    };
+    const initialized = { value: false };
+    return new Promise((resolve) => {
+      const rl = (0, import_node_readline2.createInterface)({
+        input,
+        crlfDelay: Number.POSITIVE_INFINITY
+      });
+      rl.on("line", (rawLine) => {
+        const line = rawLine.trim();
+        if (!line) {
+          return;
+        }
+        let req;
+        try {
+          req = JSON.parse(line);
+        } catch {
+          write(respondError(null, -32700, "Parse error"));
+          return;
+        }
+        this.handleRequest(req, initialized, write).catch((err) => {
+          write(respondError(req.id, -32603, String(err)));
+        });
+      });
+      rl.on("close", resolve);
+    });
+  }
+};
+
+// src/plugin/ryu-plugin.ts
+function toDisposable(teardown) {
+  let done = false;
+  return {
+    dispose() {
+      if (done) {
+        return;
+      }
+      done = true;
+      teardown();
+    }
+  };
+}
+
 // src/runnable/agent.ts
 var CAPABILITY_SLOTS = ["rag", "memory", "tts", "stt"];
 function lowerChatSlot(chat) {
@@ -2014,6 +2517,7 @@ function definePlugin(options) {
     turn_hooks: options.turnHooks ?? [],
     hook_events: options.hookEvents ?? [],
     composer_controls: options.composerControls ?? [],
+    chat_features: [],
     settings_tabs: options.settingsTabs ?? [],
     slash_commands: options.slashCommands ?? [],
     lsp_servers: options.lspServers ?? {},
@@ -2025,9 +2529,11 @@ function definePlugin(options) {
     sidebar_sections: [],
     sidebar_buttons: [],
     dock_panels: [],
+    live_activities: [],
     data_categories: [],
     pi_extensions: [],
-    output_styles: []
+    output_styles: [],
+    message_actions: []
   };
   const tools = options.tools ?? [];
   const runnables = tools.map((t) => inlineToolRunnable(t));
@@ -2076,6 +2582,10 @@ function defineWorkflow(options) {
   CapabilityReqSchema,
   CompanionSurfaceSchema,
   DEFAULT_GATEWAY_URL,
+  MCP_PROTOCOL_VERSION,
+  McpServer,
+  McpServerAuthSchema,
+  McpServerDeclSchema,
   ModelClient,
   PRIMITIVE_BINDINGS,
   PluginBuilder,
@@ -2093,6 +2603,7 @@ function defineWorkflow(options) {
   app,
   appToolId,
   assertAllowedEgressUrl,
+  callTool,
   coreManifestJsonSchema,
   createAgent,
   createPrimitives,
@@ -2106,12 +2617,15 @@ function defineWorkflow(options) {
   defineWorkflow,
   httpPrimitiveTransport,
   inlineToolRunnable,
+  listTools,
   query,
   resolveGatewayToken,
   resolveGatewayUrl,
   ryuTool,
   skill,
+  toDisposable,
   tool,
+  unwrapContent,
   validateManifestStrict,
   validatePluginId,
   workflow