@hiai-gg/hiai-opencode 0.1.6 → 0.1.8

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

@@ -1,188 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin"
-import type { Platform } from "./session-notification-sender"
-
-type SessionNotificationConfig = {
-  playSound: boolean
-  soundPath: string
-  idleConfirmationDelay: number
-  skipIfIncompleteTodos: boolean
-  maxTrackedSessions: number
-  /** Grace period in ms to ignore late-arriving activity events after scheduling (default: 100) */
-  activityGracePeriodMs?: number
-}
-
-export function createIdleNotificationScheduler(options: {
-  ctx: PluginInput
-  platform: Platform
-  config: SessionNotificationConfig
-  hasIncompleteTodos: (ctx: PluginInput, sessionID: string) => Promise<boolean>
-  send: (ctx: PluginInput, platform: Platform, sessionID: string) => Promise<void>
-  playSound: (ctx: PluginInput, platform: Platform, soundPath: string) => Promise<void>
-}) {
-  const notifiedSessions = new Set<string>()
-  const pendingTimers = new Map<string, ReturnType<typeof setTimeout>>()
-  const sessionActivitySinceIdle = new Set<string>()
-  const notificationVersions = new Map<string, number>()
-  const executingNotifications = new Set<string>()
-  const scheduledAt = new Map<string, number>()
-
-  const activityGracePeriodMs = options.config.activityGracePeriodMs ?? 100
-
-  function cleanupOldSessions(): void {
-    const maxSessions = options.config.maxTrackedSessions
-    if (notifiedSessions.size > maxSessions) {
-      const sessionsToRemove = Array.from(notifiedSessions).slice(0, notifiedSessions.size - maxSessions)
-      sessionsToRemove.forEach((id) => {
-        notifiedSessions.delete(id)
-      })
-    }
-    if (sessionActivitySinceIdle.size > maxSessions) {
-      const sessionsToRemove = Array.from(sessionActivitySinceIdle).slice(0, sessionActivitySinceIdle.size - maxSessions)
-      sessionsToRemove.forEach((id) => {
-        sessionActivitySinceIdle.delete(id)
-      })
-    }
-    if (notificationVersions.size > maxSessions) {
-      const sessionsToRemove = Array.from(notificationVersions.keys()).slice(0, notificationVersions.size - maxSessions)
-      sessionsToRemove.forEach((id) => {
-        notificationVersions.delete(id)
-      })
-    }
-    if (executingNotifications.size > maxSessions) {
-      const sessionsToRemove = Array.from(executingNotifications).slice(0, executingNotifications.size - maxSessions)
-      sessionsToRemove.forEach((id) => {
-        executingNotifications.delete(id)
-      })
-    }
-    if (scheduledAt.size > maxSessions) {
-      const sessionsToRemove = Array.from(scheduledAt.keys()).slice(0, scheduledAt.size - maxSessions)
-      sessionsToRemove.forEach((id) => {
-        scheduledAt.delete(id)
-      })
-    }
-  }
-
-  function cancelPendingNotification(sessionID: string): void {
-    const timer = pendingTimers.get(sessionID)
-    if (timer) {
-      clearTimeout(timer)
-      pendingTimers.delete(sessionID)
-    }
-    scheduledAt.delete(sessionID)
-    sessionActivitySinceIdle.add(sessionID)
-    notificationVersions.set(sessionID, (notificationVersions.get(sessionID) ?? 0) + 1)
-  }
-
-  function markSessionActivity(sessionID: string): void {
-    const scheduledTime = scheduledAt.get(sessionID)
-    if (
-      activityGracePeriodMs > 0 &&
-      scheduledTime !== undefined &&
-      Date.now() - scheduledTime <= activityGracePeriodMs
-    ) {
-      return
-    }
-
-    cancelPendingNotification(sessionID)
-    if (!executingNotifications.has(sessionID)) {
-      notifiedSessions.delete(sessionID)
-    }
-  }
-
-  async function executeNotification(sessionID: string, version: number): Promise<void> {
-    if (executingNotifications.has(sessionID)) {
-      pendingTimers.delete(sessionID)
-      scheduledAt.delete(sessionID)
-      return
-    }
-
-    if (notificationVersions.get(sessionID) !== version) {
-      pendingTimers.delete(sessionID)
-      scheduledAt.delete(sessionID)
-      return
-    }
-
-    if (sessionActivitySinceIdle.has(sessionID)) {
-      sessionActivitySinceIdle.delete(sessionID)
-      pendingTimers.delete(sessionID)
-      scheduledAt.delete(sessionID)
-      return
-    }
-
-    if (notifiedSessions.has(sessionID)) {
-      pendingTimers.delete(sessionID)
-      scheduledAt.delete(sessionID)
-      return
-    }
-
-    executingNotifications.add(sessionID)
-    try {
-      if (options.config.skipIfIncompleteTodos) {
-        const hasPendingWork = await options.hasIncompleteTodos(options.ctx, sessionID)
-        if (notificationVersions.get(sessionID) !== version) {
-          return
-        }
-        if (hasPendingWork) return
-      }
-
-      if (notificationVersions.get(sessionID) !== version) {
-        return
-      }
-
-      if (sessionActivitySinceIdle.has(sessionID)) {
-        sessionActivitySinceIdle.delete(sessionID)
-        return
-      }
-
-      notifiedSessions.add(sessionID)
-
-      await options.send(options.ctx, options.platform, sessionID)
-
-      if (options.config.playSound && options.config.soundPath) {
-        await options.playSound(options.ctx, options.platform, options.config.soundPath)
-      }
-    } finally {
-      executingNotifications.delete(sessionID)
-      pendingTimers.delete(sessionID)
-      scheduledAt.delete(sessionID)
-      if (sessionActivitySinceIdle.has(sessionID)) {
-        notifiedSessions.delete(sessionID)
-        sessionActivitySinceIdle.delete(sessionID)
-      }
-    }
-  }
-
-  function scheduleIdleNotification(sessionID: string): void {
-    if (notifiedSessions.has(sessionID)) return
-    if (pendingTimers.has(sessionID)) return
-    if (executingNotifications.has(sessionID)) return
-
-    sessionActivitySinceIdle.delete(sessionID)
-    scheduledAt.set(sessionID, Date.now())
-
-    const currentVersion = (notificationVersions.get(sessionID) ?? 0) + 1
-    notificationVersions.set(sessionID, currentVersion)
-
-    const timer = setTimeout(() => {
-      executeNotification(sessionID, currentVersion)
-    }, options.config.idleConfirmationDelay)
-
-    pendingTimers.set(sessionID, timer)
-    cleanupOldSessions()
-  }
-
-  function deleteSession(sessionID: string): void {
-    cancelPendingNotification(sessionID)
-    notifiedSessions.delete(sessionID)
-    sessionActivitySinceIdle.delete(sessionID)
-    notificationVersions.delete(sessionID)
-    executingNotifications.delete(sessionID)
-    scheduledAt.delete(sessionID)
-  }
-
-  return {
-    markSessionActivity,
-    scheduleIdleNotification,
-    deleteSession,
-  }
-}

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

@@ -1,117 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin"
-import { platform } from "os"
-import {
-  getOsascriptPath,
-  getNotifySendPath,
-  getPowershellPath,
-  getAfplayPath,
-  getPaplayPath,
-  getAplayPath,
-  getTerminalNotifierPath,
-} from "./session-notification-utils"
-import { buildWindowsToastScript, escapeAppleScriptText, escapePowerShellSingleQuotedText } from "./session-notification-formatting"
-
-export type Platform = "darwin" | "linux" | "win32" | "unsupported"
-
-export function detectPlatform(): Platform {
-  const detected = platform()
-  if (detected === "darwin" || detected === "linux" || detected === "win32") return detected
-  return "unsupported"
-}
-
-export function getDefaultSoundPath(platform: Platform): string {
-  switch (platform) {
-    case "darwin":
-      return "/System/Library/Sounds/Glass.aiff"
-    case "linux":
-      return "/usr/share/sounds/freedesktop/stereo/complete.oga"
-    case "win32":
-      return "C:\\Windows\\Media\\notify.wav"
-    default:
-      return ""
-  }
-}
-
-export async function sendSessionNotification(
-  ctx: PluginInput,
-  platform: Platform,
-  title: string,
-  message: string
-): Promise<void> {
-  switch (platform) {
-    case "darwin": {
-      // Try terminal-notifier first - deterministic click-to-focus
-      const terminalNotifierPath = await getTerminalNotifierPath()
-      if (terminalNotifierPath) {
-        const bundleId = process.env.__CFBundleIdentifier
-        try {
-          if (bundleId) {
-            await ctx.$`${terminalNotifierPath} -title ${title} -message ${message} -activate ${bundleId}`.quiet()
-          } else {
-            await ctx.$`${terminalNotifierPath} -title ${title} -message ${message}`.quiet()
-          }
-          break
-        } catch {
-        }
-      }
-
-      // Fallback: osascript (click may open Finder instead of terminal)
-      const osascriptPath = await getOsascriptPath()
-      if (!osascriptPath) return
-
-      const escapedTitle = escapeAppleScriptText(title)
-      const escapedMessage = escapeAppleScriptText(message)
-      await ctx.$`${osascriptPath} -e ${"display notification \"" + escapedMessage + "\" with title \"" + escapedTitle + "\""}`.nothrow().quiet()
-      break
-    }
-    case "linux": {
-      const notifySendPath = await getNotifySendPath()
-      if (!notifySendPath) return
-
-      await ctx.$`${notifySendPath} ${title} ${message} 2>/dev/null`.nothrow().quiet()
-      break
-    }
-    case "win32": {
-      const powershellPath = await getPowershellPath()
-      if (!powershellPath) return
-
-      const toastScript = buildWindowsToastScript(title, message)
-      await ctx.$`${powershellPath} -Command ${toastScript}`.nothrow().quiet()
-      break
-    }
-  }
-}
-
-export async function playSessionNotificationSound(
-  ctx: PluginInput,
-  platform: Platform,
-  soundPath: string
-): Promise<void> {
-  switch (platform) {
-    case "darwin": {
-      const afplayPath = await getAfplayPath()
-      if (!afplayPath) return
-      ctx.$`${afplayPath} ${soundPath}`.nothrow().quiet()
-      break
-    }
-    case "linux": {
-      const paplayPath = await getPaplayPath()
-      if (paplayPath) {
-        ctx.$`${paplayPath} ${soundPath} 2>/dev/null`.nothrow().quiet()
-      } else {
-        const aplayPath = await getAplayPath()
-        if (aplayPath) {
-          ctx.$`${aplayPath} ${soundPath} 2>/dev/null`.nothrow().quiet()
-        }
-      }
-      break
-    }
-    case "win32": {
-      const powershellPath = await getPowershellPath()
-      if (!powershellPath) return
-      const escaped = escapePowerShellSingleQuotedText(soundPath)
-      ctx.$`${powershellPath} -Command ${"(New-Object Media.SoundPlayer '" + escaped + "').PlaySync()"}`.nothrow().quiet()
-      break
-    }
-  }
-}

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

@@ -1,80 +0,0 @@
-import { log } from "../shared/logger"
-
-declare const Bun: {
-  which(commandName: string): string | null
-}
-
-type Platform = "darwin" | "linux" | "win32" | "unsupported"
-
-async function findCommand(commandName: string): Promise<string | null> {
-  try {
-    return Bun.which(commandName)
-  } catch (error) {
-    log("[session-notification] failed to resolve command path", {
-      commandName,
-      error: error instanceof Error ? error.message : String(error),
-    })
-    return null
-  }
-}
-
-function logBackgroundCheckError(commandName: string, error: unknown): void {
-  log("[session-notification] background command check failed", {
-    commandName,
-    error: error instanceof Error ? error.message : String(error),
-  })
-}
-
-function createCommandFinder(commandName: string): () => Promise<string | null> {
-  let cachedPath: string | null = null
-  let pending: Promise<string | null> | null = null
-
-  return async () => {
-    if (cachedPath !== null) return cachedPath
-    if (pending) return pending
-
-    pending = (async () => {
-      const path = await findCommand(commandName)
-      cachedPath = path
-      return path
-    })()
-
-    return pending
-  }
-}
-
-export const getNotifySendPath = createCommandFinder("notify-send")
-export const getOsascriptPath = createCommandFinder("osascript")
-export const getPowershellPath = createCommandFinder("powershell")
-export const getAfplayPath = createCommandFinder("afplay")
-export const getPaplayPath = createCommandFinder("paplay")
-export const getAplayPath = createCommandFinder("aplay")
-export const getTerminalNotifierPath = createCommandFinder("terminal-notifier")
-
-export function startBackgroundCheck(platform: Platform): void {
-  if (platform === "darwin") {
-    getOsascriptPath().catch((error) => {
-      logBackgroundCheckError("osascript", error)
-    })
-    getAfplayPath().catch((error) => {
-      logBackgroundCheckError("afplay", error)
-    })
-    getTerminalNotifierPath().catch((error) => {
-      logBackgroundCheckError("terminal-notifier", error)
-    })
-  } else if (platform === "linux") {
-    getNotifySendPath().catch((error) => {
-      logBackgroundCheckError("notify-send", error)
-    })
-    getPaplayPath().catch((error) => {
-      logBackgroundCheckError("paplay", error)
-    })
-    getAplayPath().catch((error) => {
-      logBackgroundCheckError("aplay", error)
-    })
-  } else if (platform === "win32") {
-    getPowershellPath().catch((error) => {
-      logBackgroundCheckError("powershell", error)
-    })
-  }
-}

package/src/hooks/session-notification.ts

@@ -1,219 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin"
-import { subagentSessions, getMainSessionID } from "../features/claude-code-session-state"
-import {
-  startBackgroundCheck,
-} from "./session-notification-utils"
-import { buildReadyNotificationContent } from "./session-notification-content"
-import {
-  type Platform,
-} from "./session-notification-sender"
-import * as sessionNotificationSender from "./session-notification-sender"
-import { hasIncompleteTodos } from "./session-todo-status"
-import { createIdleNotificationScheduler } from "./session-notification-scheduler"
-
-interface SessionNotificationConfig {
-  title?: string
-  message?: string
-  questionMessage?: string
-  permissionMessage?: string
-  playSound?: boolean
-  soundPath?: string
-  /** Delay in ms before sending notification to confirm session is still idle (default: 1500) */
-  idleConfirmationDelay?: number
-  /** Skip notification if there are incomplete todos (default: true) */
-  skipIfIncompleteTodos?: boolean
-  /** Maximum number of sessions to track before cleanup (default: 100) */
-  maxTrackedSessions?: number
-  enforceMainSessionFilter?: boolean
-  /** Grace period in ms to ignore late-arriving activity events after scheduling (default: 100) */
-  activityGracePeriodMs?: number
-}
-export function createSessionNotification(
-  ctx: PluginInput,
-  config: SessionNotificationConfig = {}
-) {
-  const currentPlatform: Platform = sessionNotificationSender.detectPlatform()
-  const defaultSoundPath = sessionNotificationSender.getDefaultSoundPath(currentPlatform)
-
-  startBackgroundCheck(currentPlatform)
-
-  const mergedConfig = {
-    title: "OpenCode",
-    message: "Agent is ready for input",
-    questionMessage: "Agent is asking a question",
-    permissionMessage: "Agent needs permission to continue",
-    playSound: false,
-    soundPath: defaultSoundPath,
-    idleConfirmationDelay: 1500,
-    skipIfIncompleteTodos: true,
-    maxTrackedSessions: 100,
-    enforceMainSessionFilter: true,
-    ...config,
-  }
-
-  const scheduler = createIdleNotificationScheduler({
-    ctx,
-    platform: currentPlatform,
-    config: mergedConfig,
-    hasIncompleteTodos,
-    send: async (hookCtx, platform, sessionID) => {
-      if (
-        typeof hookCtx.client.session.get !== "function"
-        && typeof hookCtx.client.session.messages !== "function"
-      ) {
-        await sessionNotificationSender.sendSessionNotification(
-          hookCtx,
-          platform,
-          mergedConfig.title,
-          mergedConfig.message,
-        )
-        return
-      }
-
-      const content = await buildReadyNotificationContent(hookCtx, {
-        sessionID,
-        baseTitle: mergedConfig.title,
-        baseMessage: mergedConfig.message,
-      })
-
-      await sessionNotificationSender.sendSessionNotification(hookCtx, platform, content.title, content.message)
-    },
-    playSound: sessionNotificationSender.playSessionNotificationSound,
-  })
-
-  const QUESTION_TOOLS = new Set(["question", "ask_user_question", "askuserquestion"])
-  const PERMISSION_EVENTS = new Set(["permission.ask", "permission.asked", "permission.updated", "permission.requested"])
-  const PERMISSION_HINT_PATTERN = /\b(permission|approve|approval|allow|deny|consent)\b/i
-
-  const getSessionID = (properties: Record<string, unknown> | undefined): string | undefined => {
-    const sessionID = properties?.sessionID
-    if (typeof sessionID === "string" && sessionID.length > 0) return sessionID
-
-    const sessionId = properties?.sessionId
-    if (typeof sessionId === "string" && sessionId.length > 0) return sessionId
-
-    const info = properties?.info as Record<string, unknown> | undefined
-    const infoSessionID = info?.sessionID
-    if (typeof infoSessionID === "string" && infoSessionID.length > 0) return infoSessionID
-
-    const infoSessionId = info?.sessionId
-    if (typeof infoSessionId === "string" && infoSessionId.length > 0) return infoSessionId
-
-    return undefined
-  }
-
-  const shouldNotifyForSession = (sessionID: string): boolean => {
-    if (subagentSessions.has(sessionID)) return false
-
-    if (mergedConfig.enforceMainSessionFilter) {
-      const mainSessionID = getMainSessionID()
-      if (mainSessionID && sessionID !== mainSessionID) return false
-    }
-
-    return true
-  }
-
-  const getEventToolName = (properties: Record<string, unknown> | undefined): string | undefined => {
-    const tool = properties?.tool
-    if (typeof tool === "string" && tool.length > 0) return tool
-
-    const name = properties?.name
-    if (typeof name === "string" && name.length > 0) return name
-
-    return undefined
-  }
-
-  const getQuestionText = (properties: Record<string, unknown> | undefined): string => {
-    const args = properties?.args as Record<string, unknown> | undefined
-    const questions = args?.questions
-    if (!Array.isArray(questions) || questions.length === 0) return ""
-
-    const firstQuestion = questions[0] as Record<string, unknown> | undefined
-    const questionText = firstQuestion?.question
-    return typeof questionText === "string" ? questionText : ""
-  }
-
-  return async ({ event }: { event: { type: string; properties?: unknown } }) => {
-    if (currentPlatform === "unsupported") return
-
-    const props = event.properties as Record<string, unknown> | undefined
-
-    if (event.type === "session.created") {
-      const info = props?.info as Record<string, unknown> | undefined
-      const sessionID = info?.id as string | undefined
-      if (sessionID) {
-        scheduler.markSessionActivity(sessionID)
-      }
-      return
-    }
-
-    if (event.type === "session.idle") {
-      const sessionID = getSessionID(props)
-      if (!sessionID) return
-
-      if (!shouldNotifyForSession(sessionID)) return
-
-      scheduler.scheduleIdleNotification(sessionID)
-      return
-    }
-
-    if (event.type === "message.updated") {
-      const info = props?.info as Record<string, unknown> | undefined
-      const sessionID = getSessionID({ ...props, info })
-      if (sessionID) {
-        scheduler.markSessionActivity(sessionID)
-      }
-      return
-    }
-
-    if (PERMISSION_EVENTS.has(event.type)) {
-      const sessionID = getSessionID(props)
-      if (!sessionID) return
-      if (!shouldNotifyForSession(sessionID)) return
-
-      scheduler.markSessionActivity(sessionID)
-      await sessionNotificationSender.sendSessionNotification(
-        ctx,
-        currentPlatform,
-        mergedConfig.title,
-        mergedConfig.permissionMessage,
-      )
-      if (mergedConfig.playSound && mergedConfig.soundPath) {
-        await sessionNotificationSender.playSessionNotificationSound(ctx, currentPlatform, mergedConfig.soundPath)
-      }
-      return
-    }
-
-    if (event.type === "tool.execute.before" || event.type === "tool.execute.after") {
-      const sessionID = getSessionID(props)
-      if (sessionID) {
-        scheduler.markSessionActivity(sessionID)
-
-        if (event.type === "tool.execute.before") {
-          const toolName = getEventToolName(props)?.toLowerCase()
-          if (toolName && QUESTION_TOOLS.has(toolName)) {
-            if (!shouldNotifyForSession(sessionID)) return
-
-            const questionText = getQuestionText(props)
-            const message = PERMISSION_HINT_PATTERN.test(questionText)
-              ? mergedConfig.permissionMessage
-              : mergedConfig.questionMessage
-
-            await sessionNotificationSender.sendSessionNotification(ctx, currentPlatform, mergedConfig.title, message)
-            if (mergedConfig.playSound && mergedConfig.soundPath) {
-              await sessionNotificationSender.playSessionNotificationSound(ctx, currentPlatform, mergedConfig.soundPath)
-            }
-          }
-        }
-      }
-      return
-    }
-
-    if (event.type === "session.deleted") {
-      const sessionInfo = props?.info as { id?: string } | undefined
-      if (sessionInfo?.id) {
-        scheduler.deleteSession(sessionInfo.id)
-      }
-    }
-  }
-}

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

@@ -1,59 +0,0 @@
-# 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 +0,0 @@
-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"])