@lov3kaizen/agentsea-structured 0.5.1

package/dist/index.d.ts

@@ -0,0 +1,783 @@
+import { z, ZodError } from 'zod';
+import { EventEmitter } from 'eventemitter3';
+
+type ExtractionMode = 'json' | 'tool' | 'prompt' | 'hybrid';
+type StructuredProvider$1 = 'openai' | 'anthropic' | 'google' | 'generic';
+type MessageRole = 'system' | 'user' | 'assistant';
+interface ChatMessage {
+    role: MessageRole;
+    content: string;
+    name?: string;
+}
+interface StructuredRequestOptions<T extends z.ZodType> {
+    model: string;
+    messages: ChatMessage[];
+    response_format: T;
+    mode?: ExtractionModeConfig;
+    retry?: Partial<RetryConfig>;
+    temperature?: number;
+    maxTokens?: number;
+    options?: Record<string, unknown>;
+}
+type ExtractionModeConfig = ExtractionMode | JsonModeConfig | ToolModeConfig | PromptModeConfig | HybridModeConfig;
+interface JsonModeConfig {
+    mode: 'json';
+    strict?: boolean;
+}
+interface ToolModeConfig {
+    mode: 'tool';
+    toolName?: string;
+    toolDescription?: string;
+}
+interface PromptModeConfig {
+    mode: 'prompt';
+    format?: 'json-schema' | 'typescript' | 'examples';
+    position?: 'system' | 'user' | 'suffix';
+    includeExamples?: boolean;
+}
+interface HybridModeConfig {
+    mode: 'hybrid';
+    fallbackOrder?: ExtractionMode[];
+}
+interface RetryConfig {
+    maxAttempts: number;
+    backoffMultiplier: number;
+    initialDelay: number;
+    maxDelay: number;
+    retryOn: RetryCondition[];
+    fixHints?: FixHintConfig;
+    recovery?: RecoveryConfig;
+}
+interface FixHintConfig {
+    includeErrors?: boolean;
+    includeExamples?: boolean;
+    suggestFixes?: boolean;
+    customHints?: (errors: ValidationError[], schema: z.ZodType) => string;
+}
+type RetryCondition = 'parse_error' | 'validation_error' | 'incomplete_response' | 'empty_response' | 'rate_limit' | 'timeout';
+interface RecoveryConfig {
+    repairJson?: boolean;
+    extractFromMarkdown?: boolean;
+    coerceTypes?: boolean;
+    usePartial?: boolean;
+}
+interface ValidationError {
+    path: (string | number)[];
+    message: string;
+    expected?: string;
+    received?: unknown;
+    code?: string;
+}
+interface ExtractionResult<T> {
+    success: boolean;
+    data?: T;
+    error?: Error;
+    raw?: string;
+    metadata: ExtractionMetadata;
+}
+interface ExtractionMetadata {
+    totalAttempts: number;
+    totalDuration: number;
+    finalMode: ExtractionMode;
+    tokenUsage?: TokenUsage;
+    attempts: ExtractionAttempt[];
+    model: string;
+}
+interface TokenUsage {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+}
+interface ExtractionAttempt {
+    attempt: number;
+    mode: ExtractionMode;
+    success: boolean;
+    duration: number;
+    rawResponse?: string;
+    error?: string;
+    validationErrors?: ValidationError[];
+}
+interface StructuredClientConfig {
+    defaultModel?: string;
+    defaultMode?: ExtractionMode;
+    defaultRetry?: Partial<RetryConfig>;
+    enableFixHints?: boolean;
+    validatePartials?: boolean;
+    providerOptions?: Record<string, unknown>;
+}
+declare class StructuredError extends Error {
+    code: string;
+    attempts: ExtractionAttempt[];
+    validationErrors?: ValidationError[];
+    partial?: unknown;
+    constructor(message: string, code: string, attempts: ExtractionAttempt[], validationErrors?: ValidationError[], partial?: unknown);
+}
+
+type SchemaFormat = 'json-schema' | 'typescript' | 'natural' | 'examples';
+interface SchemaPromptOptions {
+    format?: SchemaFormat;
+    includeDescriptions?: boolean;
+    includeExamples?: boolean;
+    includeConstraints?: boolean;
+    maxDepth?: number;
+    indent?: number;
+}
+interface SchemaPrompt {
+    text: string;
+    format: SchemaFormat;
+    jsonSchema?: JsonSchema;
+    typeScript?: string;
+}
+interface JsonSchema {
+    $schema?: string;
+    type?: string | string[];
+    properties?: Record<string, JsonSchema>;
+    items?: JsonSchema | JsonSchema[];
+    required?: string[];
+    enum?: unknown[];
+    const?: unknown;
+    anyOf?: JsonSchema[];
+    oneOf?: JsonSchema[];
+    allOf?: JsonSchema[];
+    not?: JsonSchema;
+    if?: JsonSchema;
+    then?: JsonSchema;
+    else?: JsonSchema;
+    description?: string;
+    default?: unknown;
+    examples?: unknown[];
+    minimum?: number;
+    maximum?: number;
+    exclusiveMinimum?: number;
+    exclusiveMaximum?: number;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    minItems?: number;
+    maxItems?: number;
+    uniqueItems?: boolean;
+    minProperties?: number;
+    maxProperties?: number;
+    additionalProperties?: boolean | JsonSchema;
+    format?: string;
+    $ref?: string;
+    $defs?: Record<string, JsonSchema>;
+    [key: string]: unknown;
+}
+interface SchemaAnalysis {
+    rootType: string;
+    fieldPaths: string[];
+    requiredFields: string[];
+    optionalFields: string[];
+    hasRecursion: boolean;
+    hasUnions: boolean;
+    hasArrays: boolean;
+    maxDepth: number;
+    complexity: number;
+}
+interface SchemaExample {
+    value: unknown;
+    description?: string;
+    isValid: boolean;
+}
+interface FieldInfo {
+    path: string;
+    name: string;
+    zodType: string;
+    jsonType: string;
+    description?: string;
+    required: boolean;
+    hasDefault: boolean;
+    defaultValue?: unknown;
+    constraints: FieldConstraint[];
+    children?: FieldInfo[];
+}
+interface FieldConstraint {
+    type: string;
+    value: unknown;
+    description: string;
+}
+interface SchemaWithExamples<T extends z.ZodType> {
+    schema: T;
+    examples: z.infer<T>[];
+}
+interface ToolDefinition {
+    type: 'function';
+    function: {
+        name: string;
+        description: string;
+        parameters: JsonSchema;
+        strict?: boolean;
+    };
+}
+interface ToolCall {
+    id: string;
+    name: string;
+    arguments: unknown;
+}
+interface SchemaValidationResult<T> {
+    success: boolean;
+    data?: T;
+    errors?: ValidationErrorDetail[];
+}
+interface ValidationErrorDetail {
+    path: (string | number)[];
+    message: string;
+    expected?: string;
+    received?: unknown;
+    code: string;
+}
+
+interface ProviderCapabilities {
+    jsonMode: boolean;
+    strictJsonMode: boolean;
+    toolCalling: boolean;
+    streaming: boolean;
+    systemMessages: boolean;
+    maxContextWindow?: number;
+    maxOutputTokens?: number;
+}
+interface ProviderAdapter {
+    readonly name: string;
+    getCapabilities(model: string): ProviderCapabilities;
+    supportsJsonMode(model: string): boolean;
+    supportsToolCalling(model: string): boolean;
+    createCompletion(request: ProviderRequest): Promise<ProviderResponse>;
+    createStreamingCompletion(request: ProviderRequest): AsyncIterableIterator<ProviderStreamChunk>;
+    formatMessages(messages: ChatMessage[]): unknown;
+    formatJsonSchema(schema: JsonSchema): unknown;
+    formatToolDefinition(tool: ToolDefinition): unknown;
+}
+interface ProviderRequest {
+    model: string;
+    messages: ChatMessage[];
+    mode: ExtractionMode;
+    jsonSchema?: JsonSchema;
+    toolDefinition?: ToolDefinition;
+    temperature?: number;
+    maxTokens?: number;
+    stream?: boolean;
+    options?: Record<string, unknown>;
+}
+interface ProviderResponse {
+    content: string;
+    usage?: TokenUsage;
+    finishReason?: string;
+    toolCalls?: ProviderToolCall[];
+    raw?: unknown;
+}
+interface ProviderToolCall {
+    id: string;
+    name: string;
+    arguments: string;
+}
+interface ProviderStreamChunk {
+    content: string;
+    isFinal: boolean;
+    finishReason?: string;
+    usage?: TokenUsage;
+    toolCallDeltas?: ProviderToolCallDelta[];
+}
+interface ProviderToolCallDelta {
+    index: number;
+    id?: string;
+    name?: string;
+    arguments?: string;
+}
+interface OpenAIOptions {
+    organization?: string;
+    baseURL?: string;
+    responseFormat?: {
+        type: 'json_object' | 'json_schema';
+        json_schema?: {
+            name: string;
+            schema: JsonSchema;
+            strict?: boolean;
+        };
+    };
+}
+interface AnthropicOptions {
+    baseURL?: string;
+    metadata?: {
+        user_id?: string;
+    };
+}
+interface GoogleOptions {
+    generationConfig?: {
+        responseMimeType?: 'application/json';
+        responseSchema?: JsonSchema;
+    };
+    safetySettings?: unknown[];
+}
+type ProviderFactoryOptions = {
+    type: 'openai';
+    client: unknown;
+    options?: OpenAIOptions;
+} | {
+    type: 'anthropic';
+    client: unknown;
+    options?: AnthropicOptions;
+} | {
+    type: 'google';
+    client: unknown;
+    options?: GoogleOptions;
+} | {
+    type: 'generic';
+    completionFn: GenericCompletionFn;
+};
+type GenericCompletionFn = (messages: ChatMessage[], options: GenericCompletionOptions) => Promise<string>;
+interface GenericCompletionOptions {
+    model: string;
+    temperature?: number;
+    maxTokens?: number;
+    systemPrompt?: string;
+}
+
+interface StreamingOptions {
+    yieldPartials?: boolean;
+    validatePartials?: boolean;
+    minFieldsBeforeYield?: number;
+    onFieldComplete?: (path: string, value: unknown) => void;
+    onPartial?: (partial: unknown, path: string | null) => void;
+    onError?: (error: Error) => void;
+}
+interface StreamingResult<T> {
+    partials(): AsyncIterableIterator<Partial<T>>;
+    fields(): AsyncIterableIterator<FieldUpdate>;
+    final(): Promise<T>;
+    onPartial(callback: (partial: Partial<T>, path: string | null) => void): void;
+    onField(callback: (path: string, value: unknown) => void): void;
+    onComplete(callback: (result: T) => void): void;
+    onError(callback: (error: Error) => void): void;
+    cancel(): void;
+    readonly isComplete: boolean;
+    readonly current: Partial<T>;
+}
+interface FieldUpdate {
+    path: string;
+    value: unknown;
+    complete: boolean;
+    timestamp: number;
+}
+interface PartialState<T> {
+    data: Partial<T>;
+    completedFields: string[];
+    inProgressFields: string[];
+    completionPercent: number;
+    isValid: boolean;
+}
+interface JsonToken {
+    type: JsonTokenType;
+    value: string;
+    path: string[];
+    complete: boolean;
+}
+type JsonTokenType = 'object_start' | 'object_end' | 'array_start' | 'array_end' | 'key' | 'string' | 'number' | 'boolean' | 'null' | 'colon' | 'comma';
+interface ParserState {
+    currentPath: string[];
+    depth: number;
+    buffer: string;
+    partial: Record<string, unknown>;
+    inString: boolean;
+    inEscape: boolean;
+    currentString: string;
+    currentKey: string | null;
+    containerStack: ('object' | 'array')[];
+}
+interface StreamChunk {
+    content: string;
+    isFinal: boolean;
+    usage?: TokenUsage;
+    index: number;
+}
+interface StreamMetadata {
+    totalChunks: number;
+    totalChars: number;
+    startTime: number;
+    endTime?: number;
+    usage?: TokenUsage;
+    model?: string;
+}
+
+interface StructuredClientEvents {
+    'extraction:start': {
+        requestId: string;
+        mode: ExtractionMode;
+    };
+    'extraction:attempt': {
+        requestId: string;
+        attempt: number;
+        mode: ExtractionMode;
+    };
+    'extraction:success': {
+        requestId: string;
+        data: unknown;
+        attempts: number;
+    };
+    'extraction:error': {
+        requestId: string;
+        error: Error;
+        attempt: number;
+    };
+    'extraction:retry': {
+        requestId: string;
+        attempt: number;
+        reason: string;
+        hints: string[];
+    };
+    'validation:failed': {
+        requestId: string;
+        errors: ValidationError[];
+    };
+    'mode:switch': {
+        requestId: string;
+        from: ExtractionMode;
+        to: ExtractionMode;
+    };
+}
+declare class StructuredClient extends EventEmitter<StructuredClientEvents> {
+    private readonly provider;
+    private readonly config;
+    constructor(provider: ProviderAdapter, config?: Partial<StructuredClientConfig>);
+    extract<T extends z.ZodType>(options: StructuredRequestOptions<T>): Promise<ExtractionResult<z.infer<T>>>;
+    extractStream<T extends z.ZodType>(options: StructuredRequestOptions<T>, streamingOptions?: StreamingOptions): Promise<StreamingResult<z.infer<T>>>;
+    private executeExtraction;
+    private extractWithJsonMode;
+    private extractWithToolMode;
+    private extractWithPromptMode;
+    private parseResponse;
+    private extractJsonFromContent;
+    private addSchemaPromptToMessages;
+    private addFixHintsToMessages;
+    private resolveMode;
+    private shouldRetry;
+    private classifyError;
+    private shouldSwitchMode;
+    private getNextMode;
+    private calculateBackoff;
+    private delay;
+    private generateRequestId;
+    private createMetadata;
+    private createStructuredError;
+    getProviderCapabilities(model: string): ProviderCapabilities;
+    supportsMode(mode: ExtractionMode, model: string): boolean;
+}
+declare function createStructuredClient(provider: ProviderAdapter, config?: Partial<StructuredClientConfig>): StructuredClient;
+
+declare function zodToJsonSchema<T extends z.ZodType>(schema: T): JsonSchema;
+declare function schemaToPrompt<T extends z.ZodType>(schema: T, options?: SchemaPromptOptions): SchemaPrompt;
+declare function analyzeSchema<T extends z.ZodType>(schema: T, opts: Required<SchemaPromptOptions>, path?: string): FieldInfo[];
+declare function extractFieldInfo(name: string, schema: z.ZodType, path: string, opts: Required<SchemaPromptOptions>): FieldInfo;
+declare function generateExample(schema: JsonSchema, maxDepth: number, depth?: number): unknown;
+declare const SchemaPromptGenerator: {
+    toJsonSchema: <T extends z.ZodType>(schema: T, options?: SchemaPromptOptions) => SchemaPrompt;
+    toTypeScript: <T extends z.ZodType>(schema: T, options?: SchemaPromptOptions) => SchemaPrompt;
+    toNatural: <T extends z.ZodType>(schema: T, options?: SchemaPromptOptions) => SchemaPrompt;
+    toExamples: <T extends z.ZodType>(schema: T, options?: SchemaPromptOptions) => SchemaPrompt;
+    generateExample: typeof generateExample;
+};
+
+declare function validateSchema<T extends z.ZodType>(schema: T, data: unknown): SchemaValidationResult<z.infer<T>>;
+declare function validateSchemaOrThrow<T extends z.ZodType>(schema: T, data: unknown): z.infer<T>;
+declare function validatePartial<T extends z.ZodType>(schema: T, data: unknown, options?: {
+    requiredFields?: string[];
+}): SchemaValidationResult<Partial<z.infer<T>>>;
+declare function matchesSchema<T extends z.ZodType>(schema: T, data: unknown): boolean;
+declare function coerceToSchema<T extends z.ZodType>(schema: T, data: unknown): SchemaValidationResult<z.infer<T>>;
+declare function getValidationHints<T extends z.ZodType>(schema: T, data: unknown): string[];
+declare function formatZodErrors(error: ZodError): ValidationErrorDetail[];
+declare const SchemaValidator: {
+    validate: typeof validateSchema;
+    validateOrThrow: typeof validateSchemaOrThrow;
+    validatePartial: typeof validatePartial;
+    matches: typeof matchesSchema;
+    coerce: typeof coerceToSchema;
+    getHints: typeof getValidationHints;
+    formatErrors: typeof formatZodErrors;
+};
+
+declare function createStreamingResult<T extends z.ZodType>(_client: StructuredClient, provider: ProviderAdapter, options: StructuredRequestOptions<T>, streamingOptions?: StreamingOptions): StreamingResult<z.infer<T>>;
+declare function getPartialState<T>(schema: z.ZodType<T>, partial: Partial<T>): PartialState<T>;
+
+interface FieldParseUpdate {
+    path: string[];
+    value: unknown;
+    complete: boolean;
+}
+declare class IncrementalJsonParser {
+    private state;
+    private result;
+    private pendingUpdates;
+    constructor();
+    feed(chunk: string): FieldParseUpdate[];
+    getResult(): Record<string, unknown>;
+    reset(): void;
+    private createInitialState;
+    private parse;
+    private parseStringChar;
+    private parseChar;
+    private processEscape;
+    private handleStringComplete;
+    private handleObjectStart;
+    private handleObjectEnd;
+    private handleArrayStart;
+    private handleArrayEnd;
+    private parseBoolean;
+    private parseNull;
+    private parseNumber;
+    private setValue;
+    private getCurrentContainer;
+    private setNestedValue;
+    private getNestedValue;
+    private finalize;
+}
+declare function tokenizeJson(json: string): JsonToken[];
+
+interface OpenAIClient {
+    chat: {
+        completions: {
+            create(params: unknown): Promise<OpenAIChatCompletion>;
+        };
+    };
+}
+interface OpenAIChatCompletion {
+    id: string;
+    choices: Array<{
+        message: {
+            role: string;
+            content: string | null;
+            tool_calls?: Array<{
+                id: string;
+                type: string;
+                function: {
+                    name: string;
+                    arguments: string;
+                };
+            }>;
+        };
+        finish_reason: string;
+    }>;
+    usage?: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    };
+}
+declare class OpenAIAdapter implements ProviderAdapter {
+    readonly name = "openai";
+    private readonly client;
+    constructor(client: OpenAIClient, _options?: OpenAIOptions);
+    getCapabilities(model: string): ProviderCapabilities;
+    supportsJsonMode(model: string): boolean;
+    supportsToolCalling(model: string): boolean;
+    createCompletion(request: ProviderRequest): Promise<ProviderResponse>;
+    createStreamingCompletion(request: ProviderRequest): AsyncIterableIterator<ProviderStreamChunk>;
+    formatMessages(messages: ChatMessage[]): unknown;
+    formatJsonSchema(schema: JsonSchema): unknown;
+    formatToolDefinition(tool: ToolDefinition): unknown;
+    private buildRequestParams;
+    private parseResponse;
+}
+declare function createOpenAIAdapter(client: OpenAIClient, options?: OpenAIOptions): OpenAIAdapter;
+
+interface AnthropicClient {
+    messages: {
+        create(params: unknown): Promise<AnthropicMessage>;
+    };
+}
+interface AnthropicMessage {
+    id: string;
+    type: string;
+    role: string;
+    content: Array<{
+        type: 'text' | 'tool_use';
+        text?: string;
+        id?: string;
+        name?: string;
+        input?: unknown;
+    }>;
+    model: string;
+    stop_reason: string | null;
+    stop_sequence: string | null;
+    usage: {
+        input_tokens: number;
+        output_tokens: number;
+    };
+}
+declare class AnthropicAdapter implements ProviderAdapter {
+    readonly name = "anthropic";
+    private readonly client;
+    private readonly options;
+    constructor(client: AnthropicClient, options?: AnthropicOptions);
+    getCapabilities(model: string): ProviderCapabilities;
+    supportsJsonMode(_model: string): boolean;
+    supportsToolCalling(model: string): boolean;
+    createCompletion(request: ProviderRequest): Promise<ProviderResponse>;
+    createStreamingCompletion(request: ProviderRequest): AsyncIterableIterator<ProviderStreamChunk>;
+    formatMessages(messages: ChatMessage[]): unknown;
+    formatJsonSchema(schema: JsonSchema): unknown;
+    formatToolDefinition(tool: ToolDefinition): unknown;
+    private buildRequestParams;
+    private parseResponse;
+}
+declare function createAnthropicAdapter(client: AnthropicClient, options?: AnthropicOptions): AnthropicAdapter;
+
+interface GoogleClient {
+    getGenerativeModel(params: {
+        model: string;
+        generationConfig?: unknown;
+        tools?: unknown[];
+        toolConfig?: unknown;
+    }): GoogleGenerativeModel;
+}
+interface GoogleGenerativeModel {
+    generateContent(request: unknown): Promise<GoogleGenerateContentResult>;
+    generateContentStream(request: unknown): Promise<GoogleGenerateContentStreamResult>;
+}
+interface GoogleGenerateContentResult {
+    response: GoogleGenerateContentResponse;
+}
+interface GoogleGenerateContentResponse {
+    text(): string;
+    candidates?: Array<{
+        content: {
+            parts: Array<{
+                text?: string;
+                functionCall?: {
+                    name: string;
+                    args: Record<string, unknown>;
+                };
+            }>;
+            role: string;
+        };
+        finishReason?: string;
+    }>;
+    usageMetadata?: {
+        promptTokenCount: number;
+        candidatesTokenCount: number;
+        totalTokenCount: number;
+    };
+    functionCalls?(): Array<{
+        name: string;
+        args: Record<string, unknown>;
+    }>;
+}
+interface GoogleGenerateContentStreamResult {
+    stream: AsyncIterable<{
+        text(): string;
+        candidates?: Array<{
+            content: {
+                parts: Array<{
+                    text?: string;
+                    functionCall?: {
+                        name: string;
+                        args: Record<string, unknown>;
+                    };
+                }>;
+            };
+            finishReason?: string;
+        }>;
+        usageMetadata?: {
+            promptTokenCount: number;
+            candidatesTokenCount: number;
+            totalTokenCount: number;
+        };
+    }>;
+    response: Promise<GoogleGenerateContentResponse>;
+}
+declare class GoogleAdapter implements ProviderAdapter {
+    readonly name = "google";
+    private readonly client;
+    private readonly options;
+    constructor(client: GoogleClient, options?: GoogleOptions);
+    getCapabilities(model: string): ProviderCapabilities;
+    supportsJsonMode(model: string): boolean;
+    supportsToolCalling(model: string): boolean;
+    createCompletion(request: ProviderRequest): Promise<ProviderResponse>;
+    createStreamingCompletion(request: ProviderRequest): AsyncIterableIterator<ProviderStreamChunk>;
+    formatMessages(messages: ChatMessage[]): unknown;
+    formatJsonSchema(schema: JsonSchema): unknown;
+    formatToolDefinition(tool: ToolDefinition): unknown;
+    private getModel;
+    private formatContents;
+    private convertToGoogleSchema;
+    private parseResponse;
+}
+declare function createGoogleAdapter(client: GoogleClient, options?: GoogleOptions): GoogleAdapter;
+
+type AgentSeaProviderType = 'openai' | 'anthropic' | 'google';
+interface AgentSeaClient {
+    readonly provider: AgentSeaProviderType;
+    readonly client: unknown;
+    readonly model?: string;
+}
+interface StructuredProviderOptions {
+    defaultModel?: string;
+    defaultMode?: ExtractionModeConfig;
+    enableFixHints?: boolean;
+    validatePartials?: boolean;
+    maxRetries?: number;
+}
+declare class StructuredProvider {
+    private readonly clients;
+    private readonly adapters;
+    private readonly options;
+    private defaultProviderName;
+    constructor(options?: StructuredProviderOptions);
+    registerProvider(name: string, agentSeaClient: AgentSeaClient, setAsDefault?: boolean): this;
+    getClient(name?: string): StructuredClient;
+    extract<T extends z.ZodType>(schema: T, prompt: string | ChatMessage[], options?: {
+        model?: string;
+        provider?: string;
+        mode?: ExtractionModeConfig;
+        temperature?: number;
+        maxTokens?: number;
+    }): Promise<ExtractionResult<z.infer<T>>>;
+    extractStream<T extends z.ZodType>(schema: T, prompt: string | ChatMessage[], options?: {
+        model?: string;
+        provider?: string;
+        mode?: ExtractionModeConfig;
+        streaming?: StreamingOptions;
+    }): Promise<StreamingResult<z.infer<T>>>;
+    createExtractor<T extends z.ZodType>(schema: T, options?: {
+        model?: string;
+        provider?: string;
+        mode?: ExtractionModeConfig;
+    }): TypedExtractor<z.infer<T>>;
+    private createAdapter;
+}
+declare class TypedExtractor<T> {
+    private readonly provider;
+    private readonly schema;
+    private readonly options?;
+    constructor(provider: StructuredProvider, schema: z.ZodType<T>, options?: {
+        model?: string;
+        provider?: string;
+        mode?: ExtractionModeConfig;
+    } | undefined);
+    extract(prompt: string | ChatMessage[], overrideOptions?: {
+        model?: string;
+        temperature?: number;
+        maxTokens?: number;
+    }): Promise<ExtractionResult<T>>;
+    extractStream(prompt: string | ChatMessage[], streamingOptions?: StreamingOptions): Promise<StreamingResult<T>>;
+    getSchema(): z.ZodType<T>;
+}
+declare function createStructuredProvider(options?: StructuredProviderOptions): StructuredProvider;
+declare const Extractors: {
+    list<T extends z.ZodType>(itemSchema: T, options?: {
+        minItems?: number;
+        maxItems?: number;
+    }): z.ZodArray<T>;
+    entity<T extends z.ZodRawShape>(shape: T): z.ZodObject<T>;
+    classification<T extends [string, ...string[]]>(categories: T, options?: {
+        confidence?: boolean;
+    }): z.ZodType;
+    sentiment(): z.ZodType;
+    keyValue(): z.ZodType;
+    summary(options?: {
+        maxLength?: number;
+    }): z.ZodType;
+};
+
+export { type AgentSeaProviderType, AnthropicAdapter, type AnthropicOptions, type ChatMessage, type ExtractionAttempt, type ExtractionMetadata, type ExtractionMode, type ExtractionModeConfig, type ExtractionResult, Extractors, type FieldConstraint, type FieldInfo, type FieldParseUpdate, type FieldUpdate, type FixHintConfig, type GenericCompletionFn, type GenericCompletionOptions, GoogleAdapter, type GoogleOptions, type HybridModeConfig, IncrementalJsonParser, type JsonModeConfig, type JsonSchema, type JsonToken, type JsonTokenType, type MessageRole, OpenAIAdapter, type OpenAIOptions, type ParserState, type PartialState, type PromptModeConfig, type ProviderAdapter, type ProviderCapabilities, type ProviderFactoryOptions, type ProviderRequest, type ProviderResponse, type ProviderStreamChunk, type ProviderToolCall, type ProviderToolCallDelta, type RecoveryConfig, type RetryCondition, type RetryConfig, type SchemaAnalysis, type SchemaExample, type SchemaFormat, type SchemaPrompt, SchemaPromptGenerator, type SchemaPromptOptions, type SchemaValidationResult, SchemaValidator, type SchemaWithExamples, type StreamChunk, type StreamMetadata, type StreamingOptions, type StreamingResult, StructuredClient, type StructuredClientConfig, StructuredError, StructuredProvider, type StructuredProviderOptions, type StructuredProvider$1 as StructuredProviderType, type StructuredRequestOptions, type TokenUsage, type ToolCall, type ToolDefinition, type ToolModeConfig, TypedExtractor, type ValidationError, type ValidationErrorDetail, analyzeSchema, coerceToSchema, createAnthropicAdapter, createGoogleAdapter, createOpenAIAdapter, createStreamingResult, createStructuredClient, createStructuredProvider, extractFieldInfo, formatZodErrors, generateExample, getPartialState, getValidationHints, matchesSchema, schemaToPrompt, tokenizeJson, validatePartial, validateSchema, validateSchemaOrThrow, zodToJsonSchema };