@xopcai/xopc 0.0.187 → 0.0.189

package/dist/packages/realtime-protocol/src/index.js

@@ -0,0 +1,83 @@
+import { clientEndpointMessageSchema, endpointHelloPayloadSchema, serverEndpointMessageSchema } from "../../endpoint-tools-protocol/src/index.js";
+import { z } from "zod";
+const REALTIME_MAX_CLIENT_FRAME_BYTES = 256 * 1024;
+const REALTIME_HELLO_TIMEOUT_MS = 5e3;
+const REALTIME_HEARTBEAT_INTERVAL_MS = 15e3;
+const REALTIME_HEARTBEAT_TIMEOUT_MS = 45e3;
+const realtimeClientKindSchema = z.enum([
+	"web",
+	"desktop",
+	"mobile",
+	"tui",
+	"mcp"
+]);
+const realtimeTopicSchema = z.string().min(1).max(512);
+const realtimeEventNameSchema = z.string().regex(/^[a-z][a-z0-9_.-]*$/).max(160);
+const messageIdSchema = z.uuid();
+const timestampSchema = z.number().int().nonnegative();
+const sequenceSchema = z.number().int().positive();
+const envelope = (kind, payload) => z.strictObject({
+	protocolVersion: z.literal(1),
+	messageId: messageIdSchema,
+	kind: z.literal(kind),
+	sentAt: timestampSchema,
+	payload
+});
+const realtimeSubscriptionSchema = z.strictObject({
+	topic: realtimeTopicSchema,
+	afterSeq: z.number().int().nonnegative().optional()
+});
+const clientRealtimeMessageSchema = z.discriminatedUnion("kind", [
+	envelope("realtime.hello", z.strictObject({
+		ticket: z.string().min(32).max(512),
+		clientId: z.string().min(1).max(160),
+		clientKind: realtimeClientKindSchema,
+		subscriptions: z.array(realtimeSubscriptionSchema).max(100).default([]),
+		endpoint: endpointHelloPayloadSchema.optional()
+	})),
+	envelope("realtime.subscribe", z.strictObject({ subscriptions: z.array(realtimeSubscriptionSchema).min(1).max(100) })),
+	envelope("realtime.unsubscribe", z.strictObject({ topics: z.array(realtimeTopicSchema).min(1).max(100) })),
+	envelope("realtime.ping", z.strictObject({})),
+	envelope("endpoint.message", clientEndpointMessageSchema)
+]);
+const realtimeEventPayloadSchema = z.strictObject({
+	topic: realtimeTopicSchema,
+	seq: sequenceSchema,
+	event: realtimeEventNameSchema,
+	data: z.unknown()
+});
+const serverRealtimeMessageSchema = z.discriminatedUnion("kind", [
+	envelope("realtime.ready", z.strictObject({
+		connectionId: z.uuid(),
+		heartbeatIntervalMs: z.literal(REALTIME_HEARTBEAT_INTERVAL_MS),
+		heartbeatTimeoutMs: z.literal(REALTIME_HEARTBEAT_TIMEOUT_MS),
+		endpoint: z.strictObject({
+			endpointId: z.string().min(1).max(160),
+			turnToken: z.string().min(32).max(160)
+		}).optional()
+	})),
+	envelope("realtime.event", realtimeEventPayloadSchema),
+	envelope("realtime.gap", z.strictObject({
+		topic: realtimeTopicSchema,
+		requestedSeq: z.number().int().nonnegative(),
+		earliestSeq: sequenceSchema
+	})),
+	envelope("realtime.pong", z.strictObject({})),
+	envelope("realtime.error", z.strictObject({
+		code: z.string().min(1).max(80),
+		message: z.string().min(1).max(500)
+	})),
+	envelope("endpoint.message", serverEndpointMessageSchema)
+]);
+function parseClientRealtimeMessage(value) {
+	return clientRealtimeMessageSchema.parse(value);
+}
+function parseServerRealtimeMessage(value) {
+	return serverRealtimeMessageSchema.parse(value);
+}
+function parseClientRealtimeJsonFrame(text) {
+	if (new TextEncoder().encode(text).byteLength > 262144) throw new Error(`Realtime client frame exceeds ${REALTIME_MAX_CLIENT_FRAME_BYTES} bytes`);
+	return JSON.parse(text);
+}
+//#endregion
+export { REALTIME_HEARTBEAT_INTERVAL_MS, REALTIME_HEARTBEAT_TIMEOUT_MS, REALTIME_HELLO_TIMEOUT_MS, REALTIME_MAX_CLIENT_FRAME_BYTES, parseClientRealtimeJsonFrame, parseClientRealtimeMessage, parseServerRealtimeMessage, realtimeClientKindSchema, realtimeEventNameSchema, realtimeTopicSchema };

package/dist/src/agent/agent-manager.d.ts

@@ -70,6 +70,7 @@ export interface AgentManagerConfig {
     model?: string;
     config?: Config;
     extensionRegistry?: ExtensionRegistry;
+    endpointTools?: import('../endpoint-tools/index.js').EndpointToolRuntime;
     hookRunner?: import('../extensions/index.js').ExtensionHookRunner;
     bus: MessageBus;
     getCurrentContext: () => SessionContext | null;

package/dist/src/agent/agent-manager.js

@@ -18,6 +18,7 @@ import { buildExecutionScopeContextForPrompt } from "./context/execution-scope.j
 import { clearBootstrapSnapshot } from "./bootstrap/bootstrap-cache.js";
 import { resolveBootstrapContextSync } from "./bootstrap/bootstrap-files.js";
 import { loadProjectAgentsContextFile } from "./bootstrap/project-agents-context.js";
+import { disposeAllSessionMcpRuntimes, retireSessionMcpRuntimeForSessionKey } from "./mcp/bundle-mcp-runtime.js";
 import { createSkillConfigManager, isSkillEnabled, resolveSkillConfig } from "./skills/config.js";
 import { isValidSkillEnvVarName } from "./skills/required-env-vars.js";
 import { resolveWorkspaceSkillsDir, resolveWorkspaceSkillsLockPath } from "./skills/workspace-skills-dir.js";
@@ -26,8 +27,6 @@ import { isUnderManagedSkillsDir } from "./skills/managed-store.js";
 import { createAgentCapabilitySessionState, resolveAgentCapabilityCatalog } from "./capabilities/registry.js";
 import "./capabilities/index.js";
 import { AgentToolsFactory } from "./tools/factory.js";
-import { parseMcpToolName } from "./mcp/bundle-mcp-policy.js";
-import { disposeAllSessionMcpRuntimes, retireSessionMcpRuntimeForSessionKey } from "./mcp/bundle-mcp-runtime.js";
 import "./mcp/bundle-mcp-tools.js";
 import { evictAllEmbeddedSessionRunners, evictEmbeddedSessionRunner } from "./embedded/session-runner.js";
 import { isMemorySubsystemEnabled } from "./memory/memory-config.js";
@@ -226,6 +225,7 @@ var AgentManager = class {
 		return {
 			workspace: this.baseWorkspacePath,
 			extensionRegistry: this.config.extensionRegistry,
+			endpointTools: this.config.endpointTools,
 			getCurrentContext: this.config.getCurrentContext,
 			hookRunner: this.config.hookRunner,
 			bus: this.config.bus,
@@ -914,12 +914,7 @@ var AgentManager = class {
 					}
 				}
 				if (!this.config.hookRunner) return;
-				const parsed = parseMcpToolName(toolName);
-				const hookResult = await this.config.hookRunner.runBeforeToolCall(toolName, args ?? {}, {
-					sessionKey,
-					isMcpTool: parsed !== null,
-					mcpServerId: parsed?.serverId
-				});
+				const hookResult = await this.config.hookRunner.runBeforeToolCall(toolName, args ?? {}, { sessionKey });
 				if (!hookResult.allowed) return {
 					block: true,
 					reason: hookResult.reason ?? "Tool call blocked by policy hook."

package/dist/src/agent/background-review/prompts.d.ts

@@ -1,2 +1,2 @@
-export declare const MEMORY_REVIEW_USER_PROMPT = "Review the conversation above and identify durable user-understanding candidates.\n\nFocus on:\n1. Has the user revealed things about themselves \u2014 persona, desires, preferences, or personal details worth remembering?\n2. Has the user expressed expectations about how you should behave, their work style, emotional-support preferences, boundaries, or how they want you to communicate?\n3. Has the user explicitly corrected a prior assumption? Prefer the correction and do not preserve the contradicted interpretation.\n\nReturn JSON only, with this shape:\n{\"candidates\":[{\"kind\":\"preference\",\"content\":\"...\",\"confidence\":0.8,\"importance\":0.7,\"durability\":\"durable\",\"sensitivity\":\"normal\",\"disclosurePolicy\":\"referenceable\",\"tags\":[\"background-review\"]}]}\n\nAllowed kinds: preference, boundary, relationship, project_context, commitment, routine, personal_logistics, open_question, milestone, current_state, task_lesson, tool_preference, long_term_goal, derived_insight.\nOnly include facts supported by the conversation and likely to matter in a future session. A temporary mood or one-off reaction is current context, not durable identity; omit it unless the user describes a recurring pattern that will matter later. Never include passwords, tokens, credentials, or speculative diagnoses. Use {\"candidates\":[]} when nothing qualifies.";
+export declare const MEMORY_REVIEW_USER_PROMPT = "Review the conversation above and identify durable user-understanding candidates.\n\nFocus on:\n1. Has the user revealed things about themselves \u2014 persona, desires, preferences, or personal details worth remembering?\n2. Has the user expressed expectations about how you should behave, their work style, emotional-support preferences, boundaries, or how they want you to communicate?\n3. Has the user explicitly corrected a prior assumption? Prefer the correction and do not preserve the contradicted interpretation.\n\nReturn JSON only, with this shape:\n{\"candidates\":[{\"kind\":\"preference\",\"content\":\"...\",\"confidence\":0.8,\"importance\":0.7,\"durability\":\"durable\",\"sensitivity\":\"normal\",\"disclosurePolicy\":\"referenceable\",\"tags\":[\"background-review\"]}]}\n\nAllowed kinds: preference, boundary, relationship, project_context, commitment, routine, personal_logistics, open_question, milestone, current_state, task_lesson, tool_preference, long_term_goal, derived_insight.\nOnly include facts supported by the conversation and likely to matter in a future session. A temporary mood or one-off reaction is current context, not durable identity; omit it unless the user describes a recurring pattern that will matter later. Never include passwords, tokens, credentials, or speculative diagnoses. Use {\"candidates\":[]} when nothing qualifies.\n\nDo not turn a request about the current task into user understanding. Exclude requested outputs, follow-up instructions, project-note edits, investigations, and other one-off work. Every candidate must be a complete standalone statement about the user or an enduring pattern; never return a clause fragment beginning with a connector such as \"and\", \"also\", \"\u5E76\u4E14\", \"\u4EE5\u53CA\", or \"\u7684\u4E8B\u9879\". Use long_term_goal only when the user states an enduring personal goal, not when they ask the assistant to create, update, investigate, summarize, or track something.";
 export declare const UNDERSTANDING_REVIEW_SYSTEM_PROMPT = "You are the user-understanding synthesis stage for the same session. You do not chat with the user and cannot write storage directly. Extract only evidence-backed, durable candidates and return strict JSON matching the requested schema.";

package/dist/src/agent/background-review/prompts.js

@@ -10,7 +10,9 @@ Return JSON only, with this shape:
 {"candidates":[{"kind":"preference","content":"...","confidence":0.8,"importance":0.7,"durability":"durable","sensitivity":"normal","disclosurePolicy":"referenceable","tags":["background-review"]}]}
 
 Allowed kinds: preference, boundary, relationship, project_context, commitment, routine, personal_logistics, open_question, milestone, current_state, task_lesson, tool_preference, long_term_goal, derived_insight.
-Only include facts supported by the conversation and likely to matter in a future session. A temporary mood or one-off reaction is current context, not durable identity; omit it unless the user describes a recurring pattern that will matter later. Never include passwords, tokens, credentials, or speculative diagnoses. Use {"candidates":[]} when nothing qualifies.`;
+Only include facts supported by the conversation and likely to matter in a future session. A temporary mood or one-off reaction is current context, not durable identity; omit it unless the user describes a recurring pattern that will matter later. Never include passwords, tokens, credentials, or speculative diagnoses. Use {"candidates":[]} when nothing qualifies.
+
+Do not turn a request about the current task into user understanding. Exclude requested outputs, follow-up instructions, project-note edits, investigations, and other one-off work. Every candidate must be a complete standalone statement about the user or an enduring pattern; never return a clause fragment beginning with a connector such as "and", "also", "并且", "以及", or "的事项". Use long_term_goal only when the user states an enduring personal goal, not when they ask the assistant to create, update, investigate, summarize, or track something.`;
 const UNDERSTANDING_REVIEW_SYSTEM_PROMPT = `You are the user-understanding synthesis stage for the same session. You do not chat with the user and cannot write storage directly. Extract only evidence-backed, durable candidates and return strict JSON matching the requested schema.`;
 //#endregion
 export { MEMORY_REVIEW_USER_PROMPT, UNDERSTANDING_REVIEW_SYSTEM_PROMPT };

package/dist/src/agent/background-review/run-background-review.d.ts

@@ -1,6 +1,7 @@
 import { Agent } from '@earendil-works/pi-agent-core';
 import type { Config } from '../../config/schema.js';
 import type { MemoryManager } from '../memory/manager.js';
+import type { UnderstandingCandidate } from '../memory/understanding/types.js';
 import type { BackgroundReviewSettings } from './settings.js';
 export interface RunBackgroundReviewParams {
     sessionKey: string;
@@ -9,4 +10,5 @@ export interface RunBackgroundReviewParams {
     memoryManager: MemoryManager;
     getConfig: () => Config | undefined;
 }
+export declare function parseUnderstandingCandidates(raw: string): UnderstandingCandidate[];
 export declare function runBackgroundReviewTurn(params: RunBackgroundReviewParams): Promise<void>;

package/dist/src/agent/background-review/run-background-review.js

@@ -6,6 +6,7 @@ import { createExtensionAwareStreamFn } from "../../providers/extension-stream-b
 import { extractTextContent } from "../context/workspace.js";
 import { resolveAgentTurnTimeoutMs, runAgentTurnWithTimeout } from "../orchestration/run-agent-turn-with-timeout.js";
 import { isAssistantTurnAborted, isAssistantTurnFailed } from "../orchestration/llm-turn-retry.js";
+import { isDurableUnderstandingCandidate } from "../../user-context/understandingQuality.js";
 import { MEMORY_REVIEW_USER_PROMPT, UNDERSTANDING_REVIEW_SYSTEM_PROMPT } from "./prompts.js";
 import { Agent } from "@earendil-works/pi-agent-core";
 //#region src/agent/background-review/run-background-review.ts
@@ -61,13 +62,15 @@ function parseUnderstandingCandidates(raw) {
 			const item = value;
 			if (!ALLOWED_UNDERSTANDING_KINDS.has(item.kind)) continue;
 			if (typeof item.content !== "string" || item.content.trim().length < 4) continue;
+			const kind = item.kind;
+			if (!isDurableUnderstandingCandidate(kind, item.content)) continue;
 			const confidence = typeof item.confidence === "number" ? item.confidence : .65;
 			const importance = typeof item.importance === "number" ? item.importance : .5;
 			const durability = item.durability === "ephemeral" || item.durability === "recurring" ? item.durability : "durable";
 			const sensitivity = ALLOWED_SENSITIVITIES.has(item.sensitivity) ? item.sensitivity : "personal";
 			const disclosurePolicy = item.disclosurePolicy === "silent" || item.disclosurePolicy === "ask_before_reference" ? item.disclosurePolicy : "referenceable";
 			output.push({
-				kind: item.kind,
+				kind,
 				content: item.content.trim(),
 				confidence: Math.max(0, Math.min(1, confidence)),
 				importance: Math.max(0, Math.min(1, importance)),
@@ -133,4 +136,4 @@ async function runBackgroundReviewTurn(params) {
 	await runUnderstandingReview(params);
 }
 //#endregion
-export { runBackgroundReviewTurn };
+export { parseUnderstandingCandidates, runBackgroundReviewTurn };

package/dist/src/agent/client-error-format.d.ts

@@ -16,5 +16,5 @@ export declare function formatAgentRunErrorForClient(rawError: string, context?:
     provider?: string;
     modelRef?: string;
 }): string;
-/** Human-readable text for TUI/CLI when SSE carries structured JSON. */
+/** Human-readable text for TUI/CLI when a run event carries structured JSON. */
 export declare function formatAgentRunErrorForDisplay(content: string): string;

package/dist/src/agent/client-error-format.js

@@ -87,7 +87,7 @@ function formatAgentRunErrorForClient(rawError, context) {
 	}
 	return JSON.stringify(payload);
 }
-/** Human-readable text for TUI/CLI when SSE carries structured JSON. */
+/** Human-readable text for TUI/CLI when a run event carries structured JSON. */
 function formatAgentRunErrorForDisplay(content) {
 	const trimmed = content.trim();
 	if (trimmed.startsWith("Error: ")) return trimmed.slice(7);

package/dist/src/agent/code-intelligence/binary.js

@@ -8,9 +8,9 @@ import { dirname, join, resolve } from "node:path";
 import { accessSync, chmodSync, constants, copyFileSync, createReadStream, createWriteStream, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { execFile } from "node:child_process";
 import { createHash, randomBytes } from "node:crypto";
+import { Readable } from "node:stream";
 import { promisify } from "node:util";
 import { pipeline } from "node:stream/promises";
-import { Readable } from "node:stream";
 import lockfile from "proper-lockfile";
 //#region src/agent/code-intelligence/binary.ts
 init_paths();

package/dist/src/agent/embedded/run-for-session.d.ts

@@ -23,7 +23,5 @@ export type RunEmbeddedForSessionParams = {
     startupAction?: 'new' | 'reset';
     forceStartupContext?: boolean;
     applyStartupContext?: boolean;
-    /** When true, dispose session MCP runtime after this turn completes. */
-    cleanupBundleMcpOnRunEnd?: boolean;
 };
 export declare function runEmbeddedTurnForSession(params: RunEmbeddedForSessionParams): Promise<RunXopcEmbeddedTurnResult>;

package/dist/src/agent/embedded/run-for-session.js

@@ -6,7 +6,6 @@ import { evaluateContextBudget } from "../memory/context-budget.js";
 import { resolveCompactionPolicy } from "../memory/compaction-policy.js";
 import { runXopcEmbeddedTurn } from "./run-turn.js";
 import { applyStartupContextToUserMessage } from "../reply/apply-turn-user-enrichment.js";
-import { mergeTurnTools, resolveEmbeddedMcpToolsForTurn } from "../mcp/resolve-embedded-mcp-tools.js";
 import crypto from "node:crypto";
 //#region src/agent/embedded/run-for-session.ts
 init_logger();
@@ -61,133 +60,121 @@ async function runEmbeddedTurnForSession(params) {
 		force: params.forceStartupContext
 	});
 	return await (async () => {
-		const mcpResolved = await resolveEmbeddedMcpToolsForTurn({
+		await maybeAutoCompactBeforeTurn({
 			sessionKey,
-			workspaceDir,
-			cfg: config,
-			baseTools: tools,
-			cleanupOnTurnEnd: params.cleanupBundleMcpOnRunEnd === true
+			sessionStore,
+			agentManager,
+			model,
+			config,
+			systemPrompt,
+			userMessage: userMessageForTurn,
+			tools,
+			imageCount: params.llmImages?.length ?? 0,
+			fallbackModels: resolvedCandidates.slice(1).map((candidate) => candidate.model),
+			abortSignal: params.abortSignal,
+			onEvent: params.onEvent
 		});
-		const turnTools = mergeTurnTools(tools, mcpResolved.tools);
-		try {
-			await maybeAutoCompactBeforeTurn({
-				sessionKey,
-				sessionStore,
-				agentManager,
-				model,
-				config,
-				systemPrompt,
-				userMessage: userMessageForTurn,
-				tools: turnTools,
-				imageCount: params.llmImages?.length ?? 0,
-				fallbackModels: resolvedCandidates.slice(1).map((candidate) => candidate.model),
-				abortSignal: params.abortSignal,
-				onEvent: params.onEvent
-			});
-			log.info({
+		log.info({
+			sessionKey,
+			runId,
+			configuredModelRef,
+			primaryModelRef: modelRef,
+			candidateModelRefs: resolvedCandidates.map((candidate) => candidate.ref)
+		}, "Agent model fallback candidates resolved");
+		let lastResult;
+		let lastError;
+		let resumeLastUserMessage = false;
+		const primaryModelRef = modelRef;
+		for (let i = 0; i < resolvedCandidates.length; i++) {
+			const candidate = resolvedCandidates[i];
+			const candidateModelRef = candidate.ref;
+			const isFallbackAttempt = i > 0;
+			const candidateModel = candidate.model;
+			const hasNextCandidate = i + 1 < resolvedCandidates.length;
+			const rowsBeforeAttempt = hasNextCandidate ? await sessionStore.loadTranscriptRows(sessionKey) : void 0;
+			if (typeof mm.applyResolvedModel === "function") mm.applyResolvedModel(agent, candidateModel, candidateModelRef);
+			agentManager.setModelForSession(sessionKey, candidateModelRef);
+			if (isFallbackAttempt) log.info({
 				sessionKey,
 				runId,
-				configuredModelRef,
-				primaryModelRef: modelRef,
-				candidateModelRefs: resolvedCandidates.map((candidate) => candidate.ref)
-			}, "Agent model fallback candidates resolved");
-			let lastResult;
-			let lastError;
-			let resumeLastUserMessage = false;
-			const primaryModelRef = modelRef;
-			for (let i = 0; i < resolvedCandidates.length; i++) {
-				const candidate = resolvedCandidates[i];
-				const candidateModelRef = candidate.ref;
-				const isFallbackAttempt = i > 0;
-				const candidateModel = candidate.model;
-				const hasNextCandidate = i + 1 < resolvedCandidates.length;
-				const rowsBeforeAttempt = hasNextCandidate ? await sessionStore.loadTranscriptRows(sessionKey) : void 0;
-				if (typeof mm.applyResolvedModel === "function") mm.applyResolvedModel(agent, candidateModel, candidateModelRef);
-				agentManager.setModelForSession(sessionKey, candidateModelRef);
-				if (isFallbackAttempt) log.info({
+				primaryModelRef,
+				fallbackModelRef: candidateModelRef,
+				attempt: i + 1,
+				total: resolvedCandidates.length
+			}, "Agent model fallback started");
+			try {
+				const turnResult = await runXopcEmbeddedTurn({
 					sessionKey,
 					runId,
-					primaryModelRef,
-					fallbackModelRef: candidateModelRef,
-					attempt: i + 1,
-					total: resolvedCandidates.length
-				}, "Agent model fallback started");
-				try {
-					const turnResult = await runXopcEmbeddedTurn({
+					userMessage: userMessageForTurn,
+					images: params.llmImages,
+					model: candidateModel,
+					modelRef: candidateModelRef,
+					tools,
+					systemPrompt,
+					thinkingLevel,
+					workspaceDir,
+					sessionStore,
+					timeoutMs: turnTimeoutMs,
+					abortSignal: params.abortSignal,
+					onEvent: params.onEvent,
+					resumeLastUserMessage
+				});
+				if (turnResult.ok) {
+					if (isFallbackAttempt) log.info({
 						sessionKey,
 						runId,
-						userMessage: userMessageForTurn,
-						images: params.llmImages,
-						model: candidateModel,
-						modelRef: candidateModelRef,
-						tools: turnTools,
-						systemPrompt,
-						thinkingLevel,
-						workspaceDir,
-						sessionStore,
-						timeoutMs: turnTimeoutMs,
-						abortSignal: params.abortSignal,
-						onEvent: params.onEvent,
-						resumeLastUserMessage
-					});
-					if (turnResult.ok) {
-						if (isFallbackAttempt) log.info({
-							sessionKey,
-							runId,
-							primaryModelRef,
-							fallbackModelRef: candidateModelRef,
-							attempt: i + 1,
-							total: resolvedCandidates.length
-						}, "Agent model fallback succeeded");
-						return turnResult;
-					}
-					lastResult = turnResult;
-					log.warn({
-						sessionKey,
-						runId,
-						modelRef: candidateModelRef,
+						primaryModelRef,
+						fallbackModelRef: candidateModelRef,
 						attempt: i + 1,
-						total: resolvedCandidates.length,
-						hasNextCandidate,
-						errorMessage: turnResult.errorMessage
-					}, hasNextCandidate ? "Agent model turn failed, trying fallback" : "Agent model turn failed, no fallback remains");
-				} catch (err) {
-					lastError = err;
-					if (err instanceof DOMException && err.name === "AbortError") throw err;
+						total: resolvedCandidates.length
+					}, "Agent model fallback succeeded");
+					return turnResult;
+				}
+				lastResult = turnResult;
+				log.warn({
+					sessionKey,
+					runId,
+					modelRef: candidateModelRef,
+					attempt: i + 1,
+					total: resolvedCandidates.length,
+					hasNextCandidate,
+					errorMessage: turnResult.errorMessage
+				}, hasNextCandidate ? "Agent model turn failed, trying fallback" : "Agent model turn failed, no fallback remains");
+			} catch (err) {
+				lastError = err;
+				if (err instanceof DOMException && err.name === "AbortError") throw err;
+				log.warn({
+					err,
+					sessionKey,
+					runId,
+					modelRef: candidateModelRef,
+					attempt: i + 1,
+					total: resolvedCandidates.length,
+					hasNextCandidate
+				}, hasNextCandidate ? "Agent model call threw, trying fallback" : "Agent model call threw, no fallback remains");
+			}
+			if (hasNextCandidate && rowsBeforeAttempt) {
+				const preparation = await sessionStore.prepareModelFallback(sessionKey, rowsBeforeAttempt);
+				if (preparation === "unsafe") {
 					log.warn({
-						err,
 						sessionKey,
 						runId,
 						modelRef: candidateModelRef,
-						attempt: i + 1,
-						total: resolvedCandidates.length,
-						hasNextCandidate
-					}, hasNextCandidate ? "Agent model call threw, trying fallback" : "Agent model call threw, no fallback remains");
-				}
-				if (hasNextCandidate && rowsBeforeAttempt) {
-					const preparation = await sessionStore.prepareModelFallback(sessionKey, rowsBeforeAttempt);
-					if (preparation === "unsafe") {
-						log.warn({
-							sessionKey,
-							runId,
-							modelRef: candidateModelRef,
-							attempt: i + 1
-						}, "Agent model fallback skipped because the failed attempt changed the transcript");
-						break;
-					}
-					resumeLastUserMessage = preparation === "resume";
+						attempt: i + 1
+					}, "Agent model fallback skipped because the failed attempt changed the transcript");
+					break;
 				}
+				resumeLastUserMessage = preparation === "resume";
 			}
-			if (lastResult) return lastResult;
-			if (lastError instanceof Error) throw lastError;
-			if (lastError != null) throw new Error(String(lastError));
-			return {
-				ok: false,
-				errorMessage: "No model candidates available"
-			};
-		} finally {
-			await mcpResolved.dispose().catch(() => {});
 		}
+		if (lastResult) return lastResult;
+		if (lastError instanceof Error) throw lastError;
+		if (lastError != null) throw new Error(String(lastError));
+		return {
+			ok: false,
+			errorMessage: "No model candidates available"
+		};
 	})();
 }
 function serializedTranscriptBytes(messages) {

package/dist/src/agent/external-tools/composio-provider.d.ts

@@ -0,0 +1,29 @@
+import type { AgentToolResult } from '@earendil-works/pi-agent-core';
+import type { Config } from '../../config/schema.js';
+import type { ExtensionHookRunner } from '../../extensions/index.js';
+import { ComposioSessionsAdapter } from '../../connectors/composio-sessions.js';
+import type { ExternalToolDescriptor, ExternalToolExecutionContext, ExternalToolProvider, ExternalToolSearchHit } from './types.js';
+type CurrentContext = {
+    channel: string;
+    chatId: string;
+    sessionKey: string;
+} | null;
+export interface ComposioToolProviderDeps {
+    getConfig: () => Config | undefined;
+    getCurrentContext: () => CurrentContext;
+    agentId?: string;
+    adapter?: ComposioSessionsAdapter;
+    hookRunner?: ExtensionHookRunner;
+}
+export declare class ComposioToolProvider implements ExternalToolProvider {
+    private readonly deps;
+    readonly source: "composio";
+    private readonly adapter;
+    constructor(deps: ComposioToolProviderDeps);
+    search(query: string): Promise<ExternalToolSearchHit[]>;
+    describe(toolRef: string): Promise<ExternalToolDescriptor | undefined>;
+    execute(toolRef: string, args: Record<string, unknown>, approvalId: string | undefined, _context: ExternalToolExecutionContext): Promise<AgentToolResult<Record<string, unknown>>>;
+    private availableInstallations;
+    private resolve;
+}
+export {};