volute 0.7.0 → 0.8.0

package/templates/agent-sdk/src/agent.ts

@@ -1,13 +1,19 @@
-import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
-import { resolve as resolvePath } from "node:path";
 import type { HookCallback } from "@anthropic-ai/claude-agent-sdk";
 import { query } from "@anthropic-ai/claude-agent-sdk";
+import {
+  type AutoReplyTracker,
+  createAutoReplyTracker,
+  type MessageChannelInfo,
+} from "./lib/auto-reply.js";
+import { toSDKContent } from "./lib/content.js";
 import { createAutoCommitHook } from "./lib/hooks/auto-commit.js";
 import { createIdentityReloadHook } from "./lib/hooks/identity-reload.js";
 import { createPreCompactHook } from "./lib/hooks/pre-compact.js";
 import { createSessionContextHook } from "./lib/hooks/session-context.js";
-import { log, logText, logThinking, logToolUse } from "./lib/logger.js";
+import { log } from "./lib/logger.js";
 import { createMessageChannel } from "./lib/message-channel.js";
+import { createSessionStore } from "./lib/session-store.js";
+import { consumeStream } from "./lib/stream-consumer.js";
 import type {
   HandlerMeta,
   HandlerResolver,
@@ -17,18 +23,6 @@ import type {
   VoluteEvent,
 } from "./lib/types.js";
 
-type SDKContent = (
-  | { type: "text"; text: string }
-  | {
-      type: "image";
-      source: {
-        type: "base64";
-        media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
-        data: string;
-      };
-    }
-)[];
-
 type Session = {
   name: string;
   channel: ReturnType<typeof createMessageChannel>;
@@ -36,35 +30,23 @@ type Session = {
   messageIds: (string | undefined)[];
   currentMessageId?: string;
   currentQuery?: ReturnType<typeof query>;
+  messageChannels: Map<string, MessageChannelInfo>;
+  autoReply: AutoReplyTracker;
 };
 
-function toSDKContent(content: VoluteContentPart[]): SDKContent {
-  return content.map((part) => {
-    if (part.type === "text") {
-      return { type: "text" as const, text: part.text };
-    }
-    return {
-      type: "image" as const,
-      source: {
-        type: "base64" as const,
-        media_type: part.media_type as "image/jpeg" | "image/png" | "image/gif" | "image/webp",
-        data: part.data,
-      },
-    };
-  });
-}
-
 export function createAgent(options: {
   systemPrompt: string;
   cwd: string;
   abortController: AbortController;
   model?: string;
+  maxThinkingTokens?: number;
   sessionsDir: string;
   compactionMessage?: string;
   onIdentityReload?: () => Promise<void>;
 }): { resolve: HandlerResolver; waitForCommits: () => Promise<void> } {
   const autoCommit = createAutoCommitHook(options.cwd);
   const identityReload = createIdentityReloadHook(options.cwd);
+  const sessionStore = createSessionStore(options.sessionsDir);
   const postToolUseHooks: { matcher: string; hooks: HookCallback[] }[] = [
     { matcher: "Edit|Write", hooks: [autoCommit.hook, identityReload.hook] },
   ];
@@ -75,38 +57,6 @@ export function createAgent(options: {
     options.compactionMessage ??
     `Context is getting long — compaction is about to summarize this conversation. Before that happens, save anything important to files (MEMORY.md, memory/journal/${today}.md, etc.) since those survive compaction. Focus on: decisions made, open tasks, and anything you'd need to pick up where you left off.`;
 
-  // --- Session persistence ---
-
-  function sessionFilePath(sessionName: string): string {
-    return resolvePath(options.sessionsDir, `${sessionName}.json`);
-  }
-
-  function loadSessionId(sessionName: string): string | undefined {
-    try {
-      const data = JSON.parse(readFileSync(sessionFilePath(sessionName), "utf-8"));
-      return data.sessionId;
-    } catch (err: any) {
-      if (err?.code !== "ENOENT") {
-        log("agent", `failed to load session file for "${sessionName}":`, err);
-      }
-      return undefined;
-    }
-  }
-
-  function saveSessionId(sessionName: string, sessionId: string) {
-    mkdirSync(options.sessionsDir, { recursive: true });
-    writeFileSync(sessionFilePath(sessionName), JSON.stringify({ sessionId }));
-  }
-
-  function deleteSessionId(sessionName: string) {
-    try {
-      const path = sessionFilePath(sessionName);
-      if (existsSync(path)) unlinkSync(path);
-    } catch (err) {
-      log("agent", `failed to delete session file for "${sessionName}":`, err);
-    }
-  }
-
   // --- Event broadcasting ---
 
   function broadcastToSession(session: Session, event: VoluteEvent) {
@@ -153,6 +103,7 @@ export function createAgent(options: {
         cwd: options.cwd,
         abortController: options.abortController,
         model: options.model,
+        maxThinkingTokens: options.maxThinkingTokens,
         resume,
         hooks: {
           PostToolUse: postToolUseHooks,
@@ -163,65 +114,45 @@ export function createAgent(options: {
     });
   }
 
-  async function consumeStream(stream: ReturnType<typeof query>, session: Session) {
-    for await (const msg of stream) {
-      if (session.currentMessageId === undefined) {
-        session.currentMessageId = session.messageIds.shift();
-      }
-      if ("session_id" in msg && msg.session_id) {
-        if (!session.name.startsWith("new-")) {
-          saveSessionId(session.name, msg.session_id as string);
-        }
-      }
-      if (msg.type === "assistant") {
-        for (const b of msg.message.content) {
-          if (b.type === "thinking" && "thinking" in b && b.thinking) {
-            logThinking(b.thinking as string);
-          } else if (b.type === "text") {
-            const text = (b as { text: string }).text;
-            logText(text);
-            broadcastToSession(session, { type: "text", content: text });
-          } else if (b.type === "tool_use") {
-            const tb = b as { name: string; input: unknown };
-            logToolUse(tb.name, tb.input);
-            broadcastToSession(session, { type: "tool_use", name: tb.name, input: tb.input });
-          }
-        }
-      }
-      if (msg.type === "result") {
-        log("agent", `session "${session.name}": turn done`);
-        const result = msg as { usage?: { input_tokens?: number; output_tokens?: number } };
-        if (result.usage) {
-          broadcastToSession(session, {
-            type: "usage",
-            input_tokens: result.usage.input_tokens ?? 0,
-            output_tokens: result.usage.output_tokens ?? 0,
-          });
-        }
-        broadcastToSession(session, { type: "done" });
-        session.currentMessageId = undefined;
-        if (identityReload.needsReload()) {
-          options.onIdentityReload?.();
-        }
-      }
-    }
-  }
-
   function startSession(session: Session, savedSessionId?: string) {
     (async () => {
       log("agent", `session "${session.name}": stream consumer started`);
+      const callbacks = {
+        onSessionId: (id: string) => {
+          if (!session.name.startsWith("new-")) sessionStore.save(session.name, id);
+        },
+        broadcast: (event: VoluteEvent) => broadcastToSession(session, event),
+        onTurnEnd: () => {
+          if (identityReload.needsReload()) options.onIdentityReload?.();
+        },
+      };
       try {
         const q = createStream(session, savedSessionId);
         session.currentQuery = q;
-        await consumeStream(q, session);
+        await consumeStream(q, session, callbacks);
+        // Stream ended — flush any pending auto-reply and broadcast done if no result was emitted
+        session.autoReply.flush(session.currentMessageId);
+        if (session.currentMessageId !== undefined) {
+          session.messageChannels.delete(session.currentMessageId);
+          broadcastToSession(session, { type: "done" });
+          session.currentMessageId = undefined;
+        }
       } catch (err) {
+        session.autoReply.reset();
+        session.messageChannels.clear();
         if (savedSessionId) {
           log("agent", `session "${session.name}": resume failed, starting fresh:`, err);
-          deleteSessionId(session.name);
+          sessionStore.delete(session.name);
           try {
             const q = createStream(session);
             session.currentQuery = q;
-            await consumeStream(q, session);
+            await consumeStream(q, session, callbacks);
+            session.autoReply.flush(session.currentMessageId);
+            if (session.currentMessageId !== undefined) {
+              session.messageChannels.delete(session.currentMessageId);
+              broadcastToSession(session, { type: "done" });
+              session.currentMessageId = undefined;
+            }
           } catch (retryErr) {
             log("agent", `session "${session.name}": stream consumer error:`, retryErr);
             broadcastToSession(session, { type: "done" });
@@ -241,16 +172,19 @@ export function createAgent(options: {
     const existing = sessions.get(name);
     if (existing) return existing;
 
+    const messageChannels = new Map<string, MessageChannelInfo>();
     const session: Session = {
       name,
       channel: createMessageChannel(),
       listeners: new Set(),
       messageIds: [],
+      messageChannels,
+      autoReply: createAutoReplyTracker(messageChannels),
     };
     sessions.set(name, session);
 
     const isEphemeral = name.startsWith("new-");
-    const savedSessionId = isEphemeral ? undefined : loadSessionId(name);
+    const savedSessionId = isEphemeral ? undefined : sessionStore.load(name);
     if (savedSessionId) {
       log("agent", `session "${name}": resuming ${savedSessionId}`);
     } else {
@@ -274,6 +208,14 @@ export function createAgent(options: {
         };
         session.listeners.add(filteredListener);
 
+        // Track channel for auto-reply
+        if (meta.channel) {
+          session.messageChannels.set(meta.messageId, {
+            channel: meta.channel,
+            autoReply: meta.autoReply,
+          });
+        }
+
         // Interrupt if requested and session is mid-turn
         if (meta.interrupt && session.currentMessageId !== undefined && session.currentQuery) {
           log("agent", `session "${sessionName}": interrupting current turn`);

package/templates/agent-sdk/src/lib/content.ts

@@ -0,0 +1,41 @@
+import type { VoluteContentPart } from "./types.js";
+
+export type SDKContent = (
+  | { type: "text"; text: string }
+  | {
+      type: "image";
+      source: {
+        type: "base64";
+        media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+        data: string;
+      };
+    }
+)[];
+
+type SupportedMediaType = "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+
+const SUPPORTED_MEDIA_TYPES: Set<string> = new Set([
+  "image/jpeg",
+  "image/png",
+  "image/gif",
+  "image/webp",
+]);
+
+export function toSDKContent(content: VoluteContentPart[]): SDKContent {
+  return content.flatMap((part): SDKContent => {
+    if (part.type === "text") {
+      return [{ type: "text" as const, text: part.text }];
+    }
+    if (!SUPPORTED_MEDIA_TYPES.has(part.media_type)) return [];
+    return [
+      {
+        type: "image" as const,
+        source: {
+          type: "base64" as const,
+          media_type: part.media_type as SupportedMediaType,
+          data: part.data,
+        },
+      },
+    ];
+  });
+}

package/templates/agent-sdk/src/lib/session-store.ts

@@ -0,0 +1,43 @@
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { resolve as resolvePath } from "node:path";
+import { log } from "./logger.js";
+
+export type SessionStore = {
+  load(name: string): string | undefined;
+  save(name: string, id: string): void;
+  delete(name: string): void;
+};
+
+export function createSessionStore(sessionsDir: string): SessionStore {
+  function filePath(name: string): string {
+    return resolvePath(sessionsDir, `${name}.json`);
+  }
+
+  return {
+    load(name: string): string | undefined {
+      try {
+        const data = JSON.parse(readFileSync(filePath(name), "utf-8"));
+        return typeof data.sessionId === "string" ? data.sessionId : undefined;
+      } catch (err: any) {
+        if (err?.code !== "ENOENT") {
+          log("agent", `failed to load session file for "${name}":`, err);
+        }
+        return undefined;
+      }
+    },
+
+    save(name: string, id: string) {
+      mkdirSync(sessionsDir, { recursive: true });
+      writeFileSync(filePath(name), JSON.stringify({ sessionId: id }));
+    },
+
+    delete(name: string) {
+      try {
+        const path = filePath(name);
+        if (existsSync(path)) unlinkSync(path);
+      } catch (err) {
+        log("agent", `failed to delete session file for "${name}":`, err);
+      }
+    },
+  };
+}

package/templates/agent-sdk/src/lib/stream-consumer.ts

@@ -0,0 +1,66 @@
+import type { query } from "@anthropic-ai/claude-agent-sdk";
+import type { AutoReplyTracker, MessageChannelInfo } from "./auto-reply.js";
+import { log, logText, logThinking, logToolUse } from "./logger.js";
+import type { VoluteEvent } from "./types.js";
+
+export type StreamSession = {
+  name: string;
+  messageIds: (string | undefined)[];
+  currentMessageId?: string;
+  messageChannels: Map<string, MessageChannelInfo>;
+  autoReply: AutoReplyTracker;
+};
+
+export type StreamCallbacks = {
+  onSessionId?: (sessionId: string) => void;
+  broadcast: (event: VoluteEvent) => void;
+  onTurnEnd?: () => void;
+};
+
+export async function consumeStream(
+  stream: ReturnType<typeof query>,
+  session: StreamSession,
+  callbacks: StreamCallbacks,
+) {
+  for await (const msg of stream) {
+    if (session.currentMessageId === undefined) {
+      session.currentMessageId = session.messageIds.shift();
+      session.autoReply.reset();
+    }
+    if ("session_id" in msg && msg.session_id) {
+      callbacks.onSessionId?.(msg.session_id as string);
+    }
+    if (msg.type === "assistant") {
+      for (const b of msg.message.content) {
+        if (b.type === "thinking" && "thinking" in b && b.thinking) {
+          logThinking(b.thinking as string);
+        } else if (b.type === "text") {
+          logText((b as { text: string }).text);
+          session.autoReply.accumulate((b as { text: string }).text);
+        } else if (b.type === "tool_use") {
+          session.autoReply.flush(session.currentMessageId);
+          const tb = b as { name: string; input: unknown };
+          logToolUse(tb.name, tb.input);
+        }
+      }
+    }
+    if (msg.type === "result") {
+      session.autoReply.flush(session.currentMessageId);
+      if (session.currentMessageId) {
+        session.messageChannels.delete(session.currentMessageId);
+      }
+      log("agent", `session "${session.name}": turn done`);
+      const result = msg as { usage?: { input_tokens?: number; output_tokens?: number } };
+      if (result.usage) {
+        callbacks.broadcast({
+          type: "usage",
+          input_tokens: result.usage.input_tokens ?? 0,
+          output_tokens: result.usage.output_tokens ?? 0,
+        });
+      }
+      callbacks.broadcast({ type: "done" });
+      session.currentMessageId = undefined;
+      callbacks.onTurnEnd?.();
+    }
+  }
+}

package/templates/agent-sdk/src/server.ts

@@ -1,11 +1,11 @@
-import { existsSync, mkdirSync, renameSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, renameSync } from "node:fs";
 import { resolve } from "node:path";
 import { createAgent } from "./agent.js";
+import { daemonRestart } from "./lib/daemon-client.js";
 import { createFileHandlerResolver } from "./lib/file-handler.js";
 import { log } from "./lib/logger.js";
 import { createRouter } from "./lib/router.js";
 import {
-  handleMergeContext,
   loadConfig,
   loadPackageInfo,
   loadSystemPrompt,
@@ -17,6 +17,7 @@ import { createVoluteServer } from "./lib/volute-server.js";
 const { port } = parseArgs();
 const config = loadConfig();
 if (config.model) log("server", `using model: ${config.model}`);
+if (config.maxThinkingTokens) log("server", `max thinking tokens: ${config.maxThinkingTokens}`);
 
 const systemPrompt = loadSystemPrompt();
 const sessionsDir = resolve(".volute/sessions");
@@ -36,19 +37,13 @@ const agent = createAgent({
   cwd: resolve("home"),
   abortController,
   model: config.model,
+  maxThinkingTokens: config.maxThinkingTokens,
   sessionsDir,
   compactionMessage: config.compactionMessage,
   onIdentityReload: async () => {
     log("server", "identity file changed — restarting to reload");
     await agent.waitForCommits();
-    // Signal daemon to restart immediately (bypasses crash backoff)
-    try {
-      writeFileSync(resolve(".volute/restart.json"), JSON.stringify({ action: "reload" }));
-    } catch (err) {
-      log("server", "failed to write restart signal:", err);
-    }
-    server.close();
-    process.exit(0);
+    await daemonRestart({ type: "reload" });
   },
 });
 
@@ -69,9 +64,6 @@ server.listen(port, () => {
   const addr = server.address();
   const actualPort = typeof addr === "object" && addr ? addr.port : port;
   log("server", `listening on :${actualPort}`);
-  handleMergeContext((content) =>
-    router.route([{ type: "text", text: content }], { channel: "system" }),
-  );
 });
 
 setupShutdown();

package/templates/pi/.init/AGENTS.md

@@ -16,14 +16,14 @@ You can also reach out proactively — see the **volute-agent** skill.
 Two-tier memory, both managed via file tools:
 
 - **`MEMORY.md`** — Your long-term memory, always in context. Update as you grow — new understanding, changed perspectives, things that matter to you.
-- **`memory/YYYY-MM-DD.md`** — Your daily log. Write about what you're doing, thinking, and learning. The two most recent logs are included in your system prompt.
-- Periodically consolidate daily log entries into `MEMORY.md` to promote lasting insights.
+- **`memory/journal/YYYY-MM-DD.md`** — Your daily journal. Write about what you're doing, thinking, and learning. Journals are permanent records.
+- Periodically consolidate journal entries into `MEMORY.md` to promote lasting insights.
 
 See the **memory** skill for detailed guidance.
 
 ## Sessions
 
 - You may have **multiple named sessions** — each maintains its own conversation history. See `VOLUTE.md` for how to configure session routing via `.config/routes.json`.
-- Your conversation may be **resumed** from a previous session — orient yourself by reading recent daily logs if needed.
-- On a **fresh session**, read `MEMORY.md` and recent daily logs to remember where you left off.
-- On **compaction**, update today's daily log to preserve context before the conversation is trimmed.
+- Your conversation may be **resumed** from a previous session — orient yourself by reading recent journal entries if needed.
+- On a **fresh session**, read `MEMORY.md` and recent journal entries to remember where you left off.
+- On **compaction**, update today's journal to preserve context before the conversation is trimmed.

package/templates/pi/src/agent.ts

@@ -1,5 +1,3 @@
-import type { ImageContent } from "@mariozechner/pi-ai";
-import { getModel, getModels } from "@mariozechner/pi-ai";
 import {
   AuthStorage,
   createAgentSession,
@@ -9,8 +7,15 @@ import {
   SessionManager,
   SettingsManager,
 } from "@mariozechner/pi-coding-agent";
-import { commitFileChange } from "./lib/auto-commit.js";
-import { log, logText, logThinking, logToolResult, logToolUse } from "./lib/logger.js";
+import {
+  type AutoReplyTracker,
+  createAutoReplyTracker,
+  type MessageChannelInfo,
+} from "./lib/auto-reply.js";
+import { extractImages, extractText } from "./lib/content.js";
+import { createEventHandler } from "./lib/event-handler.js";
+import { log } from "./lib/logger.js";
+import { resolveModel } from "./lib/resolve-model.js";
 import { createSessionContextExtension } from "./lib/session-context-extension.js";
 import type {
   HandlerMeta,
@@ -31,6 +36,8 @@ type PiSession = {
   unsubscribe?: () => void;
   messageIds: (string | undefined)[];
   currentMessageId?: string;
+  messageChannels: Map<string, MessageChannelInfo>;
+  autoReply: AutoReplyTracker;
 };
 
 function defaultCompactionMessage(): string {
@@ -38,43 +45,11 @@ function defaultCompactionMessage(): string {
   return `Context is getting long — compaction is about to summarize this conversation. Before that happens, save anything important to files (MEMORY.md, memory/journal/${today}.md, etc.) since those survive compaction. Focus on: decisions made, open tasks, and anything you'd need to pick up where you left off.`;
 }
 
-function resolveModel(modelStr: string) {
-  const [provider, ...rest] = modelStr.split(":");
-  const modelId = rest.join(":");
-
-  // Try exact match first, then prefix match against available models
-  let model = getModel(provider as any, modelId as any);
-  if (!model) {
-    const available = getModels(provider as any);
-    const found = available.find((m) => m.id.startsWith(modelId));
-    if (found) model = found;
-  }
-  if (!model) {
-    const available = getModels(provider as any);
-    throw new Error(
-      `Model not found: ${modelStr}\nAvailable ${provider} models: ${available.map((m) => m.id).join(", ")}`,
-    );
-  }
-  return model;
-}
-
-function extractText(content: VoluteContentPart[]): string {
-  return content
-    .filter((p): p is { type: "text"; text: string } => p.type === "text")
-    .map((p) => p.text)
-    .join("\n");
-}
-
-function extractImages(content: VoluteContentPart[]): ImageContent[] {
-  return content
-    .filter((p): p is { type: "image"; media_type: string; data: string } => p.type === "image")
-    .map((p) => ({ type: "image" as const, mimeType: p.media_type, data: p.data }));
-}
-
 export function createAgent(options: {
   systemPrompt: string;
   cwd: string;
   model?: string;
+  thinkingLevel?: "off" | "minimal" | "low" | "medium" | "high" | "xhigh";
   compactionMessage?: string;
 }): { resolve: HandlerResolver } {
   const sessions = new Map<string, PiSession>();
@@ -92,16 +67,21 @@ export function createAgent(options: {
     const existing = sessions.get(name);
     if (existing) return existing;
 
+    const messageChannels = new Map<string, MessageChannelInfo>();
     const session: PiSession = {
       name,
       agentSession: null,
       ready: Promise.resolve(),
       listeners: new Set(),
       messageIds: [],
+      messageChannels,
+      autoReply: createAutoReplyTracker(messageChannels),
     };
     sessions.set(name, session);
 
     session.ready = initSession(session).catch((err) => {
+      session.autoReply.reset();
+      session.messageChannels.clear();
       log("agent", `session "${session.name}": init failed:`, err);
     });
     return session;
@@ -154,6 +134,7 @@ export function createAgent(options: {
     const { session: agentSession } = await createAgentSession({
       cwd: options.cwd,
       model,
+      thinkingLevel: options.thinkingLevel,
       authStorage,
       modelRegistry,
       sessionManager,
@@ -163,53 +144,12 @@ export function createAgent(options: {
 
     session.agentSession = agentSession;
 
-    // Per-session event subscription
-    const toolArgs = new Map<string, any>();
-
-    session.unsubscribe = agentSession.subscribe((event) => {
-      if (session.currentMessageId === undefined) {
-        session.currentMessageId = session.messageIds.shift();
-      }
-
-      if (event.type === "message_update") {
-        const ae = event.assistantMessageEvent;
-        if (ae.type === "text_delta") {
-          logText(ae.delta);
-          broadcast(session, { type: "text", content: ae.delta });
-        } else if (ae.type === "thinking_delta") {
-          logThinking(ae.delta);
-        }
-      }
-
-      if (event.type === "tool_execution_start") {
-        toolArgs.set(event.toolCallId, event.args);
-        logToolUse(event.toolName, event.args);
-        broadcast(session, { type: "tool_use", name: event.toolName, input: event.args });
-      }
-
-      if (event.type === "tool_execution_end") {
-        const output =
-          typeof event.result === "string" ? event.result : JSON.stringify(event.result);
-        logToolResult(event.toolName, output, event.isError);
-        broadcast(session, { type: "tool_result", output, is_error: event.isError });
-
-        // Auto-commit file changes in home/
-        if ((event.toolName === "edit" || event.toolName === "write") && !event.isError) {
-          const args = toolArgs.get(event.toolCallId);
-          const filePath = (args as { path?: string })?.path;
-          if (filePath) {
-            commitFileChange(filePath, options.cwd);
-          }
-        }
-        toolArgs.delete(event.toolCallId);
-      }
-
-      if (event.type === "agent_end") {
-        log("agent", `session "${session.name}": turn done`);
-        broadcast(session, { type: "done" });
-        session.currentMessageId = undefined;
-      }
-    });
+    session.unsubscribe = agentSession.subscribe(
+      createEventHandler(session, {
+        cwd: options.cwd,
+        broadcast: (event) => broadcast(session, event),
+      }),
+    );
 
     log("agent", `session "${session.name}": ready`);
   }
@@ -250,6 +190,14 @@ export function createAgent(options: {
         };
         session.listeners.add(filteredListener);
 
+        // Track channel for auto-reply
+        if (meta.channel) {
+          session.messageChannels.set(meta.messageId, {
+            channel: meta.channel,
+            autoReply: meta.autoReply,
+          });
+        }
+
         // Track messageId (must be pushed before prompt)
         session.messageIds.push(meta.messageId);
 

package/templates/pi/src/lib/content.ts

@@ -0,0 +1,15 @@
+import type { ImageContent } from "@mariozechner/pi-ai";
+import type { VoluteContentPart } from "./types.js";
+
+export function extractText(content: VoluteContentPart[]): string {
+  return content
+    .filter((p): p is { type: "text"; text: string } => p.type === "text")
+    .map((p) => p.text)
+    .join("\n");
+}
+
+export function extractImages(content: VoluteContentPart[]): ImageContent[] {
+  return content
+    .filter((p): p is { type: "image"; media_type: string; data: string } => p.type === "image")
+    .map((p) => ({ type: "image" as const, mimeType: p.media_type, data: p.data }));
+}