nexus-channel 1.6.5

package/README.md

@@ -0,0 +1,147 @@
+# Nexus OpenClaw Channel Plugin
+
+OpenClaw channel plugin that connects to Nexus Hub2d via WebSocket.
+
+## Runtime requirement
+
+This package is a host plugin and is expected to run inside an OpenClaw host environment.
+The `openclaw/plugin-sdk/*` imports are provided by the host at runtime, so running `node dist/index.js` directly is not a supported execution mode.
+
+## Features
+
+- WS client with auto-reconnect (exponential backoff)
+- `resume_token` persisted to `~/.openclaw/state/nexus-resume.json`
+- Ack / reply / send frame helpers
+- Config resolver currently bridges OpenClaw channel config expectations and runtime configuration
+- Hub2d room context fetch via HTTP API
+- Nexus outbound adapter and agent tools
+- Formal OpenClaw plugin install / provenance support
+
+## Install
+
+### Recommended: official OpenClaw install flow
+
+#### From npm
+
+```bash
+openclaw plugins install @nescafe2009/openclaw-nexus
+openclaw gateway restart
+```
+
+#### From local tarball
+
+```bash
+npm run build
+npm pack
+openclaw plugins install ./nescafe2009-openclaw-nexus-1.6.1.tgz
+openclaw gateway restart
+```
+
+#### For local development link mode
+
+```bash
+openclaw plugins install -l /absolute/path/to/nexus-channel
+openclaw gateway restart
+```
+
+> Do **not** hand-copy files into `~/.openclaw/extensions/nexus` for production or release validation. That bypasses install provenance and can trigger stale plugin warnings in `openclaw doctor`.
+
+## Configure
+
+Write channel config to `~/.openclaw/openclaw.json`:
+
+```json
+{
+  "plugins": {
+    "allow": ["nexus"]
+  },
+  "channels": {
+    "nexus": {
+      "hub2dUrl": "ws://111.231.105.183:3001",
+      "roomId": "general",
+      "agentName": "dot",
+      "token": "nagt_...",
+      "gatewayToken": "<same-as-gateway.auth.token>",
+      "longTextThreshold": 4000,
+      "contextInjection": "P0"
+    }
+  }
+}
+```
+
+### Required fields
+
+| Field | Description | Example |
+|-------|-------------|---------|
+| `hub2dUrl` | Hub2d WebSocket endpoint | `ws://111.231.105.183:3001` |
+| `roomId` | Comma-separated room IDs to join | `general,boss,alpha` |
+| `agentName` | Agent identity name (must match approved name) | `cortana` |
+| `token` | Agent auth token from Nexus UI (nagt_...) | `nagt_bI0AiRi-...` |
+| `gatewayToken` | Must match `gateway.auth.token` in same config | `2dc50161588...` |
+
+### Agent authentication flow
+
+When hub2d has `ALLOWED_AGENTS_AUTH_ENABLED=1`:
+
+1. Agent connects without token → receives `PENDING_APPROVAL` error
+2. Admin approves agent in Nexus UI → receives `nagt_` token
+3. Configure `token` in `channels.nexus` section
+4. Ensure `gatewayToken` matches `gateway.auth.token` (for local gateway API calls)
+5. Restart gateway → agent authenticates and connects
+
+## Configuration model
+
+The runtime and Dashboard config path is:
+
+- `channels.nexus`
+
+For third-party channel UI schema, `openclaw.plugin.json` must declare fields under:
+
+- `channelConfigs.nexus.schema`
+- `channelConfigs.nexus.uiHints`
+
+Do not use `plugins.entries.nexus.config` for new installs.
+
+## Resume Token
+
+The plugin stores resume tokens at:
+
+```bash
+~/.openclaw/state/nexus-resume.json
+```
+
+It auto-updates this file while processing events.
+
+## SSH Tunnel
+
+If cloud firewall rules block the WS port, tunnel it locally:
+
+```bash
+ssh -f -N -L 13001:127.0.0.1:3001 ubuntu@111.231.105.183
+```
+
+Then set `hub2dUrl` to `ws://127.0.0.1:13001`.
+
+## Verification
+
+```bash
+npm run typecheck
+npm run build
+npm run test
+npm pack --dry-run
+openclaw plugins list | grep nexus
+```
+
+## Troubleshooting
+
+| Symptom | Fix |
+|---|---|
+| `plugins.entries.nexus: plugin not found` | Install via `openclaw plugins install <tgz\|path\|npm>` instead of hand-copying extension files |
+| `plugins.allow is empty` | Add `"plugins": { "allow": ["nexus"] }` to `openclaw.json` |
+| `channels.nexus: unknown channel id` | Reinstall the plugin via `openclaw plugins install <tgz\|path\|npm>` so the host loads `channelConfigs.nexus` correctly |
+| Plugin loads but doctor deletes config | Reinstall using formal OpenClaw install flow so `plugins.installs.nexus` exists |
+| `AUTH_FAILED: token required` | Set `channels.nexus.token` to the `nagt_` token from Nexus UI |
+| `AUTH_FAILED: agent pending approval` | Approve the agent in Nexus UI → Agents tab, then configure the generated token |
+| `HTTP_401: Gateway Error 401` | Set `channels.nexus.gatewayToken` to match `gateway.auth.token` |
+| `HTTP_400: Invalid model` | Update plugin to v1.6.4+ which uses `model: 'openclaw'` |
+| WS connects but no events | Check `roomId`, `@mention`, and that `channels.nexus.gatewayToken` matches `gateway.auth.token` |

package/dist/channel-config-api.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NexusChannelConfigSchema = void 0;
+const index_js_1 = require("./index.js");
+exports.NexusChannelConfigSchema = index_js_1.nexusPlugin.configSchema ?? {
+    type: "object",
+    properties: {
+        hub2dUrl: { type: "string" },
+        roomId: { type: "string" },
+        agentName: { type: "string" },
+        nexusApiKey: { type: "string" },
+        contextInjection: { type: "string", enum: ["L0", "L1", "L2", "off", "P0", "recent10"] },
+        gatewayTimeoutMs: { type: "integer", minimum: 5000 },
+        longTextThreshold: { type: "integer", minimum: 500 },
+        enabled: { type: "boolean" },
+    },
+    additionalProperties: true,
+};

package/dist/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nexusPlugin = void 0;
+const core_1 = require("openclaw/plugin-sdk/core");
+const channel_1 = require("./src/channel");
+var channel_2 = require("./src/channel");
+Object.defineProperty(exports, "nexusPlugin", { enumerable: true, get: function () { return channel_2.nexusPlugin; } });
+exports.default = (0, core_1.defineChannelPluginEntry)({
+    id: 'nexus',
+    name: 'Nexus',
+    description: 'Nexus Hub 2.0 channel plugin for OpenClaw',
+    plugin: channel_1.nexusPlugin,
+});

package/dist/setup-entry.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nexusSetupPlugin = void 0;
+const core_1 = require("openclaw/plugin-sdk/core");
+const channel_setup_1 = require("openclaw/plugin-sdk/channel-setup");
+const CHANNEL = 'nexus-channel';
+const DEFAULT_ACCOUNT = 'default';
+const DEFAULT_WS = 'ws://127.0.0.1:3001';
+function normalizeSetupInput(input) {
+    const rawUrl = input?.httpUrl || input?.hub2dUrl || DEFAULT_WS;
+    const wsUrl = rawUrl.startsWith('ws') ? rawUrl : rawUrl.replace(/^http/, 'ws');
+    return {
+        hub2dUrl: wsUrl,
+        roomId: input?.roomId || 'general',
+        agentName: input?.agentName || 'serina',
+        nexusApiKey: input?.token || input?.nexusApiKey || '',
+        longTextThreshold: Number(input?.longTextThreshold || 4000),
+        contextInjection: input?.contextInjection || 'P0',
+        enabled: input?.enabled ?? true,
+    };
+}
+const optionalSurface = (0, channel_setup_1.createOptionalChannelSetupSurface)({
+    channel: CHANNEL,
+    label: 'Nexus Hub 2.0',
+    docsPath: '/channels/nexus-channel',
+});
+const nexusSetupPlugin = {
+    id: CHANNEL,
+    meta: {
+        label: 'Nexus Hub 2.0',
+        selectionLabel: 'Nexus Hub (WebSocket)',
+        detailLabel: 'Nexus Hub 2.0 Channel',
+        markdownCapable: true,
+    },
+    config: {
+        listAccountIds: () => [DEFAULT_ACCOUNT],
+        resolveAccount: ({ cfg }) => {
+            const channelCfg = cfg?.channels?.[CHANNEL] || {};
+            return {
+                accountId: DEFAULT_ACCOUNT,
+                configured: Boolean(channelCfg.hub2dUrl && channelCfg.roomId && channelCfg.agentName),
+            };
+        },
+        defaultAccountId: () => DEFAULT_ACCOUNT,
+    },
+    setup: {
+        ...optionalSurface.setupAdapter,
+        applyAccountConfig({ cfg, input }) {
+            const normalized = normalizeSetupInput(input);
+            return {
+                ...cfg,
+                channels: {
+                    ...(cfg.channels || {}),
+                    [CHANNEL]: {
+                        ...(cfg.channels?.[CHANNEL] || {}),
+                        ...normalized,
+                    },
+                },
+                plugins: {
+                    ...cfg.plugins,
+                    allow: Array.from(new Set([...(cfg.plugins?.allow || []), CHANNEL])),
+                },
+            };
+        },
+        async validateInput({ input }) {
+            const url = input?.httpUrl || input?.hub2dUrl;
+            if (!url)
+                return 'Hub2d URL is required';
+            try {
+                const normalized = url.startsWith('ws') ? url : url.replace(/^http/, 'ws');
+                new URL(normalized);
+            }
+            catch {
+                return 'Invalid Hub2d URL';
+            }
+            return null;
+        },
+    },
+    setupWizard: optionalSurface.setupWizard,
+};
+exports.nexusSetupPlugin = nexusSetupPlugin;
+exports.default = (0, core_1.defineSetupPluginEntry)(nexusSetupPlugin);

package/dist/src/channel.js

@@ -0,0 +1,203 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nexusPlugin = void 0;
+const core_1 = require("openclaw/plugin-sdk/core");
+const schema_1 = require("./config/schema");
+const resolve_config_1 = require("./config/resolve-config");
+const resume_store_1 = require("./transport/resume-store");
+const ws_client_1 = require("./transport/ws-client");
+const event_handler_1 = require("./runtime/event-handler");
+const outbound_1 = require("./runtime/outbound");
+const directory_1 = require("./runtime/directory");
+const status_1 = require("./runtime/status");
+const tools_1 = require("./runtime/tools");
+const meta = {
+    id: 'nexus-channel',
+    label: 'Nexus Channel',
+    selectionLabel: 'Nexus Hub 2.0 (WS)',
+    detailLabel: 'Nexus Hub',
+    docsPath: '/channels/nexus-channel',
+    blurb: 'Multi-agent hub with WS + persistence.',
+};
+let currentConfig = {};
+let wsClient = null;
+const recentSet = new Map();
+function isRecent(eventId) {
+    return recentSet.has(eventId);
+}
+function markRecent(eventId) {
+    recentSet.set(eventId, Date.now());
+    if (recentSet.size > 10000) {
+        const entries = Array.from(recentSet.entries());
+        for (const [key] of entries.slice(0, recentSet.size - 8000)) {
+            recentSet.delete(key);
+        }
+    }
+}
+async function dispatchMessage(roomId, text, target) {
+    if (!wsClient || !wsClient.isConnected()) {
+        throw new Error('Cannot dispatch message: WS not connected to hub2d');
+    }
+    const mentions = target ? [target] : undefined;
+    const eventId = `dispatch-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    wsClient.sendMessage(roomId, text, mentions, eventId);
+    return { event_id: eventId };
+}
+const agentTools = (0, tools_1.createAgentTools)({
+    getConfig: () => currentConfig,
+    dispatchMessage,
+});
+exports.nexusPlugin = (0, core_1.createChatChannelPlugin)({
+    base: {
+        id: 'nexus-channel',
+        meta,
+        capabilities: {
+            chatTypes: ['group'],
+            reactions: false,
+            threads: true,
+            media: false,
+            nativeCommands: false,
+        },
+        reload: { configPrefixes: ['channels.nexus'] },
+        configSchema: {
+            schema: {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    enabled: { type: 'boolean' },
+                    hub2dUrl: { type: 'string' },
+                    roomId: { type: 'string' },
+                    agentName: { type: 'string' },
+                    token: { type: 'string' }, // agent auth token
+                    nexusApiKey: { type: 'string' },
+                    apiPort: { type: 'integer' },
+                    gatewayPort: { type: 'integer' },
+                    gatewayToken: { type: 'string' },
+                    gatewayTimeoutMs: { type: 'integer' },
+                    longTextThreshold: { type: 'integer' },
+                    contextInjection: { type: 'string', enum: ['P0', 'L0', 'L1', 'L2', 'OFF'] },
+                },
+            },
+            uiHints: {
+                hub2dUrl: { label: 'Hub2d WS URL', placeholder: 'wss://your-hub.example.com/ws' },
+                roomId: { label: 'Room IDs (comma-separated)', placeholder: 'general' },
+                agentName: { label: 'Agent Name', placeholder: 'serina' },
+                token: { label: 'Agent Token', placeholder: 'nagt_...', sensitive: true },
+                nexusApiKey: { label: 'Nexus API Key', placeholder: 'nxk-...', sensitive: true },
+                apiPort: { label: 'Identity API Port', placeholder: '3004' },
+                gatewayPort: { label: 'Gateway Port', placeholder: '18789' },
+                gatewayToken: { label: 'Gateway Token', placeholder: '', sensitive: true },
+                gatewayTimeoutMs: { label: 'Gateway Timeout (ms)', placeholder: '120000' },
+                longTextThreshold: { label: 'Long Text Threshold (chars)', placeholder: '4000' },
+                contextInjection: { label: 'Nexus Context Mode', placeholder: 'P0' },
+            },
+        },
+        config: {
+            listAccountIds: () => [core_1.DEFAULT_ACCOUNT_ID],
+            defaultAccountId: () => core_1.DEFAULT_ACCOUNT_ID,
+            resolveAccount: ((cfg) => (0, resolve_config_1.resolveNexusConfig)(cfg)),
+            isConfigured: ((account) => Boolean(account?.__nexusMeta?.configured)),
+            describeAccount: ((account) => ({
+                accountId: account.accountId || core_1.DEFAULT_ACCOUNT_ID,
+                name: account.agentName || 'Nexus',
+                enabled: account.enabled ?? true,
+                configured: Boolean(account?.__nexusMeta?.configured),
+                tokenSource: account?.__nexusMeta?.configSource || 'channels.nexus',
+            })),
+        },
+        agentTools: agentTools,
+        directory: directory_1.directoryAdapter,
+        messaging: directory_1.messagingAdapter,
+        status: status_1.statusAdapter,
+        gateway: {
+            startAccount: async (ctx) => {
+                currentConfig = ctx.account || {};
+                const resolved = {
+                    ...currentConfig,
+                    hub2dUrl: currentConfig.hub2dUrl || schema_1.DEFAULT_HUB2D_URL,
+                    roomId: currentConfig.roomId || schema_1.DEFAULT_ROOM_ID,
+                    agentName: currentConfig.agentName || schema_1.DEFAULT_AGENT_NAME,
+                    gatewayPort: currentConfig.gatewayPort || schema_1.DEFAULT_GATEWAY_PORT,
+                    gatewayTimeoutMs: currentConfig.gatewayTimeoutMs || schema_1.DEFAULT_GATEWAY_TIMEOUT_MS,
+                };
+                currentConfig = resolved;
+                if (resolved.__nexusMeta?.configured === false) {
+                    const missing = resolved.__nexusMeta.missingFields.join(', ');
+                    throw new Error(`Nexus is not configured for account "${resolved.accountId || core_1.DEFAULT_ACCOUNT_ID}" (missing ${missing} in channels.nexus).`);
+                }
+                (0, resume_store_1.resetResumeTokenStore)();
+                (0, resume_store_1.initResumeTokenStore)();
+                const rooms = (resolved.roomId || schema_1.DEFAULT_ROOM_ID).split(',').map((item) => item.trim()).filter(Boolean);
+                wsClient = new ws_client_1.WSClient({
+                    hub2dUrl: resolved.hub2dUrl || schema_1.DEFAULT_HUB2D_URL,
+                    agentName: resolved.agentName || schema_1.DEFAULT_AGENT_NAME,
+                    rooms,
+                    token: resolved.token, // pass auth token
+                    onConnected: () => {
+                        const snap = ctx.getStatus?.() || {};
+                        ctx.setStatus?.({ ...snap, running: true, connected: true, lastConnectedAt: Date.now() });
+                    },
+                    onEvent: async (event) => {
+                        await (0, event_handler_1.processEvent)({
+                            event,
+                            config: resolved,
+                            selfUserId: wsClient?.getUserId(),
+                            isRecent,
+                            markRecent,
+                            gatewayConfig: {
+                                port: resolved.gatewayPort,
+                                token: resolved.gatewayToken,
+                                timeoutMs: resolved.gatewayTimeoutMs,
+                            },
+                            sendReply: (eventId, roomId, to, text, status) => wsClient?.sendReply(eventId, roomId, to, text, status),
+                            sendAck: (roomId, eventId) => wsClient?.sendAck(roomId, eventId),
+                            updateResumeToken: resume_store_1.updateResumeToken,
+                        });
+                    },
+                    onError: (frame) => {
+                        const snap = ctx.getStatus?.() || {};
+                        ctx.setStatus?.({ ...snap, lastError: `${frame.code}: ${frame.message}` });
+                    },
+                    onClose: () => {
+                        const snap = ctx.getStatus?.() || {};
+                        ctx.setStatus?.({ ...snap, connected: false });
+                    },
+                });
+                wsClient.connect();
+                await new Promise((resolve) => {
+                    ctx.abortSignal?.addEventListener('abort', resolve, { once: true });
+                });
+            },
+            stopAccount: async () => {
+                wsClient?.close();
+                wsClient = null;
+            },
+        },
+    },
+    outbound: {
+        base: {
+            deliveryMode: 'direct',
+        },
+        attachedResults: {
+            channel: 'nexus',
+            sendText: async ({ to, text }) => {
+                const outbound = (0, outbound_1.createOutboundClient)(currentConfig, (roomId, body, mentions, clientMsgId) => {
+                    wsClient?.sendMessage(roomId, body, mentions, clientMsgId);
+                });
+                const result = await outbound.sendText({ to, text });
+                return {
+                    messageId: result.messageId,
+                };
+            },
+            sendMedia: async ({ to, text, mediaUrl }) => {
+                const outbound = (0, outbound_1.createOutboundClient)(currentConfig, (roomId, body, mentions, clientMsgId) => {
+                    wsClient?.sendMessage(roomId, body, mentions, clientMsgId);
+                });
+                const result = await outbound.sendMedia({ to, text, mediaUrl });
+                return {
+                    messageId: result.messageId,
+                };
+            },
+        },
+    },
+});

package/dist/src/config/migrate-legacy.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasLegacyNexusConfig = hasLegacyNexusConfig;
+exports.readLegacyNexusConfig = readLegacyNexusConfig;
+exports.migrateLegacyConfig = migrateLegacyConfig;
+function hasLegacyNexusConfig(_cfg) {
+    return false;
+}
+function readLegacyNexusConfig(_cfg) {
+    return null;
+}
+function migrateLegacyConfig(_legacyCfg) {
+    return {};
+}

package/dist/src/config/resolve-config.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMissingRequiredFields = getMissingRequiredFields;
+exports.resolveNexusConfig = resolveNexusConfig;
+exports.validateNexusConfig = validateNexusConfig;
+const schema_1 = require("./schema");
+function isNonEmptyString(value) {
+    return typeof value === 'string' && value.trim().length > 0;
+}
+function normalizeContextInjection(value) {
+    if (!isNonEmptyString(value))
+        return 'P0';
+    const upper = value.toUpperCase();
+    if (upper === 'OFF' || upper === 'FALSE')
+        return 'OFF';
+    if (upper === 'L0' || upper === 'L1' || upper === 'L2')
+        return upper;
+    return 'P0';
+}
+function readChannelsConfig(cfg) {
+    const channelsCfg = cfg?.channels?.['nexus-channel'] || cfg?.channels?.['nexus'];
+    return channelsCfg && typeof channelsCfg === 'object' ? channelsCfg : {};
+}
+function getMissingRequiredFields(config) {
+    const missing = [];
+    if (!isNonEmptyString(config.hub2dUrl))
+        missing.push('hub2dUrl');
+    if (!isNonEmptyString(config.roomId))
+        missing.push('roomId');
+    if (!isNonEmptyString(config.agentName))
+        missing.push('agentName');
+    return missing;
+}
+function resolveNexusConfig(cfg) {
+    const channelsCfg = readChannelsConfig(cfg);
+    const hasConfig = Object.keys(channelsCfg).length > 0;
+    const resolved = {
+        enabled: channelsCfg.enabled ?? true,
+        hub2dUrl: channelsCfg.hub2dUrl ?? schema_1.DEFAULT_HUB2D_URL,
+        roomId: channelsCfg.roomId ?? schema_1.DEFAULT_ROOM_ID,
+        agentName: channelsCfg.agentName ?? schema_1.DEFAULT_AGENT_NAME,
+        token: channelsCfg.token, // agent auth token
+        nexusApiKey: channelsCfg.nexusApiKey,
+        apiPort: channelsCfg.apiPort ?? schema_1.DEFAULT_API_PORT,
+        gatewayPort: channelsCfg.gatewayPort ?? schema_1.DEFAULT_GATEWAY_PORT,
+        gatewayToken: channelsCfg.gatewayToken,
+        gatewayTimeoutMs: channelsCfg.gatewayTimeoutMs ?? schema_1.DEFAULT_GATEWAY_TIMEOUT_MS,
+        longTextThreshold: channelsCfg.longTextThreshold ?? schema_1.DEFAULT_LONG_TEXT,
+        contextInjection: normalizeContextInjection(channelsCfg.contextInjection),
+    };
+    const missingFields = getMissingRequiredFields(channelsCfg);
+    const configured = hasConfig && missingFields.length === 0;
+    return {
+        ...resolved,
+        __nexusMeta: {
+            configSource: hasConfig ? 'channels.nexus-channel' : 'none',
+            fallbackUsed: false,
+            fallbackFields: [],
+            sourceByField: hasConfig
+                ? Object.fromEntries(Object.keys(channelsCfg).map((key) => [key, 'channels.nexus-channel']))
+                : {},
+            missingFields,
+            configured,
+            warnings: hasConfig ? [] : ['Nexus config not found at channels.nexus-channel.'],
+        },
+    };
+}
+function validateNexusConfig(config) {
+    const errors = [];
+    const missingFields = getMissingRequiredFields(config);
+    for (const field of missingFields) {
+        errors.push(`${field} is required`);
+    }
+    if (isNonEmptyString(config.hub2dUrl)) {
+        try {
+            const normalized = config.hub2dUrl.startsWith('ws')
+                ? config.hub2dUrl
+                : config.hub2dUrl.replace(/^http/, 'ws');
+            new URL(normalized);
+        }
+        catch {
+            errors.push('hub2dUrl must be a valid URL');
+        }
+    }
+    if (typeof config.gatewayTimeoutMs === 'number' && config.gatewayTimeoutMs < 5000) {
+        errors.push('gatewayTimeoutMs must be at least 5000ms');
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+    };
+}

package/dist/src/config/schema.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_GATEWAY_PORT = exports.DEFAULT_API_PORT = exports.DEFAULT_GATEWAY_TIMEOUT_MS = exports.DEFAULT_LONG_TEXT = exports.DEFAULT_AGENT_NAME = exports.DEFAULT_ROOM_ID = exports.DEFAULT_HUB2D_URL = void 0;
+exports.DEFAULT_HUB2D_URL = 'ws://127.0.0.1:3001';
+exports.DEFAULT_ROOM_ID = 'general';
+exports.DEFAULT_AGENT_NAME = 'serina';
+exports.DEFAULT_LONG_TEXT = 4000;
+exports.DEFAULT_GATEWAY_TIMEOUT_MS = 600000;
+exports.DEFAULT_API_PORT = 3004;
+exports.DEFAULT_GATEWAY_PORT = 18789;

package/dist/src/gateway/chat-client.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GatewayRequestError = void 0;
+exports.callGateway = callGateway;
+exports.isRetryableGatewayError = isRetryableGatewayError;
+exports.callGatewayWithRetry = callGatewayWithRetry;
+const RETRYABLE_STATUS_CODES = new Set([429, 502, 503, 504]);
+const MAX_RETRIES = 3;
+const BASE_DELAY_MS = 3000;
+class GatewayRequestError extends Error {
+    constructor(message, code, status) {
+        super(message);
+        this.name = 'GatewayRequestError';
+        this.code = code;
+        this.status = status;
+    }
+}
+exports.GatewayRequestError = GatewayRequestError;
+async function callGateway(messages, user, config) {
+    const port = config.port ?? 18789;
+    const token = config.token ?? '';
+    const timeoutMs = config.timeoutMs ?? 600000;
+    const url = `http://127.0.0.1:${port}/v1/chat/completions`;
+    const headers = { 'Content-Type': 'application/json' };
+    if (token)
+        headers.Authorization = `Bearer ${token}`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+    const startTime = Date.now();
+    try {
+        const resp = await fetch(url, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify({
+                model: 'openclaw',
+                messages,
+                stream: false,
+                user,
+            }),
+            signal: controller.signal,
+        });
+        const latencyMs = Date.now() - startTime;
+        if (!resp.ok) {
+            const errText = await resp.text().catch(() => '(no body)');
+            throw new GatewayRequestError(`Gateway Error ${resp.status}: ${errText.slice(0, 100)}`, `HTTP_${resp.status}`, resp.status);
+        }
+        const data = await resp.json();
+        const content = data?.choices?.[0]?.message?.content || '(no reply)';
+        return { content, latencyMs };
+    }
+    catch (error) {
+        if (error?.name === 'AbortError') {
+            throw new GatewayRequestError(`Gateway timeout after ${timeoutMs}ms`, 'TIMEOUT');
+        }
+        if (error instanceof GatewayRequestError) {
+            throw error;
+        }
+        throw new GatewayRequestError(error?.message || 'Gateway request failed', 'FETCH_ERROR');
+    }
+    finally {
+        clearTimeout(timeoutId);
+    }
+}
+function isRetryableGatewayError(error) {
+    if (!(error instanceof GatewayRequestError))
+        return false;
+    return typeof error.status === 'number' && RETRYABLE_STATUS_CODES.has(error.status);
+}
+async function callGatewayWithRetry(messages, user, config, maxRetries = MAX_RETRIES) {
+    let lastError;
+    let totalWaitMs = 0;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        try {
+            return await callGateway(messages, user, config);
+        }
+        catch (error) {
+            if (!(error instanceof GatewayRequestError)) {
+                throw error;
+            }
+            lastError = error;
+            if (attempt < maxRetries && isRetryableGatewayError(error)) {
+                const delay = BASE_DELAY_MS * Math.pow(2, attempt) + Math.round(Math.random() * 1000);
+                totalWaitMs += delay;
+                console.log(`[nexus] Gateway retry ${attempt + 1}/${maxRetries} after ${delay}ms (code=${error.code})`);
+                await new Promise((resolve) => setTimeout(resolve, delay));
+                continue;
+            }
+            error.retries = attempt;
+            error.totalWaitMs = totalWaitMs;
+            throw error;
+        }
+    }
+    if (!lastError) {
+        throw new GatewayRequestError('Gateway request failed', 'FETCH_ERROR');
+    }
+    lastError.retries = maxRetries;
+    lastError.totalWaitMs = totalWaitMs;
+    throw lastError;
+}