@aithos/sdk 0.1.0-alpha.5 → 0.1.0-alpha.51

package/dist/test/transcribe.test.js

@@ -0,0 +1,186 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2026 Mathieu Colla
+// Unit tests for the transcription low-level API (sdk.compute.{prepare,
+// start,getStatus,listPending}Transcribe) with a mock fetch. A real
+// BrowserIdentity signs the envelopes, so any signing/canonicalization
+// regression surfaces here too.
+import { strict as assert } from "node:assert";
+import { describe, it } from "node:test";
+import { createBrowserIdentity } from "@aithos/protocol-client";
+import { AithosAuth, AithosSDK, memoryKeyStore, noopStore, } from "../src/index.js";
+import { serializeRecoveryFile } from "../src/internal/recovery-file.js";
+const APP_DID = "did:aithos:app:test";
+async function makeSdk(fetchImpl) {
+    const id = createBrowserIdentity("test-handle", "Test User");
+    const auth = new AithosAuth({
+        authBaseUrl: "https://auth.test",
+        fetch: (() => {
+            throw new Error("auth not used in compute tests");
+        }),
+        sessionStore: noopStore(),
+        keyStore: memoryKeyStore(),
+    });
+    const { text } = serializeRecoveryFile(id);
+    await auth.signInWithRecovery({ file: text });
+    return new AithosSDK({
+        auth,
+        appDid: APP_DID,
+        endpoints: { compute: "https://compute.example.test" },
+        fetch: fetchImpl,
+    });
+}
+function jsonRpc(result) {
+    return new Response(JSON.stringify({ result }), {
+        status: 200,
+        headers: { "content-type": "application/json" },
+    });
+}
+function bodyParams(init) {
+    return JSON.parse(init?.body).params;
+}
+function bodyMethod(init) {
+    return JSON.parse(init?.body).method;
+}
+describe("compute.prepareTranscribe", () => {
+    it("posts transcribe_prepare with app_did + content_type and maps the result", async () => {
+        let method;
+        let params;
+        const sdk = await makeSdk(async (_url, init) => {
+            method = bodyMethod(init);
+            params = bodyParams(init);
+            return jsonRpc({
+                job_id: "tj_ABC",
+                upload_url: "https://s3.example/upload?sig=1",
+                s3_object_key: "uploads/2026/05/tj_ABC.webm",
+                expires_at: 1717000000,
+            });
+        });
+        const out = await sdk.compute.prepareTranscribe({
+            contentType: "audio/webm",
+            durationSecEstimate: 120,
+        });
+        assert.equal(method, "aithos.compute_transcribe_prepare");
+        assert.equal(params?.app_did, APP_DID);
+        assert.equal(params?.content_type, "audio/webm");
+        assert.equal(params?.duration_sec_estimate, 120);
+        assert.ok(params._envelope, "must carry an envelope");
+        assert.deepEqual(out, {
+            jobId: "tj_ABC",
+            uploadUrl: "https://s3.example/upload?sig=1",
+            s3ObjectKey: "uploads/2026/05/tj_ABC.webm",
+            expiresAt: 1717000000,
+        });
+    });
+});
+describe("compute.startTranscribe", () => {
+    it("posts transcribe_start with the wire params and maps the result", async () => {
+        let method;
+        let params;
+        const sdk = await makeSdk(async (_url, init) => {
+            method = bodyMethod(init);
+            params = bodyParams(init);
+            return jsonRpc({
+                job_id: "tj_ABC",
+                status: "running",
+                estimated_credits: 240,
+                walletBalance: 49_760,
+                fundedBy: "purchase",
+            });
+        });
+        const out = await sdk.compute.startTranscribe({
+            jobId: "tj_ABC",
+            model: "transcribe:aws-fr-standard",
+            durationSec: 120,
+            languageCode: "fr-FR",
+            diarization: false,
+            idempotencyKey: "ik_1",
+        });
+        assert.equal(method, "aithos.compute_transcribe_start");
+        assert.equal(params?.job_id, "tj_ABC");
+        assert.equal(params?.model, "transcribe:aws-fr-standard");
+        assert.equal(params?.duration_sec, 120);
+        assert.equal(params?.language_code, "fr-FR");
+        assert.equal(params?.diarization, false);
+        assert.equal(params?.idempotency_key, "ik_1");
+        assert.ok(typeof params?.mandate_id === "string" && params.mandate_id.length > 0);
+        assert.deepEqual(out, {
+            jobId: "tj_ABC",
+            status: "running",
+            estimatedCredits: 240,
+            walletBalance: 49_760,
+            fundedBy: "purchase",
+        });
+    });
+});
+describe("compute.getTranscribeStatus", () => {
+    it("maps a running response", async () => {
+        const sdk = await makeSdk(async () => jsonRpc({ job_id: "tj_ABC", status: "running", elapsed_sec: 12 }));
+        const out = await sdk.compute.getTranscribeStatus({ jobId: "tj_ABC" });
+        assert.deepEqual(out, { jobId: "tj_ABC", status: "running", elapsedSec: 12 });
+    });
+    it("maps a completed response (duration_sec_actual -> durationSec)", async () => {
+        const sdk = await makeSdk(async () => jsonRpc({
+            job_id: "tj_ABC",
+            status: "completed",
+            text: "Bonjour le monde",
+            segments: [{ start_sec: 0, end_sec: 1.4, text: "Bonjour le monde" }],
+            words: [{ start_sec: 0, end_sec: 0.4, content: "Bonjour", confidence: 0.99 }],
+            duration_sec_actual: 127,
+            language_code: "fr-FR",
+            creditsCharged: 254,
+            walletBalance: 49_746,
+            auditId: "audit_1",
+            fundedBy: "purchase",
+        }));
+        const out = await sdk.compute.getTranscribeStatus({ jobId: "tj_ABC" });
+        assert.equal(out.status, "completed");
+        if (out.status !== "completed")
+            return;
+        assert.equal(out.text, "Bonjour le monde");
+        assert.equal(out.durationSec, 127);
+        assert.equal(out.languageCode, "fr-FR");
+        assert.equal(out.creditsCharged, 254);
+        assert.equal(out.auditId, "audit_1");
+        assert.equal(out.fundedBy, "purchase");
+        assert.equal(out.segments.length, 1);
+        assert.equal(out.words[0]?.content, "Bonjour");
+    });
+    it("maps a failed response", async () => {
+        const sdk = await makeSdk(async () => jsonRpc({
+            job_id: "tj_ABC",
+            status: "failed",
+            error: { code: "transcribe_provider_error", message: "boom" },
+        }));
+        const out = await sdk.compute.getTranscribeStatus({ jobId: "tj_ABC" });
+        assert.equal(out.status, "failed");
+        if (out.status !== "failed")
+            return;
+        assert.equal(out.error.code, "transcribe_provider_error");
+        assert.equal(out.error.message, "boom");
+    });
+});
+describe("compute.listPendingTranscribes", () => {
+    it("forwards include_completed and maps job summaries", async () => {
+        let params;
+        const sdk = await makeSdk(async (_url, init) => {
+            params = bodyParams(init);
+            return jsonRpc({
+                jobs: [
+                    { job_id: "tj_1", status: "running", created_at: 1717000000, estimated_credits: 240 },
+                    { job_id: "tj_2", status: "completed", created_at: 1717000100, creditsCharged: 250 },
+                ],
+            });
+        });
+        const out = await sdk.compute.listPendingTranscribes({ includeCompleted: true });
+        assert.equal(params?.include_completed, true);
+        assert.equal(out.jobs.length, 2);
+        assert.deepEqual(out.jobs[0], {
+            jobId: "tj_1",
+            status: "running",
+            createdAt: 1717000000,
+            estimatedCredits: 240,
+        });
+        assert.equal(out.jobs[1]?.creditsCharged, 250);
+    });
+});
+//# sourceMappingURL=transcribe.test.js.map

package/dist/test/web.test.d.ts

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

package/dist/test/web.test.js

@@ -0,0 +1,270 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2026 Mathieu Colla
+// Unit tests for sdk.web.extract with a mock fetch.
+//
+// Mirrors test/compute.test.ts: real BrowserIdentity (synchronous Ed25519)
+// so the envelope-signing path runs for real and any
+// signature/canonicalization regression surfaces here.
+import { strict as assert } from "node:assert";
+import { describe, it } from "node:test";
+import { createBrowserIdentity } from "@aithos/protocol-client";
+import { AithosAuth, AithosSDK, AithosSDKError, memoryKeyStore, noopStore, } from "../src/index.js";
+import { serializeRecoveryFile } from "../src/internal/recovery-file.js";
+const APP_DID = "did:aithos:app:test";
+async function makeSdk(fetchImpl) {
+    const id = createBrowserIdentity("test-handle", "Test User");
+    const auth = new AithosAuth({
+        authBaseUrl: "https://auth.test",
+        fetch: (() => {
+            throw new Error("auth not used in web tests");
+        }),
+        sessionStore: noopStore(),
+        keyStore: memoryKeyStore(),
+    });
+    const { text } = serializeRecoveryFile(id);
+    await auth.signInWithRecovery({ file: text });
+    return new AithosSDK({
+        auth,
+        appDid: APP_DID,
+        endpoints: { web: "https://extract.example.test" },
+        fetch: fetchImpl,
+    });
+}
+const HAPPY_RESULT = {
+    data: {
+        url: "https://example.com",
+        final_url: "https://example.com/",
+        fetched_at: "2026-05-13T05:30:00.000Z",
+        render_ms: 1234,
+        meta: {
+            title: "Example",
+            description: null,
+            lang: "en",
+            charset: "UTF-8",
+            viewport: null,
+            canonical: null,
+            og: {},
+        },
+        structure: { headings: [], sections: [], nav_links: [], forms: [] },
+        content: {
+            main_html: "<main>hi</main>",
+            main_text: "hi",
+            images: [],
+            links: { internal: [], external: [] },
+        },
+        styles: { css: "", inline_styles_count: 0 },
+        visual_signature: {
+            colors: {
+                palette: [],
+                background: "#ffffff",
+                text: "#000000",
+                primary: null,
+                link: null,
+            },
+            typography: {
+                heading_font: null,
+                body_font: "sans-serif",
+                size_scale: [],
+                base_size_px: 16,
+                base_line_height: 1.5,
+            },
+            radii: { button: null, input: null, card: null },
+            spacing: { base_unit_px: null, common_gaps_px: [] },
+            layout: { max_content_width_px: null, mode: "block" },
+            components: { buttons: [], inputs: [], cards: [] },
+        },
+        logo: null,
+    },
+    creditsCharged: 1,
+    walletBalance: 99_999,
+    auditId: "audit-web-1",
+};
+describe("web.extract — happy path", () => {
+    it("posts to ${web}/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 = await makeSdk(fakeFetch);
+        const out = await sdk.web.extract({ url: "https://example.com" });
+        assert.deepEqual(out, HAPPY_RESULT);
+        assert.equal(capturedUrl, "https://extract.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.web_extract");
+        assert.equal(body.params.url, "https://example.com");
+        assert.equal(body.params.app_did, APP_DID);
+        assert.ok(typeof body.params.mandate_id === "string");
+        assert.ok(body.params.mandate_id.length > 0);
+        assert.ok(body.params._envelope, "request must carry a signed envelope");
+    });
+    it("forwards waitUntil and timeoutMs as snake_case-free params", async () => {
+        let capturedBody;
+        const fakeFetch = async (_input, init) => {
+            capturedBody = JSON.parse(init.body);
+            return new Response(JSON.stringify({ result: HAPPY_RESULT }), {
+                status: 200,
+                headers: { "content-type": "application/json" },
+            });
+        };
+        const sdk = await makeSdk(fakeFetch);
+        await sdk.web.extract({
+            url: "https://example.com",
+            waitUntil: "domcontentloaded",
+            timeoutMs: 5000,
+        });
+        assert.equal(capturedBody?.params.waitUntil, "domcontentloaded");
+        assert.equal(capturedBody?.params.timeoutMs, 5000);
+    });
+});
+describe("web.extract — error mapping", () => {
+    it("propagates -32071 insufficient_balance as AithosSDKError with data", async () => {
+        const fakeFetch = async () => new Response(JSON.stringify({
+            error: {
+                code: -32071,
+                message: "Insufficient balance",
+                data: { required: 1, available: 0 },
+            },
+        }), { status: 200, headers: { "content-type": "application/json" } });
+        const sdk = await makeSdk(fakeFetch);
+        await assert.rejects(() => sdk.web.extract({ url: "https://example.com" }), (err) => {
+            assert.ok(err instanceof AithosSDKError);
+            assert.equal(err.code, "-32071");
+            const data = err.data;
+            assert.equal(data?.required, 1);
+            assert.equal(data?.available, 0);
+            return true;
+        });
+    });
+    it("propagates -32042 scope mismatch as AithosSDKError", async () => {
+        const fakeFetch = async () => new Response(JSON.stringify({
+            error: {
+                code: -32042,
+                message: "mandate does not carry the web.extract scope",
+                data: {
+                    mandate_id: "mandate:abc",
+                    required_scope: "web.extract",
+                },
+            },
+        }), { status: 200, headers: { "content-type": "application/json" } });
+        const sdk = await makeSdk(fakeFetch);
+        await assert.rejects(() => sdk.web.extract({ url: "https://example.com" }), (err) => {
+            assert.ok(err instanceof AithosSDKError);
+            assert.equal(err.code, "-32042");
+            return true;
+        });
+    });
+    it("rejects HTTP transport errors as AithosSDKError code=http", async () => {
+        const fakeFetch = async () => new Response("upstream is down", { status: 502 });
+        const sdk = await makeSdk(fakeFetch);
+        await assert.rejects(() => sdk.web.extract({ url: "https://example.com" }), (err) => {
+            assert.ok(err instanceof AithosSDKError);
+            assert.equal(err.code, "http");
+            return true;
+        });
+    });
+});
+describe("web.extract — endpoint default", () => {
+    it("defaults to https://extract.aithos.be when no override is given", async () => {
+        let capturedUrl;
+        const fakeFetch = async (input) => {
+            capturedUrl = typeof input === "string" ? input : input.toString();
+            return new Response(JSON.stringify({ result: HAPPY_RESULT }), {
+                status: 200,
+                headers: { "content-type": "application/json" },
+            });
+        };
+        const id = createBrowserIdentity("test-handle", "Test User");
+        const auth = new AithosAuth({
+            authBaseUrl: "https://auth.test",
+            fetch: (() => {
+                throw new Error("auth not used");
+            }),
+            sessionStore: noopStore(),
+            keyStore: memoryKeyStore(),
+        });
+        const { text } = serializeRecoveryFile(id);
+        await auth.signInWithRecovery({ file: text });
+        const sdk = new AithosSDK({
+            auth,
+            appDid: APP_DID,
+            fetch: fakeFetch,
+        });
+        await sdk.web.extract({ url: "https://example.com" });
+        assert.equal(capturedUrl, "https://extract.aithos.be/v1/invoke");
+    });
+});
+describe("web.fetchAsset — happy path", () => {
+    it("posts to ${web}/v1/invoke with method aithos.web_fetch_asset", async () => {
+        let capturedUrl;
+        let capturedInit;
+        const fakeResult = {
+            data: {
+                url: "https://example.com/logo.png",
+                final_url: "https://example.com/logo.png",
+                content_type: "image/png",
+                size_bytes: 4096,
+                base64: "aGVsbG8K",
+            },
+            creditsCharged: 1,
+            walletBalance: 99_998,
+            auditId: "audit-asset-1",
+        };
+        const fakeFetch = async (input, init) => {
+            capturedUrl = typeof input === "string" ? input : input.toString();
+            capturedInit = init;
+            return new Response(JSON.stringify({ result: fakeResult }), {
+                status: 200,
+                headers: { "content-type": "application/json" },
+            });
+        };
+        const sdk = await makeSdk(fakeFetch);
+        const out = await sdk.web.fetchAsset({ url: "https://example.com/logo.png" });
+        assert.deepEqual(out, fakeResult);
+        assert.equal(capturedUrl, "https://extract.example.test/v1/invoke");
+        const body = JSON.parse(capturedInit?.body);
+        assert.equal(body.method, "aithos.web_fetch_asset");
+        assert.equal(body.params.url, "https://example.com/logo.png");
+        assert.equal(body.params.app_did, APP_DID);
+        assert.ok(typeof body.params.mandate_id === "string");
+        assert.ok(body.params._envelope, "request must carry a signed envelope");
+    });
+});
+describe("web.fetchAsset — error propagation", () => {
+    it("propagates -32071 insufficient_balance as AithosSDKError", async () => {
+        const fakeFetch = async () => new Response(JSON.stringify({
+            error: {
+                code: -32071,
+                message: "Insufficient balance",
+                data: { required: 1, available: 0 },
+            },
+        }), { status: 200, headers: { "content-type": "application/json" } });
+        const sdk = await makeSdk(fakeFetch);
+        await assert.rejects(() => sdk.web.fetchAsset({ url: "https://example.com/logo.png" }), (err) => {
+            assert.ok(err instanceof AithosSDKError);
+            assert.equal(err.code, "-32071");
+            return true;
+        });
+    });
+    it("propagates -32000 upstream fetch failure as AithosSDKError", async () => {
+        const fakeFetch = async () => new Response(JSON.stringify({
+            error: { code: -32000, message: "Asset fetch failed", data: { reason: "upstream HTTP 404" } },
+        }), { status: 200, headers: { "content-type": "application/json" } });
+        const sdk = await makeSdk(fakeFetch);
+        await assert.rejects(() => sdk.web.fetchAsset({ url: "https://example.com/missing.png" }), (err) => {
+            assert.ok(err instanceof AithosSDKError);
+            assert.equal(err.code, "-32000");
+            return true;
+        });
+    });
+});
+//# sourceMappingURL=web.test.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aithos/sdk",
-  "version": "0.1.0-alpha.5",
+  "version": "0.1.0-alpha.51",
   "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,10 +56,23 @@
     "node": ">=20"
   },
   "peerDependencies": {
-    "@aithos/protocol-client": ">=0.1.0-alpha.11 <0.2.0"
+    "@aithos/assets-crypto": ">=0.1.0-alpha.1 <0.2.0",
+    "@aithos/protocol-client": "^0.1.0-alpha.17",
+    "@aithos/protocol-core": ">=0.6.3 <0.7.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/assets-crypto": "^0.1.0-alpha.1",
+    "@aithos/protocol-client": "^0.1.0-alpha.17",
+    "@aithos/protocol-core": ">=0.6.3 <0.7.0",
     "@types/node": "^24.12.2",
     "fake-indexeddb": "^6.2.5",
     "typescript": "^5.9.2"