qlogicagent 2.13.5 → 2.13.6

package/dist/orchestration/tool-cascade.d.ts

@@ -1,49 +0,0 @@
-/**
- * Tool Cascade — provider-native tool augmentation layer.
- *
- * When a provider (e.g. Zhipu GLM) offers native utility APIs (web search, reader,
- * tokenizer, etc.), the tool cascade automatically routes through the provider API
- * first, falling back to the host-provided implementation (e.g. SearXNG) on failure.
- *
- * ## Architecture
- *
- * Two levels of provider tool integration:
- *
- * 1. **D-level (builtin tools)**: Injected directly into chat completion request
- *    via `builtinWebSearch` / `builtinCodeInterpreter` / `builtinUrlContext` / `builtinMapsGrounding` / `builtinFileSearch` quirks.
- *    The LLM decides to use these inline during generation — no agent intervention.
- *    → Handled by openai-chat.ts (GLM/Kimi) and gemini-generatecontent.ts (Google) transport layers.
- *
- * 2. **C-level (independent APIs)**: Discrete API endpoints the agent calls explicitly
- *    as tool steps (web_search, reader, tokenizer, moderations).
- *    → Handled by this cascade layer — wraps host-provided tool deps with
- *      provider-native backends, falling back on error.
- *
- * ## Usage
- *
- * ```ts
- * import { cascadeWebSearch } from "./tool-cascade.js";
- * const providerApi = host.resolveProviderToolApi();
- *
- * const providerApi = new ZhipuToolAPI({ baseUrl, apiKey });
- * const cascadedSearch = cascadeWebSearch(providerApi, fallbackSearchFn);
- * const tool = createWebSearchTool({ search: cascadedSearch });
- * ```
- */
-import type { WebSearchBackend } from "../runtime/ports/web-search-contracts.js";
-export interface ProviderToolApiPort {
-    capabilities: readonly string[];
-    webSearch?(query: string, options?: {
-        maxResults?: number;
-    }): Promise<Array<{
-        title: string;
-        url: string;
-        snippet: string;
-    }>>;
-}
-/**
- * Cascade web search: provider-native search → host fallback.
- * Returns a WebSearchToolDeps.search function that tries the provider's
- * webSearch API first, falling back to the host's search on error.
- */
-export declare function cascadeWebSearch(providerApi: ProviderToolApiPort | undefined, fallbackSearch: WebSearchBackend["search"]): WebSearchBackend["search"];

package/dist/orchestration/tool-cascade.js

@@ -1,86 +0,0 @@
-/**
- * Tool Cascade — provider-native tool augmentation layer.
- *
- * When a provider (e.g. Zhipu GLM) offers native utility APIs (web search, reader,
- * tokenizer, etc.), the tool cascade automatically routes through the provider API
- * first, falling back to the host-provided implementation (e.g. SearXNG) on failure.
- *
- * ## Architecture
- *
- * Two levels of provider tool integration:
- *
- * 1. **D-level (builtin tools)**: Injected directly into chat completion request
- *    via `builtinWebSearch` / `builtinCodeInterpreter` / `builtinUrlContext` / `builtinMapsGrounding` / `builtinFileSearch` quirks.
- *    The LLM decides to use these inline during generation — no agent intervention.
- *    → Handled by openai-chat.ts (GLM/Kimi) and gemini-generatecontent.ts (Google) transport layers.
- *
- * 2. **C-level (independent APIs)**: Discrete API endpoints the agent calls explicitly
- *    as tool steps (web_search, reader, tokenizer, moderations).
- *    → Handled by this cascade layer — wraps host-provided tool deps with
- *      provider-native backends, falling back on error.
- *
- * ## Usage
- *
- * ```ts
- * import { cascadeWebSearch } from "./tool-cascade.js";
- * const providerApi = host.resolveProviderToolApi();
- *
- * const providerApi = new ZhipuToolAPI({ baseUrl, apiKey });
- * const cascadedSearch = cascadeWebSearch(providerApi, fallbackSearchFn);
- * const tool = createWebSearchTool({ search: cascadedSearch });
- * ```
- */
-/**
- * Cascade web search: provider-native search → host fallback.
- * Returns a WebSearchToolDeps.search function that tries the provider's
- * webSearch API first, falling back to the host's search on error.
- */
-export function cascadeWebSearch(providerApi, fallbackSearch) {
-    if (!providerApi?.webSearch || !providerApi.capabilities.includes("web_search")) {
-        return fallbackSearch;
-    }
-    return async (query, options) => {
-        try {
-            const results = await providerApi.webSearch(query, { maxResults: options?.maxResults });
-            // Apply domain filtering (allowedDomains / blockedDomains)
-            let filtered = results;
-            if (options?.allowedDomains?.length) {
-                const allowed = new Set(options.allowedDomains.map(d => d.toLowerCase()));
-                filtered = filtered.filter(r => {
-                    try {
-                        return allowed.has(new URL(r.url).hostname.toLowerCase());
-                    }
-                    catch {
-                        return false;
-                    }
-                });
-            }
-            if (options?.blockedDomains?.length) {
-                const blocked = new Set(options.blockedDomains.map(d => d.toLowerCase()));
-                filtered = filtered.filter(r => {
-                    try {
-                        return !blocked.has(new URL(r.url).hostname.toLowerCase());
-                    }
-                    catch {
-                        return true;
-                    }
-                });
-            }
-            if (filtered.length > 0) {
-                return {
-                    query,
-                    results: filtered.map(r => ({
-                        title: r.title,
-                        url: r.url,
-                        snippet: r.snippet,
-                    })),
-                };
-            }
-            // If provider returned 0 results after filtering, fall through to fallback
-        }
-        catch {
-            // Provider API failed — fall through to fallback
-        }
-        return fallbackSearch(query, options);
-    };
-}

package/dist/orchestration/tool-loop/conversation-repair.d.ts

@@ -1,61 +0,0 @@
-export interface OpenAiToolCall {
-    id: string;
-    type: "function";
-    function: {
-        name: string;
-        arguments: string;
-    };
-}
-export interface OpenAiChatToolCallRef {
-    id?: string;
-    function?: {
-        name?: string;
-        arguments?: string;
-    };
-    name?: string;
-    [key: string]: unknown;
-}
-export interface OpenAiChatMessageLike {
-    role: string;
-    content?: unknown;
-    tool_calls?: OpenAiChatToolCallRef[];
-    tool_call_id?: string;
-    [key: string]: unknown;
-}
-export interface OpenAiResponsesItemLike {
-    type: string;
-    id?: string;
-    call_id?: string;
-    role?: string;
-    content?: unknown;
-    status?: string;
-    [key: string]: unknown;
-}
-export interface ConversationRepairOptions {
-    stopReason?: string;
-    placeholderToolResult?: string;
-    placeholderFunctionCallOutput?: string;
-    forcedStopReasons?: readonly string[];
-}
-type ContentPart = {
-    type: string;
-    text?: string;
-    [key: string]: unknown;
-};
-export type { ContentPart };
-export declare function sanitizeOpenAiChatMessages<T extends OpenAiChatMessageLike>(messages: readonly T[]): T[];
-export declare function ensureAssistantReasoningContent<T extends Record<string, unknown>>(messages: readonly T[], defaultValue?: string): T[];
-export declare function stripForcedStopAssistantToolMetadata<T extends OpenAiChatMessageLike>(messages: readonly T[], options?: ConversationRepairOptions): T[];
-export declare function injectDanglingToolCallPlaceholders<T extends OpenAiChatMessageLike>(messages: readonly T[], options?: ConversationRepairOptions): T[];
-export declare function repairOpenAiChatConversation<T extends OpenAiChatMessageLike>(messages: readonly T[], options?: ConversationRepairOptions): T[];
-export declare function downgradeOpenAiFunctionCallReasoningPairs<T extends {
-    role?: unknown;
-    content?: unknown;
-    toolCallId?: unknown;
-    toolUseId?: unknown;
-}>(messages: readonly T[]): T[];
-export declare function downgradeOpenAiReasoningBlocks<T extends {
-    role?: unknown;
-    content?: unknown;
-}>(messages: readonly T[]): T[];
-export declare function repairOpenAiResponsesItems<T extends OpenAiResponsesItemLike>(items: readonly T[], options?: ConversationRepairOptions): T[];

package/dist/orchestration/tool-loop/conversation-repair.js

@@ -1,429 +0,0 @@
-const DEFAULT_FORCED_STOP_REASONS = ["stop", "aborted", "timeout", "cancelled", "interrupted", "error"];
-const FORCED_STOP_ASSISTANT_METADATA_KEYS = [
-    "tool_calls",
-    "toolCalls",
-    "function_call",
-    "functionCall",
-    "raw_tool_calls",
-    "rawToolCalls",
-];
-function normalizeUserMessageContent(content) {
-    if (content == null) {
-        return [];
-    }
-    if (typeof content === "string") {
-        return content.length > 0 ? [{ type: "text", text: content }] : [];
-    }
-    if (Array.isArray(content)) {
-        return content;
-    }
-    return [{ type: "text", text: String(content) }];
-}
-function mergeConsecutiveUserMessages(left, right) {
-    return {
-        ...left,
-        content: [
-            ...normalizeUserMessageContent(left.content),
-            ...normalizeUserMessageContent(right.content),
-        ],
-    };
-}
-function isValidOpenAiChatToolCall(call) {
-    if (!call || typeof call !== "object") {
-        return false;
-    }
-    if (call.function && typeof call.function === "object") {
-        const functionName = call.function.name;
-        if (typeof functionName === "string" && functionName.length > 0) {
-            return true;
-        }
-    }
-    return typeof call.name === "string" && call.name.length > 0;
-}
-function normalizeForcedStopReasons(forcedStopReasons) {
-    return new Set((forcedStopReasons ?? DEFAULT_FORCED_STOP_REASONS).map((reason) => reason.trim().toLowerCase()));
-}
-function shouldStripForcedStopToolMetadata(stopReason, forcedStopReasons) {
-    if (!stopReason) {
-        return false;
-    }
-    return normalizeForcedStopReasons(forcedStopReasons).has(stopReason.trim().toLowerCase());
-}
-function splitOpenAiFunctionCallPairing(id) {
-    const separator = id.indexOf("|");
-    if (separator <= 0 || separator >= id.length - 1) {
-        return { callId: id };
-    }
-    return {
-        callId: id.slice(0, separator),
-        itemId: id.slice(separator + 1),
-    };
-}
-function parseOpenAiReasoningSignature(value) {
-    if (!value) {
-        return null;
-    }
-    let candidate = null;
-    if (typeof value === "string") {
-        const trimmed = value.trim();
-        if (!trimmed.startsWith("{") || !trimmed.endsWith("}")) {
-            return null;
-        }
-        try {
-            candidate = JSON.parse(trimmed);
-        }
-        catch {
-            return null;
-        }
-    }
-    else if (typeof value === "object") {
-        candidate = value;
-    }
-    if (!candidate) {
-        return null;
-    }
-    const id = typeof candidate.id === "string" ? candidate.id : "";
-    const type = typeof candidate.type === "string" ? candidate.type : "";
-    if (!id.startsWith("rs_")) {
-        return null;
-    }
-    if (type === "reasoning" || type.startsWith("reasoning.")) {
-        return { id, type };
-    }
-    return null;
-}
-function hasFollowingNonThinkingBlock(content, index) {
-    for (let nextIndex = index + 1; nextIndex < content.length; nextIndex += 1) {
-        const block = content[nextIndex];
-        if (!block || typeof block !== "object") {
-            return true;
-        }
-        if (block.type !== "thinking") {
-            return true;
-        }
-    }
-    return false;
-}
-export function sanitizeOpenAiChatMessages(messages) {
-    if (!Array.isArray(messages) || messages.length === 0) {
-        return [...messages];
-    }
-    const normalizedMessages = messages.map((message) => {
-        if (message.role === "assistant" && Array.isArray(message.tool_calls)) {
-            const validToolCalls = message.tool_calls.filter((call) => isValidOpenAiChatToolCall(call));
-            return {
-                ...message,
-                ...(validToolCalls.length > 0 ? { tool_calls: validToolCalls } : { tool_calls: undefined }),
-            };
-        }
-        return { ...message };
-    });
-    const validToolCallIds = new Set();
-    for (const message of normalizedMessages) {
-        if (message.role !== "assistant" || !Array.isArray(message.tool_calls)) {
-            continue;
-        }
-        for (const toolCall of message.tool_calls) {
-            if (typeof toolCall.id === "string" && toolCall.id) {
-                validToolCallIds.add(toolCall.id);
-            }
-        }
-    }
-    const withoutOrphanToolMessages = normalizedMessages.filter((message) => {
-        if (message.role !== "tool") {
-            return true;
-        }
-        return Boolean(message.tool_call_id && validToolCallIds.has(message.tool_call_id));
-    });
-    const survivingToolIds = new Set();
-    for (const message of withoutOrphanToolMessages) {
-        if (message.role === "tool" && typeof message.tool_call_id === "string" && message.tool_call_id) {
-            survivingToolIds.add(message.tool_call_id);
-        }
-    }
-    const cleanedMessages = [];
-    for (const message of withoutOrphanToolMessages) {
-        if (message.role === "assistant" && Array.isArray(message.tool_calls) && message.tool_calls.length > 0) {
-            const matchedToolCalls = message.tool_calls.filter((toolCall) => typeof toolCall.id === "string" && survivingToolIds.has(toolCall.id));
-            if (matchedToolCalls.length === 0) {
-                const { tool_calls: _droppedToolCalls, ...rest } = message;
-                if (rest.content != null && rest.content !== "") {
-                    cleanedMessages.push(rest);
-                }
-                continue;
-            }
-            if (matchedToolCalls.length < message.tool_calls.length) {
-                cleanedMessages.push({ ...message, tool_calls: matchedToolCalls });
-                continue;
-            }
-        }
-        cleanedMessages.push(message);
-    }
-    const mergedMessages = [];
-    for (const message of cleanedMessages) {
-        const previous = mergedMessages.length > 0 ? mergedMessages[mergedMessages.length - 1] : undefined;
-        if (message.role === "user" && previous?.role === "user") {
-            mergedMessages[mergedMessages.length - 1] = mergeConsecutiveUserMessages(previous, message);
-            continue;
-        }
-        mergedMessages.push(message);
-    }
-    return mergedMessages;
-}
-export function ensureAssistantReasoningContent(messages, defaultValue = "") {
-    return messages.map((message) => {
-        if (message.role === "assistant" && !Object.hasOwn(message, "reasoning_content")) {
-            return { ...message, reasoning_content: defaultValue };
-        }
-        return { ...message };
-    });
-}
-export function stripForcedStopAssistantToolMetadata(messages, options) {
-    if (!shouldStripForcedStopToolMetadata(options?.stopReason, options?.forcedStopReasons)) {
-        return [...messages];
-    }
-    return messages.map((message) => {
-        if (message.role !== "assistant") {
-            return { ...message };
-        }
-        const nextMessage = { ...message };
-        for (const key of FORCED_STOP_ASSISTANT_METADATA_KEYS) {
-            delete nextMessage[key];
-        }
-        return nextMessage;
-    });
-}
-export function injectDanglingToolCallPlaceholders(messages, options) {
-    const placeholderContent = options?.placeholderToolResult ?? "Error: Tool loop interrupted before the tool result was replayed.";
-    const matchedToolResultIds = new Set();
-    for (const message of messages) {
-        if (message.role === "tool" && typeof message.tool_call_id === "string" && message.tool_call_id) {
-            matchedToolResultIds.add(message.tool_call_id);
-        }
-    }
-    const repairedMessages = [];
-    for (const message of messages) {
-        repairedMessages.push({ ...message });
-        if (message.role !== "assistant" || !Array.isArray(message.tool_calls) || message.tool_calls.length === 0) {
-            continue;
-        }
-        for (const toolCall of message.tool_calls) {
-            if (typeof toolCall.id !== "string" || !toolCall.id || matchedToolResultIds.has(toolCall.id)) {
-                continue;
-            }
-            matchedToolResultIds.add(toolCall.id);
-            repairedMessages.push({
-                role: "tool",
-                tool_call_id: toolCall.id,
-                content: placeholderContent,
-            });
-        }
-    }
-    return repairedMessages;
-}
-export function repairOpenAiChatConversation(messages, options) {
-    const sanitizedMessages = sanitizeOpenAiChatMessages(messages);
-    const strippedMessages = stripForcedStopAssistantToolMetadata(sanitizedMessages, options);
-    return injectDanglingToolCallPlaceholders(strippedMessages, options);
-}
-export function downgradeOpenAiFunctionCallReasoningPairs(messages) {
-    let changed = false;
-    const rewrittenMessages = [];
-    let pendingRewrittenIds = null;
-    for (const message of messages) {
-        if (!message || typeof message !== "object") {
-            pendingRewrittenIds = null;
-            rewrittenMessages.push(message);
-            continue;
-        }
-        if (message.role === "assistant") {
-            if (!Array.isArray(message.content)) {
-                pendingRewrittenIds = null;
-                rewrittenMessages.push(message);
-                continue;
-            }
-            const localRewrittenIds = new Map();
-            let seenReplayableReasoning = false;
-            let assistantChanged = false;
-            const nextContent = message.content.map((block) => {
-                if (!block || typeof block !== "object") {
-                    return block;
-                }
-                const maybeThinking = block;
-                if (maybeThinking.type === "thinking" && parseOpenAiReasoningSignature(maybeThinking.thinkingSignature)) {
-                    seenReplayableReasoning = true;
-                    return block;
-                }
-                const maybeToolCall = block;
-                if (!["toolCall", "toolUse", "functionCall"].includes(String(maybeToolCall.type)) || typeof maybeToolCall.id !== "string") {
-                    return block;
-                }
-                const pairing = splitOpenAiFunctionCallPairing(maybeToolCall.id);
-                if (seenReplayableReasoning || !pairing.itemId || !pairing.itemId.startsWith("fc_")) {
-                    return block;
-                }
-                assistantChanged = true;
-                localRewrittenIds.set(maybeToolCall.id, pairing.callId);
-                return {
-                    ...block,
-                    id: pairing.callId,
-                };
-            });
-            pendingRewrittenIds = localRewrittenIds.size > 0 ? localRewrittenIds : null;
-            if (!assistantChanged) {
-                rewrittenMessages.push(message);
-                continue;
-            }
-            changed = true;
-            rewrittenMessages.push({ ...message, content: nextContent });
-            continue;
-        }
-        if (message.role === "toolResult" && pendingRewrittenIds && pendingRewrittenIds.size > 0) {
-            const updates = {};
-            let toolResultChanged = false;
-            if (typeof message.toolCallId === "string") {
-                const nextToolCallId = pendingRewrittenIds.get(message.toolCallId);
-                if (nextToolCallId && nextToolCallId !== message.toolCallId) {
-                    updates.toolCallId = nextToolCallId;
-                    toolResultChanged = true;
-                }
-            }
-            if (typeof message.toolUseId === "string") {
-                const nextToolUseId = pendingRewrittenIds.get(message.toolUseId);
-                if (nextToolUseId && nextToolUseId !== message.toolUseId) {
-                    updates.toolUseId = nextToolUseId;
-                    toolResultChanged = true;
-                }
-            }
-            if (!toolResultChanged) {
-                rewrittenMessages.push(message);
-                continue;
-            }
-            changed = true;
-            rewrittenMessages.push({ ...message, ...updates });
-            continue;
-        }
-        pendingRewrittenIds = null;
-        rewrittenMessages.push(message);
-    }
-    return changed ? rewrittenMessages : [...messages];
-}
-export function downgradeOpenAiReasoningBlocks(messages) {
-    const out = [];
-    for (const message of messages) {
-        if (!message || typeof message !== "object") {
-            out.push(message);
-            continue;
-        }
-        if (message.role !== "assistant") {
-            out.push(message);
-            continue;
-        }
-        if (!Array.isArray(message.content)) {
-            out.push(message);
-            continue;
-        }
-        let changed = false;
-        const nextContent = [];
-        for (let index = 0; index < message.content.length; index += 1) {
-            const block = message.content[index];
-            if (!block || typeof block !== "object") {
-                nextContent.push(block);
-                continue;
-            }
-            const record = block;
-            if (record.type !== "thinking") {
-                nextContent.push(block);
-                continue;
-            }
-            const signature = parseOpenAiReasoningSignature(record.thinkingSignature);
-            if (!signature) {
-                nextContent.push(block);
-                continue;
-            }
-            if (hasFollowingNonThinkingBlock(message.content, index)) {
-                nextContent.push(block);
-                continue;
-            }
-            changed = true;
-        }
-        if (!changed) {
-            out.push(message);
-            continue;
-        }
-        if (nextContent.length === 0) {
-            continue;
-        }
-        out.push({ ...message, content: nextContent });
-    }
-    return out;
-}
-export function repairOpenAiResponsesItems(items, options) {
-    const placeholderOutput = options?.placeholderFunctionCallOutput ?? "Error: Tool loop interrupted before function_call_output was provided.";
-    const stripForced = shouldStripForcedStopToolMetadata(options?.stopReason, options?.forcedStopReasons);
-    const rewrittenItems = [];
-    for (let index = 0; index < items.length; index += 1) {
-        const item = items[index];
-        if (!item || typeof item !== "object") {
-            rewrittenItems.push(item);
-            continue;
-        }
-        if (item.type === "reasoning" && typeof item.id === "string" && item.id.startsWith("rs_")) {
-            const hasFollowingNonReasoning = items.slice(index + 1).some((next) => next && typeof next === "object" && next.type !== "reasoning");
-            if (!hasFollowingNonReasoning) {
-                continue;
-            }
-        }
-        if (item.type !== "function_call") {
-            rewrittenItems.push({ ...item });
-            continue;
-        }
-        const nextItem = { ...item };
-        if (typeof nextItem.id === "string") {
-            const pairing = splitOpenAiFunctionCallPairing(nextItem.id);
-            if (pairing.itemId?.startsWith("fc_")) {
-                nextItem.id = pairing.callId;
-            }
-        }
-        rewrittenItems.push(nextItem);
-    }
-    const validFunctionCallIds = new Set();
-    const functionCallByCallId = new Map();
-    for (const item of rewrittenItems) {
-        if (item.type !== "function_call") {
-            continue;
-        }
-        const callId = typeof item.call_id === "string" && item.call_id ? item.call_id : typeof item.id === "string" ? item.id : undefined;
-        if (!callId) {
-            continue;
-        }
-        validFunctionCallIds.add(callId);
-        functionCallByCallId.set(callId, item);
-    }
-    const pairedOutputs = new Set();
-    const repairedItems = [];
-    for (const item of rewrittenItems) {
-        if (stripForced && item.type === "function_call") {
-            continue;
-        }
-        if (item.type === "function_call_output") {
-            const callId = typeof item.call_id === "string" ? item.call_id : "";
-            if (!callId || !validFunctionCallIds.has(callId)) {
-                continue;
-            }
-            pairedOutputs.add(callId);
-        }
-        repairedItems.push(item);
-    }
-    for (const [callId] of functionCallByCallId) {
-        if (pairedOutputs.has(callId) || stripForced) {
-            continue;
-        }
-        repairedItems.push({
-            type: "function_call_output",
-            call_id: callId,
-            output: placeholderOutput,
-        });
-    }
-    return repairedItems;
-}

package/dist/orchestration/tool-loop/tool-choice-policy.d.ts

@@ -1,54 +0,0 @@
-import type { RuntimeToolEligibilityContract } from "../../protocol/wire/index.js";
-export type ToolChoiceLike = "auto" | "none" | "required" | {
-    type: "function";
-    function?: {
-        name?: string;
-    };
-} | Record<string, unknown> | undefined;
-export interface ToolChoiceToolLike {
-    type?: string;
-    function?: {
-        name?: string;
-        description?: string;
-        parameters?: Record<string, unknown>;
-    };
-    name?: string;
-    description?: string;
-    requiresApproval?: boolean;
-}
-export type ToolEligibilityLike = RuntimeToolEligibilityContract;
-export interface ToolChoiceCompatibilityPolicy {
-    allowNamedToolChoice?: boolean;
-    allowRequiredToolChoice?: boolean;
-    requiredFallback?: "required" | "auto" | "none";
-    namedFallback?: "required" | "auto" | "none";
-    requireAutoWhenThinking?: boolean;
-}
-export interface ApplyToolChoicePolicyInput<TTool extends ToolChoiceToolLike> {
-    tools: readonly TTool[];
-    toolChoice: ToolChoiceLike;
-    eligibility?: readonly ToolEligibilityLike[];
-    thinkingEnabled?: boolean;
-    compatibility?: ToolChoiceCompatibilityPolicy;
-}
-export interface ApplyToolChoicePolicyResult<TTool extends ToolChoiceToolLike> {
-    tools: TTool[];
-    normalizedToolChoice?: ToolChoiceLike;
-    extraSystemPrompt?: string;
-    warnings: string[];
-}
-export declare function filterEligibleTools<TTool extends ToolChoiceToolLike>(params: {
-    tools: readonly TTool[];
-    eligibility?: readonly ToolEligibilityLike[];
-}): TTool[];
-export declare function normalizeAnthropicFunctionToolDefinition(tool: unknown): Record<string, unknown> | undefined;
-export declare function normalizeAnthropicToolChoice(toolChoice: unknown): unknown;
-export declare function applyToolChoiceCompatibility(params: {
-    toolChoice: ToolChoiceLike;
-    thinkingEnabled?: boolean;
-    compatibility?: ToolChoiceCompatibilityPolicy;
-}): {
-    normalizedToolChoice?: ToolChoiceLike;
-    warnings: string[];
-};
-export declare function applyToolChoicePolicy<TTool extends ToolChoiceToolLike>(params: ApplyToolChoicePolicyInput<TTool>): ApplyToolChoicePolicyResult<TTool>;