@hiai-gg/hiai-opencode 0.1.6 → 0.1.8

package/src/hooks/session-recovery/detect-error-type.ts

@@ -1,102 +0,0 @@
-export type RecoveryErrorType =
-  | "tool_result_missing"
-  | "thinking_block_order"
-  | "thinking_disabled_violation"
-  | "assistant_prefill_unsupported"
-  | "unavailable_tool"
-  | null
-
-function getErrorMessage(error: unknown): string {
-  if (!error) return ""
-  if (typeof error === "string") return error.toLowerCase()
-
-  const errorObj = error as Record<string, unknown>
-  const paths = [
-    errorObj.data,
-    errorObj.error,
-    errorObj,
-    (errorObj.data as Record<string, unknown>)?.error,
-  ]
-
-  for (const obj of paths) {
-    if (obj && typeof obj === "object") {
-      const msg = (obj as Record<string, unknown>).message
-      if (typeof msg === "string" && msg.length > 0) {
-        return msg.toLowerCase()
-      }
-    }
-  }
-
-  try {
-    return JSON.stringify(error).toLowerCase()
-  } catch {
-    return ""
-  }
-}
-
-export function extractMessageIndex(error: unknown): number | null {
-  try {
-    const message = getErrorMessage(error)
-    const match = message.match(/messages\.(\d+)/)
-    return match ? parseInt(match[1], 10) : null
-  } catch {
-    return null
-  }
-}
-
-export function extractUnavailableToolName(error: unknown): string | null {
-  try {
-    const message = getErrorMessage(error)
-    const match = message.match(/(?:unavailable tool|no such tool)[:\s'"]+([^'".\s]+)/)
-    return match ? match[1] : null
-  } catch {
-    return null
-  }
-}
-
-export function detectErrorType(error: unknown): RecoveryErrorType {
-  try {
-    const message = getErrorMessage(error)
-
-    if (
-      message.includes("assistant message prefill") ||
-      message.includes("conversation must end with a user message")
-    ) {
-      return "assistant_prefill_unsupported"
-    }
-
-    if (
-      message.includes("thinking") &&
-      (message.includes("first block") ||
-        message.includes("must start with") ||
-        message.includes("preceeding") ||
-        message.includes("final block") ||
-        message.includes("cannot be thinking") ||
-        (message.includes("expected") && message.includes("found")))
-    ) {
-      return "thinking_block_order"
-    }
-
-    if (message.includes("thinking is disabled") && message.includes("cannot contain")) {
-      return "thinking_disabled_violation"
-    }
-
-    if (message.includes("tool_use") && message.includes("tool_result")) {
-      return "tool_result_missing"
-    }
-
-    if (
-      message.includes("dummy_tool") ||
-      message.includes("unavailable tool") ||
-      message.includes("model tried to call unavailable") ||
-      message.includes("nosuchtoolerror") ||
-      message.includes("no such tool")
-    ) {
-      return "unavailable_tool"
-    }
-
-    return null
-  } catch {
-    return null
-  }
-}

package/src/hooks/session-recovery/hook.ts

@@ -1,166 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin"
-import type { ExperimentalConfig } from "../../config"
-import { log } from "../../shared/logger"
-import { detectErrorType } from "./detect-error-type"
-import type { RecoveryErrorType } from "./detect-error-type"
-import type { MessageData } from "./types"
-import { recoverToolResultMissing } from "./recover-tool-result-missing"
-import { recoverUnavailableTool } from "./recover-unavailable-tool"
-import { recoverThinkingBlockOrder } from "./recover-thinking-block-order"
-import { recoverThinkingDisabledViolation } from "./recover-thinking-disabled-violation"
-import { extractResumeConfig, findLastUserMessage, resumeSession } from "./resume"
-
-interface MessageInfo {
-  id?: string
-  role?: string
-  sessionID?: string
-  parentID?: string
-  error?: unknown
-}
-
-export interface SessionRecoveryOptions {
-  experimental?: ExperimentalConfig
-}
-
-export interface SessionRecoveryHook {
-  handleSessionRecovery: (info: MessageInfo) => Promise<boolean>
-  isRecoverableError: (error: unknown) => boolean
-  setOnAbortCallback: (callback: (sessionID: string) => void) => void
-  setOnRecoveryCompleteCallback: (callback: (sessionID: string) => void) => void
-}
-
-export function createSessionRecoveryHook(ctx: PluginInput, options?: SessionRecoveryOptions): SessionRecoveryHook {
-  const processingErrors = new Set<string>()
-  const experimental = options?.experimental
-  let onAbortCallback: ((sessionID: string) => void) | null = null
-  let onRecoveryCompleteCallback: ((sessionID: string) => void) | null = null
-
-  const setOnAbortCallback = (callback: (sessionID: string) => void): void => {
-    onAbortCallback = callback
-  }
-
-  const setOnRecoveryCompleteCallback = (callback: (sessionID: string) => void): void => {
-    onRecoveryCompleteCallback = callback
-  }
-
-  const isRecoverableError = (error: unknown): boolean => {
-    return detectErrorType(error) !== null
-  }
-
-  const handleSessionRecovery = async (info: MessageInfo): Promise<boolean> => {
-    if (!info || info.role !== "assistant" || !info.error) return false
-
-    const errorType = detectErrorType(info.error)
-    if (!errorType) return false
-
-    const sessionID = info.sessionID
-    let assistantMsgID = info.id
-
-    if (!sessionID) return false
-
-    if (!assistantMsgID) {
-      try {
-        const messagesResp = await ctx.client.session.messages({
-          path: { id: sessionID },
-          query: { directory: ctx.directory },
-        })
-        const msgs = (messagesResp as { data?: MessageData[] }).data
-        const lastAssistant = msgs?.findLast((m) => m.info?.role === "assistant" && m.info?.error)
-        assistantMsgID = lastAssistant?.info?.id
-      } catch {
-        log("[session-recovery] Failed to fetch messages for messageID fallback", { sessionID })
-      }
-    }
-
-    if (!assistantMsgID) return false
-    if (processingErrors.has(assistantMsgID)) return false
-    processingErrors.add(assistantMsgID)
-
-    try {
-      if (onAbortCallback) {
-        onAbortCallback(sessionID)
-      }
-
-      await ctx.client.session.abort({ path: { id: sessionID } }).catch(() => {})
-
-      const messagesResp = await ctx.client.session.messages({
-        path: { id: sessionID },
-        query: { directory: ctx.directory },
-      })
-      const msgs = (messagesResp as { data?: MessageData[] }).data
-
-      const failedMsg = msgs?.find((m) => m.info?.id === assistantMsgID)
-      if (!failedMsg) {
-        return false
-      }
-
-      const toastTitles: Record<RecoveryErrorType & string, string> = {
-        tool_result_missing: "Tool Crash Recovery",
-        unavailable_tool: "Tool Recovery",
-        thinking_block_order: "Thinking Block Recovery",
-        thinking_disabled_violation: "Thinking Strip Recovery",
-        "assistant_prefill_unsupported": "Prefill Unsupported",
-      }
-      const toastMessages: Record<RecoveryErrorType & string, string> = {
-        tool_result_missing: "Injecting cancelled tool results...",
-        unavailable_tool: "Recovering from unavailable tool call...",
-        thinking_block_order: "Fixing message structure...",
-        thinking_disabled_violation: "Stripping thinking blocks...",
-        "assistant_prefill_unsupported": "Prefill not supported; continuing without recovery.",
-      }
-
-      await ctx.client.tui
-        .showToast({
-          body: {
-            title: toastTitles[errorType],
-            message: toastMessages[errorType],
-            variant: "warning",
-            duration: 3000,
-          },
-        })
-        .catch(() => {})
-
-      let success = false
-
-      if (errorType === "tool_result_missing") {
-        success = await recoverToolResultMissing(ctx.client, sessionID, failedMsg)
-      } else if (errorType === "unavailable_tool") {
-        success = await recoverUnavailableTool(ctx.client, sessionID, failedMsg)
-      } else if (errorType === "thinking_block_order") {
-        success = await recoverThinkingBlockOrder(ctx.client, sessionID, failedMsg, ctx.directory, info.error)
-        if (success && experimental?.auto_resume) {
-          const lastUser = findLastUserMessage(msgs ?? [])
-          const resumeConfig = extractResumeConfig(lastUser, sessionID)
-          await resumeSession(ctx.client, resumeConfig)
-        }
-      } else if (errorType === "thinking_disabled_violation") {
-        success = await recoverThinkingDisabledViolation(ctx.client, sessionID, failedMsg)
-        if (success && experimental?.auto_resume) {
-          const lastUser = findLastUserMessage(msgs ?? [])
-          const resumeConfig = extractResumeConfig(lastUser, sessionID)
-          await resumeSession(ctx.client, resumeConfig)
-        }
-      } else if (errorType === "assistant_prefill_unsupported") {
-        success = false
-      }
-
-      return success
-    } catch (err) {
-      log("[session-recovery] Recovery failed:", err)
-      return false
-    } finally {
-      processingErrors.delete(assistantMsgID)
-
-      if (sessionID && onRecoveryCompleteCallback) {
-        onRecoveryCompleteCallback(sessionID)
-      }
-    }
-  }
-
-  return {
-    handleSessionRecovery,
-    isRecoverableError,
-    setOnAbortCallback,
-    setOnRecoveryCompleteCallback,
-  }
-}

package/src/hooks/session-recovery/index.ts

@@ -1,7 +0,0 @@
-export { createSessionRecoveryHook } from "./hook"
-export type { SessionRecoveryHook, SessionRecoveryOptions } from "./hook"
-
-export { detectErrorType } from "./detect-error-type"
-export type { RecoveryErrorType } from "./detect-error-type"
-
-export type { MessageData, ResumeConfig } from "./types"

package/src/hooks/session-recovery/recover-empty-content-message-sdk.ts

@@ -1,201 +0,0 @@
-import type { createOpencodeClient } from "@opencode-ai/sdk"
-import type { MessageData } from "./types"
-import { extractMessageIndex } from "./detect-error-type"
-import { META_TYPES, THINKING_TYPES } from "./constants"
-import { normalizeSDKResponse } from "../../shared"
-
-type Client = ReturnType<typeof createOpencodeClient>
-
-type ReplaceEmptyTextPartsAsync = (
-  client: Client,
-  sessionID: string,
-  messageID: string,
-  replacementText: string
-) => Promise<boolean>
-
-type InjectTextPartAsync = (
-  client: Client,
-  sessionID: string,
-  messageID: string,
-  text: string
-) => Promise<boolean>
-
-type FindMessagesWithEmptyTextPartsFromSDK = (
-  client: Client,
-  sessionID: string
-) => Promise<string[]>
-
-export async function recoverEmptyContentMessageFromSDK(
-  client: Client,
-  sessionID: string,
-  failedAssistantMsg: MessageData,
-  error: unknown,
-  dependencies: {
-    placeholderText: string
-    replaceEmptyTextPartsAsync: ReplaceEmptyTextPartsAsync
-    injectTextPartAsync: InjectTextPartAsync
-    findMessagesWithEmptyTextPartsFromSDK: FindMessagesWithEmptyTextPartsFromSDK
-  }
-): Promise<boolean> {
-  const targetIndex = extractMessageIndex(error)
-  const failedID = failedAssistantMsg.info?.id
-  let anySuccess = false
-
-  const messagesWithEmptyText = await dependencies.findMessagesWithEmptyTextPartsFromSDK(client, sessionID)
-  for (const messageID of messagesWithEmptyText) {
-    if (
-      await dependencies.replaceEmptyTextPartsAsync(
-        client,
-        sessionID,
-        messageID,
-        dependencies.placeholderText
-      )
-    ) {
-      anySuccess = true
-    }
-  }
-
-  const messages = await readMessagesFromSDK(client, sessionID)
-
-  const thinkingOnlyIDs = findMessagesWithThinkingOnlyFromSDK(messages)
-  for (const messageID of thinkingOnlyIDs) {
-    if (await dependencies.injectTextPartAsync(client, sessionID, messageID, dependencies.placeholderText)) {
-      anySuccess = true
-    }
-  }
-
-  if (targetIndex !== null) {
-    const targetMessageID = findEmptyMessageByIndexFromSDK(messages, targetIndex)
-    if (targetMessageID) {
-      if (
-        await dependencies.replaceEmptyTextPartsAsync(
-          client,
-          sessionID,
-          targetMessageID,
-          dependencies.placeholderText
-        )
-      ) {
-        return true
-      }
-      if (await dependencies.injectTextPartAsync(client, sessionID, targetMessageID, dependencies.placeholderText)) {
-        return true
-      }
-    }
-  }
-
-  if (failedID) {
-    if (await dependencies.replaceEmptyTextPartsAsync(client, sessionID, failedID, dependencies.placeholderText)) {
-      return true
-    }
-    if (await dependencies.injectTextPartAsync(client, sessionID, failedID, dependencies.placeholderText)) {
-      return true
-    }
-  }
-
-  const freshMessages = await readMessagesFromSDK(client, sessionID)
-  const emptyMessageIDs = findEmptyMessagesFromSDK(freshMessages)
-  for (const messageID of emptyMessageIDs) {
-    if (
-      await dependencies.replaceEmptyTextPartsAsync(
-        client,
-        sessionID,
-        messageID,
-        dependencies.placeholderText
-      )
-    ) {
-      anySuccess = true
-    }
-    if (await dependencies.injectTextPartAsync(client, sessionID, messageID, dependencies.placeholderText)) {
-      anySuccess = true
-    }
-  }
-
-  return anySuccess
-}
-
-type SdkPart = NonNullable<MessageData["parts"]>[number]
-
-function sdkPartHasContent(part: SdkPart): boolean {
-  if (THINKING_TYPES.has(part.type)) return false
-  if (META_TYPES.has(part.type)) return false
-
-  if (part.type === "text") {
-    return !!part.text?.trim()
-  }
-
-  if (part.type === "tool" || part.type === "tool_use" || part.type === "tool_result") {
-    return true
-  }
-
-  return true
-}
-
-function sdkMessageHasContent(message: MessageData): boolean {
-  return (message.parts ?? []).some(sdkPartHasContent)
-}
-
-async function readMessagesFromSDK(client: Client, sessionID: string): Promise<MessageData[]> {
-  try {
-    const response = await client.session.messages({ path: { id: sessionID } })
-    return normalizeSDKResponse(response, [] as MessageData[], { preferResponseOnMissingData: true })
-  } catch {
-    return []
-  }
-}
-
-function findMessagesWithThinkingOnlyFromSDK(messages: MessageData[]): string[] {
-  const result: string[] = []
-
-  for (const msg of messages) {
-    if (msg.info?.role !== "assistant") continue
-    if (!msg.info?.id) continue
-    if (!msg.parts || msg.parts.length === 0) continue
-
-    const hasThinking = msg.parts.some((part) => THINKING_TYPES.has(part.type))
-    const hasContent = msg.parts.some(sdkPartHasContent)
-
-    if (hasThinking && !hasContent) {
-      result.push(msg.info.id)
-    }
-  }
-
-  return result
-}
-
-function findEmptyMessagesFromSDK(messages: MessageData[]): string[] {
-  const emptyIds: string[] = []
-
-  for (const msg of messages) {
-    if (!msg.info?.id) continue
-    if (!sdkMessageHasContent(msg)) {
-      emptyIds.push(msg.info.id)
-    }
-  }
-
-  return emptyIds
-}
-
-function findEmptyMessageByIndexFromSDK(messages: MessageData[], targetIndex: number): string | null {
-  const indicesToTry = [
-    targetIndex,
-    targetIndex - 1,
-    targetIndex + 1,
-    targetIndex - 2,
-    targetIndex + 2,
-    targetIndex - 3,
-    targetIndex - 4,
-    targetIndex - 5,
-  ]
-
-  for (const index of indicesToTry) {
-    if (index < 0 || index >= messages.length) continue
-    const targetMessage = messages[index]
-    if (!targetMessage.info?.id) continue
-
-    if (!sdkMessageHasContent(targetMessage)) {
-      return targetMessage.info.id
-    }
-  }
-
-  return null
-}

package/src/hooks/session-recovery/recover-thinking-block-order.ts

@@ -1,137 +0,0 @@
-import type { createOpencodeClient } from "@opencode-ai/sdk"
-import type { MessageData } from "./types"
-import { extractMessageIndex } from "./detect-error-type"
-import { findMessageByIndexNeedingThinking, findMessagesWithOrphanThinking, prependThinkingPart } from "./storage"
-import { isSqliteBackend } from "../../shared/opencode-storage-detection"
-import { prependThinkingPartAsync } from "./storage/thinking-prepend"
-import { THINKING_TYPES } from "./constants"
-import { normalizeSDKResponse } from "../../shared"
-
-type Client = ReturnType<typeof createOpencodeClient>
-
-export async function recoverThinkingBlockOrder(
-  client: Client,
-  sessionID: string,
-  _failedAssistantMsg: MessageData,
-  _directory: string,
-  error: unknown
-): Promise<boolean> {
-  if (isSqliteBackend()) {
-    return recoverThinkingBlockOrderFromSDK(client, sessionID, error)
-  }
-
-  const targetIndex = extractMessageIndex(error)
-  if (targetIndex !== null) {
-    const targetMessageID = findMessageByIndexNeedingThinking(sessionID, targetIndex)
-    if (targetMessageID) {
-      return prependThinkingPart(sessionID, targetMessageID)
-    }
-  }
-
-  const orphanMessages = findMessagesWithOrphanThinking(sessionID)
-  if (orphanMessages.length === 0) {
-    return false
-  }
-
-  let anySuccess = false
-  for (const messageID of orphanMessages) {
-    if (prependThinkingPart(sessionID, messageID)) {
-      anySuccess = true
-    }
-  }
-
-  return anySuccess
-}
-
-async function recoverThinkingBlockOrderFromSDK(
-  client: Client,
-  sessionID: string,
-  error: unknown
-): Promise<boolean> {
-  const targetIndex = extractMessageIndex(error)
-  if (targetIndex !== null) {
-    const targetMessageID = await findMessageByIndexNeedingThinkingFromSDK(client, sessionID, targetIndex)
-    if (targetMessageID) {
-      return prependThinkingPartAsync(client, sessionID, targetMessageID)
-    }
-  }
-
-  const orphanMessages = await findMessagesWithOrphanThinkingFromSDK(client, sessionID)
-  if (orphanMessages.length === 0) {
-    return false
-  }
-
-  let anySuccess = false
-  for (const messageID of orphanMessages) {
-    if (await prependThinkingPartAsync(client, sessionID, messageID)) {
-      anySuccess = true
-    }
-  }
-
-  return anySuccess
-}
-
-async function findMessagesWithOrphanThinkingFromSDK(
-  client: Client,
-  sessionID: string
-): Promise<string[]> {
-  let messages: MessageData[]
-  try {
-    const response = await client.session.messages({ path: { id: sessionID } })
-    messages = normalizeSDKResponse(response, [] as MessageData[], { preferResponseOnMissingData: true })
-  } catch {
-    return []
-  }
-
-  const result: string[] = []
-  for (const msg of messages) {
-    if (msg.info?.role !== "assistant") continue
-    if (!msg.info?.id) continue
-    if (!msg.parts || msg.parts.length === 0) continue
-
-    const partsWithIds = msg.parts.filter(
-      (part): part is { id: string; type: string } => typeof part.id === "string"
-    )
-    if (partsWithIds.length === 0) continue
-
-    const sortedParts = [...partsWithIds].sort((a, b) => a.id.localeCompare(b.id))
-    const firstPart = sortedParts[0]
-    if (!THINKING_TYPES.has(firstPart.type)) {
-      result.push(msg.info.id)
-    }
-  }
-
-  return result
-}
-
-async function findMessageByIndexNeedingThinkingFromSDK(
-  client: Client,
-  sessionID: string,
-  targetIndex: number
-): Promise<string | null> {
-  let messages: MessageData[]
-  try {
-    const response = await client.session.messages({ path: { id: sessionID } })
-    messages = normalizeSDKResponse(response, [] as MessageData[], { preferResponseOnMissingData: true })
-  } catch {
-    return null
-  }
-
-  if (targetIndex < 0 || targetIndex >= messages.length) return null
-
-  const targetMessage = messages[targetIndex]
-  if (targetMessage.info?.role !== "assistant") return null
-  if (!targetMessage.info?.id) return null
-  if (!targetMessage.parts || targetMessage.parts.length === 0) return null
-
-  const partsWithIds = targetMessage.parts.filter(
-    (part): part is { id: string; type: string } => typeof part.id === "string"
-  )
-  if (partsWithIds.length === 0) return null
-
-  const sortedParts = [...partsWithIds].sort((a, b) => a.id.localeCompare(b.id))
-  const firstPart = sortedParts[0]
-  const firstIsThinking = THINKING_TYPES.has(firstPart.type)
-
-  return firstIsThinking ? null : targetMessage.info.id
-}

package/src/hooks/session-recovery/recover-thinking-disabled-violation.ts

@@ -1,75 +0,0 @@
-import type { createOpencodeClient } from "@opencode-ai/sdk"
-import type { MessageData } from "./types"
-import { findMessagesWithThinkingBlocks, stripThinkingParts } from "./storage"
-import { isSqliteBackend } from "../../shared/opencode-storage-detection"
-import { stripThinkingPartsAsync } from "./storage/thinking-strip"
-import { THINKING_TYPES } from "./constants"
-import { log } from "../../shared/logger"
-import { normalizeSDKResponse } from "../../shared"
-
-type Client = ReturnType<typeof createOpencodeClient>
-
-export async function recoverThinkingDisabledViolation(
-  client: Client,
-  sessionID: string,
-  _failedAssistantMsg: MessageData
-): Promise<boolean> {
-  if (isSqliteBackend()) {
-    return recoverThinkingDisabledViolationFromSDK(client, sessionID)
-  }
-
-  const messagesWithThinking = findMessagesWithThinkingBlocks(sessionID)
-  if (messagesWithThinking.length === 0) {
-    return false
-  }
-
-  let anySuccess = false
-  for (const messageID of messagesWithThinking) {
-    if (stripThinkingParts(messageID)) {
-      anySuccess = true
-    }
-  }
-
-  return anySuccess
-}
-
-async function recoverThinkingDisabledViolationFromSDK(
-  client: Client,
-  sessionID: string
-): Promise<boolean> {
-  try {
-    const response = await client.session.messages({ path: { id: sessionID } })
-    const messages = normalizeSDKResponse(response, [] as MessageData[], { preferResponseOnMissingData: true })
-
-    const messageIDsWithThinking: string[] = []
-    for (const msg of messages) {
-      if (msg.info?.role !== "assistant") continue
-      if (!msg.info?.id) continue
-      if (!msg.parts) continue
-
-      const hasThinking = msg.parts.some((part) => THINKING_TYPES.has(part.type))
-      if (hasThinking) {
-        messageIDsWithThinking.push(msg.info.id)
-      }
-    }
-
-    if (messageIDsWithThinking.length === 0) {
-      return false
-    }
-
-    let anySuccess = false
-    for (const messageID of messageIDsWithThinking) {
-      if (await stripThinkingPartsAsync(client, sessionID, messageID)) {
-        anySuccess = true
-      }
-    }
-
-    return anySuccess
-  } catch (error) {
-    log("[session-recovery] recoverThinkingDisabledViolationFromSDK failed", {
-      sessionID,
-      error: String(error),
-    })
-    return false
-  }
-}