import { FetchFunction } from '@ai-sdk/provider-utils';
import { LanguageModelV2, LanguageModelV2CallOptions } from '@ai-sdk/provider';

type DifyChatModelId = string;
interface Logger {
    debug: (message: string, extra?: Record<string, any>) => void;
    info: (message: string, extra?: Record<string, any>) => void;
    warn: (message: string, extra?: Record<string, any>) => void;
    error: (message: string, extra?: Record<string, any>) => void;
}
interface DifyChatSettings {
    /**
     * Additional inputs to send with the request.
     * This corresponds to the 'inputs' field in Dify's API.
     */
    inputs?: Record<string, any>;
    /**
     * Response mode, defaults to "streaming".
     */
    responseMode?: "streaming" | "blocking";
    /**
     * API key.
     */
    apiKey?: string;
    /**
     * Logger instance for debugging. If not provided, uses default console logger at info level.
     * Set to `false` to disable logging.
     */
    logger?: Logger | false;
    /**
     * Inject tool definitions into the query prompt for LLMs that don't natively support tool calling.
     * Defaults to `true` (appended to query). Set to `false` to disable.
     */
    injectToolsPrompt?: boolean;
    /**
     * Log request and response messages. Defaults to `false`.
     */
    logMessages?: boolean;
}

interface ModelConfig {
    provider: string;
    baseURL: string;
    headers: () => Record<string, string>;
    fetch?: FetchFunction;
}
declare class DifyChatLanguageModel implements LanguageModelV2 {
    private settings;
    readonly specificationVersion: "v2";
    readonly modelId: string;
    readonly supportedUrls: Record<string, RegExp[]>;
    private readonly generateId;
    private readonly chatMessagesEndpoint;
    private readonly config;
    private readonly logger?;
    constructor(modelId: DifyChatModelId, settings: DifyChatSettings, config: ModelConfig);
    private createErrorHandler;
    get provider(): string;
    doGenerate(options: LanguageModelV2CallOptions): Promise<Awaited<ReturnType<LanguageModelV2["doGenerate"]>>>;
    doStream(options: LanguageModelV2CallOptions): Promise<Awaited<ReturnType<LanguageModelV2["doStream"]>>>;
    /**
     * Get the request body for the Dify API
     */
    private getRequestBody;
    private findConversationId;
    private buildQuery;
    private extractSystemPrompt;
    private extractTextFromMessage;
    private extractToolResult;
}

interface DifyProvider {
    (modelId: DifyChatModelId, settings?: DifyChatSettings): DifyChatLanguageModel;
    chat(modelId: DifyChatModelId, settings?: DifyChatSettings): DifyChatLanguageModel;
}
interface DifyProviderSettings {
    /**
     * Use a different URL prefix for API calls, e.g. to use self-hosted Dify instance.
     */
    baseURL?: string;
    /**
     * Custom headers to include in the requests.
     */
    headers?: Record<string, string>;
    /**
     * Custom fetch implementation. You can use it as a middleware to intercept requests,
     * or to provide a custom fetch implementation for e.g. testing.
     */
    fetch?: FetchFunction;
    /**
     * Logger instance for debugging. Set to `false` to disable logging.
     */
    logger?: Logger | false;
}
declare function createDifyProvider(options?: DifyProviderSettings): DifyProvider;
/**
 * Default Dify provider instance.
 */
declare const difyProvider: DifyProvider;

export { type DifyProvider, type DifyProviderSettings, createDifyProvider, difyProvider };