@tangle-network/tcloud 0.2.0 → 0.4.0

package/dist/{chunk-HL4CXKET.js → chunk-AKR7CS4P.js}

@@ -213,6 +213,7 @@ var PrivateRouter = class {
 
 // src/client.ts
 var DEFAULT_BASE_URL = "https://router.tangle.tools/v1";
+var SDK_VERSION = "0.4.0";
 async function proxiedFetch(privacy, url, init, streaming) {
   if (!privacy || privacy.mode === "direct") {
     return fetch(url, init);
@@ -259,8 +260,10 @@ var DEFAULT_RETRY = {
   retryableStatuses: [429, 500, 502, 503, 504]
 };
 var DEFAULT_TIMEOUT_MS = 6e4;
+var DEFAULT_PLATFORM_URL = "https://id.tangle.tools";
 var TCloudClient = class _TCloudClient {
   baseURL;
+  platformURL;
   apiKey;
   model;
   headers;
@@ -277,6 +280,7 @@ var TCloudClient = class _TCloudClient {
   static OPERATORS_TTL_MS = 5 * 60 * 1e3;
   constructor(config = {}) {
     this.baseURL = (config.baseURL || DEFAULT_BASE_URL).replace(/\/$/, "");
+    this.platformURL = (config.platformURL || DEFAULT_PLATFORM_URL).replace(/\/$/, "");
     this.apiKey = config.apiKey || process.env.TCLOUD_API_KEY;
     this.model = config.model || "gpt-4o-mini";
     this.privacy = config.privacy;
@@ -285,7 +289,7 @@ var TCloudClient = class _TCloudClient {
     this.timeoutMs = config.timeout ?? DEFAULT_TIMEOUT_MS;
     this.headers = {
       "Content-Type": "application/json",
-      "X-Tangle-Client": "tcloud-sdk/0.2.0"
+      "X-Tangle-Client": `tcloud-sdk/${SDK_VERSION}`
     };
     if (this.apiKey) {
       this.headers["Authorization"] = `Bearer ${this.apiKey}`;
@@ -465,10 +469,11 @@ var TCloudClient = class _TCloudClient {
     return res;
   }
   /**
-   * Prepare headers for chat requests — operator routing + SpendAuth.
+   * Prepare headers for chat requests — operator routing + SpendAuth +
+   * bridge short-circuit headers when `options.bridge` is set.
    * Shared between chat() and chatStream() to eliminate duplication.
    */
-  async _prepareChatRequest(model) {
+  async _prepareChatRequest(model, bridge) {
     const headers = { ...this.headers };
     if (this.spendAuthFn) {
       const auth = await this.spendAuthFn();
@@ -485,12 +490,28 @@ var TCloudClient = class _TCloudClient {
         delete headers["Authorization"];
       }
     }
+    if (bridge) {
+      headers["X-Bridge-Unlock"] = bridge.unlock;
+      if (bridge.resume) headers["X-Resume"] = bridge.resume;
+      if (bridge.bridgeUrl) headers["X-Bridge-Url"] = bridge.bridgeUrl;
+      if (bridge.bridgeBearer) headers["X-Bridge-Bearer"] = bridge.bridgeBearer;
+    }
     return { headers, baseURL };
   }
+  /**
+   * Resolve the effective model string. When a bridge is set, rewrite to
+   * `bridge/<harness>/<model>` (or `bridge/<harness>` if no model).
+   */
+  _effectiveModel(options) {
+    if (options.bridge) {
+      return options.bridge.model ? `bridge/${options.bridge.harness}/${options.bridge.model}` : `bridge/${options.bridge.harness}`;
+    }
+    return options.model || this.model;
+  }
   /** Build the chat completions request body */
   _chatBody(options, stream) {
     return JSON.stringify({
-      model: options.model || this.model,
+      model: this._effectiveModel(options),
       messages: options.messages,
       temperature: options.temperature,
       max_tokens: options.maxTokens,
@@ -502,13 +523,17 @@ var TCloudClient = class _TCloudClient {
       response_format: options.responseFormat,
       tools: options.tools,
       tool_choice: options.toolChoice,
+      ...options.gateway ? { gateway: options.gateway } : {},
       ...options.providerOptions
     });
   }
   /** Chat completion (non-streaming) */
   async chat(options) {
     this.checkLimits();
-    const { headers, baseURL } = await this._prepareChatRequest(options.model || this.model);
+    const { headers, baseURL } = await this._prepareChatRequest(
+      this._effectiveModel(options),
+      options.bridge
+    );
     const res = await this._doFetch(`${baseURL}/chat/completions`, {
       method: "POST",
       headers,
@@ -522,7 +547,10 @@ var TCloudClient = class _TCloudClient {
   async *chatStream(options) {
     this.checkLimits();
     this._requestCount++;
-    const { headers, baseURL } = await this._prepareChatRequest(options.model || this.model);
+    const { headers, baseURL } = await this._prepareChatRequest(
+      this._effectiveModel(options),
+      options.bridge
+    );
     const res = await this._doFetch(`${baseURL}/chat/completions`, {
       method: "POST",
       headers,
@@ -551,6 +579,24 @@ var TCloudClient = class _TCloudClient {
       }
     }
   }
+  /**
+   * Bridge — scoped helper for a subscription-backed CLI harness behind
+   * the Tangle Router's cli-bridge. Returns a mini-client bound to
+   * (harness, unlock, resume) so you don't thread those through every
+   * call.
+   *
+   * ```ts
+   * const kimi = tcloud.bridge({ harness: 'kimi-code', model: 'kimi-for-coding', unlock: UNLOCK, resume: 'pr-42' })
+   * await kimi.ask('review this diff…')
+   * for await (const chunk of kimi.stream('continue…')) process.stdout.write(chunk)
+   * ```
+   *
+   * Sessions persist across process restarts — use the same `resume` id
+   * to land on the same CLI conversation (context intact, no replay tax).
+   */
+  bridge(cfg) {
+    return new BridgeSession(this, cfg);
+  }
   /** Convenience: send a single message and get the text response */
   async ask(message, modelOrOptions) {
     const options = typeof modelOrOptions === "string" ? { model: modelOrOptions } : modelOrOptions;
@@ -589,43 +635,89 @@ var TCloudClient = class _TCloudClient {
     const apiRoot = this.baseURL.replace(/\/v1$/, "");
     return this._fetch(`${apiRoot}/api/operators`);
   }
+  // ── Billing (via id.tangle.tools) ──
   /** Get credit balance */
   async credits() {
-    const apiRoot = this.baseURL.replace(/\/v1$/, "");
-    return this._fetch(`${apiRoot}/api/billing`);
+    const { data } = await this._fetch(`${this.platformURL}/v1/billing/balance`);
+    return data;
   }
-  /** Add credits */
+  /** Add credits via Stripe checkout. Returns the checkout URL. */
   async addCredits(amount) {
-    const apiRoot = this.baseURL.replace(/\/v1$/, "");
-    return this._fetch(`${apiRoot}/api/billing`, {
+    const { data } = await this._fetch(`${this.platformURL}/v1/billing/topup`, {
       method: "POST",
       body: JSON.stringify({ amount })
     });
+    return data;
   }
-  /** Create a new API key */
-  async createKey(name) {
-    const apiRoot = this.baseURL.replace(/\/v1$/, "");
-    return this._fetch(`${apiRoot}/api/keys`, {
+  /** Get transaction history */
+  async transactions(limit = 50) {
+    const { data } = await this._fetch(`${this.platformURL}/v1/billing/transactions?limit=${limit}`);
+    return data;
+  }
+  // ── API Keys (via id.tangle.tools) ──
+  /**
+   * Create a new API key.
+   * When called with an API key (not session), the new key is automatically
+   * a child of the calling key — enabling hierarchical key delegation.
+   *
+   * Pass `parentKeyId` explicitly to create a child of a specific key.
+   * Child keys inherit the parent's product scope, allowedModels, and rpmLimit
+   * if not specified. Budget cannot exceed the parent's remaining budget.
+   */
+  async createKey(opts) {
+    const { data } = await this._fetch(`${this.platformURL}/v1/keys`, {
       method: "POST",
-      body: JSON.stringify({ name })
+      body: JSON.stringify(opts)
     });
+    return data;
   }
-  /** List API keys */
-  async keys() {
-    const apiRoot = this.baseURL.replace(/\/v1$/, "");
-    return this._fetch(`${apiRoot}/api/keys`);
+  /** Get a single API key by ID */
+  async getKey(id) {
+    const { data } = await this._fetch(`${this.platformURL}/v1/keys/${id}`);
+    return data;
+  }
+  /**
+   * List API keys.
+   * Pass `children: true` to list child keys of the calling API key.
+   */
+  async keys(opts) {
+    const q = opts?.children ? "?children=true" : "";
+    const { data } = await this._fetch(`${this.platformURL}/v1/keys${q}`);
+    return data;
+  }
+  /**
+   * Update an API key's limits.
+   * Can adjust budget, allowedModels, rpmLimit, expiresAt, and name.
+   */
+  async updateKey(id, updates) {
+    const { data } = await this._fetch(`${this.platformURL}/v1/keys/${id}`, {
+      method: "PATCH",
+      body: JSON.stringify(updates)
+    });
+    return data;
   }
-  /** Revoke an API key */
+  /** Revoke an API key. If the key has children, they are also revoked recursively. */
   async revokeKey(id) {
-    const apiRoot = this.baseURL.replace(/\/v1$/, "");
-    const res = await proxiedFetch(this.privacy, `${apiRoot}/api/keys/${id}`, {
-      method: "DELETE",
-      headers: this.headers
-    }, false);
-    if (!res.ok) {
-      const err = await res.json().catch(() => ({ error: res.statusText }));
-      throw new TCloudError(res.status, err.error?.message || err.error || err.message || res.statusText);
-    }
+    await this._fetch(`${this.platformURL}/v1/keys/${id}`, { method: "DELETE" });
+  }
+  /** Rotate an API key — creates new key with same config, revokes old */
+  async rotateKey(id) {
+    const { data } = await this._fetch(`${this.platformURL}/v1/keys/${id}/rotate`, { method: "POST" });
+    return data;
+  }
+  // ── Projects (via id.tangle.tools) ──
+  /** Create a project for usage attribution */
+  async createProject(name, product) {
+    const { data } = await this._fetch(`${this.platformURL}/v1/projects`, {
+      method: "POST",
+      body: JSON.stringify({ name, product })
+    });
+    return data;
+  }
+  /** List projects */
+  async projects() {
+    const { data } = await this._fetch(`${this.platformURL}/v1/projects`);
+    return data;
   }
   /** Generate embeddings */
   async embeddings(options) {
@@ -936,6 +1028,61 @@ var TCloudClient = class _TCloudClient {
       };
     });
   }
+  // ── Eval ──────────────────────────────────────────────────────────────
+  get _apiRoot() {
+    return this.baseURL.replace(/\/v1$/, "");
+  }
+  async eval(opts) {
+    return this._request(`${this._apiRoot}/api/eval`, { method: "POST", body: JSON.stringify(opts) });
+  }
+  async createSuite(opts) {
+    return this._request(`${this._apiRoot}/api/eval/suites`, { method: "POST", body: JSON.stringify(opts) });
+  }
+  async listSuites() {
+    return this._fetch(`${this._apiRoot}/api/eval/suites`);
+  }
+  async runSuite(suiteId, opts) {
+    return this._request(`${this._apiRoot}/api/eval/suites/${suiteId}/runs`, { method: "POST", body: JSON.stringify(opts || {}) });
+  }
+  async listRuns(suiteId) {
+    return this._fetch(`${this._apiRoot}/api/eval/suites/${suiteId}/runs`);
+  }
+  async getRun(runId) {
+    return this._fetch(`${this._apiRoot}/api/eval/runs/${runId}`);
+  }
+  async setBaseline(runId) {
+    await this._request(`${this._apiRoot}/api/eval/runs/${runId}`, { method: "PATCH", body: JSON.stringify({ baseline: true }) });
+  }
+  // ── Sandbox ──────────────────────────────────────────────────────────
+  async sandboxPricing(opts) {
+    const p = new URLSearchParams();
+    if (opts?.cpu) p.set("cpu", String(opts.cpu));
+    if (opts?.ram) p.set("ram", String(opts.ram));
+    if (opts?.disk) p.set("disk", String(opts.disk));
+    return this._fetch(`${this._apiRoot}/api/sandbox/pricing?${p}`);
+  }
+  async sandboxStatus() {
+    return this._fetch(`${this._apiRoot}/api/sandbox/link-key`);
+  }
+  async sandboxProvision() {
+    return this._request(`${this._apiRoot}/api/sandbox/provision`, { method: "POST" });
+  }
+  async sandboxCreate(opts) {
+    return this._request(`${this._apiRoot}/api/sandbox/sessions`, { method: "POST", body: JSON.stringify(opts) });
+  }
+  async sandboxList() {
+    return this._fetch(`${this._apiRoot}/api/sandbox/sessions`);
+  }
+  async sandboxStats(sandboxId) {
+    return this._fetch(`${this._apiRoot}/api/sandbox/stats/${sandboxId}`);
+  }
+  async sandboxDestroy(sessionId) {
+    return this._request(`${this._apiRoot}/api/sandbox/sessions/${sessionId}`, { method: "DELETE" });
+  }
+  // ── User Info ────────────────────────────────────────────────────────
+  async userInfo() {
+    return this._fetch(`${this._apiRoot}/api/auth/userinfo`);
+  }
 };
 var ALL_TIERS = [
   { name: "cpu-only", cpu: 4, ramGb: 16, gpu: 0, tee: false },
@@ -946,6 +1093,59 @@ var ALL_TIERS = [
   { name: "max-gpu", cpu: 64, ramGb: 256, gpu: 4, tee: false },
   { name: "max-gpu-tee", cpu: 64, ramGb: 256, gpu: 4, tee: true }
 ];
+var BridgeSession = class _BridgeSession {
+  constructor(client, cfg) {
+    this.client = client;
+    this.cfg = cfg;
+  }
+  /** Full chat completion (non-streaming). */
+  async chat(options) {
+    return this.client.chat({ ...options, bridge: this.cfg });
+  }
+  /** Stream OpenAI chat.completion.chunks. */
+  chatStream(options) {
+    return this.client.chatStream({ ...options, bridge: this.cfg });
+  }
+  /** One-shot: send a string, get the assistant text. */
+  async ask(message, extra) {
+    const completion = await this.chat({
+      messages: [{ role: "user", content: message }],
+      ...extra
+    });
+    return completion.choices[0]?.message?.content || "";
+  }
+  /** One-shot: send a string, stream text deltas. */
+  async *stream(message, extra) {
+    for await (const chunk of this.chatStream({
+      messages: [{ role: "user", content: message }],
+      ...extra
+    })) {
+      const content = chunk.choices?.[0]?.delta?.content;
+      if (content) yield content;
+    }
+  }
+  /** Turn-based: send full message history, get assistant text. */
+  async turn(messages, extra) {
+    const completion = await this.chat({ messages, ...extra });
+    return completion.choices[0]?.message?.content || "";
+  }
+  /** Clone with a new resume id — same harness, different logical conversation. */
+  withResume(resume) {
+    return new _BridgeSession(this.client, { ...this.cfg, resume });
+  }
+  /** Clone with a different model inside the same harness. */
+  withModel(model) {
+    return new _BridgeSession(this.client, { ...this.cfg, model });
+  }
+  /** The effective model id that will land on the router (`bridge/<harness>/<model>`). */
+  get model() {
+    return this.cfg.model ? `bridge/${this.cfg.harness}/${this.cfg.model}` : `bridge/${this.cfg.harness}`;
+  }
+  /** The resume id currently bound to this session, if any. */
+  get resume() {
+    return this.cfg.resume;
+  }
+};
 function selectTiers(all, n) {
   if (n >= all.length) return [...all];
   if (n <= 1) return [all[0]];
@@ -972,5 +1172,6 @@ var TCloudError = class extends Error {
 export {
   PrivateRouter,
   TCloudClient,
+  BridgeSession,
   TCloudError
 };

package/dist/{chunk-VD4RNZOC.js → chunk-MKLCBBHZ.js}

@@ -1,6 +1,6 @@
 import {
   TCloudClient
-} from "./chunk-HL4CXKET.js";
+} from "./chunk-AKR7CS4P.js";
 
 // src/shielded.ts
 import { privateKeyToAccount } from "viem/accounts";

package/dist/{chunk-STNZT6YR.js → chunk-QNIJ7KAA.js}

@@ -1,10 +1,10 @@
 import {
   createShieldedClient,
   generateWallet
-} from "./chunk-VD4RNZOC.js";
+} from "./chunk-MKLCBBHZ.js";
 import {
   TCloudClient
-} from "./chunk-HL4CXKET.js";
+} from "./chunk-AKR7CS4P.js";
 
 // src/index.ts
 var TCloud = class _TCloud extends TCloudClient {