goatcode-sh 0.0.1 → 0.1.3

package/src/hooks/foreground-fallback/handler.ts

@@ -0,0 +1,294 @@
+import type { PluginHookContributions } from "../../types/hook";
+import { buildFallbackChain } from "../../shared/fallback-chain";
+import { resolveModel } from "../../shared/model-resolution-pipeline";
+import { log } from "../../shared/logger";
+
+type EventHook = NonNullable<PluginHookContributions["event"]>;
+
+type ForegroundFallbackReason = "rate-limit";
+
+type ForegroundFallbackDependencies = {
+  defaultFallbackChain?: string[];
+  getCurrentModel?: (sessionID: string) => string | undefined;
+  getAvailableModels?: (sessionID: string) => Set<string>;
+  setCurrentModel?: (sessionID: string, model: string) => void | Promise<void>;
+  onFallbackApplied?: (input: {
+    sessionID: string;
+    previousModel: string;
+    nextModel: string;
+    reason: ForegroundFallbackReason;
+  }) => void | Promise<void>;
+  onRetryRequested?: (input: { sessionID: string; model: string }) => void | Promise<void>;
+  now?: () => number;
+};
+
+type EventEnvelope = {
+  event?: {
+    type?: unknown;
+    properties?: unknown;
+  };
+};
+
+const RATE_LIMIT_PATTERNS = [
+  /\b429\b/,
+  /rate.?limit/i,
+  /too many requests/i,
+  /quota.?exceeded/i,
+  /usage.?exceeded/i,
+  /usage limit/i,
+  /overloaded/i,
+  /resource.?exhausted/i,
+  /insufficient.?quota/i,
+  /high concurrency/i,
+  /reduce concurrency/i,
+] as const;
+
+const DEDUP_WINDOW_MS = 5_000;
+const SESSION_TTL_MS = 5 * 60 * 1000;
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+function collectErrorFragments(error: unknown, depth = 0): string[] {
+  if (depth > 5) return [];
+
+  if (typeof error === "string") {
+    return [error];
+  }
+
+  if (!isRecord(error)) {
+    return [];
+  }
+
+  const parts: string[] = [];
+
+  const message = error.message;
+  if (typeof message === "string") parts.push(message);
+
+  const statusCode = error.statusCode;
+  if (typeof statusCode === "number") parts.push(String(statusCode));
+
+  const status = error.status;
+  if (typeof status === "number") parts.push(String(status));
+
+  const data = error.data;
+  if (isRecord(data)) {
+    if (typeof data.message === "string") parts.push(data.message);
+    if (typeof data.responseBody === "string") parts.push(data.responseBody);
+    if (typeof data.statusCode === "number") parts.push(String(data.statusCode));
+  }
+
+  const nested = error.error;
+  if (nested !== undefined && nested !== error) {
+    parts.push(...collectErrorFragments(nested, depth + 1));
+  }
+
+  return parts;
+}
+
+function isRateLimitError(error: unknown): boolean {
+  const normalized = collectErrorFragments(error).join(" ");
+  if (normalized.length === 0) return false;
+  return RATE_LIMIT_PATTERNS.some((pattern) => pattern.test(normalized));
+}
+
+function getSessionID(properties: Record<string, unknown>): string | undefined {
+  const directSessionID = properties.sessionID;
+  if (typeof directSessionID === "string" && directSessionID.length > 0) {
+    return directSessionID;
+  }
+
+  const info = properties.info;
+  if (isRecord(info)) {
+    const infoID = info.id;
+    if (typeof infoID === "string" && infoID.length > 0) {
+      return infoID;
+    }
+
+    const infoSessionID = info.sessionID;
+    if (typeof infoSessionID === "string" && infoSessionID.length > 0) {
+      return infoSessionID;
+    }
+  }
+
+  return undefined;
+}
+
+function getCurrentModelFromProperties(properties: Record<string, unknown>): string | undefined {
+  const model = properties.model;
+  if (typeof model === "string" && model.length > 0) {
+    return model;
+  }
+
+  const info = properties.info;
+  if (isRecord(info)) {
+    const providerID = info.providerID;
+    const modelID = info.modelID;
+    if (typeof providerID === "string" && typeof modelID === "string" && providerID && modelID) {
+      return `${providerID}/${modelID}`;
+    }
+  }
+
+  return undefined;
+}
+
+function getConfiguredFallbacks(
+  properties: Record<string, unknown>,
+): string | string[] | undefined {
+  const fallbackChain = properties.fallbackChain;
+  if (typeof fallbackChain === "string") {
+    return fallbackChain;
+  }
+  if (Array.isArray(fallbackChain)) {
+    const strings = fallbackChain.filter((item): item is string => typeof item === "string");
+    return strings.length > 0 ? strings : undefined;
+  }
+
+  return undefined;
+}
+
+function getNextFallbackModel(input: {
+  currentModel: string;
+  configuredFallbacks: string | string[] | undefined;
+  defaultChain: string[];
+  availableModels: Set<string>;
+}): string | undefined {
+  const fullChain = buildFallbackChain(input.configuredFallbacks, input.defaultChain);
+  const currentIndex = fullChain.findIndex(
+    (model) => model.toLowerCase() === input.currentModel.toLowerCase(),
+  );
+  const remaining = currentIndex >= 0 ? fullChain.slice(currentIndex + 1) : fullChain;
+
+  return resolveModel({
+    fallbackChain: remaining,
+    availableModels: input.availableModels,
+  })?.model;
+}
+
+function setRetryProperties(properties: Record<string, unknown>, model: string): void {
+  properties.retryRequested = true;
+  properties.retryWithModel = model;
+}
+
+function shouldHandleRateLimitEvent(type: string, properties: Record<string, unknown>): boolean {
+  if (type === "session.error") {
+    return isRateLimitError(properties.error);
+  }
+
+  if (type === "message.updated") {
+    const info = properties.info;
+    if (!isRecord(info)) return false;
+    return isRateLimitError(info.error);
+  }
+
+  return false;
+}
+
+export function createForegroundFallbackHandler(
+  deps: ForegroundFallbackDependencies = {},
+): EventHook {
+  const now = deps.now ?? Date.now;
+  const sessionModels = new Map<string, string>();
+  const inProgress = new Set<string>();
+  const lastTrigger = new Map<string, number>();
+
+  const cleanupExpiredSessionState = (currentTime: number) => {
+    for (const [key, timestamp] of lastTrigger.entries()) {
+      if (currentTime - timestamp > SESSION_TTL_MS) {
+        lastTrigger.delete(key);
+      }
+    }
+
+    for (const sessionID of sessionModels.keys()) {
+      const hasRecentTrigger = Array.from(lastTrigger.entries()).some(([key, timestamp]) => {
+        return key.startsWith(`${sessionID}:`) && currentTime - timestamp <= SESSION_TTL_MS;
+      });
+
+      if (!hasRecentTrigger) {
+        sessionModels.delete(sessionID);
+      }
+    }
+  };
+
+  const defaultSetCurrentModel = async (sessionID: string, model: string) => {
+    sessionModels.set(sessionID, model);
+  };
+
+  return async (input: unknown) => {
+    if (!isRecord(input)) return;
+    if (lastTrigger.size > 100) {
+      cleanupExpiredSessionState(now());
+    }
+
+    const envelope = input as EventEnvelope;
+    if (!isRecord(envelope.event)) return;
+
+    const type = envelope.event.type;
+    if (typeof type !== "string") return;
+
+    const properties = envelope.event.properties;
+    if (!isRecord(properties)) return;
+    if (!shouldHandleRateLimitEvent(type, properties)) return;
+
+    const sessionID = getSessionID(properties);
+    if (!sessionID) return;
+
+    if (inProgress.has(sessionID)) return;
+
+    inProgress.add(sessionID);
+    try {
+      const configuredFallbacks = getConfiguredFallbacks(properties);
+      const eventModel = getCurrentModelFromProperties(properties);
+      const currentModel =
+        eventModel ?? deps.getCurrentModel?.(sessionID) ?? sessionModels.get(sessionID);
+      if (!currentModel) return;
+
+      const currentTime = now();
+      const dedupKey = `${sessionID}:${currentModel}`;
+      const lastTime = lastTrigger.get(dedupKey);
+      if (typeof lastTime === "number" && currentTime - lastTime < DEDUP_WINDOW_MS) {
+        return;
+      }
+
+      const availableModels = deps.getAvailableModels?.(sessionID) ?? new Set<string>();
+      const nextModel = getNextFallbackModel({
+        currentModel,
+        configuredFallbacks,
+        defaultChain: deps.defaultFallbackChain ?? [],
+        availableModels,
+      });
+
+      if (!nextModel || nextModel.toLowerCase() === currentModel.toLowerCase()) {
+        log("[foreground-fallback] no eligible fallback model", { sessionID, currentModel });
+        return;
+      }
+
+      if (deps.setCurrentModel) {
+        await Promise.resolve(deps.setCurrentModel(sessionID, nextModel));
+      }
+      await Promise.resolve(defaultSetCurrentModel(sessionID, nextModel));
+
+      setRetryProperties(properties, nextModel);
+      await Promise.resolve(deps.onRetryRequested?.({ sessionID, model: nextModel }));
+      await Promise.resolve(
+        deps.onFallbackApplied?.({
+          sessionID,
+          previousModel: currentModel,
+          nextModel,
+          reason: "rate-limit",
+        }),
+      );
+      lastTrigger.set(dedupKey, currentTime);
+      lastTrigger.set(`${sessionID}:${nextModel}`, currentTime);
+
+      log("[foreground-fallback] switched model and requested retry", {
+        sessionID,
+        from: currentModel,
+        to: nextModel,
+      });
+    } finally {
+      inProgress.delete(sessionID);
+    }
+  };
+}

package/src/hooks/foreground-fallback/index.ts

@@ -0,0 +1,2 @@
+export { createForegroundFallbackHandler } from "./handler";
+export { foregroundFallbackPlugin } from "./plugin";

package/src/hooks/foreground-fallback/plugin.ts

@@ -0,0 +1,18 @@
+import { definePlugin } from "../../plugin-api";
+import { safeCreateHook } from "../../shared/safe-create-hook";
+import { createForegroundFallbackHandler } from "./handler";
+
+const foregroundFallbackEventHook = safeCreateHook(
+  "foreground-fallback",
+  createForegroundFallbackHandler,
+);
+
+export const foregroundFallbackPlugin = definePlugin({
+  name: "foreground-fallback",
+  version: "0.1.0",
+  hooks: foregroundFallbackEventHook
+    ? {
+        event: foregroundFallbackEventHook,
+      }
+    : {},
+});

package/src/hooks/hashline-diff-enhancer/handler.test.ts

@@ -0,0 +1,166 @@
+import { describe, it, expect } from "bun:test";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import {
+  createHashlineDiffEnhancerBeforeHandler,
+  createHashlineDiffEnhancerAfterHandler,
+  createHashlineDiffEnhancerHandlers,
+} from "./handler";
+
+const HASHLINE_PATTERN = /^[0-9]+#[ZPMQVRWSNKTXJBYH]{2}\|/;
+
+describe("createHashlineDiffEnhancerHandlers", () => {
+  describe("#given a Write tool that modifies an existing file", () => {
+    describe("#when before and after handlers both run", () => {
+      it("#then metadata contains diff, hashlined content, and filediff", async () => {
+        const beforeHandler = createHashlineDiffEnhancerBeforeHandler();
+        const afterHandler = createHashlineDiffEnhancerAfterHandler();
+
+        const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "hashline-diff-"));
+        const filePath = path.join(tempDir, "test.ts");
+        fs.writeFileSync(filePath, "const a = 1\nconst b = 2\n");
+
+        const sessionID = "s1";
+        const callID = "c1";
+        const beforeInput = { tool: "write", sessionID, callID };
+        const beforeOutput = { args: { filePath } };
+
+        await beforeHandler(beforeInput, beforeOutput);
+
+        fs.writeFileSync(filePath, "const a = 1\nconst b = 2\nconst c = 3\n");
+
+        const afterInput = { tool: "write", sessionID, callID, args: {} };
+        const afterOutput = {
+          title: "write",
+          output: "File written successfully.",
+          metadata: {} as Record<string, unknown>,
+        };
+
+        await afterHandler(afterInput, afterOutput);
+
+        expect(afterOutput.metadata.diff).toBeDefined();
+        expect(typeof afterOutput.metadata.diff).toBe("string");
+        expect(afterOutput.metadata.hashlined).toBeDefined();
+        const hashlined = afterOutput.metadata.hashlined as string;
+        expect(hashlined).toMatch(HASHLINE_PATTERN);
+        expect(afterOutput.metadata.filediff).toBeDefined();
+        expect(afterOutput.title).toBe(filePath);
+
+        fs.rmSync(tempDir, { recursive: true, force: true });
+      });
+    });
+  });
+
+  describe("#given a non-Write tool", () => {
+    describe("#when the before handler processes the input", () => {
+      it("#then does not capture any state and after handler is a no-op", async () => {
+        const beforeHandler = createHashlineDiffEnhancerBeforeHandler();
+        const input = { tool: "read", sessionID: "s1", callID: "c2" };
+        const output = { args: { filePath: "/some/file.ts" } };
+
+        await beforeHandler(input, output);
+
+        const afterHandler = createHashlineDiffEnhancerAfterHandler();
+        const afterInput = { tool: "read", sessionID: "s1", callID: "c2", args: {} };
+        const afterOutput = {
+          title: "read",
+          output: "file content",
+          metadata: {} as Record<string, unknown>,
+        };
+
+        await afterHandler(afterInput, afterOutput);
+
+        expect(afterOutput.metadata.diff).toBeUndefined();
+        expect(afterOutput.metadata.hashlined).toBeUndefined();
+      });
+    });
+  });
+
+  describe("#given after handler called without prior before capture", () => {
+    describe("#when a different callID is used", () => {
+      it("#then after handler produces no diff metadata", async () => {
+        const afterHandler = createHashlineDiffEnhancerAfterHandler();
+        const afterInput = { tool: "write", sessionID: "s1", callID: "c-no-before", args: {} };
+        const afterOutput = {
+          title: "write",
+          output: "File written successfully.",
+          metadata: {} as Record<string, unknown>,
+        };
+
+        await afterHandler(afterInput, afterOutput);
+
+        expect(afterOutput.metadata.diff).toBeUndefined();
+        expect(afterOutput.metadata.hashlined).toBeUndefined();
+        expect(afterOutput.title).toBe("write");
+      });
+    });
+  });
+
+  describe("#given a Write tool targeting a new file", () => {
+    describe("#when before captures empty content and after reads the written file", () => {
+      it("#then diff reflects all lines as additions", async () => {
+        const { before, after } = createHashlineDiffEnhancerHandlers();
+
+        const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "hashline-diff-new-"));
+        const filePath = path.join(tempDir, "new-file.ts");
+
+        const sessionID = "s2";
+        const callID = "c3";
+        const beforeInput = { tool: "write", sessionID, callID };
+        const beforeOutput = { args: { filePath } };
+
+        await before(beforeInput, beforeOutput);
+
+        fs.writeFileSync(filePath, "line one\nline two\nline three\n");
+
+        const afterInput = { tool: "write", sessionID, callID, args: {} };
+        const afterOutput = {
+          title: "write",
+          output: "File written successfully.",
+          metadata: {} as Record<string, unknown>,
+        };
+
+        await after(afterInput, afterOutput);
+
+        expect(afterOutput.metadata.diff).toBeDefined();
+        const diff = afterOutput.metadata.diff as string;
+        expect(diff).toContain("+3 additions");
+        expect(diff).toContain("-0 deletions");
+        expect(afterOutput.metadata.hashlined).toBeDefined();
+        expect(afterOutput.title).toBe(filePath);
+
+        fs.rmSync(tempDir, { recursive: true, force: true });
+      });
+    });
+  });
+
+  describe("#given missing sessionID or callID", () => {
+    describe("#when the before handler receives incomplete input", () => {
+      it("#then does not capture state", async () => {
+        const beforeHandler = createHashlineDiffEnhancerBeforeHandler();
+        const afterHandler = createHashlineDiffEnhancerAfterHandler();
+
+        const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "hashline-diff-noid-"));
+        const filePath = path.join(tempDir, "test.ts");
+        fs.writeFileSync(filePath, "content\n");
+
+        const beforeInput = { tool: "write", sessionID: "", callID: "" };
+        const beforeOutput = { args: { filePath } };
+        await beforeHandler(beforeInput, beforeOutput);
+
+        const afterInput = { tool: "write", sessionID: "", callID: "", args: {} };
+        const afterOutput = {
+          title: "write",
+          output: "File written successfully.",
+          metadata: {} as Record<string, unknown>,
+        };
+        await afterHandler(afterInput, afterOutput);
+
+        expect(afterOutput.metadata.diff).toBeUndefined();
+
+        fs.rmSync(tempDir, { recursive: true, force: true });
+      });
+    });
+  });
+});

package/src/hooks/hashline-diff-enhancer/handler.ts

@@ -0,0 +1,186 @@
+import type { PluginHookContributions } from "../../types/hook";
+import { log } from "../../shared/logger";
+import { computeLineHash } from "../../tools/hashline-edit/hash-computation";
+
+const STALE_TIMEOUT_MS = 5 * 60 * 1000;
+
+type BeforeInput = { tool: string; sessionID: string; callID: string };
+type BeforeOutput = { args: Record<string, unknown> };
+type AfterInput = { tool: string; sessionID: string; callID: string };
+type AfterOutput = { title: string; output: string; metadata: Record<string, unknown> };
+
+type PreToolUseHook = NonNullable<PluginHookContributions["tool.execute.before"]>;
+type PostToolUseHook = NonNullable<PluginHookContributions["tool.execute.after"]>;
+
+interface PendingCapture {
+  content: string;
+  filePath: string;
+  storedAt: number;
+}
+
+const pendingCaptures = new Map<string, PendingCapture>();
+
+function makeKey(sessionID: string, callID: string): string {
+  return `${sessionID}:${callID}`;
+}
+
+function cleanupStaleEntries(): void {
+  const now = Date.now();
+  for (const [key, entry] of pendingCaptures) {
+    if (now - entry.storedAt > STALE_TIMEOUT_MS) {
+      pendingCaptures.delete(key);
+    }
+  }
+}
+
+function isWriteTool(toolName: string): boolean {
+  return toolName.toLowerCase() === "write";
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+function extractFilePath(args: Record<string, unknown>): string | undefined {
+  const path = args.path ?? args.filePath ?? args.file_path;
+  return typeof path === "string" ? path : undefined;
+}
+
+async function captureOldContent(filePath: string): Promise<string> {
+  try {
+    const file = Bun.file(filePath);
+    if (await file.exists()) {
+      return await file.text();
+    }
+  } catch {
+    log("[hashline-diff-enhancer] failed to read old content", { filePath });
+  }
+  return "";
+}
+
+function toHashlineContent(content: string): string {
+  if (!content) return content;
+  const lines = content.split("\n");
+  const lastLine = lines[lines.length - 1];
+  const hasTrailingNewline = lastLine === "";
+  const contentLines = hasTrailingNewline ? lines.slice(0, -1) : lines;
+  const hashlined = contentLines.map((line, i) => {
+    const lineNum = i + 1;
+    const hash = computeLineHash(lineNum, line);
+    return `${lineNum}#${hash}|${line}`;
+  });
+  return hasTrailingNewline ? hashlined.join("\n") + "\n" : hashlined.join("\n");
+}
+
+function buildSimpleDiff(oldContent: string, newContent: string, filePath: string): string {
+  const oldLines = oldContent.split("\n");
+  const newLines = newContent.split("\n");
+
+  const oldSet = new Map<string, number>();
+  for (const line of oldLines) {
+    oldSet.set(line, (oldSet.get(line) ?? 0) + 1);
+  }
+
+  const newSet = new Map<string, number>();
+  for (const line of newLines) {
+    newSet.set(line, (newSet.get(line) ?? 0) + 1);
+  }
+
+  let deletions = 0;
+  for (const [line, count] of oldSet) {
+    const newCount = newSet.get(line) ?? 0;
+    if (count > newCount) deletions += count - newCount;
+  }
+
+  let additions = 0;
+  for (const [line, count] of newSet) {
+    const oldCount = oldSet.get(line) ?? 0;
+    if (count > oldCount) additions += count - oldCount;
+  }
+
+  return `--- ${filePath}\n+++ ${filePath}\n@@ -${oldLines.length} lines +${newLines.length} lines @@\n+${additions} additions, -${deletions} deletions`;
+}
+
+export function createHashlineDiffEnhancerBeforeHandler(): PreToolUseHook {
+  return async (input: unknown, output: unknown) => {
+    if (!isRecord(input) || !isRecord(output)) return;
+
+    const tool = input.tool;
+    if (typeof tool !== "string" || !isWriteTool(tool)) return;
+
+    const args = output.args;
+    if (!isRecord(args)) return;
+
+    const filePath = extractFilePath(args);
+    if (!filePath) return;
+
+    const sessionID = typeof input.sessionID === "string" ? input.sessionID : "";
+    const callID = typeof input.callID === "string" ? input.callID : "";
+    if (!sessionID || !callID) return;
+
+    cleanupStaleEntries();
+    const oldContent = await captureOldContent(filePath);
+    pendingCaptures.set(makeKey(sessionID, callID), {
+      content: oldContent,
+      filePath,
+      storedAt: Date.now(),
+    });
+  };
+}
+
+export function createHashlineDiffEnhancerAfterHandler(): PostToolUseHook {
+  return async (input: unknown, output: unknown) => {
+    if (!isRecord(input) || !isRecord(output)) return;
+
+    const tool = input.tool;
+    if (typeof tool !== "string" || !isWriteTool(tool)) return;
+
+    const sessionID = typeof input.sessionID === "string" ? input.sessionID : "";
+    const callID = typeof input.callID === "string" ? input.callID : "";
+    if (!sessionID || !callID) return;
+
+    const key = makeKey(sessionID, callID);
+    const captured = pendingCaptures.get(key);
+    if (!captured) return;
+    pendingCaptures.delete(key);
+
+    const { content: oldContent, filePath } = captured;
+
+    let newContent: string;
+    try {
+      newContent = await Bun.file(filePath).text();
+    } catch {
+      log("[hashline-diff-enhancer] failed to read new content", { filePath });
+      return;
+    }
+
+    const metadata = output.metadata;
+    if (!isRecord(metadata)) return;
+
+    const diff = buildSimpleDiff(oldContent, newContent, filePath);
+    const hashlinedNew = toHashlineContent(newContent);
+
+    metadata.filediff = {
+      file: filePath,
+      path: filePath,
+      before: oldContent,
+      after: newContent,
+    };
+    metadata.diff = diff;
+    metadata.hashlined = hashlinedNew;
+
+    output.title = filePath as string;
+  };
+}
+
+export function createHashlineDiffEnhancerHandlers(): {
+  before: PreToolUseHook;
+  after: PostToolUseHook;
+} {
+  return {
+    before: createHashlineDiffEnhancerBeforeHandler(),
+    after: createHashlineDiffEnhancerAfterHandler(),
+  };
+}
+
+export type { BeforeInput, BeforeOutput, AfterInput, AfterOutput };

package/src/hooks/hashline-diff-enhancer/index.ts

@@ -0,0 +1,6 @@
+export { hashlineDiffEnhancerPlugin } from "./plugin";
+export {
+  createHashlineDiffEnhancerBeforeHandler,
+  createHashlineDiffEnhancerAfterHandler,
+  createHashlineDiffEnhancerHandlers,
+} from "./handler";

package/src/hooks/hashline-diff-enhancer/plugin.ts

@@ -0,0 +1,24 @@
+import { definePlugin } from "../../plugin-api/define-plugin";
+import { safeCreateHook } from "../../shared/safe-create-hook";
+import {
+  createHashlineDiffEnhancerBeforeHandler,
+  createHashlineDiffEnhancerAfterHandler,
+} from "./handler";
+
+const toolExecuteBeforeHook = safeCreateHook(
+  "hashline-diff-enhancer-before",
+  createHashlineDiffEnhancerBeforeHandler,
+);
+const toolExecuteAfterHook = safeCreateHook(
+  "hashline-diff-enhancer-after",
+  createHashlineDiffEnhancerAfterHandler,
+);
+
+export const hashlineDiffEnhancerPlugin = definePlugin({
+  name: "hashline-diff-enhancer",
+  version: "0.1.0",
+  hooks: {
+    ...(toolExecuteBeforeHook ? { "tool.execute.before": toolExecuteBeforeHook } : {}),
+    ...(toolExecuteAfterHook ? { "tool.execute.after": toolExecuteAfterHook } : {}),
+  },
+});