@assistant-ui/react 0.12.10 → 0.12.12

package/src/tests/LocalThreadRuntimeCore.test.ts

@@ -0,0 +1,321 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { LocalThreadRuntimeCore } from "../legacy-runtime/runtime-cores/local/LocalThreadRuntimeCore";
+import type { ChatModelAdapter } from "../legacy-runtime/runtime-cores/local/ChatModelAdapter";
+import type { LocalRuntimeOptionsBase } from "../legacy-runtime/runtime-cores/local/LocalRuntimeOptions";
+import type { ModelContextProvider } from "@assistant-ui/core";
+import type { AppendMessage } from "@assistant-ui/core";
+
+const createMockContextProvider = (): ModelContextProvider => ({
+  getModelContext: () => ({}),
+});
+
+const createOptions = (
+  adapter: ChatModelAdapter,
+  overrides: Partial<LocalRuntimeOptionsBase> = {},
+): LocalRuntimeOptionsBase => ({
+  adapters: { chatModel: adapter },
+  ...overrides,
+});
+
+const createUserAppendMessage = (
+  text: string,
+  overrides: Partial<AppendMessage> = {},
+): AppendMessage => ({
+  role: "user",
+  content: [{ type: "text", text }],
+  attachments: [],
+  metadata: { custom: {} },
+  parentId: null,
+  sourceId: null,
+  runConfig: undefined,
+  createdAt: new Date(),
+  ...overrides,
+});
+
+describe("LocalThreadRuntimeCore", () => {
+  let contextProvider: ModelContextProvider;
+
+  beforeEach(() => {
+    contextProvider = createMockContextProvider();
+  });
+
+  it("appends a user message and runs the chat model", async () => {
+    const adapter: ChatModelAdapter = {
+      run: vi.fn().mockResolvedValue({
+        content: [{ type: "text", text: "Hello!" }],
+        status: { type: "complete", reason: "stop" },
+      }),
+    };
+    const core = new LocalThreadRuntimeCore(
+      contextProvider,
+      createOptions(adapter),
+    );
+
+    await core.append(createUserAppendMessage("Hi"));
+
+    const messages = core.messages;
+    expect(messages).toHaveLength(2);
+    expect(messages[0]!.role).toBe("user");
+    expect(messages[1]!.role).toBe("assistant");
+    expect(messages[1]!.content).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ type: "text", text: "Hello!" }),
+      ]),
+    );
+    expect(messages[1]!.status).toEqual({ type: "complete", reason: "stop" });
+    expect(adapter.run).toHaveBeenCalledOnce();
+  });
+
+  it("streams assistant response via async generator", async () => {
+    const adapter: ChatModelAdapter = {
+      run: vi.fn().mockImplementation(async function* () {
+        yield {
+          content: [{ type: "text" as const, text: "Hel" }],
+        };
+        yield {
+          content: [{ type: "text" as const, text: "Hello world" }],
+          status: { type: "complete" as const, reason: "stop" as const },
+        };
+      }),
+    };
+    const core = new LocalThreadRuntimeCore(
+      contextProvider,
+      createOptions(adapter),
+    );
+
+    await core.append(createUserAppendMessage("Stream test"));
+
+    const messages = core.messages;
+    expect(messages).toHaveLength(2);
+    const assistant = messages[1]!;
+    expect(assistant.role).toBe("assistant");
+    expect(assistant.content).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ type: "text", text: "Hello world" }),
+      ]),
+    );
+    expect(assistant.status).toEqual({ type: "complete", reason: "stop" });
+  });
+
+  it("cancels a running response", async () => {
+    const adapter: ChatModelAdapter = {
+      run: vi.fn().mockImplementation(async function* ({ abortSignal }) {
+        yield {
+          content: [{ type: "text" as const, text: "partial" }],
+        };
+        // Wait until the abort signal fires
+        await new Promise<void>((_resolve, reject) => {
+          if (abortSignal.aborted) {
+            reject(abortSignal.reason);
+            return;
+          }
+          abortSignal.addEventListener(
+            "abort",
+            () => reject(abortSignal.reason),
+            { once: true },
+          );
+        });
+      }),
+    };
+    const core = new LocalThreadRuntimeCore(
+      contextProvider,
+      createOptions(adapter),
+    );
+
+    // Start append but don't await (it will hang until cancelled)
+    const appendPromise = core.append(createUserAppendMessage("Cancel me"));
+
+    // Give the generator time to yield first chunk
+    await new Promise((r) => setTimeout(r, 50));
+
+    core.cancelRun();
+    await appendPromise;
+
+    const messages = core.messages;
+    expect(messages).toHaveLength(2);
+    const assistant = messages[1]!;
+    expect(assistant.status).toBeDefined();
+    expect(assistant.status!.type).toBe("incomplete");
+    if (assistant.status!.type === "incomplete") {
+      expect(assistant.status!.reason).toBe("cancelled");
+    }
+  });
+
+  it("handles adapter errors gracefully", async () => {
+    const adapter: ChatModelAdapter = {
+      run: vi.fn().mockRejectedValue(new Error("Model unavailable")),
+    };
+    const core = new LocalThreadRuntimeCore(
+      contextProvider,
+      createOptions(adapter),
+    );
+
+    await expect(
+      core.append(createUserAppendMessage("Error test")),
+    ).rejects.toThrow("Model unavailable");
+
+    const messages = core.messages;
+    expect(messages).toHaveLength(2);
+    const assistant = messages[1]!;
+    expect(assistant.status).toBeDefined();
+    expect(assistant.status!.type).toBe("incomplete");
+    if (assistant.status!.type === "incomplete") {
+      expect(assistant.status!.reason).toBe("error");
+      expect(assistant.status!.error).toBe("Model unavailable");
+    }
+  });
+
+  it("continues tool execution loop", async () => {
+    let callCount = 0;
+    const adapter: ChatModelAdapter = {
+      run: vi.fn().mockImplementation(() => {
+        callCount++;
+        if (callCount === 1) {
+          return Promise.resolve({
+            content: [
+              {
+                type: "tool-call",
+                toolCallId: "tc1",
+                toolName: "myTool",
+                args: { input: "test" },
+                argsText: '{"input":"test"}',
+              },
+            ],
+            status: { type: "requires-action", reason: "tool-calls" },
+          });
+        }
+        return Promise.resolve({
+          content: [{ type: "text", text: "Done with tool" }],
+          status: { type: "complete", reason: "stop" },
+        });
+      }),
+    };
+    const core = new LocalThreadRuntimeCore(
+      contextProvider,
+      createOptions(adapter),
+    );
+
+    await core.append(createUserAppendMessage("Use a tool"));
+
+    // The assistant message should have a tool-call with no result yet
+    // and status requires-action. Now add the tool result.
+    const assistantMsg = core.messages[1]!;
+    expect(assistantMsg.role).toBe("assistant");
+
+    core.addToolResult({
+      messageId: assistantMsg.id,
+      toolName: "myTool",
+      toolCallId: "tc1",
+      result: "tool output",
+      isError: false,
+    });
+
+    // Wait for the second roundtrip to complete
+    await new Promise((r) => setTimeout(r, 100));
+
+    expect(adapter.run).toHaveBeenCalledTimes(2);
+
+    const finalMessages = core.messages;
+    const finalAssistant = finalMessages[1]!;
+    // Content should include both the tool-call from round 1 and text from round 2
+    expect(finalAssistant.content.some((c) => c.type === "tool-call")).toBe(
+      true,
+    );
+    expect(
+      finalAssistant.content.some(
+        (c) => c.type === "text" && c.text === "Done with tool",
+      ),
+    ).toBe(true);
+  });
+
+  it("stops at maxSteps", async () => {
+    const adapter: ChatModelAdapter = {
+      run: vi.fn().mockResolvedValue({
+        content: [
+          {
+            type: "tool-call",
+            toolCallId: "tc1",
+            toolName: "myTool",
+            args: {},
+            argsText: "{}",
+          },
+        ],
+        status: { type: "requires-action", reason: "tool-calls" },
+        metadata: {
+          steps: [{ usage: { promptTokens: 10, completionTokens: 5 } }],
+        },
+      }),
+    };
+    const core = new LocalThreadRuntimeCore(
+      contextProvider,
+      createOptions(adapter, { maxSteps: 1 }),
+    );
+
+    await core.append(createUserAppendMessage("Tool call"));
+
+    // Add tool result - this should NOT trigger another roundtrip because maxSteps=1
+    const assistantMsg = core.messages[1]!;
+    core.addToolResult({
+      messageId: assistantMsg.id,
+      toolName: "myTool",
+      toolCallId: "tc1",
+      result: "result",
+      isError: false,
+    });
+
+    // Wait a bit to ensure no additional roundtrip happened
+    await new Promise((r) => setTimeout(r, 100));
+
+    // Should have been called only once (the initial run)
+    expect(adapter.run).toHaveBeenCalledTimes(1);
+
+    const finalAssistant = core.messages[1]!;
+    expect(finalAssistant.status).toBeDefined();
+    expect(finalAssistant.status!.type).toBe("incomplete");
+    if (finalAssistant.status!.type === "incomplete") {
+      expect(finalAssistant.status!.reason).toBe("tool-calls");
+    }
+  });
+
+  it("capabilities update from options", () => {
+    const adapter: ChatModelAdapter = {
+      run: vi.fn().mockResolvedValue({ content: [] }),
+    };
+    const core = new LocalThreadRuntimeCore(
+      contextProvider,
+      createOptions(adapter),
+    );
+
+    // Default capabilities
+    expect(core.capabilities.speech).toBe(false);
+    expect(core.capabilities.dictation).toBe(false);
+    expect(core.capabilities.attachments).toBe(false);
+    expect(core.capabilities.feedback).toBe(false);
+
+    // Update with adapters
+    core.__internal_setOptions({
+      adapters: {
+        chatModel: adapter,
+        speech: {} as any,
+        dictation: {} as any,
+        attachments: {} as any,
+        feedback: {} as any,
+      },
+    });
+
+    expect(core.capabilities.speech).toBe(true);
+    expect(core.capabilities.dictation).toBe(true);
+    expect(core.capabilities.attachments).toBe(true);
+    expect(core.capabilities.feedback).toBe(true);
+
+    // Update back to no adapters
+    core.__internal_setOptions({
+      adapters: { chatModel: adapter },
+    });
+
+    expect(core.capabilities.speech).toBe(false);
+    expect(core.capabilities.dictation).toBe(false);
+    expect(core.capabilities.attachments).toBe(false);
+    expect(core.capabilities.feedback).toBe(false);
+  });
+});

package/src/tests/external-message-converter.test.ts

@@ -1,7 +1,7 @@
 import { describe, it, expect } from "vitest";
 import { convertExternalMessages } from "../legacy-runtime/runtime-cores/external-store/external-message-converter";
 import type { useExternalMessageConverter } from "../legacy-runtime/runtime-cores/external-store/external-message-converter";
-import { isErrorMessageId } from "../utils/idUtils";
+import { isErrorMessageId } from "@assistant-ui/core/internal";
 
 describe("convertExternalMessages", () => {
   describe("reasoning part merging", () => {

package/src/tests/shouldContinue.test.ts

@@ -0,0 +1,89 @@
+import type { ThreadAssistantMessage } from "@assistant-ui/core";
+import { describe, expect, it } from "vitest";
+import { shouldContinue } from "../legacy-runtime/runtime-cores/local/shouldContinue";
+
+const makeMessage = (
+  overrides: Partial<ThreadAssistantMessage>,
+): ThreadAssistantMessage => ({
+  id: "msg-1",
+  role: "assistant",
+  createdAt: new Date(),
+  content: [],
+  status: { type: "complete", reason: "stop" },
+  metadata: {
+    unstable_state: null,
+    unstable_annotations: [],
+    unstable_data: [],
+    steps: [],
+    custom: {},
+  },
+  ...overrides,
+});
+
+const toolCall = (toolName: string, result?: unknown) => ({
+  type: "tool-call" as const,
+  toolCallId: `call-${toolName}`,
+  toolName,
+  args: {},
+  argsText: "{}",
+  ...(result !== undefined ? { result } : {}),
+});
+
+describe("shouldContinue", () => {
+  it("returns false when status is not requires-action", () => {
+    const msg = makeMessage({
+      status: { type: "complete", reason: "stop" },
+    });
+    expect(shouldContinue(msg, undefined)).toBe(false);
+  });
+
+  it("returns false when reason is not tool-calls", () => {
+    const msg = makeMessage({
+      status: { type: "requires-action", reason: "interrupt" },
+    });
+    expect(shouldContinue(msg, undefined)).toBe(false);
+  });
+
+  it("returns true when all tool calls have results (no humanToolNames)", () => {
+    const msg = makeMessage({
+      status: { type: "requires-action", reason: "tool-calls" },
+      content: [toolCall("search", "found it"), toolCall("calculate", 42)],
+    });
+    expect(shouldContinue(msg, undefined)).toBe(true);
+  });
+
+  it("returns false when some tool calls have no result (no humanToolNames)", () => {
+    const msg = makeMessage({
+      status: { type: "requires-action", reason: "tool-calls" },
+      content: [toolCall("search", "found it"), toolCall("calculate")],
+    });
+    expect(shouldContinue(msg, undefined)).toBe(false);
+  });
+
+  it("returns true when unresolved tool call is not a human tool", () => {
+    const msg = makeMessage({
+      status: { type: "requires-action", reason: "tool-calls" },
+      content: [toolCall("auto-tool")],
+    });
+    expect(shouldContinue(msg, ["human-approval"])).toBe(true);
+  });
+
+  it("returns false when unresolved tool call IS a human tool", () => {
+    const msg = makeMessage({
+      status: { type: "requires-action", reason: "tool-calls" },
+      content: [toolCall("human-approval")],
+    });
+    expect(shouldContinue(msg, ["human-approval"])).toBe(false);
+  });
+
+  it("returns true for non-tool-call content parts", () => {
+    const msg = makeMessage({
+      status: { type: "requires-action", reason: "tool-calls" },
+      content: [
+        { type: "text", text: "Hello" } as any,
+        toolCall("search", "done"),
+      ],
+    });
+    expect(shouldContinue(msg, undefined)).toBe(true);
+  });
+});

package/src/types/index.ts

@@ -1,11 +1,9 @@
+// Re-export core types from @assistant-ui/core
 export type {
   Attachment,
   PendingAttachment,
   CompleteAttachment,
   AttachmentStatus,
-} from "./AttachmentTypes";
-
-export type {
   AppendMessage,
   TextMessagePart,
   ReasoningMessagePart,
@@ -18,15 +16,19 @@ export type {
   MessageStatus,
   MessagePartStatus,
   ToolCallMessagePartStatus,
-  // thread message types
+  MessageTiming,
   ThreadUserMessagePart,
   ThreadAssistantMessagePart,
   ThreadSystemMessage,
   ThreadAssistantMessage,
   ThreadUserMessage,
   ThreadMessage,
-} from "./AssistantTypes";
+  Unsubscribe,
+  QuoteInfo,
+  CreateAttachment,
+} from "@assistant-ui/core";
 
+// React component types (from core/react)
 export type {
   EmptyMessagePartComponent,
   EmptyMessagePartProps,
@@ -42,15 +44,13 @@ export type {
   FileMessagePartProps,
   Unstable_AudioMessagePartComponent,
   Unstable_AudioMessagePartProps,
+  DataMessagePartComponent,
+  DataMessagePartProps,
   ToolCallMessagePartComponent,
   ToolCallMessagePartProps,
   ReasoningGroupProps,
   ReasoningGroupComponent,
-} from "./MessagePartComponentTypes";
+} from "@assistant-ui/core/react";
 
 // Thread list item types
-export type { ThreadListItemStatus } from "../legacy-runtime/runtime/ThreadListItemRuntime";
-
-export type { Unsubscribe } from "./Unsubscribe";
-
-export type { QuoteInfo } from "./QuoteTypes";
+export type { ThreadListItemStatus } from "@assistant-ui/core";

package/src/types/scopes/index.ts

@@ -1,69 +1,59 @@
+// Re-export 11 scope types from core
 export type {
   ThreadsState,
   ThreadsMethods,
   ThreadsClientSchema,
-} from "./threads";
-export type {
   ThreadListItemState,
   ThreadListItemMethods,
   ThreadListItemMeta,
   ThreadListItemEvents,
   ThreadListItemClientSchema,
-} from "./threadListItem";
-export type {
   ThreadState,
   ThreadMethods,
   ThreadMeta,
   ThreadEvents,
   ThreadClientSchema,
-} from "./thread";
-export type {
   MessageState,
   MessageMethods,
   MessageMeta,
   MessageClientSchema,
-} from "./message";
-export type {
   PartState,
   PartMethods,
   PartMeta,
   PartClientSchema,
-} from "./part";
-export type {
   ComposerState,
   ComposerMethods,
   ComposerMeta,
   ComposerEvents,
   ComposerClientSchema,
-} from "./composer";
-export type {
   AttachmentState,
   AttachmentMethods,
   AttachmentMeta,
   AttachmentClientSchema,
-} from "./attachment";
-export type { ToolsState, ToolsMethods, ToolsClientSchema } from "./tools";
-export type {
   SuggestionsState,
   SuggestionsMethods,
   SuggestionsClientSchema,
   Suggestion,
-} from "./suggestions";
-export type {
   SuggestionState,
   SuggestionMethods,
   SuggestionMeta,
   SuggestionClientSchema,
-} from "./suggestion";
-export type {
   ModelContextState,
   ModelContextMethods,
   ModelContextClientSchema,
-} from "./modelContext";
-export type {
   ChainOfThoughtState,
   ChainOfThoughtMethods,
   ChainOfThoughtMeta,
   ChainOfThoughtClientSchema,
   ChainOfThoughtPart,
-} from "./chainOfThought";
+} from "@assistant-ui/core/store";
+
+// Scope types from core/react
+export type {
+  ToolsState,
+  ToolsMethods,
+  ToolsClientSchema,
+  DataRenderersState,
+  DataRenderersMethods,
+  DataRenderersClientSchema,
+} from "@assistant-ui/core/react";

package/src/utils/smooth/SmoothContext.tsx

@@ -11,10 +11,10 @@ import {
 } from "react";
 import { ReadonlyStore } from "../../context/ReadonlyStore";
 import { create, UseBoundStore } from "zustand";
-import {
+import type {
   MessagePartStatus,
   ToolCallMessagePartStatus,
-} from "../../types/AssistantTypes";
+} from "@assistant-ui/core";
 import { useAui } from "@assistant-ui/store";
 import { createContextStoreHook } from "../../context/react/utils/createContextStoreHook";
 

package/src/utils/smooth/{useSmooth.tsx → useSmooth.ts}

@@ -2,15 +2,15 @@
 
 import { useEffect, useMemo, useRef, useState } from "react";
 import { useAuiState } from "@assistant-ui/store";
-import {
+import type {
   MessagePartStatus,
   ReasoningMessagePart,
   TextMessagePart,
-} from "../../types/AssistantTypes";
+  MessagePartState,
+} from "@assistant-ui/core";
 import { useCallbackRef } from "@radix-ui/react-use-callback-ref";
 import { useSmoothStatusStore } from "./SmoothContext";
 import { writableStore } from "../../context/ReadonlyStore";
-import { MessagePartState } from "../../legacy-runtime/runtime/MessagePartRuntime";
 
 class TextStreamAnimator {
   private animationFrameId: number | null = null;
@@ -78,7 +78,9 @@ export const useSmooth = (
   const id = useAuiState((s) => s.message.id);
 
   const idRef = useRef(id);
-  const [displayedText, setDisplayedText] = useState(text);
+  const [displayedText, setDisplayedText] = useState(
+    state.status.type === "running" ? "" : text,
+  );
 
   const smoothStatusStore = useSmoothStatusStore({ optional: true });
   const setText = useCallbackRef((text: string) => {
@@ -104,7 +106,7 @@ export const useSmooth = (
   }, [smoothStatusStore, smooth, text, displayedText, state.status]);
 
   const [animatorRef] = useState<TextStreamAnimator>(
-    new TextStreamAnimator(text, setText),
+    new TextStreamAnimator(displayedText, setText),
   );
 
   useEffect(() => {
@@ -115,18 +117,27 @@ export const useSmooth = (
 
     if (idRef.current !== id || !text.startsWith(animatorRef.targetText)) {
       idRef.current = id;
-      setText(text);
 
-      animatorRef.currentText = text;
-      animatorRef.targetText = text;
-      animatorRef.stop();
+      if (state.status.type === "running") {
+        // New streaming message → animate from empty string
+        setText("");
+        animatorRef.currentText = "";
+        animatorRef.targetText = text;
+        animatorRef.start();
+      } else {
+        // Completed message → display immediately
+        setText(text);
+        animatorRef.currentText = text;
+        animatorRef.targetText = text;
+        animatorRef.stop();
+      }
 
       return;
     }
 
     animatorRef.targetText = text;
     animatorRef.start();
-  }, [setText, animatorRef, id, smooth, text]);
+  }, [setText, animatorRef, id, smooth, text, state.status.type]);
 
   useEffect(() => {
     return () => {

package/dist/client/ChainOfThoughtClient.d.ts

@@ -1,15 +0,0 @@
-import { type ClientOutput } from "@assistant-ui/store";
-import type { ChainOfThoughtPart } from "../types/scopes/chainOfThought.js";
-import type { PartMethods } from "../types/scopes/part.js";
-export declare const ChainOfThoughtClient: (props: {
-    parts: readonly ChainOfThoughtPart[];
-    getMessagePart: (selector: {
-        index: number;
-    }) => PartMethods;
-}) => import("@assistant-ui/tap").ResourceElement<ClientOutput<"chainOfThought">, {
-    parts: readonly ChainOfThoughtPart[];
-    getMessagePart: (selector: {
-        index: number;
-    }) => PartMethods;
-}>;
-//# sourceMappingURL=ChainOfThoughtClient.d.ts.map

package/dist/client/ChainOfThoughtClient.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ChainOfThoughtClient.d.ts","sourceRoot":"","sources":["../../src/client/ChainOfThoughtClient.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,KAAK,EAEV,kBAAkB,EACnB,0CAAuC;AAExC,OAAO,KAAK,EAAE,WAAW,EAAE,gCAA6B;AAMxD,eAAO,MAAM,oBAAoB;WAKtB,SAAS,kBAAkB,EAAE;oBACpB,CAAC,QAAQ,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,KAAK,WAAW;;WADrD,SAAS,kBAAkB,EAAE;oBACpB,CAAC,QAAQ,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,KAAK,WAAW;EAuB/D,CAAC"}

package/dist/client/ChainOfThoughtClient.js

@@ -1,21 +0,0 @@
-import { resource, tapMemo, tapState } from "@assistant-ui/tap";
-const COMPLETE_STATUS = Object.freeze({
-    type: "complete",
-});
-export const ChainOfThoughtClient = resource(({ parts, getMessagePart, }) => {
-    const [collapsed, setCollapsed] = tapState(true);
-    const status = tapMemo(() => {
-        const lastPart = parts[parts.length - 1];
-        return lastPart?.status ?? COMPLETE_STATUS;
-    }, [parts]);
-    const state = tapMemo(() => ({ parts, collapsed, status }), [parts, collapsed, status]);
-    return {
-        state,
-        methods: {
-            getState: () => state,
-            setCollapsed,
-            part: getMessagePart,
-        },
-    };
-});
-//# sourceMappingURL=ChainOfThoughtClient.js.map

package/dist/client/ChainOfThoughtClient.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ChainOfThoughtClient.js","sourceRoot":"","sources":["../../src/client/ChainOfThoughtClient.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAShE,MAAM,eAAe,GAAsB,MAAM,CAAC,MAAM,CAAC;IACvD,IAAI,EAAE,UAAU;CACjB,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,oBAAoB,GAAG,QAAQ,CAC1C,CAAC,EACC,KAAK,EACL,cAAc,GAIf,EAAkC,EAAE;IACnC,MAAM,CAAC,SAAS,EAAE,YAAY,CAAC,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC;IAEjD,MAAM,MAAM,GAAG,OAAO,CAAC,GAAG,EAAE;QAC1B,MAAM,QAAQ,GAAG,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;QACzC,OAAO,QAAQ,EAAE,MAAM,IAAI,eAAe,CAAC;IAC7C,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC;IAEZ,MAAM,KAAK,GAAG,OAAO,CACnB,GAAG,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,CAAC,EACpC,CAAC,KAAK,EAAE,SAAS,EAAE,MAAM,CAAC,CAC3B,CAAC;IAEF,OAAO;QACL,KAAK;QACL,OAAO,EAAE;YACP,QAAQ,EAAE,GAAG,EAAE,CAAC,KAAK;YACrB,YAAY;YACZ,IAAI,EAAE,cAAc;SACrB;KACF,CAAC;AACJ,CAAC,CACF,CAAC"}

package/dist/client/ModelContextClient.d.ts

@@ -1,3 +0,0 @@
-import { type ClientOutput } from "@assistant-ui/store";
-export declare const ModelContext: () => import("@assistant-ui/tap").ResourceElement<ClientOutput<"modelContext">, undefined>;
-//# sourceMappingURL=ModelContextClient.d.ts.map