extrait 0.5.5 → 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

@@ -110,6 +110,7 @@ export interface MCPListToolsResult {
 export interface MCPCallToolParams {
     name: string;
     arguments?: Record<string, unknown>;
+    _meta?: Record<string, unknown>;
 }
 export interface MCPToolClient {
     id: string;
@@ -148,6 +149,7 @@ export interface LLMRequest {
     systemPrompt?: string;
     messages?: LLMMessage[];
     temperature?: number;
+    reasoningEffort?: "low" | "medium" | "high" | "max";
     maxTokens?: number;
     mcpClients?: MCPToolClient[];
     toolChoice?: LLMToolChoice;
@@ -156,6 +158,7 @@ export interface LLMRequest {
     onToolExecution?: (execution: LLMToolExecution) => void;
     transformToolOutput?: LLMToolOutputTransformer;
     transformToolArguments?: LLMToolArgumentsTransformer;
+    transformToolCallParams?: LLMToolCallParamsTransformer;
     unknownToolError?: (toolName: string) => string;
     toolDebug?: boolean | LLMToolDebugOptions;
     body?: Record<string, unknown>;
@@ -169,6 +172,7 @@ export interface LLMUsage {
 }
 export interface LLMResponse {
     text: string;
+    reasoning?: string;
     raw?: unknown;
     usage?: LLMUsage;
     finishReason?: string;
@@ -177,6 +181,7 @@ export interface LLMResponse {
 }
 export interface LLMStreamChunk {
     textDelta: string;
+    reasoningDelta?: string;
     raw?: unknown;
     done?: boolean;
     usage?: LLMUsage;
@@ -237,6 +242,11 @@ export type LLMToolArgumentsTransformer = (args: Record<string, unknown>, contex
     remoteName: string;
     clientId: string;
 }) => Record<string, unknown> | Promise<Record<string, unknown>>;
+export type LLMToolCallParamsTransformer = (params: MCPCallToolParams, context: {
+    name: string;
+    remoteName: string;
+    clientId: string;
+}) => MCPCallToolParams | Promise<MCPCallToolParams>;
 export interface LLMToolDebugOptions {
     enabled?: boolean;
     logger?: (line: string) => void;
@@ -258,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;
 }
@@ -274,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 {
@@ -292,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;
@@ -305,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;
@@ -326,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[];
@@ -337,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.5",
+  "version": "0.6.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/tterrasson/extrait.git"