@assistant-ui/react-langchain 0.0.20 → 0.0.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@assistant-ui/react-langchain",
-  "version": "0.0.20",
+  "version": "0.0.21",
   "description": "LangChain useStream adapter for assistant-ui",
   "keywords": [
     "langchain",
@@ -29,10 +29,10 @@
   ],
   "sideEffects": false,
   "dependencies": {
-    "@assistant-ui/core": "^0.2.22",
-    "@assistant-ui/store": "^0.2.21",
+    "@assistant-ui/core": "^0.3.0",
+    "@assistant-ui/store": "^0.3.0",
     "assistant-cloud": "*",
-    "assistant-stream": "^0.3.27"
+    "assistant-stream": "^0.3.29"
   },
   "peerDependencies": {
     "@langchain/react": "^1.0.2",
@@ -53,7 +53,7 @@
     "jsdom": "^29.1.1",
     "react": "^19.2.8",
     "vitest": "^4.1.10",
-    "@assistant-ui/x-buildutils": "0.0.19"
+    "@assistant-ui/x-buildutils": "0.0.20"
   },
   "publishConfig": {
     "access": "public",

package/src/useStreamRuntime.test.tsx

@@ -103,15 +103,12 @@ const renderAui = (stream: MockStream) => {
 };
 
 const getText = (aui: ReturnType<typeof useAui>) =>
-  aui
-    .thread()
-    .getState()
-    .messages.map((m) =>
-      m.content
-        .filter((part) => part.type === "text")
-        .map((part) => part.text)
-        .join(""),
-    );
+  aui.thread.getState().messages.map((m) =>
+    m.content
+      .filter((part) => part.type === "text")
+      .map((part) => part.text)
+      .join(""),
+  );
 
 describe("useStreamRuntime staged messages", () => {
   it("stages a new user message without submitting when startRun is false", async () => {
@@ -119,7 +116,7 @@ describe("useStreamRuntime staged messages", () => {
     const { auiResult } = renderAui(stream);
 
     await act(async () => {
-      auiResult.current.thread().append({
+      auiResult.current.thread.append({
         role: "user",
         content: [{ type: "text", text: "draft" }],
         startRun: false,
@@ -141,7 +138,7 @@ describe("useStreamRuntime staged messages", () => {
     const { auiResult, rerender } = renderAui(stream);
 
     await act(async () => {
-      auiResult.current.thread().append({
+      auiResult.current.thread.append({
         role: "user",
         parentId: "u1",
         content: [{ type: "text", text: "edited" }],
@@ -171,12 +168,12 @@ describe("useStreamRuntime staged messages", () => {
     const { auiResult, rerender } = renderAui(stream);
 
     await act(async () => {
-      auiResult.current.thread().append({
+      auiResult.current.thread.append({
         role: "user",
         content: [{ type: "text", text: "first staged" }],
         startRun: false,
       });
-      auiResult.current.thread().append({
+      auiResult.current.thread.append({
         role: "user",
         content: [{ type: "text", text: "second staged" }],
         startRun: false,
@@ -191,9 +188,9 @@ describe("useStreamRuntime staged messages", () => {
       ]);
     });
 
-    const firstStagedId = auiResult.current.thread().getState().messages[1]!.id;
+    const firstStagedId = auiResult.current.thread.getState().messages[1]!.id;
     await act(async () => {
-      await auiResult.current.thread().startRun({
+      await auiResult.current.thread.startRun({
         parentId: firstStagedId,
         sourceId: null,
         runConfig: {},

package/src/runConfigToSubmitOptions.test.ts

@@ -1,24 +0,0 @@
-import { describe, expect, it } from "vitest";
-import type { AppendMessage } from "@assistant-ui/core";
-import { runConfigToSubmitOptions } from "./useStreamRuntime";
-
-type RunConfig = AppendMessage["runConfig"];
-
-describe("runConfigToSubmitOptions", () => {
-  it("returns undefined when runConfig is undefined", () => {
-    expect(runConfigToSubmitOptions(undefined)).toBeUndefined();
-  });
-
-  it("returns undefined when custom is undefined", () => {
-    expect(
-      runConfigToSubmitOptions({ custom: undefined } as unknown as RunConfig),
-    ).toBeUndefined();
-  });
-
-  it("maps custom to config.configurable", () => {
-    const runConfig = { custom: { mode: "plan" } } as RunConfig;
-    expect(runConfigToSubmitOptions(runConfig)).toEqual({
-      config: { configurable: { mode: "plan" } },
-    });
-  });
-});

package/src/streamingTiming.test.ts

@@ -1,118 +0,0 @@
-import { describe, expect, it } from "vitest";
-import type { LangChainBaseMessage } from "./types";
-import { langChainStreamingTimingAccessors } from "./streamingTiming";
-
-const ai = (
-  fields: Partial<LangChainBaseMessage> & { id: string; content: unknown },
-): LangChainBaseMessage => ({
-  _getType: () => "ai",
-  ...fields,
-});
-
-const human = (id: string, content: unknown): LangChainBaseMessage => ({
-  _getType: () => "human",
-  id,
-  content,
-});
-
-const { getAssistantMessageId, getTextLength, getToolCallCount } =
-  langChainStreamingTimingAccessors;
-
-describe("langChainStreamingTimingAccessors", () => {
-  it("resolves the last assistant message id via _getType()", () => {
-    expect(
-      getAssistantMessageId([human("u1", "hi"), ai({ id: "a1", content: "" })]),
-    ).toBe("a1");
-    expect(
-      getAssistantMessageId([
-        ai({ id: "a1", content: "" }),
-        human("u2", "hi"),
-        ai({ id: "a2", content: "" }),
-      ]),
-    ).toBe("a2");
-  });
-
-  it("returns undefined when there is no assistant message", () => {
-    expect(getAssistantMessageId([human("u1", "hi")])).toBeUndefined();
-  });
-
-  it("measures string content length", () => {
-    expect(getTextLength([ai({ id: "a1", content: "hello" })], "a1")).toBe(5);
-  });
-
-  it("sums text and thinking lengths across content blocks", () => {
-    expect(
-      getTextLength(
-        [
-          ai({
-            id: "a1",
-            content: [
-              { type: "thinking", thinking: "hmm" },
-              { type: "text", text: "answer" },
-            ],
-          }),
-        ],
-        "a1",
-      ),
-    ).toBe("hmm".length + "answer".length);
-  });
-
-  it("measures reasoning blocks (summary and reasoning fields)", () => {
-    // reasoning via summary_text entries, joined like contentToParts does.
-    expect(
-      getTextLength(
-        [
-          ai({
-            id: "a1",
-            content: [
-              {
-                type: "reasoning",
-                summary: [
-                  { type: "summary_text", text: "step one" },
-                  { type: "summary_text", text: "step two" },
-                ],
-              },
-            ],
-          }),
-        ],
-        "a1",
-      ),
-    ).toBe("step one\n\n\nstep two".length);
-
-    // reasoning via the bare `reasoning` field when no summary is present.
-    expect(
-      getTextLength(
-        [
-          ai({
-            id: "a2",
-            content: [{ type: "reasoning", reasoning: "deduced" }],
-          }),
-        ],
-        "a2",
-      ),
-    ).toBe("deduced".length);
-  });
-
-  it("counts tool_calls on the assistant message", () => {
-    expect(
-      getToolCallCount(
-        [
-          ai({
-            id: "a1",
-            content: "",
-            tool_calls: [
-              { id: "t1", name: "search", args: {} },
-              { id: "t2", name: "fetch", args: {} },
-            ],
-          }),
-        ],
-        "a1",
-      ),
-    ).toBe(2);
-  });
-
-  it("returns 0 when the message is missing or not assistant", () => {
-    expect(getTextLength([human("u1", "hi")], "a1")).toBe(0);
-    expect(getToolCallCount([human("u1", "hi")], "a1")).toBe(0);
-  });
-});

package/src/useLangChainError.test.tsx

@@ -1,48 +0,0 @@
-// @vitest-environment jsdom
-
-import { describe, expect, it, vi } from "vitest";
-import { renderHook } from "@testing-library/react";
-import {
-  createRunSelectorAgainst,
-  makeExtras,
-  type Selector,
-} from "./__tests__/langChainTestUtils";
-
-const { mockUseAuiState } = vi.hoisted(() => ({
-  mockUseAuiState: vi.fn(),
-}));
-
-vi.mock(import("@assistant-ui/store"), async (importOriginal) => {
-  const actual = await importOriginal();
-  return {
-    ...actual,
-    useAuiState: ((selector: Selector) =>
-      mockUseAuiState(selector)) as typeof actual.useAuiState,
-    useAui: (() => ({})) as unknown as typeof actual.useAui,
-  };
-});
-
-import { useLangChainError } from "./hooks";
-
-const runSelectorAgainst = createRunSelectorAgainst(mockUseAuiState);
-
-describe("useLangChainError", () => {
-  it("returns undefined when extras are absent", () => {
-    runSelectorAgainst(undefined);
-    const { result } = renderHook(() => useLangChainError());
-    expect(result.current).toBeUndefined();
-  });
-
-  it("returns the error value when extras carry error", () => {
-    const error = new Error("boom");
-    runSelectorAgainst(makeExtras({ error }));
-    const { result } = renderHook(() => useLangChainError());
-    expect(result.current).toBe(error);
-  });
-
-  it("returns undefined when extras carry no error", () => {
-    runSelectorAgainst(makeExtras({ error: undefined }));
-    const { result } = renderHook(() => useLangChainError());
-    expect(result.current).toBeUndefined();
-  });
-});

package/src/useLangChainInterrupts.test.tsx

@@ -1,48 +0,0 @@
-// @vitest-environment jsdom
-
-import { describe, expect, it, vi } from "vitest";
-import { renderHook } from "@testing-library/react";
-import {
-  createRunSelectorAgainst,
-  makeExtras,
-  type Selector,
-} from "./__tests__/langChainTestUtils";
-
-const { mockUseAuiState } = vi.hoisted(() => ({
-  mockUseAuiState: vi.fn(),
-}));
-
-vi.mock(import("@assistant-ui/store"), async (importOriginal) => {
-  const actual = await importOriginal();
-  return {
-    ...actual,
-    useAuiState: ((selector: Selector) =>
-      mockUseAuiState(selector)) as typeof actual.useAuiState,
-    useAui: (() => ({})) as unknown as typeof actual.useAui,
-  };
-});
-
-import { useLangChainInterrupts } from "./hooks";
-
-const runSelectorAgainst = createRunSelectorAgainst(mockUseAuiState);
-
-describe("useLangChainInterrupts", () => {
-  it("returns an empty array when extras are absent", () => {
-    runSelectorAgainst(undefined);
-    const { result } = renderHook(() => useLangChainInterrupts());
-    expect(result.current).toEqual([]);
-  });
-
-  it("returns the pending interrupts from extras", () => {
-    const interrupts = [{ id: "i1", value: { q: "ok?" } }];
-    runSelectorAgainst(makeExtras({ interrupts }));
-    const { result } = renderHook(() => useLangChainInterrupts());
-    expect(result.current).toBe(interrupts);
-  });
-
-  it("returns an empty array when extras carry no interrupts", () => {
-    runSelectorAgainst(makeExtras({ interrupts: undefined }));
-    const { result } = renderHook(() => useLangChainInterrupts());
-    expect(result.current).toEqual([]);
-  });
-});

package/src/useLangChainRespond.test.tsx

@@ -1,49 +0,0 @@
-// @vitest-environment jsdom
-
-import { describe, expect, it, vi } from "vitest";
-import { renderHook } from "@testing-library/react";
-import { makeExtras } from "./__tests__/langChainTestUtils";
-
-const { mockUseAui } = vi.hoisted(() => ({
-  mockUseAui: vi.fn(),
-}));
-
-vi.mock(import("@assistant-ui/store"), async (importOriginal) => {
-  const actual = await importOriginal();
-  return {
-    ...actual,
-    useAui: (() => mockUseAui()) as unknown as typeof actual.useAui,
-  };
-});
-
-import { useLangChainRespond } from "./hooks";
-
-describe("useLangChainRespond", () => {
-  it("forwards the response and options to stream.respond", async () => {
-    const respond = vi.fn().mockResolvedValue(undefined);
-    mockUseAui.mockReturnValue({
-      thread: () => ({
-        getState: () => ({ extras: makeExtras({ respond }) }),
-      }),
-    });
-
-    const { result } = renderHook(() => useLangChainRespond());
-    await result.current({ approved: true }, { interruptId: "x" });
-
-    expect(respond).toHaveBeenCalledWith(
-      { approved: true },
-      { interruptId: "x" },
-    );
-  });
-
-  it("throws when extras are absent or unbranded", () => {
-    mockUseAui.mockReturnValue({
-      thread: () => ({ getState: () => ({ extras: { respond: vi.fn() } }) }),
-    });
-
-    const { result } = renderHook(() => useLangChainRespond());
-    expect(() => result.current({ approved: true })).toThrow(
-      "useStreamRuntime",
-    );
-  });
-});

package/src/useLangChainRespondAll.test.tsx

@@ -1,52 +0,0 @@
-// @vitest-environment jsdom
-
-import { describe, expect, it, vi } from "vitest";
-import { renderHook } from "@testing-library/react";
-import { makeExtras } from "./__tests__/langChainTestUtils";
-
-const { mockUseAui } = vi.hoisted(() => ({
-  mockUseAui: vi.fn(),
-}));
-
-vi.mock(import("@assistant-ui/store"), async (importOriginal) => {
-  const actual = await importOriginal();
-  return {
-    ...actual,
-    useAui: (() => mockUseAui()) as unknown as typeof actual.useAui,
-  };
-});
-
-import { useLangChainRespondAll } from "./hooks";
-
-describe("useLangChainRespondAll", () => {
-  it("forwards the responses and options to stream.respondAll", async () => {
-    const respondAll = vi.fn().mockResolvedValue(undefined);
-    mockUseAui.mockReturnValue({
-      thread: () => ({
-        getState: () => ({ extras: makeExtras({ respondAll }) }),
-      }),
-    });
-
-    const { result } = renderHook(() => useLangChainRespondAll());
-    await result.current(
-      { a: { approved: true }, b: { approved: false } },
-      { metadata: { src: "ui" } },
-    );
-
-    expect(respondAll).toHaveBeenCalledWith(
-      { a: { approved: true }, b: { approved: false } },
-      { metadata: { src: "ui" } },
-    );
-  });
-
-  it("throws when extras are absent or unbranded", () => {
-    mockUseAui.mockReturnValue({
-      thread: () => ({ getState: () => ({ extras: { respondAll: vi.fn() } }) }),
-    });
-
-    const { result } = renderHook(() => useLangChainRespondAll());
-    expect(() => result.current({ a: { approved: true } })).toThrow(
-      "useStreamRuntime",
-    );
-  });
-});

package/src/useLangChainStream.test.tsx

@@ -1,42 +0,0 @@
-// @vitest-environment jsdom
-
-import { describe, expect, it, vi } from "vitest";
-import { renderHook } from "@testing-library/react";
-import {
-  createRunSelectorAgainst,
-  makeExtras,
-  type Selector,
-} from "./__tests__/langChainTestUtils";
-
-const { mockUseAuiState } = vi.hoisted(() => ({
-  mockUseAuiState: vi.fn(),
-}));
-
-vi.mock(import("@assistant-ui/store"), async (importOriginal) => {
-  const actual = await importOriginal();
-  return {
-    ...actual,
-    useAuiState: ((selector: Selector) =>
-      mockUseAuiState(selector)) as typeof actual.useAuiState,
-    useAui: (() => ({})) as unknown as typeof actual.useAui,
-  };
-});
-
-import { useLangChainStream } from "./hooks";
-
-const runSelectorAgainst = createRunSelectorAgainst(mockUseAuiState);
-
-describe("useLangChainStream", () => {
-  it("returns undefined when extras are absent", () => {
-    runSelectorAgainst(undefined);
-    const { result } = renderHook(() => useLangChainStream());
-    expect(result.current).toBeUndefined();
-  });
-
-  it("returns the stream handle from extras", () => {
-    const stream = { submit: () => {} };
-    runSelectorAgainst(makeExtras({ stream }));
-    const { result } = renderHook(() => useLangChainStream());
-    expect(result.current).toBe(stream);
-  });
-});

package/src/useLangChainSubagents.test.tsx

@@ -1,48 +0,0 @@
-// @vitest-environment jsdom
-
-import { describe, expect, it, vi } from "vitest";
-import { renderHook } from "@testing-library/react";
-import {
-  createRunSelectorAgainst,
-  makeExtras,
-  type Selector,
-} from "./__tests__/langChainTestUtils";
-
-const { mockUseAuiState } = vi.hoisted(() => ({
-  mockUseAuiState: vi.fn(),
-}));
-
-vi.mock(import("@assistant-ui/store"), async (importOriginal) => {
-  const actual = await importOriginal();
-  return {
-    ...actual,
-    useAuiState: ((selector: Selector) =>
-      mockUseAuiState(selector)) as typeof actual.useAuiState,
-    useAui: (() => ({})) as unknown as typeof actual.useAui,
-  };
-});
-
-import { useLangChainSubagents } from "./hooks";
-
-const runSelectorAgainst = createRunSelectorAgainst(mockUseAuiState);
-
-describe("useLangChainSubagents", () => {
-  it("returns the stable empty map when extras are absent", () => {
-    runSelectorAgainst(undefined);
-    const { result } = renderHook(() => useLangChainSubagents());
-    expect(result.current.size).toBe(0);
-  });
-
-  it("returns the subagents map from extras", () => {
-    const subagents = new Map([["researcher", { namespace: "researcher" }]]);
-    runSelectorAgainst(makeExtras({ subagents }));
-    const { result } = renderHook(() => useLangChainSubagents());
-    expect(result.current).toBe(subagents);
-  });
-
-  it("returns the stable empty map when extras carry no subagents", () => {
-    runSelectorAgainst(makeExtras({ subagents: undefined }));
-    const { result } = renderHook(() => useLangChainSubagents());
-    expect(result.current.size).toBe(0);
-  });
-});

package/src/useLangChainSubgraphs.test.tsx

@@ -1,48 +0,0 @@
-// @vitest-environment jsdom
-
-import { describe, expect, it, vi } from "vitest";
-import { renderHook } from "@testing-library/react";
-import {
-  createRunSelectorAgainst,
-  makeExtras,
-  type Selector,
-} from "./__tests__/langChainTestUtils";
-
-const { mockUseAuiState } = vi.hoisted(() => ({
-  mockUseAuiState: vi.fn(),
-}));
-
-vi.mock(import("@assistant-ui/store"), async (importOriginal) => {
-  const actual = await importOriginal();
-  return {
-    ...actual,
-    useAuiState: ((selector: Selector) =>
-      mockUseAuiState(selector)) as typeof actual.useAuiState,
-    useAui: (() => ({})) as unknown as typeof actual.useAui,
-  };
-});
-
-import { useLangChainSubgraphs } from "./hooks";
-
-const runSelectorAgainst = createRunSelectorAgainst(mockUseAuiState);
-
-describe("useLangChainSubgraphs", () => {
-  it("returns the stable empty map when extras are absent", () => {
-    runSelectorAgainst(undefined);
-    const { result } = renderHook(() => useLangChainSubgraphs());
-    expect(result.current.size).toBe(0);
-  });
-
-  it("returns the subgraphs map from extras", () => {
-    const subgraphs = new Map([["planner", { namespace: "planner" }]]);
-    runSelectorAgainst(makeExtras({ subgraphs }));
-    const { result } = renderHook(() => useLangChainSubgraphs());
-    expect(result.current).toBe(subgraphs);
-  });
-
-  it("returns the stable empty map when extras carry no subgraphs", () => {
-    runSelectorAgainst(makeExtras({ subgraphs: undefined }));
-    const { result } = renderHook(() => useLangChainSubgraphs());
-    expect(result.current.size).toBe(0);
-  });
-});

package/src/useLangChainToolCalls.test.tsx

@@ -1,48 +0,0 @@
-// @vitest-environment jsdom
-
-import { describe, expect, it, vi } from "vitest";
-import { renderHook } from "@testing-library/react";
-import {
-  createRunSelectorAgainst,
-  makeExtras,
-  type Selector,
-} from "./__tests__/langChainTestUtils";
-
-const { mockUseAuiState } = vi.hoisted(() => ({
-  mockUseAuiState: vi.fn(),
-}));
-
-vi.mock(import("@assistant-ui/store"), async (importOriginal) => {
-  const actual = await importOriginal();
-  return {
-    ...actual,
-    useAuiState: ((selector: Selector) =>
-      mockUseAuiState(selector)) as typeof actual.useAuiState,
-    useAui: (() => ({})) as unknown as typeof actual.useAui,
-  };
-});
-
-import { useLangChainToolCalls } from "./hooks";
-
-const runSelectorAgainst = createRunSelectorAgainst(mockUseAuiState);
-
-describe("useLangChainToolCalls", () => {
-  it("returns an empty array when extras are absent", () => {
-    runSelectorAgainst(undefined);
-    const { result } = renderHook(() => useLangChainToolCalls());
-    expect(result.current).toEqual([]);
-  });
-
-  it("returns the assembled tool calls from extras", () => {
-    const toolCalls = [{ id: "a", name: "search", args: { q: "x" } }];
-    runSelectorAgainst(makeExtras({ toolCalls }));
-    const { result } = renderHook(() => useLangChainToolCalls());
-    expect(result.current).toBe(toolCalls);
-  });
-
-  it("returns an empty array when extras carry no tool calls", () => {
-    runSelectorAgainst(makeExtras({ toolCalls: undefined }));
-    const { result } = renderHook(() => useLangChainToolCalls());
-    expect(result.current).toEqual([]);
-  });
-});