@hiai-gg/hiai-opencode 0.1.7 → 0.1.8

package/src/hooks/anthropic-context-window-limit-recovery/parser.ts

@@ -1,209 +0,0 @@
-import type { ParsedTokenLimitError } from "./types"
-
-interface AnthropicErrorData {
-  type: "error"
-  error: {
-    type: string
-    message: string
-  }
-  request_id?: string
-}
-
-const TOKEN_LIMIT_PATTERNS = [
-  /(\d+)\s*tokens?\s*>\s*(\d+)\s*maximum/i,
-  /prompt.*?(\d+).*?tokens.*?exceeds.*?(\d+)/i,
-  /(\d+).*?tokens.*?limit.*?(\d+)/i,
-  /context.*?length.*?(\d+).*?maximum.*?(\d+)/i,
-  /max.*?context.*?(\d+).*?but.*?(\d+)/i,
-]
-
-const TOKEN_LIMIT_KEYWORDS = [
-  "prompt is too long",
-  "is too long",
-  "context_length_exceeded",
-  "max_tokens",
-  "token limit",
-  "context length",
-  "too many tokens",
-  "non-empty content",
-]
-
-// Patterns that indicate thinking block structure errors (NOT token limit errors)
-// These should be handled by session-recovery hook, not compaction
-const THINKING_BLOCK_ERROR_PATTERNS = [
-  /thinking.*first block/i,
-  /first block.*thinking/i,
-  /must.*start.*thinking/i,
-  /thinking.*redacted_thinking/i,
-  /expected.*thinking.*found/i,
-  /thinking.*disabled.*cannot.*contain/i,
-]
-
-function isThinkingBlockError(text: string): boolean {
-  return THINKING_BLOCK_ERROR_PATTERNS.some((pattern) => pattern.test(text))
-}
-
-const MESSAGE_INDEX_PATTERN = /messages\.(\d+)/
-
-function extractTokensFromMessage(message: string): { current: number; max: number } | null {
-  for (const pattern of TOKEN_LIMIT_PATTERNS) {
-    const match = message.match(pattern)
-    if (match) {
-      const num1 = parseInt(match[1], 10)
-      const num2 = parseInt(match[2], 10)
-      return num1 > num2 ? { current: num1, max: num2 } : { current: num2, max: num1 }
-    }
-  }
-  return null
-}
-
-function extractMessageIndex(text: string): number | undefined {
-  const match = text.match(MESSAGE_INDEX_PATTERN)
-  if (match) {
-    return parseInt(match[1], 10)
-  }
-  return undefined
-}
-
-function isTokenLimitError(text: string): boolean {
-  if (isThinkingBlockError(text)) {
-    return false
-  }
-  const lower = text.toLowerCase()
-  return TOKEN_LIMIT_KEYWORDS.some((kw) => lower.includes(kw))
-}
-
-export function parseAnthropicTokenLimitError(err: unknown): ParsedTokenLimitError | null {
-  try {
-    return parseAnthropicTokenLimitErrorUnsafe(err)
-  } catch {
-    return null
-  }
-}
-
-function parseAnthropicTokenLimitErrorUnsafe(err: unknown): ParsedTokenLimitError | null {
-  if (typeof err === "string") {
-    if (err.toLowerCase().includes("non-empty content")) {
-      return {
-        currentTokens: 0,
-        maxTokens: 0,
-        errorType: "non-empty content",
-        messageIndex: extractMessageIndex(err),
-      }
-    }
-    if (isTokenLimitError(err)) {
-      const tokens = extractTokensFromMessage(err)
-      return {
-        currentTokens: tokens?.current ?? 0,
-        maxTokens: tokens?.max ?? 0,
-        errorType: "token_limit_exceeded_string",
-      }
-    }
-    return null
-  }
-
-  if (!err || typeof err !== "object") return null
-
-  const errObj = err as Record<string, unknown>
-
-  const dataObj = errObj.data as Record<string, unknown> | undefined
-  const responseBody = dataObj?.responseBody
-  const errorMessage = errObj.message as string | undefined
-  const errorData = errObj.error as Record<string, unknown> | undefined
-  const nestedError = errorData?.error as Record<string, unknown> | undefined
-
-  const textSources: string[] = []
-
-  if (typeof responseBody === "string") textSources.push(responseBody)
-  if (typeof errorMessage === "string") textSources.push(errorMessage)
-  if (typeof errorData?.message === "string") textSources.push(errorData.message as string)
-  if (typeof errObj.body === "string") textSources.push(errObj.body as string)
-  if (typeof errObj.details === "string") textSources.push(errObj.details as string)
-  if (typeof errObj.reason === "string") textSources.push(errObj.reason as string)
-  if (typeof errObj.description === "string") textSources.push(errObj.description as string)
-  if (typeof nestedError?.message === "string") textSources.push(nestedError.message as string)
-  if (typeof dataObj?.message === "string") textSources.push(dataObj.message as string)
-  if (typeof dataObj?.error === "string") textSources.push(dataObj.error as string)
-
-  if (textSources.length === 0) {
-    try {
-      const jsonStr = JSON.stringify(errObj)
-      if (isTokenLimitError(jsonStr)) {
-        textSources.push(jsonStr)
-      }
-    } catch {}
-  }
-
-  const combinedText = textSources.join(" ")
-  if (!isTokenLimitError(combinedText)) return null
-
-  if (typeof responseBody === "string") {
-    try {
-      const jsonPatterns = [
-        // Greedy match to last } for nested JSON
-        /data:\s*(\{[\s\S]*\})\s*$/m,
-        /(\{"type"\s*:\s*"error"[\s\S]*\})/,
-        /(\{[\s\S]*"error"[\s\S]*\})/,
-      ]
-
-      for (const pattern of jsonPatterns) {
-        const dataMatch = responseBody.match(pattern)
-        if (dataMatch) {
-          try {
-            const jsonData: AnthropicErrorData = JSON.parse(dataMatch[1])
-            const message = jsonData.error?.message || ""
-            const tokens = extractTokensFromMessage(message)
-
-            if (tokens) {
-              return {
-                currentTokens: tokens.current,
-                maxTokens: tokens.max,
-                requestId: jsonData.request_id,
-                errorType: jsonData.error?.type || "token_limit_exceeded",
-              }
-            }
-          } catch {}
-        }
-      }
-
-      const bedrockJson = JSON.parse(responseBody)
-      if (typeof bedrockJson.message === "string" && isTokenLimitError(bedrockJson.message)) {
-        return {
-          currentTokens: 0,
-          maxTokens: 0,
-          errorType: "bedrock_input_too_long",
-        }
-      }
-    } catch {}
-  }
-
-  for (const text of textSources) {
-    const tokens = extractTokensFromMessage(text)
-    if (tokens) {
-      return {
-        currentTokens: tokens.current,
-        maxTokens: tokens.max,
-        errorType: "token_limit_exceeded",
-      }
-    }
-  }
-
-  if (combinedText.toLowerCase().includes("non-empty content")) {
-    return {
-      currentTokens: 0,
-      maxTokens: 0,
-      errorType: "non-empty content",
-      messageIndex: extractMessageIndex(combinedText),
-    }
-  }
-
-  if (isTokenLimitError(combinedText)) {
-    return {
-      currentTokens: 0,
-      maxTokens: 0,
-      errorType: "token_limit_exceeded_unknown",
-    }
-  }
-
-  return null
-}

package/src/hooks/anthropic-context-window-limit-recovery/pruning-deduplication.ts

@@ -1,189 +0,0 @@
-import { readdirSync, readFileSync } from "node:fs"
-import { join } from "node:path"
-import type { PluginInput } from "@opencode-ai/plugin"
-import type { PruningState, ToolCallSignature } from "./pruning-types"
-import { estimateTokens } from "./pruning-types"
-import { log } from "../../shared/logger"
-import { getMessageDir } from "../../shared/opencode-message-dir"
-import { isSqliteBackend } from "../../shared/opencode-storage-detection"
-import { normalizeSDKResponse } from "../../shared"
-
-type OpencodeClient = PluginInput["client"]
-
-export interface DeduplicationConfig {
-  enabled: boolean
-  protectedTools?: string[]
-}
-
-interface ToolPart {
-  type: string
-  callID?: string
-  tool?: string
-  state?: {
-    input?: unknown
-    output?: string
-  }
-}
-
-interface MessagePart {
-  type: string
-  parts?: ToolPart[]
-}
-
-export function createToolSignature(toolName: string, input: unknown): string {
-  const sortedInput = sortObject(input)
-  return `${toolName}::${JSON.stringify(sortedInput)}`
-}
-
-function sortObject(obj: unknown): unknown {
-  if (obj === null || obj === undefined) return obj
-  if (typeof obj !== "object") return obj
-  if (Array.isArray(obj)) return obj.map(sortObject)
-  
-  const sorted: Record<string, unknown> = {}
-  const keys = Object.keys(obj as Record<string, unknown>).sort()
-  for (const key of keys) {
-    sorted[key] = sortObject((obj as Record<string, unknown>)[key])
-  }
-  return sorted
-}
-
-function readMessages(sessionID: string): MessagePart[] {
-  const messageDir = getMessageDir(sessionID)
-  if (!messageDir) return []
-
-  const messages: MessagePart[] = []
-  
-  try {
-    const files = readdirSync(messageDir).filter((f: string) => f.endsWith(".json"))
-    for (const file of files) {
-      const content = readFileSync(join(messageDir, file), "utf-8")
-      const data = JSON.parse(content)
-      if (data.parts) {
-        messages.push(data)
-      }
-    }
-  } catch {
-    return []
-  }
-
-  return messages
-}
-
-async function readMessagesFromSDK(client: OpencodeClient, sessionID: string): Promise<MessagePart[]> {
-  try {
-    const response = await client.session.messages({ path: { id: sessionID } })
-    const rawMessages = normalizeSDKResponse(response, [] as Array<{ parts?: ToolPart[] }>, { preferResponseOnMissingData: true })
-    return rawMessages.filter((m) => m.parts) as MessagePart[]
-  } catch {
-    return []
-  }
-}
-
-export async function executeDeduplication(
-  sessionID: string,
-  state: PruningState,
-  config: DeduplicationConfig,
-  protectedTools: Set<string>,
-  client?: OpencodeClient,
-): Promise<number> {
-  if (!config.enabled) return 0
-
-  const messages = (client && isSqliteBackend())
-    ? await readMessagesFromSDK(client, sessionID)
-    : readMessages(sessionID)
-
-  const signatures = new Map<string, ToolCallSignature[]>()
-  
-  let currentTurn = 0
-  
-  for (const msg of messages) {
-    if (!msg.parts) continue
-    
-    for (const part of msg.parts) {
-      if (part.type === "step-start") {
-        currentTurn++
-        continue
-      }
-      
-      if (part.type !== "tool" || !part.callID || !part.tool) continue
-      
-      if (protectedTools.has(part.tool)) continue
-      
-      if (config.protectedTools?.includes(part.tool)) continue
-      
-      if (state.toolIdsToPrune.has(part.callID)) continue
-      
-      const signature = createToolSignature(part.tool, part.state?.input)
-      
-      if (!signatures.has(signature)) {
-        signatures.set(signature, [])
-      }
-      
-      signatures.get(signature)!.push({
-        toolName: part.tool,
-        signature,
-        callID: part.callID,
-        turn: currentTurn,
-      })
-      
-      if (!state.toolSignatures.has(signature)) {
-        state.toolSignatures.set(signature, [])
-      }
-      state.toolSignatures.get(signature)!.push({
-        toolName: part.tool,
-        signature,
-        callID: part.callID,
-        turn: currentTurn,
-      })
-    }
-  }
-  
-  let prunedCount = 0
-  let tokensSaved = 0
-  
-  for (const [signature, calls] of signatures) {
-    if (calls.length > 1) {
-      const toPrune = calls.slice(0, -1)
-      
-      for (const call of toPrune) {
-        state.toolIdsToPrune.add(call.callID)
-        prunedCount++
-        
-        const output = findToolOutput(messages, call.callID)
-        if (output) {
-          tokensSaved += estimateTokens(output)
-        }
-        
-        log("[pruning-deduplication] pruned duplicate", {
-          tool: call.toolName,
-          callID: call.callID,
-          turn: call.turn,
-          signature: signature.substring(0, 100),
-        })
-      }
-    }
-  }
-  
-  log("[pruning-deduplication] complete", {
-    prunedCount,
-    tokensSaved,
-    uniqueSignatures: signatures.size,
-  })
-  
-  return prunedCount
-}
-
-function findToolOutput(messages: MessagePart[], callID: string): string | null {
-  for (const msg of messages) {
-    if (!msg.parts) continue
-    
-    for (const part of msg.parts) {
-      if (part.type === "tool" && part.callID === callID && part.state?.output) {
-        return part.state.output
-      }
-    }
-  }
-  
-  return null
-}

package/src/hooks/anthropic-context-window-limit-recovery/pruning-tool-output-truncation.ts

@@ -1,142 +0,0 @@
-import { existsSync, readdirSync, readFileSync } from "node:fs"
-import { join } from "node:path"
-import type { PluginInput } from "@opencode-ai/plugin"
-import { getOpenCodeStorageDir } from "../../shared/data-path"
-import { truncateToolResult } from "./storage"
-import { truncateToolResultAsync } from "./tool-result-storage-sdk"
-import { log } from "../../shared/logger"
-import { getMessageDir } from "../../shared/opencode-message-dir"
-import { isSqliteBackend } from "../../shared/opencode-storage-detection"
-import { normalizeSDKResponse } from "../../shared"
-
-type OpencodeClient = PluginInput["client"]
-
-interface StoredToolPart {
-  type?: string
-  callID?: string
-  truncated?: boolean
-  state?: {
-    output?: string
-  }
-}
-
-interface SDKToolPart {
-  id: string
-  type: string
-  callID?: string
-  tool?: string
-  state?: { output?: string; time?: { compacted?: number } }
-}
-
-interface SDKMessage {
-  info?: { id?: string }
-  parts?: SDKToolPart[]
-}
-
-function getPartStorage(): string {
-  return join(getOpenCodeStorageDir(), "part")
-}
-
-function getMessageIds(sessionID: string): string[] {
-  const messageDir = getMessageDir(sessionID)
-  if (!messageDir) return []
-
-  const messageIds: string[] = []
-  for (const file of readdirSync(messageDir)) {
-    if (!file.endsWith(".json")) continue
-    messageIds.push(file.replace(".json", ""))
-  }
-
-  return messageIds
-}
-
-export async function truncateToolOutputsByCallId(
-  sessionID: string,
-  callIds: Set<string>,
-  client?: OpencodeClient,
-): Promise<{ truncatedCount: number }> {
-  if (callIds.size === 0) return { truncatedCount: 0 }
-
-  if (client && isSqliteBackend()) {
-    return truncateToolOutputsByCallIdFromSDK(client, sessionID, callIds)
-  }
-
-  const messageIds = getMessageIds(sessionID)
-  if (messageIds.length === 0) return { truncatedCount: 0 }
-
-  let truncatedCount = 0
-
-  for (const messageID of messageIds) {
-    const partDir = join(getPartStorage(), messageID)
-    if (!existsSync(partDir)) continue
-
-    for (const file of readdirSync(partDir)) {
-      if (!file.endsWith(".json")) continue
-      const partPath = join(partDir, file)
-
-      try {
-        const content = readFileSync(partPath, "utf-8")
-        const part = JSON.parse(content) as StoredToolPart
-
-        if (part.type !== "tool" || !part.callID) continue
-        if (!callIds.has(part.callID)) continue
-        if (!part.state?.output || part.truncated) continue
-
-        const result = truncateToolResult(partPath)
-        if (result.success) {
-          truncatedCount++
-        }
-      } catch {
-        continue
-      }
-    }
-  }
-
-  if (truncatedCount > 0) {
-    log("[auto-compact] pruned duplicate tool outputs", {
-      sessionID,
-      truncatedCount,
-    })
-  }
-
-  return { truncatedCount }
-}
-
-async function truncateToolOutputsByCallIdFromSDK(
-  client: OpencodeClient,
-  sessionID: string,
-  callIds: Set<string>,
-): Promise<{ truncatedCount: number }> {
-  try {
-    const response = await client.session.messages({ path: { id: sessionID } })
-    const messages = normalizeSDKResponse(response, [] as SDKMessage[], { preferResponseOnMissingData: true })
-    let truncatedCount = 0
-
-    for (const msg of messages) {
-      const messageID = msg.info?.id
-      if (!messageID || !msg.parts) continue
-
-      for (const part of msg.parts) {
-        if (part.type !== "tool" || !part.callID) continue
-        if (!callIds.has(part.callID)) continue
-        if (!part.state?.output || part.state?.time?.compacted) continue
-
-        const result = await truncateToolResultAsync(client, sessionID, messageID, part.id, part)
-        if (result.success) {
-          truncatedCount++
-        }
-      }
-    }
-
-    if (truncatedCount > 0) {
-      log("[auto-compact] pruned duplicate tool outputs (SDK)", {
-        sessionID,
-        truncatedCount,
-      })
-    }
-
-    return { truncatedCount }
-  } catch {
-    return { truncatedCount: 0 }
-  }
-}

package/src/hooks/anthropic-context-window-limit-recovery/pruning-types.ts

@@ -1,44 +0,0 @@
-export interface ToolCallSignature {
-  toolName: string
-  signature: string
-  callID: string
-  turn: number
-}
-
-export interface FileOperation {
-  callID: string
-  tool: string
-  filePath: string
-  turn: number
-}
-
-export interface ErroredToolCall {
-  callID: string
-  toolName: string
-  turn: number
-  errorAge: number
-}
-
-export interface PruningResult {
-  itemsPruned: number
-  totalTokensSaved: number
-  strategies: {
-    deduplication: number
-    supersedeWrites: number
-    purgeErrors: number
-  }
-}
-
-export interface PruningState {
-  toolIdsToPrune: Set<string>
-  currentTurn: number
-  fileOperations: Map<string, FileOperation[]>
-  toolSignatures: Map<string, ToolCallSignature[]>
-  erroredTools: Map<string, ErroredToolCall>
-}
-
-export const CHARS_PER_TOKEN = 4
-
-export function estimateTokens(text: string): number {
-  return Math.ceil(text.length / CHARS_PER_TOKEN)
-}

package/src/hooks/anthropic-context-window-limit-recovery/recovery-hook.test-support.ts

@@ -1,119 +0,0 @@
-import { mock } from "bun:test"
-import type { PluginInput } from "@opencode-ai/plugin"
-import type { HiaiOpenCodeConfig } from "../../config"
-import { createAnthropicContextWindowLimitRecoveryHook } from "./recovery-hook"
-
-type ExecuteCompactFn = typeof import("./executor").executeCompact
-type GetLastAssistantFn = typeof import("./executor").getLastAssistant
-type ParseAnthropicTokenLimitErrorFn = typeof import("./parser").parseAnthropicTokenLimitError
-
-export type MockLastAssistant = {
-  info: {
-    summary?: boolean
-    providerID: string
-    modelID: string
-  }
-  hasContent: boolean
-}
-
-export const executeCompactMock = mock<ExecuteCompactFn>(async () => {})
-export const getLastAssistantMock = mock<GetLastAssistantFn>(async (): Promise<MockLastAssistant> => ({
-  info: {
-    providerID: "anthropic",
-    modelID: "claude-sonnet-4-6",
-  },
-  hasContent: true,
-}))
-export const parseAnthropicTokenLimitErrorMock = mock<ParseAnthropicTokenLimitErrorFn>(() => ({
-  currentTokens: 250000,
-  maxTokens: 200000,
-  errorType: "token_limit_exceeded",
-  providerID: "anthropic",
-  modelID: "claude-sonnet-4-6",
-}))
-
-const pluginConfig = {
-  git_master: {
-    commit_footer: false,
-    include_co_authored_by: false,
-    git_env_prefix: "",
-  },
-} satisfies HiaiOpenCodeConfig
-
-export function createRecoveryHook() {
-  return createAnthropicContextWindowLimitRecoveryHook(
-    createMockContext(),
-    {
-      pluginConfig,
-      dependencies: {
-        executeCompact: executeCompactMock,
-        getLastAssistant: getLastAssistantMock,
-        log: () => {},
-        parseAnthropicTokenLimitError: parseAnthropicTokenLimitErrorMock,
-      },
-    } as never,
-  )
-}
-
-export function createMockContext(): PluginInput {
-  return {
-    client: {
-      session: {
-        messages: mock(() => Promise.resolve({ data: [] })),
-      },
-      tui: {
-        showToast: mock(() => Promise.resolve()),
-      },
-    },
-    project: {} as never,
-    directory: "/tmp",
-    worktree: "/tmp",
-    serverUrl: new URL("http://localhost"),
-    $: {} as never,
-  } as never
-}
-
-export function setupDelayedTimeoutMocks(): {
-  createUntrackedTimeout: () => ReturnType<typeof setTimeout>
-  runScheduledTimeout: (index: number) => void
-  restore: () => void
-  getClearTimeoutCalls: () => Array<ReturnType<typeof setTimeout>>
-  getScheduledTimeouts: () => Array<ReturnType<typeof setTimeout>>
-} {
-  const originalSetTimeout = globalThis.setTimeout
-  const originalClearTimeout = globalThis.clearTimeout
-  const clearTimeoutCalls: Array<ReturnType<typeof setTimeout>> = []
-  const scheduledTimeouts: Array<ReturnType<typeof setTimeout>> = []
-  const scheduledCallbacks: Array<() => void> = []
-
-  function createTimeoutHandle(): ReturnType<typeof setTimeout> {
-    const timeoutID = originalSetTimeout(() => {}, 60_000)
-    originalClearTimeout(timeoutID)
-    return timeoutID
-  }
-
-  globalThis.setTimeout = ((callback: () => void, _delay?: number) => {
-    const timeoutID = createTimeoutHandle()
-    scheduledTimeouts.push(timeoutID)
-    scheduledCallbacks.push(callback)
-    return timeoutID
-  }) as typeof setTimeout
-
-  globalThis.clearTimeout = ((timeoutID: ReturnType<typeof setTimeout>) => {
-    clearTimeoutCalls.push(timeoutID)
-    originalClearTimeout(timeoutID)
-  }) as typeof clearTimeout
-
-  return {
-    createUntrackedTimeout: createTimeoutHandle,
-    runScheduledTimeout: (index: number) => {
-      scheduledCallbacks[index]?.()
-    },
-    restore: () => {
-      globalThis.setTimeout = originalSetTimeout
-      globalThis.clearTimeout = originalClearTimeout
-    },
-    getClearTimeoutCalls: () => clearTimeoutCalls,
-    getScheduledTimeouts: () => scheduledTimeouts,
-  }
-}