import { z } from "zod"; import { uniqueSorted } from "../domain/canonicalOrdering.js"; import type { JsonValue } from "../domain/jsonValue.js"; import type { AnalysisOperationPort } from "../ports/AnalysisProvider.js"; import { parseProcessCaptureEvidence } from "../application/process/ProcessEvidence.js"; import type { BinarySessionPort } from "../application/binary/BinarySessionPort.js"; import type { PromptCompletionKind } from "../contracts/promptContracts.js"; import { listProceduresFact } from "../domain/native/nativeOperationFacts.js"; import { currentMcpRequestSignal } from "./EvidenceMcpServerCore.js"; import { parseArtifactInventoryEvidence } from "../domain/artifactInventoryEvidence.js"; import { EvidenceIntegrityError } from "../domain/evidenceErrors.js"; import type { Evidence } from "../domain/evidence.js"; const documentListSchema = z.array(z.string().min(1)); const providerStatusSchema = z.object({ analysis_provider_candidates: z.array( z.object({ provider: z.object({ id: z.string().min(1) }) }), ), }); interface CompletionContext { readonly arguments?: Readonly>; } /** Read-only session projection used by MCP prompt argument completers. */ export interface PromptCompletionSource { complete( kind: PromptCompletionKind, value: string, context?: CompletionContext, ): Promise; } /** Build live completion over the active provider and session ledger. */ export const createPromptCompletionSource = ( analysis: AnalysisOperationPort, session?: BinarySessionPort, ): PromptCompletionSource => ({ async complete(kind, value, context) { const candidates = await completionCandidates( kind, analysis, session, context, ); const prefix = normalize(value); const nonEmpty = candidates.filter((candidate) => candidate.length > 0); return uniqueSorted(nonEmpty).filter((candidate) => normalize(candidate).startsWith(prefix), ); }, }); const completionCandidates = async ( kind: PromptCompletionKind, analysis: AnalysisOperationPort, session: BinarySessionPort | undefined, context: CompletionContext | undefined, ): Promise => { switch (kind) { case "document": return documentCandidates(analysis, session); case "procedure": return procedureCandidates( analysis, session, context?.arguments?.document, ); case "provider": return providerCandidates(session); case "evidence": case "capture": case "manifest": case "occurrence": return evidenceCandidates(kind, session); case "unknown": return unknownCandidates(session); } }; const documentCandidates = async ( analysis: AnalysisOperationPort, session: BinarySessionPort | undefined, ): Promise => { const result = await completionInventoryLookup( analysis, session, "list_documents", {}, ); if (result === undefined) return []; if (!result.ok) return []; const parsed = documentListSchema.safeParse(result.value.result); return parsed.success ? parsed.data : []; }; const procedureCandidates = async ( analysis: AnalysisOperationPort, session: BinarySessionPort | undefined, document: string | undefined, ): Promise => { const addresses = new Set(); // null records proven ambiguity; later rows cannot restore uniqueness. const addressByName = new Map(); const input = document === undefined || document.length === 0 ? {} : { document }; const result = await completionInventoryLookup( analysis, session, "list_procedures", input, ); if (result === undefined) return []; if (result.ok) { const parsed = listProceduresFact.schema.safeParse(result.value.result); if (parsed.success) for (const { address, value: name } of parsed.data) { addresses.add(address); if (name.length === 0) continue; const previous = addressByName.get(name); addressByName.set( name, previous === undefined || previous === address ? address : null, ); } } const candidates = [...addresses]; for (const [name, address] of addressByName) if (address !== null) candidates.push(name); return candidates; }; const completionInventoryLookup = async ( analysis: AnalysisOperationPort, session: BinarySessionPort | undefined, operation: "list_documents" | "list_procedures", parameters: Readonly>, ) => { const signal = currentMcpRequestSignal(); const options = signal === undefined ? {} : { signal }; const result = session === undefined ? await analysis.execute(operation, parameters, options) : await session.executeIfProviderReady(operation, parameters, options); return signal?.aborted === true ? undefined : result; }; const providerCandidates = async ( session: BinarySessionPort | undefined, ): Promise => { if (session === undefined) return []; const signal = currentMcpRequestSignal(); const parsed = providerStatusSchema.safeParse( await session.status({ detail: "summary", ...(signal === undefined ? {} : { signal }), }), ); if (!parsed.success) return []; const candidates = parsed.data.analysis_provider_candidates.map( ({ provider }) => provider.id, ); return ["auto", ...candidates]; }; const evidenceCandidates = ( kind: "evidence" | "capture" | "manifest" | "occurrence", session: BinarySessionPort | undefined, ): readonly string[] => { if (session === undefined) return []; const candidates: string[] = []; for (const evidence of session.immutableEvidenceBundle().records) for (const value of evidenceValues(kind, evidence)) candidates.push(value); return candidates; }; const evidenceValues = ( kind: "evidence" | "capture" | "manifest" | "occurrence", evidence: Evidence, ): readonly string[] => { if (kind === "evidence") return [evidence.evidence_id]; if (kind === "capture") return isProcessCaptureEvidence(evidence) ? [evidence.evidence_id] : []; if ( evidence.operation === "inventory_artifact" || evidence.operation === "inspect_artifact" ) return artifactInventoryValues(kind, evidence); return []; }; const artifactInventoryValues = ( kind: "manifest" | "occurrence", evidence: unknown, ): readonly string[] => { try { const { inventory } = parseArtifactInventoryEvidence(evidence); return kind === "manifest" ? [inventory.manifest.manifest_id] : inventory.occurrences.map(({ occurrence_id: id }) => id); } catch (cause: unknown) { if (cause instanceof EvidenceIntegrityError) return []; throw cause; } }; const isProcessCaptureEvidence = (evidence: Evidence): boolean => { const parsed = parseProcessCaptureEvidence(evidence); if (parsed.ok) return true; switch (parsed.error.kind) { case "wrong-workflow": case "unsupported-provider": return false; case "invalid-evidence": case "invalid-capture": return false; } }; const unknownCandidates = ( session: BinarySessionPort | undefined, ): readonly string[] => session === undefined ? [] : session .listUnknowns() .filter(({ status }) => status !== "resolved") .map(({ unknown_id: id }) => id); const normalize = (value: string): string => value.normalize("NFKC").toLowerCase();