@ryuhq/sdk 0.1.14 → 0.2.0

package/dist/chunk-IKEDLLFY.js

@@ -0,0 +1,19 @@
+// src/model/gateway.ts
+import * as native from "@ryuhq/sdk-native";
+var DEFAULT_GATEWAY_URL = "http://127.0.0.1:7981";
+function resolveGatewayUrl2() {
+  return native.resolveGatewayUrl();
+}
+function resolveGatewayToken2() {
+  return native.resolveGatewayToken() ?? void 0;
+}
+function assertAllowedEgressUrl(baseUrl) {
+  native.assertAllowedEgress(baseUrl);
+}
+
+export {
+  DEFAULT_GATEWAY_URL,
+  resolveGatewayUrl2 as resolveGatewayUrl,
+  resolveGatewayToken2 as resolveGatewayToken,
+  assertAllowedEgressUrl
+};

package/dist/chunk-IOLP5FFE.js

@@ -0,0 +1,354 @@
+import {
+  defineApp
+} from "./chunk-W3KPP4WN.js";
+import {
+  PluginManifestSchema,
+  RunnableMetaSchema
+} from "./chunk-IEUQ3CDG.js";
+
+// src/builder.ts
+var RunnableBuilder = class {
+  _id = "";
+  _name = "";
+  id(value) {
+    this._id = value;
+    return this;
+  }
+  name(value) {
+    this._name = value;
+    return this;
+  }
+};
+var AgentBuilder = class extends RunnableBuilder {
+  build() {
+    const result = RunnableMetaSchema.safeParse({
+      id: this._id,
+      name: this._name,
+      kind: "agent"
+    });
+    if (!result.success) {
+      throw new Error(
+        `Invalid agent runnable: ${result.error.issues.map((i) => i.message).join("; ")}`
+      );
+    }
+    return result.data;
+  }
+};
+var WorkflowBuilder = class extends RunnableBuilder {
+  build() {
+    const result = RunnableMetaSchema.safeParse({
+      id: this._id,
+      name: this._name,
+      kind: "workflow"
+    });
+    if (!result.success) {
+      throw new Error(
+        `Invalid workflow runnable: ${result.error.issues.map((i) => i.message).join("; ")}`
+      );
+    }
+    return result.data;
+  }
+};
+var ToolBuilder = class extends RunnableBuilder {
+  build() {
+    const result = RunnableMetaSchema.safeParse({
+      id: this._id,
+      name: this._name,
+      kind: "tool"
+    });
+    if (!result.success) {
+      throw new Error(
+        `Invalid tool runnable: ${result.error.issues.map((i) => i.message).join("; ")}`
+      );
+    }
+    return result.data;
+  }
+};
+var SkillBuilder = class extends RunnableBuilder {
+  build() {
+    const result = RunnableMetaSchema.safeParse({
+      id: this._id,
+      name: this._name,
+      kind: "skill"
+    });
+    if (!result.success) {
+      throw new Error(
+        `Invalid skill runnable: ${result.error.issues.map((i) => i.message).join("; ")}`
+      );
+    }
+    return result.data;
+  }
+};
+var agent = () => new AgentBuilder();
+var workflow = () => new WorkflowBuilder();
+var tool = () => new ToolBuilder();
+var skill = () => new SkillBuilder();
+var PluginBuilder = class {
+  _id = "";
+  _name = "";
+  _version = "";
+  _runnables = [];
+  _grants = [];
+  _companion = void 0;
+  _dependencies = [];
+  _requiredCapabilities = [];
+  _requiredGrants = [];
+  _targets = [];
+  /** Set the reverse-domain app id (e.g. `"com.example.my-app"`). */
+  id(value) {
+    this._id = value;
+    return this;
+  }
+  /** Set the human-readable display name. */
+  name(value) {
+    this._name = value;
+    return this;
+  }
+  /** Set the semver version string (e.g. `"1.0.0"`). */
+  version(value) {
+    this._version = value;
+    return this;
+  }
+  /** Append a pre-built `RunnableMeta` (from any per-kind builder). */
+  runnable(meta) {
+    this._runnables.push(meta);
+    return this;
+  }
+  /** Declare a permission grant (e.g. `"mcp:web_search"`). */
+  grant(permission) {
+    this._grants.push(permission);
+    return this;
+  }
+  /** Set an optional Companion surface descriptor. */
+  companion(surface) {
+    this._companion = surface;
+    return this;
+  }
+  /**
+   * Declare a **plugin-to-plugin dependency**: `id` must be installed and is
+   * auto-enabled (in dependency order) before this plugin enables.
+   *
+   * `minVersion` is a MINIMUM — a bare `"1.2.0"` means `">=1.2.0"`, so an
+   * installed `2.0.0` satisfies it (comparator syntax like `">=1.2, <2"` is
+   * honoured verbatim).
+   */
+  dependsOn(id, minVersion) {
+    this._dependencies.push(
+      minVersion ? { id, min_version: minVersion } : { id }
+    );
+    return this;
+  }
+  /**
+   * Declare a permission grant implied by this plugin's dependencies
+   * (`requires.grants`). Declaration only — the Gateway remains the sole
+   * authority on what a grant allows. Use {@link PluginBuilder.grant} for the
+   * grants this plugin needs in its own right.
+   */
+  requiredGrant(permission) {
+    this._requiredGrants.push(permission);
+    return this;
+  }
+  /**
+   * Declare an abstract **capability** edge (`requires.capabilities`) the broker
+   * resolves to a bound provider at enable time — e.g. `requiresCapability("rag")`.
+   * Distinct from a specific-plugin dependency: a capability edge lets the
+   * binding registry choose the provider. `minVersion` is a MINIMUM (`"1.2.0"`
+   * = `">=1.2.0"`).
+   */
+  requiresCapability(capability, minVersion) {
+    this._requiredCapabilities.push(
+      minVersion ? { capability, min_version: minVersion } : { capability }
+    );
+    return this;
+  }
+  /**
+   * Restrict this plugin to a host surface (`"desktop"`, `"island"`, …).
+   * Declaring NO target is the default and means **every** surface.
+   */
+  target(surface) {
+    this._targets.push(surface);
+    return this;
+  }
+  /**
+   * Validate and return the assembled `PluginManifest`. Throws an `Error` with
+   * the failing field name and message when validation fails.
+   */
+  build() {
+    const hasRequires = this._dependencies.length > 0 || this._requiredCapabilities.length > 0 || this._requiredGrants.length > 0;
+    const raw = {
+      id: this._id,
+      name: this._name,
+      version: this._version,
+      runnables: this._runnables,
+      permission_grants: this._grants,
+      companion: this._companion,
+      targets: this._targets,
+      ...hasRequires ? {
+        requires: {
+          apps: this._dependencies,
+          capabilities: this._requiredCapabilities,
+          grants: this._requiredGrants
+        }
+      } : {}
+    };
+    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;
+  }
+};
+var AppBuilder = class {
+  _id = "";
+  _title = "";
+  _version = "";
+  _slug = "";
+  _server = void 0;
+  _displayMode = void 0;
+  _mime = void 0;
+  _uiEntry = "";
+  _grants = [];
+  _activationEvents = [];
+  _tools = [];
+  _dependencies = [];
+  _requiredCapabilities = [];
+  _requiredGrants = [];
+  _targets = [];
+  /** Set the reverse-domain app id (e.g. `"com.example.checklist"`). */
+  id(value) {
+    this._id = value;
+    return this;
+  }
+  /** Set the human-readable display name. */
+  title(value) {
+    this._title = value;
+    return this;
+  }
+  /** Set the semver version string (e.g. `"1.0.0"`). */
+  version(value) {
+    this._version = value;
+    return this;
+  }
+  /** Set the app slug (drives `ui://widget/<slug>.html` and the server default). */
+  slug(value) {
+    this._slug = value;
+    return this;
+  }
+  /** Override the MCP server namespace for tool ids (defaults to the slug). */
+  server(value) {
+    this._server = value;
+    return this;
+  }
+  /** Set the default widget display mode (`inline` | `fullscreen` | `pip`). */
+  displayMode(value) {
+    this._displayMode = value;
+    return this;
+  }
+  /** Override the widget MIME dialect (defaults to `text/html+skybridge`). */
+  mime(value) {
+    this._mime = value;
+    return this;
+  }
+  /** Set the widget UI source entry `ryu pack` bundles into `ui_code`. */
+  uiEntry(value) {
+    this._uiEntry = value;
+    return this;
+  }
+  /** Declare a permission grant (e.g. `"mcp:web_search"`). */
+  grant(permission) {
+    this._grants.push(permission);
+    return this;
+  }
+  /** Add a VS-Code-style activation event (empty = eager `["*"]`). */
+  activationEvent(event) {
+    this._activationEvents.push(event);
+    return this;
+  }
+  /** Append a tool spec (render tool unless `accessible:true`). */
+  tool(spec) {
+    this._tools.push(spec);
+    return this;
+  }
+  /**
+   * Declare a **plugin-to-plugin dependency** (auto-enabled, in dependency order,
+   * before this app). `minVersion` is a MINIMUM (`"1.2.0"` = `">=1.2.0"`).
+   */
+  dependsOn(id, minVersion) {
+    this._dependencies.push(
+      minVersion ? { id, min_version: minVersion } : { id }
+    );
+    return this;
+  }
+  /** Declare a grant implied by this app's dependencies (`requires.grants`). */
+  requiredGrant(permission) {
+    this._requiredGrants.push(permission);
+    return this;
+  }
+  /**
+   * Declare an abstract **capability** edge (`requires.capabilities`) the broker
+   * resolves to a bound provider at enable time — e.g. `requiresCapability("rag")`.
+   * Distinct from a specific-plugin dependency: a capability edge lets the
+   * binding registry choose the provider. `minVersion` is a MINIMUM (`"1.2.0"`
+   * = `">=1.2.0"`).
+   */
+  requiresCapability(capability, minVersion) {
+    this._requiredCapabilities.push(
+      minVersion ? { capability, min_version: minVersion } : { capability }
+    );
+    return this;
+  }
+  /** Restrict this app to a host surface. No target = every surface. */
+  target(surface) {
+    this._targets.push(surface);
+    return this;
+  }
+  /**
+   * Validate and return the assembled `PluginManifest`. Throws an `Error` naming
+   * the failing field when validation fails.
+   */
+  build() {
+    const hasRequires = this._dependencies.length > 0 || this._requiredCapabilities.length > 0 || this._requiredGrants.length > 0;
+    const options = {
+      id: this._id,
+      title: this._title,
+      version: this._version,
+      slug: this._slug,
+      uiEntry: this._uiEntry,
+      tools: this._tools,
+      grants: this._grants,
+      ...this._server ? { server: this._server } : {},
+      ...this._displayMode ? { displayMode: this._displayMode } : {},
+      ...this._mime ? { mime: this._mime } : {},
+      ...this._activationEvents.length > 0 ? { activationEvents: this._activationEvents } : {},
+      ...hasRequires ? {
+        requires: {
+          apps: this._dependencies,
+          capabilities: this._requiredCapabilities,
+          grants: this._requiredGrants
+        }
+      } : {},
+      ...this._targets.length > 0 ? { targets: this._targets } : {}
+    };
+    return defineApp(options);
+  }
+};
+var app = () => new AppBuilder();
+
+export {
+  AgentBuilder,
+  WorkflowBuilder,
+  ToolBuilder,
+  SkillBuilder,
+  agent,
+  workflow,
+  tool,
+  skill,
+  PluginBuilder,
+  AppBuilder,
+  app
+};

package/dist/{chunk-G6FLVEC4.js → chunk-JX6DDRXV.js}

@@ -74,6 +74,21 @@ function toSpecEnv(value) {
   }
   return Object.keys(env).length > 0 ? env : void 0;
 }
+function validateRemoteUrl(name, raw) {
+  let parsed;
+  try {
+    parsed = new URL(raw);
+  } catch {
+    return `mcp server '${name}' remote url ${JSON.stringify(raw)} is invalid and was omitted`;
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    return `mcp server '${name}' remote url must use http or https and was omitted`;
+  }
+  if (parsed.username || parsed.password || parsed.hash) {
+    return `mcp server '${name}' remote url must not contain credentials or a fragment and was omitted`;
+  }
+  return void 0;
+}
 function toSpecServer(name, decl) {
   const extras = {};
   const commandEnv = asString(decl.command_env);
@@ -91,6 +106,37 @@ function toSpecServer(name, decl) {
       note: `mcp server '${name}' is disabled in the native manifest and was omitted from ${AGENT_PLUGIN_MCP_FILE}`
     };
   }
+  const declaredType = asString(decl.type);
+  const remoteUrl = asString(decl.url);
+  const remoteType = declaredType === "sse" ? "sse" : declaredType === "streamable-http" || declaredType === "streamable_http" || declaredType === "http" || !declaredType && remoteUrl ? "streamable-http" : void 0;
+  if (remoteType) {
+    if (!remoteUrl) {
+      return {
+        extras,
+        note: `mcp server '${name}' has remote type '${remoteType}' but no url and was omitted`
+      };
+    }
+    const urlNote = validateRemoteUrl(name, remoteUrl);
+    if (urlNote) {
+      return { extras, note: urlNote };
+    }
+    const server2 = {
+      type: remoteType,
+      url: remoteUrl
+    };
+    const headers = toSpecEnv(decl.headers);
+    if (headers) {
+      server2.headers = headers;
+    }
+    const note = decl.auth ? `mcp server '${name}' uses Ryu OAuth metadata that is not portable; static headers were exported` : void 0;
+    return { server: server2, extras, note };
+  }
+  if (declaredType && declaredType !== "stdio") {
+    return {
+      extras,
+      note: `mcp server '${name}' has unsupported transport '${declaredType}' and was omitted`
+    };
+  }
   const command = asString(decl.command);
   if (!command) {
     return {

package/dist/chunk-T5676WL2.js

@@ -0,0 +1,240 @@
+import {
+  PluginManifestSchema
+} from "./chunk-IEUQ3CDG.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/tool.ts
+function validateInput(input, schema, toolId) {
+  if (typeof input !== "object" || input === null || Array.isArray(input)) {
+    throw new Error(
+      `[ryu-sdk] Tool "${toolId}" input must be an object, got ${JSON.stringify(input)}`
+    );
+  }
+  const record = input;
+  for (const requiredKey of schema.required ?? []) {
+    if (!(requiredKey in record)) {
+      throw new Error(
+        `[ryu-sdk] Tool "${toolId}" input missing required field "${requiredKey}"`
+      );
+    }
+  }
+  for (const [key, prop] of Object.entries(schema.properties)) {
+    if (!(key in record)) {
+      continue;
+    }
+    const value = record[key];
+    if (!checkType(value, prop.type)) {
+      throw new Error(
+        `[ryu-sdk] Tool "${toolId}" input field "${key}" expected type "${prop.type}", got ${JSON.stringify(value)}`
+      );
+    }
+  }
+}
+function checkType(value, type) {
+  switch (type) {
+    case "string":
+      return typeof value === "string";
+    case "number":
+    case "integer":
+      return typeof value === "number";
+    case "boolean":
+      return typeof value === "boolean";
+    case "array":
+      return Array.isArray(value);
+    case "object":
+      return typeof value === "object" && value !== null && !Array.isArray(value);
+    default:
+      return false;
+  }
+}
+function defineTool(options) {
+  const { id, name, schema, run } = options;
+  const code = `return await (${run.toString()})(input, host);`;
+  return {
+    id,
+    name,
+    kind: "tool",
+    schema,
+    code,
+    run(input, ctx) {
+      validateInput(input, schema, id);
+      return run(input, ctx);
+    }
+  };
+}
+function inlineToolRunnable(tool, options) {
+  return {
+    id: tool.id,
+    name: tool.name,
+    kind: "tool",
+    config: {
+      slug: tool.id,
+      backend: "inline_deno",
+      code: tool.code,
+      input_schema: tool.schema,
+      ...options?.description ? { description: options.description } : {}
+    }
+  };
+}
+
+// src/runnable/workflow.ts
+function defineWorkflow(options) {
+  const { id, name, run } = options;
+  return {
+    id,
+    name,
+    kind: "workflow",
+    run
+  };
+}
+
+export {
+  defineAgent,
+  defineSkill,
+  defineTool,
+  inlineToolRunnable,
+  defineWorkflow
+};

package/dist/chunk-TLDPEGC7.js

@@ -0,0 +1,21 @@
+// src/plugin/ryu-plugin.ts
+function toDisposable(teardown) {
+  let done = false;
+  return {
+    dispose() {
+      if (done) {
+        return;
+      }
+      done = true;
+      teardown();
+    }
+  };
+}
+function definePlugin(plugin) {
+  return plugin;
+}
+
+export {
+  toDisposable,
+  definePlugin
+};