@ryuhq/sdk 0.1.14 → 0.2.2

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-MTUBUPIV.js → chunk-Z57QDDJR.js}

@@ -1,231 +1,15 @@
+import {
+  createPrimitives,
+  httpPrimitiveTransport
+} from "./chunk-ZTJWBRUL.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-ZTJWBRUL.js

@@ -0,0 +1,282 @@
+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"
+  },
+  "storage.get": {
+    transport: "bridge",
+    method: "storage.get",
+    grant: "storage:kv"
+  },
+  "storage.set": {
+    transport: "bridge",
+    method: "storage.set",
+    grant: "storage:kv"
+  },
+  "storage.delete": {
+    transport: "bridge",
+    method: "storage.delete",
+    grant: "storage:kv"
+  },
+  "storage.keys": {
+    transport: "bridge",
+    method: "storage.keys",
+    grant: "storage:kv"
+  },
+  "storage.compareAndSet": {
+    transport: "bridge",
+    method: "storage.compareAndSet",
+    grant: "storage:kv"
+  },
+  // 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
+      })
+    },
+    storage: {
+      get: (input) => transport.bridge("storage.get", input),
+      set: (input) => transport.bridge("storage.set", input).then(() => void 0),
+      delete: (input) => transport.bridge("storage.delete", input).then(() => void 0),
+      keys: (input) => transport.bridge("storage.keys", input ?? {}).then((value) => Array.isArray(value) ? value : []),
+      compareAndSet: (input) => transport.bridge("storage.compareAndSet", input)
+    },
+    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
+};