@aithos/sdk 0.1.0-alpha.21 → 0.1.0-alpha.24

package/dist/src/web.d.ts

@@ -0,0 +1,279 @@
+import type { AithosAuth } from "./auth.js";
+import { type AithosSdkEndpoints } from "./endpoints.js";
+/** Opt-in scope a mandate must carry to invoke `aithos.web_extract`. */
+export declare const WEB_EXTRACT_SCOPE: "web.extract";
+export interface ExtractArgs {
+    /**
+     * Mandate ID under which this call should be attributed.
+     *
+     * - **Owner sessions**: optional. The SDK uses the owner's own DID
+     *   as a sentinel "self" mandate id — the proxy skips mandate checks
+     *   when the envelope is owner-signed.
+     * - **Delegate sessions**: required. Must reference the imported
+     *   mandate bundle the SDK signs with; the proxy enforces the
+     *   `web.extract` scope.
+     */
+    readonly mandateId?: string;
+    /** Absolute http(s) URL to extract. */
+    readonly url: string;
+    /**
+     * Playwright `waitUntil` strategy passed straight through to the
+     * server-side navigation. Defaults to `"networkidle"` server-side
+     * if omitted.
+     */
+    readonly waitUntil?: "load" | "domcontentloaded" | "networkidle";
+    /** Navigation timeout in ms. Server validates [1000, 60000]. */
+    readonly timeoutMs?: number;
+    /** Reserved for audit-level deduplication; the proxy currently does not
+     *  enforce idempotency keys for extractions. */
+    readonly idempotencyKey?: string;
+    /** Abort signal to cancel the request. */
+    readonly signal?: AbortSignal;
+}
+export interface ExtractMeta {
+    readonly title: string | null;
+    readonly description: string | null;
+    readonly lang: string | null;
+    readonly charset: string | null;
+    readonly viewport: string | null;
+    readonly canonical: string | null;
+    readonly og: Readonly<Record<string, string>>;
+}
+export interface ExtractHeading {
+    readonly level: 1 | 2 | 3 | 4 | 5 | 6;
+    readonly text: string;
+    readonly id: string | null;
+}
+export interface ExtractSection {
+    readonly tag: string;
+    readonly role: string | null;
+    readonly html: string;
+    readonly text_len: number;
+}
+export interface ExtractLink {
+    readonly label: string;
+    readonly href: string;
+    readonly internal: boolean;
+}
+export interface ExtractImage {
+    readonly src: string;
+    readonly alt: string | null;
+    readonly role: string | null;
+}
+export interface ExtractFormField {
+    readonly type: string;
+    readonly name: string | null;
+    readonly required: boolean;
+}
+export interface ExtractForm {
+    readonly action: string | null;
+    readonly method: string;
+    readonly fields: readonly ExtractFormField[];
+}
+export interface ExtractStructure {
+    readonly headings: readonly ExtractHeading[];
+    readonly sections: readonly ExtractSection[];
+    readonly nav_links: readonly ExtractLink[];
+    readonly forms: readonly ExtractForm[];
+}
+export interface ExtractContent {
+    readonly main_html: string;
+    readonly main_text: string;
+    readonly images: readonly ExtractImage[];
+    readonly links: {
+        readonly internal: readonly ExtractLink[];
+        readonly external: readonly ExtractLink[];
+    };
+}
+export interface ExtractStyles {
+    readonly css: string;
+    readonly inline_styles_count: number;
+}
+export interface PaletteEntry {
+    readonly hex: string;
+    readonly weight: number;
+    readonly role: "background" | "text" | "accent" | "other";
+}
+export interface ComponentStyle {
+    readonly count: number;
+    readonly bg: string | null;
+    readonly fg: string | null;
+    readonly border: string | null;
+    readonly radius: string | null;
+    readonly padding: string | null;
+    readonly font_size: string | null;
+    readonly font_weight: string | null;
+}
+export interface VisualSignature {
+    readonly colors: {
+        readonly palette: readonly PaletteEntry[];
+        readonly background: string | null;
+        readonly text: string | null;
+        readonly primary: string | null;
+        readonly link: string | null;
+    };
+    readonly typography: {
+        readonly heading_font: string | null;
+        readonly body_font: string | null;
+        readonly size_scale: readonly number[];
+        readonly base_size_px: number | null;
+        readonly base_line_height: number | null;
+    };
+    readonly radii: {
+        readonly button: string | null;
+        readonly input: string | null;
+        readonly card: string | null;
+    };
+    readonly spacing: {
+        readonly base_unit_px: number | null;
+        readonly common_gaps_px: readonly number[];
+    };
+    readonly layout: {
+        readonly max_content_width_px: number | null;
+        readonly mode: "flex" | "grid" | "block" | null;
+    };
+    readonly components: {
+        readonly buttons: readonly ComponentStyle[];
+        readonly inputs: readonly ComponentStyle[];
+        readonly cards: readonly ComponentStyle[];
+    };
+}
+export interface ExtractIconDeclaration {
+    /** href as written in the HTML (relative or absolute). */
+    readonly href: string;
+    /** rel value, lowercased: "icon", "apple-touch-icon", "shortcut icon", ... */
+    readonly rel: string;
+    /** Declared `sizes` attribute, e.g. "180x180" or "any" or null. */
+    readonly sizes: string | null;
+    /** Declared mime type, e.g. "image/svg+xml" or null. */
+    readonly type: string | null;
+}
+/**
+ * Logo asset resolved server-side. The Lambda picks the best
+ * symbol-only asset available on the page — declared <link rel="icon"|
+ * "apple-touch-icon"> declarations + conventional well-known paths
+ * (/apple-touch-icon.png, /favicon.svg, /favicon.ico) — in that
+ * order of expected quality. Null when nothing resolves.
+ *
+ * Favicons are symbol-only by construction (no designer ships a
+ * wordmark inside a 16-180 px icon), which sidesteps the
+ * lockup-vs-symbol problem callers used to handle client-side with
+ * a vision model.
+ */
+export interface ExtractLogo {
+    /** Absolute URL of the asset that was successfully fetched. */
+    readonly url: string;
+    /** Which source produced the winner. */
+    readonly source: "link-icon-svg" | "link-apple-touch-icon" | "link-icon-large" | "link-icon" | "link-shortcut-icon" | "well-known-apple-180" | "well-known-apple" | "well-known-svg" | "well-known-png-large" | "well-known-ico";
+    readonly content_type: string;
+    readonly size_bytes: number;
+    /** Base64-encoded asset bytes (no `data:` prefix). Build a data
+     *  URI with `data:${content_type};base64,${base64}`. */
+    readonly base64: string;
+}
+export interface ExtractData {
+    readonly url: string;
+    readonly final_url: string;
+    readonly fetched_at: string;
+    readonly render_ms: number;
+    readonly meta: ExtractMeta;
+    readonly structure: ExtractStructure;
+    readonly content: ExtractContent;
+    readonly styles: ExtractStyles;
+    readonly visual_signature: VisualSignature;
+    /**
+     * Best logo asset resolved by the lambda — null when no
+     * <link rel="icon"> declaration and no conventional favicon
+     * path produced a usable image. Callers should then let the
+     * operator upload the logo manually rather than treat this as
+     * a fatal error.
+     */
+    readonly logo: ExtractLogo | null;
+}
+export interface ExtractResult {
+    /** Cleaned extraction payload. */
+    readonly data: ExtractData;
+    /** Microcredits charged for this call (1 on success, 0 on refunded failures). */
+    readonly creditsCharged: number;
+    /** Wallet balance after the (possibly refunded) debit. */
+    readonly walletBalance: number;
+    /** Audit log id for traceability. */
+    readonly auditId: string;
+}
+export interface FetchAssetArgs {
+    /** Absolute http(s) URL of the asset to fetch. */
+    readonly url: string;
+    /** Mandate id under which this call should be attributed. */
+    readonly mandateId?: string;
+    /** Abort signal. */
+    readonly signal?: AbortSignal;
+}
+export interface FetchAssetResult {
+    /** Asset payload. */
+    readonly data: {
+        /** URL we asked the proxy to fetch. */
+        readonly url: string;
+        /** URL after the proxy followed any redirects. */
+        readonly final_url: string;
+        /** Content-Type reported by the upstream server. */
+        readonly content_type: string;
+        /** Size of the fetched body in bytes. */
+        readonly size_bytes: number;
+        /** Base64-encoded body (no `data:` prefix). Build a data URI
+         *  with `data:${content_type};base64,${base64}`. */
+        readonly base64: string;
+    };
+    /** Microcredits charged for this call. */
+    readonly creditsCharged: number;
+    readonly walletBalance: number;
+    readonly auditId: string;
+}
+export interface WebNamespaceDeps {
+    readonly auth: AithosAuth;
+    readonly appDid: string;
+    readonly endpoints: AithosSdkEndpoints;
+    readonly fetch: typeof fetch;
+}
+/**
+ * `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 declare class WebNamespace {
+    #private;
+    constructor(deps: WebNamespaceDeps);
+    /**
+     * Extract a public webpage. Returns the cleaned HTML, purged CSS and
+     * a deterministic visual signature (palette, typography, dominant
+     * radii, spacing, layout mode, component digests).
+     */
+    extract(args: ExtractArgs): Promise<ExtractResult>;
+    /**
+     * 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.
+     */
+    fetchAsset(args: FetchAssetArgs): Promise<FetchAssetResult>;
+}
+//# sourceMappingURL=web.d.ts.map

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/dist/test/compute.test.js

@@ -187,166 +187,8 @@ describe("compute.invokeBedrock — abort", () => {
         assert.equal(receivedSignal, ac.signal);
     });
 });
-/* -------------------------------------------------------------------------- */
-/*  invokeUrlFetch                                                            */
-/* -------------------------------------------------------------------------- */
-const URL_FETCH_HAPPY_RESULT = {
-    content: "Tata.com propose un service Y avec une couleur primaire bleu (#1E40AF).",
-    citations: [
-        {
-            url: "https://tata.com",
-            citedText: "Notre service révolutionne...",
-            documentTitle: "Tata — Home",
-            startCharIndex: 0,
-            endCharIndex: 28,
-        },
-    ],
-    urlsFetched: [
-        {
-            url: "https://tata.com",
-            retrievedAt: "2026-05-12T10:00:00Z",
-            title: "Tata — Home",
-        },
-    ],
-    stopReason: "end_turn",
-    usage: { inputTokens: 28_500, outputTokens: 420, webFetchInvocations: 1 },
-    creditsCharged: 35,
-    walletBalance: 99_965,
-    auditId: "audit-url-1",
-};
-describe("compute.invokeUrlFetch — happy path", () => {
-    it("posts to ${compute}/v1/invoke with method=aithos.compute_invoke_url_fetch", 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: URL_FETCH_HAPPY_RESULT }), {
-                status: 200,
-                headers: { "content-type": "application/json" },
-            });
-        };
-        const sdk = await makeSdk(fakeFetch);
-        const out = await sdk.compute.invokeUrlFetch({
-            mandateId: "mandate:abc",
-            prompt: "Voici l'URL https://tata.com — résume.",
-        });
-        assert.deepEqual(out, URL_FETCH_HAPPY_RESULT);
-        assert.equal(capturedUrl, "https://compute.example.test/v1/invoke");
-        const body = JSON.parse(capturedInit?.body);
-        assert.equal(body.jsonrpc, "2.0");
-        assert.equal(body.method, "aithos.compute_invoke_url_fetch");
-        assert.equal(body.params.app_did, APP_DID);
-        assert.equal(body.params.mandate_id, "mandate:abc");
-        // Default model is Haiku 4.5 (cheapest model that supports web_fetch).
-        assert.equal(body.params.model, "claude-haiku-4-5");
-        assert.equal(body.params.prompt, "Voici l'URL https://tata.com — résume.");
-        // Auto-generated idempotency key.
-        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");
-        // Optional params NOT forwarded when not provided.
-        assert.equal(body.params.system, undefined);
-        assert.equal(body.params.max_fetches, undefined);
-        assert.equal(body.params.max_content_tokens, undefined);
-        assert.equal(body.params.citations, undefined);
-        assert.equal(body.params.allowed_domains, undefined);
-        assert.equal(body.params.blocked_domains, undefined);
-    });
-    it("forwards all optional knobs: system / maxTokens / maxFetches / maxContentTokens / citations / allowedDomains / idempotencyKey / model", async () => {
-        let capturedBody;
-        const fakeFetch = async (_input, init) => {
-            capturedBody = JSON.parse(init?.body).params;
-            return new Response(JSON.stringify({ result: URL_FETCH_HAPPY_RESULT }), {
-                status: 200,
-                headers: { "content-type": "application/json" },
-            });
-        };
-        const sdk = await makeSdk(fakeFetch);
-        await sdk.compute.invokeUrlFetch({
-            mandateId: "mandate:abc",
-            model: "claude-sonnet-4-6",
-            prompt: "Analyse https://tata.com",
-            system: "You are a brand analyst.",
-            maxTokens: 1024,
-            temperature: 0.1,
-            maxFetches: 3,
-            maxContentTokens: 50_000,
-            citations: false,
-            allowedDomains: ["tata.com", "*.tata.com"],
-            idempotencyKey: "idem-url-1",
-        });
-        assert.equal(capturedBody?.model, "claude-sonnet-4-6");
-        assert.equal(capturedBody?.system, "You are a brand analyst.");
-        assert.equal(capturedBody?.max_tokens, 1024);
-        assert.equal(capturedBody?.temperature, 0.1);
-        assert.equal(capturedBody?.max_fetches, 3);
-        assert.equal(capturedBody?.max_content_tokens, 50_000);
-        assert.equal(capturedBody?.citations, false);
-        assert.deepEqual(capturedBody?.allowed_domains, ["tata.com", "*.tata.com"]);
-        assert.equal(capturedBody?.idempotency_key, "idem-url-1");
-        // Empty / undefined arrays must NOT bleed through as `[]` on the wire.
-        assert.equal(capturedBody?.blocked_domains, undefined);
-    });
-    it("omits empty allowedDomains / blockedDomains arrays from the wire payload", async () => {
-        let capturedBody;
-        const fakeFetch = async (_input, init) => {
-            capturedBody = JSON.parse(init?.body).params;
-            return new Response(JSON.stringify({ result: URL_FETCH_HAPPY_RESULT }), {
-                status: 200,
-                headers: { "content-type": "application/json" },
-            });
-        };
-        const sdk = await makeSdk(fakeFetch);
-        await sdk.compute.invokeUrlFetch({
-            mandateId: "mandate:abc",
-            prompt: "Analyse https://tata.com",
-            allowedDomains: [],
-            blockedDomains: [],
-        });
-        assert.equal(capturedBody?.allowed_domains, undefined);
-        assert.equal(capturedBody?.blocked_domains, undefined);
-    });
-});
-describe("compute.invokeUrlFetch — errors", () => {
-    it("wraps a JSON-RPC error from the proxy as AithosSDKError with the proxy code", async () => {
-        const fakeFetch = async () => new Response(JSON.stringify({
-            error: {
-                code: -32074,
-                message: "web_fetch failed: robots.txt disallows /api/* — fetch refused",
-                data: { detail: "robots_blocked" },
-            },
-        }), { status: 200, headers: { "content-type": "application/json" } });
-        const sdk = await makeSdk(fakeFetch);
-        await assert.rejects(sdk.compute.invokeUrlFetch({
-            mandateId: "mandate:abc",
-            prompt: "Analyse https://tata.com/api/secret",
-        }), (err) => {
-            assert.ok(err instanceof AithosSDKError);
-            assert.equal(err.code, "-32074");
-            assert.match(err.message, /robots\.txt/);
-            return true;
-        });
-    });
-});
-describe("compute.invokeUrlFetch — abort", () => {
-    it("propagates an AbortSignal to fetch", async () => {
-        let receivedSignal;
-        const fakeFetch = async (_input, init) => {
-            receivedSignal = init?.signal;
-            return new Response(JSON.stringify({ result: URL_FETCH_HAPPY_RESULT }), {
-                status: 200,
-                headers: { "content-type": "application/json" },
-            });
-        };
-        const sdk = await makeSdk(fakeFetch);
-        const ac = new AbortController();
-        await sdk.compute.invokeUrlFetch({
-            mandateId: "mandate:abc",
-            prompt: "Analyse https://tata.com",
-            signal: ac.signal,
-        });
-        assert.equal(receivedSignal, ac.signal);
-    });
-});
+// `compute.invokeUrlFetch` was removed in alpha.24 (BREAKING). The
+// Anthropic API-direct + web_fetch tool path is replaced by the
+// `sdk.web.extract` namespace which routes through the deterministic
+// web-extractor Lambda. No tests here anymore.
 //# sourceMappingURL=compute.test.js.map

package/dist/test/endpoints.test.js

@@ -4,7 +4,7 @@
 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";
+import { computeInvokeUrl, resolveEndpoints, walletTopupCheckoutUrl, webInvokeUrl, } from "../src/endpoints.js";
 describe("resolveEndpoints", () => {
     it("returns a fresh copy of the defaults when no override is given", () => {
         const a = resolveEndpoints();
@@ -23,12 +23,14 @@ describe("computeInvokeUrl", () => {
         assert.equal(computeInvokeUrl({
             compute: "https://compute.aithos.be",
             wallet: "https://wallet.aithos.be",
+            web: "https://extract.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",
+            web: "https://extract.aithos.be",
         }), "https://compute.aithos.be/v1/invoke");
     });
 });
@@ -37,7 +39,24 @@ describe("walletTopupCheckoutUrl", () => {
         assert.equal(walletTopupCheckoutUrl({
             compute: "https://compute.aithos.be",
             wallet: "https://wallet.aithos.be",
+            web: "https://extract.aithos.be",
         }), "https://wallet.aithos.be/v1/wallet/topup/checkout");
     });
 });
+describe("webInvokeUrl", () => {
+    it("appends /v1/invoke to the web base", () => {
+        assert.equal(webInvokeUrl({
+            compute: "https://compute.aithos.be",
+            wallet: "https://wallet.aithos.be",
+            web: "https://extract.aithos.be",
+        }), "https://extract.aithos.be/v1/invoke");
+    });
+    it("trims a trailing slash on the web base", () => {
+        assert.equal(webInvokeUrl({
+            compute: "https://compute.aithos.be",
+            wallet: "https://wallet.aithos.be",
+            web: "https://extract.aithos.be/",
+        }), "https://extract.aithos.be/v1/invoke");
+    });
+});
 //# sourceMappingURL=endpoints.test.js.map

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

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