@couplet/agent-ui 1.0.0

package/dist/chunk-PVUMYYWU.js

@@ -0,0 +1,194 @@
+import {
+  appendMessageChainNode,
+  appendSessionMessages,
+  appendUserReplyChainNode,
+  createAgentMessage,
+  removeSessionMessage,
+  streamEventToChainNode,
+  updateClarifyMessage,
+  updateMessageContent,
+  updateMessageReasoning
+} from "./chunk-MJFUPOSB.js";
+
+// src/core/session-runtime.ts
+function replaceSession(sessions, nextSession) {
+  return sessions.map((session) => session.id === nextSession.id ? nextSession : session);
+}
+function upsertSession(sessions, nextSession) {
+  const exists = sessions.some((session) => session.id === nextSession.id);
+  return sortSessions(exists ? replaceSession(sessions, nextSession) : [nextSession, ...sessions]);
+}
+function sortSessions(sessions) {
+  return [...sessions].sort((first, second) => second.updatedAt - first.updatedAt);
+}
+async function loadInitialChatSession(client, mode) {
+  if (mode === "new") {
+    return { sessionId: await client.createSession(), messages: [] };
+  }
+  return client.loadLatestSession();
+}
+function updateSessionInState(sessions, sessionId, updater) {
+  const current = sessions.find((s) => s.id === sessionId);
+  if (!current) return sessions;
+  return sortSessions(replaceSession(sessions, updater(current)));
+}
+function handleStreamEvent(event, ctx) {
+  const { sessionId, assistantMessageId, setSessions, setStatus, setContextUsage, onNavigate } = ctx;
+  switch (event.kind) {
+    case "MessageChunk":
+      setSessions(
+        (prev) => updateSessionInState(prev, sessionId, (current) => {
+          const message = current.messages.find((item) => item.id === assistantMessageId);
+          if (!message) return current;
+          return updateMessageContent(current, assistantMessageId, message.content + event.text);
+        })
+      );
+      setStatus((prev) => prev === "retrying" ? "streaming" : prev);
+      break;
+    case "ThinkingChunk":
+      handleThinkingChunk(event, ctx);
+      break;
+    case "ClarifyEvent":
+      setSessions(
+        (prev) => updateSessionInState(
+          prev,
+          sessionId,
+          (current) => updateClarifyMessage(current, assistantMessageId, {
+            question: event.question,
+            options: event.options.length ? event.options : void 0
+          })
+        )
+      );
+      break;
+    case "FinalEvent":
+      if (event.content) {
+        setSessions(
+          (prev) => updateSessionInState(
+            prev,
+            sessionId,
+            (current) => updateMessageContent(current, assistantMessageId, event.content)
+          )
+        );
+      }
+      break;
+    case "Retrying":
+      setStatus("retrying");
+      break;
+    case "FatalError":
+      throw new Error(event.message || "Agent stream failed");
+    case "OpenPageEvent":
+    case "OpenExternalLinkEvent":
+      if (!onNavigate) throw new Error("Agent navigation handler is not configured");
+      onNavigate(event);
+      break;
+    case "ContextUsageEvent":
+      setContextUsage?.({
+        budget_tokens: event.budget_tokens,
+        used_tokens: event.used_tokens,
+        used_percent: event.used_percent,
+        categories: event.categories,
+        source: event.source,
+        estimated_tokens: event.estimated_tokens,
+        prompt_tokens: event.prompt_tokens
+      });
+      break;
+    case "MessageStop":
+    case "ToolCallFinished":
+    case "ContextCompressed":
+    case "LongToolHint":
+      break;
+    default:
+      handleChainNodeEvent(event, ctx);
+  }
+}
+function handleThinkingChunk(event, ctx) {
+  const { sessionId, assistantMessageId, setSessions } = ctx;
+  if (event.node_id) {
+    setSessions(
+      (prev) => updateSessionInState(
+        prev,
+        sessionId,
+        (current) => appendMessageChainNode(current, assistantMessageId, {
+          id: event.node_id,
+          type: "thinking",
+          content: event.content
+        })
+      )
+    );
+    return;
+  }
+  setSessions(
+    (prev) => updateSessionInState(prev, sessionId, (current) => {
+      const message = current.messages.find((item) => item.id === assistantMessageId);
+      const nextReasoning = (message?.reasoning ?? "") + event.content;
+      return updateMessageReasoning(current, assistantMessageId, nextReasoning);
+    })
+  );
+}
+function handleChainNodeEvent(event, ctx) {
+  const chainNode = streamEventToChainNode(event);
+  if (!chainNode) return;
+  const { sessionId, assistantMessageId, setSessions } = ctx;
+  setSessions(
+    (prev) => updateSessionInState(
+      prev,
+      sessionId,
+      (current) => appendMessageChainNode(current, assistantMessageId, chainNode)
+    )
+  );
+}
+function createPendingSession(session, content, assistantMessage, chainReplyTo) {
+  const userMessages = chainReplyTo ? [] : [createAgentMessage("user", content)];
+  const appended = appendSessionMessages(session, [...userMessages, assistantMessage]);
+  return chainReplyTo ? appendUserReplyChainNode(appended, chainReplyTo, content) : appended;
+}
+async function runAgentStream(options) {
+  const { client, session, content, chainReplyTo, setSessions, setStatus, abortControllerRef } = options;
+  const assistantMessage = createAgentMessage("assistant", "");
+  const nextSession = createPendingSession(session, content, assistantMessage, chainReplyTo);
+  const abortController = new AbortController();
+  abortControllerRef.current = abortController;
+  setStatus("streaming");
+  setSessions((prev) => sortSessions(replaceSession(prev, nextSession)));
+  try {
+    await client.sendMessageStream({
+      request: {
+        session_id: session.id,
+        message: { role: "user", content },
+        stream: true,
+        chain_reply_to: chainReplyTo
+      },
+      signal: abortController.signal,
+      onEvent: (event) => handleStreamEvent(event, {
+        sessionId: session.id,
+        assistantMessageId: assistantMessage.id,
+        setSessions,
+        setStatus,
+        setContextUsage: options.setContextUsage,
+        onNavigate: options.onNavigate
+      })
+    });
+    setStatus("idle");
+  } catch (error) {
+    if (abortController.signal.aborted) {
+      setSessions((prev) => replaceSession(prev, removeSessionMessage(nextSession, assistantMessage.id)));
+      setStatus("idle");
+      return;
+    }
+    const message = error instanceof Error ? error.message : options.getStreamErrorMessage();
+    setSessions(
+      (prev) => replaceSession(prev, updateMessageContent(nextSession, assistantMessage.id, message, true))
+    );
+    setStatus("error");
+  } finally {
+    abortControllerRef.current = null;
+  }
+}
+
+export {
+  replaceSession,
+  upsertSession,
+  sortSessions,
+  loadInitialChatSession,
+  runAgentStream
+};

package/dist/client.d.ts

@@ -0,0 +1,11 @@
+import { u as CreateAgentClientOptions, b as AgentClient, f as AgentEndpoints } from './types-rklAgjcr.js';
+export { l as AgentTransport, o as ChatSessionListItem, p as ChatSessionListResponse } from './types-rklAgjcr.js';
+
+declare function createAgentClient(options: CreateAgentClientOptions): AgentClient;
+
+declare const DEFAULT_AGENT_ENDPOINTS: AgentEndpoints;
+declare function resolveAgentEndpoints(overrides?: Partial<AgentEndpoints>): AgentEndpoints;
+declare function getSessionDetailEndpoint(endpoints: AgentEndpoints, sessionId: string): string;
+declare function getContextUsageEndpoint(endpoints: AgentEndpoints, sessionId: string): string;
+
+export { AgentClient, AgentEndpoints, CreateAgentClientOptions, DEFAULT_AGENT_ENDPOINTS, createAgentClient, getContextUsageEndpoint, getSessionDetailEndpoint, resolveAgentEndpoints };

package/dist/client.js

@@ -0,0 +1,15 @@
+import {
+  DEFAULT_AGENT_ENDPOINTS,
+  createAgentClient,
+  getContextUsageEndpoint,
+  getSessionDetailEndpoint,
+  resolveAgentEndpoints
+} from "./chunk-LQB4Y7J4.js";
+import "./chunk-MJFUPOSB.js";
+export {
+  DEFAULT_AGENT_ENDPOINTS,
+  createAgentClient,
+  getContextUsageEndpoint,
+  getSessionDetailEndpoint,
+  resolveAgentEndpoints
+};

package/dist/core.d.ts

@@ -0,0 +1,51 @@
+import { A as AgentSession, m as ChainNode, j as AgentToolCall, g as AgentMessage, e as AgentClarify, d as AgentPendingClarify, b as AgentClient, a as AgentStatus, c as AgentNavigationEvent, C as ContextUsage, S as StreamEvent } from './types-rklAgjcr.js';
+export { h as AgentMessageRole, i as AgentStreamRequest, k as AgentToolCallFunction, n as ChainNodeType, q as ClarifyEvent, r as ContextCompressedEvent, s as ContextUsageCategory, t as ContextUsageEvent, F as FatalErrorEvent, v as FinalEvent, L as LongToolHintEvent, M as MessageChunkEvent, w as MessageStopEvent, O as OpenExternalLinkEvent, x as OpenPageEvent, R as RetryingEvent, y as StreamEventBase, T as ThinkingChunkEvent, z as ToolCallEvent, B as ToolCallFinishedEvent, D as ToolResultEvent, U as UserReplyEvent } from './types-rklAgjcr.js';
+import { Dispatch, SetStateAction, MutableRefObject } from 'react';
+
+declare function createAgentSession(id?: string, now?: number): AgentSession;
+declare function createAgentMessage(role: AgentMessage['role'], content: string, extras?: Partial<AgentMessage>): AgentMessage;
+declare function createClarifyMessage(question: string, options?: readonly string[]): AgentMessage;
+declare function findLastClarifyCall(chain: readonly ChainNode[]): ChainNode | undefined;
+declare function isClarifyCallAnswered(chain: readonly ChainNode[], clarifyCall: ChainNode): boolean;
+declare function extractClarifyFromChain(chain: readonly ChainNode[]): AgentClarify | undefined;
+declare function getPendingClarify(messages: readonly AgentMessage[]): AgentPendingClarify | undefined;
+declare function updateMessageType(session: AgentSession, messageId: string, type: AgentMessage['type']): AgentSession;
+declare function updateClarifyMessage(session: AgentSession, messageId: string, clarify: AgentClarify): AgentSession;
+declare function getSessionTitle(input: string): string;
+declare function appendSessionMessages(session: AgentSession, messages: readonly AgentMessage[]): AgentSession;
+declare function updateMessageContent(session: AgentSession, messageId: string, content: string, error?: boolean): AgentSession;
+declare function updateMessageReasoning(session: AgentSession, messageId: string, reasoning: string): AgentSession;
+declare function appendUserReplyChainNode(session: AgentSession, parentNodeId: string, content: string): AgentSession;
+declare function appendMessageChainNode(session: AgentSession, messageId: string, node: ChainNode): AgentSession;
+declare function appendMessageToolCalls(session: AgentSession, messageId: string, deltas: readonly AgentToolCall[]): AgentSession;
+declare function removeSessionMessage(session: AgentSession, messageId: string): AgentSession;
+
+type InitialAgentSessionMode = 'latest' | 'new';
+interface AgentStreamRunnerOptions {
+    readonly client: AgentClient;
+    readonly session: AgentSession;
+    readonly content: string;
+    readonly chainReplyTo?: string;
+    readonly setSessions: Dispatch<SetStateAction<readonly AgentSession[]>>;
+    readonly setStatus: Dispatch<SetStateAction<AgentStatus>>;
+    readonly abortControllerRef: MutableRefObject<AbortController | null>;
+    readonly onNavigate?: (event: AgentNavigationEvent) => void;
+    readonly setContextUsage?: Dispatch<SetStateAction<ContextUsage | null>>;
+    readonly getStreamErrorMessage: () => string;
+}
+declare function replaceSession(sessions: readonly AgentSession[], nextSession: AgentSession): readonly AgentSession[];
+declare function upsertSession(sessions: readonly AgentSession[], nextSession: AgentSession): readonly AgentSession[];
+declare function sortSessions(sessions: readonly AgentSession[]): readonly AgentSession[];
+declare function loadInitialChatSession(client: AgentClient, mode: InitialAgentSessionMode): Promise<{
+    sessionId: string;
+    messages: AgentMessage[];
+}>;
+declare function runAgentStream(options: AgentStreamRunnerOptions): Promise<void>;
+
+type JsonObject = Record<string, unknown>;
+declare function parseStreamEvent(eventPayload: JsonObject): StreamEvent | null;
+declare function streamEventToChainNode(event: StreamEvent): ChainNode | null;
+declare function parseSseEnvelope(rawEvent: string): StreamEvent | null;
+declare function consumeAgentSseStream(body: ReadableStream<Uint8Array>, onEvent: (event: StreamEvent) => void): Promise<void>;
+
+export { AgentClarify, AgentMessage, AgentNavigationEvent, AgentPendingClarify, AgentSession, AgentStatus, type AgentStreamRunnerOptions, AgentToolCall, ChainNode, ContextUsage, type InitialAgentSessionMode, StreamEvent, appendMessageChainNode, appendMessageToolCalls, appendSessionMessages, appendUserReplyChainNode, consumeAgentSseStream, createAgentMessage, createAgentSession, createClarifyMessage, extractClarifyFromChain, findLastClarifyCall, getPendingClarify, getSessionTitle, isClarifyCallAnswered, loadInitialChatSession, parseSseEnvelope, parseStreamEvent, removeSessionMessage, replaceSession, runAgentStream, sortSessions, streamEventToChainNode, updateClarifyMessage, updateMessageContent, updateMessageReasoning, updateMessageType, upsertSession };

package/dist/core.js

@@ -0,0 +1,58 @@
+import {
+  loadInitialChatSession,
+  replaceSession,
+  runAgentStream,
+  sortSessions,
+  upsertSession
+} from "./chunk-PVUMYYWU.js";
+import {
+  appendMessageChainNode,
+  appendMessageToolCalls,
+  appendSessionMessages,
+  appendUserReplyChainNode,
+  consumeAgentSseStream,
+  createAgentMessage,
+  createAgentSession,
+  createClarifyMessage,
+  extractClarifyFromChain,
+  findLastClarifyCall,
+  getPendingClarify,
+  getSessionTitle,
+  isClarifyCallAnswered,
+  parseSseEnvelope,
+  parseStreamEvent,
+  removeSessionMessage,
+  streamEventToChainNode,
+  updateClarifyMessage,
+  updateMessageContent,
+  updateMessageReasoning,
+  updateMessageType
+} from "./chunk-MJFUPOSB.js";
+export {
+  appendMessageChainNode,
+  appendMessageToolCalls,
+  appendSessionMessages,
+  appendUserReplyChainNode,
+  consumeAgentSseStream,
+  createAgentMessage,
+  createAgentSession,
+  createClarifyMessage,
+  extractClarifyFromChain,
+  findLastClarifyCall,
+  getPendingClarify,
+  getSessionTitle,
+  isClarifyCallAnswered,
+  loadInitialChatSession,
+  parseSseEnvelope,
+  parseStreamEvent,
+  removeSessionMessage,
+  replaceSession,
+  runAgentStream,
+  sortSessions,
+  streamEventToChainNode,
+  updateClarifyMessage,
+  updateMessageContent,
+  updateMessageReasoning,
+  updateMessageType,
+  upsertSession
+};

package/dist/index.d.ts

@@ -0,0 +1,162 @@
+import { A as AgentSession, a as AgentStatus, C as ContextUsage, b as AgentClient, c as AgentNavigationEvent, d as AgentPendingClarify } from './types-rklAgjcr.js';
+export { e as AgentClarify, f as AgentEndpoints, g as AgentMessage, h as AgentMessageRole, i as AgentStreamRequest, j as AgentToolCall, k as AgentToolCallFunction, l as AgentTransport, m as ChainNode, n as ChainNodeType, o as ChatSessionListItem, p as ChatSessionListResponse, q as ClarifyEvent, r as ContextCompressedEvent, s as ContextUsageCategory, t as ContextUsageEvent, u as CreateAgentClientOptions, F as FatalErrorEvent, v as FinalEvent, L as LongToolHintEvent, M as MessageChunkEvent, w as MessageStopEvent, O as OpenExternalLinkEvent, x as OpenPageEvent, R as RetryingEvent, S as StreamEvent, y as StreamEventBase, T as ThinkingChunkEvent, z as ToolCallEvent, B as ToolCallFinishedEvent, D as ToolResultEvent, U as UserReplyEvent } from './types-rklAgjcr.js';
+export { AgentStreamRunnerOptions, InitialAgentSessionMode, appendMessageChainNode, appendMessageToolCalls, appendSessionMessages, appendUserReplyChainNode, consumeAgentSseStream, createAgentMessage, createAgentSession, createClarifyMessage, extractClarifyFromChain, findLastClarifyCall, getPendingClarify, getSessionTitle, isClarifyCallAnswered, loadInitialChatSession, parseSseEnvelope, parseStreamEvent, removeSessionMessage, replaceSession, runAgentStream, sortSessions, streamEventToChainNode, updateClarifyMessage, updateMessageContent, updateMessageReasoning, updateMessageType, upsertSession } from './core.js';
+export { DEFAULT_AGENT_ENDPOINTS, createAgentClient, getContextUsageEndpoint, getSessionDetailEndpoint, resolveAgentEndpoints } from './client.js';
+import * as react from 'react';
+
+interface AgentContextUsageLabels {
+    readonly title: string;
+    readonly tokens: string;
+    readonly percent: string;
+    readonly categoryLabels: Record<string, string>;
+}
+interface AgentComposerLabels {
+    readonly placeholder: string;
+    readonly send: string;
+    readonly stop: string;
+    readonly clarifyTitle: string;
+    readonly contextUsage: AgentContextUsageLabels;
+}
+interface AgentConversationViewLabels {
+    readonly copy: string;
+    readonly copied: string;
+    readonly thinking: string;
+    readonly thoughtProcess: string;
+    readonly toolInput: string;
+    readonly toolOutput: string;
+    readonly userSelected: string;
+    readonly clarifyQuestion: string;
+}
+interface AgentHistoryLabels {
+    readonly title: string;
+    readonly description: string;
+    readonly search: string;
+    readonly recent: string;
+    readonly empty: string;
+    readonly loading: string;
+    readonly loadError: string;
+    readonly selectError: string;
+    readonly untitled: string;
+    readonly messageCount: (count: number) => string;
+}
+interface AgentSessionLabels {
+    readonly streamError: string;
+}
+interface AgentConversationLabels {
+    readonly conversation: AgentConversationViewLabels;
+    readonly composer: AgentComposerLabels;
+}
+interface AgentPanelHeaderLabels {
+    readonly title: string;
+    readonly newConversation: string;
+    readonly history: string;
+    readonly close: string;
+    readonly expandToFullPage: string;
+    readonly collapseToPanel: string;
+    readonly resizeHandle: string;
+}
+interface AgentSurfaceLabels extends AgentConversationLabels {
+}
+
+interface UseAgentSessionOptions {
+    readonly client: AgentClient;
+    readonly labels: Pick<AgentSessionLabels, 'streamError'>;
+    readonly autoInit?: boolean;
+    readonly initialSessionMode?: 'latest' | 'new';
+    readonly onNavigate?: (event: AgentNavigationEvent) => void;
+}
+interface UseAgentSessionState {
+    readonly currentSession: AgentSession;
+    readonly status: AgentStatus;
+    readonly contextUsage: ContextUsage | null;
+    readonly createSession: () => Promise<void>;
+    readonly selectSession: (sessionId: string) => Promise<void>;
+    readonly sendMessage: (content: string) => Promise<void>;
+    readonly sendClarifyOption: (option: string, chainReplyTo: string) => Promise<void>;
+    readonly stopStreaming: () => void;
+}
+
+declare function useAgentSession(options: UseAgentSessionOptions): UseAgentSessionState;
+
+interface AgentComposerProps {
+    readonly status: AgentStatus;
+    readonly contextUsage?: ContextUsage | null;
+    readonly pendingClarify?: AgentPendingClarify;
+    readonly labels: {
+        readonly placeholder: string;
+        readonly send: string;
+        readonly stop: string;
+        readonly clarifyTitle: string;
+        readonly contextUsage: {
+            readonly title: string;
+            readonly tokens: string;
+            readonly percent: string;
+            readonly categoryLabels: Record<string, string>;
+        };
+    };
+    readonly isNew: boolean;
+    readonly initialQuestions?: readonly string[];
+    readonly className?: string;
+    readonly onSubmit: (content: string) => Promise<void>;
+    readonly onClarifyOption: (option: string, chainReplyTo: string) => Promise<void>;
+    readonly onStop: () => void;
+}
+declare function AgentComposer({ status, contextUsage, pendingClarify, labels, isNew, initialQuestions, className, onSubmit, onClarifyOption, onStop, }: AgentComposerProps): react.JSX.Element;
+
+interface AIConversationRef {
+    scrollToBottom: () => void;
+}
+
+interface ConversationViewLabels {
+    readonly copy: string;
+    readonly copied: string;
+    readonly toolInput: string;
+    readonly toolOutput: string;
+    readonly userSelected: string;
+    readonly clarifyQuestion: string;
+    readonly thinking: string;
+    readonly thoughtProcess: string;
+}
+
+interface ConversationViewProps {
+    readonly session: AgentSession;
+    readonly status: AgentStatus;
+    readonly awaitingUserReply?: boolean;
+    readonly labels: ConversationViewLabels;
+    readonly conversationRef?: React.RefObject<AIConversationRef | null>;
+}
+declare function ConversationView({ session, status, awaitingUserReply, labels, conversationRef, }: ConversationViewProps): react.JSX.Element;
+
+interface AgentConversationSurfaceProps {
+    readonly agent: UseAgentSessionState;
+    readonly labels: AgentSurfaceLabels;
+    readonly initialQuestions?: readonly string[];
+    readonly className?: string;
+}
+declare function AgentConversationSurface({ agent, labels, initialQuestions, className, }: AgentConversationSurfaceProps): react.JSX.Element;
+
+interface AgentHistoryDialogProps {
+    readonly client: AgentClient;
+    readonly open: boolean;
+    readonly busy: boolean;
+    readonly onOpenChange: (open: boolean) => void;
+    readonly onSelectSession: (sessionId: string) => Promise<void>;
+    readonly labels: AgentHistoryLabels;
+}
+declare function AgentHistoryDialog({ client, open, busy, onOpenChange, onSelectSession, labels, }: AgentHistoryDialogProps): react.JSX.Element;
+
+interface ContextUsageIndicatorProps {
+    readonly usage: ContextUsage | null;
+    readonly hasMessages: boolean;
+    readonly isStreaming: boolean;
+    readonly labels: {
+        readonly title: string;
+        readonly tokens: string;
+        readonly percent: string;
+        readonly categoryLabels: Record<string, string>;
+    };
+    readonly className?: string;
+}
+declare function ContextUsageIndicator({ usage, hasMessages, isStreaming, labels, className, }: ContextUsageIndicatorProps): react.JSX.Element | null;
+
+export { AgentClient, AgentComposer, type AgentComposerLabels, type AgentContextUsageLabels, type AgentConversationLabels, AgentConversationSurface, type AgentConversationSurfaceProps, type AgentConversationViewLabels, AgentHistoryDialog, type AgentHistoryDialogProps, type AgentHistoryLabels, AgentNavigationEvent, type AgentPanelHeaderLabels, AgentPendingClarify, AgentSession, type AgentSessionLabels, AgentStatus, type AgentSurfaceLabels, ContextUsage, ContextUsageIndicator, ConversationView, type ConversationViewLabels, type UseAgentSessionOptions, type UseAgentSessionState, useAgentSession };