@agent-native/core 0.111.4 → 0.113.0

package/corpus/core/src/client/chat/ChatHistoryList.tsx

@@ -1,404 +1,7 @@
-import {
-  IconDots,
-  IconPencil,
-  IconPinned,
-  IconPinnedOff,
-  IconSearch,
-  IconTrash,
-} from "@tabler/icons-react";
-import React, { useEffect, useRef, useState } from "react";
-
-import { cn } from "../utils.js";
-
-/** A single row in a chat history list. Purely data — no fetching, no
- * assistant-ui context. Formatting (relative time, "Active"/"Open" labels,
- * status spinners) is the caller's responsibility; hand in the already
- * rendered node via `timestamp`. */
-export interface ChatHistoryItem {
-  id: string;
-  title: React.ReactNode;
-  /** Plain-text form of `title`, used to seed the inline rename input.
-   * Only needed when `onRename` is supplied. */
-  titleText?: string;
-  /** Secondary line — e.g. a message preview. */
-  subtitle?: React.ReactNode;
-  /** Tertiary line — e.g. a scope/folder label. */
-  detail?: React.ReactNode;
-  /** Pre-formatted trailing value: a relative time, "Active"/"Open", or a
-   * status node (spinner, unread dot). This component does not format
-   * dates or compute status itself. */
-  timestamp?: React.ReactNode;
-  pinned?: boolean;
-  disabled?: boolean;
-}
-
-export interface ChatHistorySection {
-  id: string;
-  label?: React.ReactNode;
-  items: ChatHistoryItem[];
-}
-
-export interface ChatHistoryListProps {
-  /** Flat item list. Ignored when `sections` is provided. */
-  items?: ChatHistoryItem[];
-  /** Grouped item list (e.g. "This deck" / "All chats", or pinned/recent). */
-  sections?: ChatHistorySection[];
-  /** Id of the currently active/selected item — highlighted in the list. */
-  activeId?: string | null;
-  onSelect: (id: string) => void;
-  /** Fired on double-click / explicit "open" gesture, distinct from select. */
-  onOpen?: (id: string) => void;
-  /** Presence enables the pin/unpin row action. */
-  onTogglePin?: (id: string) => void;
-  /** Presence enables the inline "Rename" row action. */
-  onRename?: (id: string, nextTitle: string) => void;
-  /** Presence enables the "Delete" row action. */
-  onDelete?: (id: string) => void;
-  /** Escape hatch: fully custom row action menu content, replacing the
-   * built-in rename/pin/delete items. Still gated by the trigger button,
-   * which shows whenever this or any of the on* callbacks above is set. */
-  renderRowActions?: (item: ChatHistoryItem) => React.ReactNode;
-
-  /** Controlled search input. Omit `onSearchChange` to hide the search box
-   * entirely and let the host render its own (results are always supplied
-   * by the caller via `items`/`sections` either way). */
-  searchValue?: string;
-  onSearchChange?: (value: string) => void;
-  searchPlaceholder?: string;
-  searchInputRef?: React.Ref<HTMLInputElement>;
-
-  /** True while results are being fetched — shows `loadingLabel` instead of
-   * the list. */
-  loading?: boolean;
-  loadingLabel?: React.ReactNode;
-  /** Shown instead of the list when set (takes priority over `loading`). */
-  error?: React.ReactNode;
-  emptyLabel?: React.ReactNode;
-  /** Shown instead of `emptyLabel` when `searchValue` is non-empty. */
-  emptySearchLabel?: React.ReactNode;
-
-  /** Rendered after the list, inside the scroll container (e.g. a
-   * "Load older chats" button). */
-  footer?: React.ReactNode;
-
-  /** "popover" (default) matches core's compact HistoryPopover list.
-   * "rail" is a denser variant with a solid active background, closer to
-   * a sidebar run rail. */
-  variant?: "popover" | "rail";
-  className?: string;
-  listClassName?: string;
-}
-
-/**
- * Presentational chat history list shared by core's `HistoryPopover`
- * (MultiTabAssistantChat.tsx) and Agent-Native Code's run rail
- * (code-agents-ui). Styling is driven by stable `an-chat-history*` class
- * names (see `styles/chat-history-list.css`) rather than Tailwind utilities
- * so the same component renders correctly in a Tailwind host and in
- * code-agents-ui's plain-CSS host.
- *
- * This component owns no data: search filtering, pin/rename persistence,
- * and time formatting all stay with the caller. It only renders whatever
- * `items`/`sections` it is given, plus the optional search box and
- * loading/empty/error states.
- */
-export function ChatHistoryList({
-  items,
-  sections,
-  activeId = null,
-  onSelect,
-  onOpen,
-  onTogglePin,
-  onRename,
-  onDelete,
-  renderRowActions,
-  searchValue,
-  onSearchChange,
-  searchPlaceholder = "Search chats...",
-  searchInputRef,
-  loading = false,
-  loadingLabel = "Searching...",
-  error,
-  emptyLabel = "No chats yet",
-  emptySearchLabel = "No matching chats",
-  footer,
-  variant = "popover",
-  className,
-  listClassName,
-}: ChatHistoryListProps) {
-  const resolvedSections: ChatHistorySection[] =
-    sections ?? (items ? [{ id: "default", items }] : []);
-  const totalCount = resolvedSections.reduce(
-    (sum, section) => sum + section.items.length,
-    0,
-  );
-  const hasSearchValue = Boolean(searchValue?.trim());
-
-  return (
-    <div
-      className={cn(
-        "an-chat-history",
-        variant === "rail" && "an-chat-history--rail",
-        className,
-      )}
-      data-agent-native="chat-history-list"
-    >
-      {onSearchChange && (
-        <div className="an-chat-history__search">
-          <IconSearch size={13} className="an-chat-history__search-icon" />
-          <input
-            ref={searchInputRef}
-            type="text"
-            value={searchValue ?? ""}
-            onChange={(event) => onSearchChange(event.target.value)}
-            placeholder={searchPlaceholder}
-            aria-label={searchPlaceholder}
-            className="an-chat-history__search-input"
-          />
-        </div>
-      )}
-      <div className={cn("an-chat-history__list", listClassName)}>
-        {error ? (
-          <div className="an-chat-history__state an-chat-history__state--error">
-            {error}
-          </div>
-        ) : loading ? (
-          <div className="an-chat-history__state">{loadingLabel}</div>
-        ) : totalCount === 0 ? (
-          <div className="an-chat-history__state">
-            {hasSearchValue ? emptySearchLabel : emptyLabel}
-          </div>
-        ) : (
-          resolvedSections.map(
-            (section) =>
-              section.items.length > 0 && (
-                <div key={section.id} className="an-chat-history__section">
-                  {section.label && (
-                    <div className="an-chat-history__section-label">
-                      {section.label}
-                    </div>
-                  )}
-                  {section.items.map((item) => (
-                    <ChatHistoryRow
-                      key={item.id}
-                      item={item}
-                      active={item.id === activeId}
-                      onSelect={onSelect}
-                      onOpen={onOpen}
-                      onTogglePin={onTogglePin}
-                      onRename={onRename}
-                      onDelete={onDelete}
-                      renderRowActions={renderRowActions}
-                    />
-                  ))}
-                </div>
-              ),
-          )
-        )}
-        {footer}
-      </div>
-    </div>
-  );
-}
-
-function ChatHistoryRow({
-  item,
-  active,
-  onSelect,
-  onOpen,
-  onTogglePin,
-  onRename,
-  onDelete,
-  renderRowActions,
-}: {
-  item: ChatHistoryItem;
-  active: boolean;
-  onSelect: (id: string) => void;
-  onOpen?: (id: string) => void;
-  onTogglePin?: (id: string) => void;
-  onRename?: (id: string, nextTitle: string) => void;
-  onDelete?: (id: string) => void;
-  renderRowActions?: (item: ChatHistoryItem) => React.ReactNode;
-}) {
-  const [isRenaming, setIsRenaming] = useState(false);
-  const [draftTitle, setDraftTitle] = useState("");
-  const [menuOpen, setMenuOpen] = useState(false);
-  const renameInputRef = useRef<HTMLInputElement | null>(null);
-  const menuRef = useRef<HTMLDivElement | null>(null);
-
-  const hasMenu = Boolean(
-    onTogglePin || onRename || onDelete || renderRowActions,
-  );
-
-  useEffect(() => {
-    if (!menuOpen) return;
-    function handlePointerDown(event: PointerEvent) {
-      if (menuRef.current && !menuRef.current.contains(event.target as Node)) {
-        setMenuOpen(false);
-      }
-    }
-    function handleKeyDown(event: KeyboardEvent) {
-      if (event.key === "Escape") setMenuOpen(false);
-    }
-    document.addEventListener("pointerdown", handlePointerDown);
-    document.addEventListener("keydown", handleKeyDown);
-    return () => {
-      document.removeEventListener("pointerdown", handlePointerDown);
-      document.removeEventListener("keydown", handleKeyDown);
-    };
-  }, [menuOpen]);
-
-  function startRename() {
-    setDraftTitle(item.titleText ?? "");
-    setIsRenaming(true);
-    setMenuOpen(false);
-    window.requestAnimationFrame(() => {
-      renameInputRef.current?.select();
-    });
-  }
-
-  function commitRename() {
-    const trimmed = draftTitle.trim();
-    setIsRenaming(false);
-    if (trimmed && trimmed !== item.titleText) {
-      onRename?.(item.id, trimmed);
-    }
-  }
-
-  function handleRenameKeyDown(event: React.KeyboardEvent<HTMLInputElement>) {
-    if (event.key === "Enter") {
-      event.preventDefault();
-      commitRename();
-    } else if (event.key === "Escape") {
-      event.preventDefault();
-      setIsRenaming(false);
-    }
-  }
-
-  return (
-    <div
-      className={cn(
-        "an-chat-history-row",
-        active && "an-chat-history-row--active",
-        item.pinned && "an-chat-history-row--pinned",
-        isRenaming && "an-chat-history-row--renaming",
-        item.disabled && "an-chat-history-row--disabled",
-      )}
-    >
-      {isRenaming ? (
-        <div className="an-chat-history-row__rename">
-          <input
-            ref={renameInputRef}
-            className="an-chat-history-row__rename-input"
-            value={draftTitle}
-            onChange={(event) => setDraftTitle(event.target.value)}
-            onKeyDown={handleRenameKeyDown}
-            onBlur={commitRename}
-            autoFocus
-            aria-label="Rename chat"
-          />
-        </div>
-      ) : (
-        <button
-          type="button"
-          className="an-chat-history-row__button"
-          onClick={() => !item.disabled && onSelect(item.id)}
-          onDoubleClick={() => !item.disabled && onOpen?.(item.id)}
-          disabled={item.disabled}
-        >
-          <div className="an-chat-history-row__topline">
-            <span className="an-chat-history-row__title">{item.title}</span>
-            {item.timestamp != null && (
-              <span className="an-chat-history-row__timestamp">
-                {item.timestamp}
-              </span>
-            )}
-          </div>
-          {item.subtitle != null && (
-            <div className="an-chat-history-row__subtitle">{item.subtitle}</div>
-          )}
-          {item.detail != null && (
-            <div className="an-chat-history-row__detail">{item.detail}</div>
-          )}
-        </button>
-      )}
-
-      {!isRenaming && hasMenu && (
-        <div className="an-chat-history-row__menu" ref={menuRef}>
-          <button
-            type="button"
-            className={cn(
-              "an-chat-history-row__menu-trigger",
-              item.pinned && "an-chat-history-row__menu-trigger--pinned",
-            )}
-            aria-label="Chat options"
-            aria-haspopup="menu"
-            aria-expanded={menuOpen}
-            onClick={() => setMenuOpen((open) => !open)}
-          >
-            {item.pinned ? (
-              <IconPinned size={13} strokeWidth={1.8} />
-            ) : (
-              <IconDots size={14} strokeWidth={1.8} />
-            )}
-          </button>
-          {menuOpen && (
-            <div className="an-chat-history-row__menu-content" role="menu">
-              {renderRowActions ? (
-                renderRowActions(item)
-              ) : (
-                <>
-                  {onRename && (
-                    <button
-                      type="button"
-                      role="menuitem"
-                      className="an-chat-history-row__menu-item"
-                      onClick={startRename}
-                    >
-                      <IconPencil size={13} strokeWidth={1.8} />
-                      <span>Rename</span>
-                    </button>
-                  )}
-                  {onTogglePin && (
-                    <button
-                      type="button"
-                      role="menuitem"
-                      className="an-chat-history-row__menu-item"
-                      onClick={() => {
-                        setMenuOpen(false);
-                        onTogglePin(item.id);
-                      }}
-                    >
-                      {item.pinned ? (
-                        <IconPinnedOff size={13} strokeWidth={1.8} />
-                      ) : (
-                        <IconPinned size={13} strokeWidth={1.8} />
-                      )}
-                      <span>
-                        {item.pinned ? "Unpin from top" : "Pin to top"}
-                      </span>
-                    </button>
-                  )}
-                  {onDelete && (
-                    <button
-                      type="button"
-                      role="menuitem"
-                      className="an-chat-history-row__menu-item an-chat-history-row__menu-item--danger"
-                      onClick={() => {
-                        setMenuOpen(false);
-                        onDelete(item.id);
-                      }}
-                    >
-                      <IconTrash size={13} strokeWidth={1.8} />
-                      <span>Delete</span>
-                    </button>
-                  )}
-                </>
-              )}
-            </div>
-          )}
-        </div>
-      )}
-    </div>
-  );
-}
+export {
+  ChatHistoryList,
+  type ChatHistoryItem,
+  type ChatHistoryListLabels,
+  type ChatHistoryListProps,
+  type ChatHistorySection,
+} from "@agent-native/toolkit/chat-history";

package/corpus/core/src/coding-tools/index.ts

@@ -451,7 +451,11 @@ export async function runCodingCommand(
   command: string,
   cwd: string,
   timeoutMs: number,
-  options: { stdin?: string; onChunk?: BashOutputChunkCallback } = {},
+  options: {
+    stdin?: string;
+    onChunk?: BashOutputChunkCallback;
+    signal?: AbortSignal;
+  } = {},
 ): Promise<CodingCommandResult> {
   const child = spawn(command, {
     cwd,
@@ -463,9 +467,10 @@ export async function runCodingCommand(
   let stderr = "";
   let timedOut = false;
   const startMs = Date.now();
+  const abort = () => child.kill("SIGTERM");
   const timer = setTimeout(() => {
     timedOut = true;
-    child.kill("SIGTERM");
+    abort();
   }, timeoutMs);
   child.stdout?.on("data", (chunk: Buffer) => {
     const text = chunk.toString();
@@ -479,12 +484,26 @@ export async function runCodingCommand(
   });
   if (options.stdin) child.stdin?.end(options.stdin);
   else child.stdin?.end();
-  const code = await new Promise<number | null>((resolve, reject) => {
-    child.once("error", reject);
-    child.once("close", resolve);
-  });
-  clearTimeout(timer);
-  return { code, stdout, stderr, timedOut, durationMs: Date.now() - startMs };
+  if (options.signal) {
+    if (options.signal.aborted) abort();
+    else options.signal.addEventListener("abort", abort, { once: true });
+  }
+  try {
+    const code = await new Promise<number | null>((resolve, reject) => {
+      child.once("error", reject);
+      child.once("close", resolve);
+    });
+    return {
+      code,
+      stdout,
+      stderr,
+      timedOut,
+      durationMs: Date.now() - startMs,
+    };
+  } finally {
+    clearTimeout(timer);
+    options.signal?.removeEventListener("abort", abort);
+  }
 }
 
 /**

package/corpus/core/src/embeddings/index.ts

@@ -0,0 +1,233 @@
+import { readBoundedResponseBytes } from "../ingestion/index.js";
+import { resolveSecret } from "../server/credential-provider.js";
+
+export type EmbeddingInputPurpose = "query" | "document";
+export interface EmbeddingImageInput {
+  mimeType: "image/png" | "image/jpeg" | "image/webp" | "image/gif";
+  base64: string;
+}
+export interface MultimodalEmbeddingInput {
+  text?: string;
+  images?: EmbeddingImageInput[];
+}
+export interface EmbeddingFamily {
+  id: string;
+  provider: "gemini" | "cohere" | "voyage" | (string & {});
+  model: string;
+  version: string;
+  dimensions: number;
+  supportedImageMimeTypes?: readonly EmbeddingImageInput["mimeType"][];
+  embed(
+    inputs: readonly MultimodalEmbeddingInput[],
+    purpose: EmbeddingInputPurpose,
+  ): Promise<number[][]>;
+}
+
+const DEFAULT_DIMENSIONS = 1024;
+function dataUrl(image: EmbeddingImageInput) {
+  return `data:${image.mimeType};base64,${image.base64}`;
+}
+function normalizedInput(input: MultimodalEmbeddingInput) {
+  const text = input.text?.trim();
+  const images = input.images ?? [];
+  if (!text && !images.length)
+    throw new Error("Embedding input needs text, an image, or both.");
+  return { text, images };
+}
+async function postJson(
+  url: string,
+  headers: Record<string, string>,
+  body: unknown,
+  providerModel: string,
+): Promise<Record<string, unknown>> {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), 30_000);
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", ...headers },
+      body: JSON.stringify(body),
+      signal: controller.signal,
+    });
+    if (!response.ok)
+      throw new Error(
+        `Embedding provider ${providerModel} failed with status ${response.status}.`,
+      );
+    const bytes = await readBoundedResponseBytes(response, 1_000_000);
+    return JSON.parse(new TextDecoder().decode(bytes)) as Record<
+      string,
+      unknown
+    >;
+  } catch (error) {
+    if (controller.signal.aborted)
+      throw new Error(`Embedding provider ${providerModel} timed out.`);
+    throw error;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+function numberVectors(value: unknown): number[][] {
+  if (!Array.isArray(value))
+    throw new Error("Embedding response was malformed.");
+  return value.map((vector) => {
+    if (
+      !Array.isArray(vector) ||
+      vector.some((entry) => !Number.isFinite(entry))
+    )
+      throw new Error("Embedding response contained an invalid vector.");
+    return vector.map(Number);
+  });
+}
+
+export function createGeminiEmbeddingFamily(
+  apiKey: string,
+  dimensions = DEFAULT_DIMENSIONS,
+): EmbeddingFamily {
+  const model = "gemini-embedding-2";
+  return {
+    id: `gemini:${model}:${dimensions}`,
+    provider: "gemini",
+    model,
+    version: "stable-2026-04",
+    dimensions,
+    supportedImageMimeTypes: ["image/png", "image/jpeg"],
+    async embed(inputs, purpose) {
+      const vectors: number[][] = [];
+      for (const raw of inputs) {
+        const input = normalizedInput(raw);
+        const instruction =
+          purpose === "query"
+            ? "task: search result | query:"
+            : "title: none | text:";
+        const result = await postJson(
+          `https://generativelanguage.googleapis.com/v1beta/models/${model}:embedContent`,
+          { "x-goog-api-key": apiKey },
+          {
+            content: {
+              parts: [
+                { text: `${instruction} ${input.text ?? ""}`.trim() },
+                ...input.images.map((image) => ({
+                  inlineData: { mimeType: image.mimeType, data: image.base64 },
+                })),
+              ],
+            },
+            output_dimensionality: dimensions,
+          },
+          `gemini/${model}`,
+        );
+        vectors.push(
+          ...numberVectors([
+            (result.embedding as { values?: unknown } | undefined)?.values,
+          ]),
+        );
+      }
+      return vectors;
+    },
+  };
+}
+export function createCohereEmbeddingFamily(
+  apiKey: string,
+  dimensions = DEFAULT_DIMENSIONS,
+): EmbeddingFamily {
+  const model = "embed-v4.0";
+  return {
+    id: `cohere:${model}:${dimensions}`,
+    provider: "cohere",
+    model,
+    version: "v4.0",
+    dimensions,
+    supportedImageMimeTypes: [
+      "image/png",
+      "image/jpeg",
+      "image/webp",
+      "image/gif",
+    ],
+    async embed(inputs, purpose) {
+      const result = await postJson(
+        "https://api.cohere.com/v2/embed",
+        { Authorization: `Bearer ${apiKey}` },
+        {
+          model,
+          inputs: inputs.map((raw) => {
+            const input = normalizedInput(raw);
+            return {
+              content: [
+                ...(input.text ? [{ type: "text", text: input.text }] : []),
+                ...input.images.map((image) => ({
+                  type: "image_url",
+                  image_url: { url: dataUrl(image) },
+                })),
+              ],
+            };
+          }),
+          input_type: purpose === "query" ? "search_query" : "search_document",
+          embedding_types: ["float"],
+          output_dimension: dimensions,
+        },
+        `cohere/${model}`,
+      );
+      const embeddings = result.embeddings as
+        | { float?: unknown; float_?: unknown }
+        | undefined;
+      return numberVectors(embeddings?.float ?? embeddings?.float_);
+    },
+  };
+}
+export function createVoyageEmbeddingFamily(apiKey: string): EmbeddingFamily {
+  const model = "voyage-multimodal-3.5";
+  return {
+    id: `voyage:${model}:1024`,
+    provider: "voyage",
+    model,
+    version: "3.5",
+    dimensions: 1024,
+    supportedImageMimeTypes: [
+      "image/png",
+      "image/jpeg",
+      "image/webp",
+      "image/gif",
+    ],
+    async embed(inputs, purpose) {
+      const result = await postJson(
+        "https://api.voyageai.com/v1/multimodalembeddings",
+        { Authorization: `Bearer ${apiKey}` },
+        {
+          model,
+          inputs: inputs.map((raw) => {
+            const input = normalizedInput(raw);
+            return {
+              content: [
+                ...(input.text ? [{ type: "text", text: input.text }] : []),
+                ...input.images.map((image) => ({
+                  type: "image_base64",
+                  image_base64: dataUrl(image),
+                })),
+              ],
+            };
+          }),
+          input_type: purpose,
+          truncation: true,
+        },
+        `voyage/${model}`,
+      );
+      return numberVectors(result.embeddings);
+    },
+  };
+}
+export async function availableEmbeddingFamilies(): Promise<EmbeddingFamily[]> {
+  const [gemini, cohere, voyage] = await Promise.all([
+    resolveSecret("GEMINI_API_KEY").catch(() => null),
+    resolveSecret("COHERE_API_KEY").catch(() => null),
+    resolveSecret("VOYAGE_API_KEY").catch(() => null),
+  ]);
+  return [
+    ...(gemini ? [createGeminiEmbeddingFamily(gemini)] : []),
+    ...(cohere ? [createCohereEmbeddingFamily(cohere)] : []),
+    ...(voyage ? [createVoyageEmbeddingFamily(voyage)] : []),
+  ];
+}
+export function defaultEmbeddingFamily(
+  families: readonly EmbeddingFamily[],
+): EmbeddingFamily | null {
+  return families.length === 1 ? (families[0] ?? null) : null;
+}