extrait 0.5.6 → 0.6.0

package/dist/llm.d.ts

@@ -1,14 +1,30 @@
 import type { z } from "zod";
 import { type ModelAdapterConfig, type ProviderRegistry } from "./providers/registry";
-import type { EmbeddingRequest, EmbeddingResult, LLMAdapter, StructuredCallOptions, StructuredPromptBuilder, StructuredResult } from "./types";
+import type { EmbeddingRequest, EmbeddingResult, GenerateCallOptions, GenerateOptions, GenerateResult, LLMAdapter, LLMRequest, ParseLLMOutputOptions, StructuredDebugOptions, StructuredCallOptions, StructuredMode, StructuredSelfHealInput, StructuredPromptBuilder, StructuredResult, StructuredTimeoutOptions, StructuredTraceEvent, GenerateTraceEvent } from "./types";
+interface LLMClientDefaults {
+    mode?: StructuredMode;
+    outdent?: boolean;
+    parse?: ParseLLMOutputOptions;
+    selfHeal?: StructuredSelfHealInput;
+    stream?: StructuredCallOptions<z.ZodTypeAny>["stream"] | GenerateCallOptions["stream"];
+    debug?: boolean | StructuredDebugOptions;
+    observe?: ((event: StructuredTraceEvent | GenerateTraceEvent) => void) | undefined;
+    systemPrompt?: string;
+    request?: Omit<LLMRequest, "prompt" | "systemPrompt" | "messages">;
+    schemaInstruction?: string;
+    timeout?: StructuredTimeoutOptions;
+}
 export interface CreateLLMOptions extends ModelAdapterConfig {
-    defaults?: StructuredCallOptions<z.ZodTypeAny>;
+    defaults?: LLMClientDefaults;
 }
 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>>>;
+    generate(prompt: StructuredPromptBuilder, options?: GenerateCallOptions): Promise<GenerateResult>;
+    generate(options: GenerateOptions): Promise<GenerateResult>;
     embed(input: string | string[], options?: Omit<EmbeddingRequest, "input">): Promise<EmbeddingResult>;
 }
 export declare function createLLM(config: CreateLLMOptions, registry?: ProviderRegistry): LLMClient;
+export {};

package/dist/structured.d.ts

@@ -2,16 +2,16 @@ 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 text: string;
+    readonly reasoning: string;
     readonly candidates: string[];
     readonly zodIssues?: z.ZodIssue[];
     readonly repairLog?: string[];
     readonly attempt: number;
     constructor(input: {
         message?: string;
-        raw: string;
-        thinkBlocks: StructuredError["thinkBlocks"];
+        text: string;
+        reasoning: string;
         candidates: string[];
         zodIssues?: z.ZodIssue[];
         repairLog?: string[];

package/dist/types.d.ts

@@ -149,6 +149,7 @@ export interface LLMRequest {
     systemPrompt?: string;
     messages?: LLMMessage[];
     temperature?: number;
+    reasoningEffort?: "low" | "medium" | "high" | "max";
     maxTokens?: number;
     mcpClients?: MCPToolClient[];
     toolChoice?: LLMToolChoice;
@@ -171,6 +172,7 @@ export interface LLMUsage {
 }
 export interface LLMResponse {
     text: string;
+    reasoning?: string;
     raw?: unknown;
     usage?: LLMUsage;
     finishReason?: string;
@@ -179,6 +181,7 @@ export interface LLMResponse {
 }
 export interface LLMStreamChunk {
     textDelta: string;
+    reasoningDelta?: string;
     raw?: unknown;
     done?: boolean;
     usage?: LLMUsage;
@@ -265,6 +268,12 @@ export interface StructuredTraceEvent {
     message: string;
     details?: unknown;
 }
+export interface GenerateTraceEvent {
+    stage: "llm.request" | "llm.response" | "llm.stream.delta" | "llm.stream.data" | "result";
+    attempt: number;
+    message: string;
+    details?: unknown;
+}
 export interface StructuredPromptContext {
     mode: StructuredMode;
 }
@@ -281,6 +290,7 @@ export type StructuredPromptBuilder = StructuredPromptValue | ((context: Structu
 export interface StructuredDebugOptions {
     enabled?: boolean;
     colors?: boolean;
+    verbose?: boolean;
     logger?: (line: string) => void;
 }
 export interface StructuredSelfHealOptions {
@@ -299,9 +309,18 @@ export interface StructuredTimeoutOptions {
 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> {
+export interface StructuredStreamDelta {
+    text: string;
+    reasoning: string;
+}
+export interface StructuredStreamSnapshot<T = unknown> {
+    text: string;
+    reasoning: string;
     data: StructuredStreamData<T> | null;
-    raw: string;
+}
+export interface StructuredStreamEvent<T = unknown> {
+    delta: StructuredStreamDelta;
+    snapshot: StructuredStreamSnapshot<T>;
     done: boolean;
     usage?: LLMUsage;
     finishReason?: string;
@@ -312,6 +331,39 @@ export interface StructuredStreamOptions<T = unknown> {
     to?: "stdout";
 }
 export type StructuredStreamInput<T = unknown> = boolean | StructuredStreamOptions<T>;
+export interface GenerateStreamDelta {
+    text: string;
+    reasoning: string;
+}
+export interface GenerateStreamSnapshot {
+    text: string;
+    reasoning: string;
+}
+export interface GenerateStreamEvent {
+    delta: GenerateStreamDelta;
+    snapshot: GenerateStreamSnapshot;
+    done: boolean;
+    usage?: LLMUsage;
+    finishReason?: string;
+}
+export interface GenerateStreamOptions {
+    enabled?: boolean;
+    onData?: (event: GenerateStreamEvent) => void;
+    to?: "stdout";
+}
+export type GenerateStreamInput = boolean | GenerateStreamOptions;
+export interface GenerateCallOptions {
+    outdent?: boolean;
+    stream?: GenerateStreamInput;
+    debug?: boolean | StructuredDebugOptions;
+    observe?: (event: GenerateTraceEvent) => void;
+    systemPrompt?: string;
+    request?: Omit<LLMRequest, "prompt" | "systemPrompt" | "messages">;
+    timeout?: StructuredTimeoutOptions;
+}
+export interface GenerateOptions extends GenerateCallOptions {
+    prompt: StructuredPromptBuilder;
+}
 export interface StructuredCallOptions<TSchema extends z.ZodTypeAny> {
     mode?: StructuredMode;
     outdent?: boolean;
@@ -333,8 +385,8 @@ export interface StructuredAttempt<T> {
     attempt: number;
     selfHeal: boolean;
     via: "complete" | "stream";
-    raw: string;
-    thinkBlocks: ThinkBlock[];
+    text: string;
+    reasoning: string;
     json: unknown | null;
     candidates: string[];
     repairLog: string[];
@@ -344,19 +396,34 @@ export interface StructuredAttempt<T> {
     finishReason?: string;
     parsed: ParseLLMOutputResult<T>;
 }
+export interface GenerateAttempt {
+    attempt: number;
+    via: "complete" | "stream";
+    text: string;
+    reasoning: string;
+    usage?: LLMUsage;
+    finishReason?: string;
+}
 export interface StructuredResult<T> {
     data: T;
-    raw: string;
-    thinkBlocks: ThinkBlock[];
+    text: string;
+    reasoning: string;
     json: unknown | null;
     attempts: StructuredAttempt<T>[];
     usage?: LLMUsage;
     finishReason?: string;
 }
+export interface GenerateResult {
+    text: string;
+    reasoning: string;
+    attempts: GenerateAttempt[];
+    usage?: LLMUsage;
+    finishReason?: string;
+}
 export interface StructuredError {
     name: "StructuredParseError";
-    raw: string;
-    thinkBlocks: ThinkBlock[];
+    text: string;
+    reasoning: string;
     candidates: string[];
     zodIssues?: z.ZodIssue[];
     repairLog?: string[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "extrait",
-  "version": "0.5.6",
+  "version": "0.6.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/tterrasson/extrait.git"