@aithos/sdk 0.1.0-alpha.1

package/LICENSE

@@ -0,0 +1,17 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   Copyright 2026 Mathieu Colla
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,70 @@
+# @aithos/sdk
+
+> High-level developer SDK for building agentic apps on the
+> [Aithos](https://aithos.be) protocol.
+
+`@aithos/sdk` is the recommended entry point for app developers. It wraps
+[`@aithos/protocol-client`](https://github.com/aithos-protocol/protocol-client)
+(low-level cryptography, signed envelopes, DID and mandate primitives) and
+adds the Aithos-hosted endpoints — the **compute proxy** for Bedrock /
+Claude inference and the **wallet** for Stripe credit-pack top-ups — behind
+a single, stable, batteries-included surface.
+
+## Status
+
+Pre-alpha. The public API may change between releases until `0.1.0`. Pin
+exact versions in production.
+
+## Installation
+
+```bash
+npm install @aithos/sdk @aithos/protocol-client
+```
+
+`@aithos/protocol-client` is a peer dependency. Apps that already vend their
+own copy keep using it; the SDK re-exports its primitives so you do not
+need to import both directly in app code.
+
+## Quick start
+
+```ts
+import { AithosSDK, createIdentity } from "@aithos/sdk";
+
+// 1. Get or restore the user's identity (a key pair + DID).
+const identity = await createIdentity();
+
+// 2. Construct the SDK. Endpoints default to the production Aithos hosts;
+//    pass `endpoints` to override (staging, self-host, tests).
+const sdk = new AithosSDK({ identity });
+
+// 3. Top up the wallet via Stripe Checkout.
+const { checkoutUrl } = await sdk.wallet.createTopupSession({
+  packId: "credits-100k",
+  successUrl: "https://my-app.example.com/?topup=success",
+  cancelUrl: "https://my-app.example.com/?topup=cancel",
+});
+window.location.href = checkoutUrl;
+
+// 4. Once the user has credits, invoke Bedrock through the compute proxy.
+const reply = await sdk.compute.invokeBedrock({
+  model: "claude-sonnet-4-6",
+  mandateId: "mandate:…",
+  messages: [{ role: "user", content: "Hello, Aithos!" }],
+});
+
+console.log(reply.content);
+```
+
+## What lives where
+
+| Namespace        | Purpose                                                                                    |
+| ---------------- | ------------------------------------------------------------------------------------------ |
+| `sdk.compute`    | Bedrock invocation through the Aithos compute proxy (signed envelope, wallet enforcement). |
+| `sdk.wallet`     | Stripe Checkout sessions for credit-pack top-ups, balance helpers.                         |
+| `sdk.ethos`      | Ethos-zone composition / parsing — re-exported from `@aithos/protocol-client`.             |
+| `sdk.onboarding` | First-run identity / DID flows — re-exported.                                              |
+| `sdk.mandates`   | Mint / verify mandates — re-exported.                                                      |
+
+## License
+
+Apache-2.0 © 2026 Mathieu Colla. See [LICENSE](./LICENSE).

package/dist/src/compute.d.ts

@@ -0,0 +1,71 @@
+import { type BrowserIdentity } from "@aithos/protocol-client";
+import { type AithosSdkEndpoints } from "./endpoints.js";
+export interface ComputeMessage {
+    readonly role: "user" | "assistant";
+    readonly content: string;
+}
+export interface InvokeBedrockArgs {
+    /** Mandate ID granting this app the right to spend the user's wallet. */
+    readonly mandateId: string;
+    /**
+     * Model id. Today the proxy accepts the canonical Aithos identifiers:
+     *   `claude-sonnet-4-6`, `claude-haiku-4-5`, `claude-opus-4-7`.
+     * The proxy maps these to Bedrock cross-region inference profiles.
+     */
+    readonly model: string;
+    /** Conversation messages (user / assistant turns). */
+    readonly messages: readonly ComputeMessage[];
+    /** Optional system prompt (Bedrock convention — sent as a separate field). */
+    readonly system?: string;
+    /** Hard cap on output tokens for this call. Server further caps by mandate. */
+    readonly maxTokens?: number;
+    /** Sampling temperature. Default model-dependent. */
+    readonly temperature?: number;
+    /** Idempotency key for retries. The SDK generates one if omitted. */
+    readonly idempotencyKey?: string;
+    /** Abort signal to cancel the request. */
+    readonly signal?: AbortSignal;
+}
+export type StopReason = "end_turn" | "max_tokens" | "stop_sequence";
+export interface InvokeBedrockResult {
+    /** Plain text response from the model. */
+    readonly content: string;
+    /** Why the model stopped generating. */
+    readonly stopReason: StopReason;
+    /** Token accounting from the model. */
+    readonly usage: {
+        readonly inputTokens: number;
+        readonly outputTokens: number;
+    };
+    /** Microcredits debited from the user wallet for this call. */
+    readonly creditsCharged: number;
+    /** New wallet balance (microcredits) after debit. */
+    readonly walletBalance: number;
+    /** Audit log id for traceability. */
+    readonly auditId: string;
+}
+export interface ComputeNamespaceDeps {
+    readonly identity: BrowserIdentity;
+    readonly appDid: string;
+    readonly endpoints: AithosSdkEndpoints;
+    readonly fetch: typeof fetch;
+}
+/**
+ * `sdk.compute` namespace. Constructed once by the {@link AithosSDK}
+ * constructor; all calls share the SDK's identity, app DID, and endpoint
+ * configuration.
+ */
+export declare class ComputeNamespace {
+    #private;
+    constructor(deps: ComputeNamespaceDeps);
+    /**
+     * Invoke a Bedrock model through the compute proxy. See
+     * {@link InvokeBedrockArgs} and {@link InvokeBedrockResult}.
+     *
+     * @throws {AithosSDKError} on protocol errors. The `code` field is one of
+     *   `network`, `http`, `empty`, or any code returned by the proxy
+     *   (`quota_exceeded`, `mandate_revoked`, `insufficient_credits`, …).
+     */
+    invokeBedrock(args: InvokeBedrockArgs): Promise<InvokeBedrockResult>;
+}
+//# sourceMappingURL=compute.d.ts.map

package/dist/src/compute.js

@@ -0,0 +1,104 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2026 Mathieu Colla
+// Compute namespace — Bedrock invocation through the Aithos compute proxy.
+//
+// Wraps the JSON-RPC + signed-envelope protocol of `compute.aithos.be`
+// behind an ergonomic method on the SDK. Internally builds a §11 envelope
+// signed with the user's public-sphere key and posts it to
+// `${compute}/v1/invoke`.
+//
+// Server-side guarantees (enforced by the proxy, not by this lib):
+//   - Envelope signature verified against the user's `did.json`.
+//   - Mandate at `mandateId` authorizes `appDid` for this model.
+//   - Wallet balance & per-call / daily / total caps respected.
+//   - Atomic debit on success.
+//   - 90/10 markup split between dev and Aithos.
+//
+// MVP scope: single-shot invocation. Multi-turn agentic loops (with native
+// tool calling on the proxy) will land in a follow-up.
+import { buildSignedEnvelope, } from "@aithos/protocol-client";
+import { computeInvokeUrl, } from "./endpoints.js";
+import { AithosSDKError } from "./types.js";
+/**
+ * `sdk.compute` namespace. Constructed once by the {@link AithosSDK}
+ * constructor; all calls share the SDK's identity, app DID, and endpoint
+ * configuration.
+ */
+export class ComputeNamespace {
+    #deps;
+    constructor(deps) {
+        this.#deps = deps;
+    }
+    /**
+     * Invoke a Bedrock model through the compute proxy. See
+     * {@link InvokeBedrockArgs} and {@link InvokeBedrockResult}.
+     *
+     * @throws {AithosSDKError} on protocol errors. The `code` field is one of
+     *   `network`, `http`, `empty`, or any code returned by the proxy
+     *   (`quota_exceeded`, `mandate_revoked`, `insufficient_credits`, …).
+     */
+    async invokeBedrock(args) {
+        const { identity, appDid, endpoints, fetch: fetchImpl } = this.#deps;
+        const url = computeInvokeUrl(endpoints);
+        const idempotencyKey = args.idempotencyKey ?? generateIdempotencyKey();
+        const params = {
+            app_did: appDid,
+            mandate_id: args.mandateId,
+            model: args.model,
+            messages: args.messages,
+            idempotency_key: idempotencyKey,
+        };
+        if (args.system !== undefined)
+            params.system = args.system;
+        if (args.maxTokens !== undefined)
+            params.max_tokens = args.maxTokens;
+        if (args.temperature !== undefined)
+            params.temperature = args.temperature;
+        const envelope = buildSignedEnvelope({
+            iss: identity.did,
+            aud: url,
+            method: "aithos.compute_invoke",
+            verificationMethod: `${identity.did}#public`,
+            params,
+            signer: identity.public,
+        });
+        let res;
+        try {
+            res = await fetchImpl(url, {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                body: JSON.stringify({
+                    jsonrpc: "2.0",
+                    id: "aithos.compute_invoke",
+                    method: "aithos.compute_invoke",
+                    params: { ...params, _envelope: envelope },
+                }),
+                ...(args.signal ? { signal: args.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 compute proxy");
+        }
+        return body.result;
+    }
+}
+function generateIdempotencyKey() {
+    const bytes = new Uint8Array(16);
+    crypto.getRandomValues(bytes);
+    let hex = "";
+    for (let i = 0; i < bytes.length; i++) {
+        hex += bytes[i].toString(16).padStart(2, "0");
+    }
+    return hex;
+}
+//# sourceMappingURL=compute.js.map

package/dist/src/endpoints.d.ts

@@ -0,0 +1,25 @@
+/** Endpoints owned and resolved by the SDK. */
+export interface AithosSdkEndpoints {
+    /** Compute proxy base URL — Bedrock invocation. Default `https://compute.aithos.be`. */
+    readonly compute: string;
+    /**
+     * Wallet base URL — Stripe top-up Checkout session creation.
+     *
+     * Production target: `https://wallet.aithos.be`. During the alpha we accept
+     * a raw AWS Lambda Function URL; both shapes work because the SDK only
+     * suffixes a fixed path to it.
+     */
+    readonly wallet: string;
+}
+/** Production defaults. */
+export declare const DEFAULT_SDK_ENDPOINTS: AithosSdkEndpoints;
+/** Compose the full compute-invoke URL: `${compute}/v1/invoke`. */
+export declare function computeInvokeUrl(endpoints: AithosSdkEndpoints): string;
+/** Compose the full top-up-checkout URL: `${wallet}/v1/wallet/topup/checkout`. */
+export declare function walletTopupCheckoutUrl(endpoints: AithosSdkEndpoints): string;
+/**
+ * Resolve a partial override on top of the production defaults. Used by the
+ * SDK constructor.
+ */
+export declare function resolveEndpoints(override?: Partial<AithosSdkEndpoints>): AithosSdkEndpoints;
+//# sourceMappingURL=endpoints.d.ts.map

package/dist/src/endpoints.js

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2026 Mathieu Colla
+/** Production defaults. */
+export const DEFAULT_SDK_ENDPOINTS = {
+    compute: "https://compute.aithos.be",
+    wallet: "https://wallet.aithos.be",
+};
+/** Compose the full compute-invoke URL: `${compute}/v1/invoke`. */
+export function computeInvokeUrl(endpoints) {
+    return `${trimSlash(endpoints.compute)}/v1/invoke`;
+}
+/** Compose the full top-up-checkout URL: `${wallet}/v1/wallet/topup/checkout`. */
+export function walletTopupCheckoutUrl(endpoints) {
+    return `${trimSlash(endpoints.wallet)}/v1/wallet/topup/checkout`;
+}
+/**
+ * Resolve a partial override on top of the production defaults. Used by the
+ * SDK constructor.
+ */
+export function resolveEndpoints(override) {
+    if (!override)
+        return { ...DEFAULT_SDK_ENDPOINTS };
+    return { ...DEFAULT_SDK_ENDPOINTS, ...override };
+}
+function trimSlash(url) {
+    return url.endsWith("/") ? url.slice(0, -1) : url;
+}
+//# sourceMappingURL=endpoints.js.map

package/dist/src/ethos.d.ts

@@ -0,0 +1,2 @@
+export { parsePublicZone, type ParsedZone, loadEditSnapshot, publishZoneEdit, publishPublicZoneAsDelegate, publishPrivateZoneAsDelegate, type EditSnapshot, type AddSectionInput, type ModifySectionInput, type PublishEditArgs, type PublishEditResult, addSectionToList, modifySectionInList, deleteSectionFromList, buildSignedFirstEdition, buildSignedNextEdition, type ZoneDoc, type ZoneManifest, type Section, SPHERES, type Sphere, } from "@aithos/protocol-client";
+//# sourceMappingURL=ethos.d.ts.map

package/dist/src/ethos.js

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2026 Mathieu Colla
+// Ethos namespace — re-exports of `@aithos/protocol-client` ethos primitives.
+//
+// The SDK exposes these so app developers don't need a direct dependency on
+// `@aithos/protocol-client` for the common operations: parsing zone
+// markdown, composing zone documents, building signed editions of the
+// user's ethos.
+//
+// The full protocol-client API surface remains available for advanced cases
+// — `import { … } from "@aithos/protocol-client"` is fully supported.
+export { 
+// Zone parser — public-zone markdown → sections.
+parsePublicZone, 
+// Editor — high-level load / mutate / publish flow.
+loadEditSnapshot, publishZoneEdit, publishPublicZoneAsDelegate, publishPrivateZoneAsDelegate, addSectionToList, modifySectionInList, deleteSectionFromList, 
+// Manifest builders — sign editions of the public, circle, or self zones.
+buildSignedFirstEdition, buildSignedNextEdition, 
+// Sphere taxonomy — "public" | "circle" | "self".
+SPHERES, } from "@aithos/protocol-client";
+//# sourceMappingURL=ethos.js.map

package/dist/src/index.d.ts

@@ -0,0 +1,15 @@
+export declare const VERSION = "0.1.0-alpha.0";
+export { AithosSDK } from "./sdk.js";
+export type { AithosSDKConfig } from "./types.js";
+export { AithosSDKError } from "./types.js";
+export type { AithosSdkEndpoints } from "./endpoints.js";
+export { DEFAULT_SDK_ENDPOINTS } from "./endpoints.js";
+export type { ComputeMessage, InvokeBedrockArgs, InvokeBedrockResult, StopReason, } from "./compute.js";
+export { ComputeNamespace } from "./compute.js";
+export type { CreditPackId, CreateTopupSessionArgs, CreateTopupSessionResult, } from "./wallet.js";
+export { WalletNamespace } from "./wallet.js";
+export * as ethos from "./ethos.js";
+export * as onboarding from "./onboarding.js";
+export * as mandates from "./mandates.js";
+export { createBrowserIdentity, browserIdentityFromStored, type BrowserIdentity, } from "@aithos/protocol-client";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.js

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2026 Mathieu Colla
+// @aithos/sdk — public API surface.
+//
+// Two entry points:
+//
+//   1. The {@link AithosSDK} class — the recommended ergonomic surface.
+//      Construct once with the user's identity and the app DID, then call
+//      `sdk.compute.invokeBedrock(...)`, `sdk.wallet.createTopupSession(...)`,
+//      etc. through namespaced methods.
+//
+//   2. Direct named exports — for callers who only need a primitive (e.g.
+//      `createBrowserIdentity` during onboarding before the SDK exists).
+//      These are re-exports of `@aithos/protocol-client`; identical to
+//      what protocol-client itself exposes.
+//
+// Public types specific to the SDK (`AithosSDKConfig`, `AithosSDKError`)
+// are exported from here. Endpoint config (`AithosSdkEndpoints`,
+// `DEFAULT_SDK_ENDPOINTS`) likewise.
+export const VERSION = "0.1.0-alpha.0";
+export { AithosSDK } from "./sdk.js";
+export { AithosSDKError } from "./types.js";
+export { DEFAULT_SDK_ENDPOINTS } from "./endpoints.js";
+export { ComputeNamespace } from "./compute.js";
+export { WalletNamespace } from "./wallet.js";
+// Re-exports under stable namespace modules. Apps may also import these
+// directly via `@aithos/protocol-client`; the SDK simply curates them.
+export * as ethos from "./ethos.js";
+export * as onboarding from "./onboarding.js";
+export * as mandates from "./mandates.js";
+// Convenience direct re-exports of the most-used identity primitives so the
+// quick-start example doesn't need a namespace import.
+export { createBrowserIdentity, browserIdentityFromStored, } from "@aithos/protocol-client";
+//# sourceMappingURL=index.js.map

package/dist/src/mandates.d.ts

@@ -0,0 +1,2 @@
+export { mintDelegateBundle, signAndPublishMandate, MintError, type MintArgs, type MintResult, type SignAndPublishMandateArgs, DEFAULT_READ_SCOPES, TTL_PRESETS, } from "@aithos/protocol-client";
+//# sourceMappingURL=mandates.d.ts.map

package/dist/src/mandates.js

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2026 Mathieu Colla
+// Mandates namespace — re-exports of mandate mint/sign primitives.
+//
+// A mandate is a signed delegation bundle that grants an app DID the right
+// to act on the user's behalf within a scoped set of operations (read
+// scopes, compute spend cap, TTL). Mandates are required by the compute
+// proxy on every Bedrock call.
+//
+// See `@aithos/protocol-client/src/mandate-mint.ts` for the canonical
+// implementation; this namespace re-exports the public surface verbatim.
+export { mintDelegateBundle, signAndPublishMandate, MintError, DEFAULT_READ_SCOPES, TTL_PRESETS, } from "@aithos/protocol-client";
+//# sourceMappingURL=mandates.js.map

package/dist/src/onboarding.d.ts

@@ -0,0 +1,2 @@
+export { runOnboarding, OnboardError, type OnboardArgs, type OnboardResult, createBrowserIdentity, browserIdentityFromStored, signedDidDocument, sphereDidUrl, type BrowserIdentity, type DidDocumentProof, type KeyAgreementMethod, type VerificationMethod, } from "@aithos/protocol-client";
+//# sourceMappingURL=onboarding.d.ts.map

package/dist/src/onboarding.js

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2026 Mathieu Colla
+// Onboarding namespace — first-run identity and DID-document publishing.
+//
+// Re-exports of `@aithos/protocol-client` so app developers can drive a
+// new-user flow without pulling protocol-client directly:
+//
+//   const { identity, edition } = await sdk.onboarding.runOnboarding({ ... });
+export { runOnboarding, OnboardError, 
+// Identity primitives — used to seed and restore the user's keys/DID.
+createBrowserIdentity, browserIdentityFromStored, signedDidDocument, sphereDidUrl, } from "@aithos/protocol-client";
+//# sourceMappingURL=onboarding.js.map

package/dist/src/sdk.d.ts

@@ -0,0 +1,18 @@
+import { ComputeNamespace } from "./compute.js";
+import { type AithosSdkEndpoints } from "./endpoints.js";
+import { WalletNamespace } from "./wallet.js";
+import type { AithosSDKConfig } from "./types.js";
+export declare class AithosSDK {
+    /** Resolved endpoint configuration (defaults + caller overrides). */
+    readonly endpoints: AithosSdkEndpoints;
+    /** Application DID (as declared in mandates). */
+    readonly appDid: string;
+    /** User DID (derived from `config.identity`). */
+    readonly userDid: string;
+    /** Compute proxy namespace — Bedrock invocation. */
+    readonly compute: ComputeNamespace;
+    /** Wallet namespace — Stripe top-up. */
+    readonly wallet: WalletNamespace;
+    constructor(config: AithosSDKConfig);
+}
+//# sourceMappingURL=sdk.d.ts.map

package/dist/src/sdk.js

@@ -0,0 +1,56 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2026 Mathieu Colla
+// AithosSDK — top-level developer surface.
+//
+// One construction, namespaced methods. The SDK takes the user's identity
+// (a `BrowserIdentity` from `@aithos/protocol-client`) and the calling
+// app's DID, then exposes:
+//
+//   sdk.compute  — Bedrock invocation through the compute proxy.
+//   sdk.wallet   — Stripe Checkout for credit-pack top-ups.
+//   sdk.ethos    — re-exports from protocol-client (zone editor, signers).
+//   sdk.onboarding / sdk.mandates — likewise.
+//
+// The class is intentionally thin: the heavy lifting lives in dedicated
+// namespace classes (`ComputeNamespace`, `WalletNamespace`) so each can be
+// tested in isolation with a mock fetch and so an advanced caller could
+// instantiate just one of them if needed.
+import { ComputeNamespace } from "./compute.js";
+import { resolveEndpoints } from "./endpoints.js";
+import { WalletNamespace } from "./wallet.js";
+export class AithosSDK {
+    /** Resolved endpoint configuration (defaults + caller overrides). */
+    endpoints;
+    /** Application DID (as declared in mandates). */
+    appDid;
+    /** User DID (derived from `config.identity`). */
+    userDid;
+    /** Compute proxy namespace — Bedrock invocation. */
+    compute;
+    /** Wallet namespace — Stripe top-up. */
+    wallet;
+    constructor(config) {
+        if (!config.identity) {
+            throw new TypeError("AithosSDK: config.identity is required");
+        }
+        if (!config.appDid || typeof config.appDid !== "string") {
+            throw new TypeError("AithosSDK: config.appDid is required (string)");
+        }
+        this.endpoints = resolveEndpoints(config.endpoints);
+        this.appDid = config.appDid;
+        this.userDid = config.identity.did;
+        const fetchImpl = config.fetch ?? globalThis.fetch.bind(globalThis);
+        this.compute = new ComputeNamespace({
+            identity: config.identity,
+            appDid: config.appDid,
+            endpoints: this.endpoints,
+            fetch: fetchImpl,
+        });
+        this.wallet = new WalletNamespace({
+            userDid: config.identity.did,
+            endpoints: this.endpoints,
+            fetch: fetchImpl,
+        });
+    }
+}
+//# sourceMappingURL=sdk.js.map

package/dist/src/types.d.ts

@@ -0,0 +1,40 @@
+import type { BrowserIdentity } from "@aithos/protocol-client";
+import type { AithosSdkEndpoints } from "./endpoints.js";
+/**
+ * Construction options for {@link AithosSDK}.
+ */
+export interface AithosSDKConfig {
+    /** User identity (Ed25519/X25519 keypairs + DID). */
+    readonly identity: BrowserIdentity;
+    /**
+     * Application DID. Identifies the calling app in mandates, audit logs,
+     * billing splits. Issued at developer onboarding (will be self-service
+     * before 0.1.0 stable).
+     */
+    readonly appDid: string;
+    /**
+     * Optional endpoint overrides. Production defaults point at the Aithos
+     * infrastructure; pass overrides for staging, self-hosting, tests.
+     */
+    readonly endpoints?: Partial<AithosSdkEndpoints>;
+    /**
+     * Optional fetch implementation. Defaults to the global `fetch`. Used by
+     * tests to inject a mock without monkeypatching globals.
+     */
+    readonly fetch?: typeof fetch;
+}
+/**
+ * SDK-level error class. The `code` field is a stable string suitable for
+ * `switch` statements; the underlying HTTP status (when applicable) is in
+ * `status`.
+ */
+export declare class AithosSDKError extends Error {
+    readonly code: string;
+    readonly status: number | undefined;
+    readonly data: Record<string, unknown> | undefined;
+    constructor(code: string, message: string, options?: {
+        status?: number;
+        data?: Record<string, unknown>;
+    });
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/src/types.js

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2026 Mathieu Colla
+/**
+ * SDK-level error class. The `code` field is a stable string suitable for
+ * `switch` statements; the underlying HTTP status (when applicable) is in
+ * `status`.
+ */
+export class AithosSDKError extends Error {
+    code;
+    status;
+    data;
+    constructor(code, message, options) {
+        super(message);
+        this.name = "AithosSDKError";
+        this.code = code;
+        this.status = options?.status;
+        this.data = options?.data;
+    }
+}
+//# sourceMappingURL=types.js.map

package/dist/src/wallet.d.ts

@@ -0,0 +1,49 @@
+import { type AithosSdkEndpoints } from "./endpoints.js";
+/**
+ * Canonical credit-pack identifiers. Pricing and microcredit amounts are
+ * authoritative server-side; the SDK only forwards the pack id.
+ *
+ *   - `credits-100k` — 100K microcredits (S, ~5 €)
+ *   - `credits-1m`   —   1M microcredits + 10 % bonus (M, ~45 €)
+ *   - `credits-5m`   —   5M microcredits + 20 % bonus (L, ~200 €)
+ */
+export type CreditPackId = "credits-100k" | "credits-1m" | "credits-5m";
+export interface CreateTopupSessionArgs {
+    /** Pack to purchase. */
+    readonly packId: CreditPackId;
+    /** Where Stripe redirects after a successful payment. */
+    readonly successUrl: string;
+    /** Where Stripe redirects if the user cancels. */
+    readonly cancelUrl: string;
+    /** Abort signal to cancel the request. */
+    readonly signal?: AbortSignal;
+}
+export interface CreateTopupSessionResult {
+    /** Hosted Stripe Checkout URL — redirect the user there. */
+    readonly checkoutUrl: string;
+    /** Stripe Checkout session id (for diagnostics). */
+    readonly sessionId: string;
+}
+export interface WalletNamespaceDeps {
+    readonly userDid: string;
+    readonly endpoints: AithosSdkEndpoints;
+    readonly fetch: typeof fetch;
+}
+/**
+ * `sdk.wallet` namespace.
+ */
+export declare class WalletNamespace {
+    #private;
+    constructor(deps: WalletNamespaceDeps);
+    /**
+     * Create a Stripe Checkout session for a credit-pack purchase. Returns the
+     * hosted URL — the caller is responsible for redirecting the user (e.g.
+     * `window.location.href = result.checkoutUrl`).
+     *
+     * On success, the Stripe webhook will credit `userDid`'s wallet once the
+     * payment clears. Wallet balances are shared across all Aithos apps that
+     * use the same DID.
+     */
+    createTopupSession(args: CreateTopupSessionArgs): Promise<CreateTopupSessionResult>;
+}
+//# sourceMappingURL=wallet.d.ts.map

package/dist/src/wallet.js

@@ -0,0 +1,71 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2026 Mathieu Colla
+// Wallet namespace — Stripe Checkout for credit-pack top-ups.
+//
+// Posts to `${wallet}/v1/wallet/topup/checkout`. The Lambda creates a
+// Stripe Checkout session bound to the user's DID via `metadata`, returns
+// the hosted URL. The frontend then redirects the user. Stripe webhook
+// (server-side) credits the wallet on `checkout.session.completed`.
+//
+// v0 scope: no envelope verify on the checkout endpoint — the link is
+// single-use and metadata-bound to `user_did`. Anyone creating a session
+// for someone else's DID would just gift them credits, no value to an
+// attacker. Envelope-verify gets added in a follow-up if abuse appears.
+import { walletTopupCheckoutUrl, } from "./endpoints.js";
+import { AithosSDKError } from "./types.js";
+/**
+ * `sdk.wallet` namespace.
+ */
+export class WalletNamespace {
+    #deps;
+    constructor(deps) {
+        this.#deps = deps;
+    }
+    /**
+     * Create a Stripe Checkout session for a credit-pack purchase. Returns the
+     * hosted URL — the caller is responsible for redirecting the user (e.g.
+     * `window.location.href = result.checkoutUrl`).
+     *
+     * On success, the Stripe webhook will credit `userDid`'s wallet once the
+     * payment clears. Wallet balances are shared across all Aithos apps that
+     * use the same DID.
+     */
+    async createTopupSession(args) {
+        const { userDid, endpoints, fetch: fetchImpl } = this.#deps;
+        const url = walletTopupCheckoutUrl(endpoints);
+        let res;
+        try {
+            res = await fetchImpl(url, {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                body: JSON.stringify({
+                    user_did: userDid,
+                    pack_id: args.packId,
+                    success_url: args.successUrl,
+                    cancel_url: args.cancelUrl,
+                }),
+                ...(args.signal ? { signal: args.signal } : {}),
+            });
+        }
+        catch (e) {
+            throw new AithosSDKError("network", e.message);
+        }
+        let body;
+        try {
+            body = await res.json();
+        }
+        catch {
+            throw new AithosSDKError("http", `HTTP ${res.status} ${res.statusText} — non-JSON response`, { status: res.status });
+        }
+        if (!res.ok) {
+            const err = body;
+            throw new AithosSDKError(err.error ?? "http", err.detail ?? `HTTP ${res.status} ${res.statusText}`, { status: res.status });
+        }
+        const ok = body;
+        if (typeof ok.checkout_url !== "string" || typeof ok.session_id !== "string") {
+            throw new AithosSDKError("empty", "wallet response missing checkout_url or session_id");
+        }
+        return { checkoutUrl: ok.checkout_url, sessionId: ok.session_id };
+    }
+}
+//# sourceMappingURL=wallet.js.map

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

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

package/dist/test/compute.test.js

@@ -0,0 +1,179 @@
+// 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

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

package/dist/test/endpoints.test.js

@@ -0,0 +1,43 @@
+// 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

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

package/dist/test/sdk.test.js

@@ -0,0 +1,86 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2026 Mathieu Colla
+// Smoke tests for the AithosSDK construction surface.
+//
+// Runtime tests of `compute.invokeBedrock` and `wallet.createTopupSession`
+// require either a running compute proxy or a more elaborate fetch mock
+// pattern; we land them in a follow-up commit alongside the rest of Phase 4
+// (mock-fetch unit tests for both namespaces).
+import { strict as assert } from "node:assert";
+import { describe, it } from "node:test";
+import { AithosSDK, AithosSDKError, DEFAULT_SDK_ENDPOINTS, VERSION, } from "../src/index.js";
+// We can't easily mint a real BrowserIdentity in a synchronous unit test
+// without crypto setup; the constructor only reads `.did` from it, so a
+// minimal stub is enough for the construction-surface tests below.
+function fakeIdentity(did) {
+    return { did };
+}
+describe("VERSION", () => {
+    it("is a non-empty semver-ish string", () => {
+        assert.equal(typeof VERSION, "string");
+        assert.match(VERSION, /^\d+\.\d+\.\d+/);
+    });
+});
+describe("DEFAULT_SDK_ENDPOINTS", () => {
+    it("points at the production Aithos hosts", () => {
+        assert.equal(DEFAULT_SDK_ENDPOINTS.compute, "https://compute.aithos.be");
+        assert.equal(DEFAULT_SDK_ENDPOINTS.wallet, "https://wallet.aithos.be");
+    });
+});
+describe("AithosSDK constructor", () => {
+    const id = fakeIdentity("did:aithos:smoke");
+    const appDid = "did:aithos:app:smoke";
+    it("requires an identity", () => {
+        assert.throws(() => 
+        // @ts-expect-error: deliberately passing an invalid config
+        new AithosSDK({ appDid }), /identity/);
+    });
+    it("requires an appDid", () => {
+        assert.throws(() => 
+        // @ts-expect-error: deliberately passing an invalid config
+        new AithosSDK({ identity: id }), /appDid/);
+    });
+    it("exposes endpoints, appDid, userDid", () => {
+        const sdk = new AithosSDK({ identity: id, appDid });
+        assert.equal(sdk.appDid, appDid);
+        assert.equal(sdk.userDid, "did:aithos:smoke");
+        assert.equal(sdk.endpoints.compute, DEFAULT_SDK_ENDPOINTS.compute);
+        assert.equal(sdk.endpoints.wallet, DEFAULT_SDK_ENDPOINTS.wallet);
+    });
+    it("merges endpoint overrides on top of defaults", () => {
+        const sdk = new AithosSDK({
+            identity: id,
+            appDid,
+            endpoints: { wallet: "https://staging-wallet.aithos.be" },
+        });
+        assert.equal(sdk.endpoints.compute, DEFAULT_SDK_ENDPOINTS.compute);
+        assert.equal(sdk.endpoints.wallet, "https://staging-wallet.aithos.be");
+    });
+    it("trims trailing slashes on endpoint URLs at compose time", async () => {
+        // Inject a fetch that captures the URL the SDK chose.
+        let capturedUrl;
+        const fakeFetch = async (input) => {
+            capturedUrl = typeof input === "string" ? input : input.toString();
+            // Reject so we don't have to construct a full happy-path response.
+            throw new Error("captured");
+        };
+        const sdk = new AithosSDK({
+            identity: id,
+            appDid,
+            endpoints: { wallet: "https://wallet.example.com/" }, // trailing slash
+            fetch: fakeFetch,
+        });
+        await assert.rejects(sdk.wallet.createTopupSession({
+            packId: "credits-100k",
+            successUrl: "https://app.example.com/?ok",
+            cancelUrl: "https://app.example.com/?ko",
+        }), AithosSDKError);
+        assert.equal(capturedUrl, "https://wallet.example.com/v1/wallet/topup/checkout");
+    });
+    it("exposes namespaces compute, wallet", () => {
+        const sdk = new AithosSDK({ identity: id, appDid });
+        assert.equal(typeof sdk.compute.invokeBedrock, "function");
+        assert.equal(typeof sdk.wallet.createTopupSession, "function");
+    });
+});
+//# sourceMappingURL=sdk.test.js.map

package/dist/test/wallet.test.d.ts

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

package/dist/test/wallet.test.js

@@ -0,0 +1,110 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2026 Mathieu Colla
+// Unit tests for sdk.wallet.createTopupSession with a mock fetch.
+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: { wallet: "https://wallet.example.test" },
+        fetch: fetchImpl,
+    });
+}
+describe("wallet.createTopupSession — happy path", () => {
+    it("posts user_did + pack_id + urls and returns the hosted URL", async () => {
+        let capturedUrl;
+        let capturedBody;
+        const fakeFetch = async (input, init) => {
+            capturedUrl = typeof input === "string" ? input : input.toString();
+            capturedBody = JSON.parse(init?.body);
+            return new Response(JSON.stringify({
+                checkout_url: "https://checkout.stripe.com/c/pay/cs_test_xyz",
+                session_id: "cs_test_xyz",
+            }), { status: 200, headers: { "content-type": "application/json" } });
+        };
+        const sdk = makeSdk(fakeFetch);
+        const out = await sdk.wallet.createTopupSession({
+            packId: "credits-1m",
+            successUrl: "https://app.example.com/?topup=success",
+            cancelUrl: "https://app.example.com/?topup=cancel",
+        });
+        assert.equal(out.checkoutUrl, "https://checkout.stripe.com/c/pay/cs_test_xyz");
+        assert.equal(out.sessionId, "cs_test_xyz");
+        assert.equal(capturedUrl, "https://wallet.example.test/v1/wallet/topup/checkout");
+        assert.equal(capturedBody?.user_did, sdk.userDid);
+        assert.equal(capturedBody?.pack_id, "credits-1m");
+        assert.equal(capturedBody?.success_url, "https://app.example.com/?topup=success");
+        assert.equal(capturedBody?.cancel_url, "https://app.example.com/?topup=cancel");
+    });
+});
+describe("wallet.createTopupSession — errors", () => {
+    it("wraps a network failure as AithosSDKError(code='network')", async () => {
+        const fakeFetch = async () => {
+            throw new TypeError("Failed to fetch");
+        };
+        const sdk = makeSdk(fakeFetch);
+        await assert.rejects(sdk.wallet.createTopupSession({
+            packId: "credits-100k",
+            successUrl: "https://app.example.com/?ok",
+            cancelUrl: "https://app.example.com/?ko",
+        }), (err) => {
+            assert.ok(err instanceof AithosSDKError);
+            assert.equal(err.code, "network");
+            return true;
+        });
+    });
+    it("surfaces the proxy's structured error (error/detail) on a 4xx", async () => {
+        const fakeFetch = async () => new Response(JSON.stringify({ error: "unknown_pack", pack_id: "credits-9999" }), { status: 400, headers: { "content-type": "application/json" } });
+        const sdk = makeSdk(fakeFetch);
+        await assert.rejects(sdk.wallet.createTopupSession({
+            // @ts-expect-error: deliberately invalid pack id
+            packId: "credits-9999",
+            successUrl: "https://app.example.com/?ok",
+            cancelUrl: "https://app.example.com/?ko",
+        }), (err) => {
+            assert.ok(err instanceof AithosSDKError);
+            assert.equal(err.code, "unknown_pack");
+            assert.equal(err.status, 400);
+            return true;
+        });
+    });
+    it("rejects a non-JSON response as AithosSDKError(code='http')", async () => {
+        const fakeFetch = async () => new Response("<html>500</html>", {
+            status: 500,
+            headers: { "content-type": "text/html" },
+        });
+        const sdk = makeSdk(fakeFetch);
+        await assert.rejects(sdk.wallet.createTopupSession({
+            packId: "credits-100k",
+            successUrl: "https://app.example.com/?ok",
+            cancelUrl: "https://app.example.com/?ko",
+        }), (err) => {
+            assert.ok(err instanceof AithosSDKError);
+            assert.equal(err.code, "http");
+            assert.equal(err.status, 500);
+            return true;
+        });
+    });
+    it("rejects a 200 with missing fields 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.wallet.createTopupSession({
+            packId: "credits-100k",
+            successUrl: "https://app.example.com/?ok",
+            cancelUrl: "https://app.example.com/?ko",
+        }), (err) => {
+            assert.ok(err instanceof AithosSDKError);
+            assert.equal(err.code, "empty");
+            return true;
+        });
+    });
+});
+//# sourceMappingURL=wallet.test.js.map

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "@aithos/sdk",
+  "version": "0.1.0-alpha.1",
+  "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",
+    "sdk",
+    "agent",
+    "bedrock",
+    "claude",
+    "wallet",
+    "stripe",
+    "did",
+    "ed25519"
+  ],
+  "license": "Apache-2.0",
+  "author": "Aithos",
+  "homepage": "https://aithos.be",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/aithos-protocol/aithos-sdk.git"
+  },
+  "bugs": {
+    "url": "https://github.com/aithos-protocol/aithos-sdk/issues"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "import": "./dist/src/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/src/index.js",
+  "types": "./dist/src/index.d.ts",
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "build:test": "tsc -p tsconfig.test.json",
+    "check-types": "tsc --noEmit && tsc -p tsconfig.test.json --noEmit",
+    "test": "npm run clean && npm run build && npm run build:test && cd dist && node --test",
+    "test:watch": "cd dist && node --test --watch",
+    "clean": "rm -rf dist",
+    "prepublishOnly": "npm run clean && npm run build && npm test"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "peerDependencies": {
+    "@aithos/protocol-client": ">=0.1.0-alpha.7 <0.2.0"
+  },
+  "devDependencies": {
+    "@aithos/protocol-client": "^0.1.0-alpha.7",
+    "@types/node": "^24.12.2",
+    "typescript": "^5.9.2"
+  },
+  "publishConfig": {
+    "access": "public",
+    "tag": "alpha"
+  }
+}