/**
 * Anthropic LLM Adapter
 *
 * Wraps the official `@anthropic-ai/sdk` npm package for direct integration.
 * The `@anthropic-ai/sdk` package must be installed as a peer dependency.
 *
 * @example Using with API key
 * ```typescript
 * const adapter = new AnthropicAdapter({ model: 'claude-sonnet-4-6', apiKey: 'sk-ant-...' });
 * ```
 *
 * @example Using with pre-configured client
 * ```typescript
 * import Anthropic from '@anthropic-ai/sdk';
 * const adapter = new AnthropicAdapter({
 *   model: 'claude-sonnet-4-6',
 *   client: new Anthropic({ apiKey: 'sk-ant-...' }),
 * });
 * ```
 */
import { type AgentCompletion, type AgentCompletionChunk, type AgentCompletionOptions, type AgentLlmAdapter, type AgentMessage, type AgentPrompt, type AgentToolDefinition } from '../../common';
import { BaseLlmAdapter, type BaseLlmAdapterConfig } from './base.adapter';
interface AnthropicClient {
    messages: {
        create(params: AnthropicCreateParams & {
            stream?: false;
        }): Promise<AnthropicMessage>;
        create(params: AnthropicCreateParams & {
            stream: true;
        }): Promise<AnthropicStream>;
        create(params: AnthropicCreateParams): Promise<AnthropicMessage | AnthropicStream>;
    };
}
interface AnthropicCreateParams {
    model: string;
    messages: AnthropicMessageParam[];
    system?: string;
    tools?: AnthropicTool[];
    tool_choice?: {
        type: 'auto' | 'any' | 'tool';
        name?: string;
    };
    temperature?: number;
    max_tokens: number;
    stop_sequences?: string[];
    stream?: boolean;
}
type AnthropicMessageParam = {
    role: 'user';
    content: string | AnthropicContentBlock[];
} | {
    role: 'assistant';
    content: string | AnthropicContentBlock[];
};
type AnthropicContentBlock = {
    type: 'text';
    text: string;
} | {
    type: 'tool_use';
    id: string;
    name: string;
    input: Record<string, unknown>;
} | {
    type: 'tool_result';
    tool_use_id: string;
    content: string;
};
interface AnthropicTool {
    name: string;
    description?: string;
    input_schema: Record<string, unknown>;
}
interface AnthropicMessage {
    content: AnthropicContentBlock[];
    stop_reason: string | null;
    usage: {
        input_tokens: number;
        output_tokens: number;
    };
}
interface AnthropicStream {
    [Symbol.asyncIterator](): AsyncIterator<AnthropicStreamEvent>;
}
type AnthropicStreamEvent = {
    type: 'message_start';
    message: {
        usage: {
            input_tokens: number;
            output_tokens: number;
        };
    };
} | {
    type: 'content_block_start';
    index: number;
    content_block: AnthropicContentBlock;
} | {
    type: 'content_block_delta';
    index: number;
    delta: AnthropicDelta;
} | {
    type: 'content_block_stop';
    index: number;
} | {
    type: 'message_delta';
    delta: {
        stop_reason: string;
    };
    usage?: {
        output_tokens: number;
    };
} | {
    type: 'message_stop';
};
type AnthropicDelta = {
    type: 'text_delta';
    text: string;
} | {
    type: 'input_json_delta';
    partial_json: string;
};
/**
 * Configuration for the Anthropic adapter.
 * Provide either `apiKey` (adapter creates client) or `client` (pre-configured).
 */
export type AnthropicAdapterConfig = (BaseLlmAdapterConfig & {
    client?: never;
}) | {
    model: string;
    client: AnthropicClient;
    temperature?: number;
    maxTokens?: number;
    timeout?: number;
    maxRetries?: number;
};
export declare class AnthropicAdapter extends BaseLlmAdapter implements AgentLlmAdapter {
    private client;
    private readonly providedClient;
    constructor(config: AnthropicAdapterConfig);
    private getClient;
    completion(prompt: AgentPrompt, tools?: AgentToolDefinition[], options?: AgentCompletionOptions): Promise<AgentCompletion>;
    streamCompletion(prompt: AgentPrompt, tools?: AgentToolDefinition[], options?: AgentCompletionOptions): AsyncGenerator<AgentCompletionChunk>;
    private buildParams;
    private formatAnthropicMessages;
    protected formatMessage(message: AgentMessage): unknown;
    protected formatTools(tools: AgentToolDefinition[]): unknown[];
    protected parseResponse(response: unknown): AgentCompletion;
    private mapStopReason;
    private wrapError;
}
export {};
//# sourceMappingURL=anthropic.adapter.d.ts.map