@multiagency/sdk 0.3.1

package/dist/contract/client.d.ts

@@ -0,0 +1,347 @@
+import { z } from "zod";
+import { reportCommand } from "../compensation-contract.js";
+import { agentConnectionIssue } from "./agent-connection.js";
+import { payeeWorkOrderRequest } from "./payee.js";
+export declare const capabilities: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    product: z.ZodLiteral<"invoices">;
+    capabilities: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export declare const signInChallenge: z.ZodObject<{
+    message: z.ZodString;
+    recipient: z.ZodString;
+    nonce: z.ZodString;
+}, z.core.$strip>;
+export declare const signIn: z.ZodObject<{
+    accountId: z.ZodString;
+    publicKey: z.ZodString;
+    signature: z.ZodString;
+    nonce: z.ZodString;
+    callbackUrls: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+/** The caller's retained identity for a mutation. The client never mints or replaces one. */
+export type Identity = {
+    submission: string;
+} | {
+    invoiceId: string;
+} | {
+    workOrderId: string;
+} | {
+    commandId: string;
+    id: string;
+    expectedVersion: number;
+};
+/**
+ * `session` (401) and `forbidden` (403) stay distinct: a refusal is not proof that the session expired.
+ * `unknown`: a mutation was sent and its outcome is not known. Keep the identity and draft, read the
+ * existing record, and never send a replacement. `unavailable`: a read failed; reading again is safe.
+ */
+export type Failure = {
+    ok: false;
+    kind: "session";
+    status: 401;
+    error: string;
+} | {
+    ok: false;
+    kind: "forbidden";
+    status: 403;
+    error: string;
+} | {
+    ok: false;
+    kind: "refused";
+    status: number;
+    error: string;
+    code?: string;
+} | {
+    ok: false;
+    kind: "unavailable";
+} | {
+    ok: false;
+    kind: "unknown";
+    identity: Identity;
+};
+export type Result<T> = {
+    ok: true;
+    value: T;
+} | Failure;
+type Fetch = (input: string, init: RequestInit) => Promise<Response>;
+/**
+ * Typed payee routes relative to an instance base (`""` or `/i/own-<24 hex>`). Same-origin in a browser; no retries.
+ * With `token` (an agent connection, `tac_…`) the client runs outside a browser: `base` is the entry's absolute URL, the
+ * token is sent as a bearer and no cookie is sent. Only the connection's permitted routes answer; others are `forbidden`.
+ */
+export declare function payeeClient({ base, fetch: send, token }?: {
+    base?: string;
+    fetch?: Fetch;
+    token?: string;
+}): {
+    capabilities: () => Promise<Result<{
+        version: 1;
+        product: "invoices";
+        capabilities: string[];
+    }>>;
+    session: () => Promise<Result<{
+        account: string | null;
+        agreed: boolean;
+    }>>;
+    signInChallenge: () => Promise<Result<{
+        message: string;
+        recipient: string;
+        nonce: string;
+    }>>;
+    signIn: (input: z.infer<typeof signIn>) => Promise<Result<{
+        account: string;
+        agreed?: boolean | undefined;
+    }>>;
+    signOut: () => Promise<Result<{
+        account: null;
+    }>>;
+    invoices: () => Promise<Result<{
+        invoices: {
+            id: string;
+            amount: string | null;
+            note: string;
+            filedAt: string;
+            status: "busy" | "failed" | "needs_agreement" | "needs_review" | "paid" | "paying" | "prepared" | "refused" | "unknown" | "waiting";
+            revisionConflict: boolean;
+        }[];
+        agreements: {
+            id: string;
+            origin: "owner" | "payee";
+            amount: string;
+            note: string;
+            submission?: string | undefined;
+            terms?: {
+                maxAmount: string;
+                until: string;
+            } | undefined;
+            status: "agreed" | "declined" | "filed" | "proposed" | "requested";
+            at: string;
+        }[];
+        agreed: boolean;
+    }>>;
+    submitInvoice: (input: {
+        submission: string;
+        amount: string;
+        note: string;
+    }) => Promise<Result<{
+        id: string;
+        status: "busy" | "failed" | "needs_agreement" | "needs_review" | "paid" | "paying" | "prepared" | "refused" | "unknown" | "waiting";
+        revisionConflict?: boolean | undefined;
+    } | {
+        id: string;
+        status: "agreed" | "busy" | "declined" | "filed" | "proposed" | "requested";
+    }>>;
+    continueInvoice: (invoiceId: string) => Promise<Result<{
+        id: string;
+        status: "busy" | "failed" | "needs_agreement" | "needs_review" | "paid" | "paying" | "prepared" | "refused" | "unknown" | "waiting";
+        revisionConflict?: boolean | undefined;
+    } | {
+        id: string;
+        status: "agreed" | "busy" | "declined" | "filed" | "proposed" | "requested";
+    }>>;
+    workOrders: () => Promise<Result<{
+        orders: {
+            id: string;
+            amount: string;
+            note: string;
+            until: string;
+            createdAt: string;
+        }[];
+    }>>;
+    workOrder: (id: string) => Promise<Result<{
+        id: string;
+        amount: string;
+        note: string;
+        until: string;
+        createdAt: string;
+        invoice: {
+            id: string;
+            amount: string | null;
+            note: string;
+            filedAt: string;
+            status: "busy" | "failed" | "needs_agreement" | "needs_review" | "paid" | "paying" | "prepared" | "refused" | "unknown" | "waiting";
+            revisionConflict: boolean;
+        } | null;
+        ready: boolean;
+        unavailable: boolean;
+    }>>;
+    fileWorkOrder: (id: string) => Promise<Result<{
+        id: string;
+        status: "busy" | "failed" | "needs_agreement" | "needs_review" | "paid" | "paying" | "prepared" | "refused" | "unknown" | "waiting";
+        revisionConflict?: boolean | undefined;
+    } | {
+        id: string;
+        status: "agreed" | "busy" | "declined" | "filed" | "proposed" | "requested";
+    }>>;
+    requestWorkOrder: (input: z.infer<typeof payeeWorkOrderRequest>) => Promise<Result<{
+        id: string;
+        status: "requested";
+    }>>;
+    compensationSession: () => Promise<Result<{
+        account: string | null;
+    }>>;
+    compensationSignIn: (input: z.infer<typeof signIn>) => Promise<Result<{
+        account: string;
+        agreed?: boolean | undefined;
+    }>>;
+    compensation: () => Promise<Result<{
+        account: string;
+        agreements: {
+            id: string;
+            version: number;
+            terms: {
+                payee: string;
+                title: string;
+                document: string;
+                signedOn: string;
+                start: string;
+                end: string;
+                ceiling: string;
+                openingApproved: string;
+                scope: string;
+            };
+            recordedBy: string;
+            at: string;
+            approved: string;
+            remaining: string;
+        }[];
+        requests: {
+            id: string;
+            version: number;
+            payee: string;
+            agreementVersion: number;
+            report: {
+                agreementId: string;
+                amount?: string | undefined;
+                start: string;
+                end: string;
+                contributions: string;
+                assessment: string;
+                evidence: string[];
+            };
+            state: "approved" | "changes_requested" | "declined" | "draft" | "submitted";
+            approvedAmount?: string | undefined;
+            feedback: string;
+            reviewedBy: string | null;
+            at: string;
+            payment: {
+                mode: "isolated" | "shared";
+                id: string;
+                until?: string | undefined;
+            } | null;
+        }[];
+        history: {
+            sequence: number;
+            actor: string;
+            record: {
+                id: string;
+                version: number;
+                payee: string;
+                agreementVersion: number;
+                report: {
+                    agreementId: string;
+                    amount?: string | undefined;
+                    start: string;
+                    end: string;
+                    contributions: string;
+                    assessment: string;
+                    evidence: string[];
+                };
+                state: "approved" | "changes_requested" | "declined" | "draft" | "submitted";
+                approvedAmount?: string | undefined;
+                feedback: string;
+                reviewedBy: string | null;
+                at: string;
+                payment: {
+                    mode: "isolated" | "shared";
+                    id: string;
+                    until?: string | undefined;
+                } | null;
+            } | {
+                id: string;
+                version: number;
+                terms: {
+                    payee: string;
+                    title: string;
+                    document: string;
+                    signedOn: string;
+                    start: string;
+                    end: string;
+                    ceiling: string;
+                    openingApproved: string;
+                    scope: string;
+                };
+                recordedBy: string;
+                at: string;
+            };
+        }[];
+        payments: {
+            requestId: string;
+            id: string;
+            status: string;
+        }[];
+    }>>;
+    submitReport: (command: z.infer<typeof reportCommand>) => Promise<Result<{
+        id: string;
+        version: number;
+        payee: string;
+        agreementVersion: number;
+        report: {
+            agreementId: string;
+            amount?: string | undefined;
+            start: string;
+            end: string;
+            contributions: string;
+            assessment: string;
+            evidence: string[];
+        };
+        state: "approved" | "changes_requested" | "declined" | "draft" | "submitted";
+        approvedAmount?: string | undefined;
+        feedback: string;
+        reviewedBy: string | null;
+        at: string;
+        payment: {
+            mode: "isolated" | "shared";
+            id: string;
+            until?: string | undefined;
+        } | null;
+    }>>;
+    agentConnections: () => Promise<Result<{
+        connections: {
+            id: string;
+            label: string;
+            role: "payee";
+            permissions: ("compensation.read" | "compensation.submit")[];
+            host: string;
+            instance: string;
+            account: string;
+            agentId: string;
+            createdAt: string;
+            expiresAt: string;
+            revoked: boolean;
+        }[];
+    }>>;
+    /** A lost answer is `unavailable`: a started connection is not a money action, and an orphan is listed and revocable. */
+    startAgentConnection: (input: z.input<typeof agentConnectionIssue>) => Promise<Result<{
+        connection: {
+            id: string;
+            label: string;
+            role: "payee";
+            permissions: ("compensation.read" | "compensation.submit")[];
+            host: string;
+            instance: string;
+            account: string;
+            agentId: string;
+            createdAt: string;
+            expiresAt: string;
+            revoked: boolean;
+        };
+        token: string;
+    }>>;
+    revokeAgentConnection: (id: string) => Promise<Result<{
+        revoked: true;
+    }>>;
+};
+export type PayeeClient = ReturnType<typeof payeeClient>;
+export {};

package/dist/contract/client.js

@@ -0,0 +1,81 @@
+import { z } from "zod";
+import { requestRecord, reportCommand } from "../compensation-contract.js";
+import { payeeContract } from "../payee-contract.js";
+import { agentConnectionIssue, agentConnectionList, agentConnectionRevoked, agentConnectionStarted } from "./agent-connection.js";
+import { compensationSession, errorBody, fileResult, invoicesView, publicWorkOrder, session, signInResult, signOutResult, payeeCompensationView, workOrderList, payeeWorkOrderRequest, workOrderRequestResult } from "./payee.js";
+export const capabilities = z.object({ version: z.literal(payeeContract.version), product: z.literal(payeeContract.product), capabilities: z.array(z.string()) });
+export const signInChallenge = z.object({ message: z.string(), recipient: z.string(), nonce: z.string() });
+export const signIn = z.object({ accountId: z.string(), publicKey: z.string(), signature: z.string(), nonce: z.string(), callbackUrls: z.array(z.string()).max(3).optional() });
+/**
+ * Typed payee routes relative to an instance base (`""` or `/i/own-<24 hex>`). Same-origin in a browser; no retries.
+ * With `token` (an agent connection, `tac_…`) the client runs outside a browser: `base` is the entry's absolute URL, the
+ * token is sent as a bearer and no cookie is sent. Only the connection's permitted routes answer; others are `forbidden`.
+ */
+export function payeeClient({ base = "", fetch: send = globalThis.fetch, token } = {}) {
+    async function call(schema, method, path, body, identity) {
+        const lost = () => identity ? { ok: false, kind: "unknown", identity } : { ok: false, kind: "unavailable" };
+        let response;
+        try {
+            response = await send(`${base}${path}`, { method, credentials: token ? "omit" : "same-origin",
+                headers: { accept: "application/json", ...(token && { authorization: `Bearer ${token}` }), ...(body !== undefined && { "content-type": "application/json" }) },
+                ...(body !== undefined && { body: JSON.stringify(body) }) });
+        }
+        catch {
+            return lost();
+        }
+        let json, readable = true;
+        try {
+            json = await response.json();
+        }
+        catch {
+            readable = false;
+        }
+        const answer = errorBody.safeParse(json);
+        // 401 and 403 are decided by status alone: a proxy or gateway page still ends the session or refuses.
+        if (response.status === 401)
+            return { ok: false, kind: "session", status: 401, error: answer.success ? answer.data.error : "Sign in again." };
+        if (response.status === 403)
+            return { ok: false, kind: "forbidden", status: 403, error: answer.success ? answer.data.error : "This account may not do that." };
+        if (!readable)
+            return lost();
+        if (response.ok) {
+            const parsed = schema.safeParse(json);
+            return parsed.success ? { ok: true, value: parsed.data } : lost();
+        }
+        // A gateway or server failure may follow an accepted mutation; only a 4xx answer is a refusal.
+        if (response.status >= 500)
+            return lost();
+        return { ok: false, kind: "refused", status: response.status, error: answer.success ? answer.data.error : "Request refused.", ...(answer.success && answer.data.code && { code: answer.data.code }) };
+    }
+    return {
+        capabilities: () => call(capabilities, "GET", "/api/capabilities"),
+        // supplier-session-v1
+        session: () => call(session, "GET", "/api/session"),
+        signInChallenge: () => call(signInChallenge, "POST", "/api/signin/challenge", {}),
+        signIn: (input) => call(signInResult, "POST", "/api/signin", signIn.parse(input)),
+        signOut: () => call(signOutResult, "POST", "/api/signout", {}),
+        // supplier-invoices-v1
+        invoices: () => call(invoicesView, "GET", "/api/invoices"),
+        submitInvoice: (input) => call(fileResult, "POST", "/api/invoices", input, { submission: input.submission }),
+        continueInvoice: (invoiceId) => call(fileResult, "POST", `/api/invoices/${encodeURIComponent(invoiceId)}/continue`, {}, { invoiceId }),
+        // supplier-work-orders-v1
+        workOrders: () => call(workOrderList, "GET", "/api/work-orders"),
+        workOrder: (id) => call(publicWorkOrder, "GET", `/api/work-orders/${encodeURIComponent(id)}`),
+        fileWorkOrder: (id) => call(fileResult, "POST", `/api/work-orders/${encodeURIComponent(id)}/file`, {}, { workOrderId: id }),
+        // supplier-work-order-requests-v1
+        requestWorkOrder: (input) => call(workOrderRequestResult, "POST", "/api/work-orders", payeeWorkOrderRequest.parse(input), { submission: input.submission }),
+        // supplier-compensation-v2
+        compensationSession: () => call(compensationSession, "GET", "/api/compensation/session"),
+        compensationSignIn: (input) => call(signInResult, "POST", "/api/compensation/signin", signIn.parse(input)),
+        compensation: () => call(payeeCompensationView, "GET", "/api/compensation"),
+        submitReport: (command) => {
+            const parsed = reportCommand.parse(command);
+            return call(requestRecord, "POST", "/api/compensation", parsed, { commandId: parsed.commandId, id: parsed.id, expectedVersion: parsed.expectedVersion });
+        },
+        // supplier-agent-connections-v1: managed from the signed-in browser session only (a bearer is refused).
+        agentConnections: () => call(agentConnectionList, "GET", "/api/agent-connections"),
+        /** A lost answer is `unavailable`: a started connection is not a money action, and an orphan is listed and revocable. */
+        startAgentConnection: (input) => call(agentConnectionStarted, "POST", "/api/agent-connections", agentConnectionIssue.parse(input)),
+        revokeAgentConnection: (id) => call(agentConnectionRevoked, "DELETE", `/api/agent-connections/${encodeURIComponent(id)}`),
+    };
+}

package/dist/contract/gateway.d.ts

@@ -0,0 +1,74 @@
+import { z } from "zod";
+export declare const gatewayAccess: z.ZodObject<{
+    canSign: z.ZodBoolean;
+    canPropose: z.ZodBoolean;
+    canVote: z.ZodBoolean;
+    canExecute: z.ZodBoolean;
+    canManage: z.ZodBoolean;
+}, z.core.$loose>;
+export declare const gatewayAgent: z.ZodObject<{
+    name: z.ZodString;
+    owner: z.ZodString;
+    dao: z.ZodBoolean;
+    area: z.ZodOptional<z.ZodEnum<{
+        payables: "payables";
+        treasury: "treasury";
+    }>>;
+    managed: z.ZodOptional<z.ZodBoolean>;
+    invoices: z.ZodOptional<z.ZodNullable<z.ZodURL>>;
+}, z.core.$loose>;
+/** `GET /gw/me`: the agents this host shows the visitor, and the signed-in account's access to each. */
+export declare const gatewayDiscovery: z.ZodObject<{
+    agents: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        owner: z.ZodString;
+        dao: z.ZodBoolean;
+        area: z.ZodOptional<z.ZodEnum<{
+            payables: "payables";
+            treasury: "treasury";
+        }>>;
+        managed: z.ZodOptional<z.ZodBoolean>;
+        invoices: z.ZodOptional<z.ZodNullable<z.ZodURL>>;
+    }, z.core.$loose>>;
+    invoices: z.ZodNullable<z.ZodURL>;
+    viewer: z.ZodNullable<z.ZodObject<{
+        account: z.ZodString;
+        access: z.ZodRecord<z.ZodString, z.ZodObject<{
+            canSign: z.ZodBoolean;
+            canPropose: z.ZodBoolean;
+            canVote: z.ZodBoolean;
+            canExecute: z.ZodBoolean;
+            canManage: z.ZodBoolean;
+        }, z.core.$loose>>;
+    }, z.core.$loose>>;
+    apps: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    demo: z.ZodOptional<z.ZodEnum<{
+        invoices: "invoices";
+        payables: "payables";
+        showcase: "showcase";
+        treasury: "treasury";
+    }>>;
+    capabilities: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    setupAreas: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        payables: "payables";
+        treasury: "treasury";
+    }>>>;
+    selfService: z.ZodOptional<z.ZodBoolean>;
+    walkthroughs: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>;
+export type GatewayDiscovery = z.output<typeof gatewayDiscovery>;
+export type GatewayAgent = z.output<typeof gatewayAgent>;
+/** Why the gateway refused: no valid session, no access to this agent, or no permission for this procedure. */
+export declare const GATEWAY_DENIAL_SCOPES: readonly ["session", "agent", "procedure"];
+export type GatewayDenialScope = (typeof GATEWAY_DENIAL_SCOPES)[number];
+/** The gateway's own 401/403 answer. `access` is absent from older gateways, machine routes and proxies. */
+export declare const gatewayDenial: z.ZodObject<{
+    error: z.ZodString;
+    access: z.ZodOptional<z.ZodEnum<{
+        agent: "agent";
+        procedure: "procedure";
+        session: "session";
+    }>>;
+}, z.core.$loose>;
+/** The scope a gateway denial body declares, or undefined when it declares none: the caller decides its own default. */
+export declare function gatewayDenialScope(body: unknown): GatewayDenialScope | undefined;

package/dist/contract/gateway.js

@@ -0,0 +1,47 @@
+import { z } from "zod";
+/**
+ * The hosted gateway's own routes (`gateway-session-v1`), as owner frontends read them. Discovery describes what this
+ * host shows; it grants nothing. Every agent call is still authorized per session, agent and procedure.
+ */
+const area = z.enum(["treasury", "payables"]);
+/** An HTTP(S) payee entry. The protocol is checked by the URL schema itself, so a malformed value fails the parse. */
+const entry = z.url({ protocol: /^https?$/ });
+export const gatewayAccess = z.looseObject({ canSign: z.boolean(), canPropose: z.boolean(), canVote: z.boolean(), canExecute: z.boolean(), canManage: z.boolean() });
+export const gatewayAgent = z.looseObject({
+    name: z.string().regex(/^[a-z0-9-]{1,32}$/),
+    owner: z.string().min(1),
+    /** Whether the owner is a Sputnik DAO (owner actions then pass through its votes). */
+    dao: z.boolean(),
+    area: area.optional(),
+    /** A self-service instance created through `/gw/agents`. */
+    managed: z.boolean().optional(),
+    /** This agent's payee entry, or null when it has none. Absent: the host-wide `invoices` applies. */
+    invoices: entry.nullable().optional(),
+});
+/** `GET /gw/me`: the agents this host shows the visitor, and the signed-in account's access to each. */
+export const gatewayDiscovery = z.looseObject({
+    agents: z.array(gatewayAgent),
+    invoices: entry.nullable(),
+    /** Null when signed out, or signed in without access here. */
+    viewer: z.looseObject({ account: z.string().min(1), access: z.record(z.string(), gatewayAccess) }).nullable(),
+    /** The hosts serving each app area on this deployment. */
+    apps: z.record(z.string(), z.string()).optional(),
+    demo: z.enum(["showcase", "payables", "treasury", "invoices"]).optional(),
+    /** The owner-app capabilities this host provides (`ownerCapabilities`). */
+    capabilities: z.array(z.string()).optional(),
+    /** The areas the visitor may create agents in here. */
+    setupAreas: z.array(area).optional(),
+    selfService: z.boolean().optional(),
+    walkthroughs: z.boolean().optional(),
+});
+/** Why the gateway refused: no valid session, no access to this agent, or no permission for this procedure. */
+export const GATEWAY_DENIAL_SCOPES = ["session", "agent", "procedure"];
+/** The gateway's own 401/403 answer. `access` is absent from older gateways, machine routes and proxies. */
+export const gatewayDenial = z.looseObject({ error: z.string(), access: z.enum(GATEWAY_DENIAL_SCOPES).optional() });
+/** The scope a gateway denial body declares, or undefined when it declares none: the caller decides its own default. */
+export function gatewayDenialScope(body) {
+    const parsed = gatewayDenial.safeParse(body);
+    return parsed.success ? parsed.data.access : undefined;
+}
+const accessMatches = true;
+void accessMatches;

package/dist/contract/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @multiagency/sdk: the platform contract apps compile against instead of copying the platform.
+ * The platform's own handlers import these modules; the package is packed from the same files.
+ * `@multiagency/sdk/payee` is the payee side alone (zod only), for apps without owner procedures.
+ */
+export { contractPackage } from "./package-version.js";
+export { payeeContract, compatiblePayeeFrontend, compatibleRelease } from "../payee-contract.js";
+export * from "./owner-capabilities.js";
+export * from "../compensation-contract.js";
+export * from "./payee.js";
+export * from "./client.js";
+export * from "./agent-connection.js";
+export * from "./owner-outputs.js";
+export * from "./owner-client.js";
+export * from "./app-consent.js";
+export * from "./app-access.js";
+export * from "./app-client.js";
+export type { OwnerInputs, OwnerAction } from "./owner-inputs.js";
+export * from "./inputs.js";
+export { ASSETS } from "./assets.js";
+export { intentsAccount, isNearcomAddress, validIntentsAccount } from "./intents-account.js";
+export { mayCall, type Access } from "./permissions.js";
+export * from "./gateway.js";
+export * from "./proposals.js";
+export * from "./run-progress-schema.js";
+export { RecordingSchema, MAX_RECORDING_BYTES, AGUI_VERSION, AGUI_PROTOCOL_VERSION, type Recording, type RunLogEvent } from "./run-log-schema.js";

package/dist/contract/index.js

@@ -0,0 +1,25 @@
+/**
+ * @multiagency/sdk: the platform contract apps compile against instead of copying the platform.
+ * The platform's own handlers import these modules; the package is packed from the same files.
+ * `@multiagency/sdk/payee` is the payee side alone (zod only), for apps without owner procedures.
+ */
+export { contractPackage } from "./package-version.js";
+export { payeeContract, compatiblePayeeFrontend, compatibleRelease } from "../payee-contract.js";
+export * from "./owner-capabilities.js";
+export * from "../compensation-contract.js";
+export * from "./payee.js";
+export * from "./client.js";
+export * from "./agent-connection.js";
+export * from "./owner-outputs.js";
+export * from "./owner-client.js";
+export * from "./app-consent.js";
+export * from "./app-access.js";
+export * from "./app-client.js";
+export * from "./inputs.js";
+export { ASSETS } from "./assets.js";
+export { intentsAccount, isNearcomAddress, validIntentsAccount } from "./intents-account.js";
+export { mayCall } from "./permissions.js";
+export * from "./gateway.js";
+export * from "./proposals.js";
+export * from "./run-progress-schema.js";
+export { RecordingSchema, MAX_RECORDING_BYTES, AGUI_VERSION, AGUI_PROTOCOL_VERSION } from "./run-log-schema.js";