@tangle-network/sandbox 0.2.1 → 0.3.0

package/dist/tangle-DQ05paN7.js

@@ -1,826 +0,0 @@
-import { t as SandboxInstance } from "./sandbox-ksXTNlo-.js";
-//#region src/tangle/abi.ts
-/**
-* Tangle Contract ABI Definitions
-*
-* Viem-compatible ABI for the ITangleJobs precompile, the AgentSandbox
-* blueprint contract views/events, and ABI parameter definitions for
-* encoding/decoding blueprint job inputs and outputs.
-*/
-const ITangleJobsAbi = [
-	{
-		type: "function",
-		name: "submitJob",
-		inputs: [
-			{
-				name: "serviceId",
-				type: "uint64"
-			},
-			{
-				name: "jobIndex",
-				type: "uint8"
-			},
-			{
-				name: "inputs",
-				type: "bytes"
-			}
-		],
-		outputs: [{
-			name: "callId",
-			type: "uint64"
-		}],
-		stateMutability: "payable"
-	},
-	{
-		type: "function",
-		name: "getJobCall",
-		inputs: [{
-			name: "serviceId",
-			type: "uint64"
-		}, {
-			name: "callId",
-			type: "uint64"
-		}],
-		outputs: [{
-			name: "",
-			type: "tuple",
-			components: [
-				{
-					name: "jobIndex",
-					type: "uint8"
-				},
-				{
-					name: "caller",
-					type: "address"
-				},
-				{
-					name: "createdAt",
-					type: "uint64"
-				},
-				{
-					name: "resultCount",
-					type: "uint32"
-				},
-				{
-					name: "payment",
-					type: "uint256"
-				},
-				{
-					name: "completed",
-					type: "bool"
-				}
-			]
-		}],
-		stateMutability: "view"
-	},
-	{
-		type: "event",
-		name: "JobSubmitted",
-		inputs: [
-			{
-				name: "serviceId",
-				type: "uint64",
-				indexed: true
-			},
-			{
-				name: "callId",
-				type: "uint64",
-				indexed: true
-			},
-			{
-				name: "jobIndex",
-				type: "uint8",
-				indexed: true
-			},
-			{
-				name: "caller",
-				type: "address",
-				indexed: false
-			},
-			{
-				name: "inputs",
-				type: "bytes",
-				indexed: false
-			}
-		]
-	},
-	{
-		type: "event",
-		name: "JobResultSubmitted",
-		inputs: [
-			{
-				name: "serviceId",
-				type: "uint64",
-				indexed: true
-			},
-			{
-				name: "callId",
-				type: "uint64",
-				indexed: true
-			},
-			{
-				name: "operator",
-				type: "address",
-				indexed: true
-			},
-			{
-				name: "result",
-				type: "bytes",
-				indexed: false
-			}
-		]
-	}
-];
-const SandboxCreateParamTypes = [
-	{
-		name: "name",
-		type: "string"
-	},
-	{
-		name: "image",
-		type: "string"
-	},
-	{
-		name: "stack",
-		type: "string"
-	},
-	{
-		name: "agent_identifier",
-		type: "string"
-	},
-	{
-		name: "env_json",
-		type: "string"
-	},
-	{
-		name: "metadata_json",
-		type: "string"
-	},
-	{
-		name: "ssh_enabled",
-		type: "bool"
-	},
-	{
-		name: "ssh_public_keys",
-		type: "string[]"
-	},
-	{
-		name: "web_terminal_enabled",
-		type: "bool"
-	},
-	{
-		name: "max_lifetime_seconds",
-		type: "uint64"
-	},
-	{
-		name: "idle_timeout_seconds",
-		type: "uint64"
-	},
-	{
-		name: "cpu_cores",
-		type: "uint64"
-	},
-	{
-		name: "memory_mb",
-		type: "uint64"
-	},
-	{
-		name: "disk_gb",
-		type: "uint64"
-	},
-	{
-		name: "tee_required",
-		type: "bool"
-	},
-	{
-		name: "tee_type",
-		type: "uint8"
-	},
-	{
-		name: "attestation_nonce",
-		type: "string"
-	}
-];
-const SandboxIdParamTypes = [{
-	name: "sandbox_id",
-	type: "string"
-}];
-const SandboxCreateResponseParamTypes = [{
-	name: "sandboxId",
-	type: "string"
-}, {
-	name: "json",
-	type: "string"
-}];
-const JsonResponseParamTypes = [{
-	name: "json",
-	type: "string"
-}];
-const AgentSandboxBlueprintAbi = [
-	{
-		type: "function",
-		name: "getAvailableCapacity",
-		inputs: [],
-		outputs: [{
-			name: "available",
-			type: "uint32"
-		}],
-		stateMutability: "view"
-	},
-	{
-		type: "function",
-		name: "getServiceStats",
-		inputs: [],
-		outputs: [{
-			name: "totalSandboxes",
-			type: "uint32"
-		}, {
-			name: "totalCapacity",
-			type: "uint32"
-		}],
-		stateMutability: "view"
-	},
-	{
-		type: "function",
-		name: "getOperatorLoad",
-		inputs: [{
-			name: "operator",
-			type: "address"
-		}],
-		outputs: [{
-			name: "active",
-			type: "uint32"
-		}, {
-			name: "max",
-			type: "uint32"
-		}],
-		stateMutability: "view"
-	},
-	{
-		type: "function",
-		name: "getSandboxOperator",
-		inputs: [{
-			name: "sandboxId",
-			type: "string"
-		}],
-		outputs: [{
-			name: "",
-			type: "address"
-		}],
-		stateMutability: "view"
-	},
-	{
-		type: "function",
-		name: "isSandboxActive",
-		inputs: [{
-			name: "sandboxId",
-			type: "string"
-		}],
-		outputs: [{
-			name: "",
-			type: "bool"
-		}],
-		stateMutability: "view"
-	},
-	{
-		type: "event",
-		name: "OperatorAssigned",
-		inputs: [
-			{
-				name: "serviceId",
-				type: "uint64",
-				indexed: true
-			},
-			{
-				name: "callId",
-				type: "uint64",
-				indexed: true
-			},
-			{
-				name: "operator",
-				type: "address",
-				indexed: true
-			}
-		]
-	},
-	{
-		type: "event",
-		name: "OperatorRouted",
-		inputs: [
-			{
-				name: "serviceId",
-				type: "uint64",
-				indexed: true
-			},
-			{
-				name: "callId",
-				type: "uint64",
-				indexed: true
-			},
-			{
-				name: "operator",
-				type: "address",
-				indexed: true
-			}
-		]
-	},
-	{
-		type: "event",
-		name: "SandboxCreated",
-		inputs: [{
-			name: "sandboxHash",
-			type: "bytes32",
-			indexed: true
-		}, {
-			name: "operator",
-			type: "address",
-			indexed: true
-		}]
-	},
-	{
-		type: "event",
-		name: "SandboxDeleted",
-		inputs: [{
-			name: "sandboxHash",
-			type: "bytes32",
-			indexed: true
-		}, {
-			name: "operator",
-			type: "address",
-			indexed: true
-		}]
-	}
-];
-//#endregion
-//#region src/tangle/types.ts
-/**
-* Tangle Sandbox Client types and constants.
-*/
-/** Tangle mainnet chain ID. */
-const TANGLE_CHAIN_ID = 5845;
-/** Tangle mainnet RPC endpoint. */
-const TANGLE_MAINNET_RPC = "https://rpc.tangle.tools";
-/** ITangleJobs precompile contract address. */
-const TANGLE_JOBS_CONTRACT = "0x0000000000000000000000000000000000000808";
-/** Job indices matching the blueprint's job IDs. */
-const JOB_SANDBOX_CREATE = 0;
-const JOB_SANDBOX_DELETE = 1;
-//#endregion
-//#region src/tangle/chain-client.ts
-function confidentialFromOptions(options) {
-	if (options.confidential) return options.confidential;
-	const profile = options.backend?.profile;
-	if (typeof profile === "object" && profile?.confidential) return profile.confidential;
-}
-function teeTypeId(tee) {
-	switch (tee) {
-		case "tdx":
-		case "phala-dstack": return 1;
-		case "nitro": return 2;
-		case "sev-snp": return 3;
-		case "any":
-		case void 0: return 0;
-		default: throw new Error(`Unsupported TEE type for Tangle blueprint: ${tee}`);
-	}
-}
-function teeCreateValues(options) {
-	const confidential = confidentialFromOptions(options);
-	const teeRequired = Boolean(confidential?.tee);
-	return [
-		teeRequired,
-		teeRequired ? teeTypeId(confidential?.tee) : 0,
-		confidential?.attestationNonce ?? ""
-	];
-}
-var TangleChainClient = class {
-	config;
-	publicClient = null;
-	walletClient = null;
-	account = null;
-	constructor(config) {
-		this.config = config;
-	}
-	async ensureInitialized() {
-		if (this.publicClient && this.walletClient) return {
-			publicClient: this.publicClient,
-			walletClient: this.walletClient
-		};
-		let viem;
-		try {
-			viem = await import("viem");
-		} catch {
-			throw new Error("viem is required for TangleSandboxClient. Install it: npm install viem");
-		}
-		const rpcUrl = this.config.rpcUrl ?? "https://rpc.tangle.tools";
-		const chain = {
-			id: TANGLE_CHAIN_ID,
-			name: "Tangle",
-			nativeCurrency: {
-				name: "TNT",
-				symbol: "TNT",
-				decimals: 18
-			},
-			rpcUrls: { default: { http: [rpcUrl] } }
-		};
-		const transport = viem.http(rpcUrl);
-		this.publicClient = viem.createPublicClient({
-			chain,
-			transport
-		});
-		if (this.config.privateKey) {
-			const { privateKeyToAccount } = await import("viem/accounts");
-			this.account = privateKeyToAccount(this.config.privateKey);
-			this.walletClient = viem.createWalletClient({
-				account: this.account,
-				chain,
-				transport
-			});
-		} else if (this.config.wallet) {
-			const wallet = this.config.wallet;
-			this.walletClient = wallet;
-			this.account = wallet.account ?? null;
-		} else throw new Error("TangleSandboxClient requires either privateKey or wallet");
-		return {
-			publicClient: this.publicClient,
-			walletClient: this.walletClient
-		};
-	}
-	encodeSandboxCreateInputs(options) {
-		return {
-			types: SandboxCreateParamTypes,
-			values: [
-				options.name ?? "",
-				options.image ?? "",
-				"",
-				"",
-				options.env ? JSON.stringify(options.env) : "",
-				options.metadata ? JSON.stringify(options.metadata) : "",
-				options.sshEnabled ?? false,
-				options.sshPublicKeys ?? (options.sshPublicKey ? [options.sshPublicKey] : []),
-				options.webTerminalEnabled ?? false,
-				BigInt(options.maxLifetimeSeconds ?? 0),
-				BigInt(options.idleTimeoutSeconds ?? 0),
-				BigInt(options.resources?.cpuCores ?? 0),
-				BigInt(options.resources?.memoryMB ?? 0),
-				BigInt(options.resources?.diskGB ?? 0),
-				...teeCreateValues(options)
-			]
-		};
-	}
-	encodeSandboxIdInputs(sandboxId) {
-		return {
-			types: SandboxIdParamTypes,
-			values: [sandboxId]
-		};
-	}
-	async submitJobAndWait(jobIndex, encoded) {
-		const { publicClient, walletClient } = await this.ensureInitialized();
-		const viem = await import("viem");
-		const contractAddress = this.config.contractAddress ?? "0x0000000000000000000000000000000000000808";
-		const serviceId = this.config.serviceId;
-		const inputs = viem.encodeAbiParameters(encoded.types, encoded.values);
-		const hash = await walletClient.writeContract({
-			address: contractAddress,
-			abi: ITangleJobsAbi,
-			functionName: "submitJob",
-			args: [
-				serviceId,
-				jobIndex,
-				inputs
-			]
-		});
-		const receipt = await publicClient.waitForTransactionReceipt({ hash });
-		const jobSubmittedEvent = receipt.logs.find((log) => {
-			try {
-				return viem.decodeEventLog({
-					abi: ITangleJobsAbi,
-					data: log.data,
-					topics: log.topics
-				}).eventName === "JobSubmitted";
-			} catch {
-				return false;
-			}
-		});
-		if (!jobSubmittedEvent) throw new Error("JobSubmitted event not found in transaction receipt");
-		const callId = viem.decodeEventLog({
-			abi: ITangleJobsAbi,
-			data: jobSubmittedEvent.data,
-			topics: jobSubmittedEvent.topics
-		}).args.callId;
-		const timeoutMs = this.config.jobTimeoutMs ?? 144e5;
-		const pollIntervalMs = this.config.pollIntervalMs ?? 5e3;
-		const deadline = Date.now() + timeoutMs;
-		while (Date.now() < deadline) {
-			await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
-			const jobCall = await publicClient.readContract({
-				address: contractAddress,
-				abi: ITangleJobsAbi,
-				functionName: "getJobCall",
-				args: [serviceId, callId]
-			});
-			if (jobCall.completed) return {
-				result: jobCall,
-				callId,
-				blockNumber: receipt.blockNumber
-			};
-		}
-		throw new Error(`Job ${jobIndex} (callId=${callId}) did not complete within ${timeoutMs}ms`);
-	}
-	async getJobResult(callId, fromBlock) {
-		const { publicClient } = await this.ensureInitialized();
-		const viem = await import("viem");
-		const contractAddress = this.config.contractAddress ?? "0x0000000000000000000000000000000000000808";
-		const logs = await publicClient.getLogs({
-			address: contractAddress,
-			event: viem.parseAbiItem("event JobResultSubmitted(uint64 indexed serviceId, uint64 indexed callId, address indexed operator, bytes result)"),
-			args: {
-				serviceId: this.config.serviceId,
-				callId
-			},
-			fromBlock: fromBlock ?? "earliest"
-		});
-		if (logs.length === 0) return null;
-		return logs[0].args.result ?? null;
-	}
-	async getAvailableCapacity() {
-		const { publicClient } = await this.ensureInitialized();
-		if (!this.config.blueprintContractAddress) throw new Error("blueprintContractAddress is required for getAvailableCapacity");
-		const result = await publicClient.readContract({
-			address: this.config.blueprintContractAddress,
-			abi: AgentSandboxBlueprintAbi,
-			functionName: "getAvailableCapacity"
-		});
-		return Number(result);
-	}
-	async getServiceStats() {
-		const { publicClient } = await this.ensureInitialized();
-		if (!this.config.blueprintContractAddress) throw new Error("blueprintContractAddress is required for getServiceStats");
-		const [totalSandboxes, totalCapacity] = await publicClient.readContract({
-			address: this.config.blueprintContractAddress,
-			abi: AgentSandboxBlueprintAbi,
-			functionName: "getServiceStats"
-		});
-		return {
-			totalSandboxes: Number(totalSandboxes),
-			totalCapacity: Number(totalCapacity)
-		};
-	}
-	getResponseParamTypes(jobIndex) {
-		if (jobIndex === 0) return SandboxCreateResponseParamTypes;
-		return JsonResponseParamTypes;
-	}
-};
-//#endregion
-//#region src/tangle/client.ts
-function randomHexToken(bytes) {
-	if (typeof globalThis.crypto === "undefined" || typeof globalThis.crypto.getRandomValues !== "function") throw new Error("randomHexToken: globalThis.crypto.getRandomValues is unavailable; this runtime cannot generate cryptographically secure nonces. Run on a host with WebCrypto support (Node 20+, browsers, Workers).");
-	const buf = new Uint8Array(bytes);
-	globalThis.crypto.getRandomValues(buf);
-	return Array.from(buf).map((b) => b.toString(16).padStart(2, "0")).join("");
-}
-function attestationNonceFromOptions(options) {
-	const direct = options.confidential?.attestationNonce;
-	if (direct) return direct;
-	const profile = options.backend?.profile;
-	if (typeof profile === "object") return profile.confidential?.attestationNonce;
-}
-function withAttestationNonce(options) {
-	if (options.confidential?.attestationRefresh && !options.confidential.attestationNonce) return {
-		...options,
-		confidential: {
-			...options.confidential,
-			attestationNonce: randomHexToken(32)
-		}
-	};
-	const profile = options.backend?.profile;
-	if (options.backend && typeof profile === "object" && profile.confidential?.attestationRefresh && !profile.confidential.attestationNonce) return {
-		...options,
-		backend: {
-			...options.backend,
-			profile: {
-				...profile,
-				confidential: {
-					...profile.confidential,
-					attestationNonce: randomHexToken(32)
-				}
-			}
-		}
-	};
-	return options;
-}
-var TangleSandboxClient = class {
-	chain;
-	sandboxes = /* @__PURE__ */ new Map();
-	operatorApiUrl;
-	operatorApiToken;
-	constructor(config) {
-		if (!config.privateKey && !config.wallet) throw new Error("TangleSandboxClient requires either privateKey or wallet");
-		this.chain = new TangleChainClient(config);
-		this.operatorApiUrl = config.operatorApiUrl?.replace(/\/+$/, "");
-		this.operatorApiToken = config.operatorApiToken;
-	}
-	/**
-	* Create a sandbox via on-chain job submission.
-	*/
-	async create(options) {
-		const createOptions = withAttestationNonce(options ?? {});
-		const encoded = this.chain.encodeSandboxCreateInputs(createOptions);
-		const { result: _result, callId, blockNumber } = await this.chain.submitJobAndWait(0, encoded);
-		const resultBytes = await this.chain.getJobResult(callId, blockNumber);
-		let sandboxId;
-		let responseJson = {};
-		if (resultBytes) try {
-			const decoded = (await import("viem")).decodeAbiParameters(this.chain.getResponseParamTypes(0), resultBytes);
-			sandboxId = decoded[0];
-			try {
-				responseJson = JSON.parse(decoded[1]);
-			} catch {}
-		} catch {
-			throw new Error("Failed to decode create job result");
-		}
-		else throw new Error("No result returned from create job");
-		const runtimeUrl = responseJson.runtimeUrl ?? responseJson.sidecarUrl ?? responseJson.sidecar_url ?? "";
-		const runtimeToken = responseJson.token ?? responseJson.runtimeToken ?? responseJson.sidecarToken ?? "";
-		if (runtimeUrl && !runtimeToken) throw new Error("Create job returned a runtime URL without an auth token");
-		const entry = {
-			id: sandboxId,
-			runtimeUrl,
-			runtimeToken,
-			status: "running",
-			createdAt: /* @__PURE__ */ new Date(),
-			teeAttestationJson: responseJson.teeAttestationJson,
-			teePublicKeyJson: responseJson.teePublicKeyJson,
-			attestationNonce: attestationNonceFromOptions(createOptions)
-		};
-		this.sandboxes.set(sandboxId, entry);
-		const info = {
-			id: sandboxId,
-			name: options?.name,
-			status: "running",
-			connection: runtimeUrl ? {
-				runtimeUrl,
-				authToken: runtimeToken
-			} : void 0,
-			metadata: {
-				...createOptions.metadata ?? {},
-				...entry.teeAttestationJson ? { teeAttestationJson: entry.teeAttestationJson } : {},
-				...entry.teePublicKeyJson ? { teePublicKeyJson: entry.teePublicKeyJson } : {},
-				...entry.attestationNonce ? { attestationNonce: entry.attestationNonce } : {}
-			},
-			createdAt: entry.createdAt
-		};
-		return new SandboxInstance(this, info);
-	}
-	/**
-	* Route interception for SandboxInstance lifecycle calls.
-	*
-	* SandboxInstance calls this.client.fetch() for:
-	* - GET /v1/sandboxes/:id → return from local tracking
-	* - POST /v1/sandboxes/:id/stop → unsupported until blueprint exposes stop
-	* - POST /v1/sandboxes/:id/resume → unsupported until blueprint exposes resume
-	* - DELETE /v1/sandboxes/:id → on-chain JOB_SANDBOX_DELETE
-	*/
-	async fetch(path, options) {
-		const method = options?.method ?? "GET";
-		const runtimeMatch = path.match(/^\/v1\/sandboxes\/([^/]+)\/runtime(\/.*)$/);
-		if (runtimeMatch) {
-			const id = decodeURIComponent(runtimeMatch[1]);
-			const runtimePath = runtimeMatch[2];
-			return this.fetchRuntime(id, runtimePath, options);
-		}
-		const getMatch = path.match(/^\/v1\/sandboxes\/([^/]+)$/);
-		if (getMatch && method === "GET") {
-			const id = decodeURIComponent(getMatch[1]);
-			const entry = this.sandboxes.get(id);
-			if (!entry) return new Response(JSON.stringify({ error: "Not found" }), { status: 404 });
-			return new Response(JSON.stringify({
-				id: entry.id,
-				status: entry.status,
-				connection: entry.runtimeUrl ? {
-					runtimeUrl: entry.runtimeUrl,
-					authToken: entry.runtimeToken
-				} : void 0,
-				metadata: {
-					...entry.teeAttestationJson ? { teeAttestationJson: entry.teeAttestationJson } : {},
-					...entry.teePublicKeyJson ? { teePublicKeyJson: entry.teePublicKeyJson } : {},
-					...entry.attestationNonce ? { attestationNonce: entry.attestationNonce } : {}
-				},
-				createdAt: entry.createdAt.toISOString()
-			}), {
-				status: 200,
-				headers: { "Content-Type": "application/json" }
-			});
-		}
-		const attestationMatch = path.match(/^\/v1\/sandboxes\/([^/]+)\/tee\/attestation$/);
-		if (attestationMatch && method === "GET") {
-			const id = decodeURIComponent(attestationMatch[1]);
-			if (this.operatorApiUrl) return this.fetchOperatorApi(`/api/sandboxes/${encodeURIComponent(id)}/tee/attestation`, options);
-			const response = await this.fetchRuntime(id, "/tee/attestation", {
-				...options,
-				method: "GET"
-			});
-			if (!response.ok) return response;
-			const attestation = await response.json();
-			return new Response(JSON.stringify({
-				sandbox_id: id,
-				attestation
-			}), {
-				status: 200,
-				headers: { "Content-Type": "application/json" }
-			});
-		}
-		if (attestationMatch && method === "POST") {
-			if (this.operatorApiUrl) {
-				const id = decodeURIComponent(attestationMatch[1]);
-				return this.fetchOperatorApi(`/api/sandboxes/${encodeURIComponent(id)}/tee/attestation`, options);
-			}
-			return new Response(JSON.stringify({ error: "Nonce-bound TEE attestation requires the operator API and is not available through the direct sidecar Tangle client" }), {
-				status: 501,
-				headers: { "Content-Type": "application/json" }
-			});
-		}
-		const publicKeyMatch = path.match(/^\/v1\/sandboxes\/([^/]+)\/tee\/public-key$/);
-		if (publicKeyMatch && method === "GET") {
-			const id = decodeURIComponent(publicKeyMatch[1]);
-			if (this.operatorApiUrl) return this.fetchOperatorApi(`/api/sandboxes/${encodeURIComponent(id)}/tee/public-key`, options);
-			const response = await this.fetchRuntime(id, "/tee/public-key", {
-				...options,
-				method: "GET"
-			});
-			if (!response.ok) return response;
-			const publicKey = await response.json();
-			return new Response(JSON.stringify({
-				sandbox_id: id,
-				public_key: publicKey
-			}), {
-				status: 200,
-				headers: { "Content-Type": "application/json" }
-			});
-		}
-		if (path.match(/^\/v1\/sandboxes\/([^/]+)\/stop$/) && method === "POST") return new Response(JSON.stringify({ error: "Sandbox stop is not exposed by the current Tangle blueprint" }), {
-			status: 501,
-			headers: { "Content-Type": "application/json" }
-		});
-		if (path.match(/^\/v1\/sandboxes\/([^/]+)\/resume$/) && method === "POST") return new Response(JSON.stringify({ error: "Sandbox resume is not exposed by the current Tangle blueprint" }), {
-			status: 501,
-			headers: { "Content-Type": "application/json" }
-		});
-		const deleteMatch = path.match(/^\/v1\/sandboxes\/([^/]+)$/);
-		if (deleteMatch && method === "DELETE") {
-			const id = decodeURIComponent(deleteMatch[1]);
-			const encoded = this.chain.encodeSandboxIdInputs(id);
-			await this.chain.submitJobAndWait(1, encoded);
-			const entry = this.sandboxes.get(id);
-			if (entry) entry.status = "deleted";
-			this.sandboxes.delete(id);
-			return new Response(null, { status: 204 });
-		}
-		throw new Error(`Operation not supported via on-chain client: ${method} ${path}`);
-	}
-	async fetchRuntime(sandboxId, runtimePath, options) {
-		const entry = this.sandboxes.get(sandboxId);
-		if (!entry?.runtimeUrl) return new Response(JSON.stringify({ error: "Sandbox runtime unavailable" }), {
-			status: 503,
-			headers: { "Content-Type": "application/json" }
-		});
-		const headers = new Headers(options?.headers);
-		headers.set("Authorization", `Bearer ${entry.runtimeToken}`);
-		const isFormDataBody = typeof FormData !== "undefined" && options?.body instanceof FormData;
-		if (!headers.has("Content-Type") && !isFormDataBody) headers.set("Content-Type", "application/json");
-		const method = options?.method ?? "GET";
-		return await fetch(`${entry.runtimeUrl.replace(/\/$/, "")}${runtimePath}`, {
-			...options,
-			method,
-			headers
-		});
-	}
-	/**
-	* Get available capacity from the blueprint contract.
-	* Requires blueprintContractAddress in config.
-	*/
-	async getAvailableCapacity() {
-		return this.chain.getAvailableCapacity();
-	}
-	/**
-	* Get service stats from the blueprint contract.
-	* Requires blueprintContractAddress in config.
-	*/
-	async getServiceStats() {
-		return this.chain.getServiceStats();
-	}
-	async fetchOperatorApi(path, options) {
-		if (!this.operatorApiUrl) return new Response(JSON.stringify({ error: "Operator API URL is not configured" }), {
-			status: 501,
-			headers: { "Content-Type": "application/json" }
-		});
-		const headers = new Headers(options?.headers);
-		if (this.operatorApiToken && !headers.has("Authorization")) headers.set("Authorization", `Bearer ${this.operatorApiToken}`);
-		if (options?.body && !headers.has("Content-Type")) headers.set("Content-Type", "application/json");
-		return fetch(`${this.operatorApiUrl}${path}`, {
-			...options,
-			headers
-		});
-	}
-};
-//#endregion
-export { TANGLE_JOBS_CONTRACT as a, ITangleJobsAbi as c, SandboxCreateResponseParamTypes as d, SandboxIdParamTypes as f, TANGLE_CHAIN_ID as i, JsonResponseParamTypes as l, JOB_SANDBOX_CREATE as n, TANGLE_MAINNET_RPC as o, JOB_SANDBOX_DELETE as r, AgentSandboxBlueprintAbi as s, TangleSandboxClient as t, SandboxCreateParamTypes as u };