openclaw-openagent 1.0.0 → 1.0.2

package/dist/src/plugin-ui/ui-extension-loader/removed-extensions.d.ts

@@ -0,0 +1,8 @@
+export type RemovedRevertResult = 'none' | 'restored' | 'failed';
+export type RemovedUIExtension = {
+    id: string;
+    /** Which shared file group this removed extension belongs to (if any). */
+    sharedFile?: string;
+    revert(controlUiDir: string): RemovedRevertResult;
+};
+export declare const REMOVED_UI_EXTENSIONS: RemovedUIExtension[];

package/dist/src/plugin-ui/ui-extension-loader/removed-extensions.js

@@ -0,0 +1,58 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { logger } from '../../util/logger.js';
+import { findFileByPrefix, resolveOpenClawDistDir } from './locator.js';
+import { restoreFile } from './backup.js';
+function fileNeedsRemoval(filepath, id, fingerprints) {
+    const content = readFileSync(filepath, 'utf-8');
+    return content.includes(`/*openagent:${id}`) || fingerprints.some(fp => content.includes(fp));
+}
+function restoreRemovedPatch(filepath, id, fingerprints) {
+    if (!filepath)
+        return 'none';
+    if (!fileNeedsRemoval(filepath, id, fingerprints))
+        return 'none';
+    const restored = restoreFile(filepath);
+    if (!restored) {
+        logger.warn(`[ui-ext] ${id}: removed extension is present but no backup exists; refusing to continue`);
+        return 'failed';
+    }
+    logger.info(`[ui-ext] ${id}: removed extension reverted from backup`);
+    return 'restored';
+}
+export const REMOVED_UI_EXTENSIONS = [
+    {
+        id: 'gateway-openagent-tool-payload',
+        revert(controlUiDir) {
+            const distDir = resolveOpenClawDistDir(controlUiDir);
+            const gatewayPath = distDir ? findFileByPrefix(distDir, 'gateway-cli-') : null;
+            return restoreRemovedPatch(gatewayPath, this.id, [
+                '__openagentToolCallIds',
+                '__openagentKeepToolPayload',
+                '__openagentEffectiveToolVerbose',
+            ]);
+        },
+    },
+    {
+        id: 'agent-event-openagent-tool-result',
+        revert(controlUiDir) {
+            const distDir = resolveOpenClawDistDir(controlUiDir);
+            const agentBundlePath = distDir ? findFileByPrefix(distDir, 'auth-profiles-') : null;
+            return restoreRemovedPatch(agentBundlePath, this.id, [
+                '__openagentIsRemoteToolName',
+            ]);
+        },
+    },
+    {
+        id: 'marked-expose',
+        sharedFile: 'index-bundle',
+        revert(controlUiDir) {
+            const assetsDir = join(controlUiDir, 'assets');
+            const bundlePath = findFileByPrefix(assetsDir, 'index-');
+            return restoreRemovedPatch(bundlePath, this.id, [
+                'window.__openagentMarked=',
+                '__openagentMarked',
+            ]);
+        },
+    },
+];

package/dist/src/plugin-ui/ui-extension-loader/types.d.ts

@@ -0,0 +1,55 @@
+/**
+ * UIExtension 类型定义与注册表
+ *
+ * 每个 UIExtension 是一个独立的、可增删的扩展点。
+ * 框架只关心 id 和 version，具体操作由 apply/revert 内部处理。
+ */
+export interface UIExtension {
+    /** 唯一标识（如 'override-script'、'html-script-tag'） */
+    id: string;
+    /** 内容版本，改了 apply 逻辑就递增 */
+    version: number;
+    /**
+     * 共享文件标识（可选）。
+     *
+     * 多个扩展修改同一文件时（如 toolcard-render 和 toolcallid-propagate 都改 index-*.js），
+     * 设置相同的 sharedFile 值。reconciler 会把它们作为一组处理：
+     * 任何一个需要变更 → 恢复 backup → 重新 apply 全组中应保留的扩展。
+     *
+     * 不设置此字段的扩展独立 apply/revert，不受其他扩展影响。
+     */
+    sharedFile?: string;
+    /**
+     * 每次启动都调用 apply（可选）。
+     *
+     * 默认行为：manifest version 匹配时跳过 apply。
+     * 设为 true 后：即使 version 不变也调用 apply，由 apply 内部判断是否需要操作。
+     * 适用于内容可能独立于 version 变化的扩展（如 override-script 的产物文件）。
+     */
+    alwaysApply?: boolean;
+    /**
+     * 加载扩展。
+     * 接收 control-ui 目录路径，内部自行决定改什么文件、怎么改。
+     * 返回 true 表示成功，false 表示失败（不写入 manifest，下次重试）。
+     */
+    apply: (controlUiDir: string) => boolean;
+    /**
+     * 卸载扩展。
+     * 还原 apply 所做的全部修改。
+     * 注意：共享文件的扩展不应单独调用 revert，由 reconciler 统一处理。
+     */
+    revert: (controlUiDir: string) => void;
+}
+/**
+ * OpenAgent 标记前缀，注入的代码旁加此注释以标识修改来源。
+ * 格式：/*openagent:<extension-id>* /
+ */
+export declare const OPENAGENT_MARKER_PREFIX = "/*openagent:";
+/**
+ * 生成标记注释。
+ */
+export declare function makeMarker(extensionId: string): string;
+/**
+ * 检查内容中是否包含指定扩展点的标记。
+ */
+export declare function hasMarker(content: string, extensionId: string): boolean;

package/dist/src/plugin-ui/ui-extension-loader/types.js

@@ -0,0 +1,23 @@
+/**
+ * UIExtension 类型定义与注册表
+ *
+ * 每个 UIExtension 是一个独立的、可增删的扩展点。
+ * 框架只关心 id 和 version，具体操作由 apply/revert 内部处理。
+ */
+/**
+ * OpenAgent 标记前缀，注入的代码旁加此注释以标识修改来源。
+ * 格式：/*openagent:<extension-id>* /
+ */
+export const OPENAGENT_MARKER_PREFIX = '/*openagent:';
+/**
+ * 生成标记注释。
+ */
+export function makeMarker(extensionId) {
+    return `/*openagent:${extensionId}*/`;
+}
+/**
+ * 检查内容中是否包含指定扩展点的标记。
+ */
+export function hasMarker(content, extensionId) {
+    return content.includes(makeMarker(extensionId));
+}

package/dist/src/proxy/auth-proxy.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Auth API Proxy — Gateway-side reverse proxy for auth.ai-talk.live
+ *
+ * Eliminates CSP connect-src patching by proxying browser requests
+ * through a same-origin plugin HTTP route:
+ *
+ *   Browser: fetch('/plugins/openagent/api/agents')
+ *     → Gateway plugin-http stage
+ *     → this handler
+ *     → fetch('https://auth.ai-talk.live/api/agents')
+ *     → response back to browser
+ *
+ * Registered via api.registerHttpRoute() in index.ts.
+ * See: docs/audit/022-A-loader-audit-v1.md §4.7–4.10
+ */
+import type { IncomingMessage, ServerResponse } from 'node:http';
+/** Returns the gateway base URL as seen by the browser (e.g. http://localhost:18794). */
+export declare function getGatewayBaseUrl(): string;
+export declare function createAuthProxyHandler(): (req: IncomingMessage, res: ServerResponse) => Promise<boolean>;
+export declare function isAllowedOasnProxyRequest(method: string, pathname: string): boolean;

package/dist/src/proxy/auth-proxy.js

@@ -0,0 +1,337 @@
+/**
+ * Auth API Proxy — Gateway-side reverse proxy for auth.ai-talk.live
+ *
+ * Eliminates CSP connect-src patching by proxying browser requests
+ * through a same-origin plugin HTTP route:
+ *
+ *   Browser: fetch('/plugins/openagent/api/agents')
+ *     → Gateway plugin-http stage
+ *     → this handler
+ *     → fetch('https://auth.ai-talk.live/api/agents')
+ *     → response back to browser
+ *
+ * Registered via api.registerHttpRoute() in index.ts.
+ * See: docs/audit/022-A-loader-audit-v1.md §4.7–4.10
+ */
+import fs from 'node:fs';
+import nodePath from 'node:path';
+import { logger } from '../util/logger.js';
+import { registry } from '../runtime/registry.js';
+import { isUnconfiguredOasnApiBase } from '../auth/config.js';
+/** TIM 路径默认上游（兼容旧版） */
+const AUTH_UPSTREAM_TIM = 'https://auth.ai-talk.live';
+const PROXY_TIMEOUT_MS = 15_000;
+const MAX_BODY_BYTES = 64 * 1024; // 64KB — tagline API body is ~100 bytes
+/**
+ * 根据当前 active runtime 的 transport 类型决定上游。
+ *
+ *   - transport='oasn'：Discovery/onboarding 用 account.apiBase；
+ *     Access-layer endpoint 用 account.accessApiBase（未配置时回落到 apiBase）
+ *   - transport='tim' 或无 active runtime：fallback 到 AUTH_UPSTREAM_TIM
+ *
+ * 浏览器侧 Agent Book 通过 /plugins/openagent/api/* 统一访问，由此处分流。
+ */
+function pickUpstream(method, pathname) {
+    const rt = registry.getDefault();
+    if (rt?.transportType === 'oasn') {
+        const apiBase = rt.config?.apiBase;
+        const accessApiBase = rt.config?.accessApiBase || apiBase;
+        const upstream = isAccessLayerProxyPath(method, pathname) ? accessApiBase : apiBase;
+        return isUnconfiguredOasnApiBase(upstream) ? null : upstream ?? null;
+    }
+    return AUTH_UPSTREAM_TIM;
+}
+// ── Gateway base URL detection ──────────────────────────────────────────
+// Captured from the first incoming HTTP request's Host header.
+// Handles Docker port mapping: container port ≠ host port.
+let _gatewayBaseUrl;
+/** Returns the gateway base URL as seen by the browser (e.g. http://localhost:18794). */
+export function getGatewayBaseUrl() {
+    return _gatewayBaseUrl ?? `http://localhost:18794`;
+}
+// ── Handler factory ─────────────────────────────────────────────────────
+export function createAuthProxyHandler() {
+    return async (req, res) => {
+        // Gateway strips the matched prefix; req.url is the path after prefix removal.
+        // E.g. /plugins/openagent/api/agents → req.url = /api/agents
+        const url = new URL(req.url ?? '/', `http://${req.headers.host ?? 'localhost'}`);
+        logger.info(`[proxy] RECEIVED: ${req.method} ${req.url}`);
+        // Capture the gateway's external base URL from the browser's request.
+        // Reads standard reverse-proxy headers for correct protocol/host detection:
+        //   - Local:  http://localhost:18794
+        //   - Docker: http://127.0.0.1:18794  (port mapped)
+        //   - Nginx:  https://oc6.openagent.club (X-Forwarded-Proto/Host)
+        if (!_gatewayBaseUrl && req.headers.host) {
+            const proto = req.headers['x-forwarded-proto']?.split(',')[0]?.trim() || 'http';
+            const host = req.headers['x-forwarded-host']?.split(',')[0]?.trim() || req.headers.host;
+            _gatewayBaseUrl = `${proto}://${host}`;
+            logger.info(`[proxy] Gateway base URL detected: ${_gatewayBaseUrl}`);
+        }
+        // ── T4: Serve local media files from /tmp/openclaw/openagent-media/ ──
+        // Files downloaded from remote agents via C2C are stored here.
+        // Tool result references them as MEDIA:http://localhost:PORT/plugins/openagent/media/{filename}
+        // to pass through the framework's filterToolResultMediaUrls (http URLs bypass whitelist check).
+        if (url.pathname.startsWith('/media/')) {
+            return serveLocalMedia(url.pathname, res);
+        }
+        // req.url may or may not have the /plugins/openagent prefix stripped by Gateway
+        // (behavior varies across Gateway versions), so strip it defensively.
+        let targetPath = url.pathname;
+        if (targetPath.startsWith('/plugins/openagent')) {
+            targetPath = targetPath.slice('/plugins/openagent'.length);
+        }
+        // v3.9+ 双轨抽象：上游按当前 transport 切换（OASN → api.oasn.ai；TIM → auth.ai-talk.live）
+        const method = req.method ?? 'GET';
+        const rt = registry.getDefault();
+        if (!rt && isOasnProxyPath(method, targetPath)) {
+            writeJson(res, 503, {
+                error: 'OASN account is not configured',
+                detail: 'Run openclaw-plugin-openagent-cli install to register this device before opening Agent Book.',
+            });
+            return true;
+        }
+        if (rt && rt.transportType !== 'oasn' && isOasnProxyPath(method, targetPath)) {
+            writeJson(res, 503, {
+                error: 'OASN transport is not active',
+                detail: 'Agent Book discovery requires an installed OASN account.',
+            });
+            return true;
+        }
+        if (rt?.transportType === 'oasn' && !isAllowedOasnProxyRequest(method, targetPath)) {
+            logger.warn(`[proxy] blocked OASN proxy path: ${method} ${targetPath}`);
+            writeJson(res, 403, { error: 'proxy path not allowed' });
+            return true;
+        }
+        const upstreamBase = pickUpstream(method, targetPath);
+        if (!upstreamBase) {
+            writeJson(res, 503, { error: 'OASN api_base is not configured' });
+            return true;
+        }
+        const targetUrl = new URL(targetPath + url.search, upstreamBase).href;
+        logger.info(`[proxy] ${method} ${url.pathname} → ${targetUrl}`);
+        try {
+            // Read request body for non-GET methods
+            let body;
+            if (method !== 'GET' && method !== 'HEAD') {
+                body = await readBody(req, MAX_BODY_BYTES);
+            }
+            // Forward to upstream with timeout
+            const upstream = await fetch(targetUrl, {
+                method,
+                headers: buildUpstreamHeaders(req),
+                body,
+                signal: AbortSignal.timeout(PROXY_TIMEOUT_MS),
+            });
+            // Relay response (binary-safe for images)
+            res.statusCode = upstream.status;
+            const contentType = upstream.headers.get('content-type');
+            if (contentType)
+                res.setHeader('Content-Type', contentType);
+            const buf = Buffer.from(await upstream.arrayBuffer());
+            res.end(buf);
+            logger.info(`[proxy] ${method} ${url.pathname} → ${upstream.status} (${buf.length} bytes)`);
+        }
+        catch (err) {
+            const msg = err.message;
+            logger.warn(`[proxy] ${method} ${targetUrl} failed: ${msg}`);
+            if (!res.headersSent) {
+                writeJson(res, 502, { error: 'proxy upstream failed', detail: msg });
+            }
+        }
+        return true;
+    };
+}
+// ── T4: Local media serve ────────────────────────────────────────────────
+const MEDIA_DIR = '/tmp/openclaw/openagent-media';
+/** MIME type lookup for common media extensions. */
+const MIME_MAP = {
+    '.mp3': 'audio/mpeg',
+    '.wav': 'audio/wav',
+    '.ogg': 'audio/ogg',
+    '.m4a': 'audio/mp4',
+    '.mp4': 'video/mp4',
+    '.webm': 'video/webm',
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.webp': 'image/webp',
+    '.pdf': 'application/pdf',
+    '.txt': 'text/plain',
+};
+/**
+ * Serve a file from the local openagent-media directory.
+ * Used by T4 remote file transfer — tool result references files as
+ * MEDIA:http://localhost:PORT/plugins/openagent/media/{filename}
+ *
+ * @returns true (request handled)
+ */
+function serveLocalMedia(pathname, res) {
+    // /media/{filename} → {filename}  (prefix already stripped by Gateway)
+    const raw = pathname.replace('/media/', '');
+    const fileName = decodeURIComponent(raw);
+    // Security: block path traversal, null bytes, and directory components
+    if (!fileName || fileName.includes('..') || fileName.includes('/') || fileName.includes('\\') || fileName.includes('\0')) {
+        logger.warn(`[proxy/media] Blocked unsafe path: ${raw}`);
+        res.statusCode = 400;
+        res.end('Bad request');
+        return true;
+    }
+    const filePath = nodePath.join(MEDIA_DIR, fileName);
+    // Double-check: resolved path must stay within MEDIA_DIR
+    if (!nodePath.resolve(filePath).startsWith(nodePath.resolve(MEDIA_DIR) + nodePath.sep) &&
+        nodePath.resolve(filePath) !== nodePath.resolve(MEDIA_DIR)) {
+        logger.warn(`[proxy/media] Path escape attempt: ${fileName} → ${filePath}`);
+        res.statusCode = 400;
+        res.end('Bad request');
+        return true;
+    }
+    if (!fs.existsSync(filePath)) {
+        logger.debug(`[proxy/media] File not found: ${filePath}`);
+        res.statusCode = 404;
+        res.end('Not found');
+        return true;
+    }
+    try {
+        const ext = nodePath.extname(fileName).toLowerCase();
+        const contentType = MIME_MAP[ext] ?? 'application/octet-stream';
+        const stat = fs.statSync(filePath);
+        res.setHeader('Content-Type', contentType);
+        res.setHeader('Content-Length', stat.size);
+        // Allow browser to cache media for 1 hour
+        res.setHeader('Cache-Control', 'private, max-age=3600');
+        const stream = fs.createReadStream(filePath);
+        stream.pipe(res);
+        stream.on('error', (err) => {
+            logger.error(`[proxy/media] Stream error: ${err.message} file=${fileName}`);
+            if (!res.headersSent) {
+                res.statusCode = 500;
+                res.end('Internal error');
+            }
+        });
+        logger.info(`[proxy/media] Serving ${fileName} (${contentType}, ${stat.size} bytes)`);
+    }
+    catch (err) {
+        logger.error(`[proxy/media] Error serving ${fileName}: ${err.message}`);
+        if (!res.headersSent) {
+            res.statusCode = 500;
+            res.end('Internal error');
+        }
+    }
+    return true;
+}
+// ── Helpers ──────────────────────────────────────────────────────────────
+/**
+ * Build headers for the upstream request.
+ * Forwards Content-Type and Authorization (needed by tagline API).
+ *
+ * OASN 模式：浏览器端没有 api_key，代理自动注入 Bearer token。
+ * TIM 模式：转发浏览器自带的 Authorization（如有）。
+ */
+function buildUpstreamHeaders(req) {
+    const headers = {};
+    const ct = req.headers['content-type'];
+    if (ct)
+        headers['Content-Type'] = ct;
+    const rt = registry.getDefault();
+    if (rt?.transportType === 'oasn') {
+        if (rt.config?.apiKey)
+            headers['Authorization'] = `Bearer ${rt.config.apiKey}`;
+        return headers;
+    }
+    // TIM mode: keep forwarding browser Authorization for the legacy auth API.
+    const auth = req.headers['authorization'];
+    if (auth) {
+        headers['Authorization'] = auth;
+    }
+    return headers;
+}
+export function isAllowedOasnProxyRequest(method, pathname) {
+    const m = method.toUpperCase();
+    const p = pathname.startsWith('/') ? pathname : `/${pathname}`;
+    const isRead = m === 'GET' || m === 'HEAD';
+    if (isRead && p === '/api/agent-card-categories')
+        return true;
+    if (isRead && /^\/api\/agent-cards\/[^/]+$/.test(p))
+        return true;
+    if (m === 'POST' && /^\/api\/agent-cards\/search\/(by-query|by-category|by-tags)$/.test(p))
+        return true;
+    if (isRead && /^\/api\/agents\/[^/]+$/.test(p))
+        return true;
+    if (m === 'POST' && p === '/api/agents/claim')
+        return true;
+    if (m === 'POST' && p === '/api/invocations')
+        return true;
+    if (isRead && /^\/api\/invocations\/[^/]+$/.test(p))
+        return true;
+    if (m === 'POST' && p === '/api/files')
+        return true;
+    if (isRead && /^\/api\/artifacts\/[^/]+\/content$/.test(p))
+        return true;
+    if (isRead && p.startsWith('/avatars/'))
+        return true;
+    return false;
+}
+function isAccessLayerProxyPath(method, pathname) {
+    const m = method.toUpperCase();
+    const p = pathname.startsWith('/') ? pathname : `/${pathname}`;
+    const isRead = m === 'GET' || m === 'HEAD';
+    if (m === 'POST' && p === '/api/invocations')
+        return true;
+    if (isRead && /^\/api\/invocations\/[^/]+$/.test(p))
+        return true;
+    if (m === 'POST' && p === '/api/files')
+        return true;
+    if (isRead && /^\/api\/artifacts\/[^/]+\/content$/.test(p))
+        return true;
+    return false;
+}
+function isOasnProxyPath(method, pathname) {
+    const m = method.toUpperCase();
+    const p = pathname.startsWith('/') ? pathname : `/${pathname}`;
+    const isRead = m === 'GET' || m === 'HEAD';
+    if (isRead && p === '/api/agent-card-categories')
+        return true;
+    if (isRead && /^\/api\/agent-cards\/[^/]+$/.test(p))
+        return true;
+    if (m === 'POST' && /^\/api\/agent-cards\/search\/(by-query|by-category|by-tags)$/.test(p))
+        return true;
+    if (isRead && /^\/api\/agents\/[^/]+$/.test(p))
+        return true;
+    if (m === 'POST' && p === '/api/agents/claim')
+        return true;
+    if (m === 'POST' && p === '/api/invocations')
+        return true;
+    if (isRead && /^\/api\/invocations\/[^/]+$/.test(p))
+        return true;
+    if (m === 'POST' && p === '/api/files')
+        return true;
+    if (isRead && /^\/api\/artifacts\/[^/]+\/content$/.test(p))
+        return true;
+    return false;
+}
+function writeJson(res, statusCode, body) {
+    res.statusCode = statusCode;
+    res.setHeader('Content-Type', 'application/json');
+    res.end(JSON.stringify(body));
+}
+/**
+ * Read the request body with a size limit.
+ */
+function readBody(req, maxBytes) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        let total = 0;
+        req.on('data', (chunk) => {
+            total += chunk.length;
+            if (total > maxBytes) {
+                req.destroy();
+                reject(new Error(`Request body exceeds ${maxBytes} bytes`));
+                return;
+            }
+            chunks.push(chunk);
+        });
+        req.on('end', () => resolve(Buffer.concat(chunks).toString('utf-8')));
+        req.on('error', reject);
+    });
+}

package/dist/src/runtime/account.d.ts

@@ -0,0 +1,156 @@
+/**
+ * AccountRuntime — All per-account state and lifecycle
+ *
+ * Owns the lifecycle of a single active account:
+ *   1. StateStore (SQLite)
+ *   2. CredentialManager (auth token lifecycle)
+ *   3. TIMClient (SDK connection)
+ *   4. Message pipeline: channelRuntime dispatch (via process-message.ts)
+ *
+ * Supports "half-alive" mode: when agent is not yet claimed,
+ * start() succeeds without TIM connection. Tools trigger
+ * lazy connection via ensureConnected().
+ *
+ * v3.2.0: Replaced shell-out executor pipeline with channelRuntime dispatch.
+ * See docs/audit/004-messaging-pipeline-v3.1.4.md for migration context.
+ *
+ * v3.9.0: 引入 AgentTransport 双轨抽象。
+ *   - transport='oasn'（默认）：走 OASN HTTP API，不再创建 TIMClient
+ *   - transport='tim'（显式配置回退）：保留原 TIMClient + CredentialManager 路径
+ *   两条路径在 start() 内按 config.transport 字段分发；旧路径在阶段 4 上层切换完毕后再删除。
+ *   详见 docs/specs/2026-06-16-oasn-transport-abstraction-design.md §5.2
+ */
+import { StateStore } from '../state/store.js';
+import { TIMClient } from '../tim/client.js';
+import type { AgentTransport } from '../transport/types.js';
+import { type OpenagentAccountConfig, type TransportType } from '../auth/config.js';
+import type { ChannelInfo, MemberInfo } from '../tim/channels.js';
+import type { HistoryMessage, SendResult } from '../tim/messages.js';
+export declare class AccountRuntime {
+    readonly accountId: string;
+    store: StateStore | null;
+    client: TIMClient | null;
+    /**
+     * v3.9+ 双轨抽象：统一 transport 接口。
+     *
+     *   - transport='tim' 下：内部仍持有 TIMClient（this.client）作为 SDK 直连；
+     *     transport 实例额外提供能力接口，便于阶段 4 上层调用
+     *   - transport='oasn' 下：this.client 始终为 null，所有调用走 transport
+     *
+     * 阶段 4 完成后，上层将不再直接访问 this.client，只使用 this.transport。
+     */
+    transport: AgentTransport | null;
+    private credentialManager;
+    private _transportType;
+    private _claimStatus;
+    private _claimUrl;
+    private _claimExpiresAt;
+    private _caAccessToken;
+    private _statusPollTimer;
+    private _running;
+    private _config;
+    private _cfg;
+    private _connectingPromise;
+    constructor(accountId: string);
+    get isRunning(): boolean;
+    get config(): OpenagentAccountConfig | null;
+    /** v3.9+ 当前账号选择的 transport 类型（'oasn' | 'tim'） */
+    get transportType(): TransportType;
+    get claimStatus(): OpenagentAccountConfig['status'];
+    get claimUrl(): string;
+    get claimExpiresAt(): string;
+    get caAccessToken(): string | undefined;
+    get isOasnClaimed(): boolean;
+    /**
+     * Account startup with half-alive support.
+     *
+     * If agent is claimed: full startup (StateStore + TIM + pipeline).
+     * If agent is unclaimed: half-alive (StateStore only, _running = true).
+     *   Tools will trigger lazy connection via ensureConnected().
+     *
+     * IMPORTANT: This method NEVER throws for unclaimed/credential errors.
+     * It must return normally so channel.ts reaches the blocking await Promise,
+     * preventing OpenClaw auto-restart.
+     *
+     * @param cfg - Full OpenClaw config object, needed for channelRuntime APIs
+     */
+    start(account: OpenagentAccountConfig, _pipelineConfig?: {
+        batchWindowMs?: number;
+        maxBatchSize?: number;
+    }, cfg?: Record<string, unknown>): Promise<void>;
+    /**
+     * OASN 连接路径（v3.9+）。
+     *
+     * 与 _connectTIM 不同：
+     *   - 无 WebSocket，ready() 只校验 api_key 有效性（GET /api/agent-cards/{agent_id}）
+     *   - 不需要 channelRuntime 接管 'message' / 'c2c_request' 事件（OASN ClientAgent 不接收外来 Invocation）
+     *   - 'credential_expired' 事件由 OasnTransport 在 401 时触发，处理：清 transport + 标记 half-alive
+     */
+    private _connectOASN;
+    /**
+     * 将 OASN 账号状态持久化到 OpenClaw 配置文件。
+     *
+     * 写入位置：~/.openclaw/openclaw.json → channels.openagent.accounts.{accountId}
+     * 采用 merge 策略。CA access_token 永远只留在 runtime 内存，不写入配置。
+     */
+    private _saveOasnAccountConfig;
+    private _syncOasnStatus;
+    private _scheduleOasnStatusPolling;
+    private _stopOasnStatusPolling;
+    assertOasnInvocationAllowed(): void;
+    /**
+     * Connect TIM and wire the channelRuntime dispatch pipeline.
+     * Called by start() and ensureConnected().
+     */
+    private _connectTIM;
+    /**
+     * Ensure TIM is connected before executing a tool operation.
+     * If not connected, attempts lazy connection.
+     *
+     * v3.9+：OASN 路径下走 _connectOASN()；TIM 路径维持原行为。
+     *
+     * @throws CredentialError — propagated to tool, which returns a user-friendly message
+     */
+    ensureConnected(): Promise<void>;
+    /**
+     * Graceful shutdown of all modules.
+     */
+    stop(): Promise<void>;
+    private _cleanup;
+    /**
+     * @deprecated Pipeline batching is now handled by channelRuntime.
+     * Retained for backward compatibility with openagent_set_strategy tool.
+     */
+    updateStrategy(_config: {
+        batchWindowMs?: number;
+        maxBatchSize?: number;
+    }): {
+        batchWindowMs: number;
+        maxBatchSize: number;
+    };
+    /**
+     * @deprecated Scheduler queue no longer exists in channelRuntime mode.
+     */
+    get schedulerQueueSize(): number;
+    listChannels(): Promise<ChannelInfo[]>;
+    searchChannels(keyword: string): Promise<ChannelInfo[]>;
+    joinChannel(channelId: string): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    leaveChannel(channelId: string): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    getMembers(channelId: string): Promise<MemberInfo[]>;
+    createChannel(name: string, description?: string, skill?: string): Promise<{
+        success: boolean;
+        channelId: string;
+    }>;
+    getChannelSkill(channelId: string): Promise<string | null>;
+    setChannelSkill(channelId: string, skill: string): Promise<{
+        success: boolean;
+    }>;
+    sendMessage(channelId: string, text: string): Promise<SendResult>;
+    fetchMessages(channelId: string, count?: number): Promise<HistoryMessage[]>;
+}