@tangle-network/tcloud 0.4.1 → 0.4.3

package/dist/{client-C547pugt.d.cts → client-DkQugNHH.d.ts}

@@ -335,7 +335,7 @@ interface GatewayOptions {
  */
 interface BridgeOptions {
     /** Which harness to drive. Picks the backend on the bridge. */
-    harness: 'claude-code' | 'claudish' | 'codex' | 'opencode' | 'kimi-code' | 'openai' | 'anthropic' | 'moonshot' | 'zai';
+    harness: 'claude-code' | 'claudish' | 'codex' | 'opencode' | 'kimi-code' | 'sandbox' | 'openai' | 'anthropic' | 'moonshot' | 'zai';
     /** Model id inside the harness (e.g. `sonnet`, `kimi-for-coding`, `gpt-5-codex`). Omit for harness default. */
     model?: string;
     /** Router-issued unlock token. Required unless operator has disabled the gate. */
@@ -590,6 +590,8 @@ declare class PrivateRouter {
     private usage;
     private currentIndex;
     private totalRequests;
+    /** Slug of the most-recently-selected operator. Populated on each selectOperator() hit. */
+    private _lastSelectedSlug;
     constructor(config?: Partial<PrivateRouterConfig>);
     /** Set the available operator pool */
     setOperators(operators: OperatorInfo[]): void;
@@ -614,6 +616,8 @@ declare class PrivateRouter {
     private minExposure;
     private latencyAware;
     private recordUsage;
+    /** Slug of the most-recently-selected operator (null before the first call). */
+    get lastSelectedSlug(): string | null;
     private getLastUsedOperator;
     private peekNextOperator;
 }
@@ -623,6 +627,35 @@ declare class PrivateRouter {
  * Shared between CLI and SDK.
  */
 
+/** Rotation knobs for {@link TCloudClient.rotating}. */
+interface RotatingRoutingConfig {
+    /** Router strategy. Defaults to `'min-exposure'`. */
+    strategy?: Extract<RoutingStrategy, 'min-exposure' | 'round-robin' | 'random'>;
+    /**
+     * Pre-seed the operator pool. When omitted the client fetches
+     * `/api/operators` on the first call (TTL-cached).
+     */
+    pool?: OperatorInfo[];
+    /** Minimum distinct operators required before routing proceeds. */
+    minOperators?: number;
+    /** Max requests per operator before forced rotation. */
+    maxRequestsPerOperator?: number;
+    /** Exclude specific operator slugs. */
+    excludeOperators?: string[];
+    /** Prefer specific regions (others kept as fallback). */
+    preferRegions?: string[];
+}
+/** Configuration accepted by {@link TCloudClient.rotating}. */
+type RotatingClientConfig = Omit<TCloudConfig, 'routing'> & {
+    routing?: RotatingRoutingConfig;
+};
+/** Rotation stats surfaced by {@link TCloudClient.getRotationStats}. */
+interface RotationStats {
+    /** Per-operator call counter. */
+    callsByOperator: Record<string, number>;
+    /** Slug of the most-recently-selected operator, if any. */
+    currentOperator: string | null;
+}
 declare class TCloudClient {
     readonly baseURL: string;
     readonly platformURL: string;
@@ -675,6 +708,28 @@ declare class TCloudClient {
         /** Optional config passthrough (timeout, retry, etc). */
         config?: Omit<TCloudConfig, 'apiKey' | 'baseURL'>;
     }): TCloudClient;
+    /**
+     * Build a client that rotates which operator serves each call. Mirrors
+     * {@link TCloudClient.shielded} in shape: returns a standard `TCloudClient`
+     * that behaves identically for the OpenAI-compatible surface but
+     * dispatches each chat/completions/embeddings request through a
+     * {@link PrivateRouter} — different operator per call per the chosen
+     * strategy.
+     *
+     * ```ts
+     * const tcloud = TCloudClient.rotating({
+     *   apiKey: process.env.TCLOUD_API_KEY,
+     *   routing: { strategy: 'min-exposure' },
+     * })
+     * await tcloud.ask('hello')
+     * tcloud.getRotationStats() // { callsByOperator: { ... }, currentOperator: '…' }
+     * ```
+     *
+     * Rotation is meaningful only for stateless calls. Sandbox-harness
+     * sessions bind to a single operator for the lifetime of the session;
+     * `rotating()` clients refuse to dispatch them — see {@link bridge}.
+     */
+    static rotating(config?: RotatingClientConfig): TCloudClient;
     constructor(config?: TCloudConfig);
     /** Set the SpendAuth signer for private mode */
     setSpendAuthSigner(fn: () => Promise<SpendAuth>): void;
@@ -754,8 +809,19 @@ declare class TCloudClient {
      *
      * Sessions persist across process restarts — use the same `resume` id
      * to land on the same CLI conversation (context intact, no replay tax).
+     *
+     * Guard: clients built via {@link TCloudClient.rotating} cannot dispatch
+     * sandbox-harness sessions (rotation rotates per call; a sandbox session
+     * binds to one operator). Attempting `bridge({ harness: 'sandbox' })` on
+     * a rotating client throws.
      */
     bridge(cfg: BridgeOptions): BridgeSession;
+    /**
+     * Rotation stats — populated only on clients created via
+     * {@link TCloudClient.rotating}. Non-rotating clients return an empty
+     * counter and `currentOperator: null`.
+     */
+    getRotationStats(): RotationStats;
     /** Convenience: send a single message and get the text response */
     ask(message: string, modelOrOptions?: string | Partial<ChatOptions>): Promise<string>;
     /** Convenience: send a single message and get the full completion (with usage) */
@@ -1149,4 +1215,4 @@ declare class TCloudError extends Error {
     constructor(status: number, message: string);
 }
 
-export { type ApiKeyInfo as A, type BatchJobResponse as B, type ChatCompletion as C, type RoutingStrategy as D, type EmbeddingOptions as E, type FineTuningJob as F, type GatewayOptions as G, type SpendAuth as H, type ImageGenerateOptions as I, type JobEvent as J, type SpendingLimits as K, TCloudError as L, type Model as M, type TierConfig as N, type Operator as O, type PricingTier as P, type TranscriptionResponse as Q, type RerankOptions as R, type ShieldedConfig as S, TCloudClient as T, type UpdateKeyOptions as U, type VideoGenerateOptions as V, type VideoResponse as W, type WatchJobOptions as X, type TCloudConfig as a, type AvatarGenerateRequest as b, type AvatarGenerateResponse as c, type AvatarJobStatus as d, type AvatarResult as e, type BatchRequest as f, type BridgeOptions as g, BridgeSession as h, type ChatCompletionChunk as i, type ChatMessage as j, type ChatOptions as k, type CompletionOptions as l, type CompletionResponse as m, type CreateKeyOptions as n, type CreatedKey as o, type CreditBalance as p, type EmbeddingResponse as q, type FineTuningJobOptions as r, type ImageResponse as s, type OperatorInfo as t, type PrivacyConfig as u, PrivateRouter as v, type PrivateRouterConfig as w, type RerankResponse as x, type RetryConfig as y, type RoutingConfig as z };
+export { type ApiKeyInfo as A, type BatchJobResponse as B, type ChatCompletion as C, type RotatingRoutingConfig as D, type EmbeddingOptions as E, type FineTuningJob as F, type GatewayOptions as G, type RotationStats as H, type ImageGenerateOptions as I, type JobEvent as J, type RoutingConfig as K, type RoutingStrategy as L, type Model as M, type SpendAuth as N, type Operator as O, type PricingTier as P, type SpendingLimits as Q, type RotatingClientConfig as R, type ShieldedConfig as S, TCloudClient as T, TCloudError as U, type TierConfig as V, type TranscriptionResponse as W, type UpdateKeyOptions as X, type VideoGenerateOptions as Y, type VideoResponse as Z, type WatchJobOptions as _, type TCloudConfig as a, type AvatarGenerateRequest as b, type AvatarGenerateResponse as c, type AvatarJobStatus as d, type AvatarResult as e, type BatchRequest as f, type BridgeOptions as g, BridgeSession as h, type ChatCompletionChunk as i, type ChatMessage as j, type ChatOptions as k, type CompletionOptions as l, type CompletionResponse as m, type CreateKeyOptions as n, type CreatedKey as o, type CreditBalance as p, type EmbeddingResponse as q, type FineTuningJobOptions as r, type ImageResponse as s, type OperatorInfo as t, type PrivacyConfig as u, PrivateRouter as v, type PrivateRouterConfig as w, type RerankOptions as x, type RerankResponse as y, type RetryConfig as z };

package/dist/index.cjs

@@ -35,10 +35,23 @@ __export(index_exports, {
   TCloud: () => TCloud,
   TCloudClient: () => TCloudClient,
   TCloudError: () => TCloudError,
+  TCloudSandbox: () => TCloudSandbox,
+  assertAttestation: () => import_tcloud_attestation2.assertAttestation,
+  createSevSnpHardwareVerifier: () => import_tcloud_attestation2.createSevSnpHardwareVerifier,
   createShieldedClient: () => createShieldedClient,
+  createTdxHardwareVerifier: () => import_tcloud_attestation2.createTdxHardwareVerifier,
+  createTeeAttestationChallenge: () => createTeeAttestationChallenge,
   estimateCost: () => estimateCost,
+  generateAttestationNonce: () => generateAttestationNonce,
   generateWallet: () => generateWallet,
-  signSpendAuth: () => signSpendAuth
+  normalizeTeeType: () => import_tcloud_attestation2.normalizeTeeType,
+  parseAttestation: () => import_tcloud_attestation2.parseAttestation,
+  parseSevSnpReport: () => import_tcloud_attestation2.parseSevSnpReport,
+  signSpendAuth: () => signSpendAuth,
+  startTeeAttestationHeartbeat: () => startTeeAttestationHeartbeat,
+  toHex: () => import_tcloud_attestation2.toHex,
+  verifyAttestation: () => import_tcloud_attestation2.verifyAttestation,
+  verifyAttestationAsync: () => import_tcloud_attestation2.verifyAttestationAsync
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -54,6 +67,8 @@ var PrivateRouter = class {
   usage = /* @__PURE__ */ new Map();
   currentIndex = 0;
   totalRequests = 0;
+  /** Slug of the most-recently-selected operator. Populated on each selectOperator() hit. */
+  _lastSelectedSlug = null;
   constructor(config = {}) {
     this.config = {
       strategy: config.strategy || "round-robin",
@@ -199,6 +214,11 @@ var PrivateRouter = class {
       requestCount: (existing?.requestCount || 0) + 1,
       lastUsedAt: Date.now()
     });
+    this._lastSelectedSlug = op.slug;
+  }
+  /** Slug of the most-recently-selected operator (null before the first call). */
+  get lastSelectedSlug() {
+    return this._lastSelectedSlug;
   }
   getLastUsedOperator() {
     let latest = null;
@@ -256,6 +276,7 @@ var PrivateRouter = class {
 };
 
 // src/client.ts
+var ROTATING_MARKER = "__tcloudRotating";
 var DEFAULT_BASE_URL = "https://router.tangle.tools/v1";
 var SDK_VERSION = "0.4.0";
 async function proxiedFetch(privacy, url, init, streaming) {
@@ -353,6 +374,54 @@ var TCloudClient = class _TCloudClient {
     const baseURL = opts.url.replace(/\/+$/, "") + "/v1";
     return new _TCloudClient({ ...opts.config ?? {}, apiKey: opts.bearer, baseURL });
   }
+  /**
+   * Build a client that rotates which operator serves each call. Mirrors
+   * {@link TCloudClient.shielded} in shape: returns a standard `TCloudClient`
+   * that behaves identically for the OpenAI-compatible surface but
+   * dispatches each chat/completions/embeddings request through a
+   * {@link PrivateRouter} — different operator per call per the chosen
+   * strategy.
+   *
+   * ```ts
+   * const tcloud = TCloudClient.rotating({
+   *   apiKey: process.env.TCLOUD_API_KEY,
+   *   routing: { strategy: 'min-exposure' },
+   * })
+   * await tcloud.ask('hello')
+   * tcloud.getRotationStats() // { callsByOperator: { ... }, currentOperator: '…' }
+   * ```
+   *
+   * Rotation is meaningful only for stateless calls. Sandbox-harness
+   * sessions bind to a single operator for the lifetime of the session;
+   * `rotating()` clients refuse to dispatch them — see {@link bridge}.
+   */
+  static rotating(config = {}) {
+    const routing = config.routing ?? {};
+    const strategy = routing.strategy ?? "min-exposure";
+    const { routing: _omit, ...base } = config;
+    const client = new _TCloudClient(base);
+    const router = new PrivateRouter({
+      strategy,
+      minOperators: routing.minOperators ?? 1,
+      maxRequestsPerOperator: routing.maxRequestsPerOperator,
+      excludeOperators: routing.excludeOperators,
+      preferRegions: routing.preferRegions
+    });
+    if (routing.pool && routing.pool.length > 0) {
+      router.setOperators(routing.pool);
+      client._cachedOperators = routing.pool;
+      client._operatorsCachedAt = Date.now();
+    }
+    ;
+    client.privateRouter = router;
+    Object.defineProperty(client, ROTATING_MARKER, {
+      value: true,
+      enumerable: false,
+      configurable: false,
+      writable: false
+    });
+    return client;
+  }
   constructor(config = {}) {
     this.baseURL = (config.baseURL || DEFAULT_BASE_URL).replace(/\/$/, "");
     this.platformURL = (config.platformURL || DEFAULT_PLATFORM_URL).replace(/\/$/, "");
@@ -668,10 +737,38 @@ var TCloudClient = class _TCloudClient {
    *
    * Sessions persist across process restarts — use the same `resume` id
    * to land on the same CLI conversation (context intact, no replay tax).
+   *
+   * Guard: clients built via {@link TCloudClient.rotating} cannot dispatch
+   * sandbox-harness sessions (rotation rotates per call; a sandbox session
+   * binds to one operator). Attempting `bridge({ harness: 'sandbox' })` on
+   * a rotating client throws.
    */
   bridge(cfg) {
+    if (cfg.harness === "sandbox" && this[ROTATING_MARKER] === true) {
+      throw new Error(
+        "TCloudClient.rotating() cannot dispatch sandbox-harness sessions.\nSandbox sessions bind to a single operator; rotation is meaningful only for\nstateless calls. Use TCloudClient.shielded() + AgentProfile.confidential.tee\nfor privacy-preserving sandbox execution instead."
+      );
+    }
     return new BridgeSession(this, cfg);
   }
+  /**
+   * Rotation stats — populated only on clients created via
+   * {@link TCloudClient.rotating}. Non-rotating clients return an empty
+   * counter and `currentOperator: null`.
+   */
+  getRotationStats() {
+    if (!this.privateRouter) {
+      return { callsByOperator: {}, currentOperator: null };
+    }
+    const callsByOperator = {};
+    for (const row of this.privateRouter.getStats().operatorBreakdown) {
+      callsByOperator[row.slug] = row.requests;
+    }
+    return {
+      callsByOperator,
+      currentOperator: this.privateRouter.lastSelectedSlug
+    };
+  }
   /** Convenience: send a single message and get the text response */
   async ask(message, modelOrOptions) {
     const options = typeof modelOrOptions === "string" ? { model: modelOrOptions } : modelOrOptions;
@@ -1173,6 +1270,8 @@ var BridgeSession = class _BridgeSession {
     this.client = client;
     this.cfg = cfg;
   }
+  client;
+  cfg;
   /** Full chat completion (non-streaming). */
   async chat(options) {
     return this.client.chat({ ...options, bridge: this.cfg });
@@ -1242,6 +1341,7 @@ var TCloudError = class extends Error {
     this.status = status;
     this.name = "TCloudError";
   }
+  status;
 };
 
 // src/shielded.ts
@@ -1497,7 +1597,321 @@ async function replenishDirect(fundingKey, tokenAddress, amount, commitment, spe
   }
 }
 
+// src/sandbox.ts
+var import_sandbox = require("@tangle-network/sandbox");
+var import_node_crypto = require("crypto");
+var import_tcloud_attestation = require("@tangle-network/tcloud-attestation");
+var DEFAULT_SANDBOX_URL = "https://sandbox.tangle.tools";
+var TCloudSandbox = class {
+  client;
+  apiKey;
+  baseUrl;
+  timeoutMs;
+  constructor(config) {
+    this.apiKey = config.apiKey;
+    this.baseUrl = (config.baseUrl ?? DEFAULT_SANDBOX_URL).replace(/\/+$/, "");
+    this.timeoutMs = config.timeoutMs;
+    this.client = new import_sandbox.Sandbox({
+      apiKey: this.apiKey,
+      baseUrl: this.baseUrl,
+      timeoutMs: config.timeoutMs
+    });
+  }
+  async create(options) {
+    const effectiveVerify = shouldVerifyAttestation(options);
+    const attestationPolicy = buildAttestationPolicy(options);
+    const createOptions = buildSandboxCreateOptions({
+      ...options,
+      verify: effectiveVerify
+    });
+    const sandbox = await this.client.create(createOptions);
+    this.attachTeeApiFallbacks(sandbox);
+    let attestation = attestationFromMetadata(sandbox.metadata);
+    if ((effectiveVerify || createOptions.confidential?.attestationNonce) && !attestation) {
+      const getTeeAttestation = sandbox.getTeeAttestation;
+      if (typeof getTeeAttestation !== "function") {
+        throw new Error("Installed @tangle-network/sandbox does not expose TEE attestation fetching");
+      }
+      attestation = (await getTeeAttestation.call(
+        sandbox,
+        createOptions.confidential?.attestationNonce ? { attestationNonce: createOptions.confidential.attestationNonce } : void 0
+      )).attestation;
+    }
+    if (effectiveVerify && !attestation) {
+      throw new Error("TEE attestation verification requested but no evidence was returned");
+    }
+    const verification = effectiveVerify ? await (0, import_tcloud_attestation.verifyAttestationAsync)(attestation, {
+      ...attestationPolicy,
+      expectedNonce: createOptions.confidential?.attestationNonce
+    }) : void 0;
+    if (verification && !verification.valid) {
+      throw new Error(`TEE attestation verification failed: ${verification.errors.join("; ")}`);
+    }
+    return {
+      sandbox,
+      attestation,
+      verification,
+      attestationNonce: createOptions.confidential?.attestationNonce,
+      attestationStatus: {
+        requested: Boolean(options.tee),
+        evidenceReturned: Boolean(attestation),
+        verified: Boolean(verification?.valid),
+        nonceBound: Boolean(createOptions.confidential?.attestationNonce && verification?.valid),
+        errors: verification?.errors ?? []
+      }
+    };
+  }
+  attachTeeApiFallbacks(sandbox) {
+    if (typeof sandbox !== "object" || sandbox === null) return;
+    const target = sandbox;
+    if (typeof target.id !== "string" || target.id.length === 0) return;
+    if (typeof target.getTeeAttestation !== "function") {
+      target.getTeeAttestation = (options) => this.fetchTeeAttestation(target.id, options?.attestationNonce);
+    }
+    if (typeof target.getTeePublicKey !== "function") {
+      target.getTeePublicKey = () => this.fetchTeePublicKey(target.id);
+    }
+  }
+  async fetchTeeAttestation(sandboxId, attestationNonce) {
+    const response = await this.fetchSandboxApi(
+      `/v1/sandboxes/${encodeURIComponent(sandboxId)}/tee/attestation`,
+      {
+        method: attestationNonce ? "POST" : "GET",
+        body: attestationNonce ? JSON.stringify({ attestation_nonce: attestationNonce }) : void 0
+      }
+    );
+    const data = await response.json();
+    if (attestationNonce && !data.attestationNonce) {
+      data.attestationNonce = attestationNonce;
+    }
+    return data;
+  }
+  async fetchTeePublicKey(sandboxId) {
+    const response = await this.fetchSandboxApi(
+      `/v1/sandboxes/${encodeURIComponent(sandboxId)}/tee/public-key`,
+      { method: "GET" }
+    );
+    return response.json();
+  }
+  async fetchSandboxApi(path, options) {
+    const headers = new Headers(options.headers);
+    headers.set("Authorization", `Bearer ${this.apiKey}`);
+    if (options.body && !headers.has("Content-Type")) {
+      headers.set("Content-Type", "application/json");
+    }
+    const response = await fetch(`${this.baseUrl}${path}`, {
+      ...options,
+      headers,
+      signal: options.signal ?? (this.timeoutMs ? AbortSignal.timeout(this.timeoutMs) : void 0)
+    });
+    if (!response.ok) {
+      const body = await response.text();
+      throw new Error(`Sandbox API ${path} failed with HTTP ${response.status}: ${body}`);
+    }
+    return response;
+  }
+};
+function createTeeAttestationChallenge(context) {
+  const randomHex = generateAttestationNonce(32);
+  if (context == null) {
+    return { nonce: randomHex, randomHex };
+  }
+  const contextHashHex = (0, import_node_crypto.createHash)("sha256").update(typeof context === "string" ? Buffer.from(context) : Buffer.from(context)).digest("hex");
+  return {
+    nonce: `${randomHex}${contextHashHex}`,
+    randomHex,
+    contextHashHex
+  };
+}
+function startTeeAttestationHeartbeat(sandbox, options = {}) {
+  const getTeeAttestation = sandbox?.getTeeAttestation;
+  if (typeof getTeeAttestation !== "function") {
+    throw new Error("Sandbox does not expose TEE attestation fetching");
+  }
+  const intervalMs = options.intervalMs ?? 6e4;
+  const sessionId = options.sessionId ?? generateAttestationNonce(16);
+  const policy = options.tee ? buildAttestationPolicy({ tee: options.tee, attestationPolicy: options.attestationPolicy }) : options.attestationPolicy ?? {};
+  let stopped = false;
+  let failures = 0;
+  let sequence = 0;
+  let latest;
+  let timer;
+  let resolveDone;
+  const done = new Promise((resolve) => {
+    resolveDone = resolve;
+  });
+  const stop = () => {
+    if (stopped) return;
+    stopped = true;
+    if (timer) clearTimeout(timer);
+    resolveDone?.();
+  };
+  const ping = async (context) => {
+    if (stopped || options.signal?.aborted) {
+      throw new Error("TEE attestation heartbeat is stopped");
+    }
+    const nextSequence = sequence + 1;
+    const boundContext = context ?? `${sessionId}:${nextSequence}`;
+    const challenge = createTeeAttestationChallenge(boundContext);
+    const response = await getTeeAttestation.call(sandbox, {
+      attestationNonce: challenge.nonce
+    });
+    const attestation = response?.attestation;
+    if (!attestation) {
+      throw new Error("TEE attestation heartbeat returned no evidence");
+    }
+    const verification = await (0, import_tcloud_attestation.verifyAttestationAsync)(attestation, {
+      ...policy,
+      expectedNonce: challenge.nonce
+    });
+    if (!verification.valid) {
+      throw new Error(`TEE attestation heartbeat verification failed: ${verification.errors.join("; ")}`);
+    }
+    const sample = {
+      sequence: nextSequence,
+      nonce: challenge.nonce,
+      context: boundContext,
+      attestation,
+      verification,
+      checkedAt: /* @__PURE__ */ new Date()
+    };
+    sequence = nextSequence;
+    latest = sample;
+    options.onSuccess?.(sample);
+    return sample;
+  };
+  const schedule = () => {
+    if (stopped || options.signal?.aborted) {
+      stop();
+      return;
+    }
+    timer = setTimeout(() => {
+      void loop();
+    }, intervalMs);
+  };
+  const loop = async () => {
+    try {
+      await ping();
+      schedule();
+    } catch (error) {
+      failures += 1;
+      options.onFailure?.(error);
+      if (options.continueOnFailure) {
+        schedule();
+      } else {
+        stop();
+      }
+    }
+  };
+  options.signal?.addEventListener("abort", stop, { once: true });
+  if (options.immediate === false) {
+    schedule();
+  } else {
+    void loop();
+  }
+  return {
+    stop,
+    ping,
+    get stopped() {
+      return stopped;
+    },
+    get failures() {
+      return failures;
+    },
+    get latest() {
+      return latest;
+    },
+    done
+  };
+}
+function buildSandboxCreateOptions(options) {
+  if (!options.tee && (options.sealed || options.attestationNonce || options.verify)) {
+    throw new Error("TEE options require a tee value");
+  }
+  const shouldGenerateNonce = options.attestationNonce === "auto" || shouldVerifyAttestation(options) && !options.attestationNonce;
+  const attestationNonce = shouldGenerateNonce ? generateAttestationNonce() : options.attestationNonce;
+  if (attestationNonce) {
+    validateAttestationNonce(attestationNonce);
+  }
+  return {
+    name: options.name,
+    environment: options.environment ?? options.image,
+    sshEnabled: options.ssh || void 0,
+    git: options.gitUrl ? {
+      url: options.gitUrl,
+      ref: options.gitRef
+    } : void 0,
+    resources: options.cpu || options.memoryMb || options.diskGb ? {
+      cpuCores: options.cpu,
+      memoryMB: options.memoryMb,
+      diskGB: options.diskGb
+    } : void 0,
+    backend: options.backend ? { type: options.backend } : void 0,
+    confidential: options.tee ? {
+      tee: options.tee,
+      sealed: options.sealed || void 0,
+      attestationNonce,
+      attestationRefresh: Boolean(attestationNonce)
+    } : void 0
+  };
+}
+function shouldVerifyAttestation(options) {
+  return Boolean(options.tee || options.verify);
+}
+function buildAttestationPolicy(options) {
+  if (!options.tee || options.tee === "any") return options.attestationPolicy ?? {};
+  const requestedTypes = acceptedAttestationTypesForTee(options.tee);
+  const acceptedTeeTypes = options.attestationPolicy?.acceptedTeeTypes;
+  if (acceptedTeeTypes?.length && !acceptedTeeTypes.some((type) => requestedTypes.includes(type))) {
+    throw new Error(
+      `TEE attestation policy does not accept requested TEE type ${options.tee}`
+    );
+  }
+  return {
+    ...options.attestationPolicy,
+    acceptedTeeTypes: acceptedTeeTypes?.length ? acceptedTeeTypes.filter((type) => requestedTypes.includes(type)) : requestedTypes
+  };
+}
+function acceptedAttestationTypesForTee(tee) {
+  switch (tee) {
+    case "phala-dstack":
+      return ["tdx", "phala-dstack"];
+    case "gcp":
+      return ["tdx", "sev-snp", "gcp"];
+    case "azure":
+      return ["sev-snp", "azure"];
+    default:
+      return [(0, import_tcloud_attestation.normalizeTeeType)(tee)];
+  }
+}
+function validateAttestationNonce(value) {
+  const normalized = value.trim().toLowerCase().replace(/^0x/, "");
+  if (!/^[0-9a-f]+$/.test(normalized)) {
+    throw new Error("attestation nonce must be hex");
+  }
+  if (normalized.length % 2 !== 0) {
+    throw new Error("attestation nonce must have even hex length");
+  }
+  const bytes = normalized.length / 2;
+  if (bytes < 32 || bytes > 64) {
+    throw new Error(`attestation nonce must be 32-64 bytes, got ${bytes}`);
+  }
+}
+function generateAttestationNonce(bytes = 32) {
+  return Array.from((0, import_node_crypto.randomBytes)(bytes)).map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function attestationFromMetadata(metadata) {
+  const raw = metadata?.teeAttestationJson;
+  if (typeof raw !== "string" || raw.trim() === "") return void 0;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+}
+
 // src/index.ts
+var import_tcloud_attestation2 = require("@tangle-network/tcloud-attestation");
 var TCloud = class _TCloud extends TCloudClient {
   constructor(config) {
     super(config);
@@ -1526,6 +1940,21 @@ var TCloud = class _TCloud extends TCloudClient {
   static shielded(config) {
     return createShieldedClient(config);
   }
+  /**
+   * Create a client that rotates operators per call.
+   * See {@link TCloudClient.rotating} for semantics.
+   *
+   * ```ts
+   * const client = TCloud.rotating({
+   *   apiKey: process.env.TCLOUD_API_KEY,
+   *   routing: { strategy: 'min-exposure' },
+   * })
+   * const stats = client.getRotationStats()
+   * ```
+   */
+  static rotating(config) {
+    return TCloudClient.rotating(config);
+  }
   /**
    * Generate a new ephemeral wallet (without creating a client).
    *
@@ -1543,8 +1972,21 @@ var TCloud = class _TCloud extends TCloudClient {
   TCloud,
   TCloudClient,
   TCloudError,
+  TCloudSandbox,
+  assertAttestation,
+  createSevSnpHardwareVerifier,
   createShieldedClient,
+  createTdxHardwareVerifier,
+  createTeeAttestationChallenge,
   estimateCost,
+  generateAttestationNonce,
   generateWallet,
-  signSpendAuth
+  normalizeTeeType,
+  parseAttestation,
+  parseSevSnpReport,
+  signSpendAuth,
+  startTeeAttestationHeartbeat,
+  toHex,
+  verifyAttestation,
+  verifyAttestationAsync
 });

package/dist/index.d.cts

@@ -1,7 +1,9 @@
 import { ShieldedWallet, generateWallet } from './shielded.cjs';
 export { createShieldedClient, estimateCost, signSpendAuth } from './shielded.cjs';
-import { T as TCloudClient, a as TCloudConfig } from './client-C547pugt.cjs';
-export { A as ApiKeyInfo, b as AvatarGenerateRequest, c as AvatarGenerateResponse, d as AvatarJobStatus, e as AvatarResult, B as BatchJobResponse, f as BatchRequest, g as BridgeOptions, h as BridgeSession, C as ChatCompletion, i as ChatCompletionChunk, j as ChatMessage, k as ChatOptions, l as CompletionOptions, m as CompletionResponse, n as CreateKeyOptions, o as CreatedKey, p as CreditBalance, E as EmbeddingOptions, q as EmbeddingResponse, F as FineTuningJob, r as FineTuningJobOptions, G as GatewayOptions, I as ImageGenerateOptions, s as ImageResponse, J as JobEvent, M as Model, O as Operator, t as OperatorInfo, P as PricingTier, u as PrivacyConfig, v as PrivateRouter, w as PrivateRouterConfig, R as RerankOptions, x as RerankResponse, y as RetryConfig, z as RoutingConfig, D as RoutingStrategy, S as ShieldedConfig, H as SpendAuth, K as SpendingLimits, L as TCloudError, N as TierConfig, Q as TranscriptionResponse, U as UpdateKeyOptions, V as VideoGenerateOptions, W as VideoResponse, X as WatchJobOptions } from './client-C547pugt.cjs';
+import { T as TCloudClient, a as TCloudConfig, R as RotatingClientConfig } from './client-DkQugNHH.cjs';
+export { A as ApiKeyInfo, b as AvatarGenerateRequest, c as AvatarGenerateResponse, d as AvatarJobStatus, e as AvatarResult, B as BatchJobResponse, f as BatchRequest, g as BridgeOptions, h as BridgeSession, C as ChatCompletion, i as ChatCompletionChunk, j as ChatMessage, k as ChatOptions, l as CompletionOptions, m as CompletionResponse, n as CreateKeyOptions, o as CreatedKey, p as CreditBalance, E as EmbeddingOptions, q as EmbeddingResponse, F as FineTuningJob, r as FineTuningJobOptions, G as GatewayOptions, I as ImageGenerateOptions, s as ImageResponse, J as JobEvent, M as Model, O as Operator, t as OperatorInfo, P as PricingTier, u as PrivacyConfig, v as PrivateRouter, w as PrivateRouterConfig, x as RerankOptions, y as RerankResponse, z as RetryConfig, D as RotatingRoutingConfig, H as RotationStats, K as RoutingConfig, L as RoutingStrategy, S as ShieldedConfig, N as SpendAuth, Q as SpendingLimits, U as TCloudError, V as TierConfig, W as TranscriptionResponse, X as UpdateKeyOptions, Y as VideoGenerateOptions, Z as VideoResponse, _ as WatchJobOptions } from './client-DkQugNHH.cjs';
+export { TCloudSandbox, TCloudSandboxAttestationStatus, TCloudSandboxConfig, TCloudSandboxCreateOptions, TCloudSandboxCreateResult, TCloudSandboxTee, TCloudTeeAttestationChallenge, TCloudTeeAttestationHeartbeat, TCloudTeeAttestationHeartbeatOptions, TCloudTeeAttestationHeartbeatSample, createTeeAttestationChallenge, generateAttestationNonce, startTeeAttestationHeartbeat } from './sandbox.cjs';
+export { AsyncAttestationPolicy, AsyncHardwareVerifier, AttestationPolicy, AttestationVerificationResult, HardwareVerifier, HardwareVerifierResult, ParsedAttestation, SevSnpReport, SevSnpVerifierOptions, TeeType, assertAttestation, createSevSnpHardwareVerifier, createTdxHardwareVerifier, normalizeTeeType, parseAttestation, parseSevSnpReport, toHex, verifyAttestation, verifyAttestationAsync } from '@tangle-network/tcloud-attestation';
 export { AgentProfile, AgentProfileCapabilities, AgentProfileMcpServer, AgentProfileModelHints, AgentProfilePermissionValue, AgentProfilePrompt, AgentProfileResources } from '@tangle-network/sandbox';
 import 'viem';
 
@@ -36,6 +38,19 @@ declare class TCloud extends TCloudClient {
         wallet: ShieldedWallet;
         stopAutoReplenish: () => void;
     };
+    /**
+     * Create a client that rotates operators per call.
+     * See {@link TCloudClient.rotating} for semantics.
+     *
+     * ```ts
+     * const client = TCloud.rotating({
+     *   apiKey: process.env.TCLOUD_API_KEY,
+     *   routing: { strategy: 'min-exposure' },
+     * })
+     * const stats = client.getRotationStats()
+     * ```
+     */
+    static rotating(config?: RotatingClientConfig): TCloudClient;
     /**
      * Generate a new ephemeral wallet (without creating a client).
      *
@@ -47,4 +62,4 @@ declare class TCloud extends TCloudClient {
     static generateWallet: typeof generateWallet;
 }
 
-export { ShieldedWallet, TCloud, TCloudClient, TCloudConfig, generateWallet };
+export { RotatingClientConfig, ShieldedWallet, TCloud, TCloudClient, TCloudConfig, generateWallet };