@aithos/sdk 0.1.0-alpha.4 → 0.1.0-alpha.40

package/dist/src/web.js

@@ -0,0 +1,186 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2026 Mathieu Colla
+// Web namespace — `aithos.web_extract` through the web-extractor proxy.
+//
+// Same JSON-RPC + signed-envelope protocol as the compute namespace, but
+// against a separate Aithos service (`extract.aithos.be`). Pricing is a
+// flat 1 microcredit per successful extraction (refunded on failure).
+//
+// The mandate scope is `web.extract` (exported as {@link WEB_EXTRACT_SCOPE}
+// for owner mint-time use). A delegate that holds only this scope can read
+// pages on the owner's behalf without gaining LLM-spend authority.
+//
+// Signing follows the same owner-vs-delegate logic as the compute namespace
+// (see ComputeNamespace.#resolveSigner). The duplication is bounded — both
+// namespaces' `#signAndPost` helpers can later move into a shared internal
+// once a third primitive arrives.
+import { buildSignedEnvelope, } from "@aithos/protocol-client";
+import { webInvokeUrl, } from "./endpoints.js";
+import { delegateKeyPair, ownerKeyPair, } from "./internal/protocol-client-bridge.js";
+import { AithosSDKError } from "./types.js";
+/** Opt-in scope a mandate must carry to invoke `aithos.web_extract`. */
+export const WEB_EXTRACT_SCOPE = "web.extract";
+/**
+ * `sdk.web` namespace — Aithos's web extraction primitive.
+ *
+ * Designed so a downstream agent can read the static content of any
+ * public page (HTML, purged CSS, computed visual signature) without
+ * involving an LLM — saving ~30× over a Bedrock-based extraction in
+ * both latency and cost.
+ *
+ * @throws {AithosSDKError} — same error taxonomy as `sdk.compute`,
+ *   including `-32071` (insufficient balance with `{required, available}`
+ *   in `data`) and `-32042` (mandate scope mismatch).
+ */
+export class WebNamespace {
+    #deps;
+    constructor(deps) {
+        this.#deps = deps;
+    }
+    /**
+     * Extract a public webpage. Returns the cleaned HTML, purged CSS and
+     * a deterministic visual signature (palette, typography, dominant
+     * radii, spacing, layout mode, component digests).
+     */
+    async extract(args) {
+        const { endpoints, fetch: fetchImpl } = this.#deps;
+        const choice = this.#resolveSigner(args.mandateId);
+        const url = webInvokeUrl(endpoints);
+        const params = {
+            app_did: this.#deps.appDid,
+            mandate_id: this.#resolveMandateIdForWire(args.mandateId, choice),
+            url: args.url,
+        };
+        if (args.waitUntil !== undefined)
+            params.waitUntil = args.waitUntil;
+        if (args.timeoutMs !== undefined)
+            params.timeoutMs = args.timeoutMs;
+        if (args.idempotencyKey !== undefined) {
+            params.idempotencyKey = args.idempotencyKey;
+        }
+        return await this.#signAndPost({
+            url,
+            method: "aithos.web_extract",
+            params,
+            choice,
+            fetchImpl,
+            signal: args.signal,
+        });
+    }
+    /**
+     * Fetch a single asset (image / font / css / json …) server-side,
+     * bypassing browser CORS. Returns the bytes as base64 + content-type.
+     *
+     * Use when `fetch(url, {mode: "cors"})` and `<img crossOrigin>`
+     * canvas readback both fail because the asset server doesn't return
+     * Access-Control-Allow-Origin headers — typical for production
+     * sites' logos hosted on the main domain.
+     *
+     * For the common "logo of a webpage" case the lambda already
+     * resolves and embeds the best symbol-only logo in
+     * {@link extract}'s `data.logo` field; you only need fetchAsset
+     * when extract's logo doesn't fit, when picking up secondary
+     * assets (og:image, hero image, document download), or when
+     * fetching an asset on a page you haven't extracted.
+     *
+     * Costs 1 mc per successful fetch, full refund on failure. Server
+     * caps: 15 s timeout, 10 MB body, http/https only.
+     */
+    async fetchAsset(args) {
+        const { endpoints, fetch: fetchImpl } = this.#deps;
+        const choice = this.#resolveSigner(args.mandateId);
+        const url = webInvokeUrl(endpoints);
+        const params = {
+            app_did: this.#deps.appDid,
+            mandate_id: this.#resolveMandateIdForWire(args.mandateId, choice),
+            url: args.url,
+        };
+        return await this.#signAndPost({
+            url,
+            method: "aithos.web_fetch_asset",
+            params,
+            choice,
+            fetchImpl,
+            signal: args.signal,
+        });
+    }
+    /* ----------------------------- internals ----------------------------- */
+    #resolveSigner(mandateId) {
+        const { auth } = this.#deps;
+        const owner = auth._getOwnerSigners();
+        const ownerLoaded = owner !== null && !owner.destroyed;
+        if (ownerLoaded) {
+            const publicKp = ownerKeyPair(owner, "public");
+            return {
+                kind: "owner",
+                iss: owner.did,
+                verificationMethod: `${owner.did}#public`,
+                signer: publicKp,
+                mandate: undefined,
+            };
+        }
+        if (mandateId === undefined || mandateId.length === 0) {
+            throw new AithosSDKError("sdk_no_signer", "no owner signed in and no mandateId provided — pass a mandateId for a delegate session, or sign in as an owner first.");
+        }
+        const actor = auth._getDelegateActor(mandateId);
+        if (!actor || actor.destroyed) {
+            throw new AithosSDKError("sdk_no_delegate_for_mandate", `no owner signed in and no imported delegate mandate matches '${mandateId}'. Sign in as an owner, or import a delegate bundle for that mandate via auth.importMandate.`);
+        }
+        const kp = delegateKeyPair(actor);
+        return {
+            kind: "delegate",
+            iss: actor.subjectDid,
+            verificationMethod: actor.granteePubkeyMultibase,
+            signer: kp,
+            mandate: actor.mandate,
+        };
+    }
+    #resolveMandateIdForWire(explicit, choice) {
+        if (explicit && explicit.length > 0)
+            return explicit;
+        if (choice.kind === "delegate")
+            return choice.mandate.id;
+        return `${choice.iss}#self`;
+    }
+    async #signAndPost(opts) {
+        const { url, method, params, choice, fetchImpl, signal } = opts;
+        const envelope = buildSignedEnvelope({
+            iss: choice.iss,
+            aud: url,
+            method,
+            verificationMethod: choice.verificationMethod,
+            params,
+            signer: choice.signer,
+            ...(choice.kind === "delegate" ? { mandate: choice.mandate } : {}),
+        });
+        let res;
+        try {
+            res = await fetchImpl(url, {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                body: JSON.stringify({
+                    jsonrpc: "2.0",
+                    id: method,
+                    method,
+                    params: { ...params, _envelope: envelope },
+                }),
+                ...(signal ? { signal } : {}),
+            });
+        }
+        catch (e) {
+            throw new AithosSDKError("network", e.message);
+        }
+        if (!res.ok) {
+            throw new AithosSDKError("http", `HTTP ${res.status} ${res.statusText}`, { status: res.status });
+        }
+        const body = (await res.json());
+        if (body.error) {
+            throw new AithosSDKError(String(body.error.code), body.error.message, body.error.data ? { data: body.error.data } : undefined);
+        }
+        if (!body.result) {
+            throw new AithosSDKError("empty", "empty result from web extractor proxy");
+        }
+        return body.result;
+    }
+}
+//# sourceMappingURL=web.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aithos/sdk",
-  "version": "0.1.0-alpha.4",
+  "version": "0.1.0-alpha.40",
   "description": "Aithos SDK — high-level TypeScript developer kit for building agentic apps on the Aithos protocol. Wraps @aithos/protocol-client and exposes the Aithos compute proxy and wallet (Stripe top-up) endpoints.",
   "keywords": [
     "aithos",
@@ -29,6 +29,10 @@
       "types": "./dist/src/index.d.ts",
       "import": "./dist/src/index.js"
     },
+    "./react": {
+      "types": "./dist/src/react/index.d.ts",
+      "import": "./dist/src/react/index.js"
+    },
     "./package.json": "./package.json"
   },
   "main": "./dist/src/index.js",
@@ -52,11 +56,22 @@
     "node": ">=20"
   },
   "peerDependencies": {
-    "@aithos/protocol-client": ">=0.1.0-alpha.11 <0.2.0"
+    "@aithos/protocol-client": ">=0.1.0-alpha.13 <0.2.0",
+    "@aithos/assets-crypto": ">=0.1.0-alpha.1 <0.2.0",
+    "react": "^18.0.0 || ^19.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@aithos/assets-crypto": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
+    }
   },
   "devDependencies": {
-    "@aithos/protocol-client": "^0.1.0-alpha.11",
+    "@aithos/protocol-client": "^0.1.0-alpha.13",
     "@types/node": "^24.12.2",
+    "fake-indexeddb": "^6.2.5",
     "typescript": "^5.9.2"
   },
   "publishConfig": {

package/dist/test/auth.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=auth.test.d.ts.map

package/dist/test/auth.test.js

@@ -1,175 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// Copyright 2026 Mathieu Colla
-// Unit tests for AithosAuth — Sign in with Google flow.
-import { strict as assert } from "node:assert";
-import { describe, it } from "node:test";
-import { AithosAuth, AithosSDKError } from "../src/index.js";
-/** Tiny window-shim that records calls instead of actually navigating. */
-function makeFakeWindow(initialHref) {
-    let href = initialHref;
-    let assigned = null;
-    let replacedHref = null;
-    const win = {
-        location: {
-            get href() {
-                return href;
-            },
-            assign(target) {
-                assigned = target;
-            },
-        },
-        history: {
-            replaceState(_state, _title, url) {
-                replacedHref = url;
-                href = url;
-            },
-        },
-    };
-    return {
-        win: win,
-        get assigned() {
-            return assigned;
-        },
-        get replacedHref() {
-            return replacedHref;
-        },
-    };
-}
-function fakeSession(overrides = {}) {
-    return {
-        session: "jwt-token-here",
-        exp: Math.floor(Date.now() / 1000) + 3600,
-        did: "did:aithos:zABC123",
-        handle: "alice-x9y2",
-        blob_b64: "",
-        blob_nonce_b64: "",
-        blob_version: 0,
-        enc_key_b64: "MTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0NTY3ODkwMTI=",
-        is_first_login: true,
-        ...overrides,
-    };
-}
-/* -------------------------------------------------------------------------- */
-/*  signInWithGoogle                                                          */
-/* -------------------------------------------------------------------------- */
-describe("AithosAuth.signInWithGoogle", () => {
-    it("navigates to /auth/sso/google/start with no params by default", () => {
-        const w = makeFakeWindow("https://app.aithos.be/login");
-        const auth = new AithosAuth({
-            authBaseUrl: "https://auth.example.test",
-            window: w.win,
-        });
-        assert.throws(() => auth.signInWithGoogle(), AithosSDKError);
-        assert.equal(w.assigned, "https://auth.example.test/auth/sso/google/start");
-    });
-    it("forwards appState as the app_state query param", () => {
-        const w = makeFakeWindow("https://app.aithos.be/login");
-        const auth = new AithosAuth({
-            authBaseUrl: "https://auth.example.test",
-            window: w.win,
-        });
-        assert.throws(() => auth.signInWithGoogle({ appState: "/dashboard" }), AithosSDKError);
-        const url = new URL(w.assigned);
-        assert.equal(url.searchParams.get("app_state"), "/dashboard");
-    });
-    it("rejects appState longer than 1024 chars without navigating", () => {
-        const w = makeFakeWindow("https://app.aithos.be/login");
-        const auth = new AithosAuth({
-            authBaseUrl: "https://auth.example.test",
-            window: w.win,
-        });
-        const tooLong = "x".repeat(1025);
-        assert.throws(() => auth.signInWithGoogle({ appState: tooLong }), (e) => e instanceof AithosSDKError && e.code === "auth_app_state_too_long");
-        assert.equal(w.assigned, null, "must not have navigated");
-    });
-    it("trims a trailing slash from authBaseUrl", () => {
-        const w = makeFakeWindow("https://app.aithos.be/");
-        const auth = new AithosAuth({
-            authBaseUrl: "https://auth.example.test/",
-            window: w.win,
-        });
-        assert.throws(() => auth.signInWithGoogle(), AithosSDKError);
-        assert.equal(w.assigned, "https://auth.example.test/auth/sso/google/start");
-    });
-});
-/* -------------------------------------------------------------------------- */
-/*  handleCallback                                                            */
-/* -------------------------------------------------------------------------- */
-describe("AithosAuth.handleCallback", () => {
-    it("returns null when the URL has no aithos_code", async () => {
-        const w = makeFakeWindow("https://app.aithos.be/auth/callback");
-        const auth = new AithosAuth({ window: w.win, fetch: undefinedFetch() });
-        const session = await auth.handleCallback();
-        assert.equal(session, null);
-    });
-    it("exchanges the code, returns the session, and strips query params", async () => {
-        const w = makeFakeWindow("https://app.aithos.be/auth/callback?aithos_code=abc123XYZ_-456&app_state=/dashboard");
-        const session = fakeSession({ is_first_login: true });
-        let capturedBody;
-        const fakeFetch = async (input, init) => {
-            assert.equal(typeof input === "string" ? input : input.toString(), "https://auth.example.test/auth/sso/exchange");
-            capturedBody = JSON.parse(init?.body);
-            return new Response(JSON.stringify(session), {
-                status: 200,
-                headers: { "content-type": "application/json" },
-            });
-        };
-        const auth = new AithosAuth({
-            authBaseUrl: "https://auth.example.test",
-            window: w.win,
-            fetch: fakeFetch,
-        });
-        const out = await auth.handleCallback();
-        assert.deepEqual(out, session);
-        assert.equal(capturedBody?.aithos_code, "abc123XYZ_-456");
-        assert.equal(w.replacedHref, "https://app.aithos.be/auth/callback", "callback params must be stripped from the URL");
-    });
-    it("throws AithosSDKError with the backend code on aithos_error", async () => {
-        const w = makeFakeWindow("https://app.aithos.be/auth/callback?aithos_error=google_id_token&app_state=/dashboard");
-        const auth = new AithosAuth({
-            authBaseUrl: "https://auth.example.test",
-            window: w.win,
-            fetch: undefinedFetch(),
-        });
-        await assert.rejects(auth.handleCallback(), (e) => e instanceof AithosSDKError && e.code === "auth_google_id_token");
-        // URL is cleaned even on error so a refresh doesn't loop the message.
-        assert.equal(w.replacedHref, "https://app.aithos.be/auth/callback");
-    });
-    it("wraps a 410 'code_consumed' as AithosSDKError(code='auth_code_consumed')", async () => {
-        const w = makeFakeWindow("https://app.aithos.be/auth/callback?aithos_code=abc123XYZ_-456");
-        const fakeFetch = async () => new Response(JSON.stringify({ error: "aithos_code expired or already used", code: "code_consumed" }), { status: 410, headers: { "content-type": "application/json" } });
-        const auth = new AithosAuth({
-            authBaseUrl: "https://auth.example.test",
-            window: w.win,
-            fetch: fakeFetch,
-        });
-        await assert.rejects(auth.handleCallback(), (e) => e instanceof AithosSDKError &&
-            e.code === "auth_code_consumed" &&
-            e.status === 410);
-    });
-    it("returns null in non-browser environments (no window)", async () => {
-        // No `window` injected and `globalThis.window` is undefined under Node test.
-        const auth = new AithosAuth({ window: undefined, fetch: undefinedFetch() });
-        const session = await auth.handleCallback();
-        assert.equal(session, null);
-    });
-});
-/* -------------------------------------------------------------------------- */
-/*  signOut                                                                   */
-/* -------------------------------------------------------------------------- */
-describe("AithosAuth.signOut", () => {
-    it("resolves immediately (sessions are stateless)", async () => {
-        const auth = new AithosAuth({ window: undefined, fetch: undefinedFetch() });
-        await auth.signOut();
-    });
-});
-/* -------------------------------------------------------------------------- */
-/*  Helpers                                                                   */
-/* -------------------------------------------------------------------------- */
-/** A fetch that fails the test if invoked — for code paths that mustn't fetch. */
-function undefinedFetch() {
-    return async () => {
-        throw new Error("fetch should not have been called");
-    };
-}
-//# sourceMappingURL=auth.test.js.map

package/dist/test/compute.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=compute.test.d.ts.map

package/dist/test/compute.test.js

@@ -1,179 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// Copyright 2026 Mathieu Colla
-// Unit tests for sdk.compute.invokeBedrock with a mock fetch.
-//
-// We construct a real BrowserIdentity (Ed25519 keypairs are synchronous)
-// rather than stubbing it out — that way the envelope-signing path runs
-// for real and any signature/canonicalization regression in the SDK or
-// in protocol-client surfaces here.
-import { strict as assert } from "node:assert";
-import { describe, it } from "node:test";
-import { createBrowserIdentity } from "@aithos/protocol-client";
-import { AithosSDK, AithosSDKError } from "../src/index.js";
-const APP_DID = "did:aithos:app:test";
-function makeSdk(fetchImpl) {
-    const identity = createBrowserIdentity("test-handle", "Test User");
-    return new AithosSDK({
-        identity,
-        appDid: APP_DID,
-        endpoints: { compute: "https://compute.example.test" },
-        fetch: fetchImpl,
-    });
-}
-const HAPPY_RESULT = {
-    content: "Hello, Aithos!",
-    stopReason: "end_turn",
-    usage: { inputTokens: 12, outputTokens: 8 },
-    creditsCharged: 9,
-    walletBalance: 99_991,
-    auditId: "audit-1",
-};
-describe("compute.invokeBedrock — happy path", () => {
-    it("posts to ${compute}/v1/invoke with a JSON-RPC envelope and parses the result", async () => {
-        let capturedUrl;
-        let capturedInit;
-        const fakeFetch = async (input, init) => {
-            capturedUrl = typeof input === "string" ? input : input.toString();
-            capturedInit = init;
-            return new Response(JSON.stringify({ result: HAPPY_RESULT }), {
-                status: 200,
-                headers: { "content-type": "application/json" },
-            });
-        };
-        const sdk = makeSdk(fakeFetch);
-        const out = await sdk.compute.invokeBedrock({
-            mandateId: "mandate:abc",
-            model: "claude-sonnet-4-6",
-            messages: [{ role: "user", content: "Hi" }],
-        });
-        assert.deepEqual(out, HAPPY_RESULT);
-        assert.equal(capturedUrl, "https://compute.example.test/v1/invoke");
-        assert.equal(capturedInit?.method, "POST");
-        const headers = capturedInit?.headers;
-        assert.equal(headers["content-type"], "application/json");
-        const body = JSON.parse(capturedInit?.body);
-        assert.equal(body.jsonrpc, "2.0");
-        assert.equal(body.method, "aithos.compute_invoke");
-        assert.equal(body.params.app_did, APP_DID);
-        assert.equal(body.params.mandate_id, "mandate:abc");
-        assert.equal(body.params.model, "claude-sonnet-4-6");
-        // Idempotency key is auto-generated when not provided.
-        assert.match(body.params.idempotency_key, /^[0-9a-f]{32}$/);
-        // Envelope is present on the wire.
-        assert.ok(body.params._envelope, "request must carry a signed envelope");
-    });
-    it("forwards optional system / max_tokens / temperature and respects a caller-provided idempotencyKey", async () => {
-        let capturedBody;
-        const fakeFetch = async (_input, init) => {
-            capturedBody = JSON.parse(init?.body).params;
-            return new Response(JSON.stringify({ result: HAPPY_RESULT }), {
-                status: 200,
-                headers: { "content-type": "application/json" },
-            });
-        };
-        const sdk = makeSdk(fakeFetch);
-        await sdk.compute.invokeBedrock({
-            mandateId: "mandate:abc",
-            model: "claude-sonnet-4-6",
-            messages: [{ role: "user", content: "Hi" }],
-            system: "You are concise.",
-            maxTokens: 256,
-            temperature: 0.2,
-            idempotencyKey: "idem-1",
-        });
-        assert.equal(capturedBody?.system, "You are concise.");
-        assert.equal(capturedBody?.max_tokens, 256);
-        assert.equal(capturedBody?.temperature, 0.2);
-        assert.equal(capturedBody?.idempotency_key, "idem-1");
-    });
-});
-describe("compute.invokeBedrock — errors", () => {
-    it("wraps a network failure as AithosSDKError(code='network')", async () => {
-        const fakeFetch = async () => {
-            throw new Error("fetch failed: ECONNREFUSED");
-        };
-        const sdk = makeSdk(fakeFetch);
-        await assert.rejects(sdk.compute.invokeBedrock({
-            mandateId: "mandate:abc",
-            model: "claude-sonnet-4-6",
-            messages: [{ role: "user", content: "Hi" }],
-        }), (err) => {
-            assert.ok(err instanceof AithosSDKError);
-            assert.equal(err.code, "network");
-            assert.match(err.message, /ECONNREFUSED/);
-            return true;
-        });
-    });
-    it("wraps an HTTP non-2xx as AithosSDKError(code='http')", async () => {
-        const fakeFetch = async () => new Response("nope", { status: 503, statusText: "Service Unavailable" });
-        const sdk = makeSdk(fakeFetch);
-        await assert.rejects(sdk.compute.invokeBedrock({
-            mandateId: "mandate:abc",
-            model: "claude-sonnet-4-6",
-            messages: [{ role: "user", content: "Hi" }],
-        }), (err) => {
-            assert.ok(err instanceof AithosSDKError);
-            assert.equal(err.code, "http");
-            assert.equal(err.status, 503);
-            return true;
-        });
-    });
-    it("wraps a JSON-RPC error response with the proxy's code and message", async () => {
-        const fakeFetch = async () => new Response(JSON.stringify({
-            error: {
-                code: 402,
-                message: "insufficient_credits",
-                data: { balance: 0, required: 1 },
-            },
-        }), { status: 200, headers: { "content-type": "application/json" } });
-        const sdk = makeSdk(fakeFetch);
-        await assert.rejects(sdk.compute.invokeBedrock({
-            mandateId: "mandate:abc",
-            model: "claude-sonnet-4-6",
-            messages: [{ role: "user", content: "Hi" }],
-        }), (err) => {
-            assert.ok(err instanceof AithosSDKError);
-            assert.equal(err.code, "402");
-            assert.equal(err.message, "insufficient_credits");
-            return true;
-        });
-    });
-    it("rejects an empty result payload as AithosSDKError(code='empty')", async () => {
-        const fakeFetch = async () => new Response(JSON.stringify({}), {
-            status: 200,
-            headers: { "content-type": "application/json" },
-        });
-        const sdk = makeSdk(fakeFetch);
-        await assert.rejects(sdk.compute.invokeBedrock({
-            mandateId: "mandate:abc",
-            model: "claude-sonnet-4-6",
-            messages: [{ role: "user", content: "Hi" }],
-        }), (err) => {
-            assert.ok(err instanceof AithosSDKError);
-            assert.equal(err.code, "empty");
-            return true;
-        });
-    });
-});
-describe("compute.invokeBedrock — abort", () => {
-    it("propagates an AbortSignal to fetch", async () => {
-        let receivedSignal;
-        const fakeFetch = async (_input, init) => {
-            receivedSignal = init?.signal;
-            return new Response(JSON.stringify({ result: HAPPY_RESULT }), {
-                status: 200,
-                headers: { "content-type": "application/json" },
-            });
-        };
-        const sdk = makeSdk(fakeFetch);
-        const ac = new AbortController();
-        await sdk.compute.invokeBedrock({
-            mandateId: "mandate:abc",
-            model: "claude-sonnet-4-6",
-            messages: [{ role: "user", content: "Hi" }],
-            signal: ac.signal,
-        });
-        assert.equal(receivedSignal, ac.signal);
-    });
-});
-//# sourceMappingURL=compute.test.js.map

package/dist/test/endpoints.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=endpoints.test.d.ts.map

package/dist/test/endpoints.test.js

@@ -1,43 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// Copyright 2026 Mathieu Colla
-// Unit tests for endpoint resolution + URL composition.
-import { strict as assert } from "node:assert";
-import { describe, it } from "node:test";
-import { DEFAULT_SDK_ENDPOINTS } from "../src/index.js";
-import { computeInvokeUrl, resolveEndpoints, walletTopupCheckoutUrl, } from "../src/endpoints.js";
-describe("resolveEndpoints", () => {
-    it("returns a fresh copy of the defaults when no override is given", () => {
-        const a = resolveEndpoints();
-        const b = resolveEndpoints();
-        assert.deepEqual(a, DEFAULT_SDK_ENDPOINTS);
-        assert.notEqual(a, b, "resolveEndpoints must not return a shared instance");
-    });
-    it("merges partial overrides on top of the defaults", () => {
-        const e = resolveEndpoints({ compute: "https://staging.aithos.be" });
-        assert.equal(e.compute, "https://staging.aithos.be");
-        assert.equal(e.wallet, DEFAULT_SDK_ENDPOINTS.wallet);
-    });
-});
-describe("computeInvokeUrl", () => {
-    it("appends /v1/invoke to the compute base", () => {
-        assert.equal(computeInvokeUrl({
-            compute: "https://compute.aithos.be",
-            wallet: "https://wallet.aithos.be",
-        }), "https://compute.aithos.be/v1/invoke");
-    });
-    it("trims a trailing slash on the compute base", () => {
-        assert.equal(computeInvokeUrl({
-            compute: "https://compute.aithos.be/",
-            wallet: "https://wallet.aithos.be",
-        }), "https://compute.aithos.be/v1/invoke");
-    });
-});
-describe("walletTopupCheckoutUrl", () => {
-    it("appends /v1/wallet/topup/checkout to the wallet base", () => {
-        assert.equal(walletTopupCheckoutUrl({
-            compute: "https://compute.aithos.be",
-            wallet: "https://wallet.aithos.be",
-        }), "https://wallet.aithos.be/v1/wallet/topup/checkout");
-    });
-});
-//# sourceMappingURL=endpoints.test.js.map

package/dist/test/sdk.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=sdk.test.d.ts.map