@cascade-fyi/sati-agent0-sdk 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1452 @@
+import { ContentType, ContentType as ContentType$1, MAX_SINGLE_SIGNATURE_CONTENT_SIZE, Outcome, Outcome as Outcome$1, SATI_PROGRAM_ADDRESS, Sati, TOKEN_2022_PROGRAM_ADDRESS, buildCounterpartyMessage, buildRegistrationFile, buildRegistrationFile as buildRegistrationFile$1, createPinataUploader, fetchRegistrationFile, fetchRegistryConfig, findAgentIndexPda, findAssociatedTokenAddress, findRegistryConfigPda, getImageUrl, getRegisterAgentInstructionAsync, handleTransactionError, loadDeployedConfig, parseFeedbackContent, serializeFeedback, stringifyRegistrationFile, zeroDataHash } from "@cascade-fyi/sati-sdk";
+import { address, generateKeyPairSigner, getAddressDecoder, signBytes } from "@solana/kit";
+import { getCreateAssociatedTokenIdempotentInstruction, getTransferInstruction, getUpdateTokenMetadataFieldInstruction, tokenMetadataField } from "@solana-program/token-2022";
+import { EndpointCrawler, EndpointCrawler as EndpointCrawler$1, EndpointType, EndpointType as EndpointType$1, TrustModel, TrustModel as TrustModel$1 } from "agent0-sdk";
+
+//#region src/adapters.ts
+/** CAIP-2 chain references for Solana networks */
+const SOLANA_CAIP2_CHAINS = {
+	mainnet: "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
+	devnet: "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1",
+	localnet: "solana:localnet"
+};
+/**
+* Format a SATI agent as a CAIP-2 compatible AgentId string.
+*
+* Format: `solana:<chainRef>:<mintAddress>`
+*/
+function formatSatiAgentId(mint, chain) {
+	return `${chain}:${mint}`;
+}
+/**
+* Parse a SATI CAIP-2 AgentId back to a mint address.
+* Returns null if the agentId is not a Solana agent.
+*
+* Expected format: `solana:<chainRef>:<mintAddress>`
+*/
+function parseSatiAgentId(agentId) {
+	if (!agentId.startsWith("solana:")) return null;
+	const parts = agentId.split(":");
+	if (parts.length !== 3) return null;
+	return parts[2];
+}
+const SATI_TO_AGENT0_TYPE = {
+	MCP: EndpointType$1.MCP,
+	A2A: EndpointType$1.A2A,
+	ENS: EndpointType$1.ENS,
+	DID: EndpointType$1.DID,
+	AGENTWALLET: EndpointType$1.WALLET,
+	WALLET: EndpointType$1.WALLET,
+	OASF: EndpointType$1.OASF
+};
+const AGENT0_TO_SATI_NAME = {
+	[EndpointType$1.MCP]: "MCP",
+	[EndpointType$1.A2A]: "A2A",
+	[EndpointType$1.ENS]: "ENS",
+	[EndpointType$1.DID]: "DID",
+	[EndpointType$1.WALLET]: "agentWallet",
+	[EndpointType$1.OASF]: "OASF"
+};
+/**
+* Convert SATI endpoints (ERC-8004 format) to agent0 endpoint format.
+*/
+function toAgent0Endpoints(satiEndpoints) {
+	return satiEndpoints.map((ep) => {
+		const meta = {};
+		if (ep.version) meta.version = ep.version;
+		if (ep.mcpTools?.length) meta.mcpTools = ep.mcpTools;
+		if (ep.mcpPrompts?.length) meta.mcpPrompts = ep.mcpPrompts;
+		if (ep.mcpResources?.length) meta.mcpResources = ep.mcpResources;
+		if (ep.a2aSkills?.length) meta.a2aSkills = ep.a2aSkills;
+		if (ep.skills?.length) meta.skills = ep.skills;
+		if (ep.domains?.length) meta.domains = ep.domains;
+		return {
+			type: SATI_TO_AGENT0_TYPE[ep.name.toUpperCase()] ?? ep.name,
+			value: ep.endpoint,
+			meta: Object.keys(meta).length > 0 ? meta : void 0
+		};
+	});
+}
+/**
+* Convert agent0 endpoints to SATI registration file endpoint format.
+*/
+function fromAgent0Endpoints(agent0Endpoints) {
+	return agent0Endpoints.map((ep) => {
+		const result = {
+			name: AGENT0_TO_SATI_NAME[ep.type] ?? ep.type,
+			endpoint: ep.value,
+			version: ep.meta?.version
+		};
+		if (ep.meta?.mcpTools) result.mcpTools = ep.meta.mcpTools;
+		if (ep.meta?.mcpPrompts) result.mcpPrompts = ep.meta.mcpPrompts;
+		if (ep.meta?.mcpResources) result.mcpResources = ep.meta.mcpResources;
+		if (ep.meta?.a2aSkills) result.a2aSkills = ep.meta.a2aSkills;
+		if (ep.meta?.skills) result.skills = ep.meta.skills;
+		if (ep.meta?.domains) result.domains = ep.meta.domains;
+		return result;
+	});
+}
+/**
+* Convert a SATI AgentIdentity + optional registration file to agent0 AgentSummary.
+*
+* @param identity - On-chain agent identity
+* @param chain - CAIP-2 chain reference (e.g. "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp")
+* @param regFile - Off-chain registration file (optional)
+* @param feedbackStats - Pre-computed feedback stats (optional, from includeFeedbackStats)
+*/
+function toAgentSummary(identity, chain, regFile, feedbackStats) {
+	const endpoints = regFile?.endpoints ?? [];
+	const mcpEp = endpoints.find((e) => e.name.toUpperCase() === "MCP");
+	const a2aEp = endpoints.find((e) => e.name.toUpperCase() === "A2A");
+	const oasfEp = endpoints.find((e) => e.name.toUpperCase() === "OASF");
+	const ensEp = endpoints.find((e) => e.name.toUpperCase() === "ENS");
+	const didEp = endpoints.find((e) => e.name.toUpperCase() === "DID");
+	const walletEp = endpoints.find((e) => e.name.toUpperCase() === "AGENTWALLET" || e.name.toUpperCase() === "WALLET");
+	const webEp = endpoints.find((e) => e.name.toUpperCase() === "WEB");
+	return {
+		chainId: 0,
+		agentId: formatSatiAgentId(identity.mint, chain),
+		name: identity.name,
+		image: regFile?.image,
+		description: regFile?.description ?? "",
+		owners: [identity.owner],
+		operators: [],
+		mcp: mcpEp?.endpoint,
+		a2a: a2aEp?.endpoint,
+		web: webEp?.endpoint,
+		ens: ensEp?.endpoint,
+		did: didEp?.endpoint,
+		walletAddress: walletEp?.endpoint,
+		supportedTrusts: regFile?.supportedTrust ?? [],
+		mcpTools: mcpEp?.mcpTools ?? [],
+		mcpPrompts: mcpEp?.mcpPrompts ?? [],
+		mcpResources: mcpEp?.mcpResources ?? [],
+		a2aSkills: a2aEp?.a2aSkills ?? [],
+		oasfSkills: oasfEp?.skills ?? [],
+		oasfDomains: oasfEp?.domains ?? [],
+		active: regFile?.active ?? true,
+		x402support: regFile?.x402support ?? false,
+		agentURI: identity.uri,
+		agentURIType: identity.uri ? detectURIType(identity.uri) : void 0,
+		feedbackCount: feedbackStats?.count,
+		averageValue: feedbackStats?.averageValue,
+		extras: {}
+	};
+}
+/** Detect URI type from prefix. */
+function detectURIType(uri) {
+	if (uri.startsWith("ipfs://") || uri.includes("/ipfs/")) return "ipfs";
+	if (uri.startsWith("ar://") || uri.includes("arweave.net")) return "arweave";
+	if (uri.startsWith("https://") || uri.startsWith("http://")) return "https";
+	return "unknown";
+}
+/**
+* Convert a SATI registration file to agent0 RegistrationFile format.
+*
+* @param satiFile - SATI registration file
+* @param identity - On-chain agent identity (optional)
+* @param chain - CAIP-2 chain reference (required when identity is provided)
+*/
+function toAgent0RegistrationFile(satiFile, identity, chain) {
+	const endpoints = toAgent0Endpoints(satiFile.endpoints ?? []);
+	const trustModels = (satiFile.supportedTrust ?? []).map((t) => {
+		if (t === "reputation") return TrustModel$1.REPUTATION;
+		if (t === "crypto-economic") return TrustModel$1.CRYPTO_ECONOMIC;
+		if (t === "tee-attestation") return TrustModel$1.TEE_ATTESTATION;
+		return t;
+	});
+	return {
+		agentId: identity && chain ? formatSatiAgentId(identity.mint, chain) : void 0,
+		agentURI: identity?.uri,
+		name: satiFile.name,
+		description: satiFile.description,
+		image: satiFile.image,
+		endpoints,
+		trustModels,
+		owners: identity ? [identity.owner] : [],
+		operators: [],
+		active: satiFile.active ?? true,
+		x402support: satiFile.x402support ?? false,
+		metadata: {},
+		updatedAt: Math.floor(Date.now() / 1e3)
+	};
+}
+/**
+* Convert agent0 RegistrationFile back to SATI registration file params.
+*/
+function fromAgent0RegistrationFile(agent0File) {
+	const endpoints = fromAgent0Endpoints(agent0File.endpoints);
+	const supportedTrust = agent0File.trustModels.map((t) => {
+		if (t === TrustModel$1.REPUTATION) return "reputation";
+		if (t === TrustModel$1.CRYPTO_ECONOMIC) return "crypto-economic";
+		if (t === TrustModel$1.TEE_ATTESTATION) return "tee-attestation";
+		return null;
+	}).filter((t) => t !== null);
+	return {
+		name: agent0File.name,
+		description: agent0File.description,
+		image: agent0File.image ?? "",
+		endpoints,
+		supportedTrust,
+		active: agent0File.active,
+		x402support: agent0File.x402support
+	};
+}
+/**
+* Convert SATI feedback attestation data to agent0 Feedback format.
+*
+* SATI stores feedback as compressed attestations with:
+* - outcome (always Neutral for FeedbackPublicV1)
+* - content JSON with value, tag1, tag2, endpoint
+*
+* agent0-sdk expects the Feedback interface with value, tags, endpoint, etc.
+*/
+function toFeedback(opts) {
+	const agentId = formatSatiAgentId(opts.agentMint, opts.chain);
+	const tags = [];
+	if (opts.content.tag1) tags.push(opts.content.tag1);
+	if (opts.content.tag2) tags.push(opts.content.tag2);
+	const id = [
+		agentId,
+		opts.reviewer,
+		opts.feedbackIndex
+	];
+	const context = { ...opts.content.context };
+	if (opts.outcome !== void 0) context.outcome = opts.outcome;
+	return {
+		id,
+		agentId,
+		reviewer: opts.reviewer,
+		txHash: opts.txSignature,
+		value: opts.content.value,
+		tags,
+		endpoint: opts.content.endpoint,
+		text: opts.content.text,
+		context: Object.keys(context).length > 0 ? context : opts.content.context,
+		createdAt: opts.createdAt ?? Math.floor(Date.now() / 1e3),
+		answers: [],
+		isRevoked: false
+	};
+}
+
+//#endregion
+//#region src/agent.ts
+/**
+* Agent0-compatible agent class backed by SATI's Solana infrastructure.
+*
+* Manages an in-memory registration file that can be flushed to chain
+* via `registerIPFS()`.
+*/
+var SatiAgent = class SatiAgent {
+	_registrationFile;
+	_endpointCrawler;
+	_identity;
+	_sdk;
+	constructor(sdk, registrationFile) {
+		this._sdk = sdk;
+		this._registrationFile = registrationFile;
+		this._endpointCrawler = new EndpointCrawler$1(5e3);
+	}
+	/** @internal Access the underlying SatiSDK instance. */
+	get sdk() {
+		return this._sdk;
+	}
+	/**
+	* Create a new agent in memory (not yet registered on-chain).
+	* @internal Called by SatiSDK.createAgent()
+	*/
+	static create(sdk, name, description, image) {
+		return new SatiAgent(sdk, {
+			name,
+			description,
+			image,
+			endpoints: [],
+			trustModels: [TrustModel$1.REPUTATION],
+			owners: [],
+			operators: [],
+			active: false,
+			x402support: false,
+			metadata: {},
+			updatedAt: Math.floor(Date.now() / 1e3)
+		});
+	}
+	/**
+	* Reconstruct an agent from on-chain identity and registration file.
+	* @internal Called by SatiSDK.loadAgent()
+	*/
+	static fromIdentity(sdk, identity, registrationFile) {
+		const agent = new SatiAgent(sdk, registrationFile);
+		agent._identity = identity;
+		agent._registrationFile.agentId = formatSatiAgentId(identity.mint, sdk.chain);
+		agent._registrationFile.agentURI = identity.uri;
+		return agent;
+	}
+	get agentId() {
+		return this._registrationFile.agentId;
+	}
+	get agentURI() {
+		return this._registrationFile.agentURI;
+	}
+	get name() {
+		return this._registrationFile.name;
+	}
+	get description() {
+		return this._registrationFile.description;
+	}
+	get image() {
+		return this._registrationFile.image;
+	}
+	get mcpEndpoint() {
+		return this._registrationFile.endpoints.find((e) => e.type === EndpointType$1.MCP)?.value;
+	}
+	get a2aEndpoint() {
+		return this._registrationFile.endpoints.find((e) => e.type === EndpointType$1.A2A)?.value;
+	}
+	get walletAddress() {
+		return this._registrationFile.walletAddress;
+	}
+	/** SATI-specific: the on-chain agent identity (available after registration). */
+	get identity() {
+		return this._identity;
+	}
+	get ensEndpoint() {
+		return this._registrationFile.endpoints.find((e) => e.type === EndpointType$1.ENS)?.value;
+	}
+	get didEndpoint() {
+		return this._registrationFile.endpoints.find((e) => e.type === EndpointType$1.DID)?.value;
+	}
+	get mcpTools() {
+		return this._registrationFile.endpoints.find((e) => e.type === EndpointType$1.MCP)?.meta?.mcpTools ?? [];
+	}
+	get mcpPrompts() {
+		return this._registrationFile.endpoints.find((e) => e.type === EndpointType$1.MCP)?.meta?.mcpPrompts ?? [];
+	}
+	get mcpResources() {
+		return this._registrationFile.endpoints.find((e) => e.type === EndpointType$1.MCP)?.meta?.mcpResources ?? [];
+	}
+	get a2aSkills() {
+		return this._registrationFile.endpoints.find((e) => e.type === EndpointType$1.A2A)?.meta?.a2aSkills ?? [];
+	}
+	get oasfSkills() {
+		return this._registrationFile.endpoints.find((e) => e.type === EndpointType$1.OASF)?.meta?.skills ?? [];
+	}
+	get oasfDomains() {
+		return this._registrationFile.endpoints.find((e) => e.type === EndpointType$1.OASF)?.meta?.domains ?? [];
+	}
+	/**
+	* Set MCP endpoint. Auto-fetches capabilities by default.
+	*/
+	async setMCP(endpoint, version = "2025-06-18", autoFetch = true) {
+		this._registrationFile.endpoints = this._registrationFile.endpoints.filter((ep) => ep.type !== EndpointType$1.MCP);
+		const meta = { version };
+		if (autoFetch) try {
+			const capabilities = await this._endpointCrawler.fetchMcpCapabilities(endpoint);
+			if (capabilities) {
+				if (capabilities.mcpTools) meta.mcpTools = capabilities.mcpTools;
+				if (capabilities.mcpPrompts) meta.mcpPrompts = capabilities.mcpPrompts;
+				if (capabilities.mcpResources) meta.mcpResources = capabilities.mcpResources;
+			}
+		} catch {}
+		this._registrationFile.endpoints.push({
+			type: EndpointType$1.MCP,
+			value: endpoint,
+			meta
+		});
+		this._registrationFile.updatedAt = Math.floor(Date.now() / 1e3);
+		return this;
+	}
+	/**
+	* Set A2A endpoint. Auto-fetches capabilities by default.
+	*/
+	async setA2A(agentcard, version = "0.30", autoFetch = true) {
+		this._registrationFile.endpoints = this._registrationFile.endpoints.filter((ep) => ep.type !== EndpointType$1.A2A);
+		const meta = { version };
+		if (autoFetch) try {
+			const capabilities = await this._endpointCrawler.fetchA2aCapabilities(agentcard);
+			if (capabilities?.a2aSkills) meta.a2aSkills = capabilities.a2aSkills;
+		} catch {}
+		this._registrationFile.endpoints.push({
+			type: EndpointType$1.A2A,
+			value: agentcard,
+			meta
+		});
+		this._registrationFile.updatedAt = Math.floor(Date.now() / 1e3);
+		return this;
+	}
+	/**
+	* Set ENS endpoint.
+	*/
+	setENS(name, version = "1.0") {
+		this._registrationFile.endpoints = this._registrationFile.endpoints.filter((ep) => ep.type !== EndpointType$1.ENS);
+		this._registrationFile.endpoints.push({
+			type: EndpointType$1.ENS,
+			value: name,
+			meta: { version }
+		});
+		this._registrationFile.updatedAt = Math.floor(Date.now() / 1e3);
+		return this;
+	}
+	/**
+	* Remove endpoint(s).
+	*/
+	removeEndpoint(opts) {
+		if (!opts || opts.type === void 0 && opts.value === void 0) this._registrationFile.endpoints = [];
+		else this._registrationFile.endpoints = this._registrationFile.endpoints.filter((ep) => {
+			const typeMatches = opts.type === void 0 || ep.type === opts.type;
+			const valueMatches = opts.value === void 0 || ep.value === opts.value;
+			return !(typeMatches && valueMatches);
+		});
+		this._registrationFile.updatedAt = Math.floor(Date.now() / 1e3);
+		return this;
+	}
+	/**
+	* Remove all endpoints (alias for removeEndpoint() with no args).
+	*/
+	removeEndpoints() {
+		return this.removeEndpoint();
+	}
+	/**
+	* Get wallet address from the registration file.
+	*/
+	getWallet() {
+		return this._registrationFile.walletAddress;
+	}
+	/**
+	* Set wallet address and add a WALLET endpoint.
+	* In-memory only - call registerIPFS() or registerHTTP() to persist on-chain.
+	*/
+	setWallet(addr) {
+		this._registrationFile.walletAddress = addr;
+		this._registrationFile.endpoints = this._registrationFile.endpoints.filter((ep) => ep.type !== EndpointType$1.WALLET);
+		this._registrationFile.endpoints.push({
+			type: EndpointType$1.WALLET,
+			value: addr
+		});
+		this._registrationFile.updatedAt = Math.floor(Date.now() / 1e3);
+		return this;
+	}
+	/**
+	* Remove wallet address and wallet endpoint.
+	*/
+	unsetWallet() {
+		this._registrationFile.walletAddress = void 0;
+		this._registrationFile.endpoints = this._registrationFile.endpoints.filter((ep) => ep.type !== EndpointType$1.WALLET);
+		this._registrationFile.updatedAt = Math.floor(Date.now() / 1e3);
+		return this;
+	}
+	addSkill(slug) {
+		const oasfEp = this._getOrCreateOasfEndpoint();
+		if (!oasfEp.meta) oasfEp.meta = {};
+		if (!Array.isArray(oasfEp.meta.skills)) oasfEp.meta.skills = [];
+		const skills = oasfEp.meta.skills;
+		if (!skills.includes(slug)) skills.push(slug);
+		this._registrationFile.updatedAt = Math.floor(Date.now() / 1e3);
+		return this;
+	}
+	removeSkill(slug) {
+		const oasfEp = this._registrationFile.endpoints.find((ep) => ep.type === EndpointType$1.OASF);
+		if (oasfEp?.meta) {
+			const skills = oasfEp.meta.skills;
+			if (Array.isArray(skills)) {
+				const idx = skills.indexOf(slug);
+				if (idx !== -1) skills.splice(idx, 1);
+			}
+			this._registrationFile.updatedAt = Math.floor(Date.now() / 1e3);
+		}
+		return this;
+	}
+	addDomain(slug) {
+		const oasfEp = this._getOrCreateOasfEndpoint();
+		if (!oasfEp.meta) oasfEp.meta = {};
+		if (!Array.isArray(oasfEp.meta.domains)) oasfEp.meta.domains = [];
+		const domains = oasfEp.meta.domains;
+		if (!domains.includes(slug)) domains.push(slug);
+		this._registrationFile.updatedAt = Math.floor(Date.now() / 1e3);
+		return this;
+	}
+	removeDomain(slug) {
+		const oasfEp = this._registrationFile.endpoints.find((ep) => ep.type === EndpointType$1.OASF);
+		if (oasfEp?.meta) {
+			const domains = oasfEp.meta.domains;
+			if (Array.isArray(domains)) {
+				const idx = domains.indexOf(slug);
+				if (idx !== -1) domains.splice(idx, 1);
+			}
+			this._registrationFile.updatedAt = Math.floor(Date.now() / 1e3);
+		}
+		return this;
+	}
+	setActive(active) {
+		this._registrationFile.active = active;
+		this._registrationFile.updatedAt = Math.floor(Date.now() / 1e3);
+		return this;
+	}
+	setX402Support(x402Support) {
+		this._registrationFile.x402support = x402Support;
+		this._registrationFile.updatedAt = Math.floor(Date.now() / 1e3);
+		return this;
+	}
+	setTrust(reputation = false, cryptoEconomic = false, teeAttestation = false) {
+		const trustModels = [];
+		if (reputation) trustModels.push(TrustModel$1.REPUTATION);
+		if (cryptoEconomic) trustModels.push(TrustModel$1.CRYPTO_ECONOMIC);
+		if (teeAttestation) trustModels.push(TrustModel$1.TEE_ATTESTATION);
+		this._registrationFile.trustModels = trustModels;
+		this._registrationFile.updatedAt = Math.floor(Date.now() / 1e3);
+		return this;
+	}
+	setMetadata(kv) {
+		Object.assign(this._registrationFile.metadata, kv);
+		this._registrationFile.updatedAt = Math.floor(Date.now() / 1e3);
+		return this;
+	}
+	getMetadata() {
+		return { ...this._registrationFile.metadata };
+	}
+	delMetadata(key) {
+		if (key in this._registrationFile.metadata) {
+			delete this._registrationFile.metadata[key];
+			this._registrationFile.updatedAt = Math.floor(Date.now() / 1e3);
+		}
+		return this;
+	}
+	/**
+	* Update basic agent information.
+	*/
+	updateInfo(name, description, image) {
+		if (name !== void 0) this._registrationFile.name = name;
+		if (description !== void 0) this._registrationFile.description = description;
+		if (image !== void 0) this._registrationFile.image = image;
+		this._registrationFile.updatedAt = Math.floor(Date.now() / 1e3);
+		return this;
+	}
+	/**
+	* Get the current in-memory registration file.
+	*/
+	getRegistrationFile() {
+		return this._registrationFile;
+	}
+	/**
+	* Register agent on-chain with IPFS.
+	*
+	* Converts the in-memory agent0 registration file to SATI format,
+	* uploads to IPFS via Pinata, then mints the agent NFT on Solana.
+	*
+	* @throws Error if image URL is not set
+	* @throws Error if pinataJwt is not configured
+	* @throws Error if SDK is in read-only mode
+	*/
+	async registerIPFS() {
+		if (!this._registrationFile.image) throw new Error("Image URL is required for registration. Set it via updateInfo() or createAgent().");
+		const pinataJwt = this._sdk.config.pinataJwt;
+		if (!pinataJwt) throw new Error("pinataJwt is required for IPFS uploads. Set it in SatiSDKConfig.");
+		const satiParams = fromAgent0RegistrationFile(this._registrationFile);
+		const uploader = createPinataUploader(pinataJwt);
+		const uri = await this._sdk.sati.uploadRegistrationFile(satiParams, uploader);
+		return this._registerOnChain(uri);
+	}
+	/**
+	* Register agent on-chain with an HTTP URI.
+	*
+	* Same as registerIPFS but takes a URI directly instead of uploading to IPFS.
+	* Use this when you already have a hosted registration file.
+	*
+	* @throws Error if SDK is in read-only mode
+	*/
+	async registerHTTP(agentUri) {
+		return this._registerOnChain(agentUri);
+	}
+	/**
+	* Update the agent's on-chain URI (metadata pointer).
+	*
+	* @throws Error if agent is not registered on-chain
+	* @throws Error if SDK is in read-only mode
+	*/
+	async setAgentURI(agentURI) {
+		if (!this._identity) throw new Error("Agent is not registered on-chain. Call registerIPFS() or registerHTTP() first.");
+		const access = this._requireWriteAccess();
+		if (access.type === "keypair") {
+			const result = await this._sdk.sati.updateAgentMetadata({
+				payer: access.signer,
+				owner: access.signer,
+				mint: address(this._identity.mint),
+				updates: { uri: agentURI }
+			});
+			this._identity.uri = agentURI;
+			this._registrationFile.agentURI = agentURI;
+			return result;
+		}
+		const updateIx = getUpdateTokenMetadataFieldInstruction({
+			metadata: this._identity.mint,
+			updateAuthority: { address: address(access.sender.address) },
+			field: tokenMetadataField("Uri"),
+			value: agentURI
+		});
+		const signature = await access.sender.signAndSend([updateIx]);
+		this._identity.uri = agentURI;
+		this._registrationFile.agentURI = agentURI;
+		return { signature };
+	}
+	/**
+	* Transfer agent ownership to a new Solana address.
+	*
+	* @throws Error if agent is not registered on-chain
+	* @throws Error if SDK is in read-only mode
+	*/
+	async transfer(newOwner) {
+		if (!this._identity) throw new Error("Agent is not registered on-chain. Call registerIPFS() or registerHTTP() first.");
+		const access = this._requireWriteAccess();
+		if (access.type === "keypair") return this._sdk.sati.transferAgent({
+			payer: access.signer,
+			owner: access.signer,
+			mint: this._identity.mint,
+			newOwner: address(newOwner)
+		});
+		const ownerAddr = address(access.sender.address);
+		const [sourceAta] = await findAssociatedTokenAddress(this._identity.mint, ownerAddr);
+		const [destAta] = await findAssociatedTokenAddress(this._identity.mint, address(newOwner));
+		const createAtaIx = getCreateAssociatedTokenIdempotentInstruction({
+			payer: { address: ownerAddr },
+			owner: address(newOwner),
+			mint: this._identity.mint,
+			ata: destAta,
+			tokenProgram: TOKEN_2022_PROGRAM_ADDRESS
+		});
+		const transferIx = getTransferInstruction({
+			source: sourceAta,
+			destination: destAta,
+			authority: { address: ownerAddr },
+			amount: 1n
+		});
+		return { signature: await access.sender.signAndSend([createAtaIx, transferIx]) };
+	}
+	_requireWriteAccess() {
+		if (this._sdk.config.signer) return {
+			type: "keypair",
+			signer: this._sdk.config.signer
+		};
+		if (this._sdk.config.transactionSender) return {
+			type: "sender",
+			sender: this._sdk.config.transactionSender
+		};
+		throw new Error("This operation requires a signer or transactionSender. Initialize SatiSDK with one for write operations.");
+	}
+	/**
+	* Shared registration logic for registerIPFS/registerHTTP.
+	* Supports both keypair and sender paths.
+	*/
+	async _registerOnChain(uri) {
+		const access = this._requireWriteAccess();
+		if (access.type === "keypair") {
+			const result = await this._sdk.sati.registerAgent({
+				payer: access.signer,
+				name: this._registrationFile.name,
+				uri
+			});
+			const agentId = this._storeIdentity(result.mint, access.signer.address, uri, result.memberNumber);
+			return {
+				signature: result.signature,
+				agentId
+			};
+		}
+		const agentMint = await generateKeyPairSigner();
+		const rpc = this._sdk.sati.getRpc();
+		const [registryConfigAddress] = await findRegistryConfigPda();
+		const registryConfig = await fetchRegistryConfig(rpc, registryConfigAddress);
+		const groupMint = registryConfig.data.groupMint;
+		const ownerAddress = address(access.sender.address);
+		const [agentTokenAccount] = await findAssociatedTokenAddress(agentMint.address, ownerAddress);
+		const [agentIndex] = await findAgentIndexPda(registryConfig.data.totalAgents + 1n);
+		const registerIx = await getRegisterAgentInstructionAsync({
+			payer: { address: ownerAddress },
+			owner: ownerAddress,
+			groupMint,
+			agentMint,
+			agentTokenAccount,
+			agentIndex,
+			name: this._registrationFile.name,
+			symbol: "",
+			uri,
+			additionalMetadata: null,
+			nonTransferable: false
+		});
+		const signature = await access.sender.signAndSend([registerIx], [agentMint]);
+		const finalMemberNumber = (await fetchRegistryConfig(rpc, registryConfigAddress)).data.totalAgents;
+		return {
+			signature,
+			agentId: this._storeIdentity(agentMint.address, ownerAddress, uri, finalMemberNumber)
+		};
+	}
+	_storeIdentity(mint, owner, uri, memberNumber) {
+		this._identity = {
+			mint,
+			owner,
+			name: this._registrationFile.name,
+			uri,
+			memberNumber,
+			additionalMetadata: {},
+			nonTransferable: false
+		};
+		const agentId = formatSatiAgentId(mint, this._sdk.chain);
+		this._registrationFile.agentId = agentId;
+		this._registrationFile.agentURI = uri;
+		return agentId;
+	}
+	_getOrCreateOasfEndpoint() {
+		const existing = this._registrationFile.endpoints.find((ep) => ep.type === EndpointType$1.OASF);
+		if (existing) return existing;
+		const oasfEndpoint = {
+			type: EndpointType$1.OASF,
+			value: "https://github.com/agntcy/oasf/",
+			meta: {
+				version: "v0.8.0",
+				skills: [],
+				domains: []
+			}
+		};
+		this._registrationFile.endpoints.push(oasfEndpoint);
+		return oasfEndpoint;
+	}
+};
+
+//#endregion
+//#region src/sdk.ts
+/**
+* Main SDK class for the SATI Agent0 adapter.
+*
+* Provides agent0-sdk compatible method signatures backed by SATI's
+* Solana infrastructure. Drop-in replacement for agent0-sdk's SDK class
+* when working with SATI agents.
+*/
+/**
+* SATI Agent0 SDK - agent0-sdk compatible interface backed by Solana.
+*
+* Method signatures match agent0-sdk's `SDK` class so that example code
+* can switch between EVM and Solana by changing only the import and config.
+*
+* @example
+* ```typescript
+* import { SatiSDK } from "@cascade-fyi/sati-agent0-sdk";
+* import { generateKeyPairSigner } from "@solana/kit";
+*
+* const signer = await generateKeyPairSigner();
+* const sdk = new SatiSDK({
+*   network: "devnet",
+*   signer,
+* });
+*
+* const agent = sdk.createAgent("MyAgent", "An AI assistant");
+* ```
+*/
+var SatiSDK = class {
+	_config;
+	_sati;
+	_sasConfig;
+	_chain;
+	constructor(config) {
+		this._config = config;
+		this._sati = new Sati({
+			network: config.network,
+			rpcUrl: config.rpcUrl
+		});
+		this._sasConfig = loadDeployedConfig(config.network);
+		this._chain = SOLANA_CAIP2_CHAINS[config.network] ?? `solana:${config.network}`;
+	}
+	/** Get the SATI network. */
+	get network() {
+		return this._config.network;
+	}
+	/**
+	* Chain ID (0 for Solana - not an EVM chain).
+	* Use `chain` property for the CAIP-2 identifier.
+	*/
+	get chainId() {
+		return 0;
+	}
+	/** Get the CAIP-2 chain reference. */
+	get chain() {
+		return this._chain;
+	}
+	/** True if SDK has no signer or transaction sender configured (read-only mode). */
+	get isReadOnly() {
+		return !this._config.signer && !this._config.transactionSender;
+	}
+	/**
+	* Access the underlying SATI client for SATI-specific operations
+	* not covered by the agent0-sdk interface (e.g. validations, compression).
+	*/
+	get sati() {
+		return this._sati;
+	}
+	/** @internal Access the SAS schema config. */
+	get sasConfig() {
+		return this._sasConfig;
+	}
+	/**
+	* Create a new agent (off-chain object in memory).
+	* Call `agent.registerIPFS()` to register on-chain.
+	*/
+	createAgent(name, description, image) {
+		return SatiAgent.create(this, name, description, image);
+	}
+	/**
+	* Load an existing agent by agent0-compatible AgentId.
+	*/
+	async loadAgent(agentId) {
+		const identity = await this._resolveIdentity(agentId);
+		const agent0RegFile = toAgent0RegistrationFile(await fetchRegistrationFile(identity.uri) ?? buildRegistrationFile$1({
+			name: identity.name,
+			description: "",
+			image: "https://placehold.co/256"
+		}), identity, this._chain);
+		return SatiAgent.fromIdentity(this, identity, agent0RegFile);
+	}
+	/**
+	* Get agent summary (read-only).
+	*/
+	async getAgent(agentId) {
+		const mint = parseSatiAgentId(agentId);
+		if (mint === null) return null;
+		const identity = await this._sati.loadAgent(address(mint));
+		if (!identity) return null;
+		const regFile = await fetchRegistrationFile(identity.uri);
+		return toAgentSummary(identity, this._chain, regFile);
+	}
+	/**
+	* Search agents with filters.
+	*
+	* Fetches agents from on-chain registry and applies client-side filtering
+	* against on-chain data and registration files.
+	*
+	* Supports most agent0-sdk SearchFilters. Unsupported filters (require indexer):
+	* `keyword`, `registeredAtFrom/To`, `updatedAtFrom/To`, `hasMetadataKey`,
+	* `metadataValue`, `operators`.
+	*
+	* Pass `includeFeedbackStats: true` in options to populate `feedbackCount` and
+	* `averageValue` on results (slower - extra RPC calls per agent).
+	* Automatically enabled when `filters.feedback` is set.
+	*/
+	async searchAgents(filters, options) {
+		let agents;
+		if (filters?.owners?.length) agents = (await Promise.all(filters.owners.map((o) => this._sati.listAgentsByOwner(address(o))))).flat();
+		else agents = await this._sati.listAllAgents({ limit: 1e3 });
+		if (filters?.agentIds?.length) {
+			const mintSet = new Set(filters.agentIds.map((id) => parseSatiAgentId(id)).filter((m) => m !== null));
+			agents = agents.filter((a) => mintSet.has(a.mint));
+		}
+		if (filters?.name) {
+			const lower = filters.name.toLowerCase();
+			agents = agents.filter((a) => a.name.toLowerCase().includes(lower));
+		}
+		const regFiles = !!(filters?.description || filters?.active !== void 0 || filters?.hasMCP || filters?.hasA2A || filters?.hasOASF || filters?.hasWeb || filters?.hasEndpoints !== void 0 || filters?.hasRegistrationFile !== void 0 || filters?.x402support !== void 0 || filters?.supportedTrust?.length || filters?.mcpTools?.length || filters?.mcpPrompts?.length || filters?.mcpResources?.length || filters?.a2aSkills?.length || filters?.oasfSkills?.length || filters?.oasfDomains?.length || filters?.walletAddress || filters?.webContains || filters?.mcpContains || filters?.a2aContains || filters?.ensContains || filters?.didContains) ? await Promise.all(agents.map((a) => fetchRegistrationFile(a.uri))) : agents.map(() => null);
+		const wantFeedbackStats = !!(options?.includeFeedbackStats || filters?.feedback);
+		let feedbackStatsMap = null;
+		if (wantFeedbackStats && this._sasConfig) {
+			feedbackStatsMap = /* @__PURE__ */ new Map();
+			const schema = this._sasConfig.schemas.feedbackPublic ?? this._sasConfig.schemas.feedback;
+			await Promise.all(agents.map(async (agent) => {
+				try {
+					const scores = (await this._sati.listFeedbacks({
+						sasSchema: schema,
+						agentMint: agent.mint
+					})).items.map((item) => {
+						if (item.data.contentType === ContentType$1.JSON && item.data.content.length > 0) return JSON.parse(new TextDecoder().decode(item.data.content))?.score;
+					}).filter((s) => s !== void 0);
+					const count = scores.length;
+					const averageValue = count > 0 ? scores.reduce((a, b) => a + b, 0) / count : 0;
+					feedbackStatsMap?.set(agent.mint, {
+						count,
+						averageValue
+					});
+				} catch {}
+			}));
+		}
+		const results = [];
+		for (let i = 0; i < agents.length; i++) {
+			const identity = agents[i];
+			const regFile = regFiles[i];
+			const endpoints = regFile?.endpoints ?? [];
+			if (filters?.hasRegistrationFile === true && !regFile) continue;
+			if (filters?.hasRegistrationFile === false && regFile) continue;
+			if (filters?.description) {
+				if (!regFile?.description?.toLowerCase().includes(filters.description.toLowerCase())) continue;
+			}
+			if (filters?.active !== void 0 && (regFile?.active ?? true) !== filters.active) continue;
+			if (filters?.x402support !== void 0 && (regFile?.x402support ?? false) !== filters.x402support) continue;
+			if (filters?.hasMCP && !endpoints.some((e) => e.name.toUpperCase() === "MCP")) continue;
+			if (filters?.hasA2A && !endpoints.some((e) => e.name.toUpperCase() === "A2A")) continue;
+			if (filters?.hasOASF && !endpoints.some((e) => e.name.toUpperCase() === "OASF")) continue;
+			if (filters?.hasWeb && !endpoints.some((e) => e.name.toUpperCase() === "WEB")) continue;
+			if (filters?.hasEndpoints === true && endpoints.length === 0) continue;
+			if (filters?.mcpContains) {
+				if (!endpoints.find((e) => e.name.toUpperCase() === "MCP")?.endpoint.includes(filters.mcpContains)) continue;
+			}
+			if (filters?.a2aContains) {
+				if (!endpoints.find((e) => e.name.toUpperCase() === "A2A")?.endpoint.includes(filters.a2aContains)) continue;
+			}
+			if (filters?.ensContains) {
+				if (!endpoints.find((e) => e.name.toUpperCase() === "ENS")?.endpoint.includes(filters.ensContains)) continue;
+			}
+			if (filters?.didContains) {
+				if (!endpoints.find((e) => e.name.toUpperCase() === "DID")?.endpoint.includes(filters.didContains)) continue;
+			}
+			if (filters?.webContains) {
+				if (!endpoints.find((e) => e.name.toUpperCase() === "WEB")?.endpoint.includes(filters.webContains)) continue;
+			}
+			if (filters?.walletAddress) {
+				if (!endpoints.find((e) => e.name.toUpperCase() === "AGENTWALLET" || e.name.toUpperCase() === "WALLET")?.endpoint.includes(filters.walletAddress)) continue;
+			}
+			if (filters?.supportedTrust?.length) {
+				const trusts = regFile?.supportedTrust ?? [];
+				if (!filters.supportedTrust.every((t) => trusts.includes(t))) continue;
+			}
+			if (filters?.mcpTools?.length) {
+				const tools = endpoints.find((e) => e.name.toUpperCase() === "MCP")?.mcpTools ?? [];
+				if (!filters.mcpTools.some((t) => tools.includes(t))) continue;
+			}
+			if (filters?.mcpPrompts?.length) {
+				const prompts = endpoints.find((e) => e.name.toUpperCase() === "MCP")?.mcpPrompts ?? [];
+				if (!filters.mcpPrompts.some((t) => prompts.includes(t))) continue;
+			}
+			if (filters?.mcpResources?.length) {
+				const resources = endpoints.find((e) => e.name.toUpperCase() === "MCP")?.mcpResources ?? [];
+				if (!filters.mcpResources.some((t) => resources.includes(t))) continue;
+			}
+			if (filters?.a2aSkills?.length) {
+				const skills = endpoints.find((e) => e.name.toUpperCase() === "A2A")?.a2aSkills ?? [];
+				if (!filters.a2aSkills.some((t) => skills.includes(t))) continue;
+			}
+			if (filters?.oasfSkills?.length) {
+				const skills = endpoints.find((e) => e.name.toUpperCase() === "OASF")?.skills ?? [];
+				if (!filters.oasfSkills.some((t) => skills.includes(t))) continue;
+			}
+			if (filters?.oasfDomains?.length) {
+				const domains = endpoints.find((e) => e.name.toUpperCase() === "OASF")?.domains ?? [];
+				if (!filters.oasfDomains.some((t) => domains.includes(t))) continue;
+			}
+			if (filters?.feedback) {
+				const fbStats = feedbackStatsMap?.get(identity.mint);
+				const fb = filters.feedback;
+				if (fb.hasFeedback === true && (!fbStats || fbStats.count === 0)) continue;
+				if (fb.hasNoFeedback === true && fbStats && fbStats.count > 0) continue;
+				if (fb.minValue !== void 0 && (!fbStats || fbStats.averageValue < fb.minValue)) continue;
+				if (fb.maxValue !== void 0 && (!fbStats || fbStats.averageValue > fb.maxValue)) continue;
+				if (fb.minCount !== void 0 && (!fbStats || fbStats.count < fb.minCount)) continue;
+				if (fb.maxCount !== void 0 && (!fbStats || fbStats.count > fb.maxCount)) continue;
+			}
+			const stats = feedbackStatsMap?.get(identity.mint) ?? null;
+			results.push(toAgentSummary(identity, this._chain, regFile, stats));
+		}
+		const sortFields = options?.sort;
+		if (sortFields?.length) results.sort((a, b) => {
+			for (const sortStr of sortFields) {
+				const [field, dir] = sortStr.split(":");
+				const mul = dir === "asc" ? 1 : -1;
+				const aVal = a[field] ?? 0;
+				const bVal = b[field] ?? 0;
+				if (aVal !== bVal) return (aVal > bVal ? 1 : -1) * mul;
+			}
+			return 0;
+		});
+		return results;
+	}
+	/**
+	* Transfer agent ownership to a new Solana address.
+	*/
+	async transferAgent(agentId, newOwner) {
+		const identity = await this._resolveIdentity(agentId);
+		const access = this._requireWriteAccess();
+		if (access.type === "keypair") return this._sati.transferAgent({
+			payer: access.signer,
+			owner: access.signer,
+			mint: identity.mint,
+			newOwner: address(newOwner)
+		});
+		const ownerAddr = address(access.sender.address);
+		const [sourceAta] = await findAssociatedTokenAddress(identity.mint, ownerAddr);
+		const [destAta] = await findAssociatedTokenAddress(identity.mint, address(newOwner));
+		const createAtaIx = getCreateAssociatedTokenIdempotentInstruction({
+			payer: { address: ownerAddr },
+			owner: address(newOwner),
+			mint: identity.mint,
+			ata: destAta,
+			tokenProgram: TOKEN_2022_PROGRAM_ADDRESS
+		});
+		const transferIx = getTransferInstruction({
+			source: sourceAta,
+			destination: destAta,
+			authority: { address: ownerAddr },
+			amount: 1n
+		});
+		return { signature: await access.sender.signAndSend([createAtaIx, transferIx]) };
+	}
+	/**
+	* Check if address owns the agent.
+	*/
+	async isAgentOwner(agentId, addr) {
+		return await this.getAgentOwner(agentId) === addr;
+	}
+	/**
+	* Get agent owner address.
+	*/
+	async getAgentOwner(agentId) {
+		const identity = await this._resolveIdentity(agentId);
+		return await this._sati.getAgentOwner(identity.mint);
+	}
+	/**
+	* Prepare an off-chain feedback file.
+	*/
+	prepareFeedbackFile(input, extra) {
+		return {
+			...input,
+			...extra
+		};
+	}
+	/**
+	* Give feedback to an agent.
+	*
+	* Uses FeedbackPublicV1 schema (CounterpartySigned mode).
+	* Value/tags stored in content JSON.
+	*
+	* @param satiOptions - SATI-specific overrides (outcome, taskRef). When omitted,
+	*   outcome defaults to Neutral and taskRef is random.
+	*/
+	async giveFeedback(agentId, value, tag1, tag2, endpoint, feedbackFile, satiOptions) {
+		const sasConfig = this._requireSASConfig();
+		const feedbackPublicSchema = sasConfig.schemas.feedbackPublic;
+		if (!feedbackPublicSchema) throw new Error("FeedbackPublic schema not deployed on this network");
+		const identity = await this._resolveIdentity(agentId);
+		const access = this._requireWriteAccess();
+		const contentObj = {};
+		if (value !== void 0) contentObj.score = typeof value === "string" ? Number.parseFloat(value) : value;
+		if (tag1) contentObj.tags = tag2 ? [tag1, tag2] : [tag1];
+		if (endpoint) contentObj.endpoint = endpoint;
+		if (feedbackFile?.text) contentObj.m = feedbackFile.text;
+		const content = Object.keys(contentObj).length > 0 ? new TextEncoder().encode(JSON.stringify(contentObj)) : new Uint8Array(0);
+		const contentType = content.length > 0 ? ContentType$1.JSON : ContentType$1.None;
+		const taskRef = satiOptions?.taskRef ?? globalThis.crypto.getRandomValues(new Uint8Array(32));
+		const outcome = satiOptions?.outcome ?? Outcome$1.Neutral;
+		const numericValue = typeof value === "string" ? Number.parseFloat(value) : value;
+		if (access.type === "keypair") {
+			const signer = access.signer;
+			const { messageBytes } = buildCounterpartyMessage({
+				schemaName: "FeedbackPublic",
+				data: serializeFeedback({
+					taskRef,
+					agentMint: identity.mint,
+					counterparty: signer.address,
+					dataHash: zeroDataHash(),
+					outcome,
+					contentType,
+					content
+				})
+			});
+			const sig = await signBytes(signer.keyPair.privateKey, messageBytes);
+			const result = await this._sati.createFeedback({
+				payer: signer,
+				sasSchema: feedbackPublicSchema,
+				taskRef,
+				agentMint: identity.mint,
+				counterparty: signer.address,
+				dataHash: zeroDataHash(),
+				outcome,
+				contentType,
+				content,
+				agentSignature: {
+					pubkey: signer.address,
+					signature: new Uint8Array(sig)
+				},
+				counterpartyMessage: messageBytes,
+				lookupTableAddress: sasConfig.lookupTable
+			});
+			const feedback = toFeedback({
+				agentMint: identity.mint,
+				chain: this._chain,
+				reviewer: signer.address,
+				feedbackIndex: 0,
+				content: {
+					value: numericValue,
+					tag1,
+					tag2,
+					endpoint,
+					text: feedbackFile?.text
+				},
+				txSignature: result.signature,
+				outcome
+			});
+			return {
+				signature: result.signature,
+				feedback
+			};
+		}
+		throw new Error("giveFeedback is not supported via transactionSender (browser wallet). Use prepareFeedback() to get SIWS message bytes, have the wallet sign them, then call submitPreparedFeedback() with a server-side KeyPairSigner to submit.");
+	}
+	/**
+	* Prepare a feedback submission for browser wallet signing.
+	*
+	* Returns SIWS message bytes that the counterparty wallet must sign.
+	* Pass the result + signature to `submitPreparedFeedback()`.
+	*
+	* @param agentId - Agent to give feedback to
+	* @param value - Numeric feedback value
+	* @param tag1 - Optional first tag
+	* @param tag2 - Optional second tag
+	* @param opts - Optional: endpoint, text, counterparty address (defaults to transactionSender address)
+	* @param satiOptions - SATI-specific overrides (outcome, taskRef)
+	*/
+	async prepareFeedback(agentId, value, tag1, tag2, opts, satiOptions) {
+		const sasConfig = this._requireSASConfig();
+		const feedbackPublicSchema = sasConfig.schemas.feedbackPublic;
+		if (!feedbackPublicSchema) throw new Error("FeedbackPublic schema not deployed on this network");
+		const identity = await this._resolveIdentity(agentId);
+		const counterpartyAddr = opts?.counterparty ?? this._config.transactionSender?.address;
+		if (!counterpartyAddr) throw new Error("counterparty address required - provide via opts.counterparty or configure transactionSender");
+		const contentObj = {};
+		if (value !== void 0) contentObj.score = value;
+		if (tag1) contentObj.tags = tag2 ? [tag1, tag2] : [tag1];
+		if (opts?.endpoint) contentObj.endpoint = opts.endpoint;
+		if (opts?.text) contentObj.m = opts.text;
+		const content = Object.keys(contentObj).length > 0 ? new TextEncoder().encode(JSON.stringify(contentObj)) : new Uint8Array(0);
+		const contentType = content.length > 0 ? ContentType$1.JSON : ContentType$1.None;
+		const taskRef = satiOptions?.taskRef ?? globalThis.crypto.getRandomValues(new Uint8Array(32));
+		const outcome = satiOptions?.outcome ?? Outcome$1.Neutral;
+		const { messageBytes } = buildCounterpartyMessage({
+			schemaName: "FeedbackPublic",
+			data: serializeFeedback({
+				taskRef,
+				agentMint: identity.mint,
+				counterparty: address(counterpartyAddr),
+				dataHash: zeroDataHash(),
+				outcome,
+				contentType,
+				content
+			})
+		});
+		return {
+			messageBytes,
+			agentMint: identity.mint,
+			counterparty: address(counterpartyAddr),
+			taskRef,
+			dataHash: zeroDataHash(),
+			outcome,
+			contentType,
+			content,
+			sasSchema: feedbackPublicSchema,
+			lookupTable: sasConfig.lookupTable,
+			feedbackMeta: {
+				value,
+				tag1,
+				tag2,
+				endpoint: opts?.endpoint,
+				text: opts?.text
+			}
+		};
+	}
+	/**
+	* Submit a prepared feedback using a server-side KeyPairSigner.
+	*
+	* The signer pays gas. The counterparty's SIWS signature proves consent.
+	*
+	* @param prepared - Result from `prepareFeedback()`
+	* @param counterpartySignature - Counterparty wallet's signature of `prepared.messageBytes`
+	*/
+	async submitPreparedFeedback(prepared, counterpartySignature) {
+		const signer = this._requireSigner();
+		const result = await this._sati.createFeedback({
+			payer: signer,
+			sasSchema: prepared.sasSchema,
+			taskRef: prepared.taskRef,
+			agentMint: prepared.agentMint,
+			counterparty: prepared.counterparty,
+			dataHash: prepared.dataHash,
+			outcome: prepared.outcome,
+			contentType: prepared.contentType,
+			content: prepared.content,
+			agentSignature: {
+				pubkey: prepared.counterparty,
+				signature: new Uint8Array(counterpartySignature)
+			},
+			counterpartyMessage: prepared.messageBytes,
+			lookupTableAddress: prepared.lookupTable
+		});
+		const feedback = toFeedback({
+			agentMint: prepared.agentMint,
+			chain: this._chain,
+			reviewer: prepared.counterparty,
+			feedbackIndex: 0,
+			content: prepared.feedbackMeta,
+			txSignature: result.signature,
+			outcome: prepared.outcome
+		});
+		return {
+			signature: result.signature,
+			feedback
+		};
+	}
+	/**
+	* Search feedback with filters.
+	*
+	* Supports most agent0-sdk FeedbackSearchFilters. The `includeRevoked`
+	* filter is a no-op on SATI (closed attestations are permanently deleted).
+	*/
+	async searchFeedback(filters, options) {
+		const sasConfig = this._requireSASConfig();
+		const satiFilter = { sasSchema: sasConfig.schemas.feedbackPublic ?? sasConfig.schemas.feedback };
+		let knownIdentity = null;
+		const targetAgentId = filters.agentId ?? filters.agents?.[0];
+		if (targetAgentId) {
+			knownIdentity = await this._resolveIdentity(targetAgentId);
+			satiFilter.agentMint = knownIdentity.mint;
+		}
+		if (filters.reviewers?.length) satiFilter.counterparty = address(filters.reviewers[0]);
+		const result = await this._sati.listFeedbacks(satiFilter);
+		const currentSlot = await this._sati.getRpc().getSlot({ commitment: "confirmed" }).send();
+		const nowSec = Math.floor(Date.now() / 1e3);
+		const feedbacks = [];
+		for (let i = 0; i < result.items.length; i++) {
+			const item = result.items[i];
+			const rawContent = item.data.contentType === ContentType$1.JSON && item.data.content.length > 0 ? JSON.parse(new TextDecoder().decode(item.data.content)) : null;
+			const score = rawContent?.score;
+			const tags = rawContent?.tags ?? [];
+			const text = rawContent?.m;
+			const endpointVal = rawContent?.endpoint;
+			const capability = rawContent?.cap;
+			const name = rawContent?.n;
+			const skill = rawContent?.sk;
+			const task = rawContent?.tsk;
+			const proofOfPayment = rawContent?.pop;
+			const fileURI = rawContent?.fileURI;
+			if (filters.tags?.length) {
+				if (!filters.tags.every((t) => tags.includes(t))) continue;
+			}
+			if (options?.minValue !== void 0 && (score === void 0 || score < options.minValue)) continue;
+			if (options?.maxValue !== void 0 && (score === void 0 || score > options.maxValue)) continue;
+			if (filters.capabilities?.length && (!capability || !filters.capabilities.includes(capability))) continue;
+			if (filters.skills?.length && (!skill || !filters.skills.includes(skill))) continue;
+			if (filters.tasks?.length && (!task || !filters.tasks.includes(task))) continue;
+			if (filters.names?.length && (!name || !filters.names.includes(name))) continue;
+			const slotDiff = Number(BigInt(currentSlot) - item.raw.slotCreated);
+			const createdAt = nowSec - Math.floor(slotDiff * .4);
+			const [compressedAddress] = getAddressDecoder().read(item.address, 0);
+			const feedback = toFeedback({
+				agentMint: item.data.agentMint,
+				chain: this._chain,
+				reviewer: item.data.counterparty,
+				feedbackIndex: i,
+				content: {
+					value: score,
+					tag1: tags[0],
+					tag2: tags[1],
+					endpoint: endpointVal,
+					text,
+					context: {
+						satiCompressedAddress: compressedAddress,
+						counterparty: item.data.counterparty,
+						agentMint: item.data.agentMint
+					}
+				},
+				createdAt,
+				outcome: item.data.outcome
+			});
+			if (capability) feedback.capability = capability;
+			if (name) feedback.name = name;
+			if (skill) feedback.skill = skill;
+			if (task) feedback.task = task;
+			if (proofOfPayment) feedback.proofOfPayment = proofOfPayment;
+			if (fileURI) feedback.fileURI = fileURI;
+			feedbacks.push(feedback);
+		}
+		if (options?.includeTxHash) {
+			const photon = this._sati.getLightClient().getRpc();
+			await Promise.all(feedbacks.map(async (fb) => {
+				const addr = fb.context?.satiCompressedAddress;
+				if (!addr) return;
+				try {
+					fb.txHash = (await photon.getCompressionSignaturesForAddress(address(addr), { limit: 1 })).items[0]?.signature;
+				} catch {}
+			}));
+		}
+		return feedbacks;
+	}
+	/**
+	* Append response to feedback.
+	*
+	* @throws Error - Not supported on SATI at the moment.
+	*/
+	async appendResponse(_agentId, _clientAddress, _feedbackIndex, _response) {
+		throw new Error("appendResponse is not supported on SATI at the moment");
+	}
+	/**
+	* Get reputation summary for an agent.
+	*
+	* Computes average score from all FeedbackPublic attestations,
+	* optionally filtered by tags.
+	*/
+	async getReputationSummary(agentId, tag1, tag2) {
+		const sasConfig = this._requireSASConfig();
+		const identity = await this._resolveIdentity(agentId);
+		const result = await this._sati.listFeedbacks({
+			sasSchema: sasConfig.schemas.feedbackPublic ?? sasConfig.schemas.feedback,
+			agentMint: identity.mint
+		});
+		if (result.items.length === 0) return {
+			count: 0,
+			averageValue: 0
+		};
+		let sum = 0;
+		let count = 0;
+		for (const item of result.items) {
+			const rawContent = item.data.contentType === ContentType$1.JSON && item.data.content.length > 0 ? JSON.parse(new TextDecoder().decode(item.data.content)) : null;
+			const score = rawContent?.score;
+			const tags = rawContent?.tags ?? [];
+			if (tag1 && !tags.includes(tag1)) continue;
+			if (tag2 && !tags.includes(tag2)) continue;
+			if (score !== void 0) {
+				sum += score;
+				count++;
+			}
+		}
+		return {
+			count,
+			averageValue: count > 0 ? sum / count : 0
+		};
+	}
+	/**
+	* Get a single feedback entry.
+	*
+	* Fetches feedbacks for the given agent + reviewer, then returns the one at feedbackIndex.
+	*/
+	async getFeedback(agentId, clientAddress, feedbackIndex) {
+		const fb = (await this.searchFeedback({
+			agentId,
+			reviewers: [clientAddress]
+		}))[feedbackIndex];
+		if (!fb) throw new Error(`Feedback not found at index ${feedbackIndex} for agent ${agentId} reviewer ${clientAddress}`);
+		return fb;
+	}
+	/**
+	* Look up the creation transaction signature for a compressed attestation.
+	*
+	* Use `feedback.context.satiCompressedAddress` from `searchFeedback()` results
+	* as the `compressedAddress` parameter.
+	*
+	* @param compressedAddress - Base58 address of the compressed account
+	* @returns Transaction signature or null if not found
+	*/
+	async getCreationSignature(compressedAddress) {
+		try {
+			return (await this._sati.getLightClient().getRpc().getCompressionSignaturesForAddress(address(compressedAddress), { limit: 1 })).items[0]?.signature ?? null;
+		} catch {
+			return null;
+		}
+	}
+	/**
+	* Revoke (close) a previously submitted feedback.
+	*
+	* Closes the compressed attestation on-chain. The signer must be the
+	* counterparty who originally submitted the feedback.
+	*
+	* Note: On SATI, revoked feedbacks are permanently deleted (Light Protocol
+	* compressed accounts are closed). They cannot be recovered.
+	*/
+	async revokeFeedback(agentId, feedbackIndex) {
+		const sasConfig = this._requireSASConfig();
+		const signer = this._requireSigner();
+		const identity = await this._resolveIdentity(agentId);
+		const schema = sasConfig.schemas.feedbackPublic ?? sasConfig.schemas.feedback;
+		const item = (await this._sati.listFeedbacks({
+			sasSchema: schema,
+			agentMint: identity.mint,
+			counterparty: signer.address
+		})).items[feedbackIndex];
+		if (!item) throw new Error(`Feedback not found at index ${feedbackIndex}`);
+		const [attestationAddress] = getAddressDecoder().read(item.address, 0);
+		return this._sati.closeCompressedAttestation({
+			payer: signer,
+			counterparty: signer,
+			sasSchema: item.attestation.sasSchema,
+			attestationAddress,
+			lookupTableAddress: sasConfig.lookupTable
+		});
+	}
+	/**
+	* Search validation attestations for an agent.
+	*
+	* Validations are on-chain attestations from validators (TEE, zkML, re-execution, etc.)
+	* that verify an agent's behavior. Unlike feedback, validations are typically automated.
+	*/
+	async searchValidations(agentId) {
+		const validationSchema = this._requireSASConfig().schemas.validation;
+		if (!validationSchema) throw new Error("Validation schema not deployed on this network");
+		const identity = await this._resolveIdentity(agentId);
+		const result = await this._sati.listValidations({
+			sasSchema: validationSchema,
+			agentMint: identity.mint
+		});
+		const currentSlot = await this._sati.getRpc().getSlot({ commitment: "confirmed" }).send();
+		const nowSec = Math.floor(Date.now() / 1e3);
+		return result.items.map((item) => {
+			const slotDiff = Number(BigInt(currentSlot) - item.raw.slotCreated);
+			const createdAt = nowSec - Math.floor(slotDiff * .4);
+			const [compressedAddress] = getAddressDecoder().read(item.address, 0);
+			return {
+				outcome: item.data.outcome,
+				agentMint: item.data.agentMint,
+				counterparty: item.data.counterparty,
+				createdAt,
+				compressedAddress
+			};
+		});
+	}
+	/** Get the feedback schema address for the current network. */
+	get feedbackSchema() {
+		return this._sasConfig?.schemas.feedback;
+	}
+	/** Get the feedbackPublic schema address for the current network. */
+	get feedbackPublicSchema() {
+		return this._sasConfig?.schemas.feedbackPublic;
+	}
+	/** Get the validation schema address for the current network. */
+	get validationSchema() {
+		return this._sasConfig?.schemas.validation;
+	}
+	/** Get the lookup table address for the current network. */
+	get lookupTable() {
+		return this._sasConfig?.lookupTable;
+	}
+	/** @internal */
+	get config() {
+		return this._config;
+	}
+	_requireSigner() {
+		if (!this._config.signer) throw new Error("This operation requires a KeyPairSigner. Initialize SatiSDK with a signer for server-side write operations.");
+		return this._config.signer;
+	}
+	/** Returns either a KeyPairSigner or a TransactionSender, or throws if read-only. */
+	_requireWriteAccess() {
+		if (this._config.signer) return {
+			type: "keypair",
+			signer: this._config.signer
+		};
+		if (this._config.transactionSender) return {
+			type: "sender",
+			sender: this._config.transactionSender
+		};
+		throw new Error("This operation requires a signer or transactionSender. Initialize SatiSDK with one for write operations.");
+	}
+	_requireSASConfig() {
+		if (!this._sasConfig) throw new Error(`No SAS config deployed for network "${this._config.network}". Deploy schemas first.`);
+		return this._sasConfig;
+	}
+	async _resolveIdentity(agentId) {
+		const mint = parseSatiAgentId(agentId);
+		if (mint === null) throw new Error(`Invalid SATI agent ID: ${agentId}. Expected format: solana:<chainRef>:<mintAddress>`);
+		const identity = await this._sati.loadAgent(address(mint));
+		if (!identity) throw new Error(`Agent not found: ${agentId}`);
+		return identity;
+	}
+};
+
+//#endregion
+export { ContentType, EndpointCrawler, EndpointType, MAX_SINGLE_SIGNATURE_CONTENT_SIZE, Outcome, SATI_PROGRAM_ADDRESS, SOLANA_CAIP2_CHAINS, SatiAgent, SatiSDK, TrustModel, buildRegistrationFile, formatSatiAgentId, fromAgent0Endpoints, fromAgent0RegistrationFile, getImageUrl, handleTransactionError, parseFeedbackContent, parseSatiAgentId, stringifyRegistrationFile, toAgent0Endpoints, toAgent0RegistrationFile, toAgentSummary, toFeedback };
+//# sourceMappingURL=index.mjs.map