import { c as VaultOptions, a as Vault } from './vault.interface-BZt4wlVo.js';

declare enum MessageRole {
    USER = "user",
    ASSISTANT = "assistant",
    SYSTEM = "system"
}
type ContentPart = {
    type: "text";
    text: string;
} | {
    type: "image";
    data: string;
    mediaType: string;
} | {
    type: "image-url";
    url: string;
} | {
    type: "file";
    data: string;
    mediaType: string;
    name?: string;
};
interface Message {
    role: MessageRole;
    content: string | ContentPart[];
}
/** Normalized tool output; provider parsers map into this shape. */
type ToolResultContent = {
    type: "text";
    text: string;
} | {
    type: "citation";
    url: string;
    title?: string;
    excerpts?: string[];
} | {
    type: "json";
    value: unknown;
} | {
    type: "media";
    mediaType: string;
    data: string;
    name?: string;
} | {
    type: "unknown";
    providerType: string;
    data: Record<string, unknown>;
};
interface ToolResult {
    toolUseId: string;
    content: ToolResultContent[];
    isError?: boolean;
    approved?: boolean;
}
interface RequestParams {
    /** Messages for this turn. May include system, user, and assistant messages. */
    messages: Message[];
    /** Opaque session identifier returned by a prior response. Absent means start a new session. */
    sessionId?: string;
    /** Vault IDs to bind to this request (credentials available to MCP servers). */
    vaultIds?: string[];
    /** Approval responses or tool outputs from a previous requires-action turn. */
    toolResults?: ToolResult[];
    /** Pass-through options forwarded directly to the underlying provider SDK call. */
    providerOptions?: Record<string, unknown>;
    /** When fired, the SDK closes the connection and the operation yields an `AbortedError`. */
    abortSignal?: AbortSignal;
    /** Metadata forwarded in the webhook payload for routing/context on the receiving end. */
    webhookMetadata?: Record<string, string>;
}
interface SessionOptions {
    vaultIds?: string[];
    providerOptions?: Record<string, unknown>;
}
interface Usage {
    inputTokens?: number;
    outputTokens?: number;
    totalTokens?: number;
}
type ToolSource = {
    type: "builtin";
} | {
    type: "custom";
} | {
    type: "mcp";
    serverName: string;
};
type McpApprovalPolicy = "always" | "never" | {
    except: string[];
};
interface McpServerConfig {
    name: string;
    url: string;
    authorization?: string;
    allowedTools?: string[];
    approvalPolicy?: McpApprovalPolicy;
}
interface McpToolDef {
    name: string;
    description?: string;
    inputSchema?: Record<string, unknown>;
}
type ActionRequired = {
    type: "tool-confirmation";
    toolUseId: string;
    toolName: string;
    input?: Record<string, unknown>;
} | {
    type: "mcp-approval";
    toolUseId: string;
    toolName: string;
    serverName: string;
    input?: Record<string, unknown>;
};
interface Response {
    content: string;
    /** Session identifier to pass as `sessionId` on the next turn to continue the conversation. */
    sessionId?: string;
    finishReason: "stop" | "length" | "error" | "requires-action" | "refused" | "other";
    usage?: Usage;
    actionsRequired?: ActionRequired[];
}
type AgentStatus = "running" | "queued" | "retrying" | "idle";
type StreamPart = {
    type: "text-delta";
    text: string;
} | {
    type: "refusal";
    text: string;
} | {
    type: "thinking";
    text: string;
} | {
    type: "tool-use-start";
    toolName: string;
    toolUseId: string;
    source?: ToolSource;
} | {
    type: "tool-use-delta";
    toolUseId: string;
    argumentsDelta: string;
} | {
    type: "tool-use-done";
    toolName: string;
    toolUseId: string;
    input?: Record<string, unknown>;
    source?: ToolSource;
} | {
    type: "tool-use-result";
    toolUseId: string;
    content: ToolResultContent[];
    isError?: boolean;
    source?: ToolSource;
} | {
    type: "mcp-tools-discovered";
    serverName: string;
    tools: McpToolDef[];
} | {
    type: "step-start";
    stepIndex: number;
} | {
    type: "step-done";
    stepIndex: number;
} | {
    type: "status-change";
    status: AgentStatus;
} | {
    type: "stream-start";
    sessionId?: string;
} | {
    type: "finish";
    response: Response;
} | {
    type: "error";
    error: Error;
} | {
    type: "provider-event";
    provider: string;
    event: string;
    data: Record<string, unknown>;
};
interface StreamCallbacks {
    /** Fires for every stream part, before type-specific callbacks. */
    onPart?: (part: StreamPart) => void | Promise<void>;
    onTextDelta?: (part: Extract<StreamPart, {
        type: "text-delta";
    }>) => void | Promise<void>;
    onThinking?: (part: Extract<StreamPart, {
        type: "thinking";
    }>) => void | Promise<void>;
    onRefusal?: (part: Extract<StreamPart, {
        type: "refusal";
    }>) => void | Promise<void>;
    onToolUseStart?: (part: Extract<StreamPart, {
        type: "tool-use-start";
    }>) => void | Promise<void>;
    onToolUseDelta?: (part: Extract<StreamPart, {
        type: "tool-use-delta";
    }>) => void | Promise<void>;
    onToolUseDone?: (part: Extract<StreamPart, {
        type: "tool-use-done";
    }>) => void | Promise<void>;
    onToolUseResult?: (part: Extract<StreamPart, {
        type: "tool-use-result";
    }>) => void | Promise<void>;
    onMcpToolsDiscovered?: (part: Extract<StreamPart, {
        type: "mcp-tools-discovered";
    }>) => void | Promise<void>;
    onStepStart?: (part: Extract<StreamPart, {
        type: "step-start";
    }>) => void | Promise<void>;
    onStepDone?: (part: Extract<StreamPart, {
        type: "step-done";
    }>) => void | Promise<void>;
    onStatusChange?: (part: Extract<StreamPart, {
        type: "status-change";
    }>) => void | Promise<void>;
    onStreamStart?: (part: Extract<StreamPart, {
        type: "stream-start";
    }>) => void | Promise<void>;
    onFinish?: (part: Extract<StreamPart, {
        type: "finish";
    }>) => void | Promise<void>;
    onError?: (part: Extract<StreamPart, {
        type: "error";
    }>) => void | Promise<void>;
    onProviderEvent?: (part: Extract<StreamPart, {
        type: "provider-event";
    }>) => void | Promise<void>;
}
interface SendResult extends PromiseLike<Response> {
    /** Unique identifier for this `send()` invocation. Known synchronously. */
    readonly runId: string;
    readonly sessionId: Promise<string>;
    readonly response: Promise<Response>;
    text(): Promise<string>;
}
interface WebhookSendResult {
    sessionId: string;
    /** Unique identifier for this `send()` invocation, also present in every webhook event. */
    runId: string;
}
type SessionEventsFactory = (sessionId: string, runId: string) => StreamCallbacks;
interface BaseProvider {
    readonly provider: string;
    readonly runtimeId: string;
    createVault(options: VaultOptions): Promise<Vault>;
    getVault(vaultId: string): Promise<Vault>;
    createSession(options?: SessionOptions): Promise<string>;
    endSession(sessionId: string): Promise<void>;
}
interface StreamingProvider extends BaseProvider {
    send(params: RequestParams): SendResult;
}
interface WebhookProvider extends BaseProvider {
    send(params: RequestParams): Promise<WebhookSendResult>;
}
type Provider = StreamingProvider | WebhookProvider;
declare const ANTHROPIC: "anthropic";
declare const OPENAI: "openai";

export { ANTHROPIC as A, type ContentPart as C, type Message as M, OPENAI as O, type Provider as P, type RequestParams as R, type SessionEventsFactory as S, type ToolResult as T, type Usage as U, type WebhookProvider as W, type StreamingProvider as a, type McpServerConfig as b, type StreamCallbacks as c, type StreamPart as d, type SendResult as e, type ActionRequired as f, type AgentStatus as g, type McpApprovalPolicy as h, type McpToolDef as i, MessageRole as j, type Response as k, type SessionOptions as l, type ToolResultContent as m, type ToolSource as n, type WebhookSendResult as o };