@assistant-ui/ai-sdk 0.0.11 → 0.0.12

package/src/runtime/useExternalHistory.ts

@@ -12,10 +12,7 @@ import type {
   Unstable_ToolInteractionLog,
 } from "@assistant-ui/core";
 import { getExternalStoreMessages } from "@assistant-ui/core";
-import {
-  MessageRepository,
-  readToolInteractionLog,
-} from "@assistant-ui/core/internal";
+import { MessageRepository } from "@assistant-ui/core/internal";
 import { useAui } from "@assistant-ui/store";
 import {
   useRef,
@@ -25,7 +22,14 @@ import {
   useCallback,
   useMemo,
 } from "react";
-import { normalizeToolApprovalAnswers } from "../converters/toolApprovalAnswers";
+import {
+  addToolData,
+  collectToolApprovalResponses,
+  collectToolArtifacts,
+  collectToolInteractions,
+  restoreToolData,
+  type StoredToolApprovalResponse,
+} from "./toolHistoryCodec";
 
 export const toExportedMessageRepository = <TMessage>(
   toThreadMessages: (messages: TMessage[]) => ThreadMessage[],
@@ -72,209 +76,6 @@ const isTerminalMessage = (message: ThreadMessage) =>
   message.status.type === "complete" ||
   message.status.type === "incomplete";
 
-const TOOL_ARTIFACTS_METADATA_KEY = "__aui_toolArtifacts";
-const TOOL_INTERACTIONS_METADATA_KEY = "__aui_toolInteractions";
-const TOOL_APPROVAL_RESPONSES_METADATA_KEY = "__aui_toolApprovalResponses";
-
-type StoredToolApprovalResponse = Omit<
-  RespondToToolApprovalOptions,
-  "approvalId"
->;
-
-const isRecord = (value: unknown): value is Record<string, unknown> =>
-  value !== null && typeof value === "object" && !Array.isArray(value);
-
-const collectToolArtifacts = (
-  message: ThreadMessage,
-  toolArtifacts: ReadonlyMap<string, unknown> | undefined,
-) => {
-  if (!toolArtifacts) return undefined;
-  const entries = message.content.flatMap((part) => {
-    if (part.type !== "tool-call") return [];
-    const artifact = toolArtifacts.get(part.toolCallId);
-    return artifact === undefined ? [] : [[part.toolCallId, artifact] as const];
-  });
-  return entries.length > 0 ? Object.fromEntries(entries) : undefined;
-};
-
-const collectToolInteractions = (
-  message: ThreadMessage,
-  toolInteractions:
-    | ReadonlyMap<string, Unstable_ToolInteractionLog>
-    | undefined,
-) => {
-  if (!toolInteractions) return undefined;
-  const entries = message.content.flatMap((part) => {
-    if (part.type !== "tool-call") return [];
-    const interactions = toolInteractions.get(part.toolCallId);
-    return interactions === undefined
-      ? []
-      : [[part.toolCallId, interactions] as const];
-  });
-  return entries.length > 0 ? Object.fromEntries(entries) : undefined;
-};
-
-const collectToolApprovalResponses = (
-  message: ThreadMessage,
-  toolApprovalResponses:
-    | ReadonlyMap<string, RespondToToolApprovalOptions>
-    | undefined,
-) => {
-  if (!toolApprovalResponses) return undefined;
-  const entries = message.content.flatMap((part) => {
-    if (part.type !== "tool-call" || !part.approval) return [];
-    const response = toolApprovalResponses.get(part.approval.id);
-    if (!response) return [];
-    return [
-      [
-        part.approval.id,
-        {
-          approved: response.approved,
-          ...(response.optionId != null && { optionId: response.optionId }),
-          ...(response.text != null && { text: response.text }),
-          ...(response.answers != null && { answers: response.answers }),
-          ...(response.reason != null && { reason: response.reason }),
-        },
-      ] as const,
-    ];
-  });
-  return entries.length > 0 ? Object.fromEntries(entries) : undefined;
-};
-
-const addToolData = <TMessage>(
-  message: TMessage,
-  toolArtifacts: Record<string, unknown> | undefined,
-  toolInteractions: Record<string, Unstable_ToolInteractionLog> | undefined,
-  toolApprovalResponses: Record<string, StoredToolApprovalResponse> | undefined,
-): TMessage => {
-  if (
-    (!toolArtifacts && !toolInteractions && !toolApprovalResponses) ||
-    !isRecord(message) ||
-    !Array.isArray(message.parts)
-  )
-    return message;
-  const toolCallIds = message.parts.flatMap((part) => {
-    if (!isRecord(part) || typeof part.toolCallId !== "string") return [];
-    return [part.toolCallId];
-  });
-  const artifacts = toolArtifacts
-    ? Object.fromEntries(
-        toolCallIds.flatMap((toolCallId) =>
-          Object.hasOwn(toolArtifacts, toolCallId)
-            ? [[toolCallId, toolArtifacts[toolCallId]] as const]
-            : [],
-        ),
-      )
-    : undefined;
-  const interactions = toolInteractions
-    ? Object.fromEntries(
-        toolCallIds.flatMap((toolCallId) =>
-          Object.hasOwn(toolInteractions, toolCallId)
-            ? [[toolCallId, toolInteractions[toolCallId]] as const]
-            : [],
-        ),
-      )
-    : undefined;
-  const approvalIds = message.parts.flatMap((part) => {
-    if (!isRecord(part) || !isRecord(part.approval)) return [];
-    const approvalId = part.approval.id;
-    return typeof approvalId === "string" ? [approvalId] : [];
-  });
-  const approvalResponses = toolApprovalResponses
-    ? Object.fromEntries(
-        approvalIds.flatMap((approvalId) =>
-          Object.hasOwn(toolApprovalResponses, approvalId)
-            ? [[approvalId, toolApprovalResponses[approvalId]] as const]
-            : [],
-        ),
-      )
-    : undefined;
-  const hasArtifacts = !!artifacts && Object.keys(artifacts).length > 0;
-  const hasInteractions =
-    !!interactions && Object.keys(interactions).length > 0;
-  const hasApprovalResponses =
-    !!approvalResponses && Object.keys(approvalResponses).length > 0;
-  if (!hasArtifacts && !hasInteractions && !hasApprovalResponses)
-    return message;
-  const metadata = isRecord(message.metadata) ? message.metadata : {};
-  return {
-    ...message,
-    metadata: {
-      ...metadata,
-      ...(hasArtifacts && { [TOOL_ARTIFACTS_METADATA_KEY]: artifacts }),
-      ...(hasInteractions && {
-        [TOOL_INTERACTIONS_METADATA_KEY]: interactions,
-      }),
-      ...(hasApprovalResponses && {
-        [TOOL_APPROVAL_RESPONSES_METADATA_KEY]: approvalResponses,
-      }),
-    },
-  } as TMessage;
-};
-
-const restoreToolData = <TMessage>(
-  message: TMessage,
-  toolArtifacts: Map<string, unknown> | undefined,
-  toolInteractions: Map<string, Unstable_ToolInteractionLog> | undefined,
-  toolApprovalResponses: Map<string, RespondToToolApprovalOptions> | undefined,
-): TMessage => {
-  if (!isRecord(message) || !isRecord(message.metadata)) return message;
-  const metadata = message.metadata;
-  const hasArtifacts = Object.hasOwn(metadata, TOOL_ARTIFACTS_METADATA_KEY);
-  const hasInteractions = Object.hasOwn(
-    metadata,
-    TOOL_INTERACTIONS_METADATA_KEY,
-  );
-  const hasApprovalResponses = Object.hasOwn(
-    metadata,
-    TOOL_APPROVAL_RESPONSES_METADATA_KEY,
-  );
-  if (!hasArtifacts && !hasInteractions && !hasApprovalResponses)
-    return message;
-  const artifacts = metadata[TOOL_ARTIFACTS_METADATA_KEY];
-  if (toolArtifacts && isRecord(artifacts)) {
-    for (const [toolCallId, artifact] of Object.entries(artifacts)) {
-      toolArtifacts.set(toolCallId, artifact);
-    }
-  }
-  const interactions = metadata[TOOL_INTERACTIONS_METADATA_KEY];
-  if (toolInteractions && isRecord(interactions)) {
-    for (const [toolCallId, value] of Object.entries(interactions)) {
-      const log = readToolInteractionLog(value);
-      if (log) toolInteractions.set(toolCallId, log);
-    }
-  }
-  const approvalResponses = metadata[TOOL_APPROVAL_RESPONSES_METADATA_KEY];
-  if (toolApprovalResponses && isRecord(approvalResponses)) {
-    for (const [approvalId, value] of Object.entries(approvalResponses)) {
-      if (!isRecord(value) || typeof value.approved !== "boolean") continue;
-      const answers = normalizeToolApprovalAnswers(value.answers);
-      toolApprovalResponses.set(approvalId, {
-        approvalId,
-        approved: value.approved,
-        ...(typeof value.optionId === "string" && {
-          optionId: value.optionId,
-        }),
-        ...(typeof value.text === "string" && { text: value.text }),
-        ...(answers && Object.keys(answers).length > 0 && { answers }),
-        ...(typeof value.reason === "string" && { reason: value.reason }),
-      });
-    }
-  }
-  const {
-    [TOOL_ARTIFACTS_METADATA_KEY]: _,
-    [TOOL_INTERACTIONS_METADATA_KEY]: __,
-    [TOOL_APPROVAL_RESPONSES_METADATA_KEY]: ___,
-    ...restMetadata
-  } = metadata;
-  const { metadata: _metadata, ...restMessage } = message;
-  return (
-    Object.keys(restMetadata).length === 0
-      ? restMessage
-      : { ...restMessage, metadata: restMetadata }
-  ) as TMessage;
-};
-
 const encodeContent = <TMessage>(
   storageFormatAdapter: MessageFormatAdapter<TMessage, any>,
   item: MessageFormatItem<TMessage>,
@@ -334,6 +135,10 @@ export const useExternalHistory = <TMessage>(
     const loadHistory = async () => {
       try {
         const repo = await formatAdapter.load();
+        const threadState = runtimeRef.current.thread.getState();
+        if (threadState.isRunning || threadState.messages.length > 0) {
+          return;
+        }
         toolArtifacts?.clear();
         toolInteractions?.clear();
         toolApprovalResponses?.clear();
@@ -394,8 +199,6 @@ export const useExternalHistory = <TMessage>(
 
     const remoteId = optionalThreadListItem()?.getState().remoteId;
     if (!remoteId) {
-      // History loads asynchronously against the thread list item; without a
-      // remote id there is nothing to await, so the flag settles here.
       // eslint-disable-next-line react-hooks/set-state-in-effect
       setHasLoaded(true);
       return aui.subscribe(() => {
@@ -413,6 +216,7 @@ export const useExternalHistory = <TMessage>(
     }
 
     loadedRef.current = true;
+    setHasLoaded(false);
     void loadHistory();
     return undefined;
   }, [

package/src/runtime/useStreamingTiming.ts

@@ -22,7 +22,7 @@ const getTextLength = (
   if (!message?.parts) return 0;
   let len = 0;
   for (const part of message.parts) {
-    if (part.type === "text") len += part.text.length;
+    if (part?.type === "text") len += part.text?.length ?? 0;
   }
   return len;
 };
@@ -35,7 +35,7 @@ const getToolCallCount = (
   if (!message?.parts) return 0;
   let count = 0;
   for (const part of message.parts) {
-    if (isToolUIPart(part)) count++;
+    if (typeof part?.type === "string" && isToolUIPart(part)) count++;
   }
   return count;
 };

package/src/tools/generativeTools.test.ts

@@ -5,7 +5,7 @@ import {
   type ToolkitDefinition,
 } from "@assistant-ui/core/react";
 import { AISDKToolkit } from "./generativeTools";
-import { wrapModelContentEnvelope } from "../converters/modelContentEnvelope";
+import { wrapModelContentEnvelope } from "assistant-stream/internal";
 
 const mocks = vi.hoisted(() => ({
   close: vi.fn(),

package/src/tools/generativeTools.ts

@@ -13,15 +13,13 @@ import type {
   Toolkit,
   ToolkitDefinition,
 } from "@assistant-ui/core/react";
-import { frontendTools, type FrontendTools } from "./frontendTools";
+import { frontendTools, type FrontendTools } from "assistant-stream/ai-sdk";
 import {
   toAISDKContent,
   toAISDKDefaultOutput,
-} from "../converters/toolOutputConversion";
-import {
   unwrapModelContentEnvelope,
   type ModelContentEnvelope,
-} from "../converters/modelContentEnvelope";
+} from "assistant-stream/internal";
 
 const EMPTY_SCHEMA = { type: "object" as const, properties: {} };
 
@@ -156,6 +154,7 @@ export type AISDKToolkitToolsOptions = {
  * // In your route handler:
  * const { tools } = await req.json();
  * streamText({
+ *   abortSignal: req.signal,
  *   model,
  *   messages,
  *   tools: await aiToolkit.tools({ frontend: tools }),
@@ -415,7 +414,7 @@ const toAISDKToModelOutput =
     const { result, modelContent } = unwrapModelContentEnvelope(options.output);
 
     if (modelContent !== undefined) {
-      return toAISDKContent(modelContent);
+      return toAISDKContent(modelContent, { taggedFileData: true });
     }
 
     if (!toModelOutput) {
@@ -426,7 +425,7 @@ const toAISDKToModelOutput =
       ...options,
       output: result,
     });
-    return toAISDKContent(parts);
+    return toAISDKContent(parts, { taggedFileData: true });
   };
 
 const toServerToolSet = (toolkit: ToolkitDefinition): ToolSet =>

package/src/utils/sliceMessagesUntil.test.ts

@@ -31,18 +31,14 @@ describe("sliceMessagesUntil", () => {
     ]);
   });
 
-  it("extends the slice to include trailing assistant messages", () => {
+  it("stops at the target even when assistant messages follow it", () => {
     const messages = [
       msg("u1", "user"),
       msg("a1", "assistant"),
       msg("a2", "assistant"),
       msg("u2", "user"),
     ];
-    expect(sliceMessagesUntil(messages, "u1").map((m) => m.id)).toEqual([
-      "u1",
-      "a1",
-      "a2",
-    ]);
+    expect(sliceMessagesUntil(messages, "u1").map((m) => m.id)).toEqual(["u1"]);
   });
 
   it("returns the whole array when the target is the last message", () => {

package/src/utils/sliceMessagesUntil.ts

@@ -6,15 +6,11 @@ export const sliceMessagesUntil = <UI_MESSAGE extends UIMessage = UIMessage>(
 ) => {
   if (messageId == null) return [];
 
-  let messageIdx = messages.findIndex((m) => m.id === messageId);
+  const messageIdx = messages.findIndex((m) => m.id === messageId);
   if (messageIdx === -1)
     throw new Error(
       `sliceMessagesUntil: Message "${messageId}" not found in AI SDK messages. This is likely an internal bug in assistant-ui.`,
     );
 
-  while (messages[messageIdx + 1]?.role === "assistant") {
-    messageIdx++;
-  }
-
   return messages.slice(0, messageIdx + 1);
 };

package/dist/converters/modelContentEnvelope.d.ts

@@ -1,14 +0,0 @@
-import type { ToolModelContentPart } from "assistant-stream";
-declare const ENVELOPE_KEY = "__aui_modelContent";
-export type ModelContentEnvelope<TResult = unknown> = {
-    readonly [ENVELOPE_KEY]: readonly ToolModelContentPart[];
-    readonly value: TResult;
-};
-export declare function isModelContentEnvelope<TResult = unknown>(value: TResult | ModelContentEnvelope<TResult>): value is ModelContentEnvelope<TResult>;
-export declare function wrapModelContentEnvelope<TResult>(result: TResult, modelContent: readonly ToolModelContentPart[]): ModelContentEnvelope<TResult>;
-export declare function unwrapModelContentEnvelope<TResult>(output: TResult | ModelContentEnvelope<TResult>): {
-    result: TResult;
-    modelContent?: readonly ToolModelContentPart[];
-};
-export {};
-//# sourceMappingURL=modelContentEnvelope.d.ts.map

package/dist/converters/modelContentEnvelope.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"modelContentEnvelope.d.ts","sourceRoot":"","sources":["../../src/converters/modelContentEnvelope.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAE7D,QAAA,MAAM,YAAY,uBAAuB,CAAC;AAE1C,MAAM,MAAM,oBAAoB,CAAC,OAAO,GAAG,OAAO,IAAI;IACpD,QAAQ,CAAC,CAAC,YAAY,CAAC,EAAE,SAAS,oBAAoB,EAAE,CAAC;IACzD,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;CACzB,CAAC;AAEF,wBAAgB,sBAAsB,CAAC,OAAO,GAAG,OAAO,EACtD,KAAK,EAAE,OAAO,GAAG,oBAAoB,CAAC,OAAO,CAAC,GAC7C,KAAK,IAAI,oBAAoB,CAAC,OAAO,CAAC,CAOxC;AAED,wBAAgB,wBAAwB,CAAC,OAAO,EAC9C,MAAM,EAAE,OAAO,EACf,YAAY,EAAE,SAAS,oBAAoB,EAAE,GAC5C,oBAAoB,CAAC,OAAO,CAAC,CAE/B;AAED,wBAAgB,0BAA0B,CAAC,OAAO,EAChD,MAAM,EAAE,OAAO,GAAG,oBAAoB,CAAC,OAAO,CAAC,GAC9C;IACD,MAAM,EAAE,OAAO,CAAC;IAChB,YAAY,CAAC,EAAE,SAAS,oBAAoB,EAAE,CAAC;CAChD,CAQA"}

package/dist/converters/modelContentEnvelope.js

@@ -1,22 +0,0 @@
-//#region src/converters/modelContentEnvelope.ts
-const ENVELOPE_KEY = "__aui_modelContent";
-function isModelContentEnvelope(value) {
-	return value != null && typeof value === "object" && ENVELOPE_KEY in value && Array.isArray(value[ENVELOPE_KEY]);
-}
-function wrapModelContentEnvelope(result, modelContent) {
-	return {
-		[ENVELOPE_KEY]: modelContent,
-		value: result
-	};
-}
-function unwrapModelContentEnvelope(output) {
-	if (isModelContentEnvelope(output)) return {
-		result: output.value,
-		modelContent: output[ENVELOPE_KEY]
-	};
-	return { result: output };
-}
-//#endregion
-export { isModelContentEnvelope, unwrapModelContentEnvelope, wrapModelContentEnvelope };
-
-//# sourceMappingURL=modelContentEnvelope.js.map

package/dist/converters/modelContentEnvelope.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"modelContentEnvelope.js","names":["ToolModelContentPart","ENVELOPE_KEY","ModelContentEnvelope","value","TResult","isModelContentEnvelope","Array","isArray","Record","wrapModelContentEnvelope","result","modelContent","unwrapModelContentEnvelope","output"],"sources":["../../src/converters/modelContentEnvelope.ts"],"sourcesContent":["import type { ToolModelContentPart } from \"assistant-stream\";\n\nconst ENVELOPE_KEY = \"__aui_modelContent\";\n\nexport type ModelContentEnvelope<TResult = unknown> = {\n  readonly [ENVELOPE_KEY]: readonly ToolModelContentPart[];\n  readonly value: TResult;\n};\n\nexport function isModelContentEnvelope<TResult = unknown>(\n  value: TResult | ModelContentEnvelope<TResult>,\n): value is ModelContentEnvelope<TResult> {\n  return (\n    value != null &&\n    typeof value === \"object\" &&\n    ENVELOPE_KEY in value &&\n    Array.isArray((value as Record<string, unknown>)[ENVELOPE_KEY])\n  );\n}\n\nexport function wrapModelContentEnvelope<TResult>(\n  result: TResult,\n  modelContent: readonly ToolModelContentPart[],\n): ModelContentEnvelope<TResult> {\n  return { [ENVELOPE_KEY]: modelContent, value: result };\n}\n\nexport function unwrapModelContentEnvelope<TResult>(\n  output: TResult | ModelContentEnvelope<TResult>,\n): {\n  result: TResult;\n  modelContent?: readonly ToolModelContentPart[];\n} {\n  if (isModelContentEnvelope(output)) {\n    return {\n      result: output.value,\n      modelContent: output[ENVELOPE_KEY],\n    };\n  }\n  return { result: output };\n}\n"],"mappings":";AAEA,MAAMC,eAAe;AAOrB,SAAgBI,uBACdF,OACwC;CACxC,OACEA,SAAS,QACT,OAAOA,UAAU,YACjBF,gBAAgBE,SAChBG,MAAMC,QAASJ,MAAkCF,aAAa;AAElE;AAEA,SAAgBQ,yBACdC,QACAC,cAC+B;CAC/B,OAAO;GAAGV,eAAeU;EAAcR,OAAOO;CAAO;AACvD;AAEA,SAAgBE,2BACdC,QAIA;CACA,IAAIR,uBAAuBQ,MAAM,GAC/B,OAAO;EACLH,QAAQG,OAAOV;EACfQ,cAAcE,OAAOZ;CACvB;CAEF,OAAO,EAAES,QAAQG,OAAO;AAC1B"}

package/dist/converters/toolOutputConversion.d.ts

@@ -1,26 +0,0 @@
-import type { JSONValue } from "ai";
-import type { ToolModelContentPart } from "assistant-stream";
-export declare const toAISDKContent: (parts: readonly ToolModelContentPart[]) => {
-    type: "content";
-    value: ({
-        type: "text";
-        text: string;
-    } | {
-        filename?: string;
-        type: "file";
-        data: {
-            type: "data";
-            data: string;
-        };
-        mediaType: string;
-        text?: never;
-    })[];
-};
-export declare const toAISDKDefaultOutput: (output: unknown) => {
-    type: "text";
-    value: string;
-} | {
-    type: "json";
-    value: JSONValue;
-};
-//# sourceMappingURL=toolOutputConversion.d.ts.map

package/dist/converters/toolOutputConversion.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"toolOutputConversion.d.ts","sourceRoot":"","sources":["../../src/converters/toolOutputConversion.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,IAAI,CAAC;AACpC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAE7D,eAAO,MAAM,cAAc,GAAI,OAAO,SAAS,oBAAoB,EAAE;;;;;;;;;;;;;;;CAiBnE,CAAC;AAEH,eAAO,MAAM,oBAAoB,GAAI,QAAQ,OAAO;;;;;WAGM,SAAS;CAAE,CAAC"}

package/dist/converters/toolOutputConversion.js

@@ -1,31 +0,0 @@
-//#region src/converters/toolOutputConversion.ts
-const toAISDKContent = (parts) => ({
-	type: "content",
-	value: parts.map((part) => {
-		if (part.type === "text") return {
-			type: "text",
-			text: part.text
-		};
-		const mediaType = typeof part.mediaType === "string" ? part.mediaType : "application/octet-stream";
-		return {
-			type: "file",
-			data: {
-				type: "data",
-				data: part.data
-			},
-			mediaType,
-			...part.filename !== void 0 && { filename: part.filename }
-		};
-	})
-});
-const toAISDKDefaultOutput = (output) => typeof output === "string" ? {
-	type: "text",
-	value: output
-} : {
-	type: "json",
-	value: output ?? null
-};
-//#endregion
-export { toAISDKContent, toAISDKDefaultOutput };
-
-//# sourceMappingURL=toolOutputConversion.js.map

package/dist/converters/toolOutputConversion.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"toolOutputConversion.js","names":["JSONValue","ToolModelContentPart","toAISDKContent","parts","type","const","value","map","part","text","mediaType","data","filename","undefined","toAISDKDefaultOutput","output"],"sources":["../../src/converters/toolOutputConversion.ts"],"sourcesContent":["import type { JSONValue } from \"ai\";\nimport type { ToolModelContentPart } from \"assistant-stream\";\n\nexport const toAISDKContent = (parts: readonly ToolModelContentPart[]) => ({\n  type: \"content\" as const,\n  value: parts.map((part) => {\n    if (part.type === \"text\") {\n      return { type: \"text\" as const, text: part.text };\n    }\n    const mediaType =\n      typeof part.mediaType === \"string\"\n        ? part.mediaType\n        : \"application/octet-stream\";\n    return {\n      type: \"file\" as const,\n      data: { type: \"data\" as const, data: part.data },\n      mediaType,\n      ...(part.filename !== undefined && { filename: part.filename }),\n    };\n  }),\n});\n\nexport const toAISDKDefaultOutput = (output: unknown) =>\n  typeof output === \"string\"\n    ? { type: \"text\" as const, value: output }\n    : { type: \"json\" as const, value: (output ?? null) as JSONValue };\n"],"mappings":";AAGA,MAAaE,kBAAkBC,WAA4C;CACzEC,MAAM;CACNE,OAAOH,MAAMI,KAAKC,SAAS;EACzB,IAAIA,KAAKJ,SAAS,QAChB,OAAO;GAAEA,MAAM;GAAiBK,MAAMD,KAAKC;EAAK;EAElD,MAAMC,YACJ,OAAOF,KAAKE,cAAc,WACtBF,KAAKE,YACL;EACN,OAAO;GACLN,MAAM;GACNO,MAAM;IAAEP,MAAM;IAAiBO,MAAMH,KAAKG;GAAK;GAC/CD;GACA,GAAIF,KAAKI,aAAaC,KAAAA,KAAa,EAAED,UAAUJ,KAAKI,SAAS;EAC/D;CACF,CAAC;AACH;AAEA,MAAaE,wBAAwBC,WACnC,OAAOA,WAAW,WACd;CAAEX,MAAM;CAAiBE,OAAOS;AAAO,IACvC;CAAEX,MAAM;CAAiBE,OAAQS,UAAU;AAAmB"}

package/dist/tools/frontendTools.d.ts

@@ -1,30 +0,0 @@
-import { type ToolSet } from "ai";
-import type { ToolJSONSchema } from "assistant-stream";
-/** Frontend tool definitions uploaded by AssistantChatTransport. */
-export type FrontendTools = Record<string, ToolJSONSchema>;
-export declare const defaultToModelOutput: ({ output }: {
-    output: unknown;
-}) => {
-    type: "content";
-    value: ({
-        type: "text";
-        text: string;
-    } | {
-        filename?: string;
-        type: "file";
-        data: {
-            type: "data";
-            data: string;
-        };
-        mediaType: string;
-        text?: never;
-    })[];
-} | {
-    type: "text";
-    value: string;
-} | {
-    type: "json";
-    value: import("ai").JSONValue;
-};
-export declare const frontendTools: (tools: FrontendTools) => ToolSet;
-//# sourceMappingURL=frontendTools.d.ts.map

package/dist/tools/frontendTools.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"frontendTools.d.ts","sourceRoot":"","sources":["../../src/tools/frontendTools.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,KAAK,OAAO,EAAE,MAAM,IAAI,CAAC;AAC9C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAOvD,oEAAoE;AACpE,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;AAE3D,eAAO,MAAM,oBAAoB,GAAI,YAAY;IAAE,MAAM,EAAE,OAAO,CAAA;CAAE;;;;;;;;;;;;;;;;;;;;;CAMnE,CAAC;AAiDF,eAAO,MAAM,aAAa,GAAI,OAAO,aAAa,KAAG,OAgBpD,CAAC"}

package/dist/tools/frontendTools.js

@@ -1,33 +0,0 @@
-import { unwrapModelContentEnvelope } from "../converters/modelContentEnvelope.js";
-import { toAISDKContent, toAISDKDefaultOutput } from "../converters/toolOutputConversion.js";
-import { jsonSchema } from "ai";
-//#region src/tools/frontendTools.ts
-const defaultToModelOutput = ({ output }) => {
-	const { result, modelContent } = unwrapModelContentEnvelope(output);
-	if (modelContent !== void 0) return toAISDKContent(modelContent);
-	return toAISDKDefaultOutput(result);
-};
-const isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-function validateFrontendTool(name, tool) {
-	if (!isPlainObject(tool)) throw new Error(`frontendTools() expected tool "${name}" to be an object with a JSON Schema parameters object.`);
-	if (!isPlainObject(tool.parameters)) throw new Error(`frontendTools() expected tool "${name}" to include a JSON Schema parameters object.`);
-	if (tool.description !== void 0 && typeof tool.description !== "string") throw new Error(`frontendTools() expected tool "${name}" description to be a string.`);
-	if (tool.providerOptions !== void 0 && !isPlainObject(tool.providerOptions)) throw new Error(`frontendTools() expected tool "${name}" providerOptions to be an object.`);
-}
-function validateFrontendTools(tools) {
-	if (!isPlainObject(tools)) throw new Error("frontendTools() expected tools to be an object keyed by tool name.");
-	for (const [name, tool] of Object.entries(tools)) validateFrontendTool(name, tool);
-}
-const frontendTools = (tools) => {
-	validateFrontendTools(tools);
-	return Object.fromEntries(Object.entries(tools).map(([name, tool]) => [name, {
-		...tool.description !== void 0 && { description: tool.description },
-		inputSchema: jsonSchema(tool.parameters),
-		toModelOutput: defaultToModelOutput,
-		...tool.providerOptions && { providerOptions: tool.providerOptions }
-	}]));
-};
-//#endregion
-export { defaultToModelOutput, frontendTools };
-
-//# sourceMappingURL=frontendTools.js.map

package/dist/tools/frontendTools.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"frontendTools.js","names":["jsonSchema","ToolSet","ToolJSONSchema","unwrapModelContentEnvelope","toAISDKContent","toAISDKDefaultOutput","FrontendTools","Record","defaultToModelOutput","output","result","modelContent","undefined","isPlainObject","value","Array","isArray","validateFrontendTool","name","tool","Error","parameters","description","providerOptions","validateFrontendTools","tools","Object","entries","frontendTools","fromEntries","map","inputSchema","toModelOutput"],"sources":["../../src/tools/frontendTools.ts"],"sourcesContent":["import { jsonSchema, type ToolSet } from \"ai\";\nimport type { ToolJSONSchema } from \"assistant-stream\";\nimport { unwrapModelContentEnvelope } from \"../converters/modelContentEnvelope\";\nimport {\n  toAISDKContent,\n  toAISDKDefaultOutput,\n} from \"../converters/toolOutputConversion\";\n\n/** Frontend tool definitions uploaded by AssistantChatTransport. */\nexport type FrontendTools = Record<string, ToolJSONSchema>;\n\nexport const defaultToModelOutput = ({ output }: { output: unknown }) => {\n  const { result, modelContent } = unwrapModelContentEnvelope(output);\n  if (modelContent !== undefined) {\n    return toAISDKContent(modelContent);\n  }\n  return toAISDKDefaultOutput(result);\n};\n\nconst isPlainObject = (value: unknown): value is Record<string, unknown> =>\n  typeof value === \"object\" && value !== null && !Array.isArray(value);\n\nfunction validateFrontendTool(\n  name: string,\n  tool: unknown,\n): asserts tool is ToolJSONSchema {\n  if (!isPlainObject(tool)) {\n    throw new Error(\n      `frontendTools() expected tool \"${name}\" to be an object with a JSON Schema parameters object.`,\n    );\n  }\n\n  if (!isPlainObject(tool.parameters)) {\n    throw new Error(\n      `frontendTools() expected tool \"${name}\" to include a JSON Schema parameters object.`,\n    );\n  }\n\n  if (tool.description !== undefined && typeof tool.description !== \"string\") {\n    throw new Error(\n      `frontendTools() expected tool \"${name}\" description to be a string.`,\n    );\n  }\n\n  if (\n    tool.providerOptions !== undefined &&\n    !isPlainObject(tool.providerOptions)\n  ) {\n    throw new Error(\n      `frontendTools() expected tool \"${name}\" providerOptions to be an object.`,\n    );\n  }\n}\n\nfunction validateFrontendTools(tools: unknown): asserts tools is FrontendTools {\n  if (!isPlainObject(tools)) {\n    throw new Error(\n      \"frontendTools() expected tools to be an object keyed by tool name.\",\n    );\n  }\n\n  for (const [name, tool] of Object.entries(tools)) {\n    validateFrontendTool(name, tool);\n  }\n}\n\nexport const frontendTools = (tools: FrontendTools): ToolSet => {\n  validateFrontendTools(tools);\n\n  return Object.fromEntries(\n    Object.entries(tools).map(([name, tool]) => [\n      name,\n      {\n        ...(tool.description !== undefined && {\n          description: tool.description,\n        }),\n        inputSchema: jsonSchema(tool.parameters),\n        toModelOutput: defaultToModelOutput,\n        ...(tool.providerOptions && { providerOptions: tool.providerOptions }),\n      },\n    ]),\n  ) as ToolSet;\n};\n"],"mappings":";;;;AAWA,MAAaQ,wBAAwB,EAAEC,aAAkC;CACvE,MAAM,EAAEC,QAAQC,iBAAiBR,2BAA2BM,MAAM;CAClE,IAAIE,iBAAiBC,KAAAA,GACnB,OAAOR,eAAeO,YAAY;CAEpC,OAAON,qBAAqBK,MAAM;AACpC;AAEA,MAAMG,iBAAiBC,UACrB,OAAOA,UAAU,YAAYA,UAAU,QAAQ,CAACC,MAAMC,QAAQF,KAAK;AAErE,SAASG,qBACPC,MACAC,MACgC;CAChC,IAAI,CAACN,cAAcM,IAAI,GACrB,MAAM,IAAIC,MACR,kCAAkCF,KAAI,wDACxC;CAGF,IAAI,CAACL,cAAcM,KAAKE,UAAU,GAChC,MAAM,IAAID,MACR,kCAAkCF,KAAI,8CACxC;CAGF,IAAIC,KAAKG,gBAAgBV,KAAAA,KAAa,OAAOO,KAAKG,gBAAgB,UAChE,MAAM,IAAIF,MACR,kCAAkCF,KAAI,8BACxC;CAGF,IACEC,KAAKI,oBAAoBX,KAAAA,KACzB,CAACC,cAAcM,KAAKI,eAAe,GAEnC,MAAM,IAAIH,MACR,kCAAkCF,KAAI,mCACxC;AAEJ;AAEA,SAASM,sBAAsBC,OAAgD;CAC7E,IAAI,CAACZ,cAAcY,KAAK,GACtB,MAAM,IAAIL,MACR,oEACF;CAGF,KAAK,MAAM,CAACF,MAAMC,SAASO,OAAOC,QAAQF,KAAK,GAC7CR,qBAAqBC,MAAMC,IAAI;AAEnC;AAEA,MAAaS,iBAAiBH,UAAkC;CAC9DD,sBAAsBC,KAAK;CAE3B,OAAOC,OAAOG,YACZH,OAAOC,QAAQF,KAAK,CAAC,CAACK,KAAK,CAACZ,MAAMC,UAAU,CAC1CD,MACA;EACE,GAAIC,KAAKG,gBAAgBV,KAAAA,KAAa,EACpCU,aAAaH,KAAKG,YACpB;EACAS,aAAa/B,WAAWmB,KAAKE,UAAU;EACvCW,eAAexB;EACf,GAAIW,KAAKI,mBAAmB,EAAEA,iBAAiBJ,KAAKI,gBAAgB;CACtE,CAAC,CACF,CACH;AACF"}

package/src/converters/modelContentEnvelope.ts

@@ -1,41 +0,0 @@
-import type { ToolModelContentPart } from "assistant-stream";
-
-const ENVELOPE_KEY = "__aui_modelContent";
-
-export type ModelContentEnvelope<TResult = unknown> = {
-  readonly [ENVELOPE_KEY]: readonly ToolModelContentPart[];
-  readonly value: TResult;
-};
-
-export function isModelContentEnvelope<TResult = unknown>(
-  value: TResult | ModelContentEnvelope<TResult>,
-): value is ModelContentEnvelope<TResult> {
-  return (
-    value != null &&
-    typeof value === "object" &&
-    ENVELOPE_KEY in value &&
-    Array.isArray((value as Record<string, unknown>)[ENVELOPE_KEY])
-  );
-}
-
-export function wrapModelContentEnvelope<TResult>(
-  result: TResult,
-  modelContent: readonly ToolModelContentPart[],
-): ModelContentEnvelope<TResult> {
-  return { [ENVELOPE_KEY]: modelContent, value: result };
-}
-
-export function unwrapModelContentEnvelope<TResult>(
-  output: TResult | ModelContentEnvelope<TResult>,
-): {
-  result: TResult;
-  modelContent?: readonly ToolModelContentPart[];
-} {
-  if (isModelContentEnvelope(output)) {
-    return {
-      result: output.value,
-      modelContent: output[ENVELOPE_KEY],
-    };
-  }
-  return { result: output };
-}

package/src/converters/toolOutputConversion.ts

@@ -1,26 +0,0 @@
-import type { JSONValue } from "ai";
-import type { ToolModelContentPart } from "assistant-stream";
-
-export const toAISDKContent = (parts: readonly ToolModelContentPart[]) => ({
-  type: "content" as const,
-  value: parts.map((part) => {
-    if (part.type === "text") {
-      return { type: "text" as const, text: part.text };
-    }
-    const mediaType =
-      typeof part.mediaType === "string"
-        ? part.mediaType
-        : "application/octet-stream";
-    return {
-      type: "file" as const,
-      data: { type: "data" as const, data: part.data },
-      mediaType,
-      ...(part.filename !== undefined && { filename: part.filename }),
-    };
-  }),
-});
-
-export const toAISDKDefaultOutput = (output: unknown) =>
-  typeof output === "string"
-    ? { type: "text" as const, value: output }
-    : { type: "json" as const, value: (output ?? null) as JSONValue };