@tangle-network/agent-app 0.45.54 → 0.45.56

package/dist/assistant/index.js

@@ -2,13 +2,13 @@ import {
   ChatComposer,
   ChatEmptyState,
   ChatMessages
-} from "../chunk-MQO5ML66.js";
+} from "../chunk-KJ2Q27U7.js";
 import "../chunk-FBVLEGEG.js";
 import "../chunk-ENLRJYVW.js";
 import "../chunk-GEYACSFW.js";
 import {
   ModelPicker
-} from "../chunk-PVP57G3S.js";
+} from "../chunk-2IFGVBNI.js";
 import "../chunk-MLG6XKPV.js";
 import "../chunk-BATKJP3P.js";
 import {
@@ -16,7 +16,7 @@ import {
 } from "../chunk-3UBAO3N5.js";
 import "../chunk-PC2WYTK7.js";
 import "../chunk-QY4BRKRJ.js";
-import "../chunk-CCVG2TL6.js";
+import "../chunk-YNMPMW3G.js";
 import "../chunk-5ZTFZBS6.js";
 import "../chunk-ZVEEWGDK.js";
 import "../chunk-KWXUBMXU.js";

package/dist/assistant/launcher.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Shared launcher state for the assistant dock. The dock is mounted once in the
+ * app shell, but other surfaces (e.g. the Workflows page) need to open it and
+ * prefill the composer with a starter prompt. This context owns the dock's
+ * open state plus a one-shot composer seed, so any `/app/*` surface can call
+ * `openAssistant("Create a workflow that …")` without reaching into the dock.
+ */
+import { type ReactNode } from "react";
+export interface AssistantLauncher {
+    /** Whether the assistant drawer is open. */
+    open: boolean;
+    /** A one-shot starter prompt to prefill the composer with, or null. */
+    seed: string | null;
+    /** Open the drawer; optionally prefill the composer with `seed`. */
+    openAssistant: (seed?: string) => void;
+    closeAssistant: () => void;
+    /** Clear the pending seed once the composer has applied it (consume-once). */
+    clearSeed: () => void;
+}
+export declare function AssistantLauncherProvider({ children, }: {
+    children: ReactNode;
+}): import("react").JSX.Element;
+export declare function useAssistantLauncher(): AssistantLauncher;

package/dist/assistant/persistence.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Thread-id persistence for the assistant panel. Only the opaque server thread
+ * id is kept in localStorage so a reload continues the same server-side
+ * conversation. The message transcript is deliberately NOT cached: it can
+ * contain workflow definitions, integration data, or pasted secrets, and
+ * localStorage survives logout and is readable by any script on the origin —
+ * caching it would be a privacy regression on shared devices.
+ *
+ * The visible transcript is instead rehydrated from the server on load (the
+ * `GET /assistant/threads/:id/messages` endpoint, called by `useAssistantChat`),
+ * keyed by this persisted thread id — so a reload restores the prior
+ * conversation without ever caching its contents locally.
+ *
+ * Keyed by user id so two accounts on one browser never share a thread.
+ * Anonymous (null-user) sessions are NOT persisted — otherwise every
+ * unauthenticated visitor on a shared device would read the same "anon" thread.
+ */
+interface PersistedThread {
+    threadId: string | null;
+    /** The user's last-selected model slug — a non-sensitive UI preference, so
+     *  unlike the transcript it is safe to cache. null → use the server default. */
+    model: string | null;
+}
+export declare function loadThread(userId: string | null): PersistedThread;
+export declare function saveThread(userId: string | null, thread: PersistedThread): void;
+export {};

package/dist/assistant/presentation.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Pure view-model mappers for the assistant panel: how an error code becomes an
+ * inline message + actionable next step, and how a proposed tool call becomes a
+ * confirmation card. Kept free of React so the rendering decisions are unit
+ * testable in isolation.
+ */
+import type { PendingProposal } from "./types";
+interface ErrorCta {
+    label: string;
+    to: string;
+}
+interface ErrorView {
+    message: string;
+    cta: ErrorCta | null;
+}
+/**
+ * Map a server error code + message to what the user sees and can do next.
+ * Codes with a clear remedy carry a CTA; the rest fall back to the server's own
+ * message, which is already written for the end user.
+ */
+export declare function presentError(code: string, message: string): ErrorView;
+interface ProposalField {
+    label: string;
+    value: string;
+}
+/** A new skill minted alongside a workflow, shown as a named line on the card
+ *  so the user sees what's being created without the raw skills JSON. */
+interface ProposalSkill {
+    name: string;
+    description: string | null;
+}
+interface ProposalView {
+    /** Verb-first heading, e.g. "Create workflow". */
+    title: string;
+    /** A body preview with its own label — a workflow's YAML (`kind: "workflow"`,
+     *  rendered as a node graph with a YAML toggle) or a skill's instructions
+     *  (`kind: "text"`, shown verbatim). Null when the action has no body. */
+    preview: {
+        label: string;
+        content: string;
+        kind: "workflow" | "text";
+    } | null;
+    /** Scalar arguments to show as a key/value list. */
+    fields: ProposalField[];
+    /** New skills minted alongside a workflow (author_workflow); omitted otherwise. */
+    skills?: ProposalSkill[];
+}
+/**
+ * Describe a proposed mutating action for its confirmation card. Workflow
+ * create/update surface a YAML preview (the issue's required behavior); other
+ * actions surface their scalar arguments. Unknown tools fall back to a generic
+ * heading plus a JSON dump of the arguments so a newly added mutating tool is
+ * never silently un-renderable.
+ */
+export declare function describeProposal(proposal: PendingProposal): ProposalView;
+/**
+ * Summarize a confirmed action's result for the transcript. Best-effort and
+ * defensive: the output shape is the tool's return value, which varies by tool.
+ */
+export declare function describeOutcome(name: string, output: unknown): string;
+/**
+ * Summarize a confirmed action's FAILURE for the error banner. Mutating tools
+ * report a domain failure by returning a negative outcome (see
+ * `resolveConfirmation`); this turns that outcome into a human message,
+ * preferring the server's own `errors[]`/`message` (already end-user-written)
+ * and falling back to the not-found/conflict markers. Best-effort and
+ * defensive: the shape varies by tool.
+ */
+export declare function describeFailure(output: unknown): string;
+export declare function isLowBalance(balanceUsd: number | null): boolean;
+/** The outcome of a confirmed tool call, mirroring `ConfirmResult` from the
+ *  stream layer without coupling presentation to it. */
+type ConfirmOutcome = {
+    ok: true;
+    output: unknown;
+} | {
+    ok: false;
+    error: string;
+};
+interface ConfirmResolution {
+    /** Transcript note to append, or null when there's nothing to say. */
+    statusText: string | null;
+    /** Error banner to surface, or null on a clean success. */
+    error: {
+        code: string;
+        message: string;
+    } | null;
+}
+/**
+ * Decide what a confirmed proposal's result means for the transcript and the
+ * error banner. The `invoke_integration` tool reports a not-connected provider
+ * as a structured `{ ok: false, code: "NOT_CONNECTED" }` outcome inside `output`
+ * (see the hub integration invoker); that exact signal maps to an
+ * `INTEGRATION_DISCONNECTED` error so the panel can offer a "Connect" step.
+ * Other failures surface as `TOOL_FAILED`. Pure so the classification is
+ * unit-testable without the hook.
+ */
+export declare function resolveConfirmation(name: string, result: ConfirmOutcome): ConfirmResolution;
+export {};

package/dist/assistant/provider-label.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Display label for a connector slug ("github" → "GitHub"). Kept in its own
+ * module — separate from the graph model — so consumers in the always-loaded app
+ * shell (e.g. ProposalIntegrations) can import the label without pulling the
+ * `yaml` parser (a `model.ts` dependency) into the main bundle.
+ */
+export declare function providerLabel(provider: string): string;

package/dist/assistant/reducer.d.ts

@@ -0,0 +1,130 @@
+/**
+ * Pure state machine driving the assistant panel. Every UI transition — a user
+ * message, each streamed SSE event, a stream failure, a confirmed/cancelled
+ * proposal, a manual stop — is modeled as an action here, so the panel's
+ * behavior can be verified without a DOM or a live stream.
+ */
+import type { AssistantStreamEvent, ChatMessage, ConnectionRequirementKind, PendingProposal, UsageInfo } from "./types";
+type ChatStatus = "idle" | "streaming" | "awaiting_confirm";
+export interface AssistantState {
+    /** The signed-in user this conversation belongs to. Carried in state so it
+     *  moves atomically with the data it labels — persistence keys off it, and a
+     *  render whose owner doesn't match the current user is masked (see
+     *  `selectVisibleState`), preventing a one-frame cross-account leak. */
+    ownerId: string | null;
+    /** Persisted across reloads to continue the same server-side thread. */
+    threadId: string | null;
+    messages: ChatMessage[];
+    status: ChatStatus;
+    /** Id of the assistant message currently accumulating deltas, if any. Set to
+     *  null mid-turn when a tool runs, so the next text delta opens a fresh
+     *  assistant bubble — keeping each reasoning segment visually distinct. */
+    streamingId: string | null;
+    /** Base id for the current turn's assistant bubbles (the `send` assistant id).
+     *  Post-tool segments derive a unique id from it; null between turns. */
+    streamBaseId: string | null;
+    /** How many assistant bubbles the current turn has opened (0 = just the first).
+     *  Drives the per-segment bubble id so segments never collide across turns. */
+    segmentSeq: number;
+    pendingProposals: PendingProposal[];
+    /** Cost/balance from the most recently settled turn. */
+    usage: UsageInfo | null;
+    /** Model slug the current/most-recent turn ran against (from the thread
+     *  event), or null before any turn this session. */
+    model: string | null;
+    /** The current turn's accumulated reasoning/thinking text (reasoning models
+     *  stream this before the answer). Shown dim while the answer is still pending;
+     *  reset at the start of each turn. Null when the model emits no reasoning. */
+    reasoning: string | null;
+    error: {
+        code: string;
+        message: string;
+    } | null;
+    /** True when the most-recent turn stopped at the per-turn step limit before the
+     *  model finished (a partial reply). Drives the one-click "Continue" affordance;
+     *  cleared when the next turn starts. */
+    capped: boolean;
+}
+type AssistantAction = {
+    type: "send";
+    messageId: string;
+    assistantId: string;
+    text: string;
+} | {
+    type: "stream";
+    event: AssistantStreamEvent;
+} | {
+    type: "stream_failed";
+    error: {
+        code: string;
+        message: string;
+    };
+} | {
+    type: "proposal_resolved";
+    /** The card's canonical identity (the model's tool-call id). */
+    callId: string;
+    status: ChatMessage | null;
+    /** Set on a failed confirmation; null clears any prior error. */
+    error: {
+        code: string;
+        message: string;
+    } | null;
+} | {
+    type: "proposal_retry_failed";
+    /** The card to KEEP (a retryable confirm failure — an unconnected
+     *  integration). The card stays confirmable; the message is shown on it. */
+    callId: string;
+    message: string;
+} | {
+    type: "requirement_connected";
+    /** The proposal card whose requirement was just connected (its callId). */
+    callId: string;
+    /** Identity of the now-connected requirement, matched within the card's
+     *  own requirements. `kind` defaults to "integration" (the card's default)
+     *  when absent, so a requirement carrying no explicit kind still matches. */
+    provider: string;
+    kind?: ConnectionRequirementKind;
+} | {
+    type: "stopped";
+} | {
+    type: "hydrate";
+    ownerId: string | null;
+    threadId: string | null;
+    messages: ChatMessage[];
+} | {
+    type: "restore_history";
+    ownerId: string | null;
+    threadId: string;
+    messages: ChatMessage[];
+    /** Unconfirmed proposals restored alongside the transcript so a card
+     *  survives reload. Empty when none are pending. */
+    proposals: PendingProposal[];
+} | {
+    type: "thread_gone";
+    ownerId: string | null;
+    threadId: string;
+} | {
+    type: "history_failed";
+    ownerId: string | null;
+    threadId: string;
+    error: {
+        code: string;
+        message: string;
+    };
+} | {
+    type: "switch_thread";
+    threadId: string;
+} | {
+    type: "reset";
+};
+export declare function initialAssistantState(): AssistantState;
+/**
+ * The state safe to render for `userId`. When the conversation in state belongs
+ * to a different user (the single commit between an auth change and the hydrate
+ * that follows it), return a fresh empty state instead of the prior user's
+ * transcript — so an account's messages and proposals are never shown, even for
+ * one frame, under another account.
+ */
+export declare function selectVisibleState(state: AssistantState, userId: string | null): AssistantState;
+export declare function assistantReducer(state: AssistantState, action: AssistantAction): AssistantState;
+export {};

package/dist/assistant/sse.d.ts

@@ -0,0 +1,24 @@
+/**
+ * POST-based SSE reading for the assistant chat stream. The browser
+ * `EventSource` is GET-only and can't send a request body, so the stream is read
+ * off a `fetch` POST response.
+ *
+ * The framing parser is vendored here (rather than depending on an internal SDK)
+ * so this module stays self-contained and consumable by any host. It mirrors the
+ * standard SSE wire format: events separated by a blank line, `event:` / `data:`
+ * fields, `:`-prefixed comments ignored, multi-line `data:` joined with `\n`, and
+ * each event's data JSON-parsed (falling back to the raw string).
+ */
+interface ParsedSSEEvent<T = unknown> {
+    data: T;
+    rawData: string;
+    eventId?: string;
+    eventType?: string;
+}
+/**
+ * Read a fetch `Response` body and invoke `onEvent` for each parsed SSE event
+ * (its `eventType` plus JSON-parsed `data`), in wire order. Resolves when the
+ * stream closes. The caller owns abort (via the fetch `signal`).
+ */
+export declare function readSSEEvents(body: ReadableStream<Uint8Array>, onEvent: (event: ParsedSSEEvent) => void): Promise<void>;
+export {};

package/dist/assistant/time-ago.d.ts

@@ -0,0 +1,6 @@
+/** Relative time label from an epoch-ms timestamp ("just now", "5m ago", "3h
+ *  ago", "6d ago", "Mar 3"). Self-contained so the assistant subpath carries no
+ *  design-system dep. Buckets stop at weeks; past ~a month the short locale date
+ *  is more useful than "11w ago" — the year rides along only when it isn't the
+ *  current one. */
+export declare function timeAgo(ts: number): string;

package/dist/assistant/transcript.d.ts

@@ -0,0 +1,97 @@
+/**
+ * The assistant's default transcript renderer, built on web-react's
+ * `ChatMessages`. The reducer streams a FLAT, per-segment transcript (user /
+ * assistant / `tool` chip / `status` messages, plus turn-level reasoning and
+ * pending proposals); `adaptTranscript` collapses each turn into one assistant
+ * message whose ordered `segments` carry that turn's text runs and tool chips in
+ * emission order, so `ChatMessages` renders them interleaved (text → tool →
+ * text) rather than as one text blob followed by a tool group. `status`
+ * messages are NOT folded into a turn: each becomes a quiet centered status
+ * line rendered by this component between `ChatMessages` runs — a settled
+ * action's note ("Created workflow …"), not an assistant-labeled turn.
+ *
+ * A host can swap this whole renderer via `AssistantPanelProps.renderTranscript`;
+ * the markdown renderer and per-tool detail renderers are injected so this
+ * subpath stays free of any product-specific markdown/tool dependency.
+ */
+import { type ReactNode } from "react";
+import { type ChatUiMessage, type ToolDetailRenderers } from "../web-react";
+import type { AssistantState } from "./reducer";
+import type { AssistantTranscriptView, ConfirmedResult } from "./types";
+/**
+ * True while a turn is streaming but the model hasn't emitted its first answer
+ * token yet — drives the "thinking" affordance so a reasoning gap reads as
+ * working, not a frozen panel.
+ */
+export declare function assistantIsThinking(state: AssistantState): boolean;
+/** A run of chat messages between two status lines, rendered through one
+ *  `ChatMessages`. */
+interface MessageRun {
+    kind: "run";
+    messages: ChatUiMessage[];
+}
+/** A settled action's one-line note ("Created workflow …", "Action cancelled."),
+ *  rendered as a quiet centered line — not routed into `ChatMessages`, where a
+ *  `system` row would paint as a full assistant-labeled turn. */
+interface StatusLine {
+    kind: "status";
+    /** The status message's own id — keys the row and any confirmed result. */
+    id: string;
+    text: string;
+}
+type TranscriptBlock = MessageRun | StatusLine;
+interface AdaptedTranscript {
+    /** Transcript-order blocks: message runs broken by status lines. */
+    blocks: TranscriptBlock[];
+    /** Every adapted chat message across all runs, flattened (status rows
+     *  excluded — they are the blocks' status lines). */
+    messages: ChatUiMessage[];
+    /** The assistant message under which pending proposals should render, or null
+     *  when there are none. */
+    proposalHostId: string | null;
+    /** The current/most-recent turn's assistant message — where the turn cost line
+     *  renders (it carries the turn's metrics), or null when there is none. */
+    metricsHostId: string | null;
+    /** Confirmed-tool results to render under their status line, keyed by that
+     *  line's id — carried from a `status` message's retained `result` so a host
+     *  card (e.g. a one-time API-key reveal) renders inline right after the action. */
+    confirmedResults: Map<string, ConfirmedResult>;
+}
+/**
+ * Fold the transcript view into transcript-order blocks: message runs (web-react
+ * `ChatUiMessage[]`) broken by quiet status lines. Within a run, each user
+ * message is 1:1; the assistant/`tool` messages between two user turns collapse
+ * into one assistant message whose ordered `segments` carry the turn's text runs
+ * and tool chips IN EMISSION ORDER (with each finished tool's outcome as the chip
+ * `result`). The joined text is also kept on `content` — web-react reads it as the
+ * "answer has started" signal that gates the reasoning box. The live turn's
+ * reasoning preview and model label hang on the last assistant message, and
+ * `proposalHostId` names the message the pending proposals render under. A
+ * `status` message ends the current run and becomes a {@link StatusLine} block.
+ */
+export declare function adaptTranscript(view: AssistantTranscriptView): AdaptedTranscript;
+export interface AssistantTranscriptProps {
+    view: AssistantTranscriptView;
+    /** Markdown renderer for assistant content; defaults to plain pre-wrapped text. */
+    renderMarkdown?: (content: string) => ReactNode;
+    /** Per-tool custom detail renderers for expanded tool cards. */
+    toolRenderers?: ToolDetailRenderers;
+    /** Render a prominent card for a CONFIRMED tool's result, inline after its
+     *  status line (e.g. a one-time API-key reveal for `create_api_key`). Return
+     *  null to fall back to just the status line. Unlike `toolRenderers` (collapsed
+     *  detail for a read-only tool chip), this is shown expanded, so a one-time
+     *  secret is visible without a click. See {@link ConfirmedResult}. */
+    renderConfirmedResult?: (result: ConfirmedResult) => ReactNode;
+    /** Zero-state shown for a fresh, non-streaming thread. */
+    emptyState?: ReactNode;
+}
+/**
+ * Render the assistant conversation: message runs through web-react's
+ * `ChatMessages` (quiet chrome — the label/meta row becomes a hover-revealed
+ * lane, which keeps the narrow dock panel uncluttered), status lines through
+ * {@link StatusRow}. Pending proposals render via the panel's bound
+ * `view.renderProposal`, placed inline after the proposing turn through
+ * `renderExtras`; the settled turn cost renders once under its assistant bubble.
+ */
+export declare function AssistantTranscript({ view, renderMarkdown, toolRenderers, renderConfirmedResult, emptyState, }: AssistantTranscriptProps): import("react").JSX.Element;
+export {};