@google/gemini-cli-core 0.9.0-nightly.20251001.33269bdb → 0.9.0-nightly.20251002.0f465e88

package/README.md

@@ -11,12 +11,12 @@ Gemini CLI is an open-source AI agent that brings the power of Gemini directly i
 
 ## 🚀 Why Gemini CLI?
 
-- **🎯 Free tier**: 60 requests/min and 1,000 requests/day with personal Google account
-- **🧠 Powerful Gemini 2.5 Pro**: Access to 1M token context window
-- **🔧 Built-in tools**: Google Search grounding, file operations, shell commands, web fetching
-- **🔌 Extensible**: MCP (Model Context Protocol) support for custom integrations
-- **💻 Terminal-first**: Designed for developers who live in the command line
-- **🛡️ Open source**: Apache 2.0 licensed
+- **🎯 Free tier**: 60 requests/min and 1,000 requests/day with personal Google account.
+- **🧠 Powerful Gemini 2.5 Pro**: Access to 1M token context window.
+- **🔧 Built-in tools**: Google Search grounding, file operations, shell commands, web fetching.
+- **🔌 Extensible**: MCP (Model Context Protocol) support for custom integrations.
+- **💻 Terminal-first**: Designed for developers who live in the command line.
+- **🛡️ Open source**: Apache 2.0 licensed.
 
 ## 📦 Installation
 
@@ -109,20 +109,14 @@ Choose the authentication method that best fits your needs:
 
 ### Option 1: Login with Google (OAuth login using your Google Account)
 
-**✨ Best for:**
-
-- Individual developers.
-- Google AI Pro and AI Ultra subscribers.
-- Anyone who has a Gemini Code Assist license.
-
-_See [quota limits and terms of service](https://cloud.google.com/gemini/docs/quotas) for details._
+**✨ Best for:** Individual developers as well as anyone who has a Gemini Code Assist License. (see [quota limits and terms of service](https://cloud.google.com/gemini/docs/quotas) for details)
 
 **Benefits:**
 
-- **Free tier** with 60 requests/min and 1,000 requests/day
-- **Gemini 2.5 Pro and Flash** with 1M token context window
+- **Free tier**: 60 requests/min and 1,000 requests/day
+- **Gemini 2.5 Pro** with 1M token context window
 - **No API key management** - just sign in with your Google account
-- **Automatic updates** to our latest models
+- **Automatic updates** to latest models
 
 #### Start Gemini CLI, then choose _Login with Google_ and follow the browser authentication flow when prompted
 
@@ -171,7 +165,7 @@ export GOOGLE_GENAI_USE_VERTEXAI=true
 gemini
 ```
 
-For Google Workspace accounts and other authentication methods, see the [authentication guide](./docs/cli/authentication.md).
+For Google Workspace accounts and other authentication methods, see the [authentication guide](./docs/get-started/authentication.md).
 
 ## 🚀 Getting Started
 
@@ -233,17 +227,18 @@ gemini
 
 ### Getting Started
 
-- [**Quickstart Guide**](./docs/cli/index.md) - Get up and running quickly
-- [**Authentication Setup**](./docs/cli/authentication.md) - Detailed auth configuration
-- [**Configuration Guide**](./docs/cli/configuration.md) - Settings and customization
-- [**Keyboard Shortcuts**](./docs/keyboard-shortcuts.md) - Productivity tips
+- [**Quickstart Guide**](./docs/get-started/index.md) - Get up and running quickly.
+- [**Authentication Setup**](./docs/get-started/authentication.md) - Detailed auth configuration.
+- [**Configuration Guide**](./docs/get-started/configuration.md) - Settings and customization.
+- [**Keyboard Shortcuts**](./docs/cli/keyboard-shortcuts.md) - Productivity tips.
 
 ### Core Features
 
-- [**Commands Reference**](./docs/cli/commands.md) - All slash commands (`/help`, `/chat`, `/mcp`, etc.)
-- [**Checkpointing**](./docs/checkpointing.md) - Save and resume conversations
-- [**Memory Management**](./docs/tools/memory.md) - Using GEMINI.md context files
-- [**Token Caching**](./docs/cli/token-caching.md) - Optimize token usage
+- [**Commands Reference**](./docs/cli/commands.md) - All slash commands (`/help`, `/chat`, etc).
+- [**Custom Commands**](./docs/cli/custom-commands.md) - Create your own reusable commands.
+- [**Context Files (GEMINI.md)**](./docs/cli/gemini-md.md) - Provide persistent context to Gemini CLI.
+- [**Checkpointing**](./docs/cli/checkpointing.md) - Save and resume conversations.
+- [**Token Caching**](./docs/cli/token-caching.md) - Optimize token usage.
 
 ### Tools & Extensions
 
@@ -251,31 +246,25 @@ gemini
   - [File System Operations](./docs/tools/file-system.md)
   - [Shell Commands](./docs/tools/shell.md)
   - [Web Fetch & Search](./docs/tools/web-fetch.md)
-  - [Multi-file Operations](./docs/tools/multi-file.md)
-- [**MCP Server Integration**](./docs/tools/mcp-server.md) - Extend with custom tools
-- [**Custom Extensions**](./docs/extension.md) - Build your own commands
+- [**MCP Server Integration**](./docs/tools/mcp-server.md) - Extend with custom tools.
+- [**Custom Extensions**](./docs/extensions/index.md) - Build and share your own commands.
 
 ### Advanced Topics
 
-- [**Architecture Overview**](./docs/architecture.md) - How Gemini CLI works
-- [**IDE Integration**](./docs/ide-integration.md) - VS Code companion
-- [**Sandboxing & Security**](./docs/sandbox.md) - Safe execution environments
-- [**Enterprise Deployment**](./docs/deployment.md) - Docker, system-wide config
-- [**Telemetry & Monitoring**](./docs/telemetry.md) - Usage tracking
-- [**Tools API Development**](./docs/core/tools-api.md) - Create custom tools
-
-### Configuration & Customization
-
-- [**Settings Reference**](./docs/cli/configuration.md) - All configuration options
-- [**Theme Customization**](./docs/cli/themes.md) - Visual customization
-- [**.gemini Directory**](./docs/gemini-ignore.md) - Project-specific settings
-- [**Environment Variables**](./docs/cli/configuration.md#environment-variables)
+- [**Headless Mode (Scripting)**](./docs/cli/headless.md) - Use Gemini CLI in automated workflows.
+- [**Architecture Overview**](./docs/architecture.md) - How Gemini CLI works.
+- [**IDE Integration**](./docs/ide-integration/index.md) - VS Code companion.
+- [**Sandboxing & Security**](./docs/cli/sandbox.md) - Safe execution environments.
+- [**Trusted Folders**](./docs/cli/trusted-folders.md) - Control execution policies by folder.
+- [**Enterprise Guide**](./docs/cli/enterprise.md) - Deploy and manage in a corporate environment.
+- [**Telemetry & Monitoring**](./docs/cli/telemetry.md) - Usage tracking.
+- [**Tools API Development**](./docs/core/tools-api.md) - Create custom tools.
 
 ### Troubleshooting & Support
 
-- [**Troubleshooting Guide**](./docs/troubleshooting.md) - Common issues and solutions
-- [**FAQ**](./docs/troubleshooting.md#frequently-asked-questions) - Quick answers
-- Use `/bug` command to report issues directly from the CLI
+- [**Troubleshooting Guide**](./docs/troubleshooting.md) - Common issues and solutions.
+- [**FAQ**](./docs/faq.md) - Frequently asked questions.
+- Use `/bug` command to report issues directly from the CLI.
 
 ### Using MCP Servers
 
@@ -293,25 +282,25 @@ See the [MCP Server Integration guide](./docs/tools/mcp-server.md) for setup ins
 
 We welcome contributions! Gemini CLI is fully open source (Apache 2.0), and we encourage the community to:
 
-- Report bugs and suggest features
-- Improve documentation
-- Submit code improvements
-- Share your MCP servers and extensions
+- Report bugs and suggest features.
+- Improve documentation.
+- Submit code improvements.
+- Share your MCP servers and extensions.
 
 See our [Contributing Guide](./CONTRIBUTING.md) for development setup, coding standards, and how to submit pull requests.
 
-Check our [Official Roadmap](https://github.com/orgs/google-gemini/projects/11/) for planned features and priorities.
+Check our [Official Roadmap](https://github.com/orgs/google-gemini/projects/11) for planned features and priorities.
 
 ## 📖 Resources
 
-- **[Official Roadmap](./ROADMAP.md)** - See what's coming next
-- **[NPM Package](https://www.npmjs.com/package/@google/gemini-cli)** - Package registry
-- **[GitHub Issues](https://github.com/google-gemini/gemini-cli/issues)** - Report bugs or request features
-- **[Security Advisories](https://github.com/google-gemini/gemini-cli/security/advisories)** - Security updates
+- **[Official Roadmap](./ROADMAP.md)** - See what's coming next.
+- **[NPM Package](https://www.npmjs.com/package/@google/gemini-cli)** - Package registry.
+- **[GitHub Issues](https://github.com/google-gemini/gemini-cli/issues)** - Report bugs or request features.
+- **[Security Advisories](https://github.com/google-gemini/gemini-cli/security/advisories)** - Security updates.
 
 ### Uninstall
 
-See the [Uninstall Guide](docs/Uninstall.md) for removal instructions.
+See the [Uninstall Guide](docs/cli/uninstall.md) for removal instructions.
 
 ## 📄 Legal
 

package/dist/src/agents/codebase-investigator.js

@@ -8,6 +8,7 @@ import { ReadFileTool } from '../tools/read-file.js';
 import { GLOB_TOOL_NAME } from '../tools/tool-names.js';
 import { GrepTool } from '../tools/grep.js';
 import { DEFAULT_GEMINI_MODEL } from '../config/models.js';
+import { Type } from '@google/genai';
 const CODEBASE_REPORT_MARKDOWN = `<CodebaseReport>
   <SummaryOfFindings>
     The user's objective is to remove an optional \`config\` property from the command context. The investigation identified that the \`CommandContext\` interface, defined in \`packages/cli/src/ui/commands/types.ts\`, contains a nullable \`config: Config | null\` property. A \`TODO\` comment confirms the intent to make this property non-nullable.
@@ -73,17 +74,22 @@ export const CodebaseInvestigatorAgent = {
         },
     },
     outputConfig: {
-        description: `A detailed markdown report summarizing the findings of the codebase investigation and insights that are the foundation for planning and executing any code modification related to the objective.
+        outputName: 'report',
+        description: 'The final investigation report.',
+        schema: {
+            type: Type.STRING,
+            description: `A detailed markdown report summarizing the findings of the codebase investigation and insights that are the foundation for planning and executing any code modification related to the objective.
       # Report Format
 The final report should be structured markdown, clearly answering the investigation focus, citing the files, symbols, architectural patterns and how they relate to the given investigation focus.
 The report should strictly follow a format like this example: 
 ${CODEBASE_REPORT_MARKDOWN}
+
+Completion Criteria:
+- The report must directly address the initial \`objective\`.
+- Cite specific files, functions, or configuration snippets and symbols as evidence for your findings.
+- Conclude with a xml markdown summary of the key files, symbols, technologies, architectural patterns, and conventions discovered.
 `,
-        completion_criteria: [
-            'The report must directly address the initial `objective`.',
-            'Cite specific files, functions, or configuration snippets and symbols as evidence for your findings.',
-            'Conclude with a xml markdown summary of the key files, symbols, technologies, architectural patterns, and conventions discovered.',
-        ],
+        },
     },
     modelConfig: {
         model: DEFAULT_GEMINI_MODEL,

package/dist/src/agents/codebase-investigator.js.map

@@ -1 +1 @@
-{"version":3,"file":"codebase-investigator.js","sourceRoot":"","sources":["../../../src/agents/codebase-investigator.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AACxC,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AACrD,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AACxD,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAC5C,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAE3D,MAAM,wBAAwB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA2Cf,CAAC;AAEnB;;;GAGG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAoB;IACxD,IAAI,EAAE,uBAAuB;IAC7B,WAAW,EAAE,6BAA6B;IAC1C,WAAW,EAAE;;kHAEmG;IAChH,WAAW,EAAE;QACX,MAAM,EAAE;YACN,SAAS,EAAE;gBACT,WAAW,EAAE;4HACuG;gBACpH,IAAI,EAAE,QAAQ;gBACd,QAAQ,EAAE,IAAI;aACf;SACF;KACF;IACD,YAAY,EAAE;QACZ,WAAW,EAAE;;;;EAIf,wBAAwB;CACzB;QACG,mBAAmB,EAAE;YACnB,2DAA2D;YAC3D,sGAAsG;YACtG,mIAAmI;SACpI;KACF;IAED,WAAW,EAAE;QACX,KAAK,EAAE,oBAAoB;QAC3B,IAAI,EAAE,GAAG;QACT,KAAK,EAAE,IAAI;QACX,cAAc,EAAE,CAAC,CAAC;KACnB;IAED,SAAS,EAAE;QACT,gBAAgB,EAAE,CAAC;QACnB,SAAS,EAAE,EAAE;KACd;IAED,UAAU,EAAE;QACV,wCAAwC;QACxC,KAAK,EAAE,CAAC,MAAM,CAAC,IAAI,EAAE,YAAY,CAAC,IAAI,EAAE,cAAc,EAAE,QAAQ,CAAC,IAAI,CAAC;KACvE;IAED,YAAY,EAAE;QACZ,KAAK,EAAE;;;aAGE;QACT,YAAY,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqDhB,wBAAwB;CACzB;KACE;CACF,CAAC"}
+{"version":3,"file":"codebase-investigator.js","sourceRoot":"","sources":["../../../src/agents/codebase-investigator.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AACxC,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AACrD,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AACxD,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAC5C,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAC3D,OAAO,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAErC,MAAM,wBAAwB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA2Cf,CAAC;AAEnB;;;GAGG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAoB;IACxD,IAAI,EAAE,uBAAuB;IAC7B,WAAW,EAAE,6BAA6B;IAC1C,WAAW,EAAE;;kHAEmG;IAChH,WAAW,EAAE;QACX,MAAM,EAAE;YACN,SAAS,EAAE;gBACT,WAAW,EAAE;4HACuG;gBACpH,IAAI,EAAE,QAAQ;gBACd,QAAQ,EAAE,IAAI;aACf;SACF;KACF;IACD,YAAY,EAAE;QACZ,UAAU,EAAE,QAAQ;QACpB,WAAW,EAAE,iCAAiC;QAC9C,MAAM,EAAE;YACN,IAAI,EAAE,IAAI,CAAC,MAAM;YACjB,WAAW,EAAE;;;;EAIjB,wBAAwB;;;;;;CAMzB;SACI;KACF;IAED,WAAW,EAAE;QACX,KAAK,EAAE,oBAAoB;QAC3B,IAAI,EAAE,GAAG;QACT,KAAK,EAAE,IAAI;QACX,cAAc,EAAE,CAAC,CAAC;KACnB;IAED,SAAS,EAAE;QACT,gBAAgB,EAAE,CAAC;QACnB,SAAS,EAAE,EAAE;KACd;IAED,UAAU,EAAE;QACV,wCAAwC;QACxC,KAAK,EAAE,CAAC,MAAM,CAAC,IAAI,EAAE,YAAY,CAAC,IAAI,EAAE,cAAc,EAAE,QAAQ,CAAC,IAAI,CAAC;KACvE;IAED,YAAY,EAAE;QACZ,KAAK,EAAE;;;aAGE;QACT,YAAY,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqDhB,wBAAwB;CACzB;KACE;CACF,CAAC"}

package/dist/src/agents/executor.d.ts

@@ -10,11 +10,8 @@ export type ActivityCallback = (activity: SubagentActivityEvent) => void;
 /**
  * Executes an agent loop based on an {@link AgentDefinition}.
  *
- * This executor uses a simplified two-phase approach:
- * 1.  **Work Phase:** The agent runs in a loop, calling tools until it has
- * gathered all necessary information to fulfill its goal.
- * 2.  **Extraction Phase:** A final prompt is sent to the model to summarize
- * the work and extract the final result in the desired format.
+ * This executor runs the agent in a loop, calling tools until it calls the
+ * mandatory `complete_task` tool to signal completion.
  */
 export declare class AgentExecutor {
     readonly definition: AgentDefinition;
@@ -60,7 +57,7 @@ export declare class AgentExecutor {
     /**
      * Executes function calls requested by the model and returns the results.
      *
-     * @returns A new `Content` object to be added to the chat history.
+     * @returns A new `Content` object for history, any submitted output, and completion status.
      */
     private processFunctionCalls;
     /**
@@ -69,8 +66,6 @@ export declare class AgentExecutor {
     private prepareToolsList;
     /** Builds the system prompt from the agent definition and inputs. */
     private buildSystemPrompt;
-    /** Builds the final message for the extraction phase. */
-    private buildExtractionMessage;
     /**
      * Applies template strings to initial messages.
      *

package/dist/src/agents/executor.js

@@ -5,6 +5,7 @@
  */
 import { reportError } from '../utils/errorReporting.js';
 import { GeminiChat, StreamEventType } from '../core/geminiChat.js';
+import { Type } from '@google/genai';
 import { executeToolCall } from '../core/nonInteractiveToolExecutor.js';
 import { ToolRegistry } from '../tools/tool-registry.js';
 import { getDirectoryContextString } from '../utils/environmentContext.js';
@@ -19,14 +20,12 @@ import { WebSearchTool } from '../tools/web-search.js';
 import { AgentTerminateMode } from './types.js';
 import { templateString } from './utils.js';
 import { parseThought } from '../utils/thoughtUtils.js';
+const TASK_COMPLETE_TOOL_NAME = 'complete_task';
 /**
  * Executes an agent loop based on an {@link AgentDefinition}.
  *
- * This executor uses a simplified two-phase approach:
- * 1.  **Work Phase:** The agent runs in a loop, calling tools until it has
- * gathered all necessary information to fulfill its goal.
- * 2.  **Extraction Phase:** A final prompt is sent to the model to summarize
- * the work and extract the final result in the desired format.
+ * This executor runs the agent in a loop, calling tools until it calls the
+ * mandatory `complete_task` tool to signal completion.
  */
 export class AgentExecutor {
     definition;
@@ -100,15 +99,12 @@ export class AgentExecutor {
         try {
             const chat = await this.createChatObject(inputs);
             const tools = this.prepareToolsList();
-            let terminateReason = AgentTerminateMode.GOAL;
-            // Phase 1: Work Phase
-            // The agent works in a loop until it stops calling tools.
+            let terminateReason = AgentTerminateMode.ERROR;
+            let finalResult = null;
             const query = this.definition.promptConfig.query
                 ? templateString(this.definition.promptConfig.query, inputs)
                 : 'Get Started!';
-            let currentMessages = [
-                { role: 'user', parts: [{ text: query }] },
-            ];
+            let currentMessage = { role: 'user', parts: [{ text: query }] };
             while (true) {
                 // Check for termination conditions like max turns or timeout.
                 const reason = this.checkTermination(startTime, turnCounter);
@@ -122,36 +118,37 @@ export class AgentExecutor {
                 }
                 // Call model
                 const promptId = `${this.runtimeContext.getSessionId()}#${this.agentId}#${turnCounter++}`;
-                const { functionCalls } = await this.callModel(chat, currentMessages, tools, signal, promptId);
+                const { functionCalls } = await this.callModel(chat, currentMessage, tools, signal, promptId);
                 if (signal.aborted) {
                     terminateReason = AgentTerminateMode.ABORTED;
                     break;
                 }
-                // If the model stops calling tools, the work phase is complete.
+                // If the model stops calling tools without calling complete_task, it's an error.
                 if (functionCalls.length === 0) {
+                    terminateReason = AgentTerminateMode.ERROR;
+                    finalResult = `Agent stopped calling tools but did not call '${TASK_COMPLETE_TOOL_NAME}' to finalize the session.`;
+                    this.emitActivity('ERROR', {
+                        error: finalResult,
+                        context: 'protocol_violation',
+                    });
                     break;
                 }
-                currentMessages = await this.processFunctionCalls(functionCalls, signal, promptId);
+                const { nextMessage, submittedOutput, taskCompleted } = await this.processFunctionCalls(functionCalls, signal, promptId);
+                if (taskCompleted) {
+                    finalResult = submittedOutput ?? 'Task completed successfully.';
+                    terminateReason = AgentTerminateMode.GOAL;
+                    break;
+                }
+                currentMessage = nextMessage;
             }
-            // If the work phase was terminated early, skip extraction and return.
-            if (terminateReason !== AgentTerminateMode.GOAL) {
+            if (terminateReason === AgentTerminateMode.GOAL) {
                 return {
-                    result: 'Agent execution was terminated before completion.',
+                    result: finalResult || 'Task completed.',
                     terminate_reason: terminateReason,
                 };
             }
-            // Phase 2: Extraction Phase
-            // A final message is sent to summarize findings and produce the output.
-            const extractionMessage = this.buildExtractionMessage();
-            const extractionMessages = [
-                { role: 'user', parts: [{ text: extractionMessage }] },
-            ];
-            const extractionPromptId = `${this.runtimeContext.getSessionId()}#${this.agentId}#extraction`;
-            // TODO: Consider if we should keep tools to avoid cache reset.
-            const { textResponse } = await this.callModel(chat, extractionMessages, [], // No tools are available in the extraction phase.
-            signal, extractionPromptId);
             return {
-                result: textResponse || 'No response generated',
+                result: finalResult || 'Agent execution was terminated before completion.',
                 terminate_reason: terminateReason,
             };
         }
@@ -165,9 +162,9 @@ export class AgentExecutor {
      *
      * @returns The model's response, including any tool calls or text.
      */
-    async callModel(chat, messages, tools, signal, promptId) {
+    async callModel(chat, message, tools, signal, promptId) {
         const messageParams = {
-            message: messages[0]?.parts || [],
+            message: message.parts || [],
             config: {
                 abortSignal: signal,
                 tools: tools.length > 0 ? [{ functionDeclarations: tools }] : undefined,
@@ -237,68 +234,171 @@ export class AgentExecutor {
     /**
      * Executes function calls requested by the model and returns the results.
      *
-     * @returns A new `Content` object to be added to the chat history.
+     * @returns A new `Content` object for history, any submitted output, and completion status.
      */
     async processFunctionCalls(functionCalls, signal, promptId) {
         const allowedToolNames = new Set(this.toolRegistry.getAllToolNames());
-        // Filter out any tool calls that are not in the agent's allowed list.
-        const validatedFunctionCalls = functionCalls.filter((call) => {
-            if (!allowedToolNames.has(call.name)) {
-                console.warn(`[AgentExecutor] Agent '${this.definition.name}' attempted to call ` +
-                    `unauthorized tool '${call.name}'. This call has been blocked.`);
-                return false;
-            }
-            return true;
-        });
-        const toolPromises = validatedFunctionCalls.map(async (functionCall, index) => {
+        // Always allow the completion tool
+        allowedToolNames.add(TASK_COMPLETE_TOOL_NAME);
+        let submittedOutput = null;
+        let taskCompleted = false;
+        // We'll collect promises for the tool executions
+        const toolExecutionPromises = [];
+        // And we'll need a place to store the synchronous results (like complete_task or blocked calls)
+        const syncResponseParts = [];
+        for (const [index, functionCall] of functionCalls.entries()) {
             const callId = functionCall.id ?? `${promptId}-${index}`;
-            const args = functionCall.args ?? {};
+            const args = (functionCall.args ?? {});
             this.emitActivity('TOOL_CALL_START', {
                 name: functionCall.name,
                 args,
             });
+            if (functionCall.name === TASK_COMPLETE_TOOL_NAME) {
+                if (taskCompleted) {
+                    // We already have a completion from this turn. Ignore subsequent ones.
+                    const error = 'Task already marked complete in this turn. Ignoring duplicate call.';
+                    syncResponseParts.push({
+                        functionResponse: {
+                            name: TASK_COMPLETE_TOOL_NAME,
+                            response: { error },
+                            id: callId,
+                        },
+                    });
+                    this.emitActivity('ERROR', {
+                        context: 'tool_call',
+                        name: functionCall.name,
+                        error,
+                    });
+                    continue;
+                }
+                const { outputConfig } = this.definition;
+                taskCompleted = true; // Signal completion regardless of output presence
+                if (outputConfig) {
+                    const outputName = outputConfig.outputName;
+                    if (args[outputName] !== undefined) {
+                        submittedOutput = String(args[outputName]);
+                        syncResponseParts.push({
+                            functionResponse: {
+                                name: TASK_COMPLETE_TOOL_NAME,
+                                response: { result: 'Output submitted and task completed.' },
+                                id: callId,
+                            },
+                        });
+                        this.emitActivity('TOOL_CALL_END', {
+                            name: functionCall.name,
+                            output: 'Output submitted and task completed.',
+                        });
+                    }
+                    else {
+                        // Failed to provide required output.
+                        taskCompleted = false; // Revoke completion status
+                        const error = `Missing required argument '${outputName}' for completion.`;
+                        syncResponseParts.push({
+                            functionResponse: {
+                                name: TASK_COMPLETE_TOOL_NAME,
+                                response: { error },
+                                id: callId,
+                            },
+                        });
+                        this.emitActivity('ERROR', {
+                            context: 'tool_call',
+                            name: functionCall.name,
+                            error,
+                        });
+                    }
+                }
+                else {
+                    // No output expected. Just signal completion.
+                    submittedOutput = 'Task completed successfully.';
+                    syncResponseParts.push({
+                        functionResponse: {
+                            name: TASK_COMPLETE_TOOL_NAME,
+                            response: { status: 'Task marked complete.' },
+                            id: callId,
+                        },
+                    });
+                    this.emitActivity('TOOL_CALL_END', {
+                        name: functionCall.name,
+                        output: 'Task marked complete.',
+                    });
+                }
+                continue;
+            }
+            // Handle standard tools
+            if (!allowedToolNames.has(functionCall.name)) {
+                const error = `Unauthorized tool call: '${functionCall.name}' is not available to this agent.`;
+                console.warn(`[AgentExecutor] Blocked call: ${error}`);
+                syncResponseParts.push({
+                    functionResponse: {
+                        name: functionCall.name,
+                        id: callId,
+                        response: { error },
+                    },
+                });
+                this.emitActivity('ERROR', {
+                    context: 'tool_call_unauthorized',
+                    name: functionCall.name,
+                    callId,
+                    error,
+                });
+                continue;
+            }
             const requestInfo = {
                 callId,
                 name: functionCall.name,
-                args: args,
+                args,
                 isClientInitiated: true,
                 prompt_id: promptId,
             };
-            const toolResponse = await executeToolCall(this.runtimeContext, requestInfo, signal);
-            if (toolResponse.error) {
-                this.emitActivity('ERROR', {
-                    context: 'tool_call',
-                    name: functionCall.name,
-                    error: toolResponse.error.message,
-                });
-            }
-            else {
-                this.emitActivity('TOOL_CALL_END', {
-                    name: functionCall.name,
-                    output: toolResponse.resultDisplay,
-                });
+            // Create a promise for the tool execution
+            const executionPromise = (async () => {
+                const toolResponse = await executeToolCall(this.runtimeContext, requestInfo, signal);
+                if (toolResponse.error) {
+                    this.emitActivity('ERROR', {
+                        context: 'tool_call',
+                        name: functionCall.name,
+                        error: toolResponse.error.message,
+                    });
+                }
+                else {
+                    this.emitActivity('TOOL_CALL_END', {
+                        name: functionCall.name,
+                        output: toolResponse.resultDisplay,
+                    });
+                }
+                return toolResponse.responseParts;
+            })();
+            toolExecutionPromises.push(executionPromise);
+        }
+        // Wait for all tool executions to complete
+        const asyncResults = await Promise.all(toolExecutionPromises);
+        // Combine all response parts
+        const toolResponseParts = [...syncResponseParts];
+        for (const result of asyncResults) {
+            if (result) {
+                toolResponseParts.push(...result);
             }
-            return toolResponse;
-        });
-        const toolResponses = await Promise.all(toolPromises);
-        const toolResponseParts = toolResponses
-            .flatMap((response) => response.responseParts)
-            .filter((part) => part !== undefined);
-        // If all authorized tool calls failed, provide a generic error message
-        // to the model so it can try a different approach.
-        if (functionCalls.length > 0 && toolResponseParts.length === 0) {
+        }
+        // If all authorized tool calls failed (and task isn't complete), provide a generic error.
+        if (functionCalls.length > 0 &&
+            toolResponseParts.length === 0 &&
+            !taskCompleted) {
             toolResponseParts.push({
-                text: 'All tool calls failed. Please analyze the errors and try an alternative approach.',
+                text: 'All tool calls failed or were unauthorized. Please analyze the errors and try an alternative approach.',
             });
         }
-        return [{ role: 'user', parts: toolResponseParts }];
+        return {
+            nextMessage: { role: 'user', parts: toolResponseParts },
+            submittedOutput,
+            taskCompleted,
+        };
     }
     /**
      * Prepares the list of tool function declarations to be sent to the model.
      */
     prepareToolsList() {
         const toolsList = [];
-        const { toolConfig } = this.definition;
+        const { toolConfig, outputConfig } = this.definition;
         if (toolConfig) {
             const toolNamesToLoad = [];
             for (const toolRef of toolConfig.tools) {
@@ -317,11 +417,32 @@ export class AgentExecutor {
             // Add schemas from tools that were registered by name.
             toolsList.push(...this.toolRegistry.getFunctionDeclarationsFiltered(toolNamesToLoad));
         }
+        // Always inject complete_task.
+        // Configure its schema based on whether output is expected.
+        const completeTool = {
+            name: TASK_COMPLETE_TOOL_NAME,
+            description: outputConfig
+                ? 'Call this tool to submit your final answer and complete the task. This is the ONLY way to finish.'
+                : 'Call this tool to signal that you have completed your task. This is the ONLY way to finish.',
+            parameters: {
+                type: Type.OBJECT,
+                properties: {},
+                required: [],
+            },
+        };
+        if (outputConfig) {
+            completeTool.parameters.properties[outputConfig.outputName] = {
+                description: outputConfig.description,
+                ...(outputConfig.schema ?? { type: Type.STRING }),
+            };
+            completeTool.parameters.required.push(outputConfig.outputName);
+        }
+        toolsList.push(completeTool);
         return toolsList;
     }
     /** Builds the system prompt from the agent definition and inputs. */
     async buildSystemPrompt(inputs) {
-        const { promptConfig, outputConfig } = this.definition;
+        const { promptConfig } = this.definition;
         if (!promptConfig.systemPrompt) {
             return '';
         }
@@ -330,38 +451,18 @@ export class AgentExecutor {
         // Append environment context (CWD and folder structure).
         const dirContext = await getDirectoryContextString(this.runtimeContext);
         finalPrompt += `\n\n# Environment Context\n${dirContext}`;
-        // Append completion criteria to guide the model's output.
-        if (outputConfig?.completion_criteria) {
-            finalPrompt += '\n\nEnsure you complete the following:\n';
-            for (const criteria of outputConfig.completion_criteria) {
-                finalPrompt += `- ${criteria}\n`;
-            }
-        }
         // Append standard rules for non-interactive execution.
         finalPrompt += `
 Important Rules:
 * You are running in a non-interactive mode. You CANNOT ask the user for input or clarification.
 * Work systematically using available tools to complete your task.
-* Always use absolute paths for file operations. Construct them using the provided "Environment Context".
-* When you have completed your analysis and are ready to produce the final answer, stop calling tools.`;
+* Always use absolute paths for file operations. Construct them using the provided "Environment Context".`;
+        finalPrompt += `
+* When you have completed your task, you MUST call the \`${TASK_COMPLETE_TOOL_NAME}\` tool.
+* Do not call any other tools in the same turn as \`${TASK_COMPLETE_TOOL_NAME}\`.
+* This is the ONLY way to complete your mission. If you stop calling tools without calling this, you have failed.`;
         return finalPrompt;
     }
-    /** Builds the final message for the extraction phase. */
-    buildExtractionMessage() {
-        const { outputConfig } = this.definition;
-        if (outputConfig?.description) {
-            let message = `Based on your work so far, provide: ${outputConfig.description}`;
-            if (outputConfig.completion_criteria?.length) {
-                message += `\n\nBe sure you have addressed:\n`;
-                for (const criteria of outputConfig.completion_criteria) {
-                    message += `- ${criteria}\n`;
-                }
-            }
-            return message;
-        }
-        // Fallback to a generic extraction message if no description is provided.
-        return 'Based on your work so far, provide a comprehensive summary of your analysis and findings. Do not perform any more function calls.';
-    }
     /**
      * Applies template strings to initial messages.
      *