@jaypie/llm 1.3.6 → 1.3.7

package/dist/cjs/index.d.cts

@@ -402,6 +402,49 @@ interface LlmMessageOptions {
     response?: NaturalSchema | z.ZodType;
     system?: string;
 }
+declare enum LlmProgressEventType {
+    Done = "done",
+    ModelRequest = "model_request",
+    ModelResponse = "model_response",
+    Retry = "retry",
+    Start = "start",
+    ToolCall = "tool_call",
+    ToolError = "tool_error",
+    ToolResult = "tool_result"
+}
+interface LlmProgressToolCall {
+    /** JSON string of arguments (tool_call events only) */
+    arguments?: string;
+    /** Tool name */
+    name: string;
+}
+/**
+ * Lightweight, serializable progress event emitted by the operate loop.
+ * Suitable for forwarding directly to websockets, queues, or UI updates.
+ */
+interface LlmProgressEvent {
+    /** Text or structured content (model_response, done) */
+    content?: string | JsonObject;
+    /** Error message (tool_error, retry) */
+    error?: string;
+    /** Maximum turns allowed for the loop (start) */
+    maxTurns?: number;
+    /** Model handling the request (start, model_request) */
+    model?: string;
+    /** Provider name (start) */
+    provider?: string;
+    /** The tool involved (tool_call, tool_result, tool_error) */
+    tool?: LlmProgressToolCall;
+    /** Tools the model requested (model_response) */
+    toolCalls?: LlmProgressToolCall[];
+    /** Current turn, 1-indexed */
+    turn?: number;
+    /** Event type */
+    type: LlmProgressEventType;
+    /** Usage: this turn for model_response, cumulative for done */
+    usage?: LlmUsage;
+}
+type LlmProgressCallback = (event: LlmProgressEvent) => unknown | Promise<unknown>;
 interface LlmOperateOptions {
     data?: NaturalMap;
     explain?: boolean;
@@ -452,6 +495,13 @@ interface LlmOperateOptions {
     };
     instructions?: string;
     model?: string;
+    /**
+     * Receives lightweight progress events as the operate loop runs:
+     * start, model_request, model_response, tool_call, tool_result,
+     * tool_error, retry, done. Errors thrown by the callback are logged
+     * and never interrupt the loop.
+     */
+    onProgress?: LlmProgressCallback;
     placeholders?: {
         input?: boolean;
         instructions?: boolean;
@@ -669,5 +719,5 @@ declare class XaiProvider implements LlmProvider {
     stream(input: string | LlmHistory | LlmInputMessage, options?: LlmOperateOptions): AsyncIterable<LlmStreamChunk>;
 }
 
-export { BedrockProvider, GoogleProvider as GeminiProvider, GoogleProvider, JaypieToolkit, constants as LLM, Llm, LlmMessageRole, LlmMessageType, LlmStreamChunkType, OpenRouterProvider, Toolkit, XaiProvider, extractReasoning, isLlmOperateInput, isLlmOperateInputContent, isLlmOperateInputFile, isLlmOperateInputImage, jsonSchemaToNaturalSchema, naturalSchemaToJsonSchema, toolkit, tools };
-export type { LlmFallbackConfig, LlmHistory, LlmInputContent, LlmInputContentFile, LlmInputContentImage, LlmInputContentText, LlmInputMessage, LlmMessageOptions, LlmOperateInput, LlmOperateInputContent, LlmOperateInputFile, LlmOperateInputImage, LlmOperateOptions, LlmOperateResponse, LlmOptions, LlmProvider, LlmStreamChunk, LlmStreamChunkDone, LlmStreamChunkError, LlmStreamChunkText, LlmStreamChunkToolCall, LlmStreamChunkToolResult, LlmTool };
+export { BedrockProvider, GoogleProvider as GeminiProvider, GoogleProvider, JaypieToolkit, constants as LLM, Llm, LlmMessageRole, LlmMessageType, LlmProgressEventType, LlmStreamChunkType, OpenRouterProvider, Toolkit, XaiProvider, extractReasoning, isLlmOperateInput, isLlmOperateInputContent, isLlmOperateInputFile, isLlmOperateInputImage, jsonSchemaToNaturalSchema, naturalSchemaToJsonSchema, toolkit, tools };
+export type { LlmFallbackConfig, LlmHistory, LlmInputContent, LlmInputContentFile, LlmInputContentImage, LlmInputContentText, LlmInputMessage, LlmMessageOptions, LlmOperateInput, LlmOperateInputContent, LlmOperateInputFile, LlmOperateInputImage, LlmOperateOptions, LlmOperateResponse, LlmOptions, LlmProgressCallback, LlmProgressEvent, LlmProgressToolCall, LlmProvider, LlmStreamChunk, LlmStreamChunkDone, LlmStreamChunkError, LlmStreamChunkText, LlmStreamChunkToolCall, LlmStreamChunkToolResult, LlmTool };

package/dist/cjs/src/index.d.ts

@@ -1,7 +1,7 @@
 export { default as Llm } from "./Llm.js";
 export * as LLM from "./constants.js";
-export type { LlmFallbackConfig, LlmHistory, LlmInputContent, LlmInputContentFile, LlmInputContentImage, LlmInputContentText, LlmInputMessage, LlmMessageOptions, LlmOperateInput, LlmOperateInputContent, LlmOperateInputFile, LlmOperateInputImage, LlmOperateOptions, LlmOperateResponse, LlmOptions, LlmProvider, } from "./types/LlmProvider.interface.js";
-export { LlmMessageRole, LlmMessageType, } from "./types/LlmProvider.interface.js";
+export type { LlmFallbackConfig, LlmHistory, LlmInputContent, LlmInputContentFile, LlmInputContentImage, LlmInputContentText, LlmInputMessage, LlmMessageOptions, LlmOperateInput, LlmOperateInputContent, LlmOperateInputFile, LlmOperateInputImage, LlmOperateOptions, LlmOperateResponse, LlmOptions, LlmProgressCallback, LlmProgressEvent, LlmProgressToolCall, LlmProvider, } from "./types/LlmProvider.interface.js";
+export { LlmMessageRole, LlmMessageType, LlmProgressEventType, } from "./types/LlmProvider.interface.js";
 export { isLlmOperateInput, isLlmOperateInputContent, isLlmOperateInputFile, isLlmOperateInputImage, } from "./types/LlmOperateInput.guards.js";
 export type { LlmTool } from "./types/LlmTool.interface.js";
 export type { LlmStreamChunk, LlmStreamChunkDone, LlmStreamChunkError, LlmStreamChunkText, LlmStreamChunkToolCall, LlmStreamChunkToolResult, } from "./types/LlmStreamChunk.interface.js";

package/dist/cjs/src/operate/OperateLoop.d.ts

@@ -34,6 +34,11 @@ export declare class OperateLoop {
     private createContext;
     private buildInitialRequest;
     private executeOneTurn;
+    /**
+     * Draconian summary of a history item for trace logging: string message
+     * content is kept; everything else is reduced to its type.
+     */
+    private summarizeHistoryItem;
     /**
      * Reconcile structured output against the declared `format` contract. A
      * declared `format` is a schema contract: returned keys should match the

package/dist/cjs/src/operate/progress/emitProgress.d.ts

@@ -0,0 +1,10 @@
+import { LlmProgressCallback, LlmProgressEvent } from "../../types/LlmProvider.interface.js";
+/**
+ * Deliver a progress event to the caller's onProgress callback.
+ * Errors thrown by the callback are logged and swallowed — progress
+ * reporting must never interrupt the operate loop.
+ */
+export declare function emitProgress({ event, onProgress, }: {
+    event: LlmProgressEvent;
+    onProgress?: LlmProgressCallback;
+}): Promise<void>;

package/dist/cjs/src/operate/progress/index.d.ts

@@ -0,0 +1 @@
+export { emitProgress } from "./emitProgress.js";

package/dist/cjs/src/types/LlmProvider.interface.d.ts

@@ -166,6 +166,49 @@ export interface LlmMessageOptions {
     response?: NaturalSchema | z.ZodType;
     system?: string;
 }
+export declare enum LlmProgressEventType {
+    Done = "done",
+    ModelRequest = "model_request",
+    ModelResponse = "model_response",
+    Retry = "retry",
+    Start = "start",
+    ToolCall = "tool_call",
+    ToolError = "tool_error",
+    ToolResult = "tool_result"
+}
+export interface LlmProgressToolCall {
+    /** JSON string of arguments (tool_call events only) */
+    arguments?: string;
+    /** Tool name */
+    name: string;
+}
+/**
+ * Lightweight, serializable progress event emitted by the operate loop.
+ * Suitable for forwarding directly to websockets, queues, or UI updates.
+ */
+export interface LlmProgressEvent {
+    /** Text or structured content (model_response, done) */
+    content?: string | JsonObject;
+    /** Error message (tool_error, retry) */
+    error?: string;
+    /** Maximum turns allowed for the loop (start) */
+    maxTurns?: number;
+    /** Model handling the request (start, model_request) */
+    model?: string;
+    /** Provider name (start) */
+    provider?: string;
+    /** The tool involved (tool_call, tool_result, tool_error) */
+    tool?: LlmProgressToolCall;
+    /** Tools the model requested (model_response) */
+    toolCalls?: LlmProgressToolCall[];
+    /** Current turn, 1-indexed */
+    turn?: number;
+    /** Event type */
+    type: LlmProgressEventType;
+    /** Usage: this turn for model_response, cumulative for done */
+    usage?: LlmUsage;
+}
+export type LlmProgressCallback = (event: LlmProgressEvent) => unknown | Promise<unknown>;
 export interface LlmOperateOptions {
     data?: NaturalMap;
     explain?: boolean;
@@ -216,6 +259,13 @@ export interface LlmOperateOptions {
     };
     instructions?: string;
     model?: string;
+    /**
+     * Receives lightweight progress events as the operate loop runs:
+     * start, model_request, model_response, tool_call, tool_result,
+     * tool_error, retry, done. Errors thrown by the callback are logged
+     * and never interrupt the loop.
+     */
+    onProgress?: LlmProgressCallback;
     placeholders?: {
         input?: boolean;
         instructions?: boolean;

package/dist/esm/index.d.ts

@@ -402,6 +402,49 @@ interface LlmMessageOptions {
     response?: NaturalSchema | z.ZodType;
     system?: string;
 }
+declare enum LlmProgressEventType {
+    Done = "done",
+    ModelRequest = "model_request",
+    ModelResponse = "model_response",
+    Retry = "retry",
+    Start = "start",
+    ToolCall = "tool_call",
+    ToolError = "tool_error",
+    ToolResult = "tool_result"
+}
+interface LlmProgressToolCall {
+    /** JSON string of arguments (tool_call events only) */
+    arguments?: string;
+    /** Tool name */
+    name: string;
+}
+/**
+ * Lightweight, serializable progress event emitted by the operate loop.
+ * Suitable for forwarding directly to websockets, queues, or UI updates.
+ */
+interface LlmProgressEvent {
+    /** Text or structured content (model_response, done) */
+    content?: string | JsonObject;
+    /** Error message (tool_error, retry) */
+    error?: string;
+    /** Maximum turns allowed for the loop (start) */
+    maxTurns?: number;
+    /** Model handling the request (start, model_request) */
+    model?: string;
+    /** Provider name (start) */
+    provider?: string;
+    /** The tool involved (tool_call, tool_result, tool_error) */
+    tool?: LlmProgressToolCall;
+    /** Tools the model requested (model_response) */
+    toolCalls?: LlmProgressToolCall[];
+    /** Current turn, 1-indexed */
+    turn?: number;
+    /** Event type */
+    type: LlmProgressEventType;
+    /** Usage: this turn for model_response, cumulative for done */
+    usage?: LlmUsage;
+}
+type LlmProgressCallback = (event: LlmProgressEvent) => unknown | Promise<unknown>;
 interface LlmOperateOptions {
     data?: NaturalMap;
     explain?: boolean;
@@ -452,6 +495,13 @@ interface LlmOperateOptions {
     };
     instructions?: string;
     model?: string;
+    /**
+     * Receives lightweight progress events as the operate loop runs:
+     * start, model_request, model_response, tool_call, tool_result,
+     * tool_error, retry, done. Errors thrown by the callback are logged
+     * and never interrupt the loop.
+     */
+    onProgress?: LlmProgressCallback;
     placeholders?: {
         input?: boolean;
         instructions?: boolean;
@@ -669,5 +719,5 @@ declare class XaiProvider implements LlmProvider {
     stream(input: string | LlmHistory | LlmInputMessage, options?: LlmOperateOptions): AsyncIterable<LlmStreamChunk>;
 }
 
-export { BedrockProvider, GoogleProvider as GeminiProvider, GoogleProvider, JaypieToolkit, constants as LLM, Llm, LlmMessageRole, LlmMessageType, LlmStreamChunkType, OpenRouterProvider, Toolkit, XaiProvider, extractReasoning, isLlmOperateInput, isLlmOperateInputContent, isLlmOperateInputFile, isLlmOperateInputImage, jsonSchemaToNaturalSchema, naturalSchemaToJsonSchema, toolkit, tools };
-export type { LlmFallbackConfig, LlmHistory, LlmInputContent, LlmInputContentFile, LlmInputContentImage, LlmInputContentText, LlmInputMessage, LlmMessageOptions, LlmOperateInput, LlmOperateInputContent, LlmOperateInputFile, LlmOperateInputImage, LlmOperateOptions, LlmOperateResponse, LlmOptions, LlmProvider, LlmStreamChunk, LlmStreamChunkDone, LlmStreamChunkError, LlmStreamChunkText, LlmStreamChunkToolCall, LlmStreamChunkToolResult, LlmTool };
+export { BedrockProvider, GoogleProvider as GeminiProvider, GoogleProvider, JaypieToolkit, constants as LLM, Llm, LlmMessageRole, LlmMessageType, LlmProgressEventType, LlmStreamChunkType, OpenRouterProvider, Toolkit, XaiProvider, extractReasoning, isLlmOperateInput, isLlmOperateInputContent, isLlmOperateInputFile, isLlmOperateInputImage, jsonSchemaToNaturalSchema, naturalSchemaToJsonSchema, toolkit, tools };
+export type { LlmFallbackConfig, LlmHistory, LlmInputContent, LlmInputContentFile, LlmInputContentImage, LlmInputContentText, LlmInputMessage, LlmMessageOptions, LlmOperateInput, LlmOperateInputContent, LlmOperateInputFile, LlmOperateInputImage, LlmOperateOptions, LlmOperateResponse, LlmOptions, LlmProgressCallback, LlmProgressEvent, LlmProgressToolCall, LlmProvider, LlmStreamChunk, LlmStreamChunkDone, LlmStreamChunkError, LlmStreamChunkText, LlmStreamChunkToolCall, LlmStreamChunkToolResult, LlmTool };

package/dist/esm/index.js

@@ -487,6 +487,18 @@ var LlmResponseStatus;
     LlmResponseStatus["Incomplete"] = "incomplete";
     LlmResponseStatus["InProgress"] = "in_progress";
 })(LlmResponseStatus || (LlmResponseStatus = {}));
+// Progress
+var LlmProgressEventType;
+(function (LlmProgressEventType) {
+    LlmProgressEventType["Done"] = "done";
+    LlmProgressEventType["ModelRequest"] = "model_request";
+    LlmProgressEventType["ModelResponse"] = "model_response";
+    LlmProgressEventType["Retry"] = "retry";
+    LlmProgressEventType["Start"] = "start";
+    LlmProgressEventType["ToolCall"] = "tool_call";
+    LlmProgressEventType["ToolError"] = "tool_error";
+    LlmProgressEventType["ToolResult"] = "tool_result";
+})(LlmProgressEventType || (LlmProgressEventType = {}));
 
 //
 //
@@ -6130,6 +6142,25 @@ class InputProcessor {
 // Export singleton instance for convenience
 const inputProcessor = new InputProcessor();
 
+/**
+ * Deliver a progress event to the caller's onProgress callback.
+ * Errors thrown by the callback are logged and swallowed — progress
+ * reporting must never interrupt the operate loop.
+ */
+async function emitProgress({ event, onProgress, }) {
+    if (!onProgress) {
+        return;
+    }
+    try {
+        await onProgress(event);
+    }
+    catch (error) {
+        const log = getLogger$6();
+        log.warn(`[operate] onProgress callback threw on "${event.type}" event`);
+        log.var({ error });
+    }
+}
+
 //
 //
 // Main
@@ -6555,12 +6586,21 @@ class OperateLoop {
         const log = getLogger$6();
         // Log what was passed to operate
         log.trace("[operate] Starting operate loop");
-        log.var({ "operate.input": input });
-        log.var({ "operate.options": options });
+        log.trace.var({ "operate.input": input });
+        log.trace.var({ "operate.options": options });
         // Initialize state
         const state = await this.initializeState(input, options);
         const context = this.createContext(options);
         const modelName = options.model ?? this.adapter.defaultModel;
+        await emitProgress({
+            event: {
+                maxTurns: state.maxTurns,
+                model: modelName,
+                provider: this.adapter.name,
+                type: LlmProgressEventType.Start,
+            },
+            onProgress: options.onProgress,
+        });
         // Enclosing LLM Observability span (no-op when DD_LLMOBS_ENABLED is unset).
         // Child llm/tool spans nest under it via the SDK's active-span context.
         return withLlmObsSpan({
@@ -6598,6 +6638,15 @@ class OperateLoop {
                 metrics: usageToLlmObsMetrics(response.usage),
                 outputData: response.content,
             });
+            await emitProgress({
+                event: {
+                    content: response.content,
+                    turn: state.currentTurn,
+                    type: LlmProgressEventType.Done,
+                    usage: response.usage,
+                },
+                onProgress: options.onProgress,
+            });
             return response;
         });
     }
@@ -6692,18 +6741,54 @@ class OperateLoop {
         });
         // Build provider-specific request
         const providerRequest = this.adapter.buildRequest(request);
-        // Log what was passed to the model
+        // Log a draconian subset of the request; the full payload is available
+        // via the beforeEachModelRequest hook
         log.trace("[operate] Calling model");
-        log.var({ "operate.request": providerRequest });
+        log.trace.var({
+            "operate.request": {
+                latest: this.summarizeHistoryItem(request.messages[request.messages.length - 1]),
+                messages: request.messages.length,
+                model: request.model,
+                turn: state.currentTurn,
+            },
+        });
+        await emitProgress({
+            event: {
+                model: request.model,
+                turn: state.currentTurn,
+                type: LlmProgressEventType.ModelRequest,
+            },
+            onProgress: options.onProgress,
+        });
         // Execute beforeEachModelRequest hook
         await this.hookRunnerInstance.runBeforeModelRequest(context.hooks, {
             input: state.currentInput,
             options,
             providerRequest,
         });
+        // Emit retry progress alongside the caller's onRetryableModelError hook
+        const hooks = context.hooks;
+        const hooksWithProgress = options.onProgress
+            ? {
+                ...hooks,
+                onRetryableModelError: async (retryContext) => {
+                    await emitProgress({
+                        event: {
+                            error: retryContext.error instanceof Error
+                                ? retryContext.error.message
+                                : String(retryContext.error),
+                            turn: state.currentTurn,
+                            type: LlmProgressEventType.Retry,
+                        },
+                        onProgress: options.onProgress,
+                    });
+                    return hooks?.onRetryableModelError?.(retryContext);
+                },
+            }
+            : hooks;
         // Execute with retry inside a child llm span (no-op when llmobs disabled).
         // RetryExecutor handles error hooks and throws appropriate errors.
-        const { parsed, response } = await withLlmObsSpan({
+        const { parsed, response, toolCalls } = await withLlmObsSpan({
             kind: "llm",
             modelName: options.model ?? this.adapter.defaultModel,
             modelProvider: this.adapter.name,
@@ -6715,19 +6800,43 @@ class OperateLoop {
                     options,
                     providerRequest,
                 },
-                hooks: context.hooks,
+                hooks: hooksWithProgress,
             });
-            // Log what was returned from the model
-            log.trace("[operate] Model response received");
-            log.var({ "operate.response": response });
             // Parse response
             const parsed = this.adapter.parseResponse(response, options);
+            const toolCalls = parsed.hasToolCalls
+                ? this.adapter.extractToolCalls(response)
+                : [];
+            // Log only the text or tool calls; the full payload is available
+            // via the afterEachModelResponse hook
+            log.trace("[operate] Model response received");
+            log.trace.var({
+                "operate.response": toolCalls.length > 0
+                    ? toolCalls.map(({ arguments: args, name }) => ({
+                        arguments: args,
+                        name,
+                    }))
+                    : parsed.content,
+            });
             annotateLlmObs({
                 inputData: state.currentInput,
                 metrics: usageToLlmObsMetrics(parsed.usage ? [parsed.usage] : undefined),
                 outputData: parsed.content ?? "",
             });
-            return { parsed, response };
+            return { parsed, response, toolCalls };
+        });
+        await emitProgress({
+            event: {
+                content: parsed.content,
+                toolCalls: toolCalls.map(({ arguments: args, name }) => ({
+                    arguments: args,
+                    name,
+                })),
+                turn: state.currentTurn,
+                type: LlmProgressEventType.ModelResponse,
+                usage: parsed.usage ? [parsed.usage] : undefined,
+            },
+            onProgress: options.onProgress,
         });
         // Track usage
         if (parsed.usage) {
@@ -6756,7 +6865,6 @@ class OperateLoop {
         }
         // Handle tool calls
         if (parsed.hasToolCalls) {
-            const toolCalls = this.adapter.extractToolCalls(response);
             if (toolCalls.length > 0 && state.toolkit && state.maxTurns > 1) {
                 // Track updated provider request for tool results
                 let currentProviderRequest = providerRequest;
@@ -6768,6 +6876,14 @@ class OperateLoop {
                 // Process each tool call
                 for (const toolCall of toolCalls) {
                     try {
+                        await emitProgress({
+                            event: {
+                                tool: { arguments: toolCall.arguments, name: toolCall.name },
+                                turn: state.currentTurn,
+                                type: LlmProgressEventType.ToolCall,
+                            },
+                            onProgress: options.onProgress,
+                        });
                         // Execute beforeEachTool hook
                         await this.hookRunnerInstance.runBeforeTool(context.hooks, {
                             args: toolCall.arguments,
@@ -6787,6 +6903,14 @@ class OperateLoop {
                             });
                             return result;
                         });
+                        await emitProgress({
+                            event: {
+                                tool: { name: toolCall.name },
+                                turn: state.currentTurn,
+                                type: LlmProgressEventType.ToolResult,
+                            },
+                            onProgress: options.onProgress,
+                        });
                         // Execute afterEachTool hook
                         await this.hookRunnerInstance.runAfterTool(context.hooks, {
                             args: toolCall.arguments,
@@ -6810,6 +6934,15 @@ class OperateLoop {
                         state.responseBuilder.appendToHistory(toolResultFormatted);
                     }
                     catch (error) {
+                        await emitProgress({
+                            event: {
+                                error: error.message,
+                                tool: { name: toolCall.name },
+                                turn: state.currentTurn,
+                                type: LlmProgressEventType.ToolError,
+                            },
+                            onProgress: options.onProgress,
+                        });
                         // Execute onToolError hook
                         await this.hookRunnerInstance.runOnToolError(context.hooks, {
                             args: toolCall.arguments,
@@ -6883,6 +7016,20 @@ class OperateLoop {
         }
         return false; // Stop loop
     }
+    /**
+     * Draconian summary of a history item for trace logging: string message
+     * content is kept; everything else is reduced to its type.
+     */
+    summarizeHistoryItem(item) {
+        if (!item) {
+            return undefined;
+        }
+        const record = item;
+        if (typeof record.content === "string") {
+            return { content: record.content, role: record.role };
+        }
+        return { type: record.type ?? "message" };
+    }
     /**
      * Reconcile structured output against the declared `format` contract. A
      * declared `format` is a schema contract: returned keys should match the
@@ -9220,5 +9367,5 @@ const toolkit = new JaypieToolkit(tools);
     [LlmMessageRole.Developer]: "user",
 });
 
-export { BedrockProvider, GoogleProvider as GeminiProvider, GoogleProvider, JaypieToolkit, constants as LLM, Llm, LlmMessageRole, LlmMessageType, LlmStreamChunkType, OpenRouterProvider, Toolkit, XaiProvider, extractReasoning, isLlmOperateInput, isLlmOperateInputContent, isLlmOperateInputFile, isLlmOperateInputImage, jsonSchemaToNaturalSchema, naturalSchemaToJsonSchema, toolkit, tools };
+export { BedrockProvider, GoogleProvider as GeminiProvider, GoogleProvider, JaypieToolkit, constants as LLM, Llm, LlmMessageRole, LlmMessageType, LlmProgressEventType, LlmStreamChunkType, OpenRouterProvider, Toolkit, XaiProvider, extractReasoning, isLlmOperateInput, isLlmOperateInputContent, isLlmOperateInputFile, isLlmOperateInputImage, jsonSchemaToNaturalSchema, naturalSchemaToJsonSchema, toolkit, tools };
 //# sourceMappingURL=index.js.map