@phnx-labs/agents-cli 1.20.72 → 1.20.74

package/dist/lib/hq/floor.js

@@ -0,0 +1,226 @@
+import { mailboxIdForActiveSession } from '../mailbox-target.js';
+function slug(s) {
+    return s.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '') || 'unknown';
+}
+function roomIdForTeam(team) {
+    return `team:${slug(team)}`;
+}
+function roomIdForMachine(machine) {
+    return `machine:${slug(machine)}`;
+}
+function agentDisplayName(session) {
+    return session.name || session.label || session.agentId || session.sessionId?.slice(0, 8) || session.kind;
+}
+function sessionMachine(session) {
+    return session.machine || session.provenance?.host || session.host || 'local';
+}
+function teamForSession(session, teammatesById) {
+    if (session.teamName)
+        return session.teamName;
+    if (session.agentId && teammatesById.has(session.agentId))
+        return teammatesById.get(session.agentId).team;
+    return undefined;
+}
+function teammateName(session, teammatesById) {
+    if (session.agentId && teammatesById.has(session.agentId)) {
+        return teammatesById.get(session.agentId).name || session.agentId.slice(0, 8);
+    }
+    return session.agentId;
+}
+function moodForSession(session, hasOpenBlock) {
+    if (session.status === 'input_required' || session.activity === 'waiting_input' || hasOpenBlock)
+        return 'waiting';
+    if (session.rateLimited)
+        return 'blocked';
+    if (session.pr)
+        return 'celebrating';
+    if (session.status === 'running' || session.activity === 'working')
+        return 'working';
+    return 'idle';
+}
+function action(id, label, command, target, extra = {}) {
+    return { id, label, command, target, ...extra };
+}
+function agentActions(agentId, session, mailboxId, team, teammate) {
+    const actions = [];
+    if (mailboxId) {
+        actions.push(action(`agent:${agentId}:message`, 'Message', ['message', mailboxId, '{message}', '--surface', 'hq'], { kind: 'agent', id: agentId }, { input: [{ name: 'message', label: 'Message', placeholder: 'What should this agent do next?', required: true }] }));
+        actions.push(action(`agent:${agentId}:stop`, 'Stop', ['feed', '--kill', mailboxId], { kind: 'agent', id: agentId }, { destructive: true }));
+    }
+    if (team && teammate) {
+        actions.push(action(`agent:${agentId}:team-stop`, 'Stop teammate', ['teams', 'stop', team, teammate], { kind: 'agent', id: agentId }, { destructive: true }));
+    }
+    if (session.sessionId) {
+        actions.push(action(`agent:${agentId}:transcript`, 'Transcript', ['sessions', session.sessionId, '--markdown'], { kind: 'agent', id: agentId }));
+    }
+    return actions;
+}
+function spawnActionForRoom(roomId, team) {
+    if (team) {
+        return action(`room:${roomId}:spawn-teammate`, 'Spawn teammate', ['teams', 'add', team, '{agent}', '{task}', '--name', '{name}', '--mode', 'edit'], { kind: 'room', id: roomId }, {
+            input: [
+                { name: 'agent', label: 'Agent', placeholder: 'claude', required: true },
+                { name: 'name', label: 'Name', placeholder: 'frontend', required: true },
+                { name: 'task', label: 'Task', placeholder: 'Implement the next scoped task', required: true },
+            ],
+        });
+    }
+    return action(`room:${roomId}:spawn-run`, 'Run agent', ['run', '{agent}', '{task}', '--name', '{name}'], { kind: 'room', id: roomId }, {
+        input: [
+            { name: 'agent', label: 'Agent', placeholder: 'claude', required: true },
+            { name: 'name', label: 'Name', placeholder: 'investigate', required: true },
+            { name: 'task', label: 'Task', placeholder: 'Investigate this room', required: true },
+        ],
+    });
+}
+export function buildHqFloor(input) {
+    const generatedAt = (input.generatedAt ?? new Date()).toISOString();
+    const teammatesById = new Map();
+    for (const [team, teammates] of input.teammatesByTeam) {
+        for (const teammate of teammates)
+            teammatesById.set(teammate.agent_id, { ...teammate, team });
+    }
+    const openBlocksByMailbox = new Map();
+    for (const block of input.blocks) {
+        const blocks = openBlocksByMailbox.get(block.mailboxId) || [];
+        blocks.push(block);
+        openBlocksByMailbox.set(block.mailboxId, blocks);
+    }
+    const rooms = new Map();
+    const ensureRoom = (room) => {
+        const existing = rooms.get(room.id);
+        if (existing)
+            return existing;
+        const created = {
+            ...room,
+            counts: { agents: 0, needsInput: 0, running: 0, failed: 0 },
+            actions: [spawnActionForRoom(room.id, room.team)],
+        };
+        rooms.set(room.id, created);
+        return created;
+    };
+    for (const team of input.teams) {
+        ensureRoom({ id: roomIdForTeam(team.task_name), kind: 'team', name: team.task_name, team: team.task_name });
+    }
+    const agents = [];
+    for (const session of input.sessions) {
+        const team = teamForSession(session, teammatesById);
+        const machine = sessionMachine(session);
+        const room = team
+            ? ensureRoom({ id: roomIdForTeam(team), kind: 'team', name: team, team })
+            : ensureRoom({ id: roomIdForMachine(machine), kind: 'machine', name: machine, machine });
+        const mailboxId = mailboxIdForActiveSession(session);
+        const blocks = mailboxId ? openBlocksByMailbox.get(mailboxId) || [] : [];
+        const id = session.agentId || session.sessionId || `${session.kind}:${agents.length + 1}`;
+        const mood = moodForSession(session, blocks.length > 0);
+        const teammate = teammateName(session, teammatesById);
+        room.counts.agents++;
+        if (mood === 'waiting')
+            room.counts.needsInput++;
+        if (session.status === 'running')
+            room.counts.running++;
+        if (mood === 'blocked')
+            room.counts.failed++;
+        agents.push({
+            id,
+            label: agentDisplayName(session),
+            agent: session.kind,
+            roomId: room.id,
+            mood,
+            status: session.status,
+            activity: session.activity,
+            preview: session.preview || session.question?.text,
+            machine,
+            team,
+            teammate,
+            sessionId: session.sessionId,
+            mailboxId,
+            pid: session.pid,
+            prUrl: session.pr?.url,
+            ticketId: session.ticket?.id,
+            actions: agentActions(id, session, mailboxId, team, teammate),
+        });
+    }
+    const ambientEvents = [];
+    for (const agent of agents) {
+        if (agent.mood === 'waiting') {
+            ambientEvents.push({
+                id: `needs-input:${agent.id}`,
+                kind: 'needs_input',
+                roomId: agent.roomId,
+                agentId: agent.id,
+                label: `${agent.label} needs input`,
+                intensity: 'high',
+            });
+        }
+        else if (agent.mood === 'blocked') {
+            ambientEvents.push({
+                id: `blocked:${agent.id}`,
+                kind: 'error',
+                roomId: agent.roomId,
+                agentId: agent.id,
+                label: `${agent.label} is blocked`,
+                intensity: 'high',
+            });
+        }
+        else if (agent.mood === 'celebrating' && agent.prUrl) {
+            ambientEvents.push({
+                id: `pr:${agent.id}`,
+                kind: 'pr',
+                roomId: agent.roomId,
+                agentId: agent.id,
+                label: `${agent.label} opened a PR`,
+                intensity: 'medium',
+            });
+        }
+    }
+    for (const room of rooms.values()) {
+        if (room.kind === 'team' && room.counts.running > 0) {
+            ambientEvents.push({
+                id: `team-active:${room.id}`,
+                kind: 'team_active',
+                roomId: room.id,
+                label: `${room.name} has ${room.counts.running} active teammate${room.counts.running === 1 ? '' : 's'}`,
+                intensity: 'low',
+            });
+        }
+        if (room.counts.agents > 0 && room.counts.running === 0 && room.counts.needsInput === 0) {
+            ambientEvents.push({
+                id: `idle:${room.id}`,
+                kind: 'idle_scene',
+                roomId: room.id,
+                label: `${room.name} is calm`,
+                intensity: 'low',
+            });
+        }
+    }
+    const floorActions = [
+        action('floor:create-team', 'Create team room', ['teams', 'create', '{team}', '--description', '{description}'], { kind: 'floor', id: 'floor' }, {
+            input: [
+                { name: 'team', label: 'Team', placeholder: 'release-squad', required: true },
+                { name: 'description', label: 'Description', placeholder: 'What this room owns' },
+            ],
+        }),
+    ];
+    const roomList = [...rooms.values()].sort((a, b) => {
+        if (a.kind !== b.kind)
+            return a.kind === 'team' ? -1 : 1;
+        return a.name.localeCompare(b.name);
+    });
+    return {
+        version: 1,
+        generatedAt,
+        counters: {
+            rooms: roomList.length,
+            agents: agents.length,
+            teams: input.teams.length,
+            needsInput: agents.filter((agent) => agent.mood === 'waiting').length,
+            failed: agents.filter((agent) => agent.mood === 'blocked').length,
+            prs: agents.filter((agent) => agent.prUrl).length,
+        },
+        rooms: roomList,
+        agents,
+        ambientEvents,
+        actions: floorActions,
+    };
+}

package/dist/lib/import.d.ts

@@ -111,3 +111,26 @@ export declare function importInstallScriptBinary(spec: AgentBinarySpec, version
  *   /opt/homebrew/bin/{cli}  ->  ../lib/node_modules/{pkg}/dist/index.js
  */
 export declare function resolvePackageDirFromBinary(binaryPath: string): string | null;
+/**
+ * Seed an ISOLATED version's home from the user's real `~/.<agent>` — the mirror of
+ * {@link importAgentConfig}, which adopts.
+ *
+ * The difference is the whole point: this COPIES and leaves the original in place,
+ * never symlinks it, never sets a default, never creates a shim. So an isolated copy
+ * can start from the setup the user already has instead of from nothing, which was
+ * the only way to get a working sandbox before.
+ *
+ * Credentials are skipped by default and reported, not silently included. An isolated
+ * copy is a separate principal — `agents add --isolated` already tells the user to
+ * sign in on first run — and copying tokens into it should be a choice, not a side
+ * effect of wanting your settings. `--with-auth` opts in.
+ */
+export declare function seedIsolatedConfigFromLocal(agentId: AgentId, version: string, opts?: {
+    withAuth?: boolean;
+}): {
+    seeded: boolean;
+    from: string;
+    to: string;
+    skippedAuth: string[];
+    error?: string;
+};

package/dist/lib/import.js

@@ -20,9 +20,9 @@ import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
 import { AGENTS } from './agents.js';
-import { getVersionsDir } from './state.js';
+import { getUserAgentsDir, getVersionsDir } from './state.js';
 import { setGlobalDefault } from './versions.js';
-import { createShim, createVersionedAlias, ensureShimCurrent, switchHomeFileSymlinks } from './shims.js';
+import { createShim, createVersionedAlias, ensureShimCurrent, switchHomeFileSymlinks, assertIsolationBoundary } from './shims.js';
 const IMPORT_VERSION_RE = /^(?:latest|[A-Za-z0-9._+-]{1,64})$/;
 export function isValidImportVersion(version) {
     return IMPORT_VERSION_RE.test(version);
@@ -39,6 +39,12 @@ export async function importAgentConfig(agentId, version) {
     if (!isValidImportVersion(version)) {
         return { success: false, error: `Invalid version: ${JSON.stringify(version)}` };
     }
+    // Adoption, done inline rather than via switchConfigSymlink — so it needs the gate
+    // directly. commands/import.ts checks at its entry point too (it must: it registers
+    // a normal version first, which would un-protect the agent before this runs), but
+    // an exported function that moves the user's real config must not depend on every
+    // future caller remembering.
+    assertIsolationBoundary(agentId, 'adopt your existing install');
     const agent = AGENTS[agentId];
     const configDir = agent.configDir;
     const versionsDir = getVersionsDir();
@@ -237,3 +243,69 @@ export function resolvePackageDirFromBinary(binaryPath) {
         return null;
     }
 }
+/**
+ * Seed an ISOLATED version's home from the user's real `~/.<agent>` — the mirror of
+ * {@link importAgentConfig}, which adopts.
+ *
+ * The difference is the whole point: this COPIES and leaves the original in place,
+ * never symlinks it, never sets a default, never creates a shim. So an isolated copy
+ * can start from the setup the user already has instead of from nothing, which was
+ * the only way to get a working sandbox before.
+ *
+ * Credentials are skipped by default and reported, not silently included. An isolated
+ * copy is a separate principal — `agents add --isolated` already tells the user to
+ * sign in on first run — and copying tokens into it should be a choice, not a side
+ * effect of wanting your settings. `--with-auth` opts in.
+ */
+export function seedIsolatedConfigFromLocal(agentId, version, opts = {}) {
+    const agent = AGENTS[agentId];
+    const configDir = agent.configDir;
+    const versionHome = path.join(getVersionsDir(), agentId, version, 'home');
+    // Mirror importAgentConfig's derivation so nested config dirs (e.g. Antigravity's
+    // ~/.gemini/antigravity-cli) land where the shim expects them.
+    const dest = path.join(versionHome, path.relative(os.homedir(), configDir));
+    const result = { seeded: false, from: configDir, to: dest, skippedAuth: [] };
+    if (!fs.existsSync(configDir))
+        return result;
+    // Known credential paths, relative to the config dir. `authFiles` covers the agents
+    // that declare them for cross-version carry; the rest are verified filenames for
+    // agents that do not declare any (codex `auth.json`, claude `.credentials.json`).
+    const authRel = new Set([
+        ...(agent.authFiles ?? []),
+        'auth.json',
+        '.credentials.json',
+        'credentials.json',
+    ]);
+    try {
+        fs.mkdirSync(path.dirname(dest), { recursive: true });
+        const agentsDir = getUserAgentsDir();
+        const inside = agentsDir + path.sep;
+        fs.cpSync(configDir, dest, {
+            recursive: true,
+            filter: (src) => {
+                const rel = path.relative(configDir, src);
+                if (!opts.withAuth && rel && (authRel.has(rel) || rel.startsWith('credentials' + path.sep))) {
+                    result.skippedAuth.push(rel);
+                    return false;
+                }
+                // Same rule as the export path: a link into ~/.agents would dangle for a copy
+                // that is supposed to stand on its own.
+                try {
+                    const st = fs.lstatSync(src);
+                    if (st.isSymbolicLink()) {
+                        const tgt = path.resolve(path.dirname(src), fs.readlinkSync(src));
+                        if (tgt === agentsDir || tgt.startsWith(inside))
+                            return false;
+                    }
+                }
+                catch { /* let cpSync surface unreadable entries */ }
+                return true;
+            },
+        });
+        result.seeded = true;
+    }
+    catch (err) {
+        return { ...result, error: err.message };
+    }
+    return result;
+}

package/dist/lib/isolation-boundary-report.d.ts

@@ -0,0 +1,10 @@
+import { IsolationBoundaryError } from './shims.js';
+/**
+ * Turn an {@link IsolationBoundaryError} into guidance. The boundary is enforced by a
+ * throw so it cannot be forgotten; this is what keeps that from surfacing as a stack
+ * trace. The remedy is always the same shape, because the protection is derived from
+ * the isolated copies themselves: drop them and the agent is ordinary again.
+ */
+export declare function explainIsolationBoundary(err: IsolationBoundaryError): void;
+/** Run `fn`, converting a boundary refusal into guidance + a non-zero exit. */
+export declare function withIsolationBoundary<T>(fn: () => Promise<T> | T): Promise<T | undefined>;

package/dist/lib/isolation-boundary-report.js

@@ -0,0 +1,35 @@
+import chalk from 'chalk';
+import { IsolationBoundaryError } from './shims.js';
+import { listInstalledVersions } from './versions.js';
+/**
+ * Turn an {@link IsolationBoundaryError} into guidance. The boundary is enforced by a
+ * throw so it cannot be forgotten; this is what keeps that from surfacing as a stack
+ * trace. The remedy is always the same shape, because the protection is derived from
+ * the isolated copies themselves: drop them and the agent is ordinary again.
+ */
+export function explainIsolationBoundary(err) {
+    const versions = listInstalledVersions(err.agent);
+    console.error(chalk.red(`\n${err.agent} is installed only as isolated copies.`));
+    console.error(chalk.gray(`  Refused: ${err.operation} — that is exactly what --isolated promises not to do.`));
+    console.error(chalk.gray('\n  To keep the sandbox and act inside it:'));
+    console.error(chalk.gray(`    agents add ${err.agent}@<version> --isolated    # another isolated copy`));
+    console.error(chalk.gray(`    agents use ${err.agent}@<version>               # pick which one 'agents run ${err.agent}' uses`));
+    console.error(chalk.gray(`    agents export ${err.agent}                      # copy its config out to your real config dir`));
+    console.error(chalk.gray('\n  To manage this agent normally instead, remove the isolated copies first:'));
+    for (const v of versions) {
+        console.error(chalk.gray(`    agents remove ${err.agent}@${v} --isolated`));
+    }
+}
+/** Run `fn`, converting a boundary refusal into guidance + a non-zero exit. */
+export async function withIsolationBoundary(fn) {
+    try {
+        return await fn();
+    }
+    catch (err) {
+        if (err instanceof IsolationBoundaryError) {
+            explainIsolationBoundary(err);
+            process.exit(1);
+        }
+        throw err;
+    }
+}

package/dist/lib/menubar/install-menubar.js

@@ -20,7 +20,7 @@ import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
 import { getRuntimeStateDir, getHelpersDir } from '../state.js';
-import { getCliVersion } from '../version.js';
+import { getCliVersion, resolveAgentsBin, resolveInstalledLayout } from '../version.js';
 const APP_BUNDLE_NAME = 'MenubarHelper.app';
 const INSTALL_DIR_NAME = 'agents-cli';
 const SERVICE_LABEL = 'com.phnx-labs.agents-menubar';
@@ -78,6 +78,10 @@ export function menubarServiceInstalled() {
  *   1. dist/lib/menubar/MenubarHelper.app — npm install layout (sibling of this file)
  *   2. <repo>/bin/MenubarHelper.app       — raw working tree (tsx/dev)
  *   3. apps/cli/menubar/dist/MenubarHelper.app — fresh local build
+ *   4. <on-disk install>/dist/lib/menubar/MenubarHelper.app — Bun single-file
+ *      binary: `import.meta.url` is a virtual `/$bunfs/` path, so the sibling
+ *      candidates above can't see the on-disk bundle; recover it via the
+ *      `agents` launcher symlink.
  */
 function sourceAppPath() {
     const candidates = [];
@@ -94,25 +98,15 @@ function sourceAppPath() {
         if (fs.existsSync(c))
             return c;
     }
-    return null;
-}
-/** Resolve the `agents` launcher binary on PATH-less GUI processes. */
-function resolveAgentsBin() {
-    const home = os.homedir();
-    const candidates = [
-        path.join(home, '.local', 'bin', 'agents'),
-        '/opt/homebrew/bin/agents',
-        '/usr/local/bin/agents',
-        path.join(home, '.npm-global', 'bin', 'agents'),
-    ];
-    for (const c of candidates) {
-        try {
-            fs.accessSync(c, fs.constants.X_OK);
-            return c;
-        }
-        catch {
-            /* try next */
-        }
+    // Candidate 4 — only reached when the sibling candidates miss (the Bun
+    // single-file binary, whose `import.meta.url` is a virtual `/$bunfs/` path).
+    // Resolve the launcher symlink lazily so the common Node path pays no extra
+    // filesystem probe.
+    const layout = resolveInstalledLayout();
+    if (layout) {
+        const p = path.join(layout.distDir, 'lib', 'menubar', APP_BUNDLE_NAME);
+        if (fs.existsSync(p))
+            return p;
     }
     return null;
 }

package/dist/lib/notify.d.ts

@@ -11,6 +11,7 @@ export interface NotifyResult {
     skipped?: boolean;
     error?: string;
 }
+export declare function formatUrgentBlockMessage(block: OpenBlock): string;
 /** Build openclaw argv for urgent notify (exported for tests). */
 export declare function buildOpenClawNotifyArgs(text: string, options?: Pick<NotifyOptions, 'channel' | 'account' | 'target'>): string[];
 export declare function notifyUrgentBlock(block: OpenBlock, options?: NotifyOptions): Promise<NotifyResult>;

package/dist/lib/notify.js

@@ -9,14 +9,14 @@
 import { execFile } from 'child_process';
 import { promisify } from 'util';
 const execFileAsync = promisify(execFile);
-function formatBlock(block) {
+export function formatUrgentBlockMessage(block) {
     const q = block.questions[0];
     const header = q?.header ? `[${q.header}] ` : '';
     const text = q?.text ?? 'Agent needs input';
     const host = block.host ? ` on ${block.host}` : '';
     const cls = block.blockClass ?? 'approval';
     const cost = block.costOfDelay ?? 'low';
-    return `🚨 ${cls.toUpperCase()}${host} — ${header}${text} (cost: ${cost}, id: ${block.blockId})`;
+    return `URGENT ${cls.toUpperCase()}${host}: ${header}${text} (cost: ${cost}, id: ${block.blockId})`;
 }
 /** Build openclaw argv for urgent notify (exported for tests). */
 export function buildOpenClawNotifyArgs(text, options = {}) {
@@ -50,7 +50,7 @@ export async function notifyUrgentBlock(block, options = {}) {
     catch {
         return { ok: false, error: 'openclaw CLI not found on PATH' };
     }
-    const text = formatBlock(block);
+    const text = formatUrgentBlockMessage(block);
     try {
         await execFileAsync('openclaw', buildOpenClawNotifyArgs(text, options));
         return { ok: true };

package/dist/lib/open-url.d.ts

@@ -0,0 +1,2 @@
+/** Best-effort: open a URL in the user's default browser. Never throws. */
+export declare function openUrl(url: string): void;

package/dist/lib/open-url.js

@@ -0,0 +1,19 @@
+/**
+ * Open a URL in the user's default browser, cross-platform. Best-effort and
+ * detached — never throws and never blocks the caller. Shared by `agents lease`
+ * (Hetzner console) and `agents fleet login` (the local login dashboard).
+ */
+import { spawn } from 'child_process';
+/** Best-effort: open a URL in the user's default browser. Never throws. */
+export function openUrl(url) {
+    const cmd = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'cmd' : 'xdg-open';
+    const args = process.platform === 'win32' ? ['/c', 'start', '', url] : [url];
+    try {
+        const p = spawn(cmd, args, { stdio: 'ignore', detached: true });
+        p.on('error', () => { });
+        p.unref();
+    }
+    catch {
+        /* best-effort */
+    }
+}

package/dist/lib/openclaw-keychain.d.ts

@@ -0,0 +1,56 @@
+import { type SpawnSyncOptions } from 'child_process';
+export declare const OPENCLAW_KEYCHAIN_ACCOUNT = "openclaw";
+export declare const OPENCLAW_KEYCHAIN_PROVIDER = "agents_keychain";
+export declare const OPENCLAW_KEYCHAIN_ENV_SERVICES: Record<string, string>;
+export interface OpenClawSecretRef {
+    source: 'exec';
+    provider: string;
+    id: string;
+}
+export interface OpenClawKeychainMigrationOptions {
+    account?: string;
+    provider?: string;
+    agentsBin?: string;
+}
+export interface OpenClawKeychainMigrationResult {
+    services: Array<{
+        envKey: string;
+        service: string;
+        value: string;
+    }>;
+    replacedPaths: string[];
+    removedEnvPaths: string[];
+    unsupportedEnvKeys: string[];
+    changed: boolean;
+}
+interface JsonObject {
+    [key: string]: unknown;
+}
+export declare function migrateOpenClawConfigToKeychainRefs(config: JsonObject, opts?: OpenClawKeychainMigrationOptions): OpenClawKeychainMigrationResult;
+export declare function buildOpenClawKeychainStoreInvocation(service: string, value: string, account?: string): {
+    command: string;
+    args: string[];
+    options: SpawnSyncOptions & {
+        input: string;
+        detached: boolean;
+    };
+};
+export declare function storeOpenClawKeychainServices(services: Array<{
+    service: string;
+    value: string;
+}>, account?: string): void;
+export declare function readOpenClawKeychainService(service: string, account?: string): string;
+export interface OpenClawExecResolverRequest {
+    protocolVersion?: number;
+    provider?: string;
+    ids?: unknown;
+}
+export interface OpenClawExecResolverResponse {
+    protocolVersion: 1;
+    values: Record<string, string>;
+    errors?: Record<string, {
+        code: string;
+    }>;
+}
+export declare function resolveOpenClawKeychainRequest(request: OpenClawExecResolverRequest, lookup: (service: string) => string): OpenClawExecResolverResponse;
+export {};