@ryuhq/sdk 0.1.14 → 0.2.0

package/dist/runnable.d.cts

@@ -0,0 +1,271 @@
+import { CapabilityReq, PluginManifest } from './manifest.cjs';
+import { i as Runnable, j as RunnableContext } from './tool-u-VR0fLF.cjs';
+export { B as BackgroundClient, a as BackgroundProcess, D as DurableClient, E as EnginesClient, G as GatewayClient, H as HttpPrimitiveTransportOptions, I as ImageClient, J as JsonSchemaProperty, M as MemoryClient, b as MemoryItem, P as PRIMITIVE_BINDINGS, c as PrimitiveBinding, d as PrimitiveTransport, R as RagChunk, e as RagClient, f as RagRerankResult, g as RealtimeClient, h as RealtimeSubscription, k as RyuPrimitives, S as SttClient, l as ToolOptions, m as ToolSchema, n as TtsClient, o as createPrimitives, p as defineTool, q as httpPrimitiveTransport } from './tool-u-VR0fLF.cjs';
+export { A as AppToolSpec, a as DefineAppOptions, b as appToolId, d as defineApp } from './app-DNaGmLVf.cjs';
+import 'zod';
+import './client-D5U6ssPc.cjs';
+
+/**
+ * defineAgent — factory for Runnable agents.
+ *
+ * An agent is a Runnable that drives a multi-turn model loop. It may reference a
+ * workflow as a named tool by including a Runnable with kind="workflow" in its
+ * `tools` list; the agent's run() implementation calls it like any other tool.
+ *
+ * All model calls must go through `ctx.gateway` — no direct provider imports.
+ *
+ * ## Composable primitive slots (the "Pokémon card" model, program §6b)
+ *
+ * `defineAgent` additionally accepts swappable-provider SLOTS —
+ * `defineAgent({ chat, rag, memory, tools, tts, stt })` — where each slot picks
+ * a provider for one attribute of the card. They **lower** to the manifest:
+ *   - `chat`  → the agent `RunnableMeta.config` (model / engine / persona);
+ *   - `rag` / `memory` / `tts` / `stt` → `requires.capabilities` edges the
+ *     capability broker binds to a provider (with an optional explicit override);
+ *   - `tools` → the tool ids the agent exposes.
+ *
+ * The slots are ADDITIVE: the classic `defineAgent({ id, name, run })` signature
+ * is unchanged. When `run` is omitted, a thin default run drives the `chat` slot
+ * through `ctx.gateway` (never a direct provider).
+ */
+
+/**
+ * A capability-backed slot (rag / memory / tts / stt). Written as:
+ *   - `true` — require the capability; the broker/registry picks the provider;
+ *   - `"com.acme.graphrag"` — bind this explicit provider app id;
+ *   - `{ provider?, minVersion? }` — provider override and/or a version floor.
+ */
+type CapabilitySlot = boolean | string | {
+    provider?: string;
+    minVersion?: string;
+};
+/**
+ * The chat/model slot — the agent's own, swappable model config. Written as a
+ * model-id string shorthand or the full object. Every field is a `string`; no
+ * provider union, so a new provider never needs an SDK change.
+ */
+type ChatSlot = string | {
+    /** Model id (swappable). */
+    model?: string;
+    /** Engine id (e.g. `"llamacpp"`, `"openai-compat"`). */
+    engine?: string;
+    /** System persona / instructions. */
+    persona?: string;
+    /** Preference key Core resolves to a model id (swappable, not hardcoded). */
+    modelPrefKey?: string;
+};
+/** The composable slots an agent card declares. All optional. */
+interface AgentSlots {
+    /** The chat/model slot (model + engine + persona). */
+    chat?: ChatSlot;
+    /** Memory provider slot → `requires.capabilities: [{ capability: "memory" }]`. */
+    memory?: CapabilitySlot;
+    /** RAG provider slot → `requires.capabilities: [{ capability: "rag" }]`. */
+    rag?: CapabilitySlot;
+    /** STT provider slot → `requires.capabilities: [{ capability: "stt" }]`. */
+    stt?: CapabilitySlot;
+    /** Tools the agent exposes — Runnables (workflows/tools) or bare tool ids. */
+    tools?: readonly (Runnable | string)[];
+    /** TTS provider slot → `requires.capabilities: [{ capability: "tts" }]`. */
+    tts?: CapabilitySlot;
+}
+/** Options accepted by `defineAgent`. */
+interface AgentOptions<TInput, TOutput> extends AgentSlots {
+    /** Stable unique identifier (e.g. "agent-researcher"). */
+    id: string;
+    /** Human-readable display name. */
+    name: string;
+    /**
+     * The agent's run implementation. OPTIONAL when slots are declared — a
+     * `chat`-slot default is synthesized (drives `ctx.gateway`). All model calls
+     * MUST go through `ctx.gateway`.
+     */
+    run?(input: TInput, ctx: RunnableContext): Promise<TOutput>;
+}
+/**
+ * The lowered "card": the swappable slots resolved to manifest-ready pieces —
+ * the persona/model config plus the `requires.capabilities` edges. This is what
+ * makes the Pokémon-card model literal in code.
+ */
+interface AgentCard {
+    /** Lowered capability edges for `requires.capabilities`. */
+    capabilities: CapabilityReq[];
+    /** Engine id from the `chat` slot. */
+    engine?: string;
+    /** Model id from the `chat` slot. */
+    model?: string;
+    /** Preference key from the `chat` slot. */
+    modelPrefKey?: string;
+    /** Persona/instructions from the `chat` slot. */
+    persona?: string;
+    /** Explicit provider bindings by capability (a slot that named a provider). */
+    providers: Record<string, string>;
+    /** Tool ids the agent exposes. */
+    tools: string[];
+}
+/** A defined agent: a Runnable plus its lowered card + a manifest lowering. */
+interface AgentRunnable<TInput = unknown, TOutput = unknown> extends Runnable<TInput, TOutput> {
+    /** The lowered slot card (empty edges when no slots were declared). */
+    readonly card: AgentCard;
+    /**
+     * Lower this agent (card + run identity) to a single-agent `manifest.json`
+     * `PluginManifest`: the agent `RunnableMeta` carries the persona/model
+     * config; `requires.capabilities` carries the slot edges. Throws if the
+     * assembled manifest is invalid.
+     */
+    toManifest(options: AgentManifestOptions): PluginManifest;
+}
+/** Options for {@link AgentRunnable.toManifest}. */
+interface AgentManifestOptions {
+    /** Extra permission grants beyond those implied by slots. */
+    grants?: string[];
+    /** Reverse-domain plugin id (e.g. `"com.acme.researcher"`). */
+    id: string;
+    /** Display name (defaults to the agent's name). */
+    name?: string;
+    /** Semver version (e.g. `"1.0.0"`). */
+    version: string;
+}
+/**
+ * Create a Runnable agent.
+ *
+ * The returned value satisfies `Runnable<TInput, TOutput>` with `kind = "agent"`
+ * and additionally exposes the lowered {@link AgentCard} + a `toManifest()`
+ * lowering, so a slot-composed agent round-trips to a valid `manifest.json`.
+ *
+ * @example Classic (unchanged, back-compat):
+ * ```ts
+ * const a = defineAgent({
+ *   id: "agent-researcher",
+ *   name: "Researcher",
+ *   async run({ query }, ctx) {
+ *     const r = await ctx.gateway.chat([{ role: "user", content: query }]);
+ *     return { answer: r.content };
+ *   },
+ * });
+ * ```
+ *
+ * @example Composable slots (the Pokémon card):
+ * ```ts
+ * const cmo = defineAgent({
+ *   id: "agent-cmo",
+ *   name: "CMO",
+ *   chat: { model: "gpt-4o", persona: "You are a CMO." },
+ *   rag: true,                    // requires.capabilities: [{ capability: "rag" }]
+ *   memory: { minVersion: "1.2" },
+ *   tts: "com.acme.elevenlabs",   // explicit provider override
+ * });
+ * const manifest = cmo.toManifest({ id: "com.acme.cmo", version: "1.0.0" });
+ * ```
+ */
+declare function defineAgent<TInput = unknown, TOutput = unknown>(options: AgentOptions<TInput, TOutput>): AgentRunnable<TInput, TOutput>;
+
+/**
+ * defineSkill — factory for Runnable skills.
+ *
+ * A skill is a prompt-template / capability block that is reusable across
+ * agents and workflows.  Like a tool it is stateless, but its primary purpose
+ * is to encapsulate a reusable prompt pattern rather than a side-effectful
+ * function.
+ *
+ * All model calls must go through `ctx.gateway` — no direct provider imports.
+ */
+
+/** Options accepted by `defineSkill`. */
+interface SkillOptions<TInput, TOutput> {
+    /** Stable unique identifier (e.g. "skill-summarise"). */
+    id: string;
+    /** Human-readable display name. */
+    name: string;
+    /**
+     * The skill's run implementation.
+     *
+     * Skills typically build a prompt from `input` and call `ctx.gateway.chat()`
+     * to get a model response, then return structured output.  All model calls
+     * MUST go through `ctx.gateway`.
+     */
+    run(input: TInput, ctx: RunnableContext): Promise<TOutput>;
+}
+/**
+ * Create a Runnable skill.
+ *
+ * The returned value satisfies the `Runnable<TInput, TOutput>` interface with
+ * `kind = "skill"`.
+ *
+ * @example
+ * ```ts
+ * const summariseSkill = defineSkill({
+ *   id: "skill-summarise",
+ *   name: "Summarise",
+ *   async run({ text }, ctx) {
+ *     const result = await ctx.gateway.chat([
+ *       { role: "user", content: `Summarise the following:\n\n${text}` },
+ *     ]);
+ *     return { summary: result.content };
+ *   },
+ * });
+ * ```
+ */
+declare function defineSkill<TInput = unknown, TOutput = unknown>(options: SkillOptions<TInput, TOutput>): Runnable<TInput, TOutput>;
+
+/**
+ * defineWorkflow — factory for Runnable workflows.
+ *
+ * A workflow orchestrates agents (and other Runnables) as sequential steps.
+ * It exposes the peer relationship described in packages/sdk/README.md §2:
+ * a workflow may list an agent as a step and call it via its run() method.
+ *
+ * All model calls must go through `ctx.gateway` — no direct provider imports.
+ */
+
+/**
+ * A single step inside a workflow definition.
+ *
+ * A step is any `Runnable` — most commonly an agent, but may also be a tool
+ * or a nested workflow (allowing composition without a strict hierarchy).
+ */
+type WorkflowStep<TStepInput = unknown, TStepOutput = unknown> = Runnable<TStepInput, TStepOutput>;
+/** Options accepted by `defineWorkflow`. */
+interface WorkflowOptions<TInput, TOutput> {
+    /** Stable unique identifier (e.g. "workflow-report"). */
+    id: string;
+    /** Human-readable display name. */
+    name: string;
+    /**
+     * The workflow's run implementation.
+     *
+     * May call any step via `step.run(input, ctx)`.  All model calls that
+     * steps make MUST go through `ctx.gateway`.
+     */
+    run(input: TInput, ctx: RunnableContext): Promise<TOutput>;
+    /**
+     * Optional list of Runnables this workflow orchestrates as steps.
+     *
+     * An agent may be listed here so the workflow can invoke it by calling
+     * `step.run(input, ctx)` — this is the peer relationship described in
+     * packages/sdk/README.md §2.
+     */
+    steps?: readonly Runnable[];
+}
+/**
+ * Create a Runnable workflow.
+ *
+ * The returned value satisfies the `Runnable<TInput, TOutput>` interface with
+ * `kind = "workflow"`.
+ *
+ * @example
+ * ```ts
+ * const myWorkflow = defineWorkflow({
+ *   id: "workflow-report",
+ *   name: "Report Workflow",
+ *   steps: [researchAgent],
+ *   async run({ topic }, ctx) {
+ *     const { answer } = await researchAgent.run({ query: topic }, ctx);
+ *     return { report: answer };
+ *   },
+ * });
+ * ```
+ */
+declare function defineWorkflow<TInput = unknown, TOutput = unknown>(options: WorkflowOptions<TInput, TOutput>): Runnable<TInput, TOutput>;
+
+export { type AgentCard, type AgentManifestOptions, type AgentOptions, type AgentRunnable, type AgentSlots, type CapabilitySlot, type ChatSlot, Runnable, RunnableContext, type SkillOptions, type WorkflowOptions, type WorkflowStep, defineAgent, defineSkill, defineWorkflow };

package/dist/runnable.d.ts

@@ -0,0 +1,271 @@
+import { CapabilityReq, PluginManifest } from './manifest.js';
+import { i as Runnable, j as RunnableContext } from './tool-DSx2bFx8.js';
+export { B as BackgroundClient, a as BackgroundProcess, D as DurableClient, E as EnginesClient, G as GatewayClient, H as HttpPrimitiveTransportOptions, I as ImageClient, J as JsonSchemaProperty, M as MemoryClient, b as MemoryItem, P as PRIMITIVE_BINDINGS, c as PrimitiveBinding, d as PrimitiveTransport, R as RagChunk, e as RagClient, f as RagRerankResult, g as RealtimeClient, h as RealtimeSubscription, k as RyuPrimitives, S as SttClient, l as ToolOptions, m as ToolSchema, n as TtsClient, o as createPrimitives, p as defineTool, q as httpPrimitiveTransport } from './tool-DSx2bFx8.js';
+export { A as AppToolSpec, a as DefineAppOptions, b as appToolId, d as defineApp } from './app-Bkw7LlCK.js';
+import 'zod';
+import './client-D5U6ssPc.js';
+
+/**
+ * defineAgent — factory for Runnable agents.
+ *
+ * An agent is a Runnable that drives a multi-turn model loop. It may reference a
+ * workflow as a named tool by including a Runnable with kind="workflow" in its
+ * `tools` list; the agent's run() implementation calls it like any other tool.
+ *
+ * All model calls must go through `ctx.gateway` — no direct provider imports.
+ *
+ * ## Composable primitive slots (the "Pokémon card" model, program §6b)
+ *
+ * `defineAgent` additionally accepts swappable-provider SLOTS —
+ * `defineAgent({ chat, rag, memory, tools, tts, stt })` — where each slot picks
+ * a provider for one attribute of the card. They **lower** to the manifest:
+ *   - `chat`  → the agent `RunnableMeta.config` (model / engine / persona);
+ *   - `rag` / `memory` / `tts` / `stt` → `requires.capabilities` edges the
+ *     capability broker binds to a provider (with an optional explicit override);
+ *   - `tools` → the tool ids the agent exposes.
+ *
+ * The slots are ADDITIVE: the classic `defineAgent({ id, name, run })` signature
+ * is unchanged. When `run` is omitted, a thin default run drives the `chat` slot
+ * through `ctx.gateway` (never a direct provider).
+ */
+
+/**
+ * A capability-backed slot (rag / memory / tts / stt). Written as:
+ *   - `true` — require the capability; the broker/registry picks the provider;
+ *   - `"com.acme.graphrag"` — bind this explicit provider app id;
+ *   - `{ provider?, minVersion? }` — provider override and/or a version floor.
+ */
+type CapabilitySlot = boolean | string | {
+    provider?: string;
+    minVersion?: string;
+};
+/**
+ * The chat/model slot — the agent's own, swappable model config. Written as a
+ * model-id string shorthand or the full object. Every field is a `string`; no
+ * provider union, so a new provider never needs an SDK change.
+ */
+type ChatSlot = string | {
+    /** Model id (swappable). */
+    model?: string;
+    /** Engine id (e.g. `"llamacpp"`, `"openai-compat"`). */
+    engine?: string;
+    /** System persona / instructions. */
+    persona?: string;
+    /** Preference key Core resolves to a model id (swappable, not hardcoded). */
+    modelPrefKey?: string;
+};
+/** The composable slots an agent card declares. All optional. */
+interface AgentSlots {
+    /** The chat/model slot (model + engine + persona). */
+    chat?: ChatSlot;
+    /** Memory provider slot → `requires.capabilities: [{ capability: "memory" }]`. */
+    memory?: CapabilitySlot;
+    /** RAG provider slot → `requires.capabilities: [{ capability: "rag" }]`. */
+    rag?: CapabilitySlot;
+    /** STT provider slot → `requires.capabilities: [{ capability: "stt" }]`. */
+    stt?: CapabilitySlot;
+    /** Tools the agent exposes — Runnables (workflows/tools) or bare tool ids. */
+    tools?: readonly (Runnable | string)[];
+    /** TTS provider slot → `requires.capabilities: [{ capability: "tts" }]`. */
+    tts?: CapabilitySlot;
+}
+/** Options accepted by `defineAgent`. */
+interface AgentOptions<TInput, TOutput> extends AgentSlots {
+    /** Stable unique identifier (e.g. "agent-researcher"). */
+    id: string;
+    /** Human-readable display name. */
+    name: string;
+    /**
+     * The agent's run implementation. OPTIONAL when slots are declared — a
+     * `chat`-slot default is synthesized (drives `ctx.gateway`). All model calls
+     * MUST go through `ctx.gateway`.
+     */
+    run?(input: TInput, ctx: RunnableContext): Promise<TOutput>;
+}
+/**
+ * The lowered "card": the swappable slots resolved to manifest-ready pieces —
+ * the persona/model config plus the `requires.capabilities` edges. This is what
+ * makes the Pokémon-card model literal in code.
+ */
+interface AgentCard {
+    /** Lowered capability edges for `requires.capabilities`. */
+    capabilities: CapabilityReq[];
+    /** Engine id from the `chat` slot. */
+    engine?: string;
+    /** Model id from the `chat` slot. */
+    model?: string;
+    /** Preference key from the `chat` slot. */
+    modelPrefKey?: string;
+    /** Persona/instructions from the `chat` slot. */
+    persona?: string;
+    /** Explicit provider bindings by capability (a slot that named a provider). */
+    providers: Record<string, string>;
+    /** Tool ids the agent exposes. */
+    tools: string[];
+}
+/** A defined agent: a Runnable plus its lowered card + a manifest lowering. */
+interface AgentRunnable<TInput = unknown, TOutput = unknown> extends Runnable<TInput, TOutput> {
+    /** The lowered slot card (empty edges when no slots were declared). */
+    readonly card: AgentCard;
+    /**
+     * Lower this agent (card + run identity) to a single-agent `manifest.json`
+     * `PluginManifest`: the agent `RunnableMeta` carries the persona/model
+     * config; `requires.capabilities` carries the slot edges. Throws if the
+     * assembled manifest is invalid.
+     */
+    toManifest(options: AgentManifestOptions): PluginManifest;
+}
+/** Options for {@link AgentRunnable.toManifest}. */
+interface AgentManifestOptions {
+    /** Extra permission grants beyond those implied by slots. */
+    grants?: string[];
+    /** Reverse-domain plugin id (e.g. `"com.acme.researcher"`). */
+    id: string;
+    /** Display name (defaults to the agent's name). */
+    name?: string;
+    /** Semver version (e.g. `"1.0.0"`). */
+    version: string;
+}
+/**
+ * Create a Runnable agent.
+ *
+ * The returned value satisfies `Runnable<TInput, TOutput>` with `kind = "agent"`
+ * and additionally exposes the lowered {@link AgentCard} + a `toManifest()`
+ * lowering, so a slot-composed agent round-trips to a valid `manifest.json`.
+ *
+ * @example Classic (unchanged, back-compat):
+ * ```ts
+ * const a = defineAgent({
+ *   id: "agent-researcher",
+ *   name: "Researcher",
+ *   async run({ query }, ctx) {
+ *     const r = await ctx.gateway.chat([{ role: "user", content: query }]);
+ *     return { answer: r.content };
+ *   },
+ * });
+ * ```
+ *
+ * @example Composable slots (the Pokémon card):
+ * ```ts
+ * const cmo = defineAgent({
+ *   id: "agent-cmo",
+ *   name: "CMO",
+ *   chat: { model: "gpt-4o", persona: "You are a CMO." },
+ *   rag: true,                    // requires.capabilities: [{ capability: "rag" }]
+ *   memory: { minVersion: "1.2" },
+ *   tts: "com.acme.elevenlabs",   // explicit provider override
+ * });
+ * const manifest = cmo.toManifest({ id: "com.acme.cmo", version: "1.0.0" });
+ * ```
+ */
+declare function defineAgent<TInput = unknown, TOutput = unknown>(options: AgentOptions<TInput, TOutput>): AgentRunnable<TInput, TOutput>;
+
+/**
+ * defineSkill — factory for Runnable skills.
+ *
+ * A skill is a prompt-template / capability block that is reusable across
+ * agents and workflows.  Like a tool it is stateless, but its primary purpose
+ * is to encapsulate a reusable prompt pattern rather than a side-effectful
+ * function.
+ *
+ * All model calls must go through `ctx.gateway` — no direct provider imports.
+ */
+
+/** Options accepted by `defineSkill`. */
+interface SkillOptions<TInput, TOutput> {
+    /** Stable unique identifier (e.g. "skill-summarise"). */
+    id: string;
+    /** Human-readable display name. */
+    name: string;
+    /**
+     * The skill's run implementation.
+     *
+     * Skills typically build a prompt from `input` and call `ctx.gateway.chat()`
+     * to get a model response, then return structured output.  All model calls
+     * MUST go through `ctx.gateway`.
+     */
+    run(input: TInput, ctx: RunnableContext): Promise<TOutput>;
+}
+/**
+ * Create a Runnable skill.
+ *
+ * The returned value satisfies the `Runnable<TInput, TOutput>` interface with
+ * `kind = "skill"`.
+ *
+ * @example
+ * ```ts
+ * const summariseSkill = defineSkill({
+ *   id: "skill-summarise",
+ *   name: "Summarise",
+ *   async run({ text }, ctx) {
+ *     const result = await ctx.gateway.chat([
+ *       { role: "user", content: `Summarise the following:\n\n${text}` },
+ *     ]);
+ *     return { summary: result.content };
+ *   },
+ * });
+ * ```
+ */
+declare function defineSkill<TInput = unknown, TOutput = unknown>(options: SkillOptions<TInput, TOutput>): Runnable<TInput, TOutput>;
+
+/**
+ * defineWorkflow — factory for Runnable workflows.
+ *
+ * A workflow orchestrates agents (and other Runnables) as sequential steps.
+ * It exposes the peer relationship described in packages/sdk/README.md §2:
+ * a workflow may list an agent as a step and call it via its run() method.
+ *
+ * All model calls must go through `ctx.gateway` — no direct provider imports.
+ */
+
+/**
+ * A single step inside a workflow definition.
+ *
+ * A step is any `Runnable` — most commonly an agent, but may also be a tool
+ * or a nested workflow (allowing composition without a strict hierarchy).
+ */
+type WorkflowStep<TStepInput = unknown, TStepOutput = unknown> = Runnable<TStepInput, TStepOutput>;
+/** Options accepted by `defineWorkflow`. */
+interface WorkflowOptions<TInput, TOutput> {
+    /** Stable unique identifier (e.g. "workflow-report"). */
+    id: string;
+    /** Human-readable display name. */
+    name: string;
+    /**
+     * The workflow's run implementation.
+     *
+     * May call any step via `step.run(input, ctx)`.  All model calls that
+     * steps make MUST go through `ctx.gateway`.
+     */
+    run(input: TInput, ctx: RunnableContext): Promise<TOutput>;
+    /**
+     * Optional list of Runnables this workflow orchestrates as steps.
+     *
+     * An agent may be listed here so the workflow can invoke it by calling
+     * `step.run(input, ctx)` — this is the peer relationship described in
+     * packages/sdk/README.md §2.
+     */
+    steps?: readonly Runnable[];
+}
+/**
+ * Create a Runnable workflow.
+ *
+ * The returned value satisfies the `Runnable<TInput, TOutput>` interface with
+ * `kind = "workflow"`.
+ *
+ * @example
+ * ```ts
+ * const myWorkflow = defineWorkflow({
+ *   id: "workflow-report",
+ *   name: "Report Workflow",
+ *   steps: [researchAgent],
+ *   async run({ topic }, ctx) {
+ *     const { answer } = await researchAgent.run({ query: topic }, ctx);
+ *     return { report: answer };
+ *   },
+ * });
+ * ```
+ */
+declare function defineWorkflow<TInput = unknown, TOutput = unknown>(options: WorkflowOptions<TInput, TOutput>): Runnable<TInput, TOutput>;
+
+export { type AgentCard, type AgentManifestOptions, type AgentOptions, type AgentRunnable, type AgentSlots, type CapabilitySlot, type ChatSlot, Runnable, RunnableContext, type SkillOptions, type WorkflowOptions, type WorkflowStep, defineAgent, defineSkill, defineWorkflow };

package/dist/runnable.js

@@ -0,0 +1,28 @@
+import {
+  defineAgent,
+  defineSkill,
+  defineTool,
+  defineWorkflow
+} from "./chunk-T5676WL2.js";
+import {
+  appToolId,
+  defineApp
+} from "./chunk-W3KPP4WN.js";
+import "./chunk-IEUQ3CDG.js";
+import {
+  PRIMITIVE_BINDINGS,
+  createPrimitives,
+  httpPrimitiveTransport
+} from "./chunk-A3RGEPDG.js";
+import "./chunk-IKEDLLFY.js";
+export {
+  PRIMITIVE_BINDINGS,
+  appToolId,
+  createPrimitives,
+  defineAgent,
+  defineApp,
+  defineSkill,
+  defineTool,
+  defineWorkflow,
+  httpPrimitiveTransport
+};