qlogicagent 2.13.4 → 2.13.5

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

@@ -0,0 +1,49 @@
+/**
+ * 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

@@ -0,0 +1,86 @@
+/**
+ * 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

@@ -0,0 +1,61 @@
+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

@@ -0,0 +1,429 @@
+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

@@ -0,0 +1,54 @@
+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>;