import * as ai from 'ai';
import { UIMessage, UIDataTypes, Tool } from 'ai';
import * as _ai_sdk_provider from '@ai-sdk/provider';
import * as _ai_sdk_provider_utils from '@ai-sdk/provider-utils';
import { z } from 'zod';
import * as schema from '@folo-services/drizzle';
import { AttachmentsModel } from '@folo-services/drizzle';
import { NodePgDatabase } from 'drizzle-orm/node-postgres';

declare const ENTRY_FIELDS: {
    readonly id: "Unique identifier of the entry";
    readonly title: "Title of the entry/article";
    readonly url: "Original URL of the entry";
    readonly content: "Full content/text of the entry";
    readonly description: "Brief description or excerpt of the entry";
    readonly guid: "Global unique identifier from the feed";
    readonly author: "Author name of the entry";
    readonly authorUrl: "URL to the author's profile or website";
    readonly authorAvatar: "Avatar image URL of the author";
    readonly insertedAt: "Date when the entry was inserted into database";
    readonly publishedAt: "Date when the entry was originally published";
    readonly media: "Array of media attachments (photos/videos) with metadata";
    readonly categories: "Array of category tags for the entry";
    readonly attachments: "Array of file attachments (audio, documents, subtitles for videos, etc.)";
    readonly extra: "Additional metadata and links related to the entry";
    readonly language: "Language code of the entry content";
    readonly feedId: "ID of the feed this entry belongs to";
};
declare const ENTRY_FIELD_NAMES: Array<keyof typeof ENTRY_FIELDS>;
declare const ENTRY_FIELD_DESCRIPTIONS: string;
declare const ENTRY_SELECT_ENUM: readonly ["id", "title", "url", "content", "description", "guid", "author", "authorUrl", "authorAvatar", "insertedAt", "publishedAt", "media", "categories", "attachments", "extra", "language", "feedId"];
declare const toolContextSchema: z.ZodObject<{
    userId: z.ZodString;
}, z.core.$strip>;
declare const optionalUserToolContextSchema: z.ZodObject<{
    userId: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
type ToolContext = z.infer<typeof toolContextSchema>;
declare const getToolContext: (options: unknown) => ToolContext | undefined;

type AiToolsDb = NodePgDatabase<typeof schema>;
declare const withAiToolsDb: <T>(database: AiToolsDb, callback: () => Promise<T> | T) => Promise<T>;

type ConciseEntryResult = {
    id: string;
    title: string | null;
    url: string | null;
    author: string | null;
    publishedAt: Date | null;
    feedId: string;
    content: string | null;
};
type DetailedEntryResult = ConciseEntryResult & {
    subtitles: string | null;
    transcription: string | null;
};
type GetEntriesInput = {
    id: string | string[];
    mode: "concise" | "detailed";
};
declare function fetchEntries({ id, mode }: GetEntriesInput): Promise<string | Array<string> | null>;
declare const getEntriesTool: ({
    deferLoading?: boolean;
    title?: string;
    providerOptions?: _ai_sdk_provider_utils.ProviderOptions;
    metadata?: _ai_sdk_provider.JSONObject;
    inputSchema: ai.FlexibleSchema<{
        id: string | string[];
        mode: "concise" | "detailed";
    }>;
    contextSchema?: ai.FlexibleSchema<_ai_sdk_provider_utils.Context> | undefined;
    needsApproval?: boolean | _ai_sdk_provider_utils.ToolNeedsApprovalFunction<{
        id: string | string[];
        mode: "concise" | "detailed";
    }, NoInfer<_ai_sdk_provider_utils.Context>> | undefined;
    onInputStart?: ((options: ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
    onInputDelta?: ((options: {
        inputTextDelta: string;
    } & ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
    onInputAvailable?: ((options: {
        input: {
            id: string | string[];
            mode: "concise" | "detailed";
        };
    } & ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
    toModelOutput?: ((options: {
        toolCallId: string;
        input: {
            id: string | string[];
            mode: "concise" | "detailed";
        };
        output: NoInfer<string | string[] | null>;
    }) => _ai_sdk_provider_utils.ToolResultOutput | PromiseLike<_ai_sdk_provider_utils.ToolResultOutput>) | undefined;
} & {
    outputSchema?: ai.FlexibleSchema<string | string[] | null> | undefined;
    execute: ai.ToolExecuteFunction<{
        id: string | string[];
        mode: "concise" | "detailed";
    }, string | string[] | null, NoInfer<_ai_sdk_provider_utils.Context>>;
} & {
    description?: string | ((options: {
        context: NoInfer<_ai_sdk_provider_utils.Context>;
        experimental_sandbox?: ai.Experimental_SandboxSession;
    }) => string) | undefined;
    strict?: boolean;
    inputExamples?: {
        input: NoInfer<{
            id: string | string[];
            mode: "concise" | "detailed";
        }>;
    }[] | undefined;
    id?: never;
    isProviderExecuted?: never;
    args?: never;
    supportsDeferredResults?: never;
} & {
    type?: undefined | "function";
} & {
    execute: ai.ToolExecuteFunction<{
        id: string | string[];
        mode: "concise" | "detailed";
    }, string | string[] | null, NoInfer<_ai_sdk_provider_utils.Context>>;
}) | ({
    deferLoading?: boolean;
    title?: string;
    providerOptions?: _ai_sdk_provider_utils.ProviderOptions;
    metadata?: _ai_sdk_provider.JSONObject;
    inputSchema: ai.FlexibleSchema<{
        id: string | string[];
        mode: "concise" | "detailed";
    }>;
    contextSchema?: ai.FlexibleSchema<_ai_sdk_provider_utils.Context> | undefined;
    needsApproval?: boolean | _ai_sdk_provider_utils.ToolNeedsApprovalFunction<{
        id: string | string[];
        mode: "concise" | "detailed";
    }, NoInfer<_ai_sdk_provider_utils.Context>> | undefined;
    onInputStart?: ((options: ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
    onInputDelta?: ((options: {
        inputTextDelta: string;
    } & ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
    onInputAvailable?: ((options: {
        input: {
            id: string | string[];
            mode: "concise" | "detailed";
        };
    } & ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
    toModelOutput?: ((options: {
        toolCallId: string;
        input: {
            id: string | string[];
            mode: "concise" | "detailed";
        };
        output: NoInfer<string | string[] | null>;
    }) => _ai_sdk_provider_utils.ToolResultOutput | PromiseLike<_ai_sdk_provider_utils.ToolResultOutput>) | undefined;
} & {
    outputSchema?: ai.FlexibleSchema<string | string[] | null> | undefined;
    execute: ai.ToolExecuteFunction<{
        id: string | string[];
        mode: "concise" | "detailed";
    }, string | string[] | null, NoInfer<_ai_sdk_provider_utils.Context>>;
} & {
    description?: string | ((options: {
        context: NoInfer<_ai_sdk_provider_utils.Context>;
        experimental_sandbox?: ai.Experimental_SandboxSession;
    }) => string) | undefined;
    strict?: boolean;
    inputExamples?: {
        input: NoInfer<{
            id: string | string[];
            mode: "concise" | "detailed";
        }>;
    }[] | undefined;
    id?: never;
    isProviderExecuted?: never;
    args?: never;
    supportsDeferredResults?: never;
} & {
    type: "dynamic";
} & {
    execute: ai.ToolExecuteFunction<{
        id: string | string[];
        mode: "concise" | "detailed";
    }, string | string[] | null, NoInfer<_ai_sdk_provider_utils.Context>>;
}) | ({
    deferLoading?: boolean;
    title?: string;
    providerOptions?: _ai_sdk_provider_utils.ProviderOptions;
    metadata?: _ai_sdk_provider.JSONObject;
    inputSchema: ai.FlexibleSchema<{
        id: string | string[];
        mode: "concise" | "detailed";
    }>;
    contextSchema?: ai.FlexibleSchema<_ai_sdk_provider_utils.Context> | undefined;
    needsApproval?: boolean | _ai_sdk_provider_utils.ToolNeedsApprovalFunction<{
        id: string | string[];
        mode: "concise" | "detailed";
    }, NoInfer<_ai_sdk_provider_utils.Context>> | undefined;
    onInputStart?: ((options: ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
    onInputDelta?: ((options: {
        inputTextDelta: string;
    } & ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
    onInputAvailable?: ((options: {
        input: {
            id: string | string[];
            mode: "concise" | "detailed";
        };
    } & ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
    toModelOutput?: ((options: {
        toolCallId: string;
        input: {
            id: string | string[];
            mode: "concise" | "detailed";
        };
        output: NoInfer<string | string[] | null>;
    }) => _ai_sdk_provider_utils.ToolResultOutput | PromiseLike<_ai_sdk_provider_utils.ToolResultOutput>) | undefined;
} & {
    outputSchema?: ai.FlexibleSchema<string | string[] | null> | undefined;
    execute: ai.ToolExecuteFunction<{
        id: string | string[];
        mode: "concise" | "detailed";
    }, string | string[] | null, NoInfer<_ai_sdk_provider_utils.Context>>;
} & {
    type: "provider";
    id: `${string}.${string}`;
    args: Record<string, unknown>;
    description?: never;
    strict?: never;
    inputExamples?: never;
} & {
    isProviderExecuted: false;
    supportsDeferredResults?: never;
} & {
    execute: ai.ToolExecuteFunction<{
        id: string | string[];
        mode: "concise" | "detailed";
    }, string | string[] | null, NoInfer<_ai_sdk_provider_utils.Context>>;
}) | ({
    deferLoading?: boolean;
    title?: string;
    providerOptions?: _ai_sdk_provider_utils.ProviderOptions;
    metadata?: _ai_sdk_provider.JSONObject;
    inputSchema: ai.FlexibleSchema<{
        id: string | string[];
        mode: "concise" | "detailed";
    }>;
    contextSchema?: ai.FlexibleSchema<_ai_sdk_provider_utils.Context> | undefined;
    needsApproval?: boolean | _ai_sdk_provider_utils.ToolNeedsApprovalFunction<{
        id: string | string[];
        mode: "concise" | "detailed";
    }, NoInfer<_ai_sdk_provider_utils.Context>> | undefined;
    onInputStart?: ((options: ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
    onInputDelta?: ((options: {
        inputTextDelta: string;
    } & ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
    onInputAvailable?: ((options: {
        input: {
            id: string | string[];
            mode: "concise" | "detailed";
        };
    } & ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
    toModelOutput?: ((options: {
        toolCallId: string;
        input: {
            id: string | string[];
            mode: "concise" | "detailed";
        };
        output: NoInfer<string | string[] | null>;
    }) => _ai_sdk_provider_utils.ToolResultOutput | PromiseLike<_ai_sdk_provider_utils.ToolResultOutput>) | undefined;
} & {
    outputSchema?: ai.FlexibleSchema<string | string[] | null> | undefined;
    execute: ai.ToolExecuteFunction<{
        id: string | string[];
        mode: "concise" | "detailed";
    }, string | string[] | null, NoInfer<_ai_sdk_provider_utils.Context>>;
} & {
    type: "provider";
    id: `${string}.${string}`;
    args: Record<string, unknown>;
    description?: never;
    strict?: never;
    inputExamples?: never;
} & {
    isProviderExecuted: true;
    supportsDeferredResults?: boolean;
} & {
    execute: ai.ToolExecuteFunction<{
        id: string | string[];
        mode: "concise" | "detailed";
    }, string | string[] | null, NoInfer<_ai_sdk_provider_utils.Context>>;
});

type TransformTool<T> = T extends Tool<infer Input, infer Output> ? {
    input: Input;
    output: Output;
} : never;
type TransformTools<T> = {
    [K in keyof T]: TransformTool<T[K]>;
};
type BizUITools = TransformTools<typeof tools & typeof onboardingTools>;
/**
 * metadata for the message when streaming finished and not error
 */
type BizUIMetadata = {
    finishTime?: string;
    totalTokens?: number;
    reasoningTokens?: number;
    billedTokens?: number;
    contextTokens?: number;
    outputTokens?: number;
    billingMultiplier?: number;
    cachedInputTokens?: number;
    remainingTokens?: number;
    duration?: number;
    modelUsed?: string;
    providerType?: "byok" | "system";
    provider?: string;
};
type BizUIMessage = UIMessage<BizUIMetadata, UIDataTypes, BizUITools>;
type ToolWithState<T> = T & {
    state: "input-streaming" | "input-available" | "output-available" | "output-error";
};

declare function getEntryAdditional(entry: {
    attachments: AttachmentsModel[] | null;
    id?: string;
}): Promise<{
    subtitles?: string;
    transcription?: string;
    readability?: string;
}>;

declare const tools: {
    display_flow_chart: ({
        deferLoading?: boolean;
        title?: string;
        providerOptions?: _ai_sdk_provider_utils.ProviderOptions;
        metadata?: _ai_sdk_provider.JSONObject;
        inputSchema: ai.FlexibleSchema<{
            schema: any;
        }>;
        contextSchema?: ai.FlexibleSchema<_ai_sdk_provider_utils.Context> | undefined;
        needsApproval?: boolean | _ai_sdk_provider_utils.ToolNeedsApprovalFunction<{
            schema: any;
        }, NoInfer<_ai_sdk_provider_utils.Context>> | undefined;
        onInputStart?: ((options: ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        onInputDelta?: ((options: {
            inputTextDelta: string;
        } & ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        onInputAvailable?: ((options: {
            input: {
                schema: any;
            };
        } & ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        toModelOutput?: ((options: {
            toolCallId: string;
            input: {
                schema: any;
            };
            output: NoInfer<{
                error: string;
                message: string;
                ok?: undefined;
            } | {
                ok: number;
                error?: undefined;
                message?: undefined;
            }>;
        }) => _ai_sdk_provider_utils.ToolResultOutput | PromiseLike<_ai_sdk_provider_utils.ToolResultOutput>) | undefined;
    } & {
        outputSchema?: ai.FlexibleSchema<{
            error: string;
            message: string;
            ok?: undefined;
        } | {
            ok: number;
            error?: undefined;
            message?: undefined;
        }> | undefined;
        execute: ai.ToolExecuteFunction<{
            schema: any;
        }, {
            error: string;
            message: string;
            ok?: undefined;
        } | {
            ok: number;
            error?: undefined;
            message?: undefined;
        }, NoInfer<_ai_sdk_provider_utils.Context>>;
    } & {
        description?: string | ((options: {
            context: NoInfer<_ai_sdk_provider_utils.Context>;
            experimental_sandbox?: ai.Experimental_SandboxSession;
        }) => string) | undefined;
        strict?: boolean;
        inputExamples?: {
            input: NoInfer<{
                schema: any;
            }>;
        }[] | undefined;
        id?: never;
        isProviderExecuted?: never;
        args?: never;
        supportsDeferredResults?: never;
    } & {
        type?: undefined | "function";
    } & {
        execute: ai.ToolExecuteFunction<{
            schema: any;
        }, {
            error: string;
            message: string;
            ok?: undefined;
        } | {
            ok: number;
            error?: undefined;
            message?: undefined;
        }, NoInfer<_ai_sdk_provider_utils.Context>>;
    }) | ({
        deferLoading?: boolean;
        title?: string;
        providerOptions?: _ai_sdk_provider_utils.ProviderOptions;
        metadata?: _ai_sdk_provider.JSONObject;
        inputSchema: ai.FlexibleSchema<{
            schema: any;
        }>;
        contextSchema?: ai.FlexibleSchema<_ai_sdk_provider_utils.Context> | undefined;
        needsApproval?: boolean | _ai_sdk_provider_utils.ToolNeedsApprovalFunction<{
            schema: any;
        }, NoInfer<_ai_sdk_provider_utils.Context>> | undefined;
        onInputStart?: ((options: ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        onInputDelta?: ((options: {
            inputTextDelta: string;
        } & ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        onInputAvailable?: ((options: {
            input: {
                schema: any;
            };
        } & ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        toModelOutput?: ((options: {
            toolCallId: string;
            input: {
                schema: any;
            };
            output: NoInfer<{
                error: string;
                message: string;
                ok?: undefined;
            } | {
                ok: number;
                error?: undefined;
                message?: undefined;
            }>;
        }) => _ai_sdk_provider_utils.ToolResultOutput | PromiseLike<_ai_sdk_provider_utils.ToolResultOutput>) | undefined;
    } & {
        outputSchema?: ai.FlexibleSchema<{
            error: string;
            message: string;
            ok?: undefined;
        } | {
            ok: number;
            error?: undefined;
            message?: undefined;
        }> | undefined;
        execute: ai.ToolExecuteFunction<{
            schema: any;
        }, {
            error: string;
            message: string;
            ok?: undefined;
        } | {
            ok: number;
            error?: undefined;
            message?: undefined;
        }, NoInfer<_ai_sdk_provider_utils.Context>>;
    } & {
        description?: string | ((options: {
            context: NoInfer<_ai_sdk_provider_utils.Context>;
            experimental_sandbox?: ai.Experimental_SandboxSession;
        }) => string) | undefined;
        strict?: boolean;
        inputExamples?: {
            input: NoInfer<{
                schema: any;
            }>;
        }[] | undefined;
        id?: never;
        isProviderExecuted?: never;
        args?: never;
        supportsDeferredResults?: never;
    } & {
        type: "dynamic";
    } & {
        execute: ai.ToolExecuteFunction<{
            schema: any;
        }, {
            error: string;
            message: string;
            ok?: undefined;
        } | {
            ok: number;
            error?: undefined;
            message?: undefined;
        }, NoInfer<_ai_sdk_provider_utils.Context>>;
    }) | ({
        deferLoading?: boolean;
        title?: string;
        providerOptions?: _ai_sdk_provider_utils.ProviderOptions;
        metadata?: _ai_sdk_provider.JSONObject;
        inputSchema: ai.FlexibleSchema<{
            schema: any;
        }>;
        contextSchema?: ai.FlexibleSchema<_ai_sdk_provider_utils.Context> | undefined;
        needsApproval?: boolean | _ai_sdk_provider_utils.ToolNeedsApprovalFunction<{
            schema: any;
        }, NoInfer<_ai_sdk_provider_utils.Context>> | undefined;
        onInputStart?: ((options: ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        onInputDelta?: ((options: {
            inputTextDelta: string;
        } & ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        onInputAvailable?: ((options: {
            input: {
                schema: any;
            };
        } & ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        toModelOutput?: ((options: {
            toolCallId: string;
            input: {
                schema: any;
            };
            output: NoInfer<{
                error: string;
                message: string;
                ok?: undefined;
            } | {
                ok: number;
                error?: undefined;
                message?: undefined;
            }>;
        }) => _ai_sdk_provider_utils.ToolResultOutput | PromiseLike<_ai_sdk_provider_utils.ToolResultOutput>) | undefined;
    } & {
        outputSchema?: ai.FlexibleSchema<{
            error: string;
            message: string;
            ok?: undefined;
        } | {
            ok: number;
            error?: undefined;
            message?: undefined;
        }> | undefined;
        execute: ai.ToolExecuteFunction<{
            schema: any;
        }, {
            error: string;
            message: string;
            ok?: undefined;
        } | {
            ok: number;
            error?: undefined;
            message?: undefined;
        }, NoInfer<_ai_sdk_provider_utils.Context>>;
    } & {
        type: "provider";
        id: `${string}.${string}`;
        args: Record<string, unknown>;
        description?: never;
        strict?: never;
        inputExamples?: never;
    } & {
        isProviderExecuted: false;
        supportsDeferredResults?: never;
    } & {
        execute: ai.ToolExecuteFunction<{
            schema: any;
        }, {
            error: string;
            message: string;
            ok?: undefined;
        } | {
            ok: number;
            error?: undefined;
            message?: undefined;
        }, NoInfer<_ai_sdk_provider_utils.Context>>;
    }) | ({
        deferLoading?: boolean;
        title?: string;
        providerOptions?: _ai_sdk_provider_utils.ProviderOptions;
        metadata?: _ai_sdk_provider.JSONObject;
        inputSchema: ai.FlexibleSchema<{
            schema: any;
        }>;
        contextSchema?: ai.FlexibleSchema<_ai_sdk_provider_utils.Context> | undefined;
        needsApproval?: boolean | _ai_sdk_provider_utils.ToolNeedsApprovalFunction<{
            schema: any;
        }, NoInfer<_ai_sdk_provider_utils.Context>> | undefined;
        onInputStart?: ((options: ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        onInputDelta?: ((options: {
            inputTextDelta: string;
        } & ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        onInputAvailable?: ((options: {
            input: {
                schema: any;
            };
        } & ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        toModelOutput?: ((options: {
            toolCallId: string;
            input: {
                schema: any;
            };
            output: NoInfer<{
                error: string;
                message: string;
                ok?: undefined;
            } | {
                ok: number;
                error?: undefined;
                message?: undefined;
            }>;
        }) => _ai_sdk_provider_utils.ToolResultOutput | PromiseLike<_ai_sdk_provider_utils.ToolResultOutput>) | undefined;
    } & {
        outputSchema?: ai.FlexibleSchema<{
            error: string;
            message: string;
            ok?: undefined;
        } | {
            ok: number;
            error?: undefined;
            message?: undefined;
        }> | undefined;
        execute: ai.ToolExecuteFunction<{
            schema: any;
        }, {
            error: string;
            message: string;
            ok?: undefined;
        } | {
            ok: number;
            error?: undefined;
            message?: undefined;
        }, NoInfer<_ai_sdk_provider_utils.Context>>;
    } & {
        type: "provider";
        id: `${string}.${string}`;
        args: Record<string, unknown>;
        description?: never;
        strict?: never;
        inputExamples?: never;
    } & {
        isProviderExecuted: true;
        supportsDeferredResults?: boolean;
    } & {
        execute: ai.ToolExecuteFunction<{
            schema: any;
        }, {
            error: string;
            message: string;
            ok?: undefined;
        } | {
            ok: number;
            error?: undefined;
            message?: undefined;
        }, NoInfer<_ai_sdk_provider_utils.Context>>;
    });
    get_flow_chart_schema: ({
        deferLoading?: boolean;
        title?: string;
        providerOptions?: _ai_sdk_provider_utils.ProviderOptions;
        metadata?: _ai_sdk_provider.JSONObject;
        inputSchema: ai.FlexibleSchema<Record<string, never>>;
        contextSchema?: ai.FlexibleSchema<_ai_sdk_provider_utils.Context> | undefined;
        needsApproval?: boolean | _ai_sdk_provider_utils.ToolNeedsApprovalFunction<Record<string, never>, NoInfer<_ai_sdk_provider_utils.Context>> | undefined;
        onInputStart?: ((options: ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        onInputDelta?: ((options: {
            inputTextDelta: string;
        } & ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        onInputAvailable?: ((options: {
            input: Record<string, never>;
        } & ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        toModelOutput?: ((options: {
            toolCallId: string;
            input: Record<string, never>;
            output: any;
        }) => _ai_sdk_provider_utils.ToolResultOutput | PromiseLike<_ai_sdk_provider_utils.ToolResultOutput>) | undefined;
    } & Partial<{
        outputSchema?: ai.FlexibleSchema<any> | undefined;
        execute: ai.ToolExecuteFunction<Record<string, never>, any, NoInfer<_ai_sdk_provider_utils.Context>>;
    }> & {
        description?: string | ((options: {
            context: NoInfer<_ai_sdk_provider_utils.Context>;
            experimental_sandbox?: ai.Experimental_SandboxSession;
        }) => string) | undefined;
        strict?: boolean;
        inputExamples?: {
            input: NoInfer<Record<string, never>>;
        }[] | undefined;
        id?: never;
        isProviderExecuted?: never;
        args?: never;
        supportsDeferredResults?: never;
    } & {
        type?: undefined | "function";
    } & {
        execute: ai.ToolExecuteFunction<Record<string, never>, any, NoInfer<_ai_sdk_provider_utils.Context>>;
    }) | ({
        deferLoading?: boolean;
        title?: string;
        providerOptions?: _ai_sdk_provider_utils.ProviderOptions;
        metadata?: _ai_sdk_provider.JSONObject;
        inputSchema: ai.FlexibleSchema<Record<string, never>>;
        contextSchema?: ai.FlexibleSchema<_ai_sdk_provider_utils.Context> | undefined;
        needsApproval?: boolean | _ai_sdk_provider_utils.ToolNeedsApprovalFunction<Record<string, never>, NoInfer<_ai_sdk_provider_utils.Context>> | undefined;
        onInputStart?: ((options: ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        onInputDelta?: ((options: {
            inputTextDelta: string;
        } & ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        onInputAvailable?: ((options: {
            input: Record<string, never>;
        } & ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        toModelOutput?: ((options: {
            toolCallId: string;
            input: Record<string, never>;
            output: any;
        }) => _ai_sdk_provider_utils.ToolResultOutput | PromiseLike<_ai_sdk_provider_utils.ToolResultOutput>) | undefined;
    } & Partial<{
        outputSchema?: ai.FlexibleSchema<any> | undefined;
        execute: ai.ToolExecuteFunction<Record<string, never>, any, NoInfer<_ai_sdk_provider_utils.Context>>;
    }> & {
        description?: string | ((options: {
            context: NoInfer<_ai_sdk_provider_utils.Context>;
            experimental_sandbox?: ai.Experimental_SandboxSession;
        }) => string) | undefined;
        strict?: boolean;
        inputExamples?: {
            input: NoInfer<Record<string, never>>;
        }[] | undefined;
        id?: never;
        isProviderExecuted?: never;
        args?: never;
        supportsDeferredResults?: never;
    } & {
        type: "dynamic";
    } & {
        execute: ai.ToolExecuteFunction<Record<string, never>, any, NoInfer<_ai_sdk_provider_utils.Context>>;
    }) | ({
        deferLoading?: boolean;
        title?: string;
        providerOptions?: _ai_sdk_provider_utils.ProviderOptions;
        metadata?: _ai_sdk_provider.JSONObject;
        inputSchema: ai.FlexibleSchema<Record<string, never>>;
        contextSchema?: ai.FlexibleSchema<_ai_sdk_provider_utils.Context> | undefined;
        needsApproval?: boolean | _ai_sdk_provider_utils.ToolNeedsApprovalFunction<Record<string, never>, NoInfer<_ai_sdk_provider_utils.Context>> | undefined;
        onInputStart?: ((options: ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        onInputDelta?: ((options: {
            inputTextDelta: string;
        } & ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        onInputAvailable?: ((options: {
            input: Record<string, never>;
        } & ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        toModelOutput?: ((options: {
            toolCallId: string;
            input: Record<string, never>;
            output: any;
        }) => _ai_sdk_provider_utils.ToolResultOutput | PromiseLike<_ai_sdk_provider_utils.ToolResultOutput>) | undefined;
    } & Partial<{
        outputSchema?: ai.FlexibleSchema<any> | undefined;
        execute: ai.ToolExecuteFunction<Record<string, never>, any, NoInfer<_ai_sdk_provider_utils.Context>>;
    }> & {
        type: "provider";
        id: `${string}.${string}`;
        args: Record<string, unknown>;
        description?: never;
        strict?: never;
        inputExamples?: never;
    } & {
        isProviderExecuted: false;
        supportsDeferredResults?: never;
    } & {
        execute: ai.ToolExecuteFunction<Record<string, never>, any, NoInfer<_ai_sdk_provider_utils.Context>>;
    }) | ({
        deferLoading?: boolean;
        title?: string;
        providerOptions?: _ai_sdk_provider_utils.ProviderOptions;
        metadata?: _ai_sdk_provider.JSONObject;
        inputSchema: ai.FlexibleSchema<Record<string, never>>;
        contextSchema?: ai.FlexibleSchema<_ai_sdk_provider_utils.Context> | undefined;
        needsApproval?: boolean | _ai_sdk_provider_utils.ToolNeedsApprovalFunction<Record<string, never>, NoInfer<_ai_sdk_provider_utils.Context>> | undefined;
        onInputStart?: ((options: ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        onInputDelta?: ((options: {
            inputTextDelta: string;
        } & ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        onInputAvailable?: ((options: {
            input: Record<string, never>;
        } & ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        toModelOutput?: ((options: {
            toolCallId: string;
            input: Record<string, never>;
            output: any;
        }) => _ai_sdk_provider_utils.ToolResultOutput | PromiseLike<_ai_sdk_provider_utils.ToolResultOutput>) | undefined;
    } & Partial<{
        outputSchema?: ai.FlexibleSchema<any> | undefined;
        execute: ai.ToolExecuteFunction<Record<string, never>, any, NoInfer<_ai_sdk_provider_utils.Context>>;
    }> & {
        type: "provider";
        id: `${string}.${string}`;
        args: Record<string, unknown>;
        description?: never;
        strict?: never;
        inputExamples?: never;
    } & {
        isProviderExecuted: true;
        supportsDeferredResults?: boolean;
    } & {
        execute: ai.ToolExecuteFunction<Record<string, never>, any, NoInfer<_ai_sdk_provider_utils.Context>>;
    });
    get_feeds: ({
        deferLoading?: boolean;
        title?: string;
        providerOptions?: _ai_sdk_provider_utils.ProviderOptions;
        metadata?: _ai_sdk_provider.JSONObject;
        inputSchema: ai.FlexibleSchema<{
            id: string | string[];
        }>;
        contextSchema?: ai.FlexibleSchema<_ai_sdk_provider_utils.Context> | undefined;
        needsApproval?: boolean | _ai_sdk_provider_utils.ToolNeedsApprovalFunction<{
            id: string | string[];
        }, NoInfer<_ai_sdk_provider_utils.Context>> | undefined;
        onInputStart?: ((options: ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        onInputDelta?: ((options: {
            inputTextDelta: string;
        } & ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        onInputAvailable?: ((options: {
            input: {
                id: string | string[];
            };
        } & ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        toModelOutput?: ((options: {
            toolCallId: string;
            input: {
                id: string | string[];
            };
            output: NoInfer<string | never[] | null>;
        }) => _ai_sdk_provider_utils.ToolResultOutput | PromiseLike<_ai_sdk_provider_utils.ToolResultOutput>) | undefined;
    } & {
        outputSchema?: ai.FlexibleSchema<string | never[] | null> | undefined;
        execute: ai.ToolExecuteFunction<{
            id: string | string[];
        }, string | never[] | null, NoInfer<_ai_sdk_provider_utils.Context>>;
    } & {
        description?: string | ((options: {
            context: NoInfer<_ai_sdk_provider_utils.Context>;
            experimental_sandbox?: ai.Experimental_SandboxSession;
        }) => string) | undefined;
        strict?: boolean;
        inputExamples?: {
            input: NoInfer<{
                id: string | string[];
            }>;
        }[] | undefined;
        id?: never;
        isProviderExecuted?: never;
        args?: never;
        supportsDeferredResults?: never;
    } & {
        type?: undefined | "function";
    } & {
        execute: ai.ToolExecuteFunction<{
            id: string | string[];
        }, string | never[] | null, NoInfer<_ai_sdk_provider_utils.Context>>;
    }) | ({
        deferLoading?: boolean;
        title?: string;
        providerOptions?: _ai_sdk_provider_utils.ProviderOptions;
        metadata?: _ai_sdk_provider.JSONObject;
        inputSchema: ai.FlexibleSchema<{
            id: string | string[];
        }>;
        contextSchema?: ai.FlexibleSchema<_ai_sdk_provider_utils.Context> | undefined;
        needsApproval?: boolean | _ai_sdk_provider_utils.ToolNeedsApprovalFunction<{
            id: string | string[];
        }, NoInfer<_ai_sdk_provider_utils.Context>> | undefined;
        onInputStart?: ((options: ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        onInputDelta?: ((options: {
            inputTextDelta: string;
        } & ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        onInputAvailable?: ((options: {
            input: {
                id: string | string[];
            };
        } & ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        toModelOutput?: ((options: {
            toolCallId: string;
            input: {
                id: string | string[];
            };
            output: NoInfer<string | never[] | null>;
        }) => _ai_sdk_provider_utils.ToolResultOutput | PromiseLike<_ai_sdk_provider_utils.ToolResultOutput>) | undefined;
    } & {
        outputSchema?: ai.FlexibleSchema<string | never[] | null> | undefined;
        execute: ai.ToolExecuteFunction<{
            id: string | string[];
        }, string | never[] | null, NoInfer<_ai_sdk_provider_utils.Context>>;
    } & {
        description?: string | ((options: {
            context: NoInfer<_ai_sdk_provider_utils.Context>;
            experimental_sandbox?: ai.Experimental_SandboxSession;
        }) => string) | undefined;
        strict?: boolean;
        inputExamples?: {
            input: NoInfer<{
                id: string | string[];
            }>;
        }[] | undefined;
        id?: never;
        isProviderExecuted?: never;
        args?: never;
        supportsDeferredResults?: never;
    } & {
        type: "dynamic";
    } & {
        execute: ai.ToolExecuteFunction<{
            id: string | string[];
        }, string | never[] | null, NoInfer<_ai_sdk_provider_utils.Context>>;
    }) | ({
        deferLoading?: boolean;
        title?: string;
        providerOptions?: _ai_sdk_provider_utils.ProviderOptions;
        metadata?: _ai_sdk_provider.JSONObject;
        inputSchema: ai.FlexibleSchema<{
            id: string | string[];
        }>;
        contextSchema?: ai.FlexibleSchema<_ai_sdk_provider_utils.Context> | undefined;
        needsApproval?: boolean | _ai_sdk_provider_utils.ToolNeedsApprovalFunction<{
            id: string | string[];
        }, NoInfer<_ai_sdk_provider_utils.Context>> | undefined;
        onInputStart?: ((options: ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        onInputDelta?: ((options: {
            inputTextDelta: string;
        } & ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        onInputAvailable?: ((options: {
            input: {
                id: string | string[];
            };
        } & ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        toModelOutput?: ((options: {
            toolCallId: string;
            input: {
                id: string | string[];
            };
            output: NoInfer<string | never[] | null>;
        }) => _ai_sdk_provider_utils.ToolResultOutput | PromiseLike<_ai_sdk_provider_utils.ToolResultOutput>) | undefined;
    } & {
        outputSchema?: ai.FlexibleSchema<string | never[] | null> | undefined;
        execute: ai.ToolExecuteFunction<{
            id: string | string[];
        }, string | never[] | null, NoInfer<_ai_sdk_provider_utils.Context>>;
    } & {
        type: "provider";
        id: `${string}.${string}`;
        args: Record<string, unknown>;
        description?: never;
        strict?: never;
        inputExamples?: never;
    } & {
        isProviderExecuted: false;
        supportsDeferredResults?: never;
    } & {
        execute: ai.ToolExecuteFunction<{
            id: string | string[];
        }, string | never[] | null, NoInfer<_ai_sdk_provider_utils.Context>>;
    }) | ({
        deferLoading?: boolean;
        title?: string;
        providerOptions?: _ai_sdk_provider_utils.ProviderOptions;
        metadata?: _ai_sdk_provider.JSONObject;
        inputSchema: ai.FlexibleSchema<{
            id: string | string[];
        }>;
        contextSchema?: ai.FlexibleSchema<_ai_sdk_provider_utils.Context> | undefined;
        needsApproval?: boolean | _ai_sdk_provider_utils.ToolNeedsApprovalFunction<{
            id: string | string[];
        }, NoInfer<_ai_sdk_provider_utils.Context>> | undefined;
        onInputStart?: ((options: ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        onInputDelta?: ((options: {
            inputTextDelta: string;
        } & ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        onInputAvailable?: ((options: {
            input: {
                id: string | string[];
            };
        } & ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        toModelOutput?: ((options: {
            toolCallId: string;
            input: {
                id: string | string[];
            };
            output: NoInfer<string | never[] | null>;
        }) => _ai_sdk_provider_utils.ToolResultOutput | PromiseLike<_ai_sdk_provider_utils.ToolResultOutput>) | undefined;
    } & {
        outputSchema?: ai.FlexibleSchema<string | never[] | null> | undefined;
        execute: ai.ToolExecuteFunction<{
            id: string | string[];
        }, string | never[] | null, NoInfer<_ai_sdk_provider_utils.Context>>;
    } & {
        type: "provider";
        id: `${string}.${string}`;
        args: Record<string, unknown>;
        description?: never;
        strict?: never;
        inputExamples?: never;
    } & {
        isProviderExecuted: true;
        supportsDeferredResults?: boolean;
    } & {
        execute: ai.ToolExecuteFunction<{
            id: string | string[];
        }, string | never[] | null, NoInfer<_ai_sdk_provider_utils.Context>>;
    });
    get_entries: ({
        deferLoading?: boolean;
        title?: string;
        providerOptions?: _ai_sdk_provider_utils.ProviderOptions;
        metadata?: _ai_sdk_provider.JSONObject;
        inputSchema: ai.FlexibleSchema<{
            id: string | string[];
            mode: "concise" | "detailed";
        }>;
        contextSchema?: ai.FlexibleSchema<_ai_sdk_provider_utils.Context> | undefined;
        needsApproval?: boolean | _ai_sdk_provider_utils.ToolNeedsApprovalFunction<{
            id: string | string[];
            mode: "concise" | "detailed";
        }, NoInfer<_ai_sdk_provider_utils.Context>> | undefined;
        onInputStart?: ((options: ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        onInputDelta?: ((options: {
            inputTextDelta: string;
        } & ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        onInputAvailable?: ((options: {
            input: {
                id: string | string[];
                mode: "concise" | "detailed";
            };
        } & ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        toModelOutput?: ((options: {
            toolCallId: string;
            input: {
                id: string | string[];
                mode: "concise" | "detailed";
            };
            output: NoInfer<string | string[] | null>;
        }) => _ai_sdk_provider_utils.ToolResultOutput | PromiseLike<_ai_sdk_provider_utils.ToolResultOutput>) | undefined;
    } & {
        outputSchema?: ai.FlexibleSchema<string | string[] | null> | undefined;
        execute: ai.ToolExecuteFunction<{
            id: string | string[];
            mode: "concise" | "detailed";
        }, string | string[] | null, NoInfer<_ai_sdk_provider_utils.Context>>;
    } & {
        description?: string | ((options: {
            context: NoInfer<_ai_sdk_provider_utils.Context>;
            experimental_sandbox?: ai.Experimental_SandboxSession;
        }) => string) | undefined;
        strict?: boolean;
        inputExamples?: {
            input: NoInfer<{
                id: string | string[];
                mode: "concise" | "detailed";
            }>;
        }[] | undefined;
        id?: never;
        isProviderExecuted?: never;
        args?: never;
        supportsDeferredResults?: never;
    } & {
        type?: undefined | "function";
    } & {
        execute: ai.ToolExecuteFunction<{
            id: string | string[];
            mode: "concise" | "detailed";
        }, string | string[] | null, NoInfer<_ai_sdk_provider_utils.Context>>;
    }) | ({
        deferLoading?: boolean;
        title?: string;
        providerOptions?: _ai_sdk_provider_utils.ProviderOptions;
        metadata?: _ai_sdk_provider.JSONObject;
        inputSchema: ai.FlexibleSchema<{
            id: string | string[];
            mode: "concise" | "detailed";
        }>;
        contextSchema?: ai.FlexibleSchema<_ai_sdk_provider_utils.Context> | undefined;
        needsApproval?: boolean | _ai_sdk_provider_utils.ToolNeedsApprovalFunction<{
            id: string | string[];
            mode: "concise" | "detailed";
        }, NoInfer<_ai_sdk_provider_utils.Context>> | undefined;
        onInputStart?: ((options: ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        onInputDelta?: ((options: {
            inputTextDelta: string;
        } & ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        onInputAvailable?: ((options: {
            input: {
                id: string | string[];
                mode: "concise" | "detailed";
            };
        } & ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        toModelOutput?: ((options: {
            toolCallId: string;
            input: {
                id: string | string[];
                mode: "concise" | "detailed";
            };
            output: NoInfer<string | string[] | null>;
        }) => _ai_sdk_provider_utils.ToolResultOutput | PromiseLike<_ai_sdk_provider_utils.ToolResultOutput>) | undefined;
    } & {
        outputSchema?: ai.FlexibleSchema<string | string[] | null> | undefined;
        execute: ai.ToolExecuteFunction<{
            id: string | string[];
            mode: "concise" | "detailed";
        }, string | string[] | null, NoInfer<_ai_sdk_provider_utils.Context>>;
    } & {
        description?: string | ((options: {
            context: NoInfer<_ai_sdk_provider_utils.Context>;
            experimental_sandbox?: ai.Experimental_SandboxSession;
        }) => string) | undefined;
        strict?: boolean;
        inputExamples?: {
            input: NoInfer<{
                id: string | string[];
                mode: "concise" | "detailed";
            }>;
        }[] | undefined;
        id?: never;
        isProviderExecuted?: never;
        args?: never;
        supportsDeferredResults?: never;
    } & {
        type: "dynamic";
    } & {
        execute: ai.ToolExecuteFunction<{
            id: string | string[];
            mode: "concise" | "detailed";
        }, string | string[] | null, NoInfer<_ai_sdk_provider_utils.Context>>;
    }) | ({
        deferLoading?: boolean;
        title?: string;
        providerOptions?: _ai_sdk_provider_utils.ProviderOptions;
        metadata?: _ai_sdk_provider.JSONObject;
        inputSchema: ai.FlexibleSchema<{
            id: string | string[];
            mode: "concise" | "detailed";
        }>;
        contextSchema?: ai.FlexibleSchema<_ai_sdk_provider_utils.Context> | undefined;
        needsApproval?: boolean | _ai_sdk_provider_utils.ToolNeedsApprovalFunction<{
            id: string | string[];
            mode: "concise" | "detailed";
        }, NoInfer<_ai_sdk_provider_utils.Context>> | undefined;
        onInputStart?: ((options: ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        onInputDelta?: ((options: {
            inputTextDelta: string;
        } & ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        onInputAvailable?: ((options: {
            input: {
                id: string | string[];
                mode: "concise" | "detailed";
            };
        } & ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        toModelOutput?: ((options: {
            toolCallId: string;
            input: {
                id: string | string[];
                mode: "concise" | "detailed";
            };
            output: NoInfer<string | string[] | null>;
        }) => _ai_sdk_provider_utils.ToolResultOutput | PromiseLike<_ai_sdk_provider_utils.ToolResultOutput>) | undefined;
    } & {
        outputSchema?: ai.FlexibleSchema<string | string[] | null> | undefined;
        execute: ai.ToolExecuteFunction<{
            id: string | string[];
            mode: "concise" | "detailed";
        }, string | string[] | null, NoInfer<_ai_sdk_provider_utils.Context>>;
    } & {
        type: "provider";
        id: `${string}.${string}`;
        args: Record<string, unknown>;
        description?: never;
        strict?: never;
        inputExamples?: never;
    } & {
        isProviderExecuted: false;
        supportsDeferredResults?: never;
    } & {
        execute: ai.ToolExecuteFunction<{
            id: string | string[];
            mode: "concise" | "detailed";
        }, string | string[] | null, NoInfer<_ai_sdk_provider_utils.Context>>;
    }) | ({
        deferLoading?: boolean;
        title?: string;
        providerOptions?: _ai_sdk_provider_utils.ProviderOptions;
        metadata?: _ai_sdk_provider.JSONObject;
        inputSchema: ai.FlexibleSchema<{
            id: string | string[];
            mode: "concise" | "detailed";
        }>;
        contextSchema?: ai.FlexibleSchema<_ai_sdk_provider_utils.Context> | undefined;
        needsApproval?: boolean | _ai_sdk_provider_utils.ToolNeedsApprovalFunction<{
            id: string | string[];
            mode: "concise" | "detailed";
        }, NoInfer<_ai_sdk_provider_utils.Context>> | undefined;
        onInputStart?: ((options: ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        onInputDelta?: ((options: {
            inputTextDelta: string;
        } & ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        onInputAvailable?: ((options: {
            input: {
                id: string | string[];
                mode: "concise" | "detailed";
            };
        } & ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        toModelOutput?: ((options: {
            toolCallId: string;
            input: {
                id: string | string[];
                mode: "concise" | "detailed";
            };
            output: NoInfer<string | string[] | null>;
        }) => _ai_sdk_provider_utils.ToolResultOutput | PromiseLike<_ai_sdk_provider_utils.ToolResultOutput>) | undefined;
    } & {
        outputSchema?: ai.FlexibleSchema<string | string[] | null> | undefined;
        execute: ai.ToolExecuteFunction<{
            id: string | string[];
            mode: "concise" | "detailed";
        }, string | string[] | null, NoInfer<_ai_sdk_provider_utils.Context>>;
    } & {
        type: "provider";
        id: `${string}.${string}`;
        args: Record<string, unknown>;
        description?: never;
        strict?: never;
        inputExamples?: never;
    } & {
        isProviderExecuted: true;
        supportsDeferredResults?: boolean;
    } & {
        execute: ai.ToolExecuteFunction<{
            id: string | string[];
            mode: "concise" | "detailed";
        }, string | string[] | null, NoInfer<_ai_sdk_provider_utils.Context>>;
    });
    get_whoami: ({
        deferLoading?: boolean;
        title?: string;
        providerOptions?: _ai_sdk_provider_utils.ProviderOptions;
        metadata?: _ai_sdk_provider.JSONObject;
        inputSchema: ai.FlexibleSchema<{
            select?: ("name" | "id" | "email" | "emailVerified" | "image" | "handle" | "createdAt" | "updatedAt" | "twoFactorEnabled" | "bio" | "website" | "socialLinks")[] | undefined;
        }>;
        contextSchema?: ai.FlexibleSchema<{
            userId: string;
        }> | undefined;
        needsApproval?: boolean | _ai_sdk_provider_utils.ToolNeedsApprovalFunction<{
            select?: ("name" | "id" | "email" | "emailVerified" | "image" | "handle" | "createdAt" | "updatedAt" | "twoFactorEnabled" | "bio" | "website" | "socialLinks")[] | undefined;
        }, NoInfer<{
            userId: string;
        }>> | undefined;
        onInputStart?: ((options: ai.ToolExecutionOptions<NoInfer<{
            userId: string;
        }>>) => void | PromiseLike<void>) | undefined;
        onInputDelta?: ((options: {
            inputTextDelta: string;
        } & ai.ToolExecutionOptions<NoInfer<{
            userId: string;
        }>>) => void | PromiseLike<void>) | undefined;
        onInputAvailable?: ((options: {
            input: {
                select?: ("name" | "id" | "email" | "emailVerified" | "image" | "handle" | "createdAt" | "updatedAt" | "twoFactorEnabled" | "bio" | "website" | "socialLinks")[] | undefined;
            };
        } & ai.ToolExecutionOptions<NoInfer<{
            userId: string;
        }>>) => void | PromiseLike<void>) | undefined;
        toModelOutput?: ((options: {
            toolCallId: string;
            input: {
                select?: ("name" | "id" | "email" | "emailVerified" | "image" | "handle" | "createdAt" | "updatedAt" | "twoFactorEnabled" | "bio" | "website" | "socialLinks")[] | undefined;
            };
            output: string;
        }) => _ai_sdk_provider_utils.ToolResultOutput | PromiseLike<_ai_sdk_provider_utils.ToolResultOutput>) | undefined;
    } & {
        outputSchema?: ai.FlexibleSchema<string> | undefined;
        execute: ai.ToolExecuteFunction<{
            select?: ("name" | "id" | "email" | "emailVerified" | "image" | "handle" | "createdAt" | "updatedAt" | "twoFactorEnabled" | "bio" | "website" | "socialLinks")[] | undefined;
        }, string, NoInfer<{
            userId: string;
        }>>;
    } & {
        description?: string | ((options: {
            context: NoInfer<{
                userId: string;
            }>;
            experimental_sandbox?: ai.Experimental_SandboxSession;
        }) => string) | undefined;
        strict?: boolean;
        inputExamples?: {
            input: NoInfer<{
                select?: ("name" | "id" | "email" | "emailVerified" | "image" | "handle" | "createdAt" | "updatedAt" | "twoFactorEnabled" | "bio" | "website" | "socialLinks")[] | undefined;
            }>;
        }[] | undefined;
        id?: never;
        isProviderExecuted?: never;
        args?: never;
        supportsDeferredResults?: never;
    } & {
        type?: undefined | "function";
    } & {
        execute: ai.ToolExecuteFunction<{
            select?: ("name" | "id" | "email" | "emailVerified" | "image" | "handle" | "createdAt" | "updatedAt" | "twoFactorEnabled" | "bio" | "website" | "socialLinks")[] | undefined;
        }, string, NoInfer<{
            userId: string;
        }>>;
    }) | ({
        deferLoading?: boolean;
        title?: string;
        providerOptions?: _ai_sdk_provider_utils.ProviderOptions;
        metadata?: _ai_sdk_provider.JSONObject;
        inputSchema: ai.FlexibleSchema<{
            select?: ("name" | "id" | "email" | "emailVerified" | "image" | "handle" | "createdAt" | "updatedAt" | "twoFactorEnabled" | "bio" | "website" | "socialLinks")[] | undefined;
        }>;
        contextSchema?: ai.FlexibleSchema<{
            userId: string;
        }> | undefined;
        needsApproval?: boolean | _ai_sdk_provider_utils.ToolNeedsApprovalFunction<{
            select?: ("name" | "id" | "email" | "emailVerified" | "image" | "handle" | "createdAt" | "updatedAt" | "twoFactorEnabled" | "bio" | "website" | "socialLinks")[] | undefined;
        }, NoInfer<{
            userId: string;
        }>> | undefined;
        onInputStart?: ((options: ai.ToolExecutionOptions<NoInfer<{
            userId: string;
        }>>) => void | PromiseLike<void>) | undefined;
        onInputDelta?: ((options: {
            inputTextDelta: string;
        } & ai.ToolExecutionOptions<NoInfer<{
            userId: string;
        }>>) => void | PromiseLike<void>) | undefined;
        onInputAvailable?: ((options: {
            input: {
                select?: ("name" | "id" | "email" | "emailVerified" | "image" | "handle" | "createdAt" | "updatedAt" | "twoFactorEnabled" | "bio" | "website" | "socialLinks")[] | undefined;
            };
        } & ai.ToolExecutionOptions<NoInfer<{
            userId: string;
        }>>) => void | PromiseLike<void>) | undefined;
        toModelOutput?: ((options: {
            toolCallId: string;
            input: {
                select?: ("name" | "id" | "email" | "emailVerified" | "image" | "handle" | "createdAt" | "updatedAt" | "twoFactorEnabled" | "bio" | "website" | "socialLinks")[] | undefined;
            };
            output: string;
        }) => _ai_sdk_provider_utils.ToolResultOutput | PromiseLike<_ai_sdk_provider_utils.ToolResultOutput>) | undefined;
    } & {
        outputSchema?: ai.FlexibleSchema<string> | undefined;
        execute: ai.ToolExecuteFunction<{
            select?: ("name" | "id" | "email" | "emailVerified" | "image" | "handle" | "createdAt" | "updatedAt" | "twoFactorEnabled" | "bio" | "website" | "socialLinks")[] | undefined;
        }, string, NoInfer<{
            userId: string;
        }>>;
    } & {
        description?: string | ((options: {
            context: NoInfer<{
                userId: string;
            }>;
            experimental_sandbox?: ai.Experimental_SandboxSession;
        }) => string) | undefined;
        strict?: boolean;
        inputExamples?: {
            input: NoInfer<{
                select?: ("name" | "id" | "email" | "emailVerified" | "image" | "handle" | "createdAt" | "updatedAt" | "twoFactorEnabled" | "bio" | "website" | "socialLinks")[] | undefined;
            }>;
        }[] | undefined;
        id?: never;
        isProviderExecuted?: never;
        args?: never;
        supportsDeferredResults?: never;
    } & {
        type: "dynamic";
    } & {
        execute: ai.ToolExecuteFunction<{
            select?: ("name" | "id" | "email" | "emailVerified" | "image" | "handle" | "createdAt" | "updatedAt" | "twoFactorEnabled" | "bio" | "website" | "socialLinks")[] | undefined;
        }, string, NoInfer<{
            userId: string;
        }>>;
    }) | ({
        deferLoading?: boolean;
        title?: string;
        providerOptions?: _ai_sdk_provider_utils.ProviderOptions;
        metadata?: _ai_sdk_provider.JSONObject;
        inputSchema: ai.FlexibleSchema<{
            select?: ("name" | "id" | "email" | "emailVerified" | "image" | "handle" | "createdAt" | "updatedAt" | "twoFactorEnabled" | "bio" | "website" | "socialLinks")[] | undefined;
        }>;
        contextSchema?: ai.FlexibleSchema<{
            userId: string;
        }> | undefined;
        needsApproval?: boolean | _ai_sdk_provider_utils.ToolNeedsApprovalFunction<{
            select?: ("name" | "id" | "email" | "emailVerified" | "image" | "handle" | "createdAt" | "updatedAt" | "twoFactorEnabled" | "bio" | "website" | "socialLinks")[] | undefined;
        }, NoInfer<{
            userId: string;
        }>> | undefined;
        onInputStart?: ((options: ai.ToolExecutionOptions<NoInfer<{
            userId: string;
        }>>) => void | PromiseLike<void>) | undefined;
        onInputDelta?: ((options: {
            inputTextDelta: string;
        } & ai.ToolExecutionOptions<NoInfer<{
            userId: string;
        }>>) => void | PromiseLike<void>) | undefined;
        onInputAvailable?: ((options: {
            input: {
                select?: ("name" | "id" | "email" | "emailVerified" | "image" | "handle" | "createdAt" | "updatedAt" | "twoFactorEnabled" | "bio" | "website" | "socialLinks")[] | undefined;
            };
        } & ai.ToolExecutionOptions<NoInfer<{
            userId: string;
        }>>) => void | PromiseLike<void>) | undefined;
        toModelOutput?: ((options: {
            toolCallId: string;
            input: {
                select?: ("name" | "id" | "email" | "emailVerified" | "image" | "handle" | "createdAt" | "updatedAt" | "twoFactorEnabled" | "bio" | "website" | "socialLinks")[] | undefined;
            };
            output: string;
        }) => _ai_sdk_provider_utils.ToolResultOutput | PromiseLike<_ai_sdk_provider_utils.ToolResultOutput>) | undefined;
    } & {
        outputSchema?: ai.FlexibleSchema<string> | undefined;
        execute: ai.ToolExecuteFunction<{
            select?: ("name" | "id" | "email" | "emailVerified" | "image" | "handle" | "createdAt" | "updatedAt" | "twoFactorEnabled" | "bio" | "website" | "socialLinks")[] | undefined;
        }, string, NoInfer<{
            userId: string;
        }>>;
    } & {
        type: "provider";
        id: `${string}.${string}`;
        args: Record<string, unknown>;
        description?: never;
        strict?: never;
        inputExamples?: never;
    } & {
        isProviderExecuted: false;
        supportsDeferredResults?: never;
    } & {
        execute: ai.ToolExecuteFunction<{
            select?: ("name" | "id" | "email" | "emailVerified" | "image" | "handle" | "createdAt" | "updatedAt" | "twoFactorEnabled" | "bio" | "website" | "socialLinks")[] | undefined;
        }, string, NoInfer<{
            userId: string;
        }>>;
    }) | ({
        deferLoading?: boolean;
        title?: string;
        providerOptions?: _ai_sdk_provider_utils.ProviderOptions;
        metadata?: _ai_sdk_provider.JSONObject;
        inputSchema: ai.FlexibleSchema<{
            select?: ("name" | "id" | "email" | "emailVerified" | "image" | "handle" | "createdAt" | "updatedAt" | "twoFactorEnabled" | "bio" | "website" | "socialLinks")[] | undefined;
        }>;
        contextSchema?: ai.FlexibleSchema<{
            userId: string;
        }> | undefined;
        needsApproval?: boolean | _ai_sdk_provider_utils.ToolNeedsApprovalFunction<{
            select?: ("name" | "id" | "email" | "emailVerified" | "image" | "handle" | "createdAt" | "updatedAt" | "twoFactorEnabled" | "bio" | "website" | "socialLinks")[] | undefined;
        }, NoInfer<{
            userId: string;
        }>> | undefined;
        onInputStart?: ((options: ai.ToolExecutionOptions<NoInfer<{
            userId: string;
        }>>) => void | PromiseLike<void>) | undefined;
        onInputDelta?: ((options: {
            inputTextDelta: string;
        } & ai.ToolExecutionOptions<NoInfer<{
            userId: string;
        }>>) => void | PromiseLike<void>) | undefined;
        onInputAvailable?: ((options: {
            input: {
                select?: ("name" | "id" | "email" | "emailVerified" | "image" | "handle" | "createdAt" | "updatedAt" | "twoFactorEnabled" | "bio" | "website" | "socialLinks")[] | undefined;
            };
        } & ai.ToolExecutionOptions<NoInfer<{
            userId: string;
        }>>) => void | PromiseLike<void>) | undefined;
        toModelOutput?: ((options: {
            toolCallId: string;
            input: {
                select?: ("name" | "id" | "email" | "emailVerified" | "image" | "handle" | "createdAt" | "updatedAt" | "twoFactorEnabled" | "bio" | "website" | "socialLinks")[] | undefined;
            };
            output: string;
        }) => _ai_sdk_provider_utils.ToolResultOutput | PromiseLike<_ai_sdk_provider_utils.ToolResultOutput>) | undefined;
    } & {
        outputSchema?: ai.FlexibleSchema<string> | undefined;
        execute: ai.ToolExecuteFunction<{
            select?: ("name" | "id" | "email" | "emailVerified" | "image" | "handle" | "createdAt" | "updatedAt" | "twoFactorEnabled" | "bio" | "website" | "socialLinks")[] | undefined;
        }, string, NoInfer<{
            userId: string;
        }>>;
    } & {
        type: "provider";
        id: `${string}.${string}`;
        args: Record<string, unknown>;
        description?: never;
        strict?: never;
        inputExamples?: never;
    } & {
        isProviderExecuted: true;
        supportsDeferredResults?: boolean;
    } & {
        execute: ai.ToolExecuteFunction<{
            select?: ("name" | "id" | "email" | "emailVerified" | "image" | "handle" | "createdAt" | "updatedAt" | "twoFactorEnabled" | "bio" | "website" | "socialLinks")[] | undefined;
        }, string, NoInfer<{
            userId: string;
        }>>;
    });
    search: ({
        deferLoading?: boolean;
        title?: string;
        providerOptions?: _ai_sdk_provider_utils.ProviderOptions;
        metadata?: _ai_sdk_provider.JSONObject;
        inputSchema: ai.FlexibleSchema<{
            scope: "feeds.all" | "feeds.userSubscriptions" | "entries.all" | "entries.userTimeline" | "entries.userStarred";
            query: ({
                field: "feeds.name" | "feeds.description" | "feeds.url" | "feeds.siteUrl" | "feeds.rsshubRoute" | "feeds.userSubscriptionsCategory" | "entries.content" | "entries.author" | "entries.feedId";
                operation: "eq" | "ilike";
                value: string | string[];
            } | {
                field: "feeds.userSubscriptionsView" | "feeds.subscriptionCount" | "feeds.updatesPerWeek" | "entries.userTimelineView";
                operation: "eq" | "gt" | "lt";
                value: number;
            } | {
                field: "entries.userTimelineRead";
                operation: "eq";
                value: boolean;
            } | {
                field: "entries.publishedAt";
                operation: "eq" | "gt" | "lt";
                value: string;
            })[] | null;
            order?: {
                field: "feeds.subscriptionCount" | "feeds.updatesPerWeek" | "entries.publishedAt";
                direction: "asc" | "desc";
            } | null | undefined;
        }>;
        contextSchema?: ai.FlexibleSchema<{
            userId?: string | undefined;
        }> | undefined;
        needsApproval?: boolean | _ai_sdk_provider_utils.ToolNeedsApprovalFunction<{
            scope: "feeds.all" | "feeds.userSubscriptions" | "entries.all" | "entries.userTimeline" | "entries.userStarred";
            query: ({
                field: "feeds.name" | "feeds.description" | "feeds.url" | "feeds.siteUrl" | "feeds.rsshubRoute" | "feeds.userSubscriptionsCategory" | "entries.content" | "entries.author" | "entries.feedId";
                operation: "eq" | "ilike";
                value: string | string[];
            } | {
                field: "feeds.userSubscriptionsView" | "feeds.subscriptionCount" | "feeds.updatesPerWeek" | "entries.userTimelineView";
                operation: "eq" | "gt" | "lt";
                value: number;
            } | {
                field: "entries.userTimelineRead";
                operation: "eq";
                value: boolean;
            } | {
                field: "entries.publishedAt";
                operation: "eq" | "gt" | "lt";
                value: string;
            })[] | null;
            order?: {
                field: "feeds.subscriptionCount" | "feeds.updatesPerWeek" | "entries.publishedAt";
                direction: "asc" | "desc";
            } | null | undefined;
        }, NoInfer<{
            userId?: string | undefined;
        }>> | undefined;
        onInputStart?: ((options: ai.ToolExecutionOptions<NoInfer<{
            userId?: string | undefined;
        }>>) => void | PromiseLike<void>) | undefined;
        onInputDelta?: ((options: {
            inputTextDelta: string;
        } & ai.ToolExecutionOptions<NoInfer<{
            userId?: string | undefined;
        }>>) => void | PromiseLike<void>) | undefined;
        onInputAvailable?: ((options: {
            input: {
                scope: "feeds.all" | "feeds.userSubscriptions" | "entries.all" | "entries.userTimeline" | "entries.userStarred";
                query: ({
                    field: "feeds.name" | "feeds.description" | "feeds.url" | "feeds.siteUrl" | "feeds.rsshubRoute" | "feeds.userSubscriptionsCategory" | "entries.content" | "entries.author" | "entries.feedId";
                    operation: "eq" | "ilike";
                    value: string | string[];
                } | {
                    field: "feeds.userSubscriptionsView" | "feeds.subscriptionCount" | "feeds.updatesPerWeek" | "entries.userTimelineView";
                    operation: "eq" | "gt" | "lt";
                    value: number;
                } | {
                    field: "entries.userTimelineRead";
                    operation: "eq";
                    value: boolean;
                } | {
                    field: "entries.publishedAt";
                    operation: "eq" | "gt" | "lt";
                    value: string;
                })[] | null;
                order?: {
                    field: "feeds.subscriptionCount" | "feeds.updatesPerWeek" | "entries.publishedAt";
                    direction: "asc" | "desc";
                } | null | undefined;
            };
        } & ai.ToolExecutionOptions<NoInfer<{
            userId?: string | undefined;
        }>>) => void | PromiseLike<void>) | undefined;
        toModelOutput?: ((options: {
            toolCallId: string;
            input: {
                scope: "feeds.all" | "feeds.userSubscriptions" | "entries.all" | "entries.userTimeline" | "entries.userStarred";
                query: ({
                    field: "feeds.name" | "feeds.description" | "feeds.url" | "feeds.siteUrl" | "feeds.rsshubRoute" | "feeds.userSubscriptionsCategory" | "entries.content" | "entries.author" | "entries.feedId";
                    operation: "eq" | "ilike";
                    value: string | string[];
                } | {
                    field: "feeds.userSubscriptionsView" | "feeds.subscriptionCount" | "feeds.updatesPerWeek" | "entries.userTimelineView";
                    operation: "eq" | "gt" | "lt";
                    value: number;
                } | {
                    field: "entries.userTimelineRead";
                    operation: "eq";
                    value: boolean;
                } | {
                    field: "entries.publishedAt";
                    operation: "eq" | "gt" | "lt";
                    value: string;
                })[] | null;
                order?: {
                    field: "feeds.subscriptionCount" | "feeds.updatesPerWeek" | "entries.publishedAt";
                    direction: "asc" | "desc";
                } | null | undefined;
            };
            output: string;
        }) => _ai_sdk_provider_utils.ToolResultOutput | PromiseLike<_ai_sdk_provider_utils.ToolResultOutput>) | undefined;
    } & {
        outputSchema?: ai.FlexibleSchema<string> | undefined;
        execute: ai.ToolExecuteFunction<{
            scope: "feeds.all" | "feeds.userSubscriptions" | "entries.all" | "entries.userTimeline" | "entries.userStarred";
            query: ({
                field: "feeds.name" | "feeds.description" | "feeds.url" | "feeds.siteUrl" | "feeds.rsshubRoute" | "feeds.userSubscriptionsCategory" | "entries.content" | "entries.author" | "entries.feedId";
                operation: "eq" | "ilike";
                value: string | string[];
            } | {
                field: "feeds.userSubscriptionsView" | "feeds.subscriptionCount" | "feeds.updatesPerWeek" | "entries.userTimelineView";
                operation: "eq" | "gt" | "lt";
                value: number;
            } | {
                field: "entries.userTimelineRead";
                operation: "eq";
                value: boolean;
            } | {
                field: "entries.publishedAt";
                operation: "eq" | "gt" | "lt";
                value: string;
            })[] | null;
            order?: {
                field: "feeds.subscriptionCount" | "feeds.updatesPerWeek" | "entries.publishedAt";
                direction: "asc" | "desc";
            } | null | undefined;
        }, string, NoInfer<{
            userId?: string | undefined;
        }>>;
    } & {
        description?: string | ((options: {
            context: NoInfer<{
                userId?: string | undefined;
            }>;
            experimental_sandbox?: ai.Experimental_SandboxSession;
        }) => string) | undefined;
        strict?: boolean;
        inputExamples?: {
            input: NoInfer<{
                scope: "feeds.all" | "feeds.userSubscriptions" | "entries.all" | "entries.userTimeline" | "entries.userStarred";
                query: ({
                    field: "feeds.name" | "feeds.description" | "feeds.url" | "feeds.siteUrl" | "feeds.rsshubRoute" | "feeds.userSubscriptionsCategory" | "entries.content" | "entries.author" | "entries.feedId";
                    operation: "eq" | "ilike";
                    value: string | string[];
                } | {
                    field: "feeds.userSubscriptionsView" | "feeds.subscriptionCount" | "feeds.updatesPerWeek" | "entries.userTimelineView";
                    operation: "eq" | "gt" | "lt";
                    value: number;
                } | {
                    field: "entries.userTimelineRead";
                    operation: "eq";
                    value: boolean;
                } | {
                    field: "entries.publishedAt";
                    operation: "eq" | "gt" | "lt";
                    value: string;
                })[] | null;
                order?: {
                    field: "feeds.subscriptionCount" | "feeds.updatesPerWeek" | "entries.publishedAt";
                    direction: "asc" | "desc";
                } | null | undefined;
            }>;
        }[] | undefined;
        id?: never;
        isProviderExecuted?: never;
        args?: never;
        supportsDeferredResults?: never;
    } & {
        type?: undefined | "function";
    } & {
        execute: ai.ToolExecuteFunction<{
            scope: "feeds.all" | "feeds.userSubscriptions" | "entries.all" | "entries.userTimeline" | "entries.userStarred";
            query: ({
                field: "feeds.name" | "feeds.description" | "feeds.url" | "feeds.siteUrl" | "feeds.rsshubRoute" | "feeds.userSubscriptionsCategory" | "entries.content" | "entries.author" | "entries.feedId";
                operation: "eq" | "ilike";
                value: string | string[];
            } | {
                field: "feeds.userSubscriptionsView" | "feeds.subscriptionCount" | "feeds.updatesPerWeek" | "entries.userTimelineView";
                operation: "eq" | "gt" | "lt";
                value: number;
            } | {
                field: "entries.userTimelineRead";
                operation: "eq";
                value: boolean;
            } | {
                field: "entries.publishedAt";
                operation: "eq" | "gt" | "lt";
                value: string;
            })[] | null;
            order?: {
                field: "feeds.subscriptionCount" | "feeds.updatesPerWeek" | "entries.publishedAt";
                direction: "asc" | "desc";
            } | null | undefined;
        }, string, NoInfer<{
            userId?: string | undefined;
        }>>;
    }) | ({
        deferLoading?: boolean;
        title?: string;
        providerOptions?: _ai_sdk_provider_utils.ProviderOptions;
        metadata?: _ai_sdk_provider.JSONObject;
        inputSchema: ai.FlexibleSchema<{
            scope: "feeds.all" | "feeds.userSubscriptions" | "entries.all" | "entries.userTimeline" | "entries.userStarred";
            query: ({
                field: "feeds.name" | "feeds.description" | "feeds.url" | "feeds.siteUrl" | "feeds.rsshubRoute" | "feeds.userSubscriptionsCategory" | "entries.content" | "entries.author" | "entries.feedId";
                operation: "eq" | "ilike";
                value: string | string[];
            } | {
                field: "feeds.userSubscriptionsView" | "feeds.subscriptionCount" | "feeds.updatesPerWeek" | "entries.userTimelineView";
                operation: "eq" | "gt" | "lt";
                value: number;
            } | {
                field: "entries.userTimelineRead";
                operation: "eq";
                value: boolean;
            } | {
                field: "entries.publishedAt";
                operation: "eq" | "gt" | "lt";
                value: string;
            })[] | null;
            order?: {
                field: "feeds.subscriptionCount" | "feeds.updatesPerWeek" | "entries.publishedAt";
                direction: "asc" | "desc";
            } | null | undefined;
        }>;
        contextSchema?: ai.FlexibleSchema<{
            userId?: string | undefined;
        }> | undefined;
        needsApproval?: boolean | _ai_sdk_provider_utils.ToolNeedsApprovalFunction<{
            scope: "feeds.all" | "feeds.userSubscriptions" | "entries.all" | "entries.userTimeline" | "entries.userStarred";
            query: ({
                field: "feeds.name" | "feeds.description" | "feeds.url" | "feeds.siteUrl" | "feeds.rsshubRoute" | "feeds.userSubscriptionsCategory" | "entries.content" | "entries.author" | "entries.feedId";
                operation: "eq" | "ilike";
                value: string | string[];
            } | {
                field: "feeds.userSubscriptionsView" | "feeds.subscriptionCount" | "feeds.updatesPerWeek" | "entries.userTimelineView";
                operation: "eq" | "gt" | "lt";
                value: number;
            } | {
                field: "entries.userTimelineRead";
                operation: "eq";
                value: boolean;
            } | {
                field: "entries.publishedAt";
                operation: "eq" | "gt" | "lt";
                value: string;
            })[] | null;
            order?: {
                field: "feeds.subscriptionCount" | "feeds.updatesPerWeek" | "entries.publishedAt";
                direction: "asc" | "desc";
            } | null | undefined;
        }, NoInfer<{
            userId?: string | undefined;
        }>> | undefined;
        onInputStart?: ((options: ai.ToolExecutionOptions<NoInfer<{
            userId?: string | undefined;
        }>>) => void | PromiseLike<void>) | undefined;
        onInputDelta?: ((options: {
            inputTextDelta: string;
        } & ai.ToolExecutionOptions<NoInfer<{
            userId?: string | undefined;
        }>>) => void | PromiseLike<void>) | undefined;
        onInputAvailable?: ((options: {
            input: {
                scope: "feeds.all" | "feeds.userSubscriptions" | "entries.all" | "entries.userTimeline" | "entries.userStarred";
                query: ({
                    field: "feeds.name" | "feeds.description" | "feeds.url" | "feeds.siteUrl" | "feeds.rsshubRoute" | "feeds.userSubscriptionsCategory" | "entries.content" | "entries.author" | "entries.feedId";
                    operation: "eq" | "ilike";
                    value: string | string[];
                } | {
                    field: "feeds.userSubscriptionsView" | "feeds.subscriptionCount" | "feeds.updatesPerWeek" | "entries.userTimelineView";
                    operation: "eq" | "gt" | "lt";
                    value: number;
                } | {
                    field: "entries.userTimelineRead";
                    operation: "eq";
                    value: boolean;
                } | {
                    field: "entries.publishedAt";
                    operation: "eq" | "gt" | "lt";
                    value: string;
                })[] | null;
                order?: {
                    field: "feeds.subscriptionCount" | "feeds.updatesPerWeek" | "entries.publishedAt";
                    direction: "asc" | "desc";
                } | null | undefined;
            };
        } & ai.ToolExecutionOptions<NoInfer<{
            userId?: string | undefined;
        }>>) => void | PromiseLike<void>) | undefined;
        toModelOutput?: ((options: {
            toolCallId: string;
            input: {
                scope: "feeds.all" | "feeds.userSubscriptions" | "entries.all" | "entries.userTimeline" | "entries.userStarred";
                query: ({
                    field: "feeds.name" | "feeds.description" | "feeds.url" | "feeds.siteUrl" | "feeds.rsshubRoute" | "feeds.userSubscriptionsCategory" | "entries.content" | "entries.author" | "entries.feedId";
                    operation: "eq" | "ilike";
                    value: string | string[];
                } | {
                    field: "feeds.userSubscriptionsView" | "feeds.subscriptionCount" | "feeds.updatesPerWeek" | "entries.userTimelineView";
                    operation: "eq" | "gt" | "lt";
                    value: number;
                } | {
                    field: "entries.userTimelineRead";
                    operation: "eq";
                    value: boolean;
                } | {
                    field: "entries.publishedAt";
                    operation: "eq" | "gt" | "lt";
                    value: string;
                })[] | null;
                order?: {
                    field: "feeds.subscriptionCount" | "feeds.updatesPerWeek" | "entries.publishedAt";
                    direction: "asc" | "desc";
                } | null | undefined;
            };
            output: string;
        }) => _ai_sdk_provider_utils.ToolResultOutput | PromiseLike<_ai_sdk_provider_utils.ToolResultOutput>) | undefined;
    } & {
        outputSchema?: ai.FlexibleSchema<string> | undefined;
        execute: ai.ToolExecuteFunction<{
            scope: "feeds.all" | "feeds.userSubscriptions" | "entries.all" | "entries.userTimeline" | "entries.userStarred";
            query: ({
                field: "feeds.name" | "feeds.description" | "feeds.url" | "feeds.siteUrl" | "feeds.rsshubRoute" | "feeds.userSubscriptionsCategory" | "entries.content" | "entries.author" | "entries.feedId";
                operation: "eq" | "ilike";
                value: string | string[];
            } | {
                field: "feeds.userSubscriptionsView" | "feeds.subscriptionCount" | "feeds.updatesPerWeek" | "entries.userTimelineView";
                operation: "eq" | "gt" | "lt";
                value: number;
            } | {
                field: "entries.userTimelineRead";
                operation: "eq";
                value: boolean;
            } | {
                field: "entries.publishedAt";
                operation: "eq" | "gt" | "lt";
                value: string;
            })[] | null;
            order?: {
                field: "feeds.subscriptionCount" | "feeds.updatesPerWeek" | "entries.publishedAt";
                direction: "asc" | "desc";
            } | null | undefined;
        }, string, NoInfer<{
            userId?: string | undefined;
        }>>;
    } & {
        description?: string | ((options: {
            context: NoInfer<{
                userId?: string | undefined;
            }>;
            experimental_sandbox?: ai.Experimental_SandboxSession;
        }) => string) | undefined;
        strict?: boolean;
        inputExamples?: {
            input: NoInfer<{
                scope: "feeds.all" | "feeds.userSubscriptions" | "entries.all" | "entries.userTimeline" | "entries.userStarred";
                query: ({
                    field: "feeds.name" | "feeds.description" | "feeds.url" | "feeds.siteUrl" | "feeds.rsshubRoute" | "feeds.userSubscriptionsCategory" | "entries.content" | "entries.author" | "entries.feedId";
                    operation: "eq" | "ilike";
                    value: string | string[];
                } | {
                    field: "feeds.userSubscriptionsView" | "feeds.subscriptionCount" | "feeds.updatesPerWeek" | "entries.userTimelineView";
                    operation: "eq" | "gt" | "lt";
                    value: number;
                } | {
                    field: "entries.userTimelineRead";
                    operation: "eq";
                    value: boolean;
                } | {
                    field: "entries.publishedAt";
                    operation: "eq" | "gt" | "lt";
                    value: string;
                })[] | null;
                order?: {
                    field: "feeds.subscriptionCount" | "feeds.updatesPerWeek" | "entries.publishedAt";
                    direction: "asc" | "desc";
                } | null | undefined;
            }>;
        }[] | undefined;
        id?: never;
        isProviderExecuted?: never;
        args?: never;
        supportsDeferredResults?: never;
    } & {
        type: "dynamic";
    } & {
        execute: ai.ToolExecuteFunction<{
            scope: "feeds.all" | "feeds.userSubscriptions" | "entries.all" | "entries.userTimeline" | "entries.userStarred";
            query: ({
                field: "feeds.name" | "feeds.description" | "feeds.url" | "feeds.siteUrl" | "feeds.rsshubRoute" | "feeds.userSubscriptionsCategory" | "entries.content" | "entries.author" | "entries.feedId";
                operation: "eq" | "ilike";
                value: string | string[];
            } | {
                field: "feeds.userSubscriptionsView" | "feeds.subscriptionCount" | "feeds.updatesPerWeek" | "entries.userTimelineView";
                operation: "eq" | "gt" | "lt";
                value: number;
            } | {
                field: "entries.userTimelineRead";
                operation: "eq";
                value: boolean;
            } | {
                field: "entries.publishedAt";
                operation: "eq" | "gt" | "lt";
                value: string;
            })[] | null;
            order?: {
                field: "feeds.subscriptionCount" | "feeds.updatesPerWeek" | "entries.publishedAt";
                direction: "asc" | "desc";
            } | null | undefined;
        }, string, NoInfer<{
            userId?: string | undefined;
        }>>;
    }) | ({
        deferLoading?: boolean;
        title?: string;
        providerOptions?: _ai_sdk_provider_utils.ProviderOptions;
        metadata?: _ai_sdk_provider.JSONObject;
        inputSchema: ai.FlexibleSchema<{
            scope: "feeds.all" | "feeds.userSubscriptions" | "entries.all" | "entries.userTimeline" | "entries.userStarred";
            query: ({
                field: "feeds.name" | "feeds.description" | "feeds.url" | "feeds.siteUrl" | "feeds.rsshubRoute" | "feeds.userSubscriptionsCategory" | "entries.content" | "entries.author" | "entries.feedId";
                operation: "eq" | "ilike";
                value: string | string[];
            } | {
                field: "feeds.userSubscriptionsView" | "feeds.subscriptionCount" | "feeds.updatesPerWeek" | "entries.userTimelineView";
                operation: "eq" | "gt" | "lt";
                value: number;
            } | {
                field: "entries.userTimelineRead";
                operation: "eq";
                value: boolean;
            } | {
                field: "entries.publishedAt";
                operation: "eq" | "gt" | "lt";
                value: string;
            })[] | null;
            order?: {
                field: "feeds.subscriptionCount" | "feeds.updatesPerWeek" | "entries.publishedAt";
                direction: "asc" | "desc";
            } | null | undefined;
        }>;
        contextSchema?: ai.FlexibleSchema<{
            userId?: string | undefined;
        }> | undefined;
        needsApproval?: boolean | _ai_sdk_provider_utils.ToolNeedsApprovalFunction<{
            scope: "feeds.all" | "feeds.userSubscriptions" | "entries.all" | "entries.userTimeline" | "entries.userStarred";
            query: ({
                field: "feeds.name" | "feeds.description" | "feeds.url" | "feeds.siteUrl" | "feeds.rsshubRoute" | "feeds.userSubscriptionsCategory" | "entries.content" | "entries.author" | "entries.feedId";
                operation: "eq" | "ilike";
                value: string | string[];
            } | {
                field: "feeds.userSubscriptionsView" | "feeds.subscriptionCount" | "feeds.updatesPerWeek" | "entries.userTimelineView";
                operation: "eq" | "gt" | "lt";
                value: number;
            } | {
                field: "entries.userTimelineRead";
                operation: "eq";
                value: boolean;
            } | {
                field: "entries.publishedAt";
                operation: "eq" | "gt" | "lt";
                value: string;
            })[] | null;
            order?: {
                field: "feeds.subscriptionCount" | "feeds.updatesPerWeek" | "entries.publishedAt";
                direction: "asc" | "desc";
            } | null | undefined;
        }, NoInfer<{
            userId?: string | undefined;
        }>> | undefined;
        onInputStart?: ((options: ai.ToolExecutionOptions<NoInfer<{
            userId?: string | undefined;
        }>>) => void | PromiseLike<void>) | undefined;
        onInputDelta?: ((options: {
            inputTextDelta: string;
        } & ai.ToolExecutionOptions<NoInfer<{
            userId?: string | undefined;
        }>>) => void | PromiseLike<void>) | undefined;
        onInputAvailable?: ((options: {
            input: {
                scope: "feeds.all" | "feeds.userSubscriptions" | "entries.all" | "entries.userTimeline" | "entries.userStarred";
                query: ({
                    field: "feeds.name" | "feeds.description" | "feeds.url" | "feeds.siteUrl" | "feeds.rsshubRoute" | "feeds.userSubscriptionsCategory" | "entries.content" | "entries.author" | "entries.feedId";
                    operation: "eq" | "ilike";
                    value: string | string[];
                } | {
                    field: "feeds.userSubscriptionsView" | "feeds.subscriptionCount" | "feeds.updatesPerWeek" | "entries.userTimelineView";
                    operation: "eq" | "gt" | "lt";
                    value: number;
                } | {
                    field: "entries.userTimelineRead";
                    operation: "eq";
                    value: boolean;
                } | {
                    field: "entries.publishedAt";
                    operation: "eq" | "gt" | "lt";
                    value: string;
                })[] | null;
                order?: {
                    field: "feeds.subscriptionCount" | "feeds.updatesPerWeek" | "entries.publishedAt";
                    direction: "asc" | "desc";
                } | null | undefined;
            };
        } & ai.ToolExecutionOptions<NoInfer<{
            userId?: string | undefined;
        }>>) => void | PromiseLike<void>) | undefined;
        toModelOutput?: ((options: {
            toolCallId: string;
            input: {
                scope: "feeds.all" | "feeds.userSubscriptions" | "entries.all" | "entries.userTimeline" | "entries.userStarred";
                query: ({
                    field: "feeds.name" | "feeds.description" | "feeds.url" | "feeds.siteUrl" | "feeds.rsshubRoute" | "feeds.userSubscriptionsCategory" | "entries.content" | "entries.author" | "entries.feedId";
                    operation: "eq" | "ilike";
                    value: string | string[];
                } | {
                    field: "feeds.userSubscriptionsView" | "feeds.subscriptionCount" | "feeds.updatesPerWeek" | "entries.userTimelineView";
                    operation: "eq" | "gt" | "lt";
                    value: number;
                } | {
                    field: "entries.userTimelineRead";
                    operation: "eq";
                    value: boolean;
                } | {
                    field: "entries.publishedAt";
                    operation: "eq" | "gt" | "lt";
                    value: string;
                })[] | null;
                order?: {
                    field: "feeds.subscriptionCount" | "feeds.updatesPerWeek" | "entries.publishedAt";
                    direction: "asc" | "desc";
                } | null | undefined;
            };
            output: string;
        }) => _ai_sdk_provider_utils.ToolResultOutput | PromiseLike<_ai_sdk_provider_utils.ToolResultOutput>) | undefined;
    } & {
        outputSchema?: ai.FlexibleSchema<string> | undefined;
        execute: ai.ToolExecuteFunction<{
            scope: "feeds.all" | "feeds.userSubscriptions" | "entries.all" | "entries.userTimeline" | "entries.userStarred";
            query: ({
                field: "feeds.name" | "feeds.description" | "feeds.url" | "feeds.siteUrl" | "feeds.rsshubRoute" | "feeds.userSubscriptionsCategory" | "entries.content" | "entries.author" | "entries.feedId";
                operation: "eq" | "ilike";
                value: string | string[];
            } | {
                field: "feeds.userSubscriptionsView" | "feeds.subscriptionCount" | "feeds.updatesPerWeek" | "entries.userTimelineView";
                operation: "eq" | "gt" | "lt";
                value: number;
            } | {
                field: "entries.userTimelineRead";
                operation: "eq";
                value: boolean;
            } | {
                field: "entries.publishedAt";
                operation: "eq" | "gt" | "lt";
                value: string;
            })[] | null;
            order?: {
                field: "feeds.subscriptionCount" | "feeds.updatesPerWeek" | "entries.publishedAt";
                direction: "asc" | "desc";
            } | null | undefined;
        }, string, NoInfer<{
            userId?: string | undefined;
        }>>;
    } & {
        type: "provider";
        id: `${string}.${string}`;
        args: Record<string, unknown>;
        description?: never;
        strict?: never;
        inputExamples?: never;
    } & {
        isProviderExecuted: false;
        supportsDeferredResults?: never;
    } & {
        execute: ai.ToolExecuteFunction<{
            scope: "feeds.all" | "feeds.userSubscriptions" | "entries.all" | "entries.userTimeline" | "entries.userStarred";
            query: ({
                field: "feeds.name" | "feeds.description" | "feeds.url" | "feeds.siteUrl" | "feeds.rsshubRoute" | "feeds.userSubscriptionsCategory" | "entries.content" | "entries.author" | "entries.feedId";
                operation: "eq" | "ilike";
                value: string | string[];
            } | {
                field: "feeds.userSubscriptionsView" | "feeds.subscriptionCount" | "feeds.updatesPerWeek" | "entries.userTimelineView";
                operation: "eq" | "gt" | "lt";
                value: number;
            } | {
                field: "entries.userTimelineRead";
                operation: "eq";
                value: boolean;
            } | {
                field: "entries.publishedAt";
                operation: "eq" | "gt" | "lt";
                value: string;
            })[] | null;
            order?: {
                field: "feeds.subscriptionCount" | "feeds.updatesPerWeek" | "entries.publishedAt";
                direction: "asc" | "desc";
            } | null | undefined;
        }, string, NoInfer<{
            userId?: string | undefined;
        }>>;
    }) | ({
        deferLoading?: boolean;
        title?: string;
        providerOptions?: _ai_sdk_provider_utils.ProviderOptions;
        metadata?: _ai_sdk_provider.JSONObject;
        inputSchema: ai.FlexibleSchema<{
            scope: "feeds.all" | "feeds.userSubscriptions" | "entries.all" | "entries.userTimeline" | "entries.userStarred";
            query: ({
                field: "feeds.name" | "feeds.description" | "feeds.url" | "feeds.siteUrl" | "feeds.rsshubRoute" | "feeds.userSubscriptionsCategory" | "entries.content" | "entries.author" | "entries.feedId";
                operation: "eq" | "ilike";
                value: string | string[];
            } | {
                field: "feeds.userSubscriptionsView" | "feeds.subscriptionCount" | "feeds.updatesPerWeek" | "entries.userTimelineView";
                operation: "eq" | "gt" | "lt";
                value: number;
            } | {
                field: "entries.userTimelineRead";
                operation: "eq";
                value: boolean;
            } | {
                field: "entries.publishedAt";
                operation: "eq" | "gt" | "lt";
                value: string;
            })[] | null;
            order?: {
                field: "feeds.subscriptionCount" | "feeds.updatesPerWeek" | "entries.publishedAt";
                direction: "asc" | "desc";
            } | null | undefined;
        }>;
        contextSchema?: ai.FlexibleSchema<{
            userId?: string | undefined;
        }> | undefined;
        needsApproval?: boolean | _ai_sdk_provider_utils.ToolNeedsApprovalFunction<{
            scope: "feeds.all" | "feeds.userSubscriptions" | "entries.all" | "entries.userTimeline" | "entries.userStarred";
            query: ({
                field: "feeds.name" | "feeds.description" | "feeds.url" | "feeds.siteUrl" | "feeds.rsshubRoute" | "feeds.userSubscriptionsCategory" | "entries.content" | "entries.author" | "entries.feedId";
                operation: "eq" | "ilike";
                value: string | string[];
            } | {
                field: "feeds.userSubscriptionsView" | "feeds.subscriptionCount" | "feeds.updatesPerWeek" | "entries.userTimelineView";
                operation: "eq" | "gt" | "lt";
                value: number;
            } | {
                field: "entries.userTimelineRead";
                operation: "eq";
                value: boolean;
            } | {
                field: "entries.publishedAt";
                operation: "eq" | "gt" | "lt";
                value: string;
            })[] | null;
            order?: {
                field: "feeds.subscriptionCount" | "feeds.updatesPerWeek" | "entries.publishedAt";
                direction: "asc" | "desc";
            } | null | undefined;
        }, NoInfer<{
            userId?: string | undefined;
        }>> | undefined;
        onInputStart?: ((options: ai.ToolExecutionOptions<NoInfer<{
            userId?: string | undefined;
        }>>) => void | PromiseLike<void>) | undefined;
        onInputDelta?: ((options: {
            inputTextDelta: string;
        } & ai.ToolExecutionOptions<NoInfer<{
            userId?: string | undefined;
        }>>) => void | PromiseLike<void>) | undefined;
        onInputAvailable?: ((options: {
            input: {
                scope: "feeds.all" | "feeds.userSubscriptions" | "entries.all" | "entries.userTimeline" | "entries.userStarred";
                query: ({
                    field: "feeds.name" | "feeds.description" | "feeds.url" | "feeds.siteUrl" | "feeds.rsshubRoute" | "feeds.userSubscriptionsCategory" | "entries.content" | "entries.author" | "entries.feedId";
                    operation: "eq" | "ilike";
                    value: string | string[];
                } | {
                    field: "feeds.userSubscriptionsView" | "feeds.subscriptionCount" | "feeds.updatesPerWeek" | "entries.userTimelineView";
                    operation: "eq" | "gt" | "lt";
                    value: number;
                } | {
                    field: "entries.userTimelineRead";
                    operation: "eq";
                    value: boolean;
                } | {
                    field: "entries.publishedAt";
                    operation: "eq" | "gt" | "lt";
                    value: string;
                })[] | null;
                order?: {
                    field: "feeds.subscriptionCount" | "feeds.updatesPerWeek" | "entries.publishedAt";
                    direction: "asc" | "desc";
                } | null | undefined;
            };
        } & ai.ToolExecutionOptions<NoInfer<{
            userId?: string | undefined;
        }>>) => void | PromiseLike<void>) | undefined;
        toModelOutput?: ((options: {
            toolCallId: string;
            input: {
                scope: "feeds.all" | "feeds.userSubscriptions" | "entries.all" | "entries.userTimeline" | "entries.userStarred";
                query: ({
                    field: "feeds.name" | "feeds.description" | "feeds.url" | "feeds.siteUrl" | "feeds.rsshubRoute" | "feeds.userSubscriptionsCategory" | "entries.content" | "entries.author" | "entries.feedId";
                    operation: "eq" | "ilike";
                    value: string | string[];
                } | {
                    field: "feeds.userSubscriptionsView" | "feeds.subscriptionCount" | "feeds.updatesPerWeek" | "entries.userTimelineView";
                    operation: "eq" | "gt" | "lt";
                    value: number;
                } | {
                    field: "entries.userTimelineRead";
                    operation: "eq";
                    value: boolean;
                } | {
                    field: "entries.publishedAt";
                    operation: "eq" | "gt" | "lt";
                    value: string;
                })[] | null;
                order?: {
                    field: "feeds.subscriptionCount" | "feeds.updatesPerWeek" | "entries.publishedAt";
                    direction: "asc" | "desc";
                } | null | undefined;
            };
            output: string;
        }) => _ai_sdk_provider_utils.ToolResultOutput | PromiseLike<_ai_sdk_provider_utils.ToolResultOutput>) | undefined;
    } & {
        outputSchema?: ai.FlexibleSchema<string> | undefined;
        execute: ai.ToolExecuteFunction<{
            scope: "feeds.all" | "feeds.userSubscriptions" | "entries.all" | "entries.userTimeline" | "entries.userStarred";
            query: ({
                field: "feeds.name" | "feeds.description" | "feeds.url" | "feeds.siteUrl" | "feeds.rsshubRoute" | "feeds.userSubscriptionsCategory" | "entries.content" | "entries.author" | "entries.feedId";
                operation: "eq" | "ilike";
                value: string | string[];
            } | {
                field: "feeds.userSubscriptionsView" | "feeds.subscriptionCount" | "feeds.updatesPerWeek" | "entries.userTimelineView";
                operation: "eq" | "gt" | "lt";
                value: number;
            } | {
                field: "entries.userTimelineRead";
                operation: "eq";
                value: boolean;
            } | {
                field: "entries.publishedAt";
                operation: "eq" | "gt" | "lt";
                value: string;
            })[] | null;
            order?: {
                field: "feeds.subscriptionCount" | "feeds.updatesPerWeek" | "entries.publishedAt";
                direction: "asc" | "desc";
            } | null | undefined;
        }, string, NoInfer<{
            userId?: string | undefined;
        }>>;
    } & {
        type: "provider";
        id: `${string}.${string}`;
        args: Record<string, unknown>;
        description?: never;
        strict?: never;
        inputExamples?: never;
    } & {
        isProviderExecuted: true;
        supportsDeferredResults?: boolean;
    } & {
        execute: ai.ToolExecuteFunction<{
            scope: "feeds.all" | "feeds.userSubscriptions" | "entries.all" | "entries.userTimeline" | "entries.userStarred";
            query: ({
                field: "feeds.name" | "feeds.description" | "feeds.url" | "feeds.siteUrl" | "feeds.rsshubRoute" | "feeds.userSubscriptionsCategory" | "entries.content" | "entries.author" | "entries.feedId";
                operation: "eq" | "ilike";
                value: string | string[];
            } | {
                field: "feeds.userSubscriptionsView" | "feeds.subscriptionCount" | "feeds.updatesPerWeek" | "entries.userTimelineView";
                operation: "eq" | "gt" | "lt";
                value: number;
            } | {
                field: "entries.userTimelineRead";
                operation: "eq";
                value: boolean;
            } | {
                field: "entries.publishedAt";
                operation: "eq" | "gt" | "lt";
                value: string;
            })[] | null;
            order?: {
                field: "feeds.subscriptionCount" | "feeds.updatesPerWeek" | "entries.publishedAt";
                direction: "asc" | "desc";
            } | null | undefined;
        }, string, NoInfer<{
            userId?: string | undefined;
        }>>;
    });
};
type AiToolsContext = {
    get_whoami: ToolContext;
    search: ToolContext;
};
declare const createToolsContext: (userId: string) => AiToolsContext;

declare const onboardingTools: {
    onboardingGetTrendingFeeds: ({
        deferLoading?: boolean;
        title?: string;
        providerOptions?: _ai_sdk_provider_utils.ProviderOptions;
        metadata?: _ai_sdk_provider.JSONObject;
        inputSchema: ai.FlexibleSchema<{
            language: "eng" | "cmn";
            user_description: string;
        }>;
        contextSchema?: ai.FlexibleSchema<_ai_sdk_provider_utils.Context> | undefined;
        needsApproval?: boolean | _ai_sdk_provider_utils.ToolNeedsApprovalFunction<{
            language: "eng" | "cmn";
            user_description: string;
        }, NoInfer<_ai_sdk_provider_utils.Context>> | undefined;
        onInputStart?: ((options: ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        onInputDelta?: ((options: {
            inputTextDelta: string;
        } & ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        onInputAvailable?: ((options: {
            input: {
                language: "eng" | "cmn";
                user_description: string;
            };
        } & ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        toModelOutput?: ((options: {
            toolCallId: string;
            input: {
                language: "eng" | "cmn";
                user_description: string;
            };
            output: NoInfer<string | never[]>;
        }) => _ai_sdk_provider_utils.ToolResultOutput | PromiseLike<_ai_sdk_provider_utils.ToolResultOutput>) | undefined;
    } & {
        outputSchema?: ai.FlexibleSchema<string | never[]> | undefined;
        execute: ai.ToolExecuteFunction<{
            language: "eng" | "cmn";
            user_description: string;
        }, string | never[], NoInfer<_ai_sdk_provider_utils.Context>>;
    } & {
        description?: string | ((options: {
            context: NoInfer<_ai_sdk_provider_utils.Context>;
            experimental_sandbox?: ai.Experimental_SandboxSession;
        }) => string) | undefined;
        strict?: boolean;
        inputExamples?: {
            input: NoInfer<{
                language: "eng" | "cmn";
                user_description: string;
            }>;
        }[] | undefined;
        id?: never;
        isProviderExecuted?: never;
        args?: never;
        supportsDeferredResults?: never;
    } & {
        type?: undefined | "function";
    } & {
        execute: ai.ToolExecuteFunction<{
            language: "eng" | "cmn";
            user_description: string;
        }, string | never[], NoInfer<_ai_sdk_provider_utils.Context>>;
    }) | ({
        deferLoading?: boolean;
        title?: string;
        providerOptions?: _ai_sdk_provider_utils.ProviderOptions;
        metadata?: _ai_sdk_provider.JSONObject;
        inputSchema: ai.FlexibleSchema<{
            language: "eng" | "cmn";
            user_description: string;
        }>;
        contextSchema?: ai.FlexibleSchema<_ai_sdk_provider_utils.Context> | undefined;
        needsApproval?: boolean | _ai_sdk_provider_utils.ToolNeedsApprovalFunction<{
            language: "eng" | "cmn";
            user_description: string;
        }, NoInfer<_ai_sdk_provider_utils.Context>> | undefined;
        onInputStart?: ((options: ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        onInputDelta?: ((options: {
            inputTextDelta: string;
        } & ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        onInputAvailable?: ((options: {
            input: {
                language: "eng" | "cmn";
                user_description: string;
            };
        } & ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        toModelOutput?: ((options: {
            toolCallId: string;
            input: {
                language: "eng" | "cmn";
                user_description: string;
            };
            output: NoInfer<string | never[]>;
        }) => _ai_sdk_provider_utils.ToolResultOutput | PromiseLike<_ai_sdk_provider_utils.ToolResultOutput>) | undefined;
    } & {
        outputSchema?: ai.FlexibleSchema<string | never[]> | undefined;
        execute: ai.ToolExecuteFunction<{
            language: "eng" | "cmn";
            user_description: string;
        }, string | never[], NoInfer<_ai_sdk_provider_utils.Context>>;
    } & {
        description?: string | ((options: {
            context: NoInfer<_ai_sdk_provider_utils.Context>;
            experimental_sandbox?: ai.Experimental_SandboxSession;
        }) => string) | undefined;
        strict?: boolean;
        inputExamples?: {
            input: NoInfer<{
                language: "eng" | "cmn";
                user_description: string;
            }>;
        }[] | undefined;
        id?: never;
        isProviderExecuted?: never;
        args?: never;
        supportsDeferredResults?: never;
    } & {
        type: "dynamic";
    } & {
        execute: ai.ToolExecuteFunction<{
            language: "eng" | "cmn";
            user_description: string;
        }, string | never[], NoInfer<_ai_sdk_provider_utils.Context>>;
    }) | ({
        deferLoading?: boolean;
        title?: string;
        providerOptions?: _ai_sdk_provider_utils.ProviderOptions;
        metadata?: _ai_sdk_provider.JSONObject;
        inputSchema: ai.FlexibleSchema<{
            language: "eng" | "cmn";
            user_description: string;
        }>;
        contextSchema?: ai.FlexibleSchema<_ai_sdk_provider_utils.Context> | undefined;
        needsApproval?: boolean | _ai_sdk_provider_utils.ToolNeedsApprovalFunction<{
            language: "eng" | "cmn";
            user_description: string;
        }, NoInfer<_ai_sdk_provider_utils.Context>> | undefined;
        onInputStart?: ((options: ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        onInputDelta?: ((options: {
            inputTextDelta: string;
        } & ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        onInputAvailable?: ((options: {
            input: {
                language: "eng" | "cmn";
                user_description: string;
            };
        } & ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        toModelOutput?: ((options: {
            toolCallId: string;
            input: {
                language: "eng" | "cmn";
                user_description: string;
            };
            output: NoInfer<string | never[]>;
        }) => _ai_sdk_provider_utils.ToolResultOutput | PromiseLike<_ai_sdk_provider_utils.ToolResultOutput>) | undefined;
    } & {
        outputSchema?: ai.FlexibleSchema<string | never[]> | undefined;
        execute: ai.ToolExecuteFunction<{
            language: "eng" | "cmn";
            user_description: string;
        }, string | never[], NoInfer<_ai_sdk_provider_utils.Context>>;
    } & {
        type: "provider";
        id: `${string}.${string}`;
        args: Record<string, unknown>;
        description?: never;
        strict?: never;
        inputExamples?: never;
    } & {
        isProviderExecuted: false;
        supportsDeferredResults?: never;
    } & {
        execute: ai.ToolExecuteFunction<{
            language: "eng" | "cmn";
            user_description: string;
        }, string | never[], NoInfer<_ai_sdk_provider_utils.Context>>;
    }) | ({
        deferLoading?: boolean;
        title?: string;
        providerOptions?: _ai_sdk_provider_utils.ProviderOptions;
        metadata?: _ai_sdk_provider.JSONObject;
        inputSchema: ai.FlexibleSchema<{
            language: "eng" | "cmn";
            user_description: string;
        }>;
        contextSchema?: ai.FlexibleSchema<_ai_sdk_provider_utils.Context> | undefined;
        needsApproval?: boolean | _ai_sdk_provider_utils.ToolNeedsApprovalFunction<{
            language: "eng" | "cmn";
            user_description: string;
        }, NoInfer<_ai_sdk_provider_utils.Context>> | undefined;
        onInputStart?: ((options: ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        onInputDelta?: ((options: {
            inputTextDelta: string;
        } & ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        onInputAvailable?: ((options: {
            input: {
                language: "eng" | "cmn";
                user_description: string;
            };
        } & ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        toModelOutput?: ((options: {
            toolCallId: string;
            input: {
                language: "eng" | "cmn";
                user_description: string;
            };
            output: NoInfer<string | never[]>;
        }) => _ai_sdk_provider_utils.ToolResultOutput | PromiseLike<_ai_sdk_provider_utils.ToolResultOutput>) | undefined;
    } & {
        outputSchema?: ai.FlexibleSchema<string | never[]> | undefined;
        execute: ai.ToolExecuteFunction<{
            language: "eng" | "cmn";
            user_description: string;
        }, string | never[], NoInfer<_ai_sdk_provider_utils.Context>>;
    } & {
        type: "provider";
        id: `${string}.${string}`;
        args: Record<string, unknown>;
        description?: never;
        strict?: never;
        inputExamples?: never;
    } & {
        isProviderExecuted: true;
        supportsDeferredResults?: boolean;
    } & {
        execute: ai.ToolExecuteFunction<{
            language: "eng" | "cmn";
            user_description: string;
        }, string | never[], NoInfer<_ai_sdk_provider_utils.Context>>;
    });
    onboardingConfirm: ({
        deferLoading?: boolean;
        title?: string;
        providerOptions?: _ai_sdk_provider_utils.ProviderOptions;
        metadata?: _ai_sdk_provider.JSONObject;
        inputSchema: ai.FlexibleSchema<Record<string, never>>;
        contextSchema?: ai.FlexibleSchema<_ai_sdk_provider_utils.Context> | undefined;
        needsApproval?: boolean | _ai_sdk_provider_utils.ToolNeedsApprovalFunction<Record<string, never>, NoInfer<_ai_sdk_provider_utils.Context>> | undefined;
        onInputStart?: ((options: ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        onInputDelta?: ((options: {
            inputTextDelta: string;
        } & ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        onInputAvailable?: ((options: {
            input: Record<string, never>;
        } & ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        toModelOutput?: ((options: {
            toolCallId: string;
            input: Record<string, never>;
            output: NoInfer<{
                confirm: boolean;
            }>;
        }) => _ai_sdk_provider_utils.ToolResultOutput | PromiseLike<_ai_sdk_provider_utils.ToolResultOutput>) | undefined;
    } & {
        outputSchema?: ai.FlexibleSchema<{
            confirm: boolean;
        }> | undefined;
        execute: ai.ToolExecuteFunction<Record<string, never>, {
            confirm: boolean;
        }, NoInfer<_ai_sdk_provider_utils.Context>>;
    } & {
        description?: string | ((options: {
            context: NoInfer<_ai_sdk_provider_utils.Context>;
            experimental_sandbox?: ai.Experimental_SandboxSession;
        }) => string) | undefined;
        strict?: boolean;
        inputExamples?: {
            input: NoInfer<Record<string, never>>;
        }[] | undefined;
        id?: never;
        isProviderExecuted?: never;
        args?: never;
        supportsDeferredResults?: never;
    } & {
        type?: undefined | "function";
    } & {
        execute: ai.ToolExecuteFunction<Record<string, never>, {
            confirm: boolean;
        }, NoInfer<_ai_sdk_provider_utils.Context>>;
    }) | ({
        deferLoading?: boolean;
        title?: string;
        providerOptions?: _ai_sdk_provider_utils.ProviderOptions;
        metadata?: _ai_sdk_provider.JSONObject;
        inputSchema: ai.FlexibleSchema<Record<string, never>>;
        contextSchema?: ai.FlexibleSchema<_ai_sdk_provider_utils.Context> | undefined;
        needsApproval?: boolean | _ai_sdk_provider_utils.ToolNeedsApprovalFunction<Record<string, never>, NoInfer<_ai_sdk_provider_utils.Context>> | undefined;
        onInputStart?: ((options: ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        onInputDelta?: ((options: {
            inputTextDelta: string;
        } & ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        onInputAvailable?: ((options: {
            input: Record<string, never>;
        } & ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        toModelOutput?: ((options: {
            toolCallId: string;
            input: Record<string, never>;
            output: NoInfer<{
                confirm: boolean;
            }>;
        }) => _ai_sdk_provider_utils.ToolResultOutput | PromiseLike<_ai_sdk_provider_utils.ToolResultOutput>) | undefined;
    } & {
        outputSchema?: ai.FlexibleSchema<{
            confirm: boolean;
        }> | undefined;
        execute: ai.ToolExecuteFunction<Record<string, never>, {
            confirm: boolean;
        }, NoInfer<_ai_sdk_provider_utils.Context>>;
    } & {
        description?: string | ((options: {
            context: NoInfer<_ai_sdk_provider_utils.Context>;
            experimental_sandbox?: ai.Experimental_SandboxSession;
        }) => string) | undefined;
        strict?: boolean;
        inputExamples?: {
            input: NoInfer<Record<string, never>>;
        }[] | undefined;
        id?: never;
        isProviderExecuted?: never;
        args?: never;
        supportsDeferredResults?: never;
    } & {
        type: "dynamic";
    } & {
        execute: ai.ToolExecuteFunction<Record<string, never>, {
            confirm: boolean;
        }, NoInfer<_ai_sdk_provider_utils.Context>>;
    }) | ({
        deferLoading?: boolean;
        title?: string;
        providerOptions?: _ai_sdk_provider_utils.ProviderOptions;
        metadata?: _ai_sdk_provider.JSONObject;
        inputSchema: ai.FlexibleSchema<Record<string, never>>;
        contextSchema?: ai.FlexibleSchema<_ai_sdk_provider_utils.Context> | undefined;
        needsApproval?: boolean | _ai_sdk_provider_utils.ToolNeedsApprovalFunction<Record<string, never>, NoInfer<_ai_sdk_provider_utils.Context>> | undefined;
        onInputStart?: ((options: ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        onInputDelta?: ((options: {
            inputTextDelta: string;
        } & ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        onInputAvailable?: ((options: {
            input: Record<string, never>;
        } & ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        toModelOutput?: ((options: {
            toolCallId: string;
            input: Record<string, never>;
            output: NoInfer<{
                confirm: boolean;
            }>;
        }) => _ai_sdk_provider_utils.ToolResultOutput | PromiseLike<_ai_sdk_provider_utils.ToolResultOutput>) | undefined;
    } & {
        outputSchema?: ai.FlexibleSchema<{
            confirm: boolean;
        }> | undefined;
        execute: ai.ToolExecuteFunction<Record<string, never>, {
            confirm: boolean;
        }, NoInfer<_ai_sdk_provider_utils.Context>>;
    } & {
        type: "provider";
        id: `${string}.${string}`;
        args: Record<string, unknown>;
        description?: never;
        strict?: never;
        inputExamples?: never;
    } & {
        isProviderExecuted: false;
        supportsDeferredResults?: never;
    } & {
        execute: ai.ToolExecuteFunction<Record<string, never>, {
            confirm: boolean;
        }, NoInfer<_ai_sdk_provider_utils.Context>>;
    }) | ({
        deferLoading?: boolean;
        title?: string;
        providerOptions?: _ai_sdk_provider_utils.ProviderOptions;
        metadata?: _ai_sdk_provider.JSONObject;
        inputSchema: ai.FlexibleSchema<Record<string, never>>;
        contextSchema?: ai.FlexibleSchema<_ai_sdk_provider_utils.Context> | undefined;
        needsApproval?: boolean | _ai_sdk_provider_utils.ToolNeedsApprovalFunction<Record<string, never>, NoInfer<_ai_sdk_provider_utils.Context>> | undefined;
        onInputStart?: ((options: ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        onInputDelta?: ((options: {
            inputTextDelta: string;
        } & ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        onInputAvailable?: ((options: {
            input: Record<string, never>;
        } & ai.ToolExecutionOptions<NoInfer<_ai_sdk_provider_utils.Context>>) => void | PromiseLike<void>) | undefined;
        toModelOutput?: ((options: {
            toolCallId: string;
            input: Record<string, never>;
            output: NoInfer<{
                confirm: boolean;
            }>;
        }) => _ai_sdk_provider_utils.ToolResultOutput | PromiseLike<_ai_sdk_provider_utils.ToolResultOutput>) | undefined;
    } & {
        outputSchema?: ai.FlexibleSchema<{
            confirm: boolean;
        }> | undefined;
        execute: ai.ToolExecuteFunction<Record<string, never>, {
            confirm: boolean;
        }, NoInfer<_ai_sdk_provider_utils.Context>>;
    } & {
        type: "provider";
        id: `${string}.${string}`;
        args: Record<string, unknown>;
        description?: never;
        strict?: never;
        inputExamples?: never;
    } & {
        isProviderExecuted: true;
        supportsDeferredResults?: boolean;
    } & {
        execute: ai.ToolExecuteFunction<Record<string, never>, {
            confirm: boolean;
        }, NoInfer<_ai_sdk_provider_utils.Context>>;
    });
};

export { type AiToolsContext, type BizUIMessage, type BizUIMetadata, type BizUITools, type ConciseEntryResult, type DetailedEntryResult, ENTRY_FIELDS, ENTRY_FIELD_DESCRIPTIONS, ENTRY_FIELD_NAMES, ENTRY_SELECT_ENUM, type ToolContext, type ToolWithState, type TransformTools, createToolsContext, fetchEntries, getEntriesTool, getEntryAdditional, getToolContext, onboardingTools, optionalUserToolContextSchema, toolContextSchema, tools, withAiToolsDb };