@townco/agent 0.1.72 → 0.1.74

package/dist/acp-server/adapter.js

@@ -258,6 +258,9 @@ export class AgentAcpAdapter {
         const subagentsMetadata = this.getSubagentsMetadata();
         response._meta = {
             ...response._meta,
+            // Include model and system prompt for Town Hall comparison feature
+            model: this.agent.definition.model,
+            systemPrompt: this.agent.definition.systemPrompt ?? null,
             ...(this.agentDescription
                 ? { agentDescription: this.agentDescription }
                 : {}),
@@ -276,11 +279,14 @@ export class AgentAcpAdapter {
     }
     async newSession(params) {
         const sessionId = Math.random().toString(36).substring(2);
+        // Extract configOverrides from _meta if provided (Town Hall comparison feature)
+        const configOverrides = params._meta?.configOverrides;
         this.sessions.set(sessionId, {
             pendingPrompt: null,
             messages: [],
             context: [],
             requestParams: params,
+            configOverrides,
         });
         // Note: Initial message is sent by the HTTP transport when SSE connection is established
         // This ensures the message is delivered after the client is ready to receive it
@@ -361,8 +367,27 @@ export class AgentAcpAdapter {
                         ...(block.icon ? { icon: block.icon } : {}),
                         ...(block.subline ? { subline: block.subline } : {}),
                         ...(block.batchId ? { batchId: block.batchId } : {}),
+                        // Include subagent data for replay - full content is sent via direct SSE
+                        // bypassing PostgreSQL NOTIFY size limits
+                        ...(block.subagentPort ? { subagentPort: block.subagentPort } : {}),
+                        ...(block.subagentSessionId
+                            ? { subagentSessionId: block.subagentSessionId }
+                            : {}),
+                        ...(block.subagentMessages
+                            ? { subagentMessages: block.subagentMessages }
+                            : {}),
                         ...block._meta,
                     };
+                    // Debug: log subagent data being replayed
+                    logger.info("Replaying tool_call", {
+                        toolCallId: block.id,
+                        title: block.title,
+                        batchId: block.batchId,
+                        hasSubagentPort: !!block.subagentPort,
+                        hasSubagentSessionId: !!block.subagentSessionId,
+                        hasSubagentMessages: !!block.subagentMessages,
+                        subagentMessagesCount: block.subagentMessages?.length,
+                    });
                     this.connection.sessionUpdate({
                         sessionId: params.sessionId,
                         update: {
@@ -456,6 +481,7 @@ export class AgentAcpAdapter {
     async prompt(params) {
         const promptSpan = telemetry.startSpan("adapter.prompt", {
             "session.id": params.sessionId,
+            "agent.session_id": params.sessionId,
         });
         const spanContext = promptSpan
             ? trace.setSpan(context.active(), promptSpan)
@@ -516,6 +542,11 @@ export class AgentAcpAdapter {
             .filter((p) => p.type === "text")
             .map((p) => p.text)
             .join("\n");
+        // Store user message in span attribute for debugger UI
+        const promptSpan = trace.getActiveSpan();
+        if (promptSpan) {
+            promptSpan.setAttribute("user.message", userMessageText);
+        }
         logger.info("User message received", {
             sessionId: params.sessionId,
             messagePreview: userMessageText.slice(0, 100),
@@ -635,11 +666,26 @@ export class AgentAcpAdapter {
             if (session.requestParams._meta) {
                 invokeParams.sessionMeta = session.requestParams._meta;
             }
+            // Pass config overrides if defined (Town Hall comparison feature)
+            if (session.configOverrides) {
+                invokeParams.configOverrides = session.configOverrides;
+            }
             const generator = this.agent.invoke(invokeParams);
+            // Track the invocation span for parenting hook spans
+            let invocationSpan = null;
             // Manually iterate to capture the return value
             let iterResult = await generator.next();
             while (!iterResult.done) {
                 const msg = iterResult.value;
+                // Capture the invocation span so we can use it for parenting hook spans
+                if ("sessionUpdate" in msg &&
+                    msg.sessionUpdate === "__invocation_span" &&
+                    "invocationSpan" in msg) {
+                    invocationSpan = msg.invocationSpan;
+                    // Skip this internal message - don't yield it
+                    iterResult = await generator.next();
+                    continue;
+                }
                 // Capture tool overhead info if provided by harness
                 if ("sessionUpdate" in msg &&
                     msg.sessionUpdate === "tool_overhead_info") {
@@ -720,6 +766,12 @@ export class AgentAcpAdapter {
                         "icon" in toolCallMsg._meta
                         ? String(toolCallMsg._meta.icon)
                         : undefined;
+                    const verbiage = toolCallMsg._meta &&
+                        typeof toolCallMsg._meta === "object" &&
+                        "verbiage" in toolCallMsg._meta &&
+                        typeof toolCallMsg._meta.verbiage === "object"
+                        ? toolCallMsg._meta.verbiage
+                        : undefined;
                     const batchId = toolCallMsg._meta &&
                         typeof toolCallMsg._meta === "object" &&
                         "batchId" in toolCallMsg._meta
@@ -752,6 +804,7 @@ export class AgentAcpAdapter {
                         title: toolCallMsg.title || "Tool",
                         ...(prettyName ? { prettyName } : {}),
                         ...(icon ? { icon } : {}),
+                        ...(verbiage ? { verbiage } : {}),
                         ...(subline ? { subline } : {}),
                         kind: toolCallMsg.kind || "other",
                         status: toolCallMsg.status || "pending",
@@ -783,6 +836,41 @@ export class AgentAcpAdapter {
                             toolCallBlock.status === "failed") {
                             toolCallBlock.completedAt = Date.now();
                         }
+                        const meta = updateMsg._meta;
+                        // Update batchId from _meta (comes from tool_call_update after preliminary tool_call)
+                        if (meta?.batchId && !toolCallBlock.batchId) {
+                            toolCallBlock.batchId = meta.batchId;
+                        }
+                        if (meta?.subagentPort) {
+                            toolCallBlock.subagentPort = meta.subagentPort;
+                        }
+                        if (meta?.subagentSessionId) {
+                            toolCallBlock.subagentSessionId = meta.subagentSessionId;
+                        }
+                        if (meta?.subagentMessages) {
+                            logger.info("Storing subagent messages for session replay", {
+                                toolCallId: updateMsg.toolCallId,
+                                messageCount: meta.subagentMessages.length,
+                            });
+                            toolCallBlock.subagentMessages = meta.subagentMessages;
+                        }
+                    }
+                    // Forward tool_call_update with _meta to the client (for subagent connection info, etc.)
+                    if (updateMsg._meta) {
+                        logger.info("Forwarding tool_call_update with _meta to client", {
+                            toolCallId: updateMsg.toolCallId,
+                            status: updateMsg.status,
+                            _meta: updateMsg._meta,
+                        });
+                        this.connection.sessionUpdate({
+                            sessionId: params.sessionId,
+                            update: {
+                                sessionUpdate: "tool_call_update",
+                                toolCallId: updateMsg.toolCallId,
+                                status: updateMsg.status,
+                                _meta: updateMsg._meta,
+                            },
+                        });
                     }
                     // Forward tool_call_update with _meta to the client (for subagent connection info, etc.)
                     if (updateMsg._meta) {
@@ -949,7 +1037,7 @@ export class AgentAcpAdapter {
                                 toolResultsTokens: midTurnSnapshot.context_size.toolResultsTokens,
                             });
                             // Execute hooks mid-turn to check if compaction is needed
-                            const midTurnContextEntries = await this.executeHooksIfConfigured(session, params.sessionId, "mid_turn");
+                            const midTurnContextEntries = await this.executeHooksIfConfigured(session, params.sessionId, "mid_turn", invocationSpan);
                             // Append new context entries returned by hooks (e.g., compaction)
                             if (midTurnContextEntries.length > 0) {
                                 logger.info(`Appending ${midTurnContextEntries.length} new context entries from mid_turn hooks`, {
@@ -1100,20 +1188,25 @@ export class AgentAcpAdapter {
      * Execute hooks if configured for this agent
      * Returns new context entries that should be appended to session.context
      */
-    async executeHooksIfConfigured(session, sessionId, executionPoint) {
+    async executeHooksIfConfigured(session, sessionId, executionPoint, parentSpan) {
         // Check if hooks are configured and session persistence is enabled
         const hooks = this.agent.definition.hooks;
         if (this.noSession || !hooks || hooks.length === 0) {
             return [];
         }
+        // If a parent span is provided (for mid-turn hooks), set it as active context
+        const baseContext = parentSpan
+            ? trace.setSpan(context.active(), parentSpan)
+            : context.active();
         const hookSpan = telemetry.startSpan("adapter.executeHooks", {
             "hooks.executionPoint": executionPoint,
             "hooks.count": hooks.length,
             "session.id": sessionId,
-        });
+            "agent.session_id": sessionId,
+        }, baseContext);
         const spanContext = hookSpan
-            ? trace.setSpan(context.active(), hookSpan)
-            : context.active();
+            ? trace.setSpan(baseContext, hookSpan)
+            : baseContext;
         return context.with(spanContext, async () => {
             try {
                 return await this._executeHooksImpl(session, sessionId, executionPoint, hooks);

package/dist/acp-server/http.js

@@ -45,6 +45,9 @@ function compressIfNeeded(rawMsg) {
 }
 // Use PGlite in-memory database for LISTEN/NOTIFY
 const pg = new PGlite();
+// Store for oversized responses that can't go through PostgreSQL NOTIFY
+// Key: request ID, Value: response object
+const oversizedResponses = new Map();
 // Helper to create safe channel names from untrusted IDs
 function safeChannelName(prefix, id) {
     const hash = createHash("sha256").update(id).digest("hex").slice(0, 16);
@@ -133,26 +136,21 @@ export function makeHttpTransport(agent, agentDir, agentName) {
                     const escapedPayload = payload.replace(/'/g, "''");
                     // Check if even compressed payload is too large
                     if (compressedSize > 7500) {
-                        logger.error("Response payload too large even after compression", {
+                        logger.info("Response payload too large for NOTIFY, using direct storage", {
                             requestId: rawMsg.id,
                             originalSize,
                             compressedSize,
                         });
-                        // Send error response
-                        const errorResponse = {
+                        // Store the response for direct retrieval by the HTTP handler
+                        oversizedResponses.set(rawMsg.id, rawMsg);
+                        // Send a small marker through NOTIFY to signal the response is ready
+                        const markerResponse = {
                             jsonrpc: "2.0",
                             id: rawMsg.id,
-                            error: {
-                                code: -32603,
-                                message: "Response payload too large even after compression",
-                                data: {
-                                    originalSize,
-                                    compressedSize,
-                                },
-                            },
+                            _oversized: true,
                         };
-                        const errorPayload = JSON.stringify(errorResponse).replace(/'/g, "''");
-                        await pg.query(`NOTIFY ${channel}, '${errorPayload}'`);
+                        const markerPayload = JSON.stringify(markerResponse).replace(/'/g, "''");
+                        await pg.query(`NOTIFY ${channel}, '${markerPayload}'`);
                         continue;
                     }
                     try {
@@ -227,6 +225,48 @@ export function makeHttpTransport(agent, agentDir, agentName) {
                         }
                         continue;
                     }
+                    // Check if this is a tool_call with subagentMessages - send directly via SSE
+                    // to bypass PostgreSQL NOTIFY size limits (7500 bytes)
+                    if (messageType === "session/update" &&
+                        "params" in rawMsg &&
+                        rawMsg.params != null &&
+                        typeof rawMsg.params === "object" &&
+                        "update" in rawMsg.params &&
+                        rawMsg.params.update != null &&
+                        typeof rawMsg.params.update === "object" &&
+                        "sessionUpdate" in rawMsg.params.update &&
+                        rawMsg.params.update.sessionUpdate === "tool_call" &&
+                        "_meta" in rawMsg.params.update &&
+                        rawMsg.params.update._meta != null &&
+                        typeof rawMsg.params.update._meta === "object" &&
+                        "subagentMessages" in rawMsg.params.update._meta) {
+                        // Send subagent tool call directly via SSE, bypassing PostgreSQL NOTIFY
+                        const stream = sseStreams.get(sessionId);
+                        if (stream) {
+                            try {
+                                await stream.writeSSE({
+                                    event: "message",
+                                    data: JSON.stringify(rawMsg),
+                                });
+                                logger.debug("Sent subagent tool call directly via SSE", {
+                                    sessionId,
+                                    payloadSize: JSON.stringify(rawMsg).length,
+                                });
+                            }
+                            catch (error) {
+                                logger.error("Failed to send subagent tool call", {
+                                    error,
+                                    sessionId,
+                                });
+                            }
+                        }
+                        else {
+                            logger.warn("No SSE stream found for subagent tool call", {
+                                sessionId,
+                            });
+                        }
+                        continue;
+                    }
                     // Other messages (notifications, requests from agent) go to
                     // session-specific channel via PostgreSQL NOTIFY
                     const channel = safeChannelName("notifications", sessionId);
@@ -513,6 +553,24 @@ export function makeHttpTransport(agent, agentDir, agentName) {
                         };
                     }
                 }
+                // Check if this is an oversized response marker
+                if (rawResponse &&
+                    typeof rawResponse === "object" &&
+                    "_oversized" in rawResponse &&
+                    rawResponse._oversized === true &&
+                    "id" in rawResponse) {
+                    // Retrieve the actual response from the oversized storage
+                    const actualResponse = oversizedResponses.get(String(rawResponse.id));
+                    if (actualResponse) {
+                        oversizedResponses.delete(String(rawResponse.id));
+                        logger.debug("Retrieved oversized response from storage", { id });
+                        responseResolver(actualResponse);
+                        return;
+                    }
+                    logger.error("Oversized response not found in storage", {
+                        id: rawResponse.id,
+                    });
+                }
                 responseResolver(rawResponse);
             });
             // Write NDJSON line into the ACP inbound stream
@@ -553,7 +611,6 @@ export function makeHttpTransport(agent, agentDir, agentName) {
     logger.info("Starting HTTP server", { port });
     Bun.serve({
         fetch: app.fetch,
-        hostname: Bun.env.BIND_HOST || "localhost",
         port,
     });
     logger.info("HTTP server listening", {

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

@@ -16,6 +16,40 @@ export interface ImageBlock {
     data?: string | undefined;
     mimeType?: string | undefined;
 }
+/**
+ * Sub-agent tool call stored within a parent tool call's subagentMessages
+ */
+export interface SubagentToolCallBlock {
+    id: string;
+    title: string;
+    prettyName?: string | undefined;
+    icon?: string | undefined;
+    status: "pending" | "in_progress" | "completed" | "failed";
+}
+/**
+ * Content block for sub-agent messages - either text or a tool call
+ */
+export interface SubagentTextBlock {
+    type: "text";
+    text: string;
+}
+export interface SubagentToolCallContentBlock {
+    type: "tool_call";
+    toolCall: SubagentToolCallBlock;
+}
+export type SubagentContentBlock = SubagentTextBlock | SubagentToolCallContentBlock;
+/**
+ * Sub-agent message stored for replay
+ */
+export interface SubagentMessage {
+    id: string;
+    /** Accumulated text content (thinking) */
+    content: string;
+    /** Interleaved content blocks in arrival order */
+    contentBlocks?: SubagentContentBlock[] | undefined;
+    /** Tool calls made by the sub-agent */
+    toolCalls?: SubagentToolCallBlock[] | undefined;
+}
 export interface ToolCallBlock {
     type: "tool_call";
     id: string;
@@ -37,6 +71,12 @@ export interface ToolCallBlock {
         originalTokens?: number;
         finalTokens?: number;
     };
+    /** Sub-agent HTTP port (for reference, not used in replay) */
+    subagentPort?: number | undefined;
+    /** Sub-agent session ID (for reference, not used in replay) */
+    subagentSessionId?: string | undefined;
+    /** Stored sub-agent messages for replay */
+    subagentMessages?: SubagentMessage[] | undefined;
 }
 export type ContentBlock = TextBlock | ImageBlock | ToolCallBlock;
 /**

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

@@ -26,6 +26,29 @@ const imageBlockSchema = z.object({
     data: z.string().optional(),
     mimeType: z.string().optional(),
 });
+const subagentToolCallBlockSchema = z.object({
+    id: z.string(),
+    title: z.string(),
+    prettyName: z.string().optional(),
+    icon: z.string().optional(),
+    status: z.enum(["pending", "in_progress", "completed", "failed"]),
+});
+const subagentContentBlockSchema = z.discriminatedUnion("type", [
+    z.object({
+        type: z.literal("text"),
+        text: z.string(),
+    }),
+    z.object({
+        type: z.literal("tool_call"),
+        toolCall: subagentToolCallBlockSchema,
+    }),
+]);
+const subagentMessageSchema = z.object({
+    id: z.string(),
+    content: z.string(),
+    contentBlocks: z.array(subagentContentBlockSchema).optional(),
+    toolCalls: z.array(subagentToolCallBlockSchema).optional(),
+});
 const toolCallBlockSchema = z.object({
     type: z.literal("tool_call"),
     id: z.string(),
@@ -52,6 +75,9 @@ const toolCallBlockSchema = z.object({
     error: z.string().optional(),
     startedAt: z.number().optional(),
     completedAt: z.number().optional(),
+    subagentPort: z.number().optional(),
+    subagentSessionId: z.string().optional(),
+    subagentMessages: z.array(subagentMessageSchema).optional(),
 });
 const contentBlockSchema = z.discriminatedUnion("type", [
     textBlockSchema,

package/dist/runner/agent-runner.d.ts

@@ -1,4 +1,5 @@
 import type { PromptRequest, PromptResponse, SessionNotification } from "@agentclientprotocol/sdk";
+import type { Span } from "@opentelemetry/api";
 import { z } from "zod";
 import type { ContentBlock } from "../acp-server/session-storage.js";
 export declare const zAgentRunnerParams: z.ZodObject<{
@@ -8,7 +9,7 @@ export declare const zAgentRunnerParams: z.ZodObject<{
     suggestedPrompts: z.ZodOptional<z.ZodArray<z.ZodString>>;
     systemPrompt: z.ZodNullable<z.ZodString>;
     model: z.ZodString;
-    tools: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodLiteral<"todo_write">, z.ZodLiteral<"get_weather">, z.ZodLiteral<"web_search">, z.ZodLiteral<"filesystem">, z.ZodLiteral<"generate_image">, z.ZodLiteral<"browser">]>, z.ZodObject<{
+    tools: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodLiteral<"todo_write">, z.ZodLiteral<"get_weather">, z.ZodLiteral<"web_search">, z.ZodLiteral<"town_web_search">, z.ZodLiteral<"filesystem">, z.ZodLiteral<"generate_image">, z.ZodLiteral<"browser">]>, z.ZodObject<{
         type: z.ZodLiteral<"custom">;
         modulePath: z.ZodString;
     }, z.core.$strip>, z.ZodObject<{
@@ -66,10 +67,16 @@ export interface SessionMessage {
     content: ContentBlock[];
     timestamp: string;
 }
+export interface ConfigOverrides {
+    model?: string;
+    systemPrompt?: string;
+    tools?: string[];
+}
 export type InvokeRequest = Omit<PromptRequest, "_meta"> & {
     messageId: string;
     sessionMeta?: Record<string, unknown>;
     contextMessages?: SessionMessage[];
+    configOverrides?: ConfigOverrides;
 };
 export interface TokenUsage {
     inputTokens?: number;
@@ -125,6 +132,9 @@ export type ExtendedSessionUpdate = (SessionNotification["update"] & {
     sessionUpdate: "tool_overhead_info";
     toolOverheadTokens: number;
     mcpOverheadTokens: number;
+} | {
+    sessionUpdate: "__invocation_span";
+    invocationSpan: Span;
 } | AgentMessageChunkWithTokens | HookNotificationUpdate;
 /** Describes an object that can run an agent definition */
 export interface AgentRunner {

package/dist/runner/hooks/predefined/tool-response-compactor.js

@@ -1,8 +1,13 @@
-import { ChatAnthropic } from "@langchain/anthropic";
-import { HumanMessage, SystemMessage } from "@langchain/core/messages";
+import Anthropic from "@anthropic-ai/sdk";
 import { createLogger } from "../../../logger.js";
+import { telemetry } from "../../../telemetry/index.js";
 import { countToolResultTokens } from "../../../utils/token-counter.js";
 const logger = createLogger("tool-response-compactor");
+// Create Anthropic client directly (not using LangChain)
+// This ensures compaction LLM calls don't get captured by LangGraph's streaming
+const anthropic = new Anthropic({
+    apiKey: process.env.ANTHROPIC_API_KEY,
+});
 // Haiku 4.5 for compaction (fast and cost-effective)
 const COMPACTION_MODEL = "claude-haiku-4-5-20251001";
 const COMPACTION_MODEL_CONTEXT = 200000; // Haiku context size for calculating truncation limits
@@ -243,10 +248,6 @@ export const toolResponseCompactor = async (ctx) => {
  * Recursive LLM compaction with adaptive retries
  */
 async function compactWithLLM(rawOutput, toolName, toolInput, conversationContext, targetTokens) {
-    const model = new ChatAnthropic({
-        model: COMPACTION_MODEL,
-        temperature: 0,
-    });
     // Step 1: Understand what we're looking for (only need to do this once)
     const analysisPrompt = `You are helping to manage context size in an agent conversation.
 
@@ -260,12 +261,38 @@ ${conversationContext}
 Based on the tool input and conversation context, what key information is the user looking for from this tool response?
 
 Provide a concise list (3-5 bullet points) of the most important elements to extract.`;
-    const analysisResponse = await model.invoke([
-        new SystemMessage("You are a helpful assistant analyzing information needs."),
-        new HumanMessage(analysisPrompt),
-    ]);
-    const keyRequirements = typeof analysisResponse.content === "string"
-        ? analysisResponse.content
+    // Create OTEL span for analysis call
+    const analysisSpan = telemetry.startSpan("compaction.analysis", {
+        "gen_ai.operation.name": "chat",
+        "gen_ai.provider.name": "anthropic",
+        "gen_ai.request.model": COMPACTION_MODEL,
+        "gen_ai.system_instructions": "You are a helpful assistant analyzing information needs.",
+    });
+    let analysisResponse;
+    try {
+        analysisResponse = await telemetry.withActiveSpanAsync(analysisSpan, () => anthropic.messages.create({
+            model: COMPACTION_MODEL,
+            max_tokens: 1024,
+            temperature: 0,
+            system: "You are a helpful assistant analyzing information needs.",
+            messages: [
+                {
+                    role: "user",
+                    content: analysisPrompt,
+                },
+            ],
+        }));
+        // Record token usage
+        telemetry.recordTokenUsage(analysisResponse.usage.input_tokens, analysisResponse.usage.output_tokens, analysisSpan);
+        telemetry.endSpan(analysisSpan);
+    }
+    catch (error) {
+        telemetry.endSpan(analysisSpan, error);
+        throw error;
+    }
+    const firstContent = analysisResponse.content[0];
+    const keyRequirements = firstContent && firstContent.type === "text"
+        ? firstContent.text
         : "Extract relevant information";
     logger.info("Identified key requirements for compaction", {
         requirements: keyRequirements.substring(0, 200),
@@ -323,14 +350,41 @@ Your task: Further compact this data by:
 
 Return ONLY valid JSON (no explanation text).`;
         }
-        const compactionResponse = await model.invoke([
-            new SystemMessage("You are a helpful assistant compacting data."),
-            new HumanMessage(compactionPrompt),
-        ]);
+        // Create OTEL span for compaction call
+        const compactionSpan = telemetry.startSpan("compaction.compact", {
+            "gen_ai.operation.name": "chat",
+            "gen_ai.provider.name": "anthropic",
+            "gen_ai.request.model": COMPACTION_MODEL,
+            "gen_ai.system_instructions": "You are a helpful assistant compacting data.",
+            "compaction.attempt": attempt + 1,
+            "compaction.target_tokens": targetTokens,
+            "compaction.current_tokens": currentTokens,
+        });
+        let compactionResponse;
+        try {
+            compactionResponse = await telemetry.withActiveSpanAsync(compactionSpan, () => anthropic.messages.create({
+                model: COMPACTION_MODEL,
+                max_tokens: 4096,
+                temperature: 0,
+                system: "You are a helpful assistant compacting data.",
+                messages: [
+                    {
+                        role: "user",
+                        content: compactionPrompt,
+                    },
+                ],
+            }));
+            // Record token usage
+            telemetry.recordTokenUsage(compactionResponse.usage.input_tokens, compactionResponse.usage.output_tokens, compactionSpan);
+            telemetry.endSpan(compactionSpan);
+        }
+        catch (error) {
+            telemetry.endSpan(compactionSpan, error);
+            throw error;
+        }
         // Extract and parse JSON
-        const responseText = typeof compactionResponse.content === "string"
-            ? compactionResponse.content
-            : JSON.stringify(compactionResponse.content);
+        const firstContent = compactionResponse.content[0];
+        const responseText = firstContent && firstContent.type === "text" ? firstContent.text : "";
         const jsonMatch = responseText.match(/```(?:json)?\n([\s\S]*?)\n```/) || [
             null,
             responseText,