@hiai-gg/hiai-opencode 0.1.7 → 0.1.8

package/src/plugin/chat-headers.ts

@@ -1,141 +0,0 @@
-import { OMO_INTERNAL_INITIATOR_MARKER } from "../shared"
-import type { PluginContext } from "./types"
-
-type ChatHeadersInput = {
-  sessionID: string
-  provider: { id: string }
-  message: {
-    id?: string
-    role?: string
-  }
-}
-
-type ChatHeadersOutput = {
-  headers: Record<string, string>
-}
-
-const INTERNAL_MARKER_CACHE_LIMIT = 1000
-const internalMarkerCache = new Map<string, boolean>()
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null
-}
-
-function buildChatHeadersInput(raw: unknown): ChatHeadersInput | null {
-  if (!isRecord(raw)) return null
-
-  const sessionID = raw.sessionID
-  const provider = raw.provider
-  const message = raw.message
-
-  if (typeof sessionID !== "string") return null
-  if (!isRecord(provider) || typeof provider.id !== "string") return null
-  if (!isRecord(message)) return null
-
-  return {
-    sessionID,
-    provider: { id: provider.id },
-    message: {
-      id: typeof message.id === "string" ? message.id : undefined,
-      role: typeof message.role === "string" ? message.role : undefined,
-    },
-  }
-}
-
-function isChatHeadersOutput(raw: unknown): raw is ChatHeadersOutput {
-  if (!isRecord(raw)) return false
-  if (!isRecord(raw.headers)) {
-    raw.headers = {}
-  }
-  return isRecord(raw.headers)
-}
-
-function isCopilotProvider(providerID: string): boolean {
-  return providerID === "github-copilot" || providerID === "github-copilot-enterprise"
-}
-
-async function hasInternalMarker(
-  client: PluginContext["client"],
-  sessionID: string,
-  messageID: string,
-): Promise<boolean> {
-  const cacheKey = `${sessionID}:${messageID}`
-  const cached = internalMarkerCache.get(cacheKey)
-  if (cached !== undefined) {
-    return cached
-  }
-
-  try {
-    const response = await client.session.message({
-      path: { id: sessionID, messageID },
-    })
-
-    const data = response.data
-    if (!isRecord(data) || !Array.isArray(data.parts)) {
-      internalMarkerCache.set(cacheKey, false)
-      if (internalMarkerCache.size > INTERNAL_MARKER_CACHE_LIMIT) {
-        internalMarkerCache.clear()
-      }
-      return false
-    }
-
-    const hasMarker = data.parts.some((part) => {
-      if (!isRecord(part) || part.type !== "text" || typeof part.text !== "string") {
-        return false
-      }
-
-      return part.text.includes(OMO_INTERNAL_INITIATOR_MARKER)
-    })
-
-    internalMarkerCache.set(cacheKey, hasMarker)
-    if (internalMarkerCache.size > INTERNAL_MARKER_CACHE_LIMIT) {
-      internalMarkerCache.clear()
-    }
-
-    return hasMarker
-  } catch {
-    internalMarkerCache.set(cacheKey, false)
-    if (internalMarkerCache.size > INTERNAL_MARKER_CACHE_LIMIT) {
-      internalMarkerCache.clear()
-    }
-    return false
-  }
-}
-
-async function isOmoInternalMessage(input: ChatHeadersInput, client: PluginContext["client"]): Promise<boolean> {
-  if (input.message.role !== "user") {
-    return false
-  }
-
-  if (!input.message.id) {
-    return false
-  }
-
-  return hasInternalMarker(client, input.sessionID, input.message.id)
-}
-
-export function createChatHeadersHandler(args: { ctx: PluginContext }): (input: unknown, output: unknown) => Promise<void> {
-  const { ctx } = args
-
-  return async (input, output): Promise<void> => {
-    const normalizedInput = buildChatHeadersInput(input)
-    if (!normalizedInput) return
-    if (!isChatHeadersOutput(output)) return
-
-    if (!isCopilotProvider(normalizedInput.provider.id)) return
-
-    // Do not override x-initiator when @ai-sdk/github-copilot is active.
-    // OpenCode's copilot fetch wrapper already sets x-initiator based on
-    // the actual request body content. Overriding it here causes a mismatch
-    // that the Copilot API rejects with "invalid initiator".
-    const model = isRecord(input) && isRecord((input as Record<string, unknown>).model)
-      ? (input as Record<string, unknown>).model as Record<string, unknown>
-      : undefined
-    const api = model && isRecord(model.api) ? model.api as Record<string, unknown> : undefined
-    if (api?.npm === "@ai-sdk/github-copilot") return
-
-    if (!(await isOmoInternalMessage(normalizedInput, ctx.client))) return
-
-    output.headers["x-initiator"] = "agent"
-  }
-}

package/src/plugin/chat-message.ts

@@ -1,307 +0,0 @@
-import type { HiaiOpenCodeConfig } from "../config"
-import type { PluginContext } from "./types"
-
-import { isModelCacheAvailable, log } from "../shared"
-import { getAgentConfigKey } from "../shared/agent-display-names"
-import { getSessionModel, setSessionModel } from "../shared/session-model-state"
-import { getMainSessionID, setSessionAgent, subagentSessions } from "../features/claude-code-session-state"
-import { applyUltraworkModelOverrideOnMessage } from "./ultrawork-model-override"
-import { NATIVE_LOOP_TRIGGERED_FLAG } from "./command-execute-before"
-import { parseRalphLoopArguments } from "../hooks/ralph-loop/command-arguments"
-
-import type { CreatedHooks } from "../create-hooks"
-
-type FirstMessageVariantGate = {
-  shouldOverride: (sessionID: string) => boolean
-  markApplied: (sessionID: string) => void
-}
-
-type ChatMessagePart = { type: string; text?: string; [key: string]: unknown }
-export type ChatMessageHandlerOutput = { message: Record<string, unknown>; parts: ChatMessagePart[] }
-export type ChatMessageInput = {
-  sessionID: string
-  agent?: string
-  model?: { providerID: string; modelID: string }
-}
-type StartWorkHookOutput = { parts: Array<{ type: string; text?: string }> }
-
-type SessionModelOverride = { providerID: string; modelID: string }
-const START_WORK_TEMPLATE_MARKER = "You are starting a Bob work session."
-
-type RawLoopCommand =
-  | { command: "ralph-loop" | "ulw-loop"; args: string }
-  | { command: "cancel-ralph"; args: "" }
-
-function isStartWorkHookOutput(value: unknown): value is StartWorkHookOutput {
-  if (typeof value !== "object" || value === null) return false
-  const record = value as Record<string, unknown>
-  const partsValue = record["parts"]
-  if (!Array.isArray(partsValue)) return false
-  return partsValue.every((part) => {
-    if (typeof part !== "object" || part === null) return false
-    const partRecord = part as Record<string, unknown>
-    return typeof partRecord["type"] === "string"
-  })
-}
-
-function hasExplicitAgentModelOverride(
-  agent: string | undefined,
-  pluginConfig: HiaiOpenCodeConfig
-): boolean {
-  const configuredAgents = pluginConfig.agents
-  const normalizedAgent = typeof agent === "string" ? getAgentConfigKey(agent) : undefined
-  if (!normalizedAgent || !configuredAgents || !(normalizedAgent in configuredAgents)) {
-    return false
-  }
-
-  const configuredAgent = configuredAgents[normalizedAgent as keyof typeof configuredAgents]
-  const configuredModel = configuredAgent?.model
-  return typeof configuredModel === "string" && configuredModel.trim().length > 0
-}
-
-function getStoredMainSessionModel(
-  input: ChatMessageInput,
-  pluginConfig: HiaiOpenCodeConfig,
-  isFirstMessage: boolean,
-  output: ChatMessageHandlerOutput
-): SessionModelOverride | undefined {
-  if (isFirstMessage) {
-    return undefined
-  }
-
-  if (subagentSessions.has(input.sessionID)) {
-    return undefined
-  }
-
-  if (getMainSessionID() !== input.sessionID) {
-    return undefined
-  }
-
-  if (input.model) {
-    return undefined
-  }
-
-  if (output.message["model"] !== undefined) {
-    return undefined
-  }
-
-  if (hasExplicitAgentModelOverride(input.agent, pluginConfig)) {
-    return undefined
-  }
-
-  return getSessionModel(input.sessionID)
-}
-
-function parseRawLoopSlashCommand(promptText: string): RawLoopCommand | null {
-  const trimmed = promptText.trim()
-  const commandText = trimmed.startsWith("/")
-    ? trimmed
-    : trimmed
-        .split("\n")
-        .map((line) => line.trim())
-        .filter((line) => /^\/(?:ralph-loop|ulw-loop|cancel-ralph)\b/i.test(line))
-        .at(-1)
-
-  if (!commandText) {
-    return null
-  }
-
-  const cancelMatch = commandText.match(/^\/cancel-ralph(?:\s+.*)?$/i)
-  if (cancelMatch) {
-    return { command: "cancel-ralph", args: "" }
-  }
-
-  const loopMatch = commandText.match(/^\/(ralph-loop|ulw-loop)\s*([\s\S]*)$/i)
-  if (!loopMatch) {
-    return null
-  }
-
-  const command = loopMatch[1]?.toLowerCase()
-  const args = loopMatch[2]?.trim() ?? ""
-
-  if (command === "ralph-loop" || command === "ulw-loop") {
-    return { command, args }
-  }
-
-  return null
-}
-
-function extractPromptText(parts: ChatMessagePart[]): string {
-  return (
-    parts
-      ?.filter((part) => part.type === "text" && part.text)
-      .map((part) => part.text)
-      .join("\n")
-      .trim() || ""
-  )
-}
-
-function isStartWorkFallbackTemplate(promptText: string): boolean {
-  return (
-    promptText.includes("<session-context>") &&
-    promptText.includes(START_WORK_TEMPLATE_MARKER)
-  )
-}
-
-function clearStoppedContinuationBeforeWorkStart(
-  hooks: CreatedHooks,
-  sessionID: string,
-  command: "start-work" | "ralph-loop" | "ulw-loop"
-): void {
-  if (hooks.stopContinuationGuard?.isStopped(sessionID)) {
-    hooks.stopContinuationGuard.clear(sessionID)
-    log("[stop-continuation] Stop state cleared by chat.message work-starting command", {
-      sessionID,
-      command,
-    })
-  }
-}
-
-export function createChatMessageHandler(args: {
-  ctx: PluginContext
-  pluginConfig: HiaiOpenCodeConfig
-  firstMessageVariantGate: FirstMessageVariantGate
-  hooks: CreatedHooks
-}): (
-  input: ChatMessageInput,
-  output: ChatMessageHandlerOutput
-) => Promise<void> {
-  const { ctx, pluginConfig, firstMessageVariantGate, hooks } = args
-  const pluginContext = ctx as {
-    client: {
-      tui: {
-        showToast: (input: {
-          body: {
-            title: string
-            message: string
-            variant: "warning"
-            duration: number
-          }
-        }) => Promise<unknown>
-      }
-    }
-  }
-  const isRuntimeFallbackEnabled =
-    hooks.runtimeFallback !== null &&
-    hooks.runtimeFallback !== undefined &&
-    (typeof pluginConfig.runtime_fallback === "boolean"
-      ? pluginConfig.runtime_fallback
-      : (pluginConfig.runtime_fallback?.enabled ?? false))
-
-  return async (
-    input: ChatMessageInput,
-    output: ChatMessageHandlerOutput
-  ): Promise<void> => {
-    if (input.agent) {
-      setSessionAgent(input.sessionID, input.agent)
-    }
-
-    const isFirstMessage = firstMessageVariantGate.shouldOverride(input.sessionID)
-    if (isFirstMessage) {
-      firstMessageVariantGate.markApplied(input.sessionID)
-    }
-
-    const storedMainSessionModel = getStoredMainSessionModel(
-      input,
-      pluginConfig,
-      isFirstMessage,
-      output,
-    )
-    if (storedMainSessionModel) {
-      output.message["model"] = storedMainSessionModel
-    }
-
-    if (!isRuntimeFallbackEnabled) {
-      await hooks.modelFallback?.["chat.message"]?.(input, output)
-    }
-    const modelOverride = output.message["model"]
-    if (
-      modelOverride &&
-      typeof modelOverride === "object" &&
-      "providerID" in modelOverride &&
-      "modelID" in modelOverride
-    ) {
-      const providerID = (modelOverride as { providerID?: string }).providerID
-      const modelID = (modelOverride as { modelID?: string }).modelID
-      if (typeof providerID === "string" && typeof modelID === "string") {
-        setSessionModel(input.sessionID, { providerID, modelID })
-      }
-    } else if (input.model) {
-      setSessionModel(input.sessionID, input.model)
-    }
-    await hooks.stopContinuationGuard?.["chat.message"]?.(input)
-    await hooks.backgroundNotificationHook?.["chat.message"]?.(input, output)
-    await hooks.runtimeFallback?.["chat.message"]?.(input, output)
-    await hooks.keywordDetector?.["chat.message"]?.(input, output)
-    await hooks.thinkMode?.["chat.message"]?.(input, output)
-    await hooks.claudeCodeHooks?.["chat.message"]?.(input, output)
-    await hooks.autoSlashCommand?.["chat.message"]?.(input, output)
-    if (hooks.startWork && isStartWorkHookOutput(output)) {
-      const promptText = extractPromptText(output.parts)
-      if (isStartWorkFallbackTemplate(promptText)) {
-        clearStoppedContinuationBeforeWorkStart(hooks, input.sessionID, "start-work")
-      }
-      await hooks.startWork["chat.message"]?.(input, output)
-    }
-
-    if (!isModelCacheAvailable()) {
-      pluginContext.client.tui
-        .showToast({
-          body: {
-            title: "⚠️ Provider Cache Missing",
-            message:
-              "Model filtering disabled. RESTART OpenCode to enable full functionality.",
-            variant: "warning" as const,
-            duration: 6000,
-          },
-        })
-        .catch(() => {})
-    }
-
-    if (hooks.ralphLoop && output.message[NATIVE_LOOP_TRIGGERED_FLAG] !== true) {
-      const parts = output.parts
-      const promptText = extractPromptText(parts)
-
-      const isRalphLoopTemplate =
-        promptText.includes("You are starting a Ralph Loop") &&
-        promptText.includes("<user-task>")
-      const isUlwLoopTemplate =
-        promptText.includes("You are starting an ULTRAWORK Loop") &&
-        promptText.includes("<user-task>")
-      const isCancelRalphTemplate = promptText.includes(
-        "Cancel the currently active Ralph Loop",
-      )
-      const rawLoopCommand =
-        !isRalphLoopTemplate && !isUlwLoopTemplate && !isCancelRalphTemplate
-          ? parseRawLoopSlashCommand(promptText)
-          : null
-
-      if (isRalphLoopTemplate || isUlwLoopTemplate || rawLoopCommand?.command === "ralph-loop" || rawLoopCommand?.command === "ulw-loop") {
-        const taskMatch = promptText.match(/<user-task>\s*([\s\S]*?)\s*<\/user-task>/i)
-        const rawTask = taskMatch?.[1]?.trim() || rawLoopCommand?.args || ""
-        const parsedArguments = parseRalphLoopArguments(rawTask)
-        const ultrawork = isUlwLoopTemplate || rawLoopCommand?.command === "ulw-loop"
-        const command = ultrawork ? "ulw-loop" : "ralph-loop"
-
-        clearStoppedContinuationBeforeWorkStart(hooks, input.sessionID, command)
-        hooks.ralphLoop.startLoop(input.sessionID, parsedArguments.prompt, {
-          ultrawork,
-          maxIterations: parsedArguments.maxIterations,
-          completionPromise: parsedArguments.completionPromise,
-          strategy: parsedArguments.strategy,
-        })
-      } else if (isCancelRalphTemplate || rawLoopCommand?.command === "cancel-ralph") {
-        hooks.ralphLoop.cancelLoop(input.sessionID)
-      }
-    }
-
-    await applyUltraworkModelOverrideOnMessage(
-      pluginConfig,
-      input.agent,
-      output,
-      pluginContext.client.tui,
-      input.sessionID,
-      pluginContext.client,
-    )
-  }
-}

package/src/plugin/chat-params.ts

@@ -1,182 +0,0 @@
-import { getSessionPromptParams } from "../shared/session-prompt-params-state"
-import { getModelCapabilities, resolveCompatibleModelSettings } from "../shared"
-
-export type ChatParamsInput = {
-  sessionID: string
-  agent: { name?: string }
-  model: { providerID: string; modelID: string }
-  provider: { id: string }
-  message: { variant?: string }
-}
-
-type ChatParamsHookInput = ChatParamsInput & {
-  rawMessage?: Record<string, unknown>
-}
-
-export type ChatParamsOutput = {
-  temperature?: number
-  topP?: number
-  topK?: number
-  maxOutputTokens?: number
-  options: Record<string, unknown>
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null
-}
-
-function buildChatParamsInput(raw: unknown): ChatParamsHookInput | null {
-  if (!isRecord(raw)) return null
-
-  const sessionID = raw.sessionID
-  const agent = raw.agent
-  const model = raw.model
-  const provider = raw.provider
-  const message = raw.message
-
-  if (typeof sessionID !== "string") return null
-  if (!isRecord(model)) return null
-  if (!isRecord(provider)) return null
-  if (!isRecord(message)) return null
-
-  let agentName: string | undefined
-  if (typeof agent === "string") {
-    agentName = agent
-  } else if (isRecord(agent)) {
-    const name = agent.name
-    if (typeof name === "string") {
-      agentName = name
-    }
-  }
-  if (!agentName) return null
-
-  const providerID = model.providerID
-  const modelID = typeof model.modelID === "string"
-    ? model.modelID
-    : typeof model.id === "string"
-      ? model.id
-      : undefined
-  const providerId = provider.id
-  if (typeof providerID !== "string") return null
-  if (typeof modelID !== "string") return null
-  if (typeof providerId !== "string") return null
-
-  return {
-    sessionID,
-    agent: { name: agentName },
-    model: { providerID, modelID },
-    provider: { id: providerId },
-    message,
-    rawMessage: message,
-  }
-}
-
-function isChatParamsOutput(raw: unknown): raw is ChatParamsOutput {
-  if (!isRecord(raw)) return false
-  if (!isRecord(raw.options)) {
-    raw.options = {}
-  }
-  return isRecord(raw.options)
-}
-
-export function createChatParamsHandler(args: {
-  anthropicEffort: { "chat.params"?: (input: ChatParamsHookInput, output: ChatParamsOutput) => Promise<void> } | null
-  client?: unknown
-}): (input: unknown, output: unknown) => Promise<void> {
-  return async (input, output): Promise<void> => {
-    const normalizedInput = buildChatParamsInput(input)
-    if (!normalizedInput) return
-    if (!isChatParamsOutput(output)) return
-
-    const storedPromptParams = getSessionPromptParams(normalizedInput.sessionID)
-    if (storedPromptParams) {
-      if (storedPromptParams.temperature !== undefined) {
-        output.temperature = storedPromptParams.temperature
-      }
-      if (storedPromptParams.topP !== undefined) {
-        output.topP = storedPromptParams.topP
-      }
-      if (storedPromptParams.maxOutputTokens !== undefined) {
-        (output as Record<string, unknown>).maxOutputTokens = storedPromptParams.maxOutputTokens
-      }
-      if (storedPromptParams.options) {
-        output.options = {
-          ...output.options,
-          ...storedPromptParams.options,
-        }
-      }
-    }
-
-    const capabilities = getModelCapabilities({
-      providerID: normalizedInput.model.providerID,
-      modelID: normalizedInput.model.modelID,
-    })
-
-    const compatibility = resolveCompatibleModelSettings({
-      providerID: normalizedInput.model.providerID,
-      modelID: normalizedInput.model.modelID,
-      desired: {
-        variant: typeof normalizedInput.message.variant === "string"
-          ? normalizedInput.message.variant
-          : undefined,
-        reasoningEffort: typeof output.options.reasoningEffort === "string"
-          ? output.options.reasoningEffort
-          : undefined,
-        temperature: typeof output.temperature === "number" ? output.temperature : undefined,
-        topP: typeof output.topP === "number" ? output.topP : undefined,
-        maxTokens: typeof output.maxOutputTokens === "number" ? output.maxOutputTokens : undefined,
-        thinking: isRecord(output.options.thinking) ? output.options.thinking : undefined,
-      },
-      capabilities,
-    })
-
-    if (normalizedInput.rawMessage) {
-      if (compatibility.variant !== undefined) {
-        normalizedInput.rawMessage.variant = compatibility.variant
-      } else {
-        delete normalizedInput.rawMessage.variant
-      }
-    }
-    normalizedInput.message = normalizedInput.rawMessage as { variant?: string }
-
-    if (compatibility.reasoningEffort !== undefined) {
-      output.options.reasoningEffort = compatibility.reasoningEffort
-    } else if ("reasoningEffort" in output.options) {
-      delete output.options.reasoningEffort
-    }
-
-    if ("temperature" in compatibility) {
-      if (compatibility.temperature !== undefined) {
-        output.temperature = compatibility.temperature
-      } else {
-        delete output.temperature
-      }
-    }
-
-    if ("topP" in compatibility) {
-      if (compatibility.topP !== undefined) {
-        output.topP = compatibility.topP
-      } else {
-        delete output.topP
-      }
-    }
-
-    if ("maxTokens" in compatibility) {
-      if (compatibility.maxTokens !== undefined) {
-        output.maxOutputTokens = compatibility.maxTokens
-      } else {
-        delete output.maxOutputTokens
-      }
-    }
-
-    if ("thinking" in compatibility) {
-      if (compatibility.thinking !== undefined) {
-        output.options.thinking = compatibility.thinking
-      } else {
-        delete output.options.thinking
-      }
-    }
-
-    await args.anthropicEffort?.["chat.params"]?.(normalizedInput, output)
-  }
-}

package/src/plugin/command-execute-before.ts

@@ -1,80 +0,0 @@
-import type { CreatedHooks } from "../create-hooks"
-import { parseRalphLoopArguments } from "../hooks/ralph-loop/command-arguments"
-import { log } from "../shared/logger"
-
-type CommandExecuteBeforeInput = {
-  command: string
-  sessionID: string
-  arguments: string
-}
-
-type CommandExecuteBeforeOutput = {
-  parts: Array<{ type: string; text?: string; [key: string]: unknown }>
-  message?: Record<string, unknown>
-}
-
-const NATIVE_LOOP_TRIGGERED_FLAG = "__omoNativeLoopTriggered"
-
-function hasPartsOutput(value: unknown): value is CommandExecuteBeforeOutput {
-  if (typeof value !== "object" || value === null) return false
-  const record = value as Record<string, unknown>
-  const parts = record["parts"]
-  return Array.isArray(parts)
-}
-
-export function createCommandExecuteBeforeHandler(args: {
-  hooks: CreatedHooks
-}): (
-  input: CommandExecuteBeforeInput,
-  output: CommandExecuteBeforeOutput,
-) => Promise<void> {
-  const { hooks } = args
-
-  return async (input, output): Promise<void> => {
-    await hooks.autoSlashCommand?.["command.execute.before"]?.(input, output)
-
-    const normalizedCommand = input.command.toLowerCase()
-    const sessionID = input.sessionID
-    if (hooks.ralphLoop && sessionID) {
-      if (normalizedCommand === "ralph-loop" || normalizedCommand === "ulw-loop") {
-        const parsedArguments = parseRalphLoopArguments(input.arguments || "")
-        hooks.ralphLoop.startLoop(sessionID, parsedArguments.prompt, {
-          ultrawork: normalizedCommand === "ulw-loop",
-          maxIterations: parsedArguments.maxIterations,
-          completionPromise: parsedArguments.completionPromise,
-          strategy: parsedArguments.strategy,
-        })
-        output.message ??= {}
-        output.message[NATIVE_LOOP_TRIGGERED_FLAG] = true
-        if (hooks.stopContinuationGuard?.isStopped(sessionID)) {
-          hooks.stopContinuationGuard.clear(sessionID)
-          log("[stop-continuation] Stop state cleared by native command", {
-            sessionID,
-            command: normalizedCommand,
-          })
-        }
-      } else if (normalizedCommand === "cancel-ralph") {
-        hooks.ralphLoop.cancelLoop(sessionID)
-        output.message ??= {}
-        output.message[NATIVE_LOOP_TRIGGERED_FLAG] = true
-      }
-    }
-
-    if (
-      hooks.startWork
-      && normalizedCommand === "start-work"
-      && hasPartsOutput(output)
-    ) {
-      await hooks.startWork["command.execute.before"]?.(input, output)
-      if (hooks.stopContinuationGuard?.isStopped(sessionID)) {
-        hooks.stopContinuationGuard.clear(sessionID)
-        log("[stop-continuation] Stop state cleared by native command", {
-          sessionID,
-          command: normalizedCommand,
-        })
-      }
-    }
-  }
-}
-
-export { NATIVE_LOOP_TRIGGERED_FLAG }