@ryuhq/sdk 0.2.0 → 0.2.2

package/dist/action.d.cts

@@ -0,0 +1,88 @@
+import { Surface, PluginManifest } from './manifest.cjs';
+import { SdkRunnable } from './mcp/server.cjs';
+import { k as RunnableContext, o as ToolSchema, T as ToolRunnable } from './tool-CgzW92O_.cjs';
+import 'zod';
+import './mcp/client.cjs';
+import './client-D5U6ssPc.cjs';
+
+/**
+ * Canonical Ryu Action authoring API.
+ *
+ * An Action is the semantic contract for a business operation: one description,
+ * input schema, output schema, implementation, and effect declaration. It lowers
+ * to Ryu's existing governed `inline_deno` Tool backend, so this adds a coherent
+ * authoring seam without introducing a second Core execution runtime.
+ */
+
+/** The two effects Core can enforce from tool annotations. */
+type ActionEffect = "mutate" | "read";
+/** MCP-compatible effect hints plus any future provider-neutral boolean hints. */
+interface ActionAnnotations {
+    destructiveHint?: boolean;
+    idempotentHint?: boolean;
+    openWorldHint?: boolean;
+    readOnlyHint?: boolean;
+    [key: string]: boolean | undefined;
+}
+/** Options for defining a canonical Action. */
+interface ActionOptions<TInput extends Record<string, unknown>, TOutput> {
+    /** Additional MCP-compatible effect hints. */
+    annotations?: ActionAnnotations;
+    /** Description the agent reads when deciding whether to call the action. */
+    description: string;
+    /** Explicit effect used by read-only and approval enforcement. */
+    effect: ActionEffect;
+    /** Stable action id, also used as the generated Core tool slug. */
+    id: string;
+    /** Human-readable action name. */
+    name: string;
+    /** Require human approval even when global smart mode would not classify it. */
+    needsApproval?: boolean;
+    /** JSON Schema for the structured action result. */
+    outputSchema?: Record<string, unknown>;
+    /** The one implementation used by local callers and the packaged tool body. */
+    run(input: TInput, ctx: RunnableContext): Promise<TOutput>;
+    /** JSON Schema for all action inputs. */
+    schema: ToolSchema;
+}
+/** Options for lowering one Action into a standalone Ryu plugin manifest. */
+interface ActionManifestOptions {
+    /** Plugin activation events; defaults to eager activation. */
+    activationEvents?: readonly string[];
+    /** Extra Gateway grants required by the action body. */
+    grants?: readonly string[];
+    /** Reverse-domain plugin id (for example `com.acme.support`). */
+    id: string;
+    /** Display name; defaults to the Action name. */
+    name?: string;
+    /** Host surfaces this plugin targets. */
+    targets?: readonly Surface[];
+    /** Plugin semver. */
+    version: string;
+}
+/** A ToolRunnable with Action semantics and manifest/MCP adapters. */
+interface ActionRunnable<TInput extends Record<string, unknown> = Record<string, unknown>, TOutput = unknown> extends ToolRunnable<TInput, TOutput> {
+    /** Discriminates this semantic contract from an ordinary ToolRunnable. */
+    readonly action: true;
+    /** Effect hints lowered into Core's existing tool metadata. */
+    readonly annotations: ActionAnnotations;
+    /** Required action description. */
+    readonly description: string;
+    /** Declared effect. */
+    readonly effect: ActionEffect;
+    /** Whether Core must queue approval before execution. */
+    readonly needsApproval: boolean;
+    /** Structured result schema, when the action returns one. */
+    readonly outputSchema?: Record<string, unknown>;
+    /** Lower this Action to a validated, installable plugin manifest. */
+    toManifest(options: ActionManifestOptions): PluginManifest;
+    /** Adapt this Action to the SDK MCP server using the same implementation. */
+    toMcpTool(context: RunnableContext): SdkRunnable;
+}
+/**
+ * Define one business operation that can be run locally, packaged as a Core
+ * tool, or registered on an SDK MCP server without rewriting its implementation.
+ */
+declare function defineAction<TInput extends Record<string, unknown> = Record<string, unknown>, TOutput = unknown>(options: ActionOptions<TInput, TOutput>): ActionRunnable<TInput, TOutput>;
+
+export { type ActionAnnotations, type ActionEffect, type ActionManifestOptions, type ActionOptions, type ActionRunnable, defineAction };

package/dist/action.d.ts

@@ -0,0 +1,88 @@
+import { Surface, PluginManifest } from './manifest.js';
+import { SdkRunnable } from './mcp/server.js';
+import { k as RunnableContext, o as ToolSchema, T as ToolRunnable } from './tool-AjkdFvhE.js';
+import 'zod';
+import './mcp/client.js';
+import './client-D5U6ssPc.js';
+
+/**
+ * Canonical Ryu Action authoring API.
+ *
+ * An Action is the semantic contract for a business operation: one description,
+ * input schema, output schema, implementation, and effect declaration. It lowers
+ * to Ryu's existing governed `inline_deno` Tool backend, so this adds a coherent
+ * authoring seam without introducing a second Core execution runtime.
+ */
+
+/** The two effects Core can enforce from tool annotations. */
+type ActionEffect = "mutate" | "read";
+/** MCP-compatible effect hints plus any future provider-neutral boolean hints. */
+interface ActionAnnotations {
+    destructiveHint?: boolean;
+    idempotentHint?: boolean;
+    openWorldHint?: boolean;
+    readOnlyHint?: boolean;
+    [key: string]: boolean | undefined;
+}
+/** Options for defining a canonical Action. */
+interface ActionOptions<TInput extends Record<string, unknown>, TOutput> {
+    /** Additional MCP-compatible effect hints. */
+    annotations?: ActionAnnotations;
+    /** Description the agent reads when deciding whether to call the action. */
+    description: string;
+    /** Explicit effect used by read-only and approval enforcement. */
+    effect: ActionEffect;
+    /** Stable action id, also used as the generated Core tool slug. */
+    id: string;
+    /** Human-readable action name. */
+    name: string;
+    /** Require human approval even when global smart mode would not classify it. */
+    needsApproval?: boolean;
+    /** JSON Schema for the structured action result. */
+    outputSchema?: Record<string, unknown>;
+    /** The one implementation used by local callers and the packaged tool body. */
+    run(input: TInput, ctx: RunnableContext): Promise<TOutput>;
+    /** JSON Schema for all action inputs. */
+    schema: ToolSchema;
+}
+/** Options for lowering one Action into a standalone Ryu plugin manifest. */
+interface ActionManifestOptions {
+    /** Plugin activation events; defaults to eager activation. */
+    activationEvents?: readonly string[];
+    /** Extra Gateway grants required by the action body. */
+    grants?: readonly string[];
+    /** Reverse-domain plugin id (for example `com.acme.support`). */
+    id: string;
+    /** Display name; defaults to the Action name. */
+    name?: string;
+    /** Host surfaces this plugin targets. */
+    targets?: readonly Surface[];
+    /** Plugin semver. */
+    version: string;
+}
+/** A ToolRunnable with Action semantics and manifest/MCP adapters. */
+interface ActionRunnable<TInput extends Record<string, unknown> = Record<string, unknown>, TOutput = unknown> extends ToolRunnable<TInput, TOutput> {
+    /** Discriminates this semantic contract from an ordinary ToolRunnable. */
+    readonly action: true;
+    /** Effect hints lowered into Core's existing tool metadata. */
+    readonly annotations: ActionAnnotations;
+    /** Required action description. */
+    readonly description: string;
+    /** Declared effect. */
+    readonly effect: ActionEffect;
+    /** Whether Core must queue approval before execution. */
+    readonly needsApproval: boolean;
+    /** Structured result schema, when the action returns one. */
+    readonly outputSchema?: Record<string, unknown>;
+    /** Lower this Action to a validated, installable plugin manifest. */
+    toManifest(options: ActionManifestOptions): PluginManifest;
+    /** Adapt this Action to the SDK MCP server using the same implementation. */
+    toMcpTool(context: RunnableContext): SdkRunnable;
+}
+/**
+ * Define one business operation that can be run locally, packaged as a Core
+ * tool, or registered on an SDK MCP server without rewriting its implementation.
+ */
+declare function defineAction<TInput extends Record<string, unknown> = Record<string, unknown>, TOutput = unknown>(options: ActionOptions<TInput, TOutput>): ActionRunnable<TInput, TOutput>;
+
+export { type ActionAnnotations, type ActionEffect, type ActionManifestOptions, type ActionOptions, type ActionRunnable, defineAction };

package/dist/action.js

@@ -0,0 +1,8 @@
+import {
+  defineAction
+} from "./chunk-4TPUZDTI.js";
+import "./chunk-QYFUNJOH.js";
+import "./chunk-NZKVOSC2.js";
+export {
+  defineAction
+};

package/dist/agent-plugin.d.cts

@@ -29,7 +29,7 @@
  * is deliberately NOT a copy of the whole native manifest — that would be a second
  * source of truth with a stale-copy failure mode.
  *
- * Both `plugins-store/*` and `apps-store/*` use this one `PluginManifest` shape, so
+ * Both `plugins-store/{plugins,lsp,external_plugins}/*` and `apps-store/*` use this one `PluginManifest` shape, so
  * one converter covers both stores.
  */
 /** Agent Plugins spec version this module targets. */

package/dist/agent-plugin.d.ts

@@ -29,7 +29,7 @@
  * is deliberately NOT a copy of the whole native manifest — that would be a second
  * source of truth with a stale-copy failure mode.
  *
- * Both `plugins-store/*` and `apps-store/*` use this one `PluginManifest` shape, so
+ * Both `plugins-store/{plugins,lsp,external_plugins}/*` and `apps-store/*` use this one `PluginManifest` shape, so
  * one converter covers both stores.
  */
 /** Agent Plugins spec version this module targets. */

package/dist/agent.cjs

@@ -282,6 +282,13 @@ function createPrimitives(transport) {
         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),

package/dist/agent.d.cts

@@ -1,4 +1,4 @@
-import { T as ToolRunnable, j as RunnableContext } from './tool-u-VR0fLF.cjs';
+import { T as ToolRunnable, k as RunnableContext } from './tool-CgzW92O_.cjs';
 import './manifest.cjs';
 import 'zod';
 import './client-D5U6ssPc.cjs';

package/dist/agent.d.ts

@@ -1,4 +1,4 @@
-import { T as ToolRunnable, j as RunnableContext } from './tool-DSx2bFx8.js';
+import { T as ToolRunnable, k as RunnableContext } from './tool-AjkdFvhE.js';
 import './manifest.js';
 import 'zod';
 import './client-D5U6ssPc.js';

package/dist/agent.js

@@ -8,8 +8,8 @@ import {
   resolveToolDefs,
   runAgentLoop,
   ryuTool
-} from "./chunk-ULSVL7EC.js";
-import "./chunk-A3RGEPDG.js";
+} from "./chunk-Z57QDDJR.js";
+import "./chunk-ZTJWBRUL.js";
 import "./chunk-HACAGK65.js";
 import "./chunk-IKEDLLFY.js";
 export {

package/dist/{app-DNaGmLVf.d.cts → app-B0Z9Ew_R.d.cts}

@@ -1,4 +1,5 @@
-import { Requires, Surface, PluginManifest } from './manifest.cjs';
+import { Requires, SlashCommandContribution, Surface, PluginManifest } from './manifest.cjs';
+import { T as ToolRunnable } from './tool-CgzW92O_.cjs';
 
 /**
  * Ryu App authoring factory — `defineApp`.
@@ -16,11 +17,13 @@ import { Requires, Surface, PluginManifest } from './manifest.cjs';
  *   - A **companion** tool (`accessible:true`) is a call target a mounted widget
  *     may invoke: it carries `widget_accessible:true` and gets no widget template.
  *
- * v1 boundary: this is **declarative pass-through only** — there is no `run`
- * handler. Third-party tool code execution needs the plugin runtime (out of
- * scope); the widget renders from `window.openai.toolInput`/`toolOutput` and Core
- * echoes the validated arguments as `structuredContent`. `ryu pack` bundles the
- * `uiEntry` source into the manifest's `ui_code`.
+ * A tool may also attach a `ToolRunnable`. When present, its self-contained run
+ * body is emitted as Core's grant-gated `inline_deno` backend, so the widget and
+ * the behavior ship in one bundle. Without a runnable, the tool remains the
+ * declarative pass-through form: the widget renders from
+ * `window.openai.toolInput`/`toolOutput` and Core echoes the validated arguments
+ * as `structuredContent`. `ryu pack` bundles the `uiEntry` source into the
+ * manifest's `ui_code`.
  */
 
 /** One tool a Ryu App declares. */
@@ -40,6 +43,13 @@ interface AppToolSpec {
     invoking?: string;
     /** Tool name (unqualified). The wire id is `<server>.<name>`. */
     name: string;
+    /**
+     * Optional executable body for this tool. Core receives it as an
+     * `inline_deno` runnable and runs it in the deny-by-default tool sandbox.
+     * The body must be self-contained; use the injected `host` capability surface
+     * for governed model calls and other platform primitives.
+     */
+    runnable?: Pick<ToolRunnable, "code" | "id" | "name" | "schema">;
 }
 /**
  * The `requires` block as an AUTHOR writes it: both members optional. Distinct
@@ -78,6 +88,8 @@ interface DefineAppOptions {
     requires?: DefineAppRequires;
     /** MCP server namespace for the tool ids. Defaults to `slug`. */
     server?: string;
+    /** Slash commands this app exposes in the chat composer. */
+    slashCommands?: SlashCommandContribution[];
     /**
      * App slug — used to build the widget uri (`ui://widget/<slug>.html`) and, when
      * `server` is omitted, the MCP server namespace that qualifies each tool id.

package/dist/{app-Bkw7LlCK.d.ts → app-C-BDJwfG.d.ts}

@@ -1,4 +1,5 @@
-import { Requires, Surface, PluginManifest } from './manifest.js';
+import { Requires, SlashCommandContribution, Surface, PluginManifest } from './manifest.js';
+import { T as ToolRunnable } from './tool-AjkdFvhE.js';
 
 /**
  * Ryu App authoring factory — `defineApp`.
@@ -16,11 +17,13 @@ import { Requires, Surface, PluginManifest } from './manifest.js';
  *   - A **companion** tool (`accessible:true`) is a call target a mounted widget
  *     may invoke: it carries `widget_accessible:true` and gets no widget template.
  *
- * v1 boundary: this is **declarative pass-through only** — there is no `run`
- * handler. Third-party tool code execution needs the plugin runtime (out of
- * scope); the widget renders from `window.openai.toolInput`/`toolOutput` and Core
- * echoes the validated arguments as `structuredContent`. `ryu pack` bundles the
- * `uiEntry` source into the manifest's `ui_code`.
+ * A tool may also attach a `ToolRunnable`. When present, its self-contained run
+ * body is emitted as Core's grant-gated `inline_deno` backend, so the widget and
+ * the behavior ship in one bundle. Without a runnable, the tool remains the
+ * declarative pass-through form: the widget renders from
+ * `window.openai.toolInput`/`toolOutput` and Core echoes the validated arguments
+ * as `structuredContent`. `ryu pack` bundles the `uiEntry` source into the
+ * manifest's `ui_code`.
  */
 
 /** One tool a Ryu App declares. */
@@ -40,6 +43,13 @@ interface AppToolSpec {
     invoking?: string;
     /** Tool name (unqualified). The wire id is `<server>.<name>`. */
     name: string;
+    /**
+     * Optional executable body for this tool. Core receives it as an
+     * `inline_deno` runnable and runs it in the deny-by-default tool sandbox.
+     * The body must be self-contained; use the injected `host` capability surface
+     * for governed model calls and other platform primitives.
+     */
+    runnable?: Pick<ToolRunnable, "code" | "id" | "name" | "schema">;
 }
 /**
  * The `requires` block as an AUTHOR writes it: both members optional. Distinct
@@ -78,6 +88,8 @@ interface DefineAppOptions {
     requires?: DefineAppRequires;
     /** MCP server namespace for the tool ids. Defaults to `slug`. */
     server?: string;
+    /** Slash commands this app exposes in the chat composer. */
+    slashCommands?: SlashCommandContribution[];
     /**
      * App slug — used to build the widget uri (`ui://widget/<slug>.html`) and, when
      * `server` is omitted, the MCP server namespace that qualifies each tool id.

package/dist/builder.cjs

@@ -177,10 +177,18 @@ var ChatWidgetTemplateSchema = import_zod.z.object({
 }).superRefine((value, ctx) => {
   const count = Number(Boolean(value.backing.tool_id)) + Number(Boolean(value.backing.view_id));
   if (count !== 1 && value.availability === "available") {
-    ctx.addIssue({ code: "custom", path: ["backing"], message: "available templates need exactly one backing tool_id or view_id" });
+    ctx.addIssue({
+      code: "custom",
+      path: ["backing"],
+      message: "available templates need exactly one backing tool_id or view_id"
+    });
   }
   if (count > 1) {
-    ctx.addIssue({ code: "custom", path: ["backing"], message: "backing must declare at most one of tool_id or view_id" });
+    ctx.addIssue({
+      code: "custom",
+      path: ["backing"],
+      message: "backing must declare at most one of tool_id or view_id"
+    });
   }
 });
 var ToolAppConfigSchema = import_zod.z.object({
@@ -203,6 +211,33 @@ var ToolAppConfigSchema = import_zod.z.object({
   /** Optional status label shown when the render tool finishes. */
   invoked: import_zod.z.string().optional()
 });
+var SlashCommandOptionSchema = import_zod.z.object({
+  description: import_zod.z.string().optional(),
+  label: import_zod.z.string().min(1),
+  value: import_zod.z.string().min(1)
+}).passthrough();
+var SlashCommandCustomOptionSchema = import_zod.z.union([
+  import_zod.z.literal(true),
+  import_zod.z.object({
+    description: import_zod.z.string().optional(),
+    label: import_zod.z.string().min(1).optional()
+  }).passthrough()
+]);
+var SlashCommandArgumentSchema = import_zod.z.object({
+  allow_custom: import_zod.z.boolean().optional(),
+  custom: SlashCommandCustomOptionSchema.optional(),
+  description: import_zod.z.string().optional(),
+  name: import_zod.z.string().min(1),
+  options: import_zod.z.array(SlashCommandOptionSchema).optional()
+}).passthrough();
+var SlashCommandContributionSchema = import_zod.z.object({
+  args: import_zod.z.array(SlashCommandArgumentSchema).optional(),
+  body: import_zod.z.string().optional(),
+  command: import_zod.z.string().min(1),
+  description: import_zod.z.string().optional(),
+  id: import_zod.z.string().optional(),
+  parameters: import_zod.z.array(SlashCommandArgumentSchema).optional()
+}).passthrough();
 var ContributesSchema = import_zod.z.object({
   turn_hooks: import_zod.z.array(TurnHookContributionSchema).default([]),
   /** App events this plugin EMITS — the provider half of the hook system, whose
@@ -217,7 +252,7 @@ var ContributesSchema = import_zod.z.object({
    * feature declaration before signing. */
   chat_features: import_zod.z.array(import_zod.z.record(import_zod.z.string(), import_zod.z.unknown())).default([]),
   settings_tabs: import_zod.z.array(import_zod.z.record(import_zod.z.string(), import_zod.z.unknown())).default([]),
-  slash_commands: import_zod.z.array(import_zod.z.record(import_zod.z.string(), import_zod.z.unknown())).default([]),
+  slash_commands: import_zod.z.array(SlashCommandContributionSchema).default([]),
   /** App widgets (Ryu Apps). Each binds a render tool id to its
    *  `ui://widget/<slug>.html` template. Mirrors the Rust-side
    *  `Contributes.widgets` field, without which the CLI's zod parse would strip
@@ -284,7 +319,10 @@ var ContributesSchema = import_zod.z.object({
   output_styles: import_zod.z.array(OutputStyleContributionSchema).default([]),
   /** Per-message actions contributed by an enabled plugin. Kept as loose records
    *  so renderer-specific `kind`/`args` payloads survive `ryu pack` unchanged. */
-  message_actions: import_zod.z.array(import_zod.z.record(import_zod.z.string(), import_zod.z.unknown())).default([])
+  message_actions: import_zod.z.array(import_zod.z.record(import_zod.z.string(), import_zod.z.unknown())).default([]),
+  /** Buttons contributed to the floating text-selection toolbar. Kept as loose
+   *  records so host-owned dispatch args survive `ryu pack` unchanged. */
+  selection_actions: import_zod.z.array(import_zod.z.record(import_zod.z.string(), import_zod.z.unknown())).default([])
 });
 var SetupStepSchema = import_zod.z.object({
   /** Card heading (e.g. the companion app name). */
@@ -434,6 +472,9 @@ var PluginManifestSchema = import_zod.z.object({
     /^\d+\.\d+\.\d+(?:-[\w.]+)?(?:\+[\w.]+)?$/,
     "version must be a valid semver string (e.g. 1.0.0)"
   ),
+  /** Core-owned release maturity metadata. The Rust contract validates the
+   *  richer shape; the SDK authoring parser must preserve it for pack/publish. */
+  stability: import_zod.z.unknown().optional(),
   /**
    * Lower-case hex `sha256(utf8_bytes(ui_code))` binding the plugin's bundled
    * sandboxed-UI code to this manifest. `ryu pack` / `ryu publish` compute it and
@@ -451,8 +492,26 @@ var PluginManifestSchema = import_zod.z.object({
    * Declarations only — grant enforcement is the Gateway's responsibility.
    */
   permission_grants: import_zod.z.array(import_zod.z.string()).default([]),
+  /** Deny-by-default sandbox permissions. Core remains authoritative; this
+   *  schema mirrors the fields so `ryu pack` cannot strip them. */
+  permissions: import_zod.z.object({
+    fs: import_zod.z.object({
+      read: import_zod.z.array(import_zod.z.string()).default([]),
+      write: import_zod.z.array(import_zod.z.string()).default([])
+    }).optional(),
+    child_process: import_zod.z.boolean().optional(),
+    run: import_zod.z.array(import_zod.z.string()).default([]),
+    network: import_zod.z.union([import_zod.z.boolean(), import_zod.z.array(import_zod.z.string())]).optional(),
+    tool: import_zod.z.array(import_zod.z.string()).default([])
+  }).optional(),
+  /** Core-owned permission presentation levels. Preserved verbatim here and
+   *  validated by Core's authoritative manifest contract. */
+  permission_levels: import_zod.z.unknown().optional(),
   /** Remote or stdio MCP servers registered by this plugin. */
   mcp_servers: import_zod.z.record(import_zod.z.string(), McpServerDeclSchema).optional(),
+  /** Core-owned sidecar declarations. Their full process/HTTP schema stays in
+   *  the Rust contract; this authoring layer must never strip them. */
+  sidecars: import_zod.z.unknown().optional(),
   /**
    * Optional Companion surface (an in-desktop overlay or sidebar panel).
    * Absent when the plugin has no Companion surface.
@@ -488,6 +547,9 @@ var PluginManifestSchema = import_zod.z.object({
    * an unsupported-target plugin stays installable and inspectable.
    */
   targets: import_zod.z.array(SurfaceSchema).default([]),
+  /** Rich per-surface declarations (`support`, UI, contributed commands, …).
+   *  Core owns and validates the nested vocabulary. */
+  surfaces: import_zod.z.unknown().optional(),
   /**
    * Host version floors — the semver requirement each surface must satisfy for
    * this plugin to install. Mirrors Core's `EnginesReq`
@@ -602,7 +664,7 @@ var PluginManifestSchema = import_zod.z.object({
    * array of steps guiding the user through post-install configuration.
    */
   setup: import_zod.z.union([SetupStepSchema, import_zod.z.array(SetupStepSchema)]).optional()
-}).superRefine((manifest, context) => {
+}).passthrough().superRefine((manifest, context) => {
   const hasOAuthServer = Object.values(manifest.mcp_servers ?? {}).some(
     (server) => server.auth?.type === "oauth"
   );
@@ -620,6 +682,26 @@ var PluginManifestSchema = import_zod.z.object({
   }
 });
 
+// src/runnable/tool.ts
+function inlineToolRunnable(tool2, options) {
+  return {
+    id: tool2.id,
+    name: tool2.name,
+    kind: "tool",
+    config: {
+      slug: tool2.id,
+      backend: "inline_deno",
+      code: tool2.code,
+      input_schema: tool2.schema,
+      ...options?.description === void 0 ? tool2.description === void 0 ? {} : { description: tool2.description } : { description: options.description },
+      ...options?.outputSchema ? { output_schema: options.outputSchema } : {},
+      ...options?.annotations ? { annotations: options.annotations } : {},
+      ...options?.action === void 0 ? {} : { action: options.action },
+      ...options?.needsApproval === void 0 ? {} : { needs_approval: options.needsApproval }
+    }
+  };
+}
+
 // src/runnable/app.ts
 var DEFAULT_APP_WIDGET_MIME = "text/html+skybridge";
 var DEFAULT_APP_DISPLAY_MODE = "inline";
@@ -631,6 +713,13 @@ function withWidgetRenderGrant(grants, widgets) {
   }
   return out;
 }
+function withToolExecuteGrant(grants, tools) {
+  const out = [...grants];
+  if (tools.some((tool2) => tool2.runnable !== void 0) && !out.includes("tool:execute")) {
+    out.push("tool:execute");
+  }
+  return out;
+}
 function appToolId(server, name) {
   return `${server}.${name}`;
 }
@@ -645,7 +734,9 @@ function defineApp(options) {
   for (const spec of options.tools) {
     const isRender = spec.accessible !== true;
     const id = appToolId(server, spec.name);
+    const executable = spec.runnable ? inlineToolRunnable(spec.runnable) : void 0;
     const config = {
+      ...executable?.config ?? {},
       slug: id,
       description: spec.description,
       widget: isRender,
@@ -679,7 +770,7 @@ function defineApp(options) {
     hook_events: [],
     composer_controls: [],
     settings_tabs: [],
-    slash_commands: [],
+    slash_commands: options.slashCommands ?? [],
     sidebar_sections: [],
     sidebar_buttons: [],
     dock_panels: [],
@@ -697,6 +788,7 @@ function defineApp(options) {
     pi_extensions: [],
     output_styles: [],
     message_actions: [],
+    selection_actions: [],
     widgets
   };
   const raw = {
@@ -710,15 +802,15 @@ function defineApp(options) {
     // Core gates widget promotion on declared-AND-enabled-AND-granted, and a
     // missing grant fails as `DeniedNoGrant` — which is an `info!` log and
     // nothing else. The widget silently renders as plain text, with no error
-    // in the UI and nothing pointing at the manifest. Every app scaffolded
-    // through `defineApp` hit that, because the only fix was a grant string
-    // the templates never mention and the builder never added; the one
-    // working example on disk hand-writes it.
+    // in the UI and nothing pointing at the manifest.
     //
     // Added only when there is a widget to render, and unioned rather than
     // overwritten so an author's own `grants` list survives and re-declaring
     // it is not an error.
-    permission_grants: withWidgetRenderGrant(options.grants ?? [], widgets),
+    permission_grants: withToolExecuteGrant(
+      withWidgetRenderGrant(options.grants ?? [], widgets),
+      options.tools
+    ),
     activation_events: options.activationEvents ?? ["*"],
     contributes,
     // `targets: []` means EVERY surface, so an app that declares none is
@@ -959,6 +1051,7 @@ var AppBuilder = class {
   _dependencies = [];
   _requiredCapabilities = [];
   _requiredGrants = [];
+  _slashCommands = [];
   _targets = [];
   /** Set the reverse-domain app id (e.g. `"com.example.checklist"`). */
   id(value) {
@@ -1015,6 +1108,11 @@ var AppBuilder = class {
     this._tools.push(spec);
     return this;
   }
+  /** Add a slash command and its optional sequential argument choices. */
+  slashCommand(command) {
+    this._slashCommands.push(command);
+    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"`).
@@ -1062,6 +1160,7 @@ var AppBuilder = class {
       uiEntry: this._uiEntry,
       tools: this._tools,
       grants: this._grants,
+      slashCommands: this._slashCommands,
       ...this._server ? { server: this._server } : {},
       ...this._displayMode ? { displayMode: this._displayMode } : {},
       ...this._mime ? { mime: this._mime } : {},

package/dist/builder.d.cts

@@ -1,6 +1,8 @@
-import { RunnableMeta, Surface, PluginManifest, CompanionSurface } from './manifest.cjs';
-import { A as AppToolSpec } from './app-DNaGmLVf.cjs';
+import { RunnableMeta, SlashCommandContribution, Surface, PluginManifest, CompanionSurface } from './manifest.cjs';
+import { A as AppToolSpec } from './app-B0Z9Ew_R.cjs';
 import 'zod';
+import './tool-CgzW92O_.cjs';
+import './client-D5U6ssPc.cjs';
 
 /**
  * Ryu SDK typed builders — one builder per RunnableKind plus a PluginBuilder that
@@ -160,6 +162,7 @@ declare class AppBuilder {
     private readonly _dependencies;
     private readonly _requiredCapabilities;
     private readonly _requiredGrants;
+    private readonly _slashCommands;
     private readonly _targets;
     /** Set the reverse-domain app id (e.g. `"com.example.checklist"`). */
     id(value: string): this;
@@ -183,6 +186,8 @@ declare class AppBuilder {
     activationEvent(event: string): this;
     /** Append a tool spec (render tool unless `accessible:true`). */
     tool(spec: AppToolSpec): this;
+    /** Add a slash command and its optional sequential argument choices. */
+    slashCommand(command: SlashCommandContribution): 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"`).

package/dist/builder.d.ts

@@ -1,6 +1,8 @@
-import { RunnableMeta, Surface, PluginManifest, CompanionSurface } from './manifest.js';
-import { A as AppToolSpec } from './app-Bkw7LlCK.js';
+import { RunnableMeta, SlashCommandContribution, Surface, PluginManifest, CompanionSurface } from './manifest.js';
+import { A as AppToolSpec } from './app-C-BDJwfG.js';
 import 'zod';
+import './tool-AjkdFvhE.js';
+import './client-D5U6ssPc.js';
 
 /**
  * Ryu SDK typed builders — one builder per RunnableKind plus a PluginBuilder that
@@ -160,6 +162,7 @@ declare class AppBuilder {
     private readonly _dependencies;
     private readonly _requiredCapabilities;
     private readonly _requiredGrants;
+    private readonly _slashCommands;
     private readonly _targets;
     /** Set the reverse-domain app id (e.g. `"com.example.checklist"`). */
     id(value: string): this;
@@ -183,6 +186,8 @@ declare class AppBuilder {
     activationEvent(event: string): this;
     /** Append a tool spec (render tool unless `accessible:true`). */
     tool(spec: AppToolSpec): this;
+    /** Add a slash command and its optional sequential argument choices. */
+    slashCommand(command: SlashCommandContribution): 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"`).

package/dist/builder.js

@@ -10,9 +10,10 @@ import {
   skill,
   tool,
   workflow
-} from "./chunk-IOLP5FFE.js";
-import "./chunk-W3KPP4WN.js";
-import "./chunk-IEUQ3CDG.js";
+} from "./chunk-HLKJZAFK.js";
+import "./chunk-SN2QBJUF.js";
+import "./chunk-QYFUNJOH.js";
+import "./chunk-NZKVOSC2.js";
 export {
   AgentBuilder,
   AppBuilder,