glirastes 0.3.2 → 0.5.0

package/dist/cjs/react/utils/followup-suggestions.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractTrailingFollowupSuggestions = extractTrailingFollowupSuggestions;
+const TRAILING_HEADING = /(?:^|\n)[ \t]{0,3}(?:\*\*|__)?(?:Vorschläge|Suggestions):?(?:\*\*|__)?[ \t]*\n([\s\S]+)$/i;
+const LIST_ITEM = /^[ \t]*(?:[-*+]|\d+[.)])[ \t]+(.+?)[ \t]*$/;
+const MAX_FALLBACK_SUGGESTIONS = 5;
+/**
+ * Extract a strictly delimited, trailing Markdown follow-up list.
+ *
+ * This is a presentation fallback for models that write suggestions instead
+ * of calling `suggest_followups`. Unmatched text is returned unchanged.
+ */
+function extractTrailingFollowupSuggestions(text, limit = MAX_FALLBACK_SUGGESTIONS) {
+    const match = TRAILING_HEADING.exec(text);
+    if (!match || match.index === undefined) {
+        return { text, suggestions: [] };
+    }
+    const lines = match[1].trimEnd().split('\n');
+    if (lines.length < 1 || lines.length > MAX_FALLBACK_SUGGESTIONS) {
+        return { text, suggestions: [] };
+    }
+    const parsed = [];
+    for (const line of lines) {
+        const item = LIST_ITEM.exec(line);
+        if (!item || item[1].trim().length === 0) {
+            return { text, suggestions: [] };
+        }
+        parsed.push(item[1].trim());
+    }
+    const boundedLimit = Math.max(1, Math.min(MAX_FALLBACK_SUGGESTIONS, limit));
+    const suggestions = Array.from(new Set(parsed)).slice(0, boundedLimit);
+    if (suggestions.length === 0) {
+        return { text, suggestions: [] };
+    }
+    return {
+        text: text.slice(0, match.index).trimEnd(),
+        suggestions,
+    };
+}

package/dist/cjs/react/utils/local-session-store.d.ts

@@ -0,0 +1,30 @@
+import type { SessionConfig } from '../types.js';
+type KeyValueStorage = Pick<Storage, 'getItem' | 'setItem' | 'removeItem'>;
+export interface LocalSessionStoreOptions {
+    /**
+     * Prefix of every key this store writes. Include the signed-in user, so two
+     * people on one browser never see each other's chats, e.g. `myapp:${userId}`.
+     */
+    storageKey: string;
+    /** Defaults to `localStorage`; `null` keeps nothing (one unsaved chat). */
+    storage?: KeyValueStorage | null;
+    /** Name of a chat nobody has written in yet. Default: "New chat". */
+    newTitle?: string;
+    /** Chats kept; the one used longest ago goes first. Default: 30. */
+    maxSessions?: number;
+    now?: () => number;
+    createId?: () => string;
+}
+/**
+ * Several chats per user, kept in the browser: pass the result as `session`
+ * to the chat provider and the session switcher lists them, with new, rename
+ * and delete. Nothing leaves the browser, and a chat is gone when its storage
+ * is cleared; an app that needs chats on every device supplies its own
+ * `SessionConfig` backed by its server instead.
+ *
+ *   <VercelAiChat endpoint="/api/chat" session={createLocalSessionStore({ storageKey: `myapp:${userId}` })} />
+ *
+ * Create it once per user (module scope or `useMemo`), not on every render.
+ */
+export declare function createLocalSessionStore(options: LocalSessionStoreOptions): SessionConfig;
+export {};

package/dist/cjs/react/utils/local-session-store.js

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLocalSessionStore = createLocalSessionStore;
+const sanitize_stored_messages_js_1 = require("./sanitize-stored-messages.js");
+const DEFAULT_ID = 'default';
+const TITLE_LENGTH = 40;
+function browserStorage() {
+    try {
+        return typeof localStorage === 'undefined' ? null : localStorage;
+    }
+    catch {
+        return null; // storage blocked
+    }
+}
+function randomId() {
+    return typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function'
+        ? crypto.randomUUID()
+        : `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+function textOf(message) {
+    const parts = message.parts;
+    if (Array.isArray(parts)) {
+        return parts
+            .filter((part) => typeof part === 'object' && part !== null && part.type === 'text'
+            && typeof part.text === 'string')
+            .map((part) => part.text)
+            .join(' ');
+    }
+    const content = message.content;
+    return typeof content === 'string' ? content : '';
+}
+/** The first question of a chat, cut at a word, as its name. */
+function titleFrom(messages) {
+    const first = messages.find((message) => message.role === 'user');
+    const text = first ? textOf(first).replace(/\s+/g, ' ').trim() : '';
+    if (text === '')
+        return null;
+    if (text.length <= TITLE_LENGTH)
+        return text;
+    const head = text.slice(0, TITLE_LENGTH + 1);
+    const cut = head.lastIndexOf(' ');
+    return `${head.slice(0, cut > 0 ? cut : TITLE_LENGTH)}…`;
+}
+function isSummary(value) {
+    const entry = value;
+    return typeof entry === 'object' && entry !== null
+        && typeof entry.id === 'string' && entry.id !== ''
+        && typeof entry.title === 'string'
+        && typeof entry.createdAt === 'number' && typeof entry.updatedAt === 'number';
+}
+/**
+ * Several chats per user, kept in the browser: pass the result as `session`
+ * to the chat provider and the session switcher lists them, with new, rename
+ * and delete. Nothing leaves the browser, and a chat is gone when its storage
+ * is cleared; an app that needs chats on every device supplies its own
+ * `SessionConfig` backed by its server instead.
+ *
+ *   <VercelAiChat endpoint="/api/chat" session={createLocalSessionStore({ storageKey: `myapp:${userId}` })} />
+ *
+ * Create it once per user (module scope or `useMemo`), not on every render.
+ */
+function createLocalSessionStore(options) {
+    const storage = options.storage === undefined ? browserStorage() : options.storage;
+    const newTitle = options.newTitle ?? 'New chat';
+    const maxSessions = Math.max(1, options.maxSessions ?? 30);
+    const now = options.now ?? (() => Date.now());
+    const createId = options.createId ?? randomId;
+    const indexKey = `${options.storageKey}:sessions`;
+    const messagesKey = (id) => `${options.storageKey}:messages:${id}`;
+    const read = (key) => {
+        try {
+            const raw = storage?.getItem(key);
+            return raw == null ? null : JSON.parse(raw);
+        }
+        catch {
+            return null; // unreadable or not JSON
+        }
+    };
+    const write = (key, value) => {
+        try {
+            storage?.setItem(key, JSON.stringify(value));
+        }
+        catch {
+            // storage full or blocked: the chat goes on unsaved
+        }
+    };
+    const drop = (key) => {
+        try {
+            storage?.removeItem(key);
+        }
+        catch {
+            // nothing to remove
+        }
+    };
+    const fresh = (id, title = newTitle) => {
+        const at = now();
+        return { id, title, createdAt: at, updatedAt: at, messageCount: 0 };
+    };
+    const sorted = (entries) => [...entries].sort((left, right) => right.updatedAt - left.updatedAt || right.createdAt - left.createdAt);
+    /** The stored chats, newest first; always at least the default one. */
+    const entries = () => {
+        const stored = read(indexKey);
+        const valid = Array.isArray(stored) ? stored.filter(isSummary) : [];
+        return valid.length > 0 ? sorted(valid) : [fresh(DEFAULT_ID)];
+    };
+    const persist = (list) => {
+        const ordered = sorted(list);
+        for (const removed of ordered.slice(maxSessions))
+            drop(messagesKey(removed.id));
+        const kept = ordered.slice(0, maxSessions);
+        write(indexKey, kept);
+        return kept;
+    };
+    const summary = ({ named: _named, ...entry }) => entry;
+    return {
+        async list() {
+            return persist(entries()).map(summary);
+        },
+        async create(opts) {
+            const entry = { ...fresh(createId(), opts?.title?.trim() || newTitle), ...(opts?.title?.trim() ? { named: true } : {}) };
+            persist([...entries(), entry]);
+            return summary(entry);
+        },
+        async remove(conversationId) {
+            drop(messagesKey(conversationId));
+            const remaining = entries().filter((entry) => entry.id !== conversationId);
+            if (remaining.length === 0)
+                drop(indexKey);
+            else
+                persist(remaining);
+        },
+        async rename(conversationId, title) {
+            const next = title.trim();
+            if (next === '')
+                return;
+            persist(entries().map((entry) => (entry.id === conversationId ? { ...entry, title: next, named: true } : entry)));
+        },
+        save(conversationId, messages) {
+            if (!storage)
+                return;
+            const list = entries();
+            const existing = list.find((entry) => entry.id === conversationId) ?? fresh(conversationId);
+            const derived = existing.named ? null : titleFrom(messages);
+            const entry = {
+                ...existing,
+                title: derived ?? existing.title,
+                updatedAt: now(),
+                messageCount: messages.length,
+            };
+            write(messagesKey(conversationId), messages);
+            persist([...list.filter((other) => other.id !== conversationId), entry]);
+        },
+        load(conversationId) {
+            const stored = read(messagesKey(conversationId));
+            if (!Array.isArray(stored) || stored.length === 0)
+                return null;
+            return (0, sanitize_stored_messages_js_1.sanitizeStoredMessages)(stored);
+        },
+        clear(conversationId) {
+            const id = conversationId ?? DEFAULT_ID;
+            drop(messagesKey(id));
+            persist(entries().map((entry) => (entry.id === id ? { ...entry, messageCount: 0 } : entry)));
+        },
+    };
+}

package/dist/cjs/react/utils/mention-markup.d.ts

@@ -1,5 +1,48 @@
-import type { Mention, MentionData, MentionSerializationConfig } from '../types.js';
+import type { Mention, MentionData, MentionResult, MentionSerializationConfig } from '../types.js';
+/**
+ * Removes `<!-- context: … -->` blocks and the whitespace after them. Scans with
+ * indexOf instead of one lazy regex, which is quadratic on many unclosed openers.
+ */
 export declare function stripContextBlocks(text: string): string;
+/**
+ * The text that tells the model which catalog definition a tool-backed
+ * command runs and with which arguments (`tool: ui.navigate, args: {...}`),
+ * or `undefined` when the definition id or the arguments cannot be sent
+ * safely. Arguments must be a JSON object of at most 2000 characters; `<` and
+ * `>` stay escaped so they can never close the surrounding context comment.
+ */
+export declare function describeToolReference(definitionId: unknown, args?: unknown): string | undefined;
+/**
+ * The structured mention a picked completion result becomes in the composer.
+ * A tool-backed command keeps its `definitionId` and `args`, because the
+ * serializer needs them to tell the model what the command runs.
+ */
+export declare function mentionDataFromResult(result: MentionResult, token: {
+    prefix: string;
+    slug: string;
+}): MentionData;
+/**
+ * A mention's tool reference as chip `dataset` values, so a chip read back
+ * from the editor keeps the definition id and arguments of the command it
+ * stands for. `undefined` when the mention has none, or none the model could
+ * be given.
+ */
+export declare function toolReferenceToDataset(mention: MentionData): {
+    definitionId: string;
+    args?: string;
+} | undefined;
+/**
+ * The inverse of `toolReferenceToDataset`: the `definitionId` (and `args`)
+ * stored in a chip's dataset, or `undefined` when there is none or it is
+ * malformed. It is validated like a reference taken from a picked result.
+ */
+export declare function toolReferenceFromDataset(dataset: {
+    mentionDefinitionId?: string;
+    mentionArgs?: string;
+}): {
+    definitionId: string;
+    args?: Record<string, unknown>;
+} | undefined;
 export declare function inferMentionPrefix(type: string): string;
 export declare function normalizeMentionSlug(value: string): string;
 export type MentionTextSegment = {

package/dist/cjs/react/utils/mention-markup.js

@@ -1,17 +1,131 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.stripContextBlocks = stripContextBlocks;
+exports.describeToolReference = describeToolReference;
+exports.mentionDataFromResult = mentionDataFromResult;
+exports.toolReferenceToDataset = toolReferenceToDataset;
+exports.toolReferenceFromDataset = toolReferenceFromDataset;
 exports.inferMentionPrefix = inferMentionPrefix;
 exports.normalizeMentionSlug = normalizeMentionSlug;
 exports.parseMentionSegments = parseMentionSegments;
 exports.serializeMentionsForSend = serializeMentionsForSend;
-const CONTEXT_BLOCK_RE = /<!--\s*context:[\s\S]*?-->\s*/gi;
-const MENTION_MARKER_RE = /\{\{mention:([^:}]+):([^:}]+):([^}]+)\}\}/g;
+const CONTEXT_OPEN_RE = /<!--\s*context:/iy;
+// Bounded parts keep the scan linear on hostile text with many unclosed markers.
+const MENTION_MARKER_RE = /\{\{mention:([^:}]{1,200}):([^:}]{1,200}):([^}]{1,1000})\}\}/g;
+const DEFINITION_ID_RE = /^[A-Za-z0-9_.-]{1,200}$/;
+const MAX_TOOL_ARGS_LENGTH = 2_000;
 function escapeRegex(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
+/**
+ * Removes `<!-- context: … -->` blocks and the whitespace after them. Scans with
+ * indexOf instead of one lazy regex, which is quadratic on many unclosed openers.
+ */
 function stripContextBlocks(text) {
-    return text.replace(CONTEXT_BLOCK_RE, '').trimStart();
+    let kept = '';
+    let cursor = 0;
+    let from = 0;
+    for (;;) {
+        const open = text.indexOf('<!--', from);
+        if (open < 0)
+            break;
+        CONTEXT_OPEN_RE.lastIndex = open;
+        if (!CONTEXT_OPEN_RE.test(text)) {
+            from = open + 4;
+            continue;
+        }
+        const close = text.indexOf('-->', CONTEXT_OPEN_RE.lastIndex);
+        if (close < 0)
+            break;
+        kept += text.slice(cursor, open);
+        let end = close + 3;
+        while (end < text.length && /\s/.test(text[end]))
+            end += 1;
+        cursor = end;
+        from = end;
+    }
+    return (kept + text.slice(cursor)).trimStart();
+}
+/**
+ * The text that tells the model which catalog definition a tool-backed
+ * command runs and with which arguments (`tool: ui.navigate, args: {...}`),
+ * or `undefined` when the definition id or the arguments cannot be sent
+ * safely. Arguments must be a JSON object of at most 2000 characters; `<` and
+ * `>` stay escaped so they can never close the surrounding context comment.
+ */
+function describeToolReference(definitionId, args) {
+    if (typeof definitionId !== 'string' || !DEFINITION_ID_RE.test(definitionId))
+        return undefined;
+    if (args === undefined)
+        return `tool: ${definitionId}`;
+    if (typeof args !== 'object' || args === null || Array.isArray(args))
+        return undefined;
+    let json;
+    try {
+        json = JSON.stringify(args);
+    }
+    catch {
+        return undefined;
+    }
+    if (json === undefined || json.length > MAX_TOOL_ARGS_LENGTH)
+        return undefined;
+    const safe = json.replace(/</g, '\\u003c').replace(/>/g, '\\u003e');
+    return `tool: ${definitionId}, args: ${safe}`;
+}
+/**
+ * The structured mention a picked completion result becomes in the composer.
+ * A tool-backed command keeps its `definitionId` and `args`, because the
+ * serializer needs them to tell the model what the command runs.
+ */
+function mentionDataFromResult(result, token) {
+    return {
+        id: result.id,
+        type: result.type,
+        label: result.label,
+        displayName: result.label,
+        slug: token.slug,
+        prefix: token.prefix,
+        ...(result.definitionId ? { definitionId: result.definitionId } : {}),
+        ...(result.args ? { args: result.args } : {}),
+    };
+}
+/**
+ * A mention's tool reference as chip `dataset` values, so a chip read back
+ * from the editor keeps the definition id and arguments of the command it
+ * stands for. `undefined` when the mention has none, or none the model could
+ * be given.
+ */
+function toolReferenceToDataset(mention) {
+    if (mention.definitionId === undefined)
+        return undefined;
+    if (describeToolReference(mention.definitionId, mention.args) === undefined)
+        return undefined;
+    const definitionId = mention.definitionId;
+    return mention.args === undefined
+        ? { definitionId }
+        : { definitionId, args: JSON.stringify(mention.args) };
+}
+/**
+ * The inverse of `toolReferenceToDataset`: the `definitionId` (and `args`)
+ * stored in a chip's dataset, or `undefined` when there is none or it is
+ * malformed. It is validated like a reference taken from a picked result.
+ */
+function toolReferenceFromDataset(dataset) {
+    const definitionId = dataset.mentionDefinitionId;
+    if (!definitionId)
+        return undefined;
+    let args;
+    if (dataset.mentionArgs !== undefined) {
+        try {
+            args = JSON.parse(dataset.mentionArgs);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    if (describeToolReference(definitionId, args) === undefined)
+        return undefined;
+    return args === undefined ? { definitionId } : { definitionId, args };
 }
 function inferMentionPrefix(type) {
     return type === 'task' || type === 'command' ? '/' : '@';
@@ -58,7 +172,7 @@ function buildContextBlock(mentions, label) {
     const summary = mentions
         .map((m) => {
         const displayName = m.displayName ?? m.label ?? m.id;
-        return `${displayName} (ID: ${m.id})`;
+        return `${displayName} (ID: ${m.id}${m.toolReference ? `, ${m.toolReference}` : ''})`;
     })
         .join(', ');
     return `<!--context:[${label}: ${summary}]--> `;
@@ -71,6 +185,23 @@ function serializeMentionsForSend(text, mentions, options) {
     const cleaned = stripContextBlocks(text);
     let nextText = cleaned;
     const serializedMentions = [];
+    // One command can arrive twice: as a chip read back from the editor DOM
+    // (dataset only, so without definition id and arguments) and as the state
+    // entry that still carries them. Only the entry first in line replaces the
+    // token, so the reference is looked up per mention, not per entry.
+    const toolReferences = new Map();
+    for (const mention of mentions) {
+        if (typeof mention.id !== 'string' || typeof mention.type !== 'string')
+            continue;
+        if (mention.definitionId === undefined)
+            continue;
+        const key = `${mention.type}\u0000${mention.id}`;
+        if (toolReferences.has(key))
+            continue;
+        const reference = describeToolReference(mention.definitionId, mention.args);
+        if (reference)
+            toolReferences.set(key, reference);
+    }
     for (const mention of mentions) {
         const id = typeof mention.id === 'string' ? mention.id : '';
         const type = typeof mention.type === 'string' ? mention.type : '';
@@ -103,15 +234,18 @@ function serializeMentionsForSend(text, mentions, options) {
                 displayName: label,
                 slug,
                 prefix,
+                toolReference: toolReferences.get(`${type}\u0000${id}`),
             });
         }
     }
-    if (options?.includeContextBlock) {
-        const contextLabel = options.contextLabel ?? 'Referenced entities';
-        const contextBlock = buildContextBlock(serializedMentions, contextLabel);
-        if (contextBlock) {
-            return `${contextBlock}${nextText}`.trim();
-        }
+    // A tool-backed command is only meaningful with its definition and
+    // arguments, so those always reach the model; other mentions need the option.
+    const contextMentions = options?.includeContextBlock
+        ? serializedMentions
+        : serializedMentions.filter((m) => m.toolReference);
+    const contextBlock = buildContextBlock(contextMentions, options?.contextLabel ?? 'Referenced entities');
+    if (contextBlock) {
+        return `${contextBlock}${nextText}`.trim();
     }
     return nextText;
 }

package/dist/cjs/react/utils/tool-presentation.d.ts

@@ -0,0 +1,23 @@
+import type { ChatLocale } from '../types.js';
+/** What a chat turn tells the UI about its tools: a label per model name and the language of the app. */
+export interface ToolPresentation {
+    locale: string;
+    labels: Record<string, string>;
+}
+/**
+ * Reads the `data-tool-presentation` part of a chat turn. It is data from the
+ * app's own server, but the UI still takes only short texts from it.
+ */
+export declare function parseToolPresentation(data: unknown): ToolPresentation | null;
+/**
+ * The built-in chat texts for a language tag (`de`, `de-AT`); empty for a
+ * language without built-in texts, which keeps the English defaults.
+ */
+export declare function languageLocale(language: string | null | undefined): Partial<ChatLocale>;
+/** Whether a language tag is German (`de`, `de-AT`). */
+export declare function isGerman(language: string | null | undefined): boolean;
+/**
+ * The `lang` of the page, read after mount so the server render and the first
+ * client render agree; null until then and for a page without one.
+ */
+export declare function usePageLanguage(): string | null;

package/dist/cjs/react/utils/tool-presentation.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseToolPresentation = parseToolPresentation;
+exports.languageLocale = languageLocale;
+exports.isGerman = isGerman;
+exports.usePageLanguage = usePageLanguage;
+const react_1 = require("react");
+const locale_de_js_1 = require("../locale-de.js");
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+/**
+ * Reads the `data-tool-presentation` part of a chat turn. It is data from the
+ * app's own server, but the UI still takes only short texts from it.
+ */
+function parseToolPresentation(data) {
+    if (!isRecord(data) || typeof data.locale !== 'string' || !isRecord(data.tools))
+        return null;
+    const labels = {};
+    for (const [name, entry] of Object.entries(data.tools)) {
+        const label = isRecord(entry) && typeof entry.label === 'string' ? entry.label.trim() : '';
+        if (label !== '' && label.length <= 200)
+            labels[name] = label;
+    }
+    return { locale: data.locale, labels };
+}
+/**
+ * The built-in chat texts for a language tag (`de`, `de-AT`); empty for a
+ * language without built-in texts, which keeps the English defaults.
+ */
+function languageLocale(language) {
+    return isGerman(language) ? locale_de_js_1.deChatLocale : {};
+}
+/** Whether a language tag is German (`de`, `de-AT`). */
+function isGerman(language) {
+    return /^de(?:-|$)/i.test(language ?? '');
+}
+/**
+ * The `lang` of the page, read after mount so the server render and the first
+ * client render agree; null until then and for a page without one.
+ */
+function usePageLanguage() {
+    const [language, setLanguage] = (0, react_1.useState)(null);
+    (0, react_1.useEffect)(() => {
+        setLanguage(document.documentElement.lang || null);
+    }, []);
+    return language;
+}

package/dist/cjs/react/utils/tool-result-config.d.ts

@@ -0,0 +1,10 @@
+import type { ToolResultDisplayConfig, ToolResultDisplayMode } from '../types.js';
+/**
+ * The tool result display of a chat. Raw JSON under every answer is noise for
+ * the people using an app, so without the app's own choice results are hidden
+ * (the work log names what ran) unless the app registered renderers for them.
+ */
+export declare function resolveToolResultConfig(config: ToolResultDisplayConfig | undefined, hasRenderers: boolean): {
+    mode: ToolResultDisplayMode;
+    allowlist: string[];
+};

package/dist/cjs/react/utils/tool-result-config.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveToolResultConfig = resolveToolResultConfig;
+/**
+ * The tool result display of a chat. Raw JSON under every answer is noise for
+ * the people using an app, so without the app's own choice results are hidden
+ * (the work log names what ran) unless the app registered renderers for them.
+ */
+function resolveToolResultConfig(config, hasRenderers) {
+    return {
+        mode: config?.mode ?? (hasRenderers ? 'default' : 'hidden'),
+        allowlist: config?.allowlist ?? [],
+    };
+}

package/dist/cjs/runtime/ai-sdk/engine.d.ts

@@ -0,0 +1,66 @@
+export interface AiSdkSourceTool {
+    description: string;
+    parameters: unknown;
+    needsApproval?: unknown;
+    execute: (input: unknown, options?: unknown) => unknown | Promise<unknown>;
+}
+export interface AiSdkToolCall {
+    toolName: string;
+    input: unknown;
+}
+export interface AiSdkToolSuccess extends AiSdkToolCall {
+    result: unknown;
+    durationMs: number;
+}
+export interface AiSdkToolFailure extends AiSdkToolCall {
+    error: unknown;
+    durationMs: number;
+}
+export interface AiSdkToolHooks {
+    beforeToolCall?: (call: AiSdkToolCall) => void | Promise<void>;
+    afterToolCall?: (call: AiSdkToolSuccess) => void | Promise<void>;
+    onToolError?: (call: AiSdkToolFailure) => void | Promise<void>;
+    resolveApproval?: (call: AiSdkToolCall) => boolean | Promise<boolean>;
+    toolTimeoutMs?: number;
+}
+/**
+ * Decides, at the moment a tool executes, whether this execution is allowed.
+ * A tool carries its gate under `AI_SDK_APPROVAL_GATE`; `createAiSdkTools`
+ * reports every `needsApproval` answer of a live call to it and asks it
+ * before every execution, with the input exactly as the AI SDK passes it
+ * (before validation). `authorize` throws to refuse.
+ *
+ * The gate travels with the tool object, so a stream handler that wraps the
+ * tools it was given (or calls their `execute` itself) cannot leave it out.
+ */
+export interface AiSdkApprovalGate {
+    recordDecision: (call: {
+        toolName: string;
+        toolCallId: string | undefined;
+        needed: boolean;
+    }) => void;
+    authorize: (call: {
+        toolName: string;
+        toolCallId: string | undefined;
+        input: unknown;
+    }) => void;
+}
+export declare const AI_SDK_APPROVAL_GATE: unique symbol;
+/**
+ * Set in the execution options that `createAiSdkTools` passes to the source
+ * tool once its gate authorized the call, so a source tool that checks the
+ * gate itself does not check the same execution twice (with the validated
+ * input, which differs for a schema that transforms).
+ */
+export declare const AI_SDK_APPROVAL_GATE_PASSED: unique symbol;
+export declare function approvalGateOf(tool: unknown): AiSdkApprovalGate | undefined;
+export interface AiSdkWrappedTool {
+    description?: string;
+    needsApproval?: unknown;
+    execute?: (input: unknown, options?: unknown) => Promise<unknown>;
+    [key: string]: unknown;
+}
+export declare function createAiSdkTools(options: {
+    tools: Record<string, AiSdkSourceTool | unknown>;
+    now?: () => number;
+} & AiSdkToolHooks): Record<string, AiSdkWrappedTool>;