@couplet/agent-ui 1.0.0

package/dist/chunk-LQB4Y7J4.js

@@ -0,0 +1,135 @@
+import {
+  consumeAgentSseStream,
+  createAgentMessage,
+  createAgentSession,
+  extractClarifyFromChain
+} from "./chunk-MJFUPOSB.js";
+
+// src/client/endpoints.ts
+var DEFAULT_AGENT_ENDPOINTS = {
+  createSession: "/api/chat/session",
+  sessions: "/api/chat/sessions",
+  completions: "/api/chat/completions"
+};
+function resolveAgentEndpoints(overrides) {
+  return {
+    ...DEFAULT_AGENT_ENDPOINTS,
+    ...overrides
+  };
+}
+function getSessionDetailEndpoint(endpoints, sessionId) {
+  return `${endpoints.sessions}/${encodeURIComponent(sessionId)}`;
+}
+function getContextUsageEndpoint(endpoints, sessionId) {
+  return `${getSessionDetailEndpoint(endpoints, sessionId)}/context-usage`;
+}
+
+// src/client/create-client.ts
+function readTimestamp(value, fallback) {
+  if (!value) return fallback;
+  const timestamp = new Date(value).getTime();
+  return Number.isNaN(timestamp) ? fallback : timestamp;
+}
+function toAgentMessage(msg) {
+  const chain = msg.chain ?? void 0;
+  const clarify = msg.type === "clarify" && chain ? extractClarifyFromChain(chain) : void 0;
+  return createAgentMessage(msg.role, msg.content ?? "", {
+    id: msg.id ?? void 0,
+    type: msg.type || void 0,
+    chain,
+    clarify,
+    createdAt: readTimestamp(msg.created_at, Date.now())
+  });
+}
+function toAgentSession(data) {
+  const now = Date.now();
+  const createdAt = readTimestamp(data.created_at, now);
+  const baseSession = createAgentSession(data.session_id, createdAt);
+  return {
+    ...baseSession,
+    title: data.title?.trim() || baseSession.title,
+    updatedAt: readTimestamp(data.updated_at, now),
+    messages: data.messages.map(toAgentMessage)
+  };
+}
+function normalizeRequestBody(body) {
+  if (body == null) return body;
+  if (typeof body === "string" || body instanceof Blob || body instanceof ArrayBuffer || ArrayBuffer.isView(body) || body instanceof FormData || body instanceof URLSearchParams || body instanceof ReadableStream) {
+    return body;
+  }
+  return JSON.stringify(body);
+}
+async function requestStream(transport, url, init = {}) {
+  const body = normalizeRequestBody(init.body);
+  const headers = new Headers(init.headers);
+  if (!headers.has("Content-Type") && typeof body === "string") {
+    headers.set("Content-Type", "application/json");
+  }
+  if (!headers.has("Accept")) {
+    headers.set("Accept", "text/event-stream");
+  }
+  return transport.requestStream(url, { ...init, headers, body });
+}
+function createAgentClient(options) {
+  const { transport } = options;
+  const endpoints = resolveAgentEndpoints(options.endpoints);
+  return {
+    endpoints,
+    async createSession() {
+      const data = await transport.request(endpoints.createSession, {
+        method: "POST"
+      });
+      return data.session_id;
+    },
+    async listSessions() {
+      const data = await transport.request(endpoints.sessions);
+      return data.sessions;
+    },
+    async loadLatestSession() {
+      const sessions = await this.listSessions();
+      if (sessions.length === 0) {
+        const sessionId = await this.createSession();
+        return { sessionId, messages: [] };
+      }
+      const detail = await this.getSessionDetail(sessions[0].id);
+      return { sessionId: detail.id, messages: [...detail.messages] };
+    },
+    async getSessionDetail(sessionId) {
+      const data = await transport.request(
+        getSessionDetailEndpoint(endpoints, sessionId)
+      );
+      return toAgentSession(data);
+    },
+    async fetchContextUsage(sessionId) {
+      const data = await transport.request(
+        getContextUsageEndpoint(endpoints, sessionId)
+      );
+      return {
+        budget_tokens: data.budget_tokens,
+        used_tokens: data.used_tokens,
+        used_percent: data.used_percent,
+        categories: data.categories,
+        source: data.source,
+        estimated_tokens: data.estimated_tokens,
+        prompt_tokens: data.prompt_tokens
+      };
+    },
+    async sendMessageStream({ request, signal, onEvent }) {
+      const response = await requestStream(transport, endpoints.completions, {
+        method: "POST",
+        body: JSON.stringify(request),
+        signal
+      });
+      if (!response.body) throw new Error("Agent response body is empty");
+      await consumeAgentSseStream(response.body, onEvent);
+    }
+  };
+}
+
+export {
+  DEFAULT_AGENT_ENDPOINTS,
+  resolveAgentEndpoints,
+  getSessionDetailEndpoint,
+  getContextUsageEndpoint,
+  createAgentClient
+};

package/dist/chunk-MJFUPOSB.js

@@ -0,0 +1,432 @@
+// src/core/session-helpers.ts
+var DEFAULT_PROJECT_NAME = "agent";
+var DEFAULT_SESSION_TITLE = "New conversation";
+var TITLE_MAX_LENGTH = 56;
+function createId(prefix) {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return `${prefix}-${crypto.randomUUID()}`;
+  }
+  return `${prefix}-${Date.now().toString(36)}`;
+}
+function createAgentSession(id, now = Date.now()) {
+  return {
+    id: id ?? createId("session"),
+    title: DEFAULT_SESSION_TITLE,
+    project: DEFAULT_PROJECT_NAME,
+    createdAt: now,
+    updatedAt: now,
+    messages: []
+  };
+}
+function createAgentMessage(role, content, extras = {}) {
+  return {
+    id: createId("message"),
+    role,
+    content,
+    createdAt: Date.now(),
+    ...extras
+  };
+}
+function createClarifyMessage(question, options) {
+  return {
+    id: createId("message"),
+    role: "assistant",
+    content: question,
+    type: "clarify",
+    clarify: { question, options },
+    createdAt: Date.now()
+  };
+}
+function findLastClarifyCall(chain) {
+  return [...chain].reverse().find((node) => node.type === "tool_call" && node.tool_name === "clarify");
+}
+function isClarifyCallAnswered(chain, clarifyCall) {
+  return chain.some((node) => node.type === "user_reply" && node.parent_id === clarifyCall.id);
+}
+function extractClarifyFromChain(chain) {
+  const lastClarifyCall = findLastClarifyCall(chain);
+  if (!lastClarifyCall) return void 0;
+  const input = lastClarifyCall.tool_input ?? {};
+  const question = typeof input.question === "string" ? input.question : "";
+  const options = Array.isArray(input.options) ? input.options.map((option) => String(option)) : void 0;
+  if (!question) return void 0;
+  return { question, options };
+}
+function getPendingClarify(messages) {
+  const message = [...messages].reverse().find((item) => item.role === "assistant" && Boolean(findLastClarifyCall(item.chain ?? [])));
+  const chain = message?.chain ?? [];
+  const lastClarifyCall = findLastClarifyCall(chain);
+  if (!lastClarifyCall || isClarifyCallAnswered(chain, lastClarifyCall)) return void 0;
+  const clarify = message?.clarify ?? extractClarifyFromChain(chain);
+  if (!clarify?.question || !clarify.options?.length) return void 0;
+  return {
+    question: clarify.question,
+    options: clarify.options,
+    chainReplyTo: lastClarifyCall.id
+  };
+}
+function updateMessageType(session, messageId, type) {
+  return {
+    ...session,
+    updatedAt: Date.now(),
+    messages: session.messages.map(
+      (message) => message.id === messageId ? { ...message, type } : message
+    )
+  };
+}
+function updateClarifyMessage(session, messageId, clarify) {
+  return {
+    ...session,
+    updatedAt: Date.now(),
+    messages: session.messages.map(
+      (message) => message.id === messageId ? { ...message, content: "", type: "clarify", clarify } : message
+    )
+  };
+}
+function getSessionTitle(input) {
+  const normalized = input.trim().replace(/\s+/g, " ");
+  if (!normalized) return DEFAULT_SESSION_TITLE;
+  if (normalized.length <= TITLE_MAX_LENGTH) return normalized;
+  return `${normalized.slice(0, TITLE_MAX_LENGTH - 1)}...`;
+}
+function appendSessionMessages(session, messages) {
+  return {
+    ...session,
+    title: session.messages.length ? session.title : getSessionTitle(messages[0]?.content ?? ""),
+    updatedAt: Date.now(),
+    messages: [...session.messages, ...messages]
+  };
+}
+function updateMessageContent(session, messageId, content, error = false) {
+  return {
+    ...session,
+    updatedAt: Date.now(),
+    messages: session.messages.map(
+      (message) => message.id === messageId ? { ...message, content, error } : message
+    )
+  };
+}
+function updateMessageReasoning(session, messageId, reasoning) {
+  return {
+    ...session,
+    updatedAt: Date.now(),
+    messages: session.messages.map(
+      (message) => message.id === messageId ? { ...message, reasoning } : message
+    )
+  };
+}
+function appendUserReplyChainNode(session, parentNodeId, content) {
+  const parentMessage = session.messages.find(
+    (message) => message.chain?.some((node2) => node2.id === parentNodeId)
+  );
+  if (!parentMessage) return session;
+  const node = {
+    id: createId("reply"),
+    type: "user_reply",
+    title: void 0,
+    content,
+    parent_id: parentNodeId
+  };
+  return appendMessageChainNode(session, parentMessage.id, node);
+}
+function appendMessageChainNode(session, messageId, node) {
+  return {
+    ...session,
+    updatedAt: Date.now(),
+    messages: session.messages.map((message) => {
+      if (message.id !== messageId) return message;
+      const existing = message.chain ?? [];
+      const index = existing.findIndex((n) => n.id === node.id);
+      const nextChain = index >= 0 ? existing.map((n, i) => i === index ? node : n) : [...existing, node];
+      return { ...message, chain: nextChain };
+    })
+  };
+}
+function mergeToolCalls(existing, deltas) {
+  const map = /* @__PURE__ */ new Map();
+  for (const item of existing ?? []) {
+    map.set(item.index, item);
+  }
+  for (const delta of deltas) {
+    const current = map.get(delta.index);
+    if (current) {
+      map.set(delta.index, {
+        index: delta.index,
+        id: delta.id || current.id,
+        type: delta.type || current.type,
+        function: {
+          name: delta.function.name || current.function.name,
+          arguments: current.function.arguments + delta.function.arguments
+        }
+      });
+    } else {
+      map.set(delta.index, delta);
+    }
+  }
+  return Array.from(map.entries()).sort(([a], [b]) => a - b).map(([, item]) => item);
+}
+function appendMessageToolCalls(session, messageId, deltas) {
+  return {
+    ...session,
+    updatedAt: Date.now(),
+    messages: session.messages.map(
+      (message) => message.id === messageId ? { ...message, toolCalls: mergeToolCalls(message.toolCalls, deltas) } : message
+    )
+  };
+}
+function removeSessionMessage(session, messageId) {
+  return {
+    ...session,
+    updatedAt: Date.now(),
+    messages: session.messages.filter((message) => message.id !== messageId)
+  };
+}
+
+// src/core/stream.ts
+var STREAM_DONE_MARKER = "[DONE]";
+var SSE_DATA_PREFIX = "data:";
+function assertJsonObject(payload) {
+  if (typeof payload !== "object" || payload === null) {
+    throw new Error("Agent stream payload must be a JSON object");
+  }
+  return payload;
+}
+function readJsonObject(value) {
+  if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+    return value;
+  }
+  return null;
+}
+function readString(value) {
+  return typeof value === "string" ? value : null;
+}
+function readStringArray(value) {
+  if (!Array.isArray(value)) return [];
+  return value.map((item) => String(item));
+}
+function readContextUsageSource(value) {
+  return value === "estimated" || value === "provider" ? value : void 0;
+}
+function parseContextUsageCategories(value) {
+  if (!Array.isArray(value)) return [];
+  return value.map((item) => {
+    const row = readJsonObject(item);
+    if (!row) return null;
+    const id = readString(row.id);
+    const label = readString(row.label);
+    const tokens = typeof row.tokens === "number" ? row.tokens : 0;
+    if (!id || !label) return null;
+    return { id, label, tokens };
+  }).filter((item) => item !== null);
+}
+function parseStreamEvent(eventPayload) {
+  const kind = readString(eventPayload.kind);
+  if (!kind) return null;
+  switch (kind) {
+    case "MessageChunk":
+      return { kind, text: readString(eventPayload.text) ?? "" };
+    case "MessageStop":
+      return { kind, final: Boolean(eventPayload.final) };
+    case "ThinkingChunk":
+      return {
+        kind,
+        content: readString(eventPayload.content) ?? "",
+        node_id: readString(eventPayload.node_id)
+      };
+    case "ToolCallFinished":
+      return {
+        kind,
+        tool_name: readString(eventPayload.tool_name) ?? "",
+        duration: typeof eventPayload.duration === "number" ? eventPayload.duration : 0,
+        ok: Boolean(eventPayload.ok),
+        index: typeof eventPayload.index === "number" ? eventPayload.index : 0
+      };
+    case "ToolCallEvent":
+      return {
+        kind,
+        node_id: readString(eventPayload.node_id) ?? "",
+        tool_name: readString(eventPayload.tool_name) ?? "",
+        tool_input: readJsonObject(eventPayload.tool_input),
+        title: readString(eventPayload.title)
+      };
+    case "ToolResultEvent":
+      return {
+        kind,
+        node_id: readString(eventPayload.node_id) ?? "",
+        tool_name: readString(eventPayload.tool_name) ?? "",
+        tool_output: readJsonObject(eventPayload.tool_output),
+        title: readString(eventPayload.title)
+      };
+    case "UserReplyEvent":
+      return {
+        kind,
+        node_id: readString(eventPayload.node_id) ?? "",
+        content: readString(eventPayload.content) ?? "",
+        parent_id: readString(eventPayload.parent_id)
+      };
+    case "ClarifyEvent":
+      return {
+        kind,
+        node_id: readString(eventPayload.node_id) ?? "",
+        question: readString(eventPayload.question) ?? "",
+        options: readStringArray(eventPayload.options)
+      };
+    case "FinalEvent":
+      return {
+        kind,
+        node_id: readString(eventPayload.node_id) ?? "",
+        content: readString(eventPayload.content) ?? ""
+      };
+    case "Retrying":
+      return {
+        kind,
+        attempt: typeof eventPayload.attempt === "number" ? eventPayload.attempt : 0,
+        max_retries: typeof eventPayload.max_retries === "number" ? eventPayload.max_retries : 0,
+        delay: typeof eventPayload.delay === "number" ? eventPayload.delay : 0,
+        reason: readString(eventPayload.reason) ?? ""
+      };
+    case "ContextCompressed":
+      return { kind };
+    case "ContextUsageEvent":
+      return {
+        kind,
+        budget_tokens: typeof eventPayload.budget_tokens === "number" ? eventPayload.budget_tokens : 0,
+        used_tokens: typeof eventPayload.used_tokens === "number" ? eventPayload.used_tokens : 0,
+        used_percent: typeof eventPayload.used_percent === "number" ? eventPayload.used_percent : 0,
+        categories: parseContextUsageCategories(eventPayload.categories),
+        source: readContextUsageSource(eventPayload.source),
+        estimated_tokens: typeof eventPayload.estimated_tokens === "number" ? eventPayload.estimated_tokens : void 0,
+        prompt_tokens: typeof eventPayload.prompt_tokens === "number" ? eventPayload.prompt_tokens : void 0
+      };
+    case "LongToolHint":
+      return {
+        kind,
+        tool_name: readString(eventPayload.tool_name) ?? "",
+        duration: typeof eventPayload.duration === "number" ? eventPayload.duration : 0
+      };
+    case "FatalError":
+      return { kind, message: readString(eventPayload.message) ?? "" };
+    case "OpenPageEvent":
+      return {
+        kind,
+        url: readString(eventPayload.url) ?? "",
+        title: readString(eventPayload.title)
+      };
+    case "OpenExternalLinkEvent":
+      return {
+        kind,
+        url: readString(eventPayload.url) ?? "",
+        title: readString(eventPayload.title)
+      };
+    default:
+      return null;
+  }
+}
+function streamEventToChainNode(event) {
+  switch (event.kind) {
+    case "ThinkingChunk":
+      return {
+        id: event.node_id ?? `thinking-${Date.now()}`,
+        type: "thinking",
+        content: event.content
+      };
+    case "ToolCallEvent":
+      return {
+        id: event.node_id,
+        type: "tool_call",
+        title: event.title ?? void 0,
+        tool_name: event.tool_name,
+        tool_input: event.tool_input ?? void 0
+      };
+    case "ToolResultEvent":
+      return {
+        id: event.node_id,
+        type: "tool_result",
+        title: event.title ?? void 0,
+        tool_name: event.tool_name,
+        tool_output: event.tool_output ?? void 0
+      };
+    case "UserReplyEvent":
+      return {
+        id: event.node_id,
+        type: "user_reply",
+        content: event.content,
+        parent_id: event.parent_id ?? void 0
+      };
+    case "FinalEvent":
+      return {
+        id: event.node_id,
+        type: "final",
+        content: event.content
+      };
+    default:
+      return null;
+  }
+}
+function parseSseEnvelope(rawEvent) {
+  const dataLines = [];
+  for (const line of rawEvent.split(/\r?\n/)) {
+    if (!line || line.startsWith(":")) continue;
+    if (line.startsWith(SSE_DATA_PREFIX)) {
+      dataLines.push(line.slice(SSE_DATA_PREFIX.length).trimStart());
+    }
+  }
+  if (!dataLines.length) return null;
+  const payload = dataLines.join("\n").trim();
+  if (payload === STREAM_DONE_MARKER) return null;
+  const parsed = assertJsonObject(JSON.parse(payload));
+  if (parsed.type !== "event") {
+    throw new Error(`Unexpected agent stream payload type: ${String(parsed.type)}`);
+  }
+  const eventPayload = readJsonObject(parsed.event);
+  if (!eventPayload) return null;
+  return parseStreamEvent(eventPayload);
+}
+function processBufferedEvents(buffered, onEvent) {
+  const events = buffered.split(/\r?\n\r?\n/);
+  const rest = events.pop() ?? "";
+  for (const raw of events) {
+    const streamEvent = parseSseEnvelope(raw);
+    if (streamEvent) onEvent(streamEvent);
+  }
+  return rest;
+}
+async function consumeAgentSseStream(body, onEvent) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffered = "";
+  while (true) {
+    const { value, done } = await reader.read();
+    if (done) break;
+    buffered = processBufferedEvents(buffered + decoder.decode(value, { stream: true }), onEvent);
+  }
+  buffered = processBufferedEvents(buffered + decoder.decode(), onEvent);
+  if (buffered.trim()) {
+    const streamEvent = parseSseEnvelope(buffered);
+    if (streamEvent) onEvent(streamEvent);
+  }
+}
+
+export {
+  createAgentSession,
+  createAgentMessage,
+  createClarifyMessage,
+  findLastClarifyCall,
+  isClarifyCallAnswered,
+  extractClarifyFromChain,
+  getPendingClarify,
+  updateMessageType,
+  updateClarifyMessage,
+  getSessionTitle,
+  appendSessionMessages,
+  updateMessageContent,
+  updateMessageReasoning,
+  appendUserReplyChainNode,
+  appendMessageChainNode,
+  appendMessageToolCalls,
+  removeSessionMessage,
+  parseStreamEvent,
+  streamEventToChainNode,
+  parseSseEnvelope,
+  consumeAgentSseStream
+};