@assistant-ui/react-ai-sdk 1.3.28 → 1.3.31

package/src/index.ts

@@ -1,4 +1,3 @@
-/// <reference types="@assistant-ui/core/store" />
 /// <reference types="@assistant-ui/core/react" />
 
 export { useAISDKRuntime } from "./ui/use-chat/useAISDKRuntime";
@@ -14,6 +13,10 @@ export type {
   ResumableClientStorage,
 } from "./ui/resumable";
 export { frontendTools } from "./frontendTools";
+export {
+  generativeTools,
+  type GenerativeToolsOptions,
+} from "./generativeTools";
 export { injectQuoteContext } from "./injectQuoteContext";
 export type { ThreadTokenUsage, TokenUsageExtractableMessage } from "./usage";
 export { getThreadMessageTokenUsage, useThreadTokenUsage } from "./usage";

package/src/ui/use-chat/useAISDKRuntime.test.ts

@@ -354,4 +354,40 @@ describe("useAISDKRuntime", () => {
       metadata: { custom: { maxTokens: 100 } },
     });
   });
+
+  it("forwards isDisabled to thread state", () => {
+    const chat = createChatHelpers();
+    const { result } = renderHook(() =>
+      useAISDKRuntime(chat, { isDisabled: true }),
+    );
+    expect(result.current.thread.getState().isDisabled).toBe(true);
+  });
+
+  it("forwards isSendDisabled to the composer canSend gate", () => {
+    const chat = createChatHelpers();
+    const { result } = renderHook(() =>
+      useAISDKRuntime(chat, { isSendDisabled: true }),
+    );
+    act(() => {
+      result.current.thread.composer.setText("hello");
+    });
+    expect(result.current.thread.composer.getState().canSend).toBe(false);
+  });
+
+  it("forwards unstable_capabilities to thread capabilities", () => {
+    const chat = createChatHelpers();
+    const { result } = renderHook(() =>
+      useAISDKRuntime(chat, { unstable_capabilities: { copy: false } }),
+    );
+    expect(result.current.thread.getState().capabilities.unstable_copy).toBe(
+      false,
+    );
+  });
+
+  it("forwards suggestions to thread state", () => {
+    const chat = createChatHelpers();
+    const suggestions = [{ prompt: "tell me a joke" }];
+    const { result } = renderHook(() => useAISDKRuntime(chat, { suggestions }));
+    expect(result.current.thread.getState().suggestions).toEqual(suggestions);
+  });
 });

package/src/ui/use-chat/useAISDKRuntime.ts

@@ -1,20 +1,19 @@
 "use client";
 
-import { useState, useMemo, useRef } from "react";
+import { useMemo, useRef, useState } from "react";
 import type { UIMessage, useChat, CreateUIMessage } from "@ai-sdk/react";
 import { isToolUIPart, generateId } from "ai";
 import {
   useExternalStoreRuntime,
   useRuntimeAdapters,
-  useToolInvocations,
-  type ToolExecutionStatus,
 } from "@assistant-ui/core/react";
+import type { ToolExecutionStatus } from "@assistant-ui/core";
 import type {
   ExternalStoreAdapter,
+  ExternalStoreSharedOptions,
   ThreadHistoryAdapter,
   AssistantRuntime,
   ThreadMessage,
-  ThreadSuggestion,
   MessageFormatAdapter,
   MessageFormatItem,
   MessageFormatRepository,
@@ -22,7 +21,10 @@ import type {
   RunConfig,
   McpAppMetadata,
 } from "@assistant-ui/core";
-import { getExternalStoreMessages } from "@assistant-ui/core";
+import {
+  getExternalStoreMessages,
+  pickExternalStoreSharedOptions,
+} from "@assistant-ui/core";
 import type { ReadonlyJSONObject } from "assistant-stream/utils";
 import { sliceMessagesUntil } from "../utils/sliceMessagesUntil";
 import { toCreateMessage } from "../utils/toCreateMessage";
@@ -56,7 +58,7 @@ const toUIMessage = <UI_MESSAGE extends UIMessage>(
     role: createMessage.role ?? fallbackRole,
   }) as UI_MESSAGE;
 
-export type AISDKRuntimeAdapter = {
+export type AISDKRuntimeAdapter = ExternalStoreSharedOptions & {
   adapters?:
     | (NonNullable<ExternalStoreAdapter["adapters"]> & {
         history?: ThreadHistoryAdapter | undefined;
@@ -80,25 +82,18 @@ export type AISDKRuntimeAdapter = {
    * (for example, an SSE reconnect endpoint keyed by turn id).
    */
   onResume?: ExternalStoreAdapter["onResume"];
-  /**
-   * Follow up suggestions to surface on the thread. Use this to drive
-   * dynamic suggestions from application state, tool results, or backend
-   * responses; flows into `thread.suggestions` and is rendered by
-   * components that read it (such as the shadcn `ThreadFollowupSuggestions`).
-   */
-  suggestions?: readonly ThreadSuggestion[] | undefined;
 };
 
 export const useAISDKRuntime = <UI_MESSAGE extends UIMessage = UIMessage>(
   chatHelpers: ReturnType<typeof useChat<UI_MESSAGE>>,
-  {
+  adapter: AISDKRuntimeAdapter = {},
+) => {
+  const {
     adapters,
     toCreateMessage: customToCreateMessage,
     cancelPendingToolCallsOnSend = true,
     onResume,
-    suggestions,
-  }: AISDKRuntimeAdapter = {},
-) => {
+  } = adapter;
   const contextAdapters = useRuntimeAdapters();
   const [toolStatuses, setToolStatuses] = useState<
     Record<string, ToolExecutionStatus>
@@ -122,6 +117,12 @@ export const useAISDKRuntime = <UI_MESSAGE extends UIMessage = UIMessage>(
 
   const messageTiming = useStreamingTiming(chatHelpers.messages, isRunning);
 
+  // Flag the streaming message optimistic: its id can be swapped for a server
+  // id mid-run, and the repository then drops the orphaned pre-swap id (#4037).
+  const lastMessage = chatHelpers.messages.at(-1);
+  const optimisticMessageId =
+    isRunning && lastMessage?.role === "assistant" ? lastMessage.id : undefined;
+
   const messages = AISDKMessageConverter.useThreadMessages({
     isRunning,
     messages: chatHelpers.messages,
@@ -132,9 +133,10 @@ export const useAISDKRuntime = <UI_MESSAGE extends UIMessage = UIMessage>(
         toolArgsKeyOrderCache: toolArgsKeyOrderCacheRef.current,
         toolLastInputCache: toolLastInputCacheRef.current,
         mcpAppMetadataCache: mcpAppMetadataCacheRef.current,
+        ...(optimisticMessageId && { optimisticMessageId }),
         ...(chatHelpers.error && { error: chatHelpers.error.message }),
       }),
-      [toolStatuses, messageTiming, chatHelpers.error],
+      [toolStatuses, messageTiming, optimisticMessageId, chatHelpers.error],
     ),
   });
 
@@ -144,29 +146,6 @@ export const useAISDKRuntime = <UI_MESSAGE extends UIMessage = UIMessage>(
     },
   }));
 
-  const toolInvocations = useToolInvocations({
-    state: {
-      messages,
-      isRunning,
-    },
-    getTools: () => runtimeRef.current.thread.getModelContext().tools,
-    onResult: (command) => {
-      if (command.type === "add-tool-result") {
-        const output =
-          command.modelContent !== undefined
-            ? wrapModelContentEnvelope(command.result, command.modelContent)
-            : command.result;
-        chatHelpers.addToolResult({
-          tool: command.toolName,
-          toolCallId: command.toolCallId,
-          output,
-          options: { metadata: lastRunConfigRef.current },
-        });
-      }
-    },
-    setToolStatuses,
-  });
-
   const isLoading = useExternalHistory(
     runtimeRef,
     adapters?.history ?? contextAdapters?.history,
@@ -185,7 +164,9 @@ export const useAISDKRuntime = <UI_MESSAGE extends UIMessage = UIMessage>(
   const completePendingToolCalls = async () => {
     if (!cancelPendingToolCallsOnSend) return;
 
-    await toolInvocations.abort();
+    // The runtime auto-aborts in-flight tool invocations when a new run
+    // is dispatched (append() / startRun()). All we need to do here is
+    // mark any tool without a result as cancelled in the UI message list.
 
     // Mark any tool without a result as cancelled (uses setMessages to avoid triggering sendAutomaticallyWhen)
     chatHelpers.setMessages((messages) => {
@@ -214,6 +195,8 @@ export const useAISDKRuntime = <UI_MESSAGE extends UIMessage = UIMessage>(
   const runtime = useExternalStoreRuntime({
     isRunning,
     messages,
+    unstable_enableToolInvocations: true,
+    setToolStatuses,
     setMessages: (messages) =>
       chatHelpers.setMessages(
         messages
@@ -278,7 +261,6 @@ export const useAISDKRuntime = <UI_MESSAGE extends UIMessage = UIMessage>(
     },
     onCancel: async () => {
       chatHelpers.stop();
-      await toolInvocations.abort();
     },
     onNew: async (message) => {
       const createMessage = (
@@ -327,29 +309,36 @@ export const useAISDKRuntime = <UI_MESSAGE extends UIMessage = UIMessage>(
 
       await chatHelpers.regenerate({ metadata: config.runConfig });
     },
-    onAddToolResult: ({ toolCallId, result, isError }) => {
+    onAddToolResult: ({
+      toolCallId,
+      toolName,
+      result,
+      isError,
+      modelContent,
+    }) => {
       const options = { metadata: lastRunConfigRef.current };
       if (isError) {
         chatHelpers.addToolOutput({
           state: "output-error",
-          tool: toolCallId,
+          tool: toolName ?? toolCallId,
           toolCallId,
           errorText:
             typeof result === "string" ? result : JSON.stringify(result),
           options,
         });
       } else {
-        chatHelpers.addToolOutput({
-          state: "output-available",
-          tool: toolCallId,
+        const output =
+          modelContent !== undefined
+            ? wrapModelContentEnvelope(result, modelContent)
+            : result;
+        chatHelpers.addToolResult({
+          tool: toolName,
           toolCallId,
-          output: result,
+          output,
           options,
         });
       }
     },
-    onResumeToolCall: (options) =>
-      toolInvocations.resume(options.toolCallId, options.payload),
     onRespondToToolApproval: ({ approvalId, approved, reason }) => {
       void chatHelpers.addToolApprovalResponse({
         id: approvalId,
@@ -358,8 +347,8 @@ export const useAISDKRuntime = <UI_MESSAGE extends UIMessage = UIMessage>(
         options: { metadata: lastRunConfigRef.current },
       });
     },
+    ...pickExternalStoreSharedOptions(adapter),
     ...(onResume && { onResume }),
-    ...(suggestions && { suggestions }),
     adapters: {
       attachments: vercelAttachmentAdapter,
       ...contextAdapters,

package/src/ui/use-chat/useChatRuntime.ts

@@ -2,7 +2,11 @@
 
 import { useChat, type UIMessage } from "@ai-sdk/react";
 import type { AssistantCloud } from "assistant-cloud";
-import type { AssistantRuntime } from "@assistant-ui/core";
+import {
+  pickExternalStoreSharedOptions,
+  type AssistantRuntime,
+  type ExternalStoreSharedOptions,
+} from "@assistant-ui/core";
 import {
   useCloudThreadListAdapter,
   useRemoteThreadListRuntime,
@@ -19,24 +23,21 @@ import type { AssistantChatResumableOptions } from "../resumable";
 import { useEffect, useMemo, useRef } from "react";
 
 export type UseChatRuntimeOptions<UI_MESSAGE extends UIMessage = UIMessage> =
-  ChatInit<UI_MESSAGE> & {
-    cloud?: AssistantCloud | undefined;
-    adapters?: AISDKRuntimeAdapter["adapters"] | undefined;
-    toCreateMessage?: CustomToCreateMessageFunction;
-    onResume?: AISDKRuntimeAdapter["onResume"];
-    suggestions?: AISDKRuntimeAdapter["suggestions"];
-  };
+  ChatInit<UI_MESSAGE> &
+    ExternalStoreSharedOptions & {
+      cloud?: AssistantCloud | undefined;
+      adapters?: AISDKRuntimeAdapter["adapters"] | undefined;
+      toCreateMessage?: CustomToCreateMessageFunction;
+      onResume?: AISDKRuntimeAdapter["onResume"];
+    };
 
 const useDynamicChatTransport = <UI_MESSAGE extends UIMessage = UIMessage>(
   transport: ChatTransport<UI_MESSAGE>,
 ): ChatTransport<UI_MESSAGE> => {
-  // biome-ignore lint/correctness/useHookAtTopLevel: intentional conditional/nested hook usage
   const transportRef = useRef<ChatTransport<UI_MESSAGE>>(transport);
-  // biome-ignore lint/correctness/useHookAtTopLevel: intentional conditional/nested hook usage
   useEffect(() => {
     transportRef.current = transport;
   });
-  // biome-ignore lint/correctness/useHookAtTopLevel: intentional conditional/nested hook usage
   const dynamicTransport = useMemo(
     () =>
       new Proxy(transportRef.current, {
@@ -72,33 +73,36 @@ const useChatThreadRuntime = <UI_MESSAGE extends UIMessage = UIMessage>(
     adapters,
     transport: transportOptions,
     toCreateMessage,
+    isDisabled: _isDisabled,
+    isSendDisabled: _isSendDisabled,
+    unstable_capabilities: _unstable_capabilities,
+    suggestions: _suggestions,
     onResume,
-    suggestions,
     ...chatOptions
   } = options ?? {};
+  // peel guard: any shared key left in `chatOptions` collapses this to `never`
+  true satisfies keyof typeof chatOptions &
+    keyof ExternalStoreSharedOptions extends never
+    ? true
+    : never;
 
-  // biome-ignore lint/correctness/useHookAtTopLevel: intentional conditional/nested hook usage
   const transport = useDynamicChatTransport(
     transportOptions ?? new AssistantChatTransport(),
   );
 
-  // biome-ignore lint/correctness/useHookAtTopLevel: intentional conditional/nested hook usage
   const id = useAuiState((s) => s.threadListItem.id);
-  // biome-ignore lint/correctness/useHookAtTopLevel: intentional conditional/nested hook usage
   const aui = useAui();
-  // biome-ignore lint/correctness/useHookAtTopLevel: intentional conditional/nested hook usage
   const chat = useChat({
     ...chatOptions,
     id,
     transport,
   });
 
-  // biome-ignore lint/correctness/useHookAtTopLevel: intentional conditional/nested hook usage
   const runtime = useAISDKRuntime(chat, {
     adapters,
+    ...pickExternalStoreSharedOptions(options ?? {}),
     ...(toCreateMessage && { toCreateMessage }),
     ...(onResume && { onResume }),
-    ...(suggestions && { suggestions }),
   });
 
   if (transport instanceof AssistantChatTransport) {
@@ -108,9 +112,7 @@ const useChatThreadRuntime = <UI_MESSAGE extends UIMessage = UIMessage>(
     );
   }
 
-  // biome-ignore lint/correctness/useHookAtTopLevel: intentional conditional/nested hook usage
   const resumeFiredRef = useRef(false);
-  // biome-ignore lint/correctness/useHookAtTopLevel: intentional conditional/nested hook usage
   useEffect(() => {
     if (resumeFiredRef.current) return;
     const adapter = getResumableAdapter(transport);
@@ -137,7 +139,6 @@ export const useChatRuntime = <UI_MESSAGE extends UIMessage = UIMessage>({
   const cloudAdapter = useCloudThreadListAdapter({ cloud });
   return useRemoteThreadListRuntime({
     runtimeHook: function RuntimeHook() {
-      // biome-ignore lint/correctness/useHookAtTopLevel: intentional conditional/nested hook usage
       return useChatThreadRuntime(options);
     },
     adapter: cloudAdapter,

package/src/ui/use-chat/useExternalHistory.test.ts

@@ -5,6 +5,7 @@ import { describe, expect, it, vi } from "vitest";
 import type {
   AssistantRuntime,
   MessageFormatAdapter,
+  MessageFormatRepository,
   ThreadHistoryAdapter,
   ThreadMessage,
 } from "@assistant-ui/core";
@@ -15,7 +16,11 @@ vi.mock("@assistant-ui/store", () => ({
   }),
 }));
 
-import { useExternalHistory } from "./useExternalHistory";
+import { MessageRepository } from "@assistant-ui/core/internal";
+import {
+  toExportedMessageRepository,
+  useExternalHistory,
+} from "./useExternalHistory";
 
 const noopThread = {
   subscribe: () => () => {},
@@ -105,3 +110,57 @@ describe("useExternalHistory withFormat contract", () => {
     expect(adapter.withFormat).toHaveBeenCalledWith(storageFormat);
   });
 });
+
+describe("toExportedMessageRepository", () => {
+  const convert = (items: { id: string; ok: boolean }[]): ThreadMessage[] =>
+    items[0]!.ok ? [{ id: items[0]!.id } as ThreadMessage] : [];
+
+  it("drops a malformed row together with its now-orphaned descendants", () => {
+    const repo: MessageFormatRepository<{ id: string; ok: boolean }> = {
+      headId: "c",
+      messages: [
+        { parentId: null, message: { id: "a", ok: true } },
+        { parentId: "a", message: { id: "b", ok: false } },
+        { parentId: "b", message: { id: "c", ok: true } },
+      ],
+    };
+
+    const result = toExportedMessageRepository(convert, repo);
+
+    expect(result.messages.map((m) => m.message.id)).toEqual(["a"]);
+    expect(result.headId).toBeNull();
+    expect(() => new MessageRepository().import(result)).not.toThrow();
+  });
+
+  it("drops a headId that points at a filtered row", () => {
+    const repo: MessageFormatRepository<{ id: string; ok: boolean }> = {
+      headId: "b",
+      messages: [
+        { parentId: null, message: { id: "a", ok: true } },
+        { parentId: "a", message: { id: "b", ok: false } },
+      ],
+    };
+
+    const result = toExportedMessageRepository(convert, repo);
+
+    expect(result.messages.map((m) => m.message.id)).toEqual(["a"]);
+    expect(result.headId).toBeNull();
+    expect(() => new MessageRepository().import(result)).not.toThrow();
+  });
+
+  it("drops a malformed root and its entire subtree", () => {
+    const repo: MessageFormatRepository<{ id: string; ok: boolean }> = {
+      headId: "b",
+      messages: [
+        { parentId: null, message: { id: "a", ok: false } },
+        { parentId: "a", message: { id: "b", ok: true } },
+      ],
+    };
+
+    const result = toExportedMessageRepository(convert, repo);
+
+    expect(result.messages).toHaveLength(0);
+    expect(result.headId).toBeNull();
+    expect(() => new MessageRepository().import(result)).not.toThrow();
+  });
+});

package/src/ui/use-chat/useExternalHistory.ts

@@ -24,15 +24,24 @@ export const toExportedMessageRepository = <TMessage>(
   toThreadMessages: (messages: TMessage[]) => ThreadMessage[],
   messages: MessageFormatRepository<TMessage>,
 ): ExportedMessageRepository => {
+  const survivingIds = new Set<string>();
+  const survivors = messages.messages.flatMap((m) => {
+    const message = toThreadMessages([m.message])[0];
+    if (!message) {
+      console.warn("Skipping a stored message that could not be loaded.");
+      return [];
+    }
+    if (m.parentId && !survivingIds.has(m.parentId)) return [];
+    survivingIds.add(message.id);
+    return [{ ...m, message }];
+  });
+
   return {
-    headId: messages.headId!,
-    messages: messages.messages.map((m) => {
-      const message = toThreadMessages([m.message])[0]!;
-      return {
-        ...m,
-        message,
-      };
-    }),
+    headId:
+      messages.headId && survivingIds.has(messages.headId)
+        ? messages.headId
+        : null,
+    messages: survivors,
   };
 };
 

package/src/ui/utils/convertMessage.test.ts

@@ -1,8 +1,36 @@
 import { describe, expect, it } from "vitest";
 import type { ReadonlyJSONObject } from "assistant-stream/utils";
-import { AISDKMessageConverter } from "./convertMessage";
+import {
+  AISDKMessageConverter,
+  type AISDKMessageConverterMetadata,
+} from "./convertMessage";
 
 describe("AISDKMessageConverter", () => {
+  it("flags the streaming assistant message as optimistic", () => {
+    const metadata: AISDKMessageConverterMetadata = {
+      optimisticMessageId: "a1",
+    };
+    const converted = AISDKMessageConverter.toThreadMessages(
+      [
+        { id: "u1", role: "user", parts: [{ type: "text", text: "hi" }] },
+        { id: "a1", role: "assistant", parts: [{ type: "text", text: "yo" }] },
+      ] as any,
+      true,
+      metadata,
+    );
+
+    expect(converted[0]?.metadata.isOptimistic).toBeFalsy();
+    expect(converted[1]?.metadata.isOptimistic).toBe(true);
+  });
+
+  it("does not flag messages when no optimistic id is provided", () => {
+    const converted = AISDKMessageConverter.toThreadMessages([
+      { id: "a1", role: "assistant", parts: [{ type: "text", text: "yo" }] },
+    ] as any);
+
+    expect(converted[0]?.metadata.isOptimistic).toBeFalsy();
+  });
+
   it("converts user files into attachments and keeps text content", () => {
     const converted = AISDKMessageConverter.toThreadMessages([
       {
@@ -338,7 +366,7 @@ describe("AISDKMessageConverter", () => {
   });
 
   it("keeps observed key order from streaming snapshots for final tool args", () => {
-    const metadata = {
+    const metadata: AISDKMessageConverterMetadata = {
       toolArgsKeyOrderCache: new Map<string, Map<string, string[]>>(),
     };
 
@@ -410,7 +438,7 @@ describe("AISDKMessageConverter", () => {
   });
 
   it("merges duplicate toolCallId across assistant snapshots", () => {
-    const metadata = {
+    const metadata: AISDKMessageConverterMetadata = {
       toolArgsKeyOrderCache: new Map<string, Map<string, string[]>>(),
     };
 
@@ -463,7 +491,7 @@ describe("AISDKMessageConverter", () => {
   });
 
   it("preserves last good input when AI SDK briefly emits null input", () => {
-    const metadata = {
+    const metadata: AISDKMessageConverterMetadata = {
       toolArgsKeyOrderCache: new Map<string, Map<string, string[]>>(),
       toolLastInputCache: new Map<string, ReadonlyJSONObject>(),
     };
@@ -506,7 +534,7 @@ describe("AISDKMessageConverter", () => {
   });
 
   it("preserves last good input across terminal state transitions", () => {
-    const metadata = {
+    const metadata: AISDKMessageConverterMetadata = {
       toolArgsKeyOrderCache: new Map<string, Map<string, string[]>>(),
       toolLastInputCache: new Map<string, ReadonlyJSONObject>(),
     };
@@ -690,7 +718,7 @@ describe("AISDKMessageConverter", () => {
   });
 
   it("memoizes MCP app metadata across conversions by resourceUri", () => {
-    const metadata = {
+    const metadata: AISDKMessageConverterMetadata = {
       mcpAppMetadataCache: new Map(),
     };
 

package/src/ui/utils/convertMessage.ts

@@ -24,6 +24,8 @@ export type AISDKMessageConverterMetadata =
     toolArgsKeyOrderCache?: Map<string, Map<string, string[]>>;
     toolLastInputCache?: Map<string, ReadonlyJSONObject>;
     mcpAppMetadataCache?: Map<string, McpAppMetadata>;
+    /** Id of the currently-streaming message, flagged optimistic (#4037). */
+    optimisticMessageId?: string | undefined;
   };
 
 function stripClosingDelimiters(json: string): string {
@@ -393,6 +395,9 @@ export const AISDKMessageConverter = unstable_createMessageConverter(
       case "system":
       case "assistant": {
         const timing = metadata.messageTiming?.[message.id];
+        const isOptimistic =
+          message.role === "assistant" &&
+          message.id === metadata.optimisticMessageId;
         return {
           role: message.role,
           id: message.id,
@@ -401,6 +406,7 @@ export const AISDKMessageConverter = unstable_createMessageConverter(
           metadata: {
             ...(message.metadata as MessageMetadata),
             ...(timing && { timing }),
+            ...(isOptimistic && { isOptimistic: true }),
           },
         };
       }

package/dist/node_modules/.pnpm/@types_json-schema@7.0.15/node_modules/@types/json-schema/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","names":["JSONSchema4TypeName","JSONSchema4Type","JSONSchema4Object","JSONSchema4Array","key","Array","JSONSchema4Version","JSONSchema4","id","$ref","$schema","title","description","default","multipleOf","maximum","exclusiveMaximum","minimum","exclusiveMinimum","maxLength","minLength","pattern","additionalItems","items","maxItems","minItems","uniqueItems","maxProperties","minProperties","required","additionalProperties","definitions","k","properties","patternProperties","dependencies","enum","type","allOf","anyOf","oneOf","not","extends","format","JSONSchema6TypeName","JSONSchema6Type","JSONSchema6Object","JSONSchema6Array","JSONSchema6Version","JSONSchema6Definition","JSONSchema6","$id","contains","propertyNames","const","examples","JSONSchema7TypeName","JSONSchema7Type","JSONSchema7Object","JSONSchema7Array","JSONSchema7Version","JSONSchema7Definition","JSONSchema7","$comment","$defs","if","then","else","contentMediaType","contentEncoding","readOnly","writeOnly","ValidationResult","ValidationError","valid","errors","property","message","validate","instance","schema","checkPropertyChange","value","mustBeValid","result"],"sources":["../../../../../../../../../node_modules/.pnpm/@types+json-schema@7.0.15/node_modules/@types/json-schema/index.d.ts"],"x_google_ignoreList":[0],"mappings":";;;;;;;;;;KA+iBYwD,mBAAAA;AAAAA;;;;;KAaAC,eAAAA;AAAAA,qBAINC,iBAAAA,GACAC,gBAAgB;AAAA;AAAA,UAILD,iBAAAA;EAAAA,CACZtD,GAAAA,WAAcqD,eAAe;AAAA;AAAA;AAAA;AAAA,UAKjBE,gBAAAA,SAAyBtD,KAAK,CAACoD,eAAAA;;;;;;;;;;;;KAapCG,kBAAAA;;;;;KAMAC,qBAAAA,GAAwBC,WAAW;AAAA,UAC9BA,WAAAA;EACbX,GAAAA;EACA1C,IAAAA;EACAC,OAAAA,GAAUkD,kBAAAA;EACVG,QAAAA;;;;;EAMAC,KAAAA;IAAAA,CACK5D,GAAAA,WAAcyD,qBAAAA;EAAAA;;;;EAMnBxB,IAAAA,GAAOmB,mBAAAA,GAAsBA,mBAAAA;EAC7BpB,IAAAA,GAAOqB,eAAAA;EACPH,KAAAA,GAAQG,eAAAA;;;;EAKR3C,UAAAA;EACAC,OAAAA;EACAC,gBAAAA;EACAC,OAAAA;EACAC,gBAAAA;;;;EAKAC,SAAAA;EACAC,SAAAA;EACAC,OAAAA;;;;EAKAE,KAAAA,GAAQsC,qBAAAA,GAAwBA,qBAAAA;EAChCvC,eAAAA,GAAkBuC,qBAAAA;EAClBrC,QAAAA;EACAC,QAAAA;EACAC,WAAAA;EACA0B,QAAAA,GAAWS,qBAAAA;;;;EAKXlC,aAAAA;EACAC,aAAAA;EACAC,QAAAA;EACAI,UAAAA;IAAAA,CACK7B,GAAAA,WAAcyD,qBAAAA;EAAAA;EAEnB3B,iBAAAA;IAAAA,CACK9B,GAAAA,WAAcyD,qBAAAA;EAAAA;EAEnB/B,oBAAAA,GAAuB+B,qBAAAA;EACvB1B,YAAAA;IAAAA,CACK/B,GAAAA,WAAcyD,qBAAAA;EAAAA;EAEnBR,aAAAA,GAAgBQ,qBAAAA;;;;EAKhBI,EAAAA,GAAKJ,qBAAAA;EACLK,IAAAA,GAAOL,qBAAAA;EACPM,IAAAA,GAAON,qBAAAA;;;;EAKPvB,KAAAA,GAAQuB,qBAAAA;EACRtB,KAAAA,GAAQsB,qBAAAA;EACRrB,KAAAA,GAAQqB,qBAAAA;EACRpB,GAAAA,GAAMoB,qBAAAA;;;;EAKNlB,MAAAA;;;;EAKAyB,gBAAAA;EACAC,eAAAA;;;;EAKAtC,WAAAA;IAAAA,CACK3B,GAAAA,WAAcyD,qBAAAA;EAAAA;;;;EAMnBlD,KAAAA;EACAC,WAAAA;EACAC,OAAAA,GAAU4C,eAAAA;EACVa,QAAAA;EACAC,SAAAA;EACAhB,QAAAA,GAAWE,eAAAA;AAAAA"}

package/dist/packages/assistant-stream/dist/core/tool/schema-utils.d.ts

@@ -1 +0,0 @@
-export { };

package/dist/packages/assistant-stream/dist/core/tool/schema-utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"schema-utils.js","names":[],"sources":["../../../../../../../assistant-stream/dist/core/tool/schema-utils.js"],"sourcesContent":["//#region src/core/tool/schema-utils.ts\nfunction isStandardSchema(schema) {\n\treturn typeof schema === \"object\" && schema !== null && \"~standard\" in schema && typeof schema[\"~standard\"] === \"object\";\n}\nfunction hasToJSONSchemaMethod(schema) {\n\treturn typeof schema === \"object\" && schema !== null && \"toJSONSchema\" in schema && typeof schema.toJSONSchema === \"function\";\n}\nfunction hasToJSONMethod(schema) {\n\treturn typeof schema === \"object\" && schema !== null && \"toJSON\" in schema && typeof schema.toJSON === \"function\";\n}\n/**\n* Converts a schema to JSONSchema7.\n* Supports:\n* - StandardSchemaV1 with ~standard.toJSONSchema (e.g., Zod v4)\n* - StandardSchemaV1 with ~standard.jsonSchema.input() (e.g., Zod v4)\n* - Objects with toJSONSchema() method (e.g., Zod v4)\n* - Objects with toJSON() method\n* - Plain JSONSchema7 objects (must have a \"type\" property)\n*/\nfunction toJSONSchema(schema) {\n\tif (isStandardSchema(schema)) {\n\t\tconst toJSONSchemaMethod = schema[\"~standard\"].toJSONSchema;\n\t\tif (typeof toJSONSchemaMethod === \"function\") return toJSONSchemaMethod();\n\t\tconst jsonSchema = schema[\"~standard\"].jsonSchema;\n\t\tif (typeof jsonSchema === \"object\" && jsonSchema !== null && typeof jsonSchema.input === \"function\") return jsonSchema.input();\n\t}\n\tif (hasToJSONSchemaMethod(schema)) return schema.toJSONSchema();\n\tif (hasToJSONMethod(schema)) return schema.toJSON();\n\tif (isStandardSchema(schema)) throw new Error(\"Could not convert schema to JSON Schema. The schema implements Standard Schema but does not support JSON Schema conversion. If you are using Zod, please upgrade to Zod v4 (npm install zod@latest). Alternatively, pass a plain JSON Schema object instead.\");\n\treturn schema;\n}\n/**\n* Returns a copy of the JSON Schema with `required` removed recursively,\n* making every property optional. Array item schemas are left unchanged.\n*/\nfunction toPartialJSONSchema(schema) {\n\tconst { required: _, ...result } = schema;\n\tif (result.properties) result.properties = Object.fromEntries(Object.entries(result.properties).map(([key, prop]) => {\n\t\tif (typeof prop === \"object\" && prop !== null && !Array.isArray(prop)) {\n\t\t\tconst p = prop;\n\t\t\treturn [key, p.properties != null ? toPartialJSONSchema(p) : prop];\n\t\t}\n\t\treturn [key, prop];\n\t}));\n\treturn result;\n}\nfunction defaultToolFilter(_name, tool) {\n\treturn !tool.disabled && tool.type !== \"backend\";\n}\n/**\n* Converts a record of tools to a record of tool definitions with JSON Schema parameters.\n* By default, filters out disabled tools and backend tools.\n*/\nfunction toToolsJSONSchema(tools, options = {}) {\n\tif (!tools) return {};\n\tconst filter = options.filter ?? defaultToolFilter;\n\treturn Object.fromEntries(Object.entries(tools).filter(([name, tool]) => filter(name, tool) && tool.parameters).map(([name, tool]) => [name, {\n\t\t...tool.description && { description: tool.description },\n\t\tparameters: toJSONSchema(tool.parameters)\n\t}]));\n}\n//#endregion\nexport { toJSONSchema, toPartialJSONSchema, toToolsJSONSchema };\n\n//# sourceMappingURL=schema-utils.js.map"],"mappings":";AACA,SAAS,iBAAiB,QAAQ;CACjC,OAAO,OAAO,WAAW,YAAY,WAAW,QAAQ,eAAe,UAAU,OAAO,OAAO,iBAAiB;AACjH;AACA,SAAS,sBAAsB,QAAQ;CACtC,OAAO,OAAO,WAAW,YAAY,WAAW,QAAQ,kBAAkB,UAAU,OAAO,OAAO,iBAAiB;AACpH;AACA,SAAS,gBAAgB,QAAQ;CAChC,OAAO,OAAO,WAAW,YAAY,WAAW,QAAQ,YAAY,UAAU,OAAO,OAAO,WAAW;AACxG;;;;;;;;;;AAUA,SAAS,aAAa,QAAQ;CAC7B,IAAI,iBAAiB,MAAM,GAAG;EAC7B,MAAM,qBAAqB,OAAO,aAAa;EAC/C,IAAI,OAAO,uBAAuB,YAAY,OAAO,mBAAmB;EACxE,MAAM,aAAa,OAAO,aAAa;EACvC,IAAI,OAAO,eAAe,YAAY,eAAe,QAAQ,OAAO,WAAW,UAAU,YAAY,OAAO,WAAW,MAAM;CAC9H;CACA,IAAI,sBAAsB,MAAM,GAAG,OAAO,OAAO,aAAa;CAC9D,IAAI,gBAAgB,MAAM,GAAG,OAAO,OAAO,OAAO;CAClD,IAAI,iBAAiB,MAAM,GAAG,MAAM,IAAI,MAAM,8PAA8P;CAC5S,OAAO;AACR;AAgBA,SAAS,kBAAkB,OAAO,MAAM;CACvC,OAAO,CAAC,KAAK,YAAY,KAAK,SAAS;AACxC;;;;;AAKA,SAAS,kBAAkB,OAAO,UAAU,CAAC,GAAG;CAC/C,IAAI,CAAC,OAAO,OAAO,CAAC;CACpB,MAAM,SAAS,QAAQ,UAAU;CACjC,OAAO,OAAO,YAAY,OAAO,QAAQ,KAAK,EAAE,QAAQ,CAAC,MAAM,UAAU,OAAO,MAAM,IAAI,KAAK,KAAK,UAAU,EAAE,KAAK,CAAC,MAAM,UAAU,CAAC,MAAM;EAC5I,GAAG,KAAK,eAAe,EAAE,aAAa,KAAK,YAAY;EACvD,YAAY,aAAa,KAAK,UAAU;CACzC,CAAC,CAAC,CAAC;AACJ"}

package/dist/packages/assistant-stream/dist/core/tool/tool-types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tool-types.d.ts","names":["AsyncIterableStream","JSONSchema7","DeepPartial","TypeAtPath","TypePath","ToolResponse","StandardSchemaV1","ToolModelContentPart","type","text","data","mediaType","filename","ToolModelOutputFunction","TArgs","TResult","Promise","toolCallId","input","output","options","ToolCallArgsReader","PathT","Record","U","Array","get","fieldPath","streamValues","streamText","forEach","ToolCallResponseReader","ToolCallReader","args","response","result","ToolExecutionContext","AbortSignal","abortSignal","human","payload","ToolExecuteFunction","context","ToolStreamCallFunction","reader","OnSchemaValidationErrorFunction","ToolBase","streamCall","BackendTool","description","parameters","disabled","execute","toModelOutput","experimental_onSchemaValidationError","FrontendTool","HumanTool","Tool","ToolWithoutType","Omit"],"sources":["../../../../../../../assistant-stream/dist/core/tool/tool-types.d.ts"],"mappings":";;KAOKO,oBAAAA;EAEME,4EADmED,IAAAA,UACnEC;EAAAA,SAAAA,IAAAA;AAAAA;EAQAE,4EANmEH,IAAAA;EAOnEI;;AAAQ;;EAARA,SAFAF,IAAAA;WACAC,SAAAA;WACAC,QAAAA;AAAAA"}

package/dist/packages/assistant-stream/dist/index.d.ts

@@ -1 +0,0 @@
-import { ToolModelContentPart } from "./core/tool/tool-types.js";

package/dist/packages/assistant-stream/dist/resumable/createResumableAssistantStreamResponse.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"createResumableAssistantStreamResponse.d.ts","names":["AssistantStreamController","AssistantStreamEncoder","ResumableStreamContext","RESUMABLE_STREAM_ID_HEADER","CreateResumableAssistantStreamResponseOptions","PromiseLike","HeadersInit","context","streamId","callback","controller","encoder","headers","createResumableAssistantStreamResponse","Response","Promise","options","CreateResumeAssistantStreamResponseOptions","missingResponse","createResumeAssistantStreamResponse"],"sources":["../../../../../../assistant-stream/dist/resumable/createResumableAssistantStreamResponse.d.ts"],"mappings":";;cAKcG,0BAAAA"}

package/dist/packages/assistant-stream/dist/resumable/createResumableAssistantStreamResponse.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"createResumableAssistantStreamResponse.js","names":[],"sources":["../../../../../../assistant-stream/dist/resumable/createResumableAssistantStreamResponse.js"],"sourcesContent":["import { DataStreamEncoder } from \"../core/serialization/data-stream/DataStream.js\";\nimport { createAssistantStream } from \"../core/modules/assistant-stream.js\";\n//#region src/resumable/createResumableAssistantStreamResponse.ts\nconst RESUMABLE_STREAM_ID_HEADER = \"x-resumable-stream-id\";\nasync function createResumableAssistantStreamResponse(options) {\n\tconst encoder = (options.encoder ?? (() => new DataStreamEncoder()))();\n\tconst stream = await options.context.run(options.streamId, () => {\n\t\treturn createAssistantStream(options.callback).pipeThrough(encoder);\n\t});\n\treturn new Response(stream, { headers: mergeHeaders(encoder.headers, options.headers, options.streamId) });\n}\nasync function createResumeAssistantStreamResponse(options) {\n\tconst stream = await options.context.resume(options.streamId);\n\tif (!stream) return options.missingResponse?.() ?? defaultMissingResponse();\n\tconst encoder = (options.encoder ?? (() => new DataStreamEncoder()))();\n\treturn new Response(stream, { headers: mergeHeaders(encoder.headers, options.headers, options.streamId) });\n}\nfunction defaultMissingResponse() {\n\treturn new Response(JSON.stringify({ error: \"stream not found\" }), {\n\t\tstatus: 404,\n\t\theaders: { \"Content-Type\": \"application/json\" }\n\t});\n}\nfunction mergeHeaders(encoderHeaders, extra, streamId) {\n\tconst merged = new Headers(encoderHeaders ?? {});\n\tif (extra) for (const [key, value] of new Headers(extra)) merged.set(key, value);\n\tmerged.set(RESUMABLE_STREAM_ID_HEADER, streamId);\n\treturn merged;\n}\n//#endregion\nexport { RESUMABLE_STREAM_ID_HEADER, createResumableAssistantStreamResponse, createResumeAssistantStreamResponse };\n\n//# sourceMappingURL=createResumableAssistantStreamResponse.js.map"],"mappings":";AAGA,MAAM,6BAA6B"}

package/dist/packages/assistant-stream/dist/utils/json/json-value.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"json-value.d.ts","names":["ReadonlyJSONValue","ReadonlyJSONObject","ReadonlyJSONArray","key"],"sources":["../../../../../../../assistant-stream/dist/utils/json/json-value.d.ts"],"mappings":";;KACKA,iBAAAA,sCAAuDC,kBAAAA,GAAqBC,iBAAiB;AAAA,KAC7FD,kBAAAA;EAAAA,UACOE,GAAAA,WAAcH,iBAAiB;AAAA;AAAA,KAEtCE,iBAAAA,YAA6BF,iBAAiB"}