@agentorg/cli 0.0.3 → 0.0.4

package/{node_modules → dist/node_modules}/@agentorg/interfaces/dist/src/hub.js

@@ -34,8 +34,8 @@ export const hubPackages = defineInterface({
         /**
          * Build a package from its source, given as data (`package.json` and files under `src/`, up to
          * 768 KiB), and add it as `add` does. It's `agentorg build`'s build, reading no tsconfig; its
-         * files import only `@agentorg/sdk`, `@agentorg/interfaces` and `zod` by name, and nothing outside
-         * the package's folder, never by a pattern. A build that fails is
+         * files import only `@agentorg/sdk`, `@agentorg/interfaces`, `zod`, `react`, `react-dom` and
+         * `@agentorg/kit` by name, and nothing outside the package's folder, never by a pattern. A build that fails is
          * `Refused("build")` with the build's message, so the source can be fixed and built again.
          */
         build: method({
@@ -75,6 +75,12 @@ export const Actor = z.object({
     host: z.object({ available: z.boolean(), reason: z.string().optional() }).optional(),
     /** For a package Actor: its view modules, which the person's shell can place. */
     views: z.array(z.string()).optional(),
+    /**
+     * The Actor it was created for, when a manager created it on another's behalf (the installer
+     * names its caller). Provenance only: the Hub grants nothing from it; only a rule the person
+     * turned on may act on it.
+     */
+    installedFor: Id.optional(),
 });
 /** One line of an Actor's log, from its `ctx.log` or its process's own output. */
 export const LogLine = z.object({
@@ -93,12 +99,14 @@ export const hubActors = defineInterface({
         /**
          * With a package, an Actor that runs it; without, an external one, whose credential is returned
          * once. `bindings` wire the new Actor's slots at once, with the caller's export-side authority
-         * (the creation is the slot side's yes), for example to its own `hub.grants@1`.
+         * (the creation is the slot side's yes), for example to its own `hub.grants@1`. `for` names
+         * the Actor it is made for, recorded as `installedFor`; only a manager may give it.
          */
         create: method({
             input: z.object({
                 name: z.string().min(1).max(128),
                 package: Hash.optional(),
+                for: Id.optional(),
                 bindings: z
                     .array(z.object({ slot: Name, provider: Id, export: Name }))
                     .max(64)
@@ -127,11 +135,18 @@ export const hubActors = defineInterface({
     },
 });
 const Wiring = { consumer: Id, slot: Name, provider: Id, export: Name };
+/** A slot made at run time: one segment, at most 48 characters, so tools named from it fit. */
+export const SlotName = z
+    .string()
+    .regex(/^[a-z][A-Za-z0-9_]*$/)
+    .max(48);
 export const Binding = z.object({
     ...Wiring,
     interface: z.string(),
     madeBy: Id,
     at: z.string(),
+    /** A slot made at run time by `hub.grants.expose`: it goes with this binding. */
+    exposed: z.literal(true).optional(),
 });
 export const BindingRequest = z.object({
     requestId: Id,
@@ -141,6 +156,11 @@ export const BindingRequest = z.object({
     reason: z.string(),
     requestedBy: Id,
     at: z.string(),
+    /**
+     * A request to expose: `slot` is the name the slot will have on `consumer`, made when it is
+     * approved. Approve it with `expose({provider, export, to: consumer, as: slot})`.
+     */
+    exposed: z.literal(true).optional(),
 });
 /**
  * `hub.grants@1`: binding with the caller's own authority, so it is safe to give any Actor. A
@@ -164,6 +184,23 @@ export const hubGrants = defineInterface({
         }),
         /** The consumer, the provider or a manager may unbind. */
         unbind: method({ input: z.object({ consumer: Id, slot: Name }), output: Empty }),
+        /**
+         * Expose an `rpc` export to one Actor: a slot made on `to`, typed by the export's interface,
+         * named `as` (by default the provider's name camelCased, `_`, and the export's last part, made
+         * unique on `to`), and bound to the export, in one step. Its authority is a binding's: with
+         * both ends it is made; with one, it is a request to the other end's approvers, who approve it
+         * by calling `expose` with the request's fields. The same export already exposed to `to`
+         * gives that slot back.
+         */
+        expose: method({
+            input: z.object({ provider: Id, export: Name, to: Id, as: SlotName.optional() }),
+            output: z.union([
+                z.object({ exposed: z.literal(true), slot: SlotName }),
+                z.object({ exposed: z.literal(false), slot: SlotName, requestId: Id }),
+            ]),
+        }),
+        /** Remove a slot made by `expose`, with its binding: as `unbind`, the consumer, the provider or a manager may. */
+        unexpose: method({ input: z.object({ to: Id, slot: SlotName }), output: Empty }),
         request: method({
             input: z.object({ ...Wiring, reason: z.string().min(1).max(1000) }),
             output: z.object({ requestId: Id }),

package/{node_modules → dist/node_modules}/@agentorg/interfaces/dist/src/index.d.ts

@@ -6,6 +6,7 @@ export { Composition, installer } from "./installer.js";
 export { kv } from "./kv.js";
 export { layout, Placement } from "./layout.js";
 export { Item, llmSession, OutputItem, Tool } from "./llm-session.js";
+export { appRules, Rule } from "./rules.js";
 export { storageAdmin } from "./storage-admin.js";
 export { uiShell } from "./ui-shell.js";
 export { uiView } from "./ui-view.js";

package/{node_modules → dist/node_modules}/@agentorg/interfaces/dist/src/index.js

@@ -6,6 +6,7 @@ export { Composition, installer } from "./installer.js";
 export { kv } from "./kv.js";
 export { layout, Placement } from "./layout.js";
 export { Item, llmSession, OutputItem, Tool } from "./llm-session.js";
+export { appRules, Rule } from "./rules.js";
 export { storageAdmin } from "./storage-admin.js";
 export { uiShell } from "./ui-shell.js";
 export { uiView } from "./ui-view.js";

package/{node_modules → dist/node_modules}/@agentorg/interfaces/dist/src/installer.d.ts

@@ -39,6 +39,10 @@ export declare const installer: import("@agentorg/sdk").RpcInterface<"installer"
      */
     plan: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
         package: z.ZodString;
+        expose: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            export: z.ZodString;
+            to: z.ZodString;
+        }, z.core.$strip>>>;
     }, z.core.$strip>, z.ZodObject<{
         slots: z.ZodArray<z.ZodObject<{
             slot: z.ZodString;
@@ -49,6 +53,14 @@ export declare const installer: import("@agentorg/sdk").RpcInterface<"installer"
             }, z.core.$strip>>;
         }, z.core.$strip>>;
         views: z.ZodArray<z.ZodString>;
+        exposes: z.ZodArray<z.ZodObject<{
+            export: z.ZodString;
+            to: z.ZodString;
+            settles: z.ZodEnum<{
+                granted: "granted";
+                request: "request";
+            }>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>;
     /**
      * Create an Actor of the package named `name`, with exactly these connections, all or none.
@@ -58,6 +70,12 @@ export declare const installer: import("@agentorg/sdk").RpcInterface<"installer"
      * slot bound to `storage`'s `kv` gets the package's seed for it (an object of key to value);
      * a seed whose slot isn't is listed in `unseeded`. Then it is started if `start`. If a seed or
      * the start fails, the new Actor is closed. Slots left out stay unbound, listed in `unbound`.
+     * The Actor is recorded as made for the caller (`installedFor`), which grants nothing.
+     *
+     * `expose` lists the new Actor's exports to expose (`rpc` exports of its host modules), each to one Actor, all or none like the
+     * connections: a manager's are made now (`granted`, with the slot); one to the caller itself
+     * is left for the caller to file (`request`, with the exact `hub.grants.expose` call); any
+     * other is refused, and nothing is created. Nothing is exposed that isn't listed.
      */
     install: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
         package: z.ZodString;
@@ -67,10 +85,29 @@ export declare const installer: import("@agentorg/sdk").RpcInterface<"installer"
             export: z.ZodString;
         }, z.core.$strip>>;
         start: z.ZodOptional<z.ZodBoolean>;
+        expose: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            export: z.ZodString;
+            to: z.ZodString;
+        }, z.core.$strip>>>;
     }, z.core.$strip>, z.ZodObject<{
         actorId: z.ZodString;
         unbound: z.ZodArray<z.ZodString>;
         unseeded: z.ZodArray<z.ZodString>;
+        exposures: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            export: z.ZodString;
+            to: z.ZodString;
+            settles: z.ZodLiteral<"granted">;
+            slot: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            export: z.ZodString;
+            to: z.ZodString;
+            settles: z.ZodLiteral<"request">;
+            call: z.ZodObject<{
+                provider: z.ZodString;
+                export: z.ZodString;
+                to: z.ZodString;
+            }, z.core.$strip>;
+        }, z.core.$strip>]>>;
     }, z.core.$strip>>;
     /**
      * The system as it is, as a composition: every package Actor that isn't closed, the

package/{node_modules → dist/node_modules}/@agentorg/interfaces/dist/src/installer.js

@@ -1,9 +1,17 @@
 import { defineInterface, method } from "@agentorg/sdk";
 import { z } from "zod";
-import { Id, Name } from "./hub.js";
+import { Id, Name, SlotName } from "./hub.js";
 const Hash = z.string().regex(/^sha256-[0-9a-f]{64}$/);
 /** An export of a running Actor, by its id and the export's name. */
 const Target = z.object({ actor: Id, export: Name });
+/** One of the new Actor's `rpc` exports (`module.export`), to expose to the Actor `to`. */
+const Exposure = z.object({ export: Name, to: Id });
+/**
+ * How an exposure settles, by the caller's own authority: `granted`, made now (the caller holds
+ * both sides: it is a manager), or `request`, which the caller files itself with
+ * `hub.grants.expose` (it holds `to`'s side: it is `to`). Nothing else is exposed.
+ */
+const Settles = z.enum(["granted", "request"]);
 /** An Actor of a composition, by the name it has there. */
 const ActorName = z.string().min(1).max(128);
 /**
@@ -46,10 +54,15 @@ export const installer = defineInterface({
          * can place.
          */
         plan: method({
-            input: z.object({ package: Hash }),
+            input: z.object({ package: Hash, expose: z.array(Exposure).max(64).optional() }),
             output: z.object({
                 slots: z.array(z.object({ slot: Name, interface: z.string(), candidates: z.array(Target) })),
                 views: z.array(z.string()),
+                /**
+                 * Each `expose` entry given, with how `install` would settle it for this caller; an entry
+                 * `install` would refuse is refused here the same way.
+                 */
+                exposes: z.array(Exposure.extend({ settles: Settles })),
             }),
         }),
         /**
@@ -60,6 +73,12 @@ export const installer = defineInterface({
          * slot bound to `storage`'s `kv` gets the package's seed for it (an object of key to value);
          * a seed whose slot isn't is listed in `unseeded`. Then it is started if `start`. If a seed or
          * the start fails, the new Actor is closed. Slots left out stay unbound, listed in `unbound`.
+         * The Actor is recorded as made for the caller (`installedFor`), which grants nothing.
+         *
+         * `expose` lists the new Actor's exports to expose (`rpc` exports of its host modules), each to one Actor, all or none like the
+         * connections: a manager's are made now (`granted`, with the slot); one to the caller itself
+         * is left for the caller to file (`request`, with the exact `hub.grants.expose` call); any
+         * other is refused, and nothing is created. Nothing is exposed that isn't listed.
          */
         install: method({
             input: z.object({
@@ -67,8 +86,20 @@ export const installer = defineInterface({
                 name: z.string().min(1).max(128),
                 connections: z.record(Name, Target),
                 start: z.boolean().optional(),
+                expose: z.array(Exposure).max(64).optional(),
+            }),
+            output: z.object({
+                actorId: Id,
+                unbound: z.array(Name),
+                unseeded: z.array(Name),
+                exposures: z.array(z.union([
+                    Exposure.extend({ settles: z.literal("granted"), slot: SlotName }),
+                    Exposure.extend({
+                        settles: z.literal("request"),
+                        call: z.object({ provider: Id, export: Name, to: Id }),
+                    }),
+                ])),
             }),
-            output: z.object({ actorId: Id, unbound: z.array(Name), unseeded: z.array(Name) }),
         }),
         /**
          * The system as it is, as a composition: every package Actor that isn't closed, the

package/dist/node_modules/@agentorg/interfaces/dist/src/rules.d.ts

@@ -0,0 +1,35 @@
+import { z } from "zod";
+/**
+ * One named rule: a convenience the person turns on, off unless they do. `says` is what it does,
+ * in the person's words.
+ */
+export declare const Rule: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    says: z.ZodString;
+    on: z.ZodBoolean;
+}, z.core.$strip>;
+/**
+ * `app.rules@1`: the person's named rules. Each is held by the person's Actor (the app's gateway),
+ * which acts on a rule that is on as the person, a manager, and only within what the person could
+ * grant. A rule is the only thing that may act on provenance such as an Actor's `installedFor`.
+ */
+export declare const appRules: import("@agentorg/sdk").RpcInterface<"app.rules", {
+    /** Every rule the app knows, each with whether it is on. */
+    list: import("@agentorg/sdk").MethodSpec<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+        rules: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            says: z.ZodString;
+            on: z.ZodBoolean;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    /** Turn a rule on or off. Turning one on settles what already waits for it. */
+    set: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
+        id: z.ZodString;
+        on: z.ZodBoolean;
+    }, z.core.$strip>, z.ZodObject<{}, z.core.$strip>>;
+}, {
+    /** A rule was turned on or off; read them again with `list`. */
+    changed: import("@agentorg/sdk").EventSpec<z.ZodObject<{}, z.core.$strip>>;
+}, 1>;

package/dist/node_modules/@agentorg/interfaces/dist/src/rules.js

@@ -0,0 +1,37 @@
+import { defineInterface, event, method } from "@agentorg/sdk";
+import { z } from "zod";
+/** A named rule's id: lowercase words joined by hyphens. */
+const RuleId = z
+    .string()
+    .regex(/^[a-z][a-z0-9]*(-[a-z0-9]+)*$/)
+    .max(64);
+/**
+ * One named rule: a convenience the person turns on, off unless they do. `says` is what it does,
+ * in the person's words.
+ */
+export const Rule = z.object({
+    id: RuleId,
+    name: z.string().max(200),
+    says: z.string().max(1000),
+    on: z.boolean(),
+});
+/**
+ * `app.rules@1`: the person's named rules. Each is held by the person's Actor (the app's gateway),
+ * which acts on a rule that is on as the person, a manager, and only within what the person could
+ * grant. A rule is the only thing that may act on provenance such as an Actor's `installedFor`.
+ */
+export const appRules = defineInterface({
+    name: "app.rules",
+    major: 1,
+    kind: "rpc",
+    methods: {
+        /** Every rule the app knows, each with whether it is on. */
+        list: method({ input: z.object({}), output: z.object({ rules: z.array(Rule) }) }),
+        /** Turn a rule on or off. Turning one on settles what already waits for it. */
+        set: method({ input: z.object({ id: RuleId, on: z.boolean() }), output: z.object({}) }),
+    },
+    events: {
+        /** A rule was turned on or off; read them again with `list`. */
+        changed: event(z.object({})),
+    },
+});

package/dist/node_modules/@agentorg/kit/dist/src/chat.d.ts

@@ -0,0 +1,37 @@
+import { type ReactNode } from "react";
+/** One message of a chat, as `chat@1` carries it. A `tool` message may say which tool ran. */
+export interface ChatEntry {
+    id: string;
+    role: "user" | "assistant" | "tool";
+    text: string;
+    tool?: {
+        name: string;
+        state: "running" | "done" | "refused";
+        input?: string;
+        output?: string;
+    };
+}
+export interface ChatProps {
+    /** In order; a reply still streaming is an `assistant` entry like any other. */
+    messages: readonly ChatEntry[];
+    /** A turn is running: Send becomes Stop. */
+    running: boolean;
+    /** Send the person's text; when it rejects, the text goes back in the composer. */
+    onSend(text: string): Promise<void>;
+    onCancel(): void;
+    /** Run the last turn again: offered under the last reply. */
+    onRetry?(): void;
+    /** Older messages remain: "Earlier messages" loads them. */
+    hasEarlier?: boolean;
+    onEarlier?(): Promise<void>;
+    /** Above the composer: a notice the caller draws (a refusal and its action). */
+    notice?: ReactNode;
+    /** Beside the send button: the plan line, say. */
+    footer?: ReactNode;
+    /** The agent's name and avatar, over its replies; its name names the composer. */
+    name?: string;
+    avatar?: ReactNode;
+    /** The composer's accessible name; by default "Message". */
+    label?: string;
+}
+export declare function Chat(props: ChatProps): import("react").JSX.Element;

package/dist/node_modules/@agentorg/kit/dist/src/chat.js

@@ -0,0 +1,131 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// A conversation with an agent, on assistant-ui's primitives (Thread, Message, Composer,
+// ActionBar) over an external store: the caller keeps the messages and runs the turns.
+import { ActionBarPrimitive, AssistantRuntimeProvider, ComposerPrimitive, MessagePrimitive, ThreadPrimitive, useAui, useAuiState, useExternalStoreRuntime, } from "@assistant-ui/react";
+import { createContext, useContext, useEffect, useState } from "react";
+import { IconButton } from "./components.js";
+import { ChevronIcon, CopyIcon, RetryIcon, SendIcon, StopIcon, ToolIcon } from "./icons.js";
+import { Markdown } from "./markdown.js";
+/**
+ * The entries as assistant-ui's messages: a person's message each, and every run of replies and
+ * tool messages between two of theirs as one reply whose parts are in order. A tool message is a
+ * tool-call part that keeps its entry, so a card can be drawn from it.
+ */
+function threadOf(entries, running) {
+    const thread = [];
+    let reply;
+    const close = () => {
+        if (reply)
+            thread.push({ role: "assistant", id: reply.id, content: reply.content });
+        reply = undefined;
+    };
+    for (const entry of entries) {
+        if (entry.role === "user") {
+            close();
+            thread.push({ role: "user", id: entry.id, content: [{ type: "text", text: entry.text }] });
+            continue;
+        }
+        reply ??= { id: entry.id, content: [] };
+        reply.content.push(entry.role === "assistant"
+            ? { type: "text", text: entry.text }
+            : {
+                type: "tool-call",
+                toolCallId: entry.id,
+                toolName: entry.tool?.name ?? "",
+                argsText: entry.tool?.input ?? "",
+                artifact: entry,
+            });
+    }
+    close();
+    const last = thread.at(-1);
+    if (running && last?.role === "assistant")
+        thread[thread.length - 1] = { ...last, status: { type: "running" } };
+    return thread;
+}
+const textOf = (message) => message.content.map((part) => (part.type === "text" ? part.text : "")).join("");
+export function Chat(props) {
+    const { messages, running, onSend, onCancel, onRetry, hasEarlier, onEarlier } = props;
+    // A refused send puts its text back, into the composer the runtime keeps.
+    const [kept, setKept] = useState();
+    const runtime = useExternalStoreRuntime({
+        messages: threadOf(messages, running),
+        convertMessage: (message) => message,
+        isRunning: running,
+        onNew: async (message) => {
+            const text = textOf(message);
+            try {
+                await onSend(text);
+            }
+            catch {
+                setKept((was) => ({ text, n: (was?.n ?? 0) + 1 }));
+            }
+        },
+        onCancel: async () => onCancel(),
+        // The options keep one shape whatever is given: the runtime doesn't take a change of shape.
+        onReload: async () => onRetry?.(),
+        hasEarlier: !!(hasEarlier && onEarlier),
+        onLoadEarlier: async () => onEarlier?.(),
+    });
+    return (_jsx(AssistantRuntimeProvider, { runtime: runtime, children: _jsx(Thread, { ...props, kept: kept }) }));
+}
+function Thread({ notice, footer, name, avatar, label = "Message", kept, running, onRetry, }) {
+    return (_jsx(Agent.Provider, { value: { name, avatar, retry: !!onRetry }, children: _jsxs(ThreadPrimitive.Root, { className: "kit-chat", children: [_jsx(ThreadPrimitive.Viewport, { className: "kit-chat-viewport", role: "log", "aria-label": "Conversation", children: _jsxs("div", { className: "kit-chat-thread", children: [_jsx(Earlier, {}), _jsx(ThreadPrimitive.Messages, { components: { UserMessage, AssistantMessage } }), running && _jsx(Thinking, {})] }) }), notice && (_jsx("div", { className: "kit-chat-notice", role: "alert", children: notice })), _jsx("div", { className: "kit-chat-composer-wrap", children: _jsxs(ComposerPrimitive.Root, { className: "kit-chat-composer", children: [_jsx(ComposerPrimitive.Input, { className: "kit-chat-input", "aria-label": label, placeholder: name ? `Message ${name}` : label, submitMode: "enter" }), _jsx(Restore, { kept: kept }), _jsxs("div", { className: "kit-chat-composer-row", children: [footer, running ? (_jsx(ComposerPrimitive.Cancel, { className: "kit-chat-send", "aria-label": "Stop", children: _jsx(StopIcon, {}) })) : (_jsx(ComposerPrimitive.Send, { className: "kit-chat-send", "aria-label": "Send", children: _jsx(SendIcon, {}) }))] })] }) })] }) }));
+}
+/** "Earlier messages", only while there are some. */
+function Earlier() {
+    const some = useAuiState(({ thread }) => thread.hasEarlier);
+    if (!some)
+        return null;
+    return (_jsx(ThreadPrimitive.LoadEarlier, { className: "kit-chat-earlier", children: "Earlier messages" }));
+}
+/** Puts a refused send's text back in the composer, once per refusal. */
+function Restore({ kept }) {
+    const aui = useAui();
+    useEffect(() => {
+        if (kept)
+            aui.composer.setText(kept.text);
+    }, [aui, kept]);
+    return null;
+}
+/** Who the replies are from, and whether they offer Retry: for every reply in the thread. */
+const Agent = createContext({
+    name: undefined,
+    avatar: undefined,
+    retry: false,
+});
+const PlainText = ({ text }) => _jsx(_Fragment, { children: text });
+const MarkdownText = ({ text }) => _jsx(Markdown, { text: text });
+const USER_PARTS = { Text: PlainText };
+const REPLY_PARTS = { Text: MarkdownText, tools: { Override: Tool } };
+const UserMessage = () => (_jsx(MessagePrimitive.Root, { className: "kit-chat-user", children: _jsx(MessagePrimitive.Parts, { components: USER_PARTS }) }));
+/** Dots while the turn has nothing to show yet: before the first text or tool of its reply. */
+function Thinking() {
+    const shown = useAuiState(({ thread }) => {
+        const last = thread.messages.at(-1);
+        return last?.role === "assistant" && last.content.length > 0;
+    });
+    if (shown)
+        return null;
+    return (_jsxs("div", { className: "kit-chat-thinking", role: "status", "aria-label": "Thinking", children: [_jsx("i", {}), _jsx("i", {}), _jsx("i", {})] }));
+}
+function AssistantMessage() {
+    const { name, avatar, retry } = useContext(Agent);
+    const running = useAuiState(({ message }) => message.status?.type === "running");
+    // Retry runs the last turn again, so only the last reply offers it; earlier replies show their
+    // bar on hover.
+    const last = useAuiState(({ message }) => message.isLast);
+    return (_jsxs(MessagePrimitive.Root, { className: "kit-chat-assistant", ...(last ? { "data-last": "" } : {}), children: [name && (_jsxs("div", { className: "kit-chat-who", children: [avatar, name] })), _jsx(MessagePrimitive.Parts, { components: REPLY_PARTS }), _jsxs(ActionBarPrimitive.Root, { className: "kit-chat-bar", ...(running ? { "data-hidden": "" } : {}), children: [_jsx(ActionBarPrimitive.Copy, { asChild: true, children: _jsx(IconButton, { label: "Copy", children: _jsx(CopyIcon, {}) }) }), retry && last && (_jsx(ActionBarPrimitive.Reload, { asChild: true, children: _jsx(IconButton, { label: "Retry", children: _jsx(RetryIcon, {}) }) }))] })] }));
+}
+/**
+ * A tool message: a card with the tool's name and how it ended, opened for what went in and what
+ * came back, when the message says which tool ran; otherwise the one line it is.
+ */
+function Tool({ artifact }) {
+    const entry = artifact;
+    const [open, setOpen] = useState(false);
+    const tool = entry.tool;
+    if (!tool)
+        return _jsx("div", { className: "kit-chat-step", children: entry.text });
+    const body = [tool.input, tool.output && `→ ${tool.output}`].filter(Boolean).join("\n");
+    return (_jsxs("div", { className: "kit-tool", ...(open ? { "data-open": "" } : {}), children: [_jsxs("button", { type: "button", "aria-expanded": open, onClick: () => setOpen(!open), children: [_jsx(ToolIcon, {}), _jsx("span", { className: "kit-tool-title", children: entry.text }), _jsx("span", { className: "kit-tool-name", children: tool.name }), tool.state === "done" ? (_jsx("span", { className: "kit-tool-done", role: "img", "aria-label": "done", children: "\u2713" })) : tool.state === "refused" ? (_jsx("span", { className: "kit-tool-refused", children: "refused" })) : (_jsx("span", { className: "kit-chat-thinking", role: "status", "aria-label": "running", children: _jsx("i", {}) })), _jsx(ChevronIcon, { className: "kit-tool-chevron" })] }), open && body && _jsx("pre", { className: "kit-tool-body", children: body })] }));
+}

package/dist/node_modules/@agentorg/kit/dist/src/components.d.ts

@@ -0,0 +1,94 @@
+import type { ButtonHTMLAttributes, CSSProperties, FormEvent, InputHTMLAttributes, ReactNode, SelectHTMLAttributes } from "react";
+export type ButtonProps = ButtonHTMLAttributes<HTMLButtonElement> & {
+    /** `primary` is the accent; `quiet` reads as a link. */
+    variant?: "primary" | "quiet";
+};
+export declare function Button({ variant, className, type, ...props }: ButtonProps): import("react").JSX.Element;
+/** A button with only an icon: its `label` is its accessible name, and its tooltip. */
+export declare function IconButton({ label, className, type, ...props }: ButtonHTMLAttributes<HTMLButtonElement> & {
+    label: string;
+}): import("react").JSX.Element;
+export declare function Switch({ checked, onChange, label, disabled, }: {
+    checked: boolean;
+    onChange(checked: boolean): void;
+    label: string;
+    disabled?: boolean;
+}): import("react").JSX.Element;
+export declare function Field({ className, ...props }: InputHTMLAttributes<HTMLInputElement>): import("react").JSX.Element;
+/** The browser's own select, drawn in the kit's look: accessible and native on every device. */
+export declare function Select({ className, ...props }: SelectHTMLAttributes<HTMLSelectElement>): import("react").JSX.Element;
+/**
+ * A modal dialog: focus held inside, Escape and a click outside close it, and focus goes back to
+ * what opened it. `title` names it. With `onSubmit` the dialog is a form, so Enter submits it.
+ */
+export declare function Dialog({ open, onClose, onSubmit, title, children, }: {
+    open?: boolean;
+    onClose(): void;
+    onSubmit?(event: FormEvent<HTMLFormElement>): void;
+    title: ReactNode;
+    children: ReactNode;
+}): import("react").JSX.Element;
+/** A row of buttons at the end of a dialog or a form. */
+export declare const Actions: ({ children }: {
+    children: ReactNode;
+}) => import("react").JSX.Element;
+/**
+ * A menu opened from `trigger` (a button: an `IconButton`, usually): arrow keys move through its
+ * items, Escape and a click outside close it.
+ */
+export declare function Menu({ trigger, children, open, onOpenChange, align, }: {
+    trigger: ReactNode;
+    children: ReactNode;
+    open?: boolean;
+    onOpenChange?(open: boolean): void;
+    align?: "start" | "end";
+}): import("react").JSX.Element;
+/** An item: choosing it closes the menu, unless `onSelect` calls `event.preventDefault()`. */
+export declare function MenuItem({ onSelect, disabled, children, }: {
+    onSelect(event: Event): void;
+    disabled?: boolean;
+    children: ReactNode;
+}): import("react").JSX.Element;
+/** Tabs, each a `[value, label]`; `children` is the selected one's panel. */
+export declare function Tabs<T extends string>({ label, tabs, value, onChange, children, className, }: {
+    className?: string;
+    label: string;
+    tabs: readonly (readonly [NoInfer<T>, ReactNode])[];
+    value: T;
+    onChange(value: T): void;
+    children: ReactNode;
+}): import("react").JSX.Element;
+export declare const Card: ({ children, className }: {
+    children: ReactNode;
+    className?: string;
+}) => import("react").JSX.Element;
+/** Rows divided by lines: each child is an `<li>`. */
+export declare const List: ({ children, label }: {
+    children: ReactNode;
+    label?: string;
+}) => import("react").JSX.Element;
+export declare function Table({ head, rows }: {
+    head: ReactNode[];
+    rows: ReactNode[][];
+}): import("react").JSX.Element;
+/** `value` of `max` as segments, one per unit: a board's done cards, say. */
+export declare function Meter({ value, max, label }: {
+    value: number;
+    max: number;
+    label: string;
+}): import("react").JSX.Element;
+type Layout = {
+    children: ReactNode;
+    gap?: number;
+    className?: string;
+    style?: CSSProperties;
+};
+/** Children in a column. */
+export declare const Stack: ({ children, gap, className, style }: Layout) => import("react").JSX.Element;
+/** Children in a row, centered on the cross axis. */
+export declare const Row: ({ children, gap, className, style }: Layout) => import("react").JSX.Element;
+/** Takes the room its parent (a `Stack` or `Row`) has left. */
+export declare const Fill: ({ children, className, style }: Layout) => import("react").JSX.Element;
+/** Scrolls what doesn't fit, with no visible scrollbar. */
+export declare const Scroll: ({ children, className, style }: Layout) => import("react").JSX.Element;
+export {};