extrait 0.1.0

package/dist/llm.d.ts

@@ -0,0 +1,13 @@
+import type { z } from "zod";
+import { type ModelAdapterConfig, type ProviderRegistry } from "./providers/registry";
+import type { LLMAdapter, StructuredCallOptions, StructuredPromptBuilder, StructuredResult } from "./types";
+export interface CreateLLMOptions extends ModelAdapterConfig {
+    defaults?: StructuredCallOptions<z.ZodTypeAny>;
+}
+export interface LLMClient {
+    adapter: LLMAdapter;
+    provider?: string;
+    model?: string;
+    structured<TSchema extends z.ZodTypeAny>(schema: TSchema, prompt: StructuredPromptBuilder, options?: StructuredCallOptions<TSchema>): Promise<StructuredResult<z.infer<TSchema>>>;
+}
+export declare function createLLM(config: CreateLLMOptions, registry?: ProviderRegistry): LLMClient;

package/dist/markdown.d.ts

@@ -0,0 +1,3 @@
+import type { MarkdownCodeBlock, MarkdownCodeOptions } from "./types";
+export declare function extractMarkdownCodeBlocks(input: string, options?: MarkdownCodeOptions): MarkdownCodeBlock[];
+export declare function extractFirstMarkdownCode(input: string, options?: Omit<MarkdownCodeOptions, "firstOnly">): MarkdownCodeBlock | null;

package/dist/mcp.d.ts

@@ -0,0 +1,40 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { type StdioServerParameters } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { type StreamableHTTPClientTransportOptions } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
+import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
+import type { MCPToolClient } from "./types";
+export interface MCPClientInfo {
+    name: string;
+    version: string;
+}
+export interface MCPStdioTransportConfig extends Omit<StdioServerParameters, "command"> {
+    type: "stdio";
+    command: string;
+}
+export interface MCPStreamableHTTPTransportConfig {
+    type: "streamable-http";
+    url: string | URL;
+    options?: StreamableHTTPClientTransportOptions;
+}
+export interface MCPInMemoryTransportConfig {
+    type: "in-memory";
+    transport: InMemoryTransport;
+}
+export type MCPTransportConfig = MCPStdioTransportConfig | MCPStreamableHTTPTransportConfig | MCPInMemoryTransportConfig;
+export interface CreateMCPClientOptions {
+    id: string;
+    transport: MCPTransportConfig;
+    clientInfo?: MCPClientInfo;
+}
+export interface ManagedMCPToolClient extends MCPToolClient {
+    sdkClient: Client;
+    transport?: Transport;
+}
+export declare function createMCPClient(options: CreateMCPClientOptions): Promise<ManagedMCPToolClient>;
+export interface WrapMCPClientOptions {
+    id: string;
+    client: Client;
+    transport?: Transport;
+}
+export declare function wrapMCPClient(options: WrapMCPClientOptions): ManagedMCPToolClient;

package/dist/outdent.d.ts

@@ -0,0 +1,10 @@
+export interface OutdentOptions {
+    trimLeadingNewline?: boolean;
+    trimTrailingNewline?: boolean;
+    newline?: string | null;
+}
+export interface OutdentTag {
+    (strings: TemplateStringsArray, ...values: unknown[]): string;
+    string(input: string): string;
+}
+export declare function createOutdent(options?: OutdentOptions): OutdentTag;

package/dist/parse.d.ts

@@ -0,0 +1,4 @@
+import type { z } from "zod";
+import type { ParseLLMOutputOptions, ParseLLMOutputResult } from "./types";
+export declare function parseLLMOutput<TSchema extends z.ZodTypeAny>(output: string, schema: TSchema, options?: ParseLLMOutputOptions): ParseLLMOutputResult<z.infer<TSchema>>;
+export declare function formatZodIssues(issues: z.ZodIssue[]): string;

package/dist/prompt.d.ts

@@ -0,0 +1,10 @@
+import type { StructuredPromptPayload, StructuredPromptResolver } from "./types";
+export interface PromptMessageBuilder extends StructuredPromptResolver {
+    system(input: string): PromptMessageBuilder;
+    system(strings: TemplateStringsArray, ...values: unknown[]): PromptMessageBuilder;
+    user(input: string): PromptMessageBuilder;
+    user(strings: TemplateStringsArray, ...values: unknown[]): PromptMessageBuilder;
+    build(): StructuredPromptPayload;
+}
+export declare function prompt(strings: TemplateStringsArray, ...values: unknown[]): string;
+export declare function prompt(): PromptMessageBuilder;

package/dist/providers/anthropic-compatible.d.ts

@@ -0,0 +1,16 @@
+import type { HTTPHeaders, LLMAdapter } from "../types";
+export interface AnthropicCompatibleAdapterOptions {
+    baseURL: string;
+    model: string;
+    apiKey?: string;
+    path?: string;
+    headers?: HTTPHeaders;
+    version?: string;
+    defaultMaxTokens?: number;
+    defaultMaxToolRounds?: number;
+    defaultBody?: Record<string, unknown>;
+    fetcher?: typeof fetch;
+}
+export declare const DEFAULT_ANTHROPIC_MAX_TOKENS = 1024;
+export declare const DEFAULT_ANTHROPIC_VERSION = "2023-06-01";
+export declare function createAnthropicCompatibleAdapter(options: AnthropicCompatibleAdapterOptions): LLMAdapter;

package/dist/providers/mcp-runtime.d.ts

@@ -0,0 +1,38 @@
+import type { LLMRequest, LLMToolCall, LLMToolExecution, MCPToolClient } from "../types";
+export interface RuntimeToolCall {
+    id?: string;
+    type?: string;
+    name?: string;
+    arguments?: unknown;
+}
+export interface ResolvedMCPTool {
+    name: string;
+    remoteName: string;
+    description?: string;
+    inputSchema: Record<string, unknown>;
+    clientId: string;
+    client: MCPToolClient;
+}
+export interface ResolvedMCPToolset {
+    tools: ResolvedMCPTool[];
+    byName: Map<string, ResolvedMCPTool>;
+}
+export interface ExecuteMCPToolCallsOptions {
+    round: number;
+    request: LLMRequest;
+    provider?: string;
+    model?: string;
+}
+export interface ExecutedMCPToolCall {
+    call: LLMToolCall;
+    execution: LLMToolExecution;
+}
+export declare const DEFAULT_MAX_TOOL_ROUNDS = 8;
+export declare function resolveMCPToolset(clients: MCPToolClient[] | undefined): Promise<ResolvedMCPToolset>;
+export declare function toProviderFunctionTools(toolset: ResolvedMCPToolset): Array<Record<string, unknown>> | undefined;
+export declare function executeMCPToolCalls(calls: RuntimeToolCall[], toolset: ResolvedMCPToolset, context: ExecuteMCPToolCallsOptions): Promise<ExecutedMCPToolCall[]>;
+export declare function hasMCPClients(clients: MCPToolClient[] | undefined): boolean;
+export declare function normalizeMaxToolRounds(value: number | undefined): number;
+export declare function parseToolArguments(value: unknown): unknown;
+export declare function stringifyToolOutput(value: unknown): string;
+export declare function formatToolExecutionDebugLine(execution: LLMToolExecution): string;

package/dist/providers/openai-compatible.d.ts

@@ -0,0 +1,13 @@
+import type { HTTPHeaders, LLMAdapter } from "../types";
+export interface OpenAICompatibleAdapterOptions {
+    baseURL: string;
+    model: string;
+    apiKey?: string;
+    path?: string;
+    responsesPath?: string;
+    defaultMaxToolRounds?: number;
+    headers?: HTTPHeaders;
+    defaultBody?: Record<string, unknown>;
+    fetcher?: typeof fetch;
+}
+export declare function createOpenAICompatibleAdapter(options: OpenAICompatibleAdapterOptions): LLMAdapter;

package/dist/providers/registry.d.ts

@@ -0,0 +1,32 @@
+import type { HTTPHeaders, LLMAdapter } from "../types";
+export type BuiltinProviderKind = "openai-compatible" | "anthropic-compatible";
+export interface ProviderFactory<TOptions = unknown> {
+    (options: TOptions): LLMAdapter;
+}
+export interface ProviderRegistry {
+    register<TOptions>(kind: string, factory: ProviderFactory<TOptions>): void;
+    create<TOptions>(kind: string, options: TOptions): LLMAdapter;
+    has(kind: string): boolean;
+    list(): string[];
+}
+export interface ProviderTransportConfig {
+    baseURL?: string;
+    apiKey?: string;
+    path?: string;
+    headers?: HTTPHeaders;
+    defaultBody?: Record<string, unknown>;
+    version?: string;
+    fetcher?: typeof fetch;
+}
+export interface ModelAdapterConfig {
+    provider: string;
+    model: string;
+    baseURL?: string;
+    apiKey?: string;
+    transport?: ProviderTransportConfig;
+    options?: Record<string, unknown>;
+}
+export declare function createProviderRegistry(): ProviderRegistry;
+export declare function registerBuiltinProviders(registry: ProviderRegistry): ProviderRegistry;
+export declare function createDefaultProviderRegistry(): ProviderRegistry;
+export declare function createModelAdapter(config: ModelAdapterConfig, registry?: ProviderRegistry): LLMAdapter;

package/dist/providers/stream-utils.d.ts

@@ -0,0 +1,2 @@
+export declare function consumeSSE(response: Response, onEvent: (data: string) => void): Promise<void>;
+export declare function consumeNDJSON(response: Response, onLine: (line: string) => void): Promise<void>;

package/dist/providers/utils.d.ts

@@ -0,0 +1,9 @@
+import type { LLMUsage } from "../types";
+export declare function normalizeBaseURL(baseURL: string): string;
+export declare function buildURL(baseURL: string, path: string): string;
+export declare function safeJSONParse(input: string): unknown;
+export declare function cleanUndefined<T extends Record<string, unknown>>(input: T): T;
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function pickString(value: unknown): string | undefined;
+export declare function toFiniteNumber(value: unknown): number | undefined;
+export declare function mergeUsage(base: LLMUsage | undefined, next: LLMUsage | undefined): LLMUsage | undefined;

package/dist/schema-builder.d.ts

@@ -0,0 +1,25 @@
+import { z } from "zod";
+declare module "zod" {
+    interface ZodNumber {
+        coerce(): z.ZodNumber;
+    }
+}
+export interface SchemaMetadataSummary {
+    name?: string;
+    description?: string;
+    requiredFields: string[];
+    defaults: Record<string, unknown>;
+    fieldDescriptions: Record<string, string>;
+}
+export declare const s: {
+    schema<TSchema extends z.ZodTypeAny>(name: string, schema: TSchema): TSchema;
+    string(): z.ZodString;
+    number(): z.ZodNumber;
+    boolean(): z.ZodBoolean;
+    array<TSchema extends z.ZodTypeAny>(schema: TSchema): z.ZodArray<TSchema>;
+    object<TShape extends z.ZodRawShape>(shape: TShape): z.ZodObject<TShape>;
+};
+export declare function setSchemaName<TSchema extends z.ZodTypeAny>(schema: TSchema, name: string): TSchema;
+export declare function getSchemaName(schema: z.ZodTypeAny): string | undefined;
+export declare function inspectSchemaMetadata(schema: z.ZodTypeAny): SchemaMetadataSummary;
+export declare function inferSchemaExample(schema: z.ZodTypeAny): unknown | null;

package/dist/schema.d.ts

@@ -0,0 +1,2 @@
+import type { z } from "zod";
+export declare function formatZodSchemaLikeTypeScript(schema: z.ZodTypeAny): string;

package/dist/structured.d.ts

@@ -0,0 +1,86 @@
+import type { z } from "zod";
+import type { LLMAdapter, ParseLLMOutputOptions, StructuredCallOptions, StructuredError, StructuredOptions, StructuredPromptBuilder, StructuredResult } from "./types";
+export declare class StructuredParseError extends Error implements StructuredError {
+    readonly name: "StructuredParseError";
+    readonly raw: string;
+    readonly thinkBlocks: StructuredError["thinkBlocks"];
+    readonly candidates: string[];
+    readonly zodIssues?: z.ZodIssue[];
+    readonly repairLog?: string[];
+    readonly attempt: number;
+    constructor(input: {
+        message?: string;
+        raw: string;
+        thinkBlocks: StructuredError["thinkBlocks"];
+        candidates: string[];
+        zodIssues?: z.ZodIssue[];
+        repairLog?: string[];
+        attempt: number;
+    });
+}
+export interface BuildDefaultStructuredPromptOptions {
+    objectInstruction?: string;
+    styleInstruction?: string;
+}
+export interface SelfHealPromptTextOptions {
+    fixInstruction?: string;
+    returnInstruction?: string;
+    noIssuesMessage?: string;
+    validationErrorsLabel?: string;
+    rawOutputLabel?: string;
+    contextLabel?: string;
+}
+type ParseDefaults = Pick<ParseLLMOutputOptions, "repair" | "maxCandidates" | "acceptArrays">;
+export declare const DEFAULT_STRUCTURED_OBJECT_INSTRUCTION = "Return exactly one strict JSON object.";
+export declare const DEFAULT_STRUCTURED_STYLE_INSTRUCTION = "No prose. No markdown.";
+export declare const DEFAULT_SELF_HEAL_FIX_INSTRUCTION: string;
+export declare const DEFAULT_SELF_HEAL_RETURN_INSTRUCTION: string;
+export declare const DEFAULT_SELF_HEAL_NO_ISSUES_MESSAGE: string;
+export declare const DEFAULT_SELF_HEAL_VALIDATION_LABEL: string;
+export declare const DEFAULT_SELF_HEAL_RAW_OUTPUT_LABEL: string;
+export declare const DEFAULT_SELF_HEAL_CONTEXT_LABEL: string;
+export declare const DEFAULT_SELF_HEAL_PROTOCOL = "extrait.self-heal.v2";
+export declare const DEFAULT_SELF_HEAL_MAX_CONTEXT_CHARS = 12000;
+export declare const DEFAULT_SELF_HEAL_STOP_ON_NO_PROGRESS = true;
+export declare const DEFAULT_STRICT_PARSE_OPTIONS: ParseDefaults;
+export declare const DEFAULT_LOOSE_PARSE_OPTIONS: ParseDefaults;
+export declare const DEFAULT_SELF_HEAL_BY_MODE: {
+    readonly loose: {
+        readonly enabled: true;
+        readonly maxAttempts: 1;
+    };
+    readonly strict: {
+        readonly enabled: false;
+        readonly maxAttempts: 0;
+    };
+};
+export declare function buildDefaultStructuredPrompt(task: string, options?: BuildDefaultStructuredPromptOptions): string;
+interface SelfHealPromptInput {
+    rawOutput: string;
+    issues: z.ZodIssue[];
+    schema: z.ZodTypeAny;
+    schemaInstruction?: string;
+    selectedOutput?: string;
+    selectedInput?: "candidate" | "sanitized" | "raw";
+    sanitizedOutput?: string;
+    parserErrors?: Array<{
+        stage: string;
+        message: string;
+        candidateId?: string;
+    }>;
+    diagnostics?: Array<{
+        candidateId: string;
+        stage: string;
+        usedRepair: boolean;
+        message?: string;
+    }>;
+    repairLog?: string[];
+    attempt?: number;
+    previousAttempt?: number;
+    maxContextChars?: number;
+    text?: SelfHealPromptTextOptions;
+}
+export declare function buildSelfHealPrompt(input: SelfHealPromptInput): string;
+export declare function structured<TSchema extends z.ZodTypeAny>(adapter: LLMAdapter, schema: TSchema, prompt: StructuredPromptBuilder, options?: StructuredCallOptions<TSchema>): Promise<StructuredResult<z.infer<TSchema>>>;
+export declare function structured<TSchema extends z.ZodTypeAny>(adapter: LLMAdapter, options: StructuredOptions<TSchema>): Promise<StructuredResult<z.infer<TSchema>>>;
+export {};

package/dist/think.d.ts

@@ -0,0 +1,7 @@
+import type { ThinkBlock, ThinkDiagnostics } from "./types";
+export interface SanitizeThinkResult {
+    visibleText: string;
+    thinkBlocks: ThinkBlock[];
+    diagnostics: ThinkDiagnostics;
+}
+export declare function sanitizeThink(input: string): SanitizeThinkResult;

package/dist/types.d.ts

@@ -0,0 +1,311 @@
+import type { z } from "zod";
+export type StructuredMode = "loose" | "strict";
+export type HTTPHeaders = Record<string, string>;
+export interface ExtractionCandidate {
+    id: string;
+    source: "fenced" | "scan" | "raw";
+    content: string;
+    language?: string | null;
+    parseHint?: ExtractionParseHint;
+    start: number;
+    end: number;
+    score: number;
+}
+export interface ExtractionParseHint {
+    success: boolean;
+    parsed: unknown | null;
+    repaired: string | null;
+    usedRepair: boolean;
+    stage: "parse" | "repair";
+    error: string;
+}
+export interface ExtractionHeuristicsOptions {
+    firstPassMin: number;
+    firstPassCap: number;
+    firstPassMultiplier: number;
+    secondPassMin: number;
+    secondPassCap: number;
+    secondPassMultiplier: number;
+    hintMaxLength: number;
+}
+export interface ExtractJsonCandidatesOptions {
+    maxCandidates?: number;
+    acceptArrays?: boolean;
+    allowRepairHints?: boolean;
+    heuristics?: Partial<ExtractionHeuristicsOptions>;
+}
+export interface ParseTraceEvent {
+    stage: "extract" | "repair" | "parse" | "validate" | "result";
+    level: "info" | "error";
+    message: string;
+    candidateId?: string;
+    details?: unknown;
+}
+export interface ParseLLMOutputOptions {
+    repair?: boolean;
+    maxCandidates?: number;
+    acceptArrays?: boolean;
+    extraction?: Partial<ExtractionHeuristicsOptions>;
+    onTrace?: (event: ParseTraceEvent) => void;
+}
+export interface PipelineError {
+    stage: "extract" | "repair" | "parse" | "validate" | "llm" | "self-heal";
+    message: string;
+    candidateId?: string;
+    details?: unknown;
+}
+export interface CandidateDiagnostics {
+    candidateId: string;
+    source: ExtractionCandidate["source"];
+    usedRepair: boolean;
+    parseSuccess: boolean;
+    validationSuccess: boolean;
+    selected: boolean;
+    stage: "repair" | "parse" | "validate" | "success";
+    message?: string;
+    zodIssues?: z.ZodIssue[];
+}
+export interface ThinkBlock {
+    id: string;
+    content: string;
+    raw: string;
+    start: number;
+    end: number;
+}
+export interface ThinkDiagnostics {
+    unterminatedCount: number;
+    nestedCount: number;
+    hiddenChars: number;
+}
+export interface ParseLLMOutputResult<T> {
+    success: boolean;
+    data: T | null;
+    raw: string;
+    sanitizedRaw: string;
+    thinkBlocks: ThinkBlock[];
+    thinkDiagnostics: ThinkDiagnostics;
+    parsed: unknown | null;
+    candidate: ExtractionCandidate | null;
+    repaired: string | null;
+    candidates: ExtractionCandidate[];
+    diagnostics: CandidateDiagnostics[];
+    errors: PipelineError[];
+    zodIssues: z.ZodIssue[];
+}
+export interface MCPToolSchema {
+    type?: string;
+    properties?: Record<string, unknown>;
+    required?: string[];
+    [key: string]: unknown;
+}
+export interface MCPToolDescriptor {
+    name: string;
+    description?: string;
+    inputSchema?: MCPToolSchema;
+}
+export interface MCPListToolsResult {
+    tools: MCPToolDescriptor[];
+    nextCursor?: string;
+}
+export interface MCPCallToolParams {
+    name: string;
+    arguments?: Record<string, unknown>;
+}
+export interface MCPToolClient {
+    id: string;
+    listTools(params?: {
+        cursor?: string;
+    }): Promise<MCPListToolsResult>;
+    callTool(params: MCPCallToolParams): Promise<unknown>;
+    close?(): Promise<void>;
+}
+export interface LLMRequest {
+    prompt: string;
+    systemPrompt?: string;
+    temperature?: number;
+    maxTokens?: number;
+    mcpClients?: MCPToolClient[];
+    toolChoice?: LLMToolChoice;
+    parallelToolCalls?: boolean;
+    maxToolRounds?: number;
+    onToolExecution?: (execution: LLMToolExecution) => void;
+    toolDebug?: boolean | LLMToolDebugOptions;
+    body?: Record<string, unknown>;
+}
+export interface LLMUsage {
+    inputTokens?: number;
+    outputTokens?: number;
+    totalTokens?: number;
+    cost?: number;
+}
+export interface LLMResponse {
+    text: string;
+    raw?: unknown;
+    usage?: LLMUsage;
+    finishReason?: string;
+    toolCalls?: LLMToolCall[];
+    toolExecutions?: LLMToolExecution[];
+}
+export interface LLMStreamChunk {
+    textDelta: string;
+    raw?: unknown;
+    done?: boolean;
+    usage?: LLMUsage;
+    finishReason?: string;
+}
+export interface LLMStreamCallbacks {
+    onStart?: () => void;
+    onToken?: (token: string) => void;
+    onChunk?: (chunk: LLMStreamChunk) => void;
+    onComplete?: (response: LLMResponse) => void;
+}
+export interface LLMAdapter {
+    provider?: string;
+    model?: string;
+    complete(request: LLMRequest): Promise<LLMResponse>;
+    stream?(request: LLMRequest, callbacks?: LLMStreamCallbacks): Promise<LLMResponse>;
+}
+export interface LLMToolCall {
+    id: string;
+    type: string;
+    name?: string;
+    arguments?: unknown;
+    output?: unknown;
+    error?: string;
+}
+export interface LLMToolExecution {
+    callId: string;
+    type: string;
+    name?: string;
+    clientId?: string;
+    remoteName?: string;
+    arguments?: unknown;
+    output?: unknown;
+    error?: string;
+    round?: number;
+    provider?: string;
+    model?: string;
+    handledLocally: boolean;
+    startedAt: string;
+    durationMs?: number;
+}
+export interface LLMToolDebugOptions {
+    enabled?: boolean;
+    logger?: (line: string) => void;
+    includeRequest?: boolean;
+    includeResult?: boolean;
+    includeResultOnError?: boolean;
+    pretty?: boolean;
+}
+export type LLMToolChoice = "none" | "auto" | "required" | {
+    type: "function";
+    function: {
+        name: string;
+    };
+} | Record<string, unknown>;
+export interface StructuredTraceEvent {
+    stage: "llm.request" | "llm.response" | "llm.stream.delta" | "llm.stream.data" | "parse" | "self-heal" | "result";
+    attempt: number;
+    selfHeal: boolean;
+    message: string;
+    details?: unknown;
+}
+export interface StructuredPromptContext {
+    mode: StructuredMode;
+}
+export interface StructuredPromptPayload {
+    prompt: string;
+    systemPrompt?: string;
+}
+export interface StructuredPromptResolver {
+    resolvePrompt(context: StructuredPromptContext): StructuredPromptPayload;
+}
+export type StructuredPromptValue = string | StructuredPromptPayload | StructuredPromptResolver;
+export type StructuredPromptBuilder = StructuredPromptValue | ((context: StructuredPromptContext) => StructuredPromptValue);
+export interface StructuredDebugOptions {
+    enabled?: boolean;
+    colors?: boolean;
+    logger?: (line: string) => void;
+}
+export interface StructuredSelfHealOptions {
+    enabled?: boolean;
+    maxAttempts?: number;
+    stopOnNoProgress?: boolean;
+    maxContextChars?: number;
+}
+export type StructuredSelfHealInput = boolean | number | StructuredSelfHealOptions;
+export type StructuredStreamData<T> = T extends Array<infer TItem> ? Array<StructuredStreamData<TItem>> : T extends object ? {
+    [K in keyof T]?: StructuredStreamData<T[K]> | null;
+} : T | null;
+export interface StructuredStreamEvent<T = unknown> {
+    data: StructuredStreamData<T> | null;
+    raw: string;
+    done: boolean;
+    usage?: LLMUsage;
+    finishReason?: string;
+}
+export interface StructuredStreamOptions<T = unknown> {
+    enabled?: boolean;
+    onData?: (event: StructuredStreamEvent<T>) => void;
+    to?: "stdout";
+}
+export type StructuredStreamInput<T = unknown> = boolean | StructuredStreamOptions<T>;
+export interface StructuredCallOptions<TSchema extends z.ZodTypeAny> {
+    mode?: StructuredMode;
+    outdent?: boolean;
+    parse?: ParseLLMOutputOptions;
+    selfHeal?: StructuredSelfHealInput;
+    stream?: StructuredStreamInput<z.infer<TSchema>>;
+    debug?: boolean | StructuredDebugOptions;
+    observe?: (event: StructuredTraceEvent) => void;
+    systemPrompt?: string;
+    request?: Omit<LLMRequest, "prompt" | "systemPrompt">;
+    schemaInstruction?: string;
+}
+export interface StructuredOptions<TSchema extends z.ZodTypeAny> extends StructuredCallOptions<TSchema> {
+    schema: TSchema;
+    prompt: StructuredPromptBuilder;
+}
+export interface StructuredAttempt<T> {
+    attempt: number;
+    selfHeal: boolean;
+    via: "complete" | "stream";
+    raw: string;
+    thinkBlocks: ThinkBlock[];
+    json: unknown | null;
+    candidates: string[];
+    repairLog: string[];
+    zodIssues: z.ZodIssue[];
+    success: boolean;
+    usage?: LLMUsage;
+    finishReason?: string;
+    parsed: ParseLLMOutputResult<T>;
+}
+export interface StructuredResult<T> {
+    data: T;
+    raw: string;
+    thinkBlocks: ThinkBlock[];
+    json: unknown | null;
+    attempts: StructuredAttempt<T>[];
+    usage?: LLMUsage;
+    finishReason?: string;
+}
+export interface StructuredError {
+    name: "StructuredParseError";
+    raw: string;
+    thinkBlocks: ThinkBlock[];
+    candidates: string[];
+    zodIssues?: z.ZodIssue[];
+    repairLog?: string[];
+    attempt: number;
+}
+export interface MarkdownCodeBlock {
+    language: string | null;
+    code: string;
+    start: number;
+    end: number;
+}
+export interface MarkdownCodeOptions {
+    language?: string;
+    firstOnly?: boolean;
+}

package/dist/utils/common.d.ts

@@ -0,0 +1,2 @@
+export declare function toErrorMessage(error: unknown): string;
+export declare function isWhitespace(char: string | undefined): boolean;

package/dist/utils/debug-colors.d.ts

@@ -0,0 +1,7 @@
+interface ColorSupportConfig {
+    colors: boolean;
+}
+export declare function color(config: ColorSupportConfig, text: string, tone: "cyan" | "yellow" | "green" | "red"): string;
+export declare function dim(config: ColorSupportConfig, text: string): string;
+export declare function title(config: ColorSupportConfig, text: string): string;
+export {};