@hiai-gg/hiai-opencode 0.1.7 → 0.1.9

package/src/plugin/hooks/create-transform-hooks.ts

@@ -1,85 +0,0 @@
-import type { HiaiOpenCodeConfig } from "../../config"
-import type { PluginContext } from "../types"
-import type { RalphLoopHook } from "../../hooks/ralph-loop"
-
-import {
-  createClaudeCodeHooksHook,
-  createKeywordDetectorHook,
-  createThinkingBlockValidatorHook,
-  createToolPairValidatorHook,
-} from "../../hooks"
-import {
-  contextCollector,
-  createContextInjectorMessagesTransformHook,
-} from "../../features/context-injector"
-import { safeCreateHook } from "../../shared/safe-create-hook"
-
-export type TransformHooks = {
-  claudeCodeHooks: ReturnType<typeof createClaudeCodeHooksHook> | null
-  keywordDetector: ReturnType<typeof createKeywordDetectorHook> | null
-  contextInjectorMessagesTransform: ReturnType<typeof createContextInjectorMessagesTransformHook>
-  thinkingBlockValidator: ReturnType<typeof createThinkingBlockValidatorHook> | null
-  toolPairValidator: ReturnType<typeof createToolPairValidatorHook> | null
-}
-
-export function createTransformHooks(args: {
-  ctx: PluginContext
-  pluginConfig: HiaiOpenCodeConfig
-  isHookEnabled: (hookName: string) => boolean
-  safeHookEnabled?: boolean
-  ralphLoop?: RalphLoopHook | null
-}): TransformHooks {
-  const { ctx, pluginConfig, isHookEnabled, ralphLoop } = args
-  const safeHookEnabled = args.safeHookEnabled ?? true
-
-  const claudeCodeHooks = isHookEnabled("claude-code-hooks")
-    ? safeCreateHook(
-        "claude-code-hooks",
-        () =>
-          createClaudeCodeHooksHook(
-            ctx,
-            {
-              disabledHooks: (pluginConfig.claude_code?.hooks ?? true) ? undefined : true,
-              keywordDetectorDisabled: !isHookEnabled("keyword-detector"),
-            },
-            contextCollector,
-          ),
-        { enabled: safeHookEnabled },
-      )
-    : null
-
-  const keywordDetector = isHookEnabled("keyword-detector")
-    ? safeCreateHook(
-        "keyword-detector",
-        () => createKeywordDetectorHook(ctx, contextCollector, ralphLoop ?? undefined),
-        { enabled: safeHookEnabled },
-      )
-    : null
-
-  const contextInjectorMessagesTransform =
-    createContextInjectorMessagesTransformHook(contextCollector)
-
-  const thinkingBlockValidator = isHookEnabled("thinking-block-validator")
-    ? safeCreateHook(
-        "thinking-block-validator",
-        () => createThinkingBlockValidatorHook(),
-        { enabled: safeHookEnabled },
-      )
-    : null
-
-  const toolPairValidator = isHookEnabled("tool-pair-validator")
-    ? safeCreateHook(
-        "tool-pair-validator",
-        () => createToolPairValidatorHook(),
-        { enabled: safeHookEnabled },
-      )
-    : null
-
-  return {
-    claudeCodeHooks,
-    keywordDetector,
-    contextInjectorMessagesTransform,
-    thinkingBlockValidator,
-    toolPairValidator,
-  }
-}

package/src/plugin/messages-transform.ts

@@ -1,28 +0,0 @@
-import type { Message, Part } from "@opencode-ai/sdk"
-
-import type { CreatedHooks } from "../create-hooks"
-
-type MessageWithParts = {
-  info: Message
-  parts: Part[]
-}
-
-type MessagesTransformOutput = { messages: MessageWithParts[] }
-
-export function createMessagesTransformHandler(args: {
-  hooks: CreatedHooks
-}): (input: Record<string, never>, output: MessagesTransformOutput) => Promise<void> {
-  return async (input, output): Promise<void> => {
-    await args.hooks.contextInjectorMessagesTransform?.[
-      "experimental.chat.messages.transform"
-    ]?.(input, output)
-
-    await args.hooks.thinkingBlockValidator?.[
-      "experimental.chat.messages.transform"
-    ]?.(input, output)
-
-    await args.hooks.toolPairValidator?.[
-      "experimental.chat.messages.transform"
-    ]?.(input, output)
-  }
-}

package/src/plugin/normalize-tool-arg-schemas.ts

@@ -1,75 +0,0 @@
-import { tool } from "@opencode-ai/plugin"
-import type { ToolDefinition } from "@opencode-ai/plugin"
-
-type ToolArgSchema = ToolDefinition["args"][string]
-
-type SchemaWithJsonSchemaOverride = ToolArgSchema & {
-  _zod: ToolArgSchema["_zod"] & {
-    toJSONSchema?: () => unknown
-  }
-}
-
-function stripRootJsonSchemaFields(jsonSchema: Record<string, unknown>): Record<string, unknown> {
-  const { $schema: _schema, ...rest } = jsonSchema
-  return rest
-}
-
-function attachJsonSchemaOverride(schema: SchemaWithJsonSchemaOverride): void {
-  if (schema._zod.toJSONSchema) {
-    return
-  }
-
-  schema._zod.toJSONSchema = (): Record<string, unknown> => {
-    const originalOverride = schema._zod.toJSONSchema
-    delete schema._zod.toJSONSchema
-
-    try {
-      return stripRootJsonSchemaFields(tool.schema.toJSONSchema(schema))
-    } finally {
-      schema._zod.toJSONSchema = originalOverride
-    }
-  }
-}
-
-export function normalizeToolArgSchemas<TDefinition extends Pick<ToolDefinition, "args">>(
-  toolDefinition: TDefinition,
-): TDefinition {
-  for (const schema of Object.values(toolDefinition.args)) {
-    attachJsonSchemaOverride(schema)
-  }
-
-  return toolDefinition
-}
-
-const UNSUPPORTED_SCHEMA_KEYWORDS = new Set(["contentEncoding", "contentMediaType"])
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value)
-}
-
-export function sanitizeJsonSchema(value: unknown, depth = 0, isPropertyName = false): unknown {
-  if (Array.isArray(value)) {
-    return value.map((item) => sanitizeJsonSchema(item, depth + 1, false))
-  }
-
-  if (!isRecord(value)) {
-    return value
-  }
-
-  const sanitized: Record<string, unknown> = {}
-
-  for (const [key, nestedValue] of Object.entries(value)) {
-    if (!isPropertyName && UNSUPPORTED_SCHEMA_KEYWORDS.has(key)) {
-      continue
-    }
-
-    if (depth === 0 && key === "$schema") {
-      continue
-    }
-
-    const childIsPropertyName = key === "properties" && !isPropertyName
-    sanitized[key] = sanitizeJsonSchema(nestedValue, depth + 1, childIsPropertyName)
-  }
-
-  return sanitized
-}

package/src/plugin/recent-synthetic-idles.ts

@@ -1,20 +0,0 @@
-export function pruneRecentSyntheticIdles(args: {
-  recentSyntheticIdles: Map<string, number>
-  recentRealIdles: Map<string, number>
-  now: number
-  dedupWindowMs: number
-}): void {
-  const { recentSyntheticIdles, recentRealIdles, now, dedupWindowMs } = args
-
-  for (const [sessionID, emittedAt] of recentSyntheticIdles) {
-    if (now - emittedAt >= dedupWindowMs) {
-      recentSyntheticIdles.delete(sessionID)
-    }
-  }
-
-  for (const [sessionID, emittedAt] of recentRealIdles) {
-    if (now - emittedAt >= dedupWindowMs) {
-      recentRealIdles.delete(sessionID)
-    }
-  }
-}

package/src/plugin/session-agent-resolver.ts

@@ -1,37 +0,0 @@
-import { log } from "../shared"
-import { normalizeSDKResponse } from "../shared"
-
-interface SessionMessage {
-  info?: {
-    agent?: string
-    role?: string
-  }
-}
-
-type SessionClient = {
-  session: {
-    messages: (opts: { path: { id: string } }) => Promise<{ data?: SessionMessage[] }>
-  }
-}
-
-export async function resolveSessionAgent(
-  client: SessionClient,
-  sessionId: string,
-): Promise<string | undefined> {
-  try {
-    const messagesResp = await client.session.messages({ path: { id: sessionId } })
-    const messages = normalizeSDKResponse(messagesResp, [] as SessionMessage[])
-
-    for (const msg of messages) {
-      if (msg.info?.agent) {
-        return msg.info.agent
-      }
-    }
-  } catch (error) {
-    log("[session-agent-resolver] Failed to resolve agent from session", {
-      sessionId,
-      error: String(error),
-    })
-  }
-  return undefined
-}

package/src/plugin/session-status-normalizer.ts

@@ -1,22 +0,0 @@
-type EventInput = { event: { type: string; properties?: Record<string, unknown> } }
-type SessionStatus = { type: string }
-
-export function normalizeSessionStatusToIdle(input: EventInput): EventInput | null {
-	if (input.event.type !== "session.status") return null
-
-	const props = input.event.properties
-	if (!props) return null
-
-	const status = props.status as SessionStatus | undefined
-	if (!status || status.type !== "idle") return null
-
-	const sessionID = props.sessionID as string | undefined
-	if (!sessionID) return null
-
-	return {
-		event: {
-			type: "session.idle",
-			properties: { sessionID },
-		},
-	}
-}

package/src/plugin/skill-context.ts

@@ -1,150 +0,0 @@
-import type { AvailableSkill } from "../agents/dynamic-agent-prompt-builder"
-import type { HiaiOpenCodeConfig } from "../config"
-import type { BrowserAutomationProvider } from "../config/schema/browser-automation"
-import type {
-  LoadedSkill,
-  SkillScope,
-} from "../features/opencode-skill-loader/types"
-
-import {
-  discoverConfigSourceSkills,
-  discoverManagedPluginSkills,
-  discoverUserClaudeSkills,
-  discoverProjectClaudeSkills,
-  discoverOpencodeGlobalSkills,
-  discoverOpencodeProjectSkills,
-  discoverProjectAgentsSkills,
-  discoverGlobalAgentsSkills,
-  mergeSkills,
-} from "../features/opencode-skill-loader"
-import { createBuiltinSkills } from "../features/builtin-skills"
-import { getSystemMcpServerNames } from "../features/claude-code-mcp-loader"
-import { resolveSkillDiscoveryConfig } from "./skill-discovery-config"
-
-export type SkillContext = {
-  mergedSkills: LoadedSkill[]
-  availableSkills: AvailableSkill[]
-  browserProvider: BrowserAutomationProvider
-  disabledSkills: Set<string>
-}
-
-const PROVIDER_GATED_SKILL_NAMES = new Set(["agent-browser", "playwright"])
-
-function mapScopeToLocation(scope: SkillScope): AvailableSkill["location"] {
-  if (scope === "user" || scope === "opencode") return "user"
-  if (scope === "project" || scope === "opencode-project") return "project"
-  return "plugin"
-}
-
-function filterProviderGatedSkills(
-  skills: LoadedSkill[],
-  browserProvider: BrowserAutomationProvider,
-): LoadedSkill[] {
-  return skills.filter((skill) => {
-    if (!PROVIDER_GATED_SKILL_NAMES.has(skill.name)) {
-      return true
-    }
-
-    return skill.name === browserProvider
-  })
-}
-
-export async function createSkillContext(args: {
-  directory: string
-  pluginConfig: HiaiOpenCodeConfig
-}): Promise<SkillContext> {
-  const { directory, pluginConfig } = args
-
-  const browserProvider: BrowserAutomationProvider =
-    pluginConfig.browser_automation_engine?.provider ?? "playwright"
-
-  const disabledSkills = new Set<string>(pluginConfig.disabled_skills ?? [])
-  const systemMcpNames = getSystemMcpServerNames()
-
-  const builtinSkills = createBuiltinSkills({
-    browserProvider,
-    disabledSkills,
-  }).filter((skill) => {
-    if (skill.mcpConfig) {
-      for (const mcpName of Object.keys(skill.mcpConfig)) {
-        if (systemMcpNames.has(mcpName)) return false
-      }
-    }
-    return true
-  })
-
-  const discovery = resolveSkillDiscoveryConfig(pluginConfig)
-  const [
-    managedPluginSkills,
-    configSourceSkills,
-    userSkills,
-    globalSkills,
-    projectSkills,
-    opencodeProjectSkills,
-    agentsProjectSkills,
-    agentsGlobalSkills,
-  ] =
-    await Promise.all([
-      discoverManagedPluginSkills(),
-      discovery.config_sources
-        ? discoverConfigSourceSkills({
-          config: pluginConfig.skills,
-          configDir: directory,
-        })
-        : Promise.resolve([]),
-      discovery.global_claude ? discoverUserClaudeSkills() : Promise.resolve([]),
-      discovery.global_opencode ? discoverOpencodeGlobalSkills() : Promise.resolve([]),
-      discovery.project_claude ? discoverProjectClaudeSkills(directory) : Promise.resolve([]),
-      discovery.project_opencode ? discoverOpencodeProjectSkills(directory) : Promise.resolve([]),
-      discovery.project_agents ? discoverProjectAgentsSkills(directory) : Promise.resolve([]),
-      discovery.global_agents ? discoverGlobalAgentsSkills() : Promise.resolve([]),
-    ])
-
-  const filteredManagedPluginSkills = filterProviderGatedSkills(
-    managedPluginSkills,
-    browserProvider,
-  )
-  const filteredConfigSourceSkills = filterProviderGatedSkills(
-    configSourceSkills,
-    browserProvider,
-  )
-  const filteredUserSkills = filterProviderGatedSkills(userSkills, browserProvider)
-  const filteredGlobalSkills = filterProviderGatedSkills(globalSkills, browserProvider)
-  const filteredProjectSkills = filterProviderGatedSkills(projectSkills, browserProvider)
-  const filteredOpencodeProjectSkills = filterProviderGatedSkills(
-    opencodeProjectSkills,
-    browserProvider,
-  )
-  const filteredAgentsProjectSkills = filterProviderGatedSkills(
-    agentsProjectSkills,
-    browserProvider,
-  )
-  const filteredAgentsGlobalSkills = filterProviderGatedSkills(
-    agentsGlobalSkills,
-    browserProvider,
-  )
-
-  const mergedSkills = mergeSkills(
-    builtinSkills,
-    pluginConfig.skills,
-    [...filteredManagedPluginSkills, ...filteredConfigSourceSkills],
-    [...filteredUserSkills, ...filteredAgentsGlobalSkills],
-    filteredGlobalSkills,
-    [...filteredProjectSkills, ...filteredAgentsProjectSkills],
-    filteredOpencodeProjectSkills,
-    { configDir: directory },
-  )
-
-  const availableSkills: AvailableSkill[] = mergedSkills.map((skill) => ({
-    name: skill.name,
-    description: skill.definition.description ?? "",
-    location: mapScopeToLocation(skill.scope),
-  }))
-
-  return {
-    mergedSkills,
-    availableSkills,
-    browserProvider,
-    disabledSkills,
-  }
-}

package/src/plugin/skill-discovery-config.ts

@@ -1,32 +0,0 @@
-import type { HiaiOpenCodeConfig } from "../config"
-import type { SkillDiscoveryConfig } from "../config/schema"
-
-export type ResolvedSkillDiscoveryConfig = Required<SkillDiscoveryConfig>
-
-const DEFAULT_SKILL_DISCOVERY: ResolvedSkillDiscoveryConfig = {
-  config_sources: true,
-  project_opencode: true,
-  global_opencode: false,
-  project_claude: false,
-  global_claude: false,
-  project_agents: false,
-  global_agents: false,
-}
-
-export function resolveSkillDiscoveryConfig(
-  pluginConfig: HiaiOpenCodeConfig,
-): ResolvedSkillDiscoveryConfig {
-  const resolved: ResolvedSkillDiscoveryConfig = {
-    ...DEFAULT_SKILL_DISCOVERY,
-    ...(pluginConfig.skill_discovery ?? {}),
-  }
-
-  // Compatibility switch: historically this only controlled Claude-style skills.
-  // Keep that meaning, but make it stronger for those two sources.
-  if (pluginConfig.claude_code?.skills === false) {
-    resolved.project_claude = false
-    resolved.global_claude = false
-  }
-
-  return resolved
-}

package/src/plugin/startup-diagnostics.ts

@@ -1,27 +0,0 @@
-import { MODE_TO_AGENT } from "../shared/mode-routing"
-
-const WRITE_CAPABLE_AGENTS = new Set(["coder", "sub", "designer", "brainstormer"])
-
-const WRITE_MODES = new Set([
-  "quick",
-  "bounded",
-  "deep",
-  "cross-module",
-  "visual-engineering",
-  "artistry",
-  "writing",
-])
-
-const READONLY_MODES = new Set(["ultrabrain", "git", "git-ops"])
-
-export function lintModeAgentCapabilities(): void {
-  for (const [mode, agent] of Object.entries(MODE_TO_AGENT)) {
-    if (WRITE_MODES.has(mode) && !WRITE_CAPABLE_AGENTS.has(agent)) {
-      console.warn(`[startup-lint] Mode "${mode}" targets agent "${agent}" which cannot write/edit. Tasks using this mode may fail when attempting file operations.`)
-    }
-
-    if (READONLY_MODES.has(mode) && WRITE_CAPABLE_AGENTS.has(agent)) {
-      console.warn(`[startup-lint] Mode "${mode}" targets agent "${agent}" which can write. Consider verifying this is intentional.`)
-    }
-  }
-}

package/src/plugin/system-transform.ts

@@ -1,6 +0,0 @@
-export function createSystemTransformHandler(): (
-  input: { sessionID?: string; model: { id: string; providerID: string; [key: string]: unknown } },
-  output: { system: string[] },
-) => Promise<void> {
-  return async (): Promise<void> => {}
-}

package/src/plugin/tool-execute-after.ts

@@ -1,178 +0,0 @@
-import { consumeToolMetadata } from "../features/tool-metadata-store"
-import type { CreatedHooks } from "../create-hooks"
-import { log } from "../shared"
-import { getAgentConfigKey, stripInvisibleAgentCharacters } from "../shared/agent-display-names"
-import type { PluginContext } from "./types"
-import { readState, writeState } from "../hooks/ralph-loop/storage"
-
-const VERIFICATION_ATTEMPT_PATTERN = /<ulw_verification_attempt_id>(.*?)<\/ulw_verification_attempt_id>/i
-const ULTRAWORK_VERIFICATION_GATE_AGENT_KEYS = new Set(["critic"])
-
-function getMetadataString(metadata: Record<string, unknown> | undefined, keys: string[]): string | undefined {
-  for (const key of keys) {
-    const value = metadata?.[key]
-    if (typeof value === "string") {
-      return value
-    }
-  }
-
-  return undefined
-}
-
-function getPluginDirectory(ctx: PluginContext): string | null {
-  if (typeof ctx === "object" && ctx !== null && "directory" in ctx && typeof ctx.directory === "string") {
-    return ctx.directory
-  }
-
-  return null
-}
-
-function normalizeAgentKey(agentName: string | undefined): string | undefined {
-  if (typeof agentName !== "string") {
-    return undefined
-  }
-
-  const stripped = stripInvisibleAgentCharacters(agentName).trim()
-  if (!stripped) {
-    return undefined
-  }
-  const normalized = stripInvisibleAgentCharacters(getAgentConfigKey(stripped)).trim().toLowerCase()
-  return normalized.length > 0 ? normalized : undefined
-}
-
-function isUltraworkVerificationAgent(agentName: string | undefined): boolean {
-  const normalized = normalizeAgentKey(agentName)
-  return normalized ? ULTRAWORK_VERIFICATION_GATE_AGENT_KEYS.has(normalized) : false
-}
-
-export function createToolExecuteAfterHandler(args: {
-  ctx: PluginContext
-  hooks: CreatedHooks
-}): (
-  input: { tool: string; sessionID: string; callID: string },
-  output:
-    | { title: string; output: string; metadata: Record<string, unknown> }
-    | undefined,
-) => Promise<void> {
-  const { ctx, hooks } = args
-
-  return async (
-    input: { tool: string; sessionID: string; callID: string },
-    output: { title: string; output: string; metadata: Record<string, unknown> } | undefined,
-  ): Promise<void> => {
-    if (!output) return
-
-    const stored = consumeToolMetadata(input.sessionID, input.callID)
-    if (stored) {
-      if (stored.title) {
-        output.title = stored.title
-      }
-      if (stored.metadata) {
-        output.metadata = { ...output.metadata, ...stored.metadata }
-      }
-    }
-
-    if (input.tool === "task") {
-      const directory = getPluginDirectory(ctx)
-      const sessionId = getMetadataString(output.metadata, ["sessionId", "sessionID", "session_id"])
-      const agent = getMetadataString(output.metadata, ["agent"])
-      const prompt = getMetadataString(output.metadata, ["prompt"])
-      const verificationAttemptId = prompt?.match(VERIFICATION_ATTEMPT_PATTERN)?.[1]?.trim()
-      const loopState = directory ? readState(directory) : null
-      const isVerificationContext =
-        isUltraworkVerificationAgent(agent)
-        && !!sessionId
-        && !!directory
-        && loopState?.active === true
-        && loopState.ultrawork === true
-        && loopState.verification_pending === true
-        && loopState.session_id === input.sessionID
-
-      log("[tool-execute-after] ULW verification tracking check", {
-        tool: input.tool,
-        agent,
-        parentSessionID: input.sessionID,
-        criticSessionID: sessionId,
-        hasPromptInMetadata: typeof prompt === "string",
-        extractedVerificationAttemptId: verificationAttemptId,
-      })
-
-      if (
-        isVerificationContext
-        && verificationAttemptId
-        && loopState.verification_attempt_id === verificationAttemptId
-      ) {
-        writeState(directory, {
-          ...loopState,
-          verification_session_id: sessionId,
-        })
-        log("[tool-execute-after] Stored critic verification session via attempt match", {
-          parentSessionID: input.sessionID,
-          criticSessionID: sessionId,
-          verificationAttemptId,
-        })
-      } else if (isVerificationContext && !verificationAttemptId) {
-        writeState(directory, {
-          ...loopState,
-          verification_session_id: sessionId,
-        })
-        log("[tool-execute-after] Fallback: stored critic verification session without attempt match", {
-          parentSessionID: input.sessionID,
-          criticSessionID: sessionId,
-          hasPromptInMetadata: typeof prompt === "string",
-          expectedAttemptId: loopState.verification_attempt_id,
-          extractedAttemptId: verificationAttemptId,
-        })
-      }
-    }
-
-    const runToolExecuteAfterHooks = async (): Promise<void> => {
-      await hooks.toolOutputTruncator?.["tool.execute.after"]?.(input, output)
-      await hooks.claudeCodeHooks?.["tool.execute.after"]?.(input, output)
-      await hooks.preemptiveCompaction?.["tool.execute.after"]?.(input, output)
-      await hooks.contextWindowMonitor?.["tool.execute.after"]?.(input, output)
-      await hooks.commentChecker?.["tool.execute.after"]?.(input, output)
-      await hooks.directoryAgentsInjector?.["tool.execute.after"]?.(input, output)
-      await hooks.directoryReadmeInjector?.["tool.execute.after"]?.(input, output)
-      await hooks.rulesInjector?.["tool.execute.after"]?.(input, output)
-      await hooks.emptyTaskResponseDetector?.["tool.execute.after"]?.(input, output)
-      await hooks.agentUsageReminder?.["tool.execute.after"]?.(input, output)
-      await hooks.categorySkillReminder?.["tool.execute.after"]?.(input, output)
-      await hooks.interactiveBashSession?.["tool.execute.after"]?.(input, output)
-      await hooks.editErrorRecovery?.["tool.execute.after"]?.(input, output)
-      await hooks.delegateTaskRetry?.["tool.execute.after"]?.(input, output)
-      await hooks.guardHook?.["tool.execute.after"]?.(input, output)
-      await hooks.taskResumeInfo?.["tool.execute.after"]?.(input, output)
-      await hooks.readImageResizer?.["tool.execute.after"]?.(input, output)
-      await hooks.hashlineReadEnhancer?.["tool.execute.after"]?.(input, output)
-      await hooks.webfetchRedirectGuard?.["tool.execute.after"]?.(input, output)
-      await hooks.jsonErrorRecovery?.["tool.execute.after"]?.(input, output)
-    }
-
-    if (input.tool === "extract" || input.tool === "discard") {
-      const originalOutput = {
-        title: output.title,
-        output: output.output,
-        metadata: { ...output.metadata },
-      }
-
-      try {
-        await runToolExecuteAfterHooks()
-      } catch (error) {
-        output.title = originalOutput.title
-        output.output = originalOutput.output
-        output.metadata = originalOutput.metadata
-        log("[tool-execute-after] Failed to process extract/discard hooks", {
-          tool: input.tool,
-          sessionID: input.sessionID,
-          callID: input.callID,
-          error,
-        })
-      }
-
-      return
-    }
-
-    await runToolExecuteAfterHooks()
-  }
-}