daycare-cli 0.0.0-canary.f57680e

package/dist/engine/agents/agent.js

@@ -0,0 +1,966 @@
+import path from "node:path";
+import { createId } from "@paralleldrive/cuid2";
+import { getLogger } from "../../log.js";
+import { listActiveInferenceProviders } from "../../providers/catalog.js";
+import { cuid2Is } from "../../utils/cuid2Is.js";
+import { agentSystemPrompt } from "./ops/agentSystemPrompt.js";
+import { agentPromptFilesEnsure } from "./ops/agentPromptFilesEnsure.js";
+import { agentPromptPathsResolve } from "./ops/agentPromptPathsResolve.js";
+import { messageBuildUser } from "../messages/messageBuildUser.js";
+import { messageFormatIncoming } from "../messages/messageFormatIncoming.js";
+import { messageBuildSystemText } from "../messages/messageBuildSystemText.js";
+import { messageBuildSystemSilentText } from "../messages/messageBuildSystemSilentText.js";
+import { messageExtractText } from "../messages/messageExtractText.js";
+import { contextCompact } from "./ops/contextCompact.js";
+import { contextCompactionStatus } from "./ops/contextCompactionStatus.js";
+import { contextEstimateTokens } from "./ops/contextEstimateTokens.js";
+import { messageContextReset } from "./ops/messageContextReset.js";
+import { permissionClone } from "../permissions/permissionClone.js";
+import { permissionEnsureDefaultFile } from "../permissions/permissionEnsureDefaultFile.js";
+import { permissionMergeDefault } from "../permissions/permissionMergeDefault.js";
+import { permissionTagsApply } from "../permissions/permissionTagsApply.js";
+import { Skills } from "../skills/skills.js";
+import { toolListContextBuild } from "../modules/tools/toolListContextBuild.js";
+import { agentDescriptorIsCron } from "./ops/agentDescriptorIsCron.js";
+import { agentDescriptorIsHeartbeat } from "./ops/agentDescriptorIsHeartbeat.js";
+import { agentDescriptorTargetResolve } from "./ops/agentDescriptorTargetResolve.js";
+import { agentLoopRun } from "./ops/agentLoopRun.js";
+import { agentHistoryAppend } from "./ops/agentHistoryAppend.js";
+import { agentHistoryLoad } from "./ops/agentHistoryLoad.js";
+import { agentHistoryLoadAll } from "./ops/agentHistoryLoadAll.js";
+import { agentStateWrite } from "./ops/agentStateWrite.js";
+import { agentDescriptorWrite } from "./ops/agentDescriptorWrite.js";
+import { agentSystemPromptWrite } from "./ops/agentSystemPromptWrite.js";
+import { agentRestoreContextResolve } from "./ops/agentRestoreContextResolve.js";
+import { agentHistoryContext } from "./ops/agentHistoryContext.js";
+import { agentHistoryPendingRlmResolve } from "./ops/agentHistoryPendingRlmResolve.js";
+import { agentHistoryPendingToolResults } from "./ops/agentHistoryPendingToolResults.js";
+import { rlmErrorTextBuild } from "../modules/rlm/rlmErrorTextBuild.js";
+import { rlmHistoryCompleteErrorRecordBuild } from "../modules/rlm/rlmHistoryCompleteErrorRecordBuild.js";
+import { RLM_TOOL_NAME } from "../modules/rlm/rlmConstants.js";
+import { rlmNoToolsModeIs } from "../modules/rlm/rlmNoToolsModeIs.js";
+import { rlmToolDescriptionBuild } from "../modules/rlm/rlmToolDescriptionBuild.js";
+import { rlmRestore } from "../modules/rlm/rlmRestore.js";
+import { rlmResultTextBuild } from "../modules/rlm/rlmResultTextBuild.js";
+import { rlmToolResultBuild } from "../modules/rlm/rlmToolResultBuild.js";
+import { signalMessageBuild } from "../signals/signalMessageBuild.js";
+import { channelMessageBuild, channelSignalDataParse } from "../channels/channelMessageBuild.js";
+const logger = getLogger("engine.agent");
+export class Agent {
+    id;
+    descriptor;
+    inbox;
+    state;
+    agentSystem;
+    providerId = null;
+    processing = false;
+    started = false;
+    inferenceAbortController = null;
+    constructor(id, descriptor, state, inbox, agentSystem) {
+        this.id = id;
+        this.descriptor = descriptor;
+        this.state = state;
+        this.inbox = inbox;
+        this.agentSystem = agentSystem;
+    }
+    /**
+     * Creates a new agent and persists descriptor + state + history start.
+     * Expects: agentId is a cuid2 value; descriptor is validated.
+     */
+    static async create(agentId, descriptor, inbox, agentSystem) {
+        if (!cuid2Is(agentId)) {
+            throw new Error("Agent id must be a cuid2 value.");
+        }
+        const now = Date.now();
+        const state = {
+            context: { messages: [] },
+            inferenceSessionId: createId(),
+            permissions: permissionClone(agentSystem.config.current.defaultPermissions),
+            tokens: null,
+            stats: {},
+            createdAt: now,
+            updatedAt: now,
+            state: "active"
+        };
+        const agent = new Agent(agentId, descriptor, state, inbox, agentSystem);
+        await agentDescriptorWrite(agentSystem.config.current, agentId, descriptor);
+        await agentStateWrite(agentSystem.config.current, agentId, state);
+        await agentHistoryAppend(agentSystem.config.current, agentId, {
+            type: "start",
+            at: now
+        });
+        agent.agentSystem.eventBus.emit("agent.created", {
+            agentId,
+            source: "agent",
+            context: {}
+        });
+        return agent;
+    }
+    /**
+     * Rehydrates an agent from persisted descriptor + state.
+     * Expects: state and descriptor already validated.
+     */
+    static restore(agentId, descriptor, state, inbox, agentSystem) {
+        return new Agent(agentId, descriptor, state, inbox, agentSystem);
+    }
+    start() {
+        if (this.started) {
+            return;
+        }
+        this.started = true;
+        logger.debug(`start: Agent loop starting agentId=${this.id} type=${this.descriptor.type}`);
+        void this.runLoop().catch((error) => {
+            this.started = false;
+            this.agentSystem.markStopped(this.id, error);
+            logger.warn({ agentId: this.id, error }, "event: Agent loop exited unexpectedly");
+        });
+    }
+    isProcessing() {
+        return this.processing;
+    }
+    /**
+     * Aborts the currently running inference call for this agent.
+     * Returns false when no active inference is in flight.
+     */
+    abortInference() {
+        const controller = this.inferenceAbortController;
+        if (!controller || controller.signal.aborted) {
+            return false;
+        }
+        controller.abort();
+        return true;
+    }
+    async runLoop() {
+        this.inbox.attach();
+        try {
+            for (;;) {
+                const entry = await this.inbox.next();
+                logger.debug(`event: Agent inbox item dequeued agentId=${this.id} type=${entry.item.type}`);
+                this.processing = true;
+                try {
+                    const result = await this.agentSystem.inReadLock(async () => this.handleInboxItem(entry.item));
+                    await this.sleepAfterItem(entry.item);
+                    entry.completion?.resolve(result);
+                }
+                catch (error) {
+                    const failure = error instanceof Error ? error : new Error(String(error));
+                    logger.error({
+                        agentId: this.id,
+                        itemType: entry.item.type,
+                        errorName: failure.name,
+                        errorMessage: failure.message,
+                        errorStack: failure.stack
+                    }, `error: Agent inbox item failed: ${failure.message}`);
+                    entry.completion?.reject(failure);
+                    if (entry.item.type === "message") {
+                        await this.sendUnexpectedError(entry.item);
+                    }
+                }
+                finally {
+                    this.processing = false;
+                }
+            }
+        }
+        finally {
+            this.inbox.detach();
+        }
+    }
+    /**
+     * Attempts to put the agent to sleep after processing a message or reset.
+     * Expects: inbox item handled successfully.
+     */
+    async sleepAfterItem(item) {
+        if (item.type !== "message" &&
+            item.type !== "system_message" &&
+            item.type !== "signal" &&
+            item.type !== "reset" &&
+            item.type !== "compact" &&
+            item.type !== "restore") {
+            return;
+        }
+        await this.agentSystem.sleepIfIdle(this.id, item.type);
+    }
+    async handleInboxItem(item) {
+        switch (item.type) {
+            case "message": {
+                const responseText = await this.handleMessage(item);
+                return { type: "message", responseText };
+            }
+            case "system_message": {
+                const responseText = await this.handleSystemMessage(item);
+                return { type: "system_message", responseText };
+            }
+            case "signal": {
+                const signalResult = await this.handleSignal(item);
+                return { type: "signal", ...signalResult };
+            }
+            case "reset": {
+                const ok = await this.handleReset(item);
+                return { type: "reset", ok };
+            }
+            case "compact": {
+                const ok = await this.handleCompaction(item);
+                return { type: "compact", ok };
+            }
+            case "restore": {
+                const ok = await this.handleRestore(item);
+                return { type: "restore", ok };
+            }
+            default:
+                return { type: "restore", ok: false };
+        }
+    }
+    async sendUnexpectedError(item) {
+        if (this.descriptor.type !== "user") {
+            return;
+        }
+        const connector = this.agentSystem.connectorRegistry.get(this.descriptor.connector);
+        if (!connector?.capabilities.sendText) {
+            return;
+        }
+        try {
+            await connector.sendMessage(this.descriptor.channelId, {
+                text: "Unexpected error",
+                replyToMessageId: item.context.messageId
+            });
+        }
+        catch (error) {
+            const failure = error instanceof Error ? error : new Error(String(error));
+            logger.warn({ agentId: this.id, error: failure }, "error: Failed to send unexpected error message");
+        }
+    }
+    async handleMessage(item) {
+        const receivedAt = Date.now();
+        const messageId = createId();
+        const context = { ...item.context };
+        const entry = {
+            id: messageId,
+            message: messageFormatIncoming(item.message, context, new Date(receivedAt)),
+            context,
+            receivedAt
+        };
+        const source = this.descriptor.type === "user"
+            ? this.descriptor.connector
+            : this.descriptor.type === "system"
+                ? this.descriptor.tag
+                : this.descriptor.type;
+        logger.debug(`start: handleMessage start agentId=${this.id} source=${source} textLength=${entry.message.text?.length ?? 0} fileCount=${entry.message.files?.length ?? 0}`);
+        this.state.updatedAt = receivedAt;
+        const rawText = entry.message.rawText ?? entry.message.text ?? "";
+        const files = toFileReferences(entry.message.files ?? []);
+        let compactionAt = null;
+        let pendingUserRecord = {
+            type: "user_message",
+            at: receivedAt,
+            text: rawText,
+            files
+        };
+        await this.completePendingToolCalls("session_crashed");
+        const providers = listActiveInferenceProviders(this.agentSystem.config.current.settings);
+        const providerId = this.resolveAgentProvider(providers);
+        const connector = this.agentSystem.connectorRegistry.get(source);
+        const pluginManager = this.agentSystem.pluginManager;
+        const configSkillsRoot = path.join(this.agentSystem.config.current.configDir, "skills");
+        const skills = new Skills({
+            configRoot: configSkillsRoot,
+            pluginManager
+        });
+        const agentKind = this.resolveAgentKind();
+        const allowCronTools = agentDescriptorIsCron(this.descriptor);
+        const defaultPermissions = this.agentSystem.config.current.defaultPermissions;
+        if (agentDescriptorIsHeartbeat(this.descriptor)) {
+            this.state.permissions = permissionMergeDefault(this.state.permissions, defaultPermissions);
+            permissionEnsureDefaultFile(this.state.permissions, defaultPermissions);
+        }
+        const permissionTags = [...(entry.context.permissionTags ?? [])];
+        if (permissionTags.length > 0) {
+            try {
+                permissionTagsApply(this.state.permissions, permissionTags);
+            }
+            catch (error) {
+                logger.warn({ agentId: this.id, error }, "error: Failed to apply task permissions");
+            }
+        }
+        const toolResolver = item.toolResolverOverride ?? this.agentSystem.toolResolver;
+        const providerSettings = providerId
+            ? providers.find((provider) => provider.id === providerId)
+            : providers[0];
+        const availableTools = toolResolver.listTools();
+        const noToolsModeEnabled = rlmNoToolsModeIs(this.agentSystem.config.current.features);
+        const rlmToolDescription = this.agentSystem.config.current.features.rlm && !noToolsModeEnabled
+            ? await rlmToolDescriptionBuild(availableTools)
+            : undefined;
+        await agentPromptFilesEnsure(agentPromptPathsResolve(this.agentSystem.config.current.dataDir));
+        logger.debug(`event: handleMessage building system prompt agentId=${this.id}`);
+        const systemPrompt = await agentSystemPrompt({
+            provider: providerSettings?.id,
+            model: providerSettings?.model,
+            permissions: this.state.permissions,
+            descriptor: this.descriptor,
+            agentSystem: this.agentSystem
+        });
+        try {
+            const wrote = await agentSystemPromptWrite(this.agentSystem.config.current, this.id, systemPrompt);
+            if (wrote) {
+                logger.debug(`event: System prompt snapshot written agentId=${this.id}`);
+            }
+        }
+        catch (error) {
+            logger.warn({ agentId: this.id, error }, "error: Failed to write system prompt snapshot");
+        }
+        const history = await agentHistoryLoad(this.agentSystem.config.current, this.id);
+        const contextTools = await this.listContextTools(toolResolver, source, {
+            agentKind,
+            allowCronTools,
+            rlmToolDescription
+        });
+        const compactionStatus = contextCompactionStatus(history, this.agentSystem.config.current.settings.agents.emergencyContextLimit, {
+            extras: {
+                systemPrompt,
+                tools: contextTools,
+                extraText: [rawText]
+            }
+        });
+        if (compactionStatus.severity !== "ok") {
+            const target = agentDescriptorTargetResolve(this.descriptor);
+            const targetId = target?.targetId ?? null;
+            if (agentKind === "foreground" && connector?.capabilities.sendText && targetId) {
+                await connector.sendMessage(targetId, {
+                    text: messageContextReset({ kind: "compaction" }),
+                    replyToMessageId: entry.context.messageId
+                });
+            }
+            const stopCompactionTyping = this.startCompactionTypingIndicator();
+            const compactionAbortController = new AbortController();
+            this.inferenceAbortController = compactionAbortController;
+            let compactionAborted = false;
+            try {
+                const compacted = await contextCompact({
+                    context: this.state.context,
+                    inferenceRouter: this.agentSystem.inferenceRouter,
+                    providers,
+                    providerId: providerId ?? undefined,
+                    inferenceSessionId: this.state.inferenceSessionId ?? this.id,
+                    signal: compactionAbortController.signal,
+                    compactionLog: {
+                        agentsDir: this.agentSystem.config.current.agentsDir,
+                        agentId: this.id
+                    }
+                });
+                const summaryMessage = compacted.messages?.[0];
+                const summaryText = summaryMessage
+                    ? messageExtractText(summaryMessage)?.trim() ?? ""
+                    : "";
+                if (summaryText) {
+                    compactionAt = await this.applyCompactionSummary(summaryText);
+                }
+                else {
+                    logger.info({ agentId: this.id }, "event: Compaction produced empty summary; using full context");
+                }
+            }
+            catch (error) {
+                if (isAbortError(error, compactionAbortController.signal)) {
+                    compactionAborted = true;
+                    logger.info({ agentId: this.id }, "event: Compaction aborted");
+                }
+                else {
+                    logger.warn({ agentId: this.id, error }, "error: Context compaction failed; continuing with full context");
+                }
+            }
+            finally {
+                stopCompactionTyping?.();
+                if (this.inferenceAbortController === compactionAbortController) {
+                    this.inferenceAbortController = null;
+                }
+            }
+            if (compactionAborted) {
+                return null;
+            }
+        }
+        if (pendingUserRecord) {
+            if (compactionAt !== null) {
+                pendingUserRecord = { ...pendingUserRecord, at: compactionAt + 1 };
+            }
+            await agentHistoryAppend(this.agentSystem.config.current, this.id, pendingUserRecord);
+        }
+        const agentContext = this.state.context;
+        const contextForRun = {
+            ...agentContext,
+            tools: contextTools,
+            systemPrompt
+        };
+        if (!contextForRun.messages) {
+            contextForRun.messages = [];
+        }
+        logger.debug(`event: handleMessage building user message agentId=${this.id}`);
+        const userMessage = await messageBuildUser(entry);
+        contextForRun.messages.push(userMessage);
+        const providersForAgent = providerId
+            ? providers.filter((provider) => provider.id === providerId)
+            : [];
+        logger.debug(`event: handleMessage invoking inference loop agentId=${this.id}`);
+        const inferenceAbortController = new AbortController();
+        this.inferenceAbortController = inferenceAbortController;
+        const result = await (async () => {
+            try {
+                return await agentLoopRun({
+                    entry,
+                    agent: this,
+                    source,
+                    context: contextForRun,
+                    connector,
+                    connectorRegistry: this.agentSystem.connectorRegistry,
+                    inferenceRouter: this.agentSystem.inferenceRouter,
+                    toolResolver,
+                    fileStore: this.agentSystem.fileStore,
+                    authStore: this.agentSystem.authStore,
+                    eventBus: this.agentSystem.eventBus,
+                    assistant: this.agentSystem.config.current.settings.assistant ?? null,
+                    agentSystem: this.agentSystem,
+                    heartbeats: this.agentSystem.heartbeats,
+                    skills,
+                    providersForAgent,
+                    verbose: this.agentSystem.config.current.verbose,
+                    logger,
+                    abortSignal: inferenceAbortController.signal,
+                    appendHistoryRecord: (record) => agentHistoryAppend(this.agentSystem.config.current, this.id, record),
+                    notifySubagentFailure: (reason, error) => this.notifySubagentFailure(reason, error)
+                });
+            }
+            finally {
+                if (this.inferenceAbortController === inferenceAbortController) {
+                    this.inferenceAbortController = null;
+                }
+            }
+        })();
+        if (result.contextOverflow) {
+            logger.warn({ agentId: this.id }, "event: Inference context overflow; resetting session");
+            await this.handleEmergencyReset(entry, source);
+            return null;
+        }
+        if (result.tokenStatsUpdates.length > 0) {
+            for (const update of result.tokenStatsUpdates) {
+                const providerStats = this.state.stats[update.provider] ?? {};
+                const modelStats = providerStats[update.model] ?? {
+                    input: 0,
+                    output: 0,
+                    cacheRead: 0,
+                    cacheWrite: 0,
+                    total: 0
+                };
+                modelStats.input += update.size.input;
+                modelStats.output += update.size.output;
+                modelStats.cacheRead += update.size.cacheRead;
+                modelStats.cacheWrite += update.size.cacheWrite;
+                modelStats.total += update.size.total;
+                providerStats[update.model] = modelStats;
+                this.state.stats[update.provider] = providerStats;
+            }
+        }
+        const lastAssistantRecord = [...result.historyRecords]
+            .reverse()
+            .find((record) => record.type === "assistant_message");
+        if (lastAssistantRecord && lastAssistantRecord.type === "assistant_message") {
+            this.state.tokens = lastAssistantRecord.tokens;
+        }
+        this.state.context = { messages: contextForRun.messages };
+        this.state.updatedAt = Date.now();
+        await agentStateWrite(this.agentSystem.config.current, this.id, this.state);
+        return result.responseText ?? null;
+    }
+    async handleSystemMessage(item) {
+        const text = item.silent
+            ? messageBuildSystemSilentText(item.text, item.origin)
+            : messageBuildSystemText(item.text, item.origin);
+        if (item.silent) {
+            const receivedAt = Date.now();
+            await agentHistoryAppend(this.agentSystem.config.current, this.id, {
+                type: "user_message",
+                at: receivedAt,
+                text,
+                files: []
+            });
+            const context = {};
+            const message = messageFormatIncoming({ text, files: [] }, context, new Date(receivedAt));
+            const entry = {
+                id: createId(),
+                message,
+                context,
+                receivedAt
+            };
+            const userMessage = await messageBuildUser(entry);
+            if (!this.state.context.messages) {
+                this.state.context.messages = [];
+            }
+            this.state.context.messages.push(userMessage);
+            this.state.updatedAt = receivedAt;
+            await agentStateWrite(this.agentSystem.config.current, this.id, this.state);
+            return null;
+        }
+        const messageItem = {
+            type: "message",
+            message: { text },
+            context: item.context ?? {}
+        };
+        return this.handleMessage(messageItem);
+    }
+    async handleSignal(item) {
+        const isInternalSignal = item.subscriptionPattern.startsWith("internal.");
+        const subscription = isInternalSignal
+            ? null
+            : this.agentSystem.signals.subscriptionGet({
+                agentId: this.id,
+                pattern: item.subscriptionPattern
+            });
+        if (!isInternalSignal && !subscription) {
+            return { delivered: false, responseText: null };
+        }
+        const channelSignalData = channelSignalDataParse(item.signal.data);
+        const text = isChannelSignalType(item.signal.type) && channelSignalData
+            ? channelMessageBuild(channelSignalData)
+            : signalMessageBuild(item.signal);
+        const responseText = await this.handleSystemMessage({
+            type: "system_message",
+            text,
+            origin: `signal:${item.signal.id}`,
+            silent: isInternalSignal ? false : (subscription?.silent ?? false),
+            context: {}
+        });
+        return { delivered: true, responseText };
+    }
+    async handleReset(item) {
+        const now = Date.now();
+        const resetMessage = item.message?.trim() ?? "";
+        if (resetMessage.length > 0) {
+            this.state.context = {
+                messages: [buildResetSystemMessage(resetMessage, now, this.id)]
+            };
+        }
+        else {
+            this.state.context = { messages: [] };
+        }
+        this.state.inferenceSessionId = createId();
+        this.state.tokens = null;
+        this.state.updatedAt = now;
+        await agentHistoryAppend(this.agentSystem.config.current, this.id, {
+            type: "reset",
+            at: now,
+            ...(resetMessage.length > 0 ? { message: resetMessage } : {})
+        });
+        await agentStateWrite(this.agentSystem.config.current, this.id, this.state);
+        this.agentSystem.eventBus.emit("agent.reset", {
+            agentId: this.id,
+            context: item.context ?? {}
+        });
+        if (this.descriptor.type !== "user") {
+            return true;
+        }
+        if (!item.context) {
+            return true;
+        }
+        const connector = this.agentSystem.connectorRegistry.get(this.descriptor.connector);
+        if (!connector?.capabilities.sendText) {
+            return true;
+        }
+        try {
+            await connector.sendMessage(this.descriptor.channelId, {
+                text: messageContextReset({ kind: "manual" }),
+                replyToMessageId: item.context?.messageId
+            });
+        }
+        catch (error) {
+            logger.warn({ agentId: this.id, error }, "error: Reset confirmation send failed");
+        }
+        return true;
+    }
+    async handleCompaction(item) {
+        const result = await this.runManualCompaction();
+        if (this.descriptor.type !== "user") {
+            return result.ok;
+        }
+        const connector = this.agentSystem.connectorRegistry.get(this.descriptor.connector);
+        if (!connector?.capabilities.sendText) {
+            return result.ok;
+        }
+        const text = this.compactionResultText(result);
+        try {
+            await connector.sendMessage(this.descriptor.channelId, {
+                text,
+                replyToMessageId: item.context?.messageId
+            });
+        }
+        catch (error) {
+            logger.warn({ agentId: this.id, error }, "error: Compaction command response failed");
+        }
+        return result.ok;
+    }
+    /**
+     * Resets the session when the emergency context limit is exceeded.
+     * Expects: reset record written and state persisted before notifying users.
+     */
+    async handleEmergencyReset(entry, source) {
+        // Estimate token usage before resetting context
+        const history = await agentHistoryLoad(this.agentSystem.config.current, this.id);
+        const estimatedTokens = contextEstimateTokens(history);
+        const reset = {
+            type: "reset",
+            message: "Emergency reset: context overflow detected. Previous session context was cleared."
+        };
+        await this.handleReset(reset);
+        if (this.resolveAgentKind() !== "foreground") {
+            return;
+        }
+        const target = agentDescriptorTargetResolve(this.descriptor);
+        const targetId = target?.targetId ?? null;
+        if (!targetId) {
+            return;
+        }
+        const connector = this.agentSystem.connectorRegistry.get(source);
+        if (!connector?.capabilities.sendText) {
+            return;
+        }
+        try {
+            await connector.sendMessage(targetId, {
+                text: messageContextReset({ kind: "overflow", estimatedTokens }),
+                replyToMessageId: entry.context.messageId
+            });
+        }
+        catch (error) {
+            logger.warn({ agentId: this.id, error }, "error: Failed to notify user about emergency reset");
+        }
+    }
+    async handleRestore(_item) {
+        await this.completePendingToolCalls("session_crashed");
+        const history = await agentHistoryLoad(this.agentSystem.config.current, this.id);
+        const historyMessages = await this.buildHistoryContext(history);
+        this.state.context = {
+            messages: agentRestoreContextResolve(this.state.context.messages ?? [], historyMessages)
+        };
+        this.state.updatedAt = Date.now();
+        await agentStateWrite(this.agentSystem.config.current, this.id, this.state);
+        this.agentSystem.eventBus.emit("agent.restored", { agentId: this.id });
+        return true;
+    }
+    async runManualCompaction() {
+        const messages = this.state.context.messages ?? [];
+        if (messages.length === 0) {
+            return { ok: false, reason: "empty" };
+        }
+        const providers = listActiveInferenceProviders(this.agentSystem.config.current.settings);
+        if (providers.length === 0) {
+            return { ok: false, reason: "no_provider" };
+        }
+        const providerId = this.resolveAgentProvider(providers);
+        const stopCompactionTyping = this.startCompactionTypingIndicator();
+        const compactionAbortController = new AbortController();
+        this.inferenceAbortController = compactionAbortController;
+        try {
+            const compacted = await contextCompact({
+                context: this.state.context,
+                inferenceRouter: this.agentSystem.inferenceRouter,
+                providers,
+                providerId: providerId ?? undefined,
+                inferenceSessionId: this.state.inferenceSessionId ?? this.id,
+                signal: compactionAbortController.signal,
+                compactionLog: {
+                    agentsDir: this.agentSystem.config.current.agentsDir,
+                    agentId: this.id
+                }
+            });
+            const summaryMessage = compacted.messages?.[0];
+            const summaryText = summaryMessage
+                ? messageExtractText(summaryMessage)?.trim() ?? ""
+                : "";
+            if (!summaryText) {
+                return { ok: false, reason: "empty_summary" };
+            }
+            const compactionAt = await this.applyCompactionSummary(summaryText);
+            this.state.updatedAt = compactionAt;
+            await agentStateWrite(this.agentSystem.config.current, this.id, this.state);
+            return { ok: true };
+        }
+        catch (error) {
+            if (isAbortError(error, compactionAbortController.signal)) {
+                logger.info({ agentId: this.id }, "event: Manual compaction aborted");
+                return { ok: false, reason: "aborted" };
+            }
+            logger.warn({ agentId: this.id, error }, "error: Manual compaction failed");
+            return { ok: false, reason: "failed" };
+        }
+        finally {
+            stopCompactionTyping?.();
+            if (this.inferenceAbortController === compactionAbortController) {
+                this.inferenceAbortController = null;
+            }
+        }
+    }
+    compactionResultText(result) {
+        if (result.ok) {
+            return "Session compacted.";
+        }
+        switch (result.reason) {
+            case "empty":
+                return "Nothing to compact yet.";
+            case "empty_summary":
+                return "Compaction produced an empty summary; context unchanged.";
+            case "no_provider":
+                return "Compaction unavailable: no inference provider configured.";
+            case "aborted":
+                return "Compaction aborted.";
+            default:
+                return "Compaction failed.";
+        }
+    }
+    /**
+     * Completes dangling tool calls from persisted history with a synthetic result.
+     * Expects: called before rebuilding context or starting a new inference loop.
+     */
+    async completePendingToolCalls(reason) {
+        const records = await agentHistoryLoadAll(this.agentSystem.config.current, this.id);
+        const pendingRlm = reason === "session_crashed" ? agentHistoryPendingRlmResolve(records) : null;
+        const pendingRlmToolCallId = pendingRlm?.start.toolCallId ?? null;
+        const completionRecords = agentHistoryPendingToolResults(records, reason, Date.now()).filter((record) => !(pendingRlmToolCallId &&
+            record.type === "tool_result" &&
+            record.toolCallId === pendingRlmToolCallId));
+        let completedToolCalls = 0;
+        for (const record of completionRecords) {
+            await agentHistoryAppend(this.agentSystem.config.current, this.id, record);
+            records.push(record);
+            completedToolCalls += 1;
+        }
+        if (pendingRlm) {
+            const appendRecord = async (record) => {
+                await agentHistoryAppend(this.agentSystem.config.current, this.id, record);
+                records.push(record);
+            };
+            const toolCall = pendingRlm.start.toolCallId;
+            let toolResultText = "";
+            let toolResultIsError = false;
+            let restoreMessage = "RLM execution completed after restart. Output: (empty)";
+            if (!pendingRlm.lastSnapshot) {
+                const message = "Process was restarted before any tool call";
+                await appendRecord(rlmHistoryCompleteErrorRecordBuild(toolCall, message));
+                toolResultText = rlmErrorTextBuild(new Error(message));
+                toolResultIsError = true;
+                restoreMessage = `RLM execution failed after restart. ${message}`;
+            }
+            else {
+                const source = this.descriptor.type === "user"
+                    ? this.descriptor.connector
+                    : this.descriptor.type === "system"
+                        ? this.descriptor.tag
+                        : this.descriptor.type;
+                try {
+                    const restored = await rlmRestore(pendingRlm.lastSnapshot, pendingRlm.start, this.agentSystem.toolResolver, this.rlmRestoreContextBuild(source), appendRecord);
+                    toolResultText = rlmResultTextBuild(restored);
+                    restoreMessage = `RLM execution completed after restart. Output: ${restored.output.length > 0 ? restored.output : "(empty)"}`;
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    await appendRecord(rlmHistoryCompleteErrorRecordBuild(toolCall, message, pendingRlm.lastSnapshot.printOutput, pendingRlm.lastSnapshot.toolCallCount));
+                    toolResultText = rlmErrorTextBuild(error);
+                    toolResultIsError = true;
+                    restoreMessage = `RLM execution failed after restart. ${message}`;
+                }
+            }
+            const result = rlmToolResultBuild({ id: toolCall, name: RLM_TOOL_NAME }, toolResultText, toolResultIsError);
+            await appendRecord({
+                type: "tool_result",
+                at: Date.now(),
+                toolCallId: toolCall,
+                output: result
+            });
+            await appendRecord({
+                type: "user_message",
+                at: Date.now(),
+                text: messageBuildSystemText(restoreMessage, "rlm_restore"),
+                files: []
+            });
+            completedToolCalls += 1;
+        }
+        if (completedToolCalls > 0) {
+            const history = await agentHistoryLoad(this.agentSystem.config.current, this.id);
+            const historyMessages = await this.buildHistoryContext(history);
+            this.state.context = {
+                messages: agentRestoreContextResolve(this.state.context.messages ?? [], historyMessages)
+            };
+            this.state.updatedAt = Date.now();
+            await agentStateWrite(this.agentSystem.config.current, this.id, this.state);
+            logger.warn({
+                agentId: this.id,
+                reason,
+                completedToolCalls
+            }, "event: Completed pending tool calls in history");
+        }
+    }
+    rlmRestoreContextBuild(source) {
+        return {
+            connectorRegistry: this.agentSystem.connectorRegistry,
+            fileStore: this.agentSystem.fileStore,
+            auth: this.agentSystem.authStore,
+            logger,
+            assistant: this.agentSystem.config.current.settings.assistant ?? null,
+            permissions: this.state.permissions,
+            agent: this,
+            source,
+            messageContext: {},
+            agentSystem: this.agentSystem,
+            heartbeats: this.agentSystem.heartbeats,
+            toolResolver: this.agentSystem.toolResolver,
+            skills: [],
+            permissionRequestRegistry: this.agentSystem.permissionRequestRegistry
+        };
+    }
+    /**
+     * Notifies a parent agent when a child background agent fails.
+     * Expects: parent agent exists.
+     */
+    async notifySubagentFailure(reason, error) {
+        if (this.descriptor.type !== "subagent" && this.descriptor.type !== "app") {
+            return;
+        }
+        const parentAgentId = this.descriptor.parentAgentId ?? null;
+        if (!parentAgentId) {
+            logger.warn({ agentId: this.id }, "event: Child agent missing parent agent");
+            return;
+        }
+        const name = this.descriptor.name ?? this.descriptor.type;
+        const descriptorType = this.descriptor.type;
+        const errorText = error instanceof Error ? error.message : error ? String(error) : "";
+        const detail = errorText ? `${reason} (${errorText})` : reason;
+        try {
+            await this.agentSystem.post({ agentId: parentAgentId }, {
+                type: "system_message",
+                text: `${descriptorType} ${name} (${this.id}) failed: ${detail}.`,
+                origin: this.id
+            });
+        }
+        catch (sendError) {
+            logger.warn({ agentId: this.id, parentAgentId, error: sendError }, "error: Child agent failure notification failed");
+        }
+    }
+    /**
+     * Resolves the cron task id for this agent when available.
+     * Expects: cron task uid maps to a task on disk.
+     */
+    async resolveCronTaskId() {
+        const descriptor = this.descriptor;
+        if (!agentDescriptorIsCron(descriptor)) {
+            return null;
+        }
+        const tasks = await this.agentSystem.crons.listTasks();
+        const task = tasks.find((entry) => entry.taskUid === descriptor.id) ?? null;
+        return task?.id ?? null;
+    }
+    async listContextTools(toolResolver, source, options) {
+        const tools = toolResolver.listTools();
+        const noToolsModeEnabled = rlmNoToolsModeIs(this.agentSystem.config.current.features);
+        let rlmToolDescription = options?.rlmToolDescription;
+        if (!rlmToolDescription && this.agentSystem.config.current.features.rlm && !noToolsModeEnabled) {
+            rlmToolDescription = await rlmToolDescriptionBuild(tools);
+        }
+        return toolListContextBuild({
+            tools,
+            source,
+            agentKind: options?.agentKind,
+            allowCronTools: options?.allowCronTools,
+            noTools: noToolsModeEnabled,
+            rlm: this.agentSystem.config.current.features.rlm,
+            rlmToolDescription,
+            connectorRegistry: this.agentSystem.connectorRegistry,
+            imageRegistry: this.agentSystem.imageRegistry
+        });
+    }
+    resolveAgentKind() {
+        if (this.descriptor.type === "user") {
+            return "foreground";
+        }
+        return "background";
+    }
+    resolveAgentProvider(providers) {
+        const activeIds = new Set(providers.map((provider) => provider.id));
+        let providerId = this.providerId ?? null;
+        if (!providerId || !activeIds.has(providerId)) {
+            providerId = providers[0]?.id ?? null;
+        }
+        if (providerId && this.providerId !== providerId) {
+            this.providerId = providerId;
+        }
+        return providerId;
+    }
+    /**
+     * Starts typing indication for foreground user agents during long compaction operations.
+     * Expects: connector supports startTyping for the active target.
+     */
+    startCompactionTypingIndicator() {
+        if (this.descriptor.type !== "user") {
+            return null;
+        }
+        const target = agentDescriptorTargetResolve(this.descriptor);
+        if (!target?.targetId) {
+            return null;
+        }
+        const connector = this.agentSystem.connectorRegistry.get(target.connector);
+        return connector?.startTyping?.(target.targetId) ?? null;
+    }
+    async buildHistoryContext(records) {
+        return agentHistoryContext(records, this.id);
+    }
+    async applyCompactionSummary(summaryText) {
+        const summaryWithContinue = `${summaryText}\n\nPlease continue with the user's latest request.`;
+        const compactionAt = Date.now();
+        const resetMessage = "Session context compacted.";
+        this.state.context = {
+            messages: [
+                buildResetSystemMessage(resetMessage, compactionAt, this.id),
+                {
+                    role: "user",
+                    content: summaryWithContinue,
+                    timestamp: compactionAt
+                }
+            ]
+        };
+        this.state.tokens = null;
+        await agentHistoryAppend(this.agentSystem.config.current, this.id, {
+            type: "reset",
+            at: compactionAt,
+            message: resetMessage
+        });
+        await agentHistoryAppend(this.agentSystem.config.current, this.id, {
+            type: "user_message",
+            at: compactionAt,
+            text: summaryWithContinue,
+            files: []
+        });
+        return compactionAt;
+    }
+}
+function isChannelSignalType(type) {
+    return type.startsWith("channel.") && type.endsWith(":message");
+}
+function toFileReferences(files) {
+    return files.map((file) => ({
+        id: file.id,
+        name: file.name,
+        path: file.path,
+        mimeType: file.mimeType,
+        size: file.size
+    }));
+}
+function buildResetSystemMessage(text, at, origin) {
+    return {
+        role: "user",
+        content: messageBuildSystemText(text, origin),
+        timestamp: at
+    };
+}
+function isAbortError(error, signal) {
+    if (signal?.aborted) {
+        return true;
+    }
+    if (error instanceof Error) {
+        return error.name === "AbortError" || error.message.toLowerCase().includes("abort");
+    }
+    return false;
+}
+//# sourceMappingURL=agent.js.map