import type { WingmanAgentConfig } from "@/agent/config/agentConfig.js";
import { type MCPProxyConfig } from "@/agent/config/mcpClientManager.js";
import { type ConnectedNodeTarget } from "@/agent/middleware/additional-messages.js";
import { type BrowserSessionManager } from "@/agent/tools/browser_session_manager.js";
import type { NodeInvokeRequest, NodeInvokeResult } from "@/agent/tools/node_invoke.js";
import { type TerminalSessionManager } from "@/agent/tools/terminal_session_manager.js";
import type { WingmanAgent } from "@/types/agents.js";
import type { Logger } from "../../logger.js";
import type { WingmanConfigType } from "../config/schema.js";
import type { OutputManager } from "./outputManager.js";
import type { SessionManager } from "./sessionManager.js";
export interface AgentInvokerOptions {
    workspace?: string;
    configDir?: string;
    outputManager: OutputManager;
    logger: Logger;
    sessionManager?: SessionManager;
    terminalSessionManager?: TerminalSessionManager;
    browserSessionManager?: BrowserSessionManager;
    workdir?: string | null;
    defaultOutputDir?: string | null;
    mcpProxyConfig?: MCPProxyConfig;
    nodeInvoker?: (request: NodeInvokeRequest) => Promise<NodeInvokeResult>;
    nodeDefaultTargetClientId?: string;
    nodeConnectedIdsProvider?: () => string[] | Promise<string[]>;
    nodeConnectedTargetsProvider?: () => ConnectedNodeTarget[] | Promise<ConnectedNodeTarget[]>;
}
export interface InvokeAgentOptions {
    signal?: AbortSignal;
    modelOverride?: string;
}
export type ImageAttachment = {
    kind?: "image";
    dataUrl: string;
    mimeType?: string;
    name?: string;
    size?: number;
};
export type AudioAttachment = {
    kind: "audio";
    dataUrl: string;
    mimeType?: string;
    name?: string;
    size?: number;
};
export type FileAttachment = {
    kind: "file";
    dataUrl: string;
    textContent: string;
    mimeType?: string;
    name?: string;
    size?: number;
};
export type MediaAttachment = ImageAttachment | AudioAttachment | FileAttachment;
type UserContentPart = {
    type: "text";
    text: string;
} | {
    type: "image_url";
    image_url: {
        url: string;
    };
} | {
    type: "audio";
    source_type: "base64";
    data: string;
    mime_type?: string;
} | {
    type: "audio";
    source_type: "url";
    url: string;
    mime_type?: string;
} | {
    type: "input_file";
    file_data?: string;
    file_url?: string;
    filename?: string;
} | {
    type: "file";
    source_type: "base64" | "url";
    mime_type: string;
    data?: string;
    url?: string;
    metadata?: {
        filename: string;
        name: string;
        title: string;
    };
};
export declare const WORKDIR_VIRTUAL_PATH = "/workdir/";
export declare const OUTPUT_VIRTUAL_PATH = "/output/";
export declare const AGENTS_MEMORY_VIRTUAL_PATHS: readonly ["/AGENTS.md"];
export type ExternalOutputMount = {
    virtualPath: string | null;
    absolutePath: string | null;
};
export type SummarizationMiddlewareSettings = {
    mode: "default";
} | {
    mode: "custom";
    maxTokensBeforeSummary?: number;
    messagesToKeep?: number;
};
export type ModelRetryMiddlewareSettings = {
    maxRetries: number;
    backoffFactor: number;
    initialDelayMs: number;
    maxDelayMs: number;
    jitter: boolean;
    onFailure: "continue" | "error";
};
export type ToolRetryMiddlewareSettings = ModelRetryMiddlewareSettings & {
    tools?: string[];
};
export type HumanInTheLoopSettings = {
    interruptOn: Record<string, boolean | {
        allowedDecisions: Array<"approve" | "edit" | "reject">;
        description?: string;
        argsSchema?: Record<string, any>;
    }>;
};
export type TokenUsageSnapshot = {
    inputTokens: number;
    outputTokens: number;
    totalTokens: number;
};
export declare const resolveExecutionWorkspace: (workspace: string, workdir?: string | null) => string;
export declare const resolveAgentExecutionWorkspace: (workspace: string, workdir?: string | null, defaultOutputDir?: string | null) => string;
export declare const resolveAgentMemorySources: (executionWorkspace: string) => string[];
export declare const toWorkspaceAliasVirtualPath: (absolutePath: string) => string | null;
export declare const resolveExternalOutputMount: (workspace: string, workdir?: string | null, defaultOutputDir?: string | null) => ExternalOutputMount;
export declare const resolveSummarizationMiddlewareSettings: (config: WingmanConfigType) => SummarizationMiddlewareSettings | null;
export declare const resolveModelRetryMiddlewareSettings: (config: WingmanConfigType) => ModelRetryMiddlewareSettings | null;
export declare const resolveToolRetryMiddlewareSettings: (config: WingmanConfigType) => ToolRetryMiddlewareSettings | null;
export declare const resolveHumanInTheLoopSettings: (config: WingmanConfigType) => HumanInTheLoopSettings | null;
export declare const configureDeepAgentSummarizationMiddleware: (agent: any, settings: SummarizationMiddlewareSettings | null, model?: any, backend?: any) => void;
export declare const resolveEffectiveSummarizationThresholdTokens: (settings: SummarizationMiddlewareSettings | null, model?: unknown) => Promise<number | undefined>;
export declare const recompileDeepAgentWithMiddlewareOverrides: <T>(agent: T) => T;
type ToolEventContext = {
    event: "on_tool_start" | "on_tool_end" | "on_tool_error";
    toolName: string;
};
export declare const detectToolEventContext: (chunk: unknown) => ToolEventContext | null;
export declare const chunkHasBuiltInSummarizationSignal: (chunk: unknown) => boolean;
export declare const chunkBelongsToSummarizationMiddleware: (chunk: unknown) => boolean;
export declare const chunkSignalsActiveSummarization: (chunk: unknown) => boolean;
export declare const chunkHasAssistantText: (chunk: unknown) => boolean;
export declare const selectStreamingFallbackText: (previousMessages: Array<{
    role?: unknown;
    content?: unknown;
}>, currentMessages: Array<{
    role?: unknown;
    content?: unknown;
}>) => string | undefined;
export declare const detectStreamErrorMessage: (chunk: unknown) => string | undefined;
export declare const extractTokenUsageSnapshot: (payload: unknown) => TokenUsageSnapshot | null;
export declare const estimateContextTokensFromChunk: (chunk: unknown) => number | null;
export declare const detectContextSummarizationTransition: ({ thresholdTokens, peakInputTokens, currentInputTokens, }: {
    thresholdTokens: number;
    peakInputTokens: number;
    currentInputTokens: number;
}) => boolean;
export declare const mergeTokenUsageSnapshots: (current: TokenUsageSnapshot | null, next: TokenUsageSnapshot | null) => TokenUsageSnapshot | null;
export declare const trackRootLangGraphRunId: (currentRootLangGraphRunId: string | undefined, chunk: unknown) => string | undefined;
export declare const isRootLangGraphTerminalEvent: (chunk: unknown, rootLangGraphRunId?: string) => boolean;
export declare const emitCompletionAndContinuePostProcessing: (input: {
    outputManager: Pick<OutputManager, "emitAgentComplete">;
    result: unknown;
    postProcess?: () => Promise<void>;
    logger?: Pick<Logger, "debug">;
}) => void;
export declare class AgentInvoker {
    private loader;
    private outputManager;
    private logger;
    private workspace;
    private configDir;
    private wingmanConfig;
    private mcpManager;
    private sessionManager;
    private terminalSessionManager;
    private browserSessionManager;
    private workdir;
    private defaultOutputDir;
    private mcpProxyConfig;
    private nodeInvoker;
    private nodeDefaultTargetClientId;
    private nodeConnectedIdsProvider;
    private nodeConnectedTargetsProvider;
    constructor(options: AgentInvokerOptions);
    findAllAgents(): WingmanAgentConfig[];
    /**
     * Find an agent by name
     */
    findAgent(name: string): Promise<WingmanAgent | undefined>;
    /**
     * Invoke a specific agent directly (bypassing main orchestration)
     */
    invokeAgent(agentName: string, prompt: string, sessionId?: string, attachments?: MediaAttachment[], options?: InvokeAgentOptions): Promise<any>;
    /**
     * List all available agents with their descriptions
     */
    listAgents(): Array<{
        name: string;
        description: string;
    }>;
    private materializeSessionImages;
}
export declare function buildUserContent(prompt: string, attachments?: MediaAttachment[], model?: unknown): string | UserContentPart[];
export {};