@machina.ai/cell-cli-core 1.36.0-rc1 → 1.38.1-rc2

package/dist/src/agents/local-executor.js

@@ -6,7 +6,7 @@
 import {} from '../config/agent-loop-context.js';
 import { reportError } from '../utils/errorReporting.js';
 import { GeminiChat, StreamEventType } from '../core/geminiChat.js';
-import { Type, } from '@google/genai';
+import {} from '@google/genai';
 import { ToolRegistry } from '../tools/tool-registry.js';
 import { PromptRegistry } from '../prompts/prompt-registry.js';
 import { ResourceRegistry } from '../resources/resource-registry.js';
@@ -14,9 +14,9 @@ import { ToolConfirmationOutcome, } from '../tools/tools.js';
 import { DiscoveredMCPTool, isMcpToolName, parseMcpToolName, MCP_TOOL_PREFIX, } from '../tools/mcp-tool.js';
 import { CompressionStatus } from '../core/turn.js';
 import {} from '../scheduler/types.js';
-import { ChatCompressionService } from '../services/chatCompressionService.js';
+import { ChatCompressionService } from '../context/chatCompressionService.js';
 import { getDirectoryContextString } from '../utils/environmentContext.js';
-import { renderUserMemory } from '../prompts/snippets.js';
+import { renderUserMemory, renderAgentSkills } from '../prompts/snippets.js';
 import { promptIdContext } from '../utils/promptIdContext.js';
 import { logAgentStart, logAgentFinish, logRecoveryAttempt, } from '../telemetry/loggers.js';
 import { AgentStartEvent, AgentFinishEvent, LlmRole, RecoveryAttemptEvent, } from '../telemetry/types.js';
@@ -26,7 +26,6 @@ import { templateString } from './utils.js';
 import { DEFAULT_GEMINI_MODEL, isAutoModel } from '../config/models.js';
 import { parseThought } from '../utils/thoughtUtils.js';
 import {} from 'zod';
-import { zodToJsonSchema } from 'zod-to-json-schema';
 import { debugLogger } from '../utils/debugLogger.js';
 import { getModelConfigAlias } from './registry.js';
 import { getVersion } from '../utils/version.js';
@@ -34,7 +33,9 @@ import { getToolCallContext } from '../utils/toolCallContext.js';
 import { scheduleAgentTools } from './agent-scheduler.js';
 import { DeadlineTimer } from '../utils/deadlineTimer.js';
 import { formatUserHintsForModel, formatBackgroundCompletionForModel, } from '../utils/fastAckHelper.js';
-const TASK_COMPLETE_TOOL_NAME = 'complete_task';
+import { createScopedWorkspaceContext, runWithScopedWorkspaceContext, } from '../config/scoped-config.js';
+import { CompleteTaskTool } from '../tools/complete-task.js';
+import { COMPLETE_TASK_TOOL_NAME, ACTIVATE_SKILL_TOOL_NAME, } from '../tools/definitions/base-declarations.js';
 const GRACE_PERIOD_MS = 60 * 1000; // 1 min
 export function createUnauthorizedToolError(toolName) {
     return `Unauthorized tool call: '${toolName}' is not available to this agent.`;
@@ -59,7 +60,8 @@ export class LocalAgentExecutor {
     get executionContext() {
         return {
             config: this.context.config,
-            promptId: this.context.promptId,
+            promptId: this.agentId,
+            parentSessionId: this.context.parentSessionId || this.context.promptId, // Always preserve the main agent session ID
             geminiClient: this.context.geminiClient,
             sandboxManager: this.context.sandboxManager,
             toolRegistry: this.toolRegistry,
@@ -166,12 +168,12 @@ export class LocalAgentExecutor {
             }
         }
         agentToolRegistry.sortTools();
-        // Get the parent prompt ID from context
-        const parentPromptId = context.promptId;
+        // Register the mandatory completion tool for this agent.
+        agentToolRegistry.registerTool(new CompleteTaskTool(subagentMessageBus, definition.outputConfig, definition.processOutput));
         // Get the parent tool call ID from context
         const toolContext = getToolCallContext();
         const parentCallId = toolContext?.callId;
-        return new LocalAgentExecutor(definition, context, parentPromptId, agentToolRegistry, agentPromptRegistry, agentResourceRegistry, onActivity, parentCallId);
+        return new LocalAgentExecutor(definition, context, agentToolRegistry, agentPromptRegistry, agentResourceRegistry, onActivity, parentCallId);
     }
     /**
      * Constructs a new AgentExecutor instance.
@@ -179,7 +181,7 @@ export class LocalAgentExecutor {
      * @private This constructor is private. Use the static `create` method to
      * instantiate the class.
      */
-    constructor(definition, context, parentPromptId, toolRegistry, promptRegistry, resourceRegistry, onActivity, parentCallId) {
+    constructor(definition, context, toolRegistry, promptRegistry, resourceRegistry, onActivity, parentCallId) {
         this.definition = definition;
         this.context = context;
         this.toolRegistry = toolRegistry;
@@ -188,11 +190,7 @@ export class LocalAgentExecutor {
         this.onActivity = onActivity;
         this.compressionService = new ChatCompressionService();
         this.parentCallId = parentCallId;
-        const randomIdPart = Math.random().toString(36).slice(2, 8);
-        // parentPromptId will be undefined if this agent is invoked directly
-        // (top-level), rather than as a sub-agent.
-        const parentPrefix = parentPromptId ? `${parentPromptId}-` : '';
-        this.agentId = `${parentPrefix}${this.definition.name}-${randomIdPart}`;
+        this.agentId = Math.random().toString(36).slice(2, 8);
     }
     /**
      * Executes a single turn of the agent's logic, from calling the model
@@ -204,8 +202,11 @@ export class LocalAgentExecutor {
     async executeTurn(chat, currentMessage, turnCounter, combinedSignal, timeoutSignal, // Pass the timeout controller's signal
     onWaitingForConfirmation) {
         const promptId = `${this.agentId}#${turnCounter}`;
-        await this.tryCompressChat(chat, promptId);
-        const { functionCalls } = await promptIdContext.run(promptId, async () => this.callModel(chat, currentMessage, combinedSignal, promptId));
+        await this.tryCompressChat(chat, promptId, combinedSignal);
+        // Allow the agent definition to modify history before the model call
+        // (e.g., superseding stale tool outputs to reclaim context tokens).
+        await this.definition.onBeforeTurn?.(chat, combinedSignal);
+        const { functionCalls, modelToUse } = await promptIdContext.run(promptId, async () => this.callModel(chat, currentMessage, combinedSignal, promptId));
         if (combinedSignal.aborted) {
             const terminateReason = timeoutSignal.aborted
                 ? AgentTerminateMode.TIMEOUT
@@ -219,7 +220,7 @@ export class LocalAgentExecutor {
         // If the model stops calling tools without calling complete_task, it's an error.
         if (functionCalls.length === 0) {
             this.emitActivity('ERROR', {
-                error: `Agent stopped calling tools but did not call '${TASK_COMPLETE_TOOL_NAME}' to finalize the session.`,
+                error: `Agent stopped calling tools but did not call '${COMPLETE_TASK_TOOL_NAME}' to finalize the session.`,
                 context: 'protocol_violation',
                 errorType: SubagentActivityErrorType.GENERIC,
             });
@@ -229,7 +230,7 @@ export class LocalAgentExecutor {
                 finalResult: null,
             };
         }
-        const { nextMessage, submittedOutput, taskCompleted, aborted } = await this.processFunctionCalls(functionCalls, combinedSignal, promptId, onWaitingForConfirmation);
+        const { nextMessage, submittedOutput, taskCompleted, aborted } = await this.processFunctionCalls(chat, modelToUse, functionCalls, combinedSignal, promptId, onWaitingForConfirmation);
         if (aborted) {
             return {
                 status: 'stop',
@@ -269,7 +270,7 @@ export class LocalAgentExecutor {
             default:
                 throw new Error(`Unknown terminate reason: ${reason}`);
         }
-        return `${explanation} You have one final chance to complete the task with a short grace period. You MUST call \`${TASK_COMPLETE_TOOL_NAME}\` immediately with your best answer and explain that your investigation was interrupted. Do not call any other tools.`;
+        return `${explanation} You have one final chance to complete the task with a short grace period. You MUST call \`${COMPLETE_TASK_TOOL_NAME}\` immediately with your best answer and explain that your investigation was interrupted. Do not call any other tools.`;
     }
     /**
      * Attempts a single, final recovery turn if the agent stops for a recoverable reason.
@@ -339,6 +340,18 @@ export class LocalAgentExecutor {
      * @returns A promise that resolves to the agent's final output.
      */
     async run(inputs, signal) {
+        // If the agent definition declares additional workspace directories,
+        // wrap execution in a scoped workspace context. All calls to
+        // Config.getWorkspaceContext() within this scope will see the extended
+        // directories, without mutating the shared Config.
+        const dirs = this.definition.workspaceDirectories;
+        if (dirs && dirs.length > 0) {
+            const scopedCtx = createScopedWorkspaceContext(this.context.config.getWorkspaceContext(), dirs);
+            return runWithScopedWorkspaceContext(scopedCtx, () => this.runInternal(inputs, signal));
+        }
+        return this.runInternal(inputs, signal);
+    }
+    async runInternal(inputs, signal) {
         const startTime = Date.now();
         let turnCounter = 0;
         let terminateReason = AgentTerminateMode.ERROR;
@@ -502,7 +515,7 @@ export class LocalAgentExecutor {
                         // The finalResult was already set by executeTurn, but we re-emit just in case.
                         finalResult =
                             finalResult ||
-                                `Agent stopped calling tools but did not call '${TASK_COMPLETE_TOOL_NAME}'.`;
+                                `Agent stopped calling tools but did not call '${COMPLETE_TASK_TOOL_NAME}'.`;
                         this.emitActivity('ERROR', {
                             error: finalResult,
                             context: 'protocol_violation',
@@ -511,8 +524,17 @@ export class LocalAgentExecutor {
                     }
                 }
             }
-            // === FINAL RETURN LOGIC ===
             if (terminateReason === AgentTerminateMode.GOAL) {
+                // Save the session summary upon completion
+                if (finalResult && chat) {
+                    try {
+                        const summary = this.getTruncatedSummary(finalResult);
+                        chat.getChatRecordingService()?.saveSummary(summary);
+                    }
+                    catch (error) {
+                        debugLogger.warn('Failed to save subagent session summary.', error);
+                    }
+                }
                 return {
                     result: finalResult || 'Task completed.',
                     terminate_reason: terminateReason,
@@ -539,6 +561,14 @@ export class LocalAgentExecutor {
                         // Recovery Succeeded
                         terminateReason = AgentTerminateMode.GOAL;
                         finalResult = recoveryResult;
+                        // Save the session summary upon successful recovery
+                        try {
+                            const summary = this.getTruncatedSummary(finalResult);
+                            chat.getChatRecordingService()?.saveSummary(summary);
+                        }
+                        catch (summaryError) {
+                            debugLogger.warn('Failed to save subagent session summary during recovery.', summaryError);
+                        }
                         return {
                             result: finalResult,
                             terminate_reason: terminateReason,
@@ -568,9 +598,9 @@ export class LocalAgentExecutor {
             logAgentFinish(this.context.config, new AgentFinishEvent(this.agentId, this.definition.name, Date.now() - startTime, turnCounter, terminateReason));
         }
     }
-    async tryCompressChat(chat, prompt_id) {
+    async tryCompressChat(chat, prompt_id, abortSignal) {
         const model = this.definition.modelConfig.model ?? DEFAULT_GEMINI_MODEL;
-        const { newHistory, info } = await this.compressionService.compress(chat, prompt_id, false, model, this.context.config, this.hasFailedCompressionAttempt);
+        const { newHistory, info } = await this.compressionService.compress(chat, prompt_id, false, model, this.context.config, this.hasFailedCompressionAttempt, abortSignal);
         if (info.compressionStatus ===
             CompressionStatus.COMPRESSION_FAILED_INFLATED_TOKEN_COUNT) {
             this.hasFailedCompressionAttempt = true;
@@ -661,7 +691,7 @@ export class LocalAgentExecutor {
                 }
             }
         }
-        return { functionCalls, textResponse };
+        return { functionCalls, textResponse, modelToUse };
     }
     /** Initializes a `GeminiChat` instance for the agent run. */
     async createChatObject(inputs, tools) {
@@ -688,22 +718,37 @@ export class LocalAgentExecutor {
      *
      * @returns A new `Content` object for history, any submitted output, and completion status.
      */
-    async processFunctionCalls(functionCalls, signal, promptId, onWaitingForConfirmation) {
+    async processFunctionCalls(chat, model, functionCalls, signal, promptId, onWaitingForConfirmation) {
         const allowedToolNames = new Set(this.toolRegistry.getAllToolNames());
-        // Always allow the completion tool
-        allowedToolNames.add(TASK_COMPLETE_TOOL_NAME);
         let submittedOutput = null;
         let taskCompleted = false;
         let aborted = false;
-        // We'll separate complete_task from other tools
         const toolRequests = [];
         // Map to keep track of tool name by callId for activity emission
         const toolNameMap = new Map();
-        // Synchronous results (like complete_task or unauthorized calls)
+        // Synchronous results (like unauthorized calls)
         const syncResults = new Map();
         for (const [index, functionCall] of functionCalls.entries()) {
             const callId = functionCall.id ?? `${promptId}-${index}`;
-            const args = functionCall.args ?? {};
+            const { args, error: parseError } = this.parseToolArguments(functionCall);
+            if (parseError) {
+                debugLogger.warn(`[LocalAgentExecutor] ${parseError}`);
+                syncResults.set(callId, {
+                    functionResponse: {
+                        name: functionCall.name,
+                        id: callId,
+                        response: { error: parseError },
+                    },
+                });
+                this.emitActivity('ERROR', {
+                    context: 'tool_call',
+                    name: functionCall.name,
+                    callId,
+                    error: parseError,
+                    errorType: SubagentActivityErrorType.GENERIC,
+                });
+                continue;
+            }
             // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
             const toolName = functionCall.name;
             let displayName = toolName;
@@ -726,139 +771,7 @@ export class LocalAgentExecutor {
                 args,
                 callId,
             });
-            if (toolName === TASK_COMPLETE_TOOL_NAME) {
-                if (taskCompleted) {
-                    const error = 'Task already marked complete in this turn. Ignoring duplicate call.';
-                    syncResults.set(callId, {
-                        functionResponse: {
-                            name: TASK_COMPLETE_TOOL_NAME,
-                            response: { error },
-                            id: callId,
-                        },
-                    });
-                    this.emitActivity('ERROR', {
-                        context: 'tool_call',
-                        name: toolName,
-                        error,
-                        errorType: SubagentActivityErrorType.GENERIC,
-                    });
-                    continue;
-                }
-                const { outputConfig } = this.definition;
-                taskCompleted = true; // Signal completion regardless of output presence
-                if (outputConfig) {
-                    const outputName = outputConfig.outputName;
-                    if (args[outputName] !== undefined) {
-                        const outputValue = args[outputName];
-                        const validationResult = outputConfig.schema.safeParse(outputValue);
-                        if (!validationResult.success) {
-                            taskCompleted = false; // Validation failed, revoke completion
-                            const error = `Output validation failed: ${JSON.stringify(validationResult.error.flatten())}`;
-                            syncResults.set(callId, {
-                                functionResponse: {
-                                    name: TASK_COMPLETE_TOOL_NAME,
-                                    response: { error },
-                                    id: callId,
-                                },
-                            });
-                            this.emitActivity('ERROR', {
-                                context: 'tool_call',
-                                name: toolName,
-                                error,
-                                errorType: SubagentActivityErrorType.GENERIC,
-                            });
-                            continue;
-                        }
-                        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-                        const validatedOutput = validationResult.data;
-                        if (this.definition.processOutput) {
-                            submittedOutput = this.definition.processOutput(validatedOutput);
-                        }
-                        else {
-                            submittedOutput =
-                                typeof outputValue === 'string'
-                                    ? outputValue
-                                    : JSON.stringify(outputValue, null, 2);
-                        }
-                        syncResults.set(callId, {
-                            functionResponse: {
-                                name: TASK_COMPLETE_TOOL_NAME,
-                                response: { result: 'Output submitted and task completed.' },
-                                id: callId,
-                            },
-                        });
-                        this.emitActivity('TOOL_CALL_END', {
-                            name: toolName,
-                            id: callId,
-                            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.`;
-                        syncResults.set(callId, {
-                            functionResponse: {
-                                name: TASK_COMPLETE_TOOL_NAME,
-                                response: { error },
-                                id: callId,
-                            },
-                        });
-                        this.emitActivity('ERROR', {
-                            context: 'tool_call',
-                            name: toolName,
-                            callId,
-                            error,
-                            errorType: SubagentActivityErrorType.GENERIC,
-                        });
-                    }
-                }
-                else {
-                    // No outputConfig - use default 'result' parameter
-                    const resultArg = args['result'];
-                    if (resultArg !== undefined &&
-                        resultArg !== null &&
-                        resultArg !== '') {
-                        submittedOutput =
-                            typeof resultArg === 'string'
-                                ? resultArg
-                                : JSON.stringify(resultArg, null, 2);
-                        syncResults.set(callId, {
-                            functionResponse: {
-                                name: TASK_COMPLETE_TOOL_NAME,
-                                response: { status: 'Result submitted and task completed.' },
-                                id: callId,
-                            },
-                        });
-                        this.emitActivity('TOOL_CALL_END', {
-                            name: toolName,
-                            id: callId,
-                            output: 'Result submitted and task completed.',
-                        });
-                    }
-                    else {
-                        // No result provided - this is an error for agents expected to return results
-                        taskCompleted = false; // Revoke completion
-                        const error = 'Missing required "result" argument. You must provide your findings when calling complete_task.';
-                        syncResults.set(callId, {
-                            functionResponse: {
-                                name: TASK_COMPLETE_TOOL_NAME,
-                                response: { error },
-                                id: callId,
-                            },
-                        });
-                        this.emitActivity('ERROR', {
-                            context: 'tool_call',
-                            name: toolName,
-                            callId,
-                            error,
-                            errorType: SubagentActivityErrorType.GENERIC,
-                        });
-                    }
-                }
-                continue;
-            }
-            // Handle standard tools
+            // Handle unauthorized tools
             if (!allowedToolNames.has(toolName)) {
                 const error = createUnauthorizedToolError(toolName);
                 debugLogger.warn(`[LocalAgentExecutor] Blocked call: ${error}`);
@@ -899,6 +812,8 @@ export class LocalAgentExecutor {
                 signal,
                 onWaitingForConfirmation,
             });
+            // Record completed tool calls for persistent chat history
+            chat.recordCompletedToolCalls(model, completedCalls);
             for (const call of completedCalls) {
                 const toolName = toolNameMap.get(call.request.callId) || call.request.name;
                 if (call.status === 'success') {
@@ -908,6 +823,18 @@ export class LocalAgentExecutor {
                         output: call.response.resultDisplay,
                         data: call.response.data,
                     });
+                    // Check if this was a completion tool call
+                    const isCompletionTool = call.request.name === COMPLETE_TASK_TOOL_NAME;
+                    const data = call.response.data;
+                    if (isCompletionTool &&
+                        !taskCompleted &&
+                        data?.['taskCompleted'] === true) {
+                        taskCompleted = true;
+                        const output = data['submittedOutput'];
+                        if (typeof output === 'string') {
+                            submittedOutput = output;
+                        }
+                    }
                 }
                 else if (call.status === 'error') {
                     this.emitActivity('ERROR', {
@@ -921,7 +848,7 @@ export class LocalAgentExecutor {
                 else if (call.status === 'cancelled') {
                     const isSoftRejection = call.outcome === ToolConfirmationOutcome.Cancel;
                     if (isSoftRejection) {
-                        const error = `${SUBAGENT_REJECTED_ERROR_PREFIX} Please acknowledge this, rethink your strategy, and try a different approach. If you cannot proceed without the rejected operation, summarize the issue and use \`${TASK_COMPLETE_TOOL_NAME}\` to report your findings and the blocker.`;
+                        const error = `${SUBAGENT_REJECTED_ERROR_PREFIX} Please acknowledge this, rethink your strategy, and try a different approach. If you cannot proceed without the rejected operation, summarize the issue and use \`${COMPLETE_TASK_TOOL_NAME}\` to report your findings and the blocker.`;
                         this.emitActivity('ERROR', {
                             context: 'tool_call',
                             name: toolName,
@@ -985,7 +912,7 @@ export class LocalAgentExecutor {
      */
     prepareToolsList() {
         const toolsList = [];
-        const { toolConfig, outputConfig } = this.definition;
+        const { toolConfig } = this.definition;
         if (toolConfig) {
             for (const toolRef of toolConfig.tools) {
                 if (typeof toolRef === 'object' && !('schema' in toolRef)) {
@@ -996,36 +923,6 @@ export class LocalAgentExecutor {
         }
         // Add schemas from tools that were explicitly registered by name, wildcard, or instance.
         toolsList.push(...this.toolRegistry.getFunctionDeclarations(this.definition.modelConfig.model));
-        // 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 submit your final findings and complete the task. This is the ONLY way to finish.',
-            parameters: {
-                type: Type.OBJECT,
-                properties: {},
-                required: [],
-            },
-        };
-        if (outputConfig) {
-            const jsonSchema = zodToJsonSchema(outputConfig.schema);
-            const { $schema: _$schema, definitions: _definitions, ...schema } = jsonSchema;
-            completeTool.parameters.properties[outputConfig.outputName] =
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-                schema;
-            completeTool.parameters.required.push(outputConfig.outputName);
-        }
-        else {
-            completeTool.parameters.properties['result'] = {
-                type: Type.STRING,
-                description: 'Your final results or findings to return to the orchestrator. ' +
-                    'Ensure this is comprehensive and follows any formatting requested in your instructions.',
-            };
-            completeTool.parameters.required.push('result');
-        }
-        toolsList.push(completeTool);
         return toolsList;
     }
     /** Builds the system prompt from the agent definition and inputs. */
@@ -1036,6 +933,18 @@ export class LocalAgentExecutor {
         }
         // Inject user inputs into the prompt template.
         let finalPrompt = templateString(promptConfig.systemPrompt, inputs);
+        // Inject skill SI if ACTIVATE_SKILL_TOOL_NAME is available to this agent.
+        if (this.toolRegistry.getTool(ACTIVATE_SKILL_TOOL_NAME) !== undefined) {
+            const skills = this.context.config.getSkillManager().getSkills();
+            if (skills.length > 0) {
+                const skillsPrompt = renderAgentSkills(skills.map((s) => ({
+                    name: s.name,
+                    description: s.description,
+                    location: s.location,
+                })));
+                finalPrompt += `\n\n${skillsPrompt}`;
+            }
+        }
         // Append memory context if available.
         const systemMemory = this.context.config.getSystemInstructionMemory();
         if (systemMemory) {
@@ -1053,16 +962,16 @@ Important Rules:
 * If a tool call is rejected by the user, acknowledge the rejection, rethink your strategy, and try a different approach. Do not repeatedly attempt the same rejected operation.`;
         if (this.definition.outputConfig) {
             finalPrompt += `
-* When you have completed your task, you MUST call the \`${TASK_COMPLETE_TOOL_NAME}\` tool with your structured output.
-* Do not call any other tools in the same turn as \`${TASK_COMPLETE_TOOL_NAME}\`.
+* When you have completed your task, you MUST call the \`${COMPLETE_TASK_TOOL_NAME}\` tool with your structured output.
+* Do not call any other tools in the same turn as \`${COMPLETE_TASK_TOOL_NAME}\`.
 * This is the ONLY way to complete your mission. If you stop calling tools without calling this, you have failed.`;
         }
         else {
             finalPrompt += `
-* When you have completed your task, you MUST call the \`${TASK_COMPLETE_TOOL_NAME}\` tool.
+* When you have completed your task, you MUST call the \`${COMPLETE_TASK_TOOL_NAME}\` tool.
 * You MUST include your final findings in the "result" parameter. This is how you return the necessary results for the task to be marked complete.
 * Ensure your findings are comprehensive and follow any specific formatting requirements provided in your instructions.
-* Do not call any other tools in the same turn as \`${TASK_COMPLETE_TOOL_NAME}\`.
+* Do not call any other tools in the same turn as \`${COMPLETE_TASK_TOOL_NAME}\`.
 * This is the ONLY way to complete your mission. If you stop calling tools without calling this, you have failed.`;
         }
         return finalPrompt;
@@ -1108,5 +1017,40 @@ Important Rules:
             this.onActivity(event);
         }
     }
+    /**
+     * Truncates a string to 200 characters in a Unicode-safe way for session summaries.
+     */
+    getTruncatedSummary(text) {
+        const chars = Array.from(text);
+        if (chars.length <= 200) {
+            return text;
+        }
+        return chars.slice(0, 197).join('') + '...';
+    }
+    /**
+     * Parses the arguments for a tool call, handling both JSON strings and objects.
+     */
+    parseToolArguments(functionCall) {
+        const args = {};
+        if (typeof functionCall.args === 'string') {
+            try {
+                const parsed = JSON.parse(functionCall.args);
+                if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                    Object.assign(args, parsed);
+                }
+                return { args };
+            }
+            catch {
+                return {
+                    args: {},
+                    error: `Failed to parse JSON arguments for tool "${functionCall.name}": ${functionCall.args}. Ensure you provide a valid JSON object.`,
+                };
+            }
+        }
+        else if (functionCall.args) {
+            return { args: functionCall.args };
+        }
+        return { args: {} };
+    }
 }
 //# sourceMappingURL=local-executor.js.map