@ryuhq/sdk 0.1.13 → 0.2.0

package/dist/{chunk-MTUBUPIV.js → chunk-ULSVL7EC.js}

@@ -1,231 +1,15 @@
+import {
+  createPrimitives,
+  httpPrimitiveTransport
+} from "./chunk-A3RGEPDG.js";
+import {
+  defineModel
+} from "./chunk-HACAGK65.js";
 import {
   assertAllowedEgressUrl,
-  defineModel,
   resolveGatewayToken,
   resolveGatewayUrl
-} from "./chunk-ODFEUVPW.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"
-  },
-  // 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 {
-    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)
-    }
-  };
-}
+} from "./chunk-IKEDLLFY.js";
 
 // src/agent/model-call.ts
 var CHAT_COMPLETIONS_PATH = "/v1/chat/completions";
@@ -659,9 +443,6 @@ function query(input) {
 }
 
 export {
-  httpPrimitiveTransport,
-  PRIMITIVE_BINDINGS,
-  createPrimitives,
   callModelWithTools,
   ryuTool,
   resolveToolDefs,

package/dist/chunk-VLIRNNAE.js

@@ -0,0 +1,154 @@
+// src/mcp/client.ts
+import { spawn } from "child_process";
+import { createInterface } from "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 env = { ...process.env, ...cmd.env ?? {} };
+    const proc = spawn(cmd.command, cmd.args ?? [], {
+      stdio: ["pipe", "pipe", "pipe"],
+      env
+    });
+    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 = 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 tool = t;
+    const name = tool.name;
+    if (typeof name !== "string") {
+      return null;
+    }
+    return {
+      name,
+      description: typeof tool.description === "string" ? tool.description : void 0,
+      inputSchema: tool.inputSchema
+    };
+  }).filter((t) => t !== null);
+}
+async function callTool(cmd, tool, args) {
+  const conn = await McpConnection.connect(cmd);
+  try {
+    return await conn.request("tools/call", { name: tool, arguments: args });
+  } finally {
+    await conn.shutdown();
+  }
+}
+
+export {
+  MCP_PROTOCOL_VERSION,
+  listTools,
+  callTool
+};

package/dist/chunk-W3KPP4WN.js

@@ -0,0 +1,135 @@
+import {
+  PluginManifestSchema
+} from "./chunk-IEUQ3CDG.js";
+
+// src/runnable/app.ts
+var DEFAULT_APP_WIDGET_MIME = "text/html+skybridge";
+var DEFAULT_APP_DISPLAY_MODE = "inline";
+var WIDGET_RENDER_GRANT = "widget:render";
+function withWidgetRenderGrant(grants, widgets) {
+  const out = [...grants];
+  if (widgets.length > 0 && !out.includes(WIDGET_RENDER_GRANT)) {
+    out.push(WIDGET_RENDER_GRANT);
+  }
+  return out;
+}
+function appToolId(server, name) {
+  return `${server}.${name}`;
+}
+function defineApp(options) {
+  const server = options.server ?? options.slug;
+  const uri = `ui://widget/${options.slug}.html`;
+  const mime = options.mime ?? DEFAULT_APP_WIDGET_MIME;
+  const displayMode = options.displayMode ?? DEFAULT_APP_DISPLAY_MODE;
+  const hasCompanions = options.tools.some((t) => t.accessible === true);
+  const runnables = [];
+  const widgets = [];
+  for (const spec of options.tools) {
+    const isRender = spec.accessible !== true;
+    const id = appToolId(server, spec.name);
+    const config = {
+      slug: id,
+      description: spec.description,
+      widget: isRender,
+      widget_accessible: isRender ? hasCompanions : true,
+      ...spec.inputSchema ? { input_schema: spec.inputSchema } : {},
+      ...spec.invoking ? { invoking: spec.invoking } : {},
+      ...spec.invoked ? { invoked: spec.invoked } : {}
+    };
+    runnables.push({
+      id,
+      name: spec.name,
+      kind: "tool",
+      config
+    });
+    if (isRender) {
+      widgets.push({
+        tool_id: id,
+        uri,
+        ui_entry: options.uiEntry,
+        mime,
+        default_display_mode: displayMode
+      });
+    }
+  }
+  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.
+    hook_events: [],
+    composer_controls: [],
+    settings_tabs: [],
+    slash_commands: [],
+    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
+    // servers writes them in a hand-authored `manifest.json`.
+    lsp_servers: {},
+    // Same reason again: a danger-zone category, a Pi extension and an output
+    // style are all hand-authored declarations, not something derivable from
+    // runnables. An output style in particular points at a Markdown file next
+    // to the manifest, which this builder never writes.
+    data_categories: [],
+    pi_extensions: [],
+    output_styles: [],
+    message_actions: [],
+    widgets
+  };
+  const raw = {
+    id: options.id,
+    name: options.title,
+    version: options.version,
+    runnables,
+    // An app that synthesises widgets MUST hold `widget:render`, so this
+    // builder declares it rather than leaving the author to discover it.
+    //
+    // Core gates widget promotion on declared-AND-enabled-AND-granted, and a
+    // missing grant fails as `DeniedNoGrant` — which is an `info!` log and
+    // nothing else. The widget silently renders as plain text, with no error
+    // in the UI and nothing pointing at the manifest. Every app scaffolded
+    // through `defineApp` hit that, because the only fix was a grant string
+    // the templates never mention and the builder never added; the one
+    // working example on disk hand-writes it.
+    //
+    // Added only when there is a widget to render, and unioned rather than
+    // overwritten so an author's own `grants` list survives and re-declaring
+    // it is not an error.
+    permission_grants: withWidgetRenderGrant(options.grants ?? [], widgets),
+    activation_events: options.activationEvents ?? ["*"],
+    contributes,
+    // `targets: []` means EVERY surface, so an app that declares none is
+    // unrestricted — the backward-compatible default.
+    targets: options.targets ?? [],
+    // `requires` stays ABSENT (not `{apps:[],grants:[]}`) when undeclared, so the
+    // emitted manifest carries no key at all — matching Core's
+    // `Option<Requires>` + `skip_serializing_if = "Option::is_none"`.
+    ...options.requires ? {
+      requires: {
+        apps: options.requires.apps ?? [],
+        capabilities: options.requires.capabilities ?? [],
+        grants: options.requires.grants ?? []
+      }
+    } : {}
+  };
+  const result = PluginManifestSchema.safeParse(raw);
+  if (!result.success) {
+    const first = result.error.issues[0];
+    const field = first?.path.join(".") ?? "unknown";
+    const message = first?.message ?? "validation failed";
+    throw new Error(
+      `manifest.json validation failed at '${field}': ${message}`
+    );
+  }
+  return result.data;
+}
+
+export {
+  appToolId,
+  defineApp
+};