@flamingo-stack/openframe-frontend-core 0.0.532-snapshot.20260811155109 → 0.0.532

package/dist/components/chat/utils/approval-display.d.ts

@@ -1,49 +0,0 @@
-/**
- * WHERE an approval card renders — the one rule, read by every path that turns
- * an approval into segments.
- *
- * There are three such paths and they must agree: the NATS kernel (live chunks),
- * the SSE kernel, and the history replay that rebuilds a dialog after a reload.
- * When the rule lived only in the live kernel, a Product Guide card rendered
- * inline while streaming and then moved into the escalation treatment on the
- * next page load — same card, two behaviors, and its buttons pointed at the
- * wrong backend once it moved.
- *
- * The rule itself: a card is gated on approval TIER (`displayApprovalTypes`,
- * the agent's own privilege model) UNLESS it came from the Product Guide, whose
- * proposals are typed by TOOL and are resolved through the hub's confirm route.
- * A hub proposal has no tier to gate on, so tier-gating one means escalating it
- * to a human who has no way to act on it.
- */
-import type { GuideOrigin } from '../../../chat-protocol/events';
-import type { MessageSegment } from '../types/message.types';
-/** Anything carrying the optional `origin` marker: a stream event, or the
- *  `data` of a rendered segment. */
-interface OriginBearing {
-    origin?: GuideOrigin | string;
-}
-/** True when this approval was minted by the Product Guide (the hub) rather
- *  than by the agent's own tool-approval tiering. */
-export declare function isGuideApproval(source: OriginBearing | null | undefined): boolean;
-/** The marker to stamp onto a built segment, or undefined for agent approvals.
- *  Keeps `origin` out of segment data unless it means something. */
-export declare function guideApprovalOrigin(source: OriginBearing | null | undefined): GuideOrigin | undefined;
-/**
- * Does this approval render inline in its turn (true), or take the consumer's
- * escalation treatment (false)?
- *
- * `displayApprovalTypes` undefined means "no tier gate configured" and every
- * agent approval displays — the pre-existing history-replay default, preserved
- * here so both kernels can share one predicate.
- */
-export declare function approvalDisplaysInline(source: OriginBearing | null | undefined, approvalType: string, displayApprovalTypes?: readonly string[]): boolean;
-/**
- * True for a rendered segment that holds a Product Guide card (single or batch).
- *
- * Consumers use it to keep such a card in the message flow, where the hub's own
- * chat puts it, instead of lifting it into their sticky pending-approvals
- * footer — and to route its buttons to the hub rather than to the agent.
- */
-export declare function isGuideApprovalSegment(segment: MessageSegment): boolean;
-export {};
-//# sourceMappingURL=approval-display.d.ts.map

package/dist/components/chat/utils/approval-display.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"approval-display.d.ts","sourceRoot":"","sources":["../../../../src/components/chat/utils/approval-display.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAA;AAEhE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAA;AAE5D;oCACoC;AACpC,UAAU,aAAa;IACrB,MAAM,CAAC,EAAE,WAAW,GAAG,MAAM,CAAA;CAC9B;AAED;qDACqD;AACrD,wBAAgB,eAAe,CAAC,MAAM,EAAE,aAAa,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CAEjF;AAED;oEACoE;AACpE,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,aAAa,GAAG,IAAI,GAAG,SAAS,GACvC,WAAW,GAAG,SAAS,CAEzB;AAED;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,aAAa,GAAG,IAAI,GAAG,SAAS,EACxC,YAAY,EAAE,MAAM,EACpB,oBAAoB,CAAC,EAAE,SAAS,MAAM,EAAE,GACvC,OAAO,CAGT;AAED;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAGvE"}

package/src/chat-protocol/confirm-tool.ts

@@ -1,67 +0,0 @@
-/**
- * The hub's confirm-tool contract — request shape and error envelope.
- *
- * Resolving a Product Guide proposal is a POST to `endpoints.approvalToolUrl`
- * whose response is an ordinary guide stream (a `decision_resolved` frame, then
- * the hub's auto-continuation). Two callers make that call today: the SSE chat
- * adapter, and any host replaying the same route into a different transport's
- * conversation (the product app resolves guide cards inside a NATS Mingo
- * dialog). They MUST send byte-identical bodies — a proposal is single-use, so a
- * caller that drifts on a field name does not degrade, it fails the write — and
- * they must surface the same server copy, because the hub's errors are written
- * for the end user ("This approval expired — ask again to get a fresh one").
- *
- * Hence both live here rather than at either call site.
- *
- * Server-safe: no React, no browser APIs.
- */
-
-/** What the user did with the card. */
-export type ApprovalToolAction = 'approve' | 'reject'
-
-/** Client-side shape of a confirm; `buildConfirmToolBody` renames it to the
- *  wire's own casing so no caller hand-writes `proposal_id`. */
-export interface ConfirmToolRequest {
-  /** The hub-minted proposal id carried by the card. */
-  proposalId: string
-  action: ApprovalToolAction
-  /**
-   * The hub's conversation id, quoted back verbatim. The hub rejects a confirm
-   * without it: a proposal only means something inside the conversation that
-   * minted it.
-   */
-  conversationId: string | null | undefined
-}
-
-/** Build the confirm-tool request body. The ONE place that knows the wire
- *  spells the id `proposal_id` while everything else is camelCase. */
-export function buildConfirmToolBody(request: ConfirmToolRequest): Record<string, unknown> {
-  return {
-    proposal_id: request.proposalId,
-    action: request.action,
-    conversationId: request.conversationId,
-  }
-}
-
-/**
- * Pull the user-facing copy out of a failed chat/confirm response.
- *
- * The route-base envelope is `{error, code}`; `error` is written for the end
- * user, so it beats any status-code copy the client could invent. Returns null
- * when the body is not that envelope (HTML error page, empty body, gateway
- * response) — the caller then supplies its own generic line.
- *
- * Consumes the body: call it once, on a response you have already decided is a
- * failure.
- */
-export async function readServerErrorMessage(response: {
-  json: () => Promise<unknown>
-}): Promise<string | null> {
-  try {
-    const body = (await response.json()) as { error?: unknown } | null
-    if (typeof body?.error === 'string' && body.error.length > 0) return body.error
-  } catch {
-    /* non-JSON error body — the caller falls through to its generic copy */
-  }
-  return null
-}

package/src/chat-protocol/leading-frames.ts

@@ -1,175 +0,0 @@
-/**
- * Leading-frame → `ChatStreamEvent` table — the ONE mapping both transports read.
- *
- * The SSE decoder (`./decode.ts`) reaches it while walking the hub's byte
- * framing. The NATS decoder (`./nats-decoder.ts`) reaches it for `GUIDE` chunks
- * carrying a `payload`: the saas-ai-agent re-streams the Product Guide's hub
- * frames VERBATIM into the Mingo chunk stream (`GuideStreamingService`), so the
- * bytes a guide answer is made of are the same frames on both transports — only
- * the envelope differs. Decoding them twice would drift the moment the hub adds
- * a frame kind, which is why this table lives outside either decoder.
- *
- * The NATS side does NOT take every event this table can produce; see
- * `guideFrameEvent` in `./nats-decoder.ts` for which ones cross over and why.
- *
- * Server-safe: no React, no browser APIs.
- */
-
-import type { ChatStreamEvent } from './events'
-
-/**
- * Escape `<` so markdown renderers that pass HTML through (rehypeRaw)
- * don't treat XML-like tokens in Claude's thinking output as elements.
- * `<` → `&lt;` preserves the visible character without breaking
- * blockquote `>` markers. Per-character, so it distributes over
- * concatenation: escape(a + b) === escape(a) + escape(b) — callers may
- * apply it per-delta or on the accumulated string interchangeably.
- */
-export function escapeThinkingTags(text: string): string {
-  return text.replace(/</g, '&lt;')
-}
-
-/**
- * Map one parsed leading frame to normalized events, replicating the
- * legacy parser's else-if chain ORDER and its exact truthiness/typeof
- * gates. Frames that matched a branch but failed its inner validation
- * (e.g. `routing` without a string `routedComplexity`) produce NO event,
- * exactly like the legacy no-op.
- *
- * Every branch pushes AT MOST ONE event — `guideFrameEvent` relies on that
- * to hand a single event back to `decodeNatsChunk`'s per-chunk contract.
- */
-export function mapLeadingFrame(meta: any, out: ChatStreamEvent[]): void {
-  if (meta.status === 'thinking') {
-    out.push({ type: 'status', phase: 'thinking' })
-  } else if (meta.kind === 'thinking-delta' && typeof meta.text === 'string') {
-    // Wire is ALREADY delta — emit verbatim, append-only contract.
-    out.push({ type: 'thinking-delta', text: meta.text })
-  } else if (meta.kind === 'usage' && meta.stage === 'start') {
-    out.push({
-      type: 'usage',
-      stage: 'start',
-      input_tokens: meta.input_tokens,
-      cache_read_input_tokens: meta.cache_read_input_tokens,
-      cache_creation_input_tokens: meta.cache_creation_input_tokens,
-    })
-  } else if (meta.kind === 'decision_resolved' && typeof meta.action === 'string') {
-    const status = meta.action === 'rejected' ? 'rejected' : 'approved'
-    const toolName = typeof meta.tool_name === 'string' ? meta.tool_name : undefined
-    const result = meta.result ?? null
-    const card = meta.card ?? null
-    out.push({
-      type: 'approval-resolved',
-      status,
-      ok: meta.ok === true,
-      willAutoContinue: meta.willAutoContinue === true,
-      ...(toolName ? { toolName } : {}),
-      ...(result ? { result } : {}),
-      ...(card?.marker ? { marker: card.marker } : {}),
-      ...(card?.ref ? { cardRef: card.ref } : {}),
-      ...(card?.type ? { cardType: card.type } : {}),
-      ...(typeof meta.receiptText === 'string' ? { receiptText: meta.receiptText } : {}),
-      requestId: typeof meta.proposalId === 'string' ? meta.proposalId : undefined,
-    })
-  } else if (meta.kind === 'approval_batch' && meta.batchId && Array.isArray(meta.proposals)) {
-    // Server-grouped multi-proposal turn → ONE batch event carrying a
-    // tool-call row per proposal. `toolExecutionRequestId` is the row's
-    // PROPOSAL id (each row resolves through its own per-proposal
-    // confirm); the batch's `requestId` is the stable anchor the shell
-    // uses for status flips. Field rows ride as the row's expandable
-    // args so per-proposal detail stays reachable inside the batch.
-    const toolCalls = (meta.proposals as Array<Record<string, any>>)
-      .filter((p) => p && typeof p.proposalId === 'string')
-      .map((p) => {
-        const rawFields = Array.isArray(p.fields)
-          ? (p.fields as Array<{ label?: string; value?: string }>).filter(
-              (f) => f && f.label && f.value,
-            )
-          : []
-        // Prefer human-readable identity labels for the row's
-        // disambiguator; opaque-id labels ("Task", "Ticket") only as
-        // the last-resort first field.
-        const detail =
-          rawFields.find((f) => /^(title|subject|name)$/i.test(String(f.label))) ??
-          rawFields[0]
-        const base =
-          typeof p.title === 'string' && p.title.length > 0 ? p.title : String(p.toolName ?? 'Tool call')
-        return {
-          toolExecutionRequestId: String(p.proposalId),
-          toolName: String(p.toolName ?? 'tool'),
-          toolTitle: detail ? `${base} — ${detail.value}` : base,
-          requiresApproval: true,
-          toolCallArguments:
-            rawFields.length > 0
-              ? Object.fromEntries(rawFields.map((f) => [String(f.label), String(f.value)]))
-              : null,
-        }
-      })
-    if (toolCalls.length > 0) {
-      out.push({
-        type: 'approval-request',
-        requestId: String(meta.batchId),
-        approvalType: 'chat',
-        toolCalls,
-        status: 'pending',
-      })
-    }
-  } else if (meta.kind === 'approval_request' && meta.proposalId) {
-    const proposalId = String(meta.proposalId)
-    const toolName = String(meta.toolName ?? 'tool')
-    const headline =
-      typeof meta.title === 'string' && meta.title.length > 0 ? meta.title : toolName
-    const rawFields = Array.isArray(meta.fields)
-      ? (meta.fields as Array<{ label?: string; value?: string }>)
-      : []
-    const fields: Array<{ label: string; value: string }> = []
-    for (const f of rawFields) {
-      if (!f || !f.label || !f.value) continue
-      fields.push({ label: f.label, value: f.value })
-    }
-    out.push({
-      type: 'approval-request',
-      requestId: proposalId,
-      approvalType: toolName,
-      command: headline,
-      fields,
-      status: 'pending',
-    })
-  } else if (meta.kind === 'text-leading' && typeof meta.text === 'string') {
-    out.push({ type: 'text-delta', text: meta.text, leading: true })
-  } else if (meta.kind === 'tool_error') {
-    const msg =
-      typeof meta.message === 'string' && meta.message.length > 0
-        ? meta.message
-        : 'Could not complete the requested action right now.'
-    out.push({ type: 'error', title: msg })
-  } else if (meta.kind === 'routing') {
-    if (typeof meta.routedComplexity === 'string') {
-      out.push({
-        type: 'metadata',
-        routing: {
-          routedComplexity: meta.routedComplexity,
-          ...(typeof meta.routedModel === 'string' ? { routedModel: meta.routedModel } : {}),
-          routedThinkingBudget:
-            typeof meta.routedThinkingBudget === 'number' ? meta.routedThinkingBudget : null,
-        },
-      })
-    }
-  } else {
-    // Catch-all metadata-ish frame. Raw values pass through UNVALIDATED
-    // (possibly undefined) so the consumer can replicate the legacy
-    // presence/truthiness gates exactly — including the `model`-presence
-    // trigger whose value is never stored.
-    out.push({
-      type: 'metadata',
-      sources: meta.sources,
-      refs: meta.refs,
-      provider: meta.provider,
-      modelLabel: meta.modelLabel,
-      modelName: meta.model,
-      contextWindowMaxTokens: meta.contextWindowMaxTokens,
-      scrollAnchor: meta.scrollAnchor,
-      conversationId: meta.conversationId,
-    })
-  }
-}

package/src/components/chat/utils/approval-display.ts

@@ -1,70 +0,0 @@
-/**
- * WHERE an approval card renders — the one rule, read by every path that turns
- * an approval into segments.
- *
- * There are three such paths and they must agree: the NATS kernel (live chunks),
- * the SSE kernel, and the history replay that rebuilds a dialog after a reload.
- * When the rule lived only in the live kernel, a Product Guide card rendered
- * inline while streaming and then moved into the escalation treatment on the
- * next page load — same card, two behaviors, and its buttons pointed at the
- * wrong backend once it moved.
- *
- * The rule itself: a card is gated on approval TIER (`displayApprovalTypes`,
- * the agent's own privilege model) UNLESS it came from the Product Guide, whose
- * proposals are typed by TOOL and are resolved through the hub's confirm route.
- * A hub proposal has no tier to gate on, so tier-gating one means escalating it
- * to a human who has no way to act on it.
- */
-
-import type { GuideOrigin } from '../../../chat-protocol/events'
-import { GUIDE_ORIGIN, isGuideOrigin } from '../../../chat-protocol/events'
-import type { MessageSegment } from '../types/message.types'
-
-/** Anything carrying the optional `origin` marker: a stream event, or the
- *  `data` of a rendered segment. */
-interface OriginBearing {
-  origin?: GuideOrigin | string
-}
-
-/** True when this approval was minted by the Product Guide (the hub) rather
- *  than by the agent's own tool-approval tiering. */
-export function isGuideApproval(source: OriginBearing | null | undefined): boolean {
-  return isGuideOrigin(source)
-}
-
-/** The marker to stamp onto a built segment, or undefined for agent approvals.
- *  Keeps `origin` out of segment data unless it means something. */
-export function guideApprovalOrigin(
-  source: OriginBearing | null | undefined,
-): GuideOrigin | undefined {
-  return isGuideApproval(source) ? GUIDE_ORIGIN : undefined
-}
-
-/**
- * Does this approval render inline in its turn (true), or take the consumer's
- * escalation treatment (false)?
- *
- * `displayApprovalTypes` undefined means "no tier gate configured" and every
- * agent approval displays — the pre-existing history-replay default, preserved
- * here so both kernels can share one predicate.
- */
-export function approvalDisplaysInline(
-  source: OriginBearing | null | undefined,
-  approvalType: string,
-  displayApprovalTypes?: readonly string[],
-): boolean {
-  if (isGuideApproval(source)) return true
-  return !displayApprovalTypes || displayApprovalTypes.includes(approvalType)
-}
-
-/**
- * True for a rendered segment that holds a Product Guide card (single or batch).
- *
- * Consumers use it to keep such a card in the message flow, where the hub's own
- * chat puts it, instead of lifting it into their sticky pending-approvals
- * footer — and to route its buttons to the hub rather than to the agent.
- */
-export function isGuideApprovalSegment(segment: MessageSegment): boolean {
-  if (segment.type !== 'approval_request' && segment.type !== 'approval_batch') return false
-  return isGuideApproval(segment.data)
-}