@xopcai/xopc 0.0.248 → 0.0.250

package/dist/src/agent/memory/builtin-provider.js

@@ -1,225 +0,0 @@
-import { init_agent_session_key, normalizeAgentId } from "../../routing/agent-session-key.js";
-import { appendMemorySignal, deleteMemoryRecord, getMemoryRecord, listMemoryRecords, searchMemoryRecords, upsertMemoryRecord } from "../../storage/sqlite/memory-records-repository.js";
-import "../../storage/sqlite/index.js";
-import { resolveMemorySessionKind } from "./turn-provenance.js";
-//#region src/agent/memory/builtin-provider.ts
-init_agent_session_key();
-/**
-* Builtin local memory provider backed exclusively by the structured SQLite store.
-*/
-var BuiltinMemoryProvider = class {
-	id = "local";
-	displayName = "Local Knowledge Store";
-	capabilities = {
-		search: true,
-		read: true,
-		write: true,
-		update: true,
-		delete: true,
-		keywordSearch: true,
-		semanticSearch: false,
-		hybridSearch: true,
-		citations: true,
-		sync: false,
-		local: true
-	};
-	isAvailable() {
-		return true;
-	}
-	async initialize() {}
-	systemPromptBlock() {
-		return "";
-	}
-	queuePrefetch() {}
-	getToolSchemas() {
-		return [];
-	}
-	async search(request) {
-		const options = {
-			query: request.query,
-			visibleToSessionKey: request.scope?.sessionKey,
-			unscopedSessionOnly: request.scope?.sessionKey == null,
-			visibleToProjectId: request.scope?.projectId,
-			unscopedProjectOnly: request.scope?.projectId == null,
-			visibleToWorkspaceId: request.scope?.workspaceId,
-			unscopedWorkspaceOnly: request.scope?.workspaceId == null,
-			kinds: request.kinds,
-			maxResults: request.maxResults,
-			minScore: request.minScore,
-			trustedOnly: request.trustedOnly
-		};
-		const [active, shadow] = [searchMemoryRecords(options), searchMemoryRecords({
-			...options,
-			statuses: ["candidate"],
-			maxResults: Math.min(5, request.maxResults ?? 5)
-		})];
-		for (const result of shadow) appendMemorySignal({
-			signal: {
-				source: "search_recall",
-				recordId: result.record.id,
-				score: result.score,
-				metadata: {
-					query: request.query,
-					shadow: true
-				}
-			},
-			providerId: this.id,
-			sourceAgentId: result.record.provenance.sourceAgentId,
-			workspaceId: request.scope?.workspaceId,
-			sessionKey: request.scope?.sessionKey
-		});
-		return active.filter((result) => this.canReadRecord(result.record, request.scope)).sort((left, right) => right.score - left.score).slice(0, request.maxResults ?? 5);
-	}
-	async read(request) {
-		if (!request.id) return null;
-		const record = getMemoryRecord(request.id);
-		return record && this.canReadRecord(record, request.scope) ? { record } : null;
-	}
-	async get(id) {
-		return getMemoryRecord(id);
-	}
-	async list(request) {
-		return listMemoryRecords({
-			providerId: this.id,
-			visibleToWorkspaceId: request.scope?.workspaceId,
-			unscopedWorkspaceOnly: request.scope?.workspaceId == null,
-			visibleToSessionKey: request.scope?.sessionKey,
-			visibleToProjectId: request.scope?.projectId,
-			kind: request.kind,
-			status: request.status,
-			canonicalKey: request.canonicalKey,
-			limit: 200
-		});
-	}
-	async write(request) {
-		const sourceAgentId = normalizeAgentId(request.sourceAgentId ?? "main");
-		const sourceSessionId = request.provenance?.sourceSessionId ?? request.scope?.sessionKey;
-		const originClass = request.confirmed ? "owner" : request.provenance?.originClass ?? "agent";
-		const record = upsertMemoryRecord({
-			providerId: this.id,
-			kind: request.kind,
-			sourceAgentId,
-			workspaceId: request.scope?.workspaceId,
-			sessionKey: request.scope?.sessionKey,
-			projectId: request.scope?.projectId,
-			content: request.content,
-			source: {
-				provider: this.id,
-				...request.source ?? {}
-			},
-			confidence: request.confidence,
-			tags: request.tags,
-			status: request.status ?? "active",
-			sensitivity: request.sensitivity,
-			canonicalKey: request.canonicalKey,
-			explicitness: request.explicitness,
-			durability: request.durability,
-			importance: request.importance,
-			disclosurePolicy: request.disclosurePolicy,
-			evidence: request.evidence,
-			validFrom: request.validFrom,
-			validTo: request.validTo,
-			reviewAfter: request.reviewAfter,
-			expiresAt: request.expiresAt,
-			supersedesRecordId: request.supersedesRecordId,
-			conflictGroupId: request.conflictGroupId,
-			originClass,
-			sessionKind: request.provenance?.sessionKind ?? (sourceSessionId ? resolveMemorySessionKind(sourceSessionId) : "unknown"),
-			observedAt: request.provenance?.observedAt,
-			sourceSessionId,
-			sourceTurnId: request.provenance?.sourceTurnId,
-			supersedesKey: request.provenance?.supersedesKey,
-			derivedFromRecalledContext: request.confirmed ? false : request.provenance?.derivedFromRecalledContext
-		});
-		return {
-			success: true,
-			message: record.status === "candidate" ? "Memory candidate added to inbox" : "Memory saved",
-			record
-		};
-	}
-	async update(request) {
-		if (!request.id) return {
-			success: false,
-			error: "Memory record id is required"
-		};
-		const existing = getMemoryRecord(request.id);
-		if (!existing || !this.canReadRecord(existing, request.scope)) return {
-			success: false,
-			error: "Memory record not found"
-		};
-		return {
-			success: true,
-			message: "Memory updated",
-			record: upsertMemoryRecord({
-				id: request.id,
-				providerId: this.id,
-				kind: existing.kind,
-				userId: existing.scope.userId,
-				sourceAgentId: existing.provenance.sourceAgentId,
-				workspaceId: existing.scope.workspaceId,
-				sessionKey: existing.scope.sessionKey,
-				projectId: existing.scope.projectId,
-				content: request.content,
-				source: existing.source,
-				confidence: existing.confidence,
-				tags: existing.tags,
-				status: existing.status,
-				sensitivity: existing.sensitivity,
-				canonicalKey: existing.canonicalKey,
-				explicitness: existing.explicitness,
-				durability: existing.durability,
-				importance: existing.importance,
-				disclosurePolicy: existing.disclosurePolicy,
-				evidence: existing.evidence,
-				validFrom: existing.validFrom,
-				validTo: existing.validTo,
-				reviewAfter: existing.reviewAfter,
-				expiresAt: existing.expiresAt,
-				supersedesRecordId: existing.supersedesRecordId,
-				conflictGroupId: existing.conflictGroupId,
-				originClass: existing.provenance.originClass,
-				sessionKind: existing.provenance.sessionKind,
-				observedAt: existing.provenance.observedAt,
-				sourceSessionId: existing.provenance.sourceSessionId,
-				sourceTurnId: existing.provenance.sourceTurnId,
-				supersedesKey: existing.provenance.supersedesKey,
-				derivedFromRecalledContext: existing.provenance.derivedFromRecalledContext
-			})
-		};
-	}
-	async delete(request) {
-		if (!request.id) return {
-			success: false,
-			error: "Memory record id is required"
-		};
-		const existing = getMemoryRecord(request.id);
-		if (!existing || !this.canReadRecord(existing, request.scope)) return {
-			success: false,
-			error: "Memory record not found"
-		};
-		deleteMemoryRecord(request.id);
-		return {
-			success: true,
-			message: "Memory deleted"
-		};
-	}
-	sync(event) {
-		if (event.type !== "signal") return;
-		appendMemorySignal({
-			signal: event.signal,
-			providerId: this.id,
-			sourceAgentId: typeof event.signal.metadata?.agentId === "string" ? normalizeAgentId(event.signal.metadata.agentId) : "main",
-			workspaceId: typeof event.signal.metadata?.workspaceId === "string" ? event.signal.metadata.workspaceId : void 0,
-			sessionKey: typeof event.signal.metadata?.sessionKey === "string" ? event.signal.metadata.sessionKey : void 0
-		});
-	}
-	async shutdown() {}
-	canReadRecord(record, scope) {
-		if (record.scope.sessionKey && record.scope.sessionKey !== scope?.sessionKey) return false;
-		if (record.scope.projectId && record.scope.projectId !== scope?.projectId) return false;
-		if (record.scope.workspaceId && record.scope.workspaceId !== scope?.workspaceId) return false;
-		return true;
-	}
-};
-//#endregion
-export { BuiltinMemoryProvider };

package/dist/src/agent/memory/context/types.d.ts

@@ -1,40 +0,0 @@
-import type { AgentMessage } from '@earendil-works/pi-agent-core';
-export type UserContextRejectionReason = 'expired' | 'not_yet_valid' | 'sensitive' | 'requires_consent' | 'needs_review' | 'scope_mismatch' | 'disabled' | 'conflict' | 'low_score' | 'budget';
-export interface PlannedUserContextItem {
-    recordId: string;
-    objectType: 'profile' | 'rule' | 'focus' | 'understanding';
-    versionId?: string;
-    content: string;
-    score: number;
-    section: 'task' | 'interaction' | 'safety';
-    citation: string;
-    origin: 'told_by_user' | 'observed' | 'inferred' | 'connected_source';
-    stability: number;
-}
-export interface UserContextPlan {
-    traceId: string;
-    modelMessage: AgentMessage;
-    items: PlannedUserContextItem[];
-    rejected: Array<{
-        recordId: string;
-        reason: UserContextRejectionReason;
-    }>;
-    consentRequests: Array<{
-        id: string;
-        recordId: string;
-        statement: string;
-        purpose: string;
-    }>;
-    estimatedTokens: number;
-    /** Exact rendered context characters prepended before the user's message. */
-    contextChars: number;
-    contextItemCount: number;
-    /** Generic durable memory records selected by the trusted automatic recall lane. */
-    memoryRecordIds?: string[];
-    allocation?: {
-        profile: 'standard' | 'deep' | 'critical';
-        maxResults: number;
-        maxChars: number;
-        reason: string;
-    };
-}

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

@@ -1,8 +0,0 @@
-import type { UserUnderstandingQualityMetrics } from '../../../storage/sqlite/index.js';
-export interface UnderstandingCadenceDecision {
-    baseIntervalTurns: number;
-    effectiveIntervalTurns: number;
-    slowed: boolean;
-    reasons: Array<'candidate_backlog' | 'low_acceptance' | 'low_recall_quality'>;
-}
-export declare function resolveAdaptiveUnderstandingCadence(baseIntervalTurns: number, metrics: UserUnderstandingQualityMetrics, enabled?: boolean): UnderstandingCadenceDecision;

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

@@ -1,18 +0,0 @@
-//#region src/agent/memory/understanding/quality.ts
-function resolveAdaptiveUnderstandingCadence(baseIntervalTurns, metrics, enabled = true) {
-	const base = Math.max(1, Math.min(1e3, Math.floor(baseIntervalTurns)));
-	const reasons = [];
-	if (enabled) {
-		if (metrics.records.candidate >= 20 || metrics.records.agingCandidates >= 10) reasons.push("candidate_backlog");
-		if (metrics.decisions.total >= 10 && metrics.decisions.acceptanceRate != null && metrics.decisions.acceptanceRate < .25) reasons.push("low_acceptance");
-		if (metrics.recall.total >= 10 && metrics.recall.helpfulRate != null && metrics.recall.helpfulRate < .4) reasons.push("low_recall_quality");
-	}
-	return {
-		baseIntervalTurns: base,
-		effectiveIntervalTurns: reasons.length > 0 ? Math.min(1e3, base * 2) : base,
-		slowed: reasons.length > 0,
-		reasons
-	};
-}
-//#endregion
-export { resolveAdaptiveUnderstandingCadence };

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

@@ -1,19 +0,0 @@
-import type { UnderstandingCandidate, UnderstandingReviewResult } from './types.js';
-export declare class UserUnderstandingService {
-    applyCandidates(candidates: UnderstandingCandidate[], context: {
-        sessionKey?: string;
-        workspaceId?: string;
-        projectId?: string;
-        sourceItemId?: string;
-        sourceItemIds?: string[];
-        sourceText?: string;
-        source?: {
-            provider?: string;
-            sourceInstanceId?: string;
-        };
-        evidenceIds?: string[];
-        reviewSource?: 'turn' | 'background';
-        supersedesRecordIds?: string[];
-        extractionRunId?: string;
-    }): Promise<Omit<UnderstandingReviewResult, 'sourceItemId'>>;
-}

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

@@ -1,209 +0,0 @@
-import { getContextExtractionRun } from "../../../storage/sqlite/context-extraction-repository.js";
-import { closeTemporalAssertions, createTemporalAssertion, linkContextObjects } from "../../../storage/sqlite/context-relation-repository.js";
-import { closeUnderstandingValidity, createContextEvidence, createUnderstanding, getUnderstanding, isUnderstandingSuppressed, linkUnderstandingEvidence, listUnderstandings, setUnderstandingStatus } from "../../../storage/sqlite/user-context-repository.js";
-import "../../../storage/sqlite/index.js";
-import { getRegisteredExtractorDefinition } from "../../../user-context/extraction/registry.js";
-import { canonicalUnderstandingKey, findContradictoryUnderstanding, findDuplicateUnderstanding } from "../../../user-context/understanding.js";
-import { inferMemorySensitivity, redactSensitiveMemoryText } from "../sensitivity.js";
-//#region src/agent/memory/understanding/service.ts
-const MAX_CANDIDATE_CHARS = 600;
-const SENSITIVITY_RANK = {
-	normal: 0,
-	personal: 1,
-	secret: 2,
-	regulated: 3
-};
-function effectiveSensitivity(declared, content) {
-	const inferred = inferMemorySensitivity(content);
-	return SENSITIVITY_RANK[inferred] > SENSITIVITY_RANK[declared] ? inferred : declared;
-}
-function normalizeContent(raw) {
-	return raw.replace(/^["'“”‘’\s]+|["'“”‘’\s]+$/g, "").replace(/\s+/g, " ").trim().slice(0, MAX_CANDIDATE_CHARS);
-}
-function candidateTime(value) {
-	if (!value) return void 0;
-	const parsed = Date.parse(value);
-	return Number.isFinite(parsed) ? parsed : void 0;
-}
-function scopeForCandidate(candidate, context) {
-	if (candidate.durability === "ephemeral" && context.sessionKey) return {
-		type: "session",
-		id: context.sessionKey
-	};
-	if (candidate.kind === "project_context" && context.projectId) return {
-		type: "project",
-		id: context.projectId
-	};
-	if ((candidate.kind === "project_context" || candidate.kind === "task_lesson") && context.workspaceId) return {
-		type: "workspace",
-		id: context.workspaceId
-	};
-	return { type: "global" };
-}
-var UserUnderstandingService = class {
-	async applyCandidates(candidates, context) {
-		let created = 0;
-		let deduplicated = 0;
-		const createdRecords = [];
-		const writeOutputs = [];
-		const correctionTarget = context.supersedesRecordIds?.length === 1 ? context.supersedesRecordIds[0] : void 0;
-		const extractionRun = context.extractionRunId ? getContextExtractionRun(context.extractionRunId) : null;
-		if (context.extractionRunId && !extractionRun) throw new Error("Context extraction run not found");
-		if (context.source?.provider && !extractionRun) throw new Error("External understanding requires an extraction run");
-		const extractionDefinition = extractionRun ? getRegisteredExtractorDefinition(extractionRun.extractorId) : void 0;
-		const prepared = candidates.slice(0, 10).map((candidate) => {
-			const content = normalizeContent(candidate.content);
-			return {
-				candidate,
-				content,
-				sensitivity: effectiveSensitivity(candidate.sensitivity, content),
-				scope: scopeForCandidate(candidate, context),
-				key: candidate.canonicalKey ?? canonicalUnderstandingKey(candidate.kind, content),
-				explicitness: extractionDefinition?.authorityCeiling === "user_explicit" ? candidate.explicitness : extractionDefinition?.authorityCeiling === "user_observed" ? candidate.explicitness === "explicit" ? "observed" : candidate.explicitness : extractionDefinition ? "inferred" : candidate.explicitness
-			};
-		});
-		const eligible = prepared.filter(({ candidate, content, sensitivity, scope, key }) => content.length >= 4 && candidate.confidence >= .55 && sensitivity !== "secret" && sensitivity !== "regulated" && (!extractionDefinition || extractionDefinition.candidateKinds.includes(candidate.kind)) && !isUnderstandingSuppressed(key, scope));
-		let rejected = candidates.length - eligible.length;
-		for (const item of prepared.filter((candidate) => !eligible.includes(candidate))) writeOutputs.push({
-			candidateKey: item.key,
-			outcome: "rejected"
-		});
-		if (!eligible.length) return {
-			proposed: candidates.length,
-			created,
-			deduplicated,
-			rejected,
-			createdRecords,
-			writeOutputs
-		};
-		const evidenceIds = [...new Set(context.evidenceIds ?? [])];
-		const sourceItemIds = [context.sourceItemId, ...context.sourceItemIds ?? []].filter((value) => Boolean(value));
-		for (const sourceItemId of [...new Set(sourceItemIds)]) {
-			const evidence = createContextEvidence({
-				sourceType: context.source?.provider ? "connector" : "runtime",
-				...context.source?.sourceInstanceId ? { sourceInstanceId: context.source.sourceInstanceId } : {},
-				sourceRef: sourceItemId,
-				...context.extractionRunId ? { sourceRunId: context.extractionRunId } : {},
-				sourceItemId,
-				retentionPolicy: "derived_only",
-				...extractionRun ? { processingPolicy: extractionRun.processingPolicy } : {},
-				...extractionRun ? {
-					extractorId: extractionRun.extractorId,
-					extractorVersion: extractionRun.extractorVersion
-				} : {},
-				...context.sourceText ? { redactedExcerpt: redactSensitiveMemoryText(context.sourceText).slice(0, MAX_CANDIDATE_CHARS) } : {},
-				trustLevel: context.source?.provider ? "untrusted" : "trusted",
-				observedAt: Date.now()
-			});
-			evidenceIds.push(evidence.id);
-		}
-		for (const { candidate, content, sensitivity, scope, key, explicitness } of eligible) {
-			const duplicate = findDuplicateUnderstanding(listUnderstandings(), {
-				kind: candidate.kind,
-				statement: content,
-				canonicalKey: key,
-				scope
-			});
-			if (duplicate) {
-				for (const evidenceId of evidenceIds) linkUnderstandingEvidence(duplicate.versionId, evidenceId, "supports", candidate.confidence);
-				deduplicated += 1;
-				writeOutputs.push({
-					candidateKey: key,
-					objectId: duplicate.id,
-					versionId: duplicate.versionId,
-					outcome: "deduplicated"
-				});
-				continue;
-			}
-			const isExplicit = explicitness === "explicit" && extractionDefinition?.maxAutomaticStatus !== "candidate";
-			const contradiction = findContradictoryUnderstanding(listUnderstandings(), {
-				kind: candidate.kind,
-				statement: content,
-				scope
-			});
-			const supersededId = isExplicit ? correctionTarget ?? contradiction?.id : void 0;
-			const validFrom = candidateTime(candidate.validFrom);
-			const validTo = candidateTime(candidate.validTo);
-			const record = createUnderstanding({
-				kind: candidate.kind,
-				canonicalKey: key,
-				status: isExplicit ? "active" : "candidate",
-				scope,
-				explicitness,
-				durability: candidate.durability,
-				sensitivity,
-				disclosurePolicy: candidate.disclosurePolicy,
-				confidence: candidate.confidence,
-				statement: content,
-				payload: candidate.payload,
-				createdBy: context.reviewSource === "background" ? "consolidation" : "runtime",
-				changeReason: context.reviewSource === "background" ? "background synthesis" : "explicit user statement",
-				...validFrom !== void 0 ? { validFrom } : {},
-				...validTo !== void 0 ? { validTo } : {},
-				...supersededId ? { supersedesId: supersededId } : {}
-			});
-			for (const evidenceId of evidenceIds) linkUnderstandingEvidence(record.versionId, evidenceId, "supports", candidate.confidence);
-			const relationTarget = supersededId ? getUnderstanding(supersededId) : contradiction;
-			if (relationTarget) linkContextObjects({
-				subjectType: "understanding",
-				subjectId: record.id,
-				subjectVersionId: record.versionId,
-				predicate: supersededId ? "supersedes" : "contradicts",
-				objectType: "understanding",
-				objectId: relationTarget.id,
-				objectVersionId: relationTarget.versionId,
-				factual: true,
-				...context.extractionRunId ? { extractionRunId: context.extractionRunId } : {}
-			});
-			if (supersededId && isExplicit) {
-				const closedAt = record.validFrom ?? Date.now();
-				closeUnderstandingValidity(supersededId, closedAt);
-				closeTemporalAssertions({
-					objectType: "understanding",
-					objectId: supersededId,
-					validTo: closedAt
-				});
-				setUnderstandingStatus(supersededId, "archived", {
-					actorType: "user",
-					source: "semantic-memory-superseded"
-				});
-			}
-			const assertionType = record.kind === "current_state" ? "current_state" : record.kind === "routine" ? "routine" : record.kind === "relationship" ? "relationship" : record.kind === "project_context" ? "project_status" : void 0;
-			if (assertionType) createTemporalAssertion({
-				objectType: "understanding",
-				objectId: record.id,
-				objectVersionId: record.versionId,
-				assertionType,
-				value: { statement: record.statement },
-				confidence: record.confidence,
-				...record.validFrom ? { validFrom: record.validFrom } : {},
-				...record.validTo ? { validTo: record.validTo } : {},
-				status: record.status === "active" ? "active" : "candidate",
-				...context.extractionRunId ? { extractionRunId: context.extractionRunId } : {}
-			});
-			created += 1;
-			createdRecords.push({
-				id: record.id,
-				content: record.statement,
-				kind: record.kind,
-				status: record.status
-			});
-			writeOutputs.push({
-				candidateKey: key,
-				objectId: record.id,
-				versionId: record.versionId,
-				outcome: "created"
-			});
-		}
-		return {
-			proposed: candidates.length,
-			created,
-			deduplicated,
-			rejected,
-			createdRecords,
-			writeOutputs
-		};
-	}
-};
-//#endregion
-export { UserUnderstandingService };

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

@@ -1,34 +0,0 @@
-import type { UnderstandingKind, UserUnderstanding } from '../../../user-context/domain.js';
-export interface UnderstandingCandidate {
-    kind: UnderstandingKind;
-    content: string;
-    payload?: Record<string, unknown>;
-    canonicalKey?: string;
-    confidence: number;
-    importance: number;
-    explicitness: UserUnderstanding['explicitness'];
-    durability: UserUnderstanding['durability'];
-    sensitivity: UserUnderstanding['sensitivity'];
-    disclosurePolicy: UserUnderstanding['disclosurePolicy'];
-    validFrom?: string;
-    validTo?: string;
-}
-export interface UnderstandingReviewResult {
-    sourceItemId?: string;
-    proposed: number;
-    created: number;
-    deduplicated: number;
-    rejected: number;
-    createdRecords: Array<{
-        id: string;
-        content: string;
-        kind: UnderstandingKind;
-        status: UserUnderstanding['status'];
-    }>;
-    writeOutputs?: Array<{
-        candidateKey: string;
-        objectId?: string;
-        versionId?: string;
-        outcome: 'created' | 'deduplicated' | 'rejected';
-    }>;
-}

package/dist/src/agent/memory/user-context-coordinator.d.ts

@@ -1,23 +0,0 @@
-import type { AgentMessage } from '@earendil-works/pi-agent-core';
-import type { Config } from '../../config/schema.js';
-import type { UserContextPlan } from './context/types.js';
-import type { MemoryManager } from './manager.js';
-export interface UserContextCoordinatorOptions {
-    getConfig: () => Config | undefined;
-    isEnabledForSession: (sessionKey: string) => boolean;
-    getWorkspaceIdForSession?: (sessionKey: string) => string;
-    getProjectIdForSession?: (sessionKey: string) => string | undefined;
-    getMemoryManagerForSession: (sessionKey: string) => MemoryManager;
-    getLastAssistantContent: (sessionKey: string) => string | null;
-}
-export declare class UserContextCoordinator {
-    private readonly options;
-    private readonly userTurn;
-    private readonly lastTurnId;
-    private readonly planner;
-    constructor(options: UserContextCoordinatorOptions);
-    forgetSession(sessionKey: string): void;
-    clear(): void;
-    prepare(userMessage: AgentMessage, sessionKey: string, turnId: string): Promise<UserContextPlan>;
-    afterTurn(sessionKey: string, userPlainText: string): Promise<void>;
-}