@tangle-network/agent-app 0.45.54 → 0.45.55

package/dist/assistant/ProposalCard.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Confirmation card for a mutating action the assistant proposed (create a
+ * workflow, author a workflow + skills, run a workflow, manage a key, …). Shows
+ * the action heading, its scalar fields, any new skills, a body preview (a
+ * workflow renders as a node graph via the injected `renderGraph`, with a YAML
+ * toggle; other bodies render verbatim), the integration requirements with a
+ * connect affordance, and Confirm/Cancel.
+ *
+ * The body preview's graph is injected so this card — in the always-loaded
+ * `./assistant` entry — doesn't pull the graph's `@xyflow/react` dependency; the
+ * host wires `renderGraph` from `./workflows`. Navigation and the integration
+ * provider icons (`renderProviderIcon`, from the host's integrations catalog)
+ * are injected too.
+ */
+import { type ReactNode } from "react";
+import type { ConnectionRequirement, PendingProposal } from "./types";
+export interface ProposalCardProps {
+    proposal: PendingProposal;
+    /** True while this proposal's confirmation is in flight (disables the buttons). */
+    confirming: boolean;
+    onConfirm: () => void;
+    onCancel: () => void;
+    /** Host navigation for connect targets / the integrations page. */
+    navigate?: (path: string) => void;
+    /** In-place connect handler for a requirement. When provided, a requirement's
+     *  connect affordance calls this (showing a busy state) instead of navigating
+     *  to `connectUrl`/the integrations page — the host runs its own connect flow
+     *  and the card flips the requirement to connected on success. Host-agnostic;
+     *  wired by the panel from {@link UseAssistantChatOptions.onConnectRequirement}. */
+    onConnect?: (requirement: ConnectionRequirement) => void | Promise<void>;
+    /** Render the workflow YAML as a node graph (the `./workflows` WorkflowGraph).
+     *  When absent, the YAML is shown as text. */
+    renderGraph?: (yaml: string) => ReactNode;
+    /** Render the brand icon for an integration requirement's provider. The host
+     *  owns the provider→icon mapping (its integrations catalog); when absent, or
+     *  when it returns a nullish node for a provider it doesn't recognize, the row
+     *  falls back to the shared sandbox-ui {@link ProviderIcon} mark (the same
+     *  brand resolution the integrations catalog uses). */
+    renderProviderIcon?: (provider: string) => ReactNode;
+}
+export declare function ProposalCard({ proposal, confirming, onConfirm, onCancel, navigate, onConnect, renderGraph, renderProviderIcon, }: ProposalCardProps): import("react").JSX.Element;

package/dist/assistant/ResizeHandle.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Drag-to-resize grip on the assistant drawer's left edge. Pointer capture keeps
+ * the drag alive while the cursor moves anywhere on screen; arrow keys resize in
+ * coarse steps for keyboard users. The drawer is right-anchored, so dragging
+ * left widens it. The in-memory width updates every move (`onPreview`); the
+ * final width is persisted once on release (`onCommit`).
+ */
+export declare function ResizeHandle({ width, maxWidth, onPreview, onCommit, onNudge, }: {
+    width: number;
+    maxWidth: number;
+    /** Live (non-persisted) width update during a drag. The value is the raw
+     *  pointer-derived width and is NOT clamped — the consumer must clamp it to its
+     *  own min/max (the bundled `usePanelWidth.previewWidth` does). */
+    onPreview: (next: number) => void;
+    /** Persist the final width (drag end). */
+    onCommit: (next: number) => void;
+    /** Keyboard resize delta (clamped + persisted). */
+    onNudge: (deltaPx: number) => void;
+}): import("react").JSX.Element;

package/dist/assistant/client-context.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Provides the configured {@link AssistantClient} to the assistant hooks. The
+ * host (a same-origin app, or a cross-origin embedder) builds one client with
+ * its transport config and supplies it here; the hooks read it rather than
+ * importing a hard-wired same-origin transport, which is what makes the panel
+ * portable across hosts.
+ */
+import { type ReactNode } from "react";
+import type { AssistantClient } from "./client";
+export declare function AssistantClientProvider({ client, children, }: {
+    client: AssistantClient;
+    children: ReactNode;
+}): import("react").JSX.Element;
+/**
+ * The assistant client for the current host. Throws when no provider is mounted
+ * rather than silently falling back to a default transport — a missing provider
+ * is a wiring bug, and a hidden default would mask it (and could target the
+ * wrong origin).
+ */
+export declare function useAssistantClient(): AssistantClient;

package/dist/assistant/client.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Configurable network client for the assistant panel: the chat SSE stream, the
+ * model/thread/history reads, and the proposal-confirmation call.
+ *
+ * The transport is injected via {@link AssistantClientConfig} so the same UI can
+ * run in different hosts: a same-origin app authenticates with the session
+ * cookie (`credentials: "include"`) and an `X-Requested-With` marker, while a
+ * cross-origin host points `baseUrl` at the API and supplies a bearer token via
+ * `headers`. The request shapes and the defensive wire parsing are identical
+ * across hosts — only the base URL and the auth headers vary.
+ */
+import type { AssistantStreamEvent, ChatMessage, ChatRequest, PendingProposal } from "./types";
+/** Host-supplied transport configuration for {@link createAssistantClient}. */
+export interface AssistantClientConfig {
+    /**
+     * Base URL the five assistant endpoints hang off, with no trailing slash —
+     * e.g. `"/api/v1/assistant"` for a same-origin SSR edge, or
+     * `"https://id.tangle.tools/api/v1/assistant"` cross-origin. Each method
+     * appends its own path (`/chat`, `/models`, `/threads`, …).
+     */
+    baseUrl: string;
+    /**
+     * `fetch` credentials mode. Defaults to `"include"` so a same-origin cookie
+     * session authenticates; a token-based cross-origin host may pass `"omit"`
+     * and carry the credential in {@link AssistantClientConfig.headers}.
+     */
+    credentials?: RequestCredentials;
+    /**
+     * Headers applied to every request — the auth token and/or the CSRF marker.
+     * Called per request so a rotating token is read fresh, never captured once.
+     */
+    headers?: () => Record<string, string>;
+}
+/** Define options for an assistant model including identifier, label, pricing, and context tokens */
+export interface AssistantModelOption {
+    slug: string;
+    label: string;
+    /** USD per million prompt tokens, when the catalog carries pricing. */
+    promptUsdPerMillion?: number;
+    /** Context window in tokens, when known. */
+    contextTokens?: number;
+}
+/** Define the structure for assistant model options including a default model slug and available models */
+export interface AssistantModels {
+    /** The slug the server uses when a turn selects no model. */
+    default: string | null;
+    models: AssistantModelOption[];
+}
+/** One past conversation in the history switcher. */
+export interface AssistantThreadSummary {
+    id: string;
+    /** Truncated first user message; may be null for an untitled thread. */
+    title: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+/**
+ * Outcome of a model-list fetch. `ok` drives caching: the caller caches on `ok`
+ * and retries on `!ok`. An EMPTY list is reported as `!ok` — the server always
+ * offers at least the default model when the router is reachable, so an empty
+ * menu means the catalog couldn't be loaded and should be retried, not cached
+ * for the whole session.
+ */
+export interface AssistantModelsResult {
+    ok: boolean;
+    data: AssistantModels;
+}
+/**
+ * Outcome of a thread-history restore. The three cases drive different recovery:
+ * `ok` rehydrates the transcript; `gone` (the thread 404s — deleted or from a
+ * reset DB) tells the caller to drop the dead thread id so the next turn starts
+ * fresh; `error` (transient/network/aborted) keeps the thread id and simply
+ * doesn't restore, so a later attempt or send still targets the live thread.
+ */
+export type ThreadHistoryResult = {
+    status: "ok";
+    messages: ChatMessage[];
+    proposals: PendingProposal[];
+} | {
+    status: "gone";
+} | {
+    status: "error";
+};
+/** Represent the outcome of a confirmation process with success or failure details */
+export type ConfirmResult = {
+    ok: true;
+    output: unknown;
+    retryable?: boolean;
+} | {
+    ok: false;
+    error: string;
+};
+/** Represent invalid client input errors with a specific code INVALID_REQUEST */
+export declare class AssistantClientInputError extends Error {
+    readonly code = "INVALID_REQUEST";
+}
+/** The assistant network surface, bound to one host's transport config. */
+export interface AssistantClient {
+    fetchModels(signal?: AbortSignal): Promise<AssistantModelsResult>;
+    fetchThreads(signal?: AbortSignal): Promise<AssistantThreadSummary[] | null>;
+    fetchThreadHistory(threadId: string, signal?: AbortSignal): Promise<ThreadHistoryResult>;
+    streamChat(req: ChatRequest, onEvent: (event: AssistantStreamEvent) => void, signal: AbortSignal): Promise<void>;
+    confirmProposal(proposalId: string): Promise<ConfirmResult>;
+    /** Delete a thread and its server-side turns/proposals. Resolves `{ ok }`; a
+     *  404 (already gone) is treated as success so a double-delete is harmless.
+     *  Optional so a host with no delete endpoint stays a valid client — the panel
+     *  hides the delete affordance when it's absent (see `useAssistantThreads`). */
+    deleteThread?(threadId: string): Promise<{
+        ok: boolean;
+    }>;
+}
+/**
+ * Build an assistant client bound to one host's transport. The returned methods
+ * carry no module state, so a host may create one client per config (or share a
+ * single same-origin client for the whole app).
+ */
+export declare function createAssistantClient(config: AssistantClientConfig): AssistantClient;