@ryuhq/sdk 0.1.13 → 0.2.0

package/dist/chunk-A3RGEPDG.js

@@ -0,0 +1,250 @@
+import {
+  assertAllowedEgressUrl
+} from "./chunk-IKEDLLFY.js";
+
+// src/runnable/primitives.ts
+function dataUrlToBytes(dataUrl) {
+  const match = /^data:([^;,]*)(;base64)?,([\s\S]*)$/.exec(dataUrl);
+  if (!match) {
+    throw new Error(
+      "stt.transcribe expects an `audio` value that is a data: URL (data:<mime>;base64,<data>)"
+    );
+  }
+  const mediaType = match[1] || "application/octet-stream";
+  const isBase64 = Boolean(match[2]);
+  const payload = match[3] ?? "";
+  if (isBase64) {
+    const binary = atob(payload);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+      bytes[i] = binary.charCodeAt(i);
+    }
+    return { bytes, mediaType };
+  }
+  return {
+    bytes: new TextEncoder().encode(decodeURIComponent(payload)),
+    mediaType
+  };
+}
+function bytesToDataUrl(bytes, mediaType) {
+  let binary = "";
+  const chunk = 32768;
+  for (let i = 0; i < bytes.length; i += chunk) {
+    binary += String.fromCharCode(...bytes.subarray(i, i + chunk));
+  }
+  return `data:${mediaType};base64,${btoa(binary)}`;
+}
+function httpPrimitiveTransport(options) {
+  const base = options.nodeUrl.replace(/\/+$/, "");
+  assertAllowedEgressUrl(base);
+  const doFetch = options.fetchImpl ?? fetch;
+  const authHeader = () => options.token ? { authorization: `Bearer ${options.token}` } : {};
+  const failDetail = async (path, res) => {
+    const detail = await res.text().catch(() => "");
+    return new Error(
+      `Ryu primitive call ${path} failed: ${res.status} ${res.statusText}${detail ? ` \u2014 ${detail}` : ""}`
+    );
+  };
+  const post = async (path, body) => {
+    const res = await doFetch(`${base}${path}`, {
+      method: "POST",
+      headers: { "content-type": "application/json", ...authHeader() },
+      body: JSON.stringify(body ?? {})
+    });
+    if (!res.ok) {
+      throw await failDetail(path, res);
+    }
+    const text = await res.text();
+    return text ? JSON.parse(text) : void 0;
+  };
+  const transcribeDirect = async (body) => {
+    const input = body ?? {};
+    if (!input.audio) {
+      throw new Error(
+        "stt.transcribe requires an `audio` data: URL (the recorded audio)"
+      );
+    }
+    const { bytes, mediaType } = dataUrlToBytes(input.audio);
+    const form = new FormData();
+    form.append(
+      "file",
+      new Blob([bytes], { type: mediaType || "audio/wav" }),
+      input.filename ?? "recording.wav"
+    );
+    const res = await doFetch(`${base}/api/voice/transcribe`, {
+      method: "POST",
+      headers: authHeader(),
+      body: form
+    });
+    if (!res.ok) {
+      throw await failDetail("/api/voice/transcribe", res);
+    }
+    const parsed = await res.json();
+    return (parsed.text ?? "").trim();
+  };
+  const speakDirect = async (body) => {
+    const res = await doFetch(`${base}/api/voice/speak`, {
+      method: "POST",
+      headers: { "content-type": "application/json", ...authHeader() },
+      body: JSON.stringify(body ?? {})
+    });
+    if (!res.ok) {
+      throw await failDetail("/api/voice/speak", res);
+    }
+    const bytes = new Uint8Array(await res.arrayBuffer());
+    const mediaType = res.headers.get("content-type") || "audio/wav";
+    return bytesToDataUrl(bytes, mediaType);
+  };
+  const generateImageDirect = async (body) => {
+    const res = await doFetch(`${base}/api/images/generate`, {
+      method: "POST",
+      headers: { "content-type": "application/json", ...authHeader() },
+      body: JSON.stringify(body ?? {})
+    });
+    if (!res.ok) {
+      throw await failDetail("/api/images/generate", res);
+    }
+    const parsed = await res.json();
+    return (parsed.data ?? []).map(
+      (item) => item.url ? item.url : `data:image/png;base64,${item.b64_json ?? ""}`
+    );
+  };
+  return {
+    bridge(method, args) {
+      if (!options.pluginId) {
+        return Promise.reject(
+          new Error(
+            `bridge primitive "${method}" requires a pluginId (the /api/plugins/:id/host caller identity)`
+          )
+        );
+      }
+      return post(`/api/plugins/${options.pluginId}/host`, { method, args });
+    },
+    direct(path, body) {
+      if (path === "/api/voice/transcribe") {
+        return transcribeDirect(body);
+      }
+      if (path === "/api/voice/speak") {
+        return speakDirect(body);
+      }
+      if (path === "/api/images/generate") {
+        return generateImageDirect(body);
+      }
+      return post(path, body);
+    },
+    capability(cap, body) {
+      return post(`/api/host/capability/${cap}`, body);
+    }
+  };
+}
+var PRIMITIVE_BINDINGS = {
+  // Bridge families (existing `PluginHookBridge`).
+  "engines.complete": {
+    transport: "bridge",
+    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",
+    path: "/api/images/generate",
+    grant: "media:generate"
+  },
+  "tts.speak": {
+    transport: "direct",
+    path: "/api/voice/speak",
+    grant: "media:generate"
+  },
+  "stt.transcribe": {
+    transport: "direct",
+    path: "/api/voice/transcribe",
+    grant: "media:transcribe"
+  },
+  // Broker capabilities — no rpc family yet (@requires-grant).
+  "rag.retrieve": { transport: "broker", capability: "rag" },
+  "rag.embed": { transport: "broker", capability: "rag" },
+  "rag.rerank": { transport: "broker", capability: "rag" },
+  "memory.recall": { transport: "broker", capability: "memory" },
+  "memory.store": { transport: "broker", capability: "memory" },
+  "realtime.broadcast": { transport: "broker", capability: "realtime" },
+  "realtime.subscribe": { transport: "broker", capability: "realtime" },
+  "durable.checkpoint": { transport: "broker", capability: "durable" },
+  "durable.resume": { transport: "broker", capability: "durable" },
+  "engines.embed": { transport: "broker", capability: "engines" }
+};
+function brokerCall(transport, cap, op, input) {
+  return transport.capability(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),
+      rerank: (input) => brokerCall(transport, "rag", "rerank", input)
+    },
+    memory: {
+      recall: (input) => brokerCall(transport, "memory", "recall", input),
+      store: (input) => brokerCall(transport, "memory", "store", input)
+    },
+    realtime: {
+      broadcast: (input) => brokerCall(transport, "realtime", "broadcast", input).then(
+        () => void 0
+      ),
+      subscribe: (input) => brokerCall(
+        transport,
+        "realtime",
+        "subscribe",
+        input
+      )
+    },
+    durable: {
+      checkpoint: (input) => brokerCall(transport, "durable", "checkpoint", input),
+      resume: (input) => brokerCall(transport, "durable", "resume", input)
+    },
+    engines: {
+      // Bridge family: model.complete → host.sideModel (wire keys are snake_case).
+      complete: (input) => transport.bridge("model.complete", {
+        prompt: input.prompt,
+        system: input.system,
+        model: input.model,
+        model_pref_key: input.modelPrefKey,
+        effort: input.effort
+      }),
+      embed: (input) => brokerCall(transport, "engines", "embed", input)
+    },
+    tts: {
+      speak: (input) => transport.direct("/api/voice/speak", input)
+    },
+    stt: {
+      transcribe: (input) => transport.direct("/api/voice/transcribe", input)
+    },
+    image: {
+      generate: (input) => transport.direct("/api/images/generate", input)
+    }
+  };
+}
+
+export {
+  httpPrimitiveTransport,
+  PRIMITIVE_BINDINGS,
+  createPrimitives
+};

package/dist/chunk-FZSFZOIN.js

@@ -0,0 +1,200 @@
+import {
+  MCP_PROTOCOL_VERSION,
+  callTool,
+  listTools
+} from "./chunk-VLIRNNAE.js";
+
+// src/mcp/server.ts
+import { createInterface } from "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 = 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);
+    });
+  }
+};
+
+export {
+  unwrapContent,
+  McpServer
+};

package/dist/{chunk-ODFEUVPW.js → chunk-HACAGK65.js}

@@ -77,24 +77,7 @@ function defineModel(modelId, options = {}) {
   return new ModelClient2(modelId, options);
 }
 
-// src/model/gateway.ts
-import * as native2 from "@ryuhq/sdk-native";
-var DEFAULT_GATEWAY_URL = "http://127.0.0.1:7981";
-function resolveGatewayUrl3() {
-  return native2.resolveGatewayUrl();
-}
-function resolveGatewayToken2() {
-  return native2.resolveGatewayToken() ?? void 0;
-}
-function assertAllowedEgressUrl(baseUrl) {
-  native2.assertAllowedEgress(baseUrl);
-}
-
 export {
   ModelClient2 as ModelClient,
-  defineModel,
-  DEFAULT_GATEWAY_URL,
-  resolveGatewayUrl3 as resolveGatewayUrl,
-  resolveGatewayToken2 as resolveGatewayToken,
-  assertAllowedEgressUrl
+  defineModel
 };

package/dist/{chunk-AO2KJRDD.js → chunk-IEUQ3CDG.js}

@@ -146,8 +146,30 @@ var WidgetContributionSchema = z.object({
   /** Default display mode (`inline` | `fullscreen` | `pip`). */
   default_display_mode: z.string().default(DEFAULT_WIDGET_DISPLAY_MODE)
 });
+var ChatWidgetTemplateSchema = z.object({
+  id: z.string().regex(/^[a-z0-9][a-z0-9._:-]*$/),
+  title: z.string().min(1),
+  description: z.string().optional(),
+  triggers: z.array(z.string()).default([]),
+  examples: z.array(z.string()).default([]),
+  backing: z.object({
+    tool_id: z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:/-]*$/).optional(),
+    view_id: z.string().regex(/^[a-z0-9][a-z0-9._:-]*$/).optional()
+  }),
+  display_mode: z.string().min(1),
+  safe_action_ids: z.array(z.string().regex(/^[a-z0-9][a-z0-9._-]*$/)).default([]),
+  availability: 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 = 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: 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
@@ -174,6 +196,11 @@ var ContributesSchema = z.object({
    *  signing, leaving an app that emits events nothing is allowed to subscribe to. */
   hook_events: z.array(HookEventContributionSchema).default([]),
   composer_controls: z.array(z.record(z.string(), 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: z.array(z.record(z.string(), z.unknown())).default([]),
   settings_tabs: z.array(z.record(z.string(), z.unknown())).default([]),
   slash_commands: z.array(z.record(z.string(), z.unknown())).default([]),
   /** App widgets (Ryu Apps). Each binds a render tool id to its
@@ -181,6 +208,8 @@ var ContributesSchema = z.object({
    *  `Contributes.widgets` field, without which the CLI's zod parse would strip
    *  every widget an app authored here declares. */
   widgets: z.array(WidgetContributionSchema).default([]),
+  /** Metadata-only chat widget templates. */
+  chat_widget_templates: 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
@@ -193,6 +222,13 @@ var ContributesSchema = 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: z.array(z.record(z.string(), 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: z.array(z.record(z.string(), 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
@@ -230,7 +266,10 @@ var ContributesSchema = 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: z.array(OutputStyleContributionSchema).default([])
+  output_styles: 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: z.array(z.record(z.string(), z.unknown())).default([])
 });
 var SetupStepSchema = z.object({
   /** Card heading (e.g. the companion app name). */
@@ -311,6 +350,61 @@ var EnginesReqSchema = z.object({
   /** Floor for the Next.js web app. */
   web: z.string().optional()
 });
+var McpServerAuthSchema = z.object({
+  client_id: z.string().min(1).optional(),
+  type: z.literal("oauth")
+}).strict();
+var McpServerDeclSchema = z.object({
+  args: z.array(z.string()).default([]),
+  auth: McpServerAuthSchema.optional(),
+  command: z.string().optional(),
+  command_env: z.string().optional(),
+  description: z.string().optional(),
+  enabled: z.boolean().default(true),
+  env: z.record(z.string(), z.string()).default({}),
+  headers: z.record(z.string(), z.string()).default({}),
+  type: z.enum(["stdio", "http", "streamable-http", "streamable_http", "sse"]).optional(),
+  url: 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 = z.object({
   /** Reverse-domain unique identifier (e.g. `"com.example.my-plugin"`). */
   id: z.string().min(1, "id is required"),
@@ -342,6 +436,8 @@ var PluginManifestSchema = z.object({
    * Declarations only — grant enforcement is the Gateway's responsibility.
    */
   permission_grants: z.array(z.string()).default([]),
+  /** Remote or stdio MCP servers registered by this plugin. */
+  mcp_servers: z.record(z.string(), McpServerDeclSchema).optional(),
   /**
    * Optional Companion surface (an in-desktop overlay or sidebar panel).
    * Absent when the plugin has no Companion surface.
@@ -435,10 +531,16 @@ var PluginManifestSchema = z.object({
       url: z.string().optional()
     })
   ]).optional(),
+  /** Public source repository URL (Claude/Codex `repository`). */
+  repository: z.string().url().optional(),
+  /** True when the provider operates outside the local Ryu runtime. */
+  external: z.boolean().optional(),
   /** Project/marketing homepage — maps to the listing `website` (Claude field). */
   homepage: z.string().optional(),
   /** Free-text search keywords (Claude field). */
   keywords: z.array(z.string()).optional(),
+  /** Stable Marketplace filter labels (Ryu extension). */
+  tags: z.array(z.string()).optional(),
   /** Taxonomy category beyond the runnable kinds (Claude field). */
   category: z.string().optional(),
   /** SPDX-ish license identifier (Claude field). */
@@ -452,6 +554,8 @@ var PluginManifestSchema = z.object({
    * from `iconUrl` (a raster logo). Falls back to `iconUrl` when omitted.
    */
   icon: z.string().optional(),
+  /** Optional detail-page hero banner metadata forwarded to the marketplace. */
+  banner: z.record(z.string(), 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
@@ -483,6 +587,22 @@ var PluginManifestSchema = z.object({
    * array of steps guiding the user through post-install configuration.
    */
   setup: z.union([SetupStepSchema, 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);
@@ -504,6 +624,7 @@ export {
   PiExtensionContributionSchema,
   OutputStyleContributionSchema,
   WidgetContributionSchema,
+  ChatWidgetTemplateSchema,
   ToolAppConfigSchema,
   ContributesSchema,
   SetupStepSchema,
@@ -512,6 +633,8 @@ export {
   RequiresSchema,
   SurfaceSchema,
   EnginesReqSchema,
+  McpServerAuthSchema,
+  McpServerDeclSchema,
   PluginManifestSchema,
   validatePluginId,
   validateManifestStrict,