@memberjunction/realtime-widget 6.2.0-edge.5 → 6.2.0-edge.7

package/dist/embed/chunks/chunk-4IZZL4GA.js

@@ -0,0 +1,2513 @@
+import {
+  IsPlainObject
+} from "./chunk-VXA62VEQ.js";
+
+// ../../AI/Core/dist/generic/baseModel.js
+var BaseResult = class {
+  get timeElapsed() {
+    return this.endTime.getTime() - this.startTime.getTime();
+  }
+  constructor(success, startTime, endTime) {
+    this.success = success;
+    this.startTime = startTime;
+    this.endTime = endTime;
+  }
+};
+var ModelUsage = class _ModelUsage {
+  /**
+   * Creates a new ModelUsage instance.
+   *
+   * @param {number} promptTokens - Number of tokens used in the prompt/input
+   * @param {number} completionTokens - Number of tokens generated in the completion/output
+   * @param {number} [cost] - Optional cost of the execution
+   * @param {string} [costCurrency] - Optional currency code for the cost (e.g., 'USD', 'EUR', 'GBP')
+   */
+  constructor(promptTokens, completionTokens, cost, costCurrency) {
+    this.cacheReadTokens = 0;
+    this.cacheWriteTokens = 0;
+    this.promptTokens = promptTokens;
+    this.completionTokens = completionTokens;
+    if (cost !== void 0) {
+      this.cost = cost;
+    }
+    if (costCurrency !== void 0) {
+      this.costCurrency = costCurrency;
+    }
+  }
+  /**
+   * Total input tokens the provider processed: uncached ({@link promptTokens}) + cache reads +
+   * cache writes. This is the figure to price at the input rate (until cache-aware per-bucket
+   * pricing is added) and equals what the provider's native "prompt token" count was before
+   * normalization. Use THIS (not promptTokens) for cost so cached tokens aren't dropped.
+   */
+  get totalInputTokens() {
+    return this.promptTokens + (this.cacheReadTokens ?? 0) + (this.cacheWriteTokens ?? 0);
+  }
+  /**
+   * Total UNCACHED tokens for the call: uncached input ({@link promptTokens}) + completion.
+   *
+   * Deliberately EXCLUDES the cache buckets so the MemberJunction invariant
+   * `TokensUsed === TokensPrompt + TokensCompletion` (enforced by AIPromptRun's CK_AIPromptRun_Tokens
+   * constraint + generated validation) continues to hold once promptTokens is net-new. The full
+   * token count INCLUDING cache is `totalInputTokens + completionTokens` — use {@link totalInputTokens}
+   * for cost so cached tokens are still billed.
+   *
+   * @returns {number} promptTokens + completionTokens
+   */
+  get totalTokens() {
+    return this.promptTokens + this.completionTokens;
+  }
+  /**
+   * Builds usage for a continuous-media execution, with the token fields zeroed.
+   *
+   * @param kind The base measure being counted — never the billing measure
+   * @param inputUnits Quantity consumed on the input side
+   * @param outputUnits Quantity produced on the output side; defaults to 0
+   */
+  static ForMedia(kind, inputUnits, outputUnits = 0) {
+    const usage = new _ModelUsage(0, 0);
+    usage.unitKind = kind;
+    usage.inputUnits = inputUnits;
+    usage.outputUnits = outputUnits;
+    return usage;
+  }
+};
+var BaseModel = class {
+  /**
+   * Only sub-classes can access the API key
+   */
+  get apiKey() {
+    return this._apiKey;
+  }
+  constructor(apiKey) {
+    if (!apiKey || apiKey.trim().length === 0)
+      console.warn("BaseModel: API key is empty, this might cause issues with model execution");
+    this._apiKey = apiKey;
+  }
+};
+
+// ../../AI/Core/dist/generic/baseRealtime.js
+function RealtimeDiagLog(message) {
+  if (typeof process === "undefined" || !process.env) {
+    return;
+  }
+  const v = (process.env.MJ_VERBOSE ?? "").toLowerCase();
+  if (v === "true" || v === "1" || v === "yes") {
+    const sanitized = message.replace(/[\r\n\p{Cc}\p{Zl}\p{Zp}]/gu, " ");
+    console.log(sanitized);
+  }
+}
+function ClampSessionSecondsValue(...candidates) {
+  let smallest;
+  for (const c of candidates) {
+    if (typeof c !== "number" || !Number.isInteger(c) || c <= 0)
+      continue;
+    if (smallest === void 0 || c < smallest)
+      smallest = c;
+  }
+  return smallest;
+}
+var BaseRealtimeModel = class extends BaseModel {
+  static {
+    this.DriverFacts = Object.freeze({});
+  }
+  /**
+   * Returns the smallest candidate that is a positive integer; see {@link ClampSessionSecondsValue}.
+   * The rule "the caller's bag wins only if smaller" lives there, once: pass the provider
+   * cap and the bag cap together.
+   */
+  ClampSessionSeconds(...candidates) {
+    return ClampSessionSecondsValue(...candidates);
+  }
+  static {
+    this.SupportsDynamicToolSet = false;
+  }
+  /**
+   * Whether this driver can mint an ephemeral, server-scoped client credential for a
+   * **client-direct** realtime session (the browser opens its own provider socket using a
+   * short-lived token the server minted).
+   *
+   * Defaults to `false`. Providers that support browser-direct sessions override this to `true`
+   * and implement {@link CreateClientSession}. The server-bridged topology (where the provider
+   * socket lives on the server, via {@link StartSession}) is supported by every driver regardless
+   * of this flag.
+   *
+   * @returns `true` if {@link CreateClientSession} is supported; `false` otherwise.
+   */
+  get SupportsClientDirect() {
+    return false;
+  }
+  /**
+   * Mints an ephemeral, server-scoped client credential plus a provider-native session config for
+   * a **client-direct** realtime session.
+   *
+   * In the client-direct topology the browser owns the provider socket (e.g. WebRTC), but the
+   * **server** still controls the prompt and tool set: it mints a short-lived token and hands back
+   * a {@link ClientRealtimeSessionConfig} whose `SessionConfig` the matching client driver applies
+   * when it opens its socket. This keeps prompt/tool authority server-side even though the media
+   * plane is client-direct.
+   *
+   * Not every provider supports this (some only expose a server-bridged socket), so this is a
+   * concrete method that throws by default rather than an abstract one — that would force every
+   * existing and future driver to implement it. Providers that support it override
+   * {@link SupportsClientDirect} to `true` and override this method.
+   *
+   * @param _params The session parameters (system prompt, tools, model, config bag).
+   * @returns A promise resolving to the minted {@link ClientRealtimeSessionConfig}.
+   * @throws Always, unless overridden by a provider that supports client-direct sessions.
+   */
+  async CreateClientSession(_params) {
+    throw new Error(`${this.constructor.name} does not support client-direct realtime sessions`);
+  }
+  /**
+   * Whether this driver's sessions carry a **video** track in addition to audio.
+   *
+   * @deprecated Nothing reads it, and no driver overrides it: it is `false` for Gemini Live, which takes camera video
+   * and renders avatars. What a session does with video is declared on its {@link IRealtimeSession.Capabilities}:
+   * {@link RealtimeSessionCapabilities.SupportedInboundTracks} for video in and
+   * {@link RealtimeSessionCapabilities.SupportedOutboundTracks} for video out, each track with its encoding. Whether a
+   * model renders a live avatar is {@link SupportsAvatarOutput}. A driver declares video there, not here.
+   *
+   * @returns `false` in every MJ driver.
+   */
+  get SupportsVideo() {
+    return false;
+  }
+  /**
+   * Whether this driver's sessions can render a live avatar for the model, on the endpoint the driver serves.
+   *
+   * Defaults to `false`: a driver whose models render no avatar says nothing more, and may ignore an avatar request. A
+   * driver that renders one for some models (Gemini Enterprise) overrides it. The client-session service reads it to
+   * tell a call or a meeting that asked for an avatar "this voice model can't show an avatar"
+   * ({@link RealtimeAvatarUnavailableReason} `'endpoint'`), whichever driver serves it.
+   *
+   * @param _model The provider's API name for the model.
+   * @returns `true` when sessions on this model can render a live avatar; `false` otherwise.
+   */
+  SupportsAvatarOutput(_model) {
+    return false;
+  }
+  /**
+   * Static fallback list of provider-native voices supported by this driver when metadata personas
+   * are not present or sparse.
+   *
+   * NOTE: Database metadata (`MJ: AI Personas` + `AI Model Personas`) is authoritative where configured.
+   * At runtime, `GetRealtimeModelVoices` unions metadata personas with this driver fallback list so that
+   * newly uncatalogued provider voices remain selectable while catalogued personas carry curated names/descriptions.
+   *
+   * @returns The supported voice ids (id + human label), or `[]` when none are declared.
+   */
+  get SupportedVoices() {
+    return [];
+  }
+};
+function ParseRealtimeClientTransport(value) {
+  return value === "direct" || value === "relay" ? value : void 0;
+}
+function ExtractToolSchedulingHint(parsed, toolName, loggerTag = "Realtime") {
+  const raw = parsed["__mj_scheduling"] ?? parsed["scheduling"];
+  if ("__mj_scheduling" in parsed) {
+    delete parsed["__mj_scheduling"];
+  }
+  if ("scheduling" in parsed) {
+    delete parsed["scheduling"];
+  }
+  if (typeof raw !== "string") {
+    return void 0;
+  }
+  const schedStr = raw.trim().toUpperCase();
+  if (schedStr.length === 0) {
+    return void 0;
+  }
+  if (schedStr === "SILENT") {
+    return "silent";
+  } else if (schedStr === "WHEN_IDLE") {
+    return "whenIdle";
+  } else if (schedStr === "INTERRUPT" || schedStr === "INTERRUPTED") {
+    return "interrupt";
+  } else {
+    console.warn(`[${loggerTag}] Unrecognized function scheduling value "${raw}" for tool "${toolName}".`);
+    return void 0;
+  }
+}
+
+// ../../AI/Core/dist/generic/chat.types.js
+var ChatMessageRole = {
+  system: "system",
+  user: "user",
+  assistant: "assistant",
+  tool: "tool"
+};
+var ChatResult = class extends BaseResult {
+};
+function ValidateToolConversation(messages) {
+  const declaredCallIds = /* @__PURE__ */ new Set();
+  const orphaned = [];
+  for (const message of messages) {
+    if (message.role === ChatMessageRole.assistant) {
+      for (const call of message.toolCalls ?? []) {
+        declaredCallIds.add(call.id);
+      }
+      continue;
+    }
+    for (const block of GetToolResultBlocks(message.content)) {
+      if (!block.toolCallId || !declaredCallIds.has(block.toolCallId)) {
+        orphaned.push(block.toolCallId ?? "(missing toolCallId)");
+      }
+    }
+  }
+  if (orphaned.length > 0) {
+    throw new Error(`Tool result(s) with no matching tool call in the conversation: ${orphaned.join(", ")}. Every tool_result must answer a call declared by an EARLIER assistant message \u2014 set ChatMessage.toolCalls from the model's ChatCompletionMessage.toolCalls when you append its reply, before appending the results.`);
+  }
+}
+function GetToolResultBlocks(content) {
+  if (typeof content === "string") {
+    return [];
+  }
+  return content.filter((block) => block.type === "tool_result");
+}
+
+// ../../AI/Core/dist/generic/cancellation.js
+var REQUEST_CANCELLED_CODE = "request_cancelled";
+var REQUEST_TIMEOUT_CODE = "request_timeout";
+var ABORT_ERROR_NAMES = /* @__PURE__ */ new Set(["AbortError", "APIUserAbortError", "RequestAbortedError"]);
+function asErrorLike(value) {
+  return value !== null && typeof value === "object" ? value : void 0;
+}
+function IsAbortError(error) {
+  const e = asErrorLike(error);
+  if (!e) {
+    return false;
+  }
+  const name = typeof e.name === "string" ? e.name : "";
+  const className = typeof e.constructor?.name === "string" ? e.constructor.name : "";
+  return ABORT_ERROR_NAMES.has(name) || ABORT_ERROR_NAMES.has(className);
+}
+function IsTimeoutAbort(signal) {
+  if (!signal?.aborted) {
+    return false;
+  }
+  const reason = asErrorLike(signal.reason);
+  return reason?.name === "TimeoutError" || reason?.IsTimeout === true;
+}
+function BuildCancellationErrorInfo(options = {}) {
+  const timedOut = IsTimeoutAbort(options.signal);
+  const reason = options.signal?.aborted ? options.signal.reason : void 0;
+  return {
+    error: options.error,
+    errorType: timedOut ? "NetworkError" : "Cancelled",
+    severity: timedOut ? "Retriable" : "Fatal",
+    canFailover: timedOut,
+    providerErrorCode: timedOut ? REQUEST_TIMEOUT_CODE : REQUEST_CANCELLED_CODE,
+    context: {
+      provider: options.provider,
+      cancelled: !timedOut,
+      reason: typeof reason === "string" ? reason : asErrorLike(reason)?.message
+    }
+  };
+}
+function DescribeCancellation(signal, subject = "Request") {
+  const verb = IsTimeoutAbort(signal) ? "timed out" : "was cancelled";
+  const reason = signal?.aborted ? signal.reason : void 0;
+  const detail = typeof reason === "string" ? reason : asErrorLike(reason)?.message;
+  return typeof detail === "string" && detail.length > 0 ? `${subject} ${verb}: ${detail}` : `${subject} ${verb}`;
+}
+
+// ../../AI/Core/dist/generic/linearTextScan.js
+function isLineTerminator(ch) {
+  return ch === "\n" || ch === "\r" || ch === "\u2028" || ch === "\u2029";
+}
+function lineEndFrom(text, from) {
+  for (let i = from; i < text.length; i++) {
+    if (isLineTerminator(text[i])) {
+      return i;
+    }
+  }
+  return text.length;
+}
+function ContainsInOrderOnOneLine(text, befores, afters) {
+  let lineStart = 0;
+  while (lineStart <= text.length) {
+    const lineEnd = lineEndFrom(text, lineStart);
+    const line = text.slice(lineStart, lineEnd);
+    for (const before of befores) {
+      const at = line.indexOf(before);
+      if (at < 0) {
+        continue;
+      }
+      for (const after of afters) {
+        if (line.indexOf(after, at + before.length) >= 0) {
+          return true;
+        }
+      }
+    }
+    lineStart = lineEnd + 1;
+  }
+  return false;
+}
+function FirstBraceSpanOnOneLine(text) {
+  let searchFrom = 0;
+  while (searchFrom < text.length) {
+    const open = text.indexOf("{", searchFrom);
+    if (open < 0) {
+      return null;
+    }
+    const lineEnd = lineEndFrom(text, open);
+    const line = text.slice(open, lineEnd);
+    const close = line.lastIndexOf("}");
+    if (close > 0) {
+      return line.slice(0, close + 1);
+    }
+    searchFrom = lineEnd + 1;
+  }
+  return null;
+}
+
+// ../../AI/Core/dist/generic/errorAnalyzer.js
+var ErrorAnalyzer = class {
+  /**
+   * Analyzes an error from an AI provider and returns standardized error information.
+   * This method extracts relevant details from provider-specific error formats and
+   * maps them to a consistent structure for easier handling.
+   *
+   * @static
+   * @param {any} error - The error object thrown by the provider SDK
+   * @param {string} [providerName] - Optional name of the provider for context
+   * @returns {AIErrorInfo} Standardized error information
+   *
+   * @example
+   * ```typescript
+   * const errorInfo = ErrorAnalyzer.analyzeError(error, 'Anthropic');
+   * console.log(`Error type: ${errorInfo.errorType}`);
+   * console.log(`Can retry: ${errorInfo.severity !== 'Fatal'}`);
+   * ```
+   */
+  static AnalyzeError(error, providerName) {
+    const carried = this.carriedErrorInfo(error);
+    if (carried) {
+      return carried;
+    }
+    const httpStatusCode = this.extractHttpStatusCode(error);
+    const errorType = this.determineErrorType(error, httpStatusCode);
+    const severity = this.determineSeverity(errorType);
+    const canFailover = this.canFailoverForError(errorType);
+    const suggestedRetryDelaySeconds = this.extractRetryDelay(error);
+    const providerErrorCode = this.extractProviderErrorCode(error);
+    if (providerErrorCode === "context_length_exceeded") {
+      return {
+        error,
+        httpStatusCode,
+        errorType: "ContextLengthExceeded",
+        severity: "Fatal",
+        canFailover: true,
+        suggestedRetryDelaySeconds,
+        providerErrorCode,
+        context: {
+          provider: providerName,
+          errorName: error?.name,
+          errorConstructor: error?.constructor?.name
+        }
+      };
+    }
+    return {
+      error,
+      httpStatusCode,
+      errorType,
+      severity,
+      canFailover,
+      suggestedRetryDelaySeconds,
+      providerErrorCode,
+      context: {
+        provider: providerName,
+        errorName: error?.name,
+        errorConstructor: error?.constructor?.name
+      }
+    };
+  }
+  /** @deprecated Use {@link AnalyzeError}. */
+  static analyzeError(error, providerName) {
+    return this.AnalyzeError(error, providerName);
+  }
+  /**
+   * The classification a failed result already carries on `errorInfo`, if it has a complete one.
+   */
+  static carriedErrorInfo(error) {
+    const info = error?.errorInfo;
+    return info && typeof info.errorType === "string" && typeof info.severity === "string" && typeof info.canFailover === "boolean" ? info : void 0;
+  }
+  /**
+   * Extracts HTTP status code from various error object structures.
+   * Different provider SDKs store status codes in different locations.
+   *
+   * @private
+   * @static
+   * @param {any} error - The error object to extract status code from
+   * @returns {number | undefined} The HTTP status code if found, undefined otherwise
+   */
+  static extractHttpStatusCode(error) {
+    const candidates = [error?.status, error?.statusCode, error?.response?.status, error?.response?.statusCode, error?.code];
+    return candidates.find((c) => typeof c === "number" && c >= 100 && c <= 599);
+  }
+  static {
+    this.TRANSPORT_ERROR_CODES = /* @__PURE__ */ new Set([
+      "ECONNREFUSED",
+      "ECONNRESET",
+      "ECONNABORTED",
+      "EPIPE",
+      "ETIMEDOUT",
+      "ENOTFOUND",
+      "EAI_AGAIN",
+      "ENETUNREACH",
+      "ENETDOWN",
+      "EHOSTUNREACH",
+      "EHOSTDOWN",
+      "UND_ERR_SOCKET",
+      "UND_ERR_CLOSED",
+      "UND_ERR_CONNECT_TIMEOUT",
+      "UND_ERR_HEADERS_TIMEOUT",
+      "UND_ERR_BODY_TIMEOUT"
+    ]);
+  }
+  static {
+    this.MAX_CAUSE_DEPTH = 5;
+  }
+  /**
+   * Whether the error is a connection failure that its message does not name. Node's fetch
+   * reports one as `TypeError: fetch failed` (or `terminated` when the socket closes mid-response)
+   * and keeps the real reason — `ECONNRESET`, `ENOTFOUND` — on `cause`. SDKs built on fetch,
+   * such as `@google/genai`, rethrow that error unchanged, so the message alone reads as unknown.
+   *
+   * A plain `AbortError` is deliberately not a transport failure: it is also what a caller's
+   * cancellation looks like, and a cancellation must not fail over.
+   */
+  static isTransportFailure(error) {
+    return this.causeChain(error).some((link) => typeof link.code === "string" && this.TRANSPORT_ERROR_CODES.has(link.code) || link.name === "TypeError" && (link.message === "fetch failed" || link.message === "terminated"));
+  }
+  /** The error followed by each `cause` beneath it, stopping at a non-error, a cycle or the depth limit. */
+  static causeChain(error) {
+    const chain = [];
+    let current = error;
+    while (current instanceof Error && chain.length < this.MAX_CAUSE_DEPTH && !chain.includes(current)) {
+      chain.push(current);
+      current = current.cause;
+    }
+    return chain;
+  }
+  /**
+   * Determines the standardized error type based on status code and error properties.
+   * Uses a combination of HTTP status codes, error messages, and error class names.
+   *
+   * @private
+   * @static
+   * @param {any} error - The error object to analyze
+   * @param {number} [statusCode] - The HTTP status code if available
+   * @returns {AIErrorType} The categorized error type
+   */
+  static determineErrorType(error, statusCode) {
+    if (IsAbortError(error) || error?.code === REQUEST_CANCELLED_CODE) {
+      return "Cancelled";
+    }
+    const errorString = (error?.message || error?.name || "").toLowerCase();
+    if (errorString.includes("context_length_exceeded") || errorString.includes("context length exceeded") || errorString.includes("reduce the length of the messages") || errorString.includes("maximum context length")) {
+      return "ContextLengthExceeded";
+    }
+    if (errorString.includes("rate limit") || errorString.includes("too many requests")) {
+      return "RateLimit";
+    }
+    if (errorString.includes("credit") || // xAI "no credits" errors
+    errorString.includes("billing") || // Generic billing issues
+    errorString.includes("payment") || // Payment required errors
+    errorString.includes("insufficient funds") || errorString.includes("quota exceeded") || errorString.includes("usage limits") || // Anthropic spend cap — sent as a 400 invalid_request_error, which the status fallback would misread as a malformed request
+    errorString.includes("balance") || // Account balance issues
+    errorString.includes("no funds")) {
+      return "NoCredit";
+    }
+    if (errorString.includes("no suitable model found") || errorString.includes("no credentials found") || errorString.includes("no api keys found")) {
+      return "NoCredentials";
+    }
+    if (errorString.includes("unauthorized") || errorString.includes("authentication failed") || errorString.includes("invalid api key") || errorString.includes("invalid key") || errorString.includes("api key is invalid") || // Google: HTTP 400 "API key not valid. Please pass a valid API key." with reason
+    // API_KEY_INVALID. None of the phrases above match it, so it fell through to the
+    // permissive VendorValidationError and failed over to another vendor instead of failing.
+    errorString.includes("api key not valid") || errorString.includes("api_key_invalid") || // Google's expired key: HTTP 400 "API key expired. Please renew the API key." with reason
+    // API_KEY_EXPIRED. It read as InvalidRequest, which stops failover with the wrong reason.
+    errorString.includes("api key expired") || errorString.includes("api_key_expired")) {
+      return "Authentication";
+    }
+    if (errorString.includes("service unavailable") || errorString.includes("service is down") || errorString.includes("maintenance") || errorString.includes("temporarily unavailable")) {
+      return "ServiceUnavailable";
+    }
+    if (errorString.includes("network") || errorString.includes("timeout") || errorString.includes("econnrefused") || errorString.includes("dns") || errorString.includes("connection reset") || this.isTransportFailure(error)) {
+      return "NetworkError";
+    }
+    if (errorString.includes("model") && (errorString.includes("not found") || errorString.includes("does not exist") || errorString.includes("overloaded") || errorString.includes("not available"))) {
+      return "ModelError";
+    }
+    if (errorString.includes("required") || errorString.includes("validation") || errorString.includes("schema") || // "X is required" is already covered by includes('required') above.
+    // Linear scans rather than /missing.*(?:field|property)/ and its reverse, which are polynomial
+    // on provider-controlled text (CodeQL js/polynomial-redos).
+    ContainsInOrderOnOneLine(errorString, ["missing"], ["field", "property"]) || // "missing field/property X"
+    ContainsInOrderOnOneLine(errorString, ["field", "property"], ["missing"]) || // "field/property X missing"
+    /must\s+(?:be|have|contain)/.test(errorString)) {
+      return "VendorValidationError";
+    }
+    if (errorString.includes("malformed json") || errorString.includes("invalid json") || errorString.includes("json parse") || errorString.includes("syntax error") || errorString.includes("malformed request")) {
+      return "InvalidRequest";
+    }
+    if (errorString.includes("invalid request") || errorString.includes("bad request")) {
+      return "VendorValidationError";
+    }
+    const errorTypeName = error?.constructor?.name || error?.name || "";
+    if (errorTypeName.includes("RateLimit"))
+      return "RateLimit";
+    if (errorTypeName.includes("Authentication"))
+      return "Authentication";
+    if (errorTypeName.includes("APIError") && statusCode === 500)
+      return "InternalServerError";
+    if (statusCode) {
+      switch (statusCode) {
+        case 429:
+          return "RateLimit";
+        case 401:
+          return "Authentication";
+        case 403:
+          return "ServiceUnavailable";
+        case 503:
+          return "ServiceUnavailable";
+        case 500:
+        case 502:
+        case 504:
+          return "InternalServerError";
+        case 400:
+        case 422:
+          return "InvalidRequest";
+      }
+    }
+    return "Unknown";
+  }
+  /**
+   * Determines the error severity based on the error type.
+   * This helps decide whether to retry immediately, wait, or fail permanently.
+   *
+   * @private
+   * @static
+   * @param {AIErrorType} errorType - The categorized error type
+   * @returns {ErrorSeverity} The severity level of the error
+   */
+  static determineSeverity(errorType) {
+    switch (errorType) {
+      case "RateLimit":
+      case "NoCredit":
+      // Billing/credit errors are retriable with another provider
+      case "ServiceUnavailable":
+      case "NetworkError":
+      case "VendorValidationError":
+        return "Retriable";
+      case "InternalServerError":
+      case "ModelError":
+        return "Transient";
+      case "Authentication":
+      case "NoCredentials":
+      // No credentials configured - cannot resolve by retrying
+      case "InvalidRequest":
+        return "Fatal";
+      case "ContextLengthExceeded":
+        return "Fatal";
+      case "Cancelled":
+        return "Fatal";
+      default:
+        return "Transient";
+    }
+  }
+  /**
+   * Determines whether an error can potentially be resolved by switching providers.
+   *
+   * Strategy: We're permissive with failover - most errors should allow trying another
+   * provider/model since vendors may use different status codes and error messages.
+   * Only block failover for clear client-side structural errors that won't be fixed by switching.
+   *
+   * @private
+   * @static
+   * @param {AIErrorType} errorType - The categorized error type
+   * @returns {boolean} True if failover might help, false otherwise
+   */
+  static canFailoverForError(errorType) {
+    switch (errorType) {
+      // Provider-specific errors - ALWAYS allow failover
+      case "RateLimit":
+      // Different provider may have capacity
+      case "NoCredit":
+      // Different provider may have credits/quota
+      case "ServiceUnavailable":
+      // Different provider may be available
+      case "InternalServerError":
+      // Different provider may be stable
+      case "NetworkError":
+      // Different provider/region may be reachable
+      case "ModelError":
+      // Different provider may have working model
+      case "ContextLengthExceeded":
+      // Different model may have larger context
+      case "Authentication":
+      // Different vendor may have valid API key
+      case "VendorValidationError":
+        return true;
+      // Clear client-side structural/configuration errors - DO NOT failover (won't help)
+      case "InvalidRequest":
+      // Malformed JSON/syntax won't work anywhere
+      case "NoCredentials":
+      // No credentials configured for ANY provider - failover won't help
+      case "Cancelled":
+        return false;
+      // Unknown errors - DEFAULT to allowing failover (permissive approach)
+      default:
+        return true;
+    }
+  }
+  /**
+   * Extracts suggested retry delay from error response.
+   * Looks for Retry-After headers and provider-specific retry delay fields.
+   *
+   * @private
+   * @static
+   * @param {any} error - The error object to extract retry delay from
+   * @returns {number | undefined} Suggested retry delay in seconds, or undefined
+   */
+  static extractRetryDelay(error) {
+    const retryAfter = error?.response?.headers?.["retry-after"] || error?.headers?.["retry-after"];
+    if (retryAfter) {
+      const seconds = parseInt(retryAfter);
+      if (!isNaN(seconds)) {
+        return seconds;
+      }
+      return 60;
+    }
+    if (error?.retryDelay) {
+      return error.retryDelay;
+    }
+    const statusCode = this.extractHttpStatusCode(error);
+    if (statusCode === 429) {
+      return 30;
+    }
+    return void 0;
+  }
+  /**
+   * Extracts the provider-specific error code from the error object.
+   * Different providers store error codes in different locations.
+   *
+   * @private
+   * @static
+   * @param {any} error - The error object to extract provider code from
+   * @returns {string | undefined} The provider error code if found, undefined otherwise
+   */
+  static extractProviderErrorCode(error) {
+    const code = error?.code || error?.errorCode || error?.error?.code || error?.response?.data?.error?.code || void 0;
+    if (code) {
+      return code;
+    }
+    const errorMessage = error?.message || error?.errorMessage || "";
+    if (errorMessage.includes("{") && errorMessage.includes("}")) {
+      try {
+        const jsonSpan = FirstBraceSpanOnOneLine(errorMessage);
+        if (jsonSpan) {
+          const parsed = JSON.parse(jsonSpan);
+          return parsed?.error?.code || parsed?.code || void 0;
+        }
+      } catch (parseError) {
+      }
+    }
+    return void 0;
+  }
+};
+
+// ../../AI/Core/dist/generic/baseLLM.js
+var BaseLLM = class extends BaseModel {
+  constructor() {
+    super(...arguments);
+    this._additionalSettings = {};
+    this.thinkingStreamState = null;
+  }
+  static {
+    this.ReplayedReasoningRequiresStablePrefix = false;
+  }
+  /**
+   * Get the current additional settings
+   */
+  get AdditionalSettings() {
+    return this._additionalSettings;
+  }
+  /**
+   * Set additional provider-specific settings
+   * Subclasses should override this method to validate required settings
+   *
+   * @param settings Provider-specific settings
+   */
+  SetAdditionalSettings(settings) {
+    this._additionalSettings = { ...this._additionalSettings, ...settings };
+  }
+  /**
+   * Clear all additional settings
+   * This is useful for resetting the state of the provider
+   * or when switching between different configurations.
+   */
+  ClearAdditionalSettings() {
+    this._additionalSettings = {};
+  }
+  /**
+   * Process a chat completion request. If streaming is enabled and supported,
+   * this will route to the streaming implementation.
+   */
+  async ChatCompletion(params) {
+    if (params.enableCaching === void 0) {
+      params.enableCaching = true;
+    }
+    if (this.SupportsTools) {
+      ValidateToolConversation(params.messages);
+    }
+    const toolsRequested = this.SupportsTools && params.tools != null && params.tools.length > 0;
+    const streamingSuppressedForTools = toolsRequested && params.streaming === true;
+    const signal = params.cancellationToken;
+    if (signal?.aborted) {
+      return this.BuildCancelledChatResult(/* @__PURE__ */ new Date(), { signal });
+    }
+    if (params.streaming && params.streamingCallbacks && this.SupportsStreaming && !streamingSuppressedForTools) {
+      return this.handleStreamingChatCompletion(params);
+    }
+    const startTime = /* @__PURE__ */ new Date();
+    let result;
+    try {
+      result = await this.nonStreamingChatCompletion(params);
+    } catch (error) {
+      if (this.IsCancellationError(error, signal)) {
+        return this.BuildCancelledChatResult(startTime, { error, signal });
+      }
+      throw error;
+    }
+    if (!result.success && signal?.aborted) {
+      return this.BuildCancelledChatResult(result.startTime ?? startTime, { error: result.exception, signal, message: result.errorMessage });
+    }
+    if (streamingSuppressedForTools) {
+      result.modelSpecificResponseDetails = {
+        ...result.modelSpecificResponseDetails,
+        streamingSuppressedForTools: true
+      };
+    }
+    return result;
+  }
+  /**
+   * Process multiple chat completion requests in parallel. This is useful for:
+   * - Generating multiple variations with different parameters (temperature, etc.)
+   * - Getting multiple responses to compare or select from
+   * - Improving reliability by sending the same request multiple times
+   *
+   * @param paramsArray Array of chat completion parameter objects
+   * @param callbacks Optional callbacks for progress and individual completions
+   * @returns Promise resolving to an array of ChatResults in the same order as the input params
+   */
+  async ChatCompletions(paramsArray, callbacks) {
+    if (!paramsArray || paramsArray.length === 0) {
+      return [];
+    }
+    const promises = paramsArray.map((params, index) => this.ChatCompletion(params).then((response) => {
+      if (callbacks?.OnCompletion) {
+        callbacks.OnCompletion(response, index);
+      }
+      return response;
+    }).catch((error) => {
+      if (callbacks?.OnError) {
+        callbacks.OnError(error, index);
+      }
+      throw error;
+    }));
+    const results = await Promise.allSettled(promises);
+    const chatResults = results.map((result, index) => {
+      if (result.status === "fulfilled") {
+        return result.value;
+      } else {
+        const startTime = /* @__PURE__ */ new Date();
+        const endTime = /* @__PURE__ */ new Date();
+        const errorResult = new ChatResult(false, startTime, endTime);
+        errorResult.data = {
+          choices: [],
+          usage: new ModelUsage(0, 0)
+        };
+        errorResult.statusText = "error";
+        errorResult.errorMessage = result.reason?.message || "Unknown error";
+        errorResult.exception = { exception: result.reason };
+        errorResult.errorInfo = ErrorAnalyzer.analyzeError(result.reason, this.constructor.name);
+        return errorResult;
+      }
+    });
+    if (callbacks?.OnAllCompleted) {
+      callbacks.OnAllCompleted(chatResults);
+    }
+    return chatResults;
+  }
+  /**
+   * Check if this provider supports streaming
+   * @returns true if streaming is supported, false otherwise
+   */
+  get SupportsStreaming() {
+    return false;
+  }
+  /**
+   * Whether this driver implements native tool/function calling — i.e. whether it maps
+   * `ChatParams.tools` onto its SDK and normalizes tool calls back into
+   * `ChatCompletionMessage.toolCalls`.
+   *
+   * This is a CODE-level capability ("has the mapping been written for this driver?"), distinct
+   * from the METADATA-level capability `ModelConfiguration.LLM.SupportsNativeToolCalling`
+   * ("does this model, on this vendor, support tools at all?"). Both must hold for native mode.
+   *
+   * A driver returning false ignores any `tools` passed to it and records the fact in the
+   * result's `modelSpecificResponseDetails` — the prompt runner's gate should keep that from
+   * happening, but the layer is safe standalone.
+   */
+  get SupportsTools() {
+    return false;
+  }
+  /**
+   * Whether this LLM provider supports assistant prefill (pre-seeding the start of the model's response).
+   * Providers that support prefill should override this to return true.
+   * This is used as a code-level default when database metadata (AIModelType/AIModel/AIModelVendor.SupportsPrefill)
+   * is null. Database values of true/false override this getter.
+   */
+  get SupportsPrefill() {
+    return false;
+  }
+  /**
+   * Whether a message is framework-authored volatile state for this request only: the loop agent's
+   * trailing runtime-state fragment (date/time, scratchpad, payload, a relocated specialization),
+   * which is rebuilt every iteration and must never sit inside a provider's cached prefix.
+   *
+   * The base test is the {@link VolatileStateMessageMetadata.volatileState} flag the agent layer
+   * sets. A driver may override to recognise the message by other means (Anthropic also accepts
+   * the fragment's tag literal for callers that pass plain text), but should call `super` first.
+   */
+  isVolatileStateMessage(message) {
+    const metadata = message?.metadata;
+    return metadata?.volatileState === true;
+  }
+  /**
+   * Index of the trailing volatile-state message in an outgoing request, or -1 when there is none.
+   * The fragment is the LAST message, or the one before it when an assistant prefill has been
+   * appended after it. -1 is also returned when nothing precedes the fragment, because then there
+   * is no stable history for a provider to cache ahead of it.
+   */
+  trailingVolatileStateIndex(messages) {
+    const last = messages.length - 1;
+    if (last >= 1 && this.isVolatileStateMessage(messages[last])) {
+      return last;
+    }
+    if (last >= 2 && messages[last].role === ChatMessageRole.assistant && this.isVolatileStateMessage(messages[last - 1])) {
+      return last - 1;
+    }
+    return -1;
+  }
+  /**
+   * Splits an outgoing request around its trailing volatile-state message, so a driver can place
+   * its cache boundary on the last message of `head` and send `tail` uncached. Returns null when the
+   * request has no trailing volatile state, in which case the driver formats the whole list as usual.
+   * Neither array is a copy of the input's messages; only the list is new.
+   */
+  splitTrailingVolatileState(messages) {
+    const index = this.trailingVolatileStateIndex(messages);
+    if (index < 1) {
+      return null;
+    }
+    return { head: messages.slice(0, index), tail: messages.slice(index) };
+  }
+  /**
+   * Returns the native file input capabilities of this LLM driver, or null if
+   * the driver does not support file attachments. Subclasses that accept files
+   * (PDFs, images, etc.) should override this method.
+   */
+  GetFileCapabilities() {
+    return null;
+  }
+  /**
+   * Template method for handling streaming chat completion
+   * This implements the common pattern across providers while delegating
+   * provider-specific logic to abstract methods.
+   */
+  async handleStreamingChatCompletion(params) {
+    const startTime = /* @__PURE__ */ new Date();
+    this.resetStreamingState();
+    return new Promise((resolve, reject) => {
+      (async () => {
+        try {
+          const stream = await this.createStreamingRequest(params);
+          let accumulatedContent = "";
+          let lastChunk = null;
+          let usage = {
+            promptTokens: 0,
+            completionTokens: 0,
+            totalTokens: 0
+          };
+          if (!stream) {
+            throw new Error("Stream is null or undefined");
+          }
+          try {
+            for await (const chunk of stream) {
+              if (chunk) {
+                const processed = this.processStreamingChunk(chunk);
+                if (processed?.content) {
+                  accumulatedContent += processed.content;
+                  if (params.streamingCallbacks?.OnContent) {
+                    params.streamingCallbacks.OnContent(processed.content, false);
+                  }
+                }
+                lastChunk = chunk;
+                if (processed?.usage) {
+                  usage = processed.usage;
+                }
+              }
+            }
+          } catch (streamError) {
+            if (!params.cancellationToken?.aborted) {
+              throw streamError;
+            }
+          }
+          if (params.cancellationToken?.aborted) {
+            this.settleCancelledStream(params, this.BuildCancelledChatResult(startTime, { signal: params.cancellationToken }), resolve);
+            return;
+          }
+          const thinkingRemainder = this.flushThinkingStreamRemainder();
+          if (thinkingRemainder) {
+            accumulatedContent += thinkingRemainder;
+            if (params.streamingCallbacks?.OnContent) {
+              params.streamingCallbacks.OnContent(thinkingRemainder, false);
+            }
+          }
+          if (params.streamingCallbacks?.OnContent) {
+            params.streamingCallbacks.OnContent("", true);
+          }
+          const endTime = /* @__PURE__ */ new Date();
+          const result = this.finalizeStreamingResponse(accumulatedContent, lastChunk, usage);
+          if (!result) {
+            throw new Error("Failed to create result");
+          }
+          result.startTime = startTime;
+          result.endTime = endTime;
+          if (params.streamingCallbacks?.OnComplete) {
+            params.streamingCallbacks.OnComplete(result);
+          }
+          resolve(result);
+        } catch (error) {
+          if (this.IsCancellationError(error, params.cancellationToken)) {
+            this.settleCancelledStream(params, this.BuildCancelledChatResult(startTime, { error, signal: params.cancellationToken }), resolve);
+            return;
+          }
+          if (params.streamingCallbacks?.OnError) {
+            params.streamingCallbacks.OnError(error);
+          }
+          const endTime = /* @__PURE__ */ new Date();
+          const errorResult = new ChatResult(false, startTime, endTime);
+          errorResult.data = {
+            choices: [],
+            usage: new ModelUsage(0, 0)
+          };
+          errorResult.statusText = "error";
+          errorResult.errorMessage = error?.message || "Unknown error";
+          errorResult.exception = { exception: error };
+          errorResult.errorInfo = ErrorAnalyzer.analyzeError(error, this.constructor.name);
+          reject(errorResult);
+        } finally {
+          try {
+            this.resetStreamingState();
+          } catch {
+          }
+        }
+      })();
+    });
+  }
+  /**
+   * Hook invoked at the start AND end (in `finally`) of every streaming chat
+   * completion to reset per-request streaming state. Default is a no-op;
+   * providers that maintain instance-level streaming state (e.g., Anthropic /
+   * OpenAI thinking-block accumulators) MUST override this. See audit R2-C5
+   * for context — without this, state from a prior request bleeds into the
+   * next one and accumulated buffers grow unbounded across the singleton's
+   * lifetime.
+   */
+  resetStreamingState() {
+  }
+  /**
+   * Settles a cancelled stream: resolves the request first, then tells `OnComplete`. A callback that
+   * throws is logged, never allowed to leave the request unsettled.
+   */
+  settleCancelledStream(params, cancelled, resolve) {
+    resolve(cancelled);
+    try {
+      params.streamingCallbacks?.OnComplete?.(cancelled);
+    } catch (callbackError) {
+      console.error("OnComplete threw for a cancelled stream:", callbackError);
+    }
+  }
+  /**
+   * Whether a request ended because it was aborted: its signal is aborted, the error is an abort by
+   * name (`AbortError`, `APIUserAbortError`, `RequestAbortedError`), or {@link IsProviderAbortError}
+   * recognizes it.
+   */
+  IsCancellationError(error, signal) {
+    return signal?.aborted === true || IsAbortError(error) || this.IsProviderAbortError(error);
+  }
+  /**
+   * Recognizes an abort error the shared names miss. A driver whose SDK raises its own class for an
+   * aborted request overrides this. Default: false.
+   */
+  IsProviderAbortError(_error) {
+    return false;
+  }
+  /**
+   * The result of a cancelled request, the same for every driver: a failed result with no choices,
+   * `statusText` `'cancelled'`, and an `errorInfo` that says `Cancelled` (Fatal, never failed over) —
+   * or, when the signal was aborted by a timeout, a retriable `NetworkError`.
+   *
+   * @param options.error The error the abort raised, kept on `exception`.
+   * @param options.signal The request's abort signal, read for why it was aborted.
+   * @param options.message The message to report; defaults to one naming the signal's reason.
+   */
+  BuildCancelledChatResult(startTime, options = {}) {
+    const result = new ChatResult(false, startTime, /* @__PURE__ */ new Date());
+    result.data = {
+      choices: [],
+      usage: new ModelUsage(0, 0)
+    };
+    result.statusText = "cancelled";
+    result.errorMessage = options.message || DescribeCancellation(options.signal);
+    result.exception = options.error;
+    result.errorInfo = BuildCancellationErrorInfo({ error: options.error, signal: options.signal, provider: this.constructor.name });
+    return result;
+  }
+  /**
+   * Check if the provider supports thinking models
+   * Providers should override this to return true if they support thinking extraction
+   */
+  supportsThinkingModels() {
+    return false;
+  }
+  /**
+   * Get the thinking tag format for this provider
+   * Providers can override this to customize the thinking tag format
+   */
+  getThinkingTagFormat() {
+    return { open: "<think>", close: "</think>" };
+  }
+  /**
+   * Extract thinking content from non-streaming content
+   * This method handles case-insensitive extraction of thinking blocks
+   */
+  extractThinkingFromContent(content) {
+    if (!content)
+      return {
+        content,
+        thinking: void 0
+      };
+    let processedContent = content.trim();
+    let thinkingContent = void 0;
+    const tags = this.getThinkingTagFormat();
+    const openTagLower = tags.open.toLowerCase();
+    const closeTagLower = tags.close.toLowerCase();
+    const contentLower = processedContent.toLowerCase();
+    if (contentLower.startsWith(openTagLower) && contentLower.includes(closeTagLower)) {
+      const thinkStart = tags.open.length;
+      const thinkEndIndex = contentLower.indexOf(closeTagLower);
+      if (thinkEndIndex !== -1) {
+        thinkingContent = processedContent.substring(thinkStart, thinkEndIndex).trim();
+        processedContent = processedContent.substring(thinkEndIndex + tags.close.length).trim();
+      }
+    }
+    return { content: processedContent, thinking: thinkingContent };
+  }
+  /**
+   * Initialize thinking stream state for streaming extraction
+   */
+  initializeThinkingStreamState() {
+    this.thinkingStreamState = {
+      accumulatedThinking: "",
+      inThinkingBlock: false,
+      pendingContent: "",
+      thinkingComplete: false
+    };
+  }
+  /**
+   * Reset thinking stream state
+   */
+  resetThinkingStreamState() {
+    this.thinkingStreamState = null;
+  }
+  /**
+   * Returns (and clears) any user-visible content the thinking-tag stripper is still holding back at
+   * the end of a stream. Mid-stream, {@link processStreamChunkWithThinking} holds back a trailing
+   * fragment that could be the start of a `<think>`/`</think>` tag so a split tag never leaks as
+   * partial text; once the stream ends, such a fragment is real content and must be emitted (bug A5).
+   *
+   * Only flushes when NOT inside a thinking block: an unterminated `<think>` block's buffered text is
+   * reasoning, not answer, and is left held back (never surfaced as visible content). Returns `''`
+   * when thinking extraction isn't active (no state) or there's nothing to flush.
+   */
+  flushThinkingStreamRemainder() {
+    const state = this.thinkingStreamState;
+    if (!state || state.inThinkingBlock) {
+      return "";
+    }
+    const remainder = state.pendingContent;
+    state.pendingContent = "";
+    return remainder;
+  }
+  /**
+   * Process streaming chunk with thinking extraction
+   * This method handles case-insensitive extraction across chunk boundaries
+   */
+  processStreamChunkWithThinking(rawContent) {
+    if (!this.thinkingStreamState) {
+      return rawContent;
+    }
+    let contentToEmit = "";
+    this.thinkingStreamState.pendingContent += rawContent;
+    if (this.thinkingStreamState.thinkingComplete) {
+      contentToEmit = this.thinkingStreamState.pendingContent;
+      this.thinkingStreamState.pendingContent = "";
+      return contentToEmit;
+    }
+    const tags = this.getThinkingTagFormat();
+    const pending = this.thinkingStreamState.pendingContent;
+    const pendingLower = pending.toLowerCase();
+    if (!this.thinkingStreamState.inThinkingBlock && pendingLower.includes(tags.open.toLowerCase())) {
+      const thinkStartIndex = pendingLower.indexOf(tags.open.toLowerCase());
+      if (thinkStartIndex > 0) {
+        contentToEmit = pending.substring(0, thinkStartIndex);
+        this.thinkingStreamState.pendingContent = pending.substring(thinkStartIndex);
+        return contentToEmit;
+      }
+      this.thinkingStreamState.inThinkingBlock = true;
+      this.thinkingStreamState.pendingContent = pending.substring(tags.open.length);
+    }
+    if (this.thinkingStreamState.inThinkingBlock) {
+      const pendingInBlockLower = this.thinkingStreamState.pendingContent.toLowerCase();
+      const thinkEndIndex = pendingInBlockLower.indexOf(tags.close.toLowerCase());
+      if (thinkEndIndex !== -1) {
+        this.thinkingStreamState.accumulatedThinking += this.thinkingStreamState.pendingContent.substring(0, thinkEndIndex);
+        this.thinkingStreamState.pendingContent = this.thinkingStreamState.pendingContent.substring(thinkEndIndex + tags.close.length);
+        this.thinkingStreamState.inThinkingBlock = false;
+        this.thinkingStreamState.thinkingComplete = true;
+        return this.processStreamChunkWithThinking("");
+      } else {
+        const closeHoldBack = this.partialTagSuffixLength(this.thinkingStreamState.pendingContent, tags.close);
+        const closeCut = this.thinkingStreamState.pendingContent.length - closeHoldBack;
+        this.thinkingStreamState.accumulatedThinking += this.thinkingStreamState.pendingContent.substring(0, closeCut);
+        this.thinkingStreamState.pendingContent = this.thinkingStreamState.pendingContent.substring(closeCut);
+        return "";
+      }
+    }
+    const openHoldBack = this.partialTagSuffixLength(this.thinkingStreamState.pendingContent, tags.open);
+    let emitEnd = this.avoidSurrogateSplit(this.thinkingStreamState.pendingContent, this.thinkingStreamState.pendingContent.length - openHoldBack);
+    contentToEmit = this.thinkingStreamState.pendingContent.substring(0, emitEnd);
+    this.thinkingStreamState.pendingContent = this.thinkingStreamState.pendingContent.substring(emitEnd);
+    return contentToEmit;
+  }
+  /**
+   * Returns the length of the longest suffix of `text` that is a non-empty prefix of `tag`
+   * (case-insensitive). Used to detect a tag that may be split across streaming chunk
+   * boundaries so the caller can hold that partial fragment back instead of emitting it.
+   * Returns 0 when no suffix of `text` is a prefix of `tag`.
+   */
+  partialTagSuffixLength(text, tag) {
+    if (!text || !tag) {
+      return 0;
+    }
+    const t = text.toLowerCase();
+    const g = tag.toLowerCase();
+    const max = Math.min(t.length, g.length - 1);
+    for (let len = max; len > 0; len--) {
+      if (t.endsWith(g.substring(0, len))) {
+        return len;
+      }
+    }
+    return 0;
+  }
+  /**
+   * Defensive guard for the tag hold-back: if the emit/hold boundary would fall *between* the two
+   * halves of a UTF-16 surrogate pair (which renders as U+FFFD), move the cut back by one so the
+   * full pair stays together in the held-back remainder. In the common case the held-back fragment
+   * is an ASCII tag prefix (e.g. "<thi"), so `cut` lands on an ASCII boundary and this is a no-op;
+   * it only bites when a hold-back boundary happens to land mid-pair. Note it does NOT hold back a
+   * lone trailing high surrogate when nothing else is being held back (holdBack === 0) — a pair
+   * split exactly at a streaming chunk boundary is left to render and is corrected by the next chunk.
+   */
+  avoidSurrogateSplit(text, cut) {
+    if (cut > 0 && cut < text.length) {
+      const code = text.charCodeAt(cut - 1);
+      if (code >= 55296 && code <= 56319) {
+        return cut - 1;
+      }
+    }
+    return cut;
+  }
+  /**
+   * Add thinking content to a chat completion message
+   */
+  addThinkingToMessage(message, thinkingContent) {
+    if (thinkingContent) {
+      message.thinking = thinkingContent;
+    }
+    return message;
+  }
+};
+
+// ../../AI/Core/dist/generic/apiKeyDictionary.js
+var AIAPIKeys = class _AIAPIKeys {
+  static {
+    this._apiKeyPrefix = "AI_VENDOR_API_KEY__";
+  }
+  static {
+    this._cachedAPIKeys = {};
+  }
+  GetCachedAPIKey(AIDriverName) {
+    const normalizedKey = AIDriverName.toUpperCase();
+    return _AIAPIKeys._cachedAPIKeys[normalizedKey];
+  }
+  SetCachedAPIKey(AIDriverName, value) {
+    const normalizedKey = AIDriverName.toUpperCase();
+    _AIAPIKeys._cachedAPIKeys[normalizedKey] = value;
+  }
+  GetAPIKey(AIDriverName) {
+    if (!AIDriverName) {
+      return void 0;
+    }
+    const normalizedKey = AIDriverName.toUpperCase();
+    const cached = this.GetCachedAPIKey(normalizedKey);
+    if (cached) {
+      return cached;
+    } else {
+      const envKey = _AIAPIKeys._apiKeyPrefix + normalizedKey;
+      const value = this.getEnvVariableCaseInsensitive(envKey);
+      if (value) {
+        this.SetCachedAPIKey(normalizedKey, value);
+        return value;
+      } else
+        return void 0;
+    }
+  }
+  getEnvVariableCaseInsensitive(name) {
+    const upperName = name.toUpperCase();
+    const envKey = Object.keys(process.env).find((key) => key.toUpperCase() === upperName);
+    return envKey ? process.env[envKey] : void 0;
+  }
+};
+
+// ../../AI/Core/dist/generic/realtimeUsage.js
+function usageHasTokenCounts(usage) {
+  if (usage === null || typeof usage !== "object") {
+    return false;
+  }
+  const candidate = usage;
+  return typeof candidate.input_tokens === "number" || typeof candidate.output_tokens === "number";
+}
+function ResolveResponseDoneUsage(event) {
+  if (usageHasTokenCounts(event.response?.usage)) {
+    return event.response?.usage;
+  }
+  return usageHasTokenCounts(event.usage) ? event.usage : void 0;
+}
+
+// ../../AI/Core/dist/generic/modelConfiguration.js
+function ParseModelConfiguration(json) {
+  return parseConfigurationBag(json, "ParseModelConfiguration", "ModelConfiguration");
+}
+function ParseVendorConfiguration(json) {
+  return parseConfigurationBag(json, "ParseVendorConfiguration", "Configuration");
+}
+function parseConfigurationBag(json, caller, column) {
+  if (typeof json !== "string" || json.trim().length === 0) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(json);
+    if (IsPlainObject(parsed)) {
+      return parsed;
+    }
+    console.warn(`[${caller}] ${column} JSON is not a plain object; skipping layer.`);
+    return null;
+  } catch (err) {
+    console.warn(`[${caller}] Failed to parse ${column} JSON; skipping malformed layer:`, err);
+    return null;
+  }
+}
+function ResolveEffectiveModelConfiguration(...layers) {
+  const result = {};
+  for (const layer of layers) {
+    if (!IsPlainObject(layer)) {
+      continue;
+    }
+    mergeInto(result, layer);
+  }
+  return Object.keys(result).length > 0 ? result : null;
+}
+function mergeInto(target, source) {
+  for (const key of Object.keys(source)) {
+    const incoming = source[key];
+    if (incoming === void 0) {
+      continue;
+    }
+    const existing = target[key];
+    if (IsPlainObject(existing) && IsPlainObject(incoming)) {
+      mergeInto(existing, incoming);
+    } else if (IsPlainObject(incoming)) {
+      const copy = {};
+      mergeInto(copy, incoming);
+      target[key] = copy;
+    } else if (Array.isArray(incoming)) {
+      target[key] = incoming.slice();
+    } else {
+      target[key] = incoming;
+    }
+  }
+}
+
+// ../../AI/Core/dist/generic/transcriptContinuation.js
+function IsTranscriptContinuation(previous, next) {
+  if (!previous || !next) {
+    return false;
+  }
+  const before = NormalizeTranscriptForComparison(previous);
+  const after = NormalizeTranscriptForComparison(next);
+  if (!before || !after) {
+    return false;
+  }
+  return after.length > before.length && after.startsWith(before);
+}
+function NormalizeTranscriptForComparison(value) {
+  return value.toLowerCase().replace(/[^\p{L}\p{N}]+/gu, " ").trim();
+}
+
+// ../../AI/Core/dist/generic/realtimeProxyRegistry.js
+var REALTIME_RELAY_TIME_LIMIT_CLOSE_CODE = 4e3;
+
+// ../../AI/Core/dist/generic/realtimeToolBatchBarrier.js
+var RealtimeToolBatchBarrier = class {
+  /**
+   * @param defaultTimeoutMs Maximum time in milliseconds to wait for remaining tool results before flushing (default 15s).
+   */
+  constructor(defaultTimeoutMs = 15e3) {
+    this._outstanding = /* @__PURE__ */ new Set();
+    this._timer = null;
+    this._timeoutMs = defaultTimeoutMs;
+  }
+  /**
+   * Records an outstanding tool call ID that must be answered.
+   * @param callId The tool call identifier.
+   * @param onTimeoutFlush Optional callback to invoke if the batch times out waiting for remaining results.
+   */
+  Opened(callId, onTimeoutFlush) {
+    if (!callId) {
+      return;
+    }
+    this._outstanding.add(callId);
+    if (onTimeoutFlush) {
+      this._onTimeoutFlush = onTimeoutFlush;
+    }
+    this.resetTimeout();
+  }
+  /**
+   * Alias for Opened.
+   */
+  TrackPendingCall(callId, onTimeoutFlush) {
+    this.Opened(callId, onTimeoutFlush);
+  }
+  /**
+   * Returns true when THIS result drains the batch and the caller should send response.create.
+   * If the call was not in the outstanding set (unknown or duplicate), returns false.
+   *
+   * @param callId The tool call identifier.
+   */
+  Closed(callId) {
+    if (!this._outstanding.delete(callId)) {
+      return false;
+    }
+    if (this._outstanding.size === 0) {
+      this.clearTimeout();
+      return true;
+    }
+    this.resetTimeout();
+    return false;
+  }
+  /**
+   * Alias for Closed.
+   */
+  RecordResult(callId) {
+    return this.Closed(callId);
+  }
+  /**
+   * Returns true if there are no outstanding tool calls.
+   */
+  get IsEmpty() {
+    return this._outstanding.size === 0;
+  }
+  /**
+   * Number of tool calls still awaiting results in the current batch.
+   */
+  get PendingCount() {
+    return this._outstanding.size;
+  }
+  /**
+   * Arms or re-arms the timeout with a custom duration and callback.
+   */
+  ArmTimeout(ms, onTimeoutFlush) {
+    this._timeoutMs = ms;
+    this._onTimeoutFlush = onTimeoutFlush;
+    this.resetTimeout();
+  }
+  /**
+   * Resets the barrier state and cancels any pending timeout (alias for Clear).
+   */
+  Reset() {
+    this.Clear();
+  }
+  /**
+   * Clears all pending tool calls and cancels any active timeout (e.g. on user interruption,
+   * error, or session close).
+   */
+  Clear() {
+    this._outstanding.clear();
+    this.clearTimeout();
+  }
+  resetTimeout() {
+    this.clearTimeout();
+    if (this._outstanding.size > 0 && this._onTimeoutFlush) {
+      this._timer = setTimeout(() => {
+        this._timer = null;
+        if (this._outstanding.size > 0) {
+          this._outstanding.clear();
+          this._onTimeoutFlush?.();
+        }
+      }, this._timeoutMs);
+    }
+  }
+  clearTimeout() {
+    if (this._timer) {
+      clearTimeout(this._timer);
+      this._timer = null;
+    }
+  }
+};
+
+// ../../AI/Core/dist/generic/realtimeSessionResumption.js
+var REALTIME_RESUMPTION_RETRY_DELAYS_MS = [0, 1e3, 3e3];
+var REALTIME_RESUMPTION_ATTEMPT_TIMEOUT_MS = 15e3;
+var REALTIME_RESUMPTION_DEADLINE_MARGIN_MS = 1e4;
+var REALTIME_RESUMPTION_MIN_DEADLINE_MARGIN_MS = 1500;
+var DEADLINE_MARGIN_SHARE_OF_NOTICE = 1 / 3;
+var UNKNOWN_TIME_LEFT_DELAY_MS = 3e4;
+function ParseDurationToMs(duration) {
+  const match = duration ? /^(\d+(?:\.\d+)?)s$/.exec(duration.trim()) : null;
+  return match ? Math.round(Number(match[1]) * 1e3) : void 0;
+}
+var RealtimeSessionResumption = class {
+  constructor(options) {
+    this._handle = null;
+    this._resumableNow = false;
+    this._turnOpen = false;
+    this._endingAnnounced = false;
+    this._reconnecting = false;
+    this._exhausted = false;
+    this._disposed = false;
+    this._deadlineTimer = null;
+    this._retryTimer = null;
+    this._currentAttempt = null;
+    this.options = options;
+  }
+  /** The latest handle the provider issued, or `null` before the first update. */
+  get Handle() {
+    return this._handle;
+  }
+  /** Whether a reconnect is in progress. */
+  get IsReconnecting() {
+    return this._reconnecting;
+  }
+  /**
+   * Records the provider's latest resumption state. `resumable: false` means the session is
+   * mid-generation or mid-tool-call: the previous handle stays as a fallback for a lost
+   * connection, but a planned move waits for the next resumable point. A resumable handle that
+   * arrives while a turn is in progress is kept as that fallback too: resuming from it would cut
+   * the turn, so it is not a point to move at.
+   *
+   * @param handle The new handle, when the provider sent one.
+   * @param resumable Whether the session can be resumed from this point without losing data.
+   */
+  RecordHandle(handle, resumable) {
+    if (!resumable) {
+      this._resumableNow = false;
+      return;
+    }
+    if (handle) {
+      this._handle = handle;
+      this._resumableNow = !this._turnOpen;
+    }
+    if (this._endingAnnounced && this._resumableNow) {
+      this.startReconnect("connection-ending");
+    }
+  }
+  /**
+   * A turn started or continued: the user's first transcribed words, a turn the client sent, or
+   * the model's output. Until {@link TurnEnded}, a planned move waits, whatever the provider's
+   * updates say; the deadline still bounds the wait. Call it for every sign of the turn: a repeat
+   * changes nothing.
+   */
+  TurnStarted() {
+    this._turnOpen = true;
+    this._resumableNow = false;
+  }
+  /**
+   * The turn ended (its `turnComplete`, with no tool call pending). A planned move now happens at
+   * the next resumable handle, which the provider issues after the turn (Vertex AI: 20-70 ms
+   * after `turnComplete`), so the new connection resumes with the finished turn.
+   */
+  TurnEnded() {
+    this._turnOpen = false;
+  }
+  /**
+   * The provider announced the current connection ends in `timeLeftMs`. The helper moves at once
+   * when the latest handle is a resumable point (issued after the last turn ended, with no turn
+   * since); otherwise it waits for one, until the deadline.
+   *
+   * @param timeLeftMs Time until the provider closes the connection; `undefined` when not given.
+   */
+  ConnectionEnding(timeLeftMs) {
+    if (this._disposed || this._exhausted || this._reconnecting) {
+      return;
+    }
+    this._endingAnnounced = true;
+    if (this._resumableNow && this._handle) {
+      this.startReconnect("connection-ending");
+      return;
+    }
+    this.armDeadline(timeLeftMs);
+  }
+  /**
+   * The connection closed without the consumer asking.
+   *
+   * @returns `true` when a reconnect started (or was already running), so the driver reports
+   *          "reconnecting" rather than an error; `false` when there is no handle to resume
+   *          from, so the driver keeps its fatal path.
+   */
+  ConnectionLost() {
+    if (this._disposed || this._exhausted || !this._handle) {
+      return false;
+    }
+    if (!this._reconnecting) {
+      this.startReconnect("connection-lost");
+    }
+    return true;
+  }
+  /** Cancels timers, abandons any attempt in flight and stops retries. Call when the consumer closes the session. */
+  Dispose() {
+    this._disposed = true;
+    this.clearDeadline();
+    this.clearRetry();
+    if (this._currentAttempt) {
+      this._currentAttempt.Abandoned = true;
+    }
+  }
+  startReconnect(reason) {
+    if (this._reconnecting || this._disposed || this._exhausted || !this._handle) {
+      return;
+    }
+    this._reconnecting = true;
+    this.clearDeadline();
+    this.options.Log?.(`[RealtimeSessionResumption] reconnecting (${reason})`);
+    this.options.OnReconnecting?.(reason);
+    this.scheduleAttempt(0);
+  }
+  scheduleAttempt(index) {
+    this._retryTimer = setTimeout(() => {
+      this._retryTimer = null;
+      void this.attempt(index);
+    }, this.retryDelays()[index]);
+  }
+  async attempt(index) {
+    if (this._disposed || !this._handle) {
+      return;
+    }
+    const attempt = { Abandoned: false };
+    this._currentAttempt = attempt;
+    try {
+      await this.withTimeout(this.options.Reconnect(this._handle, attempt), attempt);
+      this.onAttemptSucceeded();
+    } catch (error) {
+      attempt.Abandoned = true;
+      this.onAttemptFailed(index, error);
+    } finally {
+      if (this._currentAttempt === attempt) {
+        this._currentAttempt = null;
+      }
+    }
+  }
+  /** Rejects when `work` outlives the attempt timeout; the attempt is then abandoned. */
+  withTimeout(work, attempt) {
+    const timeoutMs = this.options.AttemptTimeoutMs ?? REALTIME_RESUMPTION_ATTEMPT_TIMEOUT_MS;
+    work.catch(() => void 0);
+    let timer = null;
+    const timeout = new Promise((_resolve, reject) => {
+      timer = setTimeout(() => {
+        attempt.Abandoned = true;
+        reject(new Error(`reconnect attempt timed out after ${timeoutMs} ms`));
+      }, timeoutMs);
+    });
+    return Promise.race([work, timeout]).finally(() => {
+      if (timer) {
+        clearTimeout(timer);
+      }
+    });
+  }
+  onAttemptSucceeded() {
+    this._reconnecting = false;
+    this._endingAnnounced = false;
+    this._resumableNow = false;
+    this._turnOpen = false;
+    if (!this._disposed) {
+      this.options.OnReconnected?.();
+    }
+  }
+  onAttemptFailed(index, error) {
+    const message = error instanceof Error ? error.message : String(error);
+    this.options.Log?.(`[RealtimeSessionResumption] attempt ${index + 1} failed: ${message}`);
+    if (this._disposed) {
+      return;
+    }
+    if (index + 1 < this.retryDelays().length) {
+      this.scheduleAttempt(index + 1);
+      return;
+    }
+    this._reconnecting = false;
+    this._exhausted = true;
+    this.options.OnReconnectFailed(error instanceof Error ? error : new Error(message));
+  }
+  armDeadline(timeLeftMs) {
+    this.clearDeadline();
+    const delay = timeLeftMs === void 0 ? UNKNOWN_TIME_LEFT_DELAY_MS : Math.max(0, timeLeftMs - this.deadlineMarginFor(timeLeftMs));
+    this._deadlineTimer = setTimeout(() => {
+      this._deadlineTimer = null;
+      this.startReconnect("connection-ending");
+    }, delay);
+  }
+  /**
+   * The margin kept before an announced connection end: a third of the notice, so a turn in
+   * progress gets the rest of it, between {@link REALTIME_RESUMPTION_MIN_DEADLINE_MARGIN_MS} and
+   * {@link RealtimeSessionResumptionOptions.DeadlineMarginMs}. A notice shorter than the least
+   * margin moves at once.
+   */
+  deadlineMarginFor(timeLeftMs) {
+    const most = this.options.DeadlineMarginMs ?? REALTIME_RESUMPTION_DEADLINE_MARGIN_MS;
+    const least = Math.min(most, REALTIME_RESUMPTION_MIN_DEADLINE_MARGIN_MS);
+    return Math.min(most, Math.max(least, Math.round(timeLeftMs * DEADLINE_MARGIN_SHARE_OF_NOTICE)));
+  }
+  retryDelays() {
+    const delays = this.options.RetryDelaysMs;
+    return delays && delays.length > 0 ? delays : REALTIME_RESUMPTION_RETRY_DELAYS_MS;
+  }
+  clearDeadline() {
+    if (this._deadlineTimer) {
+      clearTimeout(this._deadlineTimer);
+      this._deadlineTimer = null;
+    }
+  }
+  clearRetry() {
+    if (this._retryTimer) {
+      clearTimeout(this._retryTimer);
+      this._retryTimer = null;
+    }
+  }
+};
+
+// ../../AI/Core/dist/generic/realtimeConnectionSetup.js
+var REALTIME_CONNECTION_SETUP_TIMEOUT_MS = 15e3;
+var RealtimeConnectionSetup = class {
+  constructor() {
+    this.settle = null;
+    this.confirmed = false;
+    this.outcome = new Promise((resolve, reject) => {
+      this.settle = { Confirm: resolve, Fail: reject };
+    });
+    this.outcome.catch(() => void 0);
+  }
+  /** Whether the provider confirmed the setup. */
+  get IsConfirmed() {
+    return this.confirmed;
+  }
+  /** The provider confirmed the setup. Later calls, and a failure reported after it, change nothing. */
+  Confirm() {
+    if (!this.settle) {
+      return;
+    }
+    this.confirmed = true;
+    this.settle.Confirm();
+    this.settle = null;
+  }
+  /**
+   * The connection closed or failed before the provider confirmed the setup. Changes nothing once the setup was
+   * confirmed or had already failed.
+   *
+   * @param error Why the setup failed; {@link Wait} rejects with it.
+   */
+  Fail(error) {
+    if (!this.settle) {
+      return;
+    }
+    this.settle.Fail(error);
+    this.settle = null;
+  }
+  /**
+   * Resolves once the provider confirms the setup. Rejects when the connection fails first, or when no confirmation
+   * comes within `timeoutMs`; the setup then counts as failed.
+   *
+   * @param timeoutMs How long to wait for the confirmation. Defaults to {@link REALTIME_CONNECTION_SETUP_TIMEOUT_MS}.
+   */
+  Wait(timeoutMs = REALTIME_CONNECTION_SETUP_TIMEOUT_MS) {
+    const timer = setTimeout(() => {
+      this.Fail(new Error(`the provider did not confirm the session setup within ${timeoutMs} ms`));
+    }, timeoutMs);
+    return this.outcome.finally(() => clearTimeout(timer));
+  }
+};
+
+// ../../AI/Core/dist/generic/realtimeTracks.js
+function RealtimeTrackKey(descriptor) {
+  const source = descriptor.SourceID && descriptor.SourceID.length > 0 ? `:${descriptor.SourceID}` : "";
+  return `${descriptor.Direction}:${String(descriptor.Modality).trim().toLowerCase()}${source}`;
+}
+function IsPcmAudioMimeType(mimeType) {
+  return /^audio\/pcm\s*(;.*)?$/i.test(mimeType.trim());
+}
+var CHANNEL_INBOUND_VIDEO_TRACK = Object.freeze({
+  Modality: "video",
+  Direction: "inbound",
+  Encoding: "image/jpeg",
+  Rate: 1,
+  UsageBasis: ["tokens", "frames"],
+  RequiresConsent: false
+});
+var DEFAULT_REALTIME_AUDIO_TRACKS = Object.freeze([
+  Object.freeze({ Modality: "audio", Direction: "inbound" }),
+  Object.freeze({ Modality: "audio", Direction: "outbound" })
+]);
+function ResolveRequestedTracks(requested, supported, makeTrackID, limits) {
+  if (!requested || requested.length === 0) {
+    return [];
+  }
+  const supportedList = supported ?? [];
+  let inboundVideoSeen = 0;
+  return requested.map((descriptor, index) => {
+    const supportedTrack = supportedList.find((s) => String(s.Modality).trim().toLowerCase() === String(descriptor.Modality).trim().toLowerCase() && s.Direction === descriptor.Direction);
+    const isSupported = Boolean(supportedTrack);
+    let refinedDescriptor = descriptor;
+    if (supportedTrack) {
+      let effectiveRate = descriptor.Rate;
+      if (typeof supportedTrack.Rate === "number" && supportedTrack.Rate > 0) {
+        effectiveRate = typeof descriptor.Rate === "number" && descriptor.Rate > 0 ? Math.min(descriptor.Rate, supportedTrack.Rate) : supportedTrack.Rate;
+      }
+      refinedDescriptor = {
+        ...descriptor,
+        Rate: effectiveRate
+      };
+    }
+    const overStreamCap = isSupported && isInboundVideo(descriptor) && exceedsStreamCap(++inboundVideoSeen, limits?.MaxInboundVideoStreams);
+    return {
+      TrackID: makeTrackID(refinedDescriptor, index),
+      Descriptor: refinedDescriptor,
+      State: isSupported && !overStreamCap ? "requested" : "unsupported",
+      Reason: !isSupported ? `Model does not support ${descriptor.Direction} ${String(descriptor.Modality)} tracks.` : overStreamCap ? `Model accepts at most ${limits?.MaxInboundVideoStreams} inbound video stream(s); this one is over the limit.` : void 0
+    };
+  });
+}
+function isInboundVideo(descriptor) {
+  return descriptor.Direction === "inbound" && String(descriptor.Modality).trim().toLowerCase() === "video";
+}
+function exceedsStreamCap(ordinal, cap) {
+  return typeof cap === "number" && ordinal > cap;
+}
+
+// ../../AI/Core/dist/generic/realtimeVisionNotes.js
+function VideoSourceSeenNote(sourceLabels) {
+  const named = typeof sourceLabels === "string" ? sourceLabels : sourceLabels.join(", ");
+  return `[You can now see: ${named}]`;
+}
+function VideoSourceTurnedOffNote(sourceLabel) {
+  return `[You can no longer see: ${sourceLabel} (the user turned it off)]`;
+}
+function VideoSourceTurnedOnNote(sourceLabel) {
+  return `[You can now see: ${sourceLabel} (turned back on)]`;
+}
+
+// ../../AI/Core/dist/generic/realtimeAvatarStatus.js
+var KNOWN_REASONS = {
+  endpoint: true,
+  bridged: true,
+  phone: true,
+  "custom-disabled": true,
+  "unknown-avatar": true,
+  "no-binding": true,
+  host: true,
+  browser: true,
+  "decoder-missing": true,
+  "decoder-failed": true,
+  "publish-failed": true,
+  "video-off": true
+};
+function isKnownReason(value) {
+  return typeof value === "string" && Object.prototype.hasOwnProperty.call(KNOWN_REASONS, value);
+}
+var REALTIME_AVATAR_UNAVAILABLE_REASONS = Object.keys(KNOWN_REASONS).filter(isKnownReason);
+
+// ../../AI/Core/dist/generic/realtimeVideoFrames.js
+var REALTIME_DEFAULT_INBOUND_VIDEO_RATE = 1;
+var REALTIME_VIDEO_FRAME_JITTER_HEADROOM = 0.75;
+function RealtimeVideoFrameIntervalMs(rate) {
+  const effective = typeof rate === "number" && Number.isFinite(rate) && rate > 0 ? rate : REALTIME_DEFAULT_INBOUND_VIDEO_RATE;
+  return Math.floor(1e3 / effective);
+}
+function RealtimeMinVideoFrameSpacingMs(rate) {
+  return Math.floor(RealtimeVideoFrameIntervalMs(rate) * REALTIME_VIDEO_FRAME_JITTER_HEADROOM);
+}
+function ScaleRealtimeVideoFrame(size, maxDimension) {
+  const longer = Math.max(size.Width, size.Height);
+  if (!maxDimension || maxDimension <= 0 || longer <= maxDimension) {
+    return { Width: size.Width, Height: size.Height };
+  }
+  const scale = maxDimension / longer;
+  return {
+    Width: Math.max(1, Math.round(size.Width * scale)),
+    Height: Math.max(1, Math.round(size.Height * scale))
+  };
+}
+
+// ../../AI/Core/dist/generic/fmp4Reader.js
+var BOX_HEADER_BYTES = 8;
+var LARGE_BOX_HEADER_BYTES = 16;
+var FULL_BOX_HEADER_BYTES = 4;
+var VISUAL_SAMPLE_ENTRY_BYTES = 78;
+var VISUAL_SAMPLE_ENTRY_WIDTH_OFFSET = 24;
+var AUDIO_SAMPLE_ENTRY_BYTES = 28;
+var DECODER_CONFIG_BYTES = 13;
+var MPEG4_AUDIO_OBJECT_TYPE = 64;
+var ES_DESCRIPTOR_TAG = 3;
+var DECODER_CONFIG_DESCRIPTOR_TAG = 4;
+var DECODER_SPECIFIC_INFO_TAG = 5;
+var SAMPLE_IS_NON_SYNC = 65536;
+var MAX_RUN_SAMPLES = 65536;
+var AAC_SAMPLE_RATES = [96e3, 88200, 64e3, 48e3, 44100, 32e3, 24e3, 22050, 16e3, 12e3, 11025, 8e3, 7350];
+var AAC_EXPLICIT_RATE_INDEX = 15;
+var AAC_GA_OBJECT_TYPES = /* @__PURE__ */ new Set([1, 2, 3, 4, 6, 7, 17, 19, 20, 21, 22, 23]);
+var TFHD = {
+  BaseDataOffset: 1,
+  SampleDescriptionIndex: 2,
+  DefaultDuration: 8,
+  DefaultSize: 16,
+  DefaultFlags: 32,
+  DefaultBaseIsMoof: 131072
+};
+var TRUN = {
+  DataOffset: 1,
+  FirstSampleFlags: 4,
+  Duration: 256,
+  Size: 512,
+  Flags: 1024,
+  CompositionOffset: 2048
+};
+var TRUN_SAMPLE_FIELDS = [TRUN.Duration, TRUN.Size, TRUN.Flags, TRUN.CompositionOffset];
+function SniffFmp4Piece(bytes) {
+  const view = viewOf(bytes);
+  if (view.byteLength < BOX_HEADER_BYTES) {
+    return null;
+  }
+  const type = fourCC(view, 4);
+  if (type === "ftyp" || type === "moov") {
+    return "init";
+  }
+  return type === "moof" || type === "styp" ? "fragment" : null;
+}
+function ReadFmp4Init(bytes) {
+  const view = viewOf(bytes);
+  const moov = readBoxes(view, 0, view.byteLength)?.find((box) => box.Type === "moov");
+  const moovBoxes = moov ? childBoxes(view, moov) : null;
+  if (!moovBoxes) {
+    return null;
+  }
+  const defaults = readTrexDefaults(view, moovBoxes.find((box) => box.Type === "mvex"));
+  const tracks = [];
+  for (const trak of moovBoxes.filter((box) => box.Type === "trak")) {
+    const track = readTrack(view, trak, defaults);
+    if (!track) {
+      return null;
+    }
+    tracks.push(track);
+  }
+  return { Tracks: tracks };
+}
+function Fmp4VideoSeconds(bytes, init) {
+  return trackSeconds(bytes, init, "vide");
+}
+function ReadFmp4Fragment(bytes, init) {
+  const view = viewOf(bytes);
+  const moofs = readBoxes(view, 0, view.byteLength)?.filter((box) => box.Type === "moof");
+  if (!moofs || moofs.length === 0) {
+    return null;
+  }
+  const samples = [];
+  for (const moof of moofs) {
+    const read = readMovieFragment(view, moof, init);
+    if (!read) {
+      return null;
+    }
+    samples.push(...read);
+  }
+  return { Samples: samples };
+}
+function viewOf(bytes) {
+  return ArrayBuffer.isView(bytes) ? new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength) : new DataView(bytes);
+}
+function fourCC(view, offset) {
+  return String.fromCharCode(view.getUint8(offset), view.getUint8(offset + 1), view.getUint8(offset + 2), view.getUint8(offset + 3));
+}
+function copyBytes(view, start, end) {
+  return new Uint8Array(view.buffer, view.byteOffset + start, end - start).slice();
+}
+function readUint64(view, offset) {
+  return view.getUint32(offset) * 4294967296 + view.getUint32(offset + 4);
+}
+function readBoxAt(view, offset, end) {
+  const size32 = view.getUint32(offset);
+  let headerBytes = BOX_HEADER_BYTES;
+  let size = size32;
+  if (size32 === 1) {
+    if (end - offset < LARGE_BOX_HEADER_BYTES) {
+      return null;
+    }
+    size = readUint64(view, offset + 8);
+    headerBytes = LARGE_BOX_HEADER_BYTES;
+  } else if (size32 === 0) {
+    size = end - offset;
+  }
+  if (size < headerBytes || size > end - offset) {
+    return null;
+  }
+  return { Type: fourCC(view, offset + 4), Offset: offset, Start: offset + headerBytes, End: offset + size };
+}
+function readBoxes(view, start, end) {
+  const boxes = [];
+  let offset = start;
+  while (end - offset >= BOX_HEADER_BYTES) {
+    const box = readBoxAt(view, offset, end);
+    if (!box) {
+      return null;
+    }
+    boxes.push(box);
+    offset = box.End;
+  }
+  return boxes;
+}
+function childBoxes(view, parent, skip = 0) {
+  return readBoxes(view, parent.Start + skip, parent.End);
+}
+function findChild(view, parent, type, skip = 0) {
+  return childBoxes(view, parent, skip)?.find((box) => box.Type === type) ?? null;
+}
+function findPath(view, parent, ...types) {
+  let box = parent;
+  for (const type of types) {
+    box = box ? findChild(view, box, type) : null;
+  }
+  return box;
+}
+function readTrack(view, trak, trexDefaults) {
+  const tkhd = findChild(view, trak, "tkhd");
+  const mdia = findChild(view, trak, "mdia");
+  const hdlr = mdia ? findChild(view, mdia, "hdlr") : null;
+  const trackID = tkhd ? readTrackID(view, tkhd) : null;
+  const handler = hdlr ? readHandler(view, hdlr) : null;
+  if (!mdia || trackID === null || handler === null) {
+    return null;
+  }
+  const mdhd = findChild(view, mdia, "mdhd");
+  const stsd = findPath(view, mdia, "minf", "stbl", "stsd");
+  const entry = stsd ? readBoxes(view, stsd.Start + FULL_BOX_HEADER_BYTES + 4, stsd.End)?.[0] : void 0;
+  return {
+    TrackID: trackID,
+    Handler: handler,
+    Codec: entry ? readCodec(view, entry) : void 0,
+    Timescale: mdhd ? readTimescale(view, mdhd) : void 0,
+    ...trexDefaults.get(trackID),
+    ...entry ? readDecoderConfig(view, entry) : {}
+  };
+}
+function readTrackID(view, tkhd) {
+  if (tkhd.End - tkhd.Start < FULL_BOX_HEADER_BYTES) {
+    return null;
+  }
+  const offset = tkhd.Start + FULL_BOX_HEADER_BYTES + (view.getUint8(tkhd.Start) === 1 ? 16 : 8);
+  return offset + 4 <= tkhd.End ? view.getUint32(offset) : null;
+}
+function readHandler(view, hdlr) {
+  const offset = hdlr.Start + FULL_BOX_HEADER_BYTES + 4;
+  return offset + 4 <= hdlr.End ? fourCC(view, offset) : null;
+}
+function readTimescale(view, mdhd) {
+  if (mdhd.End - mdhd.Start < FULL_BOX_HEADER_BYTES) {
+    return void 0;
+  }
+  const offset = mdhd.Start + FULL_BOX_HEADER_BYTES + (view.getUint8(mdhd.Start) === 1 ? 16 : 8);
+  const timescale = offset + 4 <= mdhd.End ? view.getUint32(offset) : 0;
+  return timescale > 0 ? timescale : void 0;
+}
+function readCodec(view, entry) {
+  switch (entry.Type) {
+    case "avc1":
+    case "avc3":
+      return avcCodec(view, entry);
+    case "mp4a":
+      return aacCodec(view, entry);
+    default:
+      return void 0;
+  }
+}
+function readDecoderConfig(view, entry) {
+  if (entry.Type === "avc1" || entry.Type === "avc3") {
+    const avcC = findChild(view, entry, "avcC", VISUAL_SAMPLE_ENTRY_BYTES);
+    const avc = avcC ? readAvcConfig(view, avcC) : null;
+    return { ...readVisualSize(view, entry), ...avc ? { Avc: avc } : {} };
+  }
+  if (entry.Type === "mp4a") {
+    const aac = readAacConfig(view, entry);
+    return aac ? { Aac: aac } : {};
+  }
+  return {};
+}
+function readVisualSize(view, entry) {
+  const offset = entry.Start + VISUAL_SAMPLE_ENTRY_WIDTH_OFFSET;
+  if (offset + 4 > entry.End) {
+    return {};
+  }
+  const width = view.getUint16(offset);
+  const height = view.getUint16(offset + 2);
+  return width > 0 && height > 0 ? { Width: width, Height: height } : {};
+}
+function avcCodec(view, entry) {
+  const avcC = findChild(view, entry, "avcC", VISUAL_SAMPLE_ENTRY_BYTES);
+  if (!avcC || avcC.End - avcC.Start < 4) {
+    return void 0;
+  }
+  const profile = hex2(view.getUint8(avcC.Start + 1));
+  const constraints = hex2(view.getUint8(avcC.Start + 2));
+  const level = hex2(view.getUint8(avcC.Start + 3));
+  return `${entry.Type}.${profile}${constraints}${level}`;
+}
+function readAvcConfig(view, avcC) {
+  if (avcC.End - avcC.Start < 6) {
+    return null;
+  }
+  const nalLengthSize = (view.getUint8(avcC.Start + 4) & 3) + 1;
+  const sps = readParameterSets(view, avcC.Start + 6, avcC.End, view.getUint8(avcC.Start + 5) & 31);
+  if (!sps || sps.End >= avcC.End) {
+    return null;
+  }
+  const pps = readParameterSets(view, sps.End + 1, avcC.End, view.getUint8(sps.End));
+  return pps && nalLengthSize !== 3 ? { NalLengthSize: nalLengthSize, Sps: sps.Sets, Pps: pps.Sets } : null;
+}
+function readParameterSets(view, start, end, count) {
+  const sets = [];
+  let offset = start;
+  for (let i = 0; i < count; i++) {
+    if (offset + 2 > end || offset + 2 + view.getUint16(offset) > end) {
+      return null;
+    }
+    const length = view.getUint16(offset);
+    sets.push(copyBytes(view, offset + 2, offset + 2 + length));
+    offset += 2 + length;
+  }
+  return { Sets: sets, End: offset };
+}
+function aacCodec(view, entry) {
+  const config = readEsdsDecoderConfig(view, entry);
+  if (!config || config.ObjectType !== MPEG4_AUDIO_OBJECT_TYPE || !config.SpecificInfo) {
+    return void 0;
+  }
+  const objectType = readAudioObjectType(view, config.SpecificInfo);
+  return objectType === void 0 ? void 0 : `mp4a.40.${objectType}`;
+}
+function readAacConfig(view, entry) {
+  const config = readEsdsDecoderConfig(view, entry);
+  if (!config || config.ObjectType !== MPEG4_AUDIO_OBJECT_TYPE || !config.SpecificInfo) {
+    return null;
+  }
+  return readAudioSpecificConfig(view, config.SpecificInfo);
+}
+function readEsdsDecoderConfig(view, entry) {
+  const esds = findChild(view, entry, "esds", AUDIO_SAMPLE_ENTRY_BYTES);
+  const es = esds ? readDescriptor(view, esds.Start + FULL_BOX_HEADER_BYTES, esds.End) : null;
+  if (!es || es.Tag !== ES_DESCRIPTOR_TAG) {
+    return null;
+  }
+  const decoderConfig = readDescriptor(view, esChildrenStart(view, es), es.End);
+  if (!decoderConfig || decoderConfig.Tag !== DECODER_CONFIG_DESCRIPTOR_TAG || decoderConfig.End - decoderConfig.Start < DECODER_CONFIG_BYTES) {
+    return null;
+  }
+  const specific = readDescriptor(view, decoderConfig.Start + DECODER_CONFIG_BYTES, decoderConfig.End);
+  return {
+    ObjectType: view.getUint8(decoderConfig.Start),
+    SpecificInfo: specific?.Tag === DECODER_SPECIFIC_INFO_TAG ? specific : void 0
+  };
+}
+function readDescriptor(view, offset, end) {
+  let position = offset + 1;
+  let size = 0;
+  for (let i = 0; i < 4; i++) {
+    if (position >= end) {
+      return null;
+    }
+    const byte = view.getUint8(position++);
+    size = size << 7 | byte & 127;
+    if ((byte & 128) === 0) {
+      break;
+    }
+  }
+  return position + size <= end ? { Tag: view.getUint8(offset), Start: position, End: position + size } : null;
+}
+function esChildrenStart(view, es) {
+  if (es.End - es.Start < 3) {
+    return es.End;
+  }
+  const flags = view.getUint8(es.Start + 2);
+  let offset = es.Start + 3;
+  if (flags & 128) {
+    offset += 2;
+  }
+  if (flags & 64) {
+    offset = offset < es.End ? offset + 1 + view.getUint8(offset) : es.End;
+  }
+  if (flags & 32) {
+    offset += 2;
+  }
+  return offset;
+}
+function readAudioObjectType(view, info) {
+  const bits = new BitReader(view, info.Start, info.End);
+  return readObjectTypeBits(bits) ?? void 0;
+}
+function readObjectTypeBits(bits) {
+  const objectType = bits.Read(5);
+  if (objectType !== 31) {
+    return objectType;
+  }
+  const escaped = bits.Read(6);
+  return escaped === null ? null : 32 + escaped;
+}
+function readAudioSpecificConfig(view, info) {
+  const bits = new BitReader(view, info.Start, info.End);
+  const objectType = readObjectTypeBits(bits);
+  const rateIndex = bits.Read(4);
+  const explicitRate = rateIndex === AAC_EXPLICIT_RATE_INDEX ? bits.Read(24) : null;
+  const channels = bits.Read(4);
+  const sampleRate = rateIndex === AAC_EXPLICIT_RATE_INDEX ? explicitRate : rateIndex !== null ? AAC_SAMPLE_RATES[rateIndex] : void 0;
+  if (objectType === null || rateIndex === null || channels === null || !sampleRate) {
+    return null;
+  }
+  const shortFrames = AAC_GA_OBJECT_TYPES.has(objectType) && bits.Read(1) === 1;
+  return { ObjectType: objectType, SampleRateIndex: rateIndex, SampleRate: sampleRate, Channels: channels, FrameLength: shortFrames ? 960 : 1024 };
+}
+function readTrexDefaults(view, mvex) {
+  const defaults = /* @__PURE__ */ new Map();
+  const trexes = (mvex ? childBoxes(view, mvex) : null)?.filter((box) => box.Type === "trex") ?? [];
+  for (const trex of trexes) {
+    const fields = trex.Start + FULL_BOX_HEADER_BYTES;
+    if (fields + 4 > trex.End) {
+      continue;
+    }
+    const positive = (at) => fields + at + 4 <= trex.End && view.getUint32(fields + at) > 0 ? view.getUint32(fields + at) : void 0;
+    defaults.set(view.getUint32(fields), { DefaultSampleDuration: positive(8), DefaultSampleSize: positive(12), DefaultSampleFlags: positive(16) });
+  }
+  return defaults;
+}
+function trackSeconds(bytes, init, handler) {
+  const track = init.Tracks.find((candidate) => candidate.Handler === handler);
+  if (!track?.Timescale) {
+    return null;
+  }
+  const view = viewOf(bytes);
+  const moofs = readBoxes(view, 0, view.byteLength)?.filter((box) => box.Type === "moof");
+  const units = moofs ? sumOrNull(moofs, (moof) => moofDuration(view, moof, track)) : null;
+  return units === null ? null : units / track.Timescale;
+}
+function moofDuration(view, moof, track) {
+  const trafs = childBoxes(view, moof)?.filter((box) => box.Type === "traf");
+  return trafs ? sumOrNull(trafs, (traf) => trafDuration(view, traf, track)) : null;
+}
+function trafDuration(view, traf, track) {
+  const boxes = childBoxes(view, traf);
+  const tfhd = boxes?.find((box) => box.Type === "tfhd");
+  const header = tfhd ? readTfhd(view, tfhd) : null;
+  if (!boxes || !header) {
+    return null;
+  }
+  if (header.TrackID !== track.TrackID) {
+    return 0;
+  }
+  const defaultDuration = header.DefaultDuration ?? track.DefaultSampleDuration;
+  return sumOrNull(boxes.filter((box) => box.Type === "trun"), (trun) => trunDuration(view, trun, defaultDuration));
+}
+function trunDuration(view, trun, defaultDuration) {
+  const layout = readTrackRunLayout(view, trun);
+  if (!layout) {
+    return null;
+  }
+  if (!(layout.Flags & TRUN.Duration)) {
+    return defaultDuration === void 0 ? null : layout.Count * defaultDuration;
+  }
+  let units = 0;
+  for (let i = 0; i < layout.Count; i++) {
+    units += view.getUint32(layout.FirstRecord + i * layout.RecordBytes);
+  }
+  return units;
+}
+function sumOrNull(items, read) {
+  let total = 0;
+  for (const item of items) {
+    const value = read(item);
+    if (value === null) {
+      return null;
+    }
+    total += value;
+  }
+  return total;
+}
+function readMovieFragment(view, moof, init) {
+  const trafs = childBoxes(view, moof)?.filter((box) => box.Type === "traf");
+  if (!trafs) {
+    return null;
+  }
+  const samples = [];
+  let previousDataEnd = moof.Offset;
+  for (const traf of trafs) {
+    const read = readTrackFragment(view, traf, moof, previousDataEnd, init);
+    if (!read) {
+      return null;
+    }
+    samples.push(...read.Samples);
+    previousDataEnd = read.DataEnd;
+  }
+  return samples;
+}
+function readTrackFragment(view, traf, moof, previousDataEnd, init) {
+  const children = childBoxes(view, traf);
+  const tfhdBox = children?.find((box) => box.Type === "tfhd");
+  const tfdtBox = children?.find((box) => box.Type === "tfdt");
+  const header = tfhdBox ? readTfhd(view, tfhdBox) : null;
+  const decodeTime = tfdtBox ? readDecodeTime(view, tfdtBox) : null;
+  if (!children || !header || header.BaseDataOffset !== void 0 || decodeTime === null) {
+    return null;
+  }
+  const baseOffset = header.DefaultBaseIsMoof ? moof.Offset : previousDataEnd;
+  const track = init?.Tracks.find((t) => t.TrackID === header.TrackID);
+  const context = { Header: header, Track: track, BaseOffset: baseOffset, DecodeTime: decodeTime, DataPosition: baseOffset };
+  const samples = [];
+  for (const trun of children.filter((box) => box.Type === "trun")) {
+    const run = readTrackRun(view, trun, context);
+    if (!run) {
+      return null;
+    }
+    samples.push(...run);
+  }
+  return { Samples: samples, DataEnd: context.DataPosition };
+}
+function readFlags(view, box) {
+  return view.getUint8(box.Start + 1) << 16 | view.getUint8(box.Start + 2) << 8 | view.getUint8(box.Start + 3);
+}
+function readTfhd(view, tfhd) {
+  const flags = readFlags(view, tfhd);
+  let offset = tfhd.Start + FULL_BOX_HEADER_BYTES;
+  if (offset + 4 > tfhd.End) {
+    return null;
+  }
+  const header = { TrackID: view.getUint32(offset), DefaultBaseIsMoof: (flags & TFHD.DefaultBaseIsMoof) !== 0 };
+  offset += 4;
+  if (flags & TFHD.BaseDataOffset) {
+    if (offset + 8 > tfhd.End) {
+      return null;
+    }
+    header.BaseDataOffset = readUint64(view, offset);
+    offset += 8;
+  }
+  offset += flags & TFHD.SampleDescriptionIndex ? 4 : 0;
+  const fields = [
+    [TFHD.DefaultDuration, "DefaultDuration"],
+    [TFHD.DefaultSize, "DefaultSize"],
+    [TFHD.DefaultFlags, "DefaultFlags"]
+  ];
+  for (const [flag, field] of fields) {
+    if (flags & flag) {
+      if (offset + 4 > tfhd.End) {
+        return null;
+      }
+      header[field] = view.getUint32(offset);
+      offset += 4;
+    }
+  }
+  return header;
+}
+function readDecodeTime(view, tfdt) {
+  const version = view.getUint8(tfdt.Start);
+  const offset = tfdt.Start + FULL_BOX_HEADER_BYTES;
+  if (offset + (version === 1 ? 8 : 4) > tfdt.End) {
+    return null;
+  }
+  return version === 1 ? readUint64(view, offset) : view.getUint32(offset);
+}
+function readTrackRunLayout(view, trun) {
+  const flags = readFlags(view, trun);
+  let offset = trun.Start + FULL_BOX_HEADER_BYTES;
+  const fixedBytes = 4 + (flags & TRUN.DataOffset ? 4 : 0) + (flags & TRUN.FirstSampleFlags ? 4 : 0);
+  const recordBytes = 4 * TRUN_SAMPLE_FIELDS.filter((field) => flags & field).length;
+  if (offset + fixedBytes > trun.End) {
+    return null;
+  }
+  const count = view.getUint32(offset);
+  if (count > MAX_RUN_SAMPLES || offset + fixedBytes + count * recordBytes > trun.End) {
+    return null;
+  }
+  offset += 4;
+  const dataOffset = flags & TRUN.DataOffset ? view.getInt32(offset) : void 0;
+  offset += dataOffset === void 0 ? 0 : 4;
+  const firstSampleFlags = flags & TRUN.FirstSampleFlags ? view.getUint32(offset) : void 0;
+  offset += firstSampleFlags === void 0 ? 0 : 4;
+  return { Version: view.getUint8(trun.Start), Flags: flags, Count: count, DataOffset: dataOffset, FirstSampleFlags: firstSampleFlags, FirstRecord: offset, RecordBytes: recordBytes };
+}
+function readTrackRun(view, trun, context) {
+  const layout = readTrackRunLayout(view, trun);
+  if (!layout) {
+    return null;
+  }
+  if (layout.DataOffset !== void 0) {
+    context.DataPosition = context.BaseOffset + layout.DataOffset;
+  }
+  const samples = [];
+  for (let i = 0; i < layout.Count; i++) {
+    const sample = readRunSample(view, layout, i, context);
+    if (!sample) {
+      return null;
+    }
+    samples.push(sample);
+  }
+  return samples;
+}
+function readRunSample(view, layout, index, context) {
+  const { Header: header, Track: track } = context;
+  let position = layout.FirstRecord + index * layout.RecordBytes;
+  const field = (flag) => {
+    if (!(layout.Flags & flag)) {
+      return void 0;
+    }
+    position += 4;
+    return flag === TRUN.CompositionOffset && layout.Version === 1 ? view.getInt32(position - 4) : view.getUint32(position - 4);
+  };
+  const duration = field(TRUN.Duration) ?? header.DefaultDuration ?? track?.DefaultSampleDuration ?? 0;
+  const size = field(TRUN.Size) ?? header.DefaultSize ?? track?.DefaultSampleSize;
+  const firstSampleFlags = index === 0 ? layout.FirstSampleFlags : void 0;
+  const sampleFlags = field(TRUN.Flags) ?? firstSampleFlags ?? header.DefaultFlags ?? track?.DefaultSampleFlags ?? 0;
+  const compositionOffset = field(TRUN.CompositionOffset) ?? 0;
+  if (size === void 0) {
+    return null;
+  }
+  const start = context.DataPosition;
+  const inPiece = start >= 0 && start + size <= view.byteLength;
+  const sample = {
+    TrackID: header.TrackID,
+    DecodeTime: context.DecodeTime,
+    CompositionOffset: compositionOffset,
+    Duration: duration,
+    Size: size,
+    IsSync: (sampleFlags & SAMPLE_IS_NON_SYNC) === 0,
+    Data: inPiece ? new Uint8Array(view.buffer, view.byteOffset + start, size) : null
+  };
+  context.DecodeTime += duration;
+  context.DataPosition += size;
+  return sample;
+}
+var BitReader = class {
+  constructor(view, start, end) {
+    this.view = view;
+    this.end = end;
+    this.position = start * 8;
+  }
+  /** The next `count` bits (at most 32) as a number, or `null` when fewer remain. */
+  Read(count) {
+    if (this.position + count > this.end * 8) {
+      return null;
+    }
+    let value = 0;
+    for (let i = 0; i < count; i++) {
+      const byte = this.view.getUint8(this.position >> 3);
+      value = value * 2 + (byte >> 7 - (this.position & 7) & 1);
+      this.position++;
+    }
+    return value;
+  }
+};
+function hex2(value) {
+  return value.toString(16).padStart(2, "0");
+}
+
+// ../../AI/Core/dist/generic/realtimeVideoOutput.js
+var FMP4_MIME_TYPE = "video/mp4";
+var FMP4_MIME_PATTERN = /^video\/mp4\s*(;|$)/i;
+function Fmp4PieceToVideoFrame(data, mimeType, init) {
+  const label = mimeType?.trim() ?? "";
+  const labelledMp4 = FMP4_MIME_PATTERN.test(label);
+  const piece = SniffFmp4Piece(data) ?? (labelledMp4 ? "fragment" : null);
+  if (!piece) {
+    return null;
+  }
+  const frame = { Kind: "fmp4", Piece: piece, Data: data, MimeType: labelledMp4 ? label : FMP4_MIME_TYPE };
+  return { ...frame, ...piece === "init" ? initPictureSize(data) : fragmentTiming(data, init) };
+}
+function initPictureSize(data) {
+  const video = ReadFmp4Init(data)?.Tracks.find((track) => track.Handler === "vide");
+  return video?.Width && video.Height ? { Width: video.Width, Height: video.Height } : {};
+}
+function fragmentTiming(data, init) {
+  const video = init?.Tracks.find((track) => track.Handler === "vide");
+  if (!video?.Timescale) {
+    return {};
+  }
+  const first = ReadFmp4Fragment(data, init)?.Samples.find((sample) => sample.TrackID === video.TrackID);
+  return first ? { PresentationTimeMs: (first.DecodeTime + first.CompositionOffset) / video.Timescale * 1e3, KeyFrame: first.IsSync } : {};
+}
+
+export {
+  RealtimeDiagLog,
+  ParseRealtimeClientTransport,
+  ExtractToolSchedulingHint,
+  ResolveResponseDoneUsage,
+  ParseModelConfiguration,
+  ParseVendorConfiguration,
+  ResolveEffectiveModelConfiguration,
+  IsTranscriptContinuation,
+  REALTIME_RELAY_TIME_LIMIT_CLOSE_CODE,
+  RealtimeToolBatchBarrier,
+  ParseDurationToMs,
+  RealtimeSessionResumption,
+  RealtimeConnectionSetup,
+  RealtimeTrackKey,
+  IsPcmAudioMimeType,
+  DEFAULT_REALTIME_AUDIO_TRACKS,
+  ResolveRequestedTracks,
+  VideoSourceSeenNote,
+  VideoSourceTurnedOffNote,
+  VideoSourceTurnedOnNote,
+  REALTIME_DEFAULT_INBOUND_VIDEO_RATE,
+  RealtimeVideoFrameIntervalMs,
+  RealtimeMinVideoFrameSpacingMs,
+  ScaleRealtimeVideoFrame,
+  SniffFmp4Piece,
+  ReadFmp4Init,
+  Fmp4VideoSeconds,
+  Fmp4PieceToVideoFrame
+};