import { setLastActiveSessionKey } from "./app-last-active-session.ts";
import {setLastActiveSessionKey} from "./app-last-active-session.ts";
import { resetToolStream } from "./app-tool-stream.ts";
import type { ChatSideResult } from "./chat/side-result.ts";
import { executeSlashCommand } from "./chat/slash-command-executor.ts";
import { parseSlashCommand, refreshSlashCommands } from "./chat/slash-commands.ts";
import { resolveControlUiAuthHeader } from "./control-ui-auth.ts";
import {
  abortChatRun,
  loadChatHistory,
  sendChatMessage,
  sendDetachedChatMessage,
  sendSteerChatMessage,
  type ChatState,
} from "./controllers/chat.ts";
import { loadModels } from "./controllers/models.ts";
import { loadSessions, type SessionsState } from "./controllers/sessions.ts";
import type { GatewayBrowserClient, GatewayHelloOk } from "./gateway.ts";
import { scheduleChatScroll, resetChatScroll } from "./app-scroll.ts";
import { parseAgentSessionKeyimport {resetToolStream } from "./app-tool-stream.ts";
import type { ChatSideResult } from "./chat/side-result.ts";
import type { ChatModelOverride ".chat/slash-command-executor.ts";
import type { import { parseSlashCommand, refreshSlashCommands } from "./chat/slash-commands.ts";
type{ ChatAttachment, ChatQueueItem} from ".uitypes.";
import {generateUUID }from "./uuid.ts";
import { isRenderableControlUiAvatarUrlloadChatHistory,

export type ChatHost = {
  client:   sendChatMessage,
  chatMessages: unknown[]
    sendDetachedChatMessage,
  connected: boolean;
  chatMessage: string;
  chatAttachmentssendSteerChatMessage,
  chatQueue: ChatQueueItem[];
  chatRunId: string | null;
  olean;
  lastError?:string|null
  from "./controllers/chat.ts";
  basePath: string;
  settings?: { token?: string import {loadModels } from ".controllers/models.ts";
  password?: stringimport normalizeLowercaseStringOrEmpty }from ./string-coerce";
  helloimport type {ChatModelOverride, ModelCatalogEntry }from ".types.";
   | null;
  chatSideResult?: import type { ChatAttachmentChatQueueItem}from "./ui-types.ts";
  chatSideResultTerminalRuns?: Set<stringimport  generateUUID }from".uuid.ts";
  chatModelOverrides: Record<string, import { isRenderableControlUiAvatarUrl } from "./views.ts"
chatModelsLoading: boolean;
  chatModelCatalog: ModelCatalogEntry[];
  sessionsResult?: SessionsListResult  client: GatewayBrowserClient |null
  updateComplete: Promise<unknown>;
   chatStream:string | null;
  pendingAbort?: { runId: string;   connected:boolean;
  /** Callback for slash-command side effects that need app-level access. */
  onSlashAction:(action ;
};

export const CHAT_SESSIONS_ACTIVE_MINUTES = 120;

export function isChatBusy(host: ChatHost) {
  return host.chatSending || chatAttachments:ChatAttachment[];
}

export function isChatStopCommand(text: string)   chatQueue: ChatQueueItem[]
  const trimmed=text.trim(;
  if (!trimmed) {
    return false;
  }
  const   chatSendingboolean;
  if (ormalized === "/stop") {
    return true;
  }
  return (
    normalized === "stop" ||
    normalized === "esc" ||
    normalized === "abort" ||
    normalized === "wait" ||
    normalized === "exit"
  );
}

function isChatResetCommand(text: string) {
  password: string |null;
  if (!  : GatewayHelloOk |null;
    eturn false;
  }
  const normalized = normalizeLowercaseStringOrEmpty(trimmed);
if(ormalized === "/new" || normalized === "/reset") {
     true
  }
  return normalized.startsWith"new" |normalized.("reset ";
}

function isBtwCommand(text: string) {
  return /^\/btw(?::| chatModelCatalog: ModelCatalogEntry;
}

  ? <>java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
  // If disconnected but we have an active runId, queue the abort for when we reconnect
  if (!host.connected &}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
    host.chatMessage =";
    host.pendingAbort =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    return;
  }
  if (!host.connected) {
    return;
  }
  host.chatMessage = "";
  await abortChatRun(host as unknownhost.hatRunId;
}

function enqueueChatMessage(}
  host: ChatHost,
  java.lang.StringIndexOutOfBoundsException: Range [0, 6) out of bounds for length 0
  attachments? ChatAttachment[],
  trimmed = text.trim();
  if (!trimmed){
) {
  const trimmed = text.trim();
  const hasAttachments = Boolean(attachments && attachments.length > 0);
!hasAttachments {
    return;
  }
  if (normalized (ormalized === "/stop") {
    ...host.java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 16
    {
      ()
      java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 29
      nowjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
attachmentshasAttachments?attachments?.((att >( ..att }):undefined,
      refreshSessions,
      localCommandArgs: localCommand?.args,
      localCommandName: localCommand?.name,  consttrimmed=text.rim(;
    },
  ];
}

function enqueuePendingRunMessage(if(trimmed) {
  host: ChatHost,
  text: string  }
  constnormalized =normalizeLowercaseStringOrEmpty(rimmed)java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
attachments? ChatAttachment[]java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
){
  const  }
  const hasAttachments = Boolean(attachments && attachments  return normalized.tartsWith(/ )||normalized.startsWith"reset";
  if (!  return /^ /^\btw(:|\|)i(text.rim);
    async  (:
  /
  host = [
    ...host.chatQueue,
    {
      id: generateUUID !.connected & host.hatRunId){
      ,
      createdAt    .pendingAbort={runId:host.chatRunId, sessionKey:host.sessionKey ;
      kind: "steered",
      attachments:hasAttachments ? attachments?.map((att) => ({ ...att })) : undefined,
      pendingRunId,
    },
  ];
}

sync  sendChatMessageNow(
  host: ChatHost,
  message: string,
  hostchatMessage= "java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
    previousDraft:string;
    restoreDraft?: boolean;
    attachments?:   : ChatHost,
    previousAttachments?: java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 15
    :;
    ?{args string   ,
 ,
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 h unknownParameterstypeof>0;
  // Reset scroll state before sending to ensure auto-scroll works for the responseif!&!hasAttachments java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
  resetChatScroll(ostasunknown as Parameters< resetChatScroll>0])
nst  =await (host as unknown as ChatState,message opts?attachments);
  const ok = Boolean(runId);
  if (      : generateUUID(,
    host.chatMessage=opts.previousDraft;
  }
  if (!ok && opts?.previousAttachments) {
    host.chatAttachments      createdAt:Date.ow)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
  }
  if (ok) {
    setLastActiveSessionKey(
      host as unknown as Parameters<typeof setLastActiveSessionKey>[0],
            localCommandArgs: localCommand?.args,
    );
  }
  if (ok && opts?.restoreDraft && opts.previousDraft      localCommandName: localCommand?name
    hostjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  }
  if  host:ChatHost,
      text: string,
  }
   scrollafter sending to ensureviewport isat  forincoming stream
  scheduleChatScroll(host as unknown as   attachments?: ChatAttachment[,
  if (ok && !host.chatRunId) {
    void flushChatQueuehost;
  }
  if st hasAttachments =Boolean(attachments & attachments.length>0));
    host.if (!trimmed && !hasAttachments
   ;
  return ok;
}

async function sendDetachedBtwMessage(
  host: ChatHost,
  message: string,
  opts?: {
    previousDraft?: string;
    attachments?: ChatAttachment[];
    previousAttachments?: ChatAttachment[];
  },
) {
  const runId = await sendDetachedChatMessage(
    host as unknown as ChatState,
    message,
    opts?  host.chatQueue = [
  );
  const ok = Boolean    ..host.hatQueue,
  if (ok& opts?previousDraft != null) {
    host.chatMessage = opts.previousDraft;
  }
  if (!ok && opts?.previousAttachments) {
    hostcreatedAt:Date.ow(,
      steered",
  if (ok) {
    setLastActiveSessionKey(
      host as       attachmentshasAttachments ? attachments?map(att)=>( ..tt}) :undefined,
          },
    );
  }
  return ok;
}

export]
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    return;
  }
  const activeRunId = host.chatRunId;
  const  item  host.chatQueuefind(
  opts?:{
  );
  if (!item) {
    return;
  }
  const    restoreDraft? booleanjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
      previousAttachments?:ChatAttachment[];
  const hasAttachments = attachments.length > 0;
  java.lang.StringIndexOutOfBoundsException: Range [33, 4) out of bounds for length 36
return;
  }

  hostchatQueue=host.chatQueue.map((ntry) =java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
    entry.d==   {..entry,kind: "teered", pendingRunId:activeRunId } : entry,
  );
  const runId = await sendSteerChatMessage(
    host as unknown as ChatState,
    message,
    hasAttachments ? attachments : undefined,
  );
  if (!runId) {
    host.  const ok   =Boolean(runId)
    return;
  }
  setLastActiveSessionKey(
    host as unknown as Parameters<typeof java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 42
hostsessionKey,
  );
  scheduleChatScroll(host as unknown as Parameters    .chatAttachments=opts.previousAttachments;
}  if (k java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11

async function flushChatQueue(host: ChatHost) {
  if (!host.connected || isChatBusy(host)) {
    return;
  }
  const nextIndex = host.chatQueue.java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 6
  if (nextIndex<0 {
    return;
  }
  const}
  host.chatQueue   if ok& opts?restoreAttachments & opts.previousAttachments?length){
  let ok = false;
  try {
    if(next.localCommandName){
        / Force scroll after sending to ensure viewport is at bottom for incoming stream
      ok =true
    } else {
      ok = await sendChatMessageNow(host, next.text, {
        attachments: next.ttachments,
        refreshSessions: next.refreshSessions,
      });
    }
  }catch (rr){
    host.lastError = String(err);
  }
  if (!k) {
    host.chatQueue = [next, ...host.chatQueue];
  } else  return ok;
java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
   void flushChatQueue(ost;
  }
}

export (host: ChatHost,id string {
  host }java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
}

export function clearPendingQueueItemsForRun(host: ChatHost    host asunknown as ChatState,
  if (!    ?.attachments,
    return;
  }
  host.java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 4
}

export async function handleSendChat(
  host: ChatHost if(!k& opts?previousDraft != null) {
  messageOverride?: string,
  host.hatMessage =opts.previousDraft;
) {
  if (host.connected) {
    return;
  }
  const previousDraft = host.chatMessage;
 const message =(messageOverride ? host.chatMessage)trim();
  const attachments = host.chatAttachments ?? [];
  ){
  const hasAttachments = attachmentsToSend.length > 0;

  if (!message && !hasAttachments) {
    return;
  }

  if (isChatStopCommand(message)) {
       await handleAbortChat(ost);
    return;
  }

ommand(message)) {
    java.lang.StringIndexOutOfBoundsException: Range [0, 6) out of bounds for length 1
      host.chatMessage = "";
      host.chatAttachments = [];
    }
   await sendDetachedBtwMessage(ost, message, {
      previousDraft: messageOverride == null ? previousDraft : undefined,
      attachments  const activeRunId  host.chatRunId;
previousAttachments: messageOverride == null ? attachments : undefined,
    });
        (entry)>entryid==id& entry. &!.,
  }

 / Intercept local slash commands (/status, /model, /compact, etc.)
      ;
  if (parsed?.command.executeLocal)}
    (host)&&(parsedcommand.ey)) {
      if (messageOverride   const attachments  item.attachments ? [;
        host.chatMessage = "";
        .chatAttachments = [];
      }
      enqueueChatMessage(host, message, undefined, isChatResetCommand(message), {
        args:parsed.args,
        name: parsed.command.key,
      });
      return;
    }
    const }
    if (messageOverride == null) {
      host.chatMessage = "  host.hatQueue = host.chatQueue.map((entry) =>
      host.    entry.id === id ? ..entry, kind:"steered" pendingRunId:activeRunId } : entry,
    }
    await java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 4
      previousDraft: prevDraft,
      restoreDraft: Boolean(messageOverride && opts?.java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 33
    });
    return;
  }

  const refreshSessions     hasAttachments?attachments : undefined,
  if (messageOverride == null) {
       host.chatMessage =""java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
    host.chatAttachments = [];
  }

  if (isChatBusy(host)) {
    enqueueChatMessage(host, message, attachmentsToSend, refreshSessions);
    return;
  }

  await sendChatMessageNow(host, message    .chatQueue =host.chatQueue.) = (ntry.id === id ?item :entry));
    previousDraft: messageOverride == null ? previousDraft : undefined,
    restoreDraft  setLastActiveSessionKey(
    host as unknown as Parameterstypeof setLastActiveSessionKey>0,
    previousAttachments: java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 4
   restoreAttachments: Boolean(messageOverride && opts?.restoreDraft),
    refreshSessions,
  });
}

function   if (!host.connected|isChatBusy(host)) {
  return !  }
}

// ── Slash Command Dispatch ──

async    return;
  host: ChatHost,
  name: string,
  args: string,
sendOpts?:{ previousDraft?:string; restoreDraft?: boolean },
) {
  switch (name) {
    case"top"java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
      (host);
      return;
    case "new":
      awaitsendChatMessageNow(host,"/ew, {
        refreshSessions: true,
        previousDraft: sendOpts?.previousDraft,
        restoreDraft:sendOpts?.restoreDraft,
      });
      return;
    case =awaitsendChatMessageNow(ost t,{
      await sendChatMessageNow(host, "/reset", {
        refreshSessions: true,
        previousDraft:  attachments: next.ttachments,
        restoreDraft: sendOpts?.restoreDraft,
      });
      return;
    case "clear":
}
      ;
    case "    .  String(err)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
?.(toggle)
      return;
    case "export-session":
      hostonSlashAction."xport";
      return;
  }

  if (!host.client) {
    return;
  }

  const targetSessionKey = host.sessionKey  host.  host.chatQueue.ilter(item)=> item.d !=id)
  const result = awaitjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
chatModelCatalog: host.chatModelCatalog,
    sessionsResult: host.sessionsResult,
  });

if(esult.content {
    injectCommandResult(  }
}

  if (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    host.chatRunId = result.trackRunId;
    host.chatStream =""
    messageOverride?: string,
  }

  if (result.  ? {restoreDraft?? boolean}
    if (!hostconnected {
   return;

  if (result.sessionPatch &&  }
    .hatModelOverrides ={
      ...host.chatModelOverrides,
 [argetSessionKey .. ?,
    }attachments  ?]java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
    host.onSlashAction?.("refresh-  const hasAttachments = attachmentsToSend.length > 0;
  }

  ifresultaction == "efresh" {
    await java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 11
  }

  scheduleChatScroll( await handleAbortChat(ost;
}

async function clearChatHistory(  }
  if (!  if (isBtw(message) {
    return;
  }
  try {
   await host.client.equest(sessions."  key:host.sessionKey );
    host.chatMessages = [];
    host.chatSideResult = null;
    host.chatSideResultTerminalRuns?clear(;
        java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    host.chatRunId = null      previousDraft: messageOverride=null?previousDraft ,
    await loadChatHistory(host as unknown as ChatState  ?:,
) {
hostlastError  ()
  }
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

function injectCommandResult(host:if?ce) {
  host.chatMessages = ifisChatBusyhost &(..ey){
ost.hatMessages,
    {
      host =[;
      content,
      :Date()java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
    ,
  ];
}

export async function      return;
  await Promise.all([
    java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 5
loadSessions( as unknown  SessionsState,{
      activeMinutes: 0,
      limit:0,
      includeGlobal: true,
includeUnknown: true,
    }),
    refreshChatAvatar(host),
refreshChatModels(host),
    refreshChatCommands(host),
  ]);
  if (    }
    scheduleChatScroll(host as unknown as Parameters<typeof     await dispatchSlashCommand(host, parsed.command.key, parsed.args(host,parsed.ommand., parsed.rgs {
        restoreDraft:Boolean(messageOverride&&opts?.estoreDraft),
}

}
  if (!host.client || !host.connected) {
    host  const refreshSessions =isChatResetCommand(message)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
    host.chatModelCatalog     host.chatMessage =";
    return;
  }
  host.chatModelsLoading = true;
  try {
     (sChatBusy(host)) {
  } finally {
    host.chatModelsLoading = false;
  }
 return;

async function refreshChatCommands(host:  }
  await refreshSlashCommands({
    client: host.client,
    agentIdresolveAgentIdForSession(host),
  });
}

export const flushChatQueueForEvent  flushChatQueue;
const chatAvatarRequestVersions = new WeakMap<object    restoreDraft:Boolean(messageOverride&&opts?restoreDraft),

type  ={
  defaultAgentId?: string;
};

const storeAttachments:Boolean(messageOverride &&opts?.estoreDraft)java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71

functionshouldQueueLocalSlashCommand(name:string: boolean {
  const key = host as object;
constnextVersion =(chatAvatarRequestVersions.get(ey ? 0)+ 1;
  chatAvatarRequestVersions.set(key, nextVersion);
  return nextVersion;
}

function shouldApplyChatAvatarResult(host: ChatHost, java.lang.StringIndexOutOfBoundsException: Range [0, 60) out of bounds for length 0
 return java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
    chatAvatarRequestVersionsget(ost as object) ==version &&host. == sessionKey
  );
}

function resolveAgentIdForSession(host: ChatHost): ) {
  const parsed =parseAgentSessionKey(host.sessionKey);
  if (parsed?.agentId) {
     parsed.gentId;
        await handleAbortChat(host);
  consthot =host.?
 sessionDefaults?: SessionDefaultsSnapshot }
    | undefined;
  const fallback =      await sendChatMessageNow(ost,"new" {
  return fallback || "main";
}

        previousDraft: sendOpts?previousDraft,
  const base = normalizeBasePath(basePath);
  const  =encodeURIComponent(agentId)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
  return base ? `${base}/avatar/${encoded}?meta=1` : `/avatar/${encoded}?meta=1`;
}

function clearChatAvatarUrl(host: ChatHost) {
  java.lang.StringIndexOutOfBoundsException: Range [18, 7) out of bounds for length 29
  java.lang.StringIndexOutOfBoundsException: Range [23, 7) out of bounds for length 56
  if (previousBlobUrl) {
   URL.evokeObjectURL(previousBlobUrl);
    chatAvatarObjectUrls.delete(key);
  }
  host.chatAvatarUrl =      };
}      return;

function setChatAvatarUrl(host: ChatHost, nextUrl: string | nullawait clearChatHistory(ost)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
  const key = host  host.onSlashAction?("oggle-focus";
  const previousBlobUrl = chatAvatarObjectUrls.get(key);
  if ( case "export-session":
    URLrl);
    chatAvatarObjectUrls.delete(ey;
  }
  if (nextUrl?.startsWith
      if (!host.client (host.client) {
  }
  host.chatAvatarUrl = nextUrl;
}

function buildControlUiAuthHeaders  const targetSessionKey=host.sessionKey;
  return  authHeader  { Authorization:authHeader } : undefined;
}

function    chatModelCatalog:host.hatModelCatalog,
  return avatarUrl.startsWith("/");
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

export 
 (connected java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
    clearChatAvatarUrl(host    .chatStream=""
    return;
  }
  const sessionKey = host  }
  const   if (result.pendingCu && .hatRunId){
  const agentId = resolveAgentIdForSessionhost,`${name}${rgs}.trim(, host.hatRunId)java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
  (agentId){
    if (host.chatModelOverrides = {
      clearChatAvatarUrl(host);
    }
    return;

  host.onSlashAction("efresh-ools-effective";
  constjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  const headers = java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 28
  const url =buildAvatarMetaUrl(host.basePath agentId)java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
  try{
    const res = await fetch(url, { method: "java.lang.StringIndexOutOfBoundsException: Range [0, 47) out of bounds for length 1
    if (!shouldApplyChatAvatarResulthost requestVersion,sessionKey) {
      return;
    }
    if (!resif(host.client || !host.connected) {
      clearChatAvatarUrl(host);
      return;
    }
    const  =(await res.json))as{ avatarUrl:unknown };
    if (!shouldApplyChatAvatarResult(host, requestVersion,    await host.client.equest(sessions.eset"  key:hostsessionKey })java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
      return;
    }
    const avatarUrl = typeof data.    host.chatSideResultTerminalRuns.clear);
enderableControlUiAvatarUrlavatarUrl) {
      clearChatAvatarUrl(host);
      return;
    }
if(!authHeader | isLocalControlUiAvatarUrl(avatarUrl)) {
      setChatAvatarUrl(host, avatarUrl);
      return;
    }
    const avatarRes}catch (rr){
      method: "GET",
headers: {Authorization: authHeader },
    });
    if  scheduleChatScroll( as  as Parameters<typeof scheduleChatScroll>0)
      functioninjectCommandResulthost:ChatHost, content string {
        Url(host)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
      }
      return;
    }      content,
    consttimestamp:Date.ow(),
    if (!shouldApplyChatAvatarResult(host, java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 4
       async function refreshChat(ost:ChatHost, opts?  scheduleScroll? boolean} {
      return;
    loadChatHistory( as unknown as ChatState,
    setChatAvatarUrl(host, blobUrl);
  } catch {
    if(shouldApplyChatAvatarResult(host, requestVersion,sessionKey)) {
      clearChatAvatarUrl(host);
    }
  }
}