@ryuhq/sdk 0.1.13 → 0.2.0

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

package/dist/plugin.d.cts

@@ -0,0 +1,215 @@
+/** A handle that undoes a registration. Idempotent: calling `dispose()` twice is
+ *  a no-op. */
+interface Disposable {
+    dispose(): void;
+}
+/** Build a {@link Disposable} from a teardown function. */
+declare function toDisposable(teardown: () => void): Disposable;
+/** A tab/route a plugin adds. `path` is matched against `tab.path` (exact match
+ *  unless `pattern` is set). The host loads `webview.entry` in a sandboxed
+ *  surface as the tab body.
+ *
+ *  Note: the OSS contract is declarative + sandboxed-webview only. A trusted,
+ *  in-process React component is a desktop-host capability (the host's registry
+ *  accepts a `(tab) => ReactNode` render-fn for BUILT-INS and first-party bundled
+ *  plugins); it is intentionally absent from this framework-agnostic contract. */
+interface RouteContribution {
+    /** Exact path (e.g. "/my-plugin") or, with `pattern: true`, a RegExp source
+     *  string matched against the full path (e.g. "^/my-plugin/[^/]+$"). */
+    path: string;
+    /** Treat `path` as a RegExp source string rather than an exact match. */
+    pattern?: boolean;
+    /** Human title (tab label, command-palette entry). */
+    title: string;
+    /** Load plugin UI in a SANDBOXED webview with NO Tauri IPC; the plugin reaches
+     *  capabilities only over the host RPC bridge. */
+    webview: {
+        entry: string;
+    };
+}
+/** A named mount region a panel can target. Generalizes the desktop's existing
+ *  per-section slots (sidebar sections, settings tabs, the chat side-panel, the
+ *  companion overlay) into declared contribution points. */
+type PanelRegion = "sidebar-section" | "settings-tab" | "chat-side-panel" | "companion-overlay";
+interface PanelContribution {
+    /** Stable id within the region (also the host's key). */
+    id: string;
+    region: PanelRegion;
+    title: string;
+    webview: {
+        entry: string;
+    };
+}
+/** A command-palette entry. Shaped to map 1:1 onto the desktop's
+ *  `CommandAction` (from `@ryu/command/types`) so a contributed command lands in
+ *  the same palette as built-ins with no shim. */
+interface CommandContribution {
+    /** Group heading in the palette. Defaults to the plugin's display name. */
+    group?: string;
+    id: string;
+    /** Extra fuzzy-search terms. */
+    keywords?: string;
+    /** The side effect. Runs in the host; for sandboxed plugins it is an RPC. */
+    run(): void | Promise<void>;
+    /** Right-aligned keyboard hint (e.g. "⌘⇧P"). */
+    shortcut?: string;
+    title: string;
+}
+interface SettingsSectionContribution {
+    id: string;
+    title: string;
+    webview: {
+        entry: string;
+    };
+}
+/** A section in the unified Store/marketplace surface. */
+interface StoreSectionContribution {
+    id: string;
+    title: string;
+    webview: {
+        entry: string;
+    };
+}
+/** A theme a plugin contributes (CSS custom-property overrides keyed by token). */
+interface ThemeContribution {
+    id: string;
+    name: string;
+    tokens: Record<string, string>;
+}
+/** The host-service surface a plugin calls back into. Each method is mediated by
+ *  the host and grant-gated by the manifest (#443). For a sandboxed plugin these
+ *  are RPCs over the postMessage bridge; the plugin never holds a Core token or
+ *  Tauri IPC handle directly. */
+interface RyuHostServices {
+    /** Read and cooperatively stop Core-visible background processes. */
+    background: {
+        list(input?: {
+            producer?: string;
+            running_only?: boolean;
+        }): Promise<{
+            process_id: string;
+            command: string;
+            cwd: string;
+            elapsed_ms: number;
+            running: boolean;
+            [key: string]: unknown;
+        }[]>;
+        stop(input: {
+            process_id: string;
+        }): Promise<{
+            ok: boolean;
+            requested: boolean;
+            process_id: string;
+        }>;
+    };
+    /** Read-only feature discovery. Older hosts may omit this method; treat that
+     * as an empty capability set rather than assuming a native surface exists. */
+    capabilities?(): Promise<RyuHostCapabilities>;
+    /** Run a registered command by id (built-in or contributed). */
+    commands: {
+        execute(id: string, ...args: unknown[]): Promise<unknown>;
+    };
+    /** Gateway-governed model access (chat/embed). Mirrors `@ryuhq/sdk` model
+     *  client semantics; every call still routes through the Gateway. */
+    gateway: {
+        chat(model: string, messages: {
+            role: string;
+            content: string;
+        }[]): Promise<string>;
+    };
+    /** List the agents on the active node, PROJECTED to `{id,name}` only. The host
+     *  holds the Core token and performs the fetch; the plugin never sees a token
+     *  or any other agent field (invariant: no capability returns a secret). Gated
+     *  by the `core:list_agents` grant. */
+    listAgents(): Promise<{
+        id: string;
+        name: string;
+    }[]>;
+    /** Mobile-native effects. These methods remain optional at the type boundary
+     * because desktop, web, extension, and terminal hosts fail closed. */
+    native?: {
+        haptics(input: RyuNativeHapticsInput): Promise<RyuNativeHapticsResult>;
+        notifications: {
+            create(input: RyuNativeNotificationInput): Promise<RyuNativeNotificationResult>;
+        };
+        liveActivities: {
+            update(input: RyuNativeLiveActivityInput): Promise<RyuNativeLiveActivityResult>;
+        };
+    };
+    /** Open a tab at a path (built-in or a route this plugin contributed). */
+    openTab(path: string): void;
+    /** Read/write the plugin's own Spaces docs (scoped by grant). */
+    spaces: {
+        ingestDocument(spaceId: string, title: string, markdown: string): Promise<{
+            docId: string;
+        }>;
+    };
+}
+/** The token-free, read-only native feature inventory returned by a host. */
+interface RyuHostCapabilities {
+    androidOngoingNotifications: boolean;
+    browserNotifications: boolean;
+    dynamicIsland: boolean;
+    haptics: boolean;
+    hardwareBleRelay: boolean;
+    liveActivities: boolean;
+    localNotifications: boolean;
+    platform: "android" | "browser" | "ios" | "unknown";
+    pushRegistration: boolean;
+    quickActions: boolean;
+    sounds: boolean;
+}
+type RyuNativeHapticStyle = "light" | "success" | "warning" | "error";
+interface RyuNativeHapticsInput {
+    style: RyuNativeHapticStyle;
+}
+interface RyuNativeNotificationInput {
+    body: string;
+    title: string;
+}
+interface RyuNativeLiveActivityInput {
+    conversationId: string;
+    detail: string;
+    status: "running" | "waiting" | "review" | "done" | "error";
+    title: string;
+}
+interface RyuNativeHapticsResult {
+    signaled: true;
+}
+interface RyuNativeNotificationResult {
+    id: string;
+    scheduled: true;
+}
+interface RyuNativeLiveActivityResult {
+    updated: true;
+}
+/** Everything a plugin can contribute. Each `register*` returns a
+ *  {@link Disposable}; collect them in {@link PluginContext.subscriptions}. */
+interface RyuPlugin {
+    /** Host services the plugin calls back into (grant-gated). */
+    readonly host: RyuHostServices;
+    registerCommand(contribution: CommandContribution): Disposable;
+    registerPanel(contribution: PanelContribution): Disposable;
+    registerRoute(contribution: RouteContribution): Disposable;
+    registerSettingsSection(contribution: SettingsSectionContribution): Disposable;
+    registerStoreSection(contribution: StoreSectionContribution): Disposable;
+    registerTheme(contribution: ThemeContribution): Disposable;
+}
+/** Passed to `activate(context)`. The plugin pushes its disposables onto
+ *  `subscriptions`; the host disposes them all on `deactivate`. */
+interface PluginContext {
+    readonly plugin: RyuPlugin;
+    /** The plugin's own id (from `manifest.json`). */
+    readonly pluginId: string;
+    /** Disposables auto-cleaned on deactivate. */
+    readonly subscriptions: Disposable[];
+}
+/** The shape the host expects a plugin's entry module to export. */
+interface RyuPluginModule {
+    activate(context: PluginContext): void | Promise<void>;
+    deactivate?(): void | Promise<void>;
+}
+/** Identity helper for authoring a typed plugin module (no runtime behavior). */
+declare function definePlugin(plugin: RyuPluginModule): RyuPluginModule;
+
+export { type CommandContribution, type Disposable, type PanelContribution, type PanelRegion, type PluginContext, type RouteContribution, type RyuHostCapabilities, type RyuHostServices, type RyuNativeHapticStyle, type RyuNativeHapticsInput, type RyuNativeHapticsResult, type RyuNativeLiveActivityInput, type RyuNativeLiveActivityResult, type RyuNativeNotificationInput, type RyuNativeNotificationResult, type RyuPlugin, type RyuPluginModule, type SettingsSectionContribution, type StoreSectionContribution, type ThemeContribution, definePlugin, toDisposable };