@townco/agent 0.1.116 → 0.1.118

package/dist/acp-server/adapter.d.ts

@@ -19,10 +19,10 @@ export interface CitationSource {
     id: string;
     url: string;
     title: string;
-    snippet?: string;
-    favicon?: string;
+    snippet?: string | undefined;
+    favicon?: string | undefined;
     toolCallId: string;
-    sourceName?: string;
+    sourceName?: string | undefined;
 }
 /**
  * Error thrown when mid-turn compaction requires the turn to be restarted

package/dist/acp-server/adapter.js

@@ -671,11 +671,17 @@ export class AgentAcpAdapter {
     async saveSessionToDisk(sessionId, session) {
         if (!this.noSession && this.storage) {
             try {
-                await this.storage.saveSession(sessionId, session.messages, session.context);
+                // Build citation storage from current session state
+                const citations = {
+                    sources: session.sources,
+                    nextId: session.sourceCounter + 1,
+                };
+                await this.storage.saveSession(sessionId, session.messages, session.context, citations);
                 logger.debug("Saved session to disk", {
                     sessionId,
                     messageCount: session.messages.length,
                     contextCount: session.context.length,
+                    citationsCount: session.sources.length,
                 });
             }
             catch (error) {
@@ -814,19 +820,25 @@ export class AgentAcpAdapter {
         }
         // Save repaired session if changes were made
         if (sessionRepaired && this.storage) {
-            await this.storage.saveSession(params.sessionId, storedSession.messages, storedSession.context);
+            await this.storage.saveSession(params.sessionId, storedSession.messages, storedSession.context, storedSession.citations);
             logger.info("Saved repaired session", { sessionId: params.sessionId });
         }
         // Restore session in active sessions map
+        // Restore citations from stored session to avoid ID conflicts
         this.sessions.set(params.sessionId, {
             pendingPrompt: null,
             messages: storedSession.messages,
             context: storedSession.context,
             requestParams: { cwd: process.cwd(), mcpServers: [] },
             isCancelled: false,
-            sourceCounter: 0,
-            sources: [],
+            sourceCounter: storedSession.citations?.nextId ?? 0,
+            sources: storedSession.citations?.sources ?? [],
+            ...(storedSession.citations && {
+                persistedCitations: storedSession.citations,
+            }),
         });
+        // Track whether we have persisted citations to skip re-extraction during replay
+        const hasPersistedCitations = (storedSession.citations?.sources.length ?? 0) > 0;
         // Replay conversation history to client with ordered content blocks
         logger.info(`Replaying ${storedSession.messages.length} messages for session ${params.sessionId}`);
         for (const msg of storedSession.messages) {
@@ -918,25 +930,27 @@ export class AgentAcpAdapter {
                             sessionId: params.sessionId,
                             update: outputUpdate,
                         });
-                        // Extract sources from replayed tool output
-                        const session = this.sessions.get(params.sessionId);
-                        if (session) {
-                            const extractedSources = this.extractSourcesFromToolOutput(block.title, block.rawOutput, block.id, session);
-                            if (extractedSources.length > 0) {
-                                session.sources.push(...extractedSources);
-                                // Emit sources notification to client during replay
-                                this.connection.sessionUpdate({
-                                    sessionId: params.sessionId,
-                                    update: {
-                                        sessionUpdate: "sources",
-                                        sources: extractedSources,
-                                    },
-                                });
-                                logger.info("Extracted sources during session replay", {
-                                    toolCallId: block.id,
-                                    toolName: block.title,
-                                    sourcesCount: extractedSources.length,
-                                });
+                        // Extract sources from replayed tool output (skip if we have persisted citations)
+                        if (!hasPersistedCitations) {
+                            const session = this.sessions.get(params.sessionId);
+                            if (session) {
+                                const extractedSources = this.extractSourcesFromToolOutput(block.title, block.rawOutput, block.id, session);
+                                if (extractedSources.length > 0) {
+                                    session.sources.push(...extractedSources);
+                                    // Emit sources notification to client during replay
+                                    this.connection.sessionUpdate({
+                                        sessionId: params.sessionId,
+                                        update: {
+                                            sessionUpdate: "sources",
+                                            sources: extractedSources,
+                                        },
+                                    });
+                                    logger.info("Extracted sources during session replay", {
+                                        toolCallId: block.id,
+                                        toolName: block.title,
+                                        sourcesCount: extractedSources.length,
+                                    });
+                                }
                             }
                         }
                     }
@@ -955,6 +969,20 @@ export class AgentAcpAdapter {
                 }
             }
         }
+        // Emit persisted citations AFTER message replay so UI can associate them with tool calls
+        if (hasPersistedCitations && storedSession.citations?.sources) {
+            this.connection.sessionUpdate({
+                sessionId: params.sessionId,
+                update: {
+                    sessionUpdate: "sources",
+                    sources: storedSession.citations.sources,
+                },
+            });
+            logger.info("Emitted persisted citations after replay", {
+                sessionId: params.sessionId,
+                citationsCount: storedSession.citations.sources.length,
+            });
+        }
         // After replay completes, send the latest context size to the UI
         const latestContext = storedSession.context.length > 0
             ? storedSession.context[storedSession.context.length - 1]
@@ -1500,8 +1528,7 @@ export class AgentAcpAdapter {
                     }
                     // Forward tool_call_update with _meta to the client (for subagent connection info, etc.)
                     if (updateMsg._meta) {
-                        const subagentCompletedValue = updateMsg._meta
-                            ?.subagentCompleted;
+                        const subagentCompletedValue = updateMsg._meta?.subagentCompleted;
                         this.connection.sessionUpdate({
                             sessionId: params.sessionId,
                             update: {
@@ -1584,6 +1611,51 @@ export class AgentAcpAdapter {
                             rawOutput = cleanOutput;
                         }
                         if (rawOutput && !this.noSession) {
+                            // IMPORTANT: Extract citations BEFORE hook execution
+                            // Hooks may compact/modify rawOutput, losing citation data
+                            // We extract from the original output to preserve citation sources
+                            const rawOutputForCitations = rawOutput;
+                            logger.debug("Extracting citations BEFORE compaction hooks", {
+                                toolCallId: outputMsg.toolCallId,
+                                toolName: toolCallBlock.title,
+                                rawOutputType: typeof rawOutputForCitations,
+                            });
+                            // Handle subagent tool outputs first
+                            const subagentResult = this.extractSubagentSources(rawOutput, outputMsg.toolCallId);
+                            if (subagentResult && subagentResult.sources.length > 0) {
+                                session.sources.push(...subagentResult.sources);
+                                this.connection.sessionUpdate({
+                                    sessionId: params.sessionId,
+                                    update: {
+                                        sessionUpdate: "sources",
+                                        sources: subagentResult.sources,
+                                    },
+                                });
+                                logger.info("Extracted citation sources from subagent (pre-compaction)", {
+                                    toolCallId: outputMsg.toolCallId,
+                                    sourcesCount: subagentResult.sources.length,
+                                });
+                            }
+                            // Extract from regular tool outputs (WebSearch, WebFetch, MCP tools)
+                            const subagentHadSources = subagentResult && subagentResult.sources.length > 0;
+                            if (!subagentHadSources) {
+                                const extractedSources = this.extractSourcesFromToolOutput(toolCallBlock.title, rawOutput, outputMsg.toolCallId, session);
+                                if (extractedSources.length > 0) {
+                                    session.sources.push(...extractedSources);
+                                    this.connection.sessionUpdate({
+                                        sessionId: params.sessionId,
+                                        update: {
+                                            sessionUpdate: "sources",
+                                            sources: extractedSources,
+                                        },
+                                    });
+                                    logger.info("Extracted citation sources from tool output (pre-compaction)", {
+                                        toolCallId: outputMsg.toolCallId,
+                                        toolName: toolCallBlock.title,
+                                        sourcesCount: extractedSources.length,
+                                    });
+                                }
+                            }
                             // Execute tool_response hooks if configured
                             const hooks = this.agent.definition.hooks ?? [];
                             if (hooks.some((h) => h.type === "tool_response")) {
@@ -1750,60 +1822,8 @@ export class AgentAcpAdapter {
                         if (rawOutput) {
                             toolCallBlock.rawOutput = rawOutput;
                         }
-                        // Handle subagent tool outputs - extract citation sources
-                        // Subagent tools return { text: string, sources: CitationSource[] }
-                        // Sources are already re-numbered by the runner with unique IDs (1001+, 2001+, etc.)
-                        const rawOutputForLog = rawOutput;
-                        logger.debug("Checking for subagent sources in tool output", {
-                            toolCallId: outputMsg.toolCallId,
-                            toolName: toolCallBlock.title,
-                            rawOutputType: typeof rawOutputForLog,
-                            rawOutputPreview: typeof rawOutputForLog === "string"
-                                ? rawOutputForLog.slice(0, 200)
-                                : typeof rawOutputForLog === "object" && rawOutputForLog
-                                    ? JSON.stringify(rawOutputForLog).slice(0, 200)
-                                    : String(rawOutputForLog),
-                        });
-                        const subagentResult = this.extractSubagentSources(rawOutput, outputMsg.toolCallId);
-                        if (subagentResult && subagentResult.sources.length > 0) {
-                            // Add sources to session (already uniquely numbered)
-                            session.sources.push(...subagentResult.sources);
-                            // Emit sources notification to client
-                            this.connection.sessionUpdate({
-                                sessionId: params.sessionId,
-                                update: {
-                                    sessionUpdate: "sources",
-                                    sources: subagentResult.sources,
-                                },
-                            });
-                            logger.info("Extracted citation sources from subagent", {
-                                toolCallId: outputMsg.toolCallId,
-                                sourcesCount: subagentResult.sources.length,
-                            });
-                        }
-                        // Extract citation sources from tool output (WebSearch, WebFetch, MCP tools)
-                        // Skip if we already extracted sources from a subagent result (with actual sources)
-                        const subagentHadSources = subagentResult && subagentResult.sources.length > 0;
-                        if (!subagentHadSources) {
-                            const extractedSources = this.extractSourcesFromToolOutput(toolCallBlock.title, rawOutput, outputMsg.toolCallId, session);
-                            if (extractedSources.length > 0) {
-                                // Add to session sources
-                                session.sources.push(...extractedSources);
-                                // Emit sources notification to client
-                                this.connection.sessionUpdate({
-                                    sessionId: params.sessionId,
-                                    update: {
-                                        sessionUpdate: "sources",
-                                        sources: extractedSources,
-                                    },
-                                });
-                                logger.info("Extracted citation sources from tool output", {
-                                    toolCallId: outputMsg.toolCallId,
-                                    toolName: toolCallBlock.title,
-                                    sourcesCount: extractedSources.length,
-                                });
-                            }
-                        }
+                        // NOTE: Citation extraction moved to BEFORE hook execution (around line 2138)
+                        // to ensure citations are captured before any compaction modifies rawOutput
                         // Store truncation warning if present (for UI display)
                         if (truncationWarning) {
                             if (!toolCallBlock._meta) {
@@ -2320,10 +2340,12 @@ export class AgentAcpAdapter {
         };
         const hookExecutor = new HookExecutor(hooks, this.agent.definition.model, (callbackRef) => loadHookCallback(callbackRef, this.agentDir), sendHookNotification, this.agent.definition);
         // Create read-only session view for hooks
+        // Include citations so compaction hooks can inject them into summaries
         const readonlySession = {
             messages: session.messages,
             context: session.context,
             requestParams: session.requestParams,
+            citations: session.sources,
         };
         // Get input token count from latest context entry
         const latestContext = session.context.length > 0

package/dist/acp-server/http.js

@@ -259,6 +259,19 @@ export function createAcpHttpApp(agent, agentDir, agentName) {
                                 const stream = sseStreams.get(msgSessionId);
                                 if (stream) {
                                     try {
+                                        // Check if this is a sources message
+                                        const isSourcesMsg = rawMsg &&
+                                            typeof rawMsg === "object" &&
+                                            "params" in rawMsg &&
+                                            rawMsg.params?.update?.sessionUpdate === "sources";
+                                        if (isSourcesMsg) {
+                                            const sourcesCount = rawMsg.params?.update?.sources?.length;
+                                            logger.info("🔶 SENDING LARGE SOURCES VIA DIRECT SSE", {
+                                                sessionId: msgSessionId,
+                                                sourcesCount,
+                                                compressedSize,
+                                            });
+                                        }
                                         await stream.writeSSE({
                                             event: "message",
                                             data: JSON.stringify(rawMsg),
@@ -798,7 +811,21 @@ export function createAcpHttpApp(agent, agentDir, agentName) {
                         return;
                     }
                 }
-                logger.trace("Sending SSE message", { sessionId, channel });
+                // Check if this is a sources message and log prominently
+                const isSourcesMsg = json &&
+                    typeof json === "object" &&
+                    "params" in json &&
+                    json.params?.update?.sessionUpdate === "sources";
+                if (isSourcesMsg) {
+                    logger.info("🔶 SENDING SOURCES VIA SSE", {
+                        sessionId,
+                        channel,
+                        sourcesCount: json.params?.update?.sources?.length,
+                    });
+                }
+                else {
+                    logger.trace("Sending SSE message", { sessionId, channel });
+                }
                 await stream.writeSSE({
                     event: "message",
                     data: JSON.stringify(json),

package/dist/acp-server/session-storage.d.ts

@@ -25,6 +25,8 @@ export interface SubagentToolCallBlock {
     prettyName?: string | undefined;
     icon?: string | undefined;
     status: "pending" | "in_progress" | "completed" | "failed";
+    rawInput?: Record<string, unknown> | undefined;
+    rawOutput?: Record<string, unknown> | undefined;
 }
 /**
  * Content block for sub-agent messages - either text or a tool call
@@ -149,6 +151,30 @@ export interface StoredSession {
     messages: SessionMessage[];
     context: ContextEntry[];
     metadata: SessionMetadata;
+    /** Persisted citation sources - survives compaction and session reload */
+    citations?: CitationStorage | undefined;
+}
+/**
+ * Citation source persisted in session storage
+ * Matches CitationSource from adapter.ts and SourceSchema from UI
+ */
+export interface PersistedCitationSource {
+    id: string;
+    url: string;
+    title: string;
+    snippet?: string | undefined;
+    favicon?: string | undefined;
+    toolCallId: string;
+    sourceName?: string | undefined;
+}
+/**
+ * Citation storage structure for session persistence
+ */
+export interface CitationStorage {
+    /** All citation sources accumulated in this session */
+    sources: PersistedCitationSource[];
+    /** Next citation ID to use (to avoid ID conflicts after reload) */
+    nextId: number;
 }
 /**
  * File-based session storage
@@ -181,7 +207,7 @@ export declare class SessionStorage {
      * Save a session to disk
      * Uses atomic write (write to temp file, then rename)
      */
-    saveSession(sessionId: string, messages: SessionMessage[], context: ContextEntry[]): Promise<void>;
+    saveSession(sessionId: string, messages: SessionMessage[], context: ContextEntry[], citations?: CitationStorage): Promise<void>;
     /**
      * Load a session from disk
      */

package/dist/acp-server/session-storage.js

@@ -32,6 +32,8 @@ const subagentToolCallBlockSchema = z.object({
     prettyName: z.string().optional(),
     icon: z.string().optional(),
     status: z.enum(["pending", "in_progress", "completed", "failed"]),
+    rawInput: z.record(z.string(), z.unknown()).optional(),
+    rawOutput: z.record(z.string(), z.unknown()).optional(),
 });
 const subagentContentBlockSchema = z.discriminatedUnion("type", [
     z.object({
@@ -134,11 +136,26 @@ const sessionMetadataSchema = z.object({
     agentName: z.string(),
     sandboxId: z.string().optional(),
 });
+// Citation schemas - matches SourceSchema from packages/ui/src/core/schemas/source.ts
+const persistedCitationSourceSchema = z.object({
+    id: z.string(),
+    url: z.string(),
+    title: z.string(),
+    snippet: z.string().optional(),
+    favicon: z.string().optional(),
+    toolCallId: z.string(),
+    sourceName: z.string().optional(),
+});
+const citationStorageSchema = z.object({
+    sources: z.array(persistedCitationSourceSchema),
+    nextId: z.number(),
+});
 const storedSessionSchema = z.object({
     sessionId: z.string(),
     messages: z.array(sessionMessageSchema),
     context: z.array(contextEntrySchema),
     metadata: sessionMetadataSchema,
+    citations: citationStorageSchema.optional(),
 });
 /**
  * File-based session storage
@@ -183,7 +200,7 @@ export class SessionStorage {
      * Save a session to disk
      * Uses atomic write (write to temp file, then rename)
      */
-    async saveSession(sessionId, messages, context) {
+    async saveSession(sessionId, messages, context, citations) {
         // Debug: log subagent data being saved
         const messagesWithSubagents = messages.filter((msg) => msg.content.some((block) => block.type === "tool_call" &&
             "subagentMessages" in block &&
@@ -223,6 +240,7 @@ export class SessionStorage {
                 updatedAt: now,
                 agentName: this.agentName,
             },
+            ...(citations && { citations }),
         };
         try {
             // Write to temp file

package/dist/definition/index.d.ts

@@ -1,5 +1,8 @@
 import { z } from "zod";
-export type AgentDefinition = z.infer<typeof AgentDefinitionSchema>;
+import type { Model } from "./models";
+export type AgentDefinition = Omit<z.infer<typeof AgentDefinitionSchema>, "model"> & {
+    model: Model | (string & {});
+};
 /** MCP configuration types. */
 export declare const McpConfigSchema: z.ZodUnion<readonly [z.ZodObject<{
     name: z.ZodString;

package/dist/definition/models.d.ts

@@ -0,0 +1,6 @@
+type AnthropicModel = "claude-opus-4-5-20251101" | "claude-opus-4-5" | "claude-3-7-sonnet-latest" | "claude-3-7-sonnet-20250219" | "claude-3-5-haiku-latest" | "claude-3-5-haiku-20241022" | "claude-haiku-4-5" | "claude-haiku-4-5-20251001" | "claude-sonnet-4-20250514" | "claude-sonnet-4-0" | "claude-4-sonnet-20250514" | "claude-sonnet-4-5" | "claude-sonnet-4-5-20250929" | "claude-opus-4-0" | "claude-opus-4-20250514" | "claude-4-opus-20250514" | "claude-opus-4-1-20250805" | "claude-3-opus-latest" | "claude-3-opus-20240229" | "claude-3-haiku-20240307";
+type TownAnthropicModel = `town-${AnthropicModel}`;
+type GeminiModel = "gemini-3-pro-preview" | "gemini-2.5-flash" | "gemini-2.5-flash-lite" | "gemini-2.5-flash-lite" | "gemini-2.5-pro" | "gemini-2.0-flash" | "gemini-2.0-flash-lite";
+type VertexModel = `vertex-${GeminiModel}`;
+export type Model = AnthropicModel | TownAnthropicModel | GeminiModel | VertexModel;
+export {};

package/dist/definition/models.js

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

package/dist/mcp/index.d.ts

@@ -0,0 +1,12 @@
+import type { z } from "zod";
+import type { McpConfigSchema } from "../definition";
+type McpConfig = z.infer<typeof McpConfigSchema>;
+interface McpHealthResult {
+    name: string;
+    status: "pass" | "fail";
+    message: string;
+    toolCount?: number;
+    details?: string;
+}
+export declare function checkAllMcpHealth(configs: McpConfig[], timeoutMs?: number): Promise<McpHealthResult[]>;
+export {};

package/dist/mcp/index.js

@@ -0,0 +1,83 @@
+import { MultiServerMCPClient } from "@langchain/mcp-adapters";
+import { getShedAuth } from "@townco/core/auth";
+const DEFAULT_TIMEOUT_MS = 10000;
+async function resolveServerConfig(config) {
+    if (typeof config === "string") {
+        const shedAuth = await getShedAuth();
+        if (!shedAuth) {
+            throw new Error("Not logged in. Run 'town login' or set SHED_API_KEY to use cloud MCP servers.");
+        }
+        const proxyUrl = process.env.MCP_PROXY_URL ?? `${shedAuth.shedUrl}/mcp_proxy`;
+        return {
+            url: `${proxyUrl}?server=${config}`,
+            headers: {
+                Authorization: `Bearer ${shedAuth.accessToken}`,
+            },
+        };
+    }
+    if (config.transport === "http") {
+        return config.headers
+            ? { url: config.url, headers: config.headers }
+            : { url: config.url };
+    }
+    return {
+        transport: "stdio",
+        command: config.command,
+        args: config.args ?? [],
+    };
+}
+function getMcpName(config) {
+    return typeof config === "string" ? config : config.name;
+}
+async function checkMcpHealth(config, timeoutMs = DEFAULT_TIMEOUT_MS) {
+    const name = getMcpName(config);
+    let serverConfig;
+    try {
+        serverConfig = await resolveServerConfig(config);
+    }
+    catch (error) {
+        return {
+            name,
+            status: "fail",
+            message: "Configuration error",
+            details: error instanceof Error ? error.message : String(error),
+        };
+    }
+    const client = new MultiServerMCPClient({
+        throwOnLoadError: true,
+        mcpServers: { [name]: serverConfig },
+    });
+    let timeoutId;
+    try {
+        const tools = await Promise.race([
+            client.getTools(),
+            new Promise((_, reject) => {
+                timeoutId = setTimeout(() => reject(new Error("Connection timeout")), timeoutMs);
+            }),
+        ]);
+        return {
+            name,
+            status: "pass",
+            message: "Connected successfully",
+            toolCount: tools.length,
+        };
+    }
+    catch (error) {
+        return {
+            name,
+            status: "fail",
+            message: error instanceof Error ? error.message : "Connection failed",
+        };
+    }
+    finally {
+        if (timeoutId)
+            clearTimeout(timeoutId);
+        await client.close();
+    }
+}
+export async function checkAllMcpHealth(configs, timeoutMs = DEFAULT_TIMEOUT_MS) {
+    if (configs.length === 0) {
+        return [];
+    }
+    return Promise.all(configs.map((c) => checkMcpHealth(c, timeoutMs)));
+}

package/dist/runner/hooks/predefined/compaction-tool.js

@@ -184,8 +184,20 @@ Please provide your summary based on the conversation above, following this stru
             summaryTokens,
             tokensSaved: inputTokensUsed - summaryTokens,
         });
+        // Build citation reference section if citations exist
+        // This ensures the agent retains access to citation sources after compaction
+        let citationSection = "";
+        if (ctx.session.citations && ctx.session.citations.length > 0) {
+            const citationLines = ctx.session.citations
+                .map((s) => `[[${s.id}]] "${s.title}" - ${s.url}`)
+                .join("\n");
+            citationSection = `\n\n--- CITATION SOURCES ---\nThe following sources were referenced in the conversation:\n${citationLines}\n--- END CITATIONS ---`;
+            logger.info("Injecting citation sources into compaction summary", {
+                citationsCount: ctx.session.citations.length,
+            });
+        }
         // Create a new context entry with the summary
-        const summaryEntry = createFullMessageEntry("user", `This session is being continued from a previous conversation that ran out of context. The conversation is summarized below:\n${summaryText}`);
+        const summaryEntry = createFullMessageEntry("user", `This session is being continued from a previous conversation that ran out of context. The conversation is summarized below:\n${summaryText}${citationSection}`);
         // Set compactedUpTo to indicate all messages have been compacted into the summary
         const lastMessageIndex = messagesToCompact.length - 1;
         const newContextEntry = createContextEntry([summaryEntry], undefined, lastMessageIndex, {

package/dist/runner/hooks/predefined/mid-turn-compaction.js

@@ -180,9 +180,21 @@ Please provide your summary based on the conversation above, following this stru
             summaryTokens,
             tokensSaved: inputTokensUsed - summaryTokens,
         });
+        // Build citation reference section if citations exist
+        // This ensures the agent retains access to citation sources after compaction
+        let citationSection = "";
+        if (ctx.session.citations && ctx.session.citations.length > 0) {
+            const citationLines = ctx.session.citations
+                .map((s) => `[[${s.id}]] "${s.title}" - ${s.url}`)
+                .join("\n");
+            citationSection = `\n\n--- CITATION SOURCES ---\nThe following sources were referenced in the conversation:\n${citationLines}\n--- END CITATIONS ---`;
+            logger.info("Injecting citation sources into compaction summary", {
+                citationsCount: ctx.session.citations.length,
+            });
+        }
         // Create a new context entry with the summary
         // Mark it as a mid-turn compaction so the agent knows to continue
-        const summaryEntry = createFullMessageEntry("user", `This session is being continued from a previous conversation that ran out of context during a tool call. The conversation AND the pending tool response are summarized below. IMPORTANT: Continue from where you left off.\n\n${summaryText}`);
+        const summaryEntry = createFullMessageEntry("user", `This session is being continued from a previous conversation that ran out of context during a tool call. The conversation AND the pending tool response are summarized below. IMPORTANT: Continue from where you left off.\n\n${summaryText}${citationSection}`);
         // Set compactedUpTo to indicate all messages have been compacted into the summary
         const lastMessageIndex = messagesToCompact.length - 1;
         const newContextEntry = createContextEntry([summaryEntry], undefined, lastMessageIndex, {

package/dist/runner/hooks/types.d.ts

@@ -1,3 +1,4 @@
+import type { CitationSource } from "../../acp-server/adapter";
 import type { ContextEntry } from "../../acp-server/session-storage";
 import type { AgentDefinition } from "../../definition";
 import type { SessionMessage } from "../agent-runner";
@@ -88,6 +89,11 @@ export interface ReadonlySession {
      * Original request parameters
      */
     readonly requestParams: Readonly<Record<string, unknown>>;
+    /**
+     * Citation sources accumulated in this session
+     * Used for injecting into compaction summaries so agent retains citation references
+     */
+    readonly citations?: ReadonlyArray<Readonly<CitationSource>>;
 }
 /**
  * Context passed to hook callbacks