agentic-assistant 0.0.0-stage → 0.1.0

package/dist/loop-CDbbDwSs.d.ts

@@ -0,0 +1,231 @@
+import { J as JsonSchema, U as Usage, c as Message, M as ModelProvider } from './types-C47SyHH5.js';
+
+declare const ACTIONS: readonly ["read", "comment", "write", "admin"];
+type Action = (typeof ACTIONS)[number];
+type Scope = string;
+declare function parseScope(scope: Scope): {
+    resource: string;
+    action: Action;
+};
+/** True when `grant` allows everything `required` asks for. */
+declare function scopeCovers(grant: Scope, required: Scope): boolean;
+/** True when any granted scope covers the required one. A malformed scope never matches. */
+declare function hasScope(granted: readonly Scope[], required: Scope): boolean;
+
+/**
+ * The acting principal. The assistant always acts as an agent of a signed-in
+ * person. The host passes the scopes, already narrowed to what the person
+ * granted this agent. The assistant never widens them.
+ */
+interface AssistantPrincipal {
+    readonly id: string;
+    readonly kind: "agent_of_human";
+    /** The person the assistant acts for. */
+    readonly parentId: string;
+    readonly scopes: readonly Scope[];
+    /** Epoch milliseconds. Calls stop at this time. */
+    readonly expiresAt?: number;
+    /** Host check, run before every tool call. A throw or a true result denies the call. */
+    readonly isRevoked?: () => boolean | Promise<boolean>;
+}
+interface PrincipalInput {
+    id: string;
+    kind?: string;
+    parentId: string;
+    scopes: readonly Scope[];
+    expiresAt?: number;
+    isRevoked?: () => boolean | Promise<boolean>;
+}
+declare class PrincipalError extends Error {
+    constructor(message: string);
+}
+/** Validates host input. A missing or other kind is an error, never a default. */
+declare function createPrincipal(input: PrincipalInput): AssistantPrincipal;
+/** Re-checks a principal at the start of a run. A cast or a plain JS caller cannot skip validation. */
+declare function assertPrincipal(principal: AssistantPrincipal): void;
+/** Who a run, a tool call, and every audit row is attributed to. Always machine-made. */
+interface Actor {
+    principalId: string;
+    kind: "agent_of_human";
+    onBehalfOf: string;
+    machineMade: true;
+}
+declare function actorOf(principal: AssistantPrincipal): Actor;
+
+/** `safe` runs at once. `risky` and `irreversible` wait for a person. */
+type ToolRisk = "safe" | "risky" | "irreversible";
+declare const TOOL_RISKS: readonly ToolRisk[];
+interface ApprovalRequest {
+    id: string;
+    tool: string;
+    risk: "risky" | "irreversible";
+    /** A frozen copy of the arguments the tool will get. */
+    input: Readonly<Record<string, unknown>>;
+    /** Binds the tool, the arguments, and the acting principal. The decision must echo it. */
+    digest: string;
+    actor: Actor;
+}
+type ApprovalDecision = {
+    requestId: string;
+    approved: true;
+    digest: string;
+    decidedBy: string;
+} | {
+    requestId: string;
+    approved: false;
+    decidedBy?: string;
+    reason?: string;
+};
+/**
+ * The approval port. Answer a request with a decision, or fail. The loop treats
+ * a failure, a timeout, and a decision that does not match the request as a refusal.
+ */
+interface ApprovalGate {
+    request(request: ApprovalRequest, signal: AbortSignal): Promise<ApprovalDecision>;
+}
+/** JSON with sorted keys, so equal values give equal text. */
+declare function canonicalJson(value: unknown): string;
+declare function digestCall(call: {
+    tool: string;
+    input: unknown;
+    principalId: string;
+    onBehalfOf: string;
+}): string;
+/**
+ * An in-memory gate. `request` waits until `approve` or `reject` is called with the request id.
+ * A panel, a CLI, or a test calls them. `approve` signs the stored digest, so a caller cannot
+ * approve other arguments than the ones the loop asked about.
+ */
+declare class QueueApprovalGate implements ApprovalGate {
+    private readonly waiting;
+    pending(): ApprovalRequest[];
+    request(request: ApprovalRequest, signal: AbortSignal): Promise<ApprovalDecision>;
+    approve(id: string, decidedBy: string): void;
+    reject(id: string, decidedBy?: string, reason?: string): void;
+    private take;
+}
+
+interface ToolContext {
+    principal: AssistantPrincipal;
+    toolUseId: string;
+    signal?: AbortSignal;
+}
+interface ToolDefinition<Input = Record<string, unknown>> {
+    name: string;
+    description: string;
+    /** A JSON Schema with `type: "object"`. The loop validates the model's input against it. */
+    inputSchema: JsonSchema;
+    /** The scope the acting principal must hold to call this tool. */
+    scope: Scope;
+    /** How much harm a call can do. `risky` and `irreversible` wait for a person's approval. Every tool must say. */
+    risk: ToolRisk;
+    handler(input: Input, context: ToolContext): Promise<unknown> | unknown;
+}
+/** Types a tool for an SDK function. The loop checks the input against `inputSchema` before it calls `handler`. */
+declare function defineTool<Input>(tool: ToolDefinition<Input>): ToolDefinition;
+declare class ToolRegistry {
+    private readonly tools;
+    private readonly ajv;
+    register(tool: ToolDefinition): this;
+    registerAll(tools: readonly ToolDefinition[]): this;
+    get(name: string): ToolDefinition | undefined;
+    list(): ToolDefinition[];
+    /** Returns a short description of the first schema violation, or undefined when the input is valid. */
+    checkInput(name: string, input: unknown): string | undefined;
+}
+
+interface RunLimits {
+    /** Most model turns in one run. Default 8. */
+    maxTurns?: number;
+    /** Most input plus output tokens, summed over all turns. */
+    maxTotalTokens?: number;
+    /** Most estimated cost in US dollars. Needs `pricing` on the provider. */
+    maxCostUsd?: number;
+    /** Output token ceiling for one turn. Default 4096. */
+    maxOutputTokensPerTurn?: number;
+    /** Time to wait for a person to decide. No decision in time means the call is refused. Default 300000. */
+    approvalTimeoutMs?: number;
+    /** Most tool calls the model may make in one turn. A larger turn runs none. Default 16. */
+    maxToolCallsPerTurn?: number;
+    /** Longest tool result, in characters, sent to the model. Longer results are cut. Default 32768. */
+    maxToolResultChars?: number;
+}
+interface RunOptions {
+    provider: ModelProvider;
+    registry: ToolRegistry;
+    principal: AssistantPrincipal;
+    /** The conversation so far, ending with the new user message. */
+    messages: readonly Message[];
+    system?: string;
+    /** Asked before a `risky` or `irreversible` tool runs. Without it, those tools are not offered and are refused. */
+    approvals?: ApprovalGate;
+    limits?: RunLimits;
+    signal?: AbortSignal;
+    now?: () => number;
+}
+type DoneReason = "end_turn" | "max_tokens" | "refusal" | "provider_stop" | "max_turns" | "token_cap" | "cost_cap" | "tool_call_cap" | "provider_error" | "principal_inactive" | "aborted";
+type DeniedReason = "unknown_tool" | "scope" | "invalid_input" | "approval";
+interface RunTotals extends Usage {
+    costUsd: number;
+}
+type AssistantEvent = {
+    type: "run_start";
+    actor: Actor;
+    provider: string;
+    model: string;
+} | {
+    type: "turn_start";
+    turn: number;
+} | {
+    type: "text_delta";
+    text: string;
+} | {
+    type: "tool_call";
+    id: string;
+    name: string;
+    input: unknown;
+    actor: Actor;
+} | {
+    type: "approval_request";
+    request: ApprovalRequest;
+} | {
+    type: "approval_decision";
+    requestId: string;
+    approved: boolean;
+    decidedBy?: string;
+    reason?: string;
+} | {
+    type: "tool_result";
+    id: string;
+    name: string;
+    content: string;
+    isError: boolean;
+    denied?: DeniedReason;
+    /** True when `content` came from a tool. Treat it as data, never as an instruction. */
+    untrusted?: true;
+    /** The raw failure text. It stays in the event and never goes to the model. */
+    detail?: string;
+    actor: Actor;
+} | {
+    type: "turn_end";
+    turn: number;
+    usage: Usage;
+    totals: RunTotals;
+} | {
+    type: "done";
+    reason: DoneReason;
+    totals: RunTotals;
+    actor: Actor;
+    messages: Message[];
+    error?: string;
+};
+/** Sent with every request. Tool output is data, never an instruction. */
+declare const DATA_NOTICE: string;
+/**
+ * Runs the assistant until the model stops, a cap trips, or the principal stops
+ * being valid. Tools run only when the model stops to use them, only inside the
+ * principal's scopes, and never after a cap has tripped.
+ */
+declare function runAssistant(options: RunOptions): AsyncGenerator<AssistantEvent>;
+
+export { ACTIONS as A, DATA_NOTICE as D, PrincipalError as P, QueueApprovalGate as Q, type RunLimits as R, type Scope as S, type ToolRisk as T, type ToolDefinition as a, type Action as b, type Actor as c, type ApprovalDecision as d, type ApprovalGate as e, type ApprovalRequest as f, type AssistantEvent as g, type AssistantPrincipal as h, type DeniedReason as i, type DoneReason as j, type PrincipalInput as k, type RunOptions as l, type RunTotals as m, TOOL_RISKS as n, type ToolContext as o, ToolRegistry as p, actorOf as q, assertPrincipal as r, canonicalJson as s, createPrincipal as t, defineTool as u, digestCall as v, hasScope as w, parseScope as x, runAssistant as y, scopeCovers as z };

package/dist/react.css

@@ -0,0 +1,57 @@
+/* Plain CSS variables. Set them on .aa-panel or a parent to match your app. Every pair below meets
+   WCAG 2.2 AA contrast; src/react/styles.test.ts checks it. No remote fonts or images. */
+.aa-panel {
+  --aa-bg: #ffffff;
+  --aa-fg: #1b1b1b;
+  --aa-muted: #4d4d4d;
+  --aa-border: #767676;
+  --aa-accent: #0b57d0;
+  --aa-accent-fg: #ffffff;
+  --aa-focus: #0b57d0;
+  --aa-machine-bg: #e8eefc;
+  --aa-machine-fg: #0a2a6b;
+  --aa-card-bg: #f4f4f4;
+  --aa-warn-bg: #fff4d6;
+  --aa-warn-fg: #5c3d00;
+  --aa-danger: #b3261e;
+
+  display: flex;
+  flex-direction: column;
+  height: 100%;
+  min-width: 18rem;
+  box-sizing: border-box;
+  background: var(--aa-bg);
+  color: var(--aa-fg);
+  border: 1px solid var(--aa-border);
+  font-family: system-ui, -apple-system, "Segoe UI", Roboto, sans-serif;
+  font-size: 1rem;
+  line-height: 1.5;
+}
+.aa-panel *, .aa-panel *::before, .aa-panel *::after { box-sizing: border-box; }
+.aa-header { display: flex; align-items: center; gap: 0.5rem; padding: 0.5rem 0.75rem; border-bottom: 1px solid var(--aa-border); }
+.aa-title { margin: 0; font-size: 1.125rem; }
+.aa-log { flex: 1; overflow-y: auto; padding: 0.75rem; display: flex; flex-direction: column; gap: 0.75rem; }
+.aa-empty { color: var(--aa-muted); margin: 0; }
+.aa-msg { padding: 0.5rem 0.75rem; border: 1px solid var(--aa-border); border-radius: 0.5rem; }
+.aa-assistant { background: var(--aa-card-bg); }
+.aa-who { margin: 0 0 0.25rem; font-weight: 600; color: var(--aa-muted); }
+.aa-text { margin: 0; white-space: pre-wrap; overflow-wrap: anywhere; }
+.aa-badge { display: inline-block; padding: 0 0.5rem; border-radius: 0.25rem; background: var(--aa-machine-bg); color: var(--aa-machine-fg); font-size: 0.875rem; font-weight: 600; border: 1px solid var(--aa-machine-fg); }
+.aa-card, .aa-approval { padding: 0.5rem 0.75rem; border: 1px solid var(--aa-border); border-radius: 0.5rem; background: var(--aa-card-bg); }
+.aa-card-head { display: flex; flex-wrap: wrap; align-items: center; gap: 0.5rem; }
+.aa-status { color: var(--aa-muted); font-weight: 600; }
+.aa-pre { margin: 0.25rem 0 0; padding: 0.5rem; max-height: 12rem; overflow: auto; background: var(--aa-bg); border: 1px solid var(--aa-border); white-space: pre-wrap; overflow-wrap: anywhere; font-family: ui-monospace, Menlo, Consolas, monospace; font-size: 0.875rem; }
+.aa-approval { background: var(--aa-warn-bg); color: var(--aa-warn-fg); border-width: 2px; border-color: var(--aa-warn-fg); }
+.aa-approval-title { margin: 0 0 0.25rem; font-size: 1rem; display: flex; align-items: center; gap: 0.5rem; }
+.aa-warn { color: var(--aa-danger); background: var(--aa-bg); padding: 0.25rem 0.5rem; border: 2px solid var(--aa-danger); border-radius: 0.25rem; }
+.aa-notice { margin: 0; padding: 0.5rem 0.75rem; border: 1px solid var(--aa-border); border-radius: 0.5rem; }
+.aa-composer { display: flex; flex-direction: column; gap: 0.5rem; padding: 0.75rem; border-top: 1px solid var(--aa-border); }
+.aa-label { font-weight: 600; }
+.aa-input { width: 100%; resize: vertical; padding: 0.5rem; font: inherit; color: var(--aa-fg); background: var(--aa-bg); border: 1px solid var(--aa-border); border-radius: 0.25rem; }
+.aa-actions { display: flex; gap: 0.5rem; margin-top: 0.5rem; }
+.aa-composer .aa-actions { margin-top: 0; }
+.aa-button { min-height: 2rem; min-width: 2rem; padding: 0.25rem 1rem; font: inherit; font-weight: 600; color: var(--aa-fg); background: var(--aa-bg); border: 2px solid var(--aa-border); border-radius: 0.25rem; cursor: pointer; }
+.aa-button.aa-primary { color: var(--aa-accent-fg); background: var(--aa-accent); border-color: var(--aa-accent); }
+.aa-button:disabled { cursor: not-allowed; opacity: 0.6; }
+.aa-panel :focus-visible { outline: 3px solid var(--aa-focus); outline-offset: 2px; }
+@media (forced-colors: active) { .aa-badge, .aa-button, .aa-approval, .aa-warn { border: 2px solid CanvasText; } }

package/dist/react.d.ts

@@ -0,0 +1,56 @@
+import * as react from 'react';
+import { g as AssistantEvent, T as ToolRisk } from './loop-CDbbDwSs.js';
+import { c as Message } from './types-C47SyHH5.js';
+
+type PanelItem = {
+    kind: "user";
+    id: string;
+    text: string;
+} | {
+    kind: "assistant";
+    id: string;
+    text: string;
+    streaming: boolean;
+} | {
+    kind: "tool";
+    id: string;
+    name: string;
+    input: unknown;
+    status: "running" | "waiting" | "done" | "failed" | "denied" | "not_run";
+    /** Text a tool returned. It is data. Show it as text. */
+    content?: string;
+} | {
+    kind: "approval";
+    id: string;
+    tool: string;
+    risk: Exclude<ToolRisk, "safe">;
+    input: unknown;
+    /** `expired`: the run ended before a decision was used. `unavailable`: the approval did not complete. */
+    status: "pending" | "approved" | "declined" | "unavailable" | "expired";
+    busy: boolean;
+    decidedBy?: string;
+} | {
+    kind: "notice";
+    id: string;
+    text: string;
+};
+interface UseAssistantOptions {
+    /** Runs the assistant for this conversation. The host owns the model, the tools, and the principal. */
+    run(messages: Message[], signal: AbortSignal): AsyncIterable<AssistantEvent>;
+    /** Passes a person's decision to the approval gate. The host owns the gate and knows who the person is. */
+    decide(requestId: string, approved: boolean, reason?: string): void | Promise<void>;
+}
+declare function useAssistant(options: UseAssistantOptions): {
+    items: PanelItem[];
+    running: boolean;
+    send: (text: string) => Promise<void>;
+    stop: () => void | undefined;
+    decide: (requestId: string, approved: boolean, reason?: string) => Promise<boolean>;
+};
+
+interface AssistantPanelProps extends UseAssistantOptions {
+    title?: string;
+}
+declare function AssistantPanel({ title, run, decide }: AssistantPanelProps): react.JSX.Element;
+
+export { AssistantPanel, type AssistantPanelProps, type PanelItem, type UseAssistantOptions, useAssistant };

package/dist/react.js

@@ -0,0 +1,321 @@
+// src/react/panel.tsx
+import { useEffect as useEffect2, useId, useLayoutEffect, useRef as useRef2, useState as useState2 } from "react";
+
+// src/react/use-assistant.ts
+import { useCallback, useEffect, useRef, useState } from "react";
+var STOP_NOTICES = {
+  max_turns: "The assistant stopped because it reached its step limit. Your messages are kept. Send a message to go on.",
+  token_cap: "The assistant stopped because the conversation reached its size limit. Your messages are kept.",
+  cost_cap: "The assistant stopped because it reached its cost limit. Your messages are kept.",
+  max_tokens: "The answer was cut short because it was too long. Ask for a shorter answer.",
+  refusal: "The model did not answer this request. Try to ask in another way.",
+  provider_error: "The assistant could not get an answer from the model. Your messages are kept. Try again.",
+  principal_inactive: "The assistant no longer has permission to act for you. Sign in again, then try again.",
+  tool_call_cap: "The assistant tried to use too many tools at once, so it used none. Your messages are kept.",
+  provider_stop: "The model stopped for a reason that is not known. Your messages are kept. Try again.",
+  aborted: "You stopped the assistant. Your messages are kept."
+};
+var RUN_FAILED = "The assistant could not finish. Your messages are kept. Try again, or contact support.";
+var DECIDE_FAILED = "Your decision could not be sent. Nothing ran. Try again.";
+function useAssistant(options) {
+  const [items, setItems] = useState([]);
+  const [running, setRunning] = useState(false);
+  const history = useRef([]);
+  const controller = useRef(null);
+  const busy = useRef(false);
+  const counter = useRef(0);
+  const latest = useRef(options);
+  latest.current = options;
+  const nextId = () => `item-${++counter.current}`;
+  const add = (item) => setItems((current) => [...current, item]);
+  const update = (id, change) => setItems((current) => current.map((item) => item.id === id ? change(item) : item));
+  const send = useCallback(async (text) => {
+    const trimmed = text.trim();
+    if (trimmed === "" || busy.current) return;
+    busy.current = true;
+    setRunning(true);
+    const userMessage = { role: "user", content: [{ type: "text", text: trimmed }] };
+    add({ kind: "user", id: nextId(), text: trimmed });
+    const abort = new AbortController();
+    controller.current = abort;
+    const sent = [...history.current, userMessage];
+    let streamingId = null;
+    let finished = false;
+    const toolItems = /* @__PURE__ */ new Map();
+    let lastToolItem = null;
+    try {
+      for await (const event of latest.current.run(sent, abort.signal)) {
+        switch (event.type) {
+          case "turn_start":
+            streamingId = null;
+            break;
+          case "text_delta": {
+            if (streamingId === null) {
+              streamingId = nextId();
+              add({ kind: "assistant", id: streamingId, text: event.text, streaming: true });
+            } else {
+              update(streamingId, (item) => item.kind === "assistant" ? { ...item, text: item.text + event.text } : item);
+            }
+            break;
+          }
+          case "turn_end":
+            if (streamingId !== null) update(streamingId, (item) => item.kind === "assistant" ? { ...item, streaming: false } : item);
+            streamingId = null;
+            break;
+          case "tool_call": {
+            const id = nextId();
+            toolItems.set(event.id, id);
+            lastToolItem = id;
+            add({ kind: "tool", id, name: event.name, input: event.input, status: "running" });
+            break;
+          }
+          case "approval_request": {
+            const { request } = event;
+            add({ kind: "approval", id: request.id, tool: request.tool, risk: request.risk, input: request.input, status: "pending", busy: false });
+            const waitingId = lastToolItem;
+            if (waitingId !== null) update(waitingId, (item) => item.kind === "tool" && item.status === "running" ? { ...item, status: "waiting" } : item);
+            break;
+          }
+          case "approval_decision":
+            update(
+              event.requestId,
+              (item) => item.kind === "approval" ? {
+                ...item,
+                status: event.approved ? "approved" : event.reason === "the person declined" ? "declined" : "unavailable",
+                busy: false,
+                decidedBy: event.decidedBy
+              } : item
+            );
+            break;
+          case "tool_result": {
+            const id = toolItems.get(event.id);
+            if (id !== void 0) {
+              update(
+                id,
+                (item) => item.kind === "tool" ? { ...item, status: event.denied ? "denied" : event.isError ? "failed" : "done", content: event.content } : item
+              );
+            }
+            break;
+          }
+          case "done": {
+            finished = true;
+            history.current = event.messages;
+            const notice = STOP_NOTICES[event.reason];
+            if (notice !== void 0) add({ kind: "notice", id: nextId(), text: notice });
+            break;
+          }
+          default:
+            break;
+        }
+      }
+    } catch {
+      add({ kind: "notice", id: nextId(), text: RUN_FAILED });
+    } finally {
+      if (!finished) history.current = sent;
+      setItems(
+        (current) => current.map((item) => {
+          if (item.kind === "approval" && item.status === "pending") return { ...item, status: "expired", busy: false };
+          if (item.kind === "tool" && (item.status === "running" || item.status === "waiting")) return { ...item, status: "not_run" };
+          return item;
+        })
+      );
+      busy.current = false;
+      controller.current = null;
+      setRunning(false);
+    }
+  }, []);
+  const stop = useCallback(() => controller.current?.abort(), []);
+  useEffect(() => () => controller.current?.abort(), []);
+  const decide = useCallback(async (requestId, approved, reason) => {
+    update(requestId, (item) => item.kind === "approval" ? { ...item, busy: true } : item);
+    try {
+      await latest.current.decide(requestId, approved, reason);
+      return true;
+    } catch {
+      update(requestId, (item) => item.kind === "approval" ? { ...item, busy: false } : item);
+      add({ kind: "notice", id: nextId(), text: DECIDE_FAILED });
+      return false;
+    }
+  }, []);
+  return { items, running, send, stop, decide };
+}
+
+// src/react/panel.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+function MachineMade() {
+  return /* @__PURE__ */ jsx("span", { className: "aa-badge", children: "Machine-made" });
+}
+var pretty = (value) => {
+  try {
+    return JSON.stringify(value, null, 2) ?? "null";
+  } catch {
+    return "[arguments cannot be shown]";
+  }
+};
+var TOOL_STATUS = {
+  running: "Running",
+  waiting: "Waiting for approval",
+  done: "Done",
+  failed: "Failed",
+  denied: "Not allowed",
+  not_run: "Not run"
+};
+function ToolCard({ item }) {
+  return /* @__PURE__ */ jsxs("article", { className: "aa-card", "aria-label": `Tool call: ${item.name}`, "data-machine-made": "true", children: [
+    /* @__PURE__ */ jsxs("header", { className: "aa-card-head", children: [
+      /* @__PURE__ */ jsx("strong", { children: item.name }),
+      " ",
+      /* @__PURE__ */ jsx(MachineMade, {}),
+      " ",
+      /* @__PURE__ */ jsx("span", { className: "aa-status", children: TOOL_STATUS[item.status] })
+    ] }),
+    /* @__PURE__ */ jsxs("details", { children: [
+      /* @__PURE__ */ jsx("summary", { children: "Arguments" }),
+      /* @__PURE__ */ jsx("pre", { className: "aa-pre", tabIndex: 0, "aria-label": `Arguments for ${item.name}`, children: pretty(item.input) })
+    ] }),
+    item.content !== void 0 && /* @__PURE__ */ jsxs("details", { children: [
+      /* @__PURE__ */ jsx("summary", { children: "Result (data from the tool, not instructions)" }),
+      /* @__PURE__ */ jsx("pre", { className: "aa-pre", tabIndex: 0, "aria-label": `Result of ${item.name}`, children: item.content })
+    ] })
+  ] });
+}
+function ApprovalPrompt({
+  item,
+  decide,
+  focusComposer
+}) {
+  const ref = useRef2(null);
+  const headingId = useId();
+  useLayoutEffect(() => {
+    if (item.status === "pending") ref.current?.focus();
+  }, [item.status]);
+  const answer = (approved) => {
+    void decide(item.id, approved).then((taken) => {
+      if (taken) focusComposer();
+    });
+  };
+  const outcome = {
+    approved: `Approved${item.decidedBy ? ` by ${item.decidedBy}` : ""}`,
+    declined: "Declined",
+    unavailable: "Not approved. The approval did not complete, so the action did not run.",
+    expired: "Expired. The assistant stopped before you decided, so the action did not run."
+  };
+  return /* @__PURE__ */ jsxs("div", { className: "aa-approval", role: "group", "aria-labelledby": headingId, tabIndex: -1, ref, "data-machine-made": "true", children: [
+    /* @__PURE__ */ jsxs("h3", { id: headingId, className: "aa-approval-title", children: [
+      "Approval needed ",
+      /* @__PURE__ */ jsx(MachineMade, {})
+    ] }),
+    /* @__PURE__ */ jsxs("p", { children: [
+      "The assistant asks to run ",
+      /* @__PURE__ */ jsx("strong", { children: item.tool }),
+      "."
+    ] }),
+    item.risk === "irreversible" ? /* @__PURE__ */ jsxs("p", { className: "aa-warn", children: [
+      /* @__PURE__ */ jsx("strong", { children: "Warning:" }),
+      " This cannot be undone."
+    ] }) : /* @__PURE__ */ jsx("p", { children: "This can change data." }),
+    /* @__PURE__ */ jsx("pre", { className: "aa-pre", tabIndex: 0, "aria-label": `Exact arguments for ${item.tool}`, children: pretty(item.input) }),
+    item.status === "pending" ? /* @__PURE__ */ jsxs("div", { className: "aa-actions", children: [
+      /* @__PURE__ */ jsx("button", { type: "button", className: "aa-button aa-primary", disabled: item.busy, "aria-label": `Approve ${item.tool}`, onClick: () => answer(true), children: "Approve" }),
+      /* @__PURE__ */ jsx("button", { type: "button", className: "aa-button", disabled: item.busy, "aria-label": `Decline ${item.tool}`, onClick: () => answer(false), children: "Decline" })
+    ] }) : /* @__PURE__ */ jsx("p", { className: "aa-status", children: outcome[item.status] })
+  ] });
+}
+function AssistantPanel({ title = "AI assistant", run, decide }) {
+  const { items, running, send, stop, decide: decideRequest } = useAssistant({ run, decide });
+  const [draft, setDraft] = useState2("");
+  const inputId = useId();
+  const input = useRef2(null);
+  const log = useRef2(null);
+  const pinned = useRef2(true);
+  useEffect2(() => {
+    const el = log.current;
+    if (el && pinned.current) el.scrollTop = el.scrollHeight;
+  }, [items]);
+  const submit = () => {
+    if (draft.trim() === "" || running) return;
+    const text = draft;
+    setDraft("");
+    void send(text);
+  };
+  const onKeyDown = (event) => {
+    if (event.key === "Enter" && !event.shiftKey && !event.nativeEvent.isComposing) {
+      event.preventDefault();
+      submit();
+    }
+  };
+  return /* @__PURE__ */ jsxs("section", { className: "aa-panel", "aria-label": title, children: [
+    /* @__PURE__ */ jsxs("header", { className: "aa-header", children: [
+      /* @__PURE__ */ jsx("h2", { className: "aa-title", children: title }),
+      /* @__PURE__ */ jsx(MachineMade, {})
+    ] }),
+    /* @__PURE__ */ jsxs(
+      "div",
+      {
+        className: "aa-log",
+        role: "log",
+        "aria-live": "polite",
+        "aria-relevant": "additions text",
+        "aria-label": "Conversation",
+        tabIndex: 0,
+        ref: log,
+        onScroll: (event) => {
+          const el = event.currentTarget;
+          pinned.current = el.scrollHeight - el.scrollTop - el.clientHeight < 24;
+        },
+        children: [
+          items.length === 0 && /* @__PURE__ */ jsx("p", { className: "aa-empty", children: "Ask the assistant to help. It acts only with your permissions, and it asks you before a risky action." }),
+          items.map((item) => {
+            switch (item.kind) {
+              case "user":
+                return /* @__PURE__ */ jsxs("div", { className: "aa-msg aa-user", children: [
+                  /* @__PURE__ */ jsx("p", { className: "aa-who", children: "You" }),
+                  /* @__PURE__ */ jsx("p", { className: "aa-text", children: item.text })
+                ] }, item.id);
+              case "assistant":
+                return /* @__PURE__ */ jsxs("div", { className: "aa-msg aa-assistant", "data-machine-made": "true", "aria-busy": item.streaming, children: [
+                  /* @__PURE__ */ jsxs("p", { className: "aa-who", children: [
+                    "Assistant ",
+                    /* @__PURE__ */ jsx(MachineMade, {})
+                  ] }),
+                  /* @__PURE__ */ jsx("p", { className: "aa-text", children: item.text })
+                ] }, item.id);
+              case "tool":
+                return /* @__PURE__ */ jsx(ToolCard, { item }, item.id);
+              case "approval":
+                return /* @__PURE__ */ jsx(ApprovalPrompt, { item, decide: decideRequest, focusComposer: () => input.current?.focus() }, item.id);
+              case "notice":
+                return /* @__PURE__ */ jsxs("p", { className: "aa-notice", children: [
+                  /* @__PURE__ */ jsx("strong", { children: "Notice:" }),
+                  " ",
+                  item.text
+                ] }, item.id);
+            }
+          })
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsxs(
+      "form",
+      {
+        className: "aa-composer",
+        onSubmit: (event) => {
+          event.preventDefault();
+          submit();
+        },
+        children: [
+          /* @__PURE__ */ jsx("label", { htmlFor: inputId, className: "aa-label", children: "Message the assistant" }),
+          /* @__PURE__ */ jsx("textarea", { id: inputId, className: "aa-input", rows: 3, value: draft, ref: input, onChange: (event) => setDraft(event.target.value), onKeyDown }),
+          /* @__PURE__ */ jsxs("div", { className: "aa-actions", children: [
+            /* @__PURE__ */ jsx("button", { type: "submit", className: "aa-button aa-primary", disabled: running || draft.trim() === "", children: "Send" }),
+            running && /* @__PURE__ */ jsx("button", { type: "button", className: "aa-button", onClick: stop, children: "Stop" })
+          ] })
+        ]
+      }
+    )
+  ] });
+}
+export {
+  AssistantPanel,
+  useAssistant
+};