@agentchatme/openclaw 0.8.1 → 0.9.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +39 -0
- package/README.md +72 -70
- package/RUNBOOK.md +65 -42
- package/SECURITY.md +9 -6
- package/dist/binding/agents-anchor.cjs +24 -20
- package/dist/binding/agents-anchor.cjs.map +1 -1
- package/dist/binding/agents-anchor.d.cts +38 -31
- package/dist/binding/agents-anchor.d.ts +38 -31
- package/dist/binding/agents-anchor.js +24 -18
- package/dist/binding/agents-anchor.js.map +1 -1
- package/dist/credentials/read-env.cjs +16 -7
- package/dist/credentials/read-env.cjs.map +1 -1
- package/dist/credentials/read-env.d.cts +26 -10
- package/dist/credentials/read-env.d.ts +26 -10
- package/dist/credentials/read-env.js +12 -6
- package/dist/credentials/read-env.js.map +1 -1
- package/dist/index.cjs +1192 -1522
- package/dist/index.cjs.map +1 -1
- package/dist/index.d.cts +155 -753
- package/dist/index.d.ts +155 -753
- package/dist/index.js +1178 -1514
- package/dist/index.js.map +1 -1
- package/dist/openclaw-layout.cjs.map +1 -1
- package/dist/openclaw-layout.d.cts +1 -1
- package/dist/openclaw-layout.d.ts +1 -1
- package/dist/openclaw-layout.js.map +1 -1
- package/dist/setup-entry-Dh6dRH2F.d.cts +754 -0
- package/dist/setup-entry-Dh6dRH2F.d.ts +754 -0
- package/dist/setup-entry.cjs +1144 -1527
- package/dist/setup-entry.cjs.map +1 -1
- package/dist/setup-entry.d.cts +2 -1
- package/dist/setup-entry.d.ts +2 -1
- package/dist/setup-entry.js +1145 -1528
- package/dist/setup-entry.js.map +1 -1
- package/openclaw.plugin.json +6 -12
- package/package.json +6 -6
- package/skills/agentchat/SKILL.md +132 -78
- package/dist/setup-entry-DU51IFUF.d.cts +0 -154
- package/dist/setup-entry-DU51IFUF.d.ts +0 -154
package/dist/setup-entry.js
CHANGED
|
@@ -3,14 +3,13 @@ import { setAccountEnabledInConfigSection, deleteAccountFromConfigSection } from
|
|
|
3
3
|
import { setSetupChannelEnabled, WizardCancelledError } from 'openclaw/plugin-sdk/setup';
|
|
4
4
|
import { readApiKeyFromEnv } from './credentials/read-env.js';
|
|
5
5
|
import * as fs from 'fs';
|
|
6
|
-
import * as
|
|
7
|
-
import {
|
|
6
|
+
import * as path2 from 'path';
|
|
7
|
+
import { WAKE_MODE_ENV, LEGACY_WAKE_MODE_ENV, readWakeModeFromEnv, readLegacyReplyGateFailOpenFromEnv, LEGACY_REPLY_GATE_FAIL_OPEN_ENV, readReplyGateTimeoutMsFromEnv, API_KEY_ENV, readReplyGateEnabledFromEnv } from './credentials/read-env.js';
|
|
8
8
|
import { resolveBoundAgentId, resolveOpenClawDefaultAgentId, resolveOpenClawStateDir } from './openclaw-layout.js';
|
|
9
|
-
import { removeAgentsAnchor, agentsAnchorPath, hasAgentsAnchorFor, writeAgentsAnchor } from './binding/agents-anchor.js';
|
|
9
|
+
import { removeAgentsAnchor, agentsAnchorPath, hasAgentsAnchorFor, writeAgentsAnchor, readAgentsAnchor } from './binding/agents-anchor.js';
|
|
10
|
+
import { AgentChatClient, RealtimeClient, gate } from 'agentchatme';
|
|
10
11
|
import { z } from 'zod';
|
|
11
12
|
import pino from 'pino';
|
|
12
|
-
import { WebSocket } from 'ws';
|
|
13
|
-
import { AgentChatClient } from 'agentchatme';
|
|
14
13
|
|
|
15
14
|
// src/channel.setup.ts
|
|
16
15
|
|
|
@@ -73,7 +72,7 @@ function listConfiguredAccountIds(cfg) {
|
|
|
73
72
|
function multiAccountRefusal(cfg) {
|
|
74
73
|
const ids = listConfiguredAccountIds(cfg);
|
|
75
74
|
if (ids.length <= 1) return null;
|
|
76
|
-
return `${ids.length} AgentChat accounts are configured (${ids.join(", ")}); this release runs one account per gateway \u2014 the hosted tools are one mcp.servers.agentchat entry on one AGENTCHAT_API_KEY, so a second account would act as the first. Keep one account under channels.agentchat (or run a second gateway) until per-account
|
|
75
|
+
return `${ids.length} AgentChat accounts are configured (${ids.join(", ")}); this release runs one account per gateway \u2014 the hosted tools are one mcp.servers.agentchat entry on one AGENTCHAT_API_KEY, so a second account would act as the first. Keep one account under channels.agentchat (or run a second gateway) until per-account integrations ship.`;
|
|
77
76
|
}
|
|
78
77
|
function isApiKeyPresent(value) {
|
|
79
78
|
return typeof value === "string" && value.length >= MIN_API_KEY_LENGTH;
|
|
@@ -105,52 +104,19 @@ function applyAgentchatAccountPatch(cfg, accountId, patch) {
|
|
|
105
104
|
return { ...cfg ?? {}, channels };
|
|
106
105
|
}
|
|
107
106
|
|
|
108
|
-
// src/errors.ts
|
|
109
|
-
var AgentChatChannelError = class extends Error {
|
|
110
|
-
class_;
|
|
111
|
-
retryAfterMs;
|
|
112
|
-
statusCode;
|
|
113
|
-
constructor(class_, message, options = {}) {
|
|
114
|
-
super(message, { cause: options.cause });
|
|
115
|
-
this.name = "AgentChatChannelError";
|
|
116
|
-
this.class_ = class_;
|
|
117
|
-
this.retryAfterMs = options.retryAfterMs;
|
|
118
|
-
this.statusCode = options.statusCode;
|
|
119
|
-
}
|
|
120
|
-
};
|
|
121
|
-
function classifyNetworkError(err) {
|
|
122
|
-
if (!err || typeof err !== "object") return "retry-transient";
|
|
123
|
-
const code = err.code;
|
|
124
|
-
if (typeof code === "string") {
|
|
125
|
-
if (code === "ECONNRESET" || code === "ETIMEDOUT" || code === "ECONNREFUSED") {
|
|
126
|
-
return "retry-transient";
|
|
127
|
-
}
|
|
128
|
-
if (code === "ENOTFOUND" || code === "EAI_AGAIN") return "retry-transient";
|
|
129
|
-
}
|
|
130
|
-
return "retry-transient";
|
|
131
|
-
}
|
|
132
|
-
|
|
133
107
|
// src/version.ts
|
|
134
|
-
var PACKAGE_VERSION = "0.
|
|
108
|
+
var PACKAGE_VERSION = "0.9.1";
|
|
135
109
|
|
|
136
110
|
// src/client-identity.ts
|
|
137
111
|
var AGENTCHAT_CLIENT_NAME = "openclaw";
|
|
112
|
+
var AGENTCHAT_CLIENT_IDENTITY = {
|
|
113
|
+
name: AGENTCHAT_CLIENT_NAME,
|
|
114
|
+
version: PACKAGE_VERSION
|
|
115
|
+
};
|
|
138
116
|
var AGENTCHAT_CLIENT_HEADERS = {
|
|
139
117
|
"X-AgentChat-Client": AGENTCHAT_CLIENT_NAME,
|
|
140
118
|
"X-AgentChat-Client-Version": PACKAGE_VERSION
|
|
141
119
|
};
|
|
142
|
-
function withAgentChatClientIdentity(fetchImpl) {
|
|
143
|
-
return (async (input, init) => {
|
|
144
|
-
const headers = new Headers(
|
|
145
|
-
typeof Request !== "undefined" && input instanceof Request ? input.headers : void 0
|
|
146
|
-
);
|
|
147
|
-
new Headers(init?.headers).forEach((value, key) => headers.set(key, value));
|
|
148
|
-
for (const [key, value] of Object.entries(AGENTCHAT_CLIENT_HEADERS)) {
|
|
149
|
-
headers.set(key, value);
|
|
150
|
-
}
|
|
151
|
-
return fetchImpl(input, { ...init, headers });
|
|
152
|
-
});
|
|
153
|
-
}
|
|
154
120
|
|
|
155
121
|
// src/setup-client.ts
|
|
156
122
|
var DEFAULT_API_BASE = "https://api.agentchat.me";
|
|
@@ -378,9 +344,9 @@ function readHandleList(details) {
|
|
|
378
344
|
if (!Array.isArray(handles)) return [];
|
|
379
345
|
return handles.filter((h) => typeof h === "string" && h.length > 0);
|
|
380
346
|
}
|
|
381
|
-
async function post(
|
|
347
|
+
async function post(path5, body, opts) {
|
|
382
348
|
const base = (opts.apiBase ?? DEFAULT_API_BASE).replace(/\/+$/, "");
|
|
383
|
-
const url = `${base}${
|
|
349
|
+
const url = `${base}${path5}`;
|
|
384
350
|
const controller = new AbortController();
|
|
385
351
|
const fetchImpl = opts.fetch ?? fetch;
|
|
386
352
|
const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
|
|
@@ -413,53 +379,41 @@ async function post(path2, body, opts) {
|
|
|
413
379
|
}
|
|
414
380
|
}
|
|
415
381
|
|
|
416
|
-
// src/
|
|
382
|
+
// src/integration/turn.ts
|
|
417
383
|
var MCP_SERVER_NAME = "agentchat";
|
|
418
384
|
var MCP_TOOL_DELIMITER = "__";
|
|
419
|
-
var
|
|
385
|
+
var MCP_TOOL_PREFIX = `${MCP_SERVER_NAME}${MCP_TOOL_DELIMITER}`;
|
|
420
386
|
function mcpToolName(tool) {
|
|
421
|
-
return `${
|
|
387
|
+
return `${MCP_TOOL_PREFIX}${tool}`;
|
|
422
388
|
}
|
|
423
|
-
var INBOX_TOOL = mcpToolName("agentchat_inbox");
|
|
424
389
|
var DECIDE_TOOL = mcpToolName("agentchat_decide");
|
|
425
390
|
var GET_CONVERSATION_TOOL = mcpToolName("agentchat_get_conversation");
|
|
426
|
-
var
|
|
427
|
-
var
|
|
428
|
-
|
|
429
|
-
|
|
430
|
-
|
|
431
|
-
|
|
432
|
-
|
|
433
|
-
|
|
434
|
-
|
|
435
|
-
var MANUAL_POINTER = `(The AgentChat manual is the ${SKILL_NAME} skill bundled with this plugin; the same text is at https://agentchat.me/skill.md.)`;
|
|
436
|
-
var KNOCK_TURN_PROMPT = `${WAKE_INSTRUCTION}
|
|
437
|
-
|
|
438
|
-
${MANUAL_POINTER}`;
|
|
439
|
-
var INVITE_TURN_PROMPT = `You were woken by AgentChat: a group invitation is pending for you. Call ${LIST_GROUP_INVITES_TOOL} first, then decide for yourself: accept with ${ACCEPT_GROUP_INVITE_TOOL}, decline with ${REJECT_GROUP_INVITE_TOOL}, or leave it pending by doing nothing. Being invited is not a reason to join.
|
|
391
|
+
var OPENCLAW_TOOL_NAMER = (tool) => tool.startsWith(MCP_TOOL_PREFIX) ? tool : mcpToolName(tool);
|
|
392
|
+
var HOSTED_TOOL_TOKEN = /\bagentchat_(?!_)[a-z0-9_]+\b/g;
|
|
393
|
+
function spellToolsForOpenClaw(text) {
|
|
394
|
+
return text.replace(HOSTED_TOOL_TOKEN, (token) => OPENCLAW_TOOL_NAMER(token));
|
|
395
|
+
}
|
|
396
|
+
function wakeTurnPrompt(texts, conversationId) {
|
|
397
|
+
const instruction = texts.wake_instruction.trim();
|
|
398
|
+
if (!conversationId) return instruction;
|
|
399
|
+
return `${instruction}
|
|
440
400
|
|
|
441
|
-
${
|
|
442
|
-
function knockTurnPrompt(replyConversations = []) {
|
|
443
|
-
const ids = replyConversations.filter((id) => typeof id === "string" && id.length > 0);
|
|
444
|
-
if (ids.length === 0) return KNOCK_TURN_PROMPT;
|
|
445
|
-
const gateLine = `The gate step before this turn decided to answer: ${ids.join(", ")}. Any other card on the tray was left undecided; decide it with the tray's question.`;
|
|
446
|
-
return `${WAKE_INSTRUCTION}
|
|
447
|
-
|
|
448
|
-
${gateLine}
|
|
449
|
-
|
|
450
|
-
${MANUAL_POINTER}`;
|
|
401
|
+
${conversationLine(conversationId)}`;
|
|
451
402
|
}
|
|
452
|
-
function
|
|
453
|
-
return
|
|
403
|
+
function conversationLine(conversationId) {
|
|
404
|
+
return `Conversation to answer in this turn: ${conversationId}. The gate decided reply; its card is still on the tray while you work, and the reply verdict for it is recorded for you when this turn completes (recording it yourself with ${DECIDE_TOOL} is idempotent) \u2014 open it with ${GET_CONVERSATION_TOOL} and reply.`;
|
|
454
405
|
}
|
|
455
|
-
function
|
|
456
|
-
return
|
|
406
|
+
function inviteTurnPrompt(texts) {
|
|
407
|
+
return texts.invite_prompt.trim();
|
|
408
|
+
}
|
|
409
|
+
function wakeSessionKey(agentId, now = Date.now(), nonce = randomNonce()) {
|
|
410
|
+
return `agent:${agentId}:subagent:agentchat-wake-${utcStamp(now)}-${nonce}`;
|
|
457
411
|
}
|
|
458
412
|
function inviteSessionKey(agentId, inviteId) {
|
|
459
413
|
return `agent:${agentId}:subagent:agentchat-invite-${sanitizeKeyPart(inviteId)}`;
|
|
460
414
|
}
|
|
461
|
-
function
|
|
462
|
-
return `agentchat-
|
|
415
|
+
function integrationLane(accountId) {
|
|
416
|
+
return `agentchat-integration:${sanitizeKeyPart(accountId)}`;
|
|
463
417
|
}
|
|
464
418
|
function utcStamp(ms) {
|
|
465
419
|
return new Date(ms).toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
|
|
@@ -472,7 +426,7 @@ function sanitizeKeyPart(value) {
|
|
|
472
426
|
return clean.length > 0 ? clean : "x";
|
|
473
427
|
}
|
|
474
428
|
|
|
475
|
-
// src/
|
|
429
|
+
// src/integration/mcp.ts
|
|
476
430
|
var MCP_PATH = "/mcp";
|
|
477
431
|
var AUTH_HEADER_TEMPLATE = `Bearer \${${API_KEY_ENV}}`;
|
|
478
432
|
var DEFAULT_API_BASE2 = "https://api.agentchat.me";
|
|
@@ -593,7 +547,7 @@ function readInitializeResult(text) {
|
|
|
593
547
|
return null;
|
|
594
548
|
}
|
|
595
549
|
|
|
596
|
-
// src/
|
|
550
|
+
// src/integration/runtime-holder.ts
|
|
597
551
|
var current = null;
|
|
598
552
|
function isUsablePluginRuntime(runtime) {
|
|
599
553
|
if (!runtime || typeof runtime !== "object" && typeof runtime !== "function") return false;
|
|
@@ -610,10 +564,10 @@ function setPluginRuntime(runtime) {
|
|
|
610
564
|
function getPluginRuntime() {
|
|
611
565
|
return current;
|
|
612
566
|
}
|
|
613
|
-
|
|
614
|
-
// src/doorbell/model.ts
|
|
615
567
|
var DEFAULT_AGENT_ID = "main";
|
|
616
568
|
var GATE_TEMPERATURE = 0;
|
|
569
|
+
var DEFAULT_GATE_MAX_TOKENS = 2048;
|
|
570
|
+
var DEFAULT_GATE_TIMEOUT_MS = 2e4;
|
|
617
571
|
var DEFAULT_TURN_WAIT_MS = 15 * 6e4;
|
|
618
572
|
var RuntimeUnavailableError = class extends Error {
|
|
619
573
|
constructor(what) {
|
|
@@ -621,13 +575,13 @@ var RuntimeUnavailableError = class extends Error {
|
|
|
621
575
|
this.name = "RuntimeUnavailableError";
|
|
622
576
|
}
|
|
623
577
|
};
|
|
624
|
-
function
|
|
578
|
+
function resolveIntegrationAgentId(params) {
|
|
625
579
|
try {
|
|
626
580
|
const route = params.channelRuntime?.routing?.resolveAgentRoute?.({
|
|
627
581
|
cfg: params.cfg,
|
|
628
582
|
channel: AGENTCHAT_CHANNEL_ID,
|
|
629
583
|
accountId: params.accountId,
|
|
630
|
-
peer: { kind: "direct", id: "
|
|
584
|
+
peer: { kind: "direct", id: "wake" }
|
|
631
585
|
});
|
|
632
586
|
const agentId = route?.agentId;
|
|
633
587
|
if (typeof agentId === "string" && agentId.trim().length > 0) return agentId.trim();
|
|
@@ -635,18 +589,19 @@ function resolveDoorbellAgentId(params) {
|
|
|
635
589
|
}
|
|
636
590
|
return DEFAULT_AGENT_ID;
|
|
637
591
|
}
|
|
638
|
-
function
|
|
592
|
+
function createRuntimeModelCall(params) {
|
|
639
593
|
const getRuntime = params.runtime ?? getPluginRuntime;
|
|
640
|
-
|
|
594
|
+
const maxTokens = params.maxTokens ?? DEFAULT_GATE_MAX_TOKENS;
|
|
595
|
+
const timeoutMs = params.timeoutMs ?? DEFAULT_GATE_TIMEOUT_MS;
|
|
596
|
+
return async (prompt) => {
|
|
641
597
|
const runtime = getRuntime();
|
|
642
598
|
if (!runtime) throw new RuntimeUnavailableError("the gate call");
|
|
643
599
|
const result = await runtime.llm.complete({
|
|
644
|
-
|
|
645
|
-
messages: [{ role: "user", content: userContent }],
|
|
600
|
+
messages: [{ role: "user", content: prompt }],
|
|
646
601
|
maxTokens,
|
|
647
602
|
temperature: GATE_TEMPERATURE,
|
|
648
603
|
...params.agentIdOverride ? { agentId: params.agentIdOverride } : {},
|
|
649
|
-
purpose: "AgentChat reply gate: the server's question about the server's cards",
|
|
604
|
+
purpose: "AgentChat reply gate: the server's question about the server's cards (tool-free triage)",
|
|
650
605
|
...Number.isFinite(timeoutMs) && timeoutMs > 0 ? { signal: AbortSignal.timeout(timeoutMs) } : {}
|
|
651
606
|
});
|
|
652
607
|
return typeof result?.text === "string" ? result.text : "";
|
|
@@ -676,7 +631,37 @@ function resolveGateAgent(params) {
|
|
|
676
631
|
const ambient = params.ambientAgentId?.trim().toLowerCase();
|
|
677
632
|
return { agentId: routed, agentIdOverride: routed === (ambient ?? routed) ? void 0 : routed };
|
|
678
633
|
}
|
|
679
|
-
function
|
|
634
|
+
function readLiveConfig(fallback, runtime = getPluginRuntime) {
|
|
635
|
+
try {
|
|
636
|
+
const loaded = runtime()?.config?.loadConfig?.();
|
|
637
|
+
if (loaded && typeof loaded === "object") return { cfg: loaded, live: true };
|
|
638
|
+
} catch {
|
|
639
|
+
}
|
|
640
|
+
return { cfg: fallback, live: false };
|
|
641
|
+
}
|
|
642
|
+
function turnReadiness(params) {
|
|
643
|
+
const env = params.env ?? process.env;
|
|
644
|
+
const restart = params.live === false ? ", then restart the gateway (this gateway cannot re-read its config while running)" : "";
|
|
645
|
+
switch (describeMcpEntry(params.cfg, params.apiBase, params.apiKey)) {
|
|
646
|
+
case "missing":
|
|
647
|
+
return { ready: false, reason: `mcp.servers.${MCP_SERVER_NAME} is not in the gateway config \u2014 run \`openclaw doctor --fix\`${restart}` };
|
|
648
|
+
case "disabled":
|
|
649
|
+
return { ready: false, reason: `mcp.servers.${MCP_SERVER_NAME} is disabled in the gateway config \u2014 enable it${restart}` };
|
|
650
|
+
case "user_managed":
|
|
651
|
+
return { ready: true };
|
|
652
|
+
case "ours": {
|
|
653
|
+
const value = env[API_KEY_ENV];
|
|
654
|
+
if (typeof value !== "string" || value.trim().length === 0) {
|
|
655
|
+
return {
|
|
656
|
+
ready: false,
|
|
657
|
+
reason: `${API_KEY_ENV} is not set in the gateway process, so the hosted tools' bearer template cannot resolve \u2014 restart the gateway (or reload its config) once ~/.openclaw/.env carries it`
|
|
658
|
+
};
|
|
659
|
+
}
|
|
660
|
+
return { ready: true };
|
|
661
|
+
}
|
|
662
|
+
}
|
|
663
|
+
}
|
|
664
|
+
function createRuntimeTurnStarter(params = {}) {
|
|
680
665
|
const getRuntime = params.runtime ?? getPluginRuntime;
|
|
681
666
|
const waitMs = params.waitMs ?? DEFAULT_TURN_WAIT_MS;
|
|
682
667
|
return async (request) => {
|
|
@@ -694,12 +679,12 @@ function createRuntimeTurnRunner(params = {}) {
|
|
|
694
679
|
} catch (err) {
|
|
695
680
|
return { ran: false, error: err instanceof Error ? err.message : String(err) };
|
|
696
681
|
}
|
|
697
|
-
|
|
698
|
-
|
|
699
|
-
|
|
700
|
-
|
|
701
|
-
|
|
702
|
-
}
|
|
682
|
+
const done = runtime.subagent.waitForRun({ runId, timeoutMs: waitMs }).then(
|
|
683
|
+
(waited) => ({ ran: true, runId, status: waited.status, ...waited.error ? { error: waited.error } : {} }),
|
|
684
|
+
// The run was admitted; only the wait failed. The turn is OpenClaw's now.
|
|
685
|
+
(err) => ({ ran: true, runId, status: "unknown", error: err instanceof Error ? err.message : String(err) })
|
|
686
|
+
);
|
|
687
|
+
return { ran: true, runId, done };
|
|
703
688
|
};
|
|
704
689
|
}
|
|
705
690
|
var HANDLE_PATTERN = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
|
|
@@ -708,7 +693,7 @@ function isValidHandleShape(value) {
|
|
|
708
693
|
}
|
|
709
694
|
var DOTENV_NAME = ".env";
|
|
710
695
|
function dotEnvPath(stateDir = resolveOpenClawStateDir()) {
|
|
711
|
-
return
|
|
696
|
+
return path2.join(stateDir, DOTENV_NAME);
|
|
712
697
|
}
|
|
713
698
|
function placeApiKeyInDotEnv(apiKey, stateDir = resolveOpenClawStateDir()) {
|
|
714
699
|
const trimmed = apiKey.trim();
|
|
@@ -777,7 +762,7 @@ function stripQuotes(value) {
|
|
|
777
762
|
}
|
|
778
763
|
return value;
|
|
779
764
|
}
|
|
780
|
-
function
|
|
765
|
+
function applyIntegrationConfig(cfg, params) {
|
|
781
766
|
const changes = [];
|
|
782
767
|
let next = cfg;
|
|
783
768
|
const bareHandle = (params.handle ?? "").trim().replace(/^@/, "");
|
|
@@ -800,13 +785,13 @@ function applyDoorbellConfig(cfg, params) {
|
|
|
800
785
|
function resolvePlacementAgentId(cfg, accountId) {
|
|
801
786
|
return resolveBoundAgentId(cfg, AGENTCHAT_CHANNEL_ID, accountId) ?? resolveOpenClawDefaultAgentId(cfg);
|
|
802
787
|
}
|
|
803
|
-
function
|
|
788
|
+
function stripIntegrationConfig(cfg, accountId) {
|
|
804
789
|
const apiBase = readAgentchatConfigField(cfg, accountId, "apiBase") ?? "https://api.agentchat.me";
|
|
805
790
|
const apiKey = readAgentchatConfigField(cfg, accountId, "apiKey");
|
|
806
791
|
const { cfg: next, removed } = withoutHostedMcpEntry(cfg, apiBase, apiKey);
|
|
807
792
|
return { cfg: next, changes: removed ? ["removed mcp.servers.agentchat"] : [] };
|
|
808
793
|
}
|
|
809
|
-
function
|
|
794
|
+
function removeIntegrationFiles(cfg, accountId, options) {
|
|
810
795
|
const changes = [];
|
|
811
796
|
try {
|
|
812
797
|
const removed = removeAgentsAnchor({ cfg, agentId: resolvePlacementAgentId(cfg, accountId) });
|
|
@@ -822,23 +807,38 @@ function removeDoorbellFiles(cfg, accountId, options) {
|
|
|
822
807
|
}
|
|
823
808
|
return changes;
|
|
824
809
|
}
|
|
825
|
-
function restoreIdentityLine(cfg, accountId, handle) {
|
|
810
|
+
function restoreIdentityLine(cfg, accountId, handle, identityLine) {
|
|
826
811
|
const agentId = resolvePlacementAgentId(cfg, accountId);
|
|
827
812
|
const bare = handle.trim().replace(/^@/, "");
|
|
828
813
|
let filePath = "";
|
|
829
814
|
try {
|
|
830
815
|
filePath = agentsAnchorPath(cfg, agentId);
|
|
831
816
|
if (!isValidHandleShape(bare)) return { outcome: "failed", path: filePath, detail: `agentHandle "${bare}" is not a valid AgentChat handle` };
|
|
832
|
-
|
|
817
|
+
if (identityLine === null) {
|
|
818
|
+
return { outcome: "skipped", path: filePath, detail: "the served identity line is not available (AgentChat unreachable and nothing cached) \u2014 run openclaw doctor --fix once it is" };
|
|
819
|
+
}
|
|
820
|
+
const present = hasAgentsAnchorFor({ cfg, handle: bare, text: identityLine, agentId });
|
|
833
821
|
filePath = present.path;
|
|
834
822
|
if (present.present) return { outcome: "present", path: present.path };
|
|
835
|
-
const written = writeAgentsAnchor({ cfg, handle: bare, agentId });
|
|
823
|
+
const written = writeAgentsAnchor({ cfg, handle: bare, text: identityLine, agentId });
|
|
836
824
|
return { outcome: "placed", path: written.path };
|
|
837
825
|
} catch (err) {
|
|
838
826
|
return { outcome: "failed", path: filePath, detail: describe(err) };
|
|
839
827
|
}
|
|
840
828
|
}
|
|
841
|
-
function
|
|
829
|
+
function refreshIdentityLine(cfg, accountId, handle, identityLine) {
|
|
830
|
+
const agentId = resolvePlacementAgentId(cfg, accountId);
|
|
831
|
+
try {
|
|
832
|
+
const found = readAgentsAnchor({ cfg, agentId });
|
|
833
|
+
if (!found.present) return { outcome: "absent", path: found.path };
|
|
834
|
+
if (found.text === identityLine.trim()) return { outcome: "unchanged", path: found.path };
|
|
835
|
+
const written = writeAgentsAnchor({ cfg, handle, text: identityLine, agentId });
|
|
836
|
+
return { outcome: "updated", path: written.path };
|
|
837
|
+
} catch (err) {
|
|
838
|
+
return { outcome: "failed", path: agentsAnchorPath(cfg, agentId), detail: describe(err) };
|
|
839
|
+
}
|
|
840
|
+
}
|
|
841
|
+
function placeIntegration(params) {
|
|
842
842
|
const steps = [];
|
|
843
843
|
if (params.placeKey !== false) {
|
|
844
844
|
try {
|
|
@@ -853,11 +853,20 @@ function placeDoorbell(params) {
|
|
|
853
853
|
}
|
|
854
854
|
}
|
|
855
855
|
const agentId = params.agentId ?? resolvePlacementAgentId(params.cfg, params.accountId ?? AGENTCHAT_DEFAULT_ACCOUNT_ID);
|
|
856
|
-
|
|
857
|
-
|
|
858
|
-
steps.push({
|
|
859
|
-
|
|
860
|
-
|
|
856
|
+
const handle = params.handle.replace(/^@/, "");
|
|
857
|
+
if (params.identityLine === null) {
|
|
858
|
+
steps.push({
|
|
859
|
+
name: "anchor",
|
|
860
|
+
status: "skipped",
|
|
861
|
+
detail: `identity line for @${handle} not placed \u2014 AgentChat's texts were unreachable and nothing is cached; run openclaw doctor --fix once it is reachable`
|
|
862
|
+
});
|
|
863
|
+
} else {
|
|
864
|
+
try {
|
|
865
|
+
const anchor = writeAgentsAnchor({ cfg: params.cfg, handle: params.handle, text: params.identityLine, agentId });
|
|
866
|
+
steps.push({ name: "anchor", status: "ok", detail: `identity line for @${handle} in ${anchor.path}` });
|
|
867
|
+
} catch (err) {
|
|
868
|
+
steps.push({ name: "anchor", status: "failed", detail: `could not write the identity line to AGENTS.md: ${describe(err)}` });
|
|
869
|
+
}
|
|
861
870
|
}
|
|
862
871
|
steps.push({ name: "manual", status: "ok", detail: "manual bundled as the agentchat skill (skills/agentchat/SKILL.md, https://agentchat.me/skill.md verbatim)" });
|
|
863
872
|
const mcp = withHostedMcpEntry(params.cfg, params.apiBase, params.apiKey);
|
|
@@ -899,7 +908,7 @@ function checkPlacement(params) {
|
|
|
899
908
|
checks.push({ name: "key", ok: false, detail: `${API_KEY_ENV} is not placed \u2014 the hosted tools cannot authenticate; ${remedy("run openclaw channels add agentchat")}` });
|
|
900
909
|
}
|
|
901
910
|
if (params.handle) {
|
|
902
|
-
const anchor = hasAgentsAnchorFor({ cfg: params.cfg, handle: params.handle, agentId: params.agentId });
|
|
911
|
+
const anchor = hasAgentsAnchorFor({ cfg: params.cfg, handle: params.handle, text: params.identityLine, agentId: params.agentId });
|
|
903
912
|
checks.push({
|
|
904
913
|
name: "anchor",
|
|
905
914
|
ok: anchor.present,
|
|
@@ -920,6 +929,266 @@ function checkPlacement(params) {
|
|
|
920
929
|
function describe(err) {
|
|
921
930
|
return err instanceof Error ? err.message : String(err);
|
|
922
931
|
}
|
|
932
|
+
var PLUGIN_STATE_DIRNAME = "agentchat";
|
|
933
|
+
function safeSegment(value) {
|
|
934
|
+
const clean = value.replace(/[^A-Za-z0-9_.-]/g, "-").replace(/^\.+/, "");
|
|
935
|
+
return clean.length > 0 ? clean : "default";
|
|
936
|
+
}
|
|
937
|
+
function integrationStateDir(accountId, stateDir = resolveOpenClawStateDir()) {
|
|
938
|
+
return path2.join(stateDir, PLUGIN_STATE_DIRNAME, safeSegment(accountId));
|
|
939
|
+
}
|
|
940
|
+
function readJsonFile(file) {
|
|
941
|
+
let raw;
|
|
942
|
+
try {
|
|
943
|
+
raw = fs.readFileSync(file, "utf8");
|
|
944
|
+
} catch {
|
|
945
|
+
return null;
|
|
946
|
+
}
|
|
947
|
+
try {
|
|
948
|
+
return JSON.parse(raw);
|
|
949
|
+
} catch {
|
|
950
|
+
return null;
|
|
951
|
+
}
|
|
952
|
+
}
|
|
953
|
+
function writeJsonFile(file, value) {
|
|
954
|
+
fs.mkdirSync(path2.dirname(file), { recursive: true });
|
|
955
|
+
const tmp = `${file}.${process.pid}.${Date.now().toString(36)}.tmp`;
|
|
956
|
+
fs.writeFileSync(tmp, `${JSON.stringify(value, null, 2)}
|
|
957
|
+
`, "utf8");
|
|
958
|
+
try {
|
|
959
|
+
fs.renameSync(tmp, file);
|
|
960
|
+
} catch (err) {
|
|
961
|
+
try {
|
|
962
|
+
fs.unlinkSync(tmp);
|
|
963
|
+
} catch {
|
|
964
|
+
}
|
|
965
|
+
throw err;
|
|
966
|
+
}
|
|
967
|
+
}
|
|
968
|
+
|
|
969
|
+
// src/integration/texts.ts
|
|
970
|
+
var TEXTS_RUNTIME = "openclaw";
|
|
971
|
+
var TEXTS_REFRESH_MS = 24 * 60 * 6e4;
|
|
972
|
+
var TEXTS_RETRY_MS = 5 * 6e4;
|
|
973
|
+
var TEXTS_FETCH_TIMEOUT_MS = 1e4;
|
|
974
|
+
var TEXTS_CACHE_FILE = "texts.json";
|
|
975
|
+
function isTexts(value) {
|
|
976
|
+
if (!value || typeof value !== "object" || Array.isArray(value)) return false;
|
|
977
|
+
const t = value;
|
|
978
|
+
const manual = t.manual;
|
|
979
|
+
return typeof t.version === "string" && typeof t.wake_instruction === "string" && t.wake_instruction.length > 0 && typeof t.invite_prompt === "string" && t.invite_prompt.length > 0 && typeof t.identity_line === "string" && t.identity_line.length > 0 && typeof t.identity_line_template === "string" && !!manual && typeof manual === "object" && typeof manual.url === "string" && typeof manual.version === "string";
|
|
980
|
+
}
|
|
981
|
+
function textsCachePath(accountId, stateDir) {
|
|
982
|
+
return path2.join(integrationStateDir(accountId, stateDir), TEXTS_CACHE_FILE);
|
|
983
|
+
}
|
|
984
|
+
function readCachedTexts(accountId, stateDir) {
|
|
985
|
+
const raw = readJsonFile(textsCachePath(accountId, stateDir));
|
|
986
|
+
if (!raw || typeof raw !== "object") return null;
|
|
987
|
+
const entry = raw;
|
|
988
|
+
if (typeof entry.fetched_at !== "string" || !isTexts(entry.texts)) return null;
|
|
989
|
+
return { fetched_at: entry.fetched_at, texts: entry.texts };
|
|
990
|
+
}
|
|
991
|
+
function writeCachedTexts(accountId, texts, fetchedAt, stateDir) {
|
|
992
|
+
const file = textsCachePath(accountId, stateDir);
|
|
993
|
+
const entry = { fetched_at: fetchedAt.toISOString(), texts };
|
|
994
|
+
writeJsonFile(file, entry);
|
|
995
|
+
return file;
|
|
996
|
+
}
|
|
997
|
+
function spellTextsForOpenClaw(texts) {
|
|
998
|
+
return {
|
|
999
|
+
...texts,
|
|
1000
|
+
wake_instruction: spellToolsForOpenClaw(texts.wake_instruction),
|
|
1001
|
+
invite_prompt: spellToolsForOpenClaw(texts.invite_prompt),
|
|
1002
|
+
identity_line: spellToolsForOpenClaw(texts.identity_line),
|
|
1003
|
+
identity_line_template: spellToolsForOpenClaw(texts.identity_line_template)
|
|
1004
|
+
};
|
|
1005
|
+
}
|
|
1006
|
+
async function fetchTexts(client, timeoutMs = TEXTS_FETCH_TIMEOUT_MS) {
|
|
1007
|
+
const texts = await client.texts.get({ runtime: TEXTS_RUNTIME, timeoutMs });
|
|
1008
|
+
if (!isTexts(texts)) throw new Error("GET /v1/texts: answer is not a texts set (missing wake_instruction, invite_prompt or identity_line)");
|
|
1009
|
+
return texts;
|
|
1010
|
+
}
|
|
1011
|
+
async function loadTexts(params) {
|
|
1012
|
+
const now = params.now ?? Date.now;
|
|
1013
|
+
try {
|
|
1014
|
+
const texts = await fetchTexts(params.client, params.timeoutMs);
|
|
1015
|
+
const fetchedAt = new Date(now());
|
|
1016
|
+
try {
|
|
1017
|
+
writeCachedTexts(params.accountId, texts, fetchedAt, params.stateDir);
|
|
1018
|
+
} catch (err) {
|
|
1019
|
+
params.log?.warn({ err: describe2(err) }, "texts fetched but the cache could not be written");
|
|
1020
|
+
}
|
|
1021
|
+
return { texts: spellTextsForOpenClaw(texts), source: "server", fetchedAt: fetchedAt.toISOString() };
|
|
1022
|
+
} catch (err) {
|
|
1023
|
+
const cached = readCachedTexts(params.accountId, params.stateDir);
|
|
1024
|
+
if (cached) {
|
|
1025
|
+
params.log?.info({ err: describe2(err), fetchedAt: cached.fetched_at }, "texts: server unreachable \u2014 using the cached copy");
|
|
1026
|
+
return { texts: spellTextsForOpenClaw(cached.texts), source: "cache", fetchedAt: cached.fetched_at };
|
|
1027
|
+
}
|
|
1028
|
+
params.log?.debug({ err: describe2(err) }, "texts: server unreachable and nothing cached");
|
|
1029
|
+
return null;
|
|
1030
|
+
}
|
|
1031
|
+
}
|
|
1032
|
+
async function loadIdentityLine(params) {
|
|
1033
|
+
const loaded = await loadTexts(params);
|
|
1034
|
+
return loaded ? loaded.texts.identity_line : null;
|
|
1035
|
+
}
|
|
1036
|
+
function cachedIdentityLine(accountId, stateDir) {
|
|
1037
|
+
const cached = readCachedTexts(accountId, stateDir);
|
|
1038
|
+
return cached ? spellToolsForOpenClaw(cached.texts.identity_line) : null;
|
|
1039
|
+
}
|
|
1040
|
+
var TextsStore = class {
|
|
1041
|
+
client;
|
|
1042
|
+
accountId;
|
|
1043
|
+
logger;
|
|
1044
|
+
stateDir;
|
|
1045
|
+
refreshMs;
|
|
1046
|
+
retryMs;
|
|
1047
|
+
fetchTimeoutMs;
|
|
1048
|
+
now;
|
|
1049
|
+
_setTimeout;
|
|
1050
|
+
_clearTimeout;
|
|
1051
|
+
loaded = null;
|
|
1052
|
+
timer = null;
|
|
1053
|
+
inFlight = null;
|
|
1054
|
+
stopped = false;
|
|
1055
|
+
missingAnnounced = false;
|
|
1056
|
+
listeners = /* @__PURE__ */ new Set();
|
|
1057
|
+
loads = 0;
|
|
1058
|
+
serverLoads = 0;
|
|
1059
|
+
constructor(options) {
|
|
1060
|
+
this.client = options.client;
|
|
1061
|
+
this.accountId = options.accountId;
|
|
1062
|
+
this.logger = options.logger.child({ component: "texts", accountId: options.accountId });
|
|
1063
|
+
this.stateDir = options.stateDir;
|
|
1064
|
+
this.refreshMs = options.refreshMs ?? TEXTS_REFRESH_MS;
|
|
1065
|
+
this.retryMs = options.retryMs ?? TEXTS_RETRY_MS;
|
|
1066
|
+
this.fetchTimeoutMs = options.fetchTimeoutMs ?? TEXTS_FETCH_TIMEOUT_MS;
|
|
1067
|
+
this.now = options.now ?? Date.now;
|
|
1068
|
+
this._setTimeout = options.setTimeout ?? ((fn, ms) => setTimeout(fn, ms));
|
|
1069
|
+
this._clearTimeout = options.clearTimeout ?? ((h) => clearTimeout(h));
|
|
1070
|
+
}
|
|
1071
|
+
/** The texts spelled for OpenClaw, or null until the first copy exists. */
|
|
1072
|
+
get current() {
|
|
1073
|
+
return this.loaded?.texts ?? null;
|
|
1074
|
+
}
|
|
1075
|
+
get source() {
|
|
1076
|
+
return this.loaded?.source ?? null;
|
|
1077
|
+
}
|
|
1078
|
+
get fetchedAt() {
|
|
1079
|
+
return this.loaded?.fetchedAt ?? null;
|
|
1080
|
+
}
|
|
1081
|
+
/** Called with every copy that arrives from the server (not with a cached one). */
|
|
1082
|
+
onServerCopy(listener) {
|
|
1083
|
+
this.listeners.add(listener);
|
|
1084
|
+
return () => {
|
|
1085
|
+
this.listeners.delete(listener);
|
|
1086
|
+
};
|
|
1087
|
+
}
|
|
1088
|
+
/** First load (server, then cache), then the timer. Resolves after the first attempt; never throws. */
|
|
1089
|
+
async start() {
|
|
1090
|
+
const texts = await this.load();
|
|
1091
|
+
if (!texts && !this.missingAnnounced) {
|
|
1092
|
+
this.missingAnnounced = true;
|
|
1093
|
+
this.logger.warn(
|
|
1094
|
+
{ retryMs: this.retryMs },
|
|
1095
|
+
"AgentChat texts unreachable and nothing cached \u2014 starting anyway; turns wait for the first copy, retried until it arrives"
|
|
1096
|
+
);
|
|
1097
|
+
}
|
|
1098
|
+
this.arm();
|
|
1099
|
+
return texts;
|
|
1100
|
+
}
|
|
1101
|
+
/** The current copy, or one load attempt now (coalesced with any in flight). */
|
|
1102
|
+
async ensure() {
|
|
1103
|
+
if (this.loaded) return this.loaded.texts;
|
|
1104
|
+
if (this.stopped) return null;
|
|
1105
|
+
return this.load();
|
|
1106
|
+
}
|
|
1107
|
+
/** Force a refresh (tests, operators). Coalesced. */
|
|
1108
|
+
refresh() {
|
|
1109
|
+
return this.load();
|
|
1110
|
+
}
|
|
1111
|
+
stop() {
|
|
1112
|
+
this.stopped = true;
|
|
1113
|
+
if (this.timer !== null) {
|
|
1114
|
+
this._clearTimeout(this.timer);
|
|
1115
|
+
this.timer = null;
|
|
1116
|
+
}
|
|
1117
|
+
this.listeners.clear();
|
|
1118
|
+
}
|
|
1119
|
+
load() {
|
|
1120
|
+
if (this.inFlight) return this.inFlight;
|
|
1121
|
+
this.inFlight = (async () => {
|
|
1122
|
+
this.loads += 1;
|
|
1123
|
+
const next = await loadTexts({
|
|
1124
|
+
client: this.client,
|
|
1125
|
+
accountId: this.accountId,
|
|
1126
|
+
stateDir: this.stateDir,
|
|
1127
|
+
now: this.now,
|
|
1128
|
+
log: this.logger,
|
|
1129
|
+
timeoutMs: this.fetchTimeoutMs
|
|
1130
|
+
});
|
|
1131
|
+
if (this.stopped) return next?.texts ?? null;
|
|
1132
|
+
if (next) {
|
|
1133
|
+
const changed = this.loaded?.texts.version !== next.texts.version || this.loaded?.texts.wake_instruction !== next.texts.wake_instruction;
|
|
1134
|
+
this.loaded = next;
|
|
1135
|
+
if (next.source === "server") {
|
|
1136
|
+
this.serverLoads += 1;
|
|
1137
|
+
this.logger[changed ? "info" : "debug"](
|
|
1138
|
+
{ version: next.texts.version, manual: next.texts.manual.version },
|
|
1139
|
+
"texts fetched from the server"
|
|
1140
|
+
);
|
|
1141
|
+
for (const listener of this.listeners) {
|
|
1142
|
+
try {
|
|
1143
|
+
listener(next.texts, next.source);
|
|
1144
|
+
} catch (err) {
|
|
1145
|
+
this.logger.warn({ err: describe2(err) }, "texts listener threw \u2014 continuing");
|
|
1146
|
+
}
|
|
1147
|
+
}
|
|
1148
|
+
}
|
|
1149
|
+
}
|
|
1150
|
+
return next?.texts ?? null;
|
|
1151
|
+
})().finally(() => {
|
|
1152
|
+
this.inFlight = null;
|
|
1153
|
+
});
|
|
1154
|
+
return this.inFlight;
|
|
1155
|
+
}
|
|
1156
|
+
arm() {
|
|
1157
|
+
if (this.stopped) return;
|
|
1158
|
+
if (this.timer !== null) this._clearTimeout(this.timer);
|
|
1159
|
+
const delay = this.loaded === null ? this.retryMs : this.loaded.source === "cache" ? this.retryMs : this.refreshMs;
|
|
1160
|
+
this.timer = this._setTimeout(() => {
|
|
1161
|
+
this.timer = null;
|
|
1162
|
+
void this.load().finally(() => this.arm());
|
|
1163
|
+
}, delay);
|
|
1164
|
+
this.timer.unref?.();
|
|
1165
|
+
}
|
|
1166
|
+
};
|
|
1167
|
+
function describe2(err) {
|
|
1168
|
+
return err instanceof Error ? err.message : String(err);
|
|
1169
|
+
}
|
|
1170
|
+
var cache = /* @__PURE__ */ new Map();
|
|
1171
|
+
function createSdkClient(params) {
|
|
1172
|
+
return new AgentChatClient({
|
|
1173
|
+
apiKey: params.apiKey,
|
|
1174
|
+
...params.apiBase ? { baseUrl: params.apiBase } : {},
|
|
1175
|
+
clientIdentity: AGENTCHAT_CLIENT_IDENTITY,
|
|
1176
|
+
...params.options
|
|
1177
|
+
});
|
|
1178
|
+
}
|
|
1179
|
+
function getClient({ accountId, config, options }) {
|
|
1180
|
+
const existing = cache.get(accountId);
|
|
1181
|
+
if (existing && existing.apiKey === config.apiKey && existing.apiBase === config.apiBase) {
|
|
1182
|
+
return existing.client;
|
|
1183
|
+
}
|
|
1184
|
+
const client = createSdkClient({ apiKey: config.apiKey, apiBase: config.apiBase, options });
|
|
1185
|
+
cache.set(accountId, {
|
|
1186
|
+
client,
|
|
1187
|
+
apiKey: config.apiKey,
|
|
1188
|
+
apiBase: config.apiBase
|
|
1189
|
+
});
|
|
1190
|
+
return client;
|
|
1191
|
+
}
|
|
923
1192
|
|
|
924
1193
|
// src/channel.wizard.ts
|
|
925
1194
|
var JUST_REGISTERED_SENTINEL = "_agentchatJustRegistered";
|
|
@@ -1590,18 +1859,22 @@ var agentchatSetupWizard = {
|
|
|
1590
1859
|
if (result.ok) {
|
|
1591
1860
|
spinner.stop(`Authenticated as @${result.agent.handle}`);
|
|
1592
1861
|
const handle = result.agent.handle;
|
|
1593
|
-
const
|
|
1862
|
+
const resolvedBase = apiBase ?? DEFAULT_API_BASE2;
|
|
1863
|
+
const identityLine = await loadIdentityLine({ client: createSdkClient({ apiKey, apiBase: resolvedBase }), accountId });
|
|
1864
|
+
const placed = placeIntegration({ cfg, handle, apiKey, apiBase: resolvedBase, identityLine, accountId });
|
|
1594
1865
|
const failed = placed.steps.filter((s) => s.status === "failed");
|
|
1866
|
+
const skipped = placed.steps.filter((s) => s.status === "skipped" && s.name === "anchor");
|
|
1595
1867
|
await prompter.note(
|
|
1596
1868
|
[
|
|
1597
1869
|
...formatPlacement(placed.steps),
|
|
1598
1870
|
"",
|
|
1599
|
-
placed.mcp === "added" || placed.steps.some((s) => s.name === "key" && s.status === "changed") ? "Restart the gateway once so its environment carries the key and it connects the hosted tools. Then `openclaw channels status` shows the
|
|
1600
|
-
...failed.length > 0 ? ["", "Some placement failed (above). Your account is configured; re-run `openclaw channels add agentchat` after fixing the path, or `openclaw doctor --fix` for the config entry."] : []
|
|
1871
|
+
placed.mcp === "added" || placed.steps.some((s) => s.name === "key" && s.status === "changed") ? "Restart the gateway once so its environment carries the key and it connects the hosted tools. Then `openclaw channels status` shows the integration and the tools." : "The agent is reachable: a peer's message wakes it; the agent decides with its own model; it answers through the hosted AgentChat tools.",
|
|
1872
|
+
...failed.length > 0 ? ["", "Some placement failed (above). Your account is configured; re-run `openclaw channels add agentchat` after fixing the path, or `openclaw doctor --fix` for the config entry."] : [],
|
|
1873
|
+
...skipped.length > 0 ? ["", "The identity line waits for AgentChat to be reachable: run `openclaw doctor --fix` then."] : []
|
|
1601
1874
|
].join("\n"),
|
|
1602
|
-
"AgentChat
|
|
1875
|
+
"AgentChat integration placed"
|
|
1603
1876
|
);
|
|
1604
|
-
const applied =
|
|
1877
|
+
const applied = applyIntegrationConfig(placed.cfg, { accountId, handle, apiKey, apiBase: resolvedBase });
|
|
1605
1878
|
return { cfg: applied.cfg };
|
|
1606
1879
|
}
|
|
1607
1880
|
spinner.stop(`API key did not pass the live check (${result.reason})`);
|
|
@@ -1650,7 +1923,7 @@ var agentchatSetupWizard = {
|
|
|
1650
1923
|
// when the user explicitly removes the channel; orphans are documented in
|
|
1651
1924
|
// RUNBOOK.md.
|
|
1652
1925
|
disable: (cfg) => {
|
|
1653
|
-
return setSetupChannelEnabled(
|
|
1926
|
+
return setSetupChannelEnabled(stripIntegrationConfig(cfg, "default").cfg, AGENTCHAT_CHANNEL_ID, false);
|
|
1654
1927
|
}
|
|
1655
1928
|
};
|
|
1656
1929
|
var reconnectConfigSchema = z.object({
|
|
@@ -1737,809 +2010,303 @@ function wrapPino(p) {
|
|
|
1737
2010
|
}
|
|
1738
2011
|
|
|
1739
2012
|
// src/metrics.ts
|
|
2013
|
+
function createInMemoryMetrics() {
|
|
2014
|
+
let state = "idle";
|
|
2015
|
+
const wakes = /* @__PURE__ */ new Map();
|
|
2016
|
+
const disconnects = /* @__PURE__ */ new Map();
|
|
2017
|
+
const errors = /* @__PURE__ */ new Map();
|
|
2018
|
+
const bump = (map, key) => {
|
|
2019
|
+
map.set(key, (map.get(key) ?? 0) + 1);
|
|
2020
|
+
};
|
|
2021
|
+
const plain = (map) => Object.fromEntries([...map.entries()].sort(([a], [b]) => a.localeCompare(b)));
|
|
2022
|
+
return {
|
|
2023
|
+
incDisconnect: ({ code, initiator }) => bump(disconnects, `${code}/${initiator}`),
|
|
2024
|
+
incError: ({ errorClass }) => bump(errors, errorClass),
|
|
2025
|
+
setConnectionState: (kind) => {
|
|
2026
|
+
state = kind;
|
|
2027
|
+
},
|
|
2028
|
+
incWake: ({ source }) => bump(wakes, source),
|
|
2029
|
+
snapshot: () => ({ state, wakes: plain(wakes), disconnects: plain(disconnects), errors: plain(errors) })
|
|
2030
|
+
};
|
|
2031
|
+
}
|
|
1740
2032
|
function createNoopMetrics() {
|
|
1741
2033
|
return {
|
|
1742
|
-
|
|
2034
|
+
incDisconnect: () => void 0,
|
|
1743
2035
|
incError: () => void 0,
|
|
1744
2036
|
setConnectionState: () => void 0,
|
|
1745
|
-
|
|
2037
|
+
incWake: () => void 0
|
|
1746
2038
|
};
|
|
1747
2039
|
}
|
|
1748
|
-
|
|
1749
|
-
|
|
1750
|
-
|
|
1751
|
-
|
|
1752
|
-
|
|
1753
|
-
|
|
1754
|
-
|
|
1755
|
-
|
|
1756
|
-
|
|
1757
|
-
|
|
1758
|
-
|
|
1759
|
-
|
|
1760
|
-
|
|
1761
|
-
|
|
1762
|
-
|
|
1763
|
-
|
|
1764
|
-
|
|
1765
|
-
|
|
1766
|
-
|
|
1767
|
-
|
|
1768
|
-
|
|
1769
|
-
|
|
1770
|
-
|
|
1771
|
-
|
|
1772
|
-
|
|
1773
|
-
|
|
1774
|
-
|
|
1775
|
-
|
|
1776
|
-
|
|
1777
|
-
|
|
1778
|
-
|
|
1779
|
-
|
|
1780
|
-
|
|
1781
|
-
|
|
1782
|
-
|
|
1783
|
-
|
|
1784
|
-
|
|
1785
|
-
|
|
1786
|
-
|
|
1787
|
-
|
|
1788
|
-
|
|
1789
|
-
|
|
1790
|
-
|
|
1791
|
-
|
|
1792
|
-
|
|
1793
|
-
|
|
1794
|
-
|
|
1795
|
-
|
|
1796
|
-
|
|
1797
|
-
|
|
1798
|
-
|
|
1799
|
-
|
|
2040
|
+
function groupInviteFromRecord(record) {
|
|
2041
|
+
if (!record || typeof record !== "object" || Array.isArray(record)) return null;
|
|
2042
|
+
const row = record;
|
|
2043
|
+
const inviteId = str(row.id);
|
|
2044
|
+
const groupId = str(row.group_id);
|
|
2045
|
+
if (!inviteId || !groupId) return null;
|
|
2046
|
+
return {
|
|
2047
|
+
inviteId,
|
|
2048
|
+
groupId,
|
|
2049
|
+
groupName: str(row.group_name) ?? "",
|
|
2050
|
+
inviterHandle: (str(row.inviter_handle) ?? "").replace(/^@/, "")
|
|
2051
|
+
};
|
|
2052
|
+
}
|
|
2053
|
+
function str(value) {
|
|
2054
|
+
return typeof value === "string" && value.length > 0 ? value : void 0;
|
|
2055
|
+
}
|
|
2056
|
+
var INVITE_LEDGER_FILE = "invites.json";
|
|
2057
|
+
var INVITE_LEDGER_MAX_AGE_MS = 30 * 24 * 60 * 6e4;
|
|
2058
|
+
function inviteLedgerPath(accountId, stateDir) {
|
|
2059
|
+
return path2.join(integrationStateDir(accountId, stateDir), INVITE_LEDGER_FILE);
|
|
2060
|
+
}
|
|
2061
|
+
var InviteLedger = class {
|
|
2062
|
+
file;
|
|
2063
|
+
now;
|
|
2064
|
+
maxAgeMs;
|
|
2065
|
+
onWriteError;
|
|
2066
|
+
offered;
|
|
2067
|
+
constructor(options) {
|
|
2068
|
+
this.file = options.file ?? inviteLedgerPath(options.accountId, options.stateDir);
|
|
2069
|
+
this.now = options.now ?? Date.now;
|
|
2070
|
+
this.maxAgeMs = options.maxAgeMs ?? INVITE_LEDGER_MAX_AGE_MS;
|
|
2071
|
+
this.onWriteError = options.onWriteError;
|
|
2072
|
+
this.offered = this.read();
|
|
2073
|
+
}
|
|
2074
|
+
get path() {
|
|
2075
|
+
return this.file;
|
|
2076
|
+
}
|
|
2077
|
+
get size() {
|
|
2078
|
+
return this.offered.size;
|
|
2079
|
+
}
|
|
2080
|
+
/** True when a turn for this invite was started before (in this process or an earlier one). */
|
|
2081
|
+
isOffered(inviteId) {
|
|
2082
|
+
return this.offered.has(inviteId);
|
|
2083
|
+
}
|
|
2084
|
+
/** Record that a turn for this invite was admitted. Persists at once. */
|
|
2085
|
+
markOffered(inviteId) {
|
|
2086
|
+
this.offered.set(inviteId, new Date(this.now()).toISOString());
|
|
2087
|
+
this.prune();
|
|
2088
|
+
try {
|
|
2089
|
+
writeJsonFile(this.file, { offered: Object.fromEntries(this.offered) });
|
|
2090
|
+
} catch (err) {
|
|
2091
|
+
this.onWriteError?.(err);
|
|
1800
2092
|
}
|
|
1801
|
-
|
|
1802
|
-
|
|
1803
|
-
|
|
1804
|
-
|
|
1805
|
-
|
|
1806
|
-
|
|
1807
|
-
|
|
2093
|
+
}
|
|
2094
|
+
read() {
|
|
2095
|
+
const raw = readJsonFile(this.file);
|
|
2096
|
+
const out = /* @__PURE__ */ new Map();
|
|
2097
|
+
if (!raw || typeof raw !== "object") return out;
|
|
2098
|
+
const offered = raw.offered;
|
|
2099
|
+
if (!offered || typeof offered !== "object" || Array.isArray(offered)) return out;
|
|
2100
|
+
for (const [id, at] of Object.entries(offered)) {
|
|
2101
|
+
if (typeof at === "string" && id.length > 0) out.set(id, at);
|
|
1808
2102
|
}
|
|
1809
|
-
|
|
1810
|
-
|
|
2103
|
+
this.offered = out;
|
|
2104
|
+
this.prune();
|
|
2105
|
+
return this.offered;
|
|
2106
|
+
}
|
|
2107
|
+
prune() {
|
|
2108
|
+
const cutoff = this.now() - this.maxAgeMs;
|
|
2109
|
+
for (const [id, at] of this.offered) {
|
|
2110
|
+
const t = Date.parse(at);
|
|
2111
|
+
if (!Number.isFinite(t) || t < cutoff) this.offered.delete(id);
|
|
1811
2112
|
}
|
|
1812
2113
|
}
|
|
2114
|
+
};
|
|
2115
|
+
|
|
2116
|
+
// src/integration/socket.ts
|
|
2117
|
+
function wakeSourceOf(reason) {
|
|
2118
|
+
return reason === "reminder" ? "reminder" : "other";
|
|
1813
2119
|
}
|
|
1814
|
-
function
|
|
1815
|
-
return
|
|
2120
|
+
function realtimeOptionsFor(config, extra = {}) {
|
|
2121
|
+
return {
|
|
2122
|
+
apiKey: config.apiKey,
|
|
2123
|
+
baseUrl: config.apiBase.replace(/^http/, "ws").replace(/\/+$/, ""),
|
|
2124
|
+
clientIdentity: AGENTCHAT_CLIENT_IDENTITY,
|
|
2125
|
+
ackOnReceipt: true,
|
|
2126
|
+
reconnect: true,
|
|
2127
|
+
reconnectInterval: config.reconnect.initialBackoffMs,
|
|
2128
|
+
maxReconnectInterval: config.reconnect.maxBackoffMs,
|
|
2129
|
+
...extra.client ? { client: extra.client } : {},
|
|
2130
|
+
...extra.webSocket ? { webSocket: extra.webSocket } : {}
|
|
2131
|
+
};
|
|
1816
2132
|
}
|
|
1817
|
-
|
|
1818
|
-
// src/ws-client.ts
|
|
1819
|
-
var HELLO_ACK_TIMEOUT_MS = 4e3;
|
|
1820
|
-
var RECONNECT_LONG_OUTAGE_AFTER_ATTEMPTS = 60;
|
|
1821
|
-
var RECONNECT_LONG_OUTAGE_BACKOFF_MS = 5 * 6e4;
|
|
1822
|
-
var AUTH_RETRY_INTERVAL_MS = 75e4;
|
|
1823
|
-
var MAX_FRAME_BYTES = 2 * 1024 * 1024;
|
|
1824
|
-
var HELLO_CAPABILITIES = ["ack"];
|
|
1825
|
-
var UNAMBIGUOUS_AUTH_CLOSE_CODES = /* @__PURE__ */ new Set([4401, 4403]);
|
|
1826
|
-
var AMBIGUOUS_AUTH_CLOSE_CODE = 1008;
|
|
1827
|
-
var SERVER_AUTH_CLOSE_REASONS = ["invalid token"];
|
|
1828
|
-
function isHandshakeRejection(code, reason) {
|
|
1829
|
-
if (UNAMBIGUOUS_AUTH_CLOSE_CODES.has(code)) return true;
|
|
1830
|
-
if (code !== AMBIGUOUS_AUTH_CLOSE_CODE) return false;
|
|
1831
|
-
const lower = reason.toLowerCase();
|
|
1832
|
-
return SERVER_AUTH_CLOSE_REASONS.some((known) => lower.includes(known));
|
|
1833
|
-
}
|
|
1834
|
-
var AgentchatWsClient = class {
|
|
2133
|
+
var IntegrationSocket = class {
|
|
1835
2134
|
config;
|
|
1836
2135
|
logger;
|
|
2136
|
+
handlers;
|
|
1837
2137
|
metrics;
|
|
2138
|
+
client;
|
|
2139
|
+
createRealtime;
|
|
2140
|
+
webSocket;
|
|
1838
2141
|
now;
|
|
1839
|
-
|
|
1840
|
-
|
|
1841
|
-
|
|
1842
|
-
|
|
1843
|
-
|
|
1844
|
-
|
|
1845
|
-
|
|
1846
|
-
|
|
1847
|
-
|
|
1848
|
-
|
|
1849
|
-
|
|
1850
|
-
* Set by `closeSocket()` before it closes the current socket, read and
|
|
1851
|
-
* cleared by `handleClose()`. A close this client asked for says nothing
|
|
1852
|
-
* about the server, whatever code travelled with it.
|
|
1853
|
-
*/
|
|
1854
|
-
closeInitiatedLocally = false;
|
|
1855
|
-
/** One error line per long outage / per run of rejected keys, then debug. */
|
|
1856
|
-
longOutageAnnounced = false;
|
|
1857
|
-
authFailAnnounced = false;
|
|
1858
|
-
helloAckTimer = null;
|
|
1859
|
-
pingTimer = null;
|
|
1860
|
-
pongTimer = null;
|
|
1861
|
-
reconnectTimer = null;
|
|
1862
|
-
drainTimer = null;
|
|
1863
|
-
listeners = {
|
|
1864
|
-
stateChanged: /* @__PURE__ */ new Set(),
|
|
1865
|
-
inboundFrame: /* @__PURE__ */ new Set(),
|
|
1866
|
-
error: /* @__PURE__ */ new Set(),
|
|
1867
|
-
authenticated: /* @__PURE__ */ new Set(),
|
|
1868
|
-
closed: /* @__PURE__ */ new Set()
|
|
1869
|
-
};
|
|
2142
|
+
selfHandle;
|
|
2143
|
+
realtime = null;
|
|
2144
|
+
/** The SDK's state as last reported through its `state` event; `stopped` is set here only for a stop before any start. */
|
|
2145
|
+
state = "idle";
|
|
2146
|
+
connectedAt = null;
|
|
2147
|
+
stopping = false;
|
|
2148
|
+
frames = 0;
|
|
2149
|
+
selfFiltered = 0;
|
|
2150
|
+
wakes = 0;
|
|
2151
|
+
invites = 0;
|
|
2152
|
+
disconnects = 0;
|
|
1870
2153
|
constructor(options) {
|
|
1871
2154
|
this.config = options.config;
|
|
1872
|
-
this.logger = options.logger.child({ component: "
|
|
1873
|
-
this.
|
|
2155
|
+
this.logger = options.logger.child({ component: "socket" });
|
|
2156
|
+
this.handlers = options.handlers ?? {};
|
|
2157
|
+
this.metrics = options.metrics ?? createNoopMetrics();
|
|
2158
|
+
this.client = options.client;
|
|
2159
|
+
this.createRealtime = options.createRealtime ?? ((opts) => new RealtimeClient(opts));
|
|
2160
|
+
this.webSocket = options.webSocket;
|
|
1874
2161
|
this.now = options.now ?? Date.now;
|
|
1875
|
-
this.
|
|
1876
|
-
this.
|
|
1877
|
-
this._setTimeout = options.setTimeout ?? ((fn, ms) => setTimeout(fn, ms));
|
|
1878
|
-
this._clearTimeout = options.clearTimeout ?? ((h) => clearTimeout(h));
|
|
1879
|
-
this._setInterval = options.setInterval ?? ((fn, ms) => setInterval(fn, ms));
|
|
1880
|
-
this._clearInterval = options.clearInterval ?? ((h) => clearInterval(h));
|
|
1881
|
-
this.metrics.setConnectionState(this.state.kind);
|
|
1882
|
-
}
|
|
1883
|
-
// ─── Public API ──────────────────────────────────────────────────────
|
|
1884
|
-
/** Current connection state. Read-only from the caller's perspective. */
|
|
1885
|
-
getState() {
|
|
1886
|
-
return this.state;
|
|
1887
|
-
}
|
|
1888
|
-
/**
|
|
1889
|
-
* True when the last `hello.ok` echoed the `ack` capability: the server
|
|
1890
|
-
* keeps envelopes `stored` until acknowledged — and this client never
|
|
1891
|
-
* acknowledges. False against a legacy server (envelopes marked on push).
|
|
1892
|
-
*/
|
|
1893
|
-
get ackNegotiated() {
|
|
1894
|
-
return this._ackNegotiated;
|
|
2162
|
+
this.selfHandle = this.config.agentHandle?.replace(/^@/, "").toLowerCase();
|
|
2163
|
+
this.metrics.setConnectionState(this.state);
|
|
1895
2164
|
}
|
|
1896
2165
|
/**
|
|
1897
|
-
*
|
|
1898
|
-
*
|
|
2166
|
+
* Open the socket. Idempotent. Resolves once the SDK has started its
|
|
2167
|
+
* connect loop; a failure to resolve a WebSocket implementation is logged
|
|
2168
|
+
* and left to the SDK's own retry. Never throws.
|
|
1899
2169
|
*/
|
|
1900
|
-
start() {
|
|
1901
|
-
if (this.
|
|
1902
|
-
|
|
1903
|
-
|
|
1904
|
-
|
|
1905
|
-
|
|
2170
|
+
async start() {
|
|
2171
|
+
if (this.realtime || this.stopping) return;
|
|
2172
|
+
const realtime = this.createRealtime(realtimeOptionsFor(this.config, { client: this.client, webSocket: this.webSocket }));
|
|
2173
|
+
this.realtime = realtime;
|
|
2174
|
+
this.bind(realtime);
|
|
2175
|
+
try {
|
|
2176
|
+
await realtime.connect();
|
|
2177
|
+
} catch (err) {
|
|
2178
|
+
this.logger.warn({ err: describe3(err) }, "socket connect failed \u2014 the SDK retries on its own schedule");
|
|
1906
2179
|
}
|
|
1907
|
-
this.openSocket(1);
|
|
1908
2180
|
}
|
|
1909
|
-
/**
|
|
1910
|
-
|
|
1911
|
-
|
|
1912
|
-
|
|
1913
|
-
|
|
1914
|
-
|
|
1915
|
-
|
|
1916
|
-
|
|
1917
|
-
|
|
1918
|
-
|
|
1919
|
-
this.
|
|
1920
|
-
this.scheduleDrainDeadline(computedDeadline);
|
|
2181
|
+
/** Close the socket for good; a stopped socket does not reconnect. Idempotent. */
|
|
2182
|
+
async stop() {
|
|
2183
|
+
this.stopping = true;
|
|
2184
|
+
const realtime = this.realtime;
|
|
2185
|
+
this.realtime = null;
|
|
2186
|
+
this.connectedAt = null;
|
|
2187
|
+
if (realtime) {
|
|
2188
|
+
try {
|
|
2189
|
+
realtime.disconnect();
|
|
2190
|
+
} catch (err) {
|
|
2191
|
+
this.logger.warn({ err: describe3(err) }, "socket disconnect threw \u2014 continuing");
|
|
1921
2192
|
}
|
|
1922
|
-
return;
|
|
1923
|
-
}
|
|
1924
|
-
if (isTerminal(this.state)) {
|
|
1925
|
-
return;
|
|
1926
|
-
}
|
|
1927
|
-
this.applyEvent({ type: "DRAIN_REQUESTED", now, deadline: computedDeadline });
|
|
1928
|
-
const after = this.state.kind;
|
|
1929
|
-
if (after === "DRAINING") {
|
|
1930
|
-
this.scheduleDrainDeadline(computedDeadline);
|
|
1931
|
-
} else if (after === "CLOSED") {
|
|
1932
|
-
this.closeSocket(1e3, "client drain (immediate)");
|
|
1933
|
-
this.emit("closed");
|
|
1934
2193
|
}
|
|
2194
|
+
if (this.state !== "stopped") this.onState("stopped", this.state);
|
|
1935
2195
|
}
|
|
1936
|
-
|
|
1937
|
-
|
|
1938
|
-
|
|
1939
|
-
|
|
1940
|
-
|
|
1941
|
-
reconfigured() {
|
|
1942
|
-
if (this.state.kind !== "AUTH_FAIL") return;
|
|
1943
|
-
this.clearReconnectTimer();
|
|
1944
|
-
this.applyEvent({ type: "RECONFIGURED" });
|
|
1945
|
-
this.openSocket(1);
|
|
1946
|
-
}
|
|
1947
|
-
on(event, handler) {
|
|
1948
|
-
this.listeners[event].add(handler);
|
|
1949
|
-
return () => {
|
|
1950
|
-
this.listeners[event].delete(handler);
|
|
2196
|
+
getHealth() {
|
|
2197
|
+
return {
|
|
2198
|
+
state: this.state,
|
|
2199
|
+
connectedAt: this.connectedAt,
|
|
2200
|
+
counters: { frames: this.frames, selfFiltered: this.selfFiltered, wakes: this.wakes, invites: this.invites, disconnects: this.disconnects }
|
|
1951
2201
|
};
|
|
1952
2202
|
}
|
|
1953
|
-
// ─── Internals
|
|
1954
|
-
|
|
1955
|
-
|
|
1956
|
-
|
|
1957
|
-
|
|
1958
|
-
|
|
1959
|
-
|
|
1960
|
-
|
|
1961
|
-
|
|
1962
|
-
|
|
1963
|
-
|
|
1964
|
-
|
|
1965
|
-
|
|
1966
|
-
|
|
1967
|
-
|
|
1968
|
-
});
|
|
1969
|
-
|
|
1970
|
-
|
|
1971
|
-
|
|
1972
|
-
|
|
1973
|
-
|
|
1974
|
-
|
|
1975
|
-
|
|
1976
|
-
|
|
1977
|
-
this.scheduleReconnect("ctor-failed");
|
|
1978
|
-
return;
|
|
1979
|
-
}
|
|
1980
|
-
this.ws = ws;
|
|
1981
|
-
this.bindSocket(ws);
|
|
1982
|
-
}
|
|
1983
|
-
bindSocket(ws) {
|
|
1984
|
-
ws.on("open", () => this.handleOpen());
|
|
1985
|
-
ws.on("message", (data, isBinary) => this.handleMessage(data, isBinary));
|
|
1986
|
-
ws.on("pong", () => this.handlePong());
|
|
1987
|
-
ws.on("close", (code, reason) => this.handleClose(code, reason.toString()));
|
|
1988
|
-
ws.on("error", (err) => {
|
|
1989
|
-
this.emitError(
|
|
1990
|
-
new AgentChatChannelError(
|
|
1991
|
-
classifyNetworkError(err),
|
|
1992
|
-
"ws transport error",
|
|
1993
|
-
{ cause: err }
|
|
1994
|
-
)
|
|
2203
|
+
// ─── Internals ─────────────────────────────────────────────────────
|
|
2204
|
+
bind(realtime) {
|
|
2205
|
+
realtime.on("state", (next, prev) => this.onState(next, prev));
|
|
2206
|
+
realtime.onConnect(() => {
|
|
2207
|
+
const at = this.now();
|
|
2208
|
+
this.connectedAt = at;
|
|
2209
|
+
this.logger.info({ at: new Date(at).toISOString() }, "connected (HELLO accepted)");
|
|
2210
|
+
this.guard("onConnected", () => this.handlers.onConnected?.(at));
|
|
2211
|
+
this.wake("connect", {});
|
|
2212
|
+
});
|
|
2213
|
+
realtime.onDisconnect((info) => {
|
|
2214
|
+
if (this.stopping) return;
|
|
2215
|
+
this.disconnects += 1;
|
|
2216
|
+
this.connectedAt = null;
|
|
2217
|
+
this.metrics.incDisconnect({ code: String(info.code), initiator: info.initiator });
|
|
2218
|
+
this.logger.info({ code: info.code, reason: info.reason, initiator: info.initiator }, "socket closed \u2014 the SDK decides what follows (backoff or blocked)");
|
|
2219
|
+
this.guard("onDisconnected", () => this.handlers.onDisconnected?.(info));
|
|
2220
|
+
});
|
|
2221
|
+
realtime.on("blocked", (info) => {
|
|
2222
|
+
if (this.stopping) return;
|
|
2223
|
+
this.metrics.incError({ errorClass: "auth" });
|
|
2224
|
+
this.logger.warn(
|
|
2225
|
+
{ code: info.code, reason: info.reason, retryInMs: info.retryInMs },
|
|
2226
|
+
"the server rejected the key during the handshake \u2014 the SDK retries a fresh HELLO on its own"
|
|
1995
2227
|
);
|
|
2228
|
+
this.guard("onBlocked", () => this.handlers.onBlocked?.(info));
|
|
2229
|
+
});
|
|
2230
|
+
realtime.onError((error) => {
|
|
2231
|
+
if (this.stopping) return;
|
|
2232
|
+
if (realtime.state === "blocked") {
|
|
2233
|
+
this.logger.debug({ err: error.message }, "SDK notice while blocked");
|
|
2234
|
+
return;
|
|
2235
|
+
}
|
|
2236
|
+
this.metrics.incError({ errorClass: classifyRealtimeError(error) });
|
|
2237
|
+
this.logger.debug({ err: error.message }, "socket error");
|
|
2238
|
+
this.guard("onError", () => this.handlers.onError?.(error));
|
|
1996
2239
|
});
|
|
2240
|
+
realtime.on("message.new", (message) => this.onMessageNew(message));
|
|
2241
|
+
realtime.on("wake", (frame) => this.onWakeFrame(frame));
|
|
2242
|
+
realtime.on("group.invite.received", (message) => this.onInvite(message));
|
|
1997
2243
|
}
|
|
1998
|
-
|
|
1999
|
-
|
|
2000
|
-
const
|
|
2001
|
-
|
|
2002
|
-
|
|
2003
|
-
|
|
2004
|
-
|
|
2005
|
-
|
|
2006
|
-
|
|
2007
|
-
|
|
2008
|
-
|
|
2009
|
-
|
|
2010
|
-
|
|
2011
|
-
);
|
|
2012
|
-
} catch (err) {
|
|
2013
|
-
this.emitError(
|
|
2014
|
-
new AgentChatChannelError(
|
|
2015
|
-
"retry-transient",
|
|
2016
|
-
"hello send failed",
|
|
2017
|
-
{ cause: err }
|
|
2018
|
-
)
|
|
2019
|
-
);
|
|
2020
|
-
this.closeSocket(1011, "hello send failed");
|
|
2244
|
+
onMessageNew(message) {
|
|
2245
|
+
this.frames += 1;
|
|
2246
|
+
const payload = message.payload ?? {};
|
|
2247
|
+
const senderRaw = payload.sender ?? payload.from ?? "";
|
|
2248
|
+
const sender = typeof senderRaw === "string" ? senderRaw.replace(/^@/, "").toLowerCase() : "";
|
|
2249
|
+
const detail = {
|
|
2250
|
+
...typeof payload.conversation_id === "string" ? { conversationId: payload.conversation_id } : {},
|
|
2251
|
+
...typeof payload.id === "string" ? { messageId: payload.id } : {},
|
|
2252
|
+
...sender ? { from: sender } : {}
|
|
2253
|
+
};
|
|
2254
|
+
if (this.selfHandle && sender === this.selfHandle) {
|
|
2255
|
+
this.selfFiltered += 1;
|
|
2256
|
+
this.logger.debug(detail, "own echo \u2014 not a wake");
|
|
2021
2257
|
return;
|
|
2022
2258
|
}
|
|
2023
|
-
this.
|
|
2024
|
-
|
|
2025
|
-
this.logger.warn({ timeoutMs: HELLO_ACK_TIMEOUT_MS }, "hello ack timeout");
|
|
2026
|
-
this.emitError(
|
|
2027
|
-
new AgentChatChannelError("retry-transient", "hello ack timeout")
|
|
2028
|
-
);
|
|
2029
|
-
this.closeSocket(1001, "hello ack timeout");
|
|
2030
|
-
}, HELLO_ACK_TIMEOUT_MS);
|
|
2259
|
+
this.logger.debug(detail, "wake \u2014 message.new");
|
|
2260
|
+
this.wake("message", detail);
|
|
2031
2261
|
}
|
|
2032
|
-
|
|
2033
|
-
|
|
2034
|
-
|
|
2035
|
-
|
|
2036
|
-
}
|
|
2037
|
-
|
|
2038
|
-
|
|
2039
|
-
|
|
2040
|
-
|
|
2262
|
+
onWakeFrame(frame) {
|
|
2263
|
+
this.frames += 1;
|
|
2264
|
+
const reason = frame.payload?.reason;
|
|
2265
|
+
const detail = { conversationId: frame.payload.conversation_id };
|
|
2266
|
+
this.logger.info({ ...detail, reason, step: frame.payload.step }, "wake \u2014 server wake frame");
|
|
2267
|
+
this.wake(wakeSourceOf(reason), detail);
|
|
2268
|
+
}
|
|
2269
|
+
onInvite(message) {
|
|
2270
|
+
this.frames += 1;
|
|
2271
|
+
const invite = groupInviteFromRecord(message.payload);
|
|
2272
|
+
if (!invite) {
|
|
2273
|
+
this.logger.warn({ keys: Object.keys(message.payload ?? {}).sort() }, "group.invite.received without ids \u2014 dropped");
|
|
2041
2274
|
return;
|
|
2042
2275
|
}
|
|
2043
|
-
|
|
2044
|
-
|
|
2045
|
-
parsed = JSON.parse(text);
|
|
2046
|
-
} catch (err) {
|
|
2047
|
-
this.emitError(
|
|
2048
|
-
new AgentChatChannelError(
|
|
2049
|
-
"validation",
|
|
2050
|
-
"malformed json frame",
|
|
2051
|
-
{ cause: err }
|
|
2052
|
-
)
|
|
2053
|
-
);
|
|
2054
|
-
return;
|
|
2055
|
-
}
|
|
2056
|
-
if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
|
|
2057
|
-
this.emitError(
|
|
2058
|
-
new AgentChatChannelError("validation", "frame not an object")
|
|
2059
|
-
);
|
|
2060
|
-
return;
|
|
2061
|
-
}
|
|
2062
|
-
const obj = parsed;
|
|
2063
|
-
const type = typeof obj.type === "string" ? obj.type : null;
|
|
2064
|
-
if (!type) {
|
|
2065
|
-
this.emitError(
|
|
2066
|
-
new AgentChatChannelError("validation", "frame missing type")
|
|
2067
|
-
);
|
|
2068
|
-
return;
|
|
2069
|
-
}
|
|
2070
|
-
if (this.state.kind === "AUTHENTICATING") {
|
|
2071
|
-
if (type === "hello.ok") {
|
|
2072
|
-
this.handleHelloOk(received, obj);
|
|
2073
|
-
return;
|
|
2074
|
-
}
|
|
2075
|
-
if (type === "hello.error" || type === "auth.rejected" || type === "error") {
|
|
2076
|
-
const reason = this.extractReason(obj) ?? "auth rejected";
|
|
2077
|
-
this.handleAuthRejected(reason);
|
|
2078
|
-
return;
|
|
2079
|
-
}
|
|
2080
|
-
this.logger.warn({ type }, "frame arrived before hello.ok \u2014 ignoring");
|
|
2081
|
-
return;
|
|
2082
|
-
}
|
|
2083
|
-
const payload = this.extractPayload(obj);
|
|
2084
|
-
this.emit("inboundFrame", {
|
|
2085
|
-
type,
|
|
2086
|
-
payload,
|
|
2087
|
-
receivedAt: received,
|
|
2088
|
-
raw: parsed
|
|
2089
|
-
});
|
|
2090
|
-
}
|
|
2091
|
-
extractReason(obj) {
|
|
2092
|
-
const payload = obj.payload;
|
|
2093
|
-
if (payload && typeof payload === "object") {
|
|
2094
|
-
const msg = payload.message;
|
|
2095
|
-
if (typeof msg === "string") return msg;
|
|
2096
|
-
const reason = payload.reason;
|
|
2097
|
-
if (typeof reason === "string") return reason;
|
|
2098
|
-
}
|
|
2099
|
-
const top = obj.message ?? obj.reason;
|
|
2100
|
-
return typeof top === "string" ? top : void 0;
|
|
2101
|
-
}
|
|
2102
|
-
extractPayload(obj) {
|
|
2103
|
-
const payload = obj.payload;
|
|
2104
|
-
return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
|
|
2105
|
-
}
|
|
2106
|
-
handleHelloOk(now, frame) {
|
|
2107
|
-
if (this.helloAckTimer) {
|
|
2108
|
-
this._clearTimeout(this.helloAckTimer);
|
|
2109
|
-
this.helloAckTimer = null;
|
|
2110
|
-
}
|
|
2111
|
-
const caps = frame.capabilities ?? this.extractPayload(frame).capabilities;
|
|
2112
|
-
this._ackNegotiated = Array.isArray(caps) && caps.includes("ack");
|
|
2113
|
-
this.logger.info({ ackNegotiated: this._ackNegotiated }, "hello.ok");
|
|
2114
|
-
this.applyEvent({ type: "HELLO_OK", now });
|
|
2115
|
-
this.attempt = 0;
|
|
2116
|
-
this.longOutageAnnounced = false;
|
|
2117
|
-
this.authFailAnnounced = false;
|
|
2118
|
-
this.startHeartbeat();
|
|
2119
|
-
this.emit("authenticated", now);
|
|
2120
|
-
}
|
|
2121
|
-
/** The server answered HELLO with a rejection frame (not a close). */
|
|
2122
|
-
handleAuthRejected(reason) {
|
|
2123
|
-
if (this.helloAckTimer) {
|
|
2124
|
-
this._clearTimeout(this.helloAckTimer);
|
|
2125
|
-
this.helloAckTimer = null;
|
|
2126
|
-
}
|
|
2127
|
-
this.enterAuthFail(reason);
|
|
2128
|
-
this.closeSocket(1e3, "auth rejected");
|
|
2129
|
-
}
|
|
2130
|
-
/**
|
|
2131
|
-
* The server rejected this key. AUTH_FAIL is not the end: retry a fresh
|
|
2132
|
-
* HELLO every `AUTH_RETRY_INTERVAL_MS` (jittered). The first rejection in a
|
|
2133
|
-
* run logs at error so an operator sees it; the following ones at debug.
|
|
2134
|
-
*/
|
|
2135
|
-
enterAuthFail(reason) {
|
|
2136
|
-
this.logger[this.authFailAnnounced ? "debug" : "error"](
|
|
2137
|
-
{ reason, retryIntervalMs: AUTH_RETRY_INTERVAL_MS, attempt: this.attempt },
|
|
2138
|
-
"auth rejected \u2014 retrying slowly until the key is accepted again"
|
|
2139
|
-
);
|
|
2140
|
-
this.authFailAnnounced = true;
|
|
2141
|
-
this.applyEvent({ type: "AUTH_REJECTED", reason });
|
|
2142
|
-
this.emitError(
|
|
2143
|
-
new AgentChatChannelError("terminal-auth", `auth rejected: ${reason}`)
|
|
2144
|
-
);
|
|
2145
|
-
this.scheduleAuthRetry();
|
|
2146
|
-
}
|
|
2147
|
-
handleClose(code, reason) {
|
|
2148
|
-
const wasAuthenticating = this.state.kind === "AUTHENTICATING";
|
|
2149
|
-
const wasDraining = this.state.kind === "DRAINING";
|
|
2150
|
-
const ours = this.closeInitiatedLocally;
|
|
2151
|
-
this.closeInitiatedLocally = false;
|
|
2152
|
-
const serverAuthClose = !ours && isHandshakeRejection(code, reason);
|
|
2153
|
-
this.stopHeartbeat();
|
|
2154
|
-
if (this.helloAckTimer) {
|
|
2155
|
-
this._clearTimeout(this.helloAckTimer);
|
|
2156
|
-
this.helloAckTimer = null;
|
|
2157
|
-
}
|
|
2158
|
-
this.ws = null;
|
|
2159
|
-
this._ackNegotiated = false;
|
|
2160
|
-
const kind = this.state.kind;
|
|
2161
|
-
if (kind === "CLOSED") {
|
|
2162
|
-
this.logger.debug({ code, reason }, "socket closed after CLOSED \u2014 no-op");
|
|
2163
|
-
return;
|
|
2164
|
-
}
|
|
2165
|
-
if (kind === "AUTH_FAIL") {
|
|
2166
|
-
this.logger.debug({ code, reason }, "socket closed after AUTH_FAIL \u2014 retry already scheduled");
|
|
2167
|
-
return;
|
|
2168
|
-
}
|
|
2169
|
-
if (serverAuthClose && wasAuthenticating) {
|
|
2170
|
-
this.enterAuthFail(`close ${code}: ${reason}`);
|
|
2171
|
-
return;
|
|
2172
|
-
}
|
|
2173
|
-
this.applyEvent({ type: "SOCKET_CLOSED", code, reason });
|
|
2174
|
-
if (wasDraining || this.state.kind === "CLOSED") {
|
|
2175
|
-
this.emit("closed");
|
|
2176
|
-
return;
|
|
2177
|
-
}
|
|
2178
|
-
this.logger.info(
|
|
2179
|
-
{ code, reason, ours, attempt: this.attempt },
|
|
2180
|
-
"socket closed \u2014 scheduling reconnect"
|
|
2181
|
-
);
|
|
2182
|
-
this.scheduleReconnect(`close-${code}`);
|
|
2183
|
-
}
|
|
2184
|
-
closeSocket(code, reason) {
|
|
2185
|
-
if (!this.ws) return;
|
|
2186
|
-
this.closeInitiatedLocally = true;
|
|
2187
|
-
try {
|
|
2188
|
-
this.ws.close(code, reason);
|
|
2189
|
-
} catch {
|
|
2190
|
-
}
|
|
2191
|
-
}
|
|
2192
|
-
// ─── Internals: heartbeat ────────────────────────────────────────────
|
|
2193
|
-
startHeartbeat() {
|
|
2194
|
-
this.stopHeartbeat();
|
|
2195
|
-
const intervalMs = this.config.ping.intervalMs;
|
|
2196
|
-
this.pingTimer = this._setInterval(() => this.sendPing(), intervalMs);
|
|
2197
|
-
}
|
|
2198
|
-
stopHeartbeat() {
|
|
2199
|
-
if (this.pingTimer) {
|
|
2200
|
-
this._clearInterval(this.pingTimer);
|
|
2201
|
-
this.pingTimer = null;
|
|
2202
|
-
}
|
|
2203
|
-
if (this.pongTimer) {
|
|
2204
|
-
this._clearTimeout(this.pongTimer);
|
|
2205
|
-
this.pongTimer = null;
|
|
2206
|
-
}
|
|
2276
|
+
this.invites += 1;
|
|
2277
|
+
this.guard("onGroupInvite", () => this.handlers.onGroupInvite?.(invite));
|
|
2207
2278
|
}
|
|
2208
|
-
|
|
2209
|
-
|
|
2210
|
-
|
|
2211
|
-
|
|
2212
|
-
} catch (err) {
|
|
2213
|
-
this.emitError(
|
|
2214
|
-
new AgentChatChannelError(
|
|
2215
|
-
"retry-transient",
|
|
2216
|
-
"ws ping failed",
|
|
2217
|
-
{ cause: err }
|
|
2218
|
-
)
|
|
2219
|
-
);
|
|
2220
|
-
return;
|
|
2221
|
-
}
|
|
2222
|
-
const timeoutMs = this.config.ping.timeoutMs;
|
|
2223
|
-
if (this.pongTimer) this._clearTimeout(this.pongTimer);
|
|
2224
|
-
this.pongTimer = this._setTimeout(() => {
|
|
2225
|
-
this.pongTimer = null;
|
|
2226
|
-
const now = this.now();
|
|
2227
|
-
this.logger.warn({ timeoutMs }, "ping timeout \u2014 declaring degraded");
|
|
2228
|
-
this.applyEvent({ type: "PING_TIMEOUT", now });
|
|
2229
|
-
this.closeSocket(1011, "ping timeout");
|
|
2230
|
-
}, timeoutMs);
|
|
2231
|
-
}
|
|
2232
|
-
handlePong() {
|
|
2233
|
-
if (this.pongTimer) {
|
|
2234
|
-
this._clearTimeout(this.pongTimer);
|
|
2235
|
-
this.pongTimer = null;
|
|
2236
|
-
}
|
|
2237
|
-
if (this.state.kind === "DEGRADED" && this.state.reason === "ping-timeout") {
|
|
2238
|
-
this.applyEvent({ type: "RECOVERED", now: this.now() });
|
|
2239
|
-
}
|
|
2240
|
-
}
|
|
2241
|
-
// ─── Internals: reconnect ────────────────────────────────────────────
|
|
2242
|
-
scheduleReconnect(reason) {
|
|
2243
|
-
if (this.state.kind === "CLOSED" || this.state.kind === "AUTH_FAIL") return;
|
|
2244
|
-
if (this.reconnectTimer) return;
|
|
2245
|
-
const nextAttempt = this.attempt + 1;
|
|
2246
|
-
if (nextAttempt > RECONNECT_LONG_OUTAGE_AFTER_ATTEMPTS && !this.longOutageAnnounced) {
|
|
2247
|
-
this.longOutageAnnounced = true;
|
|
2248
|
-
this.logger.error(
|
|
2249
|
-
{
|
|
2250
|
-
attempt: nextAttempt,
|
|
2251
|
-
maxBackoffMs: Math.max(this.config.reconnect.maxBackoffMs, RECONNECT_LONG_OUTAGE_BACKOFF_MS)
|
|
2252
|
-
},
|
|
2253
|
-
`still reconnecting after ${RECONNECT_LONG_OUTAGE_AFTER_ATTEMPTS} attempts \u2014 backing off further, not giving up`
|
|
2254
|
-
);
|
|
2255
|
-
}
|
|
2256
|
-
const delay = this.computeReconnectDelay(nextAttempt);
|
|
2257
|
-
this.metrics.incReconnect({ reason });
|
|
2258
|
-
this.logger.info(
|
|
2259
|
-
{ attempt: nextAttempt, delayMs: delay, reason },
|
|
2260
|
-
"scheduling reconnect"
|
|
2261
|
-
);
|
|
2262
|
-
this.reconnectTimer = this._setTimeout(() => {
|
|
2263
|
-
this.reconnectTimer = null;
|
|
2264
|
-
this.openSocket(nextAttempt);
|
|
2265
|
-
}, delay);
|
|
2266
|
-
}
|
|
2267
|
-
/** AUTH_FAIL's own cadence: a fresh HELLO every AUTH_RETRY_INTERVAL_MS, jittered. */
|
|
2268
|
-
scheduleAuthRetry() {
|
|
2269
|
-
if (this.state.kind !== "AUTH_FAIL") return;
|
|
2270
|
-
this.clearReconnectTimer();
|
|
2271
|
-
const nextAttempt = this.attempt + 1;
|
|
2272
|
-
const delay = this.jittered(AUTH_RETRY_INTERVAL_MS);
|
|
2273
|
-
this.metrics.incReconnect({ reason: "auth-retry" });
|
|
2274
|
-
this.logger.debug({ attempt: nextAttempt, delayMs: delay }, "scheduling auth retry");
|
|
2275
|
-
this.reconnectTimer = this._setTimeout(() => {
|
|
2276
|
-
this.reconnectTimer = null;
|
|
2277
|
-
this.openSocket(nextAttempt);
|
|
2278
|
-
}, delay);
|
|
2279
|
-
}
|
|
2280
|
-
clearReconnectTimer() {
|
|
2281
|
-
if (this.reconnectTimer) {
|
|
2282
|
-
this._clearTimeout(this.reconnectTimer);
|
|
2283
|
-
this.reconnectTimer = null;
|
|
2284
|
-
}
|
|
2285
|
-
}
|
|
2286
|
-
computeReconnectDelay(attempt) {
|
|
2287
|
-
const { initialBackoffMs, maxBackoffMs } = this.config.reconnect;
|
|
2288
|
-
const reconnectCount = Math.max(1, attempt - 1);
|
|
2289
|
-
const exp = initialBackoffMs * Math.pow(2, Math.min(reconnectCount - 1, 20));
|
|
2290
|
-
const cap = attempt > RECONNECT_LONG_OUTAGE_AFTER_ATTEMPTS ? Math.max(maxBackoffMs, RECONNECT_LONG_OUTAGE_BACKOFF_MS) : maxBackoffMs;
|
|
2291
|
-
return this.jittered(Math.min(exp, cap));
|
|
2292
|
-
}
|
|
2293
|
-
/**
|
|
2294
|
-
* Symmetric ±`jitterRatio`. Thundering-herd-safe: a fleet that all drops
|
|
2295
|
-
* at the same instant re-enters the connect queue spread across
|
|
2296
|
-
* ms * [1-jitterRatio, 1+jitterRatio].
|
|
2297
|
-
*/
|
|
2298
|
-
jittered(ms) {
|
|
2299
|
-
const { jitterRatio } = this.config.reconnect;
|
|
2300
|
-
const jitter = 1 - jitterRatio + this.random() * 2 * jitterRatio;
|
|
2301
|
-
return Math.max(0, Math.floor(ms * jitter));
|
|
2302
|
-
}
|
|
2303
|
-
// ─── Internals: drain ────────────────────────────────────────────────
|
|
2304
|
-
scheduleDrainDeadline(deadline) {
|
|
2305
|
-
if (this.drainTimer) this._clearTimeout(this.drainTimer);
|
|
2306
|
-
const now = this.now();
|
|
2307
|
-
const delay = Math.max(0, deadline - now);
|
|
2308
|
-
this.drainTimer = this._setTimeout(() => {
|
|
2309
|
-
this.drainTimer = null;
|
|
2310
|
-
if (this.state.kind === "DRAINING") {
|
|
2311
|
-
this.logger.warn({ deadline }, "drain deadline exceeded \u2014 force-closing");
|
|
2312
|
-
this.applyEvent({ type: "DRAIN_COMPLETED" });
|
|
2313
|
-
this.closeSocket(1e3, "drain deadline");
|
|
2314
|
-
this.emit("closed");
|
|
2315
|
-
}
|
|
2316
|
-
}, delay);
|
|
2279
|
+
wake(source, detail) {
|
|
2280
|
+
this.wakes += 1;
|
|
2281
|
+
this.metrics.incWake({ source });
|
|
2282
|
+
this.guard("onWake", () => this.handlers.onWake?.(source, detail));
|
|
2317
2283
|
}
|
|
2318
|
-
/**
|
|
2319
|
-
|
|
2320
|
-
* let the WS client transition CLOSED earlier than the deadline.
|
|
2321
|
-
*/
|
|
2322
|
-
drainCompleted() {
|
|
2323
|
-
if (this.state.kind !== "DRAINING") return;
|
|
2324
|
-
if (this.drainTimer) {
|
|
2325
|
-
this._clearTimeout(this.drainTimer);
|
|
2326
|
-
this.drainTimer = null;
|
|
2327
|
-
}
|
|
2328
|
-
this.applyEvent({ type: "DRAIN_COMPLETED" });
|
|
2329
|
-
this.closeSocket(1e3, "drain completed");
|
|
2330
|
-
this.emit("closed");
|
|
2331
|
-
}
|
|
2332
|
-
// ─── Internals: state machine + emit ─────────────────────────────────
|
|
2333
|
-
applyEvent(event) {
|
|
2334
|
-
const prev = this.state;
|
|
2335
|
-
const next = transition(prev, event);
|
|
2336
|
-
if (next === prev) {
|
|
2337
|
-
this.logger.debug(
|
|
2338
|
-
{ from: prev.kind, event: event.type },
|
|
2339
|
-
"transition.invalid"
|
|
2340
|
-
);
|
|
2341
|
-
return;
|
|
2342
|
-
}
|
|
2284
|
+
/** The SDK's state transition, mirrored for the health probe and the gauge, then handed on. */
|
|
2285
|
+
onState(next, prev) {
|
|
2343
2286
|
this.state = next;
|
|
2344
|
-
|
|
2345
|
-
|
|
2346
|
-
|
|
2347
|
-
this.metrics.setConnectionState(next.kind);
|
|
2348
|
-
this.logger.info(
|
|
2349
|
-
{ from: prev.kind, to: next.kind, event: event.type },
|
|
2350
|
-
"state transition"
|
|
2351
|
-
);
|
|
2352
|
-
this.emit("stateChanged", next, prev);
|
|
2353
|
-
}
|
|
2354
|
-
emit(event, ...args) {
|
|
2355
|
-
for (const listener of this.listeners[event]) {
|
|
2356
|
-
try {
|
|
2357
|
-
;
|
|
2358
|
-
listener(...args);
|
|
2359
|
-
} catch (err) {
|
|
2360
|
-
this.logger.error(
|
|
2361
|
-
{ event, err: err instanceof Error ? err.message : String(err) },
|
|
2362
|
-
"listener threw \u2014 continuing"
|
|
2363
|
-
);
|
|
2364
|
-
}
|
|
2365
|
-
}
|
|
2366
|
-
}
|
|
2367
|
-
emitError(error) {
|
|
2368
|
-
this.metrics.incError({ errorClass: error.class_ });
|
|
2369
|
-
this.logger.warn(
|
|
2370
|
-
{ class: error.class_, message: error.message, statusCode: error.statusCode },
|
|
2371
|
-
"channel error"
|
|
2372
|
-
);
|
|
2373
|
-
this.emit("error", error);
|
|
2374
|
-
}
|
|
2375
|
-
};
|
|
2376
|
-
|
|
2377
|
-
// src/knock-frames.ts
|
|
2378
|
-
function readMessageKnock(frame) {
|
|
2379
|
-
if (frame.type !== "message.new") return null;
|
|
2380
|
-
const payload = frame.payload;
|
|
2381
|
-
const senderRaw = payload.sender ?? payload.from ?? "";
|
|
2382
|
-
const sender = typeof senderRaw === "string" ? senderRaw.replace(/^@/, "").toLowerCase() : "";
|
|
2383
|
-
return {
|
|
2384
|
-
kind: "message",
|
|
2385
|
-
sender,
|
|
2386
|
-
messageId: str(payload.id) ?? "<no-id>",
|
|
2387
|
-
conversationId: str(payload.conversation_id) ?? "<no-conv>"
|
|
2388
|
-
};
|
|
2389
|
-
}
|
|
2390
|
-
function readGroupInviteKnock(frame) {
|
|
2391
|
-
if (frame.type !== "group.invite.received") return null;
|
|
2392
|
-
return groupInviteFromRecord(frame.payload);
|
|
2393
|
-
}
|
|
2394
|
-
function groupInviteFromRecord(record) {
|
|
2395
|
-
if (!record || typeof record !== "object" || Array.isArray(record)) return null;
|
|
2396
|
-
const row = record;
|
|
2397
|
-
const inviteId = str(row.id);
|
|
2398
|
-
const groupId = str(row.group_id);
|
|
2399
|
-
if (!inviteId || !groupId) return null;
|
|
2400
|
-
return {
|
|
2401
|
-
kind: "group-invite",
|
|
2402
|
-
inviteId,
|
|
2403
|
-
groupId,
|
|
2404
|
-
groupName: str(row.group_name) ?? "",
|
|
2405
|
-
inviterHandle: (str(row.inviter_handle) ?? "").replace(/^@/, "")
|
|
2406
|
-
};
|
|
2407
|
-
}
|
|
2408
|
-
function str(value) {
|
|
2409
|
-
return typeof value === "string" && value.length > 0 ? value : void 0;
|
|
2410
|
-
}
|
|
2411
|
-
|
|
2412
|
-
// src/runtime.ts
|
|
2413
|
-
var BACKLOG_WINDOW_MS = 5e3;
|
|
2414
|
-
var AgentchatChannelRuntime = class {
|
|
2415
|
-
config;
|
|
2416
|
-
handlers;
|
|
2417
|
-
logger;
|
|
2418
|
-
ws;
|
|
2419
|
-
selfHandle;
|
|
2420
|
-
now;
|
|
2421
|
-
started = false;
|
|
2422
|
-
authenticated = false;
|
|
2423
|
-
stopPromise = null;
|
|
2424
|
-
frames = 0;
|
|
2425
|
-
selfFiltered = 0;
|
|
2426
|
-
knocks = 0;
|
|
2427
|
-
invites = 0;
|
|
2428
|
-
authenticatedAt = null;
|
|
2429
|
-
constructor(opts) {
|
|
2430
|
-
this.config = opts.config;
|
|
2431
|
-
this.handlers = opts.handlers ?? {};
|
|
2432
|
-
this.now = opts.now ?? Date.now;
|
|
2433
|
-
this.logger = opts.logger ?? createLogger({
|
|
2434
|
-
level: this.config.observability.logLevel,
|
|
2435
|
-
redactKeys: this.config.observability.redactKeys
|
|
2436
|
-
});
|
|
2437
|
-
this.selfHandle = this.config.agentHandle?.replace(/^@/, "").toLowerCase();
|
|
2438
|
-
this.ws = new AgentchatWsClient({
|
|
2439
|
-
config: this.config,
|
|
2440
|
-
logger: this.logger,
|
|
2441
|
-
metrics: opts.metrics ?? createNoopMetrics(),
|
|
2442
|
-
webSocketCtor: opts.webSocketCtor,
|
|
2443
|
-
now: opts.now,
|
|
2444
|
-
random: opts.random
|
|
2445
|
-
});
|
|
2446
|
-
this.bindWsEvents();
|
|
2447
|
-
}
|
|
2448
|
-
/** Open the transport. Idempotent — subsequent calls are no-ops. */
|
|
2449
|
-
start() {
|
|
2450
|
-
if (this.started) return;
|
|
2451
|
-
this.started = true;
|
|
2452
|
-
this.ws.start();
|
|
2453
|
-
}
|
|
2454
|
-
/** Graceful shutdown: close the socket (nothing is in flight — the runtime sends nothing). */
|
|
2455
|
-
stop(deadlineMs) {
|
|
2456
|
-
if (this.stopPromise) return this.stopPromise;
|
|
2457
|
-
const deadline = deadlineMs ?? this.now() + 5e3;
|
|
2458
|
-
this.stopPromise = new Promise((resolve) => {
|
|
2459
|
-
const off = this.ws.on("closed", () => {
|
|
2460
|
-
off();
|
|
2461
|
-
resolve();
|
|
2462
|
-
});
|
|
2463
|
-
this.ws.stop(deadline);
|
|
2464
|
-
this.ws.drainCompleted();
|
|
2465
|
-
});
|
|
2466
|
-
return this.stopPromise;
|
|
2467
|
-
}
|
|
2468
|
-
/** Operator rotated the API key — leave AUTH_FAIL so the next `start()` can retry. */
|
|
2469
|
-
reconfigured() {
|
|
2470
|
-
this.ws.reconfigured();
|
|
2471
|
-
}
|
|
2472
|
-
getHealth() {
|
|
2473
|
-
return {
|
|
2474
|
-
state: this.ws.getState(),
|
|
2475
|
-
authenticated: this.authenticated,
|
|
2476
|
-
ackNegotiated: this.ws.ackNegotiated,
|
|
2477
|
-
counters: { frames: this.frames, selfFiltered: this.selfFiltered, knocks: this.knocks, invites: this.invites }
|
|
2478
|
-
};
|
|
2479
|
-
}
|
|
2480
|
-
// ─── Internals ─────────────────────────────────────────────────────
|
|
2481
|
-
bindWsEvents() {
|
|
2482
|
-
this.ws.on("stateChanged", (next, prev) => {
|
|
2483
|
-
if (next.kind !== "READY" && next.kind !== "DEGRADED") this.authenticated = false;
|
|
2484
|
-
this.guard("onStateChanged", () => this.handlers.onStateChanged?.(next, prev));
|
|
2485
|
-
});
|
|
2486
|
-
this.ws.on("authenticated", (at) => {
|
|
2487
|
-
this.authenticated = true;
|
|
2488
|
-
this.authenticatedAt = at;
|
|
2489
|
-
if (!this.ws.ackNegotiated) {
|
|
2490
|
-
this.logger.warn({}, "server did not negotiate the ack capability \u2014 envelopes will be marked delivered on push, before any verdict");
|
|
2491
|
-
}
|
|
2492
|
-
this.guard("onAuthenticated", () => this.handlers.onAuthenticated?.(at));
|
|
2493
|
-
this.knock("connect");
|
|
2494
|
-
});
|
|
2495
|
-
this.ws.on("inboundFrame", (frame) => this.dispatchFrame(frame));
|
|
2496
|
-
this.ws.on("error", (error) => {
|
|
2497
|
-
this.guard("onError", () => this.handlers.onError?.(error));
|
|
2498
|
-
});
|
|
2287
|
+
this.metrics.setConnectionState(next);
|
|
2288
|
+
this.logger.debug({ from: prev, to: next }, "socket state");
|
|
2289
|
+
this.guard("onStateChanged", () => this.handlers.onStateChanged?.(next, prev));
|
|
2499
2290
|
}
|
|
2500
|
-
|
|
2501
|
-
this.frames += 1;
|
|
2502
|
-
if (frame.type === "message.new") {
|
|
2503
|
-
const knock = readMessageKnock(frame);
|
|
2504
|
-
if (!knock) return;
|
|
2505
|
-
if (this.selfHandle && knock.sender === this.selfHandle) {
|
|
2506
|
-
this.selfFiltered += 1;
|
|
2507
|
-
this.logger.debug({ conversationId: knock.conversationId, messageId: knock.messageId }, "own echo \u2014 not a knock");
|
|
2508
|
-
return;
|
|
2509
|
-
}
|
|
2510
|
-
const backlog = this.authenticatedAt !== null && this.now() - this.authenticatedAt < BACKLOG_WINDOW_MS;
|
|
2511
|
-
this.logger[backlog ? "debug" : "info"](
|
|
2512
|
-
{ conversationId: knock.conversationId, messageId: knock.messageId, from: knock.sender || "?", ...backlog ? { backlog: true } : {} },
|
|
2513
|
-
"knock \u2014 message.new"
|
|
2514
|
-
);
|
|
2515
|
-
this.knock("message");
|
|
2516
|
-
return;
|
|
2517
|
-
}
|
|
2518
|
-
if (frame.type === "group.invite.received") {
|
|
2519
|
-
const invite = readGroupInviteKnock(frame);
|
|
2520
|
-
if (!invite) {
|
|
2521
|
-
this.logger.warn({ keys: Object.keys(frame.payload).sort() }, "group.invite.received without ids \u2014 dropped");
|
|
2522
|
-
return;
|
|
2523
|
-
}
|
|
2524
|
-
this.invites += 1;
|
|
2525
|
-
this.guard("onGroupInvite", () => this.handlers.onGroupInvite?.(invite));
|
|
2526
|
-
return;
|
|
2527
|
-
}
|
|
2528
|
-
this.logger.debug({ type: frame.type }, "frame \u2014 not a knock");
|
|
2529
|
-
}
|
|
2530
|
-
knock(source) {
|
|
2531
|
-
this.knocks += 1;
|
|
2532
|
-
this.guard("onKnock", () => this.handlers.onKnock?.(source));
|
|
2533
|
-
}
|
|
2534
|
-
/** A failing handler never takes the socket down; the next frame knocks again and the tray keeps the cards. */
|
|
2291
|
+
/** A failing handler never takes the socket down; the next frame wakes again and the tray keeps the cards. */
|
|
2535
2292
|
guard(name, fn) {
|
|
2536
2293
|
try {
|
|
2537
2294
|
fn();
|
|
2538
2295
|
} catch (err) {
|
|
2539
|
-
this.logger.error({ err:
|
|
2296
|
+
this.logger.error({ err: describe3(err), handler: name }, "handler threw \u2014 continuing");
|
|
2540
2297
|
}
|
|
2541
2298
|
}
|
|
2542
2299
|
};
|
|
2300
|
+
function classifyRealtimeError(error) {
|
|
2301
|
+
const message = error.message;
|
|
2302
|
+
if (/handler failed/i.test(message)) return "handler";
|
|
2303
|
+
if (/failed validation|not an object|expected a bare array/i.test(message)) return "protocol";
|
|
2304
|
+
if (error.name === "ConnectionError" || /websocket|hello|handshake|liveness|reconnecting|sync drain|sync ack/i.test(message)) return "transport";
|
|
2305
|
+
return "other";
|
|
2306
|
+
}
|
|
2307
|
+
function describe3(err) {
|
|
2308
|
+
return err instanceof Error ? err.message : String(err);
|
|
2309
|
+
}
|
|
2543
2310
|
|
|
2544
2311
|
// src/binding/runtime-registry.ts
|
|
2545
2312
|
var registry = /* @__PURE__ */ new Map();
|
|
@@ -2558,62 +2325,73 @@ function withAccountLock(accountId, op) {
|
|
|
2558
2325
|
);
|
|
2559
2326
|
return next;
|
|
2560
2327
|
}
|
|
2561
|
-
function
|
|
2328
|
+
function registerIntegration(params) {
|
|
2562
2329
|
return withAccountLock(params.accountId, async () => {
|
|
2563
2330
|
const existing = registry.get(params.accountId);
|
|
2564
2331
|
if (existing) {
|
|
2565
|
-
await stopEntry(existing
|
|
2332
|
+
await stopEntry(existing);
|
|
2566
2333
|
registry.delete(params.accountId);
|
|
2567
2334
|
}
|
|
2568
|
-
let runtimeRef = null;
|
|
2569
2335
|
let built = null;
|
|
2570
2336
|
const handlers = {
|
|
2571
|
-
|
|
2337
|
+
onWake: (source, detail) => built?.handlers.onWake?.(source, detail),
|
|
2572
2338
|
onGroupInvite: (invite) => built?.handlers.onGroupInvite?.(invite),
|
|
2573
|
-
|
|
2574
|
-
|
|
2575
|
-
|
|
2339
|
+
onConnected: (at) => built?.handlers.onConnected?.(at),
|
|
2340
|
+
onDisconnected: (info) => built?.handlers.onDisconnected?.(info),
|
|
2341
|
+
onBlocked: (info) => built?.handlers.onBlocked?.(info),
|
|
2342
|
+
onError: (error) => built?.handlers.onError?.(error),
|
|
2343
|
+
onStateChanged: (next, prev) => built?.handlers.onStateChanged?.(next, prev)
|
|
2344
|
+
};
|
|
2345
|
+
const create = params.createSocket ?? ((options) => new IntegrationSocket(options));
|
|
2346
|
+
const socket = create({ config: params.config, logger: params.logger, handlers, ...params.socketOptions ?? {} });
|
|
2347
|
+
built = params.build(socket);
|
|
2348
|
+
const entry = {
|
|
2349
|
+
socket,
|
|
2350
|
+
invoker: built.invoker,
|
|
2351
|
+
texts: built.texts ?? null,
|
|
2352
|
+
metrics: params.socketOptions?.metrics ?? null,
|
|
2353
|
+
config: params.config,
|
|
2354
|
+
logger: params.logger
|
|
2576
2355
|
};
|
|
2577
|
-
const create = params.createRuntime ?? ((p) => new AgentchatChannelRuntime(p));
|
|
2578
|
-
runtimeRef = create({ config: params.config, logger: params.logger, handlers });
|
|
2579
|
-
built = params.build(runtimeRef);
|
|
2580
|
-
const entry = { runtime: runtimeRef, invoker: built.invoker, config: params.config, logger: params.logger };
|
|
2581
2356
|
registry.set(params.accountId, entry);
|
|
2582
2357
|
try {
|
|
2583
|
-
|
|
2358
|
+
await socket.start();
|
|
2584
2359
|
} catch (err) {
|
|
2585
2360
|
registry.delete(params.accountId);
|
|
2586
2361
|
built.invoker?.stop();
|
|
2362
|
+
built.texts?.stop();
|
|
2587
2363
|
throw err;
|
|
2588
2364
|
}
|
|
2589
2365
|
return entry;
|
|
2590
2366
|
});
|
|
2591
2367
|
}
|
|
2592
|
-
function
|
|
2368
|
+
function unregisterIntegration(accountId) {
|
|
2593
2369
|
return withAccountLock(accountId, async () => {
|
|
2594
2370
|
const entry = registry.get(accountId);
|
|
2595
2371
|
if (!entry) return;
|
|
2596
2372
|
registry.delete(accountId);
|
|
2597
|
-
await stopEntry(entry
|
|
2373
|
+
await stopEntry(entry);
|
|
2598
2374
|
});
|
|
2599
2375
|
}
|
|
2600
|
-
async function stopEntry(entry
|
|
2376
|
+
async function stopEntry(entry) {
|
|
2601
2377
|
entry.invoker?.stop();
|
|
2378
|
+
entry.texts?.stop();
|
|
2602
2379
|
try {
|
|
2603
|
-
await entry.
|
|
2380
|
+
await entry.socket.stop();
|
|
2604
2381
|
} catch (err) {
|
|
2605
|
-
entry.logger.error({ err: err instanceof Error ? err.message : String(err) }, "
|
|
2382
|
+
entry.logger.error({ err: err instanceof Error ? err.message : String(err) }, "socket.stop threw during unregister");
|
|
2606
2383
|
}
|
|
2607
2384
|
}
|
|
2608
|
-
function
|
|
2385
|
+
function getIntegration(accountId) {
|
|
2609
2386
|
return registry.get(accountId);
|
|
2610
2387
|
}
|
|
2611
2388
|
|
|
2612
|
-
// src/
|
|
2389
|
+
// src/integration/wake.ts
|
|
2613
2390
|
var DEFAULT_DEBOUNCE_MS = 2e3;
|
|
2614
2391
|
var DEFAULT_MAX_WINDOW_MS = 6e3;
|
|
2615
|
-
var
|
|
2392
|
+
var WakeCoalescer = class {
|
|
2616
2393
|
onFire;
|
|
2394
|
+
onDelayedWake;
|
|
2617
2395
|
debounceMs;
|
|
2618
2396
|
maxWindowMs;
|
|
2619
2397
|
now;
|
|
@@ -2624,7 +2402,7 @@ var KnockCoalescer = class {
|
|
|
2624
2402
|
delayed = null;
|
|
2625
2403
|
delayedDeadline = null;
|
|
2626
2404
|
stopped = false;
|
|
2627
|
-
|
|
2405
|
+
wakes = 0;
|
|
2628
2406
|
absorbed = 0;
|
|
2629
2407
|
fires = 0;
|
|
2630
2408
|
constructor(options) {
|
|
@@ -2633,6 +2411,7 @@ var KnockCoalescer = class {
|
|
|
2633
2411
|
const maxWindow = options.maxWindowMs ?? DEFAULT_MAX_WINDOW_MS;
|
|
2634
2412
|
if (!(maxWindow >= debounce)) throw new RangeError("maxWindowMs must be >= debounceMs");
|
|
2635
2413
|
this.onFire = options.onFire;
|
|
2414
|
+
this.onDelayedWake = options.onDelayedWake;
|
|
2636
2415
|
this.debounceMs = debounce;
|
|
2637
2416
|
this.maxWindowMs = maxWindow;
|
|
2638
2417
|
this.now = options.now ?? Date.now;
|
|
@@ -2643,17 +2422,17 @@ var KnockCoalescer = class {
|
|
|
2643
2422
|
get armed() {
|
|
2644
2423
|
return this.timer !== null;
|
|
2645
2424
|
}
|
|
2646
|
-
/** True while a retry
|
|
2425
|
+
/** True while a retry wake is scheduled and has not fired. */
|
|
2647
2426
|
get delayedPending() {
|
|
2648
2427
|
return this.delayed !== null;
|
|
2649
2428
|
}
|
|
2650
2429
|
/**
|
|
2651
|
-
* A
|
|
2430
|
+
* A wake. The first one of a burst arms the window; every later one is
|
|
2652
2431
|
* absorbed and restarts it (trailing edge), never past the burst's cap.
|
|
2653
2432
|
*/
|
|
2654
|
-
|
|
2433
|
+
wake() {
|
|
2655
2434
|
if (this.stopped) return;
|
|
2656
|
-
this.
|
|
2435
|
+
this.wakes += 1;
|
|
2657
2436
|
const now = this.now();
|
|
2658
2437
|
if (this.timer === null) {
|
|
2659
2438
|
this.burstStartedAt = now;
|
|
@@ -2666,8 +2445,8 @@ var KnockCoalescer = class {
|
|
|
2666
2445
|
this._clearTimeout(this.timer);
|
|
2667
2446
|
this.timer = this._setTimeout(() => this.fire(), delay);
|
|
2668
2447
|
}
|
|
2669
|
-
/** A delayed
|
|
2670
|
-
|
|
2448
|
+
/** A delayed wake (retry ladder). The sooner pending deadline is kept. */
|
|
2449
|
+
wakeAfter(delayMs) {
|
|
2671
2450
|
if (this.stopped) return;
|
|
2672
2451
|
const delay = Math.max(0, delayMs);
|
|
2673
2452
|
const deadline = this.now() + delay;
|
|
@@ -2681,10 +2460,15 @@ var KnockCoalescer = class {
|
|
|
2681
2460
|
this.delayed = this._setTimeout(() => {
|
|
2682
2461
|
this.delayed = null;
|
|
2683
2462
|
this.delayedDeadline = null;
|
|
2684
|
-
this.
|
|
2463
|
+
if (this.stopped) return;
|
|
2464
|
+
try {
|
|
2465
|
+
this.onDelayedWake?.();
|
|
2466
|
+
} catch {
|
|
2467
|
+
}
|
|
2468
|
+
this.wake();
|
|
2685
2469
|
}, delay);
|
|
2686
2470
|
}
|
|
2687
|
-
/** Cancel everything; later
|
|
2471
|
+
/** Cancel everything; later wakes are ignored. */
|
|
2688
2472
|
stop() {
|
|
2689
2473
|
this.stopped = true;
|
|
2690
2474
|
if (this.timer !== null) {
|
|
@@ -2710,453 +2494,93 @@ var KnockCoalescer = class {
|
|
|
2710
2494
|
}
|
|
2711
2495
|
};
|
|
2712
2496
|
|
|
2713
|
-
// src/
|
|
2714
|
-
var DEFAULT_TIMEOUT_MS2 = 15e3;
|
|
2715
|
-
var INBOX_MAX_LIMIT = 50;
|
|
2716
|
-
var INBOX_WAIT_MAX_MS = 5e4;
|
|
2717
|
-
var INBOX_PATH = "/v1/inbox";
|
|
2718
|
-
var MainLineError = class extends Error {
|
|
2719
|
-
status;
|
|
2720
|
-
code;
|
|
2721
|
-
constructor(message, options = {}) {
|
|
2722
|
-
super(message, { cause: options.cause });
|
|
2723
|
-
this.name = "MainLineError";
|
|
2724
|
-
this.status = options.status;
|
|
2725
|
-
this.code = options.code;
|
|
2726
|
-
}
|
|
2727
|
-
};
|
|
2728
|
-
var MainLineClient = class {
|
|
2729
|
-
apiKey;
|
|
2730
|
-
apiBase;
|
|
2731
|
-
timeoutMs;
|
|
2732
|
-
fetchImpl;
|
|
2733
|
-
constructor(options) {
|
|
2734
|
-
this.apiKey = options.apiKey;
|
|
2735
|
-
this.apiBase = options.apiBase.replace(/\/+$/, "");
|
|
2736
|
-
this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS2;
|
|
2737
|
-
this.fetchImpl = options.fetch ?? fetch;
|
|
2738
|
-
}
|
|
2739
|
-
/**
|
|
2740
|
-
* `GET /v1/inbox` — the briefing cards plus the gate question, returned as
|
|
2741
|
-
* the server sent them (`you`, `question`, `categories`, `conversations`,
|
|
2742
|
-
* `deferred`, `truncated`, and any field a newer server adds). Marks
|
|
2743
|
-
* nothing delivered.
|
|
2744
|
-
*/
|
|
2745
|
-
async inbox(params = {}) {
|
|
2746
|
-
const waitMs = params.waitMs ?? 0;
|
|
2747
|
-
const limit = params.limit ?? INBOX_MAX_LIMIT;
|
|
2748
|
-
if (!Number.isInteger(waitMs) || waitMs < 0 || waitMs > INBOX_WAIT_MAX_MS) {
|
|
2749
|
-
throw new RangeError(`waitMs must be an integer within 0..${INBOX_WAIT_MAX_MS}`);
|
|
2750
|
-
}
|
|
2751
|
-
if (!Number.isInteger(limit) || limit < 1 || limit > INBOX_MAX_LIMIT) {
|
|
2752
|
-
throw new RangeError(`limit must be an integer within 1..${INBOX_MAX_LIMIT}`);
|
|
2753
|
-
}
|
|
2754
|
-
const url = `${this.apiBase}${INBOX_PATH}?wait_ms=${waitMs}&limit=${limit}`;
|
|
2755
|
-
const data = await this.request("GET", url, void 0, this.timeoutMs + waitMs);
|
|
2756
|
-
if (!data || typeof data !== "object" || Array.isArray(data)) {
|
|
2757
|
-
throw new MainLineError(`GET ${INBOX_PATH}: expected a JSON object`);
|
|
2758
|
-
}
|
|
2759
|
-
return data;
|
|
2760
|
-
}
|
|
2761
|
-
/**
|
|
2762
|
-
* `POST /v1/conversations/{id}/decisions` — record one verdict. The server
|
|
2763
|
-
* validates `decision`, `category` and `defer_seconds` against its own
|
|
2764
|
-
* taxonomy; this client passes them through and raises `MainLineError`
|
|
2765
|
-
* (`status` 400) when the server rejects a value, so the caller can retry
|
|
2766
|
-
* with less.
|
|
2767
|
-
*/
|
|
2768
|
-
async recordDecision(conversationId, input) {
|
|
2769
|
-
if (!conversationId) throw new RangeError("conversationId is required");
|
|
2770
|
-
const body = { decision: input.decision };
|
|
2771
|
-
if (input.category) body.category = input.category;
|
|
2772
|
-
if (input.throughMessageId) body.through_message_id = input.throughMessageId;
|
|
2773
|
-
if (input.deferSeconds !== void 0) body.defer_seconds = input.deferSeconds;
|
|
2774
|
-
const path2 = `/v1/conversations/${encodeURIComponent(conversationId)}/decisions`;
|
|
2775
|
-
const data = await this.request("POST", `${this.apiBase}${path2}`, body, this.timeoutMs);
|
|
2776
|
-
return data && typeof data === "object" && !Array.isArray(data) ? data : {};
|
|
2777
|
-
}
|
|
2778
|
-
async request(method, url, body, timeoutMs) {
|
|
2779
|
-
const controller = new AbortController();
|
|
2780
|
-
const timer = setTimeout(() => controller.abort(), timeoutMs);
|
|
2781
|
-
const what = `${method} ${new URL(url).pathname}`;
|
|
2782
|
-
let res;
|
|
2783
|
-
try {
|
|
2784
|
-
res = await this.fetchImpl(url, {
|
|
2785
|
-
method,
|
|
2786
|
-
headers: {
|
|
2787
|
-
authorization: `Bearer ${this.apiKey}`,
|
|
2788
|
-
accept: "application/json",
|
|
2789
|
-
...body !== void 0 ? { "content-type": "application/json" } : {},
|
|
2790
|
-
...AGENTCHAT_CLIENT_HEADERS
|
|
2791
|
-
},
|
|
2792
|
-
...body !== void 0 ? { body: JSON.stringify(body) } : {},
|
|
2793
|
-
signal: controller.signal
|
|
2794
|
-
});
|
|
2795
|
-
} catch (err) {
|
|
2796
|
-
throw new MainLineError(`${what}: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
|
|
2797
|
-
} finally {
|
|
2798
|
-
clearTimeout(timer);
|
|
2799
|
-
}
|
|
2800
|
-
const text = await res.text().catch(() => "");
|
|
2801
|
-
let parsed = void 0;
|
|
2802
|
-
if (text.length > 0) {
|
|
2803
|
-
try {
|
|
2804
|
-
parsed = JSON.parse(text);
|
|
2805
|
-
} catch {
|
|
2806
|
-
if (res.ok) throw new MainLineError(`${what}: invalid JSON in a ${res.status} answer`, { status: res.status });
|
|
2807
|
-
}
|
|
2808
|
-
}
|
|
2809
|
-
if (res.ok) return parsed ?? {};
|
|
2810
|
-
const fields = parsed && typeof parsed === "object" ? parsed : {};
|
|
2811
|
-
const code = typeof fields.code === "string" ? fields.code : void 0;
|
|
2812
|
-
const message = typeof fields.message === "string" ? fields.message : void 0;
|
|
2813
|
-
throw new MainLineError(
|
|
2814
|
-
`${what}: HTTP ${res.status}${code ? ` ${code}` : ""}${message ? ` \u2014 ${message}` : ""}`,
|
|
2815
|
-
{ status: res.status, code }
|
|
2816
|
-
);
|
|
2817
|
-
}
|
|
2818
|
-
};
|
|
2819
|
-
|
|
2820
|
-
// src/doorbell/gate.ts
|
|
2821
|
-
var DEFAULT_GATE_MAX_TOKENS = 2048;
|
|
2822
|
-
var REPLY = "reply";
|
|
2823
|
-
var DISMISS = "dismiss";
|
|
2824
|
-
var DEFER = "defer";
|
|
2825
|
-
var REPLY_TOKENS = /* @__PURE__ */ new Set(["reply", "respond", "answer", "yes", "true"]);
|
|
2826
|
-
var DISMISS_TOKENS = /* @__PURE__ */ new Set([
|
|
2827
|
-
"dismiss",
|
|
2828
|
-
"dismissed",
|
|
2829
|
-
"no_reply",
|
|
2830
|
-
"no-reply",
|
|
2831
|
-
"noreply",
|
|
2832
|
-
"silent",
|
|
2833
|
-
"silence",
|
|
2834
|
-
"skip",
|
|
2835
|
-
"ignore",
|
|
2836
|
-
"no",
|
|
2837
|
-
"false"
|
|
2838
|
-
]);
|
|
2839
|
-
var DEFER_TOKENS = /* @__PURE__ */ new Set(["defer", "deferred", "later", "wait", "postpone"]);
|
|
2840
|
-
var FENCE_RE = /```(?:json)?\s*([\s\S]+?)```/i;
|
|
2841
|
-
function startTurn(result) {
|
|
2842
|
-
return result.replyConversations.length > 0 || result.source === "fail_open";
|
|
2843
|
-
}
|
|
2844
|
-
function countVerdicts(result) {
|
|
2845
|
-
const counts = { reply: 0, dismiss: 0, defer: 0 };
|
|
2846
|
-
for (const verdict of result.verdicts) counts[verdict.decision] += 1;
|
|
2847
|
-
return counts;
|
|
2848
|
-
}
|
|
2849
|
-
function cardsOf(tray) {
|
|
2850
|
-
const raw = tray.conversations;
|
|
2851
|
-
if (!Array.isArray(raw)) return [];
|
|
2852
|
-
return raw.filter((card) => Boolean(card) && typeof card === "object" && !Array.isArray(card));
|
|
2853
|
-
}
|
|
2854
|
-
function cardIds(cards) {
|
|
2855
|
-
const out = [];
|
|
2856
|
-
for (const card of cards) {
|
|
2857
|
-
const id = card.conversation_id;
|
|
2858
|
-
if (typeof id === "string" && id.length > 0) out.push(id);
|
|
2859
|
-
}
|
|
2860
|
-
return out;
|
|
2861
|
-
}
|
|
2862
|
-
function categoriesOf(tray) {
|
|
2863
|
-
const raw = tray.categories;
|
|
2864
|
-
if (!Array.isArray(raw)) return [];
|
|
2865
|
-
return raw.filter((item) => typeof item === "string" && item.length > 0);
|
|
2866
|
-
}
|
|
2867
|
-
function buildGateMessages(tray) {
|
|
2868
|
-
const question = tray.question;
|
|
2869
|
-
if (typeof question !== "string" || question.trim().length === 0) {
|
|
2870
|
-
throw new Error("tray carries no gate question");
|
|
2871
|
-
}
|
|
2872
|
-
const cards = cardsOf(tray);
|
|
2873
|
-
const categories = categoriesOf(tray);
|
|
2874
|
-
let shape = '{"decisions": [{"conversation_id": "<conversation_id from a card>", "decision": "reply" | "dismiss" | "defer"';
|
|
2875
|
-
if (categories.length > 0) {
|
|
2876
|
-
shape += `, "category": "<one of: ${categories.join(", ")}>"`;
|
|
2877
|
-
}
|
|
2878
|
-
shape += ', "defer_seconds": <seconds until you look again, only with defer>}]}';
|
|
2879
|
-
const wrapper = "Answer with ONLY a JSON object, no prose and no code fences, in this shape: " + shape + " \u2014 one entry per card, every card decided.";
|
|
2880
|
-
const payload = {};
|
|
2881
|
-
if (typeof tray.you === "string" && tray.you.length > 0) payload.you = tray.you;
|
|
2882
|
-
payload.conversations = cards;
|
|
2883
|
-
return {
|
|
2884
|
-
systemPrompt: `${question.trim()}
|
|
2885
|
-
|
|
2886
|
-
${wrapper}`,
|
|
2887
|
-
userContent: `Your tray, as the server built it:
|
|
2888
|
-
${JSON.stringify(payload)}`
|
|
2889
|
-
};
|
|
2890
|
-
}
|
|
2891
|
-
function parseVerdicts(text, params) {
|
|
2892
|
-
const raw = extractJson(text);
|
|
2893
|
-
if (raw === null) return null;
|
|
2894
|
-
let obj;
|
|
2895
|
-
try {
|
|
2896
|
-
obj = JSON.parse(raw);
|
|
2897
|
-
} catch {
|
|
2898
|
-
return null;
|
|
2899
|
-
}
|
|
2900
|
-
let items;
|
|
2901
|
-
if (obj && typeof obj === "object" && !Array.isArray(obj)) {
|
|
2902
|
-
const record = obj;
|
|
2903
|
-
items = record.decisions ?? record.verdicts;
|
|
2904
|
-
if (items === void 0 && "conversation_id" in record) items = [record];
|
|
2905
|
-
} else {
|
|
2906
|
-
items = obj;
|
|
2907
|
-
}
|
|
2908
|
-
if (!Array.isArray(items)) return null;
|
|
2909
|
-
const known = new Set(params.knownIds);
|
|
2910
|
-
const allowed = new Set((params.categories ?? []).map((c) => c.toLowerCase()));
|
|
2911
|
-
const seen = /* @__PURE__ */ new Set();
|
|
2912
|
-
const out = [];
|
|
2913
|
-
for (const item of items) {
|
|
2914
|
-
if (!item || typeof item !== "object" || Array.isArray(item)) continue;
|
|
2915
|
-
const entry = item;
|
|
2916
|
-
const id = entry.conversation_id;
|
|
2917
|
-
if (typeof id !== "string" || !known.has(id) || seen.has(id)) continue;
|
|
2918
|
-
const decision = normalizeDecision(entry.decision);
|
|
2919
|
-
if (decision === null) continue;
|
|
2920
|
-
seen.add(id);
|
|
2921
|
-
const category = normalizeCategory(entry.category, allowed);
|
|
2922
|
-
const deferSeconds = decision === DEFER ? normalizeDeferSeconds(entry.defer_seconds) : void 0;
|
|
2923
|
-
out.push({
|
|
2924
|
-
conversationId: id,
|
|
2925
|
-
decision,
|
|
2926
|
-
...category !== void 0 ? { category } : {},
|
|
2927
|
-
...deferSeconds !== void 0 ? { deferSeconds } : {}
|
|
2928
|
-
});
|
|
2929
|
-
}
|
|
2930
|
-
return out;
|
|
2931
|
-
}
|
|
2932
|
-
function extractJson(text) {
|
|
2933
|
-
if (!text || text.trim().length === 0) return null;
|
|
2934
|
-
let s = text.trim();
|
|
2935
|
-
const fence = FENCE_RE.exec(s);
|
|
2936
|
-
if (fence?.[1]) s = fence[1].trim();
|
|
2937
|
-
const starts = [s.indexOf("{"), s.indexOf("[")].filter((i) => i !== -1);
|
|
2938
|
-
if (starts.length === 0) return null;
|
|
2939
|
-
const start = Math.min(...starts);
|
|
2940
|
-
const closer = s[start] === "{" ? "}" : "]";
|
|
2941
|
-
const end = s.lastIndexOf(closer);
|
|
2942
|
-
if (end <= start) return null;
|
|
2943
|
-
return s.slice(start, end + 1);
|
|
2944
|
-
}
|
|
2945
|
-
function normalizeDecision(value) {
|
|
2946
|
-
if (typeof value !== "string") return null;
|
|
2947
|
-
const token = value.trim().toLowerCase().replace(/\s+/g, "_");
|
|
2948
|
-
if (REPLY_TOKENS.has(token)) return REPLY;
|
|
2949
|
-
if (DISMISS_TOKENS.has(token)) return DISMISS;
|
|
2950
|
-
if (DEFER_TOKENS.has(token)) return DEFER;
|
|
2951
|
-
return null;
|
|
2952
|
-
}
|
|
2953
|
-
function normalizeCategory(value, allowed) {
|
|
2954
|
-
if (allowed.size === 0 || typeof value !== "string") return void 0;
|
|
2955
|
-
const token = value.trim().toLowerCase();
|
|
2956
|
-
return allowed.has(token) ? token : void 0;
|
|
2957
|
-
}
|
|
2958
|
-
function normalizeDeferSeconds(value) {
|
|
2959
|
-
if (typeof value !== "number" || !Number.isFinite(value)) return void 0;
|
|
2960
|
-
const seconds = Math.trunc(value);
|
|
2961
|
-
return seconds > 0 ? seconds : void 0;
|
|
2962
|
-
}
|
|
2963
|
-
async function runGate(params) {
|
|
2964
|
-
const cards = cardsOf(params.tray);
|
|
2965
|
-
const ids = cardIds(cards);
|
|
2966
|
-
const truncated = params.tray.truncated === true;
|
|
2967
|
-
const now = params.now ?? Date.now;
|
|
2968
|
-
const log = params.log ?? (() => void 0);
|
|
2969
|
-
if (ids.length === 0) return emptyResult("empty", truncated);
|
|
2970
|
-
const started = now();
|
|
2971
|
-
let text;
|
|
2972
|
-
try {
|
|
2973
|
-
const messages = buildGateMessages(params.tray);
|
|
2974
|
-
text = await params.caller({
|
|
2975
|
-
systemPrompt: messages.systemPrompt,
|
|
2976
|
-
userContent: messages.userContent,
|
|
2977
|
-
maxTokens: params.maxTokens ?? DEFAULT_GATE_MAX_TOKENS,
|
|
2978
|
-
timeoutMs: params.timeoutMs
|
|
2979
|
-
});
|
|
2980
|
-
} catch (err) {
|
|
2981
|
-
const reason = `decision call failed: ${err instanceof Error ? err.message : String(err)}`;
|
|
2982
|
-
log("warn", `gate: ${reason} (${ids.length} cards)`);
|
|
2983
|
-
return failedResult(ids, params.failOpen, reason, now() - started, truncated);
|
|
2984
|
-
}
|
|
2985
|
-
const latencyMs = now() - started;
|
|
2986
|
-
const verdicts = parseVerdicts(text, { knownIds: ids, categories: categoriesOf(params.tray) });
|
|
2987
|
-
if (!verdicts || verdicts.length === 0) {
|
|
2988
|
-
log("warn", `gate: unusable answer for ${ids.length} cards (latency ${latencyMs} ms)`);
|
|
2989
|
-
log("debug", `gate: raw model output: ${(text ?? "").slice(0, 200)}`);
|
|
2990
|
-
return failedResult(ids, params.failOpen, "no usable verdicts in the answer", latencyMs, truncated);
|
|
2991
|
-
}
|
|
2992
|
-
const byId = /* @__PURE__ */ new Map();
|
|
2993
|
-
for (const card of cards) {
|
|
2994
|
-
const id = card.conversation_id;
|
|
2995
|
-
if (typeof id === "string") byId.set(id, card);
|
|
2996
|
-
}
|
|
2997
|
-
const decided = new Set(verdicts.map((v) => v.conversationId));
|
|
2998
|
-
const undecided = ids.filter((id) => !decided.has(id));
|
|
2999
|
-
const reply = [];
|
|
3000
|
-
let posted = 0;
|
|
3001
|
-
let postFailures = 0;
|
|
3002
|
-
for (const verdict of verdicts) {
|
|
3003
|
-
if (verdict.decision === REPLY) {
|
|
3004
|
-
reply.push(verdict.conversationId);
|
|
3005
|
-
continue;
|
|
3006
|
-
}
|
|
3007
|
-
if (await postVerdict(params.mainLine, verdict, byId.get(verdict.conversationId), log)) posted += 1;
|
|
3008
|
-
else postFailures += 1;
|
|
3009
|
-
}
|
|
3010
|
-
if (undecided.length > 0) {
|
|
3011
|
-
log("warn", `gate: ${undecided.length} of ${ids.length} cards left undecided by the model: ${undecided.join(", ")}`);
|
|
3012
|
-
}
|
|
3013
|
-
return {
|
|
3014
|
-
source: "llm",
|
|
3015
|
-
cards: ids.length,
|
|
3016
|
-
verdicts,
|
|
3017
|
-
undecided,
|
|
3018
|
-
replyConversations: reply,
|
|
3019
|
-
posted,
|
|
3020
|
-
postFailures,
|
|
3021
|
-
truncated,
|
|
3022
|
-
latencyMs,
|
|
3023
|
-
failure: null
|
|
3024
|
-
};
|
|
3025
|
-
}
|
|
3026
|
-
function emptyResult(source, truncated, replyConversations = []) {
|
|
3027
|
-
return {
|
|
3028
|
-
source,
|
|
3029
|
-
cards: replyConversations.length,
|
|
3030
|
-
verdicts: [],
|
|
3031
|
-
undecided: [],
|
|
3032
|
-
replyConversations,
|
|
3033
|
-
posted: 0,
|
|
3034
|
-
postFailures: 0,
|
|
3035
|
-
truncated,
|
|
3036
|
-
latencyMs: 0,
|
|
3037
|
-
failure: null
|
|
3038
|
-
};
|
|
3039
|
-
}
|
|
3040
|
-
function failedResult(ids, failOpen, reason, latencyMs, truncated) {
|
|
3041
|
-
return {
|
|
3042
|
-
source: failOpen ? "fail_open" : "fail_closed",
|
|
3043
|
-
cards: ids.length,
|
|
3044
|
-
verdicts: [],
|
|
3045
|
-
undecided: ids,
|
|
3046
|
-
replyConversations: failOpen ? ids : [],
|
|
3047
|
-
posted: 0,
|
|
3048
|
-
postFailures: 0,
|
|
3049
|
-
truncated,
|
|
3050
|
-
latencyMs,
|
|
3051
|
-
failure: reason
|
|
3052
|
-
};
|
|
3053
|
-
}
|
|
3054
|
-
async function postVerdict(mainLine, verdict, card, log = () => void 0) {
|
|
3055
|
-
const through = previewMessageId(card);
|
|
3056
|
-
try {
|
|
3057
|
-
await mainLine.recordDecision(verdict.conversationId, {
|
|
3058
|
-
decision: verdict.decision,
|
|
3059
|
-
category: verdict.category,
|
|
3060
|
-
throughMessageId: through,
|
|
3061
|
-
deferSeconds: verdict.deferSeconds
|
|
3062
|
-
});
|
|
3063
|
-
return true;
|
|
3064
|
-
} catch (err) {
|
|
3065
|
-
const retryable = err instanceof MainLineError && err.status === 400 && (verdict.category !== void 0 || verdict.deferSeconds !== void 0);
|
|
3066
|
-
if (!retryable) {
|
|
3067
|
-
log("warn", `gate: verdict ${verdict.decision} for ${verdict.conversationId} not recorded: ${describe2(err)}`);
|
|
3068
|
-
return false;
|
|
3069
|
-
}
|
|
3070
|
-
log("warn", `gate: server rejected optional fields for ${verdict.conversationId} (${describe2(err)}) \u2014 retrying bare verdict`);
|
|
3071
|
-
}
|
|
3072
|
-
try {
|
|
3073
|
-
await mainLine.recordDecision(verdict.conversationId, {
|
|
3074
|
-
decision: verdict.decision,
|
|
3075
|
-
throughMessageId: through
|
|
3076
|
-
});
|
|
3077
|
-
return true;
|
|
3078
|
-
} catch (err) {
|
|
3079
|
-
log("warn", `gate: verdict ${verdict.decision} for ${verdict.conversationId} not recorded: ${describe2(err)}`);
|
|
3080
|
-
return false;
|
|
3081
|
-
}
|
|
3082
|
-
}
|
|
3083
|
-
function previewMessageId(card) {
|
|
3084
|
-
if (!card) return void 0;
|
|
3085
|
-
const preview = card.preview;
|
|
3086
|
-
if (!preview || typeof preview !== "object" || Array.isArray(preview)) return void 0;
|
|
3087
|
-
const id = preview.message_id;
|
|
3088
|
-
return typeof id === "string" && id.length > 0 ? id : void 0;
|
|
3089
|
-
}
|
|
3090
|
-
function describe2(err) {
|
|
3091
|
-
return err instanceof Error ? err.message : String(err);
|
|
3092
|
-
}
|
|
3093
|
-
|
|
3094
|
-
// src/doorbell/invoker.ts
|
|
3095
|
-
var DEFAULT_GATE_TIMEOUT_MS = 2e4;
|
|
2497
|
+
// src/integration/invoker.ts
|
|
3096
2498
|
var RETRY_LADDER_MS = [6e4, 3e5, 18e5];
|
|
3097
2499
|
var AgentInvoker = class {
|
|
3098
2500
|
accountId;
|
|
3099
2501
|
agentId;
|
|
3100
|
-
|
|
3101
|
-
|
|
3102
|
-
|
|
2502
|
+
client;
|
|
2503
|
+
callModel;
|
|
2504
|
+
startTurn;
|
|
2505
|
+
texts;
|
|
2506
|
+
invites;
|
|
3103
2507
|
logger;
|
|
2508
|
+
metrics;
|
|
2509
|
+
readiness;
|
|
3104
2510
|
gateEnabled;
|
|
3105
|
-
gateFailOpen;
|
|
3106
|
-
gateTimeoutMs;
|
|
3107
2511
|
ladder;
|
|
3108
2512
|
now;
|
|
3109
2513
|
coalescer;
|
|
3110
2514
|
cycleDue = false;
|
|
3111
2515
|
running = null;
|
|
3112
2516
|
stopped = false;
|
|
3113
|
-
|
|
3114
|
-
|
|
2517
|
+
pendingInvites = [];
|
|
2518
|
+
invitesDirty = false;
|
|
3115
2519
|
retryRung = 0;
|
|
2520
|
+
turnsInFlight = 0;
|
|
2521
|
+
/**
|
|
2522
|
+
* Conversations whose reply turn is running. Their verdict is recorded
|
|
2523
|
+
* only when the turn completes, so the card stays on the tray meanwhile
|
|
2524
|
+
* and every wake in between would re-gate it and queue a second turn.
|
|
2525
|
+
* Such cards are left out of the cycle; once the turn ends the tray is
|
|
2526
|
+
* read again if any were.
|
|
2527
|
+
*/
|
|
2528
|
+
replyTurnsInFlight = /* @__PURE__ */ new Set();
|
|
2529
|
+
skippedWhileInFlight = false;
|
|
2530
|
+
/** The reason the tools were last found unavailable; logged when it changes, not per wake. */
|
|
2531
|
+
unreadyReason = null;
|
|
3116
2532
|
cycles = 0;
|
|
3117
2533
|
turns = 0;
|
|
3118
2534
|
inviteTurns = 0;
|
|
3119
2535
|
constructor(options) {
|
|
3120
2536
|
this.accountId = options.accountId;
|
|
3121
2537
|
this.agentId = options.agentId;
|
|
3122
|
-
this.
|
|
3123
|
-
this.
|
|
3124
|
-
this.
|
|
3125
|
-
this.
|
|
2538
|
+
this.client = options.client;
|
|
2539
|
+
this.callModel = options.callModel;
|
|
2540
|
+
this.startTurn = options.startTurn;
|
|
2541
|
+
this.texts = options.texts;
|
|
2542
|
+
this.invites = options.invites;
|
|
2543
|
+
this.logger = options.logger.child({ component: "integration", accountId: options.accountId });
|
|
2544
|
+
this.metrics = options.metrics ?? createNoopMetrics();
|
|
2545
|
+
this.readiness = options.readiness ?? (() => ({ ready: true }));
|
|
3126
2546
|
this.gateEnabled = options.gateEnabled ?? true;
|
|
3127
|
-
this.gateFailOpen = options.gateFailOpen ?? false;
|
|
3128
|
-
this.gateTimeoutMs = options.gateTimeoutMs ?? DEFAULT_GATE_TIMEOUT_MS;
|
|
3129
2547
|
this.ladder = options.retryLadderMs ?? RETRY_LADDER_MS;
|
|
3130
2548
|
this.now = options.now ?? Date.now;
|
|
3131
|
-
this.coalescer = new
|
|
3132
|
-
onFire: () => this.
|
|
2549
|
+
this.coalescer = new WakeCoalescer({
|
|
2550
|
+
onFire: () => this.onWakeFired(),
|
|
2551
|
+
onDelayedWake: () => {
|
|
2552
|
+
this.logger.debug({ source: "retry" }, "wake");
|
|
2553
|
+
this.metrics.incWake({ source: "retry" });
|
|
2554
|
+
},
|
|
3133
2555
|
debounceMs: options.debounceMs ?? DEFAULT_DEBOUNCE_MS,
|
|
3134
2556
|
now: this.now,
|
|
3135
2557
|
...options.setTimeout ? { setTimeout: options.setTimeout } : {},
|
|
3136
2558
|
...options.clearTimeout ? { clearTimeout: options.clearTimeout } : {}
|
|
3137
2559
|
});
|
|
3138
2560
|
}
|
|
3139
|
-
// ───
|
|
3140
|
-
/** A
|
|
3141
|
-
|
|
2561
|
+
// ─── wakes ──────────────────────────────────────────────────────────
|
|
2562
|
+
/** A wake from the socket (a frame, a connect, a reminder) or any other source. Coalesced, then cycled. */
|
|
2563
|
+
wake(source) {
|
|
3142
2564
|
if (this.stopped) return;
|
|
3143
|
-
this.logger.debug({ source }, "
|
|
3144
|
-
this.coalescer.
|
|
2565
|
+
this.logger.debug({ source }, "wake");
|
|
2566
|
+
this.coalescer.wake();
|
|
3145
2567
|
}
|
|
3146
2568
|
/**
|
|
3147
|
-
* The second
|
|
3148
|
-
*
|
|
3149
|
-
*
|
|
2569
|
+
* The second wake kind. An invite already offered (this process or an
|
|
2570
|
+
* earlier one, per the ledger) or already pending is ignored, so an
|
|
2571
|
+
* invite seen live and again on a connect-time catch-up is decided once.
|
|
2572
|
+
* Returns true when newly queued.
|
|
3150
2573
|
*/
|
|
3151
2574
|
groupInvite(invite, source) {
|
|
3152
2575
|
if (this.stopped) return false;
|
|
3153
|
-
if (this.
|
|
3154
|
-
this.
|
|
2576
|
+
if (this.invites.isOffered(invite.inviteId)) return false;
|
|
2577
|
+
if (this.pendingInvites.some((pending) => pending.inviteId === invite.inviteId)) return false;
|
|
3155
2578
|
this.logger.info(
|
|
3156
2579
|
{ groupId: invite.groupId, groupName: invite.groupName, inviter: invite.inviterHandle, inviteId: invite.inviteId, source },
|
|
3157
2580
|
"group invite \u2014 queuing one invite turn"
|
|
3158
2581
|
);
|
|
3159
|
-
this.
|
|
2582
|
+
this.pendingInvites.push(invite);
|
|
2583
|
+
this.invitesDirty = true;
|
|
3160
2584
|
this.schedule();
|
|
3161
2585
|
return true;
|
|
3162
2586
|
}
|
|
@@ -3165,7 +2589,7 @@ var AgentInvoker = class {
|
|
|
3165
2589
|
this.stopped = true;
|
|
3166
2590
|
this.coalescer.stop();
|
|
3167
2591
|
}
|
|
3168
|
-
/** The promise of the
|
|
2592
|
+
/** The promise of the work currently running, for tests and for graceful stops. */
|
|
3169
2593
|
settled() {
|
|
3170
2594
|
return this.running ?? Promise.resolve();
|
|
3171
2595
|
}
|
|
@@ -3174,14 +2598,17 @@ var AgentInvoker = class {
|
|
|
3174
2598
|
cycles: this.cycles,
|
|
3175
2599
|
turns: this.turns,
|
|
3176
2600
|
inviteTurns: this.inviteTurns,
|
|
3177
|
-
|
|
2601
|
+
turnsInFlight: this.turnsInFlight,
|
|
2602
|
+
wakes: this.coalescer.wakes,
|
|
3178
2603
|
absorbed: this.coalescer.absorbed,
|
|
3179
|
-
retryRung: this.retryRung
|
|
2604
|
+
retryRung: this.retryRung,
|
|
2605
|
+
pendingInvites: this.pendingInvites.length
|
|
3180
2606
|
};
|
|
3181
2607
|
}
|
|
3182
2608
|
// ─── worker ─────────────────────────────────────────────────────────
|
|
3183
|
-
|
|
2609
|
+
onWakeFired() {
|
|
3184
2610
|
this.cycleDue = true;
|
|
2611
|
+
if (this.pendingInvites.length > 0) this.invitesDirty = true;
|
|
3185
2612
|
this.schedule();
|
|
3186
2613
|
}
|
|
3187
2614
|
/** Run the worker if idle. One cycle at a time; work that lands mid-cycle runs afterwards. */
|
|
@@ -3189,14 +2616,14 @@ var AgentInvoker = class {
|
|
|
3189
2616
|
if (this.running) return;
|
|
3190
2617
|
this.running = this.drain().finally(() => {
|
|
3191
2618
|
this.running = null;
|
|
3192
|
-
if (!this.stopped && (this.cycleDue || this.
|
|
2619
|
+
if (!this.stopped && (this.cycleDue || this.invitesDirty)) this.schedule();
|
|
3193
2620
|
});
|
|
3194
2621
|
}
|
|
3195
2622
|
async drain() {
|
|
3196
2623
|
while (!this.stopped) {
|
|
3197
|
-
|
|
3198
|
-
|
|
3199
|
-
await this.
|
|
2624
|
+
if (this.invitesDirty) {
|
|
2625
|
+
this.invitesDirty = false;
|
|
2626
|
+
await this.runInviteTurns();
|
|
3200
2627
|
continue;
|
|
3201
2628
|
}
|
|
3202
2629
|
if (this.cycleDue) {
|
|
@@ -3204,8 +2631,7 @@ var AgentInvoker = class {
|
|
|
3204
2631
|
try {
|
|
3205
2632
|
await this.runCycle();
|
|
3206
2633
|
} catch (err) {
|
|
3207
|
-
this.logger.error({ err:
|
|
3208
|
-
this.scheduleRetry("unhandled error");
|
|
2634
|
+
this.logger.error({ err: describe4(err), ...this.retry() }, "cycle failed with an unhandled error \u2014 re-waking later");
|
|
3209
2635
|
}
|
|
3210
2636
|
continue;
|
|
3211
2637
|
}
|
|
@@ -3213,147 +2639,293 @@ var AgentInvoker = class {
|
|
|
3213
2639
|
}
|
|
3214
2640
|
}
|
|
3215
2641
|
// ─── one cycle ──────────────────────────────────────────────────────
|
|
3216
|
-
/** Read the tray, gate it, start a turn
|
|
2642
|
+
/** Read the tray, gate it, start a turn per reply. Public so tests can drive one cycle. */
|
|
3217
2643
|
async runCycle() {
|
|
3218
2644
|
this.cycles += 1;
|
|
2645
|
+
const started = this.now();
|
|
3219
2646
|
let tray;
|
|
3220
2647
|
try {
|
|
3221
|
-
tray = await this.
|
|
2648
|
+
tray = await this.client.inbox.tray({ waitMs: 0 });
|
|
3222
2649
|
} catch (err) {
|
|
3223
|
-
this.logger.warn({ err:
|
|
3224
|
-
this.
|
|
3225
|
-
return null;
|
|
2650
|
+
this.logger.warn({ err: describe4(err), ...this.retry() }, "tray read failed \u2014 re-waking later");
|
|
2651
|
+
return this.result("tray_failed", 0, false, started, describe4(err));
|
|
3226
2652
|
}
|
|
3227
|
-
const
|
|
2653
|
+
const allCards = gate.cardsOf(tray);
|
|
3228
2654
|
const truncated = tray.truncated === true;
|
|
3229
|
-
if (
|
|
2655
|
+
if (allCards.length === 0) {
|
|
3230
2656
|
this.logger.info({ deferred: tray.deferred ?? 0 }, "tray empty \u2014 nothing to decide");
|
|
3231
2657
|
this.retryRung = 0;
|
|
3232
|
-
return
|
|
2658
|
+
return this.result("empty", 0, truncated, started);
|
|
2659
|
+
}
|
|
2660
|
+
const cards = allCards.filter((card) => !this.replyTurnsInFlight.has(card.conversation_id));
|
|
2661
|
+
const skippedInFlight = allCards.length - cards.length;
|
|
2662
|
+
if (skippedInFlight > 0) this.skippedWhileInFlight = true;
|
|
2663
|
+
if (cards.length === 0) {
|
|
2664
|
+
this.logger.info({ skippedInFlight }, "every card on the tray has a reply turn running \u2014 nothing new to decide");
|
|
2665
|
+
return { ...this.result("empty", 0, truncated, started), skippedInFlight };
|
|
2666
|
+
}
|
|
2667
|
+
const texts = await this.texts.ensure();
|
|
2668
|
+
if (!texts) {
|
|
2669
|
+
this.logger.warn({ cards: cards.length, ...this.retry() }, "served texts not available \u2014 not gating; the cards wait on the tray");
|
|
2670
|
+
return { ...this.result("texts_missing", cards.length, truncated, started, "texts missing"), skippedInFlight };
|
|
2671
|
+
}
|
|
2672
|
+
const readiness = this.readiness();
|
|
2673
|
+
if (!readiness.ready) {
|
|
2674
|
+
const changed = this.unreadyReason !== readiness.reason;
|
|
2675
|
+
this.unreadyReason = readiness.reason;
|
|
2676
|
+
this.logger[changed ? "warn" : "debug"]({ cards: cards.length, reason: readiness.reason, ...this.retry() }, "AgentChat tools not available to a turn \u2014 not gating; the cards wait on the tray");
|
|
2677
|
+
return { ...this.result("tools_unavailable", cards.length, truncated, started, readiness.reason), skippedInFlight };
|
|
2678
|
+
}
|
|
2679
|
+
if (this.unreadyReason !== null) {
|
|
2680
|
+
this.unreadyReason = null;
|
|
2681
|
+
this.logger.info({}, "AgentChat tools available to turns again");
|
|
3233
2682
|
}
|
|
3234
2683
|
let result;
|
|
3235
2684
|
if (!this.gateEnabled) {
|
|
3236
|
-
this.
|
|
3237
|
-
result = emptyResult("disabled", truncated, cardIds(cards));
|
|
2685
|
+
result = await this.runUngated(cards.length, texts, truncated, started);
|
|
3238
2686
|
} else {
|
|
3239
|
-
|
|
3240
|
-
|
|
3241
|
-
mainLine: this.mainLine,
|
|
3242
|
-
caller: this.gateCaller,
|
|
3243
|
-
failOpen: this.gateFailOpen,
|
|
3244
|
-
timeoutMs: this.gateTimeoutMs,
|
|
3245
|
-
now: this.now,
|
|
3246
|
-
log: (level, message) => this.logger[level]({}, message)
|
|
3247
|
-
});
|
|
3248
|
-
const counts = countVerdicts(result);
|
|
3249
|
-
this.logger.info(
|
|
3250
|
-
{
|
|
3251
|
-
cards: result.cards,
|
|
3252
|
-
reply: counts.reply,
|
|
3253
|
-
dismiss: counts.dismiss,
|
|
3254
|
-
defer: counts.defer,
|
|
3255
|
-
undecided: result.undecided.length,
|
|
3256
|
-
posted: result.posted,
|
|
3257
|
-
postFailures: result.postFailures,
|
|
3258
|
-
source: result.source,
|
|
3259
|
-
latencyMs: result.latencyMs,
|
|
3260
|
-
...result.failure ? { failure: result.failure } : {}
|
|
3261
|
-
},
|
|
3262
|
-
"gate"
|
|
3263
|
-
);
|
|
2687
|
+
const trayToGate = skippedInFlight > 0 ? { ...tray, conversations: cards } : tray;
|
|
2688
|
+
result = await this.runGated(trayToGate, cards.length, texts, truncated, started, skippedInFlight);
|
|
3264
2689
|
}
|
|
3265
|
-
if (
|
|
3266
|
-
|
|
3267
|
-
|
|
2690
|
+
if (skippedInFlight > 0) result = { ...result, skippedInFlight };
|
|
2691
|
+
if (truncated && result.outcome !== "fail_closed") {
|
|
2692
|
+
this.logger.info({}, "tray truncated \u2014 waking again for the rest");
|
|
2693
|
+
this.coalescer.wake();
|
|
3268
2694
|
}
|
|
3269
|
-
|
|
3270
|
-
|
|
3271
|
-
|
|
3272
|
-
|
|
3273
|
-
|
|
3274
|
-
|
|
3275
|
-
|
|
3276
|
-
|
|
2695
|
+
return result;
|
|
2696
|
+
}
|
|
2697
|
+
/** Gate off: the agent judges in-turn with the hosted tools. One turn, nothing recorded here. */
|
|
2698
|
+
async runUngated(cards, texts, truncated, started) {
|
|
2699
|
+
this.logger.info({ cards }, "gate off \u2014 starting one turn with the served wake instruction");
|
|
2700
|
+
const sessionKey = wakeSessionKey(this.agentId, this.now());
|
|
2701
|
+
this.logger.info({ sessionKey }, "turn start");
|
|
2702
|
+
const admission = await this.startTurn({ sessionKey, prompt: wakeTurnPrompt(texts), lane: integrationLane(this.accountId) });
|
|
2703
|
+
if (!admission.ran) {
|
|
2704
|
+
this.logger.warn({ sessionKey, error: admission.error, ...this.retry() }, "turn not started \u2014 re-waking later");
|
|
3277
2705
|
} else {
|
|
2706
|
+
this.admitted(sessionKey, admission, "turn complete (final text discarded; the send is a hosted-tool call)");
|
|
3278
2707
|
this.retryRung = 0;
|
|
3279
2708
|
}
|
|
3280
|
-
|
|
3281
|
-
this.
|
|
3282
|
-
|
|
2709
|
+
return {
|
|
2710
|
+
...this.result("gate_off", cards, truncated, started),
|
|
2711
|
+
turnsStarted: admission.ran ? 1 : 0,
|
|
2712
|
+
turnsRefused: admission.ran ? 0 : 1
|
|
2713
|
+
};
|
|
2714
|
+
}
|
|
2715
|
+
async runGated(tray, cards, texts, truncated, started, skippedInFlight = 0) {
|
|
2716
|
+
const decided = await gate.run({ tray, callModel: this.callModel, client: this.client, toolNamer: OPENCLAW_TOOL_NAMER });
|
|
2717
|
+
const latencyMs = this.now() - started;
|
|
2718
|
+
const counts = { reply: 0, dismiss: 0, defer: 0 };
|
|
2719
|
+
for (const verdict of decided.verdicts) counts[verdict.decision] += 1;
|
|
2720
|
+
if (decided.outcome === "fail_closed") {
|
|
2721
|
+
this.logger.warn({ cards, failure: decided.failure, latencyMs, ...this.retry() }, "gate failed closed \u2014 nothing recorded, no turn started");
|
|
2722
|
+
return { ...this.result("fail_closed", cards, truncated, started, decided.failure), undecided: cards, latencyMs };
|
|
3283
2723
|
}
|
|
3284
|
-
|
|
2724
|
+
if (decided.outcome === "empty") {
|
|
2725
|
+
this.retryRung = 0;
|
|
2726
|
+
return this.result("empty", cards, truncated, started);
|
|
2727
|
+
}
|
|
2728
|
+
let turnsStarted = 0;
|
|
2729
|
+
let turnsRefused = 0;
|
|
2730
|
+
const recordFailures = decided.recordFailures.length;
|
|
2731
|
+
const recorded = decided.recorded;
|
|
2732
|
+
for (const entry of decided.reply) {
|
|
2733
|
+
if (this.replyTurnsInFlight.has(entry.conversationId)) {
|
|
2734
|
+
this.skippedWhileInFlight = true;
|
|
2735
|
+
continue;
|
|
2736
|
+
}
|
|
2737
|
+
const sessionKey = wakeSessionKey(this.agentId, this.now());
|
|
2738
|
+
this.logger.info({ sessionKey, conversationId: entry.conversationId }, "turn start");
|
|
2739
|
+
const admission = await this.startTurn({ sessionKey, prompt: wakeTurnPrompt(texts, entry.conversationId), lane: integrationLane(this.accountId) });
|
|
2740
|
+
if (!admission.ran) {
|
|
2741
|
+
turnsRefused += 1;
|
|
2742
|
+
this.logger.warn({ sessionKey, conversationId: entry.conversationId, error: admission.error }, "turn not started \u2014 reply not recorded; the conversation stays unread");
|
|
2743
|
+
continue;
|
|
2744
|
+
}
|
|
2745
|
+
turnsStarted += 1;
|
|
2746
|
+
this.replyTurnsInFlight.add(entry.conversationId);
|
|
2747
|
+
this.admitted(sessionKey, admission, "turn complete (final text discarded; the send is a hosted-tool call)", entry);
|
|
2748
|
+
}
|
|
2749
|
+
const summary = {
|
|
2750
|
+
cards,
|
|
2751
|
+
reply: counts.reply,
|
|
2752
|
+
dismiss: counts.dismiss,
|
|
2753
|
+
defer: counts.defer,
|
|
2754
|
+
undecided: decided.undecided.length,
|
|
2755
|
+
recorded,
|
|
2756
|
+
recordFailures,
|
|
2757
|
+
turnsStarted,
|
|
2758
|
+
turnsRefused,
|
|
2759
|
+
skippedInFlight,
|
|
2760
|
+
latencyMs
|
|
2761
|
+
};
|
|
2762
|
+
if (turnsRefused > 0) {
|
|
2763
|
+
this.logger.warn({ ...summary, ...this.retry() }, "gate \u2014 some turns were refused; re-waking later");
|
|
2764
|
+
} else if (recordFailures > 0 || decided.undecided.length > 0) {
|
|
2765
|
+
this.logger.warn({ ...summary, ...this.retry() }, "gate \u2014 cards left on the tray; re-waking later");
|
|
2766
|
+
} else {
|
|
2767
|
+
this.retryRung = 0;
|
|
2768
|
+
this.logger.info(summary, "gate");
|
|
2769
|
+
}
|
|
2770
|
+
return { ...this.result("decided", cards, truncated, started), ...summary };
|
|
3285
2771
|
}
|
|
3286
|
-
|
|
2772
|
+
result(outcome, cards, truncated, started, failure = null) {
|
|
2773
|
+
return {
|
|
2774
|
+
outcome,
|
|
2775
|
+
cards,
|
|
2776
|
+
reply: 0,
|
|
2777
|
+
dismiss: 0,
|
|
2778
|
+
defer: 0,
|
|
2779
|
+
undecided: 0,
|
|
2780
|
+
recorded: 0,
|
|
2781
|
+
recordFailures: 0,
|
|
2782
|
+
turnsStarted: 0,
|
|
2783
|
+
turnsRefused: 0,
|
|
2784
|
+
skippedInFlight: 0,
|
|
2785
|
+
truncated,
|
|
2786
|
+
latencyMs: this.now() - started,
|
|
2787
|
+
failure
|
|
2788
|
+
};
|
|
2789
|
+
}
|
|
2790
|
+
/** Arm the next rung (or report why not). Returned as log fields so every caller writes ONE line. */
|
|
2791
|
+
retry() {
|
|
3287
2792
|
if (this.coalescer.delayedPending) {
|
|
3288
|
-
|
|
3289
|
-
return;
|
|
2793
|
+
return { retry: { kind: "pending" } };
|
|
3290
2794
|
}
|
|
3291
2795
|
if (this.retryRung >= this.ladder.length) {
|
|
3292
|
-
|
|
3293
|
-
return;
|
|
2796
|
+
return { retry: { kind: "exhausted" } };
|
|
3294
2797
|
}
|
|
3295
|
-
const
|
|
2798
|
+
const delayMs = this.ladder[this.retryRung] ?? this.ladder[this.ladder.length - 1] ?? 6e4;
|
|
3296
2799
|
this.retryRung += 1;
|
|
3297
|
-
this.
|
|
3298
|
-
this.
|
|
2800
|
+
this.coalescer.wakeAfter(delayMs);
|
|
2801
|
+
return { retry: { kind: "armed", delayMs, rung: this.retryRung } };
|
|
3299
2802
|
}
|
|
3300
2803
|
// ─── turns ──────────────────────────────────────────────────────────
|
|
3301
|
-
/**
|
|
3302
|
-
|
|
3303
|
-
|
|
3304
|
-
|
|
3305
|
-
|
|
3306
|
-
|
|
3307
|
-
|
|
3308
|
-
|
|
3309
|
-
|
|
3310
|
-
|
|
3311
|
-
|
|
3312
|
-
this.
|
|
3313
|
-
|
|
3314
|
-
|
|
2804
|
+
/**
|
|
2805
|
+
* Book an admitted turn and log its end whenever it comes. The cycle moves
|
|
2806
|
+
* on at once; OpenClaw's lane keeps the runs of one account in order.
|
|
2807
|
+
*
|
|
2808
|
+
* For a reply turn the end is also when the `reply` verdict is recorded —
|
|
2809
|
+
* only if the run completed (`status: ok`, no error): a turn that looked
|
|
2810
|
+
* and chose not to send still counts as read. A run that ended in error,
|
|
2811
|
+
* on the wait timeout, or whose wait failed records nothing: the card stays
|
|
2812
|
+
* on the tray and the ladder re-wakes so the conversation is gated again.
|
|
2813
|
+
*/
|
|
2814
|
+
admitted(sessionKey, admission, completeLine, reply) {
|
|
2815
|
+
this.turns += 1;
|
|
2816
|
+
this.turnsInFlight += 1;
|
|
2817
|
+
void admission.done.then(
|
|
2818
|
+
async (outcome) => {
|
|
2819
|
+
this.turnsInFlight -= 1;
|
|
2820
|
+
const completed = outcome.ran && outcome.status === "ok" && !outcome.error;
|
|
2821
|
+
this.logger[completed ? "info" : "warn"](
|
|
2822
|
+
{ sessionKey, runId: outcome.runId, status: outcome.status, ...outcome.error ? { error: outcome.error } : {} },
|
|
2823
|
+
completeLine
|
|
2824
|
+
);
|
|
2825
|
+
if (!reply) return;
|
|
2826
|
+
try {
|
|
2827
|
+
if (!completed) {
|
|
2828
|
+
this.logger.warn(
|
|
2829
|
+
{ sessionKey, conversationId: reply.conversationId, status: outcome.status, ...outcome.error ? { error: outcome.error } : {}, ...this.retry() },
|
|
2830
|
+
"turn did not complete \u2014 reply not recorded; the conversation stays unread and is gated again"
|
|
2831
|
+
);
|
|
2832
|
+
return;
|
|
2833
|
+
}
|
|
2834
|
+
await this.recordReply(sessionKey, reply);
|
|
2835
|
+
} finally {
|
|
2836
|
+
this.replyTurnEnded(reply.conversationId);
|
|
2837
|
+
}
|
|
2838
|
+
},
|
|
2839
|
+
async (err) => {
|
|
2840
|
+
this.turnsInFlight -= 1;
|
|
2841
|
+
this.logger.warn({ sessionKey, runId: admission.runId, err: describe4(err) }, `${completeLine} \u2014 the wait failed`);
|
|
2842
|
+
if (reply) {
|
|
2843
|
+
this.logger.warn(
|
|
2844
|
+
{ sessionKey, conversationId: reply.conversationId, err: describe4(err), ...this.retry() },
|
|
2845
|
+
"turn did not complete \u2014 reply not recorded; the conversation stays unread and is gated again"
|
|
2846
|
+
);
|
|
2847
|
+
this.replyTurnEnded(reply.conversationId);
|
|
2848
|
+
}
|
|
2849
|
+
}
|
|
3315
2850
|
);
|
|
3316
|
-
return outcome.ran;
|
|
3317
2851
|
}
|
|
3318
|
-
|
|
3319
|
-
|
|
3320
|
-
this.
|
|
2852
|
+
/** The reply turn for `conversationId` is over: its card may be gated again, and a tray that held skipped cards is read once more. */
|
|
2853
|
+
replyTurnEnded(conversationId) {
|
|
2854
|
+
this.replyTurnsInFlight.delete(conversationId);
|
|
2855
|
+
if (this.skippedWhileInFlight && !this.stopped) {
|
|
2856
|
+
this.skippedWhileInFlight = false;
|
|
2857
|
+
this.logger.debug({ conversationId }, "reply turn ended \u2014 re-reading the tray for the cards left out meanwhile");
|
|
2858
|
+
this.coalescer.wake();
|
|
2859
|
+
}
|
|
2860
|
+
}
|
|
2861
|
+
/** The `reply` verdict for a completed turn. A record the server refuses leaves the conversation unread; the ladder re-wakes. */
|
|
2862
|
+
async recordReply(sessionKey, reply) {
|
|
3321
2863
|
try {
|
|
3322
|
-
|
|
3323
|
-
|
|
3324
|
-
this.logger[outcome.ran ? "info" : "warn"](
|
|
3325
|
-
{ sessionKey, ran: outcome.ran, runId: outcome.runId, status: outcome.status, ...outcome.error ? { error: outcome.error } : {} },
|
|
3326
|
-
outcome.ran ? "group-invite turn complete" : "group-invite turn not started \u2014 the invite stays pending server-side"
|
|
3327
|
-
);
|
|
2864
|
+
await reply.record();
|
|
2865
|
+
this.logger.info({ sessionKey, conversationId: reply.conversationId }, "reply verdict recorded \u2014 turn completed");
|
|
3328
2866
|
} catch (err) {
|
|
3329
|
-
this.logger.
|
|
2867
|
+
this.logger.warn(
|
|
2868
|
+
{ sessionKey, conversationId: reply.conversationId, err: describe4(err), ...this.retry() },
|
|
2869
|
+
"reply verdict not recorded after the turn completed \u2014 the conversation stays unread; the next wake gates it again"
|
|
2870
|
+
);
|
|
2871
|
+
}
|
|
2872
|
+
}
|
|
2873
|
+
/**
|
|
2874
|
+
* Every pending invite gets one attempt. An invite leaves the pending list
|
|
2875
|
+
* only once its turn was admitted (and is then remembered in the ledger);
|
|
2876
|
+
* a refused one stays there for the next wake. Invites that arrive while
|
|
2877
|
+
* this runs are appended and get their pass on the next drain.
|
|
2878
|
+
*/
|
|
2879
|
+
async runInviteTurns() {
|
|
2880
|
+
const batch = [...this.pendingInvites];
|
|
2881
|
+
if (batch.length > 0) {
|
|
2882
|
+
const readiness = this.readiness();
|
|
2883
|
+
if (!readiness.ready) {
|
|
2884
|
+
const changed = this.unreadyReason !== readiness.reason;
|
|
2885
|
+
this.unreadyReason = readiness.reason;
|
|
2886
|
+
this.logger[changed ? "warn" : "debug"]({ pending: batch.length, reason: readiness.reason, ...this.retry() }, "AgentChat tools not available to a turn \u2014 invite turns wait; re-waking later");
|
|
2887
|
+
return;
|
|
2888
|
+
}
|
|
2889
|
+
}
|
|
2890
|
+
let texts = null;
|
|
2891
|
+
let refused = 0;
|
|
2892
|
+
let waitingForTexts = 0;
|
|
2893
|
+
for (const invite of batch) {
|
|
2894
|
+
if (this.stopped) return;
|
|
2895
|
+
texts ??= await this.texts.ensure();
|
|
2896
|
+
if (!texts) {
|
|
2897
|
+
waitingForTexts = batch.length;
|
|
2898
|
+
break;
|
|
2899
|
+
}
|
|
2900
|
+
const sessionKey = inviteSessionKey(this.agentId, invite.inviteId);
|
|
2901
|
+
this.logger.info({ sessionKey, groupId: invite.groupId, inviteId: invite.inviteId }, "group-invite turn start");
|
|
2902
|
+
let admission;
|
|
2903
|
+
try {
|
|
2904
|
+
admission = await this.startTurn({ sessionKey, prompt: inviteTurnPrompt(texts), lane: integrationLane(this.accountId) });
|
|
2905
|
+
} catch (err) {
|
|
2906
|
+
admission = { ran: false, error: describe4(err) };
|
|
2907
|
+
}
|
|
2908
|
+
if (!admission.ran) {
|
|
2909
|
+
refused += 1;
|
|
2910
|
+
this.logger.warn({ sessionKey, inviteId: invite.inviteId, error: admission.error }, "group-invite turn not started \u2014 the invite stays pending; retried on the next wake");
|
|
2911
|
+
continue;
|
|
2912
|
+
}
|
|
2913
|
+
this.inviteTurns += 1;
|
|
2914
|
+
this.invites.markOffered(invite.inviteId);
|
|
2915
|
+
this.pendingInvites = this.pendingInvites.filter((pending) => pending.inviteId !== invite.inviteId);
|
|
2916
|
+
this.admitted(sessionKey, admission, "group-invite turn complete");
|
|
2917
|
+
}
|
|
2918
|
+
if (this.stopped) return;
|
|
2919
|
+
if (waitingForTexts > 0) {
|
|
2920
|
+
this.logger.warn({ pending: waitingForTexts, ...this.retry() }, "served texts not available \u2014 invite turns wait; re-waking later");
|
|
2921
|
+
} else if (refused > 0) {
|
|
2922
|
+
this.logger.warn({ pending: refused, ...this.retry() }, "invite turns refused \u2014 re-waking later");
|
|
3330
2923
|
}
|
|
3331
2924
|
}
|
|
3332
2925
|
};
|
|
3333
|
-
function
|
|
2926
|
+
function describe4(err) {
|
|
3334
2927
|
return err instanceof Error ? err.message : String(err);
|
|
3335
2928
|
}
|
|
3336
|
-
var cache = /* @__PURE__ */ new Map();
|
|
3337
|
-
function getClient({ accountId, config, options }) {
|
|
3338
|
-
const existing = cache.get(accountId);
|
|
3339
|
-
if (existing && existing.apiKey === config.apiKey && existing.apiBase === config.apiBase) {
|
|
3340
|
-
return existing.client;
|
|
3341
|
-
}
|
|
3342
|
-
const client = new AgentChatClient({
|
|
3343
|
-
apiKey: config.apiKey,
|
|
3344
|
-
baseUrl: config.apiBase,
|
|
3345
|
-
...options,
|
|
3346
|
-
fetch: withAgentChatClientIdentity(options?.fetch ?? globalThis.fetch)
|
|
3347
|
-
});
|
|
3348
|
-
cache.set(accountId, {
|
|
3349
|
-
client,
|
|
3350
|
-
apiKey: config.apiKey,
|
|
3351
|
-
apiBase: config.apiBase
|
|
3352
|
-
});
|
|
3353
|
-
return client;
|
|
3354
|
-
}
|
|
3355
|
-
|
|
3356
|
-
// src/binding/gateway.ts
|
|
3357
2929
|
function adaptLog(log) {
|
|
3358
2930
|
if (!log) return void 0;
|
|
3359
2931
|
const adapted = {
|
|
@@ -3369,18 +2941,6 @@ function adaptLog(log) {
|
|
|
3369
2941
|
function withLifecycle(snapshot, lifecycle) {
|
|
3370
2942
|
return Object.assign({}, snapshot, { lifecycle });
|
|
3371
2943
|
}
|
|
3372
|
-
function statusStateFor(kind) {
|
|
3373
|
-
switch (kind) {
|
|
3374
|
-
case "READY":
|
|
3375
|
-
return "linked";
|
|
3376
|
-
case "AUTH_FAIL":
|
|
3377
|
-
return "not-linked";
|
|
3378
|
-
case "CLOSED":
|
|
3379
|
-
return "configured";
|
|
3380
|
-
default:
|
|
3381
|
-
return "unstable";
|
|
3382
|
-
}
|
|
3383
|
-
}
|
|
3384
2944
|
function formatLogLine(obj, msg) {
|
|
3385
2945
|
const head = msg ?? "";
|
|
3386
2946
|
const keys = Object.keys(obj);
|
|
@@ -3411,24 +2971,30 @@ var agentchatGatewayAdapter = {
|
|
|
3411
2971
|
const config = account.config;
|
|
3412
2972
|
const logger = adaptLog(ctx.log) ?? createLogger({ level: config.observability.logLevel, redactKeys: config.observability.redactKeys });
|
|
3413
2973
|
ctx.setStatus(withLifecycle({ ...ctx.getStatus(), running: true, connected: false }, "starting"));
|
|
3414
|
-
|
|
2974
|
+
const wakeMode = readWakeModeFromEnv();
|
|
2975
|
+
if (wakeMode.mode === "off") {
|
|
3415
2976
|
ctx.log?.info?.(
|
|
3416
|
-
`[agentchat:${ctx.accountId}]
|
|
2977
|
+
`[agentchat:${ctx.accountId}] ${wakeMode.variable}=off \u2014 no socket, no wakes, no turns; the hosted tools and the manual stay placed` + (wakeMode.variable === LEGACY_WAKE_MODE_ENV ? ` (${LEGACY_WAKE_MODE_ENV} is the old spelling; ${WAKE_MODE_ENV} is the new one)` : "")
|
|
3417
2978
|
);
|
|
3418
2979
|
ctx.setStatus(withLifecycle({ ...ctx.getStatus(), running: false, connected: false, linked: true, statusState: "disabled" }, "stopped"));
|
|
3419
2980
|
await waitUntilAbort(ctx.abortSignal, () => void 0);
|
|
3420
2981
|
return;
|
|
3421
2982
|
}
|
|
2983
|
+
if (readLegacyReplyGateFailOpenFromEnv()) {
|
|
2984
|
+
ctx.log?.warn?.(
|
|
2985
|
+
`[agentchat:${ctx.accountId}] ${LEGACY_REPLY_GATE_FAIL_OPEN_ENV} is set but no longer honoured \u2014 a gate that cannot run fails closed (nothing recorded, no turn) and re-wakes on the ladder`
|
|
2986
|
+
);
|
|
2987
|
+
}
|
|
3422
2988
|
const refusal = multiAccountRefusal(ctx.cfg);
|
|
3423
2989
|
if (refusal) {
|
|
3424
|
-
ctx.log?.error?.(`[agentchat:${ctx.accountId}]
|
|
2990
|
+
ctx.log?.error?.(`[agentchat:${ctx.accountId}] integration not started \u2014 ${refusal}`);
|
|
3425
2991
|
ctx.setStatus(withLifecycle({ ...ctx.getStatus(), running: false, connected: false, statusState: "not-linked", lastDisconnect: { at: Date.now(), error: refusal } }, "blocked"));
|
|
3426
2992
|
await waitUntilAbort(ctx.abortSignal, () => void 0);
|
|
3427
2993
|
return;
|
|
3428
2994
|
}
|
|
3429
2995
|
const channelRuntime = ctx.channelRuntime;
|
|
3430
2996
|
const { agentId, agentIdOverride } = resolveGateAgent({
|
|
3431
|
-
routedAgentId:
|
|
2997
|
+
routedAgentId: resolveIntegrationAgentId({ cfg: ctx.cfg, accountId: ctx.accountId, channelRuntime }),
|
|
3432
2998
|
ambientAgentId: resolveOpenClawDefaultAgentId(ctx.cfg)
|
|
3433
2999
|
});
|
|
3434
3000
|
if (agentIdOverride && !readLlmAgentOverrideOptIn(ctx.cfg)) {
|
|
@@ -3436,69 +3002,101 @@ var agentchatGatewayAdapter = {
|
|
|
3436
3002
|
`[agentchat:${ctx.accountId}] this account is routed to agent "${agentIdOverride}", not OpenClaw's default \u2014 the gate call will be refused (LLM_COMPLETION_NOT_AUTHORIZED) until ${LLM_AGENT_OVERRIDE_PATH} is true; \`openclaw doctor --fix\` writes it`
|
|
3437
3003
|
);
|
|
3438
3004
|
}
|
|
3439
|
-
const
|
|
3005
|
+
const client = getClient({ accountId: ctx.accountId, config });
|
|
3440
3006
|
const gateTimeoutMs = readReplyGateTimeoutMsFromEnv();
|
|
3441
|
-
|
|
3007
|
+
const texts = new TextsStore({ client, accountId: ctx.accountId, logger });
|
|
3008
|
+
const handle = config.agentHandle;
|
|
3009
|
+
if (handle) {
|
|
3010
|
+
texts.onServerCopy((copy) => {
|
|
3011
|
+
const refreshed = refreshIdentityLine(ctx.cfg, ctx.accountId, handle, copy.identity_line);
|
|
3012
|
+
if (refreshed.outcome === "updated") ctx.log?.info?.(`[agentchat:${ctx.accountId}] identity line refreshed from the served texts in ${refreshed.path}`);
|
|
3013
|
+
else if (refreshed.outcome === "failed") ctx.log?.warn?.(`[agentchat:${ctx.accountId}] identity line could not be refreshed in ${refreshed.path}: ${refreshed.detail ?? "unknown error"}`);
|
|
3014
|
+
});
|
|
3015
|
+
}
|
|
3016
|
+
await texts.start();
|
|
3017
|
+
const invites = new InviteLedger({
|
|
3018
|
+
accountId: ctx.accountId,
|
|
3019
|
+
onWriteError: (err) => ctx.log?.warn?.(`[agentchat:${ctx.accountId}] invite ledger could not be written: ${err instanceof Error ? err.message : String(err)}`)
|
|
3020
|
+
});
|
|
3021
|
+
const metrics = createInMemoryMetrics();
|
|
3022
|
+
await registerIntegration({
|
|
3442
3023
|
accountId: ctx.accountId,
|
|
3443
3024
|
config,
|
|
3444
3025
|
logger,
|
|
3445
|
-
|
|
3026
|
+
socketOptions: { client, metrics },
|
|
3027
|
+
build: (socket) => {
|
|
3446
3028
|
const invoker = new AgentInvoker({
|
|
3447
3029
|
accountId: ctx.accountId,
|
|
3448
3030
|
agentId,
|
|
3449
|
-
|
|
3450
|
-
|
|
3451
|
-
|
|
3031
|
+
client,
|
|
3032
|
+
callModel: createRuntimeModelCall({ agentIdOverride, ...gateTimeoutMs !== void 0 ? { timeoutMs: gateTimeoutMs } : {} }),
|
|
3033
|
+
startTurn: createRuntimeTurnStarter(),
|
|
3034
|
+
// Gating waits until a turn can have the hosted tools (the MCP
|
|
3035
|
+
// entry in the LIVE config — OpenClaw hot-applies `mcp.*` — and
|
|
3036
|
+
// its key in this process): a connect wake on a cold gateway
|
|
3037
|
+
// otherwise spends a gate call and runs a turn that cannot look.
|
|
3038
|
+
readiness: () => {
|
|
3039
|
+
const live = readLiveConfig(ctx.cfg);
|
|
3040
|
+
return turnReadiness({ cfg: live.cfg, apiBase: config.apiBase, apiKey: config.apiKey, live: live.live });
|
|
3041
|
+
},
|
|
3042
|
+
texts,
|
|
3043
|
+
invites,
|
|
3452
3044
|
logger,
|
|
3453
|
-
|
|
3454
|
-
|
|
3455
|
-
...gateTimeoutMs !== void 0 ? { gateTimeoutMs } : {}
|
|
3045
|
+
metrics,
|
|
3046
|
+
gateEnabled: readReplyGateEnabledFromEnv()
|
|
3456
3047
|
});
|
|
3457
|
-
let
|
|
3048
|
+
let blocked = false;
|
|
3458
3049
|
return {
|
|
3459
3050
|
invoker,
|
|
3051
|
+
texts,
|
|
3460
3052
|
handlers: {
|
|
3461
|
-
|
|
3053
|
+
onWake: (source) => invoker.wake(source),
|
|
3462
3054
|
onGroupInvite: (invite) => invoker.groupInvite(invite, "live"),
|
|
3463
|
-
|
|
3464
|
-
|
|
3055
|
+
onConnected: (at) => {
|
|
3056
|
+
if (blocked) {
|
|
3057
|
+
blocked = false;
|
|
3058
|
+
ctx.log?.info?.(`[agentchat:${ctx.accountId}] key accepted again \u2014 blocked cleared`);
|
|
3059
|
+
}
|
|
3060
|
+
ctx.log?.info?.(`[agentchat:${ctx.accountId}] connected at ${new Date(at).toISOString()} (agent ${agentId})`);
|
|
3465
3061
|
ctx.setStatus(withLifecycle({ ...ctx.getStatus(), running: true, connected: true, linked: true, statusState: "linked", lastConnectedAt: at }, "ready"));
|
|
3466
|
-
void catchUpInvites(ctx.accountId,
|
|
3062
|
+
void catchUpInvites(ctx.accountId, client, invoker, logger);
|
|
3063
|
+
},
|
|
3064
|
+
onBlocked: (info) => {
|
|
3065
|
+
const close = `close ${info.code}${info.reason ? ` ${info.reason}` : ""}`;
|
|
3066
|
+
const next = info.retryInMs === null ? "no retry scheduled" : `next HELLO in about ${Math.max(1, Math.round(info.retryInMs / 6e4))} min`;
|
|
3067
|
+
if (blocked) {
|
|
3068
|
+
ctx.log?.debug?.(`[agentchat:${ctx.accountId}] still blocked (${close}; ${next})`);
|
|
3069
|
+
return;
|
|
3070
|
+
}
|
|
3071
|
+
blocked = true;
|
|
3072
|
+
ctx.log?.error?.(
|
|
3073
|
+
`[agentchat:${ctx.accountId}] key rejected (${close}) \u2014 the server refused the key; the SDK retries a fresh HELLO every 10\u201315 min until it is accepted (${next}); rotate the key with openclaw channels add agentchat or openclaw config set channels.agentchat.apiKey \u2026`
|
|
3074
|
+
);
|
|
3075
|
+
ctx.setStatus(
|
|
3076
|
+
withLifecycle(
|
|
3077
|
+
{ ...ctx.getStatus(), running: false, connected: false, statusState: "not-linked", lastDisconnect: { at: Date.now(), error: `key rejected: ${close}` } },
|
|
3078
|
+
"blocked"
|
|
3079
|
+
)
|
|
3080
|
+
);
|
|
3467
3081
|
},
|
|
3468
3082
|
onError: (err) => {
|
|
3469
|
-
|
|
3470
|
-
ctx.log?.[level]?.(`[agentchat:${ctx.accountId}] runtime error: ${err.message} (class=${err.class_})`);
|
|
3083
|
+
ctx.log?.[blocked ? "debug" : "warn"]?.(`[agentchat:${ctx.accountId}] socket error: ${err.message}`);
|
|
3471
3084
|
},
|
|
3472
|
-
onStateChanged: (next) => {
|
|
3473
|
-
|
|
3474
|
-
|
|
3475
|
-
|
|
3085
|
+
onStateChanged: (next, prev) => {
|
|
3086
|
+
switch (next) {
|
|
3087
|
+
case "backoff":
|
|
3088
|
+
if (blocked) {
|
|
3089
|
+
ctx.log?.debug?.(`[agentchat:${ctx.accountId}] socket in backoff while blocked (from ${prev})`);
|
|
3090
|
+
return;
|
|
3091
|
+
}
|
|
3092
|
+
ctx.setStatus(withLifecycle({ ...ctx.getStatus(), running: true, connected: false, statusState: "unstable" }, "recovering"));
|
|
3093
|
+
return;
|
|
3094
|
+
case "stopped":
|
|
3095
|
+
ctx.setStatus(withLifecycle({ ...ctx.getStatus(), running: false, connected: false, statusState: "configured" }, "stopped"));
|
|
3096
|
+
return;
|
|
3097
|
+
default:
|
|
3476
3098
|
return;
|
|
3477
|
-
}
|
|
3478
|
-
authBlocked = true;
|
|
3479
|
-
ctx.log?.error?.(
|
|
3480
|
-
`[agentchat:${ctx.accountId}] AUTH_FAIL (${next.reason}) \u2014 the server rejected the key; retrying every 10\u201315 min; rotate the key or re-run openclaw channels add agentchat`
|
|
3481
|
-
);
|
|
3482
|
-
ctx.setStatus(
|
|
3483
|
-
withLifecycle(
|
|
3484
|
-
{ ...ctx.getStatus(), running: false, connected: false, statusState: "not-linked", lastDisconnect: { at: Date.now(), error: `AUTH_FAIL: ${next.reason}` } },
|
|
3485
|
-
"blocked"
|
|
3486
|
-
)
|
|
3487
|
-
);
|
|
3488
|
-
return;
|
|
3489
|
-
}
|
|
3490
|
-
if (authBlocked && next.kind !== "READY" && next.kind !== "CLOSED") {
|
|
3491
|
-
ctx.log?.debug?.(`[agentchat:${ctx.accountId}] AUTH_FAIL retry: ${next.kind.toLowerCase()}`);
|
|
3492
|
-
return;
|
|
3493
|
-
}
|
|
3494
|
-
if (authBlocked) {
|
|
3495
|
-
authBlocked = false;
|
|
3496
|
-
if (next.kind === "READY") ctx.log?.info?.(`[agentchat:${ctx.accountId}] key accepted again \u2014 AUTH_FAIL cleared`);
|
|
3497
3099
|
}
|
|
3498
|
-
const running = next.kind !== "CLOSED";
|
|
3499
|
-
const connected = next.kind === "READY" || next.kind === "DEGRADED";
|
|
3500
|
-
const lifecycle = next.kind === "READY" || next.kind === "DEGRADED" ? "ready" : next.kind === "CLOSED" ? "stopped" : runtime.getHealth().counters.knocks > 0 ? "recovering" : "starting";
|
|
3501
|
-
ctx.setStatus(withLifecycle({ ...ctx.getStatus(), running, connected, statusState: statusStateFor(next.kind) }, lifecycle));
|
|
3502
3100
|
}
|
|
3503
3101
|
}
|
|
3504
3102
|
};
|
|
@@ -3506,20 +3104,19 @@ var agentchatGatewayAdapter = {
|
|
|
3506
3104
|
});
|
|
3507
3105
|
await waitUntilAbort(ctx.abortSignal, async () => {
|
|
3508
3106
|
try {
|
|
3509
|
-
await
|
|
3107
|
+
await unregisterIntegration(ctx.accountId);
|
|
3510
3108
|
} catch (err) {
|
|
3511
3109
|
ctx.log?.error?.(`[agentchat:${ctx.accountId}] unregister failed on abort: ${err instanceof Error ? err.message : String(err)}`);
|
|
3512
3110
|
}
|
|
3513
3111
|
});
|
|
3514
3112
|
},
|
|
3515
3113
|
async stopAccount(ctx) {
|
|
3516
|
-
await
|
|
3114
|
+
await unregisterIntegration(ctx.accountId);
|
|
3517
3115
|
ctx.setStatus(withLifecycle({ ...ctx.getStatus(), running: false, connected: false }, "stopped"));
|
|
3518
3116
|
}
|
|
3519
3117
|
};
|
|
3520
|
-
async function catchUpInvites(accountId,
|
|
3118
|
+
async function catchUpInvites(accountId, client, invoker, logger) {
|
|
3521
3119
|
try {
|
|
3522
|
-
const client = getClient({ accountId, config });
|
|
3523
3120
|
const invites = await client.listGroupInvites();
|
|
3524
3121
|
if (!Array.isArray(invites)) return;
|
|
3525
3122
|
let surfaced = 0;
|
|
@@ -3527,16 +3124,20 @@ async function catchUpInvites(accountId, config, invoker, logger) {
|
|
|
3527
3124
|
const invite = groupInviteFromRecord(row);
|
|
3528
3125
|
if (invite && invoker.groupInvite(invite, "catch-up")) surfaced += 1;
|
|
3529
3126
|
}
|
|
3530
|
-
if (surfaced > 0) logger.info({ surfaced }, "pending group invites surfaced on connect");
|
|
3127
|
+
if (surfaced > 0) logger.info({ accountId, surfaced }, "pending group invites surfaced on connect");
|
|
3531
3128
|
} catch (err) {
|
|
3532
3129
|
logger.warn(
|
|
3533
|
-
{ err: err instanceof Error ? err.message : String(err) },
|
|
3130
|
+
{ accountId, err: err instanceof Error ? err.message : String(err) },
|
|
3534
3131
|
"pending-invite catch-up failed \u2014 live invite frames are unaffected and the agent can still list invites with the hosted tools"
|
|
3535
3132
|
);
|
|
3536
3133
|
}
|
|
3537
3134
|
}
|
|
3538
3135
|
var PROBE_MIN_MS = 1e3;
|
|
3539
3136
|
var PROBE_MAX_MS = 1e4;
|
|
3137
|
+
function formatCounts(counts) {
|
|
3138
|
+
const parts = Object.entries(counts).map(([label, n]) => `${label} ${n}`);
|
|
3139
|
+
return parts.length > 0 ? parts.join(", ") : "none";
|
|
3140
|
+
}
|
|
3540
3141
|
var agentchatStatusAdapter = {
|
|
3541
3142
|
async probeAccount({ account, timeoutMs, cfg }) {
|
|
3542
3143
|
if (!account.config) {
|
|
@@ -3565,28 +3166,32 @@ var agentchatStatusAdapter = {
|
|
|
3565
3166
|
handle: config.agentHandle ?? me.handle,
|
|
3566
3167
|
apiKey: config.apiKey,
|
|
3567
3168
|
apiBase: config.apiBase,
|
|
3169
|
+
identityLine: cachedIdentityLine(account.accountId),
|
|
3568
3170
|
agentId: resolvePlacementAgentId(cfg, account.accountId),
|
|
3569
3171
|
accountId: account.accountId
|
|
3570
3172
|
});
|
|
3571
3173
|
const enabled = account.enabled && isAgentchatAccountEnabled(cfg, account.accountId);
|
|
3572
|
-
const live =
|
|
3573
|
-
const health = live?.
|
|
3174
|
+
const live = getIntegration(account.accountId);
|
|
3175
|
+
const health = live?.socket.getHealth();
|
|
3574
3176
|
const counters = live?.invoker?.counters();
|
|
3575
|
-
const
|
|
3576
|
-
|
|
3577
|
-
|
|
3578
|
-
|
|
3177
|
+
const textsSource = live ? live.texts?.source ?? "missing" : void 0;
|
|
3178
|
+
const socketCounters = live?.metrics?.snapshot?.();
|
|
3179
|
+
const integration = {
|
|
3180
|
+
mode: readWakeModeFromEnv().mode,
|
|
3181
|
+
...health ? { state: health.state } : {},
|
|
3182
|
+
...counters ? { wakes: counters.wakes, cycles: counters.cycles, turns: counters.turns } : {},
|
|
3183
|
+
...textsSource ? { texts: textsSource } : {},
|
|
3184
|
+
...socketCounters ? { socket: socketCounters } : {}
|
|
3579
3185
|
};
|
|
3580
3186
|
const refusal = multiAccountRefusal(cfg);
|
|
3581
|
-
const legacyServer = health !== void 0 && health.authenticated && !health.ackNegotiated;
|
|
3582
3187
|
return {
|
|
3583
|
-
ok: enabled && me.status === "active" && mcp.ok && placement.every((c) => c.ok) && !refusal
|
|
3188
|
+
ok: enabled && me.status === "active" && mcp.ok && placement.every((c) => c.ok) && !refusal,
|
|
3584
3189
|
handle: me.handle,
|
|
3585
3190
|
status: me.status,
|
|
3586
3191
|
pausedByOwner: me.paused_by_owner ?? "none",
|
|
3587
3192
|
mcp,
|
|
3588
3193
|
placement,
|
|
3589
|
-
|
|
3194
|
+
integration,
|
|
3590
3195
|
...refusal ? { refusal } : {},
|
|
3591
3196
|
...enabled ? {} : { disabled: agentchatReenableHint(cfg, account.accountId) }
|
|
3592
3197
|
};
|
|
@@ -3609,22 +3214,27 @@ var agentchatStatusAdapter = {
|
|
|
3609
3214
|
for (const check of probe.placement ?? []) {
|
|
3610
3215
|
lines.push({ text: `${check.name}: ${check.detail}`, tone: check.ok ? "muted" : "warn" });
|
|
3611
3216
|
}
|
|
3612
|
-
if (probe.refusal) lines.push({ text: `
|
|
3613
|
-
if (probe.
|
|
3614
|
-
const d = probe.
|
|
3615
|
-
if (d.mode === "off") lines.push({ text:
|
|
3217
|
+
if (probe.refusal) lines.push({ text: `integration not started \u2014 ${probe.refusal}`, tone: "error" });
|
|
3218
|
+
if (probe.integration) {
|
|
3219
|
+
const d = probe.integration;
|
|
3220
|
+
if (d.mode === "off") lines.push({ text: `integration off (${WAKE_MODE_ENV}=off or ${LEGACY_WAKE_MODE_ENV}=off): no socket, no wakes, no turns`, tone: "warn" });
|
|
3616
3221
|
else if (d.state) {
|
|
3617
3222
|
lines.push({
|
|
3618
|
-
text: `
|
|
3619
|
-
tone: d.state === "
|
|
3223
|
+
text: `integration ${d.state} \u2014 wakes ${d.wakes ?? 0}, cycles ${d.cycles ?? 0}, turns ${d.turns ?? 0}`,
|
|
3224
|
+
tone: d.state === "ready" ? "success" : "warn"
|
|
3620
3225
|
});
|
|
3621
|
-
if (d.
|
|
3226
|
+
if (d.socket) {
|
|
3622
3227
|
lines.push({
|
|
3623
|
-
text:
|
|
3624
|
-
tone: "
|
|
3228
|
+
text: `socket \u2014 wakes: ${formatCounts(d.socket.wakes)} \xB7 closes: ${formatCounts(d.socket.disconnects)} \xB7 notices: ${formatCounts(d.socket.errors)}`,
|
|
3229
|
+
tone: "muted"
|
|
3625
3230
|
});
|
|
3626
3231
|
}
|
|
3627
|
-
|
|
3232
|
+
if (d.texts === "missing") {
|
|
3233
|
+
lines.push({ text: "served texts not available yet (AgentChat unreachable, nothing cached) \u2014 turns wait for the first copy", tone: "error" });
|
|
3234
|
+
} else if (d.texts === "cache") {
|
|
3235
|
+
lines.push({ text: "served texts from the cached copy \u2014 AgentChat was unreachable at start; refreshed when it is back", tone: "warn" });
|
|
3236
|
+
}
|
|
3237
|
+
} else if (!probe.refusal) lines.push({ text: "integration not running in this process", tone: "muted" });
|
|
3628
3238
|
}
|
|
3629
3239
|
return lines;
|
|
3630
3240
|
},
|
|
@@ -3639,7 +3249,7 @@ var agentchatDoctorAdapter = {
|
|
|
3639
3249
|
collectPreviewWarnings({ cfg, doctorFixCommand, env }) {
|
|
3640
3250
|
const warnings = [];
|
|
3641
3251
|
const refusal = multiAccountRefusal(cfg);
|
|
3642
|
-
if (refusal) warnings.push(`[${AGENTCHAT_CHANNEL_ID}]
|
|
3252
|
+
if (refusal) warnings.push(`[${AGENTCHAT_CHANNEL_ID}] integration will not start \u2014 ${refusal}`);
|
|
3643
3253
|
for (const accountId of listConfiguredAccountIds(cfg)) {
|
|
3644
3254
|
if (!isAgentchatAccountEnabled(cfg, accountId)) {
|
|
3645
3255
|
warnings.push(`[${AGENTCHAT_CHANNEL_ID}:${accountId}] ${agentchatReenableHint(cfg, accountId)}`);
|
|
@@ -3649,7 +3259,7 @@ var agentchatDoctorAdapter = {
|
|
|
3649
3259
|
const apiBase = readAgentchatConfigField(cfg, accountId, "apiBase") ?? DEFAULT_API_BASE2;
|
|
3650
3260
|
const handle = readAgentchatConfigField(cfg, accountId, "agentHandle");
|
|
3651
3261
|
const agentId = resolvePlacementAgentId(cfg, accountId);
|
|
3652
|
-
for (const check of checkPlacement({ cfg, handle, apiKey, apiBase, agentId, accountId, env })) {
|
|
3262
|
+
for (const check of checkPlacement({ cfg, handle, apiKey, apiBase, identityLine: cachedIdentityLine(accountId), agentId, accountId, env })) {
|
|
3653
3263
|
if (check.ok) continue;
|
|
3654
3264
|
const fix = check.name === "mcp" ? ` (${doctorFixCommand} adds it)` : "";
|
|
3655
3265
|
warnings.push(`[${AGENTCHAT_CHANNEL_ID}:${accountId}] ${check.name}: ${check.detail}${fix}`);
|
|
@@ -3697,9 +3307,11 @@ var agentchatDoctorAdapter = {
|
|
|
3697
3307
|
}
|
|
3698
3308
|
const handle = readAgentchatConfigField(next, accountId, "agentHandle");
|
|
3699
3309
|
if (apiKey && handle && placeIdentityLines) {
|
|
3700
|
-
const
|
|
3310
|
+
const identityLine = await loadIdentityLine({ client: createSdkClient({ apiKey, apiBase }), accountId });
|
|
3311
|
+
const restored = restoreIdentityLine(next, accountId, handle, identityLine);
|
|
3701
3312
|
if (restored.outcome === "placed") changes.push(`placed the identity line for @${handle.replace(/^@/, "")} in ${restored.path}`);
|
|
3702
3313
|
else if (restored.outcome === "failed") warnings.push(`[${AGENTCHAT_CHANNEL_ID}:${accountId}] could not place the identity line for @${handle.replace(/^@/, "")}: ${restored.detail ?? "unknown error"}`);
|
|
3314
|
+
else if (restored.outcome === "skipped") warnings.push(`[${AGENTCHAT_CHANNEL_ID}:${accountId}] identity line for @${handle.replace(/^@/, "")} not placed: ${restored.detail ?? "the served text is not available"}`);
|
|
3703
3315
|
}
|
|
3704
3316
|
}
|
|
3705
3317
|
for (const [apiBase, apiKey] of bases) {
|
|
@@ -3831,12 +3443,12 @@ var agentchatSetupAdapter = {
|
|
|
3831
3443
|
const apiKey = readAgentchatConfigField(withAccount, accountId, "apiKey");
|
|
3832
3444
|
if (!apiKey) return withAccount;
|
|
3833
3445
|
const apiBase = readAgentchatConfigField(withAccount, accountId, "apiBase") ?? DEFAULT_API_BASE2;
|
|
3834
|
-
return
|
|
3446
|
+
return applyIntegrationConfig(withAccount, { accountId, handle, apiKey, apiBase }).cfg;
|
|
3835
3447
|
},
|
|
3836
3448
|
/**
|
|
3837
|
-
* Files only: the key into OpenClaw's state-dir `.env`, the
|
|
3838
|
-
* into the bound agent's `AGENTS.md`. Reports through
|
|
3839
|
-
* Never throws: setup-time UX is "warn and proceed".
|
|
3449
|
+
* Files only: the key into OpenClaw's state-dir `.env`, the served
|
|
3450
|
+
* identity line into the bound agent's `AGENTS.md`. Reports through
|
|
3451
|
+
* `RuntimeEnv.log`. Never throws: setup-time UX is "warn and proceed".
|
|
3840
3452
|
*/
|
|
3841
3453
|
async afterAccountConfigWritten({ cfg, accountId, input, runtime }) {
|
|
3842
3454
|
const apiKey = typeof input.token === "string" ? input.token : readAgentchatConfigField(cfg, accountId, "apiKey");
|
|
@@ -3859,7 +3471,8 @@ var agentchatSetupAdapter = {
|
|
|
3859
3471
|
}
|
|
3860
3472
|
}
|
|
3861
3473
|
try {
|
|
3862
|
-
const
|
|
3474
|
+
const identityLine = await loadIdentityLine({ client: createSdkClient({ apiKey, apiBase }), accountId });
|
|
3475
|
+
const placed = placeIntegration({ cfg, handle, apiKey, apiBase, identityLine, accountId });
|
|
3863
3476
|
for (const line of formatPlacement(placed.steps.filter((s) => s.name !== "mcp"))) say(runtime, "log", `[agentchat:${accountId}] ${line}`);
|
|
3864
3477
|
say(runtime, "log", `[agentchat:${accountId}] \u2713 config: agentHandle and mcp.servers.agentchat written with the account (restart the gateway, or reload its config, so \${AGENTCHAT_API_KEY} resolves)`);
|
|
3865
3478
|
} catch (err) {
|
|
@@ -3868,11 +3481,11 @@ var agentchatSetupAdapter = {
|
|
|
3868
3481
|
}
|
|
3869
3482
|
};
|
|
3870
3483
|
function disableAccountConfig(cfg, accountId) {
|
|
3871
|
-
const stripped =
|
|
3484
|
+
const stripped = stripIntegrationConfig(cfg, accountId).cfg;
|
|
3872
3485
|
return setAccountEnabledInConfigSection({ cfg: stripped, sectionKey: AGENTCHAT_CHANNEL_ID, accountId, enabled: false, allowTopLevel: true });
|
|
3873
3486
|
}
|
|
3874
3487
|
function deleteAccountConfig(cfg, accountId) {
|
|
3875
|
-
const stripped =
|
|
3488
|
+
const stripped = stripIntegrationConfig(cfg, accountId).cfg;
|
|
3876
3489
|
return deleteAccountFromConfigSection({ cfg: stripped, sectionKey: AGENTCHAT_CHANNEL_ID, accountId, clearBaseFields: ["apiKey", "apiBase", "agentHandle"] });
|
|
3877
3490
|
}
|
|
3878
3491
|
function isAccountEnabled(cfg, accountId) {
|
|
@@ -3897,7 +3510,7 @@ var agentchatLifecycleAdapter = {
|
|
|
3897
3510
|
return;
|
|
3898
3511
|
}
|
|
3899
3512
|
if (!isEnabled) {
|
|
3900
|
-
for (const line of
|
|
3513
|
+
for (const line of removeIntegrationFiles(nextCfg, accountId, { clearKey: false })) say(runtime, "log", `[agentchat:${accountId}] ${line}`);
|
|
3901
3514
|
return;
|
|
3902
3515
|
}
|
|
3903
3516
|
const handle = validHandle(readAgentchatConfigField(nextCfg, accountId, "agentHandle"));
|
|
@@ -3905,12 +3518,16 @@ var agentchatLifecycleAdapter = {
|
|
|
3905
3518
|
say(runtime, "log", `[agentchat:${accountId}] agentHandle not in config \u2014 run \`openclaw doctor --fix\` to learn it from the key and place the identity line`);
|
|
3906
3519
|
return;
|
|
3907
3520
|
}
|
|
3908
|
-
const
|
|
3521
|
+
const apiKey = readAgentchatConfigField(nextCfg, accountId, "apiKey");
|
|
3522
|
+
const apiBase = readAgentchatConfigField(nextCfg, accountId, "apiBase") ?? DEFAULT_API_BASE2;
|
|
3523
|
+
const identityLine = apiKey ? await loadIdentityLine({ client: createSdkClient({ apiKey, apiBase }), accountId }) : null;
|
|
3524
|
+
const restored = restoreIdentityLine(nextCfg, accountId, handle, identityLine);
|
|
3909
3525
|
if (restored.outcome === "placed") say(runtime, "log", `[agentchat:${accountId}] placed the identity line for @${handle} in ${restored.path}`);
|
|
3526
|
+
else if (restored.outcome === "skipped") say(runtime, "log", `[agentchat:${accountId}] identity line for @${handle} not placed: ${restored.detail ?? "the served text is not available"}`);
|
|
3910
3527
|
else if (restored.outcome === "failed") say(runtime, "error", `[agentchat:${accountId}] could not place the identity line for @${handle}: ${restored.detail ?? "unknown error"} \u2014 run \`openclaw doctor --fix\` after fixing the path`);
|
|
3911
3528
|
},
|
|
3912
3529
|
async onAccountRemoved({ prevCfg, accountId, runtime }) {
|
|
3913
|
-
for (const line of
|
|
3530
|
+
for (const line of removeIntegrationFiles(prevCfg, accountId, { clearKey: true })) say(runtime, "log", `[agentchat:${accountId}] ${line}`);
|
|
3914
3531
|
}
|
|
3915
3532
|
};
|
|
3916
3533
|
var agentchatPlugin = {
|
|
@@ -3922,7 +3539,7 @@ var agentchatPlugin = {
|
|
|
3922
3539
|
detailLabel: "AgentChat",
|
|
3923
3540
|
docsPath: "/channels/agentchat",
|
|
3924
3541
|
docsLabel: "agentchat",
|
|
3925
|
-
blurb: "the AgentChat
|
|
3542
|
+
blurb: "the AgentChat integration \u2014 your agent gets a permanent @handle on the messaging network for AI agents, is woken when a peer writes, and decides for itself with its own model whether to reply through the hosted AgentChat tools.",
|
|
3926
3543
|
systemImage: "message",
|
|
3927
3544
|
markdownCapable: true,
|
|
3928
3545
|
order: 100
|
|
@@ -4014,7 +3631,7 @@ var agentchatPlugin = {
|
|
|
4014
3631
|
setup: agentchatSetupAdapter,
|
|
4015
3632
|
// ─── OpenClaw ↔ AgentChat binding ─────────────────────────────────────
|
|
4016
3633
|
//
|
|
4017
|
-
// gateway — holds the socket,
|
|
3634
|
+
// gateway — holds the socket, wakes, gates, starts turns (the integration).
|
|
4018
3635
|
// status — the doctor-style probe: key, hosted MCP reachability, placement.
|
|
4019
3636
|
// doctor — `openclaw doctor` warnings and the mcp.servers.agentchat repair.
|
|
4020
3637
|
//
|
|
@@ -4031,11 +3648,11 @@ var agentchatPlugin = {
|
|
|
4031
3648
|
defineChannelPluginEntry({
|
|
4032
3649
|
id: AGENTCHAT_CHANNEL_ID,
|
|
4033
3650
|
name: "AgentChat",
|
|
4034
|
-
description: "The AgentChat
|
|
3651
|
+
description: "The AgentChat integration: wakes your OpenClaw agent when a peer writes on the messaging network for AI agents.",
|
|
4035
3652
|
plugin: agentchatPlugin,
|
|
4036
3653
|
// Called in every registration mode except cli-metadata and tool-discovery
|
|
4037
3654
|
// (docs.openclaw.ai/plugins/sdk-entrypoints/define-channel-plugin-entry).
|
|
4038
|
-
// The
|
|
3655
|
+
// The integration reads `runtime.llm.complete` (the gate on the agent's own
|
|
4039
3656
|
// model) and `runtime.subagent.run` (one turn, `deliver: false`) from it.
|
|
4040
3657
|
setRuntime: (runtime) => setPluginRuntime(runtime)
|
|
4041
3658
|
});
|