entasis 0.11.0 → 0.12.0

package/dist/components/AIThread/threadRenderItems.d.ts

@@ -1,11 +1,33 @@
+import type { AIAskAnswers, AIAskQuestion } from '../AIAskUserQuestion/aiAskUserQuestion.props.js';
 import type { AIToolCall } from '../AITool/aiTool.props.js';
-import type { AIThreadAskUserQuestion, AIThreadItem } from './aiThread.props.js';
-export type AIThreadRenderItem<TMessage extends AIThreadItem = AIThreadItem> = {
+import type { AIFileSource, AIThreadAskUserQuestion, AIThreadAskUserQuestionState, AIThreadItem, AIThreadRole, AIThreadSource } from './aiThread.props.js';
+export { collectAIThreadMessageTools } from './threadTools.js';
+/**
+ * The action bar of one transcript unit. A user message is its own unit; an assistant turn —
+ * reasoning, tools, and text up to the next user message or marker — is one unit with one bar at
+ * its end. `content` joins every text segment of the unit, so copy takes the whole answer, and
+ * `message`/`messageIndex` point at the turn's last assistant message, the retry target.
+ */
+export type AIThreadUnitActions<TMessage extends AIThreadItem = AIThreadItem> = {
+    message: TMessage;
+    messageIndex: number;
+    role: AIThreadRole;
+    content: string;
+    /** The unit is the final assistant turn: nothing but markers follows it. */
+    latest: boolean;
+};
+export type AIThreadRenderItem<TMessage extends AIThreadItem = AIThreadItem> = ({
     kind: 'message';
     key: string;
     message: TMessage;
     messageIndex: number;
     content?: string;
+    /** Files from AI SDK `file` parts, shown with this segment. */
+    files?: readonly AIFileSource[];
+    /** The unit's action bar when this segment ends its unit; `false` when another one does. */
+    actions?: AIThreadUnitActions<TMessage> | false;
+    /** The segment is the end of a reply that is still streaming. */
+    streaming?: boolean;
 } | {
     kind: 'marker';
     key: string;
@@ -19,11 +41,60 @@ export type AIThreadRenderItem<TMessage extends AIThreadItem = AIThreadItem> = {
     message: TMessage;
     messageIndex: number;
     tools: AIToolCall[];
+} | {
+    kind: 'reasoning';
+    key: string;
+    message: TMessage;
+    messageIndex: number;
+    content: string;
+    streaming: boolean;
+} | {
+    kind: 'question-summary';
+    key: string;
+    message: TMessage;
+    messageIndex: number;
+    questions: readonly AIAskQuestion[];
+    value: AIAskAnswers;
+    title?: string;
+} | {
+    kind: 'sources';
+    key: string;
+    message: TMessage;
+    messageIndex: number;
+    sources: AIThreadSource[];
+} | {
+    /** A unit's action bar on its own row, when the unit ends with tools or reasoning. */
+    kind: 'actions';
+    key: string;
+    message: TMessage;
+    messageIndex: number;
+    actions: AIThreadUnitActions<TMessage>;
+} | {
+    /** Placeholder assistant row while a reply to the last user turn has not started. */
+    kind: 'pending';
+    key: string;
+} | {
+    /** The conversation error, shown where the reply failed. */
+    kind: 'error';
+    key: string;
+}) & {
+    /**
+     * The key of the transcript unit the row belongs to (a user message, an assistant turn or a
+     * marker). Rows of one unit share it; status rows (pending, error) have none.
+     */
+    unit?: string;
 };
 export type DeriveAIThreadRenderItemsOptions<TMessage extends AIThreadItem> = {
     getMessageKey: (message: TMessage, index: number) => string;
     activeQuestion?: AIThreadAskUserQuestion<TMessage> | null;
     splitMessageParts?: boolean;
+    /** Local ask-user-question resolutions, by request key, that the messages may not show yet. */
+    questionStates?: Record<string, AIThreadAskUserQuestionState | undefined>;
+    /** Submitted ask-user-question values by request key. */
+    questionValues?: Record<string, AIAskAnswers | undefined>;
+    /** An assistant reply is streaming: adds the pending row or marks the streaming segment. */
+    streaming?: boolean;
+    /** Appends the error row at the end of the transcript. */
+    error?: boolean;
 };
 export declare function deriveAIThreadRenderItems<TMessage extends AIThreadItem>(messages: readonly TMessage[], options: DeriveAIThreadRenderItemsOptions<TMessage>): AIThreadRenderItem<TMessage>[];
-export declare function collectAIThreadMessageTools(message: AIThreadItem, _messageIndex: number, messageKey: string, includePartTools?: boolean): AIToolCall[];

package/dist/components/AIThread/threadRenderItems.js

@@ -1,3 +1,6 @@
+import { isAskUserQuestionTool, toAskUserQuestionRequest } from './threadAskUserQuestion.js';
+import { collectAIThreadMessageTools, normalizeToolCall, toolFromPart } from './threadTools.js';
+export { collectAIThreadMessageTools } from './threadTools.js';
 export function deriveAIThreadRenderItems(messages, options) {
     const items = [];
     let pendingTools;
@@ -13,8 +16,15 @@ export function deriveAIThreadRenderItems(messages, options) {
         });
         pendingTools = undefined;
     }
-    function pushMessage(message, messageIndex, key, content) {
-        items.push({ kind: 'message', key, message, messageIndex, content });
+    function pushMessage(message, messageIndex, key, content, files) {
+        items.push({
+            kind: 'message',
+            key,
+            message,
+            messageIndex,
+            content,
+            ...(files?.length ? { files } : {})
+        });
     }
     function pushMarker(message, messageIndex, key, content, variant) {
         items.push({ kind: 'marker', key, message, messageIndex, content, variant });
@@ -25,6 +35,25 @@ export function deriveAIThreadRenderItems(messages, options) {
             flushTools();
             return;
         }
+        const question = isAskUserQuestionTool(normalizedTool)
+            ? toAskUserQuestionRequest(message, messageIndex, messageKey, normalizedTool, toolIndex, options.questionStates ?? {})
+            : undefined;
+        // An answered question keeps a compact question → answer record in the transcript instead of
+        // a raw tool row; a dismissed one settles as a cancelled call rather than spinning.
+        if (question?.state === 'completed') {
+            flushTools();
+            items.push({
+                kind: 'question-summary',
+                key: `${messageKey}:question-${toolIndex}`,
+                message,
+                messageIndex,
+                questions: question.questions,
+                value: options.questionValues?.[question.key] ?? question.value ?? {},
+                title: question.title
+            });
+            return;
+        }
+        const groupedTool = question?.state === 'discarded' ? { ...normalizedTool, status: 'cancelled' } : normalizedTool;
         pendingTools ??= {
             firstKey: `${messageKey}:${toolIndex}`,
             lastKey: `${messageKey}:${toolIndex}`,
@@ -33,7 +62,7 @@ export function deriveAIThreadRenderItems(messages, options) {
             tools: []
         };
         pendingTools.lastKey = `${messageKey}:${toolIndex}`;
-        pendingTools.tools.push(normalizedTool);
+        pendingTools.tools.push(groupedTool);
     }
     for (const [messageIndex, message] of messages.entries()) {
         const messageKey = options.getMessageKey(message, messageIndex);
@@ -43,14 +72,28 @@ export function deriveAIThreadRenderItems(messages, options) {
             continue;
         }
         if (options.splitMessageParts !== false && message.parts?.length) {
+            let files = messageFileParts(message.parts, messageKey);
+            // Files may be spliced in at the start of this message below, so a tool group still open
+            // from the previous message closes first and keeps its place before them.
+            if (files.length > 0)
+                flushTools();
+            const firstItemIndex = items.length;
+            let sources;
             let renderedPart = false;
+            const takeFiles = () => {
+                const taken = files;
+                files = undefined;
+                return taken;
+            };
             const hasTextPart = message.parts.some((part) => part.type === 'text' && Boolean(part.text));
             if (!hasTextPart && hasMessageContent(message)) {
                 flushTools();
-                pushMessage(message, messageIndex, `${messageKey}:content`);
+                pushMessage(message, messageIndex, `${messageKey}:content`, undefined, takeFiles());
                 renderedPart = true;
             }
             let toolIndex = 0;
+            const lastPartIndex = message.parts.length - 1;
+            const isLastMessage = messageIndex === messages.length - 1;
             for (const [partIndex, part] of message.parts.entries()) {
                 const partKey = `${messageKey}:part-${partIndex}`;
                 const tool = toolFromPart(part, partKey);
@@ -68,10 +111,62 @@ export function deriveAIThreadRenderItems(messages, options) {
                 }
                 if (part.type === 'text' && part.text) {
                     flushTools();
-                    pushMessage(message, messageIndex, partKey, part.text);
+                    pushMessage(message, messageIndex, partKey, part.text, takeFiles());
+                    renderedPart = true;
+                    continue;
+                }
+                if (part.type === 'reasoning' && typeof part.text === 'string' && part.text) {
+                    flushTools();
+                    items.push({
+                        kind: 'reasoning',
+                        key: partKey,
+                        message,
+                        messageIndex,
+                        content: part.text,
+                        // AI SDK marks a reasoning part `streaming` until it is done; without a state, the
+                        // last part of a streaming reply is the one still being written.
+                        streaming: part.state === 'streaming' ||
+                            (part.state === undefined &&
+                                Boolean(options.streaming) &&
+                                isLastMessage &&
+                                partIndex === lastPartIndex)
+                    });
+                    renderedPart = true;
+                    continue;
+                }
+                const source = sourceFromPart(part, partKey);
+                if (source) {
+                    if (sources) {
+                        sources.push(source);
+                    }
+                    else {
+                        flushTools();
+                        sources = [source];
+                        items.push({
+                            kind: 'sources',
+                            key: `${partKey}:sources`,
+                            message,
+                            messageIndex,
+                            sources
+                        });
+                    }
                     renderedPart = true;
                 }
             }
+            // Files with no text segment to sit on get a segment of their own, first in the message,
+            // where an uploaded file sits above its prompt.
+            const leftoverFiles = takeFiles();
+            if (leftoverFiles?.length) {
+                items.splice(firstItemIndex, 0, {
+                    kind: 'message',
+                    key: `${messageKey}:files`,
+                    message,
+                    messageIndex,
+                    content: '',
+                    files: leftoverFiles
+                });
+                renderedPart = true;
+            }
             if (renderedPart)
                 continue;
         }
@@ -86,95 +181,188 @@ export function deriveAIThreadRenderItems(messages, options) {
             }
             continue;
         }
+        // An assistant message with nothing visible is not a row: an AI SDK message whose parts are
+        // only `step-start`, `data-*` or empty text, or the empty placeholder a client adds before the
+        // first token. While the reply streams, the pending row stays in its place.
+        if (isEmptyAssistantMessage(message) &&
+            (message.parts !== undefined || (options.streaming && messageIndex === messages.length - 1))) {
+            continue;
+        }
         flushTools();
         pushMessage(message, messageIndex, `${messageKey}:message`);
     }
     flushTools();
-    return items;
+    const withActions = assignUnitActions(items, options.streaming === true);
+    return appendStatusItems(withActions, options);
 }
-export function collectAIThreadMessageTools(message, _messageIndex, messageKey, includePartTools = true) {
-    const partTools = (includePartTools ? (message.parts ?? []) : []).flatMap((part, index) => {
-        const tool = toolFromPart(part, `${messageKey}:part-${index}`);
-        return tool ? [tool] : [];
-    });
-    if (partTools.length > 0)
-        return partTools;
-    if (message.tools?.length) {
-        return message.tools.map((tool, index) => normalizeToolCall(tool, `${messageKey}:tool-${index}`));
+function itemRole(item) {
+    return item.message.role ?? 'assistant';
+}
+/**
+ * Splits the transcript into units and gives each one action bar. A user (or system) message is
+ * one unit; an assistant turn runs from the first non-user item to the next user message or
+ * marker. The bar belongs to text answers: it sits on the turn's last text segment when that
+ * segment holds the whole text, otherwise on an `actions` row right after it, never under the
+ * thinking or tool rows that follow. An assistant turn without text (only thinking or tool calls)
+ * has no bar, and neither does the final assistant turn of a streaming reply.
+ * Like markers, system notices do not end the latest turn: only a user message does.
+ */
+function assignUnitActions(items, streaming) {
+    const units = [];
+    for (const [index, item] of items.entries()) {
+        const previous = units.at(-1);
+        if (item.kind === 'marker') {
+            units.push({ kind: 'none', start: index, end: index });
+            continue;
+        }
+        const role = itemRole(item);
+        if (item.kind === 'message' && (role === 'user' || role === 'system')) {
+            const kind = role === 'user' ? 'user' : 'system';
+            // Several text parts of one user message stay one unit.
+            const previousItem = previous ? items[previous.end] : undefined;
+            if (previous?.kind === kind &&
+                previousItem?.kind === 'message' &&
+                previousItem.messageIndex === item.messageIndex) {
+                previous.end = index;
+            }
+            else {
+                units.push({ kind, start: index, end: index });
+            }
+            continue;
+        }
+        if (previous?.kind === 'assistant')
+            previous.end = index;
+        else
+            units.push({ kind: 'assistant', start: index, end: index });
     }
-    if (message.tool)
-        return [normalizeToolCall(message.tool, messageKey)];
-    if (message.role === 'tool' || message.type === 'tool') {
-        return [
-            {
-                id: message.id ?? messageKey,
-                name: message.toolName ?? message.name,
-                title: message.name,
-                status: messageToolStatus(message),
-                input: message.input,
-                output: message.output !== undefined ? message.output : message.content,
-                error: message.error
+    const lastUserUnit = units.findLastIndex((unit) => unit.kind === 'user');
+    const lastAssistantUnit = units.findLastIndex((unit) => unit.kind === 'assistant');
+    const result = [];
+    for (const [unitIndex, unit] of units.entries()) {
+        const unitItems = items.slice(unit.start, unit.end + 1);
+        const unitKey = unitItems[0].key;
+        if (unit.kind === 'none') {
+            result.push(...unitItems.map((item) => ({ ...item, unit: unitKey })));
+            continue;
+        }
+        const latest = unit.kind === 'assistant' && unitIndex === lastAssistantUnit && unitIndex > lastUserUnit;
+        const messageItems = unitItems.filter((item) => item.kind === 'message');
+        const content = messageItems
+            .map((item) => item.content ?? item.message.content ?? '')
+            .filter(Boolean)
+            .join('\n\n');
+        const last = unitItems.at(-1);
+        // The row the bar follows: an assistant turn's last text segment, a user message's last item.
+        const anchor = unit.kind === 'assistant'
+            ? messageItems.findLast((item) => (item.content ?? item.message.content ?? '').trim())
+            : last;
+        const target = messageItems.findLast((item) => itemRole(item) === 'assistant') ??
+            messageItems.at(-1) ??
+            last;
+        const actions = {
+            message: target.message,
+            messageIndex: target.messageIndex,
+            role: unit.kind === 'assistant' ? 'assistant' : itemRole(target),
+            content,
+            latest
+        };
+        const replying = streaming && latest;
+        const showBar = !replying && anchor !== undefined;
+        // The bar rides on the anchor only when it holds the whole unit's text (and is the retry
+        // target), so its copy and retry act on the unit; otherwise it gets a row right after it.
+        const barOnAnchor = anchor?.kind === 'message' &&
+            anchor === target &&
+            (anchor.content ?? anchor.message.content ?? '') === content;
+        for (const item of unitItems) {
+            const isLast = item === last;
+            if (item.kind !== 'message') {
+                result.push({ ...item, unit: unitKey });
+            }
+            else {
+                result.push({
+                    ...item,
+                    unit: unitKey,
+                    actions: showBar && barOnAnchor && item === anchor ? actions : false,
+                    ...(replying && isLast ? { streaming: true } : {})
+                });
+            }
+            if (showBar && !barOnAnchor && item === anchor) {
+                result.push({
+                    kind: 'actions',
+                    key: `${item.key}:actions`,
+                    message: actions.message,
+                    messageIndex: actions.messageIndex,
+                    actions,
+                    unit: unitKey
+                });
             }
-        ];
+        }
+    }
+    return result;
+}
+function appendStatusItems(items, options) {
+    const result = items;
+    if (options.error) {
+        result.push({ kind: 'error', key: `error:${items.at(-1)?.key ?? 'empty'}` });
+        return result;
     }
-    return [];
+    if (!options.streaming)
+        return result;
+    const lastContent = items.findLast((item) => item.kind !== 'marker');
+    if (lastContent?.kind === 'message' && itemRole(lastContent) === 'user') {
+        result.push({ kind: 'pending', key: `pending:${lastContent.key}` });
+    }
+    return result;
 }
 function hasMessageContent(message) {
     return message.content !== undefined && message.content !== '';
 }
-function normalizeToolCall(tool, fallbackId) {
-    return { ...tool, id: tool.id ?? fallbackId, status: toolStatus(tool) };
+function isEmptyAssistantMessage(message) {
+    return ((message.role ?? 'assistant') === 'assistant' &&
+        !hasMessageContent(message) &&
+        !message.files?.length &&
+        !message.attachments?.length);
 }
-function toolStatus(tool) {
-    if (tool.status)
-        return tool.status;
-    if (tool.error !== undefined)
-        return 'error';
-    if (tool.output !== undefined || tool.result !== undefined)
-        return 'success';
-    return undefined;
+const SAFE_URL = /^(?:https?:|blob:|data:image\/)/i;
+function messageFileParts(parts, messageKey) {
+    return parts.flatMap((part, index) => {
+        if (part.type !== 'file')
+            return [];
+        const url = typeof part.url === 'string' && SAFE_URL.test(part.url) ? part.url : undefined;
+        const type = typeof part.mediaType === 'string' ? part.mediaType : undefined;
+        const name = (typeof part.filename === 'string' && part.filename) ||
+            (url && !url.startsWith('data:') ? (url.split(/[?#]/)[0]?.split('/').at(-1) ?? '') : '') ||
+            type ||
+            'file';
+        return [{ id: `${messageKey}:part-${index}`, name, type, previewUrl: url }];
+    });
 }
-function messageToolStatus(message) {
-    if (message.status)
-        return message.status;
-    if (message.error !== undefined)
-        return 'error';
-    if (message.output !== undefined || message.content !== undefined)
-        return 'success';
+function sourceFromPart(part, key) {
+    if (part.type === 'source-url' && typeof part.url === 'string') {
+        const url = /^https?:/i.test(part.url) ? part.url : undefined;
+        return {
+            id: typeof part.sourceId === 'string' ? part.sourceId : key,
+            url,
+            title: (typeof part.title === 'string' && part.title) || hostname(part.url) || part.url
+        };
+    }
+    if (part.type === 'source-document') {
+        return {
+            id: typeof part.sourceId === 'string' ? part.sourceId : key,
+            title: (typeof part.title === 'string' && part.title) ||
+                (typeof part.filename === 'string' && part.filename) ||
+                (typeof part.mediaType === 'string' ? part.mediaType : key)
+        };
+    }
     return undefined;
 }
-function toolFromPart(part, fallbackId) {
-    if (part.type === 'tool' && part.tool)
-        return normalizeToolCall(part.tool, fallbackId);
-    if (!isToolPart(part))
+function hostname(url) {
+    try {
+        return new URL(url).hostname.replace(/^www\./, '');
+    }
+    catch {
         return undefined;
-    const name = part.toolName ?? (part.type.startsWith('tool-') ? part.type.slice(5) : undefined);
-    return normalizeToolCall({
-        id: part.toolCallId ?? fallbackId,
-        name,
-        title: name,
-        status: toolPartStatus(part.state),
-        input: part.input,
-        output: part.output,
-        structuredContent: part.structuredContent,
-        result: part.result,
-        error: part.errorText ?? part.error,
-        _meta: part._meta
-    }, fallbackId);
-}
-function isToolPart(part) {
-    return part.type === 'dynamic-tool' || part.type?.startsWith('tool-') === true;
-}
-function toolPartStatus(state) {
-    if (state === 'output-error')
-        return 'error';
-    if (state === 'output-available')
-        return 'success';
-    if (state === 'input-streaming')
-        return 'streaming';
-    if (state === 'input-available')
-        return 'running';
-    return undefined;
+    }
 }
 function isQuestionTool(request, messageIndex, tool, toolIndex) {
     if (!request || (request.state !== undefined && request.state !== 'pending'))

package/dist/components/AIThread/threadScrollController.d.ts

@@ -1,23 +1,15 @@
 import type { Virtualizer } from '@tanstack/svelte-virtual';
 import type { AIThreadScrollBehavior } from './aiThread.props.js';
 export declare class AIThreadScrollController {
-    private readonly getScrollBehavior;
-    private shouldSmoothAppendAdjustment;
-    private smoothAppendResetFrame;
     private appendFollowFrame;
     private prependSettleFrame;
-    constructor(getScrollBehavior: () => AIThreadScrollBehavior);
     scrollToFn: (offset: number, { adjustments, behavior }: {
         adjustments?: number;
         behavior?: AIThreadScrollBehavior;
     }, instance: Virtualizer<HTMLDivElement, HTMLElement>) => void;
-    prepareSmoothAppendAdjustment(enabled: boolean): void;
-    scheduleSmoothAppendAdjustmentReset(): void;
     settlePrependedItems(scrollToTarget: () => void, sync: () => void): void;
     watchAppendFollowEnd(isAtEnd: () => boolean, onEnd: () => void): void;
     destroy(): void;
-    private resolveScrollBehavior;
-    private cancelSmoothAppendReset;
     private cancelAppendFollow;
     private cancelPrependSettle;
 }

package/dist/components/AIThread/threadScrollController.js

@@ -1,38 +1,17 @@
 export class AIThreadScrollController {
-    getScrollBehavior;
-    shouldSmoothAppendAdjustment = false;
-    smoothAppendResetFrame;
     appendFollowFrame;
     prependSettleFrame;
-    constructor(getScrollBehavior) {
-        this.getScrollBehavior = getScrollBehavior;
-    }
     scrollToFn = (offset, { adjustments = 0, behavior }, instance) => {
         const scrollElement = instance.scrollElement;
         if (!scrollElement)
             return;
         const targetOffset = offset + adjustments;
-        const resolvedBehavior = this.resolveScrollBehavior(behavior);
-        if (!resolvedBehavior || resolvedBehavior === 'auto' || resolvedBehavior === 'instant') {
+        if (!behavior || behavior === 'auto' || behavior === 'instant') {
             scrollElement.scrollTop = targetOffset;
             return;
         }
-        scrollElement.scrollTo({ top: targetOffset, behavior: resolvedBehavior });
+        scrollElement.scrollTo({ top: targetOffset, behavior });
     };
-    prepareSmoothAppendAdjustment(enabled) {
-        this.shouldSmoothAppendAdjustment = enabled;
-    }
-    scheduleSmoothAppendAdjustmentReset() {
-        if (this.smoothAppendResetFrame !== undefined) {
-            cancelAnimationFrame(this.smoothAppendResetFrame);
-        }
-        this.smoothAppendResetFrame = requestAnimationFrame(() => {
-            this.smoothAppendResetFrame = requestAnimationFrame(() => {
-                this.shouldSmoothAppendAdjustment = false;
-                this.smoothAppendResetFrame = undefined;
-            });
-        });
-    }
     settlePrependedItems(scrollToTarget, sync) {
         this.cancelPrependSettle();
         scrollToTarget();
@@ -61,25 +40,9 @@ export class AIThreadScrollController {
         this.appendFollowFrame = requestAnimationFrame(check);
     }
     destroy() {
-        this.cancelSmoothAppendReset();
         this.cancelAppendFollow();
         this.cancelPrependSettle();
     }
-    resolveScrollBehavior(behavior) {
-        if (this.shouldSmoothAppendAdjustment &&
-            behavior === 'auto' &&
-            this.getScrollBehavior() === 'smooth') {
-            this.shouldSmoothAppendAdjustment = false;
-            return 'smooth';
-        }
-        return behavior;
-    }
-    cancelSmoothAppendReset() {
-        if (this.smoothAppendResetFrame === undefined)
-            return;
-        cancelAnimationFrame(this.smoothAppendResetFrame);
-        this.smoothAppendResetFrame = undefined;
-    }
     cancelAppendFollow() {
         if (this.appendFollowFrame === undefined)
             return;

package/dist/components/AIThread/threadTools.d.ts

@@ -0,0 +1,11 @@
+import type { AIToolCall } from '../AITool/aiTool.props.js';
+import type { AIThreadItem, AIThreadPart, AIThreadToolPart } from './aiThread.props.js';
+/**
+ * Every tool call a transcript message carries, in order: AI SDK tool parts and `{ type: 'tool' }`
+ * parts first, then `tools`, `tool`, or a tool-shaped message. Shared by the render-item
+ * derivation and ask-user-question detection so both see the same calls with the same ids.
+ */
+export declare function collectAIThreadMessageTools(message: AIThreadItem, _messageIndex: number, messageKey: string, includePartTools?: boolean): AIToolCall[];
+export declare function normalizeToolCall(tool: AIToolCall, fallbackId: string): AIToolCall;
+export declare function toolFromPart(part: AIThreadPart, fallbackId: string): AIToolCall | undefined;
+export declare function isToolPart(part: AIThreadPart): part is AIThreadToolPart;