@assistant-ui/ai-sdk 0.0.10 → 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,6 +22,14 @@ import {
   useCallback,
   useMemo,
 } from "react";
+import {
+  addToolData,
+  collectToolApprovalResponses,
+  collectToolArtifacts,
+  collectToolInteractions,
+  restoreToolData,
+  type StoredToolApprovalResponse,
+} from "./toolHistoryCodec";
 
 export const toExportedMessageRepository = <TMessage>(
   toThreadMessages: (messages: TMessage[]) => ThreadMessage[],
@@ -71,206 +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.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;
-      toolApprovalResponses.set(approvalId, {
-        approvalId,
-        approved: value.approved,
-        ...(typeof value.optionId === "string" && {
-          optionId: value.optionId,
-        }),
-        ...(typeof value.text === "string" && { text: value.text }),
-        ...(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>,
@@ -330,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();
@@ -390,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(() => {
@@ -409,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

@@ -1,7 +1,11 @@
 import { beforeEach, describe, expect, it, vi } from "vitest";
-import { defineMcpToolkit } from "@assistant-ui/core/react";
+import {
+  defineMcpToolkit,
+  defineToolkit,
+  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(),
@@ -130,6 +134,190 @@ describe("AISDKToolkit.tools()", () => {
       supportsDeferredResults: false,
     });
   });
+
+  it("converts unchanged provider and backend schemas once", async () => {
+    const toBackendJSONSchema = vi.fn(() => ({
+      type: "object" as const,
+      properties: {},
+    }));
+    const toProviderJSONSchema = vi.fn(() => ({
+      type: "object" as const,
+      properties: {},
+    }));
+    const toolkitDefinition = {
+      serverTool: {
+        type: "backend",
+        parameters: { toJSONSchema: toBackendJSONSchema },
+        execute: async () => "ok",
+      } as never,
+      providerTool: {
+        type: "provider",
+        providerId: "provider.tool",
+        args: {},
+        parameters: { toJSONSchema: toProviderJSONSchema },
+      } as never,
+    };
+    const firstToolkit = new AISDKToolkit({ toolkit: toolkitDefinition });
+    const secondToolkit = new AISDKToolkit({ toolkit: toolkitDefinition });
+
+    const first = await firstToolkit.tools();
+    const second = await secondToolkit.tools();
+
+    expect(toBackendJSONSchema).toHaveBeenCalledTimes(1);
+    expect(toProviderJSONSchema).toHaveBeenCalledTimes(1);
+    expect(second.serverTool).not.toBe(first.serverTool);
+    expect(second.providerTool).not.toBe(first.providerTool);
+    expect(second.serverTool!.inputSchema).not.toBe(
+      first.serverTool!.inputSchema,
+    );
+    expect(
+      (second.serverTool!.inputSchema as { jsonSchema: unknown }).jsonSchema,
+    ).toBe(
+      (first.serverTool!.inputSchema as { jsonSchema: unknown }).jsonSchema,
+    );
+  });
+
+  it("converts the current frontend tools on every call", async () => {
+    const toolkit = new AISDKToolkit({ toolkit: {} });
+
+    const first = await toolkit.tools({
+      frontend: {
+        firstClientTool: {
+          parameters: { type: "object", properties: {} },
+        },
+      },
+    });
+    const second = await toolkit.tools({
+      frontend: {
+        secondClientTool: {
+          parameters: { type: "object", properties: {} },
+        },
+      },
+    });
+
+    expect(first).toHaveProperty("firstClientTool");
+    expect(first).not.toHaveProperty("secondClientTool");
+    expect(second).toHaveProperty("secondClientTool");
+    expect(second).not.toHaveProperty("firstClientTool");
+  });
+
+  it("does not convert disabled static toolkit entries", async () => {
+    const toJSONSchema = vi.fn(() => ({
+      type: "object" as const,
+      properties: {},
+    }));
+    const toolkit = new AISDKToolkit({
+      toolkit: {
+        disabledServerTool: {
+          type: "backend",
+          disabled: true,
+          parameters: { toJSONSchema },
+        } as never,
+        disabledProviderTool: {
+          type: "provider",
+          disabled: true,
+          providerId: "provider.tool",
+          args: {},
+          parameters: { toJSONSchema },
+        } as never,
+      },
+    });
+
+    await expect(toolkit.tools()).resolves.toEqual({});
+    expect(toJSONSchema).not.toHaveBeenCalled();
+  });
+
+  it("reflects replaced toolkit entries on the next call", async () => {
+    const definition: ToolkitDefinition = {
+      serverTool: {
+        description: "Original tool",
+        parameters: { type: "object" as const, properties: {} },
+        execute: async () => "original",
+      },
+    };
+    const toolkit = new AISDKToolkit({ toolkit: defineToolkit(definition) });
+
+    const first = await toolkit.tools();
+    definition.serverTool = {
+      description: "Replacement tool",
+      parameters: { type: "object" as const, properties: {} },
+      execute: async () => "replacement",
+    };
+
+    const refreshed = await toolkit.tools();
+
+    expect(first.serverTool?.description).toBe("Original tool");
+    expect(refreshed.serverTool?.description).toBe("Replacement tool");
+  });
+
+  it("reconverts a replaced parameters object", async () => {
+    const firstConversion = vi.fn(() => ({
+      type: "object" as const,
+      properties: { first: { type: "string" } },
+    }));
+    const secondConversion = vi.fn(() => ({
+      type: "object" as const,
+      properties: { second: { type: "string" } },
+    }));
+    const definition: ToolkitDefinition = {
+      serverTool: {
+        parameters: { toJSONSchema: firstConversion },
+        execute: async () => "ok",
+      } as never,
+    };
+    const toolkit = new AISDKToolkit({ toolkit: defineToolkit(definition) });
+
+    await toolkit.tools();
+    definition.serverTool!.parameters = {
+      toJSONSchema: secondConversion,
+    } as never;
+    await toolkit.tools();
+
+    expect(firstConversion).toHaveBeenCalledOnce();
+    expect(secondConversion).toHaveBeenCalledOnce();
+  });
+
+  it("reflects in-place toolkit entry changes on the next call", async () => {
+    const definition: ToolkitDefinition = {
+      serverTool: {
+        description: "Original tool",
+        parameters: { type: "object" as const, properties: {} },
+        execute: async () => "ok",
+      },
+    };
+    const toolkit = new AISDKToolkit({ toolkit: defineToolkit(definition) });
+
+    expect((await toolkit.tools()).serverTool?.description).toBe(
+      "Original tool",
+    );
+
+    definition.serverTool!.description = "Updated tool";
+    expect((await toolkit.tools()).serverTool?.description).toBe(
+      "Updated tool",
+    );
+
+    definition.serverTool!.disabled = true;
+    expect(await toolkit.tools()).not.toHaveProperty("serverTool");
+  });
+
+  it("does not share mutable tool entries between calls", async () => {
+    const toolkit = new AISDKToolkit({
+      toolkit: defineToolkit({
+        serverTool: {
+          description: "Original tool",
+          parameters: { type: "object" as const, properties: {} },
+          execute: async () => "ok",
+        },
+      }),
+    });
+
+    const first = await toolkit.tools();
+    first.serverTool!.description = "Changed returned tool";
+
+    const second = await toolkit.tools();
+
+    expect(second.serverTool?.description).toBe("Original tool");
+  });
 });
 
 describe("AISDKToolkit", () => {

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: {} };
 
@@ -76,8 +74,29 @@ const withMcpConnectionTimeout = async <T>(
   }
 };
 
-const parametersToInputSchema = (parameters: Tool["parameters"] | undefined) =>
-  jsonSchema(parameters ? toJSONSchema(parameters) : EMPTY_SCHEMA);
+// Converted schemas are shared by parameter identity and treated as immutable.
+const convertedParameterSchemas = new WeakMap<
+  object,
+  ReturnType<typeof toJSONSchema>
+>();
+
+const getOrConvertParameterSchema = (
+  parameters: NonNullable<Tool["parameters"]>,
+) => {
+  const cached = convertedParameterSchemas.get(parameters);
+  if (cached) return cached;
+
+  const converted = toJSONSchema(parameters);
+  convertedParameterSchemas.set(parameters, converted);
+  return converted;
+};
+
+const parametersToInputSchema = (
+  parameters: Tool["parameters"] | undefined,
+) => {
+  if (!parameters) return jsonSchema(EMPTY_SCHEMA);
+  return jsonSchema(getOrConvertParameterSchema(parameters));
+};
 
 /**
  * @deprecated Options for the deprecated {@link generativeTools}. Use
@@ -135,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 }),
@@ -394,7 +414,7 @@ const toAISDKToModelOutput =
     const { result, modelContent } = unwrapModelContentEnvelope(options.output);
 
     if (modelContent !== undefined) {
-      return toAISDKContent(modelContent);
+      return toAISDKContent(modelContent, { taggedFileData: true });
     }
 
     if (!toModelOutput) {
@@ -405,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"}