@iloveagents/foundry-web-ui 0.3.1 → 0.4.0

package/src/__tests__/tool-fallback.test.tsx

@@ -1,109 +0,0 @@
-/**
- * Unit tests for the error-shape sniffing helpers in
- * ``tool-fallback.tsx``. The component itself renders a collapsible
- * card which is awkward to assert from node-land without
- * ``@testing-library/react`` (not a workspace dep); exercising the
- * pure helpers covers the interesting logic. The helpers are
- * exported with an underscore prefix specifically for this use.
- */
-
-import { describe, expect, it } from "vitest";
-import {
-  _detectErrorResult,
-  _extractErrorMessage,
-} from "../components/tool-fallback.tsx";
-
-describe("_detectErrorResult", () => {
-  it("returns false for null / undefined", () => {
-    expect(_detectErrorResult(null)).toBe(false);
-    expect(_detectErrorResult(undefined)).toBe(false);
-  });
-
-  it("returns false for normal strings", () => {
-    expect(_detectErrorResult("Found 3 documents.")).toBe(false);
-    expect(_detectErrorResult("")).toBe(false);
-  });
-
-  it("detects the agent-framework `Error: ...` serialization", () => {
-    expect(_detectErrorResult("Error: search backend 500")).toBe(true);
-    expect(_detectErrorResult("  Error: with leading whitespace")).toBe(true);
-  });
-
-  it("does NOT false-positive on strings containing the word Error mid-text", () => {
-    // This is the failure the anchored regex exists to prevent.
-    expect(
-      _detectErrorResult("A passage about Error Handling in Python"),
-    ).toBe(false);
-    expect(_detectErrorResult("Error Boundaries in React")).toBe(false);
-  });
-
-  it("detects MCP canonical `{isError: true, content: [...]}`", () => {
-    expect(
-      _detectErrorResult({
-        isError: true,
-        content: [{ type: "text", text: "forbidden" }],
-      }),
-    ).toBe(true);
-  });
-
-  it("returns false when isError is false/undefined", () => {
-    expect(_detectErrorResult({ isError: false, content: [] })).toBe(false);
-    expect(_detectErrorResult({ data: [] })).toBe(false);
-  });
-
-  it("detects structured `{error: 'msg'}`", () => {
-    expect(_detectErrorResult({ error: "boom" })).toBe(true);
-  });
-
-  it("does not treat an empty `error` string as an error", () => {
-    // Avoids false-positives where a tool echoes `error: ""` in a success
-    // envelope. Narrow by design.
-    expect(_detectErrorResult({ error: "" })).toBe(false);
-  });
-
-  it("detects `{error: {message: 'msg'}}`", () => {
-    expect(_detectErrorResult({ error: { message: "timed out" } })).toBe(true);
-  });
-});
-
-describe("_extractErrorMessage", () => {
-  it("strips the `Error: ` prefix from string errors", () => {
-    expect(_extractErrorMessage("Error: search backend 500")).toBe(
-      "search backend 500",
-    );
-  });
-
-  it("returns `Execution failed` when the string is just `Error:`", () => {
-    expect(_extractErrorMessage("Error:")).toBe("Execution failed");
-  });
-
-  it("returns null for normal strings (so caller falls back)", () => {
-    expect(_extractErrorMessage("All good")).toBeNull();
-  });
-
-  it("extracts `error: 'msg'` directly", () => {
-    expect(_extractErrorMessage({ error: "timed out" })).toBe("timed out");
-  });
-
-  it("extracts nested `error.message`", () => {
-    expect(
-      _extractErrorMessage({ error: { message: "invalid token" } }),
-    ).toBe("invalid token");
-  });
-
-  it("extracts the first text item from MCP content arrays", () => {
-    expect(
-      _extractErrorMessage({
-        isError: true,
-        content: [
-          { type: "text", text: "forbidden" },
-          { type: "text", text: "second" },
-        ],
-      }),
-    ).toBe("forbidden");
-  });
-
-  it("returns null when no recognisable payload is present", () => {
-    expect(_extractErrorMessage({ random: "shape" })).toBeNull();
-  });
-});

package/src/components/__tests__/context-bar.test.ts

@@ -1,112 +0,0 @@
-/**
- * Unit tests for ``getNavigablePath`` — the function powering
- * click-to-navigate on pinned context chips. Two shapes the framework
- * supports: page (uses payload.path) and ref (uses sourcePage as the
- * deep-link URL set by the source module).
- */
-
-import { describe, expect, it } from "vitest";
-import { getNavigablePath } from "../context-bar.tsx";
-import type { ContextItem } from "../../lib/app-store.ts";
-
-function pageItem(path: string): ContextItem {
-  return {
-    id: "i-1",
-    type: "page",
-    label: "Workspace",
-    payload: { kind: "page", path, label: "Workspace" },
-    sourcePage: path,
-    persistence: "persistent",
-    createdAt: 0,
-  };
-}
-
-function refItem(refId: string, sourcePage: string): ContextItem {
-  return {
-    id: "i-2",
-    type: "ref",
-    label: "Field · cell",
-    payload: { kind: "ref", refType: "block", refId },
-    sourcePage,
-    persistence: "persistent",
-    createdAt: 0,
-  };
-}
-
-describe("getNavigablePath", () => {
-  it("returns the page payload path for page items", () => {
-    expect(getNavigablePath(pageItem("/spaces/abc"))).toBe("/spaces/abc");
-  });
-
-  it("returns the ref's sourcePage URL (incl. hash) for ref items", () => {
-    // The source module places the deep-link in sourcePage when it
-    // creates the ref; the framework surfaces it without knowing
-    // anything about the ref shape.
-    expect(
-      getNavigablePath(refItem("abc:b1", "/spaces/abc#block-b1")),
-    ).toBe("/spaces/abc#block-b1");
-  });
-
-  it("returns null when a ref has no sourcePage", () => {
-    const item = refItem("abc:b1", "");
-    expect(getNavigablePath(item)).toBeNull();
-  });
-
-  it("returns null for selection items (excerpts are not anchors)", () => {
-    const item: ContextItem = {
-      id: "i-3",
-      type: "selection",
-      label: "x",
-      payload: { kind: "text", text: "x" },
-      sourcePage: "/spaces/abc",
-      persistence: "ephemeral",
-      createdAt: 0,
-    };
-    expect(getNavigablePath(item)).toBeNull();
-  });
-
-  it("returns null for note items (use text payload — note shares it)", () => {
-    // ``ContextPayload`` is a closed union of ``text | page | ref``.
-    // Note items reuse the ``text`` payload (the ``type`` field is
-    // what distinguishes them from selections).
-    const item: ContextItem = {
-      id: "i-4",
-      type: "note",
-      label: "n",
-      payload: { kind: "text", text: "n" },
-      sourcePage: "/spaces/abc",
-      persistence: "ephemeral",
-      createdAt: 0,
-    };
-    expect(getNavigablePath(item)).toBeNull();
-  });
-
-  it("returns null for ref items whose sourcePage isn't a route-like path", () => {
-    // Some callers populate ``sourcePage`` with a free-form
-    // breadcrumb label rather than a URL. Guard against navigate()
-    // pushing a relative/invalid route.
-    const item: ContextItem = {
-      id: "i-5",
-      type: "ref",
-      label: "Field · x",
-      payload: { kind: "ref", refType: "block", refId: "abc:b1" },
-      sourcePage: "Workspace breadcrumb",
-      persistence: "persistent",
-      createdAt: 0,
-    };
-    expect(getNavigablePath(item)).toBeNull();
-  });
-
-  it("accepts hash-only sourcePages (same-page deep-link)", () => {
-    const item: ContextItem = {
-      id: "i-6",
-      type: "ref",
-      label: "Field · x",
-      payload: { kind: "ref", refType: "block", refId: "abc:b1" },
-      sourcePage: "#block-b1",
-      persistence: "persistent",
-      createdAt: 0,
-    };
-    expect(getNavigablePath(item)).toBe("#block-b1");
-  });
-});

package/src/components/ag-ui-runtime-provider.tsx

@@ -1,170 +0,0 @@
-import { createContext, useContext, useState, useCallback, useMemo } from "react";
-import { AssistantRuntimeProvider, useLocalRuntime } from "@assistant-ui/react";
-import type { ThreadHistoryAdapter } from "@assistant-ui/react";
-import { TooltipProvider } from "../ui/tooltip.tsx";
-import { AGUIAdapterSDK } from "../lib/ag-ui-adapter.ts";
-import { FileAttachmentAdapter } from "../lib/attachment-adapter.ts";
-import { ShowDocumentToolUI } from "./show-document-tool-ui.tsx";
-import { ClientToolExecutor } from "./client-tool-executor.tsx";
-
-/**
- * Per-mount inputs the host shell passes when it wants a chat
- * conversation history wired to the runtime. Mirrors
- * :type:`ChatConversationFactoryArgs` in ``foundry-web-shell`` —
- * duplicated here (rather than imported) so the web-ui package stays
- * independent of the shell package's dependency graph.
- */
-export interface AGUIChatConversationFactoryArgs {
-  /** Conversation id captured from the URL (resumed chat) or undefined (fresh). */
-  urlMatch?: string;
-  /** Stable AG-UI adapter thread id — present in both cases. */
-  aguiThreadId: string;
-}
-
-/**
- * Factory the consumer passes to build a :type:`ThreadHistoryAdapter`
- * once the AG-UI adapter has minted its thread id. Called inside the
- * keyed runtime mount; assistant-ui invokes ``load()``/``append()``
- * via the returned adapter.
- */
-export type AGUIHistoryAdapterFactory = (
-  args: AGUIChatConversationFactoryArgs,
-) => ThreadHistoryAdapter;
-
-interface AGUIRuntimeProviderProps {
-  children: React.ReactNode;
-  /** Custom fetch for agent requests. Handles URL rewriting + auth in production. */
-  fetchFn?: typeof fetch;
-  /**
-   * Optional stable thread id for the AG-UI adapter. When set, the
-   * agent's POST body carries this id so server-side persistence
-   * (Foundry thread, conversation row) targets the same conversation
-   * across reloads / resumes. Changing the id remounts the inner
-   * runtime — past messages from a different thread don't bleed
-   * into the new one.
-   */
-  threadId?: string;
-  /**
-   * Conversation id captured from the current URL when the user
-   * resumed an existing chat (e.g. ``/chat/<id>``), or ``undefined``
-   * for a brand-new chat. Distinct from ``threadId``: the host shell
-   * MAY set ``threadId`` from a non-URL source (a sticky active
-   * conversation, a freshly-minted UUID) so ``threadId`` alone can't
-   * tell a history adapter "we're resuming". ``urlMatch`` carries
-   * that signal verbatim into ``historyAdapterFactory`` so the
-   * adapter can decide whether to load history (resume) or
-   * initialise empty (fresh) without inferring from ``threadId``.
-   */
-  urlMatch?: string;
-  /**
-   * Factory that builds the assistant-ui ``ThreadHistoryAdapter`` for
-   * this mount. Called once after the AG-UI adapter exists so it can
-   * receive both the URL match (when resuming) and the adapter's own
-   * thread id (always set — covers fresh chats). Pass alongside
-   * ``threadId`` for resumed chats; pass without ``threadId`` to get
-   * a fresh-chat runtime that still persists.
-   */
-  historyAdapterFactory?: AGUIHistoryAdapterFactory;
-}
-
-interface AGUIContextValue {
-  adapter: AGUIAdapterSDK;
-  resetThread: () => void;
-}
-
-const AGUIAdapterContext = createContext<AGUIContextValue | null>(null);
-
-export function useAGUIAdapter() {
-  const context = useContext(AGUIAdapterContext);
-  if (!context) {
-    throw new Error("useAGUIAdapter must be used within AGUIRuntimeProvider");
-  }
-  return context;
-}
-
-export function AGUIRuntimeProvider(props: AGUIRuntimeProviderProps) {
-  // Splitting render across an outer wrapper + a keyed inner is the
-  // canonical React idiom for "rebuild this stateful subtree when X
-  // changes". assistant-ui's runtime is created inside useLocalRuntime
-  // and tracks its messages internally; swapping threadId or history
-  // mid-life would leave stale state. Keying the inner subtree on
-  // threadId (+ the manual reset counter) guarantees a clean runtime
-  // per conversation, matching the ChatGPT-style "click → fresh chat
-  // backed by past messages" UX.
-  const [resetKey, setResetKey] = useState(0);
-  const resetThread = useCallback(() => setResetKey((p) => p + 1), []);
-
-  const innerKey = `${props.threadId ?? "fresh"}:${resetKey}`;
-
-  return (
-    <AGUIRuntimeInner key={innerKey} {...props} resetThread={resetThread} />
-  );
-}
-
-function AGUIRuntimeInner({
-  children,
-  fetchFn,
-  threadId,
-  urlMatch,
-  historyAdapterFactory,
-  resetThread,
-}: AGUIRuntimeProviderProps & { resetThread: () => void }) {
-  const adapter = useMemo(
-    () =>
-      new AGUIAdapterSDK(
-        "/api/agent",
-        // Only pass options if at least one is set, mirroring the prior
-        // single-arg semantics for the "fresh chat, no overrides" case.
-        fetchFn || threadId ? { fetchFn, threadId } : undefined,
-      ),
-    [fetchFn, threadId],
-  );
-
-  const attachmentAdapter = useMemo(() => new FileAttachmentAdapter(), []);
-
-  // Build the history adapter ONCE per inner mount, after the AG-UI
-  // adapter exists so we know its thread id. The keyed-remount in the
-  // outer wrapper ensures threadId changes trigger a fresh adapter +
-  // fresh history adapter together, so resumed chats hydrate from the
-  // right conversation and fresh chats persist under their assistant-
-  // ui-minted UUID.
-  const historyAdapter = useMemo<ThreadHistoryAdapter | undefined>(() => {
-    if (!historyAdapterFactory) return undefined;
-    return historyAdapterFactory({
-      // ``urlMatch`` is the URL-derived resume signal (undefined for
-      // fresh chats). ``aguiThreadId`` is always defined — the AG-UI
-      // adapter mints it on construction. The factory uses ``urlMatch``
-      // to decide "load history" vs "initialise empty", and
-      // ``aguiThreadId`` to identify the row to write into.
-      urlMatch,
-      aguiThreadId: adapter.threadId,
-    });
-    // adapter is stable for the life of this inner mount (keyed remount
-    // covers the threadId change case), so it's OK to depend on the
-    // factory + urlMatch here.
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [historyAdapterFactory, urlMatch]);
-
-  const runtime = useLocalRuntime(adapter, {
-    adapters: {
-      attachments: attachmentAdapter,
-      // history is optional — when undefined, the runtime acts as a
-      // pure in-memory thread (the original behaviour). When provided,
-      // assistant-ui calls .load() on mount to seed past messages and
-      // .append() after every turn.
-      ...(historyAdapter ? { history: historyAdapter } : {}),
-    },
-  });
-
-  return (
-    <AGUIAdapterContext.Provider value={{ adapter, resetThread }}>
-      <AssistantRuntimeProvider runtime={runtime}>
-        <TooltipProvider>
-          <ShowDocumentToolUI />
-          <ClientToolExecutor />
-          {children}
-        </TooltipProvider>
-      </AssistantRuntimeProvider>
-    </AGUIAdapterContext.Provider>
-  );
-}

package/src/components/app-brand.tsx

@@ -1,38 +0,0 @@
-import { Layers3 } from "lucide-react";
-import { cn } from "@iloveagents/foundry-web-primitives";
-import { useThemeRuntime } from "./theme-runtime-provider.tsx";
-
-export function AppBrand({
-  showName = true,
-  className,
-  iconClassName,
-  labelClassName,
-}: {
-  showName?: boolean;
-  className?: string;
-  iconClassName?: string;
-  labelClassName?: string;
-}) {
-  const runtime = useThemeRuntime();
-  const brandName = runtime.branding.appName || "eomi";
-  const logoUrl =
-    runtime.mode === "dark"
-      ? runtime.branding.darkLogoUrl || runtime.branding.logoUrl
-      : runtime.branding.logoUrl || runtime.branding.darkLogoUrl;
-  const shouldShowName = showName && !logoUrl;
-
-  return (
-    <span className={cn("flex items-center gap-2", className)}>
-      {logoUrl ? (
-        <img
-          src={logoUrl}
-          alt={brandName}
-          className={cn("h-5 w-auto max-w-[7rem] shrink-0 object-contain", iconClassName)}
-        />
-      ) : (
-        <Layers3 className={cn("size-5 shrink-0 text-primary", iconClassName)} />
-      )}
-      {shouldShowName && <span className={cn("truncate", labelClassName)}>{brandName}</span>}
-    </span>
-  );
-}