@moldea.ai/adapter-cloudflare-agents 1.0.0

package/dist/index.js

@@ -0,0 +1,1646 @@
+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 CLOUDFLARE_AGENTS_ADAPTER_ID = "cloudflare-agents";
+var CLOUDFLARE_AGENTS_PACKAGE_NAME = "agents";
+var CLOUDFLARE_AI_CHAT_PACKAGE_NAME = "@cloudflare/ai-chat";
+var CLOUDFLARE_THINK_PACKAGE_NAME = "@cloudflare/think";
+var CLOUDFLARE_THINK_TARGET_ID = "typescript-think-0-16-ai-sdk-7";
+var CLOUDFLARE_AI_CHAT_TARGET_ID = "typescript-ai-chat-agent-0-10-ai-sdk-7";
+var CLOUDFLARE_THINK_SUPPORTED_RANGE = ">=0.16.0 <0.17.0";
+var CLOUDFLARE_AI_CHAT_SUPPORTED_RANGE = ">=0.10.2 <0.11.0";
+var CLOUDFLARE_AGENTS_SUPPORTED_RANGE = ">=0.21.0 <0.22.0";
+var AI_SDK_SUPPORTED_RANGE = ">=7.0.0 <8.0.0";
+var CLOUDFLARE_AGENTS_SUPPORTED_REPOSITORY_FORMAT_VERSIONS = Object.freeze([1]);
+//#endregion
+//#region ../../packages/adapter-static-analysis/dist/index.js
+/**
+* Creates an operation-local inspection session with deterministic promise caches.
+* @param options Provider callbacks and the optional operation signal.
+* @returns Cached source, package, and entry inspection functions.
+* @throws If the inspection is aborted.
+*/
+var createInspectionSession = (options) => {
+	const sourceCache = /* @__PURE__ */ new Map();
+	const packageCache = /* @__PURE__ */ new Map();
+	const entryCache = /* @__PURE__ */ new Map();
+	const analyzeSource = (path) => {
+		options.signal?.throwIfAborted();
+		const existing = sourceCache.get(path);
+		if (existing !== void 0) return existing;
+		const analysis = (async () => {
+			options.signal?.throwIfAborted();
+			const bytes = await options.readFile(path, options.signal);
+			options.signal?.throwIfAborted();
+			const result = await options.analyzeSource(path, bytes, options.signal);
+			options.signal?.throwIfAborted();
+			return result;
+		})();
+		sourceCache.set(path, analysis);
+		return analysis;
+	};
+	const discoverPackage = (path) => {
+		options.signal?.throwIfAborted();
+		const existing = packageCache.get(path);
+		if (existing !== void 0) return existing;
+		const discovery = options.discoverPackage(path, options.signal);
+		packageCache.set(path, discovery);
+		return discovery;
+	};
+	const getEntry = (path) => {
+		options.signal?.throwIfAborted();
+		const existing = entryCache.get(path);
+		if (existing !== void 0) return existing;
+		const entry = options.getEntry(path, options.signal);
+		entryCache.set(path, entry);
+		return entry;
+	};
+	return Object.freeze({
+		analyzeSource,
+		discoverPackage,
+		getEntry,
+		...options.signal === void 0 ? {} : { signal: options.signal }
+	});
+};
+var decoder = new TextDecoder("utf-8", {
+	fatal: true,
+	ignoreBOM: true
+});
+var findLineIndex = (lineStarts, offset) => {
+	let lower = 0;
+	let upper = lineStarts.length - 1;
+	while (lower < upper) {
+		const middle = Math.ceil((lower + upper) / 2);
+		if ((lineStarts[middle] ?? 0) <= offset) lower = middle;
+		else upper = middle - 1;
+	}
+	return lower;
+};
+/**
+* Creates a TypeScript UTF-16-offset to Unicode-scalar source locator.
+* @param value The normalized valid Unicode-scalar text.
+* @returns The scalar-aware source locator.
+*/
+var createSourceLocator = (value) => {
+	const scalarOffsets = new Uint32Array(value.length + 1);
+	const lineStarts = [0];
+	let scalarOffset = 0;
+	for (let codeUnitOffset = 0; codeUnitOffset < value.length;) {
+		const codePoint = value.codePointAt(codeUnitOffset);
+		const width = codePoint !== void 0 && codePoint > 65535 ? 2 : 1;
+		scalarOffsets[codeUnitOffset] = scalarOffset;
+		for (let interiorOffset = 1; interiorOffset < width; interiorOffset += 1) scalarOffsets[codeUnitOffset + interiorOffset] = scalarOffset;
+		codeUnitOffset += width;
+		scalarOffset += 1;
+		scalarOffsets[codeUnitOffset] = scalarOffset;
+		if (codePoint === 10) lineStarts.push(codeUnitOffset);
+	}
+	const locatePosition = (candidateOffset) => {
+		const codeUnitOffset = Math.max(0, Math.min(value.length, candidateOffset));
+		const lineIndex = findLineIndex(lineStarts, codeUnitOffset);
+		const lineStart = lineStarts[lineIndex] ?? 0;
+		const positionScalarOffset = scalarOffsets[codeUnitOffset] ?? 0;
+		return {
+			column: positionScalarOffset - (scalarOffsets[lineStart] ?? 0) + 1,
+			line: lineIndex + 1,
+			offset: positionScalarOffset
+		};
+	};
+	return Object.freeze({ locateRange: (startOffset, endOffset) => ({
+		end: locatePosition(endOffset),
+		start: locatePosition(startOffset)
+	}) });
+};
+/**
+* Decodes and normalizes source bytes through the runtime-adapter text contract.
+* @param bytes The exact reader-owned source bytes.
+* @returns The normalized text and locator or an invalid-text result.
+*/
+var normalizeText = (bytes) => {
+	let decoded;
+	try {
+		decoded = decoder.decode(bytes);
+	} catch {
+		return Object.freeze({ valid: false });
+	}
+	const value = (decoded.startsWith("") ? decoded.slice(1) : decoded).replace(/\r\n?/gu, "\n");
+	if (value.includes("\0")) return Object.freeze({ valid: false });
+	return Object.freeze({
+		locator: createSourceLocator(value),
+		valid: true,
+		value
+	});
+};
+Object.freeze([
+	"dependencies",
+	"optionalDependencies",
+	"peerDependencies",
+	"devDependencies"
+]);
+/**
+* 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);
+};
+/**
+* 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;
+};
+var getStaticPropertyName = (name) => {
+	if (ts.isIdentifier(name) || ts.isStringLiteral(name)) return name.text;
+	return null;
+};
+/**
+* Indexes a closed object literal with exact identifier or string-literal keys.
+* @param objectLiteral The candidate closed object.
+* @returns Exact property expressions or `null` for dynamic or duplicate members.
+*/
+var getClosedObjectProperties = (objectLiteral) => {
+	const properties = /* @__PURE__ */ new Map();
+	for (const property of objectLiteral.properties) {
+		if (!ts.isPropertyAssignment(property) && !ts.isShorthandPropertyAssignment(property)) return null;
+		const propertyName = getStaticPropertyName(property.name);
+		if (propertyName === null || properties.has(propertyName)) return null;
+		properties.set(propertyName, unwrapExpression(ts.isPropertyAssignment(property) ? property.initializer : property.name));
+	}
+	return properties;
+};
+/**
+* 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;
+};
+/**
+* Determines whether a JSON-like expression is fully static.
+* @param expression The candidate schema or literal value.
+* @returns Whether every nested value is statically represented.
+*/
+var isStaticLiteralValue = (expression) => {
+	const candidate = unwrapExpression(expression);
+	if (ts.isStringLiteral(candidate) || ts.isNoSubstitutionTemplateLiteral(candidate) || ts.isNumericLiteral(candidate) || candidate.kind === ts.SyntaxKind.TrueKeyword || candidate.kind === ts.SyntaxKind.FalseKeyword || candidate.kind === ts.SyntaxKind.NullKeyword) return true;
+	if (ts.isPrefixUnaryExpression(candidate) && (candidate.operator === ts.SyntaxKind.PlusToken || candidate.operator === ts.SyntaxKind.MinusToken) && ts.isNumericLiteral(candidate.operand)) return true;
+	if (ts.isArrayLiteralExpression(candidate)) return candidate.elements.every((element) => !ts.isOmittedExpression(element) && !ts.isSpreadElement(element) && isStaticLiteralValue(element));
+	if (!ts.isObjectLiteralExpression(candidate)) return false;
+	const properties = getClosedObjectProperties(candidate);
+	return properties !== null && [...properties.values()].every((property) => isStaticLiteralValue(property));
+};
+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 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));
+//#endregion
+//#region src/source-analysis/source-analysis.ts
+var IMPORT_CONFIG = Object.freeze({
+	namedConstructorImports: ["Think"],
+	packageName: CLOUDFLARE_THINK_PACKAGE_NAME,
+	supportsDefaultConstructorImport: false
+});
+var indexCloudflareAgentsImports = (sourceFile) => {
+	const imports = {
+		agentToolNames: /* @__PURE__ */ new Set(),
+		aiChatAgentNames: /* @__PURE__ */ new Set(),
+		generateTextNames: /* @__PURE__ */ new Set(),
+		outputNames: /* @__PURE__ */ new Set(),
+		streamTextNames: /* @__PURE__ */ new Set(),
+		thinkNames: /* @__PURE__ */ new Set(),
+		toolNames: /* @__PURE__ */ new Set()
+	};
+	for (const statement of sourceFile.statements) {
+		if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier) || statement.importClause?.isTypeOnly === true || statement.importClause?.namedBindings === void 0 || !ts.isNamedImports(statement.importClause.namedBindings)) continue;
+		for (const element of statement.importClause.namedBindings.elements) {
+			const importedName = element.propertyName?.text ?? element.name.text;
+			if (element.isTypeOnly) continue;
+			if (statement.moduleSpecifier.text === "@cloudflare/ai-chat" && importedName === "AIChatAgent") imports.aiChatAgentNames.add(element.name.text);
+			else if (statement.moduleSpecifier.text === "@cloudflare/think" && importedName === "Think") imports.thinkNames.add(element.name.text);
+			else if (statement.moduleSpecifier.text === "agents/agent-tools" && importedName === "agentTool") imports.agentToolNames.add(element.name.text);
+			else if (statement.moduleSpecifier.text === "ai") {
+				if (importedName === "generateText") imports.generateTextNames.add(element.name.text);
+				if (importedName === "Output") imports.outputNames.add(element.name.text);
+				if (importedName === "streamText") imports.streamTextNames.add(element.name.text);
+				if (importedName === "tool") imports.toolNames.add(element.name.text);
+			}
+		}
+	}
+	return Object.freeze(imports);
+};
+/** Parses and indexes one Cloudflare Agents TypeScript module without executing it. */
+var analyzeCloudflareAgentsSource = (path, bytes, signal) => {
+	const result = analyzeTypeScriptModule(path, bytes, IMPORT_CONFIG, signal);
+	if (result.kind !== "valid") return result;
+	const analysis = Object.freeze({
+		...result.analysis,
+		imports: indexCloudflareAgentsImports(result.analysis.sourceFile),
+		path
+	});
+	return Object.freeze({
+		analysis,
+		kind: "valid"
+	});
+};
+//#endregion
+//#region src/source-analysis/class-initialization.ts
+var hasDecorators = (node) => ts.canHaveDecorators(node) && (ts.getDecorators(node)?.length ?? 0) > 0;
+var hasStaticModifier = (node) => ts.canHaveModifiers(node) && (ts.getModifiers(node)?.some((modifier) => modifier.kind === ts.SyntaxKind.StaticKeyword) ?? false);
+var isSimpleParameter = (parameter) => ts.isIdentifier(parameter.name) && parameter.dotDotDotToken === void 0 && parameter.initializer === void 0 && parameter.questionToken === void 0 && (parameter.modifiers?.length ?? 0) === 0 && !hasDecorators(parameter);
+var isPassThroughConstructor = (constructor) => {
+	if (constructor.body === void 0 || constructor.parameters.length !== 2 || !constructor.parameters.every(isSimpleParameter) || constructor.body.statements.length !== 1) return false;
+	const statement = constructor.body.statements[0];
+	if (statement === void 0 || !ts.isExpressionStatement(statement)) return false;
+	const expression = unwrapExpression(statement.expression);
+	return ts.isCallExpression(expression) && expression.expression.kind === ts.SyntaxKind.SuperKeyword && expression.arguments.length === 2 && expression.arguments.every((argument, index) => ts.isIdentifier(unwrapExpression(argument)) && unwrapExpression(argument).text === (constructor.parameters[index]?.name).text);
+};
+/** Determines whether the class initialization surface is closed and side-effect free. */
+var isCloudflareAgentsClassInitializationSupported = (declaration) => {
+	if (hasDecorators(declaration)) return false;
+	let constructorCount = 0;
+	for (const member of declaration.members) {
+		if (hasDecorators(member)) return false;
+		if (ts.isConstructorDeclaration(member)) {
+			constructorCount += 1;
+			if (constructorCount > 1 || !isPassThroughConstructor(member)) return false;
+			continue;
+		}
+		if (ts.isMethodDeclaration(member)) {
+			if (member.asteriskToken !== void 0 || ts.isComputedPropertyName(member.name) || member.parameters.some((parameter) => hasDecorators(parameter))) return false;
+			continue;
+		}
+		if (ts.isPropertyDeclaration(member)) {
+			if (ts.isComputedPropertyName(member.name) || hasStaticModifier(member) || member.initializer === void 0 || !isStaticLiteralValue(member.initializer)) return false;
+			continue;
+		}
+		return false;
+	}
+	return true;
+};
+//#endregion
+//#region src/source-analysis/bindings.ts
+/** Returns an exact supported object or class member name. */
+var getCloudflareAgentsPropertyName = (name) => ts.isIdentifier(name) || ts.isStringLiteral(name) ? name.text : null;
+/** Determines whether an object uses JavaScript's non-own `__proto__` setter form. */
+var hasCloudflareAgentsPrototypeSetter = (object) => object.properties.some((property) => ts.isPropertyAssignment(property) && !ts.isComputedPropertyName(property.name) && getCloudflareAgentsPropertyName(property.name) === "__proto__");
+/** Classifies exact fields in one closed or partially unrelated object literal. */
+var analyzeCloudflareAgentsObjectRelationships = (object, names) => {
+	const relationships = Object.fromEntries(names.map((name) => [name, { kind: "absent" }]));
+	const relationshipNames = new Set(names);
+	const markAllUnresolved = () => {
+		for (const name of names) relationships[name] = { kind: "unresolved" };
+	};
+	if (hasCloudflareAgentsPrototypeSetter(object)) {
+		markAllUnresolved();
+		return relationships;
+	}
+	for (const property of object.properties) {
+		if (ts.isSpreadAssignment(property) || ts.isComputedPropertyName(property.name)) {
+			markAllUnresolved();
+			continue;
+		}
+		const propertyName = getCloudflareAgentsPropertyName(property.name);
+		if (propertyName === null || !relationshipNames.has(propertyName)) continue;
+		const name = propertyName;
+		if (relationships[name].kind !== "absent") relationships[name] = { kind: "unresolved" };
+		else if (ts.isPropertyAssignment(property)) relationships[name] = {
+			expression: unwrapExpression(property.initializer),
+			kind: "present"
+		};
+		else if (ts.isShorthandPropertyAssignment(property)) relationships[name] = {
+			expression: property.name,
+			kind: "present"
+		};
+		else relationships[name] = { kind: "unresolved" };
+	}
+	return relationships;
+};
+/** Classifies a direct relationship to one explicitly bound runtime symbol. */
+var classifyCloudflareAgentsDirectBinding = (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;
+};
+/** Classifies a required direct or awaited instruction-loader call. */
+var classifyCloudflareAgentsInstructionLoader = (relationship, analysis, reference) => {
+	if (relationship.kind === "absent") return false;
+	if (relationship.kind === "unresolved" || reference.symbol === void 0) return null;
+	const call = getDirectCall(relationship.expression);
+	if (call === null) return ts.isStringLiteral(unwrapExpression(relationship.expression)) ? false : 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;
+};
+//#endregion
+//#region src/source-analysis/methods.ts
+/** Returns a supported non-generator block-bodied method with an exact parameter count. */
+var getCloudflareAgentsMethod = (methods, name, parameterCount) => {
+	const method = methods.get(name);
+	if (method === void 0 || method.declaration.asteriskToken !== void 0 || method.declaration.parameters.length !== parameterCount || method.declaration.parameters.some((parameter) => !ts.isIdentifier(parameter.name) || parameter.dotDotDotToken !== void 0 || parameter.initializer !== void 0)) return null;
+	return method;
+};
+/** Indexes static method names while rejecting overloads and duplicate implementations. */
+var indexCloudflareAgentsMethods = (declaration) => {
+	const methods = /* @__PURE__ */ new Map();
+	for (const member of declaration.members) {
+		if (!ts.isMethodDeclaration(member)) continue;
+		const name = getCloudflareAgentsPropertyName(member.name);
+		if (name === null || member.body === void 0 || methods.has(name)) return null;
+		methods.set(name, Object.freeze({
+			body: member.body,
+			declaration: member
+		}));
+	}
+	return methods;
+};
+//#endregion
+//#region src/source-analysis/class-definitions.ts
+var hasExportModifier = (declaration) => ts.canHaveModifiers(declaration) && (ts.getModifiers(declaration)?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword) ?? false);
+var getTargetId = (declaration, analysis) => {
+	const heritageClauses = declaration.heritageClauses;
+	if (heritageClauses?.length !== 1) return null;
+	const clause = heritageClauses[0];
+	if (clause === void 0 || clause.token !== ts.SyntaxKind.ExtendsKeyword) return null;
+	const types = clause.types;
+	if (types.length !== 1) return null;
+	const baseType = types[0];
+	if (baseType === void 0 || baseType.typeArguments !== void 0) return null;
+	const base = unwrapExpression(baseType.expression);
+	if (!ts.isIdentifier(base) || !isModuleBindingVisible(base, analysis)) return null;
+	if (analysis.imports.thinkNames.has(base.text)) return CLOUDFLARE_THINK_TARGET_ID;
+	return analysis.imports.aiChatAgentNames.has(base.text) ? CLOUDFLARE_AI_CHAT_TARGET_ID : null;
+};
+/** Classifies one directly exported Cloudflare agent class under the closed class contract. */
+var getCloudflareAgentsClassDefinition = (analysis, symbol) => {
+	const exported = analysis.exports.get(symbol);
+	if (exported === void 0) return Object.freeze({ kind: "absent" });
+	if (!ts.isClassDeclaration(exported.declaration) || exported.declaration.name?.text !== symbol || !hasExportModifier(exported.declaration)) return Object.freeze({
+		declaration: exported.declaration,
+		kind: "present-unsupported"
+	});
+	const targetId = getTargetId(exported.declaration, analysis);
+	if (targetId === null) return Object.freeze({
+		declaration: exported.declaration,
+		kind: "present-unsupported"
+	});
+	const methods = indexCloudflareAgentsMethods(exported.declaration);
+	if (methods === null || !isCloudflareAgentsClassInitializationSupported(exported.declaration)) return Object.freeze({
+		declaration: exported.declaration,
+		kind: "present-unsupported",
+		targetId
+	});
+	if (targetId === "typescript-ai-chat-agent-0-10-ai-sdk-7" && (methods.get("onChatMessage")?.declaration.parameters.length !== 2 || methods.get("onChatMessage")?.declaration.parameters[0]?.questionToken !== void 0 || methods.get("onChatMessage")?.declaration.parameters[1]?.dotDotDotToken !== void 0)) return Object.freeze({
+		declaration: exported.declaration,
+		kind: "present-unsupported",
+		targetId
+	});
+	return Object.freeze({
+		definition: Object.freeze({
+			declaration: exported.declaration,
+			methods,
+			targetId
+		}),
+		kind: "present-supported"
+	});
+};
+//#endregion
+//#region src/source-analysis/think-instructions.ts
+/** Extracts the exact direct loader call returned by `getSystemPrompt`. */
+var getCloudflareAgentsThinkSystemPrompt = (definition) => {
+	const method = getCloudflareAgentsMethod(definition.methods, "getSystemPrompt", 0);
+	if (method === null || method.body.statements.length !== 1) return Object.freeze({ kind: "absent" });
+	const statement = method.body.statements[0];
+	if (statement === void 0 || !ts.isReturnStatement(statement) || statement.expression === void 0) return Object.freeze({ kind: "unresolved" });
+	return Object.freeze(getDirectCall(statement.expression) === null ? { kind: "unresolved" } : {
+		expression: statement.expression,
+		kind: "present"
+	});
+};
+//#endregion
+//#region src/source-analysis/session-builders.ts
+var mergeInstruction = (current, expression) => current.kind === "absent" ? Object.freeze({
+	expression,
+	kind: "present"
+}) : Object.freeze({ kind: "unresolved" });
+var getProviderLoader = (expression) => {
+	const candidate = unwrapExpression(expression);
+	if (!ts.isObjectLiteralExpression(candidate)) return null;
+	const properties = getClosedObjectProperties(candidate);
+	if (properties === null || !properties.has("get")) return null;
+	const getter = unwrapExpression(properties.get("get"));
+	if (ts.isIdentifier(getter)) return ts.factory.createCallExpression(getter, void 0, []);
+	if (ts.isArrowFunction(getter) || ts.isFunctionExpression(getter)) {
+		if (ts.isBlock(getter.body)) {
+			if (getter.body.statements.length !== 1) return null;
+			const statement = getter.body.statements[0];
+			return statement !== void 0 && ts.isReturnStatement(statement) && statement.expression !== void 0 ? statement.expression : null;
+		}
+		return getter.body;
+	}
+	return null;
+};
+/** Extracts an exact Think session-builder instruction source from supported chaining. */
+var getCloudflareAgentsThinkSessionInstructions = (definition) => {
+	const method = getCloudflareAgentsMethod(definition.methods, "configureSession", 1);
+	if (method === null || method.body.statements.length !== 1) return Object.freeze({ kind: "absent" });
+	const statement = method.body.statements[0];
+	const parameter = method.declaration.parameters[0]?.name;
+	if (statement === void 0 || !ts.isReturnStatement(statement) || statement.expression === void 0 || parameter === void 0 || !ts.isIdentifier(parameter)) return Object.freeze({ kind: "unresolved" });
+	let expression = unwrapExpression(statement.expression);
+	let instructions = { kind: "absent" };
+	while (ts.isCallExpression(expression)) {
+		const callee = unwrapExpression(expression.expression);
+		if (!ts.isPropertyAccessExpression(callee)) return Object.freeze({ kind: "unresolved" });
+		const methodName = callee.name.text;
+		if (methodName === "withInstructions") {
+			const argument = expression.arguments[0];
+			if (expression.arguments.length !== 1 || argument === void 0 || getDirectCall(argument) === null) return Object.freeze({ kind: "unresolved" });
+			instructions = mergeInstruction(instructions, argument);
+		} else if (methodName === "withContext") {
+			const argument = expression.arguments[0];
+			const loader = argument === void 0 ? null : getProviderLoader(argument);
+			if (expression.arguments.length !== 1 || loader === null || getDirectCall(loader) === null) return Object.freeze({ kind: "unresolved" });
+			instructions = mergeInstruction(instructions, loader);
+		} else if (methodName === "withCachedPrompt") {
+			if (expression.arguments.length > 1) return Object.freeze({ kind: "unresolved" });
+			const argument = expression.arguments[0];
+			if (argument !== void 0) {
+				const loader = getProviderLoader(argument);
+				if (loader === null || getDirectCall(loader) === null) return Object.freeze({ kind: "unresolved" });
+				instructions = mergeInstruction(instructions, loader);
+			}
+		} else if (methodName === "forSession") {
+			if (expression.arguments.length !== 1 || getStaticString(expression.arguments[0]) === null) return Object.freeze({ kind: "unresolved" });
+		} else if (methodName === "compactAfter") {
+			const argument = expression.arguments[0];
+			if (expression.arguments.length !== 1 || argument === void 0 || !ts.isNumericLiteral(unwrapExpression(argument)) || !Number.isSafeInteger(Number(unwrapExpression(argument).getText())) || Number(unwrapExpression(argument).getText()) < 0) return Object.freeze({ kind: "unresolved" });
+		} else return Object.freeze({ kind: "unresolved" });
+		expression = unwrapExpression(callee.expression);
+	}
+	return ts.isIdentifier(expression) && expression.text === parameter.text ? Object.freeze(instructions) : Object.freeze({ kind: "unresolved" });
+};
+//#endregion
+//#region src/source-analysis/channel-tools.ts
+/** Determines whether Think channel configuration can influence the assembled tool set. */
+var getCloudflareAgentsThinkChannelTools = (definition) => {
+	const method = getCloudflareAgentsMethod(definition.methods, "configureChannels", 0);
+	if (method === null) return Object.freeze({ kind: definition.methods.has("configureChannels") ? "unresolved" : "absent" });
+	if (method.body.statements.length !== 1) return Object.freeze({ kind: "unresolved" });
+	const statement = method.body.statements[0];
+	if (statement === void 0 || !ts.isReturnStatement(statement) || statement.expression === void 0) return Object.freeze({ kind: "unresolved" });
+	const channelMap = unwrapExpression(statement.expression);
+	if (!ts.isObjectLiteralExpression(channelMap)) return Object.freeze({ kind: "unresolved" });
+	const channels = getClosedObjectProperties(channelMap);
+	if (channels === null) return Object.freeze({ kind: "unresolved" });
+	for (const channelExpression of channels.values()) {
+		const channel = unwrapExpression(channelExpression);
+		if (!ts.isObjectLiteralExpression(channel)) return Object.freeze({ kind: "unresolved" });
+		const properties = getClosedObjectProperties(channel);
+		if (properties === null || properties.has("tools")) return Object.freeze({ kind: "unresolved" });
+	}
+	return Object.freeze({ kind: "absent" });
+};
+//#endregion
+//#region src/source-analysis/think-tools.ts
+/** Extracts the direct tools expression returned by a closed Think `getTools` method. */
+var getCloudflareAgentsThinkTools = (definition) => {
+	const method = getCloudflareAgentsMethod(definition.methods, "getTools", 0);
+	if (method === null || method.body.statements.length !== 1) return Object.freeze({ kind: "absent" });
+	const statement = method.body.statements[0];
+	return statement !== void 0 && ts.isReturnStatement(statement) && statement.expression !== void 0 ? Object.freeze({
+		expression: unwrapExpression(statement.expression),
+		kind: "present"
+	}) : Object.freeze({ kind: "unresolved" });
+};
+//#endregion
+//#region src/source-analysis/generation-requests.ts
+/** Finds supported direct AI SDK requests in the method's own lexical body. */
+var getCloudflareAgentsGenerationRequests = (method, analysis) => {
+	const requests = [];
+	const visit = (node) => {
+		if (node !== method.body && ts.isFunctionLike(node)) return;
+		if (ts.isCallExpression(node)) {
+			const callee = unwrapExpression(node.expression);
+			const argument = node.arguments[0] === void 0 ? null : unwrapExpression(node.arguments[0]);
+			if (ts.isIdentifier(callee) && isModuleBindingVisible(callee, analysis) && argument !== null && ts.isObjectLiteralExpression(argument)) {
+				const call = analysis.imports.generateTextNames.has(callee.text) ? "generateText" : analysis.imports.streamTextNames.has(callee.text) ? "streamText" : null;
+				if (call !== null && node.arguments.length === 1) {
+					const relationships = analyzeCloudflareAgentsObjectRelationships(argument, [
+						"instructions",
+						"system",
+						"output",
+						"tools",
+						"prepareStep"
+					]);
+					const instructions = relationships.prepareStep.kind !== "absent" ? { kind: "unresolved" } : relationships.instructions.kind !== "absent" ? relationships.instructions : relationships.system;
+					requests.push(Object.freeze({
+						call,
+						instructions,
+						object: argument,
+						output: relationships.output,
+						tools: relationships.tools
+					}));
+				}
+			}
+		}
+		ts.forEachChild(node, visit);
+	};
+	visit(method.body);
+	return Object.freeze(requests);
+};
+//#endregion
+//#region src/source-analysis/ai-chat-agents.ts
+/** Extracts direct AI SDK requests from the supported AIChatAgent handler. */
+var getCloudflareAgentsAiChatRequests = (definition, analysis) => {
+	const method = getCloudflareAgentsMethod(definition.methods, "onChatMessage", 2);
+	return method === null ? Object.freeze([]) : getCloudflareAgentsGenerationRequests(method, analysis);
+};
+//#endregion
+//#region src/source-analysis/output-specifications.ts
+/** Classifies a direct AI SDK `Output.object(...)` schema relationship. */
+var getCloudflareAgentsOutputSchema = (relationship, analysis) => {
+	if (relationship.kind !== "present") return relationship;
+	const candidate = unwrapExpression(relationship.expression);
+	if (!ts.isCallExpression(candidate) || candidate.arguments.length !== 1) return Object.freeze({ kind: "unresolved" });
+	const callee = unwrapExpression(candidate.expression);
+	if (!ts.isPropertyAccessExpression(callee) || callee.name.text !== "object" || !ts.isIdentifier(unwrapExpression(callee.expression))) return Object.freeze({ kind: "unresolved" });
+	const output = unwrapExpression(callee.expression);
+	const object = unwrapExpression(candidate.arguments[0]);
+	if (!analysis.imports.outputNames.has(output.text) || !isModuleBindingVisible(output, analysis) || !ts.isObjectLiteralExpression(object) || hasCloudflareAgentsPrototypeSetter(object)) return Object.freeze({ kind: "unresolved" });
+	let schema = { kind: "absent" };
+	const seen = /* @__PURE__ */ new Set();
+	for (const property of object.properties) {
+		if (ts.isSpreadAssignment(property) || ts.isComputedPropertyName(property.name)) return Object.freeze({ kind: "unresolved" });
+		const name = getCloudflareAgentsPropertyName(property.name);
+		if (name === null || ![
+			"description",
+			"name",
+			"schema"
+		].includes(name) || seen.has(name)) return Object.freeze({ kind: "unresolved" });
+		seen.add(name);
+		if (name === "schema") schema = ts.isPropertyAssignment(property) ? {
+			expression: unwrapExpression(property.initializer),
+			kind: "present"
+		} : ts.isShorthandPropertyAssignment(property) ? {
+			expression: property.name,
+			kind: "present"
+		} : { kind: "unresolved" };
+	}
+	return Object.freeze(schema.kind === "absent" ? { kind: "unresolved" } : schema);
+};
+//#endregion
+//#region src/source-analysis/function-tools.ts
+var TOLERATED_PROPERTY_NAMES = /* @__PURE__ */ new Set([
+	"contextSchema",
+	"description",
+	"execute",
+	"inputExamples",
+	"inputSchema",
+	"metadata",
+	"needsApproval",
+	"onInputAvailable",
+	"onInputDelta",
+	"onInputStart",
+	"outputSchema",
+	"providerOptions",
+	"strict",
+	"title",
+	"toModelOutput",
+	"type"
+]);
+/** Classifies one direct AI SDK function-tool declaration. */
+var getCloudflareAgentsFunctionTool = (analysis, declaration) => {
+	if (declaration.initializer === void 0) return null;
+	const call = unwrapExpression(declaration.initializer);
+	if (!ts.isCallExpression(call) || call.arguments.length !== 1) return null;
+	const callee = unwrapExpression(call.expression);
+	const object = unwrapExpression(call.arguments[0]);
+	if (!ts.isIdentifier(callee) || !analysis.imports.toolNames.has(callee.text) || !isModuleBindingVisible(callee, analysis) || !ts.isObjectLiteralExpression(object)) return null;
+	const names = /* @__PURE__ */ new Set();
+	for (const property of object.properties) {
+		if (ts.isSpreadAssignment(property) || ts.isComputedPropertyName(property.name)) return null;
+		const name = getCloudflareAgentsPropertyName(property.name);
+		if (name === null || !TOLERATED_PROPERTY_NAMES.has(name) || names.has(name)) return null;
+		names.add(name);
+	}
+	if (!names.has("inputSchema")) return null;
+	const relationships = analyzeCloudflareAgentsObjectRelationships(object, [
+		"execute",
+		"inputSchema",
+		"outputSchema"
+	]);
+	return Object.freeze({
+		declaration,
+		...relationships
+	});
+};
+//#endregion
+//#region src/source-analysis/agent-tools.ts
+/** Classifies one direct Cloudflare `agentTool(...)` declaration. */
+var getCloudflareAgentsAgentTool = (analysis, declaration) => {
+	if (declaration.initializer === void 0) return null;
+	const call = unwrapExpression(declaration.initializer);
+	if (!ts.isCallExpression(call) || call.arguments.length < 1 || call.arguments.length > 2) return null;
+	const callee = unwrapExpression(call.expression);
+	const target = unwrapExpression(call.arguments[0]);
+	if (!ts.isIdentifier(callee) || !analysis.imports.agentToolNames.has(callee.text) || !isModuleBindingVisible(callee, analysis) || !ts.isIdentifier(target)) return null;
+	const options = call.arguments[1];
+	let description = null;
+	if (options !== void 0) {
+		const candidate = unwrapExpression(options);
+		if (!ts.isObjectLiteralExpression(candidate)) return null;
+		const properties = getClosedObjectProperties(candidate);
+		if (properties === null || [...properties.keys()].some((name) => !["description", "name"].includes(name))) return null;
+		description = getStaticString(properties.get("description"));
+		if (properties.has("description") && description === null) return null;
+	}
+	return Object.freeze({
+		declaration,
+		description,
+		target
+	});
+};
+//#endregion
+//#region src/source-analysis/tool-maps.ts
+/** Classifies one direct tools-map object while retaining supported own entries. */
+var getCloudflareAgentsToolMap = (object) => {
+	const entries = [];
+	const names = /* @__PURE__ */ new Set();
+	let isUnresolved = false;
+	for (const property of object.properties) {
+		if (ts.isSpreadAssignment(property) || ts.isComputedPropertyName(property.name)) {
+			isUnresolved = true;
+			continue;
+		}
+		const name = getCloudflareAgentsPropertyName(property.name);
+		if (name === null || names.has(name)) {
+			isUnresolved = true;
+			continue;
+		}
+		names.add(name);
+		if (ts.isPropertyAssignment(property) && name !== "__proto__") entries.push(Object.freeze({
+			expression: unwrapExpression(property.initializer),
+			name
+		}));
+		else if (ts.isShorthandPropertyAssignment(property)) entries.push(Object.freeze({
+			expression: property.name,
+			name
+		}));
+		else if (name !== "__proto__") isUnresolved = true;
+	}
+	return Object.freeze({
+		entries: Object.freeze(entries),
+		kind: isUnresolved ? "unresolved" : "closed"
+	});
+};
+//#endregion
+//#region src/diagnostics/index.ts
+var CLOUDFLARE_AGENTS_ADAPTER_DIAGNOSTICS = Object.freeze({
+	CLOUDFLARE_AGENTS_AGENT_OUTPUT_SCHEMA_NOT_WIRED: "The declared agent output schema is not wired to the detected AIChatAgent structured output.",
+	CLOUDFLARE_AGENTS_AGENT_OUTPUT_SCHEMA_SYMBOL_NOT_FOUND: "The declared agent output-schema symbol was not found.",
+	CLOUDFLARE_AGENTS_HANDOFF_ROUTING_DESCRIPTION_MISSING: "The detected Cloudflare agent-tool routing description is missing.",
+	CLOUDFLARE_AGENTS_HANDOFF_ROUTING_DESCRIPTION_NOT_WIRED: "The detected Cloudflare agent-tool routing description is not wired to the target agent's effective routing description.",
+	CLOUDFLARE_AGENTS_HANDOFF_TARGET_AMBIGUOUS: "The detected Cloudflare agent-tool target maps to more than one registered agent.",
+	CLOUDFLARE_AGENTS_INSTRUCTION_LOADER_NOT_WIRED: "The declared instruction loader is not wired to a supported configured Cloudflare agent instruction source.",
+	CLOUDFLARE_AGENTS_INSTRUCTION_LOADER_SYMBOL_NOT_FOUND: "The declared instruction-loader symbol was not found.",
+	CLOUDFLARE_AGENTS_PACKAGE_MANIFEST_INVALID: "The owning package manifest is invalid for Cloudflare Agents dependency detection.",
+	CLOUDFLARE_AGENTS_RUNTIME_AGENT_SYMBOL_NOT_FOUND: "The declared runtime-agent symbol was not found.",
+	CLOUDFLARE_AGENTS_RUNTIME_VERSION_UNSUPPORTED: "The observed Cloudflare Agents dependency range is disjoint from the supported target.",
+	CLOUDFLARE_AGENTS_SOURCE_SYNTAX_INVALID: "The referenced Cloudflare Agents source file contains invalid TypeScript syntax.",
+	CLOUDFLARE_AGENTS_SOURCE_TEXT_INVALID: "The referenced Cloudflare Agents source file is not valid normalized text.",
+	CLOUDFLARE_AGENTS_TOOL_IMPLEMENTATION_NOT_WIRED: "The declared tool implementation is not wired to the detected Cloudflare agent function tool.",
+	CLOUDFLARE_AGENTS_TOOL_IMPLEMENTATION_SYMBOL_NOT_FOUND: "The declared tool-implementation symbol was not found.",
+	CLOUDFLARE_AGENTS_TOOL_INPUT_SCHEMA_NOT_WIRED: "The declared tool input schema is not wired to the detected Cloudflare agent function tool.",
+	CLOUDFLARE_AGENTS_TOOL_INPUT_SCHEMA_SYMBOL_NOT_FOUND: "The declared tool input-schema symbol was not found.",
+	CLOUDFLARE_AGENTS_TOOL_NAME_MISMATCH: "The declared tool name does not match the detected Cloudflare agent tools-map key.",
+	CLOUDFLARE_AGENTS_TOOL_OUTPUT_SCHEMA_NOT_WIRED: "The declared tool output schema is not wired to the detected Cloudflare agent function tool.",
+	CLOUDFLARE_AGENTS_TOOL_OUTPUT_SCHEMA_SYMBOL_NOT_FOUND: "The declared tool output-schema symbol was not found.",
+	CLOUDFLARE_AGENTS_TOOL_REGISTRATION_NOT_WIRED: "The declared tool registration is not wired to the detected Cloudflare agent tools map.",
+	CLOUDFLARE_AGENTS_TOOL_REGISTRATION_SYMBOL_NOT_FOUND: "The declared tool-registration symbol was not found."
+});
+/** Creates one frozen, safely namespaced Cloudflare Agents adapter diagnostic. */
+var createCloudflareAgentsDiagnostic = (input) => Object.freeze({
+	...input,
+	details: Object.freeze({ ...input.details }),
+	entity: input.entity === null ? null : Object.freeze({ ...input.entity }),
+	message: CLOUDFLARE_AGENTS_ADAPTER_DIAGNOSTICS[input.code],
+	source: CLOUDFLARE_AGENTS_ADAPTER_ID
+});
+//#endregion
+//#region src/inspection/common.ts
+/** Compares exact strings without locale-dependent behavior. */
+var compareCloudflareAgentsStrings = (left, right) => left < right ? -1 : left > right ? 1 : 0;
+var freezeReference = (reference) => Object.freeze({
+	path: reference.path,
+	...reference.symbol === void 0 ? {} : { symbol: reference.symbol }
+});
+/** Creates one deeply immutable Cloudflare Agents evidence record. */
+var createCloudflareAgentsEvidence = (evidence) => Object.freeze({
+	...evidence,
+	details: Object.freeze({ ...evidence.details }),
+	references: Object.freeze(evidence.references.map(freezeReference))
+});
+var createEntity = (agentId, capabilityId) => Object.freeze({
+	adapterId: CLOUDFLARE_AGENTS_ADAPTER_ID,
+	agentId,
+	...capabilityId === void 0 ? {} : {
+		capabilityId,
+		capabilityKind: "tool"
+	}
+});
+/** Appends one stable package-owned diagnostic. */
+var addCloudflareAgentsDiagnostic = (diagnostics, code, path, agentId, range = null, capabilityId, details = {}) => {
+	diagnostics.push(createCloudflareAgentsDiagnostic({
+		code,
+		details,
+		entity: createEntity(agentId, capabilityId),
+		path,
+		pointer: null,
+		range
+	}));
+};
+/** Loads and validates one supported bound TypeScript source. */
+var analyzeCloudflareAgentsBoundReference = async (session, reference, diagnostics, agentId, capabilityId) => {
+	if (!isSupportedTypeScriptSourcePath(reference.path)) return null;
+	const result = await session.analyzeSource(reference.path);
+	if (result.kind === "invalid-text") {
+		addCloudflareAgentsDiagnostic(diagnostics, "CLOUDFLARE_AGENTS_SOURCE_TEXT_INVALID", reference.path, agentId, null, capabilityId);
+		return null;
+	}
+	if (result.kind === "invalid-syntax") {
+		addCloudflareAgentsDiagnostic(diagnostics, "CLOUDFLARE_AGENTS_SOURCE_SYNTAX_INVALID", reference.path, agentId, result.range, capabilityId);
+		return null;
+	}
+	return result.analysis;
+};
+/** Determines whether a declared symbol exists in its exact analyzed module. */
+var hasCloudflareAgentsSymbol = async (session, reference, diagnostics, agentId, missingCode, capabilityId) => {
+	const analysis = await analyzeCloudflareAgentsBoundReference(session, reference, diagnostics, agentId, capabilityId);
+	if (analysis === null || reference.symbol === void 0) return null;
+	if (!analysis.exports.has(reference.symbol)) {
+		addCloudflareAgentsDiagnostic(diagnostics, missingCode, reference.path, agentId, null, capabilityId);
+		return null;
+	}
+	return analysis;
+};
+//#endregion
+//#region src/inspection/package-inspection.ts
+var classifyDeclaration = (declaration, supportedRange) => {
+	const normalized = validRange(declaration.declaredRange, {
+		includePrerelease: false,
+		loose: false
+	});
+	if (normalized === null) return "ambiguous";
+	if (subset(normalized, supportedRange, {
+		includePrerelease: false,
+		loose: false
+	})) return "supported";
+	return intersects(normalized, supportedRange, {
+		includePrerelease: false,
+		loose: false
+	}) ? "ambiguous" : "unsupported";
+};
+var getTargetPackages = (targetId) => Object.freeze([
+	targetId === "typescript-ai-chat-agent-0-10-ai-sdk-7" ? {
+		packageName: CLOUDFLARE_AI_CHAT_PACKAGE_NAME,
+		supportedRange: CLOUDFLARE_AI_CHAT_SUPPORTED_RANGE
+	} : {
+		packageName: CLOUDFLARE_THINK_PACKAGE_NAME,
+		supportedRange: CLOUDFLARE_THINK_SUPPORTED_RANGE
+	},
+	{
+		packageName: CLOUDFLARE_AGENTS_PACKAGE_NAME,
+		supportedRange: CLOUDFLARE_AGENTS_SUPPORTED_RANGE
+	},
+	{
+		packageName: "ai",
+		supportedRange: AI_SDK_SUPPORTED_RANGE
+	}
+]);
+/** Inspects exact package declarations and gates one verified target. */
+var inspectCloudflareAgentsPackage = async (session, sourcePath, targetId, evidence, diagnostics, agentId) => {
+	const discovery = await session.discoverPackage(sourcePath);
+	if (discovery.kind === "absent") return false;
+	if (discovery.kind === "invalid") {
+		addCloudflareAgentsDiagnostic(diagnostics, "CLOUDFLARE_AGENTS_PACKAGE_MANIFEST_INVALID", discovery.path, agentId);
+		return false;
+	}
+	for (const targetPackage of getTargetPackages(targetId)) {
+		const declarations = discovery.observation.declarations.get(targetPackage.packageName);
+		if (declarations === void 0 || declarations.length === 0) return false;
+		for (const declaration of declarations) {
+			const compatibility = classifyDeclaration(declaration, targetPackage.supportedRange);
+			if (compatibility === "unsupported") {
+				addCloudflareAgentsDiagnostic(diagnostics, "CLOUDFLARE_AGENTS_RUNTIME_VERSION_UNSUPPORTED", discovery.observation.path, agentId, null, void 0, {
+					declaredRange: declaration.declaredRange,
+					packageName: targetPackage.packageName,
+					targetId
+				});
+				return false;
+			}
+			evidence.push(createCloudflareAgentsEvidence({
+				agentId,
+				capabilityId: null,
+				capabilityKind: null,
+				details: {
+					compatibility,
+					declaredRange: declaration.declaredRange,
+					dependencyKind: declaration.dependencyKind,
+					targetId
+				},
+				kind: "runtime-package",
+				references: [{ path: discovery.observation.path }],
+				runtimeName: targetPackage.packageName,
+				source: CLOUDFLARE_AGENTS_ADAPTER_ID
+			}));
+		}
+	}
+	return true;
+};
+//#endregion
+//#region src/inspection/resolution.ts
+var resolveVariableReference = async (session, analysis, expression) => {
+	const candidate = unwrapExpression(expression);
+	if (!ts.isIdentifier(candidate)) return null;
+	const references = resolveBindingReferences(candidate, analysis);
+	for (const reference of references) {
+		const path = parseRepositoryPath(reference.path);
+		const targetAnalysis = path === analysis.path ? analysis : await session.analyzeSource(path).then((result) => result.kind === "valid" ? result.analysis : null);
+		if (targetAnalysis === null) continue;
+		const declaration = targetAnalysis.moduleConstDeclarations.get(reference.symbol);
+		if (declaration !== void 0) return Object.freeze({
+			analysis: targetAnalysis,
+			declaration,
+			reference: Object.freeze({
+				path,
+				symbol: reference.symbol
+			})
+		});
+	}
+	return null;
+};
+/** Resolves one supported inline, local, or relative-imported tools map. */
+var resolveCloudflareAgentsToolMap = async (session, analysis, relationship) => {
+	if (relationship.kind !== "present") return null;
+	const candidate = unwrapExpression(relationship.expression);
+	if (ts.isObjectLiteralExpression(candidate)) return Object.freeze({
+		analysis,
+		map: getCloudflareAgentsToolMap(candidate),
+		reference: null
+	});
+	const resolved = await resolveVariableReference(session, analysis, candidate);
+	if (resolved?.declaration.initializer === void 0) return null;
+	const initializer = unwrapExpression(resolved.declaration.initializer);
+	return ts.isObjectLiteralExpression(initializer) ? Object.freeze({
+		analysis: resolved.analysis,
+		map: getCloudflareAgentsToolMap(initializer),
+		reference: resolved.reference
+	}) : null;
+};
+/** Resolves one supported ordinary tool or `agentTool` declaration from a map entry. */
+var resolveCloudflareAgentsToolDefinition = async (session, analysis, expression) => {
+	const resolved = await resolveVariableReference(session, analysis, expression);
+	if (resolved === null) return null;
+	const functionTool = getCloudflareAgentsFunctionTool(resolved.analysis, resolved.declaration);
+	if (functionTool !== null) return Object.freeze({
+		analysis: resolved.analysis,
+		definition: Object.freeze({
+			kind: "function-tool",
+			tool: functionTool
+		}),
+		reference: resolved.reference
+	});
+	const agentTool = getCloudflareAgentsAgentTool(resolved.analysis, resolved.declaration);
+	return agentTool === null ? null : Object.freeze({
+		analysis: resolved.analysis,
+		definition: Object.freeze({
+			kind: "agent-tool",
+			tool: agentTool
+		}),
+		reference: resolved.reference
+	});
+};
+//#endregion
+//#region src/inspection/handoffs.ts
+var findTargetAgents = (target, analysis, agents) => {
+	const candidate = unwrapExpression(target);
+	if (!ts.isIdentifier(candidate)) return Object.freeze([]);
+	const references = resolveBindingReferences(candidate, analysis);
+	return Object.freeze(agents.filter((agent) => {
+		const runtimeAgent = agent.declaration.bindings?.runtimeAgent;
+		return runtimeAgent?.symbol !== void 0 && references.some((reference) => reference.path === runtimeAgent.path && reference.symbol === runtimeAgent.symbol);
+	}));
+};
+/** Inspects active Cloudflare `agentTool` helpers as runtime handoff registrations. */
+var inspectCloudflareAgentsHandoffs = async (session, sourceAgent, agents, resolvedMaps, evidence, diagnostics) => {
+	for (const resolvedMap of resolvedMaps) for (const entry of resolvedMap.map.entries) {
+		const resolved = await resolveCloudflareAgentsToolDefinition(session, resolvedMap.analysis, entry.expression);
+		if (resolved?.definition.kind !== "agent-tool") continue;
+		const targets = findTargetAgents(resolved.definition.tool.target, resolved.analysis, agents);
+		if (targets.length > 1) {
+			addCloudflareAgentsDiagnostic(diagnostics, "CLOUDFLARE_AGENTS_HANDOFF_TARGET_AMBIGUOUS", resolved.reference.path, sourceAgent.id, null, void 0, { toolName: entry.name });
+			continue;
+		}
+		const target = targets[0];
+		if (target === void 0) continue;
+		const description = resolved.definition.tool.description;
+		const effectiveDescription = target.handoffDescription?.value ?? target.description.value;
+		if (description === null || description.length === 0) {
+			addCloudflareAgentsDiagnostic(diagnostics, "CLOUDFLARE_AGENTS_HANDOFF_ROUTING_DESCRIPTION_MISSING", resolved.reference.path, sourceAgent.id, null, void 0, {
+				targetAgentId: target.id,
+				toolName: entry.name
+			});
+			continue;
+		}
+		if (description !== effectiveDescription) {
+			addCloudflareAgentsDiagnostic(diagnostics, "CLOUDFLARE_AGENTS_HANDOFF_ROUTING_DESCRIPTION_NOT_WIRED", resolved.reference.path, sourceAgent.id, null, void 0, {
+				targetAgentId: target.id,
+				toolName: entry.name
+			});
+			continue;
+		}
+		const targetReference = target.declaration.bindings?.runtimeAgent;
+		if (targetReference === void 0) continue;
+		evidence.push(createCloudflareAgentsEvidence({
+			agentId: sourceAgent.id,
+			capabilityId: null,
+			capabilityKind: null,
+			details: {
+				targetAgentId: target.id,
+				toolName: entry.name
+			},
+			kind: "handoff-registration",
+			references: [resolved.reference, targetReference],
+			runtimeName: entry.name,
+			source: CLOUDFLARE_AGENTS_ADAPTER_ID
+		}));
+	}
+};
+//#endregion
+//#region src/inspection/relationships.ts
+var inspectBinding = async (session, agent, relationship, analysis, reference, symbolMissingCode, notWiredCode, evidenceKind, evidence, diagnostics, schemaRole) => {
+	if (await hasCloudflareAgentsSymbol(session, reference, diagnostics, agent.id, symbolMissingCode) === null) return;
+	if ((evidenceKind === "instruction-loader" ? classifyCloudflareAgentsInstructionLoader(relationship, analysis, reference) : classifyCloudflareAgentsDirectBinding(relationship, analysis, reference)) !== true) {
+		addCloudflareAgentsDiagnostic(diagnostics, notWiredCode, reference.path, agent.id);
+		return;
+	}
+	evidence.push(createCloudflareAgentsEvidence({
+		agentId: agent.id,
+		capabilityId: null,
+		capabilityKind: null,
+		details: schemaRole === void 0 ? {} : { schemaRole },
+		kind: evidenceKind,
+		references: [reference],
+		runtimeName: reference.symbol ?? null,
+		source: CLOUDFLARE_AGENTS_ADAPTER_ID
+	}));
+};
+var inspectToolReference = async (session, agent, capabilityId, relationship, relationshipAnalysis, reference, symbolMissingCode, notWiredCode, diagnostics) => {
+	if (reference === void 0) return true;
+	if (await hasCloudflareAgentsSymbol(session, reference, diagnostics, agent.id, symbolMissingCode, capabilityId) === null) return false;
+	if (classifyCloudflareAgentsDirectBinding(relationship, relationshipAnalysis, reference) !== true) {
+		addCloudflareAgentsDiagnostic(diagnostics, notWiredCode, reference.path, agent.id, null, capabilityId);
+		return false;
+	}
+	return true;
+};
+var inspectTools = async (session, inspected, agents, evidence, diagnostics) => {
+	if (inspected.tools.some((relationship) => relationship.kind === "unresolved")) return;
+	const presentRelationships = inspected.tools.filter((relationship) => relationship.kind === "present");
+	const resolvedMaps = (await Promise.all(presentRelationships.map((relationship) => resolveCloudflareAgentsToolMap(session, inspected.analysis, relationship)))).filter((map) => map !== null && map.map.kind === "closed");
+	if (resolvedMaps.length !== presentRelationships.length) return;
+	await inspectCloudflareAgentsHandoffs(session, inspected.agent, agents, resolvedMaps, evidence, diagnostics);
+	for (const [capabilityId, tool] of Object.entries(inspected.agent.declaration.tools ?? {})) {
+		if (tool.registration === void 0) continue;
+		await hasCloudflareAgentsSymbol(session, tool.registration, diagnostics, inspected.agent.id, "CLOUDFLARE_AGENTS_TOOL_REGISTRATION_SYMBOL_NOT_FOUND", capabilityId);
+		let matchedEntry;
+		for (const resolvedMap of resolvedMaps) for (const entry of resolvedMap.map.entries) if (classifyCloudflareAgentsDirectBinding({
+			expression: entry.expression,
+			kind: "present"
+		}, resolvedMap.analysis, tool.registration) === true) {
+			matchedEntry = {
+				analysis: resolvedMap.analysis,
+				...entry
+			};
+			break;
+		}
+		if (matchedEntry === void 0) {
+			addCloudflareAgentsDiagnostic(diagnostics, "CLOUDFLARE_AGENTS_TOOL_REGISTRATION_NOT_WIRED", tool.registration.path, inspected.agent.id, null, capabilityId);
+			continue;
+		}
+		if (matchedEntry.name !== tool.name) {
+			addCloudflareAgentsDiagnostic(diagnostics, "CLOUDFLARE_AGENTS_TOOL_NAME_MISMATCH", tool.registration.path, inspected.agent.id, null, capabilityId, {
+				declaredName: tool.name,
+				detectedName: matchedEntry.name
+			});
+			continue;
+		}
+		const resolvedTool = await resolveCloudflareAgentsToolDefinition(session, matchedEntry.analysis, matchedEntry.expression);
+		if (resolvedTool?.definition.kind !== "function-tool") continue;
+		const functionTool = resolvedTool.definition.tool;
+		const implementationMatches = await inspectToolReference(session, inspected.agent, capabilityId, functionTool.execute, resolvedTool.analysis, tool.implementation, "CLOUDFLARE_AGENTS_TOOL_IMPLEMENTATION_SYMBOL_NOT_FOUND", "CLOUDFLARE_AGENTS_TOOL_IMPLEMENTATION_NOT_WIRED", diagnostics);
+		const inputMatches = await inspectToolReference(session, inspected.agent, capabilityId, functionTool.inputSchema, resolvedTool.analysis, tool.inputSchema, "CLOUDFLARE_AGENTS_TOOL_INPUT_SCHEMA_SYMBOL_NOT_FOUND", "CLOUDFLARE_AGENTS_TOOL_INPUT_SCHEMA_NOT_WIRED", diagnostics);
+		const outputMatches = await inspectToolReference(session, inspected.agent, capabilityId, functionTool.outputSchema, resolvedTool.analysis, tool.outputSchema, "CLOUDFLARE_AGENTS_TOOL_OUTPUT_SCHEMA_SYMBOL_NOT_FOUND", "CLOUDFLARE_AGENTS_TOOL_OUTPUT_SCHEMA_NOT_WIRED", diagnostics);
+		if (implementationMatches && inputMatches && outputMatches) {
+			evidence.push(createCloudflareAgentsEvidence({
+				agentId: inspected.agent.id,
+				capabilityId,
+				capabilityKind: "tool",
+				details: { toolName: matchedEntry.name },
+				kind: "tool-registration",
+				references: [tool.registration, tool.implementation],
+				runtimeName: matchedEntry.name,
+				source: CLOUDFLARE_AGENTS_ADAPTER_ID
+			}));
+			for (const [schemaRole, reference] of [["tool-input", tool.inputSchema], ["tool-output", tool.outputSchema]]) if (reference !== void 0) evidence.push(createCloudflareAgentsEvidence({
+				agentId: inspected.agent.id,
+				capabilityId,
+				capabilityKind: "tool",
+				details: { schemaRole },
+				kind: "schema",
+				references: [reference],
+				runtimeName: reference.symbol ?? null,
+				source: CLOUDFLARE_AGENTS_ADAPTER_ID
+			}));
+		}
+	}
+};
+/** Inspects manifest relationships for every supported Cloudflare runtime agent. */
+var inspectCloudflareAgentsRelationships = async (session, inspectedAgents, evidence, diagnostics) => {
+	const verifiedAgents = Object.freeze(inspectedAgents.map(({ agent }) => agent));
+	for (const inspected of inspectedAgents) {
+		const bindings = inspected.agent.declaration.bindings;
+		if (bindings?.instructionLoader !== void 0) await inspectBinding(session, inspected.agent, inspected.instructions, inspected.analysis, bindings.instructionLoader, "CLOUDFLARE_AGENTS_INSTRUCTION_LOADER_SYMBOL_NOT_FOUND", "CLOUDFLARE_AGENTS_INSTRUCTION_LOADER_NOT_WIRED", "instruction-loader", evidence, diagnostics);
+		if (bindings?.outputSchema !== void 0) await inspectBinding(session, inspected.agent, getCloudflareAgentsOutputSchema(inspected.output, inspected.analysis), inspected.analysis, bindings.outputSchema, "CLOUDFLARE_AGENTS_AGENT_OUTPUT_SCHEMA_SYMBOL_NOT_FOUND", "CLOUDFLARE_AGENTS_AGENT_OUTPUT_SCHEMA_NOT_WIRED", "schema", evidence, diagnostics, "agent-output");
+		await inspectTools(session, inspected, verifiedAgents, evidence, diagnostics);
+	}
+};
+//#endregion
+//#region src/package-discovery/index.ts
+var PACKAGE_NAMES = Object.freeze([
+	CLOUDFLARE_THINK_PACKAGE_NAME,
+	CLOUDFLARE_AI_CHAT_PACKAGE_NAME,
+	CLOUDFLARE_AGENTS_PACKAGE_NAME,
+	"ai"
+]);
+var 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. */
+var createCloudflareAgentsPackageManifestCandidatePaths = (sourcePath) => createPackageManifestCandidatePaths(sourcePath).map((path) => parseRepositoryPath(path));
+var extractDeclarations = (manifest) => {
+	const declarations = /* @__PURE__ */ new Map();
+	for (const field of DEPENDENCY_FIELDS) {
+		const dependencies = manifest[field];
+		if (dependencies === void 0) continue;
+		if (!isRecord(dependencies)) return null;
+		for (const packageName of PACKAGE_NAMES) {
+			const declaredRange = dependencies[packageName];
+			if (declaredRange === void 0) continue;
+			if (typeof declaredRange !== "string" || declaredRange.trim().length === 0) return null;
+			const entries = declarations.get(packageName) ?? [];
+			entries.push(Object.freeze({
+				declaredRange,
+				dependencyKind: field
+			}));
+			declarations.set(packageName, entries);
+		}
+	}
+	return new Map([...declarations].map(([packageName, entries]) => [packageName, Object.freeze(entries)]));
+};
+/** Discovers the nearest manifest containing a Cloudflare Agents target dependency. */
+var discoverCloudflareAgentsPackage = async (repository, sourcePath, signal) => {
+	const options = signal === void 0 ? void 0 : { signal };
+	for (const candidatePath of createCloudflareAgentsPackageManifestCandidatePaths(sourcePath)) {
+		signal?.throwIfAborted();
+		const entry = await repository.getEntry(candidatePath, options);
+		if (entry === null) continue;
+		if (entry.type !== "file") return Object.freeze({
+			kind: "invalid",
+			path: candidatePath
+		});
+		const text = normalizeText(await repository.readFile(candidatePath, options));
+		if (!text.valid) return Object.freeze({
+			kind: "invalid",
+			path: candidatePath
+		});
+		let parsed;
+		try {
+			parsed = JSON.parse(text.value);
+		} catch {
+			return Object.freeze({
+				kind: "invalid",
+				path: candidatePath
+			});
+		}
+		if (!isRecord(parsed)) return Object.freeze({
+			kind: "invalid",
+			path: candidatePath
+		});
+		const declarations = extractDeclarations(parsed);
+		if (declarations === null) return Object.freeze({
+			kind: "invalid",
+			path: candidatePath
+		});
+		if (!declarations.has("@cloudflare/think") && !declarations.has("@cloudflare/ai-chat")) return Object.freeze({ kind: "absent" });
+		return Object.freeze({
+			kind: "observed",
+			observation: Object.freeze({
+				declarations,
+				path: parseRepositoryPath(posix.normalize(candidatePath))
+			})
+		});
+	}
+	return Object.freeze({ kind: "absent" });
+};
+//#endregion
+//#region src/inspection/session.ts
+/** Creates one operation-local Cloudflare Agents inspection session. */
+var createCloudflareAgentsInspectionSession = (context) => createInspectionSession({
+	analyzeSource: analyzeCloudflareAgentsSource,
+	discoverPackage: (path, signal) => discoverCloudflareAgentsPackage(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 combineRelationships = (relationships) => {
+	const present = relationships.filter((relationship) => relationship.kind === "present");
+	if (relationships.some((relationship) => relationship.kind === "unresolved") || present.length > 1) return Object.freeze({ kind: "unresolved" });
+	return Object.freeze(present[0] ?? { kind: "absent" });
+};
+var inspectAgent = async (session, agent, evidence, diagnostics) => {
+	const runtimeAgent = agent.declaration.bindings?.runtimeAgent;
+	if (runtimeAgent === void 0 || !isSupportedTypeScriptSourcePath(runtimeAgent.path)) return null;
+	evidence.push(createCloudflareAgentsEvidence({
+		agentId: agent.id,
+		capabilityId: null,
+		capabilityKind: null,
+		details: { language: "typescript" },
+		kind: "language",
+		references: [runtimeAgent],
+		runtimeName: null,
+		source: CLOUDFLARE_AGENTS_ADAPTER_ID
+	}));
+	if (runtimeAgent.symbol === void 0) return null;
+	const analysis = await analyzeCloudflareAgentsBoundReference(session, runtimeAgent, diagnostics, agent.id);
+	if (analysis === null) return null;
+	if (!analysis.exports.has(runtimeAgent.symbol)) {
+		addCloudflareAgentsDiagnostic(diagnostics, "CLOUDFLARE_AGENTS_RUNTIME_AGENT_SYMBOL_NOT_FOUND", runtimeAgent.path, agent.id);
+		return null;
+	}
+	const classResult = getCloudflareAgentsClassDefinition(analysis, runtimeAgent.symbol);
+	if (classResult.kind === "absent") return null;
+	const targetId = classResult.kind === "present-supported" ? classResult.definition.targetId : classResult.targetId;
+	if (targetId === void 0) return null;
+	if (!await inspectCloudflareAgentsPackage(session, runtimeAgent.path, targetId, evidence, diagnostics, agent.id)) return null;
+	evidence.push(createCloudflareAgentsEvidence({
+		agentId: agent.id,
+		capabilityId: null,
+		capabilityKind: null,
+		details: { targetId },
+		kind: "agent-definition",
+		references: [runtimeAgent],
+		runtimeName: runtimeAgent.symbol,
+		source: CLOUDFLARE_AGENTS_ADAPTER_ID
+	}));
+	if (classResult.kind !== "present-supported") return null;
+	if (classResult.definition.targetId === "typescript-ai-chat-agent-0-10-ai-sdk-7") {
+		const requests = getCloudflareAgentsAiChatRequests(classResult.definition, analysis);
+		if (requests.length === 0) return Object.freeze({
+			agent,
+			analysis,
+			definition: classResult.definition,
+			instructions: Object.freeze({ kind: "absent" }),
+			output: Object.freeze({ kind: "absent" }),
+			requests,
+			tools: Object.freeze([])
+		});
+		evidence.push(createCloudflareAgentsEvidence({
+			agentId: agent.id,
+			capabilityId: null,
+			capabilityKind: null,
+			details: { calls: [...new Set(requests.map(({ call }) => call))].join(",") },
+			kind: "runtime-pattern",
+			references: [runtimeAgent],
+			runtimeName: runtimeAgent.symbol,
+			source: CLOUDFLARE_AGENTS_ADAPTER_ID
+		}));
+		return Object.freeze({
+			agent,
+			analysis,
+			definition: classResult.definition,
+			instructions: combineRelationships(requests.map(({ instructions }) => instructions)),
+			output: combineRelationships(requests.map(({ output }) => output)),
+			requests,
+			tools: Object.freeze(requests.map(({ tools }) => tools))
+		});
+	}
+	const thinkTools = combineRelationships([getCloudflareAgentsThinkTools(classResult.definition), getCloudflareAgentsThinkChannelTools(classResult.definition)]);
+	return Object.freeze({
+		agent,
+		analysis,
+		definition: classResult.definition,
+		instructions: combineRelationships([getCloudflareAgentsThinkSystemPrompt(classResult.definition), getCloudflareAgentsThinkSessionInstructions(classResult.definition)]),
+		output: Object.freeze({ kind: "absent" }),
+		requests: Object.freeze([]),
+		tools: Object.freeze([thinkTools])
+	});
+};
+/**
+* Inspects all scoped Cloudflare Agents 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 inspectCloudflareAgents = async (context) => {
+	context.signal?.throwIfAborted();
+	const session = createCloudflareAgentsInspectionSession(context);
+	const evidence = [];
+	const diagnostics = [];
+	const agents = [...context.agents].sort((left, right) => compareCloudflareAgentsStrings(left.id, right.id));
+	const inspectedAgents = [];
+	for (const agent of agents) {
+		context.signal?.throwIfAborted();
+		const inspected = await inspectAgent(session, agent, evidence, diagnostics);
+		if (inspected !== null) inspectedAgents.push(inspected);
+	}
+	context.signal?.throwIfAborted();
+	await inspectCloudflareAgentsRelationships(session, inspectedAgents, evidence, diagnostics);
+	return Object.freeze({
+		diagnostics: Object.freeze(diagnostics),
+		evidence: Object.freeze(evidence)
+	});
+};
+//#endregion
+//#region src/adapter/index.ts
+var cloudflareAgentsAdapter = Object.freeze({
+	id: CLOUDFLARE_AGENTS_ADAPTER_ID,
+	inspect: inspectCloudflareAgents,
+	supportedRepositoryFormatVersions: CLOUDFLARE_AGENTS_SUPPORTED_REPOSITORY_FORMAT_VERSIONS
+});
+//#endregion
+export { cloudflareAgentsAdapter };