add skelly tool output summarization via gemma for every tool call

Author: sidwan02

packages/core/src/agents/executor.ts

@@ -71,6 +71,8 @@ import {
   // DOUBLE_INTERRUPT,
 } from '../common/abort-signal-manager.js';
 
+import { SummarizationService } from '../services/summarizer.js';
+
 /** A callback function to report on agent activity. */
 export type ActivityCallback = (activity: SubagentActivityEvent) => void;
 
@@ -103,6 +105,7 @@ export class AgentExecutor<TOutput extends z.ZodTypeAny> {
   private readonly runtimeContext: Config;
   private readonly onActivity?: ActivityCallback;
   private readonly compressionService: ChatCompressionService;
+  private readonly summarizationService: SummarizationService;
   private hasFailedCompressionAttempt = false;
 
   /**
@@ -181,6 +184,7 @@ export class AgentExecutor<TOutput extends z.ZodTypeAny> {
     this.toolRegistry = toolRegistry;
     this.onActivity = onActivity;
     this.compressionService = new ChatCompressionService();
+    this.summarizationService = new SummarizationService();
 
     const randomIdPart = Math.random().toString(36).slice(2, 8);
     // parentPromptId will be undefined if this agent is invoked directly
@@ -1339,7 +1343,36 @@ export class AgentExecutor<TOutput extends z.ZodTypeAny> {
           });
         }
 
-        return toolResponse.responseParts;
+        const toolResponsePartsToReturn: GeminiPart[] =
+          toolResponse.responseParts;
+
+        // Apply summarization if enabled and content is present
+        if (this.definition.runConfig.summarizeToolOutput) {
+          const summary = await this.summarizationService.summarize(
+            toolResponse.responseParts,
+            this.definition.modelConfig,
+          );
+          if (summary) {
+            debugLogger.log(
+              `[AgentExecutor] Summarized output for tool: ${functionCall.name} (ID: ${callId})`,
+            );
+            for (const part of toolResponsePartsToReturn) {
+              if ('functionResponse' in part && part.functionResponse) {
+                // This is a bit awkward, but `response` is just `object`
+                // in the type, so we have to cast.
+                const responseObject = part.functionResponse.response as {
+                  llmContent?: unknown;
+                };
+                if (responseObject.llmContent) {
+                  responseObject.llmContent = summary;
+                  break; // Assume only one functionResponse part
+                }
+              }
+            }
+          }
+        }
+
+        return toolResponsePartsToReturn;
       })();
 
       toolExecutionPromises.push(executionPromise);

packages/core/src/agents/types.ts

@@ -191,4 +191,6 @@ export interface RunConfig {
   max_time_minutes: number;
   /** The maximum number of conversational turns. */
   max_turns?: number;
+  /** Whether to summarize tool output before sending it to the model. */
+  summarizeToolOutput?: boolean;
 }

packages/core/src/services/summarizer.ts

@@ -0,0 +1,68 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type { OllamaModelConfig, ModelConfig } from '../agents/types.js';
+import { type Part as OllamaPart, OllamaChat } from '../core/ollamaChat.js';
+import type { Part as GeminiPart } from '@google/genai';
+import { StreamEventType } from '../core/geminiChat.js';
+
+const SUMMARIZER_SYSTEM_PROMPT = `You are a text summarizer. Your sole purpose is to receive text and provide a concise, factual summary of it. Do not add any commentary or analysis. Focus on the key information presented in the text.`;
+
+export class SummarizationService {
+  constructor() {}
+
+  async summarize(
+    tollResponseParts: GeminiPart[],
+    modelConfig: OllamaModelConfig | ModelConfig,
+  ): Promise<string | null> {
+    if ('host' in modelConfig) {
+      const userParts: OllamaPart[] = [];
+      for (const part of tollResponseParts) {
+        if ('functionResponse' in part) {
+          // Singe gemma can't handle function responses, we convert it into a string.
+          userParts.push({ text: JSON.stringify(part.functionResponse) });
+        } else {
+          userParts.push(part as OllamaPart);
+        }
+      }
+
+      const chat = new OllamaChat(
+        modelConfig as OllamaModelConfig,
+        SUMMARIZER_SYSTEM_PROMPT,
+      );
+
+      const messageParams = {
+        message: userParts,
+      };
+
+      const responseStream = await chat.sendMessageStream(
+        modelConfig?.model,
+        messageParams,
+      );
+
+      let textResponse = '';
+
+      for await (const resp of responseStream) {
+        if (resp.type === StreamEventType.CHUNK) {
+          const chunk = resp.value;
+          const parts = chunk.candidates?.[0]?.content?.parts;
+
+          const text = parts?.map((p) => p.text).join('') || '';
+
+          if (text) {
+            textResponse = text;
+          }
+        }
+      }
+
+      // Just return the raw text response from the summarizer model.
+      return textResponse;
+    } else {
+      // Summarization for non-Ollama models can be implemented here.
+      throw new Error('Summarization using Gemini Model is not implemented.');
+    }
+  }
+}