import { Middleware, RunInstance, RunContext } from '../context.js';
import { E as Emitter, C as Callback, a as EmitterOptions } from '../emitter-kHxkUxco.js';
import { i as ChatModelOutput } from '../chat-CfTNfR60.js';
import { Tool } from '../tools/base.js';
import '../internals/serializable.js';
import '../internals/types.js';
import '../internals/helpers/guards.js';
import '../internals/helpers/promise.js';
import '../errors.js';
import '../backend/message.js';
import 'ai';
import 'promise-based-task';
import '../cache/base.js';
import '../backend/constants.js';
import 'zod';
import 'ajv';
import '../template.js';
import '../logger/logger.js';
import 'pino';
import '../internals/helpers/schema.js';
import 'zod-to-json-schema';

/**
 * Copyright 2025 © BeeAI a Series of LF Projects, LLC
 * SPDX-License-Identifier: Apache-2.0
 */

/**
 * Event emitted when the middleware detects an update to the target tool's arguments
 */
interface StreamToolCallMiddlewareUpdateEvent<T = any> {
    /** The validated and structured tool input */
    outputStructured: T | null;
    /** The current value of the target field */
    output: string;
    /** The incremental change since the last update */
    delta: string;
}
/**
 * Callbacks for StreamToolCallMiddleware events
 */
interface StreamToolCallMiddlewareCallbacks<T = any> {
    update: Callback<StreamToolCallMiddlewareUpdateEvent<T>>;
}
/**
 * Options for configuring StreamToolCallMiddleware
 */
interface StreamToolCallMiddlewareOptions {
    /** The tool to monitor for streaming updates */
    target: Tool<any>;
    /** The field name in the tool's input schema to stream */
    key: string;
    /** Whether to apply middleware to nested run contexts */
    matchNested?: boolean;
    /** Whether to force streaming on the ChatModel */
    forceStreaming?: boolean;
}
/**
 * Middleware for handling streaming tool calls in a ChatModel.
 *
 * This middleware observes and listens to ChatModel stream updates and parses
 * the tool calls on demand so that they can be consumed as soon as possible.
 *
 * @example
 * ```typescript
 * const middleware = new StreamToolCallMiddleware({
 *   target: thinkTool,
 *   key: "thoughts",
 *   matchNested: false,
 *   forceStreaming: true,
 * });
 *
 * middleware.emitter.on("update", (event) => {
 *   console.log("Delta:", event.delta);
 *   console.log("Structured:", event.outputStructured);
 * });
 *
 * await llm.run(messages, { tools: [thinkTool] }).middleware(middleware);
 * ```
 */
declare class StreamToolCallMiddleware<T = any> extends Middleware<RunInstance> {
    private readonly target;
    private readonly key;
    private readonly matchNested;
    private readonly forceStreaming;
    private readonly cleanups;
    private output;
    private buffer;
    private delta;
    readonly emitter: Emitter<StreamToolCallMiddlewareCallbacks<T>>;
    constructor(options: StreamToolCallMiddlewareOptions);
    reset(): void;
    add(chunk: ChatModelOutput): Promise<void>;
    isEmpty(): boolean;
    bind(ctx: RunContext<RunInstance>): void;
    unbind(): void;
    protected createEmitterOptions(): EmitterOptions;
    private process;
    private handleStart;
    private handleSuccess;
    private handleNewToken;
}

export { StreamToolCallMiddleware, type StreamToolCallMiddlewareCallbacks, type StreamToolCallMiddlewareOptions, type StreamToolCallMiddlewareUpdateEvent };