@ryuhq/sdk 0.1.14 → 0.2.2

package/dist/chunk-BC3A7HMO.js

@@ -0,0 +1,164 @@
+import {
+  PluginManifestSchema
+} from "./chunk-NZKVOSC2.js";
+
+// src/runnable/agent.ts
+var CAPABILITY_SLOTS = ["rag", "memory", "tts", "stt"];
+function lowerChatSlot(chat) {
+  if (chat === void 0) {
+    return {};
+  }
+  if (typeof chat === "string") {
+    return { model: chat };
+  }
+  return {
+    model: chat.model,
+    engine: chat.engine,
+    persona: chat.persona,
+    modelPrefKey: chat.modelPrefKey
+  };
+}
+function lowerCapabilitySlot(capability, slot, card) {
+  if (slot === void 0 || slot === false) {
+    return;
+  }
+  if (slot === true) {
+    card.capabilities.push({ capability });
+    return;
+  }
+  if (typeof slot === "string") {
+    card.capabilities.push({ capability });
+    card.providers[capability] = slot;
+    return;
+  }
+  card.capabilities.push(
+    slot.minVersion ? { capability, min_version: slot.minVersion } : { capability }
+  );
+  if (slot.provider) {
+    card.providers[capability] = slot.provider;
+  }
+}
+function lowerSlots(options) {
+  const card = {
+    ...lowerChatSlot(options.chat),
+    capabilities: [],
+    providers: {},
+    tools: []
+  };
+  for (const capability of CAPABILITY_SLOTS) {
+    lowerCapabilitySlot(capability, options[capability], card);
+  }
+  for (const t of options.tools ?? []) {
+    card.tools.push(typeof t === "string" ? t : t.id);
+  }
+  return card;
+}
+function defaultRun(card) {
+  return async (input, ctx) => {
+    const content = typeof input === "string" ? input : JSON.stringify(input ?? "");
+    const messages = card.persona ? [
+      { role: "system", content: card.persona },
+      { role: "user", content }
+    ] : [{ role: "user", content }];
+    const result = await ctx.gateway.chat(messages);
+    return result.content;
+  };
+}
+function cardConfig(card) {
+  const config = {};
+  if (card.model) {
+    config.model = card.model;
+  }
+  if (card.engine) {
+    config.engine = card.engine;
+  }
+  if (card.persona) {
+    config.persona = card.persona;
+  }
+  if (card.modelPrefKey) {
+    config.model_pref_key = card.modelPrefKey;
+  }
+  if (Object.keys(card.providers).length > 0) {
+    config.capability_providers = card.providers;
+  }
+  if (card.tools.length > 0) {
+    config.tools = card.tools;
+  }
+  return config;
+}
+function agentToManifest(agent, options) {
+  const config = cardConfig(agent.card);
+  const meta = {
+    id: agent.id,
+    name: agent.name,
+    kind: "agent",
+    ...Object.keys(config).length > 0 ? { config } : {}
+  };
+  const hasRequires = agent.card.capabilities.length > 0 || (options.grants?.length ?? 0) > 0;
+  const raw = {
+    id: options.id,
+    name: options.name ?? agent.name,
+    version: options.version,
+    runnables: [meta],
+    ...hasRequires ? {
+      requires: {
+        apps: [],
+        capabilities: agent.card.capabilities,
+        grants: options.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(
+      `agent manifest validation failed at '${field}': ${message}`
+    );
+  }
+  return result.data;
+}
+function defineAgent(options) {
+  const { id, name } = options;
+  const card = lowerSlots(options);
+  const run = options.run ?? defaultRun(card);
+  return {
+    id,
+    name,
+    kind: "agent",
+    run,
+    card,
+    toManifest(manifestOptions) {
+      return agentToManifest(this, manifestOptions);
+    }
+  };
+}
+
+// src/runnable/skill.ts
+function defineSkill(options) {
+  const { id, name, run } = options;
+  return {
+    id,
+    name,
+    kind: "skill",
+    run
+  };
+}
+
+// src/runnable/workflow.ts
+function defineWorkflow(options) {
+  const { id, name, run } = options;
+  return {
+    id,
+    name,
+    kind: "workflow",
+    run
+  };
+}
+
+export {
+  defineAgent,
+  defineSkill,
+  defineWorkflow
+};

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
 };