@xopcai/xopc 0.0.170 → 0.0.172

package/dist/src/agent/memory/understanding/service.d.ts

@@ -19,7 +19,9 @@ export declare class UserUnderstandingService {
         agentId?: string;
         sessionKey?: string;
         sourceItemId?: string;
+        sourceItemIds?: string[];
         sourceText?: string;
+        source?: MemoryRecord['source'];
         reviewSource?: 'turn' | 'background';
         supersedesRecordIds?: string[];
     }): Promise<Omit<UnderstandingReviewResult, 'sourceItemId'>>;

package/dist/src/agent/memory/understanding/service.js

@@ -92,6 +92,7 @@ var UserUnderstandingService = class {
 		const contentHash = createHash("sha256").update(sourceText).digest("hex");
 		const sourceItemId = upsertKnowledgeSourceItems([{
 			sourceInstanceId: params.sessionKey ? `session:${params.sessionKey}` : "session:unknown",
+			collectionScope: "conversation",
 			externalId: contentHash,
 			itemType: "conversation_turn",
 			authorRole: "user",
@@ -136,20 +137,21 @@ var UserUnderstandingService = class {
 			const key = candidate.canonicalKey ?? canonicalKey(candidate.kind, content);
 			const supersedesRecordId = correctionTargets.length === 1 ? correctionTargets[0] : void 0;
 			const existing = await this.options.list(key);
-			const evidence = {
-				...context.sourceItemId ? { sourceItemId: context.sourceItemId } : {},
+			const sourceItemIds = [...new Set([...context.sourceItemId ? [context.sourceItemId] : [], ...context.sourceItemIds ?? []])];
+			const evidence = (sourceItemIds.length ? sourceItemIds : [void 0]).map((sourceItemId) => ({
+				...sourceItemId ? { sourceItemId } : {},
 				relation: "supports",
 				...context.sessionKey ? { sessionKey: context.sessionKey } : {},
 				...evidenceText ? { sourceText: evidenceText } : {},
 				observedAt: (/* @__PURE__ */ new Date()).toISOString(),
 				confidence: candidate.confidence
-			};
+			}));
 			if (existing[0]) {
 				deduplicated += 1;
 				recordIds.push(existing[0].id);
-				if (context.sourceItemId) attachMemoryEvidence({
+				for (const sourceItemId of sourceItemIds) attachMemoryEvidence({
 					recordId: existing[0].id,
-					sourceItemId: context.sourceItemId,
+					sourceItemId,
 					relation: "supports",
 					excerpt: evidenceText,
 					confidence: candidate.confidence
@@ -166,7 +168,7 @@ var UserUnderstandingService = class {
 				} : void 0,
 				target: candidate.kind === "preference" ? "user" : "memory",
 				tags: [...new Set(["user-understanding", ...candidate.tags ?? []])],
-				source: { provider: "user-understanding" },
+				source: context.source ?? { provider: "user-understanding" },
 				confidence: candidate.confidence,
 				status: "candidate",
 				sensitivity,
@@ -174,7 +176,7 @@ var UserUnderstandingService = class {
 				durability: candidate.durability,
 				importance: candidate.importance,
 				disclosurePolicy: candidate.disclosurePolicy,
-				evidence: [evidence],
+				evidence,
 				validFrom: candidate.validFrom,
 				validTo: candidate.validTo,
 				reviewAfter: nextMemoryReviewAt({
@@ -194,9 +196,9 @@ var UserUnderstandingService = class {
 						kind: write.record.kind
 					});
 				}
-				if (write.record && context.sourceItemId) attachMemoryEvidence({
+				for (const sourceItemId of write.record ? sourceItemIds : []) attachMemoryEvidence({
 					recordId: write.record.id,
-					sourceItemId: context.sourceItemId,
+					sourceItemId,
 					relation: "supports",
 					excerpt: evidenceText,
 					confidence: candidate.confidence

package/dist/src/agent/orchestration/context-overflow.d.ts

@@ -0,0 +1 @@
+export declare function isContextOverflowError(value: unknown): boolean;

package/dist/src/agent/orchestration/context-overflow.js

@@ -0,0 +1,19 @@
+//#region src/agent/orchestration/context-overflow.ts
+const CONTEXT_OVERFLOW_PATTERNS = [
+	/context(?:_|\s|-)*(?:length|window).*(?:exceed|limit|maximum|too (?:large|long))/i,
+	/maximum context length/i,
+	/max(?:imum)? tokens?.*(?:exceed|limit)/i,
+	/too many tokens/i,
+	/prompt (?:is )?too (?:large|long)/i,
+	/request (?:is )?too large/i,
+	/input (?:is )?too (?:large|long)/i,
+	/input token count.*exceed/i,
+	/reduce (?:the )?(?:length|size) of (?:the )?(?:messages|prompt|input)/i,
+	/token limit exceeded/i
+];
+function isContextOverflowError(value) {
+	const message = value instanceof Error ? value.message : String(value ?? "");
+	return CONTEXT_OVERFLOW_PATTERNS.some((pattern) => pattern.test(message));
+}
+//#endregion
+export { isContextOverflowError };

package/dist/src/agent/orchestration/loop-guard.js

@@ -11,12 +11,16 @@ const DEFAULT_CONFIG = {
 * Stable fingerprint for tool call comparison.
 * Recursively sorts object keys; truncates long string values.
 */
-function fingerprint(toolName, params) {
-	return `${toolName}::${JSON.stringify(params, (_key, value) => {
-		if (typeof value === "object" && value !== null && !Array.isArray(value)) return Object.fromEntries(Object.entries(value).sort(([a], [b]) => a.localeCompare(b)));
-		if (typeof value === "string" && value.length > 200) return `${value.slice(0, 80)}…[${value.length}]`;
-		return value;
-	})}`;
+function stableJson(value) {
+	return JSON.stringify(value, (_key, item) => {
+		if (typeof item === "object" && item !== null && !Array.isArray(item)) return Object.fromEntries(Object.entries(item).sort(([a], [b]) => a.localeCompare(b)));
+		if (typeof item === "string" && item.length > 200) return `${item.slice(0, 80)}…[${item.length}]`;
+		return item;
+	});
+}
+function fingerprint(call) {
+	const result = call.resultPreview === void 0 ? "" : `::result=${stableJson(call.resultPreview)}`;
+	return `${call.name}::${stableJson(call.params)}${result}`;
 }
 /**
 * Analyze recent tool calls and produce loop guard result.
@@ -70,11 +74,11 @@ function findConsecutiveRepeats(calls) {
 	let index = calls.length - 1;
 	while (index >= 0) {
 		const current = calls[index];
-		const fp = fingerprint(current.name, current.params);
+		const fp = fingerprint(current);
 		let count = 1;
 		while (index - count >= 0) {
 			const prev = calls[index - count];
-			if (fingerprint(prev.name, prev.params) !== fp) break;
+			if (fingerprint(prev) !== fp) break;
 			count++;
 		}
 		if (count >= 2) groups.push({
@@ -92,7 +96,7 @@ function findConsecutiveRepeats(calls) {
 function countFrequency(calls) {
 	const map = /* @__PURE__ */ new Map();
 	for (const call of calls) {
-		const fp = fingerprint(call.name, call.params);
+		const fp = fingerprint(call);
 		map.set(fp, (map.get(fp) ?? 0) + 1);
 	}
 	return map;

package/dist/src/agent/reply/post-compaction-context.d.ts

@@ -5,6 +5,8 @@ export type PostCompactionContextOptions = {
     agentId?: string;
     nowMs?: number;
     userTimezone?: string;
+    sectionNames?: string[];
+    maxContextChars?: number;
 };
 export declare function readPostCompactionContextFromAgentsMd(agentsMdContent: string, options?: PostCompactionContextOptions): string | null;
 export declare function readPostCompactionContext(params: {
@@ -13,4 +15,6 @@ export declare function readPostCompactionContext(params: {
     agentId?: string;
     nowMs?: number;
     userTimezone?: string;
+    sectionNames?: string[];
+    maxContextChars?: number;
 }): string | null;

package/dist/src/agent/reply/post-compaction-context.js

@@ -53,7 +53,7 @@ function extractSections(content, sectionNames, foundNames) {
 	return results;
 }
 function readPostCompactionContextFromAgentsMd(agentsMdContent, options) {
-	const sectionNames = DEFAULT_POST_COMPACTION_SECTIONS;
+	const sectionNames = options?.sectionNames ?? DEFAULT_POST_COMPACTION_SECTIONS;
 	if (sectionNames.length === 0) return null;
 	const foundSectionNames = [];
 	const sections = extractSections(agentsMdContent, sectionNames, foundSectionNames);
@@ -62,7 +62,7 @@ function readPostCompactionContextFromAgentsMd(agentsMdContent, options) {
 	const timezone = options?.userTimezone?.trim() || Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
 	const nowMs = options?.nowMs ?? Date.now();
 	const dateStamp = new Intl.DateTimeFormat("en-CA", { timeZone: timezone }).format(new Date(nowMs));
-	const maxContextChars = MAX_CONTEXT_CHARS;
+	const maxContextChars = Math.max(1, options?.maxContextChars ?? MAX_CONTEXT_CHARS);
 	const combined = sections.join("\n\n").replaceAll("YYYY-MM-DD", dateStamp);
 	const safeContent = combined.length > maxContextChars ? `${combined.slice(0, maxContextChars)}\n...[truncated]...` : combined;
 	const isDefaultSections = sectionNames.length === DEFAULT_POST_COMPACTION_SECTIONS.length && sectionNames.every((name, index) => normalizeHeading(name) === normalizeHeading(DEFAULT_POST_COMPACTION_SECTIONS[index] ?? ""));
@@ -84,7 +84,9 @@ function readPostCompactionContext(params) {
 			cfg,
 			agentId,
 			nowMs: params.nowMs,
-			userTimezone: params.userTimezone
+			userTimezone: params.userTimezone,
+			sectionNames: params.sectionNames,
+			maxContextChars: params.maxContextChars
 		});
 	} catch {
 		return null;

package/dist/src/agent/service/process-direct-one-shot.js

@@ -17,8 +17,7 @@ async function runProcessDirect(deps, input) {
 			cfg: deps.config,
 			sessionKey: input.sessionKey,
 			body: input.content,
-			resetSession: deps.resetSession,
-			skipImplicitExpiry: channel === "webchat"
+			resetSession: deps.resetSession
 		});
 		resetTriggeredAtInit = turn.resetTriggered;
 		if (turn.bareReset && turn.ackMessage) return turn.ackMessage;

package/dist/src/agent/service/process-direct-streaming.js

@@ -154,8 +154,7 @@ async function* runProcessDirectStreaming(deps, input) {
 					cfg,
 					sessionKey,
 					body: input.content,
-					resetSession: deps.resetSession,
-					skipImplicitExpiry: channel === "webchat"
+					resetSession: deps.resetSession
 				});
 				resetTriggeredAtInit = turn.resetTriggered;
 				if (turn.bareReset && turn.ackMessage) {

package/dist/src/agent/service.d.ts

@@ -102,7 +102,6 @@ export declare class AgentService {
     private createHookRunner;
     private createProgressManager;
     private initializeReliabilityModules;
-    private initializeLifecycleHandlers;
     setChannelManager(channelManager: ChannelManager): void;
     /**
      * Apply config after save or hot reload so the default model updates without restarting the gateway.
@@ -118,6 +117,7 @@ export declare class AgentService {
     refreshSkillsAfterSkillConfigChange(): void;
     refreshActionTrustPolicy(): void;
     refreshUserProfileContext(): void;
+    getMemoryManager(): import("./memory/manager.js").MemoryManager;
     getModelForSession(sessionKey: string): string;
     switchModelForSession(sessionKey: string, modelId: string): Promise<boolean>;
     /**
@@ -191,7 +191,6 @@ export declare class AgentService {
      * Handle events from a specific session's agent
      */
     private handleSessionEvent;
-    private checkAndCompact;
     private getContextWindowForSession;
     private dispose;
 }

package/dist/src/agent/service.js

@@ -15,6 +15,7 @@ import { onSessionTranscriptUpdate } from "../session/transcript-events.js";
 import { persistInboundAttachments } from "../channels/attachments/inbound-persist.js";
 import { AgentManager } from "./agent-manager.js";
 import { maybeRefineSessionTitleWithLlm, maybeSetProvisionalSessionTitle } from "../session/session-title.js";
+import { resolveCompactionPolicy } from "./memory/compaction-policy.js";
 import { SessionStore } from "../session/store.js";
 import { SessionConfigStore } from "../session/config-store.js";
 import "../session/index.js";
@@ -38,7 +39,6 @@ import "./middleware/index.js";
 import { TurnDiffTracker } from "./coding/turn-diff-tracker.js";
 import { LifecycleManager } from "./lifecycle/manager.js";
 import "./lifecycle/index.js";
-import { CompactionLifecycleHandler } from "./lifecycle/handlers/compaction.js";
 import { MessageRouter } from "./messaging/message-router.js";
 import { CommandHandler } from "./messaging/command-handler.js";
 import { StreamManager } from "./messaging/stream-manager.js";
@@ -203,10 +203,20 @@ var AgentService = class {
 				return this.currentContext?.sessionKey;
 			}
 		});
+		this.sessionStore.setCompactionHooks({
+			before: ({ sessionKey, messageCount, tokenCount }) => this.hookHandler.triggerWithSessionKey(sessionKey, "before_compaction", {
+				messageCount,
+				tokenCount
+			}),
+			after: ({ sessionKey, messageCount, tokenCount, compactedCount }) => this.hookHandler.triggerWithSessionKey(sessionKey, "after_compaction", {
+				messageCount,
+				tokenCount,
+				compactedCount
+			})
+		});
 		this.progressManager = this.createProgressManager();
 		this.initializeReliabilityModules();
 		this.lifecycleManager = new LifecycleManager();
-		this.initializeLifecycleHandlers();
 		this.streamManager = new StreamManager();
 		this.sessionContextManager = new SessionContextManager();
 		this.feedbackCoordinator = new FeedbackCoordinator({
@@ -400,7 +410,6 @@ var AgentService = class {
 			setupSessionEventHandling: (sk) => this.setupSessionEventHandling(sk),
 			sessionHydrator: this.sessionHydrator,
 			getLastAssistantPlainText: (sk) => this.getLastAssistantPlainText(sk),
-			checkAndCompact: (sk, msgs) => this.checkAndCompact(sk, msgs),
 			enqueueMaybeAutoTitleAfterPersist: (sk) => this.enqueueMaybeAutoTitleAfterPersist(sk),
 			getConfig: () => this.effectiveAppConfig(),
 			resetSession: (sk) => this.resetSession(sk),
@@ -418,19 +427,9 @@ var AgentService = class {
 			keepRecentMessages: 20,
 			preserveSystemMessages: true
 		};
-		const compactionConfig = {
-			enabled: true,
-			mode: "abstractive",
-			reserveTokens: 8e3,
-			triggerThreshold: .8,
-			minMessagesBeforeCompact: 10,
-			keepRecentMessages: 10,
-			evictionWindow: .2,
-			retentionWindow: 6
-		};
 		const appCfg = this.config.config;
 		if (!appCfg) throw new Error("AgentService requires config.config for session store paths");
-		return new SessionStore({ config: appCfg }, windowConfig, compactionConfig);
+		return new SessionStore({ config: appCfg }, windowConfig, resolveCompactionPolicy(appCfg));
 	}
 	createHookRunner() {
 		if (!this.config.extensionRegistry) return void 0;
@@ -498,15 +497,6 @@ var AgentService = class {
 		});
 		this.contextMiddleware = new ContextMiddleware();
 	}
-	initializeLifecycleHandlers() {
-		this.lifecycleManager.on("llm_response", new CompactionLifecycleHandler({
-			minMessages: 20,
-			maxTokens: 8e3,
-			preserveReasoning: true,
-			accumulateUsage: true
-		}));
-		log.debug({ handlers: this.lifecycleManager.getRegisteredHandlers() }, "Lifecycle handlers initialized");
-	}
 	setChannelManager(channelManager) {
 		this.inboundLoop.setChannelManager(channelManager);
 	}
@@ -566,6 +556,9 @@ var AgentService = class {
 	refreshUserProfileContext() {
 		this.agentManager.refreshUserProfileContext();
 	}
+	getMemoryManager() {
+		return this.agentManager.getMemoryManager();
+	}
 	getModelForSession(sessionKey) {
 		return this.modelManager.getModelForSession(sessionKey);
 	}
@@ -809,27 +802,6 @@ var AgentService = class {
 		}
 		this.agentEventHandler.handle(event, currentContext);
 	}
-	async checkAndCompact(sessionKey, messages) {
-		const contextWindow = this.getContextWindowForSession(sessionKey);
-		const prep = this.sessionStore.prepareCompaction(sessionKey, messages, contextWindow);
-		if (!prep.needsCompaction) return;
-		log.info({
-			sessionKey,
-			reason: prep.stats?.reason,
-			usagePercent: prep.stats?.usagePercent
-		}, "Session needs compaction");
-		const result = await this.sessionStore.compact(sessionKey, messages, contextWindow, void 0, false);
-		await this.hookHandler.trigger("after_compaction", {
-			messageCount: messages.length,
-			tokenCount: result.tokensBefore,
-			compactedCount: messages.length - result.firstKeptIndex
-		});
-		log.info({
-			sessionKey,
-			tokensBefore: result.tokensBefore,
-			tokensAfter: result.tokensAfter
-		}, "Session compacted");
-	}
 	getContextWindowForSession(sessionKey) {
 		try {
 			return this.modelManager.getResolvedModelForSession(sessionKey).contextWindow ?? 128e3;

package/dist/src/agent/session/session-inspector.js

@@ -2,8 +2,10 @@ import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
 import { init_workspace_defaults, resolveDefaultAgentWorkspaceDir } from "../../config/workspace-defaults.js";
 import { resolveEffectiveAgentProfileForSession } from "../../config/agent-profile.js";
+import { init_providers, resolveModel } from "../../providers/index.js";
 import { effectiveWorkspacePathForSession, projectWorkspacePath } from "../../session/session-workspace.js";
 import { getProjectForSession } from "../../projects/workspace.js";
+import { resolveCompactionPolicy } from "../memory/compaction-policy.js";
 import { resolveVerboseLevel } from "../../session/config-store.js";
 import { resolveEffectiveReasoningLevel, resolveEffectiveThinkingLevel } from "../../session/thinking-resolve.js";
 import "../../session/index.js";
@@ -12,6 +14,7 @@ import { formatSessionContextReport } from "../service/session-context-report.js
 //#region src/agent/session/session-inspector.ts
 init_workspace_defaults();
 init_logger();
+init_providers();
 const log = createLogger("SessionInspector");
 var SessionInspector = class {
 	opts;
@@ -37,8 +40,13 @@ var SessionInspector = class {
 	*/
 	async compact(sessionKey, options) {
 		const messages = await this.opts.sessionStore.load(sessionKey);
-		const contextWindow = await this.contextWindowForSession(sessionKey);
-		const result = await this.opts.sessionStore.compact(sessionKey, messages, contextWindow, options?.instructions, options?.force ?? true);
+		await this.ensureEffectiveSessionModel(sessionKey);
+		const policy = resolveCompactionPolicy(this.opts.getConfig());
+		const sessionModel = this.opts.modelManager.getResolvedModelForSession(sessionKey);
+		const model = policy.model ? resolveModel(policy.model) : sessionModel;
+		const primaryRef = `${model.provider}/${model.id}`;
+		const fallbackModels = this.opts.modelManager.getFallbackCandidatesForSession(sessionKey).map((candidate) => resolveModel(`${candidate.provider}/${candidate.model}`)).filter((candidate) => `${candidate.provider}/${candidate.id}` !== primaryRef);
+		const result = await this.opts.sessionStore.compact(sessionKey, messages, model, options?.instructions, options?.force ?? true, { fallbackModels });
 		if (result.compacted) this.opts.agentManager.removeAgent(sessionKey);
 		log.info({
 			sessionKey,

package/dist/src/automations/domain/validation.d.ts

@@ -90,12 +90,12 @@ export declare const AutomationStateSchema: z.ZodObject<{
     runningRunId: z.ZodPreprocess<z.ZodOptional<z.ZodString>>;
     lastRunAtMs: z.ZodOptional<z.ZodNumber>;
     lastRunStatus: z.ZodOptional<z.ZodEnum<{
+        queued: "queued";
+        running: "running";
         failed: "failed";
         cancelled: "cancelled";
         timeout: "timeout";
         succeeded: "succeeded";
-        running: "running";
-        queued: "queued";
     }>>;
     lastError: z.ZodOptional<z.ZodString>;
     consecutiveFailures: z.ZodOptional<z.ZodNumber>;
@@ -185,12 +185,12 @@ export declare const AutomationSchema: z.ZodObject<{
         runningRunId: z.ZodPreprocess<z.ZodOptional<z.ZodString>>;
         lastRunAtMs: z.ZodOptional<z.ZodNumber>;
         lastRunStatus: z.ZodOptional<z.ZodEnum<{
+            queued: "queued";
+            running: "running";
             failed: "failed";
             cancelled: "cancelled";
             timeout: "timeout";
             succeeded: "succeeded";
-            running: "running";
-            queued: "queued";
         }>>;
         lastError: z.ZodOptional<z.ZodString>;
         consecutiveFailures: z.ZodOptional<z.ZodNumber>;
@@ -283,12 +283,12 @@ export declare const CreateAutomationSchema: z.ZodObject<{
         runningRunId: z.ZodOptional<z.ZodPreprocess<z.ZodOptional<z.ZodString>>>;
         lastRunAtMs: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
         lastRunStatus: z.ZodOptional<z.ZodOptional<z.ZodEnum<{
+            queued: "queued";
+            running: "running";
             failed: "failed";
             cancelled: "cancelled";
             timeout: "timeout";
             succeeded: "succeeded";
-            running: "running";
-            queued: "queued";
         }>>>;
         lastError: z.ZodOptional<z.ZodOptional<z.ZodString>>;
         consecutiveFailures: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
@@ -331,12 +331,12 @@ export declare const UpdateAutomationSchema: z.ZodObject<{
         runningRunId: z.ZodPreprocess<z.ZodOptional<z.ZodString>>;
         lastRunAtMs: z.ZodOptional<z.ZodNumber>;
         lastRunStatus: z.ZodOptional<z.ZodEnum<{
+            queued: "queued";
+            running: "running";
             failed: "failed";
             cancelled: "cancelled";
             timeout: "timeout";
             succeeded: "succeeded";
-            running: "running";
-            queued: "queued";
         }>>;
         lastError: z.ZodOptional<z.ZodString>;
         consecutiveFailures: z.ZodOptional<z.ZodNumber>;

package/dist/src/automations/draft/automation-draft-validator.d.ts

@@ -89,7 +89,7 @@ export declare function buildAutomationDraftResponse(draft: GeneratedAutomationD
             nextRunAtMs?: number;
             runningRunId?: string;
             lastRunAtMs?: number;
-            lastRunStatus?: "failed" | "cancelled" | "timeout" | "succeeded" | "running" | "queued";
+            lastRunStatus?: "queued" | "running" | "failed" | "cancelled" | "timeout" | "succeeded";
             lastError?: string;
             consecutiveFailures?: number;
         };

package/dist/src/cli/commands/doctor/checks/database-schema.js

@@ -52,7 +52,7 @@ async function checkDatabaseSchema(ctx) {
 		id: "database-schema",
 		label: "Database schema",
 		status: "pass",
-		message: `SQLite schema v${status.dbVersion} (current release v59).`,
+		message: `SQLite schema v${status.dbVersion} (current release v65).`,
 		hints: []
 	};
 }

package/dist/src/config/schema.d.ts

@@ -1552,7 +1552,23 @@ export declare const ConfigSchema: z.ZodDefault<z.ZodObject<{
                 }>>;
             }, z.core.$strict>>;
             retention: z.ZodOptional<z.ZodObject<{
-                compaction: z.ZodDefault<z.ZodBoolean>;
+                compaction: z.ZodDefault<z.ZodObject<{
+                    enabled: z.ZodDefault<z.ZodBoolean>;
+                    triggerThreshold: z.ZodDefault<z.ZodNumber>;
+                    reserveTokens: z.ZodDefault<z.ZodNumber>;
+                    minMessagesBeforeCompact: z.ZodDefault<z.ZodNumber>;
+                    keepRecentTokens: z.ZodDefault<z.ZodNumber>;
+                    recentTurnsPreserve: z.ZodDefault<z.ZodNumber>;
+                    summaryMaxTokens: z.ZodDefault<z.ZodNumber>;
+                    summaryChunkTokens: z.ZodDefault<z.ZodNumber>;
+                    summaryTimeoutMs: z.ZodDefault<z.ZodNumber>;
+                    summaryRetries: z.ZodDefault<z.ZodNumber>;
+                    qualityGuard: z.ZodDefault<z.ZodBoolean>;
+                    model: z.ZodOptional<z.ZodString>;
+                    minToolResultKeepChars: z.ZodDefault<z.ZodNumber>;
+                    maxActiveTranscriptBytes: z.ZodDefault<z.ZodNumber>;
+                    postCompactionSections: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                }, z.core.$strict>>;
                 maxAgeDays: z.ZodOptional<z.ZodNumber>;
                 maxItems: z.ZodOptional<z.ZodNumber>;
                 maxChars: z.ZodOptional<z.ZodNumber>;

package/dist/src/connectors/composio-sessions.d.ts

@@ -73,6 +73,7 @@ export type ComposioSessionsClient = {
 export type ComposioSessionContext = {
     principalId: string;
     installationScope?: string;
+    providerPrincipalId?: string;
     toolkits?: string[];
     connectedAccounts?: Record<string, string[]>;
     callbackUrl?: string;

package/dist/src/connectors/composio-sessions.js

@@ -1,3 +1,4 @@
+import { init_paths_state, resolveStateDir } from "../config/paths-state.js";
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
 import { appendConnectorExecutionAudit, getConnectorInstallation, listConnectorConnections, upsertConnectorConnection } from "../storage/sqlite/connector-repository.js";
@@ -7,6 +8,7 @@ import { resolve } from "node:path";
 import { createHash } from "node:crypto";
 //#region src/connectors/composio-sessions.ts
 init_credentials();
+init_paths_state();
 init_logger();
 const log = createLogger("Connectors:ComposioSessions");
 const COMPOSIO_API_KEY_PROVIDER = "connector-composio-api-key";
@@ -22,8 +24,7 @@ function stableHash(value) {
 	return createHash("sha256").update(value).digest("hex").slice(0, 24);
 }
 function defaultInstallationScope() {
-	const configured = process.env.XOPC_STATE_DIR?.trim() || process.env.XOPC_CONFIG_PATH?.trim();
-	return configured ? resolve(configured) : resolve(process.cwd());
+	return resolve(resolveStateDir());
 }
 /** Convert local identities to stable opaque Composio user IDs without disclosing user data. */
 function createComposioPrincipalId(principalId, installationScope = defaultInstallationScope()) {
@@ -105,7 +106,7 @@ var ComposioSessionsAdapter = class {
 			...context.toolkits?.length ? { toolkits: { enable: context.toolkits } } : {},
 			...context.connectedAccounts && Object.keys(context.connectedAccounts).length > 0 ? { connectedAccounts: context.connectedAccounts } : {}
 		};
-		return client.sessions.create(createComposioPrincipalId(context.principalId, context.installationScope), config);
+		return client.sessions.create(context.providerPrincipalId ?? createComposioPrincipalId(context.principalId, context.installationScope), config);
 	}
 	async listToolkitCatalog(context) {
 		const session = await this.createSession(context);
@@ -130,8 +131,10 @@ var ComposioSessionsAdapter = class {
 		return items;
 	}
 	async authorize(context) {
+		const providerPrincipalId = createComposioPrincipalId(context.principalId, context.installationScope);
 		const request = await (await this.createSession({
 			...context,
+			providerPrincipalId,
 			toolkits: [context.toolkit]
 		})).authorize(context.toolkit, {
 			callbackUrl: context.callbackUrl,
@@ -152,7 +155,10 @@ var ComposioSessionsAdapter = class {
 				principalId: context.principalId,
 				connectorId
 			}).length === 0,
-			metadata: { toolkit: context.toolkit }
+			metadata: {
+				toolkit: context.toolkit,
+				providerPrincipalId
+			}
 		});
 		return {
 			toolkit: context.toolkit,
@@ -249,9 +255,12 @@ var ComposioSessionsAdapter = class {
 		try {
 			const toolkit = input.action.toolkit;
 			const connectedAccounts = toolkit && input.connection ? { [toolkit]: [input.connection.providerConnectionId] } : input.context.connectedAccounts;
+			const providerPrincipalId = input.connection?.metadata.providerPrincipalId;
+			if (input.connection && (typeof providerPrincipalId !== "string" || !providerPrincipalId.trim())) throw new Error("Connected account is missing its provider identity. Reconnect the account and try again.");
 			const result = await (await this.createSession({
 				...input.context,
-				connectedAccounts
+				connectedAccounts,
+				...typeof providerPrincipalId === "string" ? { providerPrincipalId } : {}
 			})).execute(input.action.actionId, input.args ?? {}, input.connection ? { account: input.connection.providerConnectionId } : void 0);
 			appendConnectorExecutionAudit({
 				installationId: input.installation.id,

package/dist/src/connectors/composio-triggers.d.ts

@@ -22,6 +22,6 @@ export declare function normalizeComposioTriggerPayload(payload: unknown, webhoo
     trigger?: string;
     data: Record<string, unknown>;
 };
-export declare function applyComposioConnectionLifecycleEvent(payload: unknown): void;
+export declare function applyComposioConnectionLifecycleEvent(payload: unknown): string | undefined;
 export declare function appendComposioTriggerEvent(config: Config, payload: unknown): Promise<ComposioTriggerArchiveEntry>;
 export declare function listComposioTriggerEvents(config: Config, limit?: number): Promise<ComposioTriggerArchiveEntry[]>;

package/dist/src/connectors/composio-triggers.js

@@ -37,17 +37,18 @@ function normalizeComposioTriggerPayload(payload, webhookId) {
 }
 function applyComposioConnectionLifecycleEvent(payload) {
 	const normalized = normalizeComposioTriggerPayload(payload);
-	if (normalized.type !== "composio.connected_account.expired" && normalized.type !== "composio.connected_account.deleted") return;
+	if (normalized.type !== "composio.connected_account.expired" && normalized.type !== "composio.connected_account.deleted") return void 0;
 	const providerConnectionId = readString(normalized.data.id ?? normalized.data.nanoid ?? normalized.data.connected_account_id);
-	if (!providerConnectionId) return;
+	if (!providerConnectionId) return void 0;
 	const connection = listConnectorConnections().find((candidate) => candidate.provider === "composio" && candidate.providerConnectionId === providerConnectionId);
-	if (!connection) return;
+	if (!connection) return void 0;
 	upsertConnectorConnection({
 		...connection,
 		status: normalized.type.endsWith(".deleted") ? "revoked" : "expired",
 		isDefault: false,
 		lastError: normalized.type.endsWith(".deleted") ? "Connection was removed in Composio." : "Connection expired and requires authorization."
 	});
+	return connection.id;
 }
 async function appendComposioTriggerEvent(config, payload) {
 	const record = payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};

package/dist/src/connectors/composio.js

@@ -57,6 +57,7 @@ const ADMIN_ACTION_TOKENS = [
 ];
 const COMPOSIO_CURATED_ACTIONS = {
 	gmail: {
+		GMAIL_GET_PROFILE: "read",
 		GMAIL_FETCH_EMAILS: "read",
 		GMAIL_GET_EMAIL: "read",
 		GMAIL_LIST_LABELS: "read",

package/dist/src/connectors/{connector-memory-sync.d.ts → connected-source-ingestion.d.ts}

@@ -1,20 +1,27 @@
 import type { Config } from '../config/schema.js';
+import { type KnowledgePullInput } from '../knowledge/index.js';
 import { ComposioSessionsAdapter } from './composio-sessions.js';
-export declare const COMPOSIO_MEMORY_SOURCE_TOOLKITS: Set<string>;
-export declare function syncComposioResultToMemory(input: {
+export declare const COMPOSIO_CONNECTED_SOURCE_TOOLKITS: Set<string>;
+export declare function ingestComposioConnectedSource(input: {
     config: Config;
     connectorId: string;
+    collectionScope: string;
+    streamKind: 'activity' | 'inventory';
     actionId: string;
     arguments?: Record<string, unknown>;
+    buildArguments?: (pull: KnowledgePullInput) => Record<string, unknown>;
     agentId: string;
     connectionId?: string;
     adapter?: ComposioSessionsAdapter;
 }): Promise<{
-    recordId: string;
     connectorId: string;
     actionId: string;
+    sourceInstanceId: string;
+    itemsSeen: number;
+    itemsIndexed: number;
+    recordIds: string[];
 }>;
-export declare function syncLocalFolderToMemory(input: {
+export declare function ingestLocalFolderSource(input: {
     config: Config;
     connectorId: string;
     agentId: string;