@ryuhq/sdk 0.1.14 → 0.2.2

package/dist/{index-BvAB5eMk.d.cts → tool-CgzW92O_.d.cts}

@@ -1,178 +1,5 @@
 import { RunnableMeta } from './manifest.cjs';
-
-/**
- * Native tool-calling model call for the Ryu agent runtime.
- *
- * The gateway-mandatory `ModelClient` (packages/sdk/src/model/client.ts) only
- * exposes text `chat`/`stream` — it cannot pass a `tools` array or receive
- * `tool_calls`. The autonomous agent loop needs both, so this module makes a
- * direct request to the node's gateway `POST /v1/chat/completions` endpoint
- * with the caller's own `tools` and reads back `message.tool_calls`.
- *
- * The no-direct-provider guarantee is preserved: `assertAllowedEgressUrl` (the
- * same Rust-cored blocklist the ModelClient uses) is called before every fetch,
- * so a direct provider base URL throws exactly as it would elsewhere in the SDK.
- *
- * `x-ryu-raw-tools: on` is always sent. On a plain gateway it is a harmless
- * no-op; on a Composio-on managed node it forces the plain completion branch so
- * the caller's `tool_calls` are returned verbatim instead of being intercepted
- * and executed by Core's own tool loop (see apps/gateway/src/pipeline/mod.rs).
- */
-/** An OpenAI function tool definition passed to the model. */
-interface ToolFunctionDef {
-    function: {
-        description?: string;
-        name: string;
-        /** JSON Schema for the function's arguments. */
-        parameters: Record<string, unknown>;
-    };
-    type: "function";
-}
-/** A single tool call emitted by the model. */
-interface ToolCall {
-    function: {
-        /** JSON-encoded arguments string (per the OpenAI wire format). */
-        arguments: string;
-        name: string;
-    };
-    id: string;
-    type: "function";
-}
-/** An assistant turn — may carry text, tool calls, or both. */
-interface AssistantMessage {
-    content: string | null;
-    role: "assistant";
-    tool_calls?: ToolCall[];
-}
-/** A message in the loop's running transcript. */
-type LoopMessage = {
-    content: string;
-    role: "system" | "user";
-} | AssistantMessage | {
-    content: string;
-    role: "tool";
-    tool_call_id: string;
-};
-/** Token usage as reported by the gateway (optional — gateway may omit). */
-interface ModelUsage {
-    completionTokens: number;
-    promptTokens: number;
-    totalTokens: number;
-}
-/** Options for a single native tool-calling completion. */
-interface ModelCallOptions {
-    /** Gateway base URL (no trailing `/v1`). */
-    baseUrl: string;
-    /** Running transcript. */
-    messages: LoopMessage[];
-    /** Model id routed by the gateway (provider is derived from the id). */
-    model: string;
-    /** Abort signal for cancellation. */
-    signal?: AbortSignal;
-    /** Bearer token forwarded to the gateway (never a provider key). */
-    token?: string;
-    /** How the model should choose tools; defaults to gateway/provider default. */
-    toolChoice?: "auto" | "none" | "required";
-    /** Function tool definitions the model may call. */
-    tools?: ToolFunctionDef[];
-}
-/** Result of a single completion. */
-interface ModelCallResult {
-    finishReason: string | null;
-    message: AssistantMessage;
-    usage?: ModelUsage;
-}
-/**
- * Call the node's gateway with the caller's own tools and return the first
- * choice, including any `tool_calls`.
- *
- * Throws when the base URL is a direct provider (egress enforcement) or when
- * the gateway returns a non-2xx status.
- */
-declare function callModelWithTools(options: ModelCallOptions): Promise<ModelCallResult>;
-
-/**
- * Gateway-mandatory model client for the Ryu SDK.
- *
- * Rust-cored: this is a thin TypeScript wrapper over the `@ryuhq/sdk-native`
- * addon's `ModelClient`, which is the `crates/ryu-sdk` Rust core. Every model
- * call is routed by the Rust core to the Ryu gateway's OpenAI-compatible
- * `/v1/chat/completions` endpoint; direct-provider base URLs are rejected at
- * construction. No provider SDK or base URL is ever imported here.
- *
- * Usage:
- *
- *   const model = defineModel("gpt-4o");
- *   const reply = await model.chat([{ role: "user", content: "hello" }]);
- *   for await (const delta of model.stream([{ role: "user", content: "hi" }])) {
- *     process.stdout.write(delta.content);
- *   }
- */
-/** A single message in a chat conversation. */
-interface ChatMessage {
-    /** The message text. */
-    content: string;
-    /** The speaker: "system", "user", or "assistant". */
-    role: "system" | "user" | "assistant";
-}
-/** A streaming chat completion delta. */
-interface ChatDelta {
-    /** Incremental text fragment from the model. */
-    content: string | null;
-    /** Non-null on the final chunk when `finish_reason` is set. */
-    finishReason: string | null;
-}
-/** Non-streaming chat completion result. */
-interface ChatResult {
-    /** The full assistant reply text. */
-    content: string;
-    /** The gateway/model-reported finish reason. */
-    finishReason: string | null;
-    /** Usage stats as reported by the gateway (optional — gateway may omit). */
-    usage?: {
-        promptTokens: number;
-        completionTokens: number;
-        totalTokens: number;
-    };
-}
-/** Options accepted by `defineModel`. */
-interface ModelClientOptions {
-    /**
-     * Gateway base URL (no trailing `/v1`). Defaults to `RYU_GATEWAY_URL` then
-     * the Rust core's default. Direct provider URLs are rejected at construction.
-     */
-    baseUrl?: string;
-    /**
-     * Bearer token forwarded to the gateway. Defaults to `RYU_GATEWAY_TOKEN`.
-     * This is the gateway token, never a provider API key.
-     */
-    token?: string;
-}
-/**
- * A gateway-mandatory model client backed by the Rust core.
- *
- * All calls go through the native `ModelClient`; if the configured base URL is a
- * direct provider, construction throws.
- */
-declare class ModelClient {
-    readonly model: string;
-    readonly baseUrl: string;
-    private readonly native;
-    constructor(model: string, options?: ModelClientOptions);
-    /** Send a non-streaming chat completion request to the gateway. */
-    chat(messages: ChatMessage[]): Promise<ChatResult>;
-    /** Send a streaming chat completion request, yielding deltas as they arrive. */
-    stream(messages: ChatMessage[]): AsyncGenerator<ChatDelta>;
-}
-/**
- * Create a gateway-mandatory model client for `modelId`.
- *
- *   const model = defineModel("gpt-4o");
- *   const model = defineModel("claude-3-5-sonnet", { baseUrl: "http://my-gateway:7981" });
- *
- * A direct provider URL throws immediately (egress enforcement in the Rust core).
- */
-declare function defineModel(modelId: string, options?: ModelClientOptions): ModelClient;
+import { a as ChatMessage, b as ChatResult, C as ChatDelta } from './client-D5U6ssPc.cjs';
 
 /**
  * Composable primitive-client surface for the Ryu SDK runtime context.
@@ -420,6 +247,67 @@ interface EnginesClient {
         model?: string;
     }): Promise<number[][]>;
 }
+/** One process visible through the shared Core background registry. */
+interface BackgroundProcess {
+    command: string;
+    cwd: string;
+    description?: string | null;
+    elapsed_ms: number;
+    exit_code?: number | null;
+    exit_signal?: string | null;
+    kind: string;
+    label?: string | null;
+    pid?: number | null;
+    process_id: string;
+    producer: string;
+    running: boolean;
+    shell_id?: string | null;
+    started_at: number;
+}
+/** Background-process registry and cooperative stop requests. */
+interface BackgroundClient {
+    list(input?: {
+        producer?: string;
+        runningOnly?: boolean;
+    }): Promise<BackgroundProcess[]>;
+    stop(input: {
+        processId: string;
+    }): Promise<{
+        ok: boolean;
+        requested: boolean;
+        process_id: string;
+    }>;
+}
+/** Durable app-owned key/value state (`storage:kv` via the host bridge). */
+interface StorageClient {
+    /** Atomically replace a value when it still equals `expected`. */
+    compareAndSet(input: {
+        expected: string | null;
+        key: string;
+        namespace?: string;
+        value: string | null;
+    }): Promise<boolean>;
+    /** Delete one value. */
+    delete(input: {
+        key: string;
+        namespace?: string;
+    }): Promise<void>;
+    /** Read one value; missing keys return `null`. */
+    get(input: {
+        key: string;
+        namespace?: string;
+    }): Promise<string | null>;
+    /** List keys in an app-owned namespace. */
+    keys(input?: {
+        namespace?: string;
+    }): Promise<string[]>;
+    /** Write one string value. JSON can be encoded by the app when needed. */
+    set(input: {
+        key: string;
+        namespace?: string;
+        value: string;
+    }): Promise<void>;
+}
 /** TTS primitive — speech synthesis (`crates/ryu-tts`). */
 interface TtsClient {
     /**
@@ -465,12 +353,14 @@ interface ImageClient {
  * Core node) — the same "what runs vs what is allowed" split as `ctx.gateway`.
  */
 interface RyuPrimitives {
+    background: BackgroundClient;
     durable: DurableClient;
     engines: EnginesClient;
     image: ImageClient;
     memory: MemoryClient;
     rag: RagClient;
     realtime: RealtimeClient;
+    storage: StorageClient;
     stt: SttClient;
     tts: TtsClient;
 }
@@ -534,6 +424,8 @@ interface RunnableContext {
     sessionId?: string;
     /** Signal to abort a long-running run. */
     signal?: AbortSignal;
+    /** Durable app-owned KV state, gated by the manifest's `storage:kv` grant. */
+    storage?: StorageClient;
     /** STT primitive: transcribe (`crates/ryu-stt`). */
     stt?: SttClient;
     /** TTS primitive: speak (`crates/ryu-tts`). */
@@ -613,9 +505,13 @@ interface ToolSchema {
     required?: string[];
     /** Type is always "object" for a tool's top-level input schema. */
     type: "object";
+    /** Preserve additional JSON Schema keywords for Core/MCP consumers. */
+    [key: string]: unknown;
 }
 /** Options accepted by `defineTool`. */
 interface ToolOptions<TInput extends Record<string, unknown>, TOutput> {
+    /** Optional description surfaced to models and tool discovery. */
+    description?: string;
     /** Stable unique identifier (e.g. "tool-web-search"). */
     id: string;
     /** Human-readable display name. */
@@ -655,6 +551,8 @@ interface ToolRunnable<TInput extends Record<string, unknown> = Record<string, u
      * the sandbox form is the second parameter aliased to `host`.
      */
     readonly code: string;
+    /** Optional description surfaced to models and tool discovery. */
+    readonly description?: string;
     readonly kind: "tool";
     /** JSON Schema for this tool's input — compatible with Core's ToolInfo.schema. */
     readonly schema: ToolSchema;
@@ -689,300 +587,29 @@ interface ToolRunnable<TInput extends Record<string, unknown> = Record<string, u
  * ```
  */
 declare function defineTool<TInput extends Record<string, unknown> = Record<string, unknown>, TOutput = unknown>(options: ToolOptions<TInput, TOutput>): ToolRunnable<TInput, TOutput>;
+/** Optional metadata lowered alongside a tool's executable backend. */
+interface InlineToolManifestOptions {
+    /** Marks the entry as a semantic Ryu Action. */
+    action?: boolean;
+    /** MCP-style effect annotations, for example `readOnlyHint`. */
+    annotations?: Record<string, boolean | undefined>;
+    /** Description shown in Core's unified tool catalog. */
+    description?: string;
+    /** Force the human approval gate before the tool runs. */
+    needsApproval?: boolean;
+    /** JSON Schema for the structured result. */
+    outputSchema?: Record<string, unknown>;
+}
 /**
  * Convert a {@link ToolRunnable} into a `manifest.json` `kind:"tool"` runnable that
  * ships its `run` body as Core's `inline_deno` backend. The emitted config
  * mirrors Core's `ToolConfig` (`apps/core/src/plugin_manifest/schema.rs`):
  * `{ slug, backend:"inline_deno", code, description?, input_schema }`. Core
- * registers it as `app__<slug>` — discoverable via `/api/tools/search` and
+ * registers it as `app.<slug>` — discoverable via `/api/tools/search` and
  * executed in the grant-gated sandbox.
  *
  * The plugin must declare the `tool:execute` grant (see `definePlugin`).
  */
-declare function inlineToolRunnable(tool: ToolRunnable, options?: {
-    description?: string;
-}): RunnableMeta;
-
-/**
- * Tool resolution + execution for the Ryu agent runtime.
- *
- * Two kinds of tool feed the same model `tools[]` array:
- *
- *  - **Local** tools are `ToolRunnable`s from `defineTool` — they run in-process
- *    via their `run(input, ctx)` implementation.
- *  - **Remote** tools are references to existing Ryu tools (e.g.
- *    `composio__GMAIL_SEARCH_EMAILS`) created with `ryuTool(id)`. Their schema is
- *    lazily fetched from Core `GET /api/tools/describe` and they execute through
- *    Core `POST /api/mcp/tools/call`, which enforces the agent's allowlist and
- *    selects the Composio connected-account entity via `user_id`.
- *
- * The model-facing function name is the **config key** the developer chose (e.g.
- * `gmailSearch`), not the raw Composio slug — internals stay hidden and names
- * stay OpenAI-safe.
- */
-
-/** A reference to an existing Ryu tool, resolved + executed via Core. */
-interface RemoteToolRef {
-    /** One-line description shown to the model (overrides Core's describe). */
-    description?: string;
-    /** Fully-qualified Ryu tool id, e.g. `composio__GMAIL_SEARCH_EMAILS`. */
-    id: string;
-    readonly kind: "remote";
-    /**
-     * JSON Schema for the tool's arguments. Optional: when omitted, a permissive
-     * open-object schema is used (Composio `describe` is shallow), so supplying
-     * this materially improves the model's tool-call accuracy.
-     */
-    parameters?: Record<string, unknown>;
-}
-/** Options accepted by `ryuTool`. */
-interface RyuToolOptions {
-    description?: string;
-    parameters?: Record<string, unknown>;
-}
-/**
- * Reference an existing Ryu tool by id so an `Agent` can call it.
- *
- * @example
- * ```ts
- * ryuTool("composio__GMAIL_SEARCH_EMAILS", {
- *   description: "Search the user's Gmail",
- *   parameters: { type: "object", properties: { query: { type: "string" } }, required: ["query"] },
- * });
- * ```
- */
-declare function ryuTool(id: string, opts?: RyuToolOptions): RemoteToolRef;
-/** A tool an `Agent` can expose to the model: local runnable or remote ref. */
-type AgentTool = RemoteToolRef | ToolRunnable;
-/** Everything the tool layer needs to resolve schemas + execute calls. */
-interface ToolExecContext {
-    /** Core agent id — REQUIRED for remote tools (governs execution). */
-    agentId?: string;
-    /** Core base URL (no trailing `/api`). */
-    coreBaseUrl: string;
-    /** Bearer token for Core (`RYU_TOKEN`); may be undefined on loopback dev. */
-    coreToken?: string;
-    /** RunnableContext handed to local tools so they may call the gateway. */
-    runnableContext: RunnableContext;
-    /** Abort signal. */
-    signal?: AbortSignal;
-    /** Composio connected-account entity selector. */
-    userId?: string;
-}
-/**
- * Build the OpenAI `tools[]` array the model sees, keyed by the developer's
- * config names. Remote tools without an explicit `parameters` schema are
- * described from Core (`describe` is shallow) and given a permissive schema.
- */
-declare function resolveToolDefs(tools: Record<string, AgentTool>, ctx: ToolExecContext): Promise<ToolFunctionDef[]>;
-/** Result of executing one tool call. */
-interface ToolExecResult {
-    /** Raw tool output (already JSON-parsed when the tool returned JSON). */
-    output: unknown;
-}
-/**
- * Execute a single model tool call by config `name`, dispatching to the local
- * runnable or the Core `/api/mcp/tools/call` endpoint.
- *
- * `argsJson` is the raw JSON string from `tool_call.function.arguments`.
- */
-declare function executeTool(name: string, argsJson: string, tools: Record<string, AgentTool>, ctx: ToolExecContext): Promise<ToolExecResult>;
-/** The connect-required envelope Core returns when an account isn't linked. */
-interface Elicitation {
-    kind?: string;
-    message?: string;
-    url?: string;
-}
-/**
- * Detect Ryu's connection-required envelope in a tool output. Mirrors Core's
- * `detect_elicitation` (apps/core/src/sidecar/mcp/composio.rs): the first Gmail
- * call for an unconnected account returns `{ "__ryu_elicitation__": { url } }`.
- */
-declare function detectElicitation(output: unknown): Elicitation | null;
-
-/**
- * The autonomous agent loop for the Ryu SDK runtime.
- *
- * This is what `defineAgent` never had: a real multi-turn tool-calling loop that
- * runs in TypeScript. Each round calls the node's gateway with the resolved
- * tool definitions; if the model emits `tool_calls`, each is executed (local
- * runnable or Core `/api/mcp/tools/call`), results are fed back, and the loop
- * repeats until the model stops calling tools or `maxSteps` is reached.
- *
- * Emitted events mirror Core's `AcpEvent` categories (see cli/dev.ts) plus an
- * `auth_required` pause — when a remote tool returns Ryu's connection-required
- * envelope (first-run Gmail OAuth), the loop surfaces the connect URL and stops
- * instead of feeding the envelope back as a normal tool result.
- */
-
-/** A streamed text fragment from the assistant. */
-interface AgentEventText {
-    content: string;
-    type: "text";
-}
-/** The model initiated a tool call. */
-interface AgentEventToolCall {
-    id: string;
-    input: unknown;
-    name: string;
-    type: "tool_call";
-}
-/** A tool finished (or failed with an error output the model can recover from). */
-interface AgentEventToolResult {
-    id: string;
-    name: string;
-    output: unknown;
-    type: "tool_result";
-}
-/** A remote tool needs an account connection — the loop paused. */
-interface AgentEventAuthRequired {
-    message?: string;
-    tool: string;
-    type: "auth_required";
-    url?: string;
-}
-/** A fatal loop error — the stream ends after this. */
-interface AgentEventError {
-    message: string;
-    type: "error";
-}
-/** Terminal event carrying the final text, step count, and aggregate usage. */
-interface AgentEventResult {
-    steps: number;
-    text: string;
-    type: "result";
-    usage?: ModelUsage;
-}
-/** Union of everything the loop yields. */
-type AgentEvent = AgentEventAuthRequired | AgentEventError | AgentEventResult | AgentEventText | AgentEventToolCall | AgentEventToolResult;
-/** Inputs for a single loop run. */
-interface LoopConfig {
-    /** Gateway base URL for inference (the target node). */
-    gatewayBaseUrl: string;
-    /** Gateway bearer token. */
-    gatewayToken?: string;
-    /** Hard ceiling on model→tool rounds. */
-    maxSteps: number;
-    /** Seed transcript (system + user messages already assembled). */
-    messages: LoopMessage[];
-    /** Model id routed by the gateway. */
-    model: string;
-    /** Abort signal. */
-    signal?: AbortSignal;
-    /** Context for resolving + executing tools. */
-    toolCtx: ToolExecContext;
-    /** Tools keyed by model-facing name. */
-    tools: Record<string, AgentTool>;
-}
-/**
- * Run the autonomous loop, yielding events as they occur. The generator returns
- * after a terminal `result`, `auth_required`, or `error` event.
- */
-declare function runAgentLoop(config: LoopConfig): AsyncGenerator<AgentEvent>;
-
-/**
- * `Agent` — the declarative agent runtime for `@ryu/sdk`.
- *
- * Unlike `defineAgent` (a declaration wrapper whose `run()` you write by hand),
- * `Agent` OWNS the loop: give it instructions, a model, a target node, and a
- * set of tools, then call `generate()` / `stream()`. Inference is pointed at the
- * node's gateway; tool calls resolve to local `defineTool` runnables or existing
- * Ryu tools (`ryuTool`) executed through Core.
- *
- * Mirrors Mastra's config-object + `.generate()`/`.stream()` shape; `query()`
- * (see query.ts) wraps the same runtime in a Claude-Agent-SDK-style streaming
- * call.
- */
-
-/** A target node for inference / tool execution: a base URL + optional token. */
-interface Endpoint {
-    baseUrl?: string;
-    token?: string;
-}
-/** Declarative configuration for an `Agent`. */
-interface AgentConfig {
-    /** Core agent id — REQUIRED when using `ryuTool` remote tools (governance). */
-    agentId?: string;
-    /** Core endpoint for tool discovery/execution. Defaults to env/localhost. */
-    core?: Endpoint;
-    /** System prompt / persona. */
-    instructions?: string;
-    /** Hard ceiling on model→tool rounds (default 10). */
-    maxSteps?: number;
-    /** Model id routed by the node's gateway. */
-    model: string;
-    /** Display name. */
-    name: string;
-    /** Target node for inference. Defaults to the local gateway. */
-    node?: Endpoint;
-    /**
-     * Reverse-domain plugin id. When set, the composable primitive surface
-     * (`ctx.rag`, `ctx.memory`, `ctx.engines`, …) is mounted on the run context,
-     * routed through this node via the governed host bridge / capability broker.
-     * Omitted = no primitives mounted (the bridge families authenticate a plugin
-     * id, so a half-wired transport is never attached).
-     */
-    pluginId?: string;
-    /** Tools keyed by the model-facing name. */
-    tools?: Record<string, AgentTool>;
-    /** Composio connected-account entity selector. */
-    userId?: string;
-}
-/** Result of a non-streaming `generate()`. */
-interface GenerateResult {
-    /** Present when the run paused for an account connection. */
-    authRequired?: AgentEventAuthRequired;
-    /** Number of model→tool rounds taken. */
-    steps: number;
-    /** Final assistant text. */
-    text: string;
-    /** Aggregate token usage across all rounds (when reported). */
-    usage?: ModelUsage;
-}
-/** A declarative, loop-owning agent. */
-declare class Agent {
-    readonly config: AgentConfig;
-    constructor(config: AgentConfig);
-    /** Assemble the loop config for a given prompt. */
-    private buildLoopConfig;
-    /** Stream loop events (text / tool_call / tool_result / auth_required / …). */
-    stream(prompt: string, signal?: AbortSignal): AsyncGenerator<AgentEvent>;
-    /** Run to completion and return the final text, step count, and usage. */
-    generate(prompt: string, signal?: AbortSignal): Promise<GenerateResult>;
-}
-/** Factory alias for `new Agent(config)`. */
-declare function createAgent(config: AgentConfig): Agent;
-
-/**
- * `query()` — Claude-Agent-SDK-style streaming entry over the same `Agent`.
- *
- * Where `Agent` gives you Mastra's config-object + method shape, `query()` gives
- * you the `for await (const msg of query({ prompt, options }))` ergonomics of
- * the Claude Agent SDK. Both drive the identical loop; this is a thin wrapper.
- */
-
-/** Options accepted by `query` — an `AgentConfig` with an optional `name`. */
-type QueryOptions = Omit<AgentConfig, "name"> & {
-    name?: string;
-};
-/** Input to `query`: a prompt plus agent options. */
-interface QueryInput {
-    options: QueryOptions;
-    prompt: string;
-}
-/**
- * Run an agent for a single prompt and stream its events.
- *
- * @example
- * ```ts
- * for await (const msg of query({
- *   prompt: "Find my expenses from last month.",
- *   options: { model: "gpt-4o", agentId: "agent-expense", tools: { gmailSearch } },
- * })) {
- *   if (msg.type === "result") console.log(msg.text);
- * }
- * ```
- */
-declare function query(input: QueryInput): AsyncGenerator<AgentEvent>;
+declare function inlineToolRunnable(tool: Pick<ToolRunnable, "code" | "description" | "id" | "name" | "schema">, options?: InlineToolManifestOptions): RunnableMeta;
 
-export { type Elicitation as $, Agent as A, defineModel as B, type ChatDelta as C, type DurableClient as D, type Endpoint as E, defineTool as F, type GatewayClient as G, type HttpPrimitiveTransportOptions as H, type ImageClient as I, type JsonSchemaProperty as J, httpPrimitiveTransport as K, inlineToolRunnable as L, type MemoryClient as M, query as N, ryuTool as O, PRIMITIVE_BINDINGS as P, type QueryInput as Q, type Runnable as R, type SttClient as S, type ToolRunnable as T, type AgentEventAuthRequired as U, type AgentEventError as V, type AgentEventResult as W, type AgentEventText as X, type AgentEventToolCall as Y, type AgentEventToolResult as Z, type AssistantMessage as _, type RunnableContext as a, type LoopConfig as a0, type LoopMessage as a1, type ModelCallOptions as a2, type ModelCallResult as a3, type ModelUsage as a4, type RyuToolOptions as a5, type ToolCall as a6, type ToolExecContext as a7, type ToolExecResult as a8, type ToolFunctionDef as a9, callModelWithTools as aa, detectElicitation as ab, executeTool as ac, resolveToolDefs as ad, runAgentLoop as ae, type AgentConfig as b, type AgentEvent as c, type AgentTool as d, type ChatMessage as e, type ChatResult as f, type EnginesClient as g, type GenerateResult as h, type MemoryItem as i, ModelClient as j, type ModelClientOptions as k, type PrimitiveBinding as l, type PrimitiveTransport as m, type QueryOptions as n, type RagChunk as o, type RagClient as p, type RagRerankResult as q, type RealtimeClient as r, type RealtimeSubscription as s, type RemoteToolRef as t, type RyuPrimitives as u, type ToolOptions as v, type ToolSchema as w, type TtsClient as x, createAgent as y, createPrimitives as z };
+export { type BackgroundClient as B, type DurableClient as D, type EnginesClient as E, type GatewayClient as G, type HttpPrimitiveTransportOptions as H, type ImageClient as I, type JsonSchemaProperty as J, type MemoryClient as M, PRIMITIVE_BINDINGS as P, type RagChunk as R, type StorageClient as S, type ToolRunnable as T, type BackgroundProcess as a, type InlineToolManifestOptions as b, type MemoryItem as c, type PrimitiveBinding as d, type PrimitiveTransport as e, type RagClient as f, type RagRerankResult as g, type RealtimeClient as h, type RealtimeSubscription as i, type Runnable as j, type RunnableContext as k, type RyuPrimitives as l, type SttClient as m, type ToolOptions as n, type ToolSchema as o, type TtsClient as p, createPrimitives as q, defineTool as r, httpPrimitiveTransport as s, inlineToolRunnable as t };

package/package.json

@@ -1,8 +1,12 @@
 {
   "name": "@ryuhq/sdk",
-  "version": "0.1.14",
+  "version": "0.2.2",
   "type": "module",
   "description": "Ryu developer SDK: typed builders and CLI for authoring manifest.json Plugin bundles",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/amajorai/ryu"
+  },
   "main": "./dist/index.cjs",
   "types": "./dist/index.d.ts",
   "exports": {
@@ -26,6 +30,46 @@
       "import": "./dist/agent.js",
       "require": "./dist/agent.cjs"
     },
+    "./action": {
+      "types": "./dist/action.d.ts",
+      "import": "./dist/action.js",
+      "require": "./dist/action.cjs"
+    },
+    "./model": {
+      "types": "./dist/model.d.ts",
+      "import": "./dist/model.js",
+      "require": "./dist/model.cjs"
+    },
+    "./mcp": {
+      "types": "./dist/mcp.d.ts",
+      "import": "./dist/mcp.js",
+      "require": "./dist/mcp.cjs"
+    },
+    "./mcp/server": {
+      "types": "./dist/mcp/server.d.ts",
+      "import": "./dist/mcp/server.js",
+      "require": "./dist/mcp/server.cjs"
+    },
+    "./mcp/client": {
+      "types": "./dist/mcp/client.d.ts",
+      "import": "./dist/mcp/client.js",
+      "require": "./dist/mcp/client.cjs"
+    },
+    "./plugin": {
+      "types": "./dist/plugin.d.ts",
+      "import": "./dist/plugin.js",
+      "require": "./dist/plugin.cjs"
+    },
+    "./runnable": {
+      "types": "./dist/runnable.d.ts",
+      "import": "./dist/runnable.js",
+      "require": "./dist/runnable.cjs"
+    },
+    "./builder": {
+      "types": "./dist/builder.d.ts",
+      "import": "./dist/builder.js",
+      "require": "./dist/builder.cjs"
+    },
     "./cli": {
       "import": "./dist/cli.js"
     }
@@ -49,11 +93,12 @@
     "clean": "rm -rf dist"
   },
   "dependencies": {
-    "@ryuhq/sdk-native": "0.1.14",
+    "@ryuhq/sdk-native": "workspace:*",
     "zod": "^4.1.13"
   },
   "devDependencies": {
-    "@types/bun": "^1.3.4",
+    "@types/bun": "catalog:",
+    "@types/node": "^22.20.1",
     "json-schema-to-typescript": "^15.0.4",
     "tsup": "^8.5.1",
     "typescript": "^5"