@iqai/adk 0.6.0 → 0.6.1

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # @iqai/adk
 
+## 0.6.1
+
+### Patch Changes
+
+- 3f78ed9: Fix: Wire up all missing plugin lifecycle callbacks
+
+  The PluginManager had several callback methods defined but never invoked, causing plugins implementing guardrails, logging, or error recovery to be silently ignored.
+
+  This fix adds the missing calls for:
+
+  - `beforeModelCallback` / `afterModelCallback` - intercept LLM requests/responses
+  - `onModelErrorCallback` - handle/recover from LLM errors
+  - `beforeToolCallback` / `afterToolCallback` - intercept tool execution
+  - `onToolErrorCallback` - handle/recover from tool errors
+
+  All 12 plugin callbacks are now properly wired up and invoked at the appropriate lifecycle points.
+
 ## 0.6.0
 
 ### Minor Changes

package/dist/index.js

@@ -7963,35 +7963,35 @@ async function handleFunctionCallsAsync(invocationContext, functionCallEvent, to
     try {
       const functionResponse = await _api.context.with(spanContext, async () => {
         const argsForTool = { ...functionArgs };
+        const pluginOverride = await invocationContext.pluginManager.runBeforeToolCallback({
+          tool,
+          toolArgs: argsForTool,
+          toolContext
+        });
+        if (pluginOverride !== null && pluginOverride !== void 0) {
+          wasOverridden = true;
+          return handleToolOverride(
+            pluginOverride,
+            tool,
+            argsForTool,
+            toolContext,
+            invocationContext,
+            executionOrder
+          );
+        }
         if (isLlmAgent2(agent)) {
           for (const cb of agent.canonicalBeforeToolCallbacks) {
             const maybeOverride = await cb(tool, argsForTool, toolContext);
             if (maybeOverride !== null && maybeOverride !== void 0) {
               wasOverridden = true;
-              const overriddenEvent = buildResponseEvent(
-                tool,
+              return handleToolOverride(
                 maybeOverride,
-                toolContext,
-                invocationContext
-              );
-              telemetryService.traceToolCall(
                 tool,
                 argsForTool,
-                overriddenEvent,
-                void 0,
-                // llmRequest
-                invocationContext
-              );
-              telemetryService.traceEnhancedTool(
-                executionOrder,
-                void 0,
-                // parallelGroup not used in sequential execution
-                0,
-                // no retry
-                true
-                // callback override
+                toolContext,
+                invocationContext,
+                executionOrder
               );
-              return { result: maybeOverride, event: overriddenEvent };
             }
           }
         }
@@ -7999,6 +7999,15 @@ async function handleFunctionCallsAsync(invocationContext, functionCallEvent, to
         if (tool.isLongRunning && !result) {
           return null;
         }
+        const pluginAfterResult = await invocationContext.pluginManager.runAfterToolCallback({
+          tool,
+          toolArgs: argsForTool,
+          toolContext,
+          result
+        });
+        if (pluginAfterResult !== null && pluginAfterResult !== void 0) {
+          result = pluginAfterResult;
+        }
         if (isLlmAgent2(agent)) {
           for (const cb of agent.canonicalAfterToolCallbacks) {
             const maybeModified = await cb(
@@ -8068,6 +8077,22 @@ async function handleFunctionCallsAsync(invocationContext, functionCallEvent, to
         status: toolStatus
       });
       telemetryService.recordError("tool", tool.name);
+      const errorRecoveryResult = await invocationContext.pluginManager.runOnToolErrorCallback({
+        tool,
+        toolArgs: functionArgs,
+        toolContext,
+        error
+      });
+      if (errorRecoveryResult !== null && errorRecoveryResult !== void 0) {
+        const recoveryEvent = buildResponseEvent(
+          tool,
+          errorRecoveryResult,
+          toolContext,
+          invocationContext
+        );
+        functionResponseEvents.push(recoveryEvent);
+        continue;
+      }
       throw error;
     } finally {
       const toolDuration = Date.now() - toolStartTime;
@@ -8170,6 +8195,32 @@ function mergeParallelFunctionResponseEvents(functionResponseEvents) {
 function isLlmAgent2(agent) {
   return agent && typeof agent === "object" && "canonicalModel" in agent;
 }
+function handleToolOverride(override, tool, argsForTool, toolContext, invocationContext, executionOrder) {
+  const overriddenEvent = buildResponseEvent(
+    tool,
+    override,
+    toolContext,
+    invocationContext
+  );
+  telemetryService.traceToolCall(
+    tool,
+    argsForTool,
+    overriddenEvent,
+    void 0,
+    // llmRequest
+    invocationContext
+  );
+  telemetryService.traceEnhancedTool(
+    executionOrder,
+    void 0,
+    // parallelGroup not used in sequential execution
+    0,
+    // no retry
+    true
+    // callback override
+  );
+  return { result: override, event: overriddenEvent };
+}
 
 // src/flows/llm-flows/base-llm-flow.ts
 var _ADK_AGENT_NAME_LABEL_KEY = "adk_agent_name";
@@ -8549,6 +8600,18 @@ var BaseLlmFlow = (_class26 = class {constructor() { _class26.prototype.__init55
     } catch (error) {
       llmStatus = "error";
       telemetryService.recordError("llm", llm.model);
+      const callbackContext = new CallbackContext(invocationContext, {
+        eventActions: modelResponseEvent.actions
+      });
+      const errorRecoveryResponse = await invocationContext.pluginManager.runOnModelErrorCallback({
+        callbackContext,
+        llmRequest,
+        error
+      });
+      if (errorRecoveryResponse) {
+        yield errorRecoveryResponse;
+        return;
+      }
       throw error;
     } finally {
       const llmDuration = Date.now() - llmStartTime;
@@ -8561,6 +8624,16 @@ var BaseLlmFlow = (_class26 = class {constructor() { _class26.prototype.__init55
     }
   }
   async _handleBeforeModelCallback(invocationContext, llmRequest, modelResponseEvent) {
+    const callbackContext = new CallbackContext(invocationContext, {
+      eventActions: modelResponseEvent.actions
+    });
+    const pluginResult = await invocationContext.pluginManager.runBeforeModelCallback({
+      callbackContext,
+      llmRequest
+    });
+    if (pluginResult !== null && pluginResult !== void 0) {
+      return pluginResult;
+    }
     const agent = invocationContext.agent;
     if (!("canonicalBeforeModelCallbacks" in agent)) {
       return;
@@ -8569,9 +8642,6 @@ var BaseLlmFlow = (_class26 = class {constructor() { _class26.prototype.__init55
     if (!beforeCallbacks) {
       return;
     }
-    const callbackContext = new CallbackContext(invocationContext, {
-      eventActions: modelResponseEvent.actions
-    });
     for (const callback of beforeCallbacks) {
       let beforeModelCallbackContent = callback({
         callbackContext,
@@ -8586,6 +8656,16 @@ var BaseLlmFlow = (_class26 = class {constructor() { _class26.prototype.__init55
     }
   }
   async _handleAfterModelCallback(invocationContext, llmResponse, modelResponseEvent) {
+    const callbackContext = new CallbackContext(invocationContext, {
+      eventActions: modelResponseEvent.actions
+    });
+    const pluginResult = await invocationContext.pluginManager.runAfterModelCallback({
+      callbackContext,
+      llmResponse
+    });
+    if (pluginResult) {
+      return pluginResult;
+    }
     const agent = invocationContext.agent;
     if (!("canonicalAfterModelCallbacks" in agent)) {
       return;
@@ -8594,9 +8674,6 @@ var BaseLlmFlow = (_class26 = class {constructor() { _class26.prototype.__init55
     if (!afterCallbacks) {
       return;
     }
-    const callbackContext = new CallbackContext(invocationContext, {
-      eventActions: modelResponseEvent.actions
-    });
     for (const callback of afterCallbacks) {
       let afterModelCallbackContent = callback({
         callbackContext,

package/dist/index.mjs

@@ -7963,35 +7963,35 @@ async function handleFunctionCallsAsync(invocationContext, functionCallEvent, to
     try {
       const functionResponse = await context2.with(spanContext, async () => {
         const argsForTool = { ...functionArgs };
+        const pluginOverride = await invocationContext.pluginManager.runBeforeToolCallback({
+          tool,
+          toolArgs: argsForTool,
+          toolContext
+        });
+        if (pluginOverride !== null && pluginOverride !== void 0) {
+          wasOverridden = true;
+          return handleToolOverride(
+            pluginOverride,
+            tool,
+            argsForTool,
+            toolContext,
+            invocationContext,
+            executionOrder
+          );
+        }
         if (isLlmAgent2(agent)) {
           for (const cb of agent.canonicalBeforeToolCallbacks) {
             const maybeOverride = await cb(tool, argsForTool, toolContext);
             if (maybeOverride !== null && maybeOverride !== void 0) {
               wasOverridden = true;
-              const overriddenEvent = buildResponseEvent(
-                tool,
+              return handleToolOverride(
                 maybeOverride,
-                toolContext,
-                invocationContext
-              );
-              telemetryService.traceToolCall(
                 tool,
                 argsForTool,
-                overriddenEvent,
-                void 0,
-                // llmRequest
-                invocationContext
-              );
-              telemetryService.traceEnhancedTool(
-                executionOrder,
-                void 0,
-                // parallelGroup not used in sequential execution
-                0,
-                // no retry
-                true
-                // callback override
+                toolContext,
+                invocationContext,
+                executionOrder
               );
-              return { result: maybeOverride, event: overriddenEvent };
             }
           }
         }
@@ -7999,6 +7999,15 @@ async function handleFunctionCallsAsync(invocationContext, functionCallEvent, to
         if (tool.isLongRunning && !result) {
           return null;
         }
+        const pluginAfterResult = await invocationContext.pluginManager.runAfterToolCallback({
+          tool,
+          toolArgs: argsForTool,
+          toolContext,
+          result
+        });
+        if (pluginAfterResult !== null && pluginAfterResult !== void 0) {
+          result = pluginAfterResult;
+        }
         if (isLlmAgent2(agent)) {
           for (const cb of agent.canonicalAfterToolCallbacks) {
             const maybeModified = await cb(
@@ -8068,6 +8077,22 @@ async function handleFunctionCallsAsync(invocationContext, functionCallEvent, to
         status: toolStatus
       });
       telemetryService.recordError("tool", tool.name);
+      const errorRecoveryResult = await invocationContext.pluginManager.runOnToolErrorCallback({
+        tool,
+        toolArgs: functionArgs,
+        toolContext,
+        error
+      });
+      if (errorRecoveryResult !== null && errorRecoveryResult !== void 0) {
+        const recoveryEvent = buildResponseEvent(
+          tool,
+          errorRecoveryResult,
+          toolContext,
+          invocationContext
+        );
+        functionResponseEvents.push(recoveryEvent);
+        continue;
+      }
       throw error;
     } finally {
       const toolDuration = Date.now() - toolStartTime;
@@ -8170,6 +8195,32 @@ function mergeParallelFunctionResponseEvents(functionResponseEvents) {
 function isLlmAgent2(agent) {
   return agent && typeof agent === "object" && "canonicalModel" in agent;
 }
+function handleToolOverride(override, tool, argsForTool, toolContext, invocationContext, executionOrder) {
+  const overriddenEvent = buildResponseEvent(
+    tool,
+    override,
+    toolContext,
+    invocationContext
+  );
+  telemetryService.traceToolCall(
+    tool,
+    argsForTool,
+    overriddenEvent,
+    void 0,
+    // llmRequest
+    invocationContext
+  );
+  telemetryService.traceEnhancedTool(
+    executionOrder,
+    void 0,
+    // parallelGroup not used in sequential execution
+    0,
+    // no retry
+    true
+    // callback override
+  );
+  return { result: override, event: overriddenEvent };
+}
 
 // src/flows/llm-flows/base-llm-flow.ts
 var _ADK_AGENT_NAME_LABEL_KEY = "adk_agent_name";
@@ -8549,6 +8600,18 @@ var BaseLlmFlow = class {
     } catch (error) {
       llmStatus = "error";
       telemetryService.recordError("llm", llm.model);
+      const callbackContext = new CallbackContext(invocationContext, {
+        eventActions: modelResponseEvent.actions
+      });
+      const errorRecoveryResponse = await invocationContext.pluginManager.runOnModelErrorCallback({
+        callbackContext,
+        llmRequest,
+        error
+      });
+      if (errorRecoveryResponse) {
+        yield errorRecoveryResponse;
+        return;
+      }
       throw error;
     } finally {
       const llmDuration = Date.now() - llmStartTime;
@@ -8561,6 +8624,16 @@ var BaseLlmFlow = class {
     }
   }
   async _handleBeforeModelCallback(invocationContext, llmRequest, modelResponseEvent) {
+    const callbackContext = new CallbackContext(invocationContext, {
+      eventActions: modelResponseEvent.actions
+    });
+    const pluginResult = await invocationContext.pluginManager.runBeforeModelCallback({
+      callbackContext,
+      llmRequest
+    });
+    if (pluginResult !== null && pluginResult !== void 0) {
+      return pluginResult;
+    }
     const agent = invocationContext.agent;
     if (!("canonicalBeforeModelCallbacks" in agent)) {
       return;
@@ -8569,9 +8642,6 @@ var BaseLlmFlow = class {
     if (!beforeCallbacks) {
       return;
     }
-    const callbackContext = new CallbackContext(invocationContext, {
-      eventActions: modelResponseEvent.actions
-    });
     for (const callback of beforeCallbacks) {
       let beforeModelCallbackContent = callback({
         callbackContext,
@@ -8586,6 +8656,16 @@ var BaseLlmFlow = class {
     }
   }
   async _handleAfterModelCallback(invocationContext, llmResponse, modelResponseEvent) {
+    const callbackContext = new CallbackContext(invocationContext, {
+      eventActions: modelResponseEvent.actions
+    });
+    const pluginResult = await invocationContext.pluginManager.runAfterModelCallback({
+      callbackContext,
+      llmResponse
+    });
+    if (pluginResult) {
+      return pluginResult;
+    }
     const agent = invocationContext.agent;
     if (!("canonicalAfterModelCallbacks" in agent)) {
       return;
@@ -8594,9 +8674,6 @@ var BaseLlmFlow = class {
     if (!afterCallbacks) {
       return;
     }
-    const callbackContext = new CallbackContext(invocationContext, {
-      eventActions: modelResponseEvent.actions
-    });
     for (const callback of afterCallbacks) {
       let afterModelCallbackContent = callback({
         callbackContext,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iqai/adk",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "Agent Development Kit for TypeScript with multi-provider LLM support",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",