@tangle-network/agent-app 0.45.53 → 0.45.55

package/dist/web-react/durable-interaction-submit.d.ts

@@ -0,0 +1,22 @@
+import { type InteractionAnswerSubmission, type InteractionAnswerSubmitterOptions, type SubmitInteractionAnswer } from './interaction-card-support';
+/** Manage storage and retrieval of interaction attempt keys by interaction and submission identifiers */
+export interface InteractionAttemptStore {
+    get(interactionId: string, submissionSignature: string): string | null;
+    set(interactionId: string, submissionSignature: string, attemptKey: string): void;
+    delete(interactionId: string, submissionSignature: string): void;
+}
+/** Create a session-based store to manage interaction attempts using provided storage and optional namespace */
+export declare function createSessionInteractionAttemptStore(storage: Pick<Storage, 'getItem' | 'setItem' | 'removeItem'>, namespace?: string): InteractionAttemptStore;
+/** Create an in-memory store to manage interaction attempts keyed by ID and signature */
+export declare function createMemoryInteractionAttemptStore(): InteractionAttemptStore;
+/** Generate a stable string signature from an interaction answer submission */
+export declare function interactionSubmissionSignature(submission: InteractionAnswerSubmission): string;
+/** Define options for submitting durable interaction answers with attempt tracking and optional key creation */
+export interface DurableInteractionAnswerSubmitterOptions extends InteractionAnswerSubmitterOptions {
+    attempts: InteractionAttemptStore;
+    createAttemptKey?: () => string;
+}
+/** Answer submitter for a durable interaction route. One opaque attempt key is
+ * retained for an ambiguous transport/5xx result and reused after reload. A
+ * changed answer has a different signature and therefore a new attempt. */
+export declare function createDurableInteractionAnswerSubmitter(options: DurableInteractionAnswerSubmitterOptions): SubmitInteractionAnswer;

package/dist/web-react/durable-plan-card.d.ts

@@ -0,0 +1,13 @@
+import { type ReactNode } from 'react';
+import type { ChatPlan } from '../plans/index';
+import type { DurablePlanDecision, DurablePlanDecisionResult } from './durable-plan-flow';
+export interface DurablePlanCardProps {
+    plan: ChatPlan;
+    canWrite: boolean;
+    decide: (decision: DurablePlanDecision, feedback?: string) => Promise<DurablePlanDecisionResult | null>;
+    deciding?: DurablePlanDecision | null;
+    error?: string | null;
+    renderMarkdown?: (markdown: string) => ReactNode;
+    className?: string;
+}
+export declare function DurablePlanCard({ plan, canWrite, decide, deciding, error, renderMarkdown, className, }: DurablePlanCardProps): import("react").JSX.Element;

package/dist/web-react/durable-plan-flow.d.ts

@@ -0,0 +1,77 @@
+import type { ChatPlan } from '../plans/index';
+/** Represent durable plan decisions as either approved or rejected */
+export type DurablePlanDecision = 'approved' | 'rejected';
+/** Stable authority receipt for the follow-up turn dispatched by a plan
+ * decision. Consumers must make `attachFollowUp` idempotent by `receiptId`;
+ * reload and retry deliberately invoke it again. */
+export interface DurablePlanFollowUpReceipt {
+    receiptId: string;
+    planId: string;
+    revision: number;
+    turnId: string;
+    state: string;
+}
+/** Describe the result of a durable plan decision including plan details and pending statuses */
+export interface DurablePlanDecisionResult {
+    plan: ChatPlan;
+    followUp?: DurablePlanFollowUpReceipt;
+    idempotent: boolean;
+    projectionPending?: boolean;
+    effectPending?: boolean;
+}
+/** Define input parameters for making a durable plan decision including optional feedback */
+export interface DurablePlanDecisionInput {
+    planId: string;
+    revision: number;
+    decision: DurablePlanDecision;
+    feedback?: string;
+}
+/** Define input parameters for retrieving the current durable plan including optional revision number */
+export interface DurablePlanCurrentInput {
+    planId: string;
+    revision?: number;
+}
+/** Define methods to obtain and decide durable plan decisions asynchronously */
+export interface DurablePlanDecisionClient {
+    current: (input: DurablePlanCurrentInput) => Promise<DurablePlanDecisionResult>;
+    decide: (input: DurablePlanDecisionInput) => Promise<DurablePlanDecisionResult>;
+}
+/** Represent errors from DurablePlanClient operations including status, code, and current plan details */
+export declare class DurablePlanClientError extends Error {
+    readonly status: number;
+    readonly code?: string | undefined;
+    readonly currentPlan?: ChatPlan | undefined;
+    constructor(message: string, status: number, code?: string | undefined, currentPlan?: ChatPlan | undefined);
+}
+/** Define configuration options for creating a durable plan decision client */
+export interface DurablePlanDecisionClientOptions {
+    url: string | ((input: DurablePlanCurrentInput | DurablePlanDecisionInput) => string);
+    body?: Record<string, unknown> | ((input: DurablePlanDecisionInput) => Record<string, unknown>);
+    fetchImpl?: typeof fetch;
+}
+/** Browser client for the shared durable-plan route. The route URL and all
+ * product routing fields are injected; workspace/session identity is still
+ * resolved and authorized on the server. */
+export declare function createDurablePlanDecisionClient(options: DurablePlanDecisionClientOptions): DurablePlanDecisionClient;
+/** Define options to configure durable plan flow with plan, client, and optional callbacks */
+export interface UseDurablePlanFlowOptions {
+    plan: ChatPlan;
+    client: DurablePlanDecisionClient;
+    /** Must be idempotent by receipt.receiptId. */
+    attachFollowUp?: (receipt: DurablePlanFollowUpReceipt) => Promise<void> | void;
+    onUpdated?: (plan: ChatPlan) => void;
+}
+/** Define the result and actions for managing a durable plan flow including decisions, restoration, and error handling */
+export interface UseDurablePlanFlowResult {
+    plan: ChatPlan;
+    deciding: DurablePlanDecision | null;
+    restoring: boolean;
+    error: string | null;
+    decide: (decision: DurablePlanDecision, feedback?: string) => Promise<DurablePlanDecisionResult | null>;
+    restore: () => Promise<DurablePlanDecisionResult | null>;
+    clearError: () => void;
+}
+/** Shared plan decision controller. It coalesces only concurrent attachment
+ * attempts; a later retry/restore calls the consumer's idempotent transport
+ * again so a lost response cannot strand an already-dispatched follow-up. */
+export declare function useDurablePlanFlow(options: UseDurablePlanFlowOptions): UseDurablePlanFlowResult;

package/dist/web-react/harness-glyphs.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Per-harness brand marks for the canonical pickers — the same marks the
+ * legacy sandbox-ui harness picker (`dashboard/harness-logo.tsx`) shipped,
+ * vendored as inline SVG so `/web-react` stays dependency-free beyond React:
+ * sandbox-ui (and its `@lobehub/icons-static-svg` bundle) is an OPTIONAL peer
+ * the canonical pickers must not force on a consumer. Geometry is the lobehub
+ * single-color artwork, rendered in `currentColor` exactly as the legacy
+ * component painted it (a foreground-filled CSS mask), so every mark tracks
+ * the theme. Harnesses with no published brand mark get an honest inline
+ * lucide glyph — bot / plug / terminal, the same fallbacks the legacy picker
+ * used — and an unknown id falls back to the neutral bot. Data-record
+ * structure mirrors `./provider-logo`.
+ */
+import type { ReactNode } from 'react';
+import type { Harness } from '../harness';
+export interface HarnessGlyphProps {
+    /** Harness to mark. Typed as the canonical union; an out-of-union runtime
+     *  value still renders — it gets the neutral fallback glyph. */
+    harness: Harness;
+    className?: string;
+}
+/**
+ * Brand mark for a harness — size it from the call site (`className="h-4
+ * w-4"`). Unknown ids render the neutral bot, never an invented logo.
+ * `data-glyph` names the resolved mark so tests and stories can assert
+ * brand-vs-fallback without snapshotting path data.
+ */
+export declare function HarnessGlyph({ harness, className }: HarnessGlyphProps): ReactNode;