@moldea.ai/adapter-openai-agents-sdk 1.0.0

package/dist/index.js

@@ -0,0 +1,1993 @@
+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 OPENAI_AGENTS_SDK_ADAPTER_ID = "openai-agents-sdk";
+var OPENAI_AGENTS_SDK_PACKAGE_NAME = "@openai/agents";
+var OPENAI_AGENTS_SDK_SUPPORTED_RANGE = ">=0.16.1 <0.17.0";
+var OPENAI_AGENTS_SDK_SUPPORTED_REPOSITORY_FORMAT_VERSIONS = Object.freeze([1]);
+var OPENAI_AGENTS_SDK_TOOL_NAME_PATTERN = /^[A-Za-z0-9_]+$/;
+//#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";
+};
+/**
+* Discovers the nearest package declaration without repository enumeration.
+* @param options The package target, repository callbacks, path, range, and signal.
+* @returns The first observed declaration, invalid manifest, or absence result.
+* @throws If repository reading or the active inspection is aborted.
+*/
+var discoverPackage = async (options) => {
+	const { packageName, reader, signal, sourcePath, supportedRange } = 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();
+		if (!isRecord(parsed)) return Object.freeze({
+			kind: "invalid",
+			path: manifestPath
+		});
+		const declarations = extractPackageDeclarations(parsed, packageName);
+		if (declarations === null) return Object.freeze({
+			kind: "invalid",
+			path: manifestPath
+		});
+		if (declarations.length === 0) return Object.freeze({ kind: "absent" });
+		return Object.freeze({
+			kind: "observed",
+			observation: Object.freeze({
+				compatibility: classifyPackageDeclarations(declarations, supportedRange),
+				declarations: Object.freeze(declarations),
+				path: manifestPath
+			})
+		});
+	}
+	return Object.freeze({ kind: "absent" });
+};
+/**
+* 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);
+};
+function getSafeModuleConstLiteral(expression, analysis, allowedReferences, kind) {
+	const candidate = unwrapExpression(expression);
+	if (!ts.isIdentifier(candidate) || !isModuleBindingVisible(candidate, analysis)) return null;
+	const declaration = analysis.moduleConstDeclarations.get(candidate.text);
+	const initializer = declaration?.initializer === void 0 ? null : unwrapExpression(declaration.initializer);
+	const isExpectedLiteral = initializer !== null && (kind === "array" ? ts.isArrayLiteralExpression(initializer) : ts.isObjectLiteralExpression(initializer));
+	if (declaration === void 0 || !isExpectedLiteral || !isModuleConstValueSafe(analysis, declaration, allowedReferences, kind)) return null;
+	return Object.freeze({
+		declaration,
+		expression: initializer
+	});
+}
+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) => [
+	".ts",
+	".tsx",
+	".mts"
+].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"
+	});
+};
+//#endregion
+//#region src/source-analysis/mutations.ts
+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 SDK object.
+* @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.
+* @returns Member-specific mutations and whether an unknown use can affect every relationship.
+*/
+var analyzeOpenAiAgentsSdkMutations = (analysis, declaration, allowedReferences) => {
+	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) 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)
+	});
+};
+//#endregion
+//#region src/source-analysis/agent-definitions.ts
+var RELATIONSHIP_NAMES = [
+	"handoffDescription",
+	"handoffs",
+	"instructions",
+	"name",
+	"outputType",
+	"tools"
+];
+var getStaticPropertyName$2 = (name) => ts.isIdentifier(name) || ts.isStringLiteral(name) ? name.text : null;
+var createAbsentRelationships = () => ({
+	handoffDescription: { kind: "absent" },
+	handoffs: { kind: "absent" },
+	instructions: { kind: "absent" },
+	name: { kind: "absent" },
+	outputType: { kind: "absent" },
+	tools: { kind: "absent" }
+});
+var markAllRelationshipsUnresolved = (relationships) => {
+	for (const relationshipName of RELATIONSHIP_NAMES) relationships[relationshipName] = { kind: "unresolved" };
+};
+var analyzeAgentRelationships = (config) => {
+	const relationships = createAbsentRelationships();
+	const relationshipNames = new Set(RELATIONSHIP_NAMES);
+	for (const property of config.properties) {
+		if (ts.isSpreadAssignment(property) || ts.isComputedPropertyName(property.name)) {
+			markAllRelationshipsUnresolved(relationships);
+			continue;
+		}
+		const propertyName = getStaticPropertyName$2(property.name);
+		if (propertyName === null || !relationshipNames.has(propertyName)) continue;
+		const relationshipName = propertyName;
+		if (relationships[relationshipName].kind !== "absent") {
+			relationships[relationshipName] = { kind: "unresolved" };
+			continue;
+		}
+		if (ts.isPropertyAssignment(property)) relationships[relationshipName] = {
+			expression: unwrapExpression(property.initializer),
+			kind: "present"
+		};
+		else if (ts.isShorthandPropertyAssignment(property)) relationships[relationshipName] = {
+			expression: property.name,
+			kind: "present"
+		};
+		else relationships[relationshipName] = { kind: "unresolved" };
+	}
+	return relationships;
+};
+var getAgentConfig = (initializer, analysis) => {
+	const candidate = unwrapExpression(initializer);
+	let callArguments;
+	if (ts.isNewExpression(candidate)) {
+		const constructor = unwrapExpression(candidate.expression);
+		if (!ts.isIdentifier(constructor) || !analysis.imports.agentNames.has(constructor.text) || !isModuleBindingVisible(constructor, analysis)) return null;
+		callArguments = candidate.arguments;
+	} else if (ts.isCallExpression(candidate)) {
+		const callee = unwrapExpression(candidate.expression);
+		if (!ts.isPropertyAccessExpression(callee) || callee.name.text !== "create" || !ts.isIdentifier(unwrapExpression(callee.expression))) return null;
+		const agentIdentifier = unwrapExpression(callee.expression);
+		if (!analysis.imports.agentNames.has(agentIdentifier.text) || !isModuleBindingVisible(agentIdentifier, analysis)) return null;
+		callArguments = candidate.arguments;
+	} else return null;
+	if (callArguments?.length !== 1) return null;
+	const config = unwrapExpression(callArguments[0]);
+	return ts.isObjectLiteralExpression(config) ? config : null;
+};
+/**
+* Classifies one directly exported Agent binding and its relationship-specific configuration.
+* @param analysis The indexed source module.
+* @param symbol The exact exported Agent symbol.
+* @returns The absent, unsupported, or supported definition state.
+*/
+var getOpenAiAgentsSdkAgentDefinition = (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 config = getAgentConfig(exported.declaration.initializer, analysis);
+	if (config === null) return Object.freeze({
+		declaration: exported.declaration,
+		kind: "present-unsupported"
+	});
+	const relationships = analyzeAgentRelationships(config);
+	const definition = Object.freeze({
+		config,
+		declaration: exported.declaration,
+		...relationships
+	});
+	return Object.freeze({
+		config,
+		declaration: exported.declaration,
+		definition,
+		kind: "present-supported"
+	});
+};
+/**
+* Applies relationship-specific post-construction Agent mutation uncertainty.
+* @param analysis The Agent source analysis.
+* @param definition The supported initial Agent definition.
+* @param allowedTargetReferences Direct uses as supported handoff targets.
+* @returns The definition with only affected relationships marked unresolved.
+*/
+var applyOpenAiAgentsSdkAgentMutations = (analysis, definition, allowedTargetReferences) => {
+	const mutations = analyzeOpenAiAgentsSdkMutations(analysis, definition.declaration, allowedTargetReferences);
+	if (!mutations.hasUnknownMutation && mutations.mutatedMembers.size === 0) return definition;
+	const relationship = (name) => mutations.hasUnknownMutation || mutations.mutatedMembers.has(name) ? { kind: "unresolved" } : definition[name];
+	return Object.freeze({
+		...definition,
+		handoffDescription: relationship("handoffDescription"),
+		handoffs: relationship("handoffs"),
+		instructions: relationship("instructions"),
+		name: relationship("name"),
+		outputType: relationship("outputType"),
+		tools: relationship("tools")
+	});
+};
+//#endregion
+//#region src/source-analysis/bindings.ts
+/**
+* Classifies a direct relationship to one explicitly bound runtime symbol.
+* @param relationship The supported configuration relationship.
+* @param analysis The source containing the relationship.
+* @param reference The exact manifest binding.
+* @returns `true` for a match, `false` for proved absence, or `null` when unresolved.
+*/
+var classifyOpenAiAgentsSdkDirectBinding = (relationship, analysis, reference) => {
+	if (relationship.kind === "absent") return false;
+	if (relationship.kind === "unresolved" || reference.symbol === void 0) return null;
+	const candidate = unwrapExpression(relationship.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 ? false : null;
+	if (isBoundIdentifier(candidate, analysis, reference)) return true;
+	return resolveBindingReferences(candidate, analysis).length > 0 ? false : null;
+};
+//#endregion
+//#region src/source-analysis/function-tools.ts
+var REQUIRED_PROPERTIES = /* @__PURE__ */ new Set([
+	"description",
+	"execute",
+	"name",
+	"parameters"
+]);
+var SUPPORTED_PROPERTIES = /* @__PURE__ */ new Set([
+	...REQUIRED_PROPERTIES,
+	"allowedCallers",
+	"customDataExtractor",
+	"deferLoading",
+	"errorFunction",
+	"inputGuardrails",
+	"isEnabled",
+	"needsApproval",
+	"outputGuardrails",
+	"outputSchema",
+	"providerData",
+	"strict",
+	"timeoutBehavior",
+	"timeoutErrorFunction",
+	"timeoutMs"
+]);
+var getStaticPropertyName$1 = (name) => ts.isIdentifier(name) || ts.isStringLiteral(name) ? name.text : null;
+var createRelationship = (properties, name) => {
+	const expression = properties.get(name);
+	return expression === void 0 ? { kind: "absent" } : {
+		expression,
+		kind: "present"
+	};
+};
+var getToolProperties = (object) => {
+	const properties = /* @__PURE__ */ new Map();
+	for (const property of object.properties) {
+		if (!ts.isPropertyAssignment(property) || ts.isComputedPropertyName(property.name)) return null;
+		const propertyName = getStaticPropertyName$1(property.name);
+		if (propertyName === null || !SUPPORTED_PROPERTIES.has(propertyName) || properties.has(propertyName)) return null;
+		properties.set(propertyName, unwrapExpression(property.initializer));
+	}
+	return [...REQUIRED_PROPERTIES].every((propertyName) => properties.has(propertyName)) ? properties : null;
+};
+/**
+* Classifies one directly exported root tool(...) declaration.
+* @param analysis The indexed tool source.
+* @param symbol The exact exported tool registration symbol.
+* @returns The absent, unsupported, or structurally supported function-tool state.
+*/
+var getOpenAiAgentsSdkFunctionTool = (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 initializer = unwrapExpression(exported.declaration.initializer);
+	if (!ts.isCallExpression(initializer) || initializer.arguments.length !== 1) return Object.freeze({
+		declaration: exported.declaration,
+		kind: "present-unsupported"
+	});
+	const helper = unwrapExpression(initializer.expression);
+	if (!ts.isIdentifier(helper) || !analysis.imports.toolNames.has(helper.text) || !isModuleBindingVisible(helper, analysis)) return Object.freeze({
+		declaration: exported.declaration,
+		kind: "present-unsupported"
+	});
+	const object = unwrapExpression(initializer.arguments[0]);
+	if (!ts.isObjectLiteralExpression(object)) return Object.freeze({
+		declaration: exported.declaration,
+		kind: "present-unsupported"
+	});
+	const properties = getToolProperties(object);
+	if (properties === null) return Object.freeze({
+		declaration: exported.declaration,
+		kind: "present-unsupported"
+	});
+	const tool = Object.freeze({
+		declaration: exported.declaration,
+		execute: createRelationship(properties, "execute"),
+		name: properties.get("name"),
+		object,
+		outputSchema: createRelationship(properties, "outputSchema"),
+		parameters: createRelationship(properties, "parameters")
+	});
+	return Object.freeze({
+		kind: "present-supported",
+		tool
+	});
+};
+//#endregion
+//#region src/source-analysis/handoffs.ts
+var RECOGNIZED_OVERRIDE_NAMES = ["toolDescriptionOverride", "toolNameOverride"];
+var TOLERATED_CONFIG_NAMES = /* @__PURE__ */ new Set([
+	"inputFilter",
+	"inputType",
+	"isEnabled",
+	"onHandoff",
+	...RECOGNIZED_OVERRIDE_NAMES
+]);
+var getStaticPropertyName = (name) => ts.isIdentifier(name) || ts.isStringLiteral(name) ? name.text : null;
+var analyzeHandoffConfig = (expression) => {
+	const relationships = {
+		toolDescriptionOverride: { kind: "absent" },
+		toolNameOverride: { kind: "absent" }
+	};
+	if (expression === void 0) return relationships;
+	const config = unwrapExpression(expression);
+	if (!ts.isObjectLiteralExpression(config)) {
+		relationships.toolDescriptionOverride = { kind: "unresolved" };
+		relationships.toolNameOverride = { kind: "unresolved" };
+		return relationships;
+	}
+	for (const property of config.properties) {
+		if (ts.isSpreadAssignment(property) || ts.isComputedPropertyName(property.name)) {
+			relationships.toolDescriptionOverride = { kind: "unresolved" };
+			relationships.toolNameOverride = { kind: "unresolved" };
+			continue;
+		}
+		const propertyName = getStaticPropertyName(property.name);
+		if (propertyName === null || !TOLERATED_CONFIG_NAMES.has(propertyName)) {
+			relationships.toolDescriptionOverride = { kind: "unresolved" };
+			relationships.toolNameOverride = { kind: "unresolved" };
+			continue;
+		}
+		if (!RECOGNIZED_OVERRIDE_NAMES.includes(propertyName)) continue;
+		const relationshipName = propertyName;
+		if (relationships[relationshipName].kind !== "absent") relationships[relationshipName] = { kind: "unresolved" };
+		else if (ts.isPropertyAssignment(property)) relationships[relationshipName] = {
+			expression: unwrapExpression(property.initializer),
+			kind: "present"
+		};
+		else if (ts.isShorthandPropertyAssignment(property)) relationships[relationshipName] = {
+			expression: property.name,
+			kind: "present"
+		};
+		else relationships[relationshipName] = { kind: "unresolved" };
+	}
+	return relationships;
+};
+var analyzeHandoffCall = (expression, analysis) => {
+	const candidate = unwrapExpression(expression);
+	if (!ts.isCallExpression(candidate) || candidate.arguments.length < 1 || candidate.arguments.length > 2) return null;
+	const helper = unwrapExpression(candidate.expression);
+	if (!ts.isIdentifier(helper) || !analysis.imports.handoffNames.has(helper.text) || !isModuleBindingVisible(helper, analysis)) return null;
+	const target = unwrapExpression(candidate.arguments[0]);
+	if (!ts.isIdentifier(target) || !isModuleBindingVisible(target, analysis)) return null;
+	return Object.freeze({
+		expression: candidate,
+		kind: "handoff",
+		target,
+		...analyzeHandoffConfig(candidate.arguments[1])
+	});
+};
+var getClosedHandoffArray = (relationship, analysis, allowedCollectionReferences) => {
+	if (relationship.kind !== "present") return null;
+	const candidate = unwrapExpression(relationship.expression);
+	const moduleArray = ts.isArrayLiteralExpression(candidate) ? null : getSafeModuleConstLiteral(candidate, analysis, allowedCollectionReferences, "array");
+	const array = ts.isArrayLiteralExpression(candidate) ? candidate : moduleArray?.expression;
+	if (array === void 0 || array.elements.some((element) => ts.isOmittedExpression(element) || ts.isSpreadElement(element))) return null;
+	return array.elements.map((element) => unwrapExpression(element));
+};
+/** Collects direct module-array references from supported Agent handoff relationships. */
+var collectOpenAiAgentsSdkHandoffCollectionReferences = (relationships) => new Set(relationships.flatMap((relationship) => {
+	if (relationship.kind !== "present") return [];
+	const candidate = unwrapExpression(relationship.expression);
+	return ts.isIdentifier(candidate) ? [candidate] : [];
+}));
+/**
+* Returns every supported expression in one closed Agent handoff collection.
+* @param relationship The Agent handoffs relationship.
+* @param analysis The source containing the collection.
+* @param allowedCollectionReferences All supported references to shared module arrays.
+* @returns Closed collection elements or `null` when the collection is unresolved.
+*/
+var getOpenAiAgentsSdkHandoffElements = (relationship, analysis, allowedCollectionReferences) => getClosedHandoffArray(relationship, analysis, allowedCollectionReferences);
+/**
+* Classifies one direct Agent or handoff(...) registration element.
+* @param element The closed collection element.
+* @param analysis The source containing the element.
+* @param allowedWrapperReferences All direct supported collection uses of module wrappers.
+* @returns The supported registration or `null` for an unresolved target form.
+*/
+var analyzeOpenAiAgentsSdkHandoffElement = (element, analysis, allowedWrapperReferences) => {
+	const directCall = analyzeHandoffCall(element, analysis);
+	if (directCall !== null) return directCall;
+	const candidate = unwrapExpression(element);
+	if (!ts.isIdentifier(candidate) || !isModuleBindingVisible(candidate, analysis)) return null;
+	const declaration = analysis.moduleConstDeclarations.get(candidate.text);
+	if (declaration?.initializer !== void 0) {
+		const wrapper = analyzeHandoffCall(declaration.initializer, analysis);
+		if (wrapper !== null) {
+			const mutations = analyzeOpenAiAgentsSdkMutations(analysis, declaration, allowedWrapperReferences);
+			if (mutations.hasUnknownMutation || mutations.mutatedMembers.has("onInvokeHandoff")) return null;
+			const toolDescriptionOverride = mutations.mutatedMembers.has("toolDescription") ? { kind: "unresolved" } : wrapper.toolDescriptionOverride;
+			const toolNameOverride = mutations.mutatedMembers.has("toolName") ? { kind: "unresolved" } : wrapper.toolNameOverride;
+			return Object.freeze({
+				...wrapper,
+				expression: candidate,
+				toolDescriptionOverride,
+				toolNameOverride
+			});
+		}
+	}
+	return Object.freeze({
+		expression: candidate,
+		kind: "agent",
+		target: candidate,
+		toolDescriptionOverride: { kind: "absent" },
+		toolNameOverride: { kind: "absent" }
+	});
+};
+/**
+* Collects Agent identifier uses that are mechanically supported handoff targets.
+* @param analysis The source containing Agent definitions and handoff collections.
+* @returns Exact target identifiers allowed by Agent mutation analysis.
+*/
+var collectOpenAiAgentsSdkHandoffTargetReferences = (analysis) => {
+	const definitions = [...analysis.exports.keys()].flatMap((symbol) => {
+		const result = getOpenAiAgentsSdkAgentDefinition(analysis, symbol);
+		return result.kind === "present-supported" && result.definition !== void 0 ? [result.definition] : [];
+	});
+	const collectionReferences = collectOpenAiAgentsSdkHandoffCollectionReferences(definitions.map(({ handoffs }) => handoffs));
+	const elements = definitions.flatMap(({ handoffs }) => getOpenAiAgentsSdkHandoffElements(handoffs, analysis, collectionReferences) ?? []);
+	const allowedWrapperReferences = new Set(elements.filter((element) => ts.isIdentifier(element)));
+	const targets = /* @__PURE__ */ new Set();
+	for (const element of elements) {
+		const registration = analyzeOpenAiAgentsSdkHandoffElement(element, analysis, allowedWrapperReferences);
+		if (registration !== null && ts.isIdentifier(registration.target)) targets.add(registration.target);
+	}
+	return targets;
+};
+//#endregion
+//#region src/source-analysis/instruction-loaders.ts
+var getWrapperReturn = (expression) => {
+	const candidate = unwrapExpression(expression);
+	if (!ts.isArrowFunction(candidate) && !ts.isFunctionExpression(candidate)) return null;
+	if (!ts.isBlock(candidate.body)) return candidate.body;
+	if (candidate.body.statements.length !== 1) return null;
+	const statement = candidate.body.statements[0];
+	return statement !== void 0 && ts.isReturnStatement(statement) && statement.expression !== void 0 ? statement.expression : null;
+};
+var classifyCall = (expression, analysis, reference) => {
+	const call = getDirectCall(expression);
+	if (call === null) return null;
+	const callee = unwrapExpression(call.expression);
+	if (!ts.isIdentifier(callee) || !isModuleBindingVisible(callee, analysis)) return null;
+	if (isBoundIdentifier(callee, analysis, reference)) return true;
+	return resolveBindingReferences(callee, analysis).length > 0 ? false : null;
+};
+/**
+* Classifies the supported direct, called, or single-return instruction-loader relationship.
+* @param relationship The Agent instructions relationship.
+* @param analysis The source containing the Agent definition.
+* @param reference The exact declared instruction-loader binding.
+* @returns `true` for wired, `false` for provably unwired, or `null` when unresolved.
+*/
+var classifyOpenAiAgentsSdkInstructionLoader = (relationship, analysis, reference) => {
+	if (relationship.kind === "absent") return false;
+	if (relationship.kind === "unresolved" || reference.symbol === void 0) return null;
+	const candidate = unwrapExpression(relationship.expression);
+	if (ts.isIdentifier(candidate) && isModuleBindingVisible(candidate, analysis)) {
+		if (isBoundIdentifier(candidate, analysis, reference)) return true;
+		return resolveBindingReferences(candidate, analysis).length > 0 ? false : null;
+	}
+	const directCall = classifyCall(candidate, analysis, reference);
+	if (directCall !== null) return directCall;
+	const wrapperReturn = getWrapperReturn(candidate);
+	if (wrapperReturn !== null) return classifyCall(wrapperReturn, analysis, reference);
+	return ts.isStringLiteral(candidate) || ts.isNoSubstitutionTemplateLiteral(candidate) || ts.isNumericLiteral(candidate) || candidate.kind === ts.SyntaxKind.NullKeyword || candidate.kind === ts.SyntaxKind.TrueKeyword || candidate.kind === ts.SyntaxKind.FalseKeyword ? false : null;
+};
+//#endregion
+//#region src/source-analysis/source-analysis.ts
+var OPENAI_AGENTS_SDK_IMPORT_CONFIG = Object.freeze({
+	namedConstructorImports: ["Agent"],
+	packageName: OPENAI_AGENTS_SDK_PACKAGE_NAME,
+	supportsDefaultConstructorImport: false
+});
+var indexOpenAiAgentsSdkImports = (sourceFile) => {
+	const agentNames = /* @__PURE__ */ new Set();
+	const handoffNames = /* @__PURE__ */ new Set();
+	const toolNames = /* @__PURE__ */ new Set();
+	for (const statement of sourceFile.statements) {
+		if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier) || statement.moduleSpecifier.text !== "@openai/agents" || statement.importClause?.isTypeOnly === true || statement.importClause?.namedBindings === void 0 || !ts.isNamedImports(statement.importClause.namedBindings)) continue;
+		for (const element of statement.importClause.namedBindings.elements) {
+			if (element.isTypeOnly) continue;
+			const importedName = element.propertyName?.text ?? element.name.text;
+			if (importedName === "Agent") agentNames.add(element.name.text);
+			else if (importedName === "handoff") handoffNames.add(element.name.text);
+			else if (importedName === "tool") toolNames.add(element.name.text);
+		}
+	}
+	return Object.freeze({
+		agentNames,
+		handoffNames,
+		toolNames
+	});
+};
+/**
+* Parses and indexes one OpenAI Agents SDK TypeScript module without executing it.
+* @param path The normalized repository source path.
+* @param bytes The exact repository bytes.
+* @param signal The active inspection signal.
+* @returns The source analysis or a stable invalid source result.
+*/
+var analyzeOpenAiAgentsSdkSource = (path, bytes, signal) => {
+	const result = analyzeTypeScriptModule(path, bytes, OPENAI_AGENTS_SDK_IMPORT_CONFIG, signal);
+	if (result.kind !== "valid") return result;
+	const analysis = Object.freeze({
+		...result.analysis,
+		imports: indexOpenAiAgentsSdkImports(result.analysis.sourceFile),
+		path
+	});
+	return Object.freeze({
+		analysis,
+		kind: "valid"
+	});
+};
+//#endregion
+//#region src/source-analysis/static-strings.ts
+var resolveCandidatePath = async (session, containingPath, moduleSpecifier) => {
+	const matchingPaths = [];
+	for (const candidate of resolveImportCandidatePaths(containingPath, moduleSpecifier)) {
+		const path = parseRepositoryPath(candidate);
+		if ((await session.getEntry(path))?.type === "file") matchingPaths.push(path);
+	}
+	return matchingPaths.length === 1 ? matchingPaths[0] : null;
+};
+var resolveStaticString = async (session, analysis, expression, visited) => {
+	session.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 resolveStaticString(session, 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(session, 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 session.analyzeSource(importedPath);
+	if (importedResult.kind !== "valid") {
+		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 resolveStaticString(session, importedResult.analysis, exported.expression, visited);
+	visited.delete(key);
+	return result;
+};
+/**
+* Resolves one exact supported static string without normalization or execution.
+* @param session The operation-local source session.
+* @param analysis The source containing the expression.
+* @param expression The candidate static string expression.
+* @returns The exact compiler-parsed string or an unsupported state.
+*/
+var resolveOpenAiAgentsSdkStaticString = (session, analysis, expression) => resolveStaticString(session, analysis, expression, /* @__PURE__ */ new Set());
+//#endregion
+//#region src/source-analysis/tool-collections.ts
+var getClosedToolArray = (relationship, analysis, allowedCollectionReferences) => {
+	if (relationship.kind !== "present") return null;
+	const candidate = unwrapExpression(relationship.expression);
+	const moduleArray = ts.isArrayLiteralExpression(candidate) ? null : getSafeModuleConstLiteral(candidate, analysis, allowedCollectionReferences, "array");
+	const array = ts.isArrayLiteralExpression(candidate) ? candidate : moduleArray?.expression;
+	if (array === void 0 || array.elements.some((element) => ts.isOmittedExpression(element) || ts.isSpreadElement(element))) return null;
+	return array.elements.map((element) => unwrapExpression(element));
+};
+/**
+* Collects module-array references that are direct supported Agent tool relationships.
+* @param relationships Agent tool relationships in one source module.
+* @returns Bare collection identifiers allowed to share one immutable module array.
+*/
+var collectOpenAiAgentsSdkToolCollectionReferences = (relationships) => new Set(relationships.flatMap((relationship) => {
+	if (relationship.kind !== "present") return [];
+	const candidate = unwrapExpression(relationship.expression);
+	return ts.isIdentifier(candidate) ? [candidate] : [];
+}));
+/**
+* Classifies whether one declared function tool appears in a closed Agent tools collection.
+* @param relationship The Agent tools relationship.
+* @param analysis The Agent source analysis.
+* @param reference The exact declared tool registration binding.
+* @param allowedCollectionReferences All supported references to shared module arrays.
+* @returns `true` for registered, `false` for proved absence, or `null` when unresolved.
+*/
+var classifyOpenAiAgentsSdkToolRegistration = (relationship, analysis, reference, allowedCollectionReferences) => {
+	if (relationship.kind === "absent") return false;
+	if (relationship.kind === "unresolved" || reference.symbol === void 0) return null;
+	const elements = getClosedToolArray(relationship, analysis, allowedCollectionReferences);
+	if (elements === null) return null;
+	let hasUnresolvedElement = false;
+	for (const element of elements) {
+		if (!ts.isIdentifier(element) || !isModuleBindingVisible(element, analysis)) {
+			hasUnresolvedElement = true;
+			continue;
+		}
+		if (isBoundIdentifier(element, analysis, reference)) return true;
+		if (resolveBindingReferences(element, analysis).length === 0) hasUnresolvedElement = true;
+	}
+	return hasUnresolvedElement ? null : false;
+};
+/**
+* Returns identifier elements from one supported tools collection.
+* @param relationship The Agent tools relationship.
+* @param analysis The source containing the collection.
+* @param allowedCollectionReferences All supported references to shared module arrays.
+* @returns Direct identifier elements or an empty collection for unsupported forms.
+*/
+var getOpenAiAgentsSdkToolElements = (relationship, analysis, allowedCollectionReferences) => (getClosedToolArray(relationship, analysis, allowedCollectionReferences) ?? []).filter((element) => ts.isIdentifier(element));
+//#endregion
+//#region src/diagnostics/index.ts
+var OPENAI_AGENTS_SDK_ADAPTER_DIAGNOSTICS = Object.freeze({
+	OPENAI_AGENTS_SDK_AGENT_OUTPUT_SCHEMA_NOT_WIRED: "The declared agent output schema is not wired to the detected OpenAI Agents SDK agent output type.",
+	OPENAI_AGENTS_SDK_AGENT_OUTPUT_SCHEMA_SYMBOL_NOT_FOUND: "The declared agent output-schema symbol was not found.",
+	OPENAI_AGENTS_SDK_HANDOFF_ROUTING_DESCRIPTION_MISSING: "The detected OpenAI Agents SDK handoff registration is missing its effective routing description.",
+	OPENAI_AGENTS_SDK_HANDOFF_ROUTING_DESCRIPTION_NOT_WIRED: "The detected OpenAI Agents SDK handoff registration does not use the target agent's effective routing description.",
+	OPENAI_AGENTS_SDK_HANDOFF_TARGET_AMBIGUOUS: "The detected OpenAI Agents SDK handoff target matches more than one registered moldea agent.",
+	OPENAI_AGENTS_SDK_INSTRUCTION_LOADER_NOT_WIRED: "The declared instruction loader is not wired to the detected OpenAI Agents SDK agent.",
+	OPENAI_AGENTS_SDK_INSTRUCTION_LOADER_SYMBOL_NOT_FOUND: "The declared instruction-loader symbol was not found.",
+	OPENAI_AGENTS_SDK_PACKAGE_MANIFEST_INVALID: "The owning package manifest is invalid for OpenAI Agents SDK dependency detection.",
+	OPENAI_AGENTS_SDK_RUNTIME_AGENT_SYMBOL_NOT_FOUND: "The declared runtime-agent symbol was not found.",
+	OPENAI_AGENTS_SDK_SOURCE_SYNTAX_INVALID: "The referenced OpenAI Agents SDK source file contains invalid TypeScript syntax.",
+	OPENAI_AGENTS_SDK_SOURCE_TEXT_INVALID: "The referenced OpenAI Agents SDK source file is not valid normalized text.",
+	OPENAI_AGENTS_SDK_TOOL_IMPLEMENTATION_NOT_WIRED: "The declared tool implementation is not wired to the detected OpenAI Agents SDK function tool.",
+	OPENAI_AGENTS_SDK_TOOL_IMPLEMENTATION_SYMBOL_NOT_FOUND: "The declared tool-implementation symbol was not found.",
+	OPENAI_AGENTS_SDK_TOOL_INPUT_SCHEMA_NOT_WIRED: "The declared tool input schema is not wired to the detected OpenAI Agents SDK function tool.",
+	OPENAI_AGENTS_SDK_TOOL_INPUT_SCHEMA_SYMBOL_NOT_FOUND: "The declared tool input-schema symbol was not found.",
+	OPENAI_AGENTS_SDK_TOOL_NAME_MISMATCH: "The declared tool name does not match the detected OpenAI Agents SDK function-tool name.",
+	OPENAI_AGENTS_SDK_TOOL_OUTPUT_SCHEMA_NOT_WIRED: "The declared tool output schema is not wired to the detected OpenAI Agents SDK function tool.",
+	OPENAI_AGENTS_SDK_TOOL_OUTPUT_SCHEMA_SYMBOL_NOT_FOUND: "The declared tool output-schema symbol was not found.",
+	OPENAI_AGENTS_SDK_TOOL_REGISTRATION_NOT_WIRED: "The declared tool registration is not wired to the detected OpenAI Agents SDK agent.",
+	OPENAI_AGENTS_SDK_TOOL_REGISTRATION_SYMBOL_NOT_FOUND: "The declared tool-registration symbol was not found.",
+	OPENAI_AGENTS_SDK_VERSION_UNSUPPORTED: "The observed OpenAI Agents SDK dependency range is disjoint from the supported range."
+});
+/**
+* Creates one frozen, safely namespaced OpenAI Agents SDK adapter diagnostic.
+* @param input The complete code, location, entity, and safe scalar details.
+* @returns The immutable adapter diagnostic.
+*/
+var createOpenAiAgentsSdkDiagnostic = (input) => Object.freeze({
+	...input,
+	details: Object.freeze({ ...input.details }),
+	entity: input.entity === null ? null : Object.freeze({ ...input.entity }),
+	message: OPENAI_AGENTS_SDK_ADAPTER_DIAGNOSTICS[input.code],
+	source: OPENAI_AGENTS_SDK_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 compareOpenAiAgentsSdkStrings = (left, right) => left < right ? -1 : left > right ? 1 : 0;
+/** Determines whether a runtime-visible value satisfies Core's machine-string contract. */
+var isOpenAiAgentsSdkMachineString = (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 OpenAI Agents SDK evidence record. */
+var createOpenAiAgentsSdkEvidence = (evidence) => Object.freeze({
+	...evidence,
+	details: Object.freeze({ ...evidence.details }),
+	references: Object.freeze(evidence.references.map(freezeReference))
+});
+var createEntity = (agentId, capabilityId) => Object.freeze({
+	adapterId: OPENAI_AGENTS_SDK_ADAPTER_ID,
+	agentId,
+	...capabilityId === void 0 ? {} : {
+		capabilityId,
+		capabilityKind: "tool"
+	}
+});
+/**
+* Appends one stable package-owned diagnostic.
+* @param diagnostics The operation result collection.
+* @param code The stable diagnostic code.
+* @param path The exact affected path.
+* @param agentId The owning source-agent identifier.
+* @param range The optional scalar source range.
+* @param capabilityId The optional owning tool capability.
+* @param details Safe scalar diagnostic details.
+*/
+var addOpenAiAgentsSdkDiagnostic = (diagnostics, code, path, agentId, range = null, capabilityId, details = {}) => {
+	diagnostics.push(createOpenAiAgentsSdkDiagnostic({
+		code,
+		details,
+		entity: createEntity(agentId, capabilityId),
+		path,
+		pointer: null,
+		range
+	}));
+};
+/** Returns the Core scalar range for one node in its analyzed source. */
+var locateOpenAiAgentsSdkNode = (analysis, node) => analysis.text.locator.locateRange(node.getStart(analysis.sourceFile), node.getEnd());
+/**
+* Loads and validates one supported bound TypeScript source.
+* @param session The operation-local inspection session.
+* @param reference The exact manifest reference.
+* @param diagnostics The operation result collection.
+* @param agentId The owning agent identifier.
+* @param capabilityId The optional owning tool capability.
+* @returns The indexed source or `null` after unsupported or invalid input.
+*/
+var analyzeOpenAiAgentsSdkBoundReference = async (session, reference, diagnostics, agentId, capabilityId) => {
+	if (!isSupportedTypeScriptSourcePath(reference.path)) return null;
+	const result = await session.analyzeSource(reference.path);
+	if (result.kind === "invalid-text") {
+		addOpenAiAgentsSdkDiagnostic(diagnostics, "OPENAI_AGENTS_SDK_SOURCE_TEXT_INVALID", reference.path, agentId, null, capabilityId);
+		return null;
+	}
+	if (result.kind === "invalid-syntax") {
+		addOpenAiAgentsSdkDiagnostic(diagnostics, "OPENAI_AGENTS_SDK_SOURCE_SYNTAX_INVALID", reference.path, agentId, result.range, capabilityId);
+		return null;
+	}
+	return result.analysis;
+};
+//#endregion
+//#region src/inspection/handoffs.ts
+var getLocalAgentDefinitions = (analysis) => [...analysis.exports.keys()].flatMap((symbol) => {
+	const result = getOpenAiAgentsSdkAgentDefinition(analysis, symbol);
+	return result.kind === "present-supported" && result.definition !== void 0 ? [result.definition] : [];
+});
+var resolveTarget = async (session, sourceAnalysis, expression) => {
+	const candidate = unwrapExpression(expression);
+	if (!ts.isIdentifier(candidate)) return null;
+	const resolvedTargets = [];
+	for (const reference of resolveBindingReferences(candidate, sourceAnalysis)) {
+		const path = parseRepositoryPath(reference.path);
+		if ((await session.getEntry(path))?.type !== "file") continue;
+		const sourceResult = await session.analyzeSource(path);
+		if (sourceResult.kind !== "valid") continue;
+		const definitionResult = getOpenAiAgentsSdkAgentDefinition(sourceResult.analysis, reference.symbol);
+		if (definitionResult.kind !== "present-supported" || definitionResult.definition === void 0) continue;
+		const definition = applyOpenAiAgentsSdkAgentMutations(sourceResult.analysis, definitionResult.definition, collectOpenAiAgentsSdkHandoffTargetReferences(sourceResult.analysis));
+		const staticName = definition.name.kind === "present" ? await resolveOpenAiAgentsSdkStaticString(session, sourceResult.analysis, definition.name.expression) : { kind: "unsupported" };
+		resolvedTargets.push(Object.freeze({
+			analysis: sourceResult.analysis,
+			definition,
+			path,
+			runtimeName: staticName.kind === "supported" && isOpenAiAgentsSdkMachineString(staticName.value) ? staticName.value : null,
+			symbol: reference.symbol
+		}));
+	}
+	return resolvedTargets.length === 1 ? resolvedTargets[0] : null;
+};
+var getMappedAgents = (context, target) => context.project.agents.filter(({ declaration }) => {
+	const runtimeAgent = declaration.bindings?.runtimeAgent;
+	return runtimeAgent?.path === target.path && runtimeAgent.symbol === target.symbol;
+});
+var getSafeDetails = (registration, routingDescriptionSource, target, targetAgentId) => ({
+	registrationKind: registration.kind,
+	routingDescriptionSource,
+	...targetAgentId === void 0 ? {} : { targetAgentId },
+	...target.runtimeName === null ? {} : { targetRuntimeName: target.runtimeName }
+});
+var getAmbiguousTargetDetails = (registration, target) => ({
+	registrationKind: registration.kind,
+	...target.runtimeName === null ? {} : { targetRuntimeName: target.runtimeName }
+});
+var getRuntimeName = async (session, sourceAnalysis, registration) => {
+	if (registration.toolNameOverride.kind !== "present") return null;
+	const result = await resolveOpenAiAgentsSdkStaticString(session, sourceAnalysis, registration.toolNameOverride.expression);
+	return result.kind === "supported" && isOpenAiAgentsSdkMachineString(result.value) ? result.value : null;
+};
+var inspectRoutingDescription = async (session, sourceAgent, sourceAnalysis, registration, target, targetAgent, diagnostics) => {
+	const canonicalDescription = targetAgent.handoffDescription?.value ?? targetAgent.description.value;
+	if (registration.toolDescriptionOverride.kind === "unresolved") return "unresolved";
+	if (registration.toolDescriptionOverride.kind === "present") {
+		const override = await resolveOpenAiAgentsSdkStaticString(session, sourceAnalysis, registration.toolDescriptionOverride.expression);
+		if (override.kind !== "supported") return "unresolved";
+		if (override.value.length > 0) {
+			if (override.value !== canonicalDescription) addOpenAiAgentsSdkDiagnostic(diagnostics, "OPENAI_AGENTS_SDK_HANDOFF_ROUTING_DESCRIPTION_NOT_WIRED", sourceAnalysis.path, sourceAgent.id, locateOpenAiAgentsSdkNode(sourceAnalysis, registration.toolDescriptionOverride.expression), void 0, getSafeDetails(registration, "override", target, targetAgent.id));
+			return "override";
+		}
+	}
+	if (target.definition.handoffDescription.kind === "unresolved") return "unresolved";
+	if (target.definition.handoffDescription.kind === "absent") {
+		addOpenAiAgentsSdkDiagnostic(diagnostics, "OPENAI_AGENTS_SDK_HANDOFF_ROUTING_DESCRIPTION_MISSING", target.path, sourceAgent.id, locateOpenAiAgentsSdkNode(target.analysis, target.definition.declaration), void 0, getSafeDetails(registration, "target", target, targetAgent.id));
+		return "target";
+	}
+	const description = await resolveOpenAiAgentsSdkStaticString(session, target.analysis, target.definition.handoffDescription.expression);
+	if (description.kind !== "supported") return "unresolved";
+	const diagnosticCode = description.value.length === 0 ? "OPENAI_AGENTS_SDK_HANDOFF_ROUTING_DESCRIPTION_MISSING" : description.value !== canonicalDescription ? "OPENAI_AGENTS_SDK_HANDOFF_ROUTING_DESCRIPTION_NOT_WIRED" : null;
+	if (diagnosticCode !== null) addOpenAiAgentsSdkDiagnostic(diagnostics, diagnosticCode, target.path, sourceAgent.id, locateOpenAiAgentsSdkNode(target.analysis, target.definition.handoffDescription.expression), void 0, getSafeDetails(registration, "target", target, targetAgent.id));
+	return "target";
+};
+/** Inspects runtime-native handoff registrations and routing-description wiring. */
+var inspectOpenAiAgentsSdkHandoffs = async (context, session, agent, analysis, definition, evidence, diagnostics) => {
+	const localDefinitions = getLocalAgentDefinitions(analysis);
+	const collectionReferences = collectOpenAiAgentsSdkHandoffCollectionReferences(localDefinitions.map(({ handoffs }) => handoffs));
+	const elements = getOpenAiAgentsSdkHandoffElements(definition.handoffs, analysis, collectionReferences);
+	if (elements === null) return;
+	const allowedWrapperReferences = new Set(localDefinitions.flatMap(({ handoffs }) => (getOpenAiAgentsSdkHandoffElements(handoffs, analysis, collectionReferences) ?? []).filter((element) => ts.isIdentifier(element))));
+	for (const element of elements) {
+		session.signal?.throwIfAborted();
+		const registration = analyzeOpenAiAgentsSdkHandoffElement(element, analysis, allowedWrapperReferences);
+		if (registration === null) continue;
+		const target = await resolveTarget(session, analysis, registration.target);
+		if (target === null) continue;
+		const mappedAgents = getMappedAgents(context, target);
+		const runtimeName = await getRuntimeName(session, analysis, registration);
+		let routingDescriptionSource = "unresolved";
+		if (mappedAgents.length > 1) addOpenAiAgentsSdkDiagnostic(diagnostics, "OPENAI_AGENTS_SDK_HANDOFF_TARGET_AMBIGUOUS", analysis.path, agent.id, locateOpenAiAgentsSdkNode(analysis, registration.target), void 0, getAmbiguousTargetDetails(registration, target));
+		else if (mappedAgents.length === 1) routingDescriptionSource = await inspectRoutingDescription(session, agent, analysis, registration, target, mappedAgents[0], diagnostics);
+		const targetAgent = mappedAgents.length === 1 ? mappedAgents[0] : void 0;
+		evidence.push(createOpenAiAgentsSdkEvidence({
+			agentId: agent.id,
+			capabilityId: null,
+			capabilityKind: null,
+			details: getSafeDetails(registration, routingDescriptionSource, target, targetAgent?.id),
+			kind: "handoff-registration",
+			references: [{ path: analysis.path }, {
+				path: target.path,
+				symbol: target.symbol
+			}],
+			runtimeName,
+			source: OPENAI_AGENTS_SDK_ADAPTER_ID
+		}));
+	}
+};
+//#endregion
+//#region src/inspection/package-inspection.ts
+/** Inspects the nearest owning package manifest for one runtime source. */
+var inspectOpenAiAgentsSdkPackage = async (session, sourcePath, evidence, diagnostics, agentId) => {
+	const discovery = await session.discoverPackage(sourcePath);
+	if (discovery.kind === "absent") return;
+	if (discovery.kind === "invalid") {
+		addOpenAiAgentsSdkDiagnostic(diagnostics, "OPENAI_AGENTS_SDK_PACKAGE_MANIFEST_INVALID", discovery.path, agentId);
+		return;
+	}
+	const { observation } = discovery;
+	if (observation.compatibility === "unsupported") {
+		addOpenAiAgentsSdkDiagnostic(diagnostics, "OPENAI_AGENTS_SDK_VERSION_UNSUPPORTED", observation.path, agentId);
+		return;
+	}
+	for (const declaration of observation.declarations) evidence.push(createOpenAiAgentsSdkEvidence({
+		agentId,
+		capabilityId: null,
+		capabilityKind: null,
+		details: {
+			compatibility: observation.compatibility,
+			declaredRange: declaration.declaredRange,
+			dependencyKind: declaration.dependencyKind
+		},
+		kind: "runtime-package",
+		references: [{ path: observation.path }],
+		runtimeName: OPENAI_AGENTS_SDK_PACKAGE_NAME,
+		source: OPENAI_AGENTS_SDK_ADAPTER_ID
+	}));
+};
+//#endregion
+//#region src/inspection/relationships.ts
+var getAgentDefinitions = (analysis) => [...analysis.exports.keys()].flatMap((symbol) => {
+	const definition = getOpenAiAgentsSdkAgentDefinition(analysis, symbol);
+	return definition.kind === "present-supported" && definition.definition !== void 0 ? [definition.definition] : [];
+});
+var getAllowedToolReferences = (analysis) => {
+	const definitions = getAgentDefinitions(analysis);
+	const collectionReferences = collectOpenAiAgentsSdkToolCollectionReferences(definitions.map(({ tools }) => tools));
+	return new Set(definitions.flatMap(({ tools }) => getOpenAiAgentsSdkToolElements(tools, analysis, collectionReferences)));
+};
+var getRelationshipRange = (analysis, relationship) => relationship.kind === "present" ? locateOpenAiAgentsSdkNode(analysis, relationship.expression) : null;
+var inspectConstSymbol = async (session, reference, diagnosticCode, agentId, diagnostics, capabilityId) => {
+	if (reference.symbol === void 0) return null;
+	const analysis = await analyzeOpenAiAgentsSdkBoundReference(session, reference, diagnostics, agentId, capabilityId);
+	if (analysis === null) return null;
+	const exported = getConstExport(analysis, reference.symbol);
+	if (exported.kind === "absent") {
+		addOpenAiAgentsSdkDiagnostic(diagnostics, diagnosticCode, reference.path, agentId, null, capabilityId);
+		return false;
+	}
+	return exported.kind === "present-supported" ? true : null;
+};
+var inspectInstructionLoader = async (session, agent, analysis, definition, evidence, diagnostics) => {
+	const reference = agent.declaration.bindings?.instructionLoader;
+	if (reference?.symbol === void 0) return;
+	const loaderAnalysis = await analyzeOpenAiAgentsSdkBoundReference(session, reference, diagnostics, agent.id);
+	if (loaderAnalysis === null) return;
+	const loader = getCallableExportState(loaderAnalysis, reference.symbol);
+	if (loader.kind === "absent") {
+		addOpenAiAgentsSdkDiagnostic(diagnostics, "OPENAI_AGENTS_SDK_INSTRUCTION_LOADER_SYMBOL_NOT_FOUND", reference.path, agent.id);
+		return;
+	}
+	if (loader.kind !== "present-supported") return;
+	const relationship = classifyOpenAiAgentsSdkInstructionLoader(definition.instructions, analysis, reference);
+	if (relationship === true) evidence.push(createOpenAiAgentsSdkEvidence({
+		agentId: agent.id,
+		capabilityId: null,
+		capabilityKind: null,
+		details: { configurationProperty: "instructions" },
+		kind: "instruction-loader",
+		references: [{ path: analysis.path }, {
+			path: reference.path,
+			symbol: reference.symbol
+		}],
+		runtimeName: reference.symbol,
+		source: OPENAI_AGENTS_SDK_ADAPTER_ID
+	}));
+	else if (relationship === false) addOpenAiAgentsSdkDiagnostic(diagnostics, "OPENAI_AGENTS_SDK_INSTRUCTION_LOADER_NOT_WIRED", analysis.path, agent.id, getRelationshipRange(analysis, definition.instructions));
+};
+var inspectAgentOutputSchema = async (session, agent, analysis, definition, evidence, diagnostics) => {
+	const reference = agent.declaration.bindings?.outputSchema;
+	if (reference?.symbol === void 0) return;
+	if (await inspectConstSymbol(session, reference, "OPENAI_AGENTS_SDK_AGENT_OUTPUT_SCHEMA_SYMBOL_NOT_FOUND", agent.id, diagnostics) !== true) return;
+	const relationship = classifyOpenAiAgentsSdkDirectBinding(definition.outputType, analysis, reference);
+	if (relationship === true) evidence.push(createOpenAiAgentsSdkEvidence({
+		agentId: agent.id,
+		capabilityId: null,
+		capabilityKind: null,
+		details: {
+			configurationProperty: "outputType",
+			schemaRole: "agent-output"
+		},
+		kind: "schema",
+		references: [{ path: analysis.path }, {
+			path: reference.path,
+			symbol: reference.symbol
+		}],
+		runtimeName: reference.symbol,
+		source: OPENAI_AGENTS_SDK_ADAPTER_ID
+	}));
+	else if (relationship === false) addOpenAiAgentsSdkDiagnostic(diagnostics, "OPENAI_AGENTS_SDK_AGENT_OUTPUT_SCHEMA_NOT_WIRED", analysis.path, agent.id, getRelationshipRange(analysis, definition.outputType));
+};
+var inspectImplementationSymbol = async (session, agent, capabilityId, reference, diagnostics) => {
+	if (reference.symbol === void 0) return null;
+	const analysis = await analyzeOpenAiAgentsSdkBoundReference(session, reference, diagnostics, agent.id, capabilityId);
+	if (analysis === null) return null;
+	const implementation = getCallableExportState(analysis, reference.symbol);
+	if (implementation.kind === "absent") {
+		addOpenAiAgentsSdkDiagnostic(diagnostics, "OPENAI_AGENTS_SDK_TOOL_IMPLEMENTATION_SYMBOL_NOT_FOUND", reference.path, agent.id, null, capabilityId);
+		return false;
+	}
+	return implementation.kind === "present-supported" ? true : null;
+};
+var inspectFunctionTool = async (session, agent, capabilityId, toolDeclaration, diagnostics) => {
+	const reference = toolDeclaration.registration;
+	if (reference?.symbol === void 0) return null;
+	const analysis = await analyzeOpenAiAgentsSdkBoundReference(session, reference, diagnostics, agent.id, capabilityId);
+	if (analysis === null) return null;
+	const registration = getOpenAiAgentsSdkFunctionTool(analysis, reference.symbol);
+	if (registration.kind === "absent") {
+		addOpenAiAgentsSdkDiagnostic(diagnostics, "OPENAI_AGENTS_SDK_TOOL_REGISTRATION_SYMBOL_NOT_FOUND", reference.path, agent.id, null, capabilityId);
+		return null;
+	}
+	if (registration.kind !== "present-supported") return null;
+	const staticName = await resolveOpenAiAgentsSdkStaticString(session, analysis, registration.tool.name);
+	if (staticName.kind !== "supported" || !OPENAI_AGENTS_SDK_TOOL_NAME_PATTERN.test(staticName.value)) return null;
+	const mutations = analyzeOpenAiAgentsSdkMutations(analysis, registration.tool.declaration, getAllowedToolReferences(analysis));
+	if (mutations.hasUnknownMutation || mutations.mutatedMembers.has("type")) return null;
+	const isNameMutable = mutations.mutatedMembers.has("name");
+	const isNameMatch = !isNameMutable && staticName.value === toolDeclaration.name;
+	const execute = mutations.mutatedMembers.has("invoke") ? { kind: "unresolved" } : registration.tool.execute;
+	const outputSchema = mutations.mutatedMembers.has("outputSchema") ? { kind: "unresolved" } : registration.tool.outputSchema;
+	const parameters = mutations.mutatedMembers.has("parameters") ? { kind: "unresolved" } : registration.tool.parameters;
+	if (!isNameMutable && !isNameMatch) addOpenAiAgentsSdkDiagnostic(diagnostics, "OPENAI_AGENTS_SDK_TOOL_NAME_MISMATCH", analysis.path, agent.id, locateOpenAiAgentsSdkNode(analysis, registration.tool.name), capabilityId);
+	return Object.freeze({
+		analysis,
+		capabilityId,
+		execute,
+		isNameMatch,
+		name: isNameMutable ? null : staticName.value,
+		outputSchema,
+		parameters,
+		reference: Object.freeze({
+			path: reference.path,
+			symbol: reference.symbol
+		}),
+		tool: registration.tool
+	});
+};
+var inspectToolSchema = async (session, agent, capabilityId, reference, registration, relationshipName, evidence, diagnostics) => {
+	if (reference.symbol === void 0) return;
+	const isOutput = relationshipName === "outputSchema";
+	if (await inspectConstSymbol(session, reference, isOutput ? "OPENAI_AGENTS_SDK_TOOL_OUTPUT_SCHEMA_SYMBOL_NOT_FOUND" : "OPENAI_AGENTS_SDK_TOOL_INPUT_SCHEMA_SYMBOL_NOT_FOUND", agent.id, diagnostics, capabilityId) !== true || registration === null) return;
+	const relationship = classifyOpenAiAgentsSdkDirectBinding(registration[relationshipName], registration.analysis, reference);
+	if (relationship === true) evidence.push(createOpenAiAgentsSdkEvidence({
+		agentId: agent.id,
+		capabilityId,
+		capabilityKind: "tool",
+		details: {
+			configurationProperty: relationshipName,
+			schemaRole: isOutput ? "tool-output" : "tool-input"
+		},
+		kind: "schema",
+		references: [{ path: registration.analysis.path }, {
+			path: reference.path,
+			symbol: reference.symbol
+		}],
+		runtimeName: reference.symbol,
+		source: OPENAI_AGENTS_SDK_ADAPTER_ID
+	}));
+	else if (relationship === false) addOpenAiAgentsSdkDiagnostic(diagnostics, isOutput ? "OPENAI_AGENTS_SDK_TOOL_OUTPUT_SCHEMA_NOT_WIRED" : "OPENAI_AGENTS_SDK_TOOL_INPUT_SCHEMA_NOT_WIRED", registration.analysis.path, agent.id, getRelationshipRange(registration.analysis, registration[relationshipName]), capabilityId);
+};
+var inspectTools = async (session, agent, runtimeAnalysis, definition, evidence, diagnostics) => {
+	const collectionReferences = collectOpenAiAgentsSdkToolCollectionReferences(getAgentDefinitions(runtimeAnalysis).map(({ tools }) => tools));
+	for (const capabilityId of Object.keys(agent.declaration.tools ?? {}).sort(compareOpenAiAgentsSdkStrings)) {
+		const toolDeclaration = agent.declaration.tools?.[capabilityId];
+		if (toolDeclaration === void 0) continue;
+		const implementationState = await inspectImplementationSymbol(session, agent, capabilityId, toolDeclaration.implementation, diagnostics);
+		const registration = await inspectFunctionTool(session, agent, capabilityId, toolDeclaration, diagnostics);
+		if (toolDeclaration.inputSchema !== void 0) await inspectToolSchema(session, agent, capabilityId, toolDeclaration.inputSchema, registration, "parameters", evidence, diagnostics);
+		if (toolDeclaration.outputSchema !== void 0) await inspectToolSchema(session, agent, capabilityId, toolDeclaration.outputSchema, registration, "outputSchema", evidence, diagnostics);
+		if (registration === null) continue;
+		const implementationRelationship = classifyOpenAiAgentsSdkDirectBinding(registration.execute, registration.analysis, toolDeclaration.implementation);
+		if (implementationState === true && implementationRelationship === false) addOpenAiAgentsSdkDiagnostic(diagnostics, "OPENAI_AGENTS_SDK_TOOL_IMPLEMENTATION_NOT_WIRED", registration.analysis.path, agent.id, getRelationshipRange(registration.analysis, registration.execute), capabilityId);
+		const registrationRelationship = classifyOpenAiAgentsSdkToolRegistration(definition.tools, runtimeAnalysis, registration.reference, collectionReferences);
+		if (registrationRelationship === false) addOpenAiAgentsSdkDiagnostic(diagnostics, "OPENAI_AGENTS_SDK_TOOL_REGISTRATION_NOT_WIRED", runtimeAnalysis.path, agent.id, getRelationshipRange(runtimeAnalysis, definition.tools), capabilityId);
+		else if (registrationRelationship === true && implementationState === true && implementationRelationship === true && registration.isNameMatch && registration.name !== null) evidence.push(createOpenAiAgentsSdkEvidence({
+			agentId: agent.id,
+			capabilityId,
+			capabilityKind: "tool",
+			details: { toolType: "function" },
+			kind: "tool-registration",
+			references: [
+				{ path: runtimeAnalysis.path },
+				{
+					path: registration.reference.path,
+					symbol: registration.reference.symbol
+				},
+				{
+					path: toolDeclaration.implementation.path,
+					...toolDeclaration.implementation.symbol === void 0 ? {} : { symbol: toolDeclaration.implementation.symbol }
+				}
+			],
+			runtimeName: registration.name,
+			source: OPENAI_AGENTS_SDK_ADAPTER_ID
+		}));
+	}
+};
+/** Inspects instruction, agent-schema, function-tool, and tool-schema relationships. */
+var inspectOpenAiAgentsSdkRelationships = async (session, agent, analysis, definition, evidence, diagnostics) => {
+	await inspectInstructionLoader(session, agent, analysis, definition, evidence, diagnostics);
+	await inspectAgentOutputSchema(session, agent, analysis, definition, evidence, diagnostics);
+	await inspectTools(session, agent, analysis, definition, evidence, diagnostics);
+};
+//#endregion
+//#region src/package-discovery/index.ts
+/**
+* Discovers the nearest relevant OpenAI Agents SDK package declaration.
+* @param repository The Core-owned budget-aware repository reader.
+* @param sourcePath The bound source whose package scope is inspected.
+* @param signal The active inspection signal.
+* @returns The first observed declaration, invalid manifest, or absence result.
+* @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 was aborted.
+*/
+var discoverOpenAiAgentsSdkPackage = async (repository, sourcePath, signal) => {
+	const repositoryOptions = signal === void 0 ? void 0 : { signal };
+	const result = await discoverPackage({
+		packageName: OPENAI_AGENTS_SDK_PACKAGE_NAME,
+		reader: {
+			getEntry: (path) => repository.getEntry(parseRepositoryPath(path), repositoryOptions),
+			readFile: (path) => repository.readFile(parseRepositoryPath(path), repositoryOptions)
+		},
+		...signal === void 0 ? {} : { signal },
+		sourcePath,
+		supportedRange: OPENAI_AGENTS_SDK_SUPPORTED_RANGE
+	});
+	if (result.kind === "invalid") return Object.freeze({
+		kind: "invalid",
+		path: parseRepositoryPath(result.path)
+	});
+	if (result.kind === "observed") return Object.freeze({
+		kind: "observed",
+		observation: Object.freeze({
+			...result.observation,
+			path: parseRepositoryPath(result.observation.path)
+		})
+	});
+	return result;
+};
+//#endregion
+//#region src/inspection/session.ts
+/** Creates one operation-local OpenAI Agents SDK inspection session. */
+var createOpenAiAgentsSdkInspectionSession = (context) => createInspectionSession({
+	analyzeSource: analyzeOpenAiAgentsSdkSource,
+	discoverPackage: (path, signal) => discoverOpenAiAgentsSdkPackage(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/inspection.ts
+var inspectAgent = async (context, session, agent, evidence, diagnostics) => {
+	const runtimeAgent = agent.declaration.bindings?.runtimeAgent;
+	if (runtimeAgent === void 0) return;
+	await inspectOpenAiAgentsSdkPackage(session, runtimeAgent.path, evidence, diagnostics, agent.id);
+	if (!isSupportedTypeScriptSourcePath(runtimeAgent.path)) return;
+	evidence.push(createOpenAiAgentsSdkEvidence({
+		agentId: agent.id,
+		capabilityId: null,
+		capabilityKind: null,
+		details: { language: "typescript" },
+		kind: "language",
+		references: [runtimeAgent.symbol === void 0 ? { path: runtimeAgent.path } : {
+			path: runtimeAgent.path,
+			symbol: runtimeAgent.symbol
+		}],
+		runtimeName: null,
+		source: OPENAI_AGENTS_SDK_ADAPTER_ID
+	}));
+	if (runtimeAgent.symbol === void 0) return;
+	const analysis = await analyzeOpenAiAgentsSdkBoundReference(session, runtimeAgent, diagnostics, agent.id);
+	if (analysis === null) return;
+	const definitionResult = getOpenAiAgentsSdkAgentDefinition(analysis, runtimeAgent.symbol);
+	if (definitionResult.kind === "absent") {
+		addOpenAiAgentsSdkDiagnostic(diagnostics, "OPENAI_AGENTS_SDK_RUNTIME_AGENT_SYMBOL_NOT_FOUND", runtimeAgent.path, agent.id);
+		return;
+	}
+	if (definitionResult.kind !== "present-supported" || definitionResult.definition === void 0) return;
+	const definition = applyOpenAiAgentsSdkAgentMutations(analysis, definitionResult.definition, collectOpenAiAgentsSdkHandoffTargetReferences(analysis));
+	const runtimeName = definition.name.kind === "present" ? await resolveOpenAiAgentsSdkStaticString(session, analysis, definition.name.expression) : { kind: "unsupported" };
+	evidence.push(createOpenAiAgentsSdkEvidence({
+		agentId: agent.id,
+		capabilityId: null,
+		capabilityKind: null,
+		details: { definitionKind: "agent" },
+		kind: "agent-definition",
+		references: [{
+			path: runtimeAgent.path,
+			symbol: runtimeAgent.symbol
+		}],
+		runtimeName: runtimeName.kind === "supported" && isOpenAiAgentsSdkMachineString(runtimeName.value) ? runtimeName.value : runtimeAgent.symbol,
+		source: OPENAI_AGENTS_SDK_ADAPTER_ID
+	}));
+	await inspectOpenAiAgentsSdkRelationships(session, agent, analysis, definition, evidence, diagnostics);
+	await inspectOpenAiAgentsSdkHandoffs(context, session, agent, analysis, definition, evidence, diagnostics);
+};
+/**
+* Inspects all scoped OpenAI Agents SDK agents through one deterministic 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 inspectOpenAiAgentsSdk = async (context) => {
+	context.signal?.throwIfAborted();
+	const session = createOpenAiAgentsSdkInspectionSession(context);
+	const evidence = [];
+	const diagnostics = [];
+	const agents = [...context.agents].sort((left, right) => compareOpenAiAgentsSdkStrings(left.id, right.id));
+	for (const agent of agents) {
+		context.signal?.throwIfAborted();
+		await inspectAgent(context, session, agent, evidence, diagnostics);
+	}
+	context.signal?.throwIfAborted();
+	return Object.freeze({
+		diagnostics: Object.freeze(diagnostics),
+		evidence: Object.freeze(evidence)
+	});
+};
+//#endregion
+//#region src/adapter/index.ts
+var openAiAgentsSdkAdapter = Object.freeze({
+	id: OPENAI_AGENTS_SDK_ADAPTER_ID,
+	inspect: inspectOpenAiAgentsSdk,
+	supportedRepositoryFormatVersions: OPENAI_AGENTS_SDK_SUPPORTED_REPOSITORY_FORMAT_VERSIONS
+});
+//#endregion
+export { openAiAgentsSdkAdapter };