@byokit/openclaw 0.1.0

package/dist/bridge.d.ts

@@ -0,0 +1,78 @@
+import type { Approval, Decision, RunRef, ToolHost, ToolSpec } from './types.ts';
+/**
+ * Asks must expire before the plugin's 195 s gate timeout, or the run gets a generic block while the approval
+ * lingers (N3). The kit passes its `approvalTimeoutMs` through; anything above is clamped to this.
+ */
+export declare const MAX_APPROVAL_TIMEOUT_MS = 190000;
+export declare const DEFAULT_SOCKET_NAME = "bridge.sock";
+export declare const DEFAULT_PARAM_PREFIX = "__byokit";
+/** Resolve the bridge naming options, validating explicit values; defaults keep prior behavior. */
+export declare function resolveBridge(o?: {
+    socketName?: string;
+    paramPrefix?: string;
+}): {
+    socketName: string;
+    paramPrefix: string;
+};
+/**
+ * Write the bridge plugin's generated files into the engine's plugin dir: the manifest OpenClaw discovers
+ * ownership from, and the tool table the shipped `plugin/index.js` registers at load. Deterministic: rewriting
+ * with the same tools leaves bytes identical.
+ */
+export declare function writePlugin(dir: string, o: {
+    id: string;
+    tools: ToolSpec[];
+    paramPrefix: string;
+    gateBuiltins: boolean;
+}): void;
+export declare class Bridge {
+    private readonly path;
+    private readonly host?;
+    private readonly tools;
+    private readonly permitted;
+    private readonly approvalTimeoutMs;
+    private readonly onAsk;
+    private readonly onAskGone;
+    private server?;
+    private readonly runs;
+    private readonly permits;
+    private readonly tickets;
+    private armed;
+    private readonly parked;
+    private stopped;
+    constructor(o: {
+        path: string;
+        host?: ToolHost;
+        tools: ReadonlySet<string>;
+        permitted: (tool: string) => boolean;
+        approvalTimeoutMs: number;
+        onAsk(a: Approval): void;
+        onAskGone(id: string): void;
+    });
+    start(): Promise<void>;
+    stop(): void;
+    register(run: RunRef): void;
+    unregister(sessionKey: string): void;
+    allowOnce(rule: {
+        keyPrefix: string;
+        tool: string;
+        input?: (i: Record<string, unknown>) => boolean;
+    }, ms: number): void;
+    disallowOnce(): void;
+    /** Resolve a parked `{ ask }` gate. Returns false when the id is not a parked ask. */
+    resolveAsk(id: string, d: Decision): boolean;
+    /**
+     * Admit one call: permitted tools get a permit, the rest get a single-use ticket (N1: never both, so no
+     * orphan ticket outlives the approval that created it). Builtins run inside the engine and never call back,
+     * so they get neither.
+     */
+    private admit;
+    private mint;
+    private reply;
+    private deny;
+    private serve;
+    private handle;
+    private gate;
+    private gateRun;
+    private call;
+}

package/dist/bridge.js

@@ -0,0 +1,345 @@
+// The fail-closed tool bridge: plugin hook -> unix socket -> app gate, with parked asks and one-use permits (5.9, O5).
+import { randomBytes } from 'node:crypto';
+import { existsSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { createServer } from 'node:net';
+import { rm } from 'node:fs/promises';
+import { words } from "./words.js";
+/** Newline-framed JSON, one request per connection; anything larger is not a gate request. */
+const FRAME_CAP = 1_000_000;
+/**
+ * Asks must expire before the plugin's 195 s gate timeout, or the run gets a generic block while the approval
+ * lingers (N3). The kit passes its `approvalTimeoutMs` through; anything above is clamped to this.
+ */
+export const MAX_APPROVAL_TIMEOUT_MS = 190_000;
+const isRecord = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+const memberOfKey = (key) => {
+    const m = /^agent:([a-z][a-z0-9-]{0,31}):/.exec(key);
+    return m?.[1];
+};
+export const DEFAULT_SOCKET_NAME = 'bridge.sock';
+export const DEFAULT_PARAM_PREFIX = '__byokit';
+/** Resolve the bridge naming options, validating explicit values; defaults keep prior behavior. */
+export function resolveBridge(o) {
+    const socketName = o?.socketName ?? DEFAULT_SOCKET_NAME;
+    const paramPrefix = o?.paramPrefix ?? DEFAULT_PARAM_PREFIX;
+    if (!/^[A-Za-z0-9][A-Za-z0-9_.-]*\.sock$/.test(socketName))
+        throw new Error(`invalid bridge socketName: ${socketName}`);
+    if (!/^__[A-Za-z0-9]+$/.test(paramPrefix))
+        throw new Error(`invalid bridge paramPrefix: ${paramPrefix}`);
+    return { socketName, paramPrefix };
+}
+/**
+ * Write the bridge plugin's generated files into the engine's plugin dir: the manifest OpenClaw discovers
+ * ownership from, and the tool table the shipped `plugin/index.js` registers at load. Deterministic: rewriting
+ * with the same tools leaves bytes identical.
+ */
+export function writePlugin(dir, o) {
+    resolveBridge({ paramPrefix: o.paramPrefix });
+    const runParam = `${o.paramPrefix}_run`;
+    const permitParam = `${o.paramPrefix}_permit`;
+    const manifest = {
+        id: o.id,
+        name: 'BYOKit bridge',
+        activation: { onStartup: true },
+        contracts: { tools: o.tools.map((t) => t.name) },
+        configSchema: { type: 'object', additionalProperties: false },
+    };
+    const table = {
+        id: o.id,
+        runParam,
+        permitParam,
+        // true: engine builtins (web_fetch, memory, ...) are gated too, not only the app's tools.
+        gateBuiltins: o.gateBuiltins,
+        tools: o.tools.map((t) => ({ name: t.name, description: t.description, parameters: t.parameters })),
+    };
+    for (const [file, data] of [['openclaw.plugin.json', manifest], ['tools.json', table]]) {
+        const text = JSON.stringify(data, null, 2) + '\n';
+        const path = `${dir}/${file}`;
+        if (!existsSync(path) || readFileSync(path, 'utf8') !== text)
+            writeFileSync(path, text, { mode: 0o600 });
+    }
+}
+export class Bridge {
+    path;
+    host;
+    tools;
+    permitted;
+    approvalTimeoutMs;
+    onAsk;
+    onAskGone;
+    server;
+    runs = new Map();
+    permits = new Map();
+    tickets = [];
+    armed;
+    parked = new Map();
+    stopped = false;
+    constructor(o) {
+        this.path = o.path;
+        this.host = o.host;
+        this.tools = o.tools;
+        this.permitted = o.permitted;
+        this.approvalTimeoutMs = Math.min(o.approvalTimeoutMs, MAX_APPROVAL_TIMEOUT_MS);
+        this.onAsk = o.onAsk;
+        this.onAskGone = o.onAskGone;
+    }
+    start() {
+        if (this.server)
+            return Promise.resolve();
+        this.stopped = false;
+        // A stale socket file from a crashed run is not a listener; a live one survives unlinking.
+        rmSync(this.path, { force: true });
+        this.server = createServer((socket) => this.serve(socket));
+        return new Promise((resolve, reject) => {
+            this.server.once('error', reject);
+            this.server.listen(this.path, () => {
+                this.server.removeListener('error', reject);
+                resolve();
+            });
+        });
+    }
+    stop() {
+        this.stopped = true;
+        for (const [id, p] of this.parked) {
+            clearTimeout(p.timer);
+            this.reply(p.socket, { allow: false, reason: words('approval.expired') });
+            // Parked gates end here; without this their approvals outlive the connection (N9).
+            this.onAskGone(id);
+        }
+        this.parked.clear();
+        this.server?.close();
+        this.server = undefined;
+        void rm(this.path, { force: true }).catch(() => { });
+    }
+    register(run) {
+        this.runs.set(run.sessionKey, run);
+    }
+    unregister(sessionKey) {
+        this.runs.delete(sessionKey);
+        for (const [permit, p] of this.permits)
+            if (p.key === sessionKey)
+                this.permits.delete(permit);
+        for (let i = this.tickets.length - 1; i >= 0; i--)
+            if (this.tickets[i].key === sessionKey)
+                this.tickets.splice(i, 1);
+    }
+    allowOnce(rule, ms) {
+        this.armed = { ...rule, until: Date.now() + ms };
+    }
+    disallowOnce() {
+        this.armed = undefined;
+    }
+    /** Resolve a parked `{ ask }` gate. Returns false when the id is not a parked ask. */
+    resolveAsk(id, d) {
+        const p = this.parked.get(id);
+        if (!p)
+            return false;
+        this.parked.delete(id);
+        clearTimeout(p.timer);
+        if (d.allow)
+            this.admit(p.socket, p.run.sessionKey, p.tool, p.input);
+        else
+            this.reply(p.socket, { allow: false, reason: d.reason ?? words('approval.expired') });
+        this.onAskGone(id);
+        return true;
+    }
+    /**
+     * Admit one call: permitted tools get a permit, the rest get a single-use ticket (N1: never both, so no
+     * orphan ticket outlives the approval that created it). Builtins run inside the engine and never call back,
+     * so they get neither.
+     */
+    admit(socket, key, tool, input) {
+        if (!this.tools.has(tool)) {
+            this.reply(socket, { allow: true });
+            return;
+        }
+        if (this.permitted(tool)) {
+            this.reply(socket, { allow: true, permit: this.mint(key, tool, input) });
+            return;
+        }
+        this.tickets.push({ key, tool, input: JSON.stringify(input) });
+        while (this.tickets.length > 1024)
+            this.tickets.shift();
+        this.reply(socket, { allow: true });
+    }
+    mint(key, tool, input) {
+        const permit = randomBytes(16).toString('hex');
+        this.permits.set(permit, { permit, key, tool, input: JSON.stringify(input) });
+        // Single-use entries are consumed on the next call; evict the oldest if the plugin never calls back.
+        while (this.permits.size > 1024)
+            this.permits.delete(this.permits.keys().next().value);
+        return permit;
+    }
+    reply(socket, message) {
+        try {
+            socket.write(JSON.stringify(message) + '\n');
+        }
+        catch { /* the plugin is gone; the deny stands */ }
+        socket.end();
+    }
+    deny(socket, reason) {
+        this.reply(socket, { allow: false, reason });
+    }
+    serve(socket) {
+        let buffer = '';
+        socket.on('data', (chunk) => {
+            buffer += String(chunk);
+            if (buffer.length > FRAME_CAP)
+                return this.deny(socket, 'request too large');
+            const end = buffer.indexOf('\n');
+            if (end < 0)
+                return;
+            const line = buffer.slice(0, end);
+            buffer = buffer.slice(end + 1);
+            this.handle(socket, line);
+        });
+        socket.on('error', () => { });
+    }
+    handle(socket, line) {
+        let message;
+        try {
+            message = JSON.parse(line);
+        }
+        catch {
+            return this.deny(socket, 'not a gate request');
+        }
+        if (!isRecord(message) || typeof message.kind !== 'string')
+            return this.deny(socket, 'not a gate request');
+        if (message.kind === 'gate')
+            return void this.gate(socket, message);
+        if (message.kind === 'call')
+            return void this.call(socket, message);
+        return this.deny(socket, 'not a gate request');
+    }
+    gate(socket, message) {
+        const key = message.key;
+        const tool = message.tool;
+        const input = message.input;
+        if (typeof key !== 'string' || typeof tool !== 'string' || !isRecord(input)) {
+            return this.deny(socket, 'not a gate request');
+        }
+        const run = this.runs.get(key);
+        if (run)
+            return void this.gateRun(socket, run, tool, input);
+        const armed = this.armed;
+        if (armed && Date.now() < armed.until && key.startsWith(armed.keyPrefix) && tool === armed.tool &&
+            (!armed.input || armed.input(input))) {
+            this.armed = undefined;
+            // '' when unattributable: never a member id (B2).
+            const member = memberOfKey(key) ?? '';
+            const runRef = { sessionKey: key, member };
+            return void this.gateRun(socket, runRef, tool, input);
+        }
+        return this.deny(socket, 'unknown run');
+    }
+    async gateRun(socket, run, tool, input) {
+        if (!this.host)
+            return this.deny(socket, "can't check this action right now");
+        let result;
+        try {
+            result = await this.host.gate(run, tool, input, { builtin: !this.tools.has(tool) });
+        }
+        catch {
+            return this.deny(socket, "can't check this action right now");
+        }
+        if (this.stopped)
+            return;
+        if ('ask' in result) {
+            const now = Date.now();
+            const approval = {
+                id: randomBytes(12).toString('base64url'),
+                source: 'gate',
+                member: run.member,
+                sessionKey: run.sessionKey,
+                tool,
+                summary: result.ask.summary,
+                input,
+                at: now,
+                expires: now + this.approvalTimeoutMs,
+            };
+            const parked = {
+                socket,
+                timer: setTimeout(() => {
+                    if (this.parked.delete(approval.id)) {
+                        this.reply(socket, { allow: false, reason: words('approval.expired') });
+                        this.onAskGone(approval.id);
+                    }
+                }, this.approvalTimeoutMs),
+                approval,
+                run,
+                tool,
+                input,
+            };
+            parked.timer.unref?.();
+            this.parked.set(approval.id, parked);
+            // A dead caller (run abort, hook timeout) must not leave an approval nothing will use (N2).
+            socket.once('close', () => {
+                if (this.parked.delete(approval.id)) {
+                    clearTimeout(parked.timer);
+                    this.onAskGone(approval.id);
+                }
+            });
+            this.onAsk(approval);
+            return;
+        }
+        if (result.allow) {
+            this.admit(socket, run.sessionKey, tool, input);
+            return;
+        }
+        this.deny(socket, result.reason);
+    }
+    async call(socket, message) {
+        const key = message.key;
+        const tool = message.tool;
+        const input = message.input;
+        if (typeof key !== 'string' || typeof tool !== 'string' || !isRecord(input)) {
+            return this.reply(socket, { ok: false, reason: 'not a call request' });
+        }
+        // Only the app's own tools run through host.call; a builtin never calls back.
+        if (!this.tools.has(tool))
+            return this.reply(socket, { ok: false, reason: 'this call was not allowed' });
+        const wanted = JSON.stringify(input);
+        const permit = message.permit;
+        if (typeof permit === 'string') {
+            const p = this.permits.get(permit);
+            if (!p || p.key !== key || p.tool !== tool || p.input !== wanted) {
+                return this.reply(socket, { ok: false, reason: 'this call was not allowed' });
+            }
+            this.permits.delete(permit);
+        }
+        else {
+            // Permitted tools travel by permit only. A ticket is itself proof of a gate allow for this exact
+            // key + tool + input, so no run registration is needed (N10: allowOnce admits unregistered keys).
+            if (this.permitted(tool))
+                return this.reply(socket, { ok: false, reason: 'this call was not allowed' });
+            const ticket = this.tickets.findIndex((t) => t.key === key && t.tool === tool && t.input === wanted);
+            if (ticket < 0)
+                return this.reply(socket, { ok: false, reason: 'this call was not allowed' });
+            this.tickets.splice(ticket, 1);
+        }
+        if (!this.host)
+            return this.reply(socket, { ok: false, reason: "can't run this action right now" });
+        const run = this.runs.get(key) ?? { sessionKey: key, member: memberOfKey(key) ?? '' };
+        // The plugin destroys its socket when the run aborts (run abort, hook timeout); without this the host's
+        // sandboxed command keeps running after the tool is gone.
+        const controller = new AbortController();
+        const onSocketGone = () => controller.abort();
+        if (socket.destroyed)
+            controller.abort();
+        else {
+            socket.once('close', onSocketGone);
+            socket.once('error', onSocketGone);
+        }
+        try {
+            const text = await this.host.call(run, tool, input, controller.signal);
+            this.reply(socket, { ok: true, text });
+        }
+        catch (error) {
+            this.reply(socket, { ok: false, reason: error instanceof Error ? error.message.slice(0, 200) : 'the call failed' });
+        }
+        finally {
+            socket.removeListener('close', onSocketGone);
+            socket.removeListener('error', onSocketGone);
+        }
+    }
+}

package/dist/classify.d.ts

@@ -0,0 +1,4 @@
+export declare function classify(message: string): {
+    kind: 'signed-out' | 'resting' | 'plan' | 'network' | 'other';
+    until?: number;
+};

package/dist/classify.js

@@ -0,0 +1,14 @@
+// Classify an engine error message into a person-visible kind, with `until` carried when present (5.8, O8).
+// The regexes are Crewhouse `classifyText`; the kinds are the kit's: rate_limit|overloaded → resting,
+// signed_out → signed-out, not_included → plan, network → network, anything unrecognised → other.
+export function classify(message) {
+    const retry = /try again in ~?(\d+)\s*(min|h)/i.exec(message);
+    const until = retry ? Date.now() + Number(retry[1]) * (retry[2].toLowerCase() === 'h' ? 3_600_000 : 60_000) : undefined;
+    const kind = /your plan doesn't include/i.test(message) ? 'plan'
+        : /usage limit|rate.?limit|quota|too many requests|\b429\b/i.test(message) ? 'resting'
+            : /overloaded|high demand|\b50[234]\b|unavailable/i.test(message) ? 'resting'
+                : /unauthori[sz]ed|\b40[13]\b|sign in again|expired|invalid.*token|authentication/i.test(message) ? 'signed-out'
+                    : /fetch failed|network|ENOTFOUND|EAI_AGAIN|ECONN|socket hang up/i.test(message) ? 'network'
+                        : 'other';
+    return until === undefined ? { kind } : { kind, until };
+}

package/dist/config.d.ts

@@ -0,0 +1,13 @@
+import type { KitOptions } from './kit.ts';
+import type { Member } from './types.ts';
+export declare function reconcileConfig(saved: object | undefined, o: {
+    root: string;
+    stateDir: string;
+    port: number;
+    pluginId: string;
+    pluginDir: string;
+    policyPath: string;
+    app?: object;
+    installPolicy?: KitOptions['installPolicy'];
+}): object;
+export declare function memoryLimited(config: object, member: Member): boolean;

package/dist/config.js

@@ -0,0 +1,74 @@
+import { dirname, join } from 'node:path';
+const object = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
+const merge = (a, b) => {
+    for (const [k, v] of Object.entries(b))
+        a[k] = object(v) ? merge(object(a[k]) ? a[k] : {}, v) : Array.isArray(v) ? structuredClone(v) : v;
+    return a;
+};
+const safeMemory = (memory) => {
+    if (!object(memory) || !object(memory.search))
+        return;
+    const s = memory.search;
+    const local = ['none', 'local', 'ollama', 'lmstudio', 'github-copilot'].includes(s.provider);
+    let remote = true;
+    if (s.provider === 'ollama' || s.provider === 'lmstudio') {
+        try {
+            const url = new URL(s.remote?.baseUrl);
+            remote = ['127.0.0.1', 'localhost', '[::1]'].includes(url.hostname) && !s.remote?.apiKey && !url.username && !url.password;
+        }
+        catch {
+            remote = false;
+        }
+    }
+    if (!local || !remote)
+        s.provider = 'none';
+    s.fallback = 'none';
+};
+export function reconcileConfig(saved, o) {
+    const c = merge(merge({}, object(saved) ? saved : {}), object(o.app) ? o.app : {});
+    merge(c, {
+        gateway: { mode: 'local', bind: 'loopback', port: o.port, auth: { mode: 'token' }, controlUi: { enabled: false }, tailscale: { mode: 'off' } },
+        discovery: { mdns: { mode: 'off' } }, env: { shellEnv: { enabled: false } },
+        update: { checkOnStart: false, auto: { enabled: false } }, telemetry: { enabled: false },
+        models: { catalogRefresh: { enabled: false } }, logging: { file: join(o.stateDir, 'logs', 'openclaw-events.log') },
+    });
+    c.channels ??= {};
+    c.agents ??= {};
+    c.agents.defaults ??= {};
+    c.agents.defaults.models ??= {};
+    c.agents.defaults.models['openai/*'] = { ...c.agents.defaults.models['openai/*'], agentRuntime: { id: 'openclaw' } };
+    const allow = c.agents.defaults.modelPolicy?.allow;
+    if (Array.isArray(allow) && allow.length && !allow.includes('openai/*'))
+        allow.push('openai/*');
+    c.memory ??= {};
+    c.memory.search ??= { provider: 'none' };
+    safeMemory(c.memory);
+    for (const entry of Object.values(c.agents.entries ?? {}))
+        safeMemory(entry.memory);
+    // The engine rejects a patched multi-agent roster without explicit ownership (O11); it normalizes the
+    // same value on boot, so the kit writes what the engine would. A lone main (or empty) roster stays sole.
+    const roster = Object.keys(c.agents.entries ?? {});
+    if (roster.length > 1 || (roster.length === 1 && roster[0] !== 'main'))
+        c.agents.ownership = 'explicit';
+    c.plugins ??= {};
+    c.plugins.load ??= {};
+    c.plugins.load.paths = [...new Set([...(c.plugins.load.paths ?? []).filter((p) => !p.includes('byokit-openclaw-bridge')), o.pluginDir])];
+    c.plugins.allow = [...new Set([...(c.plugins.allow ?? []), o.pluginId])];
+    c.plugins.entries ??= {};
+    c.plugins.entries[o.pluginId] = merge(c.plugins.entries[o.pluginId] ?? {}, { hooks: { timeouts: { before_tool_call: 200_000 } } });
+    c.security ??= {};
+    c.security.installPolicy = { enabled: true, exec: {
+            source: 'exec', command: process.execPath, args: [o.policyPath],
+            trustedDirs: [dirname(process.execPath), dirname(o.policyPath)], timeoutMs: 10_000,
+            passEnv: ['OPENCLAW_STATE_DIR'], env: {
+                BYOKIT_TRUSTED_SKILLS: o.installPolicy?.trustedSkills ?? '',
+                BYOKIT_OWN_ROOTS: JSON.stringify(o.installPolicy?.ownRoots ?? []),
+            },
+        } };
+    return c;
+}
+export function memoryLimited(config, member) {
+    const c = config;
+    const entry = c.agents?.entries?.[member];
+    return (entry?.memory ?? c.memory)?.search?.provider === 'none';
+}

package/dist/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const ENGINE_VERSION = "2026.8.1";
+export declare const PROTOCOL_VERSION = 4;
+export declare const OPERATOR_SCOPES: readonly ["operator.read", "operator.write", "operator.admin", "operator.approvals", "operator.questions", "operator.pairing", "operator.talk"];

package/dist/constants.js

@@ -0,0 +1,13 @@
+// The pins this kit is built against (D4, D6). Data, not behavior: an installed engine on another version is
+// `needs-update`, never silently run.
+export const ENGINE_VERSION = '2026.8.1';
+export const PROTOCOL_VERSION = 4;
+export const OPERATOR_SCOPES = [
+    'operator.read',
+    'operator.write',
+    'operator.admin',
+    'operator.approvals',
+    'operator.questions',
+    'operator.pairing',
+    'operator.talk',
+];

package/dist/device.d.ts

@@ -0,0 +1,63 @@
+import type { DeviceLink } from '@byokit/link';
+import { type AccountView } from './words.ts';
+import type { Approval, Decision, GatewayEventName, GatewayEventPayload, GatewayMethod, GatewayParams, GatewayResult, KitState, Route, RunEnd, RunEvent, SignInView } from './types.ts';
+export type { GatewayEventName, GatewayEventPayload, GatewayMethod, GatewayParams, GatewayResult } from './types.ts';
+export type { Approval, Decision, KitState, Route, RunEnd, RunEvent, SignInView } from './types.ts';
+/** One `oc.events` frame: a member's Gateway event, typed by name, or an approval add/resolve (7.2). */
+export type OpenClawLinkEvent = {
+    [E in GatewayEventName]: {
+        event: E;
+        payload: GatewayEventPayload<E>;
+    };
+}[GatewayEventName] | {
+    event: 'approval';
+    change: 'added' | 'resolved';
+    approval: Approval;
+};
+/** One `oc.sessions` row: `sessions.list` filtered to the member's `agent:<member>:` keys. */
+export type SessionRow = {
+    sessionKey: string;
+    [k: string]: unknown;
+};
+/**
+ * The host ended a stream with its own words (e.g. a refusal). Portable twin of link's PublicLinkError:
+ * same shape ({ code: 'failed', sealed: true }) so a screen can show .message the same way. A device-side
+ * import of link's class would drag node:* into this portable entry (test/portable.test.ts).
+ */
+export declare class LinkRefused extends Error {
+    readonly code = "failed";
+    readonly sealed = true;
+    constructor(message: string);
+}
+export declare function openclawDevice(link: DeviceLink): {
+    state(): Promise<{
+        state: KitState;
+        words: string;
+    }>;
+    routes(): Promise<Route[]>;
+    signIn: {
+        start(p: string, via: 'browser' | 'code'): Promise<SignInView>;
+        view(p: string): Promise<AccountView>;
+        paste(p: string, t: string): Promise<void>;
+        cancel(p: string): Promise<void>;
+    };
+    signOut(p: string): Promise<void>;
+    sessions(): Promise<SessionRow[]>;
+    run(message: string, o?: {
+        sessionKey?: string;
+        model?: string;
+    }): AsyncIterable<RunEvent | {
+        type: 'end';
+        end: RunEnd;
+    }>;
+    steer(k: string, t: string): Promise<void>;
+    abort(k: string): Promise<void>;
+    approvals(): Promise<Approval[]>;
+    decide(id: string, d: Decision): Promise<void>;
+    events(): AsyncIterable<OpenClawLinkEvent>;
+    registerNotices(seed: Uint8Array): Promise<void>;
+    openNotice(data: Record<string, unknown>, seed: Uint8Array): Approval | null;
+    call<M extends GatewayMethod>(method: M, params: GatewayParams<M>): Promise<GatewayResult<M>>;
+};
+export { openNotice } from './notices.ts';
+export { stateWords, toAccountView, words, type AccountView, type WordKey } from './words.ts';