@oyasmi/pipiclaw 0.5.0 → 0.5.2

package/dist/agent.js

@@ -1,782 +1,2 @@
-import { Agent } from "@mariozechner/pi-agent-core";
-import { AgentSession, AuthStorage, convertToLlm, DefaultResourceLoader, ModelRegistry, SessionManager, } from "@mariozechner/pi-coding-agent";
-import { mkdir, writeFile } from "fs/promises";
-import { dirname, join, resolve } from "path";
-import { COMMAND_RESULT_CUSTOM_TYPE, createCommandExtension } from "./command-extension.js";
-import { renderBuiltInHelp } from "./commands.js";
-import { getAgentConfig, getApiKeyForModel, getSoul, loadPipiclawSkills } from "./config-loader.js";
-import { PipiclawSettingsManager } from "./context.js";
-import * as log from "./log.js";
-import { createMemoryCandidateCache } from "./memory-candidates.js";
-import { MemoryLifecycle } from "./memory-lifecycle.js";
-import { recallRelevantMemory } from "./memory-recall.js";
-import { resolveInitialModel } from "./model-utils.js";
-import { APP_HOME_DIR, AUTH_CONFIG_PATH, MODELS_CONFIG_PATH } from "./paths.js";
-import { buildAppendSystemPrompt } from "./prompt-builder.js";
-import { createExecutor } from "./sandbox.js";
-import { discoverSubAgents, formatSubAgentList } from "./sub-agents.js";
-import { createPipiclawTools } from "./tools/index.js";
-function isSilentOutcome(outcome) {
-    return outcome.kind === "silent";
-}
-function isFinalOutcome(outcome) {
-    return outcome.kind === "final";
-}
-function getFinalOutcomeText(outcome) {
-    return isFinalOutcome(outcome) ? outcome.text : null;
-}
-function createModelRegistry(authStorage, modelsJsonPath) {
-    const registryClass = ModelRegistry;
-    return typeof registryClass.create === "function"
-        ? registryClass.create(authStorage, modelsJsonPath)
-        : new registryClass(authStorage, modelsJsonPath);
-}
-// ============================================================================
-// Text helpers
-// ============================================================================
-function truncate(text, maxLen) {
-    if (text.length <= maxLen)
-        return text;
-    return `${text.substring(0, maxLen - 3)}...`;
-}
-const MAX_USER_MESSAGE_CHARS = 12_000;
-const HAN_REGEX = /\p{Script=Han}/u;
-function sanitizeProgressText(text) {
-    return text
-        .replace(/\uFFFC/g, "")
-        .replace(/\r/g, "")
-        .trim();
-}
-function clipUserInput(text, maxChars) {
-    const normalized = text.replace(/\r/g, "").trim();
-    if (normalized.length <= maxChars) {
-        return normalized;
-    }
-    const headChars = Math.floor(maxChars * 0.6);
-    const tailChars = maxChars - headChars;
-    return `${normalized.slice(0, headChars)}\n\n[... omitted ${normalized.length - maxChars} chars ...]\n\n${normalized.slice(-tailChars)}`;
-}
-function formatProgressEntry(kind, text) {
-    const cleaned = sanitizeProgressText(text);
-    if (!cleaned)
-        return "";
-    const normalized = cleaned.replace(/\n+/g, " ").trim();
-    switch (kind) {
-        case "tool":
-            return `Running: ${normalized}`;
-        case "thinking":
-            return `Thinking: ${normalized}`;
-        case "error":
-            return `Error: ${normalized}`;
-        case "assistant":
-            return normalized;
-    }
-}
-function extractToolResultText(result) {
-    if (typeof result === "string") {
-        return result;
-    }
-    if (result &&
-        typeof result === "object" &&
-        "content" in result &&
-        Array.isArray(result.content)) {
-        const content = result.content;
-        const textParts = [];
-        for (const part of content) {
-            if (part.type === "text" && part.text) {
-                textParts.push(part.text);
-            }
-        }
-        if (textParts.length > 0) {
-            return textParts.join("\n");
-        }
-    }
-    return JSON.stringify(result);
-}
-function isSubAgentToolDetails(value) {
-    if (!value || typeof value !== "object" || !("kind" in value) || value.kind !== "subagent") {
-        return false;
-    }
-    if (!("usage" in value)) {
-        return false;
-    }
-    const usage = value.usage;
-    return (!!usage &&
-        typeof usage === "object" &&
-        "input" in usage &&
-        "output" in usage &&
-        "cacheRead" in usage &&
-        "cacheWrite" in usage &&
-        "cost" in usage);
-}
-function mergeSubAgentUsage(totalUsage, details) {
-    totalUsage.input += details.usage.input;
-    totalUsage.output += details.usage.output;
-    totalUsage.cacheRead += details.usage.cacheRead;
-    totalUsage.cacheWrite += details.usage.cacheWrite;
-    totalUsage.cost.input += details.usage.cost.input;
-    totalUsage.cost.output += details.usage.cost.output;
-    totalUsage.cost.cacheRead += details.usage.cost.cacheRead;
-    totalUsage.cost.cacheWrite += details.usage.cost.cacheWrite;
-    totalUsage.cost.total += details.usage.cost.total;
-}
-function extractCustomCommandResultText(message) {
-    if (!message ||
-        typeof message !== "object" ||
-        !("role" in message) ||
-        !("customType" in message) ||
-        message.role !== "custom" ||
-        message.customType !== COMMAND_RESULT_CUSTOM_TYPE) {
-        return null;
-    }
-    const content = message.content;
-    return typeof content === "string" && content.trim() ? content : null;
-}
-function createEmptyRunState() {
-    return {
-        ctx: null,
-        logCtx: null,
-        store: null,
-        queue: null,
-        pendingTools: new Map(),
-        totalUsage: {
-            input: 0,
-            output: 0,
-            cacheRead: 0,
-            cacheWrite: 0,
-            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-        },
-        stopReason: "stop",
-        errorMessage: undefined,
-        finalOutcome: { kind: "none" },
-        finalResponseDelivered: false,
-    };
-}
-function isRecord(value) {
-    return typeof value === "object" && value !== null;
-}
-function isMessageWithRole(value) {
-    return isRecord(value) && typeof value.role === "string";
-}
-function isAssistantEventMessage(value) {
-    return (isMessageWithRole(value) && value.role === "assistant" && Array.isArray(value.content));
-}
-function isThinkingPart(part) {
-    return part.type === "thinking" && typeof part.thinking === "string";
-}
-function isTextPart(part) {
-    return part.type === "text" && typeof part.text === "string";
-}
-function extractLabelFromArgs(args) {
-    if (!isRecord(args)) {
-        return null;
-    }
-    return typeof args.label === "string" && args.label.trim() ? args.label.trim() : null;
-}
-function hasEventType(value, type) {
-    return isRecord(value) && value.type === type;
-}
-function isToolExecutionStartEvent(value) {
-    return (hasEventType(value, "tool_execution_start") &&
-        typeof value.toolCallId === "string" &&
-        typeof value.toolName === "string");
-}
-function isToolExecutionUpdateEvent(value) {
-    return (hasEventType(value, "tool_execution_update") &&
-        typeof value.toolCallId === "string" &&
-        typeof value.toolName === "string");
-}
-function isToolExecutionEndEvent(value) {
-    return (hasEventType(value, "tool_execution_end") &&
-        typeof value.toolCallId === "string" &&
-        typeof value.toolName === "string" &&
-        typeof value.isError === "boolean");
-}
-function isMessageStartEvent(value) {
-    return hasEventType(value, "message_start") && "message" in value;
-}
-function isMessageEndEvent(value) {
-    return hasEventType(value, "message_end") && "message" in value;
-}
-function isTurnEndEvent(value) {
-    return hasEventType(value, "turn_end") && "message" in value && Array.isArray(value.toolResults);
-}
-function isAutoCompactionStartEvent(value) {
-    return hasEventType(value, "auto_compaction_start") && (value.reason === "threshold" || value.reason === "overflow");
-}
-function isAutoCompactionEndEvent(value) {
-    return hasEventType(value, "auto_compaction_end");
-}
-function isAutoRetryStartEvent(value) {
-    return (hasEventType(value, "auto_retry_start") &&
-        typeof value.attempt === "number" &&
-        typeof value.maxAttempts === "number" &&
-        typeof value.errorMessage === "string");
-}
-// ============================================================================
-// ChannelRunner
-// ============================================================================
-class ChannelRunner {
-    constructor(sandboxConfig, channelId, channelDir) {
-        // --- Per run ---
-        this.runState = createEmptyRunState();
-        this.sandboxConfig = sandboxConfig;
-        this.channelId = channelId;
-        this.channelDir = channelDir;
-        const executor = createExecutor(sandboxConfig);
-        this.workspaceDir = resolve(dirname(channelDir));
-        this.workspacePath = executor.getWorkspacePath(this.workspaceDir);
-        // Initial skill summaries
-        const initialSkills = loadPipiclawSkills(channelDir, this.workspacePath);
-        this.currentSkills = initialSkills;
-        // Create session manager
-        const contextFile = join(channelDir, "context.jsonl");
-        this.sessionManager = SessionManager.open(contextFile, channelDir);
-        this.settingsManager = new PipiclawSettingsManager(APP_HOME_DIR);
-        // Create AuthStorage and ModelRegistry
-        const authStorage = AuthStorage.create(AUTH_CONFIG_PATH);
-        this.modelRegistry = createModelRegistry(authStorage, MODELS_CONFIG_PATH);
-        // Resolve model: prefer saved global default, fall back to first available model
-        this.activeModel = resolveInitialModel(this.modelRegistry, this.settingsManager);
-        log.logInfo(`Using model: ${this.activeModel.provider}/${this.activeModel.id} (${this.activeModel.name})`);
-        this.subAgentDiscovery = this.refreshSubAgentDiscovery();
-        // Create tools
-        const tools = createPipiclawTools({
-            executor,
-            getCurrentModel: () => this.activeModel,
-            getAvailableModels: () => this.modelRegistry.getAvailable(),
-            resolveApiKey: async (model) => getApiKeyForModel(this.modelRegistry, model),
-            workspaceDir: this.workspaceDir,
-            channelDir: this.channelDir,
-            workspacePath: this.workspacePath,
-            channelId: this.channelId,
-            sandboxConfig: this.sandboxConfig,
-            getSubAgentDiscovery: () => this.subAgentDiscovery,
-            getMemoryRecallSettings: () => this.settingsManager.getMemoryRecallSettings(),
-        });
-        // Create agent
-        this.agent = new Agent({
-            initialState: {
-                systemPrompt: "",
-                model: this.activeModel,
-                thinkingLevel: "off",
-                tools,
-            },
-            convertToLlm,
-            getApiKey: async () => getApiKeyForModel(this.modelRegistry, this.activeModel),
-        });
-        this.memoryLifecycle = new MemoryLifecycle({
-            channelId: this.channelId,
-            channelDir: this.channelDir,
-            getMessages: () => this.session.messages,
-            getSessionEntries: () => this.sessionManager.getBranch(),
-            getModel: () => this.session.model ?? this.activeModel,
-            resolveApiKey: async (model) => getApiKeyForModel(this.modelRegistry, model),
-            getSessionMemorySettings: () => this.settingsManager.getSessionMemorySettings(),
-        });
-        const resourceLoader = new DefaultResourceLoader({
-            cwd: process.cwd(),
-            agentDir: APP_HOME_DIR,
-            settingsManager: this.settingsManager,
-            extensionFactories: [
-                this.memoryLifecycle.createExtensionFactory(),
-                createCommandExtension({
-                    getCurrentModel: () => this.session.model ?? this.activeModel,
-                    getAvailableModels: async () => {
-                        this.modelRegistry.refresh();
-                        return await this.modelRegistry.getAvailable();
-                    },
-                    getSessionStats: () => this.session.getSessionStats(),
-                    getThinkingLevel: () => this.session.thinkingLevel,
-                    switchModel: async (model) => {
-                        await this.session.setModel(model);
-                        this.activeModel = model;
-                    },
-                    refreshSessionResources: async () => {
-                        await this.refreshSessionResources();
-                    },
-                }),
-            ],
-            appendSystemPromptOverride: (base) => {
-                const soul = getSoul(this.workspaceDir);
-                const sections = [...base];
-                if (soul) {
-                    sections.unshift(soul);
-                }
-                sections.push(buildAppendSystemPrompt(this.workspacePath, this.channelId, this.sandboxConfig, {
-                    subAgentList: formatSubAgentList(this.subAgentDiscovery.agents),
-                }));
-                return sections;
-            },
-            agentsFilesOverride: () => {
-                const agentConfig = getAgentConfig(this.channelDir);
-                return {
-                    agentsFiles: agentConfig ? [{ path: `${this.workspacePath}/AGENTS.md`, content: agentConfig }] : [],
-                };
-            },
-            skillsOverride: (base) => ({
-                skills: [...base.skills, ...this.currentSkills],
-                diagnostics: base.diagnostics,
-            }),
-        });
-        const baseToolsOverride = Object.fromEntries(tools.map((tool) => [tool.name, tool]));
-        // Create AgentSession
-        this.session = new AgentSession({
-            agent: this.agent,
-            sessionManager: this.sessionManager,
-            settingsManager: this.settingsManager,
-            cwd: process.cwd(),
-            modelRegistry: this.modelRegistry,
-            resourceLoader,
-            baseToolsOverride,
-        });
-        // Subscribe to session events
-        this.subscribeToSessionEvents();
-        this.sessionReady = this.initializeSession();
-    }
-    // === Public API ===
-    async run(ctx, store) {
-        this.resetRunState(ctx, store);
-        // Create queue for this run
-        let queueChain = Promise.resolve();
-        this.runState.queue = {
-            enqueue: (fn, errorContext) => {
-                queueChain = queueChain.then(async () => {
-                    try {
-                        await fn();
-                    }
-                    catch (err) {
-                        const errMsg = err instanceof Error ? err.message : String(err);
-                        log.logWarning(`DingTalk API error (${errorContext})`, errMsg);
-                    }
-                });
-            },
-            enqueueMessage: function (text, target, errorContext, doLog = true) {
-                this.enqueue(() => (target === "main" ? ctx.respond(text, doLog) : ctx.respondInThread(text)), errorContext);
-            },
-        };
-        try {
-            await this.ensureSessionReady();
-            // Ensure channel directory exists
-            await mkdir(this.channelDir, { recursive: true });
-            const candidateCache = createMemoryCandidateCache();
-            const clippedInput = clipUserInput(ctx.message.text, MAX_USER_MESSAGE_CHARS);
-            const userMessage = this.formatUserMessage(clippedInput, ctx.message.userName);
-            let promptText = this.shouldPreserveRawInput(ctx.message.text) ? clippedInput : userMessage;
-            let recalledContextText = "";
-            if (!this.shouldPreserveRawInput(ctx.message.text)) {
-                const recallSettings = this.settingsManager.getMemoryRecallSettings();
-                if (recallSettings.enabled) {
-                    const recall = await recallRelevantMemory({
-                        query: clippedInput,
-                        workspaceDir: this.workspaceDir,
-                        channelDir: this.channelDir,
-                        maxCandidates: recallSettings.maxCandidates,
-                        maxInjected: recallSettings.maxInjected,
-                        maxChars: recallSettings.maxChars,
-                        rerankWithModel: recallSettings.rerankWithModel,
-                        autoRerank: HAN_REGEX.test(clippedInput),
-                        model: this.session.model ?? this.activeModel,
-                        resolveApiKey: async (model) => getApiKeyForModel(this.modelRegistry, model),
-                        candidateCache,
-                    });
-                    if (recall.renderedText) {
-                        recalledContextText = recall.renderedText;
-                        promptText = `${recall.renderedText}\n\n<user_message>\n${promptText}\n</user_message>`;
-                    }
-                }
-            }
-            // Debug: write context to last_prompt.json (only with PIPICLAW_DEBUG=1)
-            if (process.env.PIPICLAW_DEBUG) {
-                const debugContext = {
-                    systemPrompt: this.agent.state.systemPrompt,
-                    messages: this.session.messages,
-                    recalledContext: recalledContextText || undefined,
-                    newUserMessage: promptText,
-                };
-                await writeFile(join(this.channelDir, "last_prompt.json"), JSON.stringify(debugContext, null, 2));
-            }
-            await this.session.prompt(promptText);
-        }
-        catch (err) {
-            this.runState.stopReason = "error";
-            this.runState.errorMessage = err instanceof Error ? err.message : String(err);
-            log.logWarning(`[${this.channelId}] Runner failed`, this.runState.errorMessage);
-        }
-        finally {
-            await queueChain;
-            const finalOutcome = this.runState.finalOutcome;
-            const finalOutcomeText = getFinalOutcomeText(finalOutcome);
-            try {
-                if (this.runState.stopReason === "error" &&
-                    this.runState.errorMessage &&
-                    !this.runState.finalResponseDelivered) {
-                    try {
-                        await ctx.replaceMessage("_Sorry, something went wrong_");
-                    }
-                    catch (err) {
-                        const errMsg = err instanceof Error ? err.message : String(err);
-                        log.logWarning("Failed to post error message", errMsg);
-                    }
-                }
-                else if (isSilentOutcome(finalOutcome)) {
-                    try {
-                        await ctx.deleteMessage();
-                        log.logInfo("Silent response - deleted message");
-                    }
-                    catch (err) {
-                        const errMsg = err instanceof Error ? err.message : String(err);
-                        log.logWarning("Failed to delete message for silent response", errMsg);
-                    }
-                }
-                else if (finalOutcomeText && !this.runState.finalResponseDelivered) {
-                    try {
-                        await ctx.replaceMessage(finalOutcomeText);
-                    }
-                    catch (err) {
-                        const errMsg = err instanceof Error ? err.message : String(err);
-                        log.logWarning("Failed to replace message with final text", errMsg);
-                    }
-                }
-                await ctx.flush();
-            }
-            finally {
-                await ctx.close();
-            }
-            // Log usage summary
-            if (this.runState.totalUsage.cost.total > 0) {
-                const messages = this.session.messages;
-                const lastAssistantMessage = messages
-                    .slice()
-                    .reverse()
-                    .find((m) => m.role === "assistant" && m.stopReason !== "aborted");
-                const contextTokens = lastAssistantMessage
-                    ? lastAssistantMessage.usage.input +
-                        lastAssistantMessage.usage.output +
-                        lastAssistantMessage.usage.cacheRead +
-                        lastAssistantMessage.usage.cacheWrite
-                    : 0;
-                const currentRunModel = this.session.model ?? this.activeModel;
-                const contextWindow = currentRunModel.contextWindow || 200000;
-                log.logUsageSummary(this.runState.logCtx, this.runState.totalUsage, contextTokens, contextWindow);
-            }
-            // Clear run state
-            this.runState.ctx = null;
-            this.runState.logCtx = null;
-            this.runState.queue = null;
-        }
-        return { stopReason: this.runState.stopReason, errorMessage: this.runState.errorMessage };
-    }
-    async handleBuiltinCommand(ctx, command) {
-        try {
-            switch (command.name) {
-                case "help":
-                    await this.sendCommandReply(ctx, renderBuiltInHelp());
-                    return;
-                case "stop":
-                    await this.sendCommandReply(ctx, "No task is running. Use `/stop` only while a task is running.");
-                    return;
-                case "steer":
-                    this.requireQueuedMessage(command.args, "steer");
-                    await this.sendCommandReply(ctx, "No task is running. Send the message directly instead of using `/steer`.");
-                    return;
-                case "followup":
-                    this.requireQueuedMessage(command.args, "followup");
-                    await this.sendCommandReply(ctx, "No task is running. Send the message directly now, or use `/followup` while a task is running.");
-                    return;
-            }
-        }
-        catch (err) {
-            const errMsg = err instanceof Error ? err.message : String(err);
-            log.logWarning(`[${this.channelId}] Built-in command failed`, errMsg);
-            await this.sendCommandReply(ctx, `命令执行失败：${errMsg}`);
-        }
-    }
-    async queueSteer(text, userName) {
-        await this.queueBusyMessage("steer", this.requireQueuedMessage(text, "steer"), userName);
-    }
-    async queueFollowUp(text, userName) {
-        await this.queueBusyMessage("followUp", this.requireQueuedMessage(text, "followup"), userName);
-    }
-    async abort() {
-        await this.session.abort();
-    }
-    // === Private helpers ===
-    async sendCommandReply(ctx, text) {
-        const delivered = await ctx.respondPlain(text);
-        if (!delivered) {
-            await ctx.replaceMessage(text);
-            await ctx.flush();
-        }
-    }
-    requireQueuedMessage(text, commandName) {
-        const trimmedText = text.trim();
-        if (!trimmedText) {
-            throw new Error(`/${commandName} requires a message.`);
-        }
-        return trimmedText;
-    }
-    shouldPreserveRawInput(text) {
-        return text.trim().startsWith("/");
-    }
-    formatUserMessage(text, userName, now = new Date()) {
-        const pad = (n) => n.toString().padStart(2, "0");
-        const offset = -now.getTimezoneOffset();
-        const offsetSign = offset >= 0 ? "+" : "-";
-        const offsetHours = pad(Math.floor(Math.abs(offset) / 60));
-        const offsetMins = pad(Math.abs(offset) % 60);
-        const timestamp = `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())} ${pad(now.getHours())}:${pad(now.getMinutes())}:${pad(now.getSeconds())}${offsetSign}${offsetHours}:${offsetMins}`;
-        return `[${timestamp}] [${userName || "unknown"}]: ${text}`;
-    }
-    async queueBusyMessage(delivery, text, userName) {
-        if (!this.session.isStreaming) {
-            throw new Error("No task is currently running.");
-        }
-        const clippedText = clipUserInput(text, MAX_USER_MESSAGE_CHARS);
-        if (clippedText !== text.trim()) {
-            log.logWarning(`[${this.channelId}] Queued message exceeded ${MAX_USER_MESSAGE_CHARS} chars and was clipped`);
-        }
-        await this.session.prompt(this.formatUserMessage(clippedText, userName), {
-            streamingBehavior: delivery,
-        });
-    }
-    resetRunState(ctx, store) {
-        this.runState = createEmptyRunState();
-        this.runState.ctx = ctx;
-        this.runState.logCtx = {
-            channelId: ctx.message.channel,
-            userName: ctx.message.userName,
-            channelName: ctx.channelName,
-        };
-        this.runState.store = store;
-    }
-    async refreshSessionResources() {
-        await this.ensureSessionReady();
-        const skills = loadPipiclawSkills(this.channelDir, this.workspacePath);
-        this.currentSkills = skills;
-        this.subAgentDiscovery = this.refreshSubAgentDiscovery();
-        await this.session.reload();
-    }
-    async initializeSession() {
-        const skills = loadPipiclawSkills(this.channelDir, this.workspacePath);
-        this.currentSkills = skills;
-        this.subAgentDiscovery = this.refreshSubAgentDiscovery();
-        await this.session.reload();
-    }
-    async ensureSessionReady() {
-        await this.sessionReady;
-    }
-    refreshSubAgentDiscovery() {
-        this.modelRegistry.refresh();
-        const discovery = discoverSubAgents(this.workspaceDir, this.modelRegistry.getAvailable());
-        for (const warning of discovery.warnings) {
-            log.logWarning(`Sub-agent config warning (${this.channelId})`, warning);
-        }
-        return discovery;
-    }
-    // === Session event subscription ===
-    subscribeToSessionEvents() {
-        this.session.subscribe(async (event) => {
-            if (!this.runState.ctx || !this.runState.logCtx || !this.runState.queue)
-                return;
-            const { ctx, logCtx, queue, pendingTools, store } = this.runState;
-            if (isToolExecutionStartEvent(event)) {
-                const label = extractLabelFromArgs(event.args) || event.toolName;
-                pendingTools.set(event.toolCallId, {
-                    toolName: event.toolName,
-                    args: event.args,
-                    startTime: Date.now(),
-                });
-                this.memoryLifecycle.noteToolCall();
-                log.logToolStart(logCtx, event.toolName, label, isRecord(event.args) ? event.args : {});
-                queue.enqueue(() => ctx.respond(formatProgressEntry("tool", label), false), "tool label");
-            }
-            else if (isToolExecutionUpdateEvent(event)) {
-                if (event.toolName !== "subagent") {
-                    return;
-                }
-                const partialText = truncate(extractToolResultText(event.partialResult), 200);
-                if (!partialText.trim()) {
-                    return;
-                }
-                queue.enqueue(() => ctx.respond(formatProgressEntry("tool", partialText), false), "tool update");
-            }
-            else if (isToolExecutionEndEvent(event)) {
-                const resultStr = extractToolResultText(event.result);
-                const pending = pendingTools.get(event.toolCallId);
-                pendingTools.delete(event.toolCallId);
-                const durationMs = pending ? Date.now() - pending.startTime : 0;
-                const subAgentDetails = event.toolName === "subagent" &&
-                    isRecord(event.result) &&
-                    "details" in event.result &&
-                    isSubAgentToolDetails(event.result.details)
-                    ? event.result.details
-                    : null;
-                if (subAgentDetails) {
-                    mergeSubAgentUsage(this.runState.totalUsage, subAgentDetails);
-                    const label = pending?.args &&
-                        typeof pending.args === "object" &&
-                        "label" in pending.args &&
-                        typeof pending.args.label === "string"
-                        ? (pending.args.label ?? "subagent").trim()
-                        : "subagent";
-                    queue.enqueue(() => store?.logSubAgentRun(logCtx.channelId, {
-                        date: new Date().toISOString(),
-                        toolCallId: event.toolCallId,
-                        label,
-                        agent: subAgentDetails.agent,
-                        source: subAgentDetails.source,
-                        model: subAgentDetails.model,
-                        tools: [...subAgentDetails.tools],
-                        turns: subAgentDetails.turns,
-                        toolCalls: subAgentDetails.toolCalls,
-                        durationMs: subAgentDetails.durationMs,
-                        failed: subAgentDetails.failed,
-                        failureReason: subAgentDetails.failureReason,
-                        output: resultStr.length > 16000 ? resultStr.slice(0, 16000) : resultStr,
-                        outputTruncated: resultStr.length > 16000,
-                        usage: {
-                            ...subAgentDetails.usage,
-                            cost: { ...subAgentDetails.usage.cost },
-                        },
-                    }) ?? Promise.resolve(), "sub-agent run log");
-                }
-                const treatAsError = event.isError || Boolean(subAgentDetails?.failed);
-                if (treatAsError) {
-                    log.logToolError(logCtx, event.toolName, durationMs, resultStr);
-                }
-                else {
-                    log.logToolSuccess(logCtx, event.toolName, durationMs, resultStr);
-                }
-                if (treatAsError) {
-                    queue.enqueue(() => ctx.respond(formatProgressEntry("error", truncate(resultStr, 200)), false), "tool error");
-                }
-            }
-            else if (isMessageStartEvent(event)) {
-                if (isAssistantEventMessage(event.message)) {
-                    log.logResponseStart(logCtx);
-                }
-            }
-            else if (isMessageEndEvent(event)) {
-                const commandResultText = extractCustomCommandResultText(event.message);
-                if (commandResultText) {
-                    this.runState.finalOutcome = { kind: "final", text: commandResultText };
-                    log.logResponse(logCtx, commandResultText);
-                    queue.enqueue(async () => {
-                        const delivered = await ctx.respondPlain(commandResultText);
-                        if (!delivered) {
-                            await ctx.replaceMessage(commandResultText);
-                        }
-                        this.runState.finalResponseDelivered = true;
-                    }, "command result");
-                    return;
-                }
-                if (isAssistantEventMessage(event.message)) {
-                    const assistantMsg = event.message;
-                    if (assistantMsg.stopReason) {
-                        this.runState.stopReason = assistantMsg.stopReason;
-                    }
-                    if (assistantMsg.errorMessage) {
-                        this.runState.errorMessage = assistantMsg.errorMessage;
-                    }
-                    if (assistantMsg.usage) {
-                        this.runState.totalUsage.input += assistantMsg.usage.input;
-                        this.runState.totalUsage.output += assistantMsg.usage.output;
-                        this.runState.totalUsage.cacheRead += assistantMsg.usage.cacheRead;
-                        this.runState.totalUsage.cacheWrite += assistantMsg.usage.cacheWrite;
-                        this.runState.totalUsage.cost.input += assistantMsg.usage.cost.input;
-                        this.runState.totalUsage.cost.output += assistantMsg.usage.cost.output;
-                        this.runState.totalUsage.cost.cacheRead += assistantMsg.usage.cost.cacheRead;
-                        this.runState.totalUsage.cost.cacheWrite += assistantMsg.usage.cost.cacheWrite;
-                        this.runState.totalUsage.cost.total += assistantMsg.usage.cost.total;
-                    }
-                    const content = assistantMsg.content;
-                    const thinkingParts = [];
-                    const textParts = [];
-                    let hasToolCalls = false;
-                    for (const part of content) {
-                        if (isThinkingPart(part)) {
-                            thinkingParts.push(part.thinking);
-                        }
-                        else if (isTextPart(part)) {
-                            textParts.push(part.text);
-                        }
-                        else if (part.type === "toolCall") {
-                            hasToolCalls = true;
-                        }
-                    }
-                    const text = textParts.join("\n");
-                    for (const thinking of thinkingParts) {
-                        log.logThinking(logCtx, thinking);
-                        queue.enqueue(() => ctx.respond(formatProgressEntry("thinking", thinking), false), "thinking");
-                    }
-                    if (hasToolCalls && text.trim()) {
-                        queue.enqueue(() => ctx.respond(formatProgressEntry("assistant", text), false), "assistant progress");
-                    }
-                }
-            }
-            else if (isTurnEndEvent(event)) {
-                if (isAssistantEventMessage(event.message) && event.toolResults.length === 0) {
-                    if (event.message.stopReason === "error" || event.message.stopReason === "aborted") {
-                        return;
-                    }
-                    const finalText = event.message.content
-                        .filter((part) => part.type === "text" && !!part.text)
-                        .map((part) => part.text)
-                        .join("\n");
-                    const trimmedFinalText = finalText.trim();
-                    if (!trimmedFinalText) {
-                        return;
-                    }
-                    if (trimmedFinalText === "[SILENT]" || trimmedFinalText.startsWith("[SILENT]")) {
-                        this.runState.finalOutcome = { kind: "silent" };
-                        this.memoryLifecycle.noteCompletedAssistantTurn();
-                        return;
-                    }
-                    if (this.runState.finalOutcome.kind === "final" &&
-                        this.runState.finalOutcome.text.trim() === trimmedFinalText) {
-                        return;
-                    }
-                    this.runState.finalOutcome = { kind: "final", text: finalText };
-                    this.memoryLifecycle.noteCompletedAssistantTurn();
-                    log.logResponse(logCtx, finalText);
-                    queue.enqueue(async () => {
-                        const delivered = await ctx.respondPlain(finalText);
-                        if (delivered) {
-                            this.runState.finalResponseDelivered = true;
-                        }
-                    }, "final response");
-                }
-            }
-            else if (isAutoCompactionStartEvent(event)) {
-                log.logInfo(`Auto-compaction started (reason: ${event.reason})`);
-                queue.enqueue(() => ctx.respond(formatProgressEntry("assistant", "Compacting context..."), false), "compaction start");
-            }
-            else if (isAutoCompactionEndEvent(event)) {
-                if (event.result) {
-                    log.logInfo(`Auto-compaction complete: ${event.result.tokensBefore} tokens compacted`);
-                }
-                else if (event.aborted) {
-                    log.logInfo("Auto-compaction aborted");
-                }
-            }
-            else if (isAutoRetryStartEvent(event)) {
-                log.logWarning(`Retrying (${event.attempt}/${event.maxAttempts})`, event.errorMessage);
-                queue.enqueue(() => ctx.respond(formatProgressEntry("assistant", `Retrying (${event.attempt}/${event.maxAttempts})...`), false), "retry");
-            }
-        });
-    }
-}
-// ============================================================================
-// Factory
-// ============================================================================
-const channelRunners = new Map();
-export function getOrCreateRunner(sandboxConfig, channelId, channelDir) {
-    const existing = channelRunners.get(channelId);
-    if (existing)
-        return existing;
-    const runner = new ChannelRunner(sandboxConfig, channelId, channelDir);
-    channelRunners.set(channelId, runner);
-    return runner;
-}
+export { ChannelRunner, getOrCreateRunner } from "./agent/index.js";
 //# sourceMappingURL=agent.js.map