loudmouth-ai 0.1.0

package/dist/agents/pi-embedded-runner/session-manager-cache.js

@@ -0,0 +1,54 @@
+import { Buffer } from "node:buffer";
+import fs from "node:fs/promises";
+import { isCacheEnabled, resolveCacheTtlMs } from "../../config/cache-utils.js";
+const SESSION_MANAGER_CACHE = new Map();
+const DEFAULT_SESSION_MANAGER_TTL_MS = 45_000; // 45 seconds
+function getSessionManagerTtl() {
+    return resolveCacheTtlMs({
+        envValue: process.env.CLAWDBOT_SESSION_MANAGER_CACHE_TTL_MS,
+        defaultTtlMs: DEFAULT_SESSION_MANAGER_TTL_MS,
+    });
+}
+function isSessionManagerCacheEnabled() {
+    return isCacheEnabled(getSessionManagerTtl());
+}
+export function trackSessionManagerAccess(sessionFile) {
+    if (!isSessionManagerCacheEnabled())
+        return;
+    const now = Date.now();
+    SESSION_MANAGER_CACHE.set(sessionFile, {
+        sessionFile,
+        loadedAt: now,
+    });
+}
+function isSessionManagerCached(sessionFile) {
+    if (!isSessionManagerCacheEnabled())
+        return false;
+    const entry = SESSION_MANAGER_CACHE.get(sessionFile);
+    if (!entry)
+        return false;
+    const now = Date.now();
+    const ttl = getSessionManagerTtl();
+    return now - entry.loadedAt <= ttl;
+}
+export async function prewarmSessionFile(sessionFile) {
+    if (!isSessionManagerCacheEnabled())
+        return;
+    if (isSessionManagerCached(sessionFile))
+        return;
+    try {
+        // Read a small chunk to encourage OS page cache warmup.
+        const handle = await fs.open(sessionFile, "r");
+        try {
+            const buffer = Buffer.alloc(4096);
+            await handle.read(buffer, 0, buffer.length, 0);
+        }
+        finally {
+            await handle.close();
+        }
+        trackSessionManagerAccess(sessionFile);
+    }
+    catch {
+        // File doesn't exist yet, SessionManager will create it
+    }
+}

package/dist/agents/pi-embedded-runner/session-manager-init.js

@@ -0,0 +1,31 @@
+import fs from "node:fs/promises";
+/**
+ * pi-coding-agent SessionManager persistence quirk:
+ * - If the file exists but has no assistant message, SessionManager marks itself `flushed=true`
+ *   and will never persist the initial user message.
+ * - If the file doesn't exist yet, SessionManager builds a new session in memory and flushes
+ *   header+user+assistant once the first assistant arrives (good).
+ *
+ * This normalizes the file/session state so the first user prompt is persisted before the first
+ * assistant entry, even for pre-created session files.
+ */
+export async function prepareSessionManagerForRun(params) {
+    const sm = params.sessionManager;
+    const header = sm.fileEntries.find((e) => e.type === "session");
+    const hasAssistant = sm.fileEntries.some((e) => e.type === "message" && e.message?.role === "assistant");
+    if (!params.hadSessionFile && header) {
+        header.id = params.sessionId;
+        header.cwd = params.cwd;
+        sm.sessionId = params.sessionId;
+        return;
+    }
+    if (params.hadSessionFile && header && !hasAssistant) {
+        // Reset file so the first assistant flush includes header+user+assistant in order.
+        await fs.writeFile(params.sessionFile, "", "utf-8");
+        sm.fileEntries = [header];
+        sm.byId?.clear?.();
+        sm.labelsById?.clear?.();
+        sm.leafId = null;
+        sm.flushed = false;
+    }
+}

package/dist/agents/pi-embedded-runner/system-prompt.js

@@ -0,0 +1,33 @@
+import { buildAgentSystemPrompt } from "../system-prompt.js";
+import { buildToolSummaryMap } from "../tool-summaries.js";
+export function buildEmbeddedSystemPrompt(params) {
+    return buildAgentSystemPrompt({
+        workspaceDir: params.workspaceDir,
+        defaultThinkLevel: params.defaultThinkLevel,
+        reasoningLevel: params.reasoningLevel,
+        extraSystemPrompt: params.extraSystemPrompt,
+        ownerNumbers: params.ownerNumbers,
+        reasoningTagHint: params.reasoningTagHint,
+        heartbeatPrompt: params.heartbeatPrompt,
+        skillsPrompt: params.skillsPrompt,
+        docsPath: params.docsPath,
+        ttsHint: params.ttsHint,
+        workspaceNotes: params.workspaceNotes,
+        reactionGuidance: params.reactionGuidance,
+        promptMode: params.promptMode,
+        runtimeInfo: params.runtimeInfo,
+        messageToolHints: params.messageToolHints,
+        sandboxInfo: params.sandboxInfo,
+        toolNames: params.tools.map((tool) => tool.name),
+        toolSummaries: buildToolSummaryMap(params.tools),
+        modelAliasLines: params.modelAliasLines,
+        userTimezone: params.userTimezone,
+        userTime: params.userTime,
+        userTimeFormat: params.userTimeFormat,
+        contextFiles: params.contextFiles,
+    });
+}
+export function createSystemPromptOverride(systemPrompt) {
+    const trimmed = systemPrompt.trim();
+    return () => trimmed;
+}

package/dist/agents/pi-embedded-runner/tool-split.js

@@ -0,0 +1,8 @@
+import { toToolDefinitions } from "../pi-tool-definition-adapter.js";
+export function splitSdkTools(options) {
+    const { tools } = options;
+    return {
+        builtInTools: [],
+        customTools: toToolDefinitions(tools),
+    };
+}

package/dist/agents/pi-embedded-runner/types.js

@@ -0,0 +1 @@
+export {};

package/dist/agents/pi-embedded-runner/utils.js

@@ -0,0 +1,25 @@
+export function mapThinkingLevel(level) {
+    // pi-agent-core supports "xhigh"; Clawdbot enables it for specific models.
+    if (!level)
+        return "off";
+    return level;
+}
+export function resolveExecToolDefaults(config) {
+    const tools = config?.tools;
+    if (!tools?.exec)
+        return undefined;
+    return tools.exec;
+}
+export function describeUnknownError(error) {
+    if (error instanceof Error)
+        return error.message;
+    if (typeof error === "string")
+        return error;
+    try {
+        const serialized = JSON.stringify(error);
+        return serialized ?? "Unknown error";
+    }
+    catch {
+        return "Unknown error";
+    }
+}

package/dist/agents/pi-embedded-runner.js

@@ -0,0 +1,10 @@
+export { compactEmbeddedPiSession } from "./pi-embedded-runner/compact.js";
+export { applyExtraParamsToAgent, resolveExtraParams } from "./pi-embedded-runner/extra-params.js";
+export { applyGoogleTurnOrderingFix } from "./pi-embedded-runner/google.js";
+export { getDmHistoryLimitFromSessionKey, limitHistoryTurns, } from "./pi-embedded-runner/history.js";
+export { resolveEmbeddedSessionLane } from "./pi-embedded-runner/lanes.js";
+export { runEmbeddedPiAgent } from "./pi-embedded-runner/run.js";
+export { abortEmbeddedPiRun, isEmbeddedPiRunActive, isEmbeddedPiRunStreaming, queueEmbeddedPiMessage, waitForEmbeddedPiRunEnd, } from "./pi-embedded-runner/runs.js";
+export { buildEmbeddedSandboxInfo } from "./pi-embedded-runner/sandbox-info.js";
+export { createSystemPromptOverride } from "./pi-embedded-runner/system-prompt.js";
+export { splitSdkTools } from "./pi-embedded-runner/tool-split.js";

package/dist/agents/pi-embedded-subscribe.handlers.js

@@ -0,0 +1,45 @@
+import { handleAgentEnd, handleAgentStart, handleAutoCompactionEnd, handleAutoCompactionStart, } from "./pi-embedded-subscribe.handlers.lifecycle.js";
+import { handleMessageEnd, handleMessageStart, handleMessageUpdate, } from "./pi-embedded-subscribe.handlers.messages.js";
+import { handleToolExecutionEnd, handleToolExecutionStart, handleToolExecutionUpdate, } from "./pi-embedded-subscribe.handlers.tools.js";
+export function createEmbeddedPiSessionEventHandler(ctx) {
+    return (evt) => {
+        switch (evt.type) {
+            case "message_start":
+                handleMessageStart(ctx, evt);
+                return;
+            case "message_update":
+                handleMessageUpdate(ctx, evt);
+                return;
+            case "message_end":
+                handleMessageEnd(ctx, evt);
+                return;
+            case "tool_execution_start":
+                // Async handler - best-effort typing indicator, avoids blocking tool summaries.
+                // Catch rejections to avoid unhandled promise rejection crashes.
+                handleToolExecutionStart(ctx, evt).catch((err) => {
+                    ctx.log.debug(`tool_execution_start handler failed: ${String(err)}`);
+                });
+                return;
+            case "tool_execution_update":
+                handleToolExecutionUpdate(ctx, evt);
+                return;
+            case "tool_execution_end":
+                handleToolExecutionEnd(ctx, evt);
+                return;
+            case "agent_start":
+                handleAgentStart(ctx);
+                return;
+            case "auto_compaction_start":
+                handleAutoCompactionStart(ctx);
+                return;
+            case "auto_compaction_end":
+                handleAutoCompactionEnd(ctx, evt);
+                return;
+            case "agent_end":
+                handleAgentEnd(ctx);
+                return;
+            default:
+                return;
+        }
+    };
+}

package/dist/agents/pi-embedded-subscribe.handlers.lifecycle.js

@@ -0,0 +1,86 @@
+import { emitAgentEvent } from "../infra/agent-events.js";
+import { createInlineCodeState } from "../markdown/code-spans.js";
+export function handleAgentStart(ctx) {
+    ctx.log.debug(`embedded run agent start: runId=${ctx.params.runId}`);
+    emitAgentEvent({
+        runId: ctx.params.runId,
+        stream: "lifecycle",
+        data: {
+            phase: "start",
+            startedAt: Date.now(),
+        },
+    });
+    void ctx.params.onAgentEvent?.({
+        stream: "lifecycle",
+        data: { phase: "start" },
+    });
+}
+export function handleAutoCompactionStart(ctx) {
+    ctx.state.compactionInFlight = true;
+    ctx.ensureCompactionPromise();
+    ctx.log.debug(`embedded run compaction start: runId=${ctx.params.runId}`);
+    emitAgentEvent({
+        runId: ctx.params.runId,
+        stream: "compaction",
+        data: { phase: "start" },
+    });
+    void ctx.params.onAgentEvent?.({
+        stream: "compaction",
+        data: { phase: "start" },
+    });
+}
+export function handleAutoCompactionEnd(ctx, evt) {
+    ctx.state.compactionInFlight = false;
+    const willRetry = Boolean(evt.willRetry);
+    if (willRetry) {
+        ctx.noteCompactionRetry();
+        ctx.resetForCompactionRetry();
+        ctx.log.debug(`embedded run compaction retry: runId=${ctx.params.runId}`);
+    }
+    else {
+        ctx.maybeResolveCompactionWait();
+    }
+    emitAgentEvent({
+        runId: ctx.params.runId,
+        stream: "compaction",
+        data: { phase: "end", willRetry },
+    });
+    void ctx.params.onAgentEvent?.({
+        stream: "compaction",
+        data: { phase: "end", willRetry },
+    });
+}
+export function handleAgentEnd(ctx) {
+    ctx.log.debug(`embedded run agent end: runId=${ctx.params.runId}`);
+    emitAgentEvent({
+        runId: ctx.params.runId,
+        stream: "lifecycle",
+        data: {
+            phase: "end",
+            endedAt: Date.now(),
+        },
+    });
+    void ctx.params.onAgentEvent?.({
+        stream: "lifecycle",
+        data: { phase: "end" },
+    });
+    if (ctx.params.onBlockReply) {
+        if (ctx.blockChunker?.hasBuffered()) {
+            ctx.blockChunker.drain({ force: true, emit: ctx.emitBlockChunk });
+            ctx.blockChunker.reset();
+        }
+        else if (ctx.state.blockBuffer.length > 0) {
+            ctx.emitBlockChunk(ctx.state.blockBuffer);
+            ctx.state.blockBuffer = "";
+        }
+    }
+    ctx.state.blockState.thinking = false;
+    ctx.state.blockState.final = false;
+    ctx.state.blockState.inlineCode = createInlineCodeState();
+    if (ctx.state.pendingCompactionRetry > 0) {
+        ctx.resolveCompactionRetry();
+    }
+    else {
+        ctx.maybeResolveCompactionWait();
+    }
+}

package/dist/agents/pi-embedded-subscribe.handlers.messages.js

@@ -0,0 +1,230 @@
+import { parseReplyDirectives } from "../auto-reply/reply/reply-directives.js";
+import { emitAgentEvent } from "../infra/agent-events.js";
+import { isMessagingToolDuplicateNormalized, normalizeTextForComparison, } from "./pi-embedded-helpers.js";
+import { appendRawStream } from "./pi-embedded-subscribe.raw-stream.js";
+import { extractAssistantText, extractAssistantThinking, extractThinkingFromTaggedStream, extractThinkingFromTaggedText, formatReasoningMessage, promoteThinkingTagsToBlocks, } from "./pi-embedded-utils.js";
+import { createInlineCodeState } from "../markdown/code-spans.js";
+export function handleMessageStart(ctx, evt) {
+    const msg = evt.message;
+    if (msg?.role !== "assistant")
+        return;
+    // KNOWN: Resetting at `text_end` is unsafe (late/duplicate end events).
+    // ASSUME: `message_start` is the only reliable boundary for “new assistant message begins”.
+    // Start-of-message is a safer reset point than message_end: some providers
+    // may deliver late text_end updates after message_end, which would otherwise
+    // re-trigger block replies.
+    ctx.resetAssistantMessageState(ctx.state.assistantTexts.length);
+    // Use assistant message_start as the earliest "writing" signal for typing.
+    void ctx.params.onAssistantMessageStart?.();
+}
+export function handleMessageUpdate(ctx, evt) {
+    const msg = evt.message;
+    if (msg?.role !== "assistant")
+        return;
+    const assistantEvent = evt.assistantMessageEvent;
+    const assistantRecord = assistantEvent && typeof assistantEvent === "object"
+        ? assistantEvent
+        : undefined;
+    const evtType = typeof assistantRecord?.type === "string" ? assistantRecord.type : "";
+    if (evtType !== "text_delta" && evtType !== "text_start" && evtType !== "text_end") {
+        return;
+    }
+    const delta = typeof assistantRecord?.delta === "string" ? assistantRecord.delta : "";
+    const content = typeof assistantRecord?.content === "string" ? assistantRecord.content : "";
+    appendRawStream({
+        ts: Date.now(),
+        event: "assistant_text_stream",
+        runId: ctx.params.runId,
+        sessionId: ctx.params.session.id,
+        evtType,
+        delta,
+        content,
+    });
+    let chunk = "";
+    if (evtType === "text_delta") {
+        chunk = delta;
+    }
+    else if (evtType === "text_start" || evtType === "text_end") {
+        if (delta) {
+            chunk = delta;
+        }
+        else if (content) {
+            // KNOWN: Some providers resend full content on `text_end`.
+            // We only append a suffix (or nothing) to keep output monotonic.
+            if (content.startsWith(ctx.state.deltaBuffer)) {
+                chunk = content.slice(ctx.state.deltaBuffer.length);
+            }
+            else if (ctx.state.deltaBuffer.startsWith(content)) {
+                chunk = "";
+            }
+            else if (!ctx.state.deltaBuffer.includes(content)) {
+                chunk = content;
+            }
+        }
+    }
+    if (chunk) {
+        ctx.state.deltaBuffer += chunk;
+        if (ctx.blockChunker) {
+            ctx.blockChunker.append(chunk);
+        }
+        else {
+            ctx.state.blockBuffer += chunk;
+        }
+    }
+    if (ctx.state.streamReasoning) {
+        // Handle partial <think> tags: stream whatever reasoning is visible so far.
+        ctx.emitReasoningStream(extractThinkingFromTaggedStream(ctx.state.deltaBuffer));
+    }
+    const next = ctx
+        .stripBlockTags(ctx.state.deltaBuffer, {
+        thinking: false,
+        final: false,
+        inlineCode: createInlineCodeState(),
+    })
+        .trim();
+    if (next && next !== ctx.state.lastStreamedAssistant) {
+        const previousText = ctx.state.lastStreamedAssistant ?? "";
+        const { text: cleanedText, mediaUrls } = parseReplyDirectives(next);
+        const { text: previousCleanedText } = parseReplyDirectives(previousText);
+        if (cleanedText.startsWith(previousCleanedText)) {
+            const deltaText = cleanedText.slice(previousCleanedText.length);
+            ctx.state.lastStreamedAssistant = next;
+            emitAgentEvent({
+                runId: ctx.params.runId,
+                stream: "assistant",
+                data: {
+                    text: cleanedText,
+                    delta: deltaText,
+                    mediaUrls: mediaUrls?.length ? mediaUrls : undefined,
+                },
+            });
+            void ctx.params.onAgentEvent?.({
+                stream: "assistant",
+                data: {
+                    text: cleanedText,
+                    delta: deltaText,
+                    mediaUrls: mediaUrls?.length ? mediaUrls : undefined,
+                },
+            });
+            if (ctx.params.onPartialReply && ctx.state.shouldEmitPartialReplies) {
+                void ctx.params.onPartialReply({
+                    text: cleanedText,
+                    mediaUrls: mediaUrls?.length ? mediaUrls : undefined,
+                });
+            }
+        }
+    }
+    if (ctx.params.onBlockReply && ctx.blockChunking && ctx.state.blockReplyBreak === "text_end") {
+        ctx.blockChunker?.drain({ force: false, emit: ctx.emitBlockChunk });
+    }
+    if (evtType === "text_end" && ctx.state.blockReplyBreak === "text_end") {
+        if (ctx.blockChunker?.hasBuffered()) {
+            ctx.blockChunker.drain({ force: true, emit: ctx.emitBlockChunk });
+            ctx.blockChunker.reset();
+        }
+        else if (ctx.state.blockBuffer.length > 0) {
+            ctx.emitBlockChunk(ctx.state.blockBuffer);
+            ctx.state.blockBuffer = "";
+        }
+    }
+}
+export function handleMessageEnd(ctx, evt) {
+    const msg = evt.message;
+    if (msg?.role !== "assistant")
+        return;
+    const assistantMessage = msg;
+    promoteThinkingTagsToBlocks(assistantMessage);
+    const rawText = extractAssistantText(assistantMessage);
+    appendRawStream({
+        ts: Date.now(),
+        event: "assistant_message_end",
+        runId: ctx.params.runId,
+        sessionId: ctx.params.session.id,
+        rawText,
+        rawThinking: extractAssistantThinking(assistantMessage),
+    });
+    const text = ctx.stripBlockTags(rawText, { thinking: false, final: false });
+    const rawThinking = ctx.state.includeReasoning || ctx.state.streamReasoning
+        ? extractAssistantThinking(assistantMessage) || extractThinkingFromTaggedText(rawText)
+        : "";
+    const formattedReasoning = rawThinking ? formatReasoningMessage(rawThinking) : "";
+    const addedDuringMessage = ctx.state.assistantTexts.length > ctx.state.assistantTextBaseline;
+    const chunkerHasBuffered = ctx.blockChunker?.hasBuffered() ?? false;
+    ctx.finalizeAssistantTexts({ text, addedDuringMessage, chunkerHasBuffered });
+    const onBlockReply = ctx.params.onBlockReply;
+    const shouldEmitReasoning = Boolean(ctx.state.includeReasoning &&
+        formattedReasoning &&
+        onBlockReply &&
+        formattedReasoning !== ctx.state.lastReasoningSent);
+    const shouldEmitReasoningBeforeAnswer = shouldEmitReasoning && ctx.state.blockReplyBreak === "message_end" && !addedDuringMessage;
+    const maybeEmitReasoning = () => {
+        if (!shouldEmitReasoning || !formattedReasoning)
+            return;
+        ctx.state.lastReasoningSent = formattedReasoning;
+        void onBlockReply?.({ text: formattedReasoning });
+    };
+    if (shouldEmitReasoningBeforeAnswer)
+        maybeEmitReasoning();
+    if ((ctx.state.blockReplyBreak === "message_end" ||
+        (ctx.blockChunker ? ctx.blockChunker.hasBuffered() : ctx.state.blockBuffer.length > 0)) &&
+        text &&
+        onBlockReply) {
+        if (ctx.blockChunker?.hasBuffered()) {
+            ctx.blockChunker.drain({ force: true, emit: ctx.emitBlockChunk });
+            ctx.blockChunker.reset();
+        }
+        else if (text !== ctx.state.lastBlockReplyText) {
+            // Check for duplicates before emitting (same logic as emitBlockChunk).
+            const normalizedText = normalizeTextForComparison(text);
+            if (isMessagingToolDuplicateNormalized(normalizedText, ctx.state.messagingToolSentTextsNormalized)) {
+                ctx.log.debug(`Skipping message_end block reply - already sent via messaging tool: ${text.slice(0, 50)}...`);
+            }
+            else {
+                ctx.state.lastBlockReplyText = text;
+                const splitResult = ctx.consumeReplyDirectives(text, { final: true });
+                if (splitResult) {
+                    const { text: cleanedText, mediaUrls, audioAsVoice, replyToId, replyToTag, replyToCurrent, } = splitResult;
+                    // Emit if there's content OR audioAsVoice flag (to propagate the flag).
+                    if (cleanedText || (mediaUrls && mediaUrls.length > 0) || audioAsVoice) {
+                        void onBlockReply({
+                            text: cleanedText,
+                            mediaUrls: mediaUrls?.length ? mediaUrls : undefined,
+                            audioAsVoice,
+                            replyToId,
+                            replyToTag,
+                            replyToCurrent,
+                        });
+                    }
+                }
+            }
+        }
+    }
+    if (!shouldEmitReasoningBeforeAnswer)
+        maybeEmitReasoning();
+    if (ctx.state.streamReasoning && rawThinking) {
+        ctx.emitReasoningStream(rawThinking);
+    }
+    if (ctx.state.blockReplyBreak === "text_end" && onBlockReply) {
+        const tailResult = ctx.consumeReplyDirectives("", { final: true });
+        if (tailResult) {
+            const { text: cleanedText, mediaUrls, audioAsVoice, replyToId, replyToTag, replyToCurrent, } = tailResult;
+            if (cleanedText || (mediaUrls && mediaUrls.length > 0) || audioAsVoice) {
+                void onBlockReply({
+                    text: cleanedText,
+                    mediaUrls: mediaUrls?.length ? mediaUrls : undefined,
+                    audioAsVoice,
+                    replyToId,
+                    replyToTag,
+                    replyToCurrent,
+                });
+            }
+        }
+    }
+    ctx.state.deltaBuffer = "";
+    ctx.state.blockBuffer = "";
+    ctx.blockChunker?.reset();
+    ctx.state.blockState.thinking = false;
+    ctx.state.blockState.final = false;
+    ctx.state.blockState.inlineCode = createInlineCodeState();
+    ctx.state.lastStreamedAssistant = undefined;
+}