@ryuhq/sdk 0.1.14 → 0.2.2

package/dist/mcp.cjs

@@ -0,0 +1,376 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/mcp/index.ts
+var mcp_exports = {};
+__export(mcp_exports, {
+  MCP_PROTOCOL_VERSION: () => MCP_PROTOCOL_VERSION,
+  McpServer: () => McpServer,
+  callTool: () => callTool,
+  listTools: () => listTools,
+  unwrapContent: () => unwrapContent
+});
+module.exports = __toCommonJS(mcp_exports);
+
+// 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 env = { ...process.env, ...cmd.env ?? {} };
+    const proc = (0, import_node_child_process.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 = (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 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();
+  }
+}
+
+// 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);
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MCP_PROTOCOL_VERSION,
+  McpServer,
+  callTool,
+  listTools,
+  unwrapContent
+});

package/dist/mcp.d.cts

@@ -0,0 +1,2 @@
+export { MCP_PROTOCOL_VERSION, McpStdioCommand, McpTool, callTool, listTools } from './mcp/client.cjs';
+export { JsonSchema, McpServer, PassthroughRegistration, SdkRunnable, unwrapContent } from './mcp/server.cjs';

package/dist/mcp.d.ts

@@ -0,0 +1,2 @@
+export { MCP_PROTOCOL_VERSION, McpStdioCommand, McpTool, callTool, listTools } from './mcp/client.js';
+export { JsonSchema, McpServer, PassthroughRegistration, SdkRunnable, unwrapContent } from './mcp/server.js';

package/dist/mcp.js

@@ -0,0 +1,17 @@
+import "./chunk-TXSHHZF2.js";
+import {
+  McpServer,
+  unwrapContent
+} from "./chunk-FZSFZOIN.js";
+import {
+  MCP_PROTOCOL_VERSION,
+  callTool,
+  listTools
+} from "./chunk-VLIRNNAE.js";
+export {
+  MCP_PROTOCOL_VERSION,
+  McpServer,
+  callTool,
+  listTools,
+  unwrapContent
+};

package/dist/model.cjs

@@ -0,0 +1,141 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/model/index.ts
+var model_exports = {};
+__export(model_exports, {
+  DEFAULT_GATEWAY_URL: () => DEFAULT_GATEWAY_URL,
+  ModelClient: () => ModelClient2,
+  assertAllowedEgressUrl: () => assertAllowedEgressUrl,
+  defineModel: () => defineModel,
+  resolveGatewayToken: () => resolveGatewayToken2,
+  resolveGatewayUrl: () => resolveGatewayUrl3
+});
+module.exports = __toCommonJS(model_exports);
+
+// src/model/client.ts
+var native = __toESM(require("@ryuhq/sdk-native"), 1);
+var ModelClient2 = class {
+  model;
+  baseUrl;
+  native;
+  constructor(model, options = {}) {
+    this.native = new native.ModelClient(
+      model,
+      options.baseUrl ?? null,
+      options.token ?? null
+    );
+    this.model = model;
+    this.baseUrl = options.baseUrl ?? native.resolveGatewayUrl();
+  }
+  /** Send a non-streaming chat completion request to the gateway. */
+  async chat(messages) {
+    const res = await this.native.chat(messages);
+    const usage = res.promptTokens === void 0 && res.completionTokens === void 0 && res.totalTokens === void 0 ? void 0 : {
+      promptTokens: res.promptTokens ?? 0,
+      completionTokens: res.completionTokens ?? 0,
+      totalTokens: res.totalTokens ?? 0
+    };
+    return {
+      content: res.content,
+      finishReason: res.finishReason ?? null,
+      usage
+    };
+  }
+  /** Send a streaming chat completion request, yielding deltas as they arrive. */
+  async *stream(messages) {
+    const queue = [];
+    let done = false;
+    let failure = null;
+    let wake = null;
+    const notify = () => {
+      if (wake) {
+        const w = wake;
+        wake = null;
+        w();
+      }
+    };
+    this.native.stream(messages, (err, delta) => {
+      if (err) {
+        failure = err;
+        done = true;
+      } else if (delta === null || delta === void 0) {
+        done = true;
+      } else {
+        queue.push({
+          content: delta.content ?? null,
+          finishReason: delta.finishReason ?? null
+        });
+      }
+      notify();
+    });
+    while (true) {
+      while (queue.length > 0) {
+        const next = queue.shift();
+        if (next) {
+          yield next;
+        }
+      }
+      if (failure) {
+        throw failure;
+      }
+      if (done) {
+        return;
+      }
+      await new Promise((resolve) => {
+        wake = resolve;
+      });
+    }
+  }
+};
+function defineModel(modelId, options = {}) {
+  return new ModelClient2(modelId, options);
+}
+
+// src/model/gateway.ts
+var native2 = __toESM(require("@ryuhq/sdk-native"), 1);
+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);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_GATEWAY_URL,
+  ModelClient,
+  assertAllowedEgressUrl,
+  defineModel,
+  resolveGatewayToken,
+  resolveGatewayUrl
+});

package/dist/model.d.cts

@@ -0,0 +1,33 @@
+export { C as ChatDelta, a as ChatMessage, b as ChatResult, M as ModelClient, c as ModelClientOptions, d as defineModel } from './client-D5U6ssPc.cjs';
+
+/**
+ * Gateway configuration + egress enforcement for the Ryu SDK model client.
+ *
+ * Rust-cored: every function here delegates to the `@ryuhq/sdk-native` addon, so
+ * the gateway URL/token resolution and the direct-provider egress blocklist are
+ * the exact same implementation (`crates/ryu-sdk/src/gateway.rs`) used by the
+ * Go/Python bindings and Core itself — one source of truth, no drift.
+ */
+/** Default base URL for the local Ryu gateway — matches Core's DEFAULT_GATEWAY_URL. */
+declare const DEFAULT_GATEWAY_URL = "http://127.0.0.1:7981";
+/**
+ * Resolve the effective gateway base URL.
+ *
+ * Resolution order (in the Rust core):
+ *   1. `RYU_GATEWAY_URL` env var (when non-empty).
+ *   2. `DEFAULT_GATEWAY_URL`.
+ */
+declare function resolveGatewayUrl(): string;
+/**
+ * Resolve the optional gateway bearer token (`RYU_GATEWAY_TOKEN`), or
+ * `undefined` when unset/empty.
+ */
+declare function resolveGatewayToken(): string | undefined;
+/**
+ * Validate that `baseUrl` is an allowed egress target. Throws a descriptive
+ * `Error` (from the Rust core) when the URL matches a known direct-provider
+ * pattern, enforcing the BYOK-at-the-gateway rule.
+ */
+declare function assertAllowedEgressUrl(baseUrl: string): void;
+
+export { DEFAULT_GATEWAY_URL, assertAllowedEgressUrl, resolveGatewayToken, resolveGatewayUrl };

package/dist/model.d.ts

@@ -0,0 +1,33 @@
+export { C as ChatDelta, a as ChatMessage, b as ChatResult, M as ModelClient, c as ModelClientOptions, d as defineModel } from './client-D5U6ssPc.js';
+
+/**
+ * Gateway configuration + egress enforcement for the Ryu SDK model client.
+ *
+ * Rust-cored: every function here delegates to the `@ryuhq/sdk-native` addon, so
+ * the gateway URL/token resolution and the direct-provider egress blocklist are
+ * the exact same implementation (`crates/ryu-sdk/src/gateway.rs`) used by the
+ * Go/Python bindings and Core itself — one source of truth, no drift.
+ */
+/** Default base URL for the local Ryu gateway — matches Core's DEFAULT_GATEWAY_URL. */
+declare const DEFAULT_GATEWAY_URL = "http://127.0.0.1:7981";
+/**
+ * Resolve the effective gateway base URL.
+ *
+ * Resolution order (in the Rust core):
+ *   1. `RYU_GATEWAY_URL` env var (when non-empty).
+ *   2. `DEFAULT_GATEWAY_URL`.
+ */
+declare function resolveGatewayUrl(): string;
+/**
+ * Resolve the optional gateway bearer token (`RYU_GATEWAY_TOKEN`), or
+ * `undefined` when unset/empty.
+ */
+declare function resolveGatewayToken(): string | undefined;
+/**
+ * Validate that `baseUrl` is an allowed egress target. Throws a descriptive
+ * `Error` (from the Rust core) when the URL matches a known direct-provider
+ * pattern, enforcing the BYOK-at-the-gateway rule.
+ */
+declare function assertAllowedEgressUrl(baseUrl: string): void;
+
+export { DEFAULT_GATEWAY_URL, assertAllowedEgressUrl, resolveGatewayToken, resolveGatewayUrl };

package/dist/model.js

@@ -0,0 +1,18 @@
+import {
+  ModelClient,
+  defineModel
+} from "./chunk-HACAGK65.js";
+import {
+  DEFAULT_GATEWAY_URL,
+  assertAllowedEgressUrl,
+  resolveGatewayToken,
+  resolveGatewayUrl
+} from "./chunk-IKEDLLFY.js";
+export {
+  DEFAULT_GATEWAY_URL,
+  ModelClient,
+  assertAllowedEgressUrl,
+  defineModel,
+  resolveGatewayToken,
+  resolveGatewayUrl
+};

package/dist/plugin.cjs

@@ -0,0 +1,46 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/plugin/ryu-plugin.ts
+var ryu_plugin_exports = {};
+__export(ryu_plugin_exports, {
+  definePlugin: () => definePlugin,
+  toDisposable: () => toDisposable
+});
+module.exports = __toCommonJS(ryu_plugin_exports);
+function toDisposable(teardown) {
+  let done = false;
+  return {
+    dispose() {
+      if (done) {
+        return;
+      }
+      done = true;
+      teardown();
+    }
+  };
+}
+function definePlugin(plugin) {
+  return plugin;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  definePlugin,
+  toDisposable
+});