@google/gemini-cli-a2a-server 0.19.0-nightly.20251123.dadd606c0 → 0.19.0-nightly.20251125.f6d97d448

package/dist/a2a-server.mjs

@@ -54965,11 +54965,11 @@ var require_verify_stream = __commonJS({
     var toString2 = require_tostring();
     var util4 = __require("util");
     var JWS_REGEX = /^[a-zA-Z0-9\-_]+?\.[a-zA-Z0-9\-_]+?\.([a-zA-Z0-9\-_]+)?$/;
-    function isObject3(thing) {
+    function isObject4(thing) {
       return Object.prototype.toString.call(thing) === "[object Object]";
     }
     function safeJsonParse(thing) {
-      if (isObject3(thing))
+      if (isObject4(thing))
         return thing;
       try {
         return JSON.parse(thing);
@@ -61890,7 +61890,7 @@ var require_event_target_shim = __commonJS({
     var CAPTURE = 1;
     var BUBBLE = 2;
     var ATTRIBUTE = 3;
-    function isObject3(x2) {
+    function isObject4(x2) {
       return x2 !== null && typeof x2 === "object";
     }
     function getListeners(eventTarget) {
@@ -61916,7 +61916,7 @@ var require_event_target_shim = __commonJS({
           return null;
         },
         set(listener) {
-          if (typeof listener !== "function" && !isObject3(listener)) {
+          if (typeof listener !== "function" && !isObject4(listener)) {
             listener = null;
           }
           const listeners = getListeners(this);
@@ -62007,11 +62007,11 @@ var require_event_target_shim = __commonJS({
         if (listener == null) {
           return;
         }
-        if (typeof listener !== "function" && !isObject3(listener)) {
+        if (typeof listener !== "function" && !isObject4(listener)) {
           throw new TypeError("'listener' should be a function or an object.");
         }
         const listeners = getListeners(this);
-        const optionsIsObj = isObject3(options2);
+        const optionsIsObj = isObject4(options2);
         const capture = optionsIsObj ? Boolean(options2.capture) : Boolean(options2);
         const listenerType = capture ? CAPTURE : BUBBLE;
         const newNode = {
@@ -62048,7 +62048,7 @@ var require_event_target_shim = __commonJS({
           return;
         }
         const listeners = getListeners(this);
-        const capture = isObject3(options2) ? Boolean(options2.capture) : Boolean(options2);
+        const capture = isObject4(options2) ? Boolean(options2.capture) : Boolean(options2);
         const listenerType = capture ? CAPTURE : BUBBLE;
         let prev = null;
         let node = listeners.get(eventName);
@@ -67220,11 +67220,11 @@ var require_ponyfill_es2018 = __commonJS({
           throw new TypeError(`${context2} is not a function.`);
         }
       }
-      function isObject3(x2) {
+      function isObject4(x2) {
         return typeof x2 === "object" && x2 !== null || typeof x2 === "function";
       }
       function assertObject2(x2, context2) {
-        if (!isObject3(x2)) {
+        if (!isObject4(x2)) {
           throw new TypeError(`${context2} is not an object.`);
         }
       }
@@ -73427,7 +73427,7 @@ var require_gaxios2 = __commonJS({
     var retry_js_1 = require_retry4();
     var stream_1 = __require("stream");
     var interceptor_js_1 = require_interceptor2();
-    var randomUUID7 = async () => globalThis.crypto?.randomUUID() || (await import("crypto")).randomUUID();
+    var randomUUID8 = async () => globalThis.crypto?.randomUUID() || (await import("crypto")).randomUUID();
     var HTTP_STATUS_NO_CONTENT = 204;
     var Gaxios = class {
       agentCache = /* @__PURE__ */ new Map();
@@ -73700,7 +73700,7 @@ var require_gaxios2 = __commonJS({
          */
         ["Blob", "File", "FormData"].includes(opts.data?.constructor?.name || "");
         if (opts.multipart?.length) {
-          const boundary = await randomUUID7();
+          const boundary = await randomUUID8();
           preparedHeaders.set("content-type", `multipart/related; boundary=${boundary}`);
           opts.body = stream_1.Readable.from(this.getMultipartRequest(opts.multipart, boundary));
         } else if (shouldDirectlyPassData) {
@@ -102305,15 +102305,15 @@ var require_merge = __commonJS({
           for (let i4 = 0, j = two.length; i4 < j; i4++) {
             result.push(takeValue(two[i4]));
           }
-        } else if (isObject3(two)) {
+        } else if (isObject4(two)) {
           const keys = Object.keys(two);
           for (let i4 = 0, j = keys.length; i4 < j; i4++) {
             const key = keys[i4];
             result[key] = takeValue(two[key]);
           }
         }
-      } else if (isObject3(one)) {
-        if (isObject3(two)) {
+      } else if (isObject4(one)) {
+        if (isObject4(two)) {
           if (!shouldMerge(one, two)) {
             return two;
           }
@@ -102334,7 +102334,7 @@ var require_merge = __commonJS({
               if (wasObjectReferenced(one, key, objects) || wasObjectReferenced(two, key, objects)) {
                 delete result[key];
               } else {
-                if (isObject3(obj1) && isObject3(obj2)) {
+                if (isObject4(obj1) && isObject4(obj2)) {
                   const arr1 = objects.get(obj1) || [];
                   const arr2 = objects.get(obj2) || [];
                   arr1.push({ obj: one, key });
@@ -102368,7 +102368,7 @@ var require_merge = __commonJS({
     function isFunction3(value) {
       return typeof value === "function";
     }
-    function isObject3(value) {
+    function isObject4(value) {
       return !isPrimitive2(value) && !isArray2(value) && !isFunction3(value) && typeof value === "object";
     }
     function isPrimitive2(value) {
@@ -108173,7 +108173,7 @@ var require_minimal = __commonJS({
     util4.isString = function isString2(value) {
       return typeof value === "string" || value instanceof String;
     };
-    util4.isObject = function isObject3(value) {
+    util4.isObject = function isObject4(value) {
       return value && typeof value === "object";
     };
     util4.isset = /**
@@ -129791,8 +129791,8 @@ var require_root2 = __commonJS({
             return metrics2;
           }();
           collector.logs = function() {
-            var logs2 = {};
-            logs2.v1 = function() {
+            var logs3 = {};
+            logs3.v1 = function() {
               var v13 = {};
               v13.LogsService = function() {
                 function LogsService(rpcImpl, requestDelimited, responseDelimited) {
@@ -130132,7 +130132,7 @@ var require_root2 = __commonJS({
               }();
               return v13;
             }();
-            return logs2;
+            return logs3;
           }();
           return collector;
         }();
@@ -133598,8 +133598,8 @@ var require_root2 = __commonJS({
           return metrics2;
         }();
         proto.logs = function() {
-          var logs2 = {};
-          logs2.v1 = function() {
+          var logs3 = {};
+          logs3.v1 = function() {
             var v13 = {};
             v13.LogsData = function() {
               function LogsData(properties) {
@@ -134537,7 +134537,7 @@ var require_root2 = __commonJS({
             }();
             return v13;
           }();
-          return logs2;
+          return logs3;
         }();
         return proto;
       }();
@@ -140578,8 +140578,8 @@ var require_ConsoleLogRecordExporter = __commonJS({
        * @param logs
        * @param resultCallback
        */
-      export(logs2, resultCallback) {
-        this._sendLogRecords(logs2, resultCallback);
+      export(logs3, resultCallback) {
+        this._sendLogRecords(logs3, resultCallback);
       }
       /**
        * Shutdown the exporter.
@@ -140688,14 +140688,14 @@ var require_InMemoryLogRecordExporter = __commonJS({
        * When false, exported log records will not be stored in-memory.
        */
       _stopped = false;
-      export(logs2, resultCallback) {
+      export(logs3, resultCallback) {
         if (this._stopped) {
           return resultCallback({
             code: core_1.ExportResultCode.FAILED,
             error: new Error("Exporter has been stopped")
           });
         }
-        this._finishedLogRecords.push(...logs2);
+        this._finishedLogRecords.push(...logs3);
         resultCallback({ code: core_1.ExportResultCode.SUCCESS });
       }
       shutdown() {
@@ -217736,9 +217736,9 @@ var require_src60 = __commonJS({
           autoPaginate: options2.autoPaginate
         }, options2.gaxOptions);
         const resp = await this.loggingService.listLogs(reqOpts, gaxOptions);
-        const [logs2] = resp;
-        if (logs2) {
-          resp[0] = logs2.map((logName) => this.log(logName));
+        const [logs3] = resp;
+        if (logs3) {
+          resp[0] = logs3.map((logName) => this.log(logName));
         }
         return resp;
       }
@@ -218873,7 +218873,7 @@ var require_cross_spawn = __commonJS({
     var cp = __require("child_process");
     var parse8 = require_parse6();
     var enoent = require_enoent();
-    function spawn9(command, args2, options2) {
+    function spawn10(command, args2, options2) {
       const parsed = parse8(command, args2, options2);
       const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);
       enoent.hookChildProcess(spawned, parsed);
@@ -218885,8 +218885,8 @@ var require_cross_spawn = __commonJS({
       result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
       return result;
     }
-    module2.exports = spawn9;
-    module2.exports.spawn = spawn9;
+    module2.exports = spawn10;
+    module2.exports.spawn = spawn10;
     module2.exports.sync = spawnSync4;
     module2.exports._parse = parse8;
     module2.exports._enoent = enoent;
@@ -268712,7 +268712,7 @@ var require_picomatch = __commonJS({
     var parse8 = require_parse11();
     var utils = require_utils22();
     var constants6 = require_constants11();
-    var isObject3 = (val) => val && typeof val === "object" && !Array.isArray(val);
+    var isObject4 = (val) => val && typeof val === "object" && !Array.isArray(val);
     var picomatch2 = (glob2, options2, returnState = false) => {
       if (Array.isArray(glob2)) {
         const fns = glob2.map((input) => picomatch2(input, options2, returnState));
@@ -268725,7 +268725,7 @@ var require_picomatch = __commonJS({
         };
         return arrayMatcher;
       }
-      const isState = isObject3(glob2) && glob2.tokens && glob2.input;
+      const isState = isObject4(glob2) && glob2.tokens && glob2.input;
       if (glob2 === "" || typeof glob2 !== "string" && !isState) {
         throw new TypeError("Expected pattern to be a non-empty string");
       }
@@ -305113,6 +305113,9 @@ var MessageBusType;
   MessageBusType2["TOOL_EXECUTION_SUCCESS"] = "tool-execution-success";
   MessageBusType2["TOOL_EXECUTION_FAILURE"] = "tool-execution-failure";
   MessageBusType2["UPDATE_POLICY"] = "update-policy";
+  MessageBusType2["HOOK_EXECUTION_REQUEST"] = "hook-execution-request";
+  MessageBusType2["HOOK_EXECUTION_RESPONSE"] = "hook-execution-response";
+  MessageBusType2["HOOK_POLICY_DECISION"] = "hook-policy-decision";
 })(MessageBusType || (MessageBusType = {}));
 
 // packages/core/dist/src/tools/tools.js
@@ -305785,6 +305788,27 @@ function getCommonAttributes(config2) {
   };
 }
 
+// packages/core/dist/src/telemetry/sanitize.js
+function sanitizeHookName(hookName) {
+  if (!hookName || !hookName.trim()) {
+    return "unknown-command";
+  }
+  const parts2 = hookName.trim().split(/\s+/);
+  if (parts2.length === 0) {
+    return "unknown-command";
+  }
+  const command = parts2[0];
+  if (!command) {
+    return "unknown-command";
+  }
+  if (command.includes("/") || command.includes("\\")) {
+    const pathParts = command.split(/[/\\]/);
+    const basename13 = pathParts[pathParts.length - 1];
+    return basename13 || "unknown-command";
+  }
+  return command;
+}
+
 // packages/core/dist/src/telemetry/metrics.js
 var EVENT_CHAT_COMPRESSION = "gemini_cli.chat_compression";
 var TOOL_CALL_COUNT = "gemini_cli.tool.call.count";
@@ -305801,6 +305825,8 @@ var CONTENT_RETRY_FAILURE_COUNT = "gemini_cli.chat.content_retry_failure.count";
 var MODEL_ROUTING_LATENCY = "gemini_cli.model_routing.latency";
 var MODEL_ROUTING_FAILURE_COUNT = "gemini_cli.model_routing.failure.count";
 var MODEL_SLASH_COMMAND_CALL_COUNT = "gemini_cli.slash_command.model.call_count";
+var EVENT_HOOK_CALL_COUNT = "gemini_cli.hook_call.count";
+var EVENT_HOOK_CALL_LATENCY = "gemini_cli.hook_call.latency";
 var AGENT_RUN_COUNT = "gemini_cli.agent.run.count";
 var AGENT_DURATION_MS = "gemini_cli.agent.duration";
 var AGENT_TURNS = "gemini_cli.agent.turns";
@@ -305921,6 +305947,12 @@ var COUNTER_DEFINITIONS = {
     valueType: ValueType.INT,
     assign: (c4) => exitFailCounter = c4,
     attributes: {}
+  },
+  [EVENT_HOOK_CALL_COUNT]: {
+    description: "Counts hook calls, tagged by hook event name and success.",
+    valueType: ValueType.INT,
+    assign: (c4) => hookCallCounter = c4,
+    attributes: {}
   }
 };
 var HISTOGRAM_DEFINITIONS = {
@@ -305986,6 +306018,13 @@ var HISTOGRAM_DEFINITIONS = {
     valueType: ValueType.DOUBLE,
     assign: (h3) => genAiClientOperationDurationHistogram = h3,
     attributes: {}
+  },
+  [EVENT_HOOK_CALL_LATENCY]: {
+    description: "Latency of hook calls in milliseconds.",
+    unit: "ms",
+    valueType: ValueType.INT,
+    assign: (c4) => hookCallLatencyHistogram = c4,
+    attributes: {}
   }
 };
 var PERFORMANCE_COUNTER_DEFINITIONS = {
@@ -306142,6 +306181,8 @@ var agentRecoveryAttemptDurationHistogram;
 var flickerFrameCounter;
 var exitFailCounter;
 var slowRenderHistogram;
+var hookCallCounter;
+var hookCallLatencyHistogram;
 var genAiClientTokenUsageHistogram;
 var genAiClientOperationDurationHistogram;
 var startupTimeHistogram;
@@ -306407,6 +306448,19 @@ function recordApiResponseMetrics(config2, durationMs, attributes) {
     });
   }
 }
+function recordHookCallMetrics(config2, hookEventName, hookName, durationMs, success) {
+  if (!hookCallCounter || !hookCallLatencyHistogram || !isMetricsInitialized)
+    return;
+  const sanitizedHookName = sanitizeHookName(hookName);
+  const metricAttributes = {
+    ...baseMetricDefinition.getCommonAttributes(config2),
+    hook_event_name: hookEventName,
+    hook_name: sanitizedHookName,
+    success
+  };
+  hookCallCounter.add(1, metricAttributes);
+  hookCallLatencyHistogram.record(durationMs, metricAttributes);
+}
 
 // packages/core/dist/src/telemetry/types.js
 init_esm2();
@@ -307506,6 +307560,66 @@ var WebFetchFallbackAttemptEvent = class {
     return `Web fetch fallback attempt. Reason: ${this.reason}`;
   }
 };
+var EVENT_HOOK_CALL = "gemini_cli.hook_call";
+var HookCallEvent = class {
+  "event.name";
+  "event.timestamp";
+  hook_event_name;
+  hook_type;
+  hook_name;
+  hook_input;
+  hook_output;
+  exit_code;
+  stdout;
+  stderr;
+  duration_ms;
+  success;
+  error;
+  constructor(hookEventName, hookType, hookName, hookInput, durationMs, success, hookOutput, exitCode, stdout, stderr, error) {
+    this["event.name"] = "hook_call";
+    this["event.timestamp"] = (/* @__PURE__ */ new Date()).toISOString();
+    this.hook_event_name = hookEventName;
+    this.hook_type = hookType;
+    this.hook_name = hookName;
+    this.hook_input = hookInput;
+    this.hook_output = hookOutput;
+    this.exit_code = exitCode;
+    this.stdout = stdout;
+    this.stderr = stderr;
+    this.duration_ms = durationMs;
+    this.success = success;
+    this.error = error;
+  }
+  toOpenTelemetryAttributes(config2) {
+    const attributes = {
+      ...getCommonAttributes(config2),
+      "event.name": EVENT_HOOK_CALL,
+      "event.timestamp": this["event.timestamp"],
+      hook_event_name: this.hook_event_name,
+      hook_type: this.hook_type,
+      // Sanitize hook_name unless full logging is enabled
+      hook_name: config2.getTelemetryLogPromptsEnabled() ? this.hook_name : sanitizeHookName(this.hook_name),
+      duration_ms: this.duration_ms,
+      success: this.success,
+      exit_code: this.exit_code
+    };
+    if (config2.getTelemetryLogPromptsEnabled()) {
+      attributes["hook_input"] = safeJsonStringify(this.hook_input, 2);
+      attributes["hook_output"] = safeJsonStringify(this.hook_output, 2);
+      attributes["stdout"] = this.stdout;
+      attributes["stderr"] = this.stderr;
+    }
+    if (this.error) {
+      attributes["error"] = this.error;
+    }
+    return attributes;
+  }
+  toLogBody() {
+    const hookId = `${this.hook_event_name}.${this.hook_name}`;
+    const status = `${this.success ? "succeeded" : "failed"}`;
+    return `Hook call ${hookId} ${status} in ${this.duration_ms}ms`;
+  }
+};
 
 // packages/core/dist/src/telemetry/loggers.js
 var import_api_logs = __toESM(require_src21(), 1);
@@ -307689,8 +307803,8 @@ var Float64Vector = import_vector.default.Float64Vector;
 var PointerVector = import_vector.default.PointerVector;
 
 // packages/core/dist/src/generated/git-commit.js
-var GIT_COMMIT_INFO = "dadd606c0";
-var CLI_VERSION = "0.19.0-nightly.20251123.dadd606c0";
+var GIT_COMMIT_INFO = "f6d97d448";
+var CLI_VERSION = "0.19.0-nightly.20251125.f6d97d448";
 
 // packages/core/dist/src/ide/detect-ide.js
 var IDE_DEFINITIONS = {
@@ -308902,8 +309016,8 @@ var FileSpanExporter = class extends FileExporter {
   }
 };
 var FileLogExporter = class extends FileExporter {
-  export(logs2, resultCallback) {
-    const data = logs2.map((log) => this.serialize(log)).join("");
+  export(logs3, resultCallback) {
+    const data = logs3.map((log) => this.serialize(log)).join("");
     this.writeStream.write(data, (err2) => {
       resultCallback({
         code: err2 ? import_core3.ExportResultCode.FAILED : import_core3.ExportResultCode.SUCCESS,
@@ -308960,9 +309074,9 @@ var GcpLogExporter = class {
     this.logging = new import_logging.Logging({ projectId });
     this.log = this.logging.log("gemini_cli");
   }
-  export(logs2, resultCallback) {
+  export(logs3, resultCallback) {
     try {
-      const entries2 = logs2.map((log) => {
+      const entries2 = logs3.map((log) => {
         const entry = this.log.entry({
           severity: this.mapSeverityToCloudLogging(log.severityNumber),
           timestamp: new Date((0, import_core4.hrTimeToMilliseconds)(log.hrTime)),
@@ -310238,6 +310352,17 @@ function logLlmLoopCheck(config2, event) {
   };
   logger6.emit(logRecord);
 }
+function logHookCall(config2, event) {
+  if (!isTelemetrySdkInitialized())
+    return;
+  const logger6 = import_api_logs.logs.getLogger(SERVICE_NAME);
+  const logRecord = {
+    body: event.toLogBody(),
+    attributes: event.toOpenTelemetryAttributes(config2)
+  };
+  logger6.emit(logRecord);
+  recordHookCallMetrics(config2, event.hook_event_name, event.hook_name, event.duration_ms, event.success);
+}
 
 // packages/core/dist/src/utils/quotaErrorDetection.js
 function isApiError(error) {
@@ -310581,7 +310706,7 @@ async function createContentGenerator(config2, gcConfig, sessionId2) {
     if (gcConfig.fakeResponses) {
       return FakeContentGenerator.fromFile(gcConfig.fakeResponses);
     }
-    const version3 = "0.19.0-nightly.20251123.dadd606c0";
+    const version3 = "0.19.0-nightly.20251125.f6d97d448";
     const userAgent = `GeminiCLI/${version3} (${process.platform}; ${process.arch})`;
     const baseHeaders = {
       "User-Agent": userAgent
@@ -333275,6 +333400,19 @@ var PolicyDecision;
   PolicyDecision2["DENY"] = "deny";
   PolicyDecision2["ASK_USER"] = "ask_user";
 })(PolicyDecision || (PolicyDecision = {}));
+var VALID_HOOK_SOURCES = [
+  "project",
+  "user",
+  "system",
+  "extension"
+];
+function getHookSource(input) {
+  const source = input["hook_source"];
+  if (typeof source === "string" && VALID_HOOK_SOURCES.includes(source)) {
+    return source;
+  }
+  return "project";
+}
 var ApprovalMode;
 (function(ApprovalMode2) {
   ApprovalMode2["DEFAULT"] = "default";
@@ -357671,6 +357809,13 @@ ${[...this.pendingCitations].sort().join("\n")}`
   getDebugResponses() {
     return this.debugResponses;
   }
+  /**
+   * Get the concatenated response text from all responses in this turn.
+   * This extracts and joins all text content from the model's responses.
+   */
+  getResponseText() {
+    return this.debugResponses.map((response) => getResponseText(response)).filter((text) => text !== null).join(" ");
+  }
 };
 function getCitations(resp) {
   return (resp.candidates?.[0]?.citationMetadata?.citations ?? []).filter((citation) => citation.uri !== void 0).map((citation) => {
@@ -358028,6 +358173,8 @@ function getCoreSystemPrompt(config2, userMemory) {
       throw new Error(`missing system prompt file '${systemMdPath}'`);
     }
   }
+  const desiredModel = getEffectiveModel(config2.isInFallbackMode(), config2.getModel(), config2.getPreviewFeatures());
+  const useChattySystemPrompt = desiredModel === PREVIEW_GEMINI_MODEL;
   const enableCodebaseInvestigator = config2.getToolRegistry().getAllToolNames().includes(CodebaseInvestigatorAgent.name);
   const enableWriteTodosTool = config2.getToolRegistry().getAllToolNames().includes(WriteTodosTool.Name);
   let basePrompt;
@@ -358125,7 +358272,13 @@ IT IS CRITICAL TO FOLLOW THESE GUIDELINES TO AVOID EXCESSIVE TOKEN CONSUMPTION.
 - **Concise & Direct:** Adopt a professional, direct, and concise tone suitable for a CLI environment.
 - **Minimal Output:** Aim for fewer than 3 lines of text output (excluding tool use/code generation) per response whenever practical. Focus strictly on the user's query.
 - **Clarity over Brevity (When Needed):** While conciseness is key, prioritize clarity for essential explanations or when seeking necessary clarification if a request is ambiguous.
-- **No Chitchat:** Avoid conversational filler, preambles ("Okay, I will now..."), or postambles ("I have finished the changes..."). Get straight to the action or answer.
+${function() {
+        if (useChattySystemPrompt) {
+          return "";
+        } else {
+          return '- **No Chitchat:** Avoid conversational filler, preambles ("Okay, I will now..."), or postambles ("I have finished the changes..."). Get straight to the action or answer.';
+        }
+      }()}
 - **Formatting:** Use GitHub-flavored Markdown. Responses will be rendered in monospace.
 - **Tools vs. Text:** Use tools for actions, text output *only* for communication. Do not add explanatory comments within tool calls or code blocks unless specifically part of the required code/command itself.
 - **Handling Inability:** If unable/unwilling to fulfill a request, state so briefly (1-2 sentences) without excessive justification. Offer alternatives if appropriate.
@@ -358769,6 +358922,20 @@ function findCompressSplitPoint(contents, fraction) {
   }
   return lastSplitPoint;
 }
+function modelStringToModelConfigAlias(model) {
+  switch (model) {
+    case PREVIEW_GEMINI_MODEL:
+      return "chat-compression-3-pro";
+    case DEFAULT_GEMINI_MODEL:
+      return "chat-compression-2.5-pro";
+    case DEFAULT_GEMINI_FLASH_MODEL:
+      return "chat-compression-2.5-flash";
+    case DEFAULT_GEMINI_FLASH_LITE_MODEL:
+      return "chat-compression-2.5-flash-lite";
+    default:
+      return "chat-compression-default";
+  }
+}
 var ChatCompressionService = class {
   async compress(chat, promptId, force, model, config2, hasFailedCompressionAttempt) {
     const curatedHistory = chat.getHistory(true);
@@ -358809,8 +358976,8 @@ var ChatCompressionService = class {
         }
       };
     }
-    const summaryResponse = await config2.getContentGenerator().generateContent({
-      model,
+    const summaryResponse = await config2.getBaseLlmClient().generateContent({
+      modelConfigKey: { model: modelStringToModelConfigAlias(model) },
       contents: [
         ...historyToCompress,
         {
@@ -358822,10 +358989,11 @@ var ChatCompressionService = class {
           ]
         }
       ],
-      config: {
-        systemInstruction: { text: getCompressionPrompt() }
-      }
-    }, promptId);
+      systemInstruction: { text: getCompressionPrompt() },
+      promptId,
+      // TODO(joshualitt): wire up a sensible abort signal,
+      abortSignal: new AbortController().signal
+    });
     const summary = getResponseText(summaryResponse) ?? "";
     const extraHistory = [
       {
@@ -358866,8 +359034,460 @@ var ChatCompressionService = class {
   }
 };
 
+// packages/core/dist/src/hooks/hookTranslator.js
+var HookTranslator = class {
+};
+function hasTextProperty(value) {
+  return typeof value === "object" && value !== null && "text" in value && typeof value.text === "string";
+}
+function isContentWithParts(content) {
+  return typeof content === "object" && content !== null && "role" in content && "parts" in content;
+}
+function extractGenerationConfig(request3) {
+  if (request3.config && typeof request3.config === "object") {
+    const config2 = request3.config;
+    return {
+      temperature: config2.temperature,
+      maxOutputTokens: config2.maxOutputTokens,
+      topP: config2.topP,
+      topK: config2.topK
+    };
+  }
+  return void 0;
+}
+var HookTranslatorGenAIv1 = class extends HookTranslator {
+  /**
+   * Convert genai SDK GenerateContentParameters to stable LLMRequest
+   *
+   * Note: This implementation intentionally extracts only text content from parts.
+   * Non-text parts (images, function calls, etc.) are filtered out in v1 to provide
+   * a simplified, stable interface for hooks. This allows hooks to focus on text
+   * manipulation without needing to handle complex multimodal content.
+   * Future versions may expose additional content types if needed.
+   */
+  toHookLLMRequest(sdkRequest) {
+    const messages = [];
+    if (sdkRequest.contents) {
+      const contents = Array.isArray(sdkRequest.contents) ? sdkRequest.contents : [sdkRequest.contents];
+      for (const content of contents) {
+        if (typeof content === "string") {
+          messages.push({
+            role: "user",
+            content
+          });
+        } else if (isContentWithParts(content)) {
+          const role = content.role === "model" ? "model" : content.role === "system" ? "system" : "user";
+          const parts2 = Array.isArray(content.parts) ? content.parts : [content.parts];
+          const textContent2 = parts2.filter(hasTextProperty).map((part) => part.text).join("");
+          if (textContent2) {
+            messages.push({
+              role,
+              content: textContent2
+            });
+          }
+        }
+      }
+    }
+    const config2 = extractGenerationConfig(sdkRequest);
+    return {
+      model: sdkRequest.model || DEFAULT_GEMINI_FLASH_MODEL,
+      messages,
+      config: {
+        temperature: config2?.temperature,
+        maxOutputTokens: config2?.maxOutputTokens,
+        topP: config2?.topP,
+        topK: config2?.topK
+      }
+    };
+  }
+  /**
+   * Convert stable LLMRequest to genai SDK GenerateContentParameters
+   */
+  fromHookLLMRequest(hookRequest, baseRequest) {
+    const contents = hookRequest.messages.map((message) => ({
+      role: message.role === "model" ? "model" : message.role,
+      parts: [
+        {
+          text: typeof message.content === "string" ? message.content : String(message.content)
+        }
+      ]
+    }));
+    const result = {
+      ...baseRequest,
+      model: hookRequest.model,
+      contents
+    };
+    if (hookRequest.config) {
+      const baseConfig = baseRequest ? extractGenerationConfig(baseRequest) : void 0;
+      result.config = {
+        ...baseConfig,
+        temperature: hookRequest.config.temperature,
+        maxOutputTokens: hookRequest.config.maxOutputTokens,
+        topP: hookRequest.config.topP,
+        topK: hookRequest.config.topK
+      };
+    }
+    return result;
+  }
+  /**
+   * Convert genai SDK GenerateContentResponse to stable LLMResponse
+   */
+  toHookLLMResponse(sdkResponse) {
+    return {
+      text: sdkResponse.text,
+      candidates: (sdkResponse.candidates || []).map((candidate) => {
+        const textParts = candidate.content?.parts?.filter(hasTextProperty).map((part) => part.text) || [];
+        return {
+          content: {
+            role: "model",
+            parts: textParts
+          },
+          finishReason: candidate.finishReason,
+          index: candidate.index,
+          safetyRatings: candidate.safetyRatings?.map((rating) => ({
+            category: String(rating.category || ""),
+            probability: String(rating.probability || "")
+          }))
+        };
+      }),
+      usageMetadata: sdkResponse.usageMetadata ? {
+        promptTokenCount: sdkResponse.usageMetadata.promptTokenCount,
+        candidatesTokenCount: sdkResponse.usageMetadata.candidatesTokenCount,
+        totalTokenCount: sdkResponse.usageMetadata.totalTokenCount
+      } : void 0
+    };
+  }
+  /**
+   * Convert stable LLMResponse to genai SDK GenerateContentResponse
+   */
+  fromHookLLMResponse(hookResponse) {
+    const response = {
+      text: hookResponse.text,
+      candidates: hookResponse.candidates.map((candidate) => ({
+        content: {
+          role: "model",
+          parts: candidate.content.parts.map((part) => ({
+            text: part
+          }))
+        },
+        finishReason: candidate.finishReason,
+        index: candidate.index,
+        safetyRatings: candidate.safetyRatings
+      })),
+      usageMetadata: hookResponse.usageMetadata
+    };
+    return response;
+  }
+  /**
+   * Convert genai SDK ToolConfig to stable HookToolConfig
+   */
+  toHookToolConfig(sdkToolConfig) {
+    return {
+      mode: sdkToolConfig.functionCallingConfig?.mode,
+      allowedFunctionNames: sdkToolConfig.functionCallingConfig?.allowedFunctionNames
+    };
+  }
+  /**
+   * Convert stable HookToolConfig to genai SDK ToolConfig
+   */
+  fromHookToolConfig(hookToolConfig) {
+    const functionCallingConfig = hookToolConfig.mode || hookToolConfig.allowedFunctionNames ? {
+      mode: hookToolConfig.mode,
+      allowedFunctionNames: hookToolConfig.allowedFunctionNames
+    } : void 0;
+    return {
+      functionCallingConfig
+    };
+  }
+};
+var defaultHookTranslator = new HookTranslatorGenAIv1();
+
+// packages/core/dist/src/hooks/types.js
+var HookEventName;
+(function(HookEventName2) {
+  HookEventName2["BeforeTool"] = "BeforeTool";
+  HookEventName2["AfterTool"] = "AfterTool";
+  HookEventName2["BeforeAgent"] = "BeforeAgent";
+  HookEventName2["Notification"] = "Notification";
+  HookEventName2["AfterAgent"] = "AfterAgent";
+  HookEventName2["SessionStart"] = "SessionStart";
+  HookEventName2["SessionEnd"] = "SessionEnd";
+  HookEventName2["PreCompress"] = "PreCompress";
+  HookEventName2["BeforeModel"] = "BeforeModel";
+  HookEventName2["AfterModel"] = "AfterModel";
+  HookEventName2["BeforeToolSelection"] = "BeforeToolSelection";
+})(HookEventName || (HookEventName = {}));
+var HookType;
+(function(HookType2) {
+  HookType2["Command"] = "command";
+})(HookType || (HookType = {}));
+function createHookOutput(eventName, data) {
+  switch (eventName) {
+    case "BeforeModel":
+      return new BeforeModelHookOutput(data);
+    case "AfterModel":
+      return new AfterModelHookOutput(data);
+    case "BeforeToolSelection":
+      return new BeforeToolSelectionHookOutput(data);
+    default:
+      return new DefaultHookOutput(data);
+  }
+}
+var DefaultHookOutput = class {
+  continue;
+  stopReason;
+  suppressOutput;
+  systemMessage;
+  decision;
+  reason;
+  hookSpecificOutput;
+  constructor(data = {}) {
+    this.continue = data.continue;
+    this.stopReason = data.stopReason;
+    this.suppressOutput = data.suppressOutput;
+    this.systemMessage = data.systemMessage;
+    this.decision = data.decision;
+    this.reason = data.reason;
+    this.hookSpecificOutput = data.hookSpecificOutput;
+  }
+  /**
+   * Check if this output represents a blocking decision
+   */
+  isBlockingDecision() {
+    return this.decision === "block" || this.decision === "deny";
+  }
+  /**
+   * Check if this output requests to stop execution
+   */
+  shouldStopExecution() {
+    return this.continue === false;
+  }
+  /**
+   * Get the effective reason for blocking or stopping
+   */
+  getEffectiveReason() {
+    return this.reason || this.stopReason || "No reason provided";
+  }
+  /**
+   * Apply LLM request modifications (specific method for BeforeModel hooks)
+   */
+  applyLLMRequestModifications(target) {
+    return target;
+  }
+  /**
+   * Apply tool config modifications (specific method for BeforeToolSelection hooks)
+   */
+  applyToolConfigModifications(target) {
+    return target;
+  }
+  /**
+   * Get additional context for adding to responses
+   */
+  getAdditionalContext() {
+    if (this.hookSpecificOutput && "additionalContext" in this.hookSpecificOutput) {
+      const context2 = this.hookSpecificOutput["additionalContext"];
+      return typeof context2 === "string" ? context2 : void 0;
+    }
+    return void 0;
+  }
+  /**
+   * Check if execution should be blocked and return error info
+   */
+  getBlockingError() {
+    if (this.isBlockingDecision()) {
+      return {
+        blocked: true,
+        reason: this.getEffectiveReason()
+      };
+    }
+    return { blocked: false, reason: "" };
+  }
+};
+var BeforeToolHookOutput = class extends DefaultHookOutput {
+  /**
+   * Get the effective blocking reason, considering compatibility fields
+   */
+  getEffectiveReason() {
+    if (this.hookSpecificOutput) {
+      if ("permissionDecisionReason" in this.hookSpecificOutput) {
+        const compatReason = this.hookSpecificOutput["permissionDecisionReason"];
+        if (typeof compatReason === "string") {
+          return compatReason;
+        }
+      }
+    }
+    return super.getEffectiveReason();
+  }
+  /**
+   * Check if this output represents a blocking decision, considering compatibility fields
+   */
+  isBlockingDecision() {
+    if (this.hookSpecificOutput && "permissionDecision" in this.hookSpecificOutput) {
+      const compatDecision = this.hookSpecificOutput["permissionDecision"];
+      if (compatDecision === "block" || compatDecision === "deny") {
+        return true;
+      }
+    }
+    return super.isBlockingDecision();
+  }
+};
+var BeforeModelHookOutput = class extends DefaultHookOutput {
+  /**
+   * Get synthetic LLM response if provided by hook
+   */
+  getSyntheticResponse() {
+    if (this.hookSpecificOutput && "llm_response" in this.hookSpecificOutput) {
+      const hookResponse = this.hookSpecificOutput["llm_response"];
+      if (hookResponse) {
+        return defaultHookTranslator.fromHookLLMResponse(hookResponse);
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Apply modifications to LLM request
+   */
+  applyLLMRequestModifications(target) {
+    if (this.hookSpecificOutput && "llm_request" in this.hookSpecificOutput) {
+      const hookRequest = this.hookSpecificOutput["llm_request"];
+      if (hookRequest) {
+        const sdkRequest = defaultHookTranslator.fromHookLLMRequest(hookRequest, target);
+        return {
+          ...target,
+          ...sdkRequest
+        };
+      }
+    }
+    return target;
+  }
+};
+var BeforeToolSelectionHookOutput = class extends DefaultHookOutput {
+  /**
+   * Apply tool configuration modifications
+   */
+  applyToolConfigModifications(target) {
+    if (this.hookSpecificOutput && "toolConfig" in this.hookSpecificOutput) {
+      const hookToolConfig = this.hookSpecificOutput["toolConfig"];
+      if (hookToolConfig) {
+        const sdkToolConfig = defaultHookTranslator.fromHookToolConfig(hookToolConfig);
+        return {
+          ...target,
+          tools: target.tools || [],
+          toolConfig: sdkToolConfig
+        };
+      }
+    }
+    return target;
+  }
+};
+var AfterModelHookOutput = class extends DefaultHookOutput {
+  /**
+   * Get modified LLM response if provided by hook
+   */
+  getModifiedResponse() {
+    if (this.hookSpecificOutput && "llm_response" in this.hookSpecificOutput) {
+      const hookResponse = this.hookSpecificOutput["llm_response"];
+      if (hookResponse?.candidates?.[0]?.content?.parts?.length) {
+        return defaultHookTranslator.fromHookLLMResponse(hookResponse);
+      }
+    }
+    if (this.shouldStopExecution()) {
+      const stopResponse = {
+        candidates: [
+          {
+            content: {
+              role: "model",
+              parts: [this.getEffectiveReason() || "Execution stopped by hook"]
+            },
+            finishReason: "STOP"
+          }
+        ]
+      };
+      return defaultHookTranslator.fromHookLLMResponse(stopResponse);
+    }
+    return void 0;
+  }
+};
+var NotificationType;
+(function(NotificationType2) {
+  NotificationType2["ToolPermission"] = "ToolPermission";
+})(NotificationType || (NotificationType = {}));
+var SessionStartSource;
+(function(SessionStartSource2) {
+  SessionStartSource2["Startup"] = "startup";
+  SessionStartSource2["Resume"] = "resume";
+  SessionStartSource2["Clear"] = "clear";
+  SessionStartSource2["Compress"] = "compress";
+})(SessionStartSource || (SessionStartSource = {}));
+var SessionEndReason;
+(function(SessionEndReason2) {
+  SessionEndReason2["Exit"] = "exit";
+  SessionEndReason2["Clear"] = "clear";
+  SessionEndReason2["Logout"] = "logout";
+  SessionEndReason2["PromptInputExit"] = "prompt_input_exit";
+  SessionEndReason2["Other"] = "other";
+})(SessionEndReason || (SessionEndReason = {}));
+var PreCompressTrigger;
+(function(PreCompressTrigger2) {
+  PreCompressTrigger2["Manual"] = "manual";
+  PreCompressTrigger2["Auto"] = "auto";
+})(PreCompressTrigger || (PreCompressTrigger = {}));
+
+// packages/core/dist/src/core/clientHookTriggers.js
+async function fireBeforeAgentHook(messageBus, request3) {
+  try {
+    const promptText = partToString(request3);
+    const response = await messageBus.request({
+      type: MessageBusType.HOOK_EXECUTION_REQUEST,
+      eventName: "BeforeAgent",
+      input: {
+        prompt: promptText
+      }
+    }, MessageBusType.HOOK_EXECUTION_RESPONSE);
+    return response.output ? createHookOutput("BeforeAgent", response.output) : void 0;
+  } catch (error) {
+    debugLogger.warn(`BeforeAgent hook failed: ${error}`);
+    return void 0;
+  }
+}
+async function fireAfterAgentHook(messageBus, request3, responseText) {
+  try {
+    const promptText = partToString(request3);
+    const response = await messageBus.request({
+      type: MessageBusType.HOOK_EXECUTION_REQUEST,
+      eventName: "AfterAgent",
+      input: {
+        prompt: promptText,
+        prompt_response: responseText,
+        stop_hook_active: false
+      }
+    }, MessageBusType.HOOK_EXECUTION_RESPONSE);
+    return response.output ? createHookOutput("AfterAgent", response.output) : void 0;
+  } catch (error) {
+    debugLogger.warn(`AfterAgent hook failed: ${error}`);
+    return void 0;
+  }
+}
+
 // packages/core/dist/src/core/client.js
 var MAX_TURNS = 100;
+function estimateTextOnlyLength(request3) {
+  if (typeof request3 === "string") {
+    return request3.length;
+  }
+  if (!Array.isArray(request3)) {
+    return 0;
+  }
+  let textLength = 0;
+  for (const part of request3) {
+    if (typeof part === "string") {
+      textLength += part.length;
+    } else if (typeof part === "object" && part !== null && "text" in part && part.text) {
+      textLength += part.text.length;
+    }
+  }
+  return textLength;
+}
 var GeminiClient = class {
   config;
   chat;
@@ -359114,6 +359734,25 @@ var GeminiClient = class {
     return getEffectiveModel(this.config.isInFallbackMode(), configModel, this.config.getPreviewFeatures());
   }
   async *sendMessageStream(request3, signal, prompt_id, turns = MAX_TURNS, isInvalidStreamRetry = false) {
+    const hooksEnabled = this.config.getEnableHooks();
+    const messageBus = this.config.getMessageBus();
+    if (hooksEnabled && messageBus) {
+      const hookOutput = await fireBeforeAgentHook(messageBus, request3);
+      if (hookOutput?.isBlockingDecision() || hookOutput?.shouldStopExecution()) {
+        yield {
+          type: GeminiEventType.Error,
+          value: {
+            error: new Error(`BeforeAgent hook blocked processing: ${hookOutput.getEffectiveReason()}`)
+          }
+        };
+        return new Turn(this.getChat(), prompt_id);
+      }
+      const additionalContext = hookOutput?.getAdditionalContext();
+      if (additionalContext) {
+        const requestArray = Array.isArray(request3) ? request3 : [request3];
+        request3 = [...requestArray, { text: additionalContext }];
+      }
+    }
     if (this.lastPromptId !== prompt_id) {
       this.loopDetector.reset(prompt_id);
       this.lastPromptId = prompt_id;
@@ -359129,7 +359768,7 @@ var GeminiClient = class {
       return new Turn(this.getChat(), prompt_id);
     }
     const modelForLimitCheck = this._getEffectiveModelForCurrentTurn();
-    const estimatedRequestTokenCount = Math.floor(JSON.stringify(request3).length / 4);
+    const estimatedRequestTokenCount = Math.floor(estimateTextOnlyLength(request3) / 4);
     const remainingTokenCount = tokenLimit(modelForLimitCheck) - this.getChat().getLastPromptTokenCount();
     if (estimatedRequestTokenCount > remainingTokenCount * 0.95) {
       yield {
@@ -359222,7 +359861,16 @@ var GeminiClient = class {
       logNextSpeakerCheck(this.config, new NextSpeakerCheckEvent(prompt_id, turn.finishReason?.toString() || "", nextSpeakerCheck?.next_speaker || ""));
       if (nextSpeakerCheck?.next_speaker === "model") {
         const nextRequest = [{ text: "Please continue." }];
-        yield* this.sendMessageStream(nextRequest, signal, prompt_id, boundedTurns - 1);
+        return yield* this.sendMessageStream(nextRequest, signal, prompt_id, boundedTurns - 1);
+      }
+    }
+    if (hooksEnabled && messageBus) {
+      const responseText = turn.getResponseText() || "[no response text]";
+      const hookOutput = await fireAfterAgentHook(messageBus, request3, responseText);
+      if (hookOutput?.isBlockingDecision() || hookOutput?.shouldStopExecution()) {
+        const continueReason = hookOutput.getEffectiveReason();
+        const continueRequest = [{ text: continueReason }];
+        yield* this.sendMessageStream(continueRequest, signal, prompt_id, boundedTurns - 1);
       }
     }
     return turn;
@@ -364822,6 +365470,31 @@ var DEFAULT_MODEL_CONFIGS = {
     "next-speaker-checker": {
       extends: "gemini-2.5-flash-base",
       modelConfig: {}
+    },
+    "chat-compression-3-pro": {
+      modelConfig: {
+        model: "gemini-3-pro-preview"
+      }
+    },
+    "chat-compression-2.5-pro": {
+      modelConfig: {
+        model: "gemini-2.5-pro"
+      }
+    },
+    "chat-compression-2.5-flash": {
+      modelConfig: {
+        model: "gemini-2.5-flash"
+      }
+    },
+    "chat-compression-2.5-flash-lite": {
+      modelConfig: {
+        model: "gemini-2.5-flash-lite"
+      }
+    },
+    "chat-compression-default": {
+      modelConfig: {
+        model: "gemini-2.5-pro"
+      }
     }
   }
 };
@@ -364973,6 +365646,7 @@ var WorkspaceContext = class {
 };
 
 // packages/core/dist/src/confirmation-bus/message-bus.js
+import { randomUUID as randomUUID6 } from "node:crypto";
 import { EventEmitter as EventEmitter10 } from "node:events";
 var MessageBus = class extends EventEmitter10 {
   policyEngine;
@@ -365030,6 +365704,27 @@ var MessageBus = class extends EventEmitter10 {
           default:
             throw new Error(`Unknown policy decision: ${decision}`);
         }
+      } else if (message.type === MessageBusType.HOOK_EXECUTION_REQUEST) {
+        const hookRequest = message;
+        const decision = await this.policyEngine.checkHook(hookRequest);
+        const effectiveDecision = decision === PolicyDecision.ALLOW ? "allow" : "deny";
+        this.emitMessage({
+          type: MessageBusType.HOOK_POLICY_DECISION,
+          eventName: hookRequest.eventName,
+          hookSource: getHookSource(hookRequest.input),
+          decision: effectiveDecision,
+          reason: decision !== PolicyDecision.ALLOW ? "Hook execution denied by policy" : void 0
+        });
+        if (decision === PolicyDecision.ALLOW) {
+          this.emitMessage(message);
+        } else {
+          this.emitMessage({
+            type: MessageBusType.HOOK_EXECUTION_RESPONSE,
+            correlationId: hookRequest.correlationId,
+            success: false,
+            error: new Error("Hook execution denied by policy")
+          });
+        }
       } else {
         this.emitMessage(message);
       }
@@ -365043,6 +365738,32 @@ var MessageBus = class extends EventEmitter10 {
   unsubscribe(type, listener) {
     this.off(type, listener);
   }
+  /**
+   * Request-response pattern: Publish a message and wait for a correlated response
+   * This enables synchronous-style communication over the async MessageBus
+   * The correlation ID is generated internally and added to the request
+   */
+  async request(request3, responseType, timeoutMs = 6e4) {
+    const correlationId = randomUUID6();
+    return new Promise((resolve14, reject) => {
+      const timeoutId = setTimeout(() => {
+        cleanup();
+        reject(new Error(`Request timed out waiting for ${responseType}`));
+      }, timeoutMs);
+      const cleanup = () => {
+        clearTimeout(timeoutId);
+        this.unsubscribe(responseType, responseHandler);
+      };
+      const responseHandler = (response) => {
+        if ("correlationId" in response && response.correlationId === correlationId) {
+          cleanup();
+          resolve14(response);
+        }
+      };
+      this.subscribe(responseType, responseHandler);
+      this.publish({ ...request3, correlationId });
+    });
+  }
 };
 
 // packages/core/dist/src/policy/stable-stringify.js
@@ -365136,18 +365857,31 @@ function ruleMatches(rule, toolCall, stringifiedArgs, serverName) {
   }
   return true;
 }
+function hookCheckerMatches(rule, context2) {
+  if (rule.eventName && rule.eventName !== context2.eventName) {
+    return false;
+  }
+  if (rule.hookSource && rule.hookSource !== context2.hookSource) {
+    return false;
+  }
+  return true;
+}
 var PolicyEngine = class {
   rules;
   checkers;
+  hookCheckers;
   defaultDecision;
   nonInteractive;
   checkerRunner;
+  allowHooks;
   constructor(config2 = {}, checkerRunner) {
     this.rules = (config2.rules ?? []).sort((a2, b) => (b.priority ?? 0) - (a2.priority ?? 0));
     this.checkers = (config2.checkers ?? []).sort((a2, b) => (b.priority ?? 0) - (a2.priority ?? 0));
+    this.hookCheckers = (config2.hookCheckers ?? []).sort((a2, b) => (b.priority ?? 0) - (a2.priority ?? 0));
     this.defaultDecision = config2.defaultDecision ?? PolicyDecision.ASK_USER;
     this.nonInteractive = config2.nonInteractive ?? false;
     this.checkerRunner = checkerRunner;
+    this.allowHooks = config2.allowHooks ?? true;
   }
   /**
    * Check if a tool call is allowed based on the configured policies.
@@ -365230,6 +365964,64 @@ var PolicyEngine = class {
   getCheckers() {
     return this.checkers;
   }
+  /**
+   * Add a new hook checker to the policy engine.
+   */
+  addHookChecker(checker) {
+    this.hookCheckers.push(checker);
+    this.hookCheckers.sort((a2, b) => (b.priority ?? 0) - (a2.priority ?? 0));
+  }
+  /**
+   * Get all current hook checkers.
+   */
+  getHookCheckers() {
+    return this.hookCheckers;
+  }
+  /**
+   * Check if a hook execution is allowed based on the configured policies.
+   * Runs hook-specific safety checkers if configured.
+   */
+  async checkHook(request3) {
+    if (!this.allowHooks) {
+      return PolicyDecision.DENY;
+    }
+    const context2 = "input" in request3 ? {
+      eventName: request3.eventName,
+      hookSource: getHookSource(request3.input),
+      trustedFolder: typeof request3.input["trusted_folder"] === "boolean" ? request3.input["trusted_folder"] : void 0
+    } : request3;
+    if (context2.trustedFolder === false && context2.hookSource === "project") {
+      return PolicyDecision.DENY;
+    }
+    if (this.checkerRunner && this.hookCheckers.length > 0) {
+      for (const checkerRule of this.hookCheckers) {
+        if (hookCheckerMatches(checkerRule, context2)) {
+          debugLogger.debug(`[PolicyEngine.checkHook] Running hook checker: ${checkerRule.checker.name} for event: ${context2.eventName}`);
+          try {
+            const syntheticCall = {
+              name: `hook:${context2.eventName}`,
+              args: {
+                hookSource: context2.hookSource,
+                trustedFolder: context2.trustedFolder
+              }
+            };
+            const result = await this.checkerRunner.runChecker(syntheticCall, checkerRule.checker);
+            if (result.decision === SafetyCheckDecision.DENY) {
+              debugLogger.debug(`[PolicyEngine.checkHook] Hook checker denied: ${result.reason}`);
+              return PolicyDecision.DENY;
+            } else if (result.decision === SafetyCheckDecision.ASK_USER) {
+              debugLogger.debug(`[PolicyEngine.checkHook] Hook checker requested ASK_USER: ${result.reason}`);
+              return this.applyNonInteractiveMode(PolicyDecision.ASK_USER);
+            }
+          } catch (error) {
+            debugLogger.debug(`[PolicyEngine.checkHook] Hook checker failed: ${error}`);
+            return PolicyDecision.DENY;
+          }
+        }
+      }
+    }
+    return PolicyDecision.ALLOW;
+  }
   applyNonInteractiveMode(decision) {
     if (this.nonInteractive && decision === PolicyDecision.ASK_USER) {
       return PolicyDecision.DENY;
@@ -365238,6 +366030,1205 @@ var PolicyEngine = class {
   }
 };
 
+// packages/core/dist/src/hooks/hookRegistry.js
+var HookRegistryNotInitializedError = class extends Error {
+  constructor(message = "Hook registry not initialized") {
+    super(message);
+    this.name = "HookRegistryNotInitializedError";
+  }
+};
+var ConfigSource;
+(function(ConfigSource2) {
+  ConfigSource2["Project"] = "project";
+  ConfigSource2["User"] = "user";
+  ConfigSource2["System"] = "system";
+  ConfigSource2["Extensions"] = "extensions";
+})(ConfigSource || (ConfigSource = {}));
+var HookRegistry = class {
+  config;
+  entries = [];
+  initialized = false;
+  constructor(config2) {
+    this.config = config2;
+  }
+  /**
+   * Initialize the registry by processing hooks from config
+   */
+  async initialize() {
+    if (this.initialized) {
+      return;
+    }
+    this.entries = [];
+    this.processHooksFromConfig();
+    this.initialized = true;
+    debugLogger.log(`Hook registry initialized with ${this.entries.length} hook entries`);
+  }
+  /**
+   * Get all hook entries for a specific event
+   */
+  getHooksForEvent(eventName) {
+    if (!this.initialized) {
+      throw new HookRegistryNotInitializedError();
+    }
+    return this.entries.filter((entry) => entry.eventName === eventName && entry.enabled).sort((a2, b) => this.getSourcePriority(a2.source) - this.getSourcePriority(b.source));
+  }
+  /**
+   * Get all registered hooks
+   */
+  getAllHooks() {
+    if (!this.initialized) {
+      throw new HookRegistryNotInitializedError();
+    }
+    return [...this.entries];
+  }
+  /**
+   * Enable or disable a specific hook
+   */
+  setHookEnabled(hookName, enabled) {
+    const updated = this.entries.filter((entry) => {
+      const name4 = this.getHookName(entry);
+      if (name4 === hookName) {
+        entry.enabled = enabled;
+        return true;
+      }
+      return false;
+    });
+    if (updated.length > 0) {
+      debugLogger.log(`${enabled ? "Enabled" : "Disabled"} ${updated.length} hook(s) matching "${hookName}"`);
+    } else {
+      debugLogger.warn(`No hooks found matching "${hookName}"`);
+    }
+  }
+  /**
+   * Get hook name for display purposes
+   */
+  getHookName(entry) {
+    return entry.config.command || "unknown-command";
+  }
+  /**
+   * Process hooks from the config that was already loaded by the CLI
+   */
+  processHooksFromConfig() {
+    const configHooks = this.config.getHooks();
+    if (configHooks) {
+      this.processHooksConfiguration(configHooks, ConfigSource.Project);
+    }
+    const extensions = this.config.getExtensions() || [];
+    for (const extension of extensions) {
+      if (extension.isActive && extension.hooks) {
+        this.processHooksConfiguration(extension.hooks, ConfigSource.Extensions);
+      }
+    }
+  }
+  /**
+   * Process hooks configuration and add entries
+   */
+  processHooksConfiguration(hooksConfig, source) {
+    for (const [eventName, definitions] of Object.entries(hooksConfig)) {
+      if (!this.isValidEventName(eventName)) {
+        debugLogger.warn(`Invalid hook event name: ${eventName}`);
+        continue;
+      }
+      const typedEventName = eventName;
+      if (!Array.isArray(definitions)) {
+        debugLogger.warn(`Hook definitions for event "${eventName}" from source "${source}" is not an array. Skipping.`);
+        continue;
+      }
+      for (const definition of definitions) {
+        this.processHookDefinition(definition, typedEventName, source);
+      }
+    }
+  }
+  /**
+   * Process a single hook definition
+   */
+  processHookDefinition(definition, eventName, source) {
+    if (!definition || typeof definition !== "object" || !Array.isArray(definition.hooks)) {
+      debugLogger.warn(`Discarding invalid hook definition for ${eventName} from ${source}:`, definition);
+      return;
+    }
+    for (const hookConfig of definition.hooks) {
+      if (hookConfig && typeof hookConfig === "object" && this.validateHookConfig(hookConfig, eventName, source)) {
+        this.entries.push({
+          config: hookConfig,
+          source,
+          eventName,
+          matcher: definition.matcher,
+          sequential: definition.sequential,
+          enabled: true
+        });
+      } else {
+        debugLogger.warn(`Discarding invalid hook configuration for ${eventName} from ${source}:`, hookConfig);
+      }
+    }
+  }
+  /**
+   * Validate a hook configuration
+   */
+  validateHookConfig(config2, eventName, source) {
+    if (!config2.type || !["command", "plugin"].includes(config2.type)) {
+      debugLogger.warn(`Invalid hook ${eventName} from ${source} type: ${config2.type}`);
+      return false;
+    }
+    if (config2.type === "command" && !config2.command) {
+      debugLogger.warn(`Command hook ${eventName} from ${source} missing command field`);
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Check if an event name is valid
+   */
+  isValidEventName(eventName) {
+    const validEventNames = Object.values(HookEventName);
+    return validEventNames.includes(eventName);
+  }
+  /**
+   * Get source priority (lower number = higher priority)
+   */
+  getSourcePriority(source) {
+    switch (source) {
+      case ConfigSource.Project:
+        return 1;
+      case ConfigSource.User:
+        return 2;
+      case ConfigSource.System:
+        return 3;
+      case ConfigSource.Extensions:
+        return 4;
+      default:
+        return 999;
+    }
+  }
+};
+
+// packages/core/dist/src/hooks/hookRunner.js
+import { spawn as spawn9 } from "node:child_process";
+var DEFAULT_HOOK_TIMEOUT = 6e4;
+var EXIT_CODE_SUCCESS = 0;
+var EXIT_CODE_BLOCKING_ERROR = 2;
+var EXIT_CODE_NON_BLOCKING_ERROR = 1;
+var HookRunner = class {
+  constructor() {
+  }
+  /**
+   * Execute a single hook
+   */
+  async executeHook(hookConfig, eventName, input) {
+    const startTime = Date.now();
+    try {
+      return await this.executeCommandHook(hookConfig, eventName, input, startTime);
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      const hookSource = hookConfig.command || "unknown";
+      const errorMessage = `Hook execution failed for event '${eventName}' (source: ${hookSource}): ${error}`;
+      debugLogger.warn(`Hook execution error (non-fatal): ${errorMessage}`);
+      return {
+        hookConfig,
+        eventName,
+        success: false,
+        error: error instanceof Error ? error : new Error(errorMessage),
+        duration
+      };
+    }
+  }
+  /**
+   * Execute multiple hooks in parallel
+   */
+  async executeHooksParallel(hookConfigs, eventName, input) {
+    const promises3 = hookConfigs.map((config2) => this.executeHook(config2, eventName, input));
+    return await Promise.all(promises3);
+  }
+  /**
+   * Execute multiple hooks sequentially
+   */
+  async executeHooksSequential(hookConfigs, eventName, input) {
+    const results = [];
+    let currentInput = input;
+    for (const config2 of hookConfigs) {
+      const result = await this.executeHook(config2, eventName, currentInput);
+      results.push(result);
+      if (result.success && result.output) {
+        currentInput = this.applyHookOutputToInput(currentInput, result.output, eventName);
+      }
+    }
+    return results;
+  }
+  /**
+   * Apply hook output to modify input for the next hook in sequential execution
+   */
+  applyHookOutputToInput(originalInput, hookOutput, eventName) {
+    const modifiedInput = { ...originalInput };
+    if (hookOutput.hookSpecificOutput) {
+      switch (eventName) {
+        case HookEventName.BeforeAgent:
+          if ("additionalContext" in hookOutput.hookSpecificOutput) {
+            const additionalContext = hookOutput.hookSpecificOutput["additionalContext"];
+            if (typeof additionalContext === "string" && "prompt" in modifiedInput) {
+              modifiedInput.prompt += "\n\n" + additionalContext;
+            }
+          }
+          break;
+        case HookEventName.BeforeModel:
+          if ("llm_request" in hookOutput.hookSpecificOutput) {
+            const hookBeforeModelOutput = hookOutput;
+            if (hookBeforeModelOutput.hookSpecificOutput?.llm_request && "llm_request" in modifiedInput) {
+              const currentRequest = modifiedInput.llm_request;
+              const partialRequest = hookBeforeModelOutput.hookSpecificOutput.llm_request;
+              modifiedInput.llm_request = {
+                ...currentRequest,
+                ...partialRequest
+              };
+            }
+          }
+          break;
+        default:
+          break;
+      }
+    }
+    return modifiedInput;
+  }
+  /**
+   * Execute a command hook
+   */
+  async executeCommandHook(hookConfig, eventName, input, startTime) {
+    const timeout = hookConfig.timeout ?? DEFAULT_HOOK_TIMEOUT;
+    return new Promise((resolve14) => {
+      if (!hookConfig.command) {
+        const errorMessage = "Command hook missing command";
+        debugLogger.warn(`Hook configuration error (non-fatal): ${errorMessage}`);
+        resolve14({
+          hookConfig,
+          eventName,
+          success: false,
+          error: new Error(errorMessage),
+          duration: Date.now() - startTime
+        });
+        return;
+      }
+      let stdout = "";
+      let stderr = "";
+      let timedOut2 = false;
+      const command = this.expandCommand(hookConfig.command, input);
+      const env2 = {
+        ...process.env,
+        GEMINI_PROJECT_DIR: input.cwd,
+        CLAUDE_PROJECT_DIR: input.cwd
+        // For compatibility
+      };
+      const child = spawn9(command, {
+        env: env2,
+        cwd: input.cwd,
+        stdio: ["pipe", "pipe", "pipe"],
+        shell: true
+      });
+      const timeoutHandle = setTimeout(() => {
+        timedOut2 = true;
+        child.kill("SIGTERM");
+        setTimeout(() => {
+          if (!child.killed) {
+            child.kill("SIGKILL");
+          }
+        }, 5e3);
+      }, timeout);
+      if (child.stdin) {
+        child.stdin.write(JSON.stringify(input));
+        child.stdin.end();
+      }
+      child.stdout?.on("data", (data) => {
+        stdout += data.toString();
+      });
+      child.stderr?.on("data", (data) => {
+        stderr += data.toString();
+      });
+      child.on("close", (exitCode) => {
+        clearTimeout(timeoutHandle);
+        const duration = Date.now() - startTime;
+        if (timedOut2) {
+          resolve14({
+            hookConfig,
+            eventName,
+            success: false,
+            error: new Error(`Hook timed out after ${timeout}ms`),
+            stdout,
+            stderr,
+            duration
+          });
+          return;
+        }
+        let output;
+        if (exitCode === EXIT_CODE_SUCCESS && stdout.trim()) {
+          try {
+            let parsed = JSON.parse(stdout.trim());
+            if (typeof parsed === "string") {
+              parsed = JSON.parse(parsed);
+            }
+            if (parsed) {
+              output = parsed;
+            }
+          } catch {
+            output = this.convertPlainTextToHookOutput(stdout.trim(), exitCode);
+          }
+        } else if (exitCode !== EXIT_CODE_SUCCESS && stderr.trim()) {
+          output = this.convertPlainTextToHookOutput(stderr.trim(), exitCode || EXIT_CODE_NON_BLOCKING_ERROR);
+        }
+        resolve14({
+          hookConfig,
+          eventName,
+          success: exitCode === EXIT_CODE_SUCCESS,
+          output,
+          stdout,
+          stderr,
+          exitCode: exitCode || EXIT_CODE_SUCCESS,
+          duration
+        });
+      });
+      child.on("error", (error) => {
+        clearTimeout(timeoutHandle);
+        const duration = Date.now() - startTime;
+        resolve14({
+          hookConfig,
+          eventName,
+          success: false,
+          error,
+          stdout,
+          stderr,
+          duration
+        });
+      });
+    });
+  }
+  /**
+   * Expand command with environment variables and input context
+   */
+  expandCommand(command, input) {
+    return command.replace(/\$GEMINI_PROJECT_DIR/g, input.cwd).replace(/\$CLAUDE_PROJECT_DIR/g, input.cwd);
+  }
+  /**
+   * Convert plain text output to structured HookOutput
+   */
+  convertPlainTextToHookOutput(text, exitCode) {
+    if (exitCode === EXIT_CODE_SUCCESS) {
+      return {
+        decision: "allow",
+        systemMessage: text
+      };
+    } else if (exitCode === EXIT_CODE_BLOCKING_ERROR) {
+      return {
+        decision: "deny",
+        reason: text
+      };
+    } else {
+      return {
+        decision: "allow",
+        systemMessage: `Warning: ${text}`
+      };
+    }
+  }
+};
+
+// packages/core/dist/src/hooks/hookAggregator.js
+var HookAggregator = class {
+  /**
+   * Aggregate results from multiple hook executions
+   */
+  aggregateResults(results, eventName) {
+    const allOutputs = [];
+    const errors = [];
+    let totalDuration = 0;
+    for (const result of results) {
+      totalDuration += result.duration;
+      if (result.error) {
+        errors.push(result.error);
+      }
+      if (result.output) {
+        allOutputs.push(result.output);
+      }
+    }
+    const mergedOutput = this.mergeOutputs(allOutputs, eventName);
+    const finalOutput = mergedOutput ? this.createSpecificHookOutput(mergedOutput, eventName) : void 0;
+    return {
+      success: errors.length === 0,
+      finalOutput,
+      allOutputs,
+      errors,
+      totalDuration
+    };
+  }
+  /**
+   * Merge hook outputs using event-specific strategies
+   *
+   * Note: We always use the merge logic even for single hooks to ensure
+   * consistent default behaviors (e.g., default decision='allow' for OR logic)
+   */
+  mergeOutputs(outputs, eventName) {
+    if (outputs.length === 0) {
+      return void 0;
+    }
+    switch (eventName) {
+      case HookEventName.BeforeTool:
+      case HookEventName.AfterTool:
+      case HookEventName.BeforeAgent:
+      case HookEventName.AfterAgent:
+      case HookEventName.SessionStart:
+        return this.mergeWithOrDecision(outputs);
+      case HookEventName.BeforeModel:
+      case HookEventName.AfterModel:
+        return this.mergeWithFieldReplacement(outputs);
+      case HookEventName.BeforeToolSelection:
+        return this.mergeToolSelectionOutputs(outputs);
+      default:
+        return this.mergeSimple(outputs);
+    }
+  }
+  /**
+   * Merge outputs with OR decision logic and message concatenation
+   */
+  mergeWithOrDecision(outputs) {
+    const merged = {
+      continue: true,
+      suppressOutput: false
+    };
+    const messages = [];
+    const reasons = [];
+    const systemMessages = [];
+    const additionalContexts = [];
+    let hasBlockDecision = false;
+    let hasContinueFalse = false;
+    for (const output of outputs) {
+      if (output.continue === false) {
+        hasContinueFalse = true;
+        merged.continue = false;
+        if (output.stopReason) {
+          messages.push(output.stopReason);
+        }
+      }
+      const tempOutput = new DefaultHookOutput(output);
+      if (tempOutput.isBlockingDecision()) {
+        hasBlockDecision = true;
+        merged.decision = output.decision;
+      }
+      if (output.reason) {
+        reasons.push(output.reason);
+      }
+      if (output.systemMessage) {
+        systemMessages.push(output.systemMessage);
+      }
+      if (output.suppressOutput) {
+        merged.suppressOutput = true;
+      }
+      this.extractAdditionalContext(output, additionalContexts);
+    }
+    if (!hasBlockDecision && !hasContinueFalse) {
+      merged.decision = "allow";
+    }
+    if (messages.length > 0) {
+      merged.stopReason = messages.join("\n");
+    }
+    if (reasons.length > 0) {
+      merged.reason = reasons.join("\n");
+    }
+    if (systemMessages.length > 0) {
+      merged.systemMessage = systemMessages.join("\n");
+    }
+    if (additionalContexts.length > 0) {
+      merged.hookSpecificOutput = {
+        ...merged.hookSpecificOutput || {},
+        additionalContext: additionalContexts.join("\n")
+      };
+    }
+    return merged;
+  }
+  /**
+   * Merge outputs with later fields replacing earlier fields
+   */
+  mergeWithFieldReplacement(outputs) {
+    let merged = {};
+    for (const output of outputs) {
+      merged = {
+        ...merged,
+        ...output,
+        hookSpecificOutput: {
+          ...merged.hookSpecificOutput,
+          ...output.hookSpecificOutput
+        }
+      };
+    }
+    return merged;
+  }
+  /**
+   * Merge tool selection outputs with specific logic for tool config
+   *
+   * Tool Selection Strategy:
+   * - The intent is to provide a UNION of tools from all hooks
+   * - If any hook specifies NONE mode, no tools are available (most restrictive wins)
+   * - If any hook specifies ANY mode (and no NONE), ANY mode is used
+   * - Otherwise AUTO mode is used
+   * - Function names are collected from all hooks and sorted for deterministic caching
+   *
+   * This means hooks can only add/enable tools, not filter them out individually.
+   * If one hook restricts and another re-enables, the union takes the re-enabled tool.
+   */
+  mergeToolSelectionOutputs(outputs) {
+    const merged = {};
+    const allFunctionNames = /* @__PURE__ */ new Set();
+    let hasNoneMode = false;
+    let hasAnyMode = false;
+    for (const output of outputs) {
+      const toolConfig = output.hookSpecificOutput?.toolConfig;
+      if (!toolConfig) {
+        continue;
+      }
+      if (toolConfig.mode === "NONE") {
+        hasNoneMode = true;
+      } else if (toolConfig.mode === "ANY") {
+        hasAnyMode = true;
+      }
+      if (toolConfig.allowedFunctionNames) {
+        for (const name4 of toolConfig.allowedFunctionNames) {
+          allFunctionNames.add(name4);
+        }
+      }
+    }
+    let finalMode;
+    let finalFunctionNames = [];
+    if (hasNoneMode) {
+      finalMode = FunctionCallingConfigMode.NONE;
+      finalFunctionNames = [];
+    } else if (hasAnyMode) {
+      finalMode = FunctionCallingConfigMode.ANY;
+      finalFunctionNames = Array.from(allFunctionNames).sort();
+    } else {
+      finalMode = FunctionCallingConfigMode.AUTO;
+      finalFunctionNames = Array.from(allFunctionNames).sort();
+    }
+    merged.hookSpecificOutput = {
+      hookEventName: "BeforeToolSelection",
+      toolConfig: {
+        mode: finalMode,
+        allowedFunctionNames: finalFunctionNames
+      }
+    };
+    return merged;
+  }
+  /**
+   * Simple merge for events without special logic
+   */
+  mergeSimple(outputs) {
+    let merged = {};
+    for (const output of outputs) {
+      merged = { ...merged, ...output };
+    }
+    return merged;
+  }
+  /**
+   * Create the appropriate specific hook output class based on event type
+   */
+  createSpecificHookOutput(output, eventName) {
+    switch (eventName) {
+      case HookEventName.BeforeTool:
+        return new BeforeToolHookOutput(output);
+      case HookEventName.BeforeModel:
+        return new BeforeModelHookOutput(output);
+      case HookEventName.BeforeToolSelection:
+        return new BeforeToolSelectionHookOutput(output);
+      case HookEventName.AfterModel:
+        return new AfterModelHookOutput(output);
+      default:
+        return new DefaultHookOutput(output);
+    }
+  }
+  /**
+   * Extract additional context from hook-specific outputs
+   */
+  extractAdditionalContext(output, contexts) {
+    const specific = output.hookSpecificOutput;
+    if (!specific) {
+      return;
+    }
+    if ("additionalContext" in specific && typeof specific["additionalContext"] === "string") {
+      contexts.push(specific["additionalContext"]);
+    }
+  }
+};
+
+// packages/core/dist/src/hooks/hookPlanner.js
+var HookPlanner = class {
+  hookRegistry;
+  constructor(hookRegistry) {
+    this.hookRegistry = hookRegistry;
+  }
+  /**
+   * Create execution plan for a hook event
+   */
+  createExecutionPlan(eventName, context2) {
+    const hookEntries = this.hookRegistry.getHooksForEvent(eventName);
+    if (hookEntries.length === 0) {
+      return null;
+    }
+    const matchingEntries = hookEntries.filter((entry) => this.matchesContext(entry, context2));
+    if (matchingEntries.length === 0) {
+      return null;
+    }
+    const deduplicatedEntries = this.deduplicateHooks(matchingEntries);
+    const hookConfigs = deduplicatedEntries.map((entry) => entry.config);
+    const sequential = deduplicatedEntries.some((entry) => entry.sequential === true);
+    const plan = {
+      eventName,
+      hookConfigs,
+      sequential
+    };
+    debugLogger.debug(`Created execution plan for ${eventName}: ${hookConfigs.length} hook(s) to execute ${sequential ? "sequentially" : "in parallel"}`);
+    return plan;
+  }
+  /**
+   * Check if a hook entry matches the given context
+   */
+  matchesContext(entry, context2) {
+    if (!entry.matcher || !context2) {
+      return true;
+    }
+    const matcher = entry.matcher.trim();
+    if (matcher === "" || matcher === "*") {
+      return true;
+    }
+    if (context2.toolName) {
+      return this.matchesToolName(matcher, context2.toolName);
+    }
+    if (context2.trigger) {
+      return this.matchesTrigger(matcher, context2.trigger);
+    }
+    return true;
+  }
+  /**
+   * Match tool name against matcher pattern
+   */
+  matchesToolName(matcher, toolName) {
+    try {
+      const regex2 = new RegExp(matcher);
+      return regex2.test(toolName);
+    } catch {
+      return matcher === toolName;
+    }
+  }
+  /**
+   * Match trigger/source against matcher pattern
+   */
+  matchesTrigger(matcher, trigger) {
+    return matcher === trigger;
+  }
+  /**
+   * Deduplicate identical hook configurations
+   */
+  deduplicateHooks(entries2) {
+    const seen = /* @__PURE__ */ new Set();
+    const deduplicated = [];
+    for (const entry of entries2) {
+      const key = this.getHookKey(entry);
+      if (!seen.has(key)) {
+        seen.add(key);
+        deduplicated.push(entry);
+      } else {
+        debugLogger.debug(`Deduplicated hook: ${key}`);
+      }
+    }
+    return deduplicated;
+  }
+  /**
+   * Generate a unique key for a hook entry
+   */
+  getHookKey(entry) {
+    return `command:${entry.config.command}`;
+  }
+};
+
+// packages/core/dist/src/hooks/hookEventHandler.js
+function isObject3(value) {
+  return typeof value === "object" && value !== null;
+}
+function validateBeforeToolInput(input) {
+  const toolName = input["tool_name"];
+  const toolInput = input["tool_input"];
+  if (typeof toolName !== "string") {
+    throw new Error("Invalid input for BeforeTool hook event: tool_name must be a string");
+  }
+  if (!isObject3(toolInput)) {
+    throw new Error("Invalid input for BeforeTool hook event: tool_input must be an object");
+  }
+  return { toolName, toolInput };
+}
+function validateAfterToolInput(input) {
+  const toolName = input["tool_name"];
+  const toolInput = input["tool_input"];
+  const toolResponse = input["tool_response"];
+  if (typeof toolName !== "string") {
+    throw new Error("Invalid input for AfterTool hook event: tool_name must be a string");
+  }
+  if (!isObject3(toolInput)) {
+    throw new Error("Invalid input for AfterTool hook event: tool_input must be an object");
+  }
+  if (!isObject3(toolResponse)) {
+    throw new Error("Invalid input for AfterTool hook event: tool_response must be an object");
+  }
+  return { toolName, toolInput, toolResponse };
+}
+function validateBeforeAgentInput(input) {
+  const prompt = input["prompt"];
+  if (typeof prompt !== "string") {
+    throw new Error("Invalid input for BeforeAgent hook event: prompt must be a string");
+  }
+  return { prompt };
+}
+function validateAfterAgentInput(input) {
+  const prompt = input["prompt"];
+  const promptResponse = input["prompt_response"];
+  const stopHookActive = input["stop_hook_active"];
+  if (typeof prompt !== "string") {
+    throw new Error("Invalid input for AfterAgent hook event: prompt must be a string");
+  }
+  if (typeof promptResponse !== "string") {
+    throw new Error("Invalid input for AfterAgent hook event: prompt_response must be a string");
+  }
+  return {
+    prompt,
+    promptResponse,
+    stopHookActive: typeof stopHookActive === "boolean" ? stopHookActive : false
+  };
+}
+function validateModelInput(input, eventName) {
+  const llmRequest = input["llm_request"];
+  if (!isObject3(llmRequest)) {
+    throw new Error(`Invalid input for ${eventName} hook event: llm_request must be an object`);
+  }
+  return { llmRequest };
+}
+function validateAfterModelInput(input) {
+  const llmRequest = input["llm_request"];
+  const llmResponse = input["llm_response"];
+  if (!isObject3(llmRequest)) {
+    throw new Error("Invalid input for AfterModel hook event: llm_request must be an object");
+  }
+  if (!isObject3(llmResponse)) {
+    throw new Error("Invalid input for AfterModel hook event: llm_response must be an object");
+  }
+  return {
+    llmRequest,
+    llmResponse
+  };
+}
+function validateNotificationInput(input) {
+  const notificationType = input["notification_type"];
+  const message = input["message"];
+  const details = input["details"];
+  if (typeof notificationType !== "string") {
+    throw new Error("Invalid input for Notification hook event: notification_type must be a string");
+  }
+  if (typeof message !== "string") {
+    throw new Error("Invalid input for Notification hook event: message must be a string");
+  }
+  if (!isObject3(details)) {
+    throw new Error("Invalid input for Notification hook event: details must be an object");
+  }
+  return {
+    notificationType,
+    message,
+    details
+  };
+}
+var HookEventHandler = class {
+  config;
+  hookPlanner;
+  hookRunner;
+  hookAggregator;
+  messageBus;
+  constructor(config2, logger6, hookPlanner, hookRunner, hookAggregator, messageBus) {
+    this.config = config2;
+    this.hookPlanner = hookPlanner;
+    this.hookRunner = hookRunner;
+    this.hookAggregator = hookAggregator;
+    this.messageBus = messageBus;
+    if (this.messageBus) {
+      this.messageBus.subscribe(MessageBusType.HOOK_EXECUTION_REQUEST, (request3) => this.handleHookExecutionRequest(request3));
+    }
+  }
+  /**
+   * Fire a BeforeTool event
+   * Called by handleHookExecutionRequest - executes hooks directly
+   */
+  async fireBeforeToolEvent(toolName, toolInput) {
+    const input = {
+      ...this.createBaseInput(HookEventName.BeforeTool),
+      tool_name: toolName,
+      tool_input: toolInput
+    };
+    const context2 = { toolName };
+    return await this.executeHooks(HookEventName.BeforeTool, input, context2);
+  }
+  /**
+   * Fire an AfterTool event
+   * Called by handleHookExecutionRequest - executes hooks directly
+   */
+  async fireAfterToolEvent(toolName, toolInput, toolResponse) {
+    const input = {
+      ...this.createBaseInput(HookEventName.AfterTool),
+      tool_name: toolName,
+      tool_input: toolInput,
+      tool_response: toolResponse
+    };
+    const context2 = { toolName };
+    return await this.executeHooks(HookEventName.AfterTool, input, context2);
+  }
+  /**
+   * Fire a BeforeAgent event
+   * Called by handleHookExecutionRequest - executes hooks directly
+   */
+  async fireBeforeAgentEvent(prompt) {
+    const input = {
+      ...this.createBaseInput(HookEventName.BeforeAgent),
+      prompt
+    };
+    return await this.executeHooks(HookEventName.BeforeAgent, input);
+  }
+  /**
+   * Fire a Notification event
+   */
+  async fireNotificationEvent(type, message, details) {
+    const input = {
+      ...this.createBaseInput(HookEventName.Notification),
+      notification_type: type,
+      message,
+      details
+    };
+    return await this.executeHooks(HookEventName.Notification, input);
+  }
+  /**
+   * Fire an AfterAgent event
+   * Called by handleHookExecutionRequest - executes hooks directly
+   */
+  async fireAfterAgentEvent(prompt, promptResponse, stopHookActive = false) {
+    const input = {
+      ...this.createBaseInput(HookEventName.AfterAgent),
+      prompt,
+      prompt_response: promptResponse,
+      stop_hook_active: stopHookActive
+    };
+    return await this.executeHooks(HookEventName.AfterAgent, input);
+  }
+  /**
+   * Fire a SessionStart event
+   */
+  async fireSessionStartEvent(source) {
+    const input = {
+      ...this.createBaseInput(HookEventName.SessionStart),
+      source
+    };
+    const context2 = { trigger: source };
+    return await this.executeHooks(HookEventName.SessionStart, input, context2);
+  }
+  /**
+   * Fire a SessionEnd event
+   */
+  async fireSessionEndEvent(reason) {
+    const input = {
+      ...this.createBaseInput(HookEventName.SessionEnd),
+      reason
+    };
+    const context2 = { trigger: reason };
+    return await this.executeHooks(HookEventName.SessionEnd, input, context2);
+  }
+  /**
+   * Fire a PreCompress event
+   */
+  async firePreCompressEvent(trigger) {
+    const input = {
+      ...this.createBaseInput(HookEventName.PreCompress),
+      trigger
+    };
+    const context2 = { trigger };
+    return await this.executeHooks(HookEventName.PreCompress, input, context2);
+  }
+  /**
+   * Fire a BeforeModel event
+   * Called by handleHookExecutionRequest - executes hooks directly
+   */
+  async fireBeforeModelEvent(llmRequest) {
+    const input = {
+      ...this.createBaseInput(HookEventName.BeforeModel),
+      llm_request: defaultHookTranslator.toHookLLMRequest(llmRequest)
+    };
+    return await this.executeHooks(HookEventName.BeforeModel, input);
+  }
+  /**
+   * Fire an AfterModel event
+   * Called by handleHookExecutionRequest - executes hooks directly
+   */
+  async fireAfterModelEvent(llmRequest, llmResponse) {
+    const input = {
+      ...this.createBaseInput(HookEventName.AfterModel),
+      llm_request: defaultHookTranslator.toHookLLMRequest(llmRequest),
+      llm_response: defaultHookTranslator.toHookLLMResponse(llmResponse)
+    };
+    return await this.executeHooks(HookEventName.AfterModel, input);
+  }
+  /**
+   * Fire a BeforeToolSelection event
+   * Called by handleHookExecutionRequest - executes hooks directly
+   */
+  async fireBeforeToolSelectionEvent(llmRequest) {
+    const input = {
+      ...this.createBaseInput(HookEventName.BeforeToolSelection),
+      llm_request: defaultHookTranslator.toHookLLMRequest(llmRequest)
+    };
+    return await this.executeHooks(HookEventName.BeforeToolSelection, input);
+  }
+  /**
+   * Execute hooks for a specific event (direct execution without MessageBus)
+   * Used as fallback when MessageBus is not available
+   */
+  async executeHooks(eventName, input, context2) {
+    try {
+      const plan = this.hookPlanner.createExecutionPlan(eventName, context2);
+      if (!plan || plan.hookConfigs.length === 0) {
+        return {
+          success: true,
+          allOutputs: [],
+          errors: [],
+          totalDuration: 0
+        };
+      }
+      const results = plan.sequential ? await this.hookRunner.executeHooksSequential(plan.hookConfigs, eventName, input) : await this.hookRunner.executeHooksParallel(plan.hookConfigs, eventName, input);
+      const aggregated = this.hookAggregator.aggregateResults(results, eventName);
+      this.processCommonHookOutputFields(aggregated);
+      this.logHookExecution(eventName, input, results, aggregated);
+      return aggregated;
+    } catch (error) {
+      debugLogger.error(`Hook event bus error for ${eventName}: ${error}`);
+      return {
+        success: false,
+        allOutputs: [],
+        errors: [error instanceof Error ? error : new Error(String(error))],
+        totalDuration: 0
+      };
+    }
+  }
+  /**
+   * Create base hook input with common fields
+   */
+  createBaseInput(eventName) {
+    return {
+      session_id: this.config.getSessionId(),
+      transcript_path: "",
+      // TODO: Implement transcript path when supported
+      cwd: this.config.getWorkingDir(),
+      hook_event_name: eventName,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  /**
+   * Log hook execution for observability
+   */
+  logHookExecution(eventName, input, results, aggregated) {
+    const successCount = results.filter((r3) => r3.success).length;
+    const errorCount = results.length - successCount;
+    if (errorCount > 0) {
+      debugLogger.warn(`Hook execution for ${eventName}: ${successCount} succeeded, ${errorCount} failed, total duration: ${aggregated.totalDuration}ms`);
+    } else {
+      debugLogger.debug(`Hook execution for ${eventName}: ${successCount} hooks executed successfully, total duration: ${aggregated.totalDuration}ms`);
+    }
+    for (const result of results) {
+      const hookName = this.getHookNameFromResult(result);
+      const hookType = this.getHookTypeFromResult(result);
+      const hookCallEvent = new HookCallEvent(eventName, hookType, hookName, { ...input }, result.duration, result.success, result.output ? { ...result.output } : void 0, result.exitCode, result.stdout, result.stderr, result.error?.message);
+      logHookCall(this.config, hookCallEvent);
+    }
+    for (const error of aggregated.errors) {
+      debugLogger.error(`Hook execution error: ${error.message}`);
+    }
+  }
+  /**
+   * Process common hook output fields centrally
+   */
+  processCommonHookOutputFields(aggregated) {
+    if (!aggregated.finalOutput) {
+      return;
+    }
+    const systemMessage = aggregated.finalOutput.systemMessage;
+    if (systemMessage && !aggregated.finalOutput.suppressOutput) {
+      debugLogger.warn(`Hook system message: ${systemMessage}`);
+    }
+    if (aggregated.finalOutput.shouldStopExecution()) {
+      const stopReason = aggregated.finalOutput.getEffectiveReason();
+      debugLogger.log(`Hook requested to stop execution: ${stopReason}`);
+    }
+  }
+  /**
+   * Get hook name from execution result for telemetry
+   */
+  getHookNameFromResult(result) {
+    return result.hookConfig.command || "unknown-command";
+  }
+  /**
+   * Get hook type from execution result for telemetry
+   */
+  getHookTypeFromResult(result) {
+    return result.hookConfig.type;
+  }
+  /**
+   * Handle hook execution requests from MessageBus
+   * This method routes the request to the appropriate fire*Event method
+   * and publishes the response back through MessageBus
+   *
+   * The request input only contains event-specific fields. This method adds
+   * the common base fields (session_id, cwd, etc.) before routing.
+   */
+  async handleHookExecutionRequest(request3) {
+    try {
+      const enrichedInput = {
+        ...this.createBaseInput(request3.eventName),
+        ...request3.input
+      };
+      let result;
+      switch (request3.eventName) {
+        case HookEventName.BeforeTool: {
+          const { toolName, toolInput } = validateBeforeToolInput(enrichedInput);
+          result = await this.fireBeforeToolEvent(toolName, toolInput);
+          break;
+        }
+        case HookEventName.AfterTool: {
+          const { toolName, toolInput, toolResponse } = validateAfterToolInput(enrichedInput);
+          result = await this.fireAfterToolEvent(toolName, toolInput, toolResponse);
+          break;
+        }
+        case HookEventName.BeforeAgent: {
+          const { prompt } = validateBeforeAgentInput(enrichedInput);
+          result = await this.fireBeforeAgentEvent(prompt);
+          break;
+        }
+        case HookEventName.AfterAgent: {
+          const { prompt, promptResponse, stopHookActive } = validateAfterAgentInput(enrichedInput);
+          result = await this.fireAfterAgentEvent(prompt, promptResponse, stopHookActive);
+          break;
+        }
+        case HookEventName.BeforeModel: {
+          const { llmRequest } = validateModelInput(enrichedInput, "BeforeModel");
+          const translatedRequest = defaultHookTranslator.toHookLLMRequest(llmRequest);
+          enrichedInput["llm_request"] = translatedRequest;
+          result = await this.fireBeforeModelEvent(llmRequest);
+          break;
+        }
+        case HookEventName.AfterModel: {
+          const { llmRequest, llmResponse } = validateAfterModelInput(enrichedInput);
+          const translatedRequest = defaultHookTranslator.toHookLLMRequest(llmRequest);
+          const translatedResponse = defaultHookTranslator.toHookLLMResponse(llmResponse);
+          enrichedInput["llm_request"] = translatedRequest;
+          enrichedInput["llm_response"] = translatedResponse;
+          result = await this.fireAfterModelEvent(llmRequest, llmResponse);
+          break;
+        }
+        case HookEventName.BeforeToolSelection: {
+          const { llmRequest } = validateModelInput(enrichedInput, "BeforeToolSelection");
+          const translatedRequest = defaultHookTranslator.toHookLLMRequest(llmRequest);
+          enrichedInput["llm_request"] = translatedRequest;
+          result = await this.fireBeforeToolSelectionEvent(llmRequest);
+          break;
+        }
+        case HookEventName.Notification: {
+          const { notificationType, message, details } = validateNotificationInput(enrichedInput);
+          result = await this.fireNotificationEvent(notificationType, message, details);
+          break;
+        }
+        default:
+          throw new Error(`Unsupported hook event: ${request3.eventName}`);
+      }
+      if (this.messageBus) {
+        this.messageBus.publish({
+          type: MessageBusType.HOOK_EXECUTION_RESPONSE,
+          correlationId: request3.correlationId,
+          success: result.success,
+          output: result.finalOutput
+        });
+      }
+    } catch (error) {
+      if (this.messageBus) {
+        this.messageBus.publish({
+          type: MessageBusType.HOOK_EXECUTION_RESPONSE,
+          correlationId: request3.correlationId,
+          success: false,
+          error: error instanceof Error ? error : new Error(String(error))
+        });
+      }
+    }
+  }
+};
+
+// packages/core/dist/src/hooks/hookSystem.js
+var import_api_logs2 = __toESM(require_src21(), 1);
+var HookSystem = class {
+  hookRegistry;
+  hookRunner;
+  hookAggregator;
+  hookPlanner;
+  hookEventHandler;
+  initialized = false;
+  constructor(config2) {
+    const logger6 = import_api_logs2.logs.getLogger(SERVICE_NAME);
+    const messageBus = config2.getMessageBus();
+    this.hookRegistry = new HookRegistry(config2);
+    this.hookRunner = new HookRunner();
+    this.hookAggregator = new HookAggregator();
+    this.hookPlanner = new HookPlanner(this.hookRegistry);
+    this.hookEventHandler = new HookEventHandler(config2, logger6, this.hookPlanner, this.hookRunner, this.hookAggregator, messageBus);
+  }
+  /**
+   * Initialize the hook system
+   */
+  async initialize() {
+    if (this.initialized) {
+      return;
+    }
+    await this.hookRegistry.initialize();
+    this.initialized = true;
+    debugLogger.debug("Hook system initialized successfully");
+  }
+  /**
+   * Get the hook event bus for firing events
+   */
+  getEventHandler() {
+    if (!this.initialized) {
+      throw new Error("Hook system not initialized");
+    }
+    return this.hookEventHandler;
+  }
+  /**
+   * Get hook registry for management operations
+   */
+  getRegistry() {
+    return this.hookRegistry;
+  }
+  /**
+   * Enable or disable a hook
+   */
+  setHookEnabled(hookName, enabled) {
+    this.hookRegistry.setHookEnabled(hookName, enabled);
+  }
+  /**
+   * Get all registered hooks for display/management
+   */
+  getAllHooks() {
+    return this.hookRegistry.getAllHooks();
+  }
+  /**
+   * Get hook system status for debugging
+   */
+  getStatus() {
+    const allHooks = this.initialized ? this.hookRegistry.getAllHooks() : [];
+    return {
+      initialized: this.initialized,
+      totalHooks: allHooks.length
+    };
+  }
+};
+
 // packages/core/dist/src/agents/registry.js
 function getModelConfigAlias(definition) {
   return `${definition.name}-config`;
@@ -367676,7 +369667,7 @@ async function readPackageUp(options2) {
 async function getPackageJson(cwd) {
   const result = await readPackageUp({ cwd });
   if (!result) {
-    return;
+    return void 0;
   }
   return result.packageJson;
 }
@@ -367738,7 +369729,7 @@ async function getClientMetadata() {
     clientMetadataPromise = (async () => ({
       ideName: "IDE_UNSPECIFIED",
       pluginType: "GEMINI",
-      ideVersion: "0.19.0-nightly.20251123.dadd606c0",
+      ideVersion: "0.19.0-nightly.20251125.f6d97d448",
       platform: getPlatform(),
       updateChannel: await getReleaseChannel(__dirname5)
     }))();
@@ -373254,6 +375245,7 @@ var Config = class {
   hooks;
   experiments;
   experimentsPromise;
+  hookSystem;
   previewModelFallbackMode = false;
   previewModelBypassMode = false;
   constructor(params) {
@@ -373413,6 +375405,10 @@ var Config = class {
       await this.mcpClientManager.startConfiguredMcpServers(),
       await this.getExtensionLoader().start(this)
     ]);
+    if (this.enableHooks) {
+      this.hookSystem = new HookSystem(this);
+      await this.hookSystem.initialize();
+    }
     await this.geminiClient.initialize();
   }
   getContentGenerator() {
@@ -374016,6 +376012,12 @@ var Config = class {
     registry.sortTools();
     return registry;
   }
+  /**
+   * Get the hook system instance
+   */
+  getHookSystem() {
+    return this.hookSystem;
+  }
   /**
    * Get hooks configuration
    */
@@ -374207,220 +376209,8 @@ function parseAndFormatApiError(error, authType, userTier, currentModel, fallbac
 init_events();
 
 // packages/core/dist/src/utils/session.js
-import { randomUUID as randomUUID6 } from "node:crypto";
-var sessionId = randomUUID6();
-
-// packages/core/dist/src/hooks/hookTranslator.js
-var HookTranslator = class {
-};
-function hasTextProperty(value) {
-  return typeof value === "object" && value !== null && "text" in value && typeof value.text === "string";
-}
-function isContentWithParts(content) {
-  return typeof content === "object" && content !== null && "role" in content && "parts" in content;
-}
-function extractGenerationConfig(request3) {
-  if (request3.config && typeof request3.config === "object") {
-    const config2 = request3.config;
-    return {
-      temperature: config2.temperature,
-      maxOutputTokens: config2.maxOutputTokens,
-      topP: config2.topP,
-      topK: config2.topK
-    };
-  }
-  return void 0;
-}
-var HookTranslatorGenAIv1 = class extends HookTranslator {
-  /**
-   * Convert genai SDK GenerateContentParameters to stable LLMRequest
-   *
-   * Note: This implementation intentionally extracts only text content from parts.
-   * Non-text parts (images, function calls, etc.) are filtered out in v1 to provide
-   * a simplified, stable interface for hooks. This allows hooks to focus on text
-   * manipulation without needing to handle complex multimodal content.
-   * Future versions may expose additional content types if needed.
-   */
-  toHookLLMRequest(sdkRequest) {
-    const messages = [];
-    if (sdkRequest.contents) {
-      const contents = Array.isArray(sdkRequest.contents) ? sdkRequest.contents : [sdkRequest.contents];
-      for (const content of contents) {
-        if (typeof content === "string") {
-          messages.push({
-            role: "user",
-            content
-          });
-        } else if (isContentWithParts(content)) {
-          const role = content.role === "model" ? "model" : content.role === "system" ? "system" : "user";
-          const parts2 = Array.isArray(content.parts) ? content.parts : [content.parts];
-          const textContent2 = parts2.filter(hasTextProperty).map((part) => part.text).join("");
-          if (textContent2) {
-            messages.push({
-              role,
-              content: textContent2
-            });
-          }
-        }
-      }
-    }
-    const config2 = extractGenerationConfig(sdkRequest);
-    return {
-      model: sdkRequest.model || DEFAULT_GEMINI_FLASH_MODEL,
-      messages,
-      config: {
-        temperature: config2?.temperature,
-        maxOutputTokens: config2?.maxOutputTokens,
-        topP: config2?.topP,
-        topK: config2?.topK
-      }
-    };
-  }
-  /**
-   * Convert stable LLMRequest to genai SDK GenerateContentParameters
-   */
-  fromHookLLMRequest(hookRequest, baseRequest) {
-    const contents = hookRequest.messages.map((message) => ({
-      role: message.role === "model" ? "model" : message.role,
-      parts: [
-        {
-          text: typeof message.content === "string" ? message.content : String(message.content)
-        }
-      ]
-    }));
-    const result = {
-      ...baseRequest,
-      model: hookRequest.model,
-      contents
-    };
-    if (hookRequest.config) {
-      const baseConfig = baseRequest ? extractGenerationConfig(baseRequest) : void 0;
-      result.config = {
-        ...baseConfig,
-        temperature: hookRequest.config.temperature,
-        maxOutputTokens: hookRequest.config.maxOutputTokens,
-        topP: hookRequest.config.topP,
-        topK: hookRequest.config.topK
-      };
-    }
-    return result;
-  }
-  /**
-   * Convert genai SDK GenerateContentResponse to stable LLMResponse
-   */
-  toHookLLMResponse(sdkResponse) {
-    return {
-      text: sdkResponse.text,
-      candidates: (sdkResponse.candidates || []).map((candidate) => {
-        const textParts = candidate.content?.parts?.filter(hasTextProperty).map((part) => part.text) || [];
-        return {
-          content: {
-            role: "model",
-            parts: textParts
-          },
-          finishReason: candidate.finishReason,
-          index: candidate.index,
-          safetyRatings: candidate.safetyRatings?.map((rating) => ({
-            category: String(rating.category || ""),
-            probability: String(rating.probability || "")
-          }))
-        };
-      }),
-      usageMetadata: sdkResponse.usageMetadata ? {
-        promptTokenCount: sdkResponse.usageMetadata.promptTokenCount,
-        candidatesTokenCount: sdkResponse.usageMetadata.candidatesTokenCount,
-        totalTokenCount: sdkResponse.usageMetadata.totalTokenCount
-      } : void 0
-    };
-  }
-  /**
-   * Convert stable LLMResponse to genai SDK GenerateContentResponse
-   */
-  fromHookLLMResponse(hookResponse) {
-    const response = {
-      text: hookResponse.text,
-      candidates: hookResponse.candidates.map((candidate) => ({
-        content: {
-          role: "model",
-          parts: candidate.content.parts.map((part) => ({
-            text: part
-          }))
-        },
-        finishReason: candidate.finishReason,
-        index: candidate.index,
-        safetyRatings: candidate.safetyRatings
-      })),
-      usageMetadata: hookResponse.usageMetadata
-    };
-    return response;
-  }
-  /**
-   * Convert genai SDK ToolConfig to stable HookToolConfig
-   */
-  toHookToolConfig(sdkToolConfig) {
-    return {
-      mode: sdkToolConfig.functionCallingConfig?.mode,
-      allowedFunctionNames: sdkToolConfig.functionCallingConfig?.allowedFunctionNames
-    };
-  }
-  /**
-   * Convert stable HookToolConfig to genai SDK ToolConfig
-   */
-  fromHookToolConfig(hookToolConfig) {
-    const functionCallingConfig = hookToolConfig.mode || hookToolConfig.allowedFunctionNames ? {
-      mode: hookToolConfig.mode,
-      allowedFunctionNames: hookToolConfig.allowedFunctionNames
-    } : void 0;
-    return {
-      functionCallingConfig
-    };
-  }
-};
-var defaultHookTranslator = new HookTranslatorGenAIv1();
-
-// packages/core/dist/src/hooks/types.js
-var HookEventName;
-(function(HookEventName2) {
-  HookEventName2["BeforeTool"] = "BeforeTool";
-  HookEventName2["AfterTool"] = "AfterTool";
-  HookEventName2["BeforeAgent"] = "BeforeAgent";
-  HookEventName2["Notification"] = "Notification";
-  HookEventName2["AfterAgent"] = "AfterAgent";
-  HookEventName2["SessionStart"] = "SessionStart";
-  HookEventName2["SessionEnd"] = "SessionEnd";
-  HookEventName2["PreCompress"] = "PreCompress";
-  HookEventName2["BeforeModel"] = "BeforeModel";
-  HookEventName2["AfterModel"] = "AfterModel";
-  HookEventName2["BeforeToolSelection"] = "BeforeToolSelection";
-})(HookEventName || (HookEventName = {}));
-var HookType;
-(function(HookType2) {
-  HookType2["Command"] = "command";
-})(HookType || (HookType = {}));
-var NotificationType;
-(function(NotificationType2) {
-  NotificationType2["ToolPermission"] = "ToolPermission";
-})(NotificationType || (NotificationType = {}));
-var SessionStartSource;
-(function(SessionStartSource2) {
-  SessionStartSource2["Startup"] = "startup";
-  SessionStartSource2["Resume"] = "resume";
-  SessionStartSource2["Clear"] = "clear";
-  SessionStartSource2["Compress"] = "compress";
-})(SessionStartSource || (SessionStartSource = {}));
-var SessionEndReason;
-(function(SessionEndReason2) {
-  SessionEndReason2["Exit"] = "exit";
-  SessionEndReason2["Clear"] = "clear";
-  SessionEndReason2["Logout"] = "logout";
-  SessionEndReason2["PromptInputExit"] = "prompt_input_exit";
-  SessionEndReason2["Other"] = "other";
-})(SessionEndReason || (SessionEndReason = {}));
-var PreCompressTrigger;
-(function(PreCompressTrigger2) {
-  PreCompressTrigger2["Manual"] = "manual";
-  PreCompressTrigger2["Auto"] = "auto";
-})(PreCompressTrigger || (PreCompressTrigger = {}));
+import { randomUUID as randomUUID7 } from "node:crypto";
+var sessionId = randomUUID7();
 
 // packages/core/dist/index.js
 init_keychain_token_storage();