@moldea.ai/adapter-openai-agents-sdk 1.0.1 → 1.0.3

package/README.md

@@ -8,7 +8,7 @@ The package implements the official `openai-agents-sdk` runtime adapter for `@mo
 
 ## Supported target
 
-Version `1.0.1` experimentally supports:
+Version `1.0.3` experimentally supports:
 
 - Repository Format version `1`
 - `@moldea.ai/core ^2.0.0`

package/dist/index.js

@@ -186,14 +186,8 @@ var classifyPackageDeclarations = (declarations, supportedRange) => {
 	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;
+var readOwningManifest = async (options) => {
+	const { reader, signal, sourcePath } = options;
 	for (const manifestPath of createPackageManifestCandidatePaths(sourcePath)) {
 		signal?.throwIfAborted();
 		const entry = await reader.getEntry(manifestPath);
@@ -221,28 +215,48 @@ var discoverPackage = async (options) => {
 			});
 		}
 		signal?.throwIfAborted();
-		if (!isRecord(parsed)) return Object.freeze({
-			kind: "invalid",
+		return isRecord(parsed) ? Object.freeze({
+			kind: "present",
+			manifest: parsed,
 			path: manifestPath
-		});
-		const declarations = extractPackageDeclarations(parsed, packageName);
-		if (declarations === null) return Object.freeze({
+		}) : 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" });
 };
 /**
+* 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 { includeManifestPackageName, packageName, reader, signal, sourcePath, supportedRange } = options;
+	const owningManifest = await readOwningManifest({
+		reader,
+		...signal === void 0 ? {} : { signal },
+		sourcePath
+	});
+	if (owningManifest.kind !== "present") return owningManifest;
+	const declarations = extractPackageDeclarations(owningManifest.manifest, packageName);
+	if (declarations === null) return Object.freeze({
+		kind: "invalid",
+		path: owningManifest.path
+	});
+	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),
+			...includeManifestPackageName === true ? { manifestPackageName: typeof owningManifest.manifest["name"] === "string" ? owningManifest.manifest["name"] : null } : {},
+			path: owningManifest.path
+		})
+	});
+};
+/**
 * Removes the transparent expression wrappers supported by runtime adapters.
 * @param expression The expression to normalize.
 * @returns The underlying expression used by static matching.
@@ -605,6 +619,117 @@ function getSafeModuleConstLiteral(expression, analysis, allowedReferences, kind
 		expression: initializer
 	});
 }
+var skipTransparentParents = (node) => {
+	let current = node;
+	while (ts.isAsExpression(current.parent) || ts.isParenthesizedExpression(current.parent) || ts.isSatisfiesExpression(current.parent)) current = current.parent;
+	return current;
+};
+var isAssignmentOperator = (kind) => kind >= ts.SyntaxKind.FirstAssignment && kind <= ts.SyntaxKind.LastAssignment;
+var isMutatingTarget = (expression) => {
+	const candidate = skipTransparentParents(expression);
+	const parent = candidate.parent;
+	return ts.isBinaryExpression(parent) && parent.left === candidate && isAssignmentOperator(parent.operatorToken.kind) || (ts.isPrefixUnaryExpression(parent) || ts.isPostfixUnaryExpression(parent)) && parent.operand === candidate && (parent.operator === ts.SyntaxKind.PlusPlusToken || parent.operator === ts.SyntaxKind.MinusMinusToken) || ts.isDeleteExpression(parent) && parent.expression === candidate || (ts.isForInStatement(parent) || ts.isForOfStatement(parent)) && parent.initializer === candidate;
+};
+var getStaticMemberName = (member) => {
+	if (ts.isPropertyAccessExpression(member)) return member.name.text;
+	const argument = member.argumentExpression;
+	return argument !== void 0 && (ts.isStringLiteral(argument) || ts.isNoSubstitutionTemplateLiteral(argument)) ? argument.text : null;
+};
+var isIgnoredIdentifier = (identifier, declarationName) => identifier === declarationName || ts.isImportSpecifier(identifier.parent) || ts.isPropertyAccessExpression(identifier.parent) && identifier.parent.name === identifier || ts.isPropertyAssignment(identifier.parent) && identifier.parent.name === identifier;
+var addObjectAssignmentMembers = (object, mutatedMembers) => {
+	let hasUnknownMutation = false;
+	for (const property of object.properties) {
+		if (!ts.isPropertyAssignment(property) && !ts.isShorthandPropertyAssignment(property) || ts.isComputedPropertyName(property.name)) {
+			hasUnknownMutation = true;
+			continue;
+		}
+		const propertyName = ts.isIdentifier(property.name) || ts.isStringLiteral(property.name) ? property.name.text : null;
+		if (propertyName === null) hasUnknownMutation = true;
+		else mutatedMembers.add(propertyName);
+	}
+	return hasUnknownMutation;
+};
+var analyzeMutationCall = (identifier, mutatedMembers) => {
+	const candidate = skipTransparentParents(identifier);
+	const parent = candidate.parent;
+	if (!ts.isCallExpression(parent)) return null;
+	const callee = unwrapExpression(parent.expression);
+	if (ts.isPropertyAccessExpression(callee) && ts.isIdentifier(callee.expression) && callee.expression.text === "Object" && callee.name.text === "assign" && parent.arguments[0] === candidate) {
+		let hasUnknownMutation = parent.arguments.length < 2;
+		for (const source of parent.arguments.slice(1)) {
+			const assignmentSource = unwrapExpression(source);
+			if (!ts.isObjectLiteralExpression(assignmentSource)) hasUnknownMutation = true;
+			else if (addObjectAssignmentMembers(assignmentSource, mutatedMembers)) hasUnknownMutation = true;
+		}
+		return hasUnknownMutation;
+	}
+	if (ts.isPropertyAccessExpression(callee) && ts.isIdentifier(callee.expression) && callee.expression.text === "Reflect" && callee.name.text === "set" && parent.arguments[0] === candidate) {
+		const member = parent.arguments[1];
+		if (member !== void 0 && (ts.isStringLiteral(member) || ts.isNoSubstitutionTemplateLiteral(member))) {
+			mutatedMembers.add(member.text);
+			return false;
+		}
+		return true;
+	}
+	return true;
+};
+/**
+* Classifies module-local mutations and escapes for one returned object value.
+* @param analysis The indexed source containing the binding.
+* @param declaration The module-local constant declaration.
+* @param allowedReferences Bare identifier uses proven to be supported registrations or targets.
+* @param safeMethodCalls Read-only method calls that preserve the value's runtime configuration.
+* @returns Member-specific mutations and whether an unknown use can affect every relationship.
+*/
+var analyzeModuleValueMutations = (analysis, declaration, allowedReferences, safeMethodCalls = /* @__PURE__ */ new Set()) => {
+	if (!ts.isIdentifier(declaration.name)) return Object.freeze({
+		hasUnknownMutation: true,
+		mutatedMembers: /* @__PURE__ */ new Set()
+	});
+	const mutatedMembers = /* @__PURE__ */ new Set();
+	let hasUnknownMutation = false;
+	for (const identifier of analysis.identifierUses.get(declaration.name.text) ?? []) {
+		if (isIgnoredIdentifier(identifier, declaration.name) || !isModuleBindingVisible(identifier, analysis) || allowedReferences.has(identifier)) continue;
+		const expression = skipTransparentParents(identifier);
+		const parent = expression.parent;
+		const member = (ts.isPropertyAccessExpression(parent) || ts.isElementAccessExpression(parent)) && parent.expression === expression ? parent : null;
+		if (member !== null) {
+			const memberName = getStaticMemberName(member);
+			if (memberName === null) hasUnknownMutation = true;
+			else if (isMutatingTarget(member)) mutatedMembers.add(memberName);
+			else {
+				const memberExpression = skipTransparentParents(member);
+				const memberParent = memberExpression.parent;
+				if ((ts.isPropertyAccessExpression(memberParent) || ts.isElementAccessExpression(memberParent)) && memberParent.expression === memberExpression && ts.isCallExpression(skipTransparentParents(memberParent).parent)) mutatedMembers.add(memberName);
+				else if (ts.isCallExpression(memberParent) && memberParent.expression === memberExpression) {
+					if (!safeMethodCalls.has(memberName)) mutatedMembers.add(memberName);
+				}
+			}
+			continue;
+		}
+		if (isMutatingTarget(identifier)) {
+			hasUnknownMutation = true;
+			continue;
+		}
+		const mutationCall = analyzeMutationCall(identifier, mutatedMembers);
+		hasUnknownMutation ||= mutationCall ?? true;
+	}
+	return Object.freeze({
+		hasUnknownMutation,
+		mutatedMembers: new Set(mutatedMembers)
+	});
+};
+var TYPESCRIPT_DECLARATION_EXTENSIONS = [
+	".d.ts",
+	".d.tsx",
+	".d.mts",
+	".d.cts"
+];
+var TYPESCRIPT_SOURCE_EXTENSIONS = [
+	".ts",
+	".tsx",
+	".mts"
+];
 var getScriptKind = (path) => path.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS;
 var createSyntaxProgram = (sourceFile, text) => {
 	return ts.createProgram({
@@ -687,11 +812,7 @@ var analyzeTypeScriptModule = (path, bytes, importConfig, signal) => {
 * @param path The bound source path.
 * @returns Whether its extension is supported.
 */
-var isSupportedTypeScriptSourcePath = (path) => [
-	".ts",
-	".tsx",
-	".mts"
-].some((extension) => path.endsWith(extension));
+var isSupportedTypeScriptSourcePath = (path) => !TYPESCRIPT_DECLARATION_EXTENSIONS.some((extension) => path.endsWith(extension)) && TYPESCRIPT_SOURCE_EXTENSIONS.some((extension) => path.endsWith(extension));
 /**
 * Classifies a direct exported runtime-agent function and exposes its body.
 * @param analysis The indexed runtime source.
@@ -753,105 +874,71 @@ var getConstExport = (analysis, symbol) => {
 		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);
+var resolveCandidatePath = async (options, containingPath, moduleSpecifier) => {
+	const matchingPaths = [];
+	for (const candidate of resolveImportCandidatePaths(containingPath, moduleSpecifier)) {
+		const path = options.parsePath(candidate);
+		if ((await options.getEntry(path))?.type === "file") matchingPaths.push(path);
 	}
-	return hasUnknownMutation;
+	return matchingPaths.length === 1 ? matchingPaths[0] : null;
 };
-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;
+var resolveStaticStringExpression = async (options, analysis, expression, visited) => {
+	options.signal?.throwIfAborted();
+	const candidate = unwrapExpression(expression);
+	const literal = getStaticString(candidate);
+	if (literal !== null) return Object.freeze({
+		expression: candidate,
+		kind: "supported",
+		value: literal
+	});
+	if (!ts.isIdentifier(candidate) || !isModuleBindingVisible(candidate, analysis)) return Object.freeze({ kind: "unsupported" });
+	const localDeclaration = analysis.moduleConstDeclarations.get(candidate.text);
+	if (localDeclaration?.initializer !== void 0) {
+		const key = `${analysis.path}\0local\0${candidate.text}`;
+		if (visited.has(key)) return Object.freeze({ kind: "unsupported" });
+		visited.add(key);
+		const result = await resolveStaticStringExpression(options, analysis, localDeclaration.initializer, visited);
+		visited.delete(key);
+		return result;
 	}
-	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;
+	const namedImport = analysis.namedImports.get(candidate.text);
+	if (namedImport === void 0) return Object.freeze({ kind: "unsupported" });
+	const importedPath = await resolveCandidatePath(options, analysis.path, namedImport.moduleSpecifier);
+	if (importedPath === null) return Object.freeze({ kind: "unsupported" });
+	const key = `${importedPath}\0export\0${namedImport.importedName}`;
+	if (visited.has(key)) return Object.freeze({ kind: "unsupported" });
+	visited.add(key);
+	const importedResult = await options.analyzeSource(importedPath);
+	if (importedResult.kind !== "valid") {
+		options.onSourceFailure?.(importedPath, importedResult);
+		visited.delete(key);
+		return Object.freeze({ kind: "unsupported" });
 	}
-	return true;
+	const exported = getConstExport(importedResult.analysis, namedImport.importedName);
+	if (exported.kind !== "present-supported" || exported.expression === void 0) {
+		visited.delete(key);
+		return Object.freeze({ kind: "unsupported" });
+	}
+	const result = await resolveStaticStringExpression(options, importedResult.analysis, exported.expression, visited);
+	visited.delete(key);
+	return result;
 };
 /**
+* Resolves one exact supported static string without normalization or execution.
+* @param options The source, expression, repository callbacks, and parser for the relationship.
+* @returns The exact compiler-parsed string or an unsupported state.
+*/
+var resolveStaticString = (options) => resolveStaticStringExpression(options, options.analysis, options.expression, /* @__PURE__ */ new Set());
+//#endregion
+//#region src/source-analysis/mutations.ts
+/**
 * 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)
-	});
-};
+var analyzeOpenAiAgentsSdkMutations = (analysis, declaration, allowedReferences) => analyzeModuleValueMutations(analysis, declaration, allowedReferences);
 //#endregion
 //#region src/source-analysis/agent-definitions.ts
 var RELATIONSHIP_NAMES = [
@@ -1307,54 +1394,6 @@ var analyzeOpenAiAgentsSdkSource = (path, bytes, signal) => {
 };
 //#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.
@@ -1362,7 +1401,14 @@ var resolveStaticString = async (session, analysis, expression, visited) => {
 * @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());
+var resolveOpenAiAgentsSdkStaticString = (session, analysis, expression) => resolveStaticString({
+	analysis,
+	analyzeSource: (path) => session.analyzeSource(path),
+	expression,
+	getEntry: (path) => session.getEntry(path),
+	parsePath: parseRepositoryPath,
+	...session.signal === void 0 ? {} : { signal: session.signal }
+});
 //#endregion
 //#region src/source-analysis/tool-collections.ts
 var getClosedToolArray = (relationship, analysis, allowedCollectionReferences) => {

package/dist/source-analysis/mutations.d.ts

@@ -1,4 +1,4 @@
-import ts from 'typescript';
+import type ts from 'typescript';
 import type { IOpenAiAgentsSdkSourceAnalysis } from '../contracts/index.js';
 export interface IOpenAiAgentsSdkMutationAnalysis {
     readonly hasUnknownMutation: boolean;

package/dist/source-analysis/mutations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mutations.d.ts","sourceRoot":"","sources":["../../src/source-analysis/mutations.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAI5B,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,uBAAuB,CAAC;AAE5E,MAAM,WAAW,gCAAgC;IAC/C,QAAQ,CAAC,kBAAkB,EAAE,OAAO,CAAC;IACrC,QAAQ,CAAC,cAAc,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CAC9C;AAiJD;;;;;;GAMG;AACH,eAAO,MAAM,+BAA+B,GAC1C,UAAU,8BAA8B,EACxC,aAAa,EAAE,CAAC,mBAAmB,EACnC,mBAAmB,WAAW,CAAC,EAAE,CAAC,UAAU,CAAC,KAC5C,gCAmEF,CAAC"}
+{"version":3,"file":"mutations.d.ts","sourceRoot":"","sources":["../../src/source-analysis/mutations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAIjC,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,uBAAuB,CAAC;AAE5E,MAAM,WAAW,gCAAgC;IAC/C,QAAQ,CAAC,kBAAkB,EAAE,OAAO,CAAC;IACrC,QAAQ,CAAC,cAAc,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CAC9C;AAED;;;;;;GAMG;AACH,eAAO,MAAM,+BAA+B,GAC1C,UAAU,8BAA8B,EACxC,aAAa,EAAE,CAAC,mBAAmB,EACnC,mBAAmB,WAAW,CAAC,EAAE,CAAC,UAAU,CAAC,KAC5C,gCACoE,CAAC"}

package/dist/source-analysis/static-strings.d.ts

@@ -1,4 +1,4 @@
-import ts from 'typescript';
+import type ts from 'typescript';
 import type { IOpenAiAgentsSdkInspectionSession, IOpenAiAgentsSdkSourceAnalysis, IOpenAiAgentsSdkStaticStringResult } from '../contracts/index.js';
 /**
  * Resolves one exact supported static string without normalization or execution.

package/dist/source-analysis/static-strings.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"static-strings.d.ts","sourceRoot":"","sources":["../../src/source-analysis/static-strings.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAW5B,OAAO,KAAK,EACV,iCAAiC,EACjC,8BAA8B,EAC9B,kCAAkC,EACnC,MAAM,uBAAuB,CAAC;AA4G/B;;;;;;GAMG;AACH,eAAO,MAAM,kCAAkC,GAC7C,SAAS,iCAAiC,EAC1C,UAAU,8BAA8B,EACxC,YAAY,EAAE,CAAC,UAAU,KACxB,OAAO,CAAC,kCAAkC,CAC0B,CAAC"}
+{"version":3,"file":"static-strings.d.ts","sourceRoot":"","sources":["../../src/source-analysis/static-strings.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAKjC,OAAO,KAAK,EACV,iCAAiC,EACjC,8BAA8B,EAC9B,kCAAkC,EACnC,MAAM,uBAAuB,CAAC;AAE/B;;;;;;GAMG;AACH,eAAO,MAAM,kCAAkC,GAC7C,SAAS,iCAAiC,EAC1C,UAAU,8BAA8B,EACxC,YAAY,EAAE,CAAC,UAAU,KACxB,OAAO,CAAC,kCAAkC,CAQzC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moldea.ai/adapter-openai-agents-sdk",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Deterministic runtime evidence and diagnostics for direct OpenAI Agents SDK integrations.",
   "homepage": "https://github.com/moldea-ai/packages/tree/main/projects/adapter-openai-agents-sdk#readme",
   "bugs": {