@hsuite/smart-engines-sdk 3.10.0 → 3.12.0

package/dist/index.js

@@ -6609,7 +6609,7 @@ var SdkHttpError = class extends Error {
 };
 function createHttpClient(config) {
   const timeout = config.timeout ?? 3e4;
-  function getHeaders(contentType) {
+  function getHeaders(contentType, opts) {
     const headers = {};
     if (contentType) {
       headers["Content-Type"] = contentType;
@@ -6620,6 +6620,12 @@ function createHttpClient(config) {
     if (config.apiKey) {
       headers["X-API-Key"] = config.apiKey;
     }
+    if (opts?.customerToken) {
+      headers["X-Customer-Session-Token"] = opts.customerToken;
+    }
+    if (opts?.headers) {
+      Object.assign(headers, opts.headers);
+    }
     return headers;
   }
   function setAuthToken(token) {
@@ -6628,14 +6634,14 @@ function createHttpClient(config) {
   function getAuthToken() {
     return config.authToken;
   }
-  async function request(method, path, body) {
+  async function request(method, path, body, opts) {
     const url = `${config.baseUrl}${path}`;
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), timeout);
     try {
       const init = {
         method,
-        headers: getHeaders("application/json"),
+        headers: getHeaders("application/json", opts),
         signal: controller.signal
       };
       if (body !== void 0) {
@@ -6664,14 +6670,14 @@ function createHttpClient(config) {
       throw new SdkHttpError(`Network error: ${err.message}`, 0, error);
     }
   }
-  async function getText(path) {
+  async function getText(path, opts) {
     const url = `${config.baseUrl}${path}`;
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), timeout);
     try {
       const response = await fetch(url, {
         method: "GET",
-        headers: getHeaders(),
+        headers: getHeaders(void 0, opts),
         signal: controller.signal
       });
       clearTimeout(timeoutId);
@@ -6694,7 +6700,37 @@ function createHttpClient(config) {
       throw new SdkHttpError(`Network error: ${err.message}`, 0, error);
     }
   }
-  async function upload(path, file, filename, metadata, fieldName = "file") {
+  async function getBinary(path, opts) {
+    const url = `${config.baseUrl}${path}`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    try {
+      const response = await fetch(url, {
+        method: "GET",
+        headers: getHeaders(void 0, opts),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errBody = await response.json().catch(() => ({}));
+        throw new SdkHttpError(
+          errBody.message || `API error: ${response.status} ${response.statusText}`,
+          response.status,
+          errBody
+        );
+      }
+      return new Uint8Array(await response.arrayBuffer());
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof SdkHttpError) throw error;
+      const err = error;
+      if (err.name === "AbortError") {
+        throw new SdkHttpError("Request timeout", 408);
+      }
+      throw new SdkHttpError(`Network error: ${err.message}`, 0, error);
+    }
+  }
+  async function upload(path, file, filename, metadata, fieldName = "file", opts) {
     const url = `${config.baseUrl}${path}`;
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), timeout * 2);
@@ -6714,6 +6750,12 @@ function createHttpClient(config) {
       if (config.apiKey) {
         headers["X-API-Key"] = config.apiKey;
       }
+      if (opts?.customerToken) {
+        headers["X-Customer-Session-Token"] = opts.customerToken;
+      }
+      if (opts?.headers) {
+        Object.assign(headers, opts.headers);
+      }
       const response = await fetch(url, {
         method: "POST",
         headers,
@@ -6761,13 +6803,14 @@ function createHttpClient(config) {
     }
   }
   const client = {
-    post: (path, body) => withAuthRetry(path, () => request("POST", path, body)),
-    get: (path) => withAuthRetry(path, () => request("GET", path)),
-    put: (path, body) => withAuthRetry(path, () => request("PUT", path, body)),
-    patch: (path, body) => withAuthRetry(path, () => request("PATCH", path, body)),
-    delete: (path) => withAuthRetry(path, () => request("DELETE", path)),
-    getText: (path) => withAuthRetry(path, () => getText(path)),
-    upload: ((path, file, filename, metadata, fieldName) => withAuthRetry(path, () => upload(path, file, filename, metadata, fieldName))),
+    post: (path, body, opts) => withAuthRetry(path, () => request("POST", path, body, opts)),
+    get: (path, opts) => withAuthRetry(path, () => request("GET", path, void 0, opts)),
+    put: (path, body, opts) => withAuthRetry(path, () => request("PUT", path, body, opts)),
+    patch: (path, body, opts) => withAuthRetry(path, () => request("PATCH", path, body, opts)),
+    delete: (path, opts) => withAuthRetry(path, () => request("DELETE", path, void 0, opts)),
+    getText: (path, opts) => withAuthRetry(path, () => getText(path, opts)),
+    getBinary: (path, opts) => withAuthRetry(path, () => getBinary(path, opts)),
+    upload: ((path, file, filename, metadata, fieldName, opts) => withAuthRetry(path, () => upload(path, file, filename, metadata, fieldName, opts))),
     setAuthToken,
     getAuthToken
   };
@@ -8530,50 +8573,58 @@ var AgentsClient = class {
   }
   http;
   /** Register a new agent */
-  async register(request) {
-    return this.http.post("/api/v3/baas/agents/register", request);
+  async register(request, opts) {
+    return this.http.post("/api/v3/baas/agents/register", request, opts);
   }
   /** Get agent details */
-  async get(agentId) {
-    return this.http.get(`/api/v3/baas/agents/${encodePathParam(agentId)}`);
+  async get(agentId, opts) {
+    return this.http.get(`/api/v3/baas/agents/${encodePathParam(agentId)}`, opts);
   }
   /** List all agents */
-  async list() {
-    return this.http.get("/api/v3/baas/agents");
+  async list(opts) {
+    return this.http.get("/api/v3/baas/agents", opts);
   }
   /**
    * Fund agent treasury (owner-only). Returns a
    * `PreparedTransactionResponse` wrapped in a `success: true` envelope —
    * the caller is expected to sign and submit the prepared bytes.
    */
-  async fund(agentId, request) {
-    return this.http.post(`/api/v3/baas/agents/${encodePathParam(agentId)}/fund`, request);
+  async fund(agentId, request, opts) {
+    return this.http.post(`/api/v3/baas/agents/${encodePathParam(agentId)}/fund`, request, opts);
   }
   /**
    * Execute a trade (agent-wallet OR owner). Returns a
    * `PreparedTransactionResponse` wrapped in a `success: true` envelope.
    */
-  async trade(agentId, request) {
-    return this.http.post(`/api/v3/baas/agents/${encodePathParam(agentId)}/trade`, request);
+  async trade(agentId, request, opts) {
+    return this.http.post(`/api/v3/baas/agents/${encodePathParam(agentId)}/trade`, request, opts);
   }
   /**
    * Withdraw from agent treasury (owner-only). Returns a
    * `PreparedTransactionResponse` wrapped in a `success: true` envelope.
    */
-  async withdraw(agentId, request) {
-    return this.http.post(`/api/v3/baas/agents/${encodePathParam(agentId)}/withdraw`, request);
+  async withdraw(agentId, request, opts) {
+    return this.http.post(`/api/v3/baas/agents/${encodePathParam(agentId)}/withdraw`, request, opts);
+  }
+  /**
+   * Execute a generic, declared capability (agent-wallet OR owner). The
+   * chain-agnostic general form of an agent action: the capability may settle
+   * on-chain, act off-chain, or both. Returns the ordered step results.
+   */
+  async execute(agentId, request, opts) {
+    return this.http.post(`/api/v3/baas/agents/${encodePathParam(agentId)}/execute`, request, opts);
   }
   /** Pause an agent */
-  async pause(agentId) {
-    return this.http.post(`/api/v3/baas/agents/${encodePathParam(agentId)}/pause`, {});
+  async pause(agentId, opts) {
+    return this.http.post(`/api/v3/baas/agents/${encodePathParam(agentId)}/pause`, {}, opts);
   }
   /** Resume a paused agent */
-  async resume(agentId) {
-    return this.http.post(`/api/v3/baas/agents/${encodePathParam(agentId)}/resume`, {});
+  async resume(agentId, opts) {
+    return this.http.post(`/api/v3/baas/agents/${encodePathParam(agentId)}/resume`, {}, opts);
   }
   /** Revoke an agent (permanent) */
-  async revoke(agentId) {
-    return this.http.post(`/api/v3/baas/agents/${encodePathParam(agentId)}/revoke`, {});
+  async revoke(agentId, opts) {
+    return this.http.post(`/api/v3/baas/agents/${encodePathParam(agentId)}/revoke`, {}, opts);
   }
   /**
    * Update agent rules.
@@ -8583,24 +8634,24 @@ var AgentsClient = class {
    * Nest matched the dynamic `:agentId` GET/POST handlers and rejected
    * the verb mismatch.
    */
-  async updateRules(agentId, rules) {
-    return this.http.patch(`/api/v3/baas/agents/${encodePathParam(agentId)}/rules`, rules);
+  async updateRules(agentId, rules, opts) {
+    return this.http.patch(`/api/v3/baas/agents/${encodePathParam(agentId)}/rules`, rules, opts);
   }
   /** Get agent events */
-  async getEvents(agentId) {
-    return this.http.get(`/api/v3/baas/agents/${encodePathParam(agentId)}/events`);
+  async getEvents(agentId, opts) {
+    return this.http.get(`/api/v3/baas/agents/${encodePathParam(agentId)}/events`, opts);
   }
   /** Get agent balances across chains */
-  async getBalances(agentId) {
-    return this.http.get(`/api/v3/baas/agents/${encodePathParam(agentId)}/balances`);
+  async getBalances(agentId, opts) {
+    return this.http.get(`/api/v3/baas/agents/${encodePathParam(agentId)}/balances`, opts);
   }
   /** Approve a pending agent operation */
-  async approve(agentId, operationId) {
-    return this.http.post(`/api/v3/baas/agents/${encodePathParam(agentId)}/approve/${encodePathParam(operationId)}`, {});
+  async approve(agentId, operationId, opts) {
+    return this.http.post(`/api/v3/baas/agents/${encodePathParam(agentId)}/approve/${encodePathParam(operationId)}`, {}, opts);
   }
   /** Reject a pending agent operation */
-  async reject(agentId, operationId) {
-    return this.http.post(`/api/v3/baas/agents/${encodePathParam(agentId)}/reject/${encodePathParam(operationId)}`, {});
+  async reject(agentId, operationId, opts) {
+    return this.http.post(`/api/v3/baas/agents/${encodePathParam(agentId)}/reject/${encodePathParam(operationId)}`, {}, opts);
   }
 };
 
@@ -10324,6 +10375,214 @@ function btcToSatoshis(btc) {
   return (amount * 1e8).toFixed(0);
 }
 
+// src/ai/index.ts
+var ai_exports = {};
+__export(ai_exports, {
+  createAnthropicProvider: () => createAnthropicProvider,
+  createGeminiProvider: () => createGeminiProvider,
+  createModelProvider: () => createModelProvider,
+  createOpenAiProvider: () => createOpenAiProvider,
+  inferJson: () => inferJson
+});
+
+// src/ai/anthropic.ts
+var ANTHROPIC_URL = "https://api.anthropic.com/v1/messages";
+var ANTHROPIC_VERSION = "2023-06-01";
+var DEFAULT_MAX_TOKENS = 1024;
+function createAnthropicProvider(opts) {
+  const { apiKey, model } = opts;
+  return {
+    provider: "anthropic",
+    async infer(args) {
+      const messages = args.messages.filter((m) => m.role === "user" || m.role === "assistant").map((m) => ({ role: m.role, content: m.content }));
+      const body = {
+        model,
+        max_tokens: args.maxTokens ?? DEFAULT_MAX_TOKENS,
+        messages
+      };
+      if (args.system) {
+        body.system = args.system;
+      }
+      const res = await fetch(ANTHROPIC_URL, {
+        method: "POST",
+        headers: {
+          "x-api-key": apiKey,
+          "anthropic-version": ANTHROPIC_VERSION,
+          "content-type": "application/json"
+        },
+        body: JSON.stringify(body)
+      });
+      if (!res.ok) {
+        throw new Error(`Anthropic request failed with status ${res.status}`);
+      }
+      const data = await res.json();
+      const text = Array.isArray(data.content) ? data.content.find((b) => typeof b.text === "string")?.text : void 0;
+      if (typeof text !== "string") {
+        return { ok: false, error: "Anthropic response contained no text block", raw: data };
+      }
+      return { ok: true, text, raw: data };
+    }
+  };
+}
+
+// src/ai/openai.ts
+var OPENAI_URL = "https://api.openai.com/v1/chat/completions";
+var DEFAULT_MAX_TOKENS2 = 1024;
+function createOpenAiProvider(opts) {
+  const { apiKey, model } = opts;
+  return {
+    provider: "openai",
+    async infer(args) {
+      const messages = [];
+      if (args.system) {
+        messages.push({ role: "system", content: args.system });
+      }
+      for (const m of args.messages) {
+        messages.push({ role: m.role, content: m.content });
+      }
+      const res = await fetch(OPENAI_URL, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+          "content-type": "application/json"
+        },
+        body: JSON.stringify({
+          model,
+          max_tokens: args.maxTokens ?? DEFAULT_MAX_TOKENS2,
+          messages
+        })
+      });
+      if (!res.ok) {
+        throw new Error(`OpenAI request failed with status ${res.status}`);
+      }
+      const data = await res.json();
+      const text = data.choices?.[0]?.message?.content;
+      if (typeof text !== "string") {
+        return { ok: false, error: "OpenAI response contained no message content", raw: data };
+      }
+      return { ok: true, text, raw: data };
+    }
+  };
+}
+
+// src/ai/gemini.ts
+var GEMINI_BASE = "https://generativelanguage.googleapis.com/v1beta/models";
+var DEFAULT_MAX_TOKENS3 = 1024;
+function createGeminiProvider(opts) {
+  const { apiKey, model } = opts;
+  return {
+    provider: "gemini",
+    async infer(args) {
+      const contents = args.messages.filter((m) => m.role === "user" || m.role === "assistant").map((m) => ({
+        role: m.role === "assistant" ? "model" : "user",
+        parts: [{ text: m.content }]
+      }));
+      const body = {
+        contents,
+        generationConfig: { maxOutputTokens: args.maxTokens ?? DEFAULT_MAX_TOKENS3 }
+      };
+      if (args.system) {
+        body.systemInstruction = { parts: [{ text: args.system }] };
+      }
+      const url = `${GEMINI_BASE}/${model}:generateContent?key=${encodeURIComponent(apiKey)}`;
+      const res = await fetch(url, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(body)
+      });
+      if (!res.ok) {
+        throw new Error(`Gemini request failed with status ${res.status}`);
+      }
+      const data = await res.json();
+      const text = data.candidates?.[0]?.content?.parts?.[0]?.text;
+      if (typeof text !== "string") {
+        return { ok: false, error: "Gemini response contained no text part", raw: data };
+      }
+      return { ok: true, text, raw: data };
+    }
+  };
+}
+
+// src/ai/factory.ts
+function createModelProvider(opts) {
+  const { provider, apiKey, model } = opts;
+  switch (provider) {
+    case "anthropic":
+      return createAnthropicProvider({ apiKey, model });
+    case "openai":
+      return createOpenAiProvider({ apiKey, model });
+    case "gemini":
+      return createGeminiProvider({ apiKey, model });
+    default: {
+      const never = provider;
+      throw new Error(`Unsupported model provider: ${String(never)}`);
+    }
+  }
+}
+
+// src/ai/infer-json.ts
+var JSON_ONLY_INSTRUCTION = "Respond with ONLY a single JSON object, no prose.";
+var RETRY_INSTRUCTION = "Return valid JSON only.";
+function extractJson(raw) {
+  const start = raw.indexOf("{");
+  const end = raw.lastIndexOf("}");
+  if (start === -1 || end === -1 || end < start) {
+    throw new Error("no JSON object found in reply");
+  }
+  return JSON.parse(raw.slice(start, end + 1));
+}
+async function inferJson(opts) {
+  const { provider, apiKey, model, system, input, maxTokens, parse } = opts;
+  let client;
+  try {
+    client = createModelProvider({ provider, apiKey, model });
+  } catch (err) {
+    return { ok: false, error: errMsg(err) };
+  }
+  const systemPrompt = system ? `${system}
+
+${JSON_ONLY_INSTRUCTION}` : JSON_ONLY_INSTRUCTION;
+  const userContent = typeof input === "string" ? input : JSON.stringify(input);
+  const messages = [{ role: "user", content: userContent }];
+  const first = await runOnce(client, { system: systemPrompt, messages, maxTokens }, parse);
+  if (first.ok) {
+    return first;
+  }
+  const retryMessages = [...messages];
+  if (typeof first.raw === "string") {
+    retryMessages.push({ role: "assistant", content: first.raw });
+  }
+  retryMessages.push({ role: "user", content: RETRY_INSTRUCTION });
+  const second = await runOnce(
+    client,
+    { system: systemPrompt, messages: retryMessages, maxTokens },
+    parse
+  );
+  return second;
+}
+async function runOnce(client, args, parse) {
+  let inferred;
+  try {
+    inferred = await client.infer(args);
+  } catch (err) {
+    return { ok: false, error: errMsg(err) };
+  }
+  if (!inferred.ok || typeof inferred.text !== "string") {
+    return { ok: false, error: inferred.error ?? "provider returned no text", raw: inferred.text };
+  }
+  const raw = inferred.text;
+  try {
+    const parsed = extractJson(raw);
+    const value = parse ? parse(parsed) : parsed;
+    return { ok: true, value, raw };
+  } catch (err) {
+    return { ok: false, error: errMsg(err), raw };
+  }
+}
+function errMsg(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+
 // src/baas/index.ts
 var baas_exports = {};
 __export(baas_exports, {
@@ -10478,30 +10737,31 @@ var StorageClient = class {
   /**
    * Upload a file to storage
    */
-  async upload(file, filename, metadata) {
+  async upload(file, filename, metadata, opts) {
     const appId = this.getAppId();
-    return this.http.upload(`/api/v3/baas/storage/${encodePathParam(appId)}/upload`, file, filename, metadata);
+    return this.http.upload(`/api/v3/baas/storage/${encodePathParam(appId)}/upload`, file, filename, metadata, void 0, opts);
   }
   /**
-   * Download a file by CID
+   * Download a file by CID. Returns the raw file bytes as a `Uint8Array`
+   * (binary-safe — never JSON-parsed or text-decoded).
    */
-  async download(cid) {
+  async download(cid, opts) {
     const appId = this.getAppId();
-    return this.http.get(`/api/v3/baas/storage/${encodePathParam(appId)}/download/${encodePathParam(cid)}`);
+    return this.http.getBinary(`/api/v3/baas/storage/${encodePathParam(appId)}/download/${encodePathParam(cid)}`, opts);
   }
   /**
    * Get file metadata
    */
-  async getMetadata(cid) {
+  async getMetadata(cid, opts) {
     const appId = this.getAppId();
-    return this.http.get(`/api/v3/baas/storage/${encodePathParam(appId)}/metadata/${encodePathParam(cid)}`);
+    return this.http.get(`/api/v3/baas/storage/${encodePathParam(appId)}/metadata/${encodePathParam(cid)}`, opts);
   }
   /**
    * Delete a file
    */
-  async delete(cid) {
+  async delete(cid, opts) {
     const appId = this.getAppId();
-    return this.http.delete(`/api/v3/baas/storage/${encodePathParam(appId)}/${encodePathParam(cid)}`);
+    return this.http.delete(`/api/v3/baas/storage/${encodePathParam(appId)}/${encodePathParam(cid)}`, opts);
   }
   /**
    * List all files for the app.
@@ -10510,27 +10770,27 @@ var StorageClient = class {
    *   `offset` for pagination).
    * @returns The file list and total count.
    */
-  async listFiles(pagination) {
+  async listFiles(pagination, opts) {
     const appId = this.getAppId();
     const params = new URLSearchParams();
     if (pagination?.limit !== void 0) params.set("limit", String(pagination.limit));
     if (pagination?.offset !== void 0) params.set("offset", String(pagination.offset));
     const qs = params.toString();
-    return this.http.get(`/api/v3/baas/storage/${encodePathParam(appId)}/files${qs ? `?${qs}` : ""}`);
+    return this.http.get(`/api/v3/baas/storage/${encodePathParam(appId)}/files${qs ? `?${qs}` : ""}`, opts);
   }
   /**
    * Get storage usage for the current app
    */
-  async getUsage() {
+  async getUsage(opts) {
     const appId = this.getAppId();
-    return this.http.get(`/api/v3/baas/storage/${encodePathParam(appId)}/usage`);
+    return this.http.get(`/api/v3/baas/storage/${encodePathParam(appId)}/usage`, opts);
   }
   /**
    * Check if a file exists
    */
-  async exists(cid) {
+  async exists(cid, opts) {
     const appId = this.getAppId();
-    return this.http.get(`/api/v3/baas/storage/${encodePathParam(appId)}/exists/${encodePathParam(cid)}`);
+    return this.http.get(`/api/v3/baas/storage/${encodePathParam(appId)}/exists/${encodePathParam(cid)}`, opts);
   }
 };
 
@@ -10543,61 +10803,99 @@ var FunctionsClient = class {
   http;
   getAppId;
   /**
-   * Deploy a new function
-   */
-  async deploy(request) {
+   * Build the Ed25519 signed-code envelope the host mandates for every deploy
+   * and eval. A fresh ephemeral keypair is generated per call, so no long-lived
+   * signing key is held anywhere — each artifact carries its own signature.
+   *
+   * Scheme (must match the host verifier): `hash = sha256(code)` (hex),
+   * `message = "<hash>:<timestamp>"`, signed Ed25519; `publicKey` is SPKI-DER
+   * (base64). `crypto` is imported lazily so this never pulls Node built-ins
+   * into a browser bundle that doesn't sign code.
+   */
+  async signCode(code) {
+    const { generateKeyPairSync, createHash, sign: sign2 } = await import('crypto');
+    const { publicKey, privateKey } = generateKeyPairSync("ed25519");
+    const hash = createHash("sha256").update(code, "utf8").digest("hex");
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const signature = sign2(null, Buffer.from(`${hash}:${timestamp}`, "utf8"), privateKey).toString("base64");
+    const publicKeyDer = publicKey.export({ format: "der", type: "spki" }).toString("base64");
+    return { code, hash, timestamp, signature, publicKey: publicKeyDer };
+  }
+  /**
+   * Deploy a new function. If `signedCode` is omitted it is auto-built from
+   * `request.code` via {@link signCode} — the host requires it, so the default
+   * is to sign rather than 400. Pass your own envelope to override.
+   */
+  async deploy(request, opts) {
     const appId = this.getAppId();
-    return this.http.post(`/api/v3/baas/functions/${encodePathParam(appId)}`, request);
+    const signedCode = request.signedCode ?? await this.signCode(request.code);
+    return this.http.post(`/api/v3/baas/functions/${encodePathParam(appId)}`, { ...request, signedCode }, opts);
   }
   /**
    * Invoke a function
    */
-  async invoke(functionId, payload) {
+  async invoke(functionId, payload, opts) {
     const appId = this.getAppId();
     return this.http.post(
       `/api/v3/baas/functions/${encodePathParam(appId)}/${encodePathParam(functionId)}/invoke`,
-      payload ?? {}
+      payload ?? {},
+      opts
     );
   }
+  /**
+   * Evaluate signed code once (ephemeral) — no persistent deploy.
+   *
+   * For throwaway / AI-generated snippets. The host runs it in the same hardened
+   * isolate and discards it; metered + quota'd like a normal invocation. As with
+   * {@link deploy}, `signedCode` is auto-built from `request.code` when omitted.
+   */
+  async eval(request, opts) {
+    const appId = this.getAppId();
+    const signedCode = request.signedCode ?? await this.signCode(request.code);
+    return this.http.post(`/api/v3/baas/functions/${encodePathParam(appId)}/eval`, { ...request, signedCode }, opts);
+  }
   /**
    * List all functions for the current app
    */
-  async list() {
+  async list(opts) {
     const appId = this.getAppId();
-    return this.http.get(`/api/v3/baas/functions/${encodePathParam(appId)}`);
+    return this.http.get(`/api/v3/baas/functions/${encodePathParam(appId)}`, opts);
   }
   /**
    * Get function details
    */
-  async get(functionId) {
+  async get(functionId, opts) {
     const appId = this.getAppId();
     return this.http.get(
-      `/api/v3/baas/functions/${encodePathParam(appId)}/${encodePathParam(functionId)}`
+      `/api/v3/baas/functions/${encodePathParam(appId)}/${encodePathParam(functionId)}`,
+      opts
     );
   }
   /**
    * Update a function
    */
-  async update(functionId, updates) {
+  async update(functionId, updates, opts) {
     const appId = this.getAppId();
     return this.http.put(
       `/api/v3/baas/functions/${encodePathParam(appId)}/${encodePathParam(functionId)}`,
-      updates
+      updates,
+      opts
     );
   }
   /**
    * Delete a function
    */
-  async delete(functionId) {
+  async delete(functionId, opts) {
     const appId = this.getAppId();
     return this.http.delete(
-      `/api/v3/baas/functions/${encodePathParam(appId)}/${encodePathParam(functionId)}`
+      `/api/v3/baas/functions/${encodePathParam(appId)}/${encodePathParam(functionId)}`,
+      opts
     );
   }
   /**
    * Get function execution logs
    */
-  async getLogs(functionId, options) {
+  async getLogs(functionId, options, opts) {
     const appId = this.getAppId();
     const params = new URLSearchParams();
     if (options?.limit !== void 0) params.set("limit", String(options.limit));
@@ -10605,15 +10903,16 @@ var FunctionsClient = class {
     if (options?.level) params.set("level", options.level);
     const qs = params.toString();
     return this.http.get(
-      `/api/v3/baas/functions/${encodePathParam(appId)}/${encodePathParam(functionId)}/logs${qs ? `?${qs}` : ""}`
+      `/api/v3/baas/functions/${encodePathParam(appId)}/${encodePathParam(functionId)}/logs${qs ? `?${qs}` : ""}`,
+      opts
     );
   }
   /**
    * Get function statistics for an app
    */
-  async getStats() {
+  async getStats(opts) {
     const appId = this.getAppId();
-    return this.http.get(`/api/v3/baas/functions/${encodePathParam(appId)}/stats`);
+    return this.http.get(`/api/v3/baas/functions/${encodePathParam(appId)}/stats`, opts);
   }
 };
 
@@ -10628,45 +10927,46 @@ var MessagingClient = class {
   /**
    * Create a new channel
    */
-  async createChannel(config) {
+  async createChannel(config, opts) {
     const appId = this.getAppId();
-    return this.http.post(`/api/v3/baas/messaging/${encodePathParam(appId)}/channels`, config);
+    return this.http.post(`/api/v3/baas/messaging/${encodePathParam(appId)}/channels`, config, opts);
   }
   /**
    * Delete a channel
    */
-  async deleteChannel(channelId) {
+  async deleteChannel(channelId, opts) {
     const appId = this.getAppId();
-    return this.http.delete(`/api/v3/baas/messaging/${encodePathParam(appId)}/channels/${encodePathParam(channelId)}`);
+    return this.http.delete(`/api/v3/baas/messaging/${encodePathParam(appId)}/channels/${encodePathParam(channelId)}`, opts);
   }
   /**
    * Get a channel by ID
    */
-  async getChannel(channelId) {
+  async getChannel(channelId, opts) {
     const appId = this.getAppId();
-    return this.http.get(`/api/v3/baas/messaging/${encodePathParam(appId)}/channels/${encodePathParam(channelId)}`);
+    return this.http.get(`/api/v3/baas/messaging/${encodePathParam(appId)}/channels/${encodePathParam(channelId)}`, opts);
   }
   /**
    * List all channels for the app
    */
-  async listChannels() {
+  async listChannels(opts) {
     const appId = this.getAppId();
-    return this.http.get(`/api/v3/baas/messaging/${encodePathParam(appId)}/channels`);
+    return this.http.get(`/api/v3/baas/messaging/${encodePathParam(appId)}/channels`, opts);
   }
   /**
    * Publish a message to a channel
    */
-  async publish(channel, message, metadata) {
+  async publish(channel, message, metadata, opts) {
     const appId = this.getAppId();
     return this.http.post(
       `/api/v3/baas/messaging/${encodePathParam(appId)}/channels/${encodePathParam(channel)}/publish`,
-      { data: message, metadata }
+      { data: message, metadata },
+      opts
     );
   }
   /**
    * Get message history for a channel
    */
-  async getHistory(channel, options) {
+  async getHistory(channel, options, opts) {
     const appId = this.getAppId();
     const params = new URLSearchParams();
     if (options?.limit !== void 0) params.set("limit", String(options.limit));
@@ -10674,7 +10974,8 @@ var MessagingClient = class {
     if (options?.after) params.set("after", options.after);
     const qs = params.toString();
     return this.http.get(
-      `/api/v3/baas/messaging/${encodePathParam(appId)}/channels/${encodePathParam(channel)}/history${qs ? `?${qs}` : ""}`
+      `/api/v3/baas/messaging/${encodePathParam(appId)}/channels/${encodePathParam(channel)}/history${qs ? `?${qs}` : ""}`,
+      opts
     );
   }
   /**
@@ -10685,11 +10986,12 @@ var MessagingClient = class {
    * `setPresence(member)` hit a non-existent appId-scoped route and 404'd
    * in production. The channel is now the first argument.
    */
-  async setPresence(channel, member) {
+  async setPresence(channel, member, opts) {
     const appId = this.getAppId();
     return this.http.post(
       `/api/v3/baas/messaging/${encodePathParam(appId)}/channels/${encodePathParam(channel)}/presence`,
-      member
+      member,
+      opts
     );
   }
   /**
@@ -10701,27 +11003,29 @@ var MessagingClient = class {
    * `clientId` (not `memberId`) the second — they're the same identifier
    * but renamed to match the server param.
    */
-  async removePresence(channel, clientId) {
+  async removePresence(channel, clientId, opts) {
     const appId = this.getAppId();
     return this.http.delete(
-      `/api/v3/baas/messaging/${encodePathParam(appId)}/channels/${encodePathParam(channel)}/presence/${encodePathParam(clientId)}`
+      `/api/v3/baas/messaging/${encodePathParam(appId)}/channels/${encodePathParam(channel)}/presence/${encodePathParam(clientId)}`,
+      opts
     );
   }
   /**
    * Get presence info for a channel
    */
-  async getPresence(channel) {
+  async getPresence(channel, opts) {
     const appId = this.getAppId();
     return this.http.get(
-      `/api/v3/baas/messaging/${encodePathParam(appId)}/channels/${encodePathParam(channel)}/presence`
+      `/api/v3/baas/messaging/${encodePathParam(appId)}/channels/${encodePathParam(channel)}/presence`,
+      opts
     );
   }
   /**
    * Get messaging statistics
    */
-  async getStats() {
+  async getStats(opts) {
     const appId = this.getAppId();
-    return this.http.get(`/api/v3/baas/messaging/${encodePathParam(appId)}/stats`);
+    return this.http.get(`/api/v3/baas/messaging/${encodePathParam(appId)}/stats`, opts);
   }
 };
 
@@ -13405,6 +13709,7 @@ exports.ValidatorDiscoveryClient = ValidatorDiscoveryClient;
 exports.ValidatorMetadataSchema = ValidatorMetadataSchema;
 exports.ValidatorRulesSchema = ValidatorRulesSchema;
 exports.XrplTransactionsClient = XrplTransactionsClient;
+exports.ai = ai_exports;
 exports.appTopic = appTopic;
 exports.atom = atom;
 exports.auth = auth_exports;
@@ -13413,7 +13718,11 @@ exports.bridge = bridge_exports;
 exports.canonicalizeAttestation = canonicalizeAttestation;
 exports.chains = chains_exports;
 exports.computeAttestationHash = computeAttestationHash;
+exports.createAnthropicProvider = createAnthropicProvider;
+exports.createGeminiProvider = createGeminiProvider;
 exports.createHttpClient = createHttpClient;
+exports.createModelProvider = createModelProvider;
+exports.createOpenAiProvider = createOpenAiProvider;
 exports.createResilientFetchWithBreaker = createResilientFetchWithBreaker;
 exports.createXrplWeb3Signer = createXrplWeb3Signer;
 exports.dao = dao_exports;
@@ -13429,6 +13738,7 @@ exports.forAgent = forAgent;
 exports.forToken = forToken;
 exports.forTopic = forTopic;
 exports.governance = governance_exports;
+exports.inferJson = inferJson;
 exports.isKnownNetwork = isKnownNetwork;
 exports.isPersonhoodVerifierNotConfigured = isPersonhoodVerifierNotConfigured;
 exports.isRuleRejected = isRuleRejected;