@hiai-gg/hiai-opencode 0.1.1 → 0.1.2

package/src/hooks/session-recovery/AGENTS.md

@@ -1,59 +1,59 @@
-# src/hooks/session-recovery/ — Auto Session Error Recovery
-
-**Generated:** 2026-04-11
-
-## OVERVIEW
-
-16 files + storage/ subdir. Session Tier hook handling `session.error` events. Detects recoverable error types, applies targeted recovery strategies, and resumes the session transparently.
-
-## RECOVERY STRATEGIES
-
-| Error Type | File | Recovery Action |
-|------------|------|-----------------|
-| `tool_result_missing` | `recover-tool-result-missing.ts` | Reconstruct missing tool results from storage |
-| `thinking_block_order` | `recover-thinking-block-order.ts` | Reorder malformed thinking blocks |
-| `thinking_disabled_violation` | `recover-thinking-disabled-violation.ts` | Strip thinking blocks when disabled |
-| `empty_content_message` | `recover-empty-content-message*.ts` | Handle empty/null content blocks |
-
-## KEY FILES
-
-| File | Purpose |
-|------|---------|
-| `hook.ts` | `createSessionRecoveryHook()` — error detection, strategy dispatch, resume |
-| `detect-error-type.ts` | `detectErrorType(error)` → `RecoveryErrorType \| null` |
-| `resume.ts` | `resumeSession()` — rebuild session context, trigger retry |
-| `storage.ts` | Per-session message storage for recovery reconstruction |
-| `recover-tool-result-missing.ts` | Reconstruct tool results from stored metadata |
-| `recover-thinking-block-order.ts` | Fix malformed thinking block sequences |
-| `recover-thinking-disabled-violation.ts` | Remove thinking blocks from model context |
-| `recover-empty-content-message.ts` | Handle empty assistant messages |
-| `recover-empty-content-message-sdk.ts` | SDK variant for empty content recovery |
-| `types.ts` | `StoredMessageMeta`, `StoredPart`, `ResumeConfig`, `MessageData` |
-
-## STORAGE SUBDIRECTORY
-
-```
-storage/
-  ├── message-store.ts    # In-memory + file message cache
-  ├── part-store.ts       # Individual message parts storage
-  └── index.ts            # Barrel export
-```
-
-Stores message metadata and parts per session for recovery reconstruction.
-
-## HOOK INTERFACE
-
-```typescript
-interface SessionRecoveryHook {
-  handleSessionRecovery: (info: MessageInfo) => Promise<boolean>
-  isRecoverableError: (error: unknown) => boolean
-  setOnAbortCallback: (cb: (sessionID: string) => void) => void
-  setOnRecoveryCompleteCallback: (cb: (sessionID: string) => void) => void
-}
-```
-
-## NOTES
-
-- Guards with `processingErrors` Set to prevent duplicate recovery attempts on same error
-- Supports `experimental` config for behavior flags
-- Distinct from `anthropic-context-window-limit-recovery` (handles token limit; this handles structural errors)
+# src/hooks/session-recovery/ — Auto Session Error Recovery
+
+**Generated:** 2026-04-11
+
+## OVERVIEW
+
+16 files + storage/ subdir. Session Tier hook handling `session.error` events. Detects recoverable error types, applies targeted recovery strategies, and resumes the session transparently.
+
+## RECOVERY STRATEGIES
+
+| Error Type | File | Recovery Action |
+|------------|------|-----------------|
+| `tool_result_missing` | `recover-tool-result-missing.ts` | Reconstruct missing tool results from storage |
+| `thinking_block_order` | `recover-thinking-block-order.ts` | Reorder malformed thinking blocks |
+| `thinking_disabled_violation` | `recover-thinking-disabled-violation.ts` | Strip thinking blocks when disabled |
+| `empty_content_message` | `recover-empty-content-message*.ts` | Handle empty/null content blocks |
+
+## KEY FILES
+
+| File | Purpose |
+|------|---------|
+| `hook.ts` | `createSessionRecoveryHook()` — error detection, strategy dispatch, resume |
+| `detect-error-type.ts` | `detectErrorType(error)` → `RecoveryErrorType \| null` |
+| `resume.ts` | `resumeSession()` — rebuild session context, trigger retry |
+| `storage.ts` | Per-session message storage for recovery reconstruction |
+| `recover-tool-result-missing.ts` | Reconstruct tool results from stored metadata |
+| `recover-thinking-block-order.ts` | Fix malformed thinking block sequences |
+| `recover-thinking-disabled-violation.ts` | Remove thinking blocks from model context |
+| `recover-empty-content-message.ts` | Handle empty assistant messages |
+| `recover-empty-content-message-sdk.ts` | SDK variant for empty content recovery |
+| `types.ts` | `StoredMessageMeta`, `StoredPart`, `ResumeConfig`, `MessageData` |
+
+## STORAGE SUBDIRECTORY
+
+```
+storage/
+  ├── message-store.ts    # In-memory + file message cache
+  ├── part-store.ts       # Individual message parts storage
+  └── index.ts            # Barrel export
+```
+
+Stores message metadata and parts per session for recovery reconstruction.
+
+## HOOK INTERFACE
+
+```typescript
+interface SessionRecoveryHook {
+  handleSessionRecovery: (info: MessageInfo) => Promise<boolean>
+  isRecoverableError: (error: unknown) => boolean
+  setOnAbortCallback: (cb: (sessionID: string) => void) => void
+  setOnRecoveryCompleteCallback: (cb: (sessionID: string) => void) => void
+}
+```
+
+## NOTES
+
+- Guards with `processingErrors` Set to prevent duplicate recovery attempts on same error
+- Supports `experimental` config for behavior flags
+- Distinct from `anthropic-context-window-limit-recovery` (handles token limit; this handles structural errors)

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

@@ -1,5 +1,5 @@
-export { OPENCODE_STORAGE, MESSAGE_STORAGE, PART_STORAGE } from "../../shared"
-
-export const THINKING_TYPES = new Set(["thinking", "redacted_thinking", "reasoning"])
-export const META_TYPES = new Set(["step-start", "step-finish"])
-export const CONTENT_TYPES = new Set(["text", "tool", "tool_use", "tool_result"])
+export { OPENCODE_STORAGE, MESSAGE_STORAGE, PART_STORAGE } from "../../shared"
+
+export const THINKING_TYPES = new Set(["thinking", "redacted_thinking", "reasoning"])
+export const META_TYPES = new Set(["step-start", "step-finish"])
+export const CONTENT_TYPES = new Set(["text", "tool", "tool_use", "tool_result"])

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

@@ -1,102 +1,102 @@
-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
-  }
-}
+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 +1,166 @@
-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,
-  }
-}
+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,
+  }
+}