krisspy-ai 1.1.17

package/dist/index.d.ts

@@ -0,0 +1,961 @@
+export * from '@anthropic-ai/claude-agent-sdk';
+
+interface ProviderConfig {
+    baseUrl?: string;
+    apiKey?: string;
+    defaultModel?: string;
+}
+interface AnthropicMessage {
+    role: 'user' | 'assistant';
+    content: string | AnthropicContentBlock[];
+}
+interface AnthropicTextBlock {
+    type: 'text';
+    text: string;
+}
+interface AnthropicImageBlock {
+    type: 'image';
+    source: {
+        type: 'url' | 'base64';
+        url?: string;
+        media_type?: string;
+        data?: string;
+    };
+}
+interface AnthropicDocumentBlock {
+    type: 'document';
+    source: {
+        type: 'base64' | 'file';
+        media_type?: string;
+        data?: string;
+        file_id?: string;
+    };
+}
+interface AnthropicToolUseBlock {
+    type: 'tool_use';
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+}
+interface AnthropicToolResultBlock {
+    type: 'tool_result';
+    tool_use_id: string;
+    content: string | unknown;
+}
+type AnthropicContentBlock = AnthropicTextBlock | AnthropicImageBlock | AnthropicDocumentBlock | AnthropicToolUseBlock | AnthropicToolResultBlock;
+interface AnthropicTool {
+    name: string;
+    description?: string;
+    input_schema?: Record<string, unknown>;
+}
+interface AnthropicRequest {
+    model: string;
+    messages: AnthropicMessage[];
+    max_tokens?: number;
+    system?: string | Array<{
+        text: string;
+    }>;
+    tools?: AnthropicTool[];
+    tool_choice?: {
+        type: 'auto' | 'any' | 'tool';
+        name?: string;
+    };
+    stream?: boolean;
+    anthropic_version?: string;
+}
+interface AnthropicResponse {
+    id: string;
+    type: 'message';
+    role: 'assistant';
+    content: AnthropicContentBlock[];
+    model: string;
+    stop_reason: string | null;
+    stop_sequence: string | null;
+    usage: {
+        input_tokens: number;
+        output_tokens: number;
+    };
+}
+interface OpenAIMessage {
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    content: string | OpenAIContentPart[] | null;
+    tool_calls?: OpenAIToolCall[];
+    tool_call_id?: string;
+}
+interface OpenAIContentPart {
+    type: 'text' | 'image_url' | 'file';
+    text?: string;
+    image_url?: {
+        url: string;
+    };
+    file?: {
+        filename: string;
+        file_data: string;
+    };
+}
+interface OpenAIToolCall {
+    id: string;
+    type: 'function';
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+interface OpenAITool {
+    type: 'function';
+    function: {
+        name: string;
+        description?: string;
+        parameters?: Record<string, unknown>;
+    };
+}
+interface OpenAIRequest {
+    model: string;
+    messages: OpenAIMessage[];
+    max_tokens?: number;
+    max_completion_tokens?: number;
+    stream?: boolean;
+    tools?: OpenAITool[];
+    tool_choice?: string | {
+        type: 'function';
+        function: {
+            name: string;
+        };
+    };
+    temperature?: number;
+}
+interface StreamResponse {
+    setHeader(name: string, value: string): void;
+    flushHeaders(): void;
+    write(chunk: string): boolean;
+    flush?(): void;
+    end(): void;
+    writableEnded: boolean;
+}
+type ProviderRequest = OpenAIRequest | AnthropicRequest;
+interface Provider {
+    getName(): string;
+    mapModel(anthropicModel: string): string;
+    convertMessages(anthropicMessages: AnthropicMessage[]): OpenAIMessage[] | AnthropicMessage[];
+    convertTools(anthropicTools?: AnthropicTool[]): OpenAITool[] | AnthropicTool[] | undefined;
+    buildRequest(anthropicRequest: AnthropicRequest): ProviderRequest;
+    getEndpoint(): string;
+    getHeaders(): Record<string, string>;
+    handleStreamingResponse(providerResponse: {
+        body: NodeJS.ReadableStream;
+    }, res: StreamResponse, messageId: string, requestedModel: string): Promise<void>;
+    convertResponse(providerData: unknown, messageId: string, requestedModel: string): AnthropicResponse;
+}
+
+/**
+ * Base provider interface
+ * All providers must implement these methods
+ */
+declare abstract class BaseProvider implements Provider {
+    protected config: ProviderConfig;
+    constructor(config?: ProviderConfig);
+    /**
+     * Get provider name
+     */
+    abstract getName(): string;
+    /**
+     * Convert Anthropic messages to provider format
+     */
+    abstract convertMessages(anthropicMessages: AnthropicMessage[]): OpenAIMessage[] | AnthropicMessage[];
+    /**
+     * Convert Anthropic tools to provider format
+     */
+    abstract convertTools(anthropicTools?: AnthropicTool[]): OpenAITool[] | AnthropicTool[] | undefined;
+    /**
+     * Map Anthropic model to provider model
+     */
+    abstract mapModel(anthropicModel: string): string;
+    /**
+     * Build request body for provider API
+     */
+    abstract buildRequest(anthropicRequest: AnthropicRequest): ProviderRequest;
+    /**
+     * Get API endpoint URL
+     */
+    abstract getEndpoint(): string;
+    /**
+     * Get request headers
+     */
+    abstract getHeaders(): Record<string, string>;
+    /**
+     * Handle streaming response - convert provider SSE to Anthropic SSE format
+     */
+    abstract handleStreamingResponse(providerResponse: {
+        body: NodeJS.ReadableStream;
+    }, res: StreamResponse, messageId: string, requestedModel: string): Promise<void>;
+    /**
+     * Convert non-streaming response to Anthropic format
+     */
+    abstract convertResponse(providerData: unknown, messageId: string, requestedModel: string): AnthropicResponse;
+}
+
+declare class OpenAIProvider extends BaseProvider {
+    protected baseUrl: string;
+    protected apiKey: string;
+    protected defaultModel: string;
+    protected modelMap: Record<string, string>;
+    constructor(config?: ProviderConfig);
+    getName(): string;
+    mapModel(anthropicModel: string): string;
+    convertMessages(anthropicMessages: AnthropicMessage[]): OpenAIMessage[];
+    convertTools(anthropicTools?: AnthropicTool[]): OpenAITool[] | undefined;
+    buildRequest(anthropicRequest: AnthropicRequest): OpenAIRequest;
+    getEndpoint(): string;
+    getHeaders(): Record<string, string>;
+    handleStreamingResponse(providerResponse: {
+        body: NodeJS.ReadableStream;
+    }, res: StreamResponse, messageId: string, requestedModel: string): Promise<void>;
+    convertResponse(providerData: unknown, messageId: string, requestedModel: string): AnthropicResponse;
+}
+
+declare class ZAIProvider extends BaseProvider {
+    protected baseUrl: string;
+    protected apiKey: string;
+    protected defaultModel: string;
+    protected modelMap: Record<string, string>;
+    constructor(config?: ProviderConfig);
+    getName(): string;
+    mapModel(anthropicModel: string): string;
+    convertMessages(anthropicMessages: AnthropicMessage[]): OpenAIMessage[];
+    convertTools(anthropicTools?: AnthropicTool[]): OpenAITool[] | undefined;
+    buildRequest(anthropicRequest: AnthropicRequest): OpenAIRequest;
+    getEndpoint(): string;
+    getHeaders(): Record<string, string>;
+    handleStreamingResponse(providerResponse: {
+        body: NodeJS.ReadableStream;
+    }, res: StreamResponse, messageId: string, requestedModel: string): Promise<void>;
+    convertResponse(providerData: unknown, messageId: string, requestedModel: string): AnthropicResponse;
+}
+
+declare class GeminiProvider extends OpenAIProvider {
+    constructor(config?: ProviderConfig);
+    getName(): string;
+    buildRequest(anthropicRequest: AnthropicRequest): OpenAIRequest;
+    getHeaders(): Record<string, string>;
+}
+
+interface BedrockConfig extends ProviderConfig {
+    accessKeyId?: string;
+    secretAccessKey?: string;
+    region?: string;
+}
+declare class BedrockProvider extends BaseProvider {
+    protected region: string;
+    protected accessKeyId: string;
+    protected secretAccessKey: string;
+    protected defaultModel: string;
+    protected modelMap: Record<string, string>;
+    protected currentModel: string;
+    constructor(config?: BedrockConfig);
+    getName(): string;
+    mapModel(anthropicModel: string): string;
+    convertMessages(anthropicMessages: AnthropicMessage[]): AnthropicMessage[];
+    convertTools(anthropicTools?: AnthropicTool[]): AnthropicTool[] | undefined;
+    private sign;
+    private getSignatureKey;
+    private createAuthHeaders;
+    buildRequest(anthropicRequest: AnthropicRequest): AnthropicRequest;
+    getEndpoint(): string;
+    getHeaders(): Record<string, string>;
+    getSignedHeaders(payload: string): Record<string, string>;
+    handleStreamingResponse(providerResponse: {
+        body: NodeJS.ReadableStream;
+    }, res: StreamResponse, messageId: string, requestedModel: string): Promise<void>;
+    convertResponse(providerData: unknown, messageId: string, requestedModel: string): AnthropicResponse;
+}
+
+interface AzureConfig extends ProviderConfig {
+    deploymentName?: string;
+    apiVersion?: string;
+}
+/**
+ * Azure AI Foundry Provider (formerly Azure OpenAI)
+ *
+ * Uses the OpenAI-compatible API format with Azure-specific authentication and endpoints.
+ *
+ * Required config:
+ * - apiKey: Azure API key
+ * - baseUrl: Azure endpoint (e.g., https://your-resource.openai.azure.com)
+ * - deploymentName: Your model deployment name
+ */
+declare class AzureProvider extends OpenAIProvider {
+    protected deploymentName: string;
+    protected apiVersion: string;
+    constructor(config?: AzureConfig);
+    getName(): string;
+    mapModel(anthropicModel: string): string;
+    buildRequest(anthropicRequest: AnthropicRequest): OpenAIRequest;
+    getEndpoint(): string;
+    getHeaders(): Record<string, string>;
+}
+
+/**
+ * Krisspy Provider
+ * Routes requests through Krisspy backend for credit-based billing
+ *
+ * The Krisspy backend acts as a proxy that:
+ * 1. Validates the user's API key
+ * 2. Checks their credit balance
+ * 3. Forwards to AWS Bedrock (using Krisspy's AWS credentials)
+ * 4. Deducts credits based on token usage
+ */
+
+interface KrisspyProviderConfig extends ProviderConfig {
+    /** Krisspy API key (required at runtime) */
+    apiKey?: string;
+    /** Krisspy backend URL (default: https://api.krisspy.ai) */
+    baseUrl?: string;
+    /** App ID for billing context */
+    appId?: string;
+    /** User ID for billing context */
+    userId?: string;
+}
+declare class KrisspyProvider extends BaseProvider {
+    private krisspyConfig;
+    constructor(config: KrisspyProviderConfig);
+    getName(): string;
+    /**
+     * Pass through model names as-is
+     * Krisspy backend will handle model name mapping
+     */
+    mapModel(model: string): string;
+    /**
+     * Pass through Anthropic messages as-is
+     * Krisspy backend expects Anthropic format
+     */
+    convertMessages(messages: AnthropicMessage[]): AnthropicMessage[];
+    /**
+     * Pass through Anthropic tools as-is
+     */
+    convertTools(tools?: AnthropicTool[]): AnthropicTool[] | undefined;
+    /**
+     * Build request - pass through as Anthropic format
+     * Add Krisspy-specific headers/metadata
+     */
+    buildRequest(request: AnthropicRequest): AnthropicRequest;
+    /**
+     * Get Krisspy AI proxy endpoint
+     * Uses /messages endpoint for transparent LLM proxying (agent runs client-side)
+     */
+    getEndpoint(): string;
+    /**
+     * Get headers with Krisspy API key
+     */
+    getHeaders(): Record<string, string>;
+    /**
+     * Handle streaming response from Krisspy backend
+     * The backend streams krisspy-ai events as SSE, so we parse and pass through
+     */
+    handleStreamingResponse(providerResponse: {
+        body: NodeJS.ReadableStream;
+    }, res: StreamResponse, messageId: string, requestedModel: string): Promise<void>;
+    /**
+     * Convert non-streaming response
+     * Krisspy backend returns Anthropic format, so minimal conversion needed
+     */
+    convertResponse(data: unknown, messageId: string, requestedModel: string): AnthropicResponse;
+}
+
+type ProviderConstructor = new (config: ProviderConfig) => Provider;
+/**
+ * Get provider instance by name
+ * @param name - Provider name (openai, zai, etc.)
+ * @param config - Optional configuration
+ * @returns Provider instance
+ */
+declare function getProvider(name: string, config?: ProviderConfig): Provider;
+/**
+ * Register a new provider
+ * @param name - Provider name
+ * @param ProviderClass - Provider class extending BaseProvider
+ */
+declare function registerProvider(name: string, ProviderClass: ProviderConstructor): void;
+/**
+ * Get list of available providers
+ * @returns Provider names
+ */
+declare function getAvailableProviders(): string[];
+
+interface GenerativeServiceConfig {
+    apiKey?: string;
+    baseUrl?: string;
+    apiVersion?: string;
+    deploymentName?: string;
+}
+interface ImageGenerationOptions {
+    prompt: string;
+    n?: number;
+    size?: '1024x1024' | '1792x1024' | '1024x1792';
+    quality?: 'standard' | 'hd';
+    style?: 'natural' | 'vivid';
+    responseFormat?: 'url' | 'b64_json';
+    user?: string;
+}
+interface GeneratedImage {
+    url?: string;
+    b64_json?: string;
+    revisedPrompt?: string;
+}
+interface ImageGenerationResult {
+    created: number;
+    data: GeneratedImage[];
+}
+interface VideoGenerationOptions {
+    prompt: string;
+    duration?: number;
+    width?: number;
+    height?: number;
+    nVariants?: number;
+    user?: string;
+    referenceImage?: string;
+    referenceImageFormat?: 'base64' | 'url';
+}
+type VideoJobStatusType = 'pending' | 'running' | 'succeeded' | 'failed' | 'canceled';
+interface VideoJobSubmission {
+    jobId: string;
+    status: VideoJobStatusType;
+    createdAt: string;
+}
+interface VideoJobStatus {
+    jobId: string;
+    status: VideoJobStatusType;
+    progress?: number;
+    error?: string;
+    createdAt: string;
+    expiresAt?: string;
+}
+interface GeneratedVideo {
+    id: string;
+    url?: string;
+}
+interface VideoGenerationResult {
+    jobId: string;
+    status: 'succeeded';
+    generations: GeneratedVideo[];
+    createdAt: string;
+}
+interface GenerateImageOptions extends ImageGenerationOptions {
+    service?: string;
+    apiKey: string;
+    baseUrl?: string;
+    deploymentName?: string;
+    apiVersion?: string;
+}
+interface GenerateVideoOptions extends VideoGenerationOptions {
+    service?: string;
+    apiKey: string;
+    baseUrl?: string;
+    deploymentName?: string;
+    apiVersion?: string;
+    pollInterval?: number;
+    timeout?: number;
+}
+type VideoGenerationEvent = {
+    type: 'status';
+    status: VideoJobStatus;
+} | {
+    type: 'result';
+    data: VideoGenerationResult;
+};
+interface TranscriptionOptions {
+    audio: Buffer | string;
+    language?: string;
+    prompt?: string;
+    responseFormat?: 'json' | 'text' | 'srt' | 'verbose_json' | 'vtt';
+    temperature?: number;
+    timestampGranularities?: ('word' | 'segment')[];
+}
+interface TranscriptionWord {
+    word: string;
+    start: number;
+    end: number;
+}
+interface TranscriptionSegment {
+    id: number;
+    seek: number;
+    start: number;
+    end: number;
+    text: string;
+    tokens: number[];
+    temperature: number;
+    avg_logprob: number;
+    compression_ratio: number;
+    no_speech_prob: number;
+}
+interface DiarizedUtterance {
+    speaker: string;
+    start: number;
+    end: number;
+    text: string;
+}
+interface TranscriptionResult {
+    text: string;
+    language?: string;
+    duration?: number;
+    words?: TranscriptionWord[];
+    segments?: TranscriptionSegment[];
+    utterances?: DiarizedUtterance[];
+}
+type TTSVoice = 'alloy' | 'ash' | 'coral' | 'echo' | 'fable' | 'onyx' | 'nova' | 'sage' | 'shimmer';
+type TTSFormat = 'mp3' | 'opus' | 'aac' | 'flac' | 'wav' | 'pcm';
+interface TTSOptions {
+    input: string;
+    voice?: TTSVoice;
+    responseFormat?: TTSFormat;
+    speed?: number;
+    instructions?: string;
+}
+interface TTSResult {
+    audio: Buffer;
+    format: TTSFormat;
+}
+interface TranscribeOptions extends TranscriptionOptions {
+    service?: string;
+    apiKey: string;
+    baseUrl?: string;
+    deploymentName?: string;
+    apiVersion?: string;
+}
+interface SynthesizeOptions extends TTSOptions {
+    service?: string;
+    apiKey: string;
+    baseUrl?: string;
+    deploymentName?: string;
+    apiVersion?: string;
+}
+
+declare abstract class BaseGenerativeService {
+    protected config: GenerativeServiceConfig;
+    constructor(config?: GenerativeServiceConfig);
+    abstract getName(): string;
+    abstract getServiceType(): 'image' | 'video' | 'transcription' | 'tts';
+}
+
+declare abstract class BaseImageService extends BaseGenerativeService {
+    constructor(config?: GenerativeServiceConfig);
+    getServiceType(): 'image';
+    abstract generate(options: ImageGenerationOptions): Promise<ImageGenerationResult>;
+}
+
+declare abstract class BaseVideoService extends BaseGenerativeService {
+    constructor(config?: GenerativeServiceConfig);
+    getServiceType(): 'video';
+    abstract submitJob(options: VideoGenerationOptions): Promise<VideoJobSubmission>;
+    abstract getJobStatus(jobId: string): Promise<VideoJobStatus>;
+    abstract getResult(jobId: string): Promise<VideoGenerationResult>;
+    abstract downloadVideo(generationId: string): Promise<Buffer>;
+    /**
+     * Convenience generator that submits a job and polls until completion.
+     * Yields status updates and returns the final result.
+     *
+     * @param options - Video generation options
+     * @param pollInterval - Time between status checks in ms (default: 5000)
+     * @param timeout - Max wait time in ms (default: 600000 = 10 minutes)
+     */
+    generateAndWait(options: VideoGenerationOptions, pollInterval?: number, timeout?: number): AsyncGenerator<VideoJobStatus, VideoGenerationResult>;
+}
+
+/**
+ * Base class for speech-to-text transcription services
+ */
+declare abstract class BaseTranscriptionService extends BaseGenerativeService {
+    constructor(config?: GenerativeServiceConfig);
+    getServiceType(): 'transcription';
+    abstract transcribe(options: TranscriptionOptions): Promise<TranscriptionResult>;
+}
+/**
+ * Base class for text-to-speech synthesis services
+ */
+declare abstract class BaseTTSService extends BaseGenerativeService {
+    constructor(config?: GenerativeServiceConfig);
+    getServiceType(): 'tts';
+    abstract synthesize(options: TTSOptions): Promise<TTSResult>;
+}
+
+declare class AzureDalleService extends BaseImageService {
+    private baseUrl;
+    private apiKey;
+    private deploymentName;
+    private apiVersion;
+    constructor(config?: GenerativeServiceConfig);
+    getName(): string;
+    generate(options: ImageGenerationOptions): Promise<ImageGenerationResult>;
+}
+
+declare class OpenAIImageService extends BaseImageService {
+    private apiKey;
+    private baseUrl;
+    private model;
+    constructor(config?: GenerativeServiceConfig);
+    getName(): string;
+    generate(options: ImageGenerationOptions): Promise<ImageGenerationResult>;
+}
+
+declare class AzureSoraService extends BaseVideoService {
+    private baseUrl;
+    private apiKey;
+    private deploymentName;
+    private apiVersion;
+    constructor(config?: GenerativeServiceConfig);
+    getName(): string;
+    private mapStatus;
+    submitJob(options: VideoGenerationOptions): Promise<VideoJobSubmission>;
+    getJobStatus(jobId: string): Promise<VideoJobStatus>;
+    getResult(jobId: string): Promise<VideoGenerationResult>;
+    downloadVideo(generationId: string): Promise<Buffer>;
+}
+
+declare class OpenAISoraService extends BaseVideoService {
+    private baseUrl;
+    private apiKey;
+    private model;
+    constructor(config?: GenerativeServiceConfig);
+    getName(): string;
+    private mapStatus;
+    submitJob(options: VideoGenerationOptions): Promise<VideoJobSubmission>;
+    getJobStatus(jobId: string): Promise<VideoJobStatus>;
+    getResult(jobId: string): Promise<VideoGenerationResult>;
+    downloadVideo(generationId: string): Promise<Buffer>;
+}
+
+declare class AzureTranscriptionService extends BaseTranscriptionService {
+    private baseUrl;
+    private apiKey;
+    private deploymentName;
+    private apiVersion;
+    constructor(config?: GenerativeServiceConfig);
+    getName(): string;
+    transcribe(options: TranscriptionOptions): Promise<TranscriptionResult>;
+}
+
+declare class OpenAITranscriptionService extends BaseTranscriptionService {
+    private baseUrl;
+    private apiKey;
+    private model;
+    constructor(config?: GenerativeServiceConfig);
+    getName(): string;
+    transcribe(options: TranscriptionOptions): Promise<TranscriptionResult>;
+}
+
+declare class AzureTTSService extends BaseTTSService {
+    private baseUrl;
+    private apiKey;
+    private deploymentName;
+    private apiVersion;
+    constructor(config?: GenerativeServiceConfig);
+    getName(): string;
+    synthesize(options: TTSOptions): Promise<TTSResult>;
+}
+
+declare class OpenAITTSService extends BaseTTSService {
+    private baseUrl;
+    private apiKey;
+    private model;
+    constructor(config?: GenerativeServiceConfig);
+    getName(): string;
+    synthesize(options: TTSOptions): Promise<TTSResult>;
+}
+
+type ImageServiceConstructor = new (config: GenerativeServiceConfig) => BaseImageService;
+type VideoServiceConstructor = new (config: GenerativeServiceConfig) => BaseVideoService;
+type TranscriptionServiceConstructor = new (config: GenerativeServiceConfig) => BaseTranscriptionService;
+type TTSServiceConstructor = new (config: GenerativeServiceConfig) => BaseTTSService;
+/**
+ * Get an image generation service by name
+ *
+ * @param name - Service name: 'azure', 'openai', 'gpt-image'
+ * @param config - Service configuration
+ * @returns Image service instance
+ */
+declare function getImageService(name: string, config?: GenerativeServiceConfig): BaseImageService;
+/**
+ * Get a video generation service by name
+ *
+ * @param name - Service name: 'azure', 'openai', 'sora'
+ * @param config - Service configuration
+ * @returns Video service instance
+ */
+declare function getVideoService(name: string, config?: GenerativeServiceConfig): BaseVideoService;
+/**
+ * Get a transcription (speech-to-text) service by name
+ *
+ * @param name - Service name: 'azure', 'openai', 'whisper', 'gpt-4o-transcribe', 'gpt-4o-transcribe-diarize'
+ * @param config - Service configuration
+ * @returns Transcription service instance
+ *
+ * @example
+ * const service = getTranscriptionService('openai', {
+ *   apiKey: 'sk-...',
+ *   deploymentName: 'whisper'  // or 'gpt-4o-transcribe-diarize'
+ * });
+ * const result = await service.transcribe({ audio: audioBuffer });
+ */
+declare function getTranscriptionService(name: string, config?: GenerativeServiceConfig): BaseTranscriptionService;
+/**
+ * Get a TTS (text-to-speech) service by name
+ *
+ * @param name - Service name: 'azure', 'openai', 'tts', 'tts', 'gpt-4o-mini-tts'
+ * @param config - Service configuration
+ * @returns TTS service instance
+ *
+ * @example
+ * const service = getTTSService('openai', {
+ *   apiKey: 'sk-...',
+ *   deploymentName: 'gpt-4o-mini-tts'
+ * });
+ * const result = await service.synthesize({ input: 'Hello world', voice: 'nova' });
+ */
+declare function getTTSService(name: string, config?: GenerativeServiceConfig): BaseTTSService;
+/**
+ * Register a custom image generation service
+ */
+declare function registerImageService(name: string, ServiceClass: ImageServiceConstructor): void;
+/**
+ * Register a custom video generation service
+ */
+declare function registerVideoService(name: string, ServiceClass: VideoServiceConstructor): void;
+/**
+ * Register a custom transcription service
+ */
+declare function registerTranscriptionService(name: string, ServiceClass: TranscriptionServiceConstructor): void;
+/**
+ * Register a custom TTS service
+ */
+declare function registerTTSService(name: string, ServiceClass: TTSServiceConstructor): void;
+declare function getAvailableImageServices(): string[];
+declare function getAvailableVideoServices(): string[];
+declare function getAvailableTranscriptionServices(): string[];
+declare function getAvailableTTSServices(): string[];
+
+interface FileAttachment {
+    type: 'pdf' | 'xlsx' | 'docx' | 'pptx' | 'csv' | 'unknown';
+    media_type: string;
+    data: string;
+}
+interface ImageAttachment {
+    type: 'url' | 'base64';
+    url?: string;
+    media_type?: string;
+    data?: string;
+}
+type ProviderType = 'claude_cli' | 'anthropic' | 'openai' | 'gemini' | 'zai' | 'zai_direct' | 'bedrock' | 'azure' | 'codex' | 'codex_cli' | 'krisspy';
+interface MCPServerConfigStdio {
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+    cwd?: string;
+}
+interface MCPServerConfigHttp {
+    type: 'http';
+    url: string;
+    headers?: Record<string, string>;
+}
+type MCPServerConfig = MCPServerConfigStdio | MCPServerConfigHttp;
+interface HookConfig {
+    command: string;
+    timeout?: number;
+}
+interface HooksConfig {
+    onStart?: HookConfig;
+    onStop?: HookConfig;
+    onToolCall?: HookConfig;
+    onToolResult?: HookConfig;
+}
+interface AgentConfig {
+    name: string;
+    model?: string;
+    systemPrompt?: string;
+    tools?: string[];
+}
+interface KrissyQueryOptions {
+    [key: string]: unknown;
+    provider?: ProviderType;
+    model?: string;
+    apiKey?: string;
+    baseUrl?: string;
+    attachments?: {
+        images?: Array<ImageAttachment>;
+        files?: Array<FileAttachment>;
+    };
+    maxThinkingTokens?: number;
+    mcpServers?: Record<string, MCPServerConfig>;
+    betas?: string[];
+    allowedTools?: string[];
+    permissionMode?: 'default' | 'acceptEdits' | 'plan' | 'bypassPermissions';
+    systemPrompt?: string | {
+        type: 'preset';
+        preset: string;
+    } | {
+        type: 'custom';
+        content: string;
+    };
+    cwd?: string;
+    env?: Record<string, string>;
+    hooks?: HooksConfig;
+    agents?: Record<string, AgentConfig>;
+    maxTurns?: number;
+    maxBudgetUsd?: number;
+    outputFormat?: 'text' | 'json' | 'stream-json';
+    resume?: string;
+    sandbox?: boolean;
+    includePartialMessages?: boolean;
+    accessKeyId?: string;
+    secretAccessKey?: string;
+    region?: string;
+    deploymentName?: string;
+    apiVersion?: string;
+}
+/**
+ * query() - Drop-in replacement for claude-agent-sdk's query()
+ *
+ * Same API as @anthropic-ai/claude-agent-sdk but with:
+ * - Multi-provider support via options.provider
+ * - Integrated proxy for OpenAI/Gemini/ZAI (no separate server needed)
+ * - Multimodal support via options.attachments
+ * - All configuration via explicit options (no env vars required)
+ *
+ * @example
+ * // Use OpenAI with explicit API key
+ * for await (const event of query({
+ *   prompt: 'Hello',
+ *   options: {
+ *     provider: 'openai',
+ *     apiKey: 'sk-...',
+ *     model: 'gpt-4o'
+ *   }
+ * })) {
+ *   console.log(event);
+ * }
+ *
+ * @example
+ * // Use Anthropic directly
+ * for await (const event of query({
+ *   prompt: 'Hello',
+ *   options: {
+ *     provider: 'anthropic',
+ *     apiKey: 'sk-ant-...'
+ *   }
+ * })) {
+ *   console.log(event);
+ * }
+ */
+declare function query(params: {
+    prompt: string | AsyncIterable<unknown>;
+    options?: KrissyQueryOptions;
+}): AsyncGenerator<unknown, void, unknown>;
+declare function cleanup(): Promise<void>;
+
+/**
+ * Generate an image using the specified service
+ *
+ * @param options - Image generation options
+ * @returns Promise resolving to image generation result
+ *
+ * @example
+ * const result = await generateImage({
+ *   prompt: 'A cute baby polar bear',
+ *   apiKey: 'your-azure-key',
+ *   baseUrl: 'https://your-resource.openai.azure.com',
+ *   deploymentName: 'gpt-image-1.5',
+ *   size: '1024x1024',
+ * });
+ * console.log(result.data[0].url);
+ *
+ * // Save to file
+ * const imageUrl = result.data[0].url;
+ * // or if using b64_json:
+ * const imageBuffer = Buffer.from(result.data[0].b64_json!, 'base64');
+ */
+declare function generateImage(options: GenerateImageOptions): Promise<ImageGenerationResult>;
+/**
+ * Generate a video using the specified service (async with polling)
+ *
+ * This is an async generator that yields status updates and finally the result.
+ *
+ * @param options - Video generation options
+ * @yields Status updates as { type: 'status', status: VideoJobStatus }
+ * @yields Final result as { type: 'result', data: VideoGenerationResult }
+ *
+ * @example
+ * for await (const event of generateVideo({
+ *   prompt: 'Wooly mammoths slowly walking in the ice',
+ *   apiKey: 'your-azure-key',
+ *   baseUrl: 'https://your-resource.openai.azure.com',
+ *   deploymentName: 'sora-2',
+ *   duration: 5,
+ * })) {
+ *   if (event.type === 'status') {
+ *     console.log(`Status: ${event.status.status}`);
+ *   } else if (event.type === 'result') {
+ *     console.log(`Video ready! Generation ID: ${event.data.generations[0].id}`);
+ *     // Download the video
+ *     const videoService = getVideoService('azure', { apiKey, baseUrl });
+ *     const videoBuffer = await videoService.downloadVideo(event.data.generations[0].id);
+ *     fs.writeFileSync('output.mp4', videoBuffer);
+ *   }
+ * }
+ */
+declare function generateVideo(options: GenerateVideoOptions): AsyncGenerator<VideoGenerationEvent>;
+/**
+ * Transcribe audio to text using the specified service
+ *
+ * @param options - Transcription options
+ * @returns Promise resolving to transcription result
+ *
+ * @example
+ * // Using OpenAI Whisper
+ * const result = await transcribe({
+ *   audio: fs.readFileSync('audio.mp3'),
+ *   apiKey: 'sk-...',
+ *   deploymentName: 'whisper',
+ * });
+ * console.log(result.text);
+ *
+ * @example
+ * // Using GPT-4o with diarization (speaker identification)
+ * const result = await transcribe({
+ *   audio: fs.readFileSync('meeting.mp3'),
+ *   apiKey: 'sk-...',
+ *   deploymentName: 'gpt-4o-transcribe-diarize',
+ *   responseFormat: 'verbose_json',
+ * });
+ * for (const utterance of result.utterances || []) {
+ *   console.log(`${utterance.speaker}: ${utterance.text}`);
+ * }
+ */
+declare function transcribe(options: TranscribeOptions): Promise<TranscriptionResult>;
+/**
+ * Synthesize speech from text using the specified service
+ *
+ * @param options - TTS options
+ * @returns Promise resolving to audio buffer
+ *
+ * @example
+ * // Using OpenAI TTS
+ * const result = await synthesize({
+ *   input: 'Hello, how are you today?',
+ *   apiKey: 'sk-...',
+ *   voice: 'nova',
+ *   responseFormat: 'mp3',
+ * });
+ * fs.writeFileSync('output.mp3', result.audio);
+ *
+ * @example
+ * // Using gpt-4o-mini-tts with voice style instructions
+ * const result = await synthesize({
+ *   input: 'Welcome to our podcast!',
+ *   apiKey: 'sk-...',
+ *   deploymentName: 'gpt-4o-mini-tts',
+ *   voice: 'coral',
+ *   instructions: 'Speak in an enthusiastic, energetic podcast host style',
+ * });
+ * fs.writeFileSync('intro.mp3', result.audio);
+ */
+declare function synthesize(options: SynthesizeOptions): Promise<TTSResult>;
+
+export { type AgentConfig, type AnthropicMessage, type AnthropicRequest, type AnthropicResponse, AzureDalleService, AzureProvider, AzureSoraService, AzureTTSService, AzureTranscriptionService, BaseGenerativeService, BaseImageService, BaseProvider, BaseTTSService, BaseTranscriptionService, BaseVideoService, BedrockProvider, type DiarizedUtterance, GeminiProvider, type GenerateImageOptions, type GenerateVideoOptions, type GeneratedImage, type GeneratedVideo, type GenerativeServiceConfig, type HookConfig, type HooksConfig, type ImageGenerationOptions, type ImageGenerationResult, KrisspyProvider, type KrissyQueryOptions, type MCPServerConfig, type MCPServerConfigHttp, type MCPServerConfigStdio, OpenAIImageService, type OpenAIMessage, OpenAIProvider, type OpenAIRequest, OpenAISoraService, OpenAITTSService, OpenAITranscriptionService, type Provider, type ProviderConfig, type ProviderType, type SynthesizeOptions, type TTSFormat, type TTSOptions, type TTSResult, type TTSVoice, type TranscribeOptions, type TranscriptionOptions, type TranscriptionResult, type TranscriptionSegment, type TranscriptionWord, type VideoGenerationEvent, type VideoGenerationOptions, type VideoGenerationResult, type VideoJobStatus, type VideoJobSubmission, ZAIProvider, cleanup, generateImage, generateVideo, getAvailableImageServices, getAvailableProviders, getAvailableTTSServices, getAvailableTranscriptionServices, getAvailableVideoServices, getImageService, getProvider, getTTSService, getTranscriptionService, getVideoService, query, registerImageService, registerProvider, registerTTSService, registerTranscriptionService, registerVideoService, synthesize, transcribe };