@hiai-gg/hiai-opencode 0.1.7 → 0.1.8

package/src/hooks/runtime-fallback/message-update-handler.ts

@@ -1,168 +0,0 @@
-import type { HookDeps } from "./types"
-import type { AutoRetryHelpers } from "./auto-retry"
-import { HOOK_NAME } from "./constants"
-import { log } from "../../shared/logger"
-import { extractStatusCode, extractErrorName, classifyErrorType, isRetryableError, extractAutoRetrySignal, containsErrorContent } from "./error-classifier"
-import { createFallbackState } from "./fallback-state"
-import { getFallbackModelsForSession } from "./fallback-models"
-import { resolveFallbackBootstrapModel } from "./fallback-bootstrap-model"
-import { dispatchFallbackRetry } from "./fallback-retry-dispatcher"
-import { hasVisibleAssistantResponse } from "./visible-assistant-response"
-
-export { hasVisibleAssistantResponse } from "./visible-assistant-response"
-
-export function createMessageUpdateHandler(deps: HookDeps, helpers: AutoRetryHelpers) {
-  const { ctx, config, pluginConfig, sessionStates, sessionLastAccess, sessionRetryInFlight, sessionAwaitingFallbackResult, sessionStatusRetryKeys } = deps
-  const checkVisibleResponse = hasVisibleAssistantResponse(extractAutoRetrySignal)
-
-  return async (props: Record<string, unknown> | undefined) => {
-    const info = props?.info as Record<string, unknown> | undefined
-    const sessionID = info?.sessionID as string | undefined
-    const timeoutEnabled = config.timeout_seconds > 0
-    const eventParts = props?.parts as Array<{ type?: string; text?: string }> | undefined
-    const infoParts = info?.parts as Array<{ type?: string; text?: string }> | undefined
-    const parts = eventParts && eventParts.length > 0 ? eventParts : infoParts
-    const retrySignalResult = extractAutoRetrySignal(info)
-    const partsText = (parts ?? [])
-      .filter((p) => typeof p?.text === "string")
-      .map((p) => (p.text ?? "").trim())
-      .filter((text) => text.length > 0)
-      .join("\n")
-    const retrySignalFromParts = partsText
-      ? extractAutoRetrySignal({ message: partsText, status: partsText, summary: partsText })?.signal
-      : undefined
-    const retrySignal = retrySignalResult?.signal ?? retrySignalFromParts
-    const errorContentResult = containsErrorContent(parts)
-    const error = info?.error ?? 
-      (retrySignal && timeoutEnabled ? { name: "ProviderRateLimitError", message: retrySignal } : undefined) ??
-      (errorContentResult.hasError ? { name: "MessageContentError", message: errorContentResult.errorMessage || "Message contains error content" } : undefined)
-    const role = info?.role as string | undefined
-    const model = info?.model as string | undefined
-
-    if (sessionID && role === "assistant" && !error) {
-      if (!sessionAwaitingFallbackResult.has(sessionID)) {
-        return
-      }
-
-      const hasVisible = await checkVisibleResponse(ctx, sessionID, info)
-      if (!hasVisible) {
-        log(`[${HOOK_NAME}] Assistant update observed without visible final response; keeping fallback timeout`, {
-          sessionID,
-          model,
-        })
-        return
-      }
-
-      sessionAwaitingFallbackResult.delete(sessionID)
-      sessionStatusRetryKeys.delete(sessionID)
-      helpers.clearSessionFallbackTimeout(sessionID)
-      const state = sessionStates.get(sessionID)
-      if (state?.pendingFallbackModel) {
-        state.pendingFallbackModel = undefined
-      }
-      log(`[${HOOK_NAME}] Assistant response observed; cleared fallback timeout`, { sessionID, model })
-      return
-    }
-
-    if (sessionID && role === "assistant" && error) {
-      sessionAwaitingFallbackResult.delete(sessionID)
-      if (sessionRetryInFlight.has(sessionID) && !retrySignal) {
-        log(`[${HOOK_NAME}] message.updated fallback skipped (retry in flight)`, { sessionID })
-        return
-      }
-
-      if (retrySignal && sessionRetryInFlight.has(sessionID) && timeoutEnabled) {
-        log(`[${HOOK_NAME}] Overriding in-flight retry due to provider auto-retry signal`, {
-          sessionID,
-          model,
-        })
-        await helpers.abortSessionRequest(sessionID, "message.updated.retry-signal")
-        sessionRetryInFlight.delete(sessionID)
-      }
-
-      if (retrySignal && timeoutEnabled) {
-        log(`[${HOOK_NAME}] Detected provider auto-retry signal`, { sessionID, model })
-      }
-
-      if (!retrySignal) {
-        helpers.clearSessionFallbackTimeout(sessionID)
-      }
-
-      log(`[${HOOK_NAME}] message.updated with assistant error`, {
-        sessionID,
-        model,
-        statusCode: extractStatusCode(error, config.retry_on_errors),
-        errorName: extractErrorName(error),
-        errorType: classifyErrorType(error),
-      })
-
-      if (!isRetryableError(error, config.retry_on_errors)) {
-        log(`[${HOOK_NAME}] message.updated error not retryable, skipping fallback`, {
-          sessionID,
-          statusCode: extractStatusCode(error, config.retry_on_errors),
-          errorName: extractErrorName(error),
-          errorType: classifyErrorType(error),
-        })
-        return
-      }
-
-      let state = sessionStates.get(sessionID)
-      const agent = info?.agent as string | undefined
-      const resolvedAgent = await helpers.resolveAgentForSessionFromContext(sessionID, agent)
-      const fallbackModels = getFallbackModelsForSession(sessionID, resolvedAgent, pluginConfig)
-
-      if (fallbackModels.length === 0) {
-        return
-      }
-
-      if (!state) {
-        const initialModel = resolveFallbackBootstrapModel({
-          sessionID,
-          source: "message.updated",
-          eventModel: model,
-          resolvedAgent,
-          pluginConfig,
-        })
-
-        if (!initialModel) {
-          log(`[${HOOK_NAME}] message.updated missing model info, cannot fallback`, {
-            sessionID,
-            errorName: extractErrorName(error),
-            errorType: classifyErrorType(error),
-          })
-          return
-        }
-
-        state = createFallbackState(initialModel)
-        sessionStates.set(sessionID, state)
-        sessionLastAccess.set(sessionID, Date.now())
-      } else {
-        sessionLastAccess.set(sessionID, Date.now())
-
-        if (state.pendingFallbackModel) {
-          if (retrySignal && timeoutEnabled) {
-            log(`[${HOOK_NAME}] Clearing pending fallback due to provider auto-retry signal`, {
-              sessionID,
-              pendingFallbackModel: state.pendingFallbackModel,
-            })
-            state.pendingFallbackModel = undefined
-          } else {
-          log(`[${HOOK_NAME}] message.updated fallback skipped (pending fallback in progress)`, {
-            sessionID,
-            pendingFallbackModel: state.pendingFallbackModel,
-          })
-          return
-          }
-        }
-      }
-
-      await dispatchFallbackRetry(deps, helpers, {
-        sessionID,
-        state,
-        fallbackModels,
-        resolvedAgent,
-        source: "message.updated",
-      })
-    }
-  }
-}

package/src/hooks/runtime-fallback/retry-model-payload.ts

@@ -1,30 +0,0 @@
-import { parseModelString } from "../../tools/delegate-task/model-string-parser"
-
-export function buildRetryModelPayload(
-  model: string,
-  agentSettings?: { variant?: string; reasoningEffort?: string },
-): { model: { providerID: string; modelID: string }; variant?: string; reasoningEffort?: string } | undefined {
-  const parsedModel = parseModelString(model)
-  if (!parsedModel) {
-    return undefined
-  }
-
-  const variant = parsedModel.variant ?? agentSettings?.variant
-  const reasoningEffort = agentSettings?.reasoningEffort
-
-  const payload: { model: { providerID: string; modelID: string }; variant?: string; reasoningEffort?: string } = {
-    model: {
-      providerID: parsedModel.providerID,
-      modelID: parsedModel.modelID,
-    },
-  }
-
-  if (variant) {
-    payload.variant = variant
-  }
-  if (reasoningEffort) {
-    payload.reasoningEffort = reasoningEffort
-  }
-
-  return payload
-}

package/src/hooks/runtime-fallback/session-messages.ts

@@ -1,38 +0,0 @@
-export type SessionMessagePart = {
-  type?: string
-  text?: string
-}
-
-export type SessionMessage = {
-  info?: Record<string, unknown>
-  parts?: SessionMessagePart[]
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null
-}
-
-function isSessionMessage(value: unknown): value is SessionMessage {
-  return isRecord(value)
-}
-
-function isSessionMessageArray(value: unknown): value is SessionMessage[] {
-  return Array.isArray(value) && value.every(isSessionMessage)
-}
-
-export function extractSessionMessages(messagesResponse: unknown): SessionMessage[] | undefined {
-  if (isSessionMessageArray(messagesResponse)) {
-    return messagesResponse
-  }
-
-  if (!isRecord(messagesResponse)) {
-    return undefined
-  }
-
-  const data = messagesResponse.data
-  if (isSessionMessageArray(data)) {
-    return data
-  }
-
-  return undefined
-}

package/src/hooks/runtime-fallback/session-status-handler.ts

@@ -1,126 +0,0 @@
-import type { HookDeps } from "./types"
-import type { AutoRetryHelpers } from "./auto-retry"
-import { HOOK_NAME, RETRYABLE_ERROR_PATTERNS } from "./constants"
-import { log } from "../../shared/logger"
-import { extractAutoRetrySignal } from "./error-classifier"
-import { createFallbackState } from "./fallback-state"
-import { getFallbackModelsForSession } from "./fallback-models"
-import { normalizeRetryStatusMessage, extractRetryAttempt } from "../../shared/retry-status-utils"
-import { resolveFallbackBootstrapModel } from "./fallback-bootstrap-model"
-import { dispatchFallbackRetry } from "./fallback-retry-dispatcher"
-
-export function createSessionStatusHandler(
-  deps: HookDeps,
-  helpers: AutoRetryHelpers,
-  sessionStatusRetryKeys: Map<string, string>,
-) {
-  const {
-    pluginConfig,
-    sessionStates,
-    sessionLastAccess,
-    sessionRetryInFlight,
-  } = deps
-
-  return async (props: Record<string, unknown> | undefined) => {
-    const sessionID = props?.sessionID as string | undefined
-    const status = props?.status as { type?: string; message?: string; attempt?: number } | undefined
-    const agent = props?.agent as string | undefined
-    const model = props?.model as string | undefined
-    const timeoutEnabled = deps.config.timeout_seconds > 0
-
-    if (!sessionID || status?.type !== "retry") return
-
-    const retryMessage = typeof status.message === "string" ? status.message : ""
-    const retrySignal = extractAutoRetrySignal({ status: retryMessage, message: retryMessage })
-    if (!retrySignal) {
-      // Fallback: status.type is already "retry", so check the message against
-      // retryable error patterns directly. This handles providers like Gemini whose
-      // retry status message may not contain "retrying in" text alongside the error.
-      const messageLower = retryMessage.toLowerCase()
-      const matchesRetryablePattern = RETRYABLE_ERROR_PATTERNS.some((pattern) => pattern.test(messageLower))
-      if (!matchesRetryablePattern) return
-    }
-
-    const retryKey = `${extractRetryAttempt(status.attempt, retryMessage)}:${normalizeRetryStatusMessage(retryMessage)}`
-    if (sessionStatusRetryKeys.get(sessionID) === retryKey) {
-      return
-    }
-    sessionStatusRetryKeys.set(sessionID, retryKey)
-
-    if (sessionRetryInFlight.has(sessionID)) {
-      if (timeoutEnabled) {
-        log(`[${HOOK_NAME}] Overriding in-flight retry due to provider auto-retry signal`, {
-          sessionID,
-          model,
-        })
-        await helpers.abortSessionRequest(sessionID, "session.status.retry-signal")
-        sessionRetryInFlight.delete(sessionID)
-      } else {
-        log(`[${HOOK_NAME}] session.status retry skipped - retry already in flight`, { sessionID })
-        return
-      }
-    }
-
-    const resolvedAgent = await helpers.resolveAgentForSessionFromContext(sessionID, agent)
-    const fallbackModels = getFallbackModelsForSession(sessionID, resolvedAgent, pluginConfig)
-    if (fallbackModels.length === 0) {
-      if (!sessionStates.has(sessionID)) {
-        sessionStatusRetryKeys.delete(sessionID)
-      }
-      return
-    }
-
-    let state = sessionStates.get(sessionID)
-    if (!state) {
-      const initialModel = resolveFallbackBootstrapModel({
-        sessionID,
-        source: "session.status",
-        eventModel: model,
-        resolvedAgent,
-        pluginConfig,
-      })
-      if (!initialModel) {
-        sessionStatusRetryKeys.delete(sessionID)
-        log(`[${HOOK_NAME}] session.status retry missing model info, cannot fallback`, { sessionID })
-        return
-      }
-
-      state = createFallbackState(initialModel)
-      sessionStates.set(sessionID, state)
-    }
-
-    sessionLastAccess.set(sessionID, Date.now())
-
-    if (state.pendingFallbackModel) {
-      if (timeoutEnabled) {
-        log(`[${HOOK_NAME}] Clearing pending fallback due to provider auto-retry signal`, {
-          sessionID,
-          pendingFallbackModel: state.pendingFallbackModel,
-        })
-        state.pendingFallbackModel = undefined
-      } else {
-        log(`[${HOOK_NAME}] session.status retry skipped (pending fallback in progress)`, {
-          sessionID,
-          pendingFallbackModel: state.pendingFallbackModel,
-        })
-        return
-      }
-    }
-
-    log(`[${HOOK_NAME}] Detected provider auto-retry signal in session.status`, {
-      sessionID,
-      model: state.currentModel,
-      retryAttempt: status.attempt,
-    })
-
-    await helpers.abortSessionRequest(sessionID, "session.status.retry-signal")
-
-    await dispatchFallbackRetry(deps, helpers, {
-      sessionID,
-      state,
-      fallbackModels,
-      resolvedAgent,
-      source: "session.status",
-    })
-  }
-}

package/src/hooks/runtime-fallback/types.ts

@@ -1,77 +0,0 @@
-import type { RuntimeFallbackConfig, HiaiOpenCodeConfig } from "../../config"
-
-export interface RuntimeFallbackInterval {
-  unref: () => void
-}
-
-export type RuntimeFallbackTimeout = object | number
-
-export interface RuntimeFallbackPluginInput {
-  client: {
-    session: {
-      abort: (input: { path: { id: string } }) => Promise<unknown>
-      messages: (input: { path: { id: string }; query: { directory: string } }) => Promise<unknown>
-      promptAsync: (input: {
-        path: { id: string }
-        body: {
-          agent?: string
-          model: { providerID: string; modelID: string }
-          parts: Array<{ type: "text"; text: string }>
-        }
-        query: { directory: string }
-      }) => Promise<unknown>
-    }
-    tui: {
-      showToast: (input: {
-        body: {
-          title: string
-          message: string
-          variant: "success" | "error" | "info" | "warning"
-          duration: number
-        }
-      }) => Promise<unknown>
-    }
-  }
-  directory: string
-}
-
-export interface FallbackState {
-  originalModel: string
-  currentModel: string
-  fallbackIndex: number
-  failedModels: Map<string, number>
-  attemptCount: number
-  pendingFallbackModel?: string
-}
-
-export interface FallbackResult {
-  success: boolean
-  newModel?: string
-  error?: string
-  maxAttemptsReached?: boolean
-}
-
-export interface RuntimeFallbackOptions {
-  config?: RuntimeFallbackConfig
-  pluginConfig?: HiaiOpenCodeConfig
-  session_timeout_ms?: number
-}
-
-export interface RuntimeFallbackHook {
-  event: (input: { event: { type: string; properties?: unknown } }) => Promise<void>
-  "chat.message"?: (input: { sessionID: string; agent?: string; model?: { providerID: string; modelID: string } }, output: { message: { model?: { providerID: string; modelID: string } }; parts?: Array<{ type: string; text?: string }> }) => Promise<void>
-  dispose?: () => void
-}
-
-export interface HookDeps {
-  ctx: RuntimeFallbackPluginInput
-  config: Required<RuntimeFallbackConfig>
-  options: RuntimeFallbackOptions | undefined
-  pluginConfig: HiaiOpenCodeConfig | undefined
-  sessionStates: Map<string, FallbackState>
-  sessionLastAccess: Map<string, number>
-  sessionRetryInFlight: Set<string>
-  sessionAwaitingFallbackResult: Set<string>
-  sessionFallbackTimeouts: Map<string, RuntimeFallbackTimeout>
-  sessionStatusRetryKeys: Map<string, string>
-}

package/src/hooks/runtime-fallback/visible-assistant-response.ts

@@ -1,80 +0,0 @@
-import type { HookDeps } from "./types"
-import type { SessionMessage, SessionMessagePart } from "./session-messages"
-import { extractSessionMessages } from "./session-messages"
-import { extractAutoRetrySignal } from "./error-classifier"
-
-function getLastUserMessageIndex(messages: SessionMessage[]): number {
-  for (let index = messages.length - 1; index >= 0; index--) {
-    if (messages[index]?.info?.role === "user") {
-      return index
-    }
-  }
-
-  return -1
-}
-
-function getAssistantText(parts: SessionMessagePart[] | undefined): string {
-  return (parts ?? [])
-    .flatMap((part) => {
-      if (part.type !== "text") {
-        return []
-      }
-
-      const text = typeof part.text === "string" ? part.text.trim() : ""
-      return text.length > 0 ? [text] : []
-    })
-    .join("\n")
-}
-
-export function hasVisibleAssistantResponse(extractAutoRetrySignalFn: typeof extractAutoRetrySignal) {
-  return async (
-    ctx: HookDeps["ctx"],
-    sessionID: string,
-    _info: Record<string, unknown> | undefined,
-  ): Promise<boolean> => {
-    try {
-      const messagesResponse = await ctx.client.session.messages({
-        path: { id: sessionID },
-        query: { directory: ctx.directory },
-      })
-      const messages = extractSessionMessages(messagesResponse)
-      if (!messages || messages.length === 0) return false
-
-      const lastUserMessageIndex = getLastUserMessageIndex(messages)
-      if (lastUserMessageIndex === -1) return false
-
-      for (let index = lastUserMessageIndex + 1; index < messages.length; index++) {
-        const message = messages[index]
-        if (message?.info?.role !== "assistant") {
-          continue
-        }
-
-        if (message.info?.error) {
-          continue
-        }
-
-        const infoParts = message.info?.parts
-        const infoMessageParts = Array.isArray(infoParts)
-          ? infoParts.filter((part): part is SessionMessagePart => typeof part === "object" && part !== null)
-          : undefined
-        const parts = message.parts && message.parts.length > 0
-          ? message.parts
-          : infoMessageParts
-        const assistantText = getAssistantText(parts)
-        if (!assistantText) {
-          continue
-        }
-
-        if (extractAutoRetrySignalFn({ message: assistantText })) {
-          continue
-        }
-
-        return true
-      }
-
-      return false
-    } catch {
-      return false
-    }
-  }
-}

package/src/hooks/session-notification-content.ts

@@ -1,145 +0,0 @@
-import { normalizeSDKResponse } from "../shared"
-
-type ReadyNotificationContext = {
-  client: {
-    session: {
-      get?: (input: { path: { id: string } }) => Promise<unknown>
-      messages?: (input: { path: { id: string }; query: { directory: string } }) => Promise<unknown>
-    }
-  }
-  directory: string
-}
-
-type SessionInfo = {
-  title?: string
-}
-
-type SessionMessagePart = {
-  type?: string
-  text?: string
-}
-
-type SessionMessage = {
-  info?: {
-    role?: string
-    error?: unknown
-  }
-  parts?: SessionMessagePart[]
-}
-
-type ReadyNotificationInput = {
-  sessionID: string
-  baseTitle: string
-  baseMessage: string
-}
-
-function extractMessageText(message: SessionMessage | undefined): string {
-  return (message?.parts ?? [])
-    .filter((part) => part.type === "text" && typeof part.text === "string")
-    .map((part) => part.text?.trim() ?? "")
-    .filter(Boolean)
-    .join("\n")
-}
-
-function collapseWhitespace(text: string): string {
-  return text
-    .split(/\r?\n/g)
-    .map((line) => line.trim())
-    .filter(Boolean)
-    .join(" ")
-}
-
-function getLastNonEmptyLine(text: string): string {
-  const lines = text
-    .split(/\r?\n/g)
-    .map((line) => line.trim())
-    .filter(Boolean)
-
-  return lines.at(-1) ?? ""
-}
-
-function findLastMessage(messages: SessionMessage[], role: "user" | "assistant"): SessionMessage | undefined {
-  for (let index = messages.length - 1; index >= 0; index--) {
-    const message = messages[index]
-    if (message.info?.role !== role) continue
-    if (role === "assistant" && message.info?.error) continue
-    if (!extractMessageText(message)) continue
-    return message
-  }
-
-  return undefined
-}
-
-async function readSessionTitle(
-  ctx: ReadyNotificationContext,
-  sessionID: string,
-): Promise<string> {
-  if (typeof ctx.client.session.get !== "function") {
-    return sessionID
-  }
-
-  try {
-    const response = await ctx.client.session.get({ path: { id: sessionID } })
-    const sessionInfo = normalizeSDKResponse(response, null as SessionInfo | null, {
-      preferResponseOnMissingData: true,
-    })
-
-    if (sessionInfo?.title && sessionInfo.title.trim().length > 0) {
-      return sessionInfo.title.trim()
-    }
-  } catch {
-  }
-
-  return sessionID
-}
-
-async function readSessionMessages(
-  ctx: ReadyNotificationContext,
-  sessionID: string,
-): Promise<SessionMessage[]> {
-  if (typeof ctx.client.session.messages !== "function") {
-    return []
-  }
-
-  try {
-    const response = await ctx.client.session.messages({
-      path: { id: sessionID },
-      query: { directory: ctx.directory },
-    })
-
-    const messages = normalizeSDKResponse(response, [] as SessionMessage[], {
-      preferResponseOnMissingData: true,
-    })
-
-    return Array.isArray(messages) ? messages : []
-  } catch {
-    return []
-  }
-}
-
-export async function buildReadyNotificationContent(
-  ctx: ReadyNotificationContext,
-  input: ReadyNotificationInput,
-): Promise<{ title: string; message: string }> {
-  const [sessionTitle, messages] = await Promise.all([
-    readSessionTitle(ctx, input.sessionID),
-    readSessionMessages(ctx, input.sessionID),
-  ])
-
-  const lastUserText = collapseWhitespace(extractMessageText(findLastMessage(messages, "user")))
-  const lastAssistantLine = getLastNonEmptyLine(
-    extractMessageText(findLastMessage(messages, "assistant")),
-  )
-
-  const detailLines = [
-    lastUserText ? `User: ${lastUserText}` : "",
-    lastAssistantLine ? `Assistant: ${lastAssistantLine}` : "",
-  ].filter(Boolean)
-
-  return {
-    title: `${input.baseTitle} · ${sessionTitle}`,
-    message: detailLines.length > 0
-      ? [input.baseMessage, ...detailLines].join("\n")
-      : input.baseMessage,
-  }
-}

package/src/hooks/session-notification-formatting.ts

@@ -1,25 +0,0 @@
-export function escapeAppleScriptText(input: string): string {
-  return input.replace(/\\/g, "\\\\").replace(/"/g, '\\"')
-}
-
-export function escapePowerShellSingleQuotedText(input: string): string {
-  return input.replace(/'/g, "''")
-}
-
-export function buildWindowsToastScript(title: string, message: string): string {
-  const psTitle = escapePowerShellSingleQuotedText(title)
-  const psMessage = escapePowerShellSingleQuotedText(message)
-
-  return `
-[Windows.UI.Notifications.ToastNotificationManager, Windows.UI.Notifications, ContentType = WindowsRuntime] | Out-Null
-$Template = [Windows.UI.Notifications.ToastNotificationManager]::GetTemplateContent([Windows.UI.Notifications.ToastTemplateType]::ToastText02)
-$RawXml = [xml] $Template.GetXml()
-($RawXml.toast.visual.binding.text | Where-Object {$_.id -eq '1'}).AppendChild($RawXml.CreateTextNode('${psTitle}')) | Out-Null
-($RawXml.toast.visual.binding.text | Where-Object {$_.id -eq '2'}).AppendChild($RawXml.CreateTextNode('${psMessage}')) | Out-Null
-$SerializedXml = New-Object Windows.Data.Xml.Dom.XmlDocument
-$SerializedXml.LoadXml($RawXml.OuterXml)
-$Toast = [Windows.UI.Notifications.ToastNotification]::new($SerializedXml)
-$Notifier = [Windows.UI.Notifications.ToastNotificationManager]::CreateToastNotifier('OpenCode')
-$Notifier.Show($Toast)
-`.trim().replace(/\n/g, "; ")
-}