@moldea.ai/adapter-langchain 1.0.0

package/dist/index.js

@@ -0,0 +1,2023 @@
+import { posix } from "node:path";
+import { intersects, subset, validRange } from "semver";
+import ts from "typescript";
+import { parseRepositoryPath } from "@moldea.ai/repository";
+//#region src/constants/index.ts
+var LANGCHAIN_ADAPTER_ID = "langchain";
+var LANGCHAIN_PACKAGE_NAME = "langchain";
+var LANGCHAIN_CORE_PACKAGE_NAME = "@langchain/core";
+var LANGCHAIN_SUPPORTED_PACKAGE_RANGE = ">=1.5.9 <1.6.0";
+var LANGCHAIN_CORE_SUPPORTED_PACKAGE_RANGE = ">=1.2.8 <1.3.0";
+var LANGCHAIN_TARGET_ID = "typescript-create-agent-1-5";
+var LANGCHAIN_SUPPORTED_REPOSITORY_FORMAT_VERSIONS = Object.freeze([1]);
+//#endregion
+//#region ../../packages/adapter-static-analysis/dist/index.js
+/**
+* Creates an operation-local inspection session with deterministic promise caches.
+* @param options Provider callbacks and the optional operation signal.
+* @returns Cached source, package, and entry inspection functions.
+* @throws If the inspection is aborted.
+*/
+var createInspectionSession = (options) => {
+	const sourceCache = /* @__PURE__ */ new Map();
+	const packageCache = /* @__PURE__ */ new Map();
+	const entryCache = /* @__PURE__ */ new Map();
+	const analyzeSource = (path) => {
+		options.signal?.throwIfAborted();
+		const existing = sourceCache.get(path);
+		if (existing !== void 0) return existing;
+		const analysis = (async () => {
+			options.signal?.throwIfAborted();
+			const bytes = await options.readFile(path, options.signal);
+			options.signal?.throwIfAborted();
+			const result = await options.analyzeSource(path, bytes, options.signal);
+			options.signal?.throwIfAborted();
+			return result;
+		})();
+		sourceCache.set(path, analysis);
+		return analysis;
+	};
+	const discoverPackage = (path) => {
+		options.signal?.throwIfAborted();
+		const existing = packageCache.get(path);
+		if (existing !== void 0) return existing;
+		const discovery = options.discoverPackage(path, options.signal);
+		packageCache.set(path, discovery);
+		return discovery;
+	};
+	const getEntry = (path) => {
+		options.signal?.throwIfAborted();
+		const existing = entryCache.get(path);
+		if (existing !== void 0) return existing;
+		const entry = options.getEntry(path, options.signal);
+		entryCache.set(path, entry);
+		return entry;
+	};
+	return Object.freeze({
+		analyzeSource,
+		discoverPackage,
+		getEntry,
+		...options.signal === void 0 ? {} : { signal: options.signal }
+	});
+};
+var decoder = new TextDecoder("utf-8", {
+	fatal: true,
+	ignoreBOM: true
+});
+var findLineIndex = (lineStarts, offset) => {
+	let lower = 0;
+	let upper = lineStarts.length - 1;
+	while (lower < upper) {
+		const middle = Math.ceil((lower + upper) / 2);
+		if ((lineStarts[middle] ?? 0) <= offset) lower = middle;
+		else upper = middle - 1;
+	}
+	return lower;
+};
+/**
+* Creates a TypeScript UTF-16-offset to Unicode-scalar source locator.
+* @param value The normalized valid Unicode-scalar text.
+* @returns The scalar-aware source locator.
+*/
+var createSourceLocator = (value) => {
+	const scalarOffsets = new Uint32Array(value.length + 1);
+	const lineStarts = [0];
+	let scalarOffset = 0;
+	for (let codeUnitOffset = 0; codeUnitOffset < value.length;) {
+		const codePoint = value.codePointAt(codeUnitOffset);
+		const width = codePoint !== void 0 && codePoint > 65535 ? 2 : 1;
+		scalarOffsets[codeUnitOffset] = scalarOffset;
+		for (let interiorOffset = 1; interiorOffset < width; interiorOffset += 1) scalarOffsets[codeUnitOffset + interiorOffset] = scalarOffset;
+		codeUnitOffset += width;
+		scalarOffset += 1;
+		scalarOffsets[codeUnitOffset] = scalarOffset;
+		if (codePoint === 10) lineStarts.push(codeUnitOffset);
+	}
+	const locatePosition = (candidateOffset) => {
+		const codeUnitOffset = Math.max(0, Math.min(value.length, candidateOffset));
+		const lineIndex = findLineIndex(lineStarts, codeUnitOffset);
+		const lineStart = lineStarts[lineIndex] ?? 0;
+		const positionScalarOffset = scalarOffsets[codeUnitOffset] ?? 0;
+		return {
+			column: positionScalarOffset - (scalarOffsets[lineStart] ?? 0) + 1,
+			line: lineIndex + 1,
+			offset: positionScalarOffset
+		};
+	};
+	return Object.freeze({ locateRange: (startOffset, endOffset) => ({
+		end: locatePosition(endOffset),
+		start: locatePosition(startOffset)
+	}) });
+};
+/**
+* Decodes and normalizes source bytes through the runtime-adapter text contract.
+* @param bytes The exact reader-owned source bytes.
+* @returns The normalized text and locator or an invalid-text result.
+*/
+var normalizeText = (bytes) => {
+	let decoded;
+	try {
+		decoded = decoder.decode(bytes);
+	} catch {
+		return Object.freeze({ valid: false });
+	}
+	const value = (decoded.startsWith("") ? decoded.slice(1) : decoded).replace(/\r\n?/gu, "\n");
+	if (value.includes("\0")) return Object.freeze({ valid: false });
+	return Object.freeze({
+		locator: createSourceLocator(value),
+		valid: true,
+		value
+	});
+};
+var PACKAGE_DEPENDENCY_FIELDS = Object.freeze([
+	"dependencies",
+	"optionalDependencies",
+	"peerDependencies",
+	"devDependencies"
+]);
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/**
+* Creates nearest-to-root package-manifest candidates for one source path.
+* @param sourcePath The normalized source path.
+* @returns Deterministically ordered manifest paths.
+*/
+var createPackageManifestCandidatePaths = (sourcePath) => {
+	const candidates = [];
+	let directory = posix.dirname(sourcePath);
+	while (true) {
+		candidates.push(posix.join(directory, "package.json"));
+		if (directory === "/") break;
+		directory = posix.dirname(directory);
+	}
+	return Object.freeze(candidates);
+};
+var extractPackageDeclarations = (manifest, packageName) => {
+	const declarations = [];
+	for (const field of PACKAGE_DEPENDENCY_FIELDS) {
+		const dependencies = manifest[field];
+		if (dependencies === void 0) continue;
+		if (!isRecord(dependencies)) return null;
+		const declaration = dependencies[packageName];
+		if (declaration === void 0) continue;
+		if (typeof declaration !== "string" || declaration.trim().length === 0) return null;
+		declarations.push(Object.freeze({
+			declaredRange: declaration,
+			dependencyKind: field
+		}));
+	}
+	return declarations;
+};
+var classifyPackageDeclarations = (declarations, supportedRange) => {
+	const classifications = declarations.map(({ declaredRange }) => {
+		const normalizedRange = validRange(declaredRange, {
+			loose: false,
+			includePrerelease: false
+		});
+		if (normalizedRange === null) return "ambiguous";
+		if (subset(normalizedRange, supportedRange, {
+			loose: false,
+			includePrerelease: false
+		})) return "supported";
+		if (!intersects(normalizedRange, supportedRange, {
+			loose: false,
+			includePrerelease: false
+		})) return "unsupported";
+		return "ambiguous";
+	});
+	if (classifications.every((classification) => classification === "supported")) return "supported";
+	if (classifications.every((classification) => classification === "unsupported")) return "unsupported";
+	return "ambiguous";
+};
+var readOwningManifest = async (options) => {
+	const { reader, signal, sourcePath } = options;
+	for (const manifestPath of createPackageManifestCandidatePaths(sourcePath)) {
+		signal?.throwIfAborted();
+		const entry = await reader.getEntry(manifestPath);
+		signal?.throwIfAborted();
+		if (entry === null) continue;
+		if (entry.type !== "file") return Object.freeze({
+			kind: "invalid",
+			path: manifestPath
+		});
+		const bytes = await reader.readFile(manifestPath);
+		signal?.throwIfAborted();
+		const text = normalizeText(bytes);
+		signal?.throwIfAborted();
+		if (!text.valid) return Object.freeze({
+			kind: "invalid",
+			path: manifestPath
+		});
+		let parsed;
+		try {
+			parsed = JSON.parse(text.value);
+		} catch {
+			return Object.freeze({
+				kind: "invalid",
+				path: manifestPath
+			});
+		}
+		signal?.throwIfAborted();
+		return isRecord(parsed) ? Object.freeze({
+			kind: "present",
+			manifest: parsed,
+			path: manifestPath
+		}) : Object.freeze({
+			kind: "invalid",
+			path: manifestPath
+		});
+	}
+	return Object.freeze({ kind: "absent" });
+};
+/**
+* Discovers multiple package declarations from one nearest owning manifest read.
+* @param options The package targets, repository callbacks, source path, and signal.
+* @returns The owning manifest's package observations, invalid state, or absence.
+* @throws If repository reading or the active inspection is aborted.
+*/
+var discoverPackages = async (options) => {
+	const owningManifest = await readOwningManifest(options);
+	if (owningManifest.kind !== "present") return owningManifest;
+	const packages = [];
+	for (const target of options.packages) {
+		const declarations = extractPackageDeclarations(owningManifest.manifest, target.packageName);
+		if (declarations === null) return Object.freeze({
+			kind: "invalid",
+			path: owningManifest.path
+		});
+		packages.push(Object.freeze({
+			compatibility: declarations.length === 0 ? "absent" : classifyPackageDeclarations(declarations, target.supportedRange),
+			declarations: Object.freeze(declarations),
+			packageName: target.packageName
+		}));
+	}
+	return Object.freeze({
+		kind: "observed",
+		observation: Object.freeze({
+			packages: Object.freeze(packages),
+			path: owningManifest.path
+		})
+	});
+};
+/**
+* Removes the transparent expression wrappers supported by runtime adapters.
+* @param expression The expression to normalize.
+* @returns The underlying expression used by static matching.
+*/
+var unwrapExpression = (expression) => {
+	let current = expression;
+	while (ts.isAsExpression(current) || ts.isParenthesizedExpression(current) || ts.isSatisfiesExpression(current)) current = current.expression;
+	return current;
+};
+/**
+* Resolves one direct call with an optional outer `await` wrapper.
+* @param expression The candidate call expression.
+* @returns The direct call or `null` when the form is unsupported.
+*/
+var getDirectCall = (expression) => {
+	const unwrapped = unwrapExpression(expression);
+	const candidate = ts.isAwaitExpression(unwrapped) ? unwrapExpression(unwrapped.expression) : unwrapped;
+	return ts.isCallExpression(candidate) ? candidate : null;
+};
+/**
+* Reads an exact static string literal from one expression.
+* @param expression The candidate string expression.
+* @returns Its exact value or `null` when dynamic.
+*/
+var getStaticString = (expression) => {
+	if (expression === null || expression === void 0) return null;
+	const candidate = unwrapExpression(expression);
+	return ts.isStringLiteral(candidate) || ts.isNoSubstitutionTemplateLiteral(candidate) ? candidate.text : null;
+};
+var hasModifier = (node, kind) => ts.canHaveModifiers(node) && (ts.getModifiers(node)?.some((modifier) => modifier.kind === kind) ?? false);
+var isConstDeclarationList = (declarationList) => (declarationList.flags & ts.NodeFlags.Const) !== 0;
+/**
+* Indexes static value imports and supported SDK constructor imports.
+* @param sourceFile The parsed TypeScript source.
+* @param config The provider package and constructor import forms.
+* @returns Module-owned import bindings needed by static checks.
+*/
+var indexImports = (sourceFile, config) => {
+	const constructorNames = /* @__PURE__ */ new Set();
+	const namedImports = /* @__PURE__ */ new Map();
+	const supportedNamedImports = new Set(config.namedConstructorImports);
+	for (const statement of sourceFile.statements) {
+		if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier)) continue;
+		const importClause = statement.importClause;
+		if (importClause?.isTypeOnly === true) continue;
+		const moduleSpecifier = statement.moduleSpecifier.text;
+		if (moduleSpecifier === config.packageName && config.supportsDefaultConstructorImport && importClause?.name !== void 0) constructorNames.add(importClause.name.text);
+		if (moduleSpecifier === config.packageName && importClause?.namedBindings !== void 0 && ts.isNamedImports(importClause.namedBindings)) for (const element of importClause.namedBindings.elements) {
+			const importedName = element.propertyName?.text ?? element.name.text;
+			if (!element.isTypeOnly && supportedNamedImports.has(importedName)) constructorNames.add(element.name.text);
+		}
+		if (!moduleSpecifier.startsWith(".") || importClause?.namedBindings === void 0 || !ts.isNamedImports(importClause.namedBindings)) continue;
+		for (const element of importClause.namedBindings.elements) {
+			if (element.isTypeOnly) continue;
+			namedImports.set(element.name.text, Object.freeze({
+				importedName: element.propertyName?.text ?? element.name.text,
+				moduleSpecifier
+			}));
+		}
+	}
+	return {
+		constructorNames,
+		namedImports
+	};
+};
+/**
+* Indexes direct exports, module-level SDK clients, and constant arrays.
+* @param sourceFile The parsed TypeScript source.
+* @param constructorNames The supported constructor bindings.
+* @returns Static module declarations used by adapter inspection.
+*/
+var indexModuleDeclarations = (sourceFile, constructorNames) => {
+	const clientNames = /* @__PURE__ */ new Set();
+	const exports = /* @__PURE__ */ new Map();
+	const moduleArrays = /* @__PURE__ */ new Map();
+	const moduleConstDeclarations = /* @__PURE__ */ new Map();
+	for (const statement of sourceFile.statements) {
+		if (ts.isFunctionDeclaration(statement) && statement.name !== void 0) {
+			if (hasModifier(statement, ts.SyntaxKind.ExportKeyword)) exports.set(statement.name.text, Object.freeze({
+				declaration: statement,
+				kind: statement.body === void 0 || hasModifier(statement, ts.SyntaxKind.DefaultKeyword) ? "present-unsupported" : "present-supported"
+			}));
+			continue;
+		}
+		if (ts.isExportDeclaration(statement) && statement.exportClause !== void 0) {
+			if (!ts.isNamedExports(statement.exportClause) || statement.isTypeOnly) continue;
+			for (const element of statement.exportClause.elements) if (!element.isTypeOnly) exports.set(element.name.text, Object.freeze({
+				declaration: element,
+				kind: "present-unsupported"
+			}));
+			continue;
+		}
+		if (!ts.isVariableStatement(statement)) {
+			if (hasModifier(statement, ts.SyntaxKind.ExportKeyword) && (ts.isClassDeclaration(statement) || ts.isEnumDeclaration(statement) || ts.isModuleDeclaration(statement)) && statement.name !== void 0 && ts.isIdentifier(statement.name)) exports.set(statement.name.text, Object.freeze({
+				declaration: statement,
+				kind: "present-unsupported"
+			}));
+			continue;
+		}
+		const isConst = isConstDeclarationList(statement.declarationList);
+		const isExported = hasModifier(statement, ts.SyntaxKind.ExportKeyword);
+		for (const declaration of statement.declarationList.declarations) {
+			if (!ts.isIdentifier(declaration.name)) continue;
+			if (isExported) exports.set(declaration.name.text, Object.freeze({
+				declaration,
+				kind: isConst && declaration.initializer !== void 0 ? "present-supported" : "present-unsupported"
+			}));
+			if (!isConst || declaration.initializer === void 0) continue;
+			moduleConstDeclarations.set(declaration.name.text, declaration);
+			const initializer = unwrapExpression(declaration.initializer);
+			if (ts.isNewExpression(initializer)) {
+				const constructor = unwrapExpression(initializer.expression);
+				if (ts.isIdentifier(constructor) && constructorNames.has(constructor.text)) clientNames.add(declaration.name.text);
+			}
+			if (ts.isArrayLiteralExpression(initializer)) moduleArrays.set(declaration.name.text, Object.freeze({
+				declaration,
+				expression: initializer
+			}));
+		}
+	}
+	return {
+		clientNames,
+		exports,
+		moduleArrays,
+		moduleConstDeclarations
+	};
+};
+var addBindingNames = (names, bindingName) => {
+	if (ts.isIdentifier(bindingName)) {
+		names.add(bindingName.text);
+		return;
+	}
+	for (const element of bindingName.elements) if (!ts.isOmittedExpression(element)) addBindingNames(names, element.name);
+};
+var addVariableDeclarationListBindings = (names, declarationList) => {
+	for (const declaration of declarationList.declarations) addBindingNames(names, declaration.name);
+};
+var addStatementBindings = (names, statement) => {
+	if (ts.isVariableStatement(statement)) {
+		addVariableDeclarationListBindings(names, statement.declarationList);
+		return;
+	}
+	if (ts.isFunctionDeclaration(statement) || ts.isClassDeclaration(statement) || ts.isEnumDeclaration(statement) || ts.isModuleDeclaration(statement)) {
+		if (statement.name !== void 0 && ts.isIdentifier(statement.name)) names.add(statement.name.text);
+	}
+};
+var isFunctionScope = (node) => ts.isArrowFunction(node) || ts.isConstructorDeclaration(node) || ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node) || ts.isGetAccessorDeclaration(node) || ts.isMethodDeclaration(node) || ts.isSetAccessorDeclaration(node);
+var getLocalBindingNames = (bindings, scope) => {
+	const existingNames = bindings.get(scope);
+	if (existingNames !== void 0) return existingNames;
+	const names = /* @__PURE__ */ new Set();
+	bindings.set(scope, names);
+	return names;
+};
+/**
+* Indexes local runtime bindings that can shadow module-owned identifiers.
+* @param sourceFile The parsed TypeScript source.
+* @returns Local binding names keyed by lexical or function scope.
+*/
+var indexLocalBindingNames = (sourceFile) => {
+	const bindings = /* @__PURE__ */ new Map();
+	const visit = (node, functionScope) => {
+		let childFunctionScope = functionScope;
+		if (isFunctionScope(node)) {
+			const names = getLocalBindingNames(bindings, node);
+			for (const parameter of node.parameters) addBindingNames(names, parameter.name);
+			if (node.name !== void 0 && ts.isIdentifier(node.name)) names.add(node.name.text);
+			childFunctionScope = node;
+		}
+		if (ts.isBlock(node) || ts.isModuleBlock(node)) {
+			const names = getLocalBindingNames(bindings, node);
+			for (const statement of node.statements) addStatementBindings(names, statement);
+		} else if (ts.isCaseBlock(node)) {
+			const names = getLocalBindingNames(bindings, node);
+			for (const clause of node.clauses) for (const statement of clause.statements) addStatementBindings(names, statement);
+		} else if (ts.isCatchClause(node) && node.variableDeclaration !== void 0) addBindingNames(getLocalBindingNames(bindings, node), node.variableDeclaration.name);
+		else if ((ts.isForStatement(node) || ts.isForInStatement(node) || ts.isForOfStatement(node)) && node.initializer !== void 0 && ts.isVariableDeclarationList(node.initializer)) addVariableDeclarationListBindings(getLocalBindingNames(bindings, node), node.initializer);
+		else if (ts.isClassExpression(node) && node.name !== void 0) getLocalBindingNames(bindings, node).add(node.name.text);
+		if (childFunctionScope !== null && ts.isVariableDeclarationList(node) && (node.flags & ts.NodeFlags.BlockScoped) === 0) addVariableDeclarationListBindings(getLocalBindingNames(bindings, childFunctionScope), node);
+		ts.forEachChild(node, (child) => visit(child, childFunctionScope));
+	};
+	visit(sourceFile, null);
+	return bindings;
+};
+/**
+* Indexes identifier occurrences once for binding-specific safety analysis.
+* @param sourceFile The parsed TypeScript source.
+* @returns Identifier occurrences grouped by exact source spelling.
+*/
+var indexIdentifierUses = (sourceFile) => {
+	const identifierUses = /* @__PURE__ */ new Map();
+	const visit = (node) => {
+		if (ts.isIdentifier(node)) {
+			const uses = identifierUses.get(node.text) ?? [];
+			uses.push(node);
+			identifierUses.set(node.text, uses);
+		}
+		ts.forEachChild(node, visit);
+	};
+	visit(sourceFile);
+	return new Map([...identifierUses].map(([name, uses]) => [name, Object.freeze(uses)]));
+};
+/**
+* Determines whether a module-bound name is visible at one identifier use.
+* @param identifier The identifier whose lexical environment is inspected.
+* @param analysis The indexed source containing the identifier.
+* @returns Whether no parameter or local declaration shadows the module binding.
+*/
+var isModuleBindingVisible = (identifier, analysis) => {
+	let current = identifier.parent;
+	while (current !== void 0 && !ts.isSourceFile(current)) {
+		if (analysis.localBindingNames.get(current)?.has(identifier.text) === true) return false;
+		current = current.parent;
+	}
+	return true;
+};
+/**
+* Resolves TypeScript source candidates for a supported relative ESM specifier.
+* @param containingPath The importing source path.
+* @param moduleSpecifier The exact relative ESM specifier.
+* @returns Supported logical source candidates in deterministic order.
+*/
+var resolveImportCandidatePaths = (containingPath, moduleSpecifier) => {
+	const resolved = posix.resolve(posix.dirname(containingPath), moduleSpecifier);
+	if (resolved.endsWith(".js")) return [`${resolved.slice(0, -3)}.ts`, `${resolved.slice(0, -3)}.tsx`];
+	if (resolved.endsWith(".mjs")) return [`${resolved.slice(0, -4)}.mts`];
+	return [
+		".ts",
+		".tsx",
+		".mts"
+	].some((extension) => resolved.endsWith(extension)) ? [resolved] : [];
+};
+/**
+* Resolves the explicit module references an identifier can denote.
+* @param identifier The local source identifier.
+* @param analysis The source containing that identifier.
+* @returns Same-file or relative-import candidates in deterministic order.
+*/
+var resolveBindingReferences = (identifier, analysis) => {
+	if (!isModuleBindingVisible(identifier, analysis)) return [];
+	const references = [];
+	if (analysis.exports.has(identifier.text)) references.push(Object.freeze({
+		path: analysis.path,
+		symbol: identifier.text
+	}));
+	const namedImport = analysis.namedImports.get(identifier.text);
+	if (namedImport !== void 0) references.push(...resolveImportCandidatePaths(analysis.path, namedImport.moduleSpecifier).map((path) => Object.freeze({
+		path,
+		symbol: namedImport.importedName
+	})));
+	return references;
+};
+/**
+* Checks whether an identifier resolves directly to an explicit bound reference.
+* @param identifier The local source identifier.
+* @param analysis The source containing that identifier.
+* @param reference The explicit source binding to match.
+* @returns Whether local or named-import identity proves the relationship.
+*/
+var isBoundIdentifier = (identifier, analysis, reference) => {
+	if (reference.symbol === void 0) return false;
+	return resolveBindingReferences(identifier, analysis).some((candidate) => candidate.path === reference.path && candidate.symbol === reference.symbol);
+};
+var READONLY_ARRAY_METHODS = /* @__PURE__ */ new Set([
+	"at",
+	"concat",
+	"entries",
+	"flat",
+	"includes",
+	"indexOf",
+	"join",
+	"keys",
+	"lastIndexOf",
+	"slice",
+	"toLocaleString",
+	"toReversed",
+	"toSpliced",
+	"toString",
+	"values",
+	"with"
+]);
+var skipTransparentParents$1 = (node) => {
+	let current = node;
+	while (ts.isAsExpression(current.parent) || ts.isParenthesizedExpression(current.parent) || ts.isSatisfiesExpression(current.parent)) current = current.parent;
+	return current;
+};
+var isAssignmentOperator$1 = (kind) => kind >= ts.SyntaxKind.FirstAssignment && kind <= ts.SyntaxKind.LastAssignment;
+var isAssignmentTarget = (expression) => {
+	let current = skipTransparentParents$1(expression);
+	while (true) {
+		const parent = current.parent;
+		if (ts.isBinaryExpression(parent) && isAssignmentOperator$1(parent.operatorToken.kind)) return parent.left === current;
+		if ((ts.isPrefixUnaryExpression(parent) || ts.isPostfixUnaryExpression(parent)) && parent.operand === current && (parent.operator === ts.SyntaxKind.PlusPlusToken || parent.operator === ts.SyntaxKind.MinusMinusToken)) return true;
+		if (ts.isDeleteExpression(parent) && parent.expression === current) return true;
+		if ((ts.isForInStatement(parent) || ts.isForOfStatement(parent)) && parent.initializer === current) return true;
+		if (ts.isPropertyAccessExpression(parent) || ts.isElementAccessExpression(parent) || ts.isPropertyAssignment(parent) || ts.isSpreadAssignment(parent) || ts.isSpreadElement(parent) || ts.isArrayLiteralExpression(parent) || ts.isObjectLiteralExpression(parent)) {
+			current = skipTransparentParents$1(parent);
+			continue;
+		}
+		return false;
+	}
+};
+var getStaticMemberName$1 = (member) => {
+	if (ts.isPropertyAccessExpression(member)) return member.name.text;
+	const argument = member.argumentExpression;
+	return argument !== void 0 && (ts.isStringLiteral(argument) || ts.isNoSubstitutionTemplateLiteral(argument)) ? argument.text : null;
+};
+var isSafeArrayMemberUse = (member) => {
+	if (isAssignmentTarget(member)) return false;
+	const candidate = skipTransparentParents$1(member);
+	const parent = candidate.parent;
+	if (!ts.isCallExpression(parent) || parent.expression !== candidate) return ts.isPropertyAccessExpression(member) && member.name.text === "length";
+	const memberName = getStaticMemberName$1(member);
+	const call = skipTransparentParents$1(parent);
+	return memberName !== null && READONLY_ARRAY_METHODS.has(memberName) && ts.isExpressionStatement(call.parent);
+};
+var isIgnoredIdentifierPosition = (identifier, declarationName) => identifier === declarationName || ts.isImportSpecifier(identifier.parent) || ts.isPropertyAssignment(identifier.parent) && identifier.parent.name === identifier || ts.isPropertyAccessExpression(identifier.parent) && identifier.parent.name === identifier;
+/**
+* Determines whether a module value binding has only explicitly allowed value uses.
+* @param analysis The indexed source containing the binding references.
+* @param bindingName The exact lexically visible module binding name.
+* @param declarationName The optional local declaration identifier to exclude.
+* @param allowedReferences Exact bare identifier occurrences owned by supported relationships.
+* @param kind Whether array read-only member access is permitted for the value.
+* @returns Whether the binding cannot be aliased, escaped, reassigned, or mutated.
+*/
+var isModuleValueBindingSafe = (analysis, bindingName, declarationName, allowedReferences, kind) => {
+	const identifierUses = analysis.identifierUses.get(bindingName) ?? [];
+	for (const identifier of identifierUses) {
+		if (isIgnoredIdentifierPosition(identifier, declarationName) || !isModuleBindingVisible(identifier, analysis)) continue;
+		if (allowedReferences.has(identifier)) continue;
+		const expression = skipTransparentParents$1(identifier);
+		const parent = expression.parent;
+		const member = (ts.isPropertyAccessExpression(parent) || ts.isElementAccessExpression(parent)) && parent.expression === expression ? parent : null;
+		if (kind !== "array" || member === null || !isSafeArrayMemberUse(member)) return false;
+	}
+	return true;
+};
+/**
+* Determines whether a module-local constant literal has only explicitly allowed value uses.
+* @param analysis The indexed source containing the declaration and its references.
+* @param declaration The module-local constant declaration to inspect.
+* @param allowedReferences Exact bare identifier occurrences owned by supported relationships.
+* @param kind Whether array read-only member access is permitted for the value.
+* @returns Whether the binding cannot be aliased, escaped, reassigned, or mutated.
+*/
+var isModuleConstValueSafe = (analysis, declaration, allowedReferences, kind) => {
+	if (!ts.isIdentifier(declaration.name)) return false;
+	return isModuleValueBindingSafe(analysis, declaration.name.text, declaration.name, allowedReferences, kind);
+};
+var skipTransparentParents = (node) => {
+	let current = node;
+	while (ts.isAsExpression(current.parent) || ts.isParenthesizedExpression(current.parent) || ts.isSatisfiesExpression(current.parent)) current = current.parent;
+	return current;
+};
+var isAssignmentOperator = (kind) => kind >= ts.SyntaxKind.FirstAssignment && kind <= ts.SyntaxKind.LastAssignment;
+var isMutatingTarget = (expression) => {
+	const candidate = skipTransparentParents(expression);
+	const parent = candidate.parent;
+	return ts.isBinaryExpression(parent) && parent.left === candidate && isAssignmentOperator(parent.operatorToken.kind) || (ts.isPrefixUnaryExpression(parent) || ts.isPostfixUnaryExpression(parent)) && parent.operand === candidate && (parent.operator === ts.SyntaxKind.PlusPlusToken || parent.operator === ts.SyntaxKind.MinusMinusToken) || ts.isDeleteExpression(parent) && parent.expression === candidate || (ts.isForInStatement(parent) || ts.isForOfStatement(parent)) && parent.initializer === candidate;
+};
+var getStaticMemberName = (member) => {
+	if (ts.isPropertyAccessExpression(member)) return member.name.text;
+	const argument = member.argumentExpression;
+	return argument !== void 0 && (ts.isStringLiteral(argument) || ts.isNoSubstitutionTemplateLiteral(argument)) ? argument.text : null;
+};
+var isIgnoredIdentifier = (identifier, declarationName) => identifier === declarationName || ts.isImportSpecifier(identifier.parent) || ts.isPropertyAccessExpression(identifier.parent) && identifier.parent.name === identifier || ts.isPropertyAssignment(identifier.parent) && identifier.parent.name === identifier;
+var addObjectAssignmentMembers = (object, mutatedMembers) => {
+	let hasUnknownMutation = false;
+	for (const property of object.properties) {
+		if (!ts.isPropertyAssignment(property) && !ts.isShorthandPropertyAssignment(property) || ts.isComputedPropertyName(property.name)) {
+			hasUnknownMutation = true;
+			continue;
+		}
+		const propertyName = ts.isIdentifier(property.name) || ts.isStringLiteral(property.name) ? property.name.text : null;
+		if (propertyName === null) hasUnknownMutation = true;
+		else mutatedMembers.add(propertyName);
+	}
+	return hasUnknownMutation;
+};
+var analyzeMutationCall = (identifier, mutatedMembers) => {
+	const candidate = skipTransparentParents(identifier);
+	const parent = candidate.parent;
+	if (!ts.isCallExpression(parent)) return null;
+	const callee = unwrapExpression(parent.expression);
+	if (ts.isPropertyAccessExpression(callee) && ts.isIdentifier(callee.expression) && callee.expression.text === "Object" && callee.name.text === "assign" && parent.arguments[0] === candidate) {
+		let hasUnknownMutation = parent.arguments.length < 2;
+		for (const source of parent.arguments.slice(1)) {
+			const assignmentSource = unwrapExpression(source);
+			if (!ts.isObjectLiteralExpression(assignmentSource)) hasUnknownMutation = true;
+			else if (addObjectAssignmentMembers(assignmentSource, mutatedMembers)) hasUnknownMutation = true;
+		}
+		return hasUnknownMutation;
+	}
+	if (ts.isPropertyAccessExpression(callee) && ts.isIdentifier(callee.expression) && callee.expression.text === "Reflect" && callee.name.text === "set" && parent.arguments[0] === candidate) {
+		const member = parent.arguments[1];
+		if (member !== void 0 && (ts.isStringLiteral(member) || ts.isNoSubstitutionTemplateLiteral(member))) {
+			mutatedMembers.add(member.text);
+			return false;
+		}
+		return true;
+	}
+	return true;
+};
+/**
+* Classifies module-local mutations and escapes for one returned object value.
+* @param analysis The indexed source containing the binding.
+* @param declaration The module-local constant declaration.
+* @param allowedReferences Bare identifier uses proven to be supported registrations or targets.
+* @param safeMethodCalls Read-only method calls that preserve the value's runtime configuration.
+* @returns Member-specific mutations and whether an unknown use can affect every relationship.
+*/
+var analyzeModuleValueMutations = (analysis, declaration, allowedReferences, safeMethodCalls = /* @__PURE__ */ new Set()) => {
+	if (!ts.isIdentifier(declaration.name)) return Object.freeze({
+		hasUnknownMutation: true,
+		mutatedMembers: /* @__PURE__ */ new Set()
+	});
+	const mutatedMembers = /* @__PURE__ */ new Set();
+	let hasUnknownMutation = false;
+	for (const identifier of analysis.identifierUses.get(declaration.name.text) ?? []) {
+		if (isIgnoredIdentifier(identifier, declaration.name) || !isModuleBindingVisible(identifier, analysis) || allowedReferences.has(identifier)) continue;
+		const expression = skipTransparentParents(identifier);
+		const parent = expression.parent;
+		const member = (ts.isPropertyAccessExpression(parent) || ts.isElementAccessExpression(parent)) && parent.expression === expression ? parent : null;
+		if (member !== null) {
+			const memberName = getStaticMemberName(member);
+			if (memberName === null) hasUnknownMutation = true;
+			else if (isMutatingTarget(member)) mutatedMembers.add(memberName);
+			else {
+				const memberExpression = skipTransparentParents(member);
+				const memberParent = memberExpression.parent;
+				if ((ts.isPropertyAccessExpression(memberParent) || ts.isElementAccessExpression(memberParent)) && memberParent.expression === memberExpression && ts.isCallExpression(skipTransparentParents(memberParent).parent)) mutatedMembers.add(memberName);
+				else if (ts.isCallExpression(memberParent) && memberParent.expression === memberExpression) {
+					if (!safeMethodCalls.has(memberName)) mutatedMembers.add(memberName);
+				}
+			}
+			continue;
+		}
+		if (isMutatingTarget(identifier)) {
+			hasUnknownMutation = true;
+			continue;
+		}
+		const mutationCall = analyzeMutationCall(identifier, mutatedMembers);
+		hasUnknownMutation ||= mutationCall ?? true;
+	}
+	return Object.freeze({
+		hasUnknownMutation,
+		mutatedMembers: new Set(mutatedMembers)
+	});
+};
+var TYPESCRIPT_DECLARATION_EXTENSIONS = [
+	".d.ts",
+	".d.tsx",
+	".d.mts",
+	".d.cts"
+];
+var TYPESCRIPT_SOURCE_EXTENSIONS = [
+	".ts",
+	".tsx",
+	".mts"
+];
+var getScriptKind = (path) => path.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS;
+var createSyntaxProgram = (sourceFile, text) => {
+	return ts.createProgram({
+		host: {
+			fileExists: (fileName) => fileName === sourceFile.fileName,
+			getCanonicalFileName: (fileName) => fileName,
+			getCurrentDirectory: () => "/",
+			getDefaultLibFileName: () => "/lib.d.ts",
+			getDirectories: () => [],
+			getNewLine: () => "\n",
+			getSourceFile: (fileName) => fileName === sourceFile.fileName ? sourceFile : void 0,
+			readFile: (fileName) => fileName === sourceFile.fileName ? text : void 0,
+			useCaseSensitiveFileNames: () => true,
+			writeFile: () => void 0
+		},
+		options: {
+			jsx: ts.JsxEmit.Preserve,
+			module: ts.ModuleKind.ESNext,
+			noLib: true,
+			noResolve: true,
+			target: ts.ScriptTarget.ES2023
+		},
+		rootNames: [sourceFile.fileName]
+	});
+};
+/**
+* Parses and indexes one TypeScript module without provider request assumptions.
+* @param path The normalized logical source path.
+* @param bytes The exact source bytes returned by the adapter reader.
+* @param importConfig The provider constructor-import contract.
+* @param signal The active inspection signal.
+* @returns A source analysis or stable invalid-text or invalid-syntax result.
+* @throws If source analysis is aborted.
+*/
+var analyzeTypeScriptModule = (path, bytes, importConfig, signal) => {
+	signal?.throwIfAborted();
+	const text = normalizeText(bytes);
+	if (!text.valid) return Object.freeze({ kind: "invalid-text" });
+	signal?.throwIfAborted();
+	const sourceFile = ts.createSourceFile(path, text.value, ts.ScriptTarget.ES2023, true, getScriptKind(path));
+	const syntaxDiagnostic = createSyntaxProgram(sourceFile, text.value).getSyntacticDiagnostics(sourceFile).filter(({ category }) => category === ts.DiagnosticCategory.Error).sort((left, right) => (left.start ?? 0) - (right.start ?? 0))[0];
+	signal?.throwIfAborted();
+	if (syntaxDiagnostic !== void 0) {
+		const start = syntaxDiagnostic.start;
+		return Object.freeze({
+			kind: "invalid-syntax",
+			range: start === void 0 ? null : text.locator.locateRange(start, start + (syntaxDiagnostic.length ?? 0))
+		});
+	}
+	const { constructorNames, namedImports } = indexImports(sourceFile, importConfig);
+	signal?.throwIfAborted();
+	const { clientNames, exports, moduleArrays, moduleConstDeclarations } = indexModuleDeclarations(sourceFile, constructorNames);
+	signal?.throwIfAborted();
+	const identifierUses = indexIdentifierUses(sourceFile);
+	signal?.throwIfAborted();
+	const localBindingNames = indexLocalBindingNames(sourceFile);
+	signal?.throwIfAborted();
+	const analysis = Object.freeze({
+		clientNames,
+		constructorNames,
+		exports,
+		identifierUses,
+		localBindingNames,
+		moduleArrays,
+		moduleConstDeclarations,
+		namedImports,
+		path,
+		safeModuleArrayNames: /* @__PURE__ */ new Set(),
+		sourceFile,
+		text
+	});
+	signal?.throwIfAborted();
+	return Object.freeze({
+		analysis,
+		kind: "valid"
+	});
+};
+/**
+* Determines whether a path uses a supported TypeScript source extension.
+* @param path The bound source path.
+* @returns Whether its extension is supported.
+*/
+var isSupportedTypeScriptSourcePath = (path) => !TYPESCRIPT_DECLARATION_EXTENSIONS.some((extension) => path.endsWith(extension)) && TYPESCRIPT_SOURCE_EXTENSIONS.some((extension) => path.endsWith(extension));
+/**
+* Classifies a direct exported runtime-agent function and exposes its body.
+* @param analysis The indexed runtime source.
+* @param symbol The bound runtime-agent symbol.
+* @returns The symbol state and supported body when available.
+*/
+var getRuntimeExport = (analysis, symbol) => {
+	const exported = analysis.exports.get(symbol);
+	if (exported === void 0) return Object.freeze({ kind: "absent" });
+	if (exported.kind === "present-unsupported") return exported;
+	const { declaration } = exported;
+	if (ts.isFunctionDeclaration(declaration) && declaration.body !== void 0) return Object.freeze({
+		body: declaration.body,
+		declaration,
+		kind: "present-supported"
+	});
+	if (ts.isVariableDeclaration(declaration) && declaration.initializer !== void 0) {
+		const initializer = unwrapExpression(declaration.initializer);
+		if (ts.isArrowFunction(initializer) || ts.isFunctionExpression(initializer)) return Object.freeze({
+			body: initializer.body,
+			declaration,
+			kind: "present-supported"
+		});
+	}
+	return Object.freeze({
+		declaration,
+		kind: "present-unsupported"
+	});
+};
+/**
+* Classifies a directly exported callable value such as an instruction loader.
+* @param analysis The indexed source.
+* @param symbol The exact bound symbol.
+* @returns The symbol state for conservative call matching.
+*/
+var getCallableExportState = (analysis, symbol) => {
+	const runtimeExport = getRuntimeExport(analysis, symbol);
+	return runtimeExport.kind === "present-supported" ? Object.freeze({
+		declaration: runtimeExport.declaration,
+		kind: "present-supported"
+	}) : runtimeExport;
+};
+/**
+* Classifies a directly exported constant and returns its static initializer.
+* @param analysis The indexed source.
+* @param symbol The exact bound symbol.
+* @returns The symbol state and initializer when supported.
+*/
+var getConstExport = (analysis, symbol) => {
+	const exported = analysis.exports.get(symbol);
+	if (exported === void 0) return Object.freeze({ kind: "absent" });
+	if (exported.kind === "present-supported" && ts.isVariableDeclaration(exported.declaration) && exported.declaration.initializer !== void 0) return Object.freeze({
+		declaration: exported.declaration,
+		expression: unwrapExpression(exported.declaration.initializer),
+		kind: "present-supported"
+	});
+	return Object.freeze({
+		declaration: exported.declaration,
+		kind: "present-unsupported"
+	});
+};
+var resolveCandidatePath = async (options, containingPath, moduleSpecifier) => {
+	const matchingPaths = [];
+	for (const candidate of resolveImportCandidatePaths(containingPath, moduleSpecifier)) {
+		const path = options.parsePath(candidate);
+		if ((await options.getEntry(path))?.type === "file") matchingPaths.push(path);
+	}
+	return matchingPaths.length === 1 ? matchingPaths[0] : null;
+};
+var resolveStaticStringExpression = async (options, analysis, expression, visited) => {
+	options.signal?.throwIfAborted();
+	const candidate = unwrapExpression(expression);
+	const literal = getStaticString(candidate);
+	if (literal !== null) return Object.freeze({
+		expression: candidate,
+		kind: "supported",
+		value: literal
+	});
+	if (!ts.isIdentifier(candidate) || !isModuleBindingVisible(candidate, analysis)) return Object.freeze({ kind: "unsupported" });
+	const localDeclaration = analysis.moduleConstDeclarations.get(candidate.text);
+	if (localDeclaration?.initializer !== void 0) {
+		const key = `${analysis.path}\0local\0${candidate.text}`;
+		if (visited.has(key)) return Object.freeze({ kind: "unsupported" });
+		visited.add(key);
+		const result = await resolveStaticStringExpression(options, analysis, localDeclaration.initializer, visited);
+		visited.delete(key);
+		return result;
+	}
+	const namedImport = analysis.namedImports.get(candidate.text);
+	if (namedImport === void 0) return Object.freeze({ kind: "unsupported" });
+	const importedPath = await resolveCandidatePath(options, analysis.path, namedImport.moduleSpecifier);
+	if (importedPath === null) return Object.freeze({ kind: "unsupported" });
+	const key = `${importedPath}\0export\0${namedImport.importedName}`;
+	if (visited.has(key)) return Object.freeze({ kind: "unsupported" });
+	visited.add(key);
+	const importedResult = await options.analyzeSource(importedPath);
+	if (importedResult.kind !== "valid") {
+		options.onSourceFailure?.(importedPath, importedResult);
+		visited.delete(key);
+		return Object.freeze({ kind: "unsupported" });
+	}
+	const exported = getConstExport(importedResult.analysis, namedImport.importedName);
+	if (exported.kind !== "present-supported" || exported.expression === void 0) {
+		visited.delete(key);
+		return Object.freeze({ kind: "unsupported" });
+	}
+	const result = await resolveStaticStringExpression(options, importedResult.analysis, exported.expression, visited);
+	visited.delete(key);
+	return result;
+};
+/**
+* Resolves one exact supported static string without normalization or execution.
+* @param options The source, expression, repository callbacks, and parser for the relationship.
+* @returns The exact compiler-parsed string or an unsupported state.
+*/
+var resolveStaticString = (options) => resolveStaticStringExpression(options, options.analysis, options.expression, /* @__PURE__ */ new Set());
+//#endregion
+//#region src/source-analysis/bindings.ts
+/** Returns an exact supported object-property name. */
+var getLangChainPropertyName = (name) => ts.isIdentifier(name) || ts.isStringLiteral(name) ? name.text : null;
+/** Determines whether an object uses JavaScript's non-own `__proto__` setter form. */
+var hasLangChainPrototypeSetter = (object) => object.properties.some((property) => ts.isPropertyAssignment(property) && !ts.isComputedPropertyName(property.name) && getLangChainPropertyName(property.name) === "__proto__");
+/** Classifies one direct expression against an exact manifest binding. */
+var classifyLangChainDirectBinding = (expression, analysis, reference) => {
+	const candidate = unwrapExpression(expression);
+	if (!ts.isIdentifier(candidate) || !isModuleBindingVisible(candidate, analysis)) return ts.isStringLiteral(candidate) || ts.isNoSubstitutionTemplateLiteral(candidate) || ts.isNumericLiteral(candidate) || ts.isObjectLiteralExpression(candidate) || ts.isArrayLiteralExpression(candidate) || ts.isArrowFunction(candidate) || ts.isFunctionExpression(candidate) || ts.isClassExpression(candidate) || candidate.kind === ts.SyntaxKind.NullKeyword || candidate.kind === ts.SyntaxKind.TrueKeyword || candidate.kind === ts.SyntaxKind.FalseKeyword ? Object.freeze({
+		expression: candidate,
+		kind: "different"
+	}) : Object.freeze({ kind: "unresolved" });
+	if (isBoundIdentifier(candidate, analysis, reference)) return Object.freeze({
+		expression: candidate,
+		kind: "wired"
+	});
+	return resolveBindingReferences(candidate, analysis).length > 0 ? Object.freeze({
+		expression: candidate,
+		kind: "different"
+	}) : Object.freeze({ kind: "unresolved" });
+};
+/** Classifies a direct or awaited call to an exact bound loader. */
+var classifyLangChainLoaderCall = (expression, analysis, reference) => {
+	const call = getDirectCall(expression);
+	if (call === null) {
+		const candidate = unwrapExpression(expression);
+		return ts.isStringLiteral(candidate) || ts.isNoSubstitutionTemplateLiteral(candidate) ? Object.freeze({
+			expression: candidate,
+			kind: "different"
+		}) : Object.freeze({ kind: "unresolved" });
+	}
+	const callee = unwrapExpression(call.expression);
+	if (!ts.isIdentifier(callee) || !isModuleBindingVisible(callee, analysis)) return Object.freeze({ kind: "unresolved" });
+	if (isBoundIdentifier(callee, analysis, reference)) return Object.freeze({
+		expression: call,
+		kind: "wired"
+	});
+	return resolveBindingReferences(callee, analysis).length > 0 ? Object.freeze({
+		expression: call,
+		kind: "different"
+	}) : Object.freeze({ kind: "unresolved" });
+};
+//#endregion
+//#region src/source-analysis/agent-definitions.ts
+var CONFIGURATION_PROPERTY_NAMES = /* @__PURE__ */ new Set([
+	"model",
+	"tools",
+	"systemPrompt",
+	"stateSchema",
+	"contextSchema",
+	"checkpointer",
+	"store",
+	"responseFormat",
+	"middleware",
+	"name",
+	"description",
+	"includeAgentName",
+	"signal",
+	"version",
+	"streamTransformers"
+]);
+var RELATIONSHIP_NAMES = [
+	"middleware",
+	"name",
+	"responseFormat",
+	"systemPrompt",
+	"tools"
+];
+var SAFE_AGENT_METHOD_CALLS = /* @__PURE__ */ new Set([
+	"invoke",
+	"stream",
+	"streamEvents"
+]);
+var AGENT_INVOCATION_MEMBER_NAMES = /* @__PURE__ */ new Set([
+	"invoke",
+	"stream",
+	"streamEvents"
+]);
+var createRelationships = () => Object.fromEntries(RELATIONSHIP_NAMES.map((name) => [name, {
+	expression: null,
+	kind: "absent"
+}]));
+var getAgentObject = (initializer, analysis) => {
+	const candidate = unwrapExpression(initializer);
+	if (!ts.isCallExpression(candidate) || candidate.arguments.length !== 1) return null;
+	const callee = unwrapExpression(candidate.expression);
+	if (!ts.isIdentifier(callee) || !analysis.imports.createAgentNames.has(callee.text) || !isModuleBindingVisible(callee, analysis)) return null;
+	const object = unwrapExpression(candidate.arguments[0]);
+	return ts.isObjectLiteralExpression(object) ? object : null;
+};
+var analyzeConfiguration = (object) => {
+	const hasPrototypeSetter = hasLangChainPrototypeSetter(object);
+	const relationships = createRelationships();
+	const seenRelationships = /* @__PURE__ */ new Set();
+	let hasModel = false;
+	let isModelClosed = false;
+	for (const property of object.properties) {
+		if (ts.isSpreadAssignment(property) || ts.isComputedPropertyName(property.name)) {
+			isModelClosed = false;
+			for (const name of RELATIONSHIP_NAMES) relationships[name] = { kind: "unresolved" };
+			continue;
+		}
+		const name = getLangChainPropertyName(property.name);
+		if (hasPrototypeSetter && name === "__proto__" && ts.isPropertyAssignment(property)) continue;
+		if (name === null || !CONFIGURATION_PROPERTY_NAMES.has(name)) return null;
+		if (name === "model") {
+			if (hasModel || !ts.isPropertyAssignment(property)) return null;
+			hasModel = true;
+			isModelClosed = true;
+			continue;
+		}
+		if (!RELATIONSHIP_NAMES.includes(name)) continue;
+		const relationshipName = name;
+		if (seenRelationships.has(name)) {
+			relationships[relationshipName] = { kind: "unresolved" };
+			continue;
+		}
+		seenRelationships.add(name);
+		relationships[relationshipName] = ts.isPropertyAssignment(property) ? {
+			expression: unwrapExpression(property.initializer),
+			kind: "present"
+		} : { kind: "unresolved" };
+	}
+	if (!hasModel || !isModelClosed) return null;
+	if (hasPrototypeSetter) for (const name of RELATIONSHIP_NAMES) relationships[name] = { kind: "unresolved" };
+	return relationships;
+};
+/** Classifies one directly exported package-root `createAgent(...)` definition. */
+var getLangChainAgentDefinition = (analysis, symbol) => {
+	const exported = analysis.exports.get(symbol);
+	if (exported === void 0) return Object.freeze({ kind: "absent" });
+	if (exported.kind !== "present-supported" || !ts.isVariableDeclaration(exported.declaration) || exported.declaration.initializer === void 0) return Object.freeze({
+		declaration: exported.declaration,
+		kind: "present-unsupported"
+	});
+	const object = getAgentObject(exported.declaration.initializer, analysis);
+	const relationships = object === null ? null : analyzeConfiguration(object);
+	if (object === null || relationships === null) return Object.freeze({
+		declaration: exported.declaration,
+		kind: "present-unsupported"
+	});
+	const mutations = analyzeModuleValueMutations(analysis, exported.declaration, /* @__PURE__ */ new Set(), SAFE_AGENT_METHOD_CALLS);
+	const hasInvocationMutation = [...AGENT_INVOCATION_MEMBER_NAMES].some((name) => mutations.mutatedMembers.has(name));
+	const hasBroadRelationshipMutation = mutations.hasUnknownMutation || [...mutations.mutatedMembers].some((name) => name !== "name" && !RELATIONSHIP_NAMES.includes(name) && !AGENT_INVOCATION_MEMBER_NAMES.has(name));
+	const relationship = (name) => {
+		const isInvocationRelationship = [
+			"middleware",
+			"responseFormat",
+			"systemPrompt",
+			"tools"
+		].includes(name);
+		return hasBroadRelationshipMutation || hasInvocationMutation && isInvocationRelationship || mutations.mutatedMembers.has(name) ? { kind: "unresolved" } : relationships[name];
+	};
+	const definition = Object.freeze({
+		configuredTools: relationships.tools,
+		declaration: exported.declaration,
+		middleware: relationship("middleware"),
+		name: mutations.hasUnknownMutation || mutations.mutatedMembers.has("name") ? { kind: "unresolved" } : relationships.name,
+		object,
+		responseFormat: relationship("responseFormat"),
+		systemPrompt: relationship("systemPrompt"),
+		tools: relationship("tools")
+	});
+	return Object.freeze({
+		definition,
+		kind: "present-supported"
+	});
+};
+//#endregion
+//#region src/source-analysis/function-tools.ts
+var FUNCTION_TOOL_FIELD_NAMES = /* @__PURE__ */ new Set([
+	"name",
+	"description",
+	"schema",
+	"responseFormat",
+	"returnDirect",
+	"defaultConfig",
+	"verboseParsingErrors",
+	"verbose",
+	"callbacks",
+	"tags",
+	"metadata",
+	"extras"
+]);
+var getFunctionToolCall = (initializer, analysis) => {
+	const candidate = unwrapExpression(initializer);
+	if (!ts.isCallExpression(candidate) || candidate.arguments.length !== 2) return null;
+	const callee = unwrapExpression(candidate.expression);
+	if (!ts.isIdentifier(callee) || !isModuleBindingVisible(callee, analysis)) return null;
+	const helperSource = analysis.imports.toolNames.get(callee.text);
+	return helperSource === void 0 ? null : Object.freeze({
+		call: candidate,
+		helperSource
+	});
+};
+var getFunctionToolFields = (call) => {
+	const fields = unwrapExpression(call.arguments[1]);
+	if (!ts.isObjectLiteralExpression(fields) || hasLangChainPrototypeSetter(fields)) return null;
+	const seen = /* @__PURE__ */ new Set();
+	let description = {
+		expression: null,
+		kind: "absent"
+	};
+	let name = null;
+	let schema = {
+		expression: null,
+		kind: "absent"
+	};
+	for (const property of fields.properties) {
+		if (!ts.isPropertyAssignment(property) || ts.isComputedPropertyName(property.name)) return null;
+		const propertyName = getLangChainPropertyName(property.name);
+		if (propertyName === null || !FUNCTION_TOOL_FIELD_NAMES.has(propertyName) || seen.has(propertyName)) return null;
+		seen.add(propertyName);
+		if (propertyName === "name") name = unwrapExpression(property.initializer);
+		else if (propertyName === "description") description = {
+			expression: unwrapExpression(property.initializer),
+			kind: "present"
+		};
+		else if (propertyName === "schema") schema = {
+			expression: unwrapExpression(property.initializer),
+			kind: "present"
+		};
+	}
+	return name === null ? null : Object.freeze({
+		description,
+		fields,
+		name,
+		schema
+	});
+};
+var createFunctionToolShape = (functionToolCall, functionToolFields, mutations) => {
+	const hasUnknownMutation = mutations?.hasUnknownMutation === true;
+	const isImplementationUnresolved = hasUnknownMutation || mutations?.mutatedMembers.has("func") === true || mutations?.mutatedMembers.has("invoke") === true;
+	const isNameUnresolved = hasUnknownMutation || mutations?.mutatedMembers.has("name") === true;
+	const implementationKind = isImplementationUnresolved ? "unresolved" : "present";
+	const nameKind = isNameUnresolved ? "unresolved" : "present";
+	const schema = hasUnknownMutation || mutations?.mutatedMembers.has("schema") === true ? { kind: "unresolved" } : functionToolFields.schema;
+	return Object.freeze({
+		description: functionToolFields.description,
+		fields: functionToolFields.fields,
+		helperSource: functionToolCall.helperSource,
+		implementation: {
+			expression: unwrapExpression(functionToolCall.call.arguments[0]),
+			kind: implementationKind
+		},
+		name: {
+			expression: functionToolFields.name,
+			kind: nameKind
+		},
+		schema
+	});
+};
+/** Classifies one directly exported normal two-argument LangChain function tool. */
+var getLangChainFunctionTool = (analysis, symbol, allowedReferences = /* @__PURE__ */ new Set()) => {
+	const exported = analysis.exports.get(symbol);
+	if (exported === void 0) return Object.freeze({ kind: "absent" });
+	if (exported.kind !== "present-supported" || !ts.isVariableDeclaration(exported.declaration) || exported.declaration.initializer === void 0) return Object.freeze({
+		declaration: exported.declaration,
+		kind: "present-unsupported"
+	});
+	const functionToolCall = getFunctionToolCall(exported.declaration.initializer, analysis);
+	const functionToolFields = functionToolCall === null ? null : getFunctionToolFields(functionToolCall.call);
+	if (functionToolCall === null || functionToolFields === null) return Object.freeze({
+		declaration: exported.declaration,
+		kind: "present-unsupported"
+	});
+	const mutations = analyzeModuleValueMutations(analysis, exported.declaration, allowedReferences);
+	const tool = Object.freeze({
+		declaration: exported.declaration,
+		...createFunctionToolShape(functionToolCall, functionToolFields, mutations)
+	});
+	return Object.freeze({
+		kind: "present-supported",
+		tool
+	});
+};
+/** Classifies one inline normal function-tool declaration. */
+var getInlineLangChainFunctionTool = (expression, analysis) => {
+	const functionToolCall = getFunctionToolCall(expression, analysis);
+	const functionToolFields = functionToolCall === null ? null : getFunctionToolFields(functionToolCall.call);
+	return functionToolCall === null || functionToolFields === null ? null : createFunctionToolShape(functionToolCall, functionToolFields);
+};
+//#endregion
+//#region src/source-analysis/source-analysis.ts
+var SUPPORTED_IMPORTS = Object.freeze({
+	"@langchain/core/messages": /* @__PURE__ */ new Set(["SystemMessage"]),
+	"@langchain/core/tools": /* @__PURE__ */ new Set(["tool"]),
+	langchain: /* @__PURE__ */ new Set([
+		"createAgent",
+		"providerStrategy",
+		"SystemMessage",
+		"tool",
+		"toolStrategy"
+	]),
+	"langchain/tools": /* @__PURE__ */ new Set(["tool"])
+});
+var indexLangChainImports = (sourceFile) => {
+	const createAgentNames = /* @__PURE__ */ new Set();
+	const providerStrategyNames = /* @__PURE__ */ new Set();
+	const systemMessageNames = /* @__PURE__ */ new Set();
+	const toolNames = /* @__PURE__ */ new Map();
+	const toolStrategyNames = /* @__PURE__ */ new Set();
+	for (const statement of sourceFile.statements) {
+		if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier) || statement.importClause?.isTypeOnly === true || statement.importClause?.namedBindings === void 0 || !ts.isNamedImports(statement.importClause.namedBindings)) continue;
+		const moduleSpecifier = statement.moduleSpecifier.text;
+		const supportedNames = SUPPORTED_IMPORTS[moduleSpecifier];
+		if (supportedNames === void 0) continue;
+		for (const element of statement.importClause.namedBindings.elements) {
+			const importedName = element.propertyName?.text ?? element.name.text;
+			if (element.isTypeOnly || !supportedNames.has(importedName)) continue;
+			if (moduleSpecifier === "langchain" && importedName === "createAgent") createAgentNames.add(element.name.text);
+			else if (moduleSpecifier === "langchain" && importedName === "providerStrategy") providerStrategyNames.add(element.name.text);
+			else if (importedName === "SystemMessage") systemMessageNames.add(element.name.text);
+			else if (importedName === "tool") toolNames.set(element.name.text, moduleSpecifier);
+			else if (moduleSpecifier === "langchain" && importedName === "toolStrategy") toolStrategyNames.add(element.name.text);
+		}
+	}
+	return Object.freeze({
+		createAgentNames,
+		providerStrategyNames,
+		systemMessageNames,
+		toolNames,
+		toolStrategyNames
+	});
+};
+/** Parses and indexes one supported LangChain TypeScript module without executing it. */
+var analyzeLangChainSource = (path, bytes, signal) => {
+	const result = analyzeTypeScriptModule(path, bytes, {
+		namedConstructorImports: [],
+		packageName: LANGCHAIN_PACKAGE_NAME,
+		supportsDefaultConstructorImport: false
+	}, signal);
+	if (result.kind !== "valid") return result;
+	const analysis = Object.freeze({
+		...result.analysis,
+		imports: indexLangChainImports(result.analysis.sourceFile),
+		path
+	});
+	return Object.freeze({
+		analysis,
+		kind: "valid"
+	});
+};
+//#endregion
+//#region src/source-analysis/static-strings.ts
+/** Resolves one supported immutable source string across relative import edges. */
+var resolveLangChainStaticString = (session, analysis, expression, onSourceFailure) => resolveStaticString({
+	analysis,
+	analyzeSource: (path) => session.analyzeSource(path),
+	expression,
+	getEntry: (path) => session.getEntry(path),
+	...onSourceFailure === void 0 ? {} : { onSourceFailure: (path, result) => onSourceFailure(Object.freeze({
+		...result,
+		path
+	})) },
+	parsePath: (path) => parseRepositoryPath(path),
+	...session.signal === void 0 ? {} : { signal: session.signal }
+});
+//#endregion
+//#region src/source-analysis/structured-output.ts
+var isExactImportedHelper = (expression, names, analysis) => ts.isIdentifier(expression) && names.has(expression.text) && isModuleBindingVisible(expression, analysis);
+var classifyProviderStrategyObject = (object, analysis, reference) => {
+	const seen = /* @__PURE__ */ new Set();
+	let schema = null;
+	for (const property of object.properties) {
+		if (!ts.isPropertyAssignment(property) || ts.isComputedPropertyName(property.name)) return Object.freeze({ kind: "unresolved" });
+		const name = getLangChainPropertyName(property.name);
+		if (name === null || !["schema", "strict"].includes(name) || seen.has(name)) return Object.freeze({ kind: "unresolved" });
+		seen.add(name);
+		if (name === "schema") schema = unwrapExpression(property.initializer);
+		else {
+			const strict = unwrapExpression(property.initializer);
+			if (strict.kind !== ts.SyntaxKind.TrueKeyword && strict.kind !== ts.SyntaxKind.FalseKeyword) return Object.freeze({ kind: "unresolved" });
+		}
+	}
+	return schema === null ? Object.freeze({ kind: "unresolved" }) : classifyLangChainDirectBinding(schema, analysis, reference);
+};
+/** Classifies a direct schema or supported one-schema response strategy. */
+var classifyLangChainResponseFormat = (expression, analysis, reference) => {
+	const candidate = unwrapExpression(expression);
+	if (ts.isArrayLiteralExpression(candidate)) return Object.freeze({ kind: "unresolved" });
+	if (!ts.isCallExpression(candidate)) return classifyLangChainDirectBinding(candidate, analysis, reference);
+	const callee = unwrapExpression(candidate.expression);
+	if (isExactImportedHelper(callee, analysis.imports.toolStrategyNames, analysis) && (candidate.arguments.length === 1 || candidate.arguments.length === 2)) {
+		const firstArgument = unwrapExpression(candidate.arguments[0]);
+		const result = ts.isArrayLiteralExpression(firstArgument) ? Object.freeze({ kind: "unresolved" }) : classifyLangChainDirectBinding(firstArgument, analysis, reference);
+		return Object.freeze({
+			...result,
+			strategy: "tool-strategy"
+		});
+	}
+	if (!isExactImportedHelper(callee, analysis.imports.providerStrategyNames, analysis) || candidate.arguments.length !== 1) return Object.freeze({ kind: "unresolved" });
+	const argument = unwrapExpression(candidate.arguments[0]);
+	const result = ts.isObjectLiteralExpression(argument) ? classifyProviderStrategyObject(argument, analysis, reference) : classifyLangChainDirectBinding(argument, analysis, reference);
+	return Object.freeze({
+		...result,
+		strategy: "provider-strategy"
+	});
+};
+/** Determines whether a schema binding is obviously an array or prebuilt strategy value. */
+var isLangChainSingleSchemaInitializer = (expression, analysis) => {
+	const candidate = unwrapExpression(expression);
+	if (ts.isArrayLiteralExpression(candidate)) return false;
+	if (!ts.isCallExpression(candidate)) return true;
+	const callee = unwrapExpression(candidate.expression);
+	return !(isExactImportedHelper(callee, analysis.imports.toolStrategyNames, analysis) || isExactImportedHelper(callee, analysis.imports.providerStrategyNames, analysis));
+};
+//#endregion
+//#region src/diagnostics/index.ts
+var LANGCHAIN_ADAPTER_DIAGNOSTICS = Object.freeze({
+	LANGCHAIN_PACKAGE_MANIFEST_INVALID: "The owning package manifest is invalid for LangChain dependency detection.",
+	LANGCHAIN_VERSION_UNSUPPORTED: "The observed LangChain package ranges are disjoint from the supported target.",
+	LANGCHAIN_SOURCE_TEXT_INVALID: "The referenced LangChain source file is not valid normalized text.",
+	LANGCHAIN_SOURCE_SYNTAX_INVALID: "The referenced LangChain source file contains invalid TypeScript syntax.",
+	LANGCHAIN_RUNTIME_AGENT_SYMBOL_NOT_FOUND: "The declared runtime-agent symbol was not found.",
+	LANGCHAIN_INSTRUCTION_LOADER_SYMBOL_NOT_FOUND: "The declared instruction-loader symbol was not found.",
+	LANGCHAIN_AGENT_OUTPUT_SCHEMA_SYMBOL_NOT_FOUND: "The declared agent output-schema symbol was not found.",
+	LANGCHAIN_TOOL_IMPLEMENTATION_SYMBOL_NOT_FOUND: "The declared tool-implementation symbol was not found.",
+	LANGCHAIN_TOOL_REGISTRATION_SYMBOL_NOT_FOUND: "The declared tool-registration symbol was not found.",
+	LANGCHAIN_TOOL_INPUT_SCHEMA_SYMBOL_NOT_FOUND: "The declared tool input-schema symbol was not found.",
+	LANGCHAIN_INSTRUCTION_LOADER_NOT_WIRED: "The declared instruction loader is not wired to the detected LangChain agent.",
+	LANGCHAIN_AGENT_OUTPUT_SCHEMA_NOT_WIRED: "The declared agent output schema is not wired to the detected LangChain structured-output configuration.",
+	LANGCHAIN_TOOL_IMPLEMENTATION_NOT_WIRED: "The declared tool implementation is not wired to the detected LangChain function tool.",
+	LANGCHAIN_TOOL_REGISTRATION_NOT_WIRED: "The declared tool registration is not available to the detected LangChain agent.",
+	LANGCHAIN_TOOL_NAME_MISMATCH: "The declared tool name does not match the detected LangChain tool name.",
+	LANGCHAIN_TOOL_INPUT_SCHEMA_NOT_WIRED: "The declared tool input schema is not wired to the detected LangChain function tool."
+});
+/** Creates one frozen, safely namespaced LangChain adapter diagnostic. */
+var createLangChainDiagnostic = (input) => Object.freeze({
+	...input,
+	details: Object.freeze({ ...input.details }),
+	entity: input.entity === null ? null : Object.freeze({ ...input.entity }),
+	message: LANGCHAIN_ADAPTER_DIAGNOSTICS[input.code],
+	source: LANGCHAIN_ADAPTER_ID
+});
+//#endregion
+//#region src/inspection/common.ts
+var LINE_BREAK_CODE_POINTS = /* @__PURE__ */ new Set([
+	10,
+	13,
+	133,
+	8232,
+	8233
+]);
+var isUnicodeWhiteSpace = (codePoint) => codePoint >= 9 && codePoint <= 13 || codePoint === 32 || codePoint === 133 || codePoint === 160 || codePoint === 5760 || codePoint >= 8192 && codePoint <= 8202 || codePoint >= 8232 && codePoint <= 8233 || codePoint === 8239 || codePoint === 8287 || codePoint === 12288;
+/** Compares exact strings without locale-dependent behavior. */
+var compareLangChainStrings = (left, right) => left < right ? -1 : left > right ? 1 : 0;
+/** Determines whether a runtime-visible value satisfies Core's machine-string contract. */
+var isLangChainMachineString = (value) => {
+	const codePoints = [...value].map((character) => character.codePointAt(0));
+	return codePoints.length > 0 && codePoints.every((codePoint) => codePoint < 55296 || codePoint > 57343) && !codePoints.includes(0) && !codePoints.some((codePoint) => LINE_BREAK_CODE_POINTS.has(codePoint)) && !isUnicodeWhiteSpace(codePoints[0]) && !isUnicodeWhiteSpace(codePoints.at(-1));
+};
+var freezeReference = (reference) => Object.freeze({
+	path: reference.path,
+	...reference.symbol === void 0 ? {} : { symbol: reference.symbol }
+});
+/** Creates one deeply immutable LangChain evidence record. */
+var createLangChainEvidence = (evidence) => Object.freeze({
+	...evidence,
+	details: Object.freeze({ ...evidence.details }),
+	references: Object.freeze(evidence.references.map(freezeReference))
+});
+var createEntity = (agentId, capabilityId) => Object.freeze({
+	adapterId: LANGCHAIN_ADAPTER_ID,
+	agentId,
+	...capabilityId === void 0 ? {} : {
+		capabilityId,
+		capabilityKind: "tool"
+	}
+});
+/** Appends one stable package-owned diagnostic. */
+var addLangChainDiagnostic = (diagnostics, code, path, agentId, range = null, capabilityId, details = {}) => {
+	diagnostics.push(createLangChainDiagnostic({
+		code,
+		details,
+		entity: createEntity(agentId, capabilityId),
+		path,
+		pointer: null,
+		range
+	}));
+};
+/** Appends the stable diagnostic for one invalid imported relationship source. */
+var addLangChainSourceFailureDiagnostic = (diagnostics, failure, agentId, capabilityId) => {
+	if (failure.kind === "invalid-text") {
+		addLangChainDiagnostic(diagnostics, "LANGCHAIN_SOURCE_TEXT_INVALID", failure.path, agentId, null, capabilityId);
+		return;
+	}
+	addLangChainDiagnostic(diagnostics, "LANGCHAIN_SOURCE_SYNTAX_INVALID", failure.path, agentId, failure.range, capabilityId);
+};
+/** Returns the Core scalar range for one node in its analyzed source. */
+var locateLangChainNode = (analysis, node) => analysis.text.locator.locateRange(node.getStart(analysis.sourceFile), node.getEnd());
+/** Loads and validates one supported manifest-bound TypeScript source. */
+var analyzeLangChainBoundReference = async (session, reference, diagnostics, agentId, capabilityId) => {
+	if (!isSupportedTypeScriptSourcePath(reference.path)) return null;
+	const result = await session.analyzeSource(reference.path);
+	if (result.kind === "invalid-text") {
+		addLangChainDiagnostic(diagnostics, "LANGCHAIN_SOURCE_TEXT_INVALID", reference.path, agentId, null, capabilityId);
+		return null;
+	}
+	if (result.kind === "invalid-syntax") {
+		addLangChainDiagnostic(diagnostics, "LANGCHAIN_SOURCE_SYNTAX_INVALID", reference.path, agentId, result.range, capabilityId);
+		return null;
+	}
+	return result.analysis;
+};
+//#endregion
+//#region src/inspection/instruction-inspection.ts
+var classifyInstruction = (inspected, reference) => {
+	const relationship = inspected.definition.systemPrompt;
+	if (relationship.kind === "absent") return Object.freeze({
+		expression: null,
+		kind: "different"
+	});
+	if (relationship.kind === "unresolved") return Object.freeze({ kind: "unresolved" });
+	const candidate = unwrapExpression(relationship.expression);
+	if (ts.isNewExpression(candidate) && candidate.arguments?.length === 1) {
+		const constructor = unwrapExpression(candidate.expression);
+		if (ts.isIdentifier(constructor) && inspected.analysis.imports.systemMessageNames.has(constructor.text) && isModuleBindingVisible(constructor, inspected.analysis)) {
+			const result = classifyLangChainLoaderCall(candidate.arguments[0], inspected.analysis, reference);
+			return Object.freeze({
+				...result,
+				instructionForm: "system-message"
+			});
+		}
+		return Object.freeze({ kind: "unresolved" });
+	}
+	const result = classifyLangChainLoaderCall(candidate, inspected.analysis, reference);
+	return Object.freeze({
+		...result,
+		instructionForm: "direct-loader-call"
+	});
+};
+/** Inspects one declared instruction loader against the supported system prompt surface. */
+var inspectLangChainInstruction = async (session, inspected, evidence, diagnostics) => {
+	const reference = inspected.agent.declaration.bindings?.instructionLoader;
+	if (reference?.symbol === void 0) return;
+	const boundReference = Object.freeze({
+		path: reference.path,
+		symbol: reference.symbol
+	});
+	const loaderAnalysis = await analyzeLangChainBoundReference(session, reference, diagnostics, inspected.agent.id);
+	if (loaderAnalysis === null) return;
+	const loader = getCallableExportState(loaderAnalysis, reference.symbol);
+	if (loader.kind === "absent") {
+		addLangChainDiagnostic(diagnostics, "LANGCHAIN_INSTRUCTION_LOADER_SYMBOL_NOT_FOUND", reference.path, inspected.agent.id);
+		return;
+	}
+	if (loader.kind !== "present-supported" || inspected.middlewareState !== "inactive") return;
+	const result = classifyInstruction(inspected, boundReference);
+	if (result.kind === "wired") evidence.push(createLangChainEvidence({
+		agentId: inspected.agent.id,
+		capabilityId: null,
+		capabilityKind: null,
+		details: {
+			instructionForm: result.instructionForm ?? "direct-loader-call",
+			property: "systemPrompt",
+			targetId: LANGCHAIN_TARGET_ID
+		},
+		kind: "instruction-loader",
+		references: [inspected.agent.declaration.bindings?.runtimeAgent, boundReference],
+		runtimeName: boundReference.symbol,
+		source: LANGCHAIN_ADAPTER_ID
+	}));
+	else if (result.kind === "different") addLangChainDiagnostic(diagnostics, "LANGCHAIN_INSTRUCTION_LOADER_NOT_WIRED", inspected.analysis.path, inspected.agent.id, result.expression === null ? locateLangChainNode(inspected.analysis, inspected.definition.object) : locateLangChainNode(inspected.analysis, result.expression));
+};
+//#endregion
+//#region src/inspection/resolution.ts
+var collectRelationshipReferences = (relationships) => {
+	const references = /* @__PURE__ */ new Set();
+	for (const relationship of relationships) {
+		if (relationship.kind !== "present") continue;
+		const expression = unwrapExpression(relationship.expression);
+		if (ts.isIdentifier(expression)) references.add(expression);
+	}
+	return references;
+};
+/** Resolves one closed inline, module-local, or relative-imported array literal. */
+var resolveLangChainArray = async (session, analysis, relationship, relatedRelationships = [relationship]) => {
+	if (relationship.kind !== "present") return Object.freeze({ kind: "unresolved" });
+	const candidate = unwrapExpression(relationship.expression);
+	if (ts.isArrayLiteralExpression(candidate)) return Object.freeze({
+		kind: "resolved",
+		value: Object.freeze({
+			analysis,
+			expression: candidate,
+			reference: null
+		})
+	});
+	if (!ts.isIdentifier(candidate) || !isModuleBindingVisible(candidate, analysis)) return Object.freeze({ kind: "unresolved" });
+	const localDeclaration = analysis.moduleConstDeclarations.get(candidate.text);
+	const localInitializer = localDeclaration?.initializer === void 0 ? null : unwrapExpression(localDeclaration.initializer);
+	if (localDeclaration !== void 0 && localInitializer !== null && ts.isArrayLiteralExpression(localInitializer) && isModuleConstValueSafe(analysis, localDeclaration, collectRelationshipReferences(relatedRelationships), "array")) return Object.freeze({
+		kind: "resolved",
+		value: Object.freeze({
+			analysis,
+			expression: localInitializer,
+			reference: Object.freeze({
+				path: analysis.path,
+				symbol: candidate.text
+			})
+		})
+	});
+	const importedCandidates = [];
+	for (const reference of resolveBindingReferences(candidate, analysis).filter(({ path }) => path !== analysis.path)) {
+		session.signal?.throwIfAborted();
+		const path = parseRepositoryPath(reference.path);
+		if ((await session.getEntry(path))?.type === "file") importedCandidates.push({
+			path,
+			symbol: reference.symbol
+		});
+	}
+	if (importedCandidates.length !== 1) return Object.freeze({ kind: "unresolved" });
+	const importedReference = importedCandidates[0];
+	const source = await session.analyzeSource(importedReference.path);
+	if (source.kind !== "valid") return Object.freeze({
+		failure: Object.freeze({
+			...source,
+			path: importedReference.path
+		}),
+		kind: "source-failure"
+	});
+	const exported = getConstExport(source.analysis, importedReference.symbol);
+	const declaration = source.analysis.moduleConstDeclarations.get(importedReference.symbol);
+	if (exported.kind !== "present-supported" || exported.expression === void 0 || !ts.isArrayLiteralExpression(exported.expression) || declaration === void 0 || !isModuleConstValueSafe(source.analysis, declaration, /* @__PURE__ */ new Set(), "array")) return Object.freeze({ kind: "unresolved" });
+	return Object.freeze({
+		kind: "resolved",
+		value: Object.freeze({
+			analysis: source.analysis,
+			expression: exported.expression,
+			reference: Object.freeze(importedReference)
+		})
+	});
+};
+/** Determines whether an array has no holes or spread elements. */
+var isClosedLangChainArray = (array) => array.elements.every((element) => !ts.isOmittedExpression(element) && !ts.isSpreadElement(element));
+//#endregion
+//#region src/inspection/middleware-inspection.ts
+/** Classifies middleware as inactive, active, or unresolved without interpreting it. */
+var classifyLangChainMiddleware = async (session, analysis, relationship, relatedRelationships, diagnostics, agentId) => {
+	if (relationship.kind === "absent") return "inactive";
+	if (relationship.kind === "unresolved") return "unresolved";
+	const resolved = await resolveLangChainArray(session, analysis, relationship, relatedRelationships);
+	if (resolved.kind === "source-failure") {
+		addLangChainSourceFailureDiagnostic(diagnostics, resolved.failure, agentId);
+		return "unresolved";
+	}
+	if (resolved.kind === "unresolved" || !isClosedLangChainArray(resolved.value.expression)) return "unresolved";
+	return resolved.value.expression.elements.length === 0 ? "inactive" : "active";
+};
+//#endregion
+//#region src/inspection/package-inspection.ts
+var getPackageRole = (packageName) => packageName === "@langchain/core" ? "companion" : "primary";
+/** Inspects the nearest owning manifest and returns the conjunctive target state. */
+var inspectLangChainPackage = async (session, sourcePath, evidence, diagnostics, agentId) => {
+	const discovery = await session.discoverPackage(sourcePath);
+	if (discovery.kind === "absent") return "absent";
+	if (discovery.kind === "invalid") {
+		addLangChainDiagnostic(diagnostics, "LANGCHAIN_PACKAGE_MANIFEST_INVALID", discovery.path, agentId);
+		return "absent";
+	}
+	const { observation } = discovery;
+	if (observation.targetClassification === "absent") return observation.targetClassification;
+	if (observation.targetClassification === "unsupported") {
+		addLangChainDiagnostic(diagnostics, "LANGCHAIN_VERSION_UNSUPPORTED", observation.path, agentId);
+		return observation.targetClassification;
+	}
+	for (const packageObservation of observation.packages) for (const declaration of packageObservation.declarations) {
+		const isSemverRange = validRange(declaration.declaredRange, {
+			includePrerelease: false,
+			loose: false
+		}) !== null;
+		evidence.push(createLangChainEvidence({
+			agentId,
+			capabilityId: null,
+			capabilityKind: null,
+			details: {
+				classification: packageObservation.compatibility,
+				dependencyKind: declaration.dependencyKind,
+				...isSemverRange ? { declaredRange: declaration.declaredRange } : {},
+				packageName: packageObservation.packageName,
+				packageRole: getPackageRole(packageObservation.packageName),
+				targetClassification: observation.targetClassification,
+				targetId: LANGCHAIN_TARGET_ID
+			},
+			kind: "runtime-package",
+			references: [{ path: observation.path }],
+			runtimeName: packageObservation.packageName === "langchain" ? LANGCHAIN_PACKAGE_NAME : LANGCHAIN_CORE_PACKAGE_NAME,
+			source: LANGCHAIN_ADAPTER_ID
+		}));
+	}
+	return observation.targetClassification;
+};
+//#endregion
+//#region src/inspection/schema-inspection.ts
+/** Inspects one declared agent output schema against supported response formats. */
+var inspectLangChainOutputSchema = async (session, inspected, evidence, diagnostics) => {
+	const reference = inspected.agent.declaration.bindings?.outputSchema;
+	if (reference?.symbol === void 0) return;
+	const boundReference = Object.freeze({
+		path: reference.path,
+		symbol: reference.symbol
+	});
+	const schemaAnalysis = await analyzeLangChainBoundReference(session, reference, diagnostics, inspected.agent.id);
+	if (schemaAnalysis === null) return;
+	const schema = getConstExport(schemaAnalysis, reference.symbol);
+	if (schema.kind === "absent") {
+		addLangChainDiagnostic(diagnostics, "LANGCHAIN_AGENT_OUTPUT_SCHEMA_SYMBOL_NOT_FOUND", reference.path, inspected.agent.id);
+		return;
+	}
+	if (schema.kind !== "present-supported" || schema.expression === void 0 || !isLangChainSingleSchemaInitializer(schema.expression, schemaAnalysis) || inspected.middlewareState !== "inactive") return;
+	const relationship = inspected.definition.responseFormat;
+	if (relationship.kind === "unresolved") return;
+	const result = relationship.kind === "absent" ? {
+		expression: null,
+		kind: "different"
+	} : classifyLangChainResponseFormat(relationship.expression, inspected.analysis, boundReference);
+	if (result.kind === "wired") evidence.push(createLangChainEvidence({
+		agentId: inspected.agent.id,
+		capabilityId: null,
+		capabilityKind: null,
+		details: {
+			property: "responseFormat",
+			schemaRole: "agent-output",
+			schemaStrategy: result.strategy ?? "direct",
+			targetId: LANGCHAIN_TARGET_ID
+		},
+		kind: "schema",
+		references: [inspected.agent.declaration.bindings?.runtimeAgent, boundReference],
+		runtimeName: boundReference.symbol,
+		source: LANGCHAIN_ADAPTER_ID
+	}));
+	else if (result.kind === "different") addLangChainDiagnostic(diagnostics, "LANGCHAIN_AGENT_OUTPUT_SCHEMA_NOT_WIRED", inspected.analysis.path, inspected.agent.id, result.expression === null ? locateLangChainNode(inspected.analysis, inspected.definition.object) : locateLangChainNode(inspected.analysis, result.expression));
+};
+//#endregion
+//#region src/package-discovery/index.ts
+var classifyTarget = (primary, companion) => {
+	if (primary === "absent") return "absent";
+	if (primary === "unsupported" || (primary === "supported" || primary === "ambiguous") && companion === "unsupported") return "unsupported";
+	if (primary === "supported" && companion === "supported") return "supported";
+	if (primary === "supported" && companion === "absent") return "incomplete";
+	return "ambiguous";
+};
+/** Discovers the exact primary and companion declarations in one owning manifest read. */
+var discoverLangChainPackages = async (reader, sourcePath, signal) => {
+	const result = await discoverPackages({
+		packages: [{
+			packageName: LANGCHAIN_PACKAGE_NAME,
+			supportedRange: LANGCHAIN_SUPPORTED_PACKAGE_RANGE
+		}, {
+			packageName: LANGCHAIN_CORE_PACKAGE_NAME,
+			supportedRange: LANGCHAIN_CORE_SUPPORTED_PACKAGE_RANGE
+		}],
+		reader: {
+			getEntry: (path) => reader.getEntry(path, signal === void 0 ? void 0 : { signal }),
+			readFile: (path) => reader.readFile(path, signal === void 0 ? void 0 : { signal })
+		},
+		...signal === void 0 ? {} : { signal },
+		sourcePath
+	});
+	if (result.kind !== "observed") return result.kind === "invalid" ? Object.freeze({
+		kind: "invalid",
+		path: result.path
+	}) : result;
+	const [primary, companion] = result.observation.packages;
+	if (primary === void 0 || companion === void 0) return Object.freeze({
+		kind: "invalid",
+		path: result.observation.path
+	});
+	return Object.freeze({
+		kind: "observed",
+		observation: Object.freeze({
+			packages: result.observation.packages,
+			path: result.observation.path,
+			targetClassification: classifyTarget(primary.compatibility, companion.compatibility)
+		})
+	});
+};
+//#endregion
+//#region src/inspection/session.ts
+/** Creates one operation-local LangChain inspection session. */
+var createLangChainInspectionSession = (context) => createInspectionSession({
+	analyzeSource: analyzeLangChainSource,
+	discoverPackage: (path, signal) => discoverLangChainPackages(context.repository, path, signal),
+	getEntry: (path, signal) => context.repository.getEntry(path, signal === void 0 ? void 0 : { signal }),
+	readFile: (path, signal) => context.repository.readFile(path, signal === void 0 ? void 0 : { signal }),
+	...context.signal === void 0 ? {} : { signal: context.signal }
+});
+//#endregion
+//#region src/inspection/tool-inspection.ts
+/** Resolves the static metadata required for one supported normal function-tool shape. */
+var resolveFunctionToolMetadata = async (session, analysis, functionTool, diagnostics, agentId, capabilityId) => {
+	const onSourceFailure = (failure) => addLangChainSourceFailureDiagnostic(diagnostics, failure, agentId, capabilityId);
+	const name = await resolveLangChainStaticString(session, analysis, functionTool.name.expression, onSourceFailure);
+	if (name.kind !== "supported" || functionTool.description.kind === "unresolved") return null;
+	if (functionTool.description.kind === "present") {
+		if ((await resolveLangChainStaticString(session, analysis, functionTool.description.expression, onSourceFailure)).kind !== "supported") return null;
+	}
+	return Object.freeze({ runtimeName: functionTool.name.kind === "present" ? name.value : null });
+};
+/** Finds the direct array containing one registration use through transparent wrappers. */
+var getContainingArrayLiteral = (identifier) => {
+	let expression = identifier;
+	while (ts.isAsExpression(expression.parent) || ts.isParenthesizedExpression(expression.parent) || ts.isSatisfiesExpression(expression.parent)) expression = expression.parent;
+	return ts.isArrayLiteralExpression(expression.parent) ? expression.parent : null;
+};
+/** Groups direct array-element uses of one bound registration by their containing arrays. */
+var collectRegistrationArrayReferences = (analysis, reference) => {
+	const references = /* @__PURE__ */ new Map();
+	for (const identifier of analysis.identifierUses.get(reference.symbol) ?? []) {
+		if (!isModuleBindingVisible(identifier, analysis) || !isBoundIdentifier(identifier, analysis, reference)) continue;
+		const array = getContainingArrayLiteral(identifier);
+		if (array !== null) {
+			const arrayReferences = references.get(array) ?? [];
+			arrayReferences.push(identifier);
+			references.set(array, arrayReferences);
+		}
+	}
+	return references;
+};
+/** Checks whether one agent relationship can resolve to a candidate registration array. */
+var canResolveToRegistrationArray = (inspected, registrationAnalysis, arrays) => {
+	if (inspected.definition.configuredTools.kind !== "present") return false;
+	const relationship = unwrapExpression(inspected.definition.configuredTools.expression);
+	if (ts.isArrayLiteralExpression(relationship)) return inspected.analysis === registrationAnalysis && arrays.has(relationship);
+	if (!ts.isIdentifier(relationship) || !isModuleBindingVisible(relationship, inspected.analysis)) return false;
+	const localDeclaration = inspected.analysis.moduleConstDeclarations.get(relationship.text);
+	const localInitializer = localDeclaration?.initializer === void 0 ? null : unwrapExpression(localDeclaration.initializer);
+	if (inspected.analysis === registrationAnalysis && localInitializer !== null && ts.isArrayLiteralExpression(localInitializer) && arrays.has(localInitializer)) return true;
+	return resolveBindingReferences(relationship, inspected.analysis).some((reference) => {
+		if (reference.path !== registrationAnalysis.path) return false;
+		const declaration = registrationAnalysis.moduleConstDeclarations.get(reference.symbol);
+		const initializer = declaration?.initializer === void 0 ? null : unwrapExpression(declaration.initializer);
+		return initializer !== null && ts.isArrayLiteralExpression(initializer) && arrays.has(initializer);
+	});
+};
+/** Collects exact registration uses from closed tool collections owned by supported agents. */
+var collectAllowedRegistrationReferences = async (session, inspectedAgents, analysis, reference) => {
+	const registrationArrays = collectRegistrationArrayReferences(analysis, reference);
+	const references = /* @__PURE__ */ new Set();
+	if (registrationArrays.size === 0) return references;
+	for (const inspected of inspectedAgents) {
+		session.signal?.throwIfAborted();
+		if (!canResolveToRegistrationArray(inspected, analysis, registrationArrays)) continue;
+		const relatedRelationships = inspectedAgents.filter(({ analysis: candidateAnalysis }) => candidateAnalysis === inspected.analysis).map(({ definition }) => definition.configuredTools);
+		const resolved = await resolveLangChainArray(session, inspected.analysis, inspected.definition.configuredTools, relatedRelationships);
+		if (resolved.kind !== "resolved" || resolved.value.analysis !== analysis || !isClosedLangChainArray(resolved.value.expression)) continue;
+		for (const candidate of registrationArrays.get(resolved.value.expression) ?? []) references.add(candidate);
+	}
+	return references;
+};
+var inspectImplementation = async (session, inspected, capabilityId, manifestTool, registrationAnalysis, functionTool, diagnostics) => {
+	const reference = manifestTool.implementation;
+	if (reference.symbol === void 0) return null;
+	const boundReference = Object.freeze({
+		path: reference.path,
+		symbol: reference.symbol
+	});
+	const implementationAnalysis = await analyzeLangChainBoundReference(session, reference, diagnostics, inspected.agent.id, capabilityId);
+	if (implementationAnalysis === null) return null;
+	const implementation = getCallableExportState(implementationAnalysis, reference.symbol);
+	if (implementation.kind === "absent") {
+		addLangChainDiagnostic(diagnostics, "LANGCHAIN_TOOL_IMPLEMENTATION_SYMBOL_NOT_FOUND", reference.path, inspected.agent.id, null, capabilityId);
+		return null;
+	}
+	if (implementation.kind !== "present-supported") return null;
+	if (functionTool.implementation.kind === "unresolved") return { kind: "unresolved" };
+	const result = classifyLangChainDirectBinding(functionTool.implementation.expression, registrationAnalysis, boundReference);
+	if (result.kind === "different") addLangChainDiagnostic(diagnostics, "LANGCHAIN_TOOL_IMPLEMENTATION_NOT_WIRED", registrationAnalysis.path, inspected.agent.id, result.expression === null ? locateLangChainNode(registrationAnalysis, functionTool.fields) : locateLangChainNode(registrationAnalysis, result.expression), capabilityId);
+	return result;
+};
+var inspectInputSchema = async (session, inspected, capabilityId, manifestTool, registrationAnalysis, functionTool, evidence, diagnostics) => {
+	const reference = manifestTool.inputSchema;
+	if (reference?.symbol === void 0) return null;
+	const boundReference = Object.freeze({
+		path: reference.path,
+		symbol: reference.symbol
+	});
+	const schemaAnalysis = await analyzeLangChainBoundReference(session, reference, diagnostics, inspected.agent.id, capabilityId);
+	if (schemaAnalysis === null) return null;
+	const schema = getConstExport(schemaAnalysis, reference.symbol);
+	if (schema.kind === "absent") {
+		addLangChainDiagnostic(diagnostics, "LANGCHAIN_TOOL_INPUT_SCHEMA_SYMBOL_NOT_FOUND", reference.path, inspected.agent.id, null, capabilityId);
+		return null;
+	}
+	if (schema.kind !== "present-supported") return null;
+	const result = functionTool.schema.kind === "absent" ? {
+		expression: null,
+		kind: "different"
+	} : functionTool.schema.kind === "unresolved" ? { kind: "unresolved" } : classifyLangChainDirectBinding(functionTool.schema.expression, registrationAnalysis, boundReference);
+	if (result.kind === "wired") evidence.push(createLangChainEvidence({
+		agentId: inspected.agent.id,
+		capabilityId,
+		capabilityKind: "tool",
+		details: {
+			property: "schema",
+			schemaRole: "tool-input",
+			targetId: LANGCHAIN_TARGET_ID
+		},
+		kind: "schema",
+		references: [manifestTool.registration, boundReference],
+		runtimeName: boundReference.symbol,
+		source: LANGCHAIN_ADAPTER_ID
+	}));
+	else if (result.kind === "different") addLangChainDiagnostic(diagnostics, "LANGCHAIN_TOOL_INPUT_SCHEMA_NOT_WIRED", registrationAnalysis.path, inspected.agent.id, result.expression === null ? locateLangChainNode(registrationAnalysis, functionTool.fields) : locateLangChainNode(registrationAnalysis, result.expression), capabilityId);
+	return result;
+};
+var classifyRegistration = async (session, inspectedAgents, inspected, registrationReference, diagnostics, capabilityId) => {
+	const relationship = inspected.definition.tools;
+	if (relationship.kind === "absent") return false;
+	if (relationship.kind === "unresolved") return null;
+	const relatedRelationships = inspectedAgents.filter(({ analysis }) => analysis === inspected.analysis).map(({ definition }) => definition.tools);
+	const resolved = await resolveLangChainArray(session, inspected.analysis, relationship, relatedRelationships);
+	if (resolved.kind === "source-failure") {
+		addLangChainSourceFailureDiagnostic(diagnostics, resolved.failure, inspected.agent.id, capabilityId);
+		return null;
+	}
+	if (resolved.kind === "unresolved" || !isClosedLangChainArray(resolved.value.expression)) return null;
+	const resolvedArray = resolved.value;
+	const knownRegistrationReferences = Object.values(inspected.agent.declaration.tools ?? {}).map(({ registration }) => registration).filter((reference) => reference?.symbol !== void 0);
+	let hasUnresolvedElement = false;
+	for (const element of resolvedArray.expression.elements) {
+		const candidate = unwrapExpression(element);
+		if (ts.isIdentifier(candidate) && isModuleBindingVisible(candidate, resolvedArray.analysis)) {
+			if (isBoundIdentifier(candidate, resolvedArray.analysis, registrationReference)) return true;
+			if (resolveBindingReferences(candidate, resolvedArray.analysis).some((reference) => knownRegistrationReferences.some((known) => known.path === reference.path && known.symbol === reference.symbol))) continue;
+			const localTool = getLangChainFunctionTool(resolvedArray.analysis, candidate.text, /* @__PURE__ */ new Set([candidate]));
+			if (localTool.kind === "present-supported") {
+				const metadata = await resolveFunctionToolMetadata(session, resolvedArray.analysis, localTool.tool, diagnostics, inspected.agent.id, capabilityId);
+				if (metadata !== null && metadata.runtimeName !== null) continue;
+			}
+			hasUnresolvedElement = true;
+			continue;
+		}
+		const inlineTool = getInlineLangChainFunctionTool(candidate, resolvedArray.analysis);
+		if (inlineTool !== null) {
+			const metadata = await resolveFunctionToolMetadata(session, resolvedArray.analysis, inlineTool, diagnostics, inspected.agent.id, capabilityId);
+			if (metadata !== null && metadata.runtimeName !== null) continue;
+		}
+		hasUnresolvedElement = true;
+	}
+	return hasUnresolvedElement ? null : false;
+};
+var createRegistrationReferences = (inspected, registrationReference, manifestTool, relationships) => [
+	inspected.agent.declaration.bindings?.runtimeAgent,
+	registrationReference,
+	...relationships.implementation?.kind === "wired" ? [manifestTool.implementation] : [],
+	...relationships.inputSchema?.kind === "wired" && manifestTool.inputSchema !== void 0 ? [manifestTool.inputSchema] : []
+];
+/** Inspects all declared normal function tools and their agent registrations. */
+var inspectLangChainTools = async (session, inspectedAgents, evidence, diagnostics) => {
+	for (const inspected of inspectedAgents) {
+		const tools = Object.entries(inspected.agent.declaration.tools ?? {}).sort(([left], [right]) => compareLangChainStrings(left, right));
+		for (const [capabilityId, manifestTool] of tools) {
+			session.signal?.throwIfAborted();
+			const registrationReference = manifestTool.registration;
+			if (registrationReference?.symbol === void 0) continue;
+			const boundRegistrationReference = Object.freeze({
+				path: registrationReference.path,
+				symbol: registrationReference.symbol
+			});
+			const registrationAnalysis = await analyzeLangChainBoundReference(session, registrationReference, diagnostics, inspected.agent.id, capabilityId);
+			if (registrationAnalysis === null) continue;
+			const functionTool = getLangChainFunctionTool(registrationAnalysis, registrationReference.symbol, await collectAllowedRegistrationReferences(session, inspectedAgents, registrationAnalysis, boundRegistrationReference));
+			if (functionTool.kind === "absent") {
+				addLangChainDiagnostic(diagnostics, "LANGCHAIN_TOOL_REGISTRATION_SYMBOL_NOT_FOUND", registrationReference.path, inspected.agent.id, null, capabilityId);
+				continue;
+			}
+			if (functionTool.kind !== "present-supported") continue;
+			const metadata = await resolveFunctionToolMetadata(session, registrationAnalysis, functionTool.tool, diagnostics, inspected.agent.id, capabilityId);
+			if (metadata === null) continue;
+			const implementation = await inspectImplementation(session, inspected, capabilityId, manifestTool, registrationAnalysis, functionTool.tool, diagnostics);
+			const inputSchema = await inspectInputSchema(session, inspected, capabilityId, manifestTool, registrationAnalysis, functionTool.tool, evidence, diagnostics);
+			const runtimeName = metadata.runtimeName !== null && isLangChainMachineString(metadata.runtimeName) ? metadata.runtimeName : null;
+			if (inspected.middlewareState !== "inactive" || runtimeName === null) continue;
+			const registration = await classifyRegistration(session, inspectedAgents, inspected, boundRegistrationReference, diagnostics, capabilityId);
+			if (registration === true && runtimeName !== manifestTool.name) addLangChainDiagnostic(diagnostics, "LANGCHAIN_TOOL_NAME_MISMATCH", registrationAnalysis.path, inspected.agent.id, locateLangChainNode(registrationAnalysis, functionTool.tool.name.expression), capabilityId);
+			else if (registration === false) addLangChainDiagnostic(diagnostics, "LANGCHAIN_TOOL_REGISTRATION_NOT_WIRED", inspected.analysis.path, inspected.agent.id, inspected.definition.tools.kind === "present" ? locateLangChainNode(inspected.analysis, inspected.definition.tools.expression) : locateLangChainNode(inspected.analysis, inspected.definition.object), capabilityId);
+			else if (registration === true) evidence.push(createLangChainEvidence({
+				agentId: inspected.agent.id,
+				capabilityId,
+				capabilityKind: "tool",
+				details: {
+					helperSource: functionTool.tool.helperSource,
+					registrationForm: "normal-function-tool",
+					targetId: LANGCHAIN_TARGET_ID
+				},
+				kind: "tool-registration",
+				references: createRegistrationReferences(inspected, boundRegistrationReference, manifestTool, {
+					implementation,
+					inputSchema
+				}),
+				runtimeName,
+				source: LANGCHAIN_ADAPTER_ID
+			}));
+		}
+	}
+};
+//#endregion
+//#region src/inspection/inspection.ts
+var inspectAgent = async (session, agent, evidence, diagnostics) => {
+	const runtimeAgent = agent.declaration.bindings?.runtimeAgent;
+	if (runtimeAgent === void 0) return null;
+	const targetClassification = await inspectLangChainPackage(session, runtimeAgent.path, evidence, diagnostics, agent.id);
+	if (!isSupportedTypeScriptSourcePath(runtimeAgent.path)) return null;
+	const analysis = await analyzeLangChainBoundReference(session, runtimeAgent, diagnostics, agent.id);
+	if (analysis === null) return null;
+	evidence.push(createLangChainEvidence({
+		agentId: agent.id,
+		capabilityId: null,
+		capabilityKind: null,
+		details: { language: "typescript" },
+		kind: "language",
+		references: [runtimeAgent],
+		runtimeName: null,
+		source: LANGCHAIN_ADAPTER_ID
+	}));
+	if (targetClassification !== "supported" || runtimeAgent.symbol === void 0) return null;
+	const definition = getLangChainAgentDefinition(analysis, runtimeAgent.symbol);
+	if (definition.kind === "absent") {
+		addLangChainDiagnostic(diagnostics, "LANGCHAIN_RUNTIME_AGENT_SYMBOL_NOT_FOUND", runtimeAgent.path, agent.id);
+		return null;
+	}
+	if (definition.kind !== "present-supported") return null;
+	const staticName = definition.definition.name.kind === "present" ? await resolveLangChainStaticString(session, analysis, definition.definition.name.expression, (failure) => addLangChainSourceFailureDiagnostic(diagnostics, failure, agent.id)) : null;
+	const runtimeName = staticName?.kind === "supported" && isLangChainMachineString(staticName.value) ? staticName.value : null;
+	evidence.push(createLangChainEvidence({
+		agentId: agent.id,
+		capabilityId: null,
+		capabilityKind: null,
+		details: { targetId: LANGCHAIN_TARGET_ID },
+		kind: "agent-definition",
+		references: [runtimeAgent],
+		runtimeName,
+		source: LANGCHAIN_ADAPTER_ID
+	}));
+	return Object.freeze({
+		agent,
+		analysis,
+		definition: definition.definition
+	});
+};
+/**
+* Inspects all scoped LangChain agents through one deterministic operation-local session.
+* @param context The Core-provided immutable adapter context.
+* @returns A promise resolving to source-grounded evidence and diagnostics.
+* @throws
+* - INVALID_REPOSITORY_PATH: The repository path is invalid.
+* - ENTRY_NOT_FOUND: The requested repository entry was not found.
+* - ENTRY_NOT_FILE: The requested repository entry is not a file.
+* - ACCESS_DENIED: Access to the repository source was denied.
+* - SOURCE_UNAVAILABLE: The repository source is unavailable.
+* - SNAPSHOT_CHANGED: The repository snapshot changed during the operation.
+* - INVALID_SOURCE_DATA: The repository source returned invalid data.
+* - RESOURCE_LIMIT_EXCEEDED: A repository reading resource limit was exceeded.
+* - ABORTED: The repository operation or inspection signal was aborted.
+*/
+var inspectLangChain = async (context) => {
+	context.signal?.throwIfAborted();
+	const session = createLangChainInspectionSession(context);
+	const evidence = [];
+	const diagnostics = [];
+	const agents = [...context.agents].sort((left, right) => compareLangChainStrings(left.id, right.id));
+	const candidates = [];
+	for (const agent of agents) {
+		context.signal?.throwIfAborted();
+		const candidate = await inspectAgent(session, agent, evidence, diagnostics);
+		if (candidate !== null) candidates.push(candidate);
+	}
+	const inspectedAgents = [];
+	for (const candidate of candidates) {
+		context.signal?.throwIfAborted();
+		const relatedMiddleware = candidates.filter(({ analysis }) => analysis === candidate.analysis).map(({ definition }) => definition.middleware);
+		const middlewareState = await classifyLangChainMiddleware(session, candidate.analysis, candidate.definition.middleware, relatedMiddleware, diagnostics, candidate.agent.id);
+		inspectedAgents.push(Object.freeze({
+			...candidate,
+			middlewareState
+		}));
+	}
+	for (const inspected of inspectedAgents) {
+		context.signal?.throwIfAborted();
+		await inspectLangChainInstruction(session, inspected, evidence, diagnostics);
+		context.signal?.throwIfAborted();
+		await inspectLangChainOutputSchema(session, inspected, evidence, diagnostics);
+	}
+	context.signal?.throwIfAborted();
+	await inspectLangChainTools(session, inspectedAgents, evidence, diagnostics);
+	context.signal?.throwIfAborted();
+	return Object.freeze({
+		diagnostics: Object.freeze(diagnostics),
+		evidence: Object.freeze(evidence)
+	});
+};
+//#endregion
+//#region src/adapter/index.ts
+var langChainAdapter = Object.freeze({
+	id: LANGCHAIN_ADAPTER_ID,
+	inspect: inspectLangChain,
+	supportedRepositoryFormatVersions: LANGCHAIN_SUPPORTED_REPOSITORY_FORMAT_VERSIONS
+});
+//#endregion
+export { langChainAdapter };