@codebolt/agent 6.1.19 → 6.1.21

package/dist/processor-pieces/messageModifiers/environmentContextModifier.js

@@ -102,6 +102,7 @@ Effective project directory for this task: ${currentDir}
 ${baseProjectPath ? `CodeBolt base project directory: ${baseProjectPath}
 CodeBolt app-level configuration, providers, plugins, and .codebolt data are loaded from the base project directory. Code changes for the task should still target the effective project directory unless the user explicitly says otherwise.` : ''}
 ${directoryListing}
+Async task policy: long-running commands and child threads are tracked as async tasks with execution_mode foreground_scoped, auto_scoped, background_scoped, or background_detached. Scoped tasks are owned by the current agent run and are stopped if the user force-stops the agent. Before completing, use async_task_list to inspect unresolved scoped work and async_task_control to wait, stop, or explicitly detach each running task. background_detached tasks survive user force-stop and natural completion, so detach only intentional background services such as dev servers.
             `.trim();
             // Prepare context parts (same as gemini-cli)
             const contextParts = [environmentContext];
@@ -119,6 +120,10 @@ ${directoryListing}
             if (mentionedEnvironmentContext) {
                 contextParts.push(mentionedEnvironmentContext);
             }
+            const asyncTaskContext = await this.formatPendingAsyncTasks();
+            if (asyncTaskContext) {
+                contextParts.push(asyncTaskContext);
+            }
             // Add full file context if enabled (just like gemini-cli does)
             if (this.options.enableFullContext) {
                 try {
@@ -137,10 +142,11 @@ ${directoryListing}
                 role: 'user',
                 content: finalContent
             };
+            const updatedMessage = (0, promptContext_1.appendUserContextMessage)(createdMessage, contextMessage);
             return Promise.resolve({
-                ...(0, promptContext_1.appendUserContextMessage)(createdMessage, contextMessage),
+                ...updatedMessage,
                 metadata: {
-                    ...createdMessage.metadata,
+                    ...updatedMessage.metadata,
                     environmentContextAdded: true,
                     projectAgentMdContextAdded: Boolean(agentMdContext),
                     fullContextAdded: this.options.enableFullContext,
@@ -187,6 +193,7 @@ ${directoryListing}
             'The user explicitly mentioned these environments with #. Treat them as routing context, not as an automatic active-environment selection.',
             'If the user asks to run, start, delegate, create, or continue work in one of these environments, first inspect this mentioned environment list and choose the matching environment.',
             'Use the thread tool `thread_create_background` to create a background thread in the selected remote environment. Pass the selected environment object in `environment`, set `isRemoteTask: true`, and put the requested work in `userMessage` or `task`.',
+            'If the next step depends on that child thread finishing, use `async_task_control` with taskId `thread:<threadId>` and action `wait` before continuing.',
             'If `thread_create_background` is not available in the current tool list, first use the tool search capability, such as `tool_search`, to find the thread/background-thread creation tool and then use the matching tool.',
             'If multiple mentioned environments could match and the user did not specify which one, ask a brief clarification before creating the background thread.',
             'Do not call environment management tools or change the active environment just because an environment was mentioned.',
@@ -194,6 +201,45 @@ ${directoryListing}
             '</mentioned-environments>',
         ].join('\n');
     }
+    async formatPendingAsyncTasks() {
+        try {
+            const response = await codeboltjs_1.default.asyncTask.listTasks({
+                scope: 'thread',
+            });
+            const tasks = Array.isArray(response === null || response === void 0 ? void 0 : response.tasks) ? response.tasks : [];
+            const unresolvedTasks = tasks.filter((task) => task &&
+                task.executionMode !== 'background_detached' &&
+                !['completed', 'failed', 'stopped'].includes(task.status));
+            const detachedTasks = tasks.filter((task) => task &&
+                task.executionMode === 'background_detached' &&
+                !['completed', 'failed', 'stopped'].includes(task.status));
+            if (unresolvedTasks.length === 0 && detachedTasks.length === 0) {
+                return null;
+            }
+            const sections = [];
+            if (unresolvedTasks.length > 0) {
+                sections.push([
+                    '<pending_async_tasks>',
+                    'These scoped async tasks are still unresolved for this thread. Before completing, choose wait, stop, or detach for each task using async_task_control. Detach only intentional background services that should survive agent stop.',
+                    JSON.stringify(unresolvedTasks, null, 2),
+                    '</pending_async_tasks>',
+                ].join('\n'));
+            }
+            if (detachedTasks.length > 0) {
+                sections.push([
+                    '<detached_async_tasks>',
+                    'These background_detached async tasks are still running in the background for this thread. They do not block completion and survive user force-stop. Stop them with async_task_control if they are no longer needed.',
+                    JSON.stringify(detachedTasks, null, 2),
+                    '</detached_async_tasks>',
+                ].join('\n'));
+            }
+            return sections.join('\n\n');
+        }
+        catch (error) {
+            console.error('Error reading pending async tasks:', error);
+            return null;
+        }
+    }
     async readProjectAgentMd(basePath, title = 'Project Agent Instructions') {
         const instructionFiles = [
             path.join(basePath, '.codebolt', 'agent.md'),

package/dist/processor-pieces/messageModifiers/ideContextModifier.js

@@ -34,10 +34,11 @@ class IdeContextModifier extends base_1.BaseMessageModifier {
                 this.lastSentIdeContext = newIdeContext;
             }
             this.forceFullContext = false;
+            const updatedMessage = (0, promptContext_1.appendSystemContextMessage)(createdMessage, ideContextMessage);
             return Promise.resolve({
-                ...(0, promptContext_1.appendSystemContextMessage)(createdMessage, ideContextMessage),
+                ...updatedMessage,
                 metadata: {
-                    ...createdMessage.metadata,
+                    ...updatedMessage.metadata,
                     ideContextAdded: true,
                     ideContextType: this.forceFullContext ? 'full' : 'incremental'
                 }

package/dist/processor-pieces/messageModifiers/memoryImportModifier.js

@@ -37,6 +37,7 @@ exports.MemoryImportModifier = void 0;
 const base_1 = require("../base");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const promptContext_1 = require("../../unified/base/promptContext");
 class MemoryImportModifier extends base_1.BaseMessageModifier {
     constructor(options = {}) {
         super();
@@ -54,8 +55,7 @@ class MemoryImportModifier extends base_1.BaseMessageModifier {
             if (!this.options.enableMemoryImport) {
                 return createdMessage;
             }
-            // Get the user message content to process
-            const userMessage = createdMessage.message.messages.find(msg => msg.role === 'user');
+            const userMessage = (0, promptContext_1.getCurrentUserMessage)(createdMessage);
             if (!userMessage || typeof userMessage.content !== 'string') {
                 return createdMessage;
             }
@@ -105,23 +105,17 @@ class MemoryImportModifier extends base_1.BaseMessageModifier {
             if (processedImports.length === 0) {
                 return createdMessage;
             }
-            // Update the user message with processed content
-            const messages = createdMessage.message.messages.map(msg => {
-                if (msg.role === 'user' && msg === userMessage) {
-                    return {
-                        ...msg,
-                        content
-                    };
-                }
-                return msg;
-            });
+            const updatedMessage = (0, promptContext_1.updateCurrentUserMessage)(createdMessage, (message) => ({
+                ...message,
+                content,
+            }));
             return Promise.resolve({
+                ...updatedMessage,
                 message: {
-                    ...createdMessage.message,
-                    messages
+                    ...updatedMessage.message,
                 },
                 metadata: {
-                    ...createdMessage.metadata,
+                    ...updatedMessage.metadata,
                     memoryImportsProcessed: true,
                     importedFiles: processedImports,
                     totalImports: processedImports.length

package/dist/processor-pieces/messageModifiers/toolInjectionModifier.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ToolInjectionModifier = void 0;
 const base_1 = require("../base");
 const agentToolLoader_1 = require("../../unified/utils/agentToolLoader");
+const promptContext_1 = require("../../unified/base/promptContext");
 class ToolInjectionModifier extends base_1.BaseMessageModifier {
     constructor(options = {}) {
         super();
@@ -19,7 +20,7 @@ class ToolInjectionModifier extends base_1.BaseMessageModifier {
     }
     async modify(originalRequest, createdMessage) {
         try {
-            let mentionedMCPs = originalRequest.mentionedMCPs || [];
+            const mentionedMCPs = originalRequest.mentionedMCPs || [];
             let tools = await (0, agentToolLoader_1.listAgentAvailableTools)(Array.isArray(mentionedMCPs) ? mentionedMCPs : []);
             // Filter tools if allowedTools is specified
             if (this.options.allowedTools && this.options.allowedTools.length > 0) {
@@ -30,17 +31,12 @@ class ToolInjectionModifier extends base_1.BaseMessageModifier {
             }
             switch (this.options.toolsLocation) {
                 case 'InsidePrompt':
-                    //@ts-ignore
                     return this.addToolsInsidePrompt(createdMessage, tools);
-                //@ts-ignore
                 case 'SystemMessage':
-                    //@ts-ignore
                     return this.addToolsAsSystemMessage(createdMessage, tools);
                 case 'Tool':
-                    //@ts-ignore
                     return this.addToolsAsToolCalls(createdMessage, tools);
                 default:
-                    //@ts-ignore
                     return this.addToolsAsToolCalls(createdMessage, tools);
             }
         }
@@ -51,23 +47,24 @@ class ToolInjectionModifier extends base_1.BaseMessageModifier {
     }
     addToolsInsidePrompt(createdMessage, tools) {
         const toolsInfo = this.generateToolsInfo(tools);
-        // Modify the last user message to include tools information
-        const modifiedMessages = createdMessage.message.messages.map((message, index) => {
-            if (message.role === 'user' && index === createdMessage.message.messages.length - 1) {
-                return {
-                    ...message,
-                    content: `${message.content}\n\n--- Available Tools ---\n${toolsInfo}`
-                };
-            }
-            return message;
-        });
+        const updatedMessage = (0, promptContext_1.updateCurrentUserMessage)(createdMessage, (message) => ({
+            ...message,
+            content: typeof message.content === 'string'
+                ? `${message.content}\n\n--- Available Tools ---\n${toolsInfo}`
+                : [
+                    ...(Array.isArray(message.content)
+                        ? message.content
+                        : [{ type: 'text', text: String(message.content) }]),
+                    { type: 'text', text: `--- Available Tools ---\n${toolsInfo}` },
+                ],
+        }));
         return {
+            ...updatedMessage,
             message: {
-                ...createdMessage.message,
-                messages: modifiedMessages
+                ...updatedMessage.message,
             },
             metadata: {
-                ...createdMessage.metadata,
+                ...updatedMessage.metadata,
                 toolsInjected: true,
                 toolsLocation: 'InsidePrompt',
                 toolsCount: tools.length
@@ -83,7 +80,7 @@ class ToolInjectionModifier extends base_1.BaseMessageModifier {
         return {
             message: {
                 ...createdMessage.message,
-                messages: [toolsMessage, ...createdMessage.message.messages]
+                input: [toolsMessage, ...createdMessage.message.input]
             },
             metadata: {
                 ...createdMessage.metadata,

package/dist/processor-pieces/postInferenceProcessors/loopDetectionModifier.js

@@ -21,32 +21,21 @@ class LoopDetectionModifier extends base_1.BasePostInferenceProcessor {
             }
             const currentTime = Date.now();
             // Add LLM response to history
-            if (llmResponseMessage.content) {
+            const responseContent = llmResponseMessage.output_text || llmResponseMessage.content;
+            if (responseContent) {
                 this.messageHistory.push({
-                    content: llmResponseMessage.content,
+                    content: typeof responseContent === 'string' ? responseContent : JSON.stringify(responseContent),
                     timestamp: currentTime,
-                    role: llmResponseMessage.role
+                    role: llmResponseMessage.role || 'assistant'
                 });
             }
-            // Add any choice messages from LLM response to history
-            if (llmResponseMessage.choices) {
-                for (const choice of llmResponseMessage.choices) {
-                    if (choice.message && choice.message.content) {
-                        this.messageHistory.push({
-                            content: choice.message.content,
-                            timestamp: currentTime,
-                            role: choice.message.role
-                        });
-                    }
-                }
-            }
             // Add the original sent message to history if it exists
-            for (const message of llmMessageSent.message.messages) {
+            for (const message of llmMessageSent.message.input) {
                 if (typeof message.content === 'string') {
                     this.messageHistory.push({
                         content: message.content,
                         timestamp: currentTime,
-                        role: message.role
+                        role: message.role || 'user'
                     });
                 }
             }
@@ -61,11 +50,11 @@ class LoopDetectionModifier extends base_1.BasePostInferenceProcessor {
                     role: 'system',
                     content: `[Loop Detection Warning] Similar messages detected in recent conversation. This may indicate a conversational loop. Consider rephrasing your request or providing more specific information.`
                 };
-                const updatedMessages = [...nextPrompt.message.messages, warningMessage];
+                const updatedMessages = [...nextPrompt.message.input, warningMessage];
                 return Promise.resolve({
                     message: {
                         ...nextPrompt.message,
-                        messages: updatedMessages
+                        input: updatedMessages
                     },
                     metadata: {
                         ...nextPrompt.metadata,

package/dist/processor-pieces/postToolCallProcessors/conversationCompactorModifier.d.ts

@@ -238,7 +238,7 @@ export declare class ConversationCompactorModifier extends BasePostToolCallProce
      * Forces compression regardless of threshold (for testing or manual trigger)
      */
     forceCompress(messages: MessageObject[]): Promise<{
-        messages: MessageObject[];
+        input: MessageObject[];
         metadata: Partial<CompressionMetadata>;
     }>;
 }

package/dist/processor-pieces/postToolCallProcessors/conversationCompactorModifier.js

@@ -304,7 +304,7 @@ class ConversationCompactorModifier extends basePostToolCallProcessor_1.BasePost
         }
         // If under budget, no truncation needed
         if (toolResponseTokens <= this.options.toolResponseTokenBudget) {
-            return { messages: result, truncated: false, tokensSaved: 0 };
+            return { input: result, truncated: false, tokensSaved: 0 };
         }
         // Iterate from oldest to newest tool messages for truncation
         // (We truncate older tool outputs first to preserve recent context)
@@ -344,7 +344,7 @@ class ConversationCompactorModifier extends basePostToolCallProcessor_1.BasePost
                 }
             }
         }
-        return { messages: result, truncated, tokensSaved };
+        return { input: result, truncated, tokensSaved };
     }
     // ========================================================================
     // History Split Point Calculation (Phase 2)
@@ -518,7 +518,7 @@ CRITICAL RULES:
         try {
             const prompt = this.getCompressionPrompt(historyToCompress);
             const response = await codeboltjs_1.default.llm.inference({
-                messages: [
+                input: [
                     { role: 'system', content: 'You are a precise conversation compression assistant.' },
                     { role: 'user', content: prompt }
                 ],
@@ -554,7 +554,7 @@ If the snapshot is accurate and complete, respond with just the original snapsho
 If there are inaccuracies or missing critical information, provide a corrected version.
 Keep the same XML format.`;
             const response = await codeboltjs_1.default.llm.inference({
-                messages: [
+                input: [
                     { role: 'system', content: 'You are verifying a conversation compression for accuracy.' },
                     { role: 'user', content: verificationPrompt }
                 ]
@@ -680,7 +680,7 @@ Keep the same XML format.`;
         if (this.options.enableLogging && deduplicatedCount > 0) {
             console.log(`[ConversationCompactor] Deduplicated ${deduplicatedCount} file reads`);
         }
-        return { messages: result, deduplicatedCount };
+        return { input: result, deduplicatedCount };
     }
     // ========================================================================
     // Compression Strategies
@@ -732,7 +732,7 @@ Keep the same XML format.`;
      */
     async compressSmart(messages) {
         // Phase 1: Truncate large tool outputs
-        const { messages: truncatedMessages, truncated } = this.truncateLargeToolOutputs(messages);
+        const { input: truncatedMessages, truncated } = this.truncateLargeToolOutputs(messages);
         // Check if truncation alone was sufficient
         const tokensAfterTruncation = this.countMessageTokens(truncatedMessages);
         const threshold = this.options.modelTokenLimit * this.options.compressionTokenThreshold;
@@ -789,7 +789,7 @@ Keep the same XML format.`;
      */
     async compressSummarize(messages) {
         // Phase 1: Truncate large tool outputs
-        const { messages: truncatedMessages, truncated } = this.truncateLargeToolOutputs(messages);
+        const { input: truncatedMessages, truncated } = this.truncateLargeToolOutputs(messages);
         // Phase 2: Find split point
         const splitIndex = this.findCompressionSplitIndex(truncatedMessages);
         if (splitIndex === 0) {
@@ -869,7 +869,7 @@ Please continue from where the previous conversation left off. Do not ask the us
         const { nextPrompt, rawLLMResponseMessage, tokenLimit } = input;
         try {
             // Safety check: ensure messages array exists
-            if (!((_a = nextPrompt === null || nextPrompt === void 0 ? void 0 : nextPrompt.message) === null || _a === void 0 ? void 0 : _a.messages) || !Array.isArray(nextPrompt.message.messages)) {
+            if (!((_a = nextPrompt === null || nextPrompt === void 0 ? void 0 : nextPrompt.message) === null || _a === void 0 ? void 0 : _a.input) || !Array.isArray(nextPrompt.message.input)) {
                 if (this.options.enableLogging) {
                     console.warn('[ConversationCompactor] No messages array found, skipping compression');
                 }
@@ -878,7 +878,7 @@ Please continue from where the previous conversation left off. Do not ask the us
                     shouldExit: false
                 };
             }
-            const messages = nextPrompt.message.messages;
+            const messages = nextPrompt.message.input;
             // Get model token limit: prefer tokenLimit from LLM response, then lookup by model name, then fallback to config
             const modelName = rawLLMResponseMessage === null || rawLLMResponseMessage === void 0 ? void 0 : rawLLMResponseMessage.model;
             const modelTokenLimit = tokenLimit !== null && tokenLimit !== void 0 ? tokenLimit : (modelName ? getModelTokenLimit(modelName) : this.options.modelTokenLimit);
@@ -981,7 +981,7 @@ Please continue from where the previous conversation left off. Do not ask the us
                 };
             }
             // Pre-compression: deduplicate file reads to reduce token waste
-            const { messages: dedupedMessages } = this.deduplicateFileReads(messages);
+            const { input: dedupedMessages } = this.deduplicateFileReads(messages);
             // Apply compression based on strategy
             let result;
             switch (this.options.compactStrategy) {
@@ -1056,7 +1056,7 @@ Please continue from where the previous conversation left off. Do not ask the us
                 nextPrompt: {
                     message: {
                         ...nextPrompt.message,
-                        messages: result.compressedMessages
+                        input: result.compressedMessages
                     },
                     metadata: {
                         ...nextPrompt.metadata,
@@ -1079,10 +1079,10 @@ Please continue from where the previous conversation left off. Do not ask the us
                         ...nextPrompt.metadata,
                         compression: {
                             status: CompressionStatus.FAILED_SUMMARIZATION_ERROR,
-                            originalTokenCount: this.countMessageTokens(nextPrompt.message.messages),
-                            newTokenCount: this.countMessageTokens(nextPrompt.message.messages),
+                            originalTokenCount: this.countMessageTokens(nextPrompt.message.input),
+                            newTokenCount: this.countMessageTokens(nextPrompt.message.input),
                             messagesCompressed: 0,
-                            messagesPreserved: nextPrompt.message.messages.length,
+                            messagesPreserved: nextPrompt.message.input.length,
                             toolOutputsTruncated: false,
                             failedAttempts: this.failedCompressionAttempts,
                             timestamp: new Date().toISOString(),
@@ -1125,7 +1125,7 @@ Please continue from where the previous conversation left off. Do not ask the us
             ? this.compressSummarize(messages)
             : this.compressSmart(messages));
         return {
-            messages: result.compressedMessages,
+            input: result.compressedMessages,
             metadata: result.metadata
         };
     }

package/dist/processor-pieces/postToolCallProcessors/shellProcessorModifier.js

@@ -42,7 +42,7 @@ class ShellProcessorModifier extends base_1.BasePostToolCallProcessor {
             // Also process any shell injections in the next prompt messages
             const updatedMessages = [];
             let contentModified = false;
-            for (const message of processedNextPrompt.message.messages) {
+            for (const message of processedNextPrompt.message.input) {
                 if (typeof message.content === 'string') {
                     let processedContent = message.content;
                     // Replace {{args}} placeholders if metadata has args
@@ -69,7 +69,7 @@ class ShellProcessorModifier extends base_1.BasePostToolCallProcessor {
                 processedNextPrompt = {
                     message: {
                         ...processedNextPrompt.message,
-                        messages: updatedMessages
+                        input: updatedMessages
                     },
                     metadata: {
                         ...processedNextPrompt.metadata,
@@ -109,7 +109,7 @@ class ShellProcessorModifier extends base_1.BasePostToolCallProcessor {
                     processedPrompt = {
                         message: {
                             ...processedPrompt.message,
-                            messages: [...processedPrompt.message.messages, systemMessage]
+                            input: [...processedPrompt.message.input, systemMessage]
                         },
                         metadata: {
                             ...processedPrompt.metadata,

package/dist/processor-pieces/preInferenceProcessors/chatCompressionModifier.js

@@ -104,12 +104,12 @@ class ChatCompressionModifier extends base_1.BasePreInferenceProcessor {
                     };
                 }
             }
-            const compressionResult = await this.tryCompressChat(createdMessage.message.messages, this.options.force || false);
+            const compressionResult = await this.tryCompressChat(createdMessage.message.input, this.options.force || false);
             if (compressionResult.compressionStatus === CompressionStatus.COMPRESSED) {
                 return {
                     message: {
                         ...createdMessage.message,
-                        messages: compressionResult.compressedMessages || createdMessage.message.messages
+                        input: compressionResult.compressedMessages || createdMessage.message.input
                     },
                     metadata: {
                         ...createdMessage.metadata,

package/dist/processor-pieces/utils/messageModifierHelper.js

@@ -7,7 +7,7 @@ const mergeMessages = (existing, additional) => {
         message: {
             ...existing.message,
             ...additional.message,
-            messages: [...existing.message.messages, ...additional.message.messages],
+            input: [...existing.message.input, ...additional.message.input],
         },
         metadata: {
             ...existing.metadata,
@@ -31,7 +31,7 @@ const addSystemMessage = (message, systemContent) => {
     return {
         message: {
             ...message.message,
-            messages: [systemMessage, ...message.message.messages]
+            input: [systemMessage, ...message.message.input]
         },
         metadata: {
             ...message.metadata,
@@ -50,7 +50,7 @@ const addUserContext = (message, contextKey, contextValue) => {
     return {
         message: {
             ...message.message,
-            messages: [...message.message.messages, contextMessage]
+            input: [...message.message.input, contextMessage]
         },
         metadata: {
             ...message.metadata,

package/dist/types/libFunctionTypes.d.ts

@@ -232,6 +232,11 @@ export interface CodeboltAPI {
         listMcpFromServers: (servers: string[]) => Promise<{
             data: OpenAITool[];
         }>;
+        getRegisteredTools: () => Promise<{
+            data?: {
+                tools: OpenAITool[];
+            };
+        }>;
         getTools: (mcps: any[]) => Promise<{
             data: OpenAITool[];
         }>;

package/dist/unified/agent/agent.d.ts

@@ -1,5 +1,46 @@
-import { AgentConfig, AgentInterface } from "@codebolt/types/agent";
+import { AgentConfig, AgentInterface, MessageModifier, PostInferenceProcessor, PostToolCallProcessor, PreInferenceProcessor, PreToolCallProcessor, ProcessedMessage, ToolResult } from "@codebolt/types/agent";
 import { FlatUserMessage } from "@codebolt/types/sdk";
+import { LoopDetectionService } from "../services/LoopDetectionService";
+import type { CompactionOrchestratorOptions } from "../services/compaction/types";
+export interface AgentOptions extends AgentConfig {
+    context?: ProcessedMessage;
+    allowedTools?: string[];
+    compaction?: CompactionOrchestratorOptions;
+    loopDetectionService?: LoopDetectionService;
+    maxTurns?: number;
+    includeDefaultModifiers?: boolean;
+    includeDefaultProcessors?: boolean;
+    messageModifiers?: MessageModifier[];
+    preInferenceProcessors?: PreInferenceProcessor[];
+    postInferenceProcessors?: PostInferenceProcessor[];
+    preToolCallProcessors?: PreToolCallProcessor[];
+    postToolCallProcessors?: PostToolCallProcessor[];
+}
+export interface AgentRunResult {
+    success: boolean;
+    state: AgentRunState | null;
+    toolResults: ToolResult[];
+    finalMessage?: string;
+    error?: string;
+    /**
+     * @deprecated Use `state.prompt` instead.
+     */
+    result: ProcessedMessage | null;
+    /**
+     * @deprecated Use `state` instead.
+     */
+    context: ProcessedMessage | null;
+}
+export interface AgentRunState {
+    prompt: ProcessedMessage;
+}
+export interface AgentRunOptions {
+    state?: AgentRunState;
+    context?: ProcessedMessage;
+}
+export interface CreateAgentOptions extends AgentOptions {
+    systemPrompt?: string;
+}
 export declare class Agent implements AgentInterface {
     private readonly config;
     private readonly messageModifiers;
@@ -8,19 +49,45 @@ export declare class Agent implements AgentInterface {
     private readonly preToolCallProcessors;
     private readonly postToolCallProcessors;
     private readonly enableLogging;
+    private readonly baseSystemPrompt;
+    private readonly context;
+    private readonly allowedTools;
     private readonly compactionOrchestrator;
     private readonly loopDetectionService;
     private readonly maxTurns;
-    constructor(config: AgentConfig);
+    private readonly localToolSchemas;
+    private readonly localToolsByExecutionName;
+    private readonly runtimeToolSetId;
+    constructor(config: AgentOptions);
+    run(message: string | FlatUserMessage, options?: ProcessedMessage | AgentRunOptions): Promise<AgentRunResult>;
+    private registerRuntimeToolsForSearch;
+    private unregisterRuntimeToolsForSearch;
+    processMessage(message: string | FlatUserMessage, options?: ProcessedMessage | AgentRunOptions): Promise<AgentRunResult>;
     execute(reqMessage: FlatUserMessage): Promise<{
         success: boolean;
         result: any;
         error?: string;
     }>;
+    getConfig(): AgentOptions;
+    getMessageModifiers(): MessageModifier[];
+    getPreInferenceProcessors(): PreInferenceProcessor[];
+    getPostInferenceProcessors(): PostInferenceProcessor[];
+    getPreToolCallProcessors(): PreToolCallProcessor[];
+    getPostToolCallProcessors(): PostToolCallProcessor[];
+    private resolveRunContext;
+    private getResumeMessageModifiers;
+    private isProcessedMessage;
     private applyCompaction;
+    private hydratePromptFromServerCompaction;
+    private isServerCompactionCurrent;
+    private extractCurrentRunMessages;
+    private isCurrentRunUserMessage;
+    private extractServerCompactedMessages;
+    private isServerCompactedMessage;
     private tryRecoverPrompt;
     private refreshAvailableTools;
     private getAllowedToolNames;
     private getRecoverableResponseError;
     private collectResponseMessages;
 }
+export declare function createAgent(options: CreateAgentOptions): Agent;