@robota-sdk/agent-provider-openai 3.0.0-beta.63 → 3.0.0-beta.82

package/dist/node/index.d.cts

@@ -1,216 +1,204 @@
-import OpenAI from 'openai';
-import { ILogger, IExecutor, TProviderOptionValueBase, AbstractAIProvider, TTextDeltaCallback, TUniversalMessage, IChatOptions, IProviderCapabilities, IProviderProfileConfig, IProviderModelCatalog, IProviderDefinition } from '@robota-sdk/agent-core';
-
-/**
- * Payload logging data structure
- */
-interface IOpenAILogData {
-    model: string;
-    messagesCount: number;
-    hasTools: boolean;
-    temperature?: number | undefined;
-    maxTokens?: number | undefined;
-    timestamp: string;
-    requestId?: string | undefined;
-}
-
-/**
- * IPayloadLogger interface for logging OpenAI API payloads
- *
- * This interface provides a contract for different logging implementations:
- * - FilePayloadLogger: Node.js file-based logging
- * - ConsolePayloadLogger: Browser console-based logging
- * - Custom implementations: User-defined loggers
- */
-interface IPayloadLogger {
-    /**
-     * Check if logging is enabled
-     * @returns true if logging is active, false otherwise
-     */
-    isEnabled(): boolean;
-    /**
-     * Log API payload data
-     * @param payload - The API request/response payload data
-     * @param type - Type of operation ('chat' or 'stream')
-     */
-    logPayload(payload: IOpenAILogData, type: 'chat' | 'stream'): Promise<void>;
-}
-/**
- * Configuration options for payload loggers
- */
-interface IPayloadLoggerOptions {
-    /**
-     * Whether logging is enabled
-     * @defaultValue true
-     */
-    enabled?: boolean;
-    /**
-     * Include timestamp in log entries
-     * @defaultValue true
-     */
-    includeTimestamp?: boolean;
-    /**
-     * Logger instance for console output
-     * @defaultValue SilentLogger
-     */
-    logger?: ILogger;
-}
-
+import { n as IPayloadLoggerOptions, t as IPayloadLogger } from "./payload-logger-BaW0K8yI.cjs";
+import { AbstractAIProvider, IChatOptions, IExecutor, ILogger, IProviderCapabilities, IProviderDefinition, IProviderModelEffortTable, IToolSchemaProjectionProfile, TProviderOptionValueBase, TTextDeltaCallback, TUniversalMessage } from "@robota-sdk/agent-core";
+import OpenAI from "openai";
+//#region src/openai/types.d.ts
 type TOpenAIApiSurface = 'responses' | 'chat-completions';
 interface IOpenAIJsonSchemaDefinition {
-    name: string;
-    description?: string;
-    schema?: Record<string, TOpenAIProviderOptionValue>;
-    strict?: boolean;
+  name: string;
+  description?: string;
+  schema?: Record<string, TOpenAIProviderOptionValue>;
+  strict?: boolean;
 }
 interface IOpenAIResponsesReasoningOptions {
-    effort?: 'low' | 'medium' | 'high';
-    summary?: 'auto' | 'concise' | 'detailed';
+  effort?: 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | 'max';
+  summary?: 'auto' | 'concise' | 'detailed';
 }
 interface IOpenAINativeWebToolsOptions {
-    webSearch?: boolean;
-    webFetch?: boolean;
+  webSearch?: boolean;
+  webFetch?: boolean;
 }
 /**
  * Valid provider option value types
  */
 type TOpenAIProviderOptionValue = string | number | boolean | undefined | null | IOpenAIJsonSchemaDefinition | IOpenAINativeWebToolsOptions | IOpenAIResponsesReasoningOptions | OpenAI | IPayloadLogger | ILogger | IExecutor | TProviderOptionValueBase | TOpenAIProviderOptionValue[] | {
-    [key: string]: TOpenAIProviderOptionValue;
+  [key: string]: TOpenAIProviderOptionValue;
 };
 /**
  * OpenAI provider options
  */
 interface IOpenAIProviderOptions {
-    /**
-     * Additional provider-specific options
-     */
-    [key: string]: TOpenAIProviderOptionValue;
-    /**
-     * OpenAI API key (required when client is not provided)
-     */
-    apiKey?: string;
-    /**
-     * OpenAI organization ID (optional)
-     */
-    organization?: string;
-    /**
-     * API request timeout (milliseconds)
-     */
-    timeout?: number;
-    /**
-     * API base URL (default: 'https://api.openai.com/v1')
-     */
-    baseURL?: string;
-    /**
-     * Default model used when chat options do not provide a model.
-     */
-    defaultModel?: string;
-    /**
-     * API surface to use for direct OpenAI calls.
-     *
-     * Defaults to Responses for official OpenAI calls. Profiles with baseURL use
-     * Chat Completions by default for OpenAI-compatible endpoint compatibility.
-     */
-    apiSurface?: TOpenAIApiSurface;
-    /**
-     * Response format (default: 'text')
-     * - 'text': Plain text response
-     * - 'json_object': JSON object mode (requires system message)
-     * - 'json_schema': Structured Outputs with schema validation
-     */
-    responseFormat?: 'text' | 'json_object' | 'json_schema';
-    /**
-     * JSON schema for structured outputs (required when responseFormat is 'json_schema')
-     */
-    jsonSchema?: IOpenAIJsonSchemaDefinition;
-    /**
-     * Responses API reasoning controls. Hidden reasoning is never exposed in message
-     * content; only explicit summaries/encrypted items requested here are represented.
-     */
-    reasoning?: IOpenAIResponsesReasoningOptions;
-    /**
-     * Whether OpenAI should store Responses API results. Defaults to OpenAI API behavior.
-     */
-    store?: boolean;
-    /**
-     * Include encrypted reasoning items for stateless reasoning continuation.
-     */
-    includeEncryptedReasoning?: boolean;
-    /**
-     * Opt into strict custom function parameter validation where supported.
-     */
-    strictTools?: boolean;
-    /**
-     * Provider-native hosted web tool request from provider profile options.
-     *
-     * OpenAI-compatible Chat Completions endpoints do not support this Robota
-     * native web contract. The provider rejects unsupported configurations before
-     * any model request is sent.
-     */
-    nativeWebTools?: IOpenAINativeWebToolsOptions;
-    /**
-     * OpenAI client instance (optional: will be created from apiKey if not provided)
-     */
-    client?: OpenAI;
-    /**
-     * Payload logger instance for debugging API requests/responses
-     *
-     * Use different implementations based on your environment:
-     * - FilePayloadLogger: Node.js file-based logging
-     * - ConsolePayloadLogger: Browser console-based logging
-     * - Custom: Implement IPayloadLogger interface
-     *
-     * @example
-     * ```typescript
-     * // Node.js
-     * import { FilePayloadLogger } from '@robota-sdk/agent-provider-openai/loggers/file';
-     * const provider = new OpenAIProvider({
-     *   client: openaiClient,
-     *   payloadLogger: new FilePayloadLogger({ logDir: './logs/openai' })
-     * });
-     *
-     * // Browser
-     * import { ConsolePayloadLogger } from '@robota-sdk/agent-provider-openai/loggers/console';
-     * const provider = new OpenAIProvider({
-     *   client: openaiClient,
-     *   payloadLogger: new ConsolePayloadLogger()
-     * });
-     * ```
-     */
-    payloadLogger?: IPayloadLogger;
-    /**
-     * Optional executor for handling AI requests
-     *
-     * When provided, the provider will delegate all chat operations to this executor
-     * instead of making direct API calls. This enables remote execution capabilities.
-     *
-     * @example
-     * ```typescript
-     * import { LocalExecutor, RemoteExecutor } from '@robota-sdk/agent-core';
-     *
-     * // Local execution (registers this provider)
-     * const localExecutor = new LocalExecutor();
-     * localExecutor.registerProvider('openai', new OpenAIProvider({ apiKey: 'sk-...' }));
-     *
-     * // Remote execution
-     * const remoteExecutor = new RemoteExecutor({
-     *   serverUrl: 'https://api.robota.io',
-     *   userApiKey: 'user-token-123'
-     * });
-     *
-     * const provider = new OpenAIProvider({
-     *   executor: remoteExecutor // No direct API key needed
-     * });
-     * ```
-     */
-    executor?: IExecutor;
-    /**
-     * Logger instance for internal OpenAI provider logging
-     * @defaultValue SilentLogger
-     */
-    logger?: ILogger;
+  /**
+   * Additional provider-specific options
+   */
+  [key: string]: TOpenAIProviderOptionValue;
+  /**
+   * OpenAI API key (required when client is not provided)
+   */
+  apiKey?: string;
+  /**
+   * OpenAI organization ID (optional)
+   */
+  organization?: string;
+  /**
+   * API request timeout (milliseconds)
+   */
+  timeout?: number;
+  /**
+   * Whether to request token usage on streaming turns via
+   * `stream_options: { include_usage: true }` (default `true`). Set `false` for
+   * OpenAI-compatible endpoints that reject `stream_options`; usage is then absent
+   * on streaming turns for this provider.
+   */
+  includeStreamUsage?: boolean;
+  /**
+   * API base URL (default: `'https://api.openai.com/v1'`).
+   *
+   * Point this at ANY OpenAI-compatible endpoint — this provider is a protocol
+   * client, not an OpenAI-vendor lock:
+   *
+   * - AI gateways: Vercel AI Gateway, LiteLLM, OpenRouter, …
+   * - Hosted compatibles: Azure OpenAI, Groq, Together, …
+   * - Local/self-hosted: vLLM, Ollama, LM Studio, …
+   *
+   * Setting `baseURL` switches the default {@link apiSurface} to
+   * `'chat-completions'` for broad endpoint compatibility (official OpenAI calls
+   * default to the Responses API). Model slugs are passed through verbatim, so
+   * gateway-namespaced ids like `anthropic/claude-sonnet-4-5` or
+   * `meta-llama/llama-3.1-70b` work as `defaultModel`/`model` values — streaming
+   * and tool calling ride the same chat-completions protocol.
+   *
+   * @example
+   * ```ts
+   * // Vercel AI Gateway with a non-OpenAI model slug
+   * createOpenAIProvider({
+   *   apiKey: process.env.AI_GATEWAY_API_KEY,
+   *   baseURL: 'https://ai-gateway.vercel.sh/v1',
+   *   defaultModel: 'anthropic/claude-sonnet-4-5',
+   * });
+   * ```
+   */
+  baseURL?: string;
+  /**
+   * Default model used when chat options do not provide a model.
+   */
+  defaultModel?: string;
+  /**
+   * API surface to use for direct OpenAI calls.
+   *
+   * Defaults to Responses for official OpenAI calls. Profiles with baseURL use
+   * Chat Completions by default for OpenAI-compatible endpoint compatibility.
+   */
+  apiSurface?: TOpenAIApiSurface;
+  /**
+   * Response format (default: 'text')
+   * - 'text': Plain text response
+   * - 'json_object': JSON object mode (requires system message)
+   * - 'json_schema': Structured Outputs with schema validation
+   */
+  responseFormat?: 'text' | 'json_object' | 'json_schema';
+  /**
+   * JSON schema for structured outputs (required when responseFormat is 'json_schema')
+   */
+  jsonSchema?: IOpenAIJsonSchemaDefinition;
+  /**
+   * Responses API reasoning controls. Hidden reasoning is never exposed in message
+   * content; only explicit summaries/encrypted items requested here are represented.
+   */
+  reasoning?: IOpenAIResponsesReasoningOptions;
+  /**
+   * Whether OpenAI should store Responses API results. Defaults to OpenAI API behavior.
+   */
+  store?: boolean;
+  /**
+   * Include encrypted reasoning items for stateless reasoning continuation.
+   */
+  includeEncryptedReasoning?: boolean;
+  /**
+   * Opt into strict custom function parameter validation where supported.
+   *
+   * PROV-007: the tool schema is rewritten for strict mode on the way out — every object node,
+   * nested ones included, is closed and given a complete `required` list. That transformation is
+   * lossy, so it runs ONLY when this flag is on; with it off the schema is forwarded exactly as
+   * authored.
+   *
+   * What "lossy" means for a caller: strict mode has no way to say "optional", so a field the
+   * schema marked optional becomes required and gains a `null` branch. The model must then supply
+   * the key explicitly, with `null` standing for "not provided". A tool whose handler distinguishes
+   * an absent key from a null value will see the difference.
+   */
+  strictTools?: boolean;
+  /**
+   * Provider-native hosted web tool request from provider profile options.
+   *
+   * OpenAI-compatible Chat Completions endpoints do not support this Robota
+   * native web contract. The provider rejects unsupported configurations before
+   * any model request is sent.
+   */
+  nativeWebTools?: IOpenAINativeWebToolsOptions;
+  /**
+   * OpenAI client instance (optional: will be created from apiKey if not provided)
+   */
+  client?: OpenAI;
+  /**
+   * Payload logger instance for debugging API requests/responses
+   *
+   * Use different implementations based on your environment:
+   * - FilePayloadLogger: Node.js file-based logging
+   * - ConsolePayloadLogger: Browser console-based logging
+   * - Custom: Implement IPayloadLogger interface
+   *
+   * @example
+   * ```typescript
+   * // Node.js
+   * import { FilePayloadLogger } from '@robota-sdk/agent-provider-openai/loggers';
+   * const provider = new OpenAIProvider({
+   *   client: openaiClient,
+   *   payloadLogger: new FilePayloadLogger({ logDir: './logs/openai' })
+   * });
+   *
+   * // Browser
+   * import { ConsolePayloadLogger } from '@robota-sdk/agent-provider-openai/loggers';
+   * const provider = new OpenAIProvider({
+   *   client: openaiClient,
+   *   payloadLogger: new ConsolePayloadLogger()
+   * });
+   * ```
+   */
+  payloadLogger?: IPayloadLogger;
+  /**
+   * Optional executor for handling AI requests
+   *
+   * When provided, the provider will delegate all chat operations to this executor
+   * instead of making direct API calls. This enables remote execution capabilities.
+   *
+   * @example
+   * ```typescript
+   * import { LocalExecutor, RemoteExecutor } from '@robota-sdk/agent-core';
+   *
+   * // Local execution (registers this provider)
+   * const localExecutor = new LocalExecutor();
+   * localExecutor.registerProvider('openai', new OpenAIProvider({ apiKey: 'sk-...' }));
+   *
+   * // Remote execution
+   * const remoteExecutor = new RemoteExecutor({
+   *   serverUrl: 'https://api.robota.io',
+   *   userApiKey: 'user-token-123'
+   * });
+   *
+   * const provider = new OpenAIProvider({
+   *   executor: remoteExecutor // No direct API key needed
+   * });
+   * ```
+   */
+  executor?: IExecutor;
+  /**
+   * Logger instance for internal OpenAI provider logging
+   * @defaultValue SilentLogger
+   */
+  logger?: ILogger;
 }
-
+//#endregion
+//#region src/openai/provider.d.ts
 /**
  * OpenAI provider implementation for Robota
  *
@@ -220,30 +208,66 @@ interface IOpenAIProviderOptions {
  * @public
  */
 declare class OpenAIProvider extends AbstractAIProvider {
-    readonly name = "openai";
-    readonly version = "1.0.0";
-    private readonly client?;
-    private readonly options;
-    private readonly apiSurface;
-    private readonly payloadLogger;
-    private readonly responseParser;
-    /**
-     * Optional callback for text deltas during streaming.
-     * Set by the consumer (e.g., Session) to receive real-time text chunks.
-     * When set, chat() uses streaming internally while still returning
-     * the complete assembled message.
-     */
-    onTextDelta?: TTextDeltaCallback;
-    constructor(options: IOpenAIProviderOptions);
-    chat(messages: TUniversalMessage[], options?: IChatOptions): Promise<TUniversalMessage>;
-    chatStream(messages: TUniversalMessage[], options?: IChatOptions): AsyncIterable<TUniversalMessage>;
-    supportsTools(): boolean;
-    getCapabilities(): IProviderCapabilities;
-    validateConfig(): boolean;
-    dispose(): Promise<void>;
-    protected validateMessages(messages: TUniversalMessage[]): void;
+  readonly name = "openai";
+  readonly version = "1.0.0";
+  private readonly client?;
+  private readonly options;
+  private readonly apiSurface;
+  private readonly payloadLogger;
+  private readonly responseParser;
+  /**
+   * Optional callback for text deltas during streaming.
+   * Set by the consumer (e.g., Session) to receive real-time text chunks.
+   * When set, chat() uses streaming internally while still returning
+   * the complete assembled message.
+   */
+  onTextDelta?: TTextDeltaCallback;
+  constructor(options: IOpenAIProviderOptions);
+  chat(messages: TUniversalMessage[], options?: IChatOptions): Promise<TUniversalMessage>;
+  chatStream(messages: TUniversalMessage[], options?: IChatOptions): AsyncIterable<TUniversalMessage>;
+  private streamDirect;
+  /**
+   * CORE-043: this provider declares no capability table — nobody has verified one for OpenAI, and
+   * inventing one would be a fabricated claim. It can still answer THIS question honestly, which is
+   * why the endpoint signal is not a field on the table.
+   *
+   * It matters most here of all the providers: setting `baseURL` also switches the API surface to
+   * `chat-completions` (see `resolveApiSurface`), so the advertised gateway configuration is exactly
+   * the one where a structured request is least likely to be enforced by whatever is on the far end.
+   */
+  endpointIsVendorDefault(): boolean;
+  /**
+   * The client's own base URL is the origin every request goes to (the SDK has already applied a
+   * constructor option or `OPENAI_BASE_URL`). An executor sends elsewhere, and an injected client
+   * whose base URL cannot be read gives no origin to compare, so neither can propagate.
+   */
+  canPropagateTraceContext(): boolean;
+  private effectiveBaseUrl;
+  private traceRequestHeaders;
+  effortTable(): IProviderModelEffortTable | undefined;
+  private resolveEffortOptions;
+  /**
+   * MCP-005: strict mode's supported subset is documented; non-strict accepts standard JSON Schema.
+   * Both the Responses and Chat Completions surfaces honor `strictTools` identically (§ Profiles).
+   */
+  protected projectionProfile(): IToolSchemaProjectionProfile | undefined;
+  /**
+   * Project `chatOptions.tools` through `projectionProfile()` before either request-building module
+   * (`responses-chat.ts`, `chat-completions-chat.ts`) sees them — the module helpers receive the
+   * projected array as a parameter; `options.tools` itself is never mutated. An empty projected array
+   * (every tool quarantined) becomes `undefined` so the downstream `tools &&` truthiness checks treat
+   * it the same as "no tools", not as a zero-length `tools: []` request field.
+   */
+  private projectChatOptions;
+  private publishModelEffortOutcome;
+  supportsTools(): boolean;
+  getCapabilities(): IProviderCapabilities;
+  validateConfig(): boolean;
+  dispose(): Promise<void>;
+  protected validateMessages(messages: TUniversalMessage[]): void;
 }
-
+//#endregion
+//#region src/openai/adapter.d.ts
 /**
  * OpenAI Conversation Adapter
  *
@@ -253,55 +277,35 @@ declare class OpenAIProvider extends AbstractAIProvider {
  * @public
  */
 declare class OpenAIConversationAdapter {
-    /**
-     * Filter messages for OpenAI compatibility
-     *
-     * OpenAI has specific requirements:
-     * - Tool messages must have valid toolCallId
-     * - Messages must be in proper sequence
-     * - Tool messages without toolCallId should be excluded
-     */
-    static filterMessagesForOpenAI(messages: TUniversalMessage[]): TUniversalMessage[];
-    /**
-     * Convert TUniversalMessage array to OpenAI message format
-     * Now properly handles tool messages for OpenAI's tool calling feature
-     */
-    static toOpenAIFormat(messages: TUniversalMessage[]): OpenAI.Chat.ChatCompletionMessageParam[];
-    /**
-     * Convert a single TUniversalMessage to OpenAI format
-     * Handles all message types including tool messages
-     */
-    static convertMessage(msg: TUniversalMessage): OpenAI.Chat.ChatCompletionMessageParam;
-    /**
-     * Add system prompt to message array if needed
-     */
-    static addSystemPromptIfNeeded(messages: OpenAI.Chat.ChatCompletionMessageParam[], systemPrompt?: string): OpenAI.Chat.ChatCompletionMessageParam[];
-}
-
-interface IOpenAIModelCatalogResponse {
-    data?: readonly IOpenAIModelCatalogResource[];
-}
-interface IOpenAIModelCatalogResource {
-    id?: string;
-}
-interface IOpenAIModelCatalogFetchInit {
-    headers: Record<string, string>;
-}
-interface IOpenAIModelCatalogFetchResponse {
-    ok: boolean;
-    status: number;
-    statusText?: string;
-    json: () => Promise<IOpenAIModelCatalogResponse>;
-}
-type TOpenAIModelCatalogFetch = (url: string, init: IOpenAIModelCatalogFetchInit) => Promise<IOpenAIModelCatalogFetchResponse>;
-interface IRefreshOpenAIModelCatalogOptions {
-    fetcher?: TOpenAIModelCatalogFetch;
-    now?: () => Date;
+  /**
+   * Filter messages for OpenAI compatibility
+   *
+   * OpenAI has specific requirements:
+   * - Tool messages must have valid toolCallId
+   * - Messages must be in proper sequence
+   * - Tool messages without toolCallId should be excluded
+   */
+  static filterMessagesForOpenAI(messages: TUniversalMessage[]): TUniversalMessage[];
+  /**
+   * Convert TUniversalMessage array to OpenAI message format
+   * Now properly handles tool messages for OpenAI's tool calling feature
+   */
+  static toOpenAIFormat(messages: TUniversalMessage[]): OpenAI.Chat.ChatCompletionMessageParam[];
+  /**
+   * Convert a single TUniversalMessage to OpenAI format
+   * Handles all message types including tool messages
+   */
+  static convertMessage(msg: TUniversalMessage): OpenAI.Chat.ChatCompletionMessageParam;
+  /**
+   * Add system prompt to message array if needed
+   */
+  static addSystemPromptIfNeeded(messages: OpenAI.Chat.ChatCompletionMessageParam[], systemPrompt?: string): OpenAI.Chat.ChatCompletionMessageParam[];
 }
-declare function refreshOpenAIModelCatalog(profile: IProviderProfileConfig, options?: IRefreshOpenAIModelCatalogOptions): Promise<IProviderModelCatalog>;
-
+//#endregion
+//#region src/openai/provider-definition.d.ts
 declare const DEFAULT_OPENAI_PROVIDER_MODEL: string | undefined;
 declare const DEFAULT_OPENAI_PROVIDER_API_KEY_REFERENCE = "$ENV:OPENAI_API_KEY";
 declare function createOpenAIProviderDefinition(): IProviderDefinition;
-
-export { DEFAULT_OPENAI_PROVIDER_API_KEY_REFERENCE, DEFAULT_OPENAI_PROVIDER_MODEL, type IOpenAIJsonSchemaDefinition, type IOpenAIModelCatalogFetchInit, type IOpenAIModelCatalogFetchResponse, type IOpenAIModelCatalogResource, type IOpenAIModelCatalogResponse, type IOpenAINativeWebToolsOptions, type IOpenAIProviderOptions, type IOpenAIResponsesReasoningOptions, type IPayloadLogger, type IPayloadLoggerOptions, type IRefreshOpenAIModelCatalogOptions, OpenAIConversationAdapter, OpenAIProvider, type TOpenAIApiSurface, type TOpenAIModelCatalogFetch, type TOpenAIProviderOptionValue, createOpenAIProviderDefinition, refreshOpenAIModelCatalog };
+//#endregion
+export { DEFAULT_OPENAI_PROVIDER_API_KEY_REFERENCE, DEFAULT_OPENAI_PROVIDER_MODEL, IOpenAIJsonSchemaDefinition, IOpenAINativeWebToolsOptions, IOpenAIProviderOptions, IOpenAIResponsesReasoningOptions, type IPayloadLogger, type IPayloadLoggerOptions, OpenAIConversationAdapter, OpenAIProvider, TOpenAIApiSurface, TOpenAIProviderOptionValue, createOpenAIProviderDefinition };
+//# sourceMappingURL=index.d.cts.map

package/dist/node/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../../src/openai/types.ts","../../src/openai/provider.ts","../../src/openai/adapter.ts","../../src/openai/provider-definition.ts"],"mappings":";;;;KAIY;UAEK;EACf;EACA;EACA,SAAS,eAAe;EACxB;;UAGe;EACf;EACA;;UAGe;EACf;EACA;;;;;KAMU,4EAMR,8BACA,+BACA,mCACA,SACA,iBACA,UACA,YACA,2BACA;GACG,cAAc;;;;;UAKJ;;;;GAId,cAAc;;;;EAKf;;;;EAKA;;;;EAKA;;;;;;;EAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6BA;;;;EAKA;;;;;;;EAQA,aAAa;;;;;;;EAQb;;;;EAKA,aAAa;;;;;EAMb,YAAY;;;;EAKZ;;;;EAKA;;;;;;;;;;;;;;EAeA;;;;;;;;EASA,iBAAiB;;;;EAKjB,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;EA2BT,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;EA2BhB,WAAW;;;;;EAMX,SAAS;;;;;;;;;;;;cCrME,uBAAuB;WAChB;WACA;mBAED;mBACA;mBACA;mBACA;mBACA;;;;;;;EAQjB,cAAc;EAEF,YAAA,SAAS;EA6BN,KACb,UAAU,qBACV,UAAU,eACT,QAAQ;EAgDK,WACd,UAAU,qBACV,UAAU,eACT,cAAc;UAiCF;;;;;;;;;;EAuCf;;;;;;EASA;UAIQ;UAKA;EAKC,eAAe;UAMhB;;;;;YAcW,qBAAqB;;;;;;;;UAahC;UAYA;EAiCC;EAIA,mBAAmB;EAwBnB;EAIM,WAAW;YAIP,iBAAiB,UAAU;;;;;;;;;;;;cC/UnC;;;;;;;;;SASJ,wBAAwB,UAAU,sBAAsB;;;;;SAqBxD,eAAe,UAAU,sBAAsB,OAAO,KAAK;;;;;SAU3D,eAAe,KAAK,oBAAoB,OAAO,KAAK;;;;SA2EpD,wBACL,UAAU,OAAO,KAAK,8BACtB,wBACC,OAAO,KAAK;;;;cC1HJ;cACA;iBAeG,kCAAkC"}