@melara/sdk 0.0.0-stage → 0.1.0

package/esm/lib/model-result.d.ts

@@ -0,0 +1,373 @@
+import type { MelaraCore } from '../core.js';
+import type { FunctionCallOutputItem } from '../models/functioncalloutputitem.js';
+import type { OpenResponsesResult } from '../models/openresponsesresult.js';
+import type { OutputFunctionCallItem } from '../models/outputfunctioncallitem.js';
+import type { OutputMessage } from '../models/outputmessage.js';
+import type { CallModelInput } from './async-params.js';
+import type { RequestOptions } from './sdks.js';
+import type { $ZodObject, $ZodShape } from 'zod/v4/core';
+import type { ConversationState, ToolContextMapWithShared, ResponseStreamEvent, InferToolEventsUnion, InferToolOutputsUnion, ParsedToolCall, StateAccessor, StopWhen, Tool, ToolStreamEvent, TurnContext } from './tool-types.js';
+import { type ContextInput } from './tool-context.js';
+import { type StreamableOutputItem } from './stream-transformers.js';
+export interface GetResponseOptions<TTools extends readonly Tool[], TShared extends Record<string, unknown> = Record<string, never>> {
+    request: CallModelInput<TTools, TShared>;
+    client: MelaraCore;
+    options?: RequestOptions;
+    tools?: TTools;
+    stopWhen?: StopWhen<TTools>;
+    state?: StateAccessor<TTools>;
+    /** Typed context data passed to tools via contextSchema. `shared` key for shared context. */
+    context?: ContextInput<ToolContextMapWithShared<TTools, TShared>>;
+    /** Zod schema for shared context validation */
+    sharedContextSchema?: $ZodObject<$ZodShape>;
+    /**
+     * Call-level approval check - overrides tool-level requireApproval setting
+     * Receives the tool call and turn context, can be sync or async
+     */
+    requireApproval?: (toolCall: ParsedToolCall<TTools[number]>, context: TurnContext) => boolean | Promise<boolean>;
+    approveToolCalls?: string[];
+    rejectToolCalls?: string[];
+    /** Callback invoked at the start of each tool execution turn */
+    onTurnStart?: (context: TurnContext) => void | Promise<void>;
+    /** Callback invoked at the end of each tool execution turn */
+    onTurnEnd?: (context: TurnContext, response: OpenResponsesResult) => void | Promise<void>;
+}
+/**
+ * A wrapper around a streaming response that provides multiple consumption patterns.
+ *
+ * Allows consuming the response in multiple ways:
+ * - `await result.getText()` - Get just the text
+ * - `await result.getResponse()` - Get the full response object
+ * - `for await (const delta of result.getTextStream())` - Stream text deltas
+ * - `for await (const msg of result.getNewMessagesStream())` - Stream cumulative message snapshots
+ * - `for await (const event of result.getFullResponsesStream())` - Stream all response events
+ *
+ * For message format conversion, use the helper functions:
+ * - `toChatMessage(response)` for OpenAI chat format
+ * - `toClaudeMessage(response)` for Anthropic Claude format
+ *
+ * All consumption patterns can be used concurrently thanks to the underlying
+ * ReusableReadableStream implementation.
+ *
+ * @template TTools - The tools array type to enable typed tool calls and results
+ * @template TShared - The shape of the shared context (inferred from sharedContextSchema)
+ */
+export declare class ModelResult<TTools extends readonly Tool[], TShared extends Record<string, unknown> = Record<string, never>> {
+    private reusableStream;
+    private textPromise;
+    private options;
+    private initPromise;
+    private toolExecutionPromise;
+    private finalResponse;
+    private toolEventBroadcaster;
+    private allToolExecutionRounds;
+    private resolvedRequest;
+    private stateAccessor;
+    private currentState;
+    private requireApprovalFn;
+    private approvedToolCalls;
+    private rejectedToolCalls;
+    private isResumingFromApproval;
+    private turnBroadcaster;
+    private initialStreamPipeStarted;
+    private initialPipePromise;
+    private contextStore;
+    constructor(options: GetResponseOptions<TTools, TShared>);
+    /**
+     * Get or create the unified turn broadcaster (lazy initialization).
+     * Broadcasts all API stream events, tool events, and turn delimiters across turns.
+     */
+    private ensureTurnBroadcaster;
+    /**
+     * Start piping the initial stream into the turn broadcaster.
+     * Idempotent ,  only starts once even if called multiple times.
+     * Wraps the initial stream events with turn.start(0) / turn.end(0) delimiters.
+     */
+    private startInitialStreamPipe;
+    /**
+     * Pipe a follow-up stream into the turn broadcaster and capture the completed response.
+     * Emits turn.start / turn.end delimiters around the stream events.
+     */
+    private pipeAndConsumeStream;
+    /**
+     * Push a tool result event to both the legacy tool event broadcaster
+     * and the unified turn broadcaster.
+     */
+    private broadcastToolResult;
+    /**
+     * Push a preliminary result event to both the legacy tool event broadcaster
+     * and the unified turn broadcaster.
+     */
+    private broadcastPreliminaryResult;
+    /**
+     * Set up the turn broadcaster with tool execution and return the consumer.
+     * Used by stream methods that need to iterate over all turns.
+     */
+    private startTurnBroadcasterExecution;
+    /**
+     * Type guard to check if a value is a non-streaming response
+     * Only requires 'output' field and absence of 'toReadableStream' method
+     */
+    private isNonStreamingResponse;
+    /**
+     * Get initial response from stream or cached final response.
+     * Consumes the stream to completion if needed to extract the response.
+     *
+     * @returns The complete non-streaming response
+     * @throws Error if neither stream nor response has been initialized
+     */
+    private getInitialResponse;
+    /**
+     * Save response output to state.
+     * Appends the response output to the message history and records the response ID.
+     *
+     * @param response - The API response to save
+     */
+    private saveResponseToState;
+    /**
+     * Mark state as complete.
+     * Sets the conversation status to 'complete' indicating no further tool execution is needed.
+     */
+    private markStateComplete;
+    /**
+     * Save tool results to state.
+     * Appends tool execution results to the message history for multi-turn context.
+     *
+     * @param toolResults - The tool execution results to save
+     */
+    private saveToolResultsToState;
+    /**
+     * Check if execution should be interrupted by external signal.
+     * Polls the state accessor for interruption flags set by external processes.
+     *
+     * @param currentResponse - The current response to save as partial state
+     * @returns True if interrupted and caller should exit, false to continue
+     */
+    private checkForInterruption;
+    /**
+     * Check if stop conditions are met.
+     * Returns true if execution should stop.
+     *
+     * @remarks
+     * Default: stepCountIs(DEFAULT_MAX_STEPS) if no stopWhen is specified.
+     * This evaluates stop conditions against the complete step history.
+     */
+    private shouldStopExecution;
+    /**
+     * Check if any tool calls have execute functions.
+     * Used to determine if automatic tool execution should be attempted.
+     *
+     * @param toolCalls - The tool calls to check
+     * @returns True if at least one tool call has an executable function
+     */
+    private hasExecutableToolCalls;
+    /**
+     * Execute tools that can auto-execute (don't require approval) in parallel.
+     *
+     * @param toolCalls - The tool calls to execute
+     * @param turnContext - The current turn context
+     * @returns Array of unsent tool results for later submission
+     */
+    private executeAutoApproveTools;
+    /**
+     * Check for tools requiring approval and handle accordingly.
+     * Partitions tool calls into those needing approval and those that can auto-execute.
+     *
+     * @param toolCalls - The tool calls to check
+     * @param currentRound - The current execution round (1-indexed)
+     * @param currentResponse - The current response to save if pausing
+     * @returns True if execution should pause for approval, false to continue
+     * @throws Error if approval is required but no state accessor is configured
+     */
+    private handleApprovalCheck;
+    /**
+     * Execute all tools in a single round in parallel.
+     * Emits tool.result events after tool execution completes.
+     *
+     * @param toolCalls - The tool calls to execute
+     * @param turnContext - The current turn context
+     * @returns Array of function call outputs formatted for the API
+     */
+    private executeToolRound;
+    /**
+     * Resolve async functions for the current turn.
+     * Updates the resolved request with turn-specific parameter values.
+     *
+     * @param turnContext - The turn context for parameter resolution
+     */
+    private resolveAsyncFunctionsForTurn;
+    /**
+     * Apply nextTurnParams from executed tools.
+     * Allows tools to modify request parameters for subsequent turns.
+     *
+     * @param toolCalls - The tool calls that were just executed
+     */
+    private applyNextTurnParams;
+    /**
+     * Make a follow-up API request with tool results.
+     * Uses streaming and pipes events through the turn broadcaster when available.
+     */
+    private makeFollowupRequest;
+    /**
+     * Validate the final response has required fields.
+     *
+     * @param response - The response to validate
+     * @throws Error if response is missing required fields or has invalid output
+     */
+    private validateFinalResponse;
+    /**
+     * Resolve async functions in the request for a given turn context.
+     * Extracts non-function fields and resolves any async parameter functions.
+     *
+     * @param context - The turn context for parameter resolution
+     * @returns The resolved request without async functions
+     */
+    private resolveRequestForContext;
+    /**
+     * Safely persist state with error handling.
+     * Wraps state save operations to ensure failures are properly reported.
+     *
+     * @param updates - Optional partial state updates to apply before saving
+     * @throws Error if state persistence fails
+     */
+    private saveStateSafely;
+    /**
+     * Remove optional properties from state when they should be cleared.
+     * Uses delete to properly remove optional properties rather than setting undefined.
+     *
+     * @param props - Array of property names to remove from current state
+     */
+    private clearOptionalStateProperties;
+    /**
+     * Initialize the stream if not already started
+     * This is idempotent - multiple calls will return the same promise
+     */
+    private initStream;
+    /**
+     * Process approval/rejection decisions and resume execution
+     */
+    private processApprovalDecisions;
+    /**
+     * Continue execution with unsent tool results
+     */
+    private continueWithUnsentResults;
+    /**
+     * Execute tools automatically if they are provided and have execute functions
+     * This is idempotent - multiple calls will return the same promise
+     */
+    private executeToolsIfNeeded;
+    /**
+     * Internal helper to get the text after tool execution
+     */
+    private getTextInternal;
+    /**
+     * Get just the text content from the response.
+     * This will consume the stream until completion, execute any tools, and extract the text.
+     */
+    getText(): Promise<string>;
+    /**
+     * Get the complete response object including usage information.
+     * This will consume the stream until completion and execute any tools.
+     * Returns the full OpenResponsesResult with usage data (inputTokens, outputTokens, cachedTokens, etc.)
+     */
+    getResponse(): Promise<OpenResponsesResult>;
+    /**
+     * Stream all response events as they arrive across all turns.
+     * Multiple consumers can iterate over this stream concurrently.
+     * Includes API events, tool events, and turn.start/turn.end delimiters.
+     */
+    getFullResponsesStream(): AsyncIterableIterator<ResponseStreamEvent<InferToolEventsUnion<TTools>, InferToolOutputsUnion<TTools>>>;
+    /**
+     * Stream only text deltas as they arrive from all turns.
+     * This filters the full event stream to only yield text content,
+     * including text from follow-up responses in multi-turn tool loops.
+     */
+    getTextStream(): AsyncIterableIterator<string>;
+    /**
+     * Stream all output items cumulatively as they arrive.
+     * Items are emitted with the same ID but progressively updated content as streaming progresses.
+     * Also yields tool results (function_call_output) after tool execution completes.
+     *
+     * Item types include:
+     * - message: Assistant text responses (emitted cumulatively as text streams)
+     * - function_call: Tool calls (emitted cumulatively as arguments stream)
+     * - reasoning: Model reasoning (emitted cumulatively as thinking streams)
+     * - web_search_call: Web search operations
+     * - file_search_call: File search operations
+     * - image_generation_call: Image generation operations
+     * - function_call_output: Results from executed tools
+     */
+    getItemsStream(): AsyncIterableIterator<StreamableOutputItem>;
+    /**
+     * @deprecated Use `getItemsStream()` instead. This method only streams messages,
+     * while `getItemsStream()` streams all output item types (messages, function_calls,
+     * reasoning, etc.) with cumulative updates.
+     *
+     * Stream cumulative message snapshots as content is added in responses format.
+     * Each iteration yields an updated version of the message with new content.
+     * Also yields function_call items and FunctionCallOutputItem after tool execution completes.
+     * Returns OutputMessage, OutputFunctionCallItem, or FunctionCallOutputItem
+     * compatible with OpenAI Responses API format.
+     */
+    getNewMessagesStream(): AsyncIterableIterator<OutputMessage | FunctionCallOutputItem | OutputFunctionCallItem>;
+    /**
+     * Stream only reasoning deltas as they arrive from all turns.
+     * This filters the full event stream to only yield reasoning content,
+     * including reasoning from follow-up responses in multi-turn tool loops.
+     */
+    getReasoningStream(): AsyncIterableIterator<string>;
+    /**
+     * Stream tool call argument deltas and preliminary results from all turns.
+     * Preliminary results are streamed in REAL-TIME as generator tools yield.
+     * - Tool call argument deltas as { type: "delta", content: string }
+     * - Preliminary results as { type: "preliminary_result", toolCallId, result }
+     */
+    getToolStream(): AsyncIterableIterator<ToolStreamEvent<InferToolEventsUnion<TTools>>>;
+    /**
+     * Get all tool calls from the completed response (before auto-execution).
+     * Note: If tools have execute functions, they will be automatically executed
+     * and this will return the tool calls from the initial response.
+     * Returns structured tool calls with parsed arguments.
+     */
+    getToolCalls(): Promise<ParsedToolCall<TTools[number]>[]>;
+    /**
+     * Stream structured tool call objects as they're completed.
+     * Each iteration yields a complete tool call with parsed arguments.
+     */
+    getToolCallsStream(): AsyncIterableIterator<ParsedToolCall<TTools[number]>>;
+    /**
+     * Returns an async iterable that emits a full context snapshot every time
+     * any tool calls ctx.update(). Can be consumed concurrently with getText(),
+     * getToolStream(), etc.
+     *
+     * @example
+     * ```typescript
+     * for await (const snapshot of result.getContextUpdates()) {
+     *   console.log('Context changed:', snapshot);
+     * }
+     * ```
+     */
+    getContextUpdates(): AsyncGenerator<ToolContextMapWithShared<TTools, TShared>>;
+    /**
+     * Cancel the underlying stream and all consumers
+     */
+    cancel(): Promise<void>;
+    /**
+     * Check if the conversation requires human approval to continue.
+     * Returns true if there are pending tool calls awaiting approval.
+     */
+    requiresApproval(): Promise<boolean>;
+    /**
+     * Get the pending tool calls that require approval.
+     * Returns empty array if no approvals needed.
+     */
+    getPendingToolCalls(): Promise<ParsedToolCall<TTools[number]>[]>;
+    /**
+     * Get the current conversation state.
+     * Useful for inspection, debugging, or custom persistence.
+     * Note: This returns the raw ConversationState for inspection only.
+     * To resume a conversation, use the StateAccessor pattern.
+     */
+    getState(): Promise<ConversationState<TTools>>;
+}
+//# sourceMappingURL=model-result.d.ts.map

package/esm/lib/model-result.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-result.d.ts","sourceRoot":"","sources":["../../src/lib/model-result.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAC7C,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,qCAAqC,CAAC;AAElF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AAC5E,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,qCAAqC,CAAC;AAClF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAKhE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAExD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAChD,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACzD,OAAO,KAAK,EACV,iBAAiB,EAEjB,wBAAwB,EACxB,mBAAmB,EACnB,oBAAoB,EACpB,qBAAqB,EACrB,cAAc,EACd,aAAa,EACb,QAAQ,EACR,IAAI,EACJ,eAAe,EACf,WAAW,EAIZ,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAE,KAAK,YAAY,EAAoC,MAAM,mBAAmB,CAAC;AAmBxF,OAAO,EAcL,KAAK,oBAAoB,EAC1B,MAAM,0BAA0B,CAAC;AAyClC,MAAM,WAAW,kBAAkB,CACjC,MAAM,SAAS,SAAS,IAAI,EAAE,EAC9B,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC;IAG/D,OAAO,EAAE,cAAc,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACzC,MAAM,EAAE,UAAU,CAAC;IACnB,OAAO,CAAC,EAAE,cAAc,CAAC;IACzB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;IAE5B,KAAK,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC9B,6FAA6F;IAC7F,OAAO,CAAC,EAAE,YAAY,CAAC,wBAAwB,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAClE,+CAA+C;IAC/C,mBAAmB,CAAC,EAAE,UAAU,CAAC,SAAS,CAAC,CAAC;IAE5C;;;OAGG;IACH,eAAe,CAAC,EAAE,CAChB,QAAQ,EAAE,cAAc,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,EACxC,OAAO,EAAE,WAAW,KACjB,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAChC,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC5B,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAE3B,gEAAgE;IAChE,WAAW,CAAC,EAAE,CAAC,OAAO,EAAE,WAAW,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7D,8DAA8D;IAC9D,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,mBAAmB,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3F;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,WAAW,CACtB,MAAM,SAAS,SAAS,IAAI,EAAE,EAC9B,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC;IAE/D,OAAO,CAAC,cAAc,CAAqD;IAC3E,OAAO,CAAC,WAAW,CAAgC;IACnD,OAAO,CAAC,OAAO,CAAsC;IACrD,OAAO,CAAC,WAAW,CAA8B;IACjD,OAAO,CAAC,oBAAoB,CAA8B;IAC1D,OAAO,CAAC,aAAa,CAAoC;IACzD,OAAO,CAAC,oBAAoB,CAYZ;IAChB,OAAO,CAAC,sBAAsB,CAKtB;IAER,OAAO,CAAC,eAAe,CAAiC;IAGxD,OAAO,CAAC,aAAa,CAAsC;IAC3D,OAAO,CAAC,YAAY,CAA0C;IAC9D,OAAO,CAAC,iBAAiB,CAAiH;IAC1I,OAAO,CAAC,iBAAiB,CAAgB;IACzC,OAAO,CAAC,iBAAiB,CAAgB;IACzC,OAAO,CAAC,sBAAsB,CAAS;IAGvC,OAAO,CAAC,eAAe,CAEP;IAChB,OAAO,CAAC,wBAAwB,CAAS;IACzC,OAAO,CAAC,kBAAkB,CAA8B;IAGxD,OAAO,CAAC,YAAY,CAAiC;gBAEzC,OAAO,EAAE,kBAAkB,CAAC,MAAM,EAAE,OAAO,CAAC;IAsBxD;;;OAGG;IACH,OAAO,CAAC,qBAAqB;IAS7B;;;;OAIG;IACH,OAAO,CAAC,sBAAsB;IAkC9B;;;OAGG;YACW,oBAAoB;IAyClC;;;OAGG;IACH,OAAO,CAAC,mBAAmB;IAoB3B;;;OAGG;IACH,OAAO,CAAC,0BAA0B;IAiBlC;;;OAGG;IACH,OAAO,CAAC,6BAA6B;IAoBrC;;;OAGG;IACH,OAAO,CAAC,sBAAsB;IAe9B;;;;;;OAMG;YACW,kBAAkB;IAUhC;;;;;OAKG;YACW,mBAAmB;IAkBjC;;;OAGG;YACW,iBAAiB;IAI/B;;;;;OAKG;YACW,sBAAsB;IASpC;;;;;;OAMG;YACW,oBAAoB;IAwBlC;;;;;;;OAOG;YACW,mBAAmB;IAyBjC;;;;;;OAMG;IACH,OAAO,CAAC,sBAAsB;IAO9B;;;;;;OAMG;YACW,uBAAuB;IA0CrC;;;;;;;;;OASG;YACW,mBAAmB;IA+CjC;;;;;;;OAOG;YACW,gBAAgB;IA6H9B;;;;;OAKG;YACW,4BAA4B;IAc1C;;;;;OAKG;YACW,mBAAmB;IAmBjC;;;OAGG;YACW,mBAAmB;IA+DjC;;;;;OAKG;IACH,OAAO,CAAC,qBAAqB;IAW7B;;;;;;OAMG;YACW,wBAAwB;IAUtC;;;;;;OAMG;YACW,eAAe;IAiB7B;;;;;OAKG;IACH,OAAO,CAAC,4BAA4B;IAapC;;;OAGG;IACH,OAAO,CAAC,UAAU;IA6GlB;;OAEG;YACW,wBAAwB;IA6EtC;;OAEG;YACW,yBAAyB;IA0DvC;;;OAGG;YACW,oBAAoB;IAqHlC;;OAEG;YACW,eAAe;IAU7B;;;OAGG;IACH,OAAO,IAAI,OAAO,CAAC,MAAM,CAAC;IAS1B;;;;OAIG;IACG,WAAW,IAAI,OAAO,CAAC,mBAAmB,CAAC;IAUjD;;;;OAIG;IACH,sBAAsB,IAAI,qBAAqB,CAAC,mBAAmB,CAAC,oBAAoB,CAAC,MAAM,CAAC,EAAE,qBAAqB,CAAC,MAAM,CAAC,CAAC,CAAC;IA4BjI;;;;OAIG;IACH,aAAa,IAAI,qBAAqB,CAAC,MAAM,CAAC;IA2B9C;;;;;;;;;;;;;OAaG;IACH,cAAc,IAAI,qBAAqB,CAAC,oBAAoB,CAAC;IAwD7D;;;;;;;;;;OAUG;IACH,oBAAoB,IAAI,qBAAqB,CAC3C,aAAa,GAAG,sBAAsB,GAAG,sBAAsB,CAChE;IA2CD;;;;OAIG;IACH,kBAAkB,IAAI,qBAAqB,CAAC,MAAM,CAAC;IA2BnD;;;;;OAKG;IACH,aAAa,IAAI,qBAAqB,CAAC,eAAe,CAAC,oBAAoB,CAAC,MAAM,CAAC,CAAC,CAAC;IAqCrF;;;;;OAKG;IACG,YAAY,IAAI,OAAO,CAAC,cAAc,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC;IAgB/D;;;OAGG;IACH,kBAAkB,IAAI,qBAAqB,CAAC,cAAc,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC;IAc3E;;;;;;;;;;;OAWG;IACI,iBAAiB,IAAI,cAAc,CAAC,wBAAwB,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IA0DrF;;OAEG;IACG,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAU7B;;;OAGG;IACG,gBAAgB,IAAI,OAAO,CAAC,OAAO,CAAC;IAY1C;;;OAGG;IACG,mBAAmB,IAAI,OAAO,CAAC,cAAc,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC;IAWtE;;;;;OAKG;IACG,QAAQ,IAAI,OAAO,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAC;CAcrD"}