openclaw-openagent 1.0.1 → 1.0.2

package/dist/src/transport/oasn/oasn-invocation.js

@@ -0,0 +1,432 @@
+/**
+ * OASN Invocation —— 任务调用 + 轮询订阅 ⭐
+ *
+ * 设计依据：
+ *   - docs/specs/2026-06-16-oasn-api-module-mapping.md §2.14 / §2.15
+ *   - docs/specs/2026-06-16-oasn-transport-abstraction-design.md
+ *       §11.1（idempotency_key 持久化）
+ *       §11.2（abort 与 cancel 缺失）
+ *       §11.3（timeoutMs ↔ effective_timeout_ms 协调）
+ *       §11.8（subscribeToInvocation 抽象 + SSE 升级）
+ *
+ * 子模块包含 3 个核心能力：
+ *
+ *   1. createInvocation()   POST /api/invocations
+ *      - 维护 idempotency_key（接受外部传入，便于 §11.1 持久化复用）
+ *      - 返回 invocation_id / session_id / effective_timeout_ms / next_poll_after_ms
+ *
+ *   2. subscribeToInvocation(id, opts)
+ *      - 默认实现 = 轮询循环
+ *      - 上层 waitForTaskResult 只调用此抽象，对推送/轮询无感知
+ *      - 后续可在此处理 SSE 升级（探测 Accept: text/event-stream），保持外部 API 不变
+ *
+ *   3. waitForTaskResult(handle, opts)
+ *      - 包装 subscribeToInvocation，转换为 TaskResult
+ *      - 终态时拉取 artifacts 列表（不下载内容，仅引用）
+ *      - 协调本地 timeoutMs 与服务端 effective_timeout_ms（§11.3）
+ *      - signal.aborted → 标记 abandoned（§11.2，不调用 cancel API 因为不存在）
+ */
+import { randomUUID } from 'node:crypto';
+import { logger } from '../../util/logger.js';
+import { makeTransportError, } from '../types.js';
+import { isInvocationTerminal, OASN_ENDPOINTS, } from './oasn-types.js';
+/** 轮询常量 —— 服务端 next_poll_after_ms 的下限保护，避免风暴 */
+const MIN_POLL_INTERVAL_MS = 500;
+/** 轮询间隔上限（防止服务端返回异常大值） */
+const MAX_POLL_INTERVAL_MS = 30_000;
+/** 当 next_poll_after_ms 缺失时使用的兜底值 */
+const FALLBACK_POLL_INTERVAL_MS = 2_000;
+export class OasnInvocation {
+    _http;
+    _pendingStore;
+    /** invocation_id → effective_timeout_ms（waitForTaskResult §11.3 用） */
+    _effectiveTimeoutMap = new Map();
+    /** invocation_id → 首轮 next_poll_after_ms */
+    _initialPollMap = new Map();
+    constructor(_http, _pendingStore) {
+        this._http = _http;
+        this._pendingStore = _pendingStore;
+    }
+    // ═══════════════════════════════════════════════════════════════
+    // sendTask（POST /api/invocations）
+    // ═══════════════════════════════════════════════════════════════
+    /**
+     * 创建 Invocation。
+     *
+     * 返回 TaskHandle —— 含 invocation_id / session_id / effective_timeout_ms / next_poll_after_ms。
+     * 上层将此 handle 传给 waitForTaskResult。
+     */
+    async sendTask(targetAgentId, task, options) {
+        // §11.1：尝试复用 pending 记录
+        let idempotencyKey;
+        let pendingRecord = null;
+        if (options?.toolCallId && this._pendingStore) {
+            pendingRecord = this._pendingStore.getPending(options.toolCallId);
+        }
+        if (pendingRecord) {
+            idempotencyKey = pendingRecord.idempotency_key;
+            logger.info(`[transport/oasn/invocation] reuse pending tool_call_id=${options?.toolCallId} `
+                + `idempotency_key=${idempotencyKey}`);
+        }
+        else {
+            idempotencyKey = randomUUID();
+        }
+        const body = {
+            idempotency_key: idempotencyKey,
+            service_agent_id: targetAgentId,
+            input: { task: task.task },
+        };
+        if (task.sessionId)
+            body.session_id = task.sessionId;
+        if (task.inputFileRefs?.length)
+            body.input_file_refs = task.inputFileRefs;
+        if (task.inputArtifactRefs?.length)
+            body.input_artifact_refs = task.inputArtifactRefs;
+        if (options?.timeoutMs !== undefined)
+            body.timeout_ms = options.timeoutMs;
+        if (options?.clientRequestGroupId)
+            body.client_request_group_id = options.clientRequestGroupId;
+        logger.info(`[transport/oasn/invocation] sendTask target=${targetAgentId} `
+            + `idempotency_key=${idempotencyKey} replay=${pendingRecord ? 'maybe' : 'new'}`);
+        // 注意：服务端按 idempotency_key 去重，重试是安全的；此处保留默认重试策略
+        const resp = await this._http.post(OASN_ENDPOINTS.INVOCATIONS, body);
+        const created = this._normalizeCreateInvocation(resp, options?.timeoutMs);
+        if (!created.invocationId) {
+            throw makeTransportError('INVALID_INVOCATION_RESPONSE', 'Create invocation response missing invocationId');
+        }
+        logger.info(`[transport/oasn/invocation] created invocation_id=${created.invocationId} `
+            + `status=${created.status} effective_timeout_ms=${created.effectiveTimeoutMs} `
+            + `replay=${created.idempotentReplay}`);
+        // 回填 pending 记录
+        if (options?.toolCallId && this._pendingStore) {
+            this._pendingStore.upsertPending({
+                tool_call_id: options.toolCallId,
+                idempotency_key: idempotencyKey,
+                invocation_id: created.invocationId,
+                session_id: created.sessionId,
+                target_agent_id: targetAgentId,
+                status: created.status,
+            });
+        }
+        // 缓存服务端裁决参数，留给 waitForTaskResult 使用
+        this._effectiveTimeoutMap.set(created.invocationId, created.effectiveTimeoutMs);
+        this._initialPollMap.set(created.invocationId, created.nextPollAfterMs);
+        return {
+            invocationId: created.invocationId,
+            sessionId: created.sessionId,
+            effectiveTimeoutMs: created.effectiveTimeoutMs,
+            nextPollAfterMs: created.nextPollAfterMs,
+        };
+    }
+    // ═══════════════════════════════════════════════════════════════
+    // subscribeToInvocation —— §11.8 抽象层
+    // ═══════════════════════════════════════════════════════════════
+    /**
+     * 订阅 Invocation 状态变化，直至终态或 abort/timeout。
+     *
+     * 当前实现：纯轮询循环。
+     * 后续若服务端支持 SSE，可在此函数内部探测升级，外部 API 保持不变。
+     *
+     * 返回 Promise，在终态/超时/abort 时 resolve（内部不抛错，错误由 onComplete 携带 final.status 判定）。
+     */
+    async subscribeToInvocation(invocationId, options) {
+        const { onProgress, onComplete, signal, totalTimeoutMs, initialPollAfterMs } = options;
+        const startAt = Date.now();
+        let nextDelay = this._clampPollInterval(initialPollAfterMs ?? this._initialPollMap.get(invocationId));
+        while (true) {
+            // ── abort 检查 ────────────────────────────────────────────
+            if (signal?.aborted) {
+                logger.warn(`[transport/oasn/invocation] subscribe aborted invocation_id=${invocationId}`);
+                // §11.2：服务端没有 cancel API，只能本地标记
+                this._pendingStore?.markAbandoned(invocationId);
+                // 用一个虚拟的"cancelled"终态通知上层
+                onComplete(this._buildAbandonedResponse(invocationId));
+                return;
+            }
+            // ── 总超时检查 ────────────────────────────────────────────
+            const elapsed = Date.now() - startAt;
+            if (elapsed >= totalTimeoutMs) {
+                logger.warn(`[transport/oasn/invocation] subscribe timed out invocation_id=${invocationId} `
+                    + `elapsed=${elapsed}ms limit=${totalTimeoutMs}ms`);
+                this._pendingStore?.markAbandoned(invocationId);
+                onComplete(this._buildTimeoutResponse(invocationId));
+                return;
+            }
+            // ── 等待下次轮询 ──────────────────────────────────────────
+            const remaining = totalTimeoutMs - elapsed;
+            const waitMs = Math.min(nextDelay, remaining);
+            await this._sleepWithAbort(waitMs, signal);
+            if (signal?.aborted)
+                continue; // 让下一轮迭代命中上面 abort 分支统一处理
+            // ── 拉取最新状态 ──────────────────────────────────────────
+            let resp;
+            try {
+                resp = await this._http.get(OASN_ENDPOINTS.INVOCATION(invocationId));
+            }
+            catch (err) {
+                const te = err;
+                // 404 当成 cancelled —— 服务端可能已清理
+                if (te.code === 'INVOCATION_NOT_FOUND' || te.code === 'HTTP_404') {
+                    logger.warn(`[transport/oasn/invocation] invocation gone: ${invocationId}`);
+                    onComplete(this._build404Response(invocationId));
+                    return;
+                }
+                // 其它错误：retryable 的等下一轮，否则向上抛
+                if (te.retryable) {
+                    logger.warn(`[transport/oasn/invocation] poll retryable error code=${te.code} for ${invocationId}, will retry`);
+                    // 延后下一轮（指数式，但不超过上限）
+                    nextDelay = this._clampPollInterval(nextDelay * 2);
+                    continue;
+                }
+                throw err;
+            }
+            // ── 进度推送 ───────────────────────────────────────────────
+            const safeStatusMessage = resp.progress?.safeStatusMessage ?? resp.progress?.safe_status_message;
+            if (onProgress && safeStatusMessage) {
+                try {
+                    onProgress({
+                        content: safeStatusMessage,
+                        raw: resp.progress,
+                    });
+                }
+                catch (cbErr) {
+                    // 不让回调异常影响轮询
+                    logger.warn(`[transport/oasn/invocation] onProgress callback threw: ${cbErr.message}`);
+                }
+            }
+            // ── 终态判定 ───────────────────────────────────────────────
+            if (isInvocationTerminal(resp.status)) {
+                logger.info(`[transport/oasn/invocation] terminal status=${resp.status} invocation_id=${invocationId}`);
+                this._pendingStore?.markTerminal(invocationId, resp.status);
+                onComplete(resp);
+                return;
+            }
+            // ── 决定下次轮询间隔 ──────────────────────────────────────
+            nextDelay = this._clampPollInterval(resp.nextPollAfterMs ?? resp.next_poll_after_ms ?? FALLBACK_POLL_INTERVAL_MS);
+        }
+    }
+    // ═══════════════════════════════════════════════════════════════
+    // waitForTaskResult —— 包装 subscribeToInvocation 为 TaskResult
+    // ═══════════════════════════════════════════════════════════════
+    /**
+     * 等待任务结果（终态后转换为 TaskResult）。
+     *
+     * §11.3 协调：
+     *   实际等待时间 = max(本地 timeoutMs, 服务端 effective_timeout_ms)
+     *   差距 > 30% 时输出 warn，提示用户调整。
+     */
+    async waitForTaskResult(handle, options) {
+        const effective = handle.effectiveTimeoutMs
+            ?? this._effectiveTimeoutMap.get(handle.invocationId)
+            ?? options.timeoutMs;
+        const totalTimeoutMs = Math.max(options.timeoutMs, effective);
+        // §11.3：差距超过 30% 时提示
+        if (effective > options.timeoutMs * 1.3) {
+            logger.warn(`[transport/oasn/invocation] effective_timeout_ms=${effective} exceeds local timeoutMs=${options.timeoutMs} `
+                + `by >30% (invocation_id=${handle.invocationId}); consider increasing local timeout`);
+        }
+        else if (options.timeoutMs > effective * 1.3) {
+            logger.warn(`[transport/oasn/invocation] local timeoutMs=${options.timeoutMs} exceeds effective_timeout_ms=${effective} `
+                + `by >30% (invocation_id=${handle.invocationId}); server may give up earlier`);
+        }
+        return new Promise((resolve, reject) => {
+            this.subscribeToInvocation(handle.invocationId, {
+                totalTimeoutMs,
+                signal: options.signal,
+                initialPollAfterMs: handle.nextPollAfterMs,
+                onProgress: options.onProgress
+                    ? (p) => options.onProgress({
+                        requestId: handle.invocationId,
+                        content: p.content,
+                    })
+                    : undefined,
+                onComplete: (final) => {
+                    try {
+                        const result = this._toTaskResult(handle.invocationId, final);
+                        // 终态错误转换为 reject，便于上层 catch
+                        if (result.status === 'error') {
+                            reject(this._terminalError(final, handle));
+                            return;
+                        }
+                        resolve(result);
+                    }
+                    catch (err) {
+                        reject(err);
+                    }
+                },
+            }).catch(reject);
+        });
+    }
+    // ═══════════════════════════════════════════════════════════════
+    // 内部工具
+    // ═══════════════════════════════════════════════════════════════
+    /**
+     * 把终态 Invocation 响应转换为 TaskResult。
+     *
+     *   - succeeded → status:'complete' + content=summary + artifacts + webuiContinuation
+     *   - 其它终态 → status:'error' + content=user_error.message
+     *
+     * content 的归一路径：
+     *   inlineResult.summary > visible_result.inline_result_summary > ''
+     *
+     * webui_continuation 仅在 succeeded 时抽取（失败场景后端不保证存在）。
+     */
+    _toTaskResult(invocationId, final) {
+        const webuiContinuation = this._toWebuiContinuation(final);
+        if (final.status === 'succeeded') {
+            const inlineResult = final.inlineResult ?? final.inline_result;
+            const visible = final.visibleResult ?? final.visible_result;
+            const summary = inlineResult?.summary
+                ?? visible?.inlineResultSummary
+                ?? visible?.inline_result_summary
+                ?? '';
+            return {
+                requestId: invocationId,
+                status: 'complete',
+                content: summary,
+                artifacts: (final.artifacts ?? []).map(this._toArtifactRef),
+                webuiContinuation,
+            };
+        }
+        // 失败/超时/取消 —— 文本统一用 user_error.message 兜底
+        const userError = final.userError ?? final.user_error;
+        const inlineResult = final.inlineResult ?? final.inline_result;
+        const visible = final.visibleResult ?? final.visible_result;
+        const message = userError?.message
+            ?? inlineResult?.summary
+            ?? visible?.inlineResultSummary
+            ?? visible?.inline_result_summary
+            ?? `Invocation ended with status=${final.status}`;
+        return {
+            requestId: invocationId,
+            status: 'error',
+            content: message,
+            artifacts: (final.artifacts ?? []).map(this._toArtifactRef),
+            webuiContinuation,
+        };
+    }
+    /**
+     * 从终态响应里抽取 WebUI continuation（camelCase / snake_case 双归一）。
+     * 缺必要字段（id / launch_url）时返回 undefined，调用方按 falsy 处理即可。
+     */
+    _toWebuiContinuation(final) {
+        const visible = final.visibleResult ?? final.visible_result;
+        const raw = visible?.webuiContinuation ?? visible?.webui_continuation;
+        if (!raw)
+            return undefined;
+        const id = raw.continuationId ?? raw.continuation_id;
+        const launchUrl = raw.launchUrl ?? raw.launch_url;
+        if (!id || !launchUrl)
+            return undefined;
+        return {
+            id,
+            launchUrl,
+            displayName: raw.displayName ?? raw.display_name ?? 'Open WebUI',
+            visibleState: raw.visibleState ?? raw.visible_state ?? 'available',
+            sessionId: raw.sessionId ?? raw.session_id,
+        };
+    }
+    /** 终态错误专用 TransportError，便于上层 catch */
+    _terminalError(final, handle) {
+        const userError = final.userError ?? final.user_error;
+        const code = userError?.code ?? `INVOCATION_${final.status.toUpperCase()}`;
+        const msg = userError?.message ?? `Invocation ${final.status}`;
+        return makeTransportError(code, msg, {
+            invocationId: handle.invocationId,
+            sessionId: handle.sessionId,
+        });
+    }
+    _toArtifactRef(art) {
+        return {
+            id: art.artifactId ?? art.artifact_id ?? '',
+            displayName: art.displayName ?? art.display_name ?? 'artifact',
+            mimeType: art.mimeType ?? art.mime_type ?? 'application/octet-stream',
+            sizeBytes: art.sizeBytes ?? art.size_bytes ?? 0,
+            contentAvailable: art.contentAvailable ?? art.content_available ?? false,
+            contentUrl: art.contentUrl ?? art.content_url ?? '',
+        };
+    }
+    _normalizeCreateInvocation(resp, requestedTimeoutMs) {
+        return {
+            invocationId: resp.invocationId ?? resp.invocation_id ?? '',
+            sessionId: resp.sessionId ?? resp.session_id,
+            status: resp.status,
+            effectiveTimeoutMs: resp.effectiveTimeoutMs ?? resp.effective_timeout_ms ?? requestedTimeoutMs ?? 0,
+            nextPollAfterMs: resp.nextPollAfterMs ?? resp.next_poll_after_ms ?? FALLBACK_POLL_INTERVAL_MS,
+            idempotentReplay: resp.idempotentReplay ?? resp.idempotent_replay ?? false,
+        };
+    }
+    /** clamp 轮询间隔到合理范围 */
+    _clampPollInterval(ms) {
+        if (!ms || ms <= 0)
+            return FALLBACK_POLL_INTERVAL_MS;
+        return Math.min(MAX_POLL_INTERVAL_MS, Math.max(MIN_POLL_INTERVAL_MS, ms));
+    }
+    /** 可被 abort 中断的 sleep */
+    _sleepWithAbort(ms, signal) {
+        return new Promise((resolve) => {
+            if (signal?.aborted) {
+                resolve();
+                return;
+            }
+            const t = setTimeout(() => {
+                if (signal)
+                    signal.removeEventListener('abort', onAbort);
+                resolve();
+            }, ms);
+            const onAbort = () => {
+                clearTimeout(t);
+                resolve();
+            };
+            signal?.addEventListener('abort', onAbort, { once: true });
+        });
+    }
+    /** abort 场景虚拟终态 —— 不调用服务端 cancel（API 不存在 §11.2） */
+    _buildAbandonedResponse(invocationId) {
+        const now = new Date().toISOString();
+        return {
+            invocation_id: invocationId,
+            session_id: '',
+            status: 'cancelled',
+            next_poll_after_ms: null,
+            created_at: now,
+            updated_at: now,
+            user_error: {
+                code: 'CLIENT_ABORTED',
+                message: '已发起调用但放弃跟踪结果（服务端可能仍在执行）',
+            },
+        };
+    }
+    /** timeout 虚拟终态 */
+    _buildTimeoutResponse(invocationId) {
+        const now = new Date().toISOString();
+        return {
+            invocation_id: invocationId,
+            session_id: '',
+            status: 'timed_out',
+            next_poll_after_ms: null,
+            created_at: now,
+            updated_at: now,
+            user_error: {
+                code: 'CLIENT_TIMEOUT',
+                message: '本地等待超时，服务端可能仍在执行',
+            },
+        };
+    }
+    /** invocation_id 不存在时的虚拟终态 */
+    _build404Response(invocationId) {
+        const now = new Date().toISOString();
+        return {
+            invocation_id: invocationId,
+            session_id: '',
+            status: 'cancelled',
+            next_poll_after_ms: null,
+            created_at: now,
+            updated_at: now,
+            user_error: {
+                code: 'INVOCATION_NOT_FOUND',
+                message: 'Invocation 不存在或已清理',
+            },
+        };
+    }
+}

package/dist/src/transport/oasn/oasn-normalize.d.ts

@@ -0,0 +1,6 @@
+import type { AgentCard, AgentStatusResult, CategoryTree, SearchResult } from '../types.js';
+import type { AgentCardResponse, AgentStatusResponse, CategoryTreeResponse, SearchResponse } from './oasn-types.js';
+export declare function normalizeAgentCard(resp: AgentCardResponse | unknown): AgentCard;
+export declare function normalizeAgentStatus(resp: AgentStatusResponse | unknown): AgentStatusResult;
+export declare function normalizeCategoryTree(resp: CategoryTreeResponse | unknown): CategoryTree;
+export declare function normalizeSearchResponse(resp: SearchResponse | unknown): SearchResult;

package/dist/src/transport/oasn/oasn-normalize.js

@@ -0,0 +1,112 @@
+function asRecord(value) {
+    return value && typeof value === 'object' ? value : {};
+}
+function pickString(record, ...keys) {
+    for (const key of keys) {
+        const value = record[key];
+        if (typeof value === 'string')
+            return value;
+    }
+    return '';
+}
+function pickNullableString(record, ...keys) {
+    for (const key of keys) {
+        const value = record[key];
+        if (typeof value === 'string')
+            return value;
+        if (value === null)
+            return null;
+    }
+    return null;
+}
+function pickNumber(record, fallback, ...keys) {
+    for (const key of keys) {
+        const value = record[key];
+        if (typeof value === 'number' && Number.isFinite(value))
+            return value;
+    }
+    return fallback;
+}
+function pickBoolean(record, fallback, ...keys) {
+    for (const key of keys) {
+        const value = record[key];
+        if (typeof value === 'boolean')
+            return value;
+    }
+    return fallback;
+}
+function pickRecord(record, ...keys) {
+    for (const key of keys) {
+        const value = record[key];
+        if (value && typeof value === 'object')
+            return value;
+    }
+    return {};
+}
+function pickArray(record, ...keys) {
+    for (const key of keys) {
+        const value = record[key];
+        if (Array.isArray(value))
+            return value;
+    }
+    return [];
+}
+function normalizeTag(value) {
+    if (typeof value === 'string')
+        return { tag_id: value, name: value };
+    const record = asRecord(value);
+    return {
+        tag_id: pickString(record, 'tagId', 'tag_id', 'id'),
+        name: pickString(record, 'name'),
+    };
+}
+export function normalizeAgentCard(resp) {
+    const record = asRecord(resp);
+    return {
+        agent_id: pickString(record, 'agentId', 'agent_id', 'id'),
+        agent_type: (pickString(record, 'agentType', 'agent_type') || 'service'),
+        name: pickString(record, 'name') || 'Unknown',
+        description: pickNullableString(record, 'description'),
+        MOM: pickNullableString(record, 'MOM'),
+        tags: pickArray(record, 'tags').map(normalizeTag).filter((tag) => tag.name || tag.tag_id),
+        category: pickArray(record, 'category'),
+        avatar_url: pickNullableString(record, 'avatarUrl', 'avatar_url', 'avatar'),
+        ...(pickString(record, 'visibility') ? { visibility: pickString(record, 'visibility') } : {}),
+    };
+}
+export function normalizeAgentStatus(resp) {
+    const record = asRecord(resp);
+    return {
+        agent_id: pickString(record, 'agentId', 'agent_id'),
+        status: pickString(record, 'status'),
+        ...(pickString(record, 'access_token', 'accessToken') ? {
+            access_token: pickString(record, 'access_token', 'accessToken'),
+        } : {}),
+    };
+}
+function normalizeCategoryNode(node) {
+    const record = asRecord(node);
+    return {
+        category_id: pickString(record, 'categoryId', 'category_id', 'id'),
+        name: pickString(record, 'name'),
+        children: pickArray(record, 'children').map(normalizeCategoryNode),
+    };
+}
+export function normalizeCategoryTree(resp) {
+    const record = asRecord(resp);
+    return {
+        categories: pickArray(record, 'categories').map(normalizeCategoryNode),
+        updated_at: pickString(record, 'updatedAt', 'updated_at'),
+    };
+}
+export function normalizeSearchResponse(resp) {
+    const record = asRecord(resp);
+    const cards = pickArray(record, 'agentCards', 'agent_cards');
+    return {
+        searchId: pickString(record, 'searchId', 'search_id'),
+        agentCards: cards.map(normalizeAgentCard),
+        pageNum: pickNumber(record, 1, 'pageNum', 'page_num'),
+        pageSize: pickNumber(record, cards.length, 'pageSize', 'page_size'),
+        hasNext: pickBoolean(record, false, 'hasNext', 'has_next'),
+    };
+}

package/dist/src/transport/oasn/oasn-register.d.ts

@@ -0,0 +1,19 @@
+/**
+ * OASN Agent 状态查询
+ *
+ * 设计依据：
+ *   - docs/specs/2026-06-16-oasn-api-module-mapping.md §2.3
+ *
+ * 注意：register 和 claim 已迁移到 CLI（openclaw-plugin-openagent-cli），
+ * 本模块仅保留 getStatus（GET /api/agents/{agent_id}）。
+ */
+import type { AgentStatusResult } from '../types.js';
+import type { OasnHttpClient } from './oasn-http.js';
+/**
+ * OASN Agent 状态查询模块。
+ */
+export declare class OasnAgentStatus {
+    private readonly _http;
+    constructor(_http: OasnHttpClient);
+    getStatus(agentId: string): Promise<AgentStatusResult>;
+}

package/dist/src/transport/oasn/oasn-register.js

@@ -0,0 +1,24 @@
+/**
+ * OASN Agent 状态查询
+ *
+ * 设计依据：
+ *   - docs/specs/2026-06-16-oasn-api-module-mapping.md §2.3
+ *
+ * 注意：register 和 claim 已迁移到 CLI（openclaw-plugin-openagent-cli），
+ * 本模块仅保留 getStatus（GET /api/agents/{agent_id}）。
+ */
+import { OASN_ENDPOINTS, } from './oasn-types.js';
+import { normalizeAgentStatus } from './oasn-normalize.js';
+/**
+ * OASN Agent 状态查询模块。
+ */
+export class OasnAgentStatus {
+    _http;
+    constructor(_http) {
+        this._http = _http;
+    }
+    async getStatus(agentId) {
+        const resp = await this._http.get(OASN_ENDPOINTS.AGENT_STATUS(agentId), { skipRetry: true });
+        return normalizeAgentStatus(resp);
+    }
+}