@agentchatme/openclaw 0.8.0 → 0.9.0
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 +32 -1
- package/README.md +72 -70
- package/RUNBOOK.md +54 -41
- package/SECURITY.md +8 -5
- 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 +978 -1421
- package/dist/index.cjs.map +1 -1
- package/dist/index.d.cts +155 -721
- package/dist/index.d.ts +155 -721
- package/dist/index.js +969 -1415
- 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-Dq5Dwg8O.d.cts +655 -0
- package/dist/setup-entry-Dq5Dwg8O.d.ts +655 -0
- package/dist/setup-entry.cjs +967 -1427
- 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 +968 -1428
- 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.cjs
CHANGED
|
@@ -7,14 +7,13 @@ var channelPluginCommon = require('openclaw/plugin-sdk/channel-plugin-common');
|
|
|
7
7
|
var setup = require('openclaw/plugin-sdk/setup');
|
|
8
8
|
var readEnv_js$1 = require('./credentials/read-env.cjs');
|
|
9
9
|
var fs = require('fs');
|
|
10
|
-
var
|
|
10
|
+
var path2 = require('path');
|
|
11
11
|
var readEnv_js = require('./credentials/read-env.cjs');
|
|
12
12
|
var openclawLayout_js = require('./openclaw-layout.cjs');
|
|
13
13
|
var agentsAnchor_js = require('./binding/agents-anchor.cjs');
|
|
14
|
+
var agentchatme = require('agentchatme');
|
|
14
15
|
var zod = require('zod');
|
|
15
16
|
var pino = require('pino');
|
|
16
|
-
var ws = require('ws');
|
|
17
|
-
var agentchatme = require('agentchatme');
|
|
18
17
|
|
|
19
18
|
function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
|
|
20
19
|
|
|
@@ -37,7 +36,7 @@ function _interopNamespace(e) {
|
|
|
37
36
|
}
|
|
38
37
|
|
|
39
38
|
var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
|
|
40
|
-
var
|
|
39
|
+
var path2__namespace = /*#__PURE__*/_interopNamespace(path2);
|
|
41
40
|
var pino__default = /*#__PURE__*/_interopDefault(pino);
|
|
42
41
|
|
|
43
42
|
// src/channel.setup.ts
|
|
@@ -101,7 +100,7 @@ function listConfiguredAccountIds(cfg) {
|
|
|
101
100
|
function multiAccountRefusal(cfg) {
|
|
102
101
|
const ids = listConfiguredAccountIds(cfg);
|
|
103
102
|
if (ids.length <= 1) return null;
|
|
104
|
-
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
|
|
103
|
+
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.`;
|
|
105
104
|
}
|
|
106
105
|
function isApiKeyPresent(value) {
|
|
107
106
|
return typeof value === "string" && value.length >= MIN_API_KEY_LENGTH;
|
|
@@ -133,52 +132,19 @@ function applyAgentchatAccountPatch(cfg, accountId, patch) {
|
|
|
133
132
|
return { ...cfg ?? {}, channels };
|
|
134
133
|
}
|
|
135
134
|
|
|
136
|
-
// src/errors.ts
|
|
137
|
-
var AgentChatChannelError = class extends Error {
|
|
138
|
-
class_;
|
|
139
|
-
retryAfterMs;
|
|
140
|
-
statusCode;
|
|
141
|
-
constructor(class_, message, options = {}) {
|
|
142
|
-
super(message, { cause: options.cause });
|
|
143
|
-
this.name = "AgentChatChannelError";
|
|
144
|
-
this.class_ = class_;
|
|
145
|
-
this.retryAfterMs = options.retryAfterMs;
|
|
146
|
-
this.statusCode = options.statusCode;
|
|
147
|
-
}
|
|
148
|
-
};
|
|
149
|
-
function classifyNetworkError(err) {
|
|
150
|
-
if (!err || typeof err !== "object") return "retry-transient";
|
|
151
|
-
const code = err.code;
|
|
152
|
-
if (typeof code === "string") {
|
|
153
|
-
if (code === "ECONNRESET" || code === "ETIMEDOUT" || code === "ECONNREFUSED") {
|
|
154
|
-
return "retry-transient";
|
|
155
|
-
}
|
|
156
|
-
if (code === "ENOTFOUND" || code === "EAI_AGAIN") return "retry-transient";
|
|
157
|
-
}
|
|
158
|
-
return "retry-transient";
|
|
159
|
-
}
|
|
160
|
-
|
|
161
135
|
// src/version.ts
|
|
162
|
-
var PACKAGE_VERSION = "0.
|
|
136
|
+
var PACKAGE_VERSION = "0.9.0";
|
|
163
137
|
|
|
164
138
|
// src/client-identity.ts
|
|
165
139
|
var AGENTCHAT_CLIENT_NAME = "openclaw";
|
|
140
|
+
var AGENTCHAT_CLIENT_IDENTITY = {
|
|
141
|
+
name: AGENTCHAT_CLIENT_NAME,
|
|
142
|
+
version: PACKAGE_VERSION
|
|
143
|
+
};
|
|
166
144
|
var AGENTCHAT_CLIENT_HEADERS = {
|
|
167
145
|
"X-AgentChat-Client": AGENTCHAT_CLIENT_NAME,
|
|
168
146
|
"X-AgentChat-Client-Version": PACKAGE_VERSION
|
|
169
147
|
};
|
|
170
|
-
function withAgentChatClientIdentity(fetchImpl) {
|
|
171
|
-
return (async (input, init) => {
|
|
172
|
-
const headers = new Headers(
|
|
173
|
-
typeof Request !== "undefined" && input instanceof Request ? input.headers : void 0
|
|
174
|
-
);
|
|
175
|
-
new Headers(init?.headers).forEach((value, key) => headers.set(key, value));
|
|
176
|
-
for (const [key, value] of Object.entries(AGENTCHAT_CLIENT_HEADERS)) {
|
|
177
|
-
headers.set(key, value);
|
|
178
|
-
}
|
|
179
|
-
return fetchImpl(input, { ...init, headers });
|
|
180
|
-
});
|
|
181
|
-
}
|
|
182
148
|
|
|
183
149
|
// src/setup-client.ts
|
|
184
150
|
var DEFAULT_API_BASE = "https://api.agentchat.me";
|
|
@@ -406,9 +372,9 @@ function readHandleList(details) {
|
|
|
406
372
|
if (!Array.isArray(handles)) return [];
|
|
407
373
|
return handles.filter((h) => typeof h === "string" && h.length > 0);
|
|
408
374
|
}
|
|
409
|
-
async function post(
|
|
375
|
+
async function post(path5, body, opts) {
|
|
410
376
|
const base = (opts.apiBase ?? DEFAULT_API_BASE).replace(/\/+$/, "");
|
|
411
|
-
const url = `${base}${
|
|
377
|
+
const url = `${base}${path5}`;
|
|
412
378
|
const controller = new AbortController();
|
|
413
379
|
const fetchImpl = opts.fetch ?? fetch;
|
|
414
380
|
const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
|
|
@@ -441,53 +407,40 @@ async function post(path2, body, opts) {
|
|
|
441
407
|
}
|
|
442
408
|
}
|
|
443
409
|
|
|
444
|
-
// src/
|
|
410
|
+
// src/integration/turn.ts
|
|
445
411
|
var MCP_SERVER_NAME = "agentchat";
|
|
446
412
|
var MCP_TOOL_DELIMITER = "__";
|
|
447
|
-
var
|
|
413
|
+
var MCP_TOOL_PREFIX = `${MCP_SERVER_NAME}${MCP_TOOL_DELIMITER}`;
|
|
448
414
|
function mcpToolName(tool) {
|
|
449
|
-
return `${
|
|
415
|
+
return `${MCP_TOOL_PREFIX}${tool}`;
|
|
450
416
|
}
|
|
451
|
-
var INBOX_TOOL = mcpToolName("agentchat_inbox");
|
|
452
|
-
var DECIDE_TOOL = mcpToolName("agentchat_decide");
|
|
453
417
|
var GET_CONVERSATION_TOOL = mcpToolName("agentchat_get_conversation");
|
|
454
|
-
var
|
|
455
|
-
var
|
|
456
|
-
|
|
457
|
-
|
|
458
|
-
|
|
459
|
-
|
|
460
|
-
|
|
461
|
-
|
|
462
|
-
|
|
463
|
-
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.)`;
|
|
464
|
-
var KNOCK_TURN_PROMPT = `${WAKE_INSTRUCTION}
|
|
465
|
-
|
|
466
|
-
${MANUAL_POINTER}`;
|
|
467
|
-
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.
|
|
468
|
-
|
|
469
|
-
${MANUAL_POINTER}`;
|
|
470
|
-
function knockTurnPrompt(replyConversations = []) {
|
|
471
|
-
const ids = replyConversations.filter((id) => typeof id === "string" && id.length > 0);
|
|
472
|
-
if (ids.length === 0) return KNOCK_TURN_PROMPT;
|
|
473
|
-
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.`;
|
|
474
|
-
return `${WAKE_INSTRUCTION}
|
|
475
|
-
|
|
476
|
-
${gateLine}
|
|
418
|
+
var OPENCLAW_TOOL_NAMER = (tool) => tool.startsWith(MCP_TOOL_PREFIX) ? tool : mcpToolName(tool);
|
|
419
|
+
var HOSTED_TOOL_TOKEN = /\bagentchat_(?!_)[a-z0-9_]+\b/g;
|
|
420
|
+
function spellToolsForOpenClaw(text) {
|
|
421
|
+
return text.replace(HOSTED_TOOL_TOKEN, (token) => OPENCLAW_TOOL_NAMER(token));
|
|
422
|
+
}
|
|
423
|
+
function wakeTurnPrompt(texts, conversationId) {
|
|
424
|
+
const instruction = texts.wake_instruction.trim();
|
|
425
|
+
if (!conversationId) return instruction;
|
|
426
|
+
return `${instruction}
|
|
477
427
|
|
|
478
|
-
${
|
|
428
|
+
${conversationLine(conversationId)}`;
|
|
479
429
|
}
|
|
480
|
-
function
|
|
481
|
-
return
|
|
430
|
+
function conversationLine(conversationId) {
|
|
431
|
+
return `Conversation to answer in this turn: ${conversationId}. The gate decided reply and your reply verdict for it is being recorded; if this conversation still shows on the tray, do not record another verdict for it \u2014 open it with ${GET_CONVERSATION_TOOL} and reply.`;
|
|
482
432
|
}
|
|
483
|
-
function
|
|
484
|
-
return
|
|
433
|
+
function inviteTurnPrompt(texts) {
|
|
434
|
+
return texts.invite_prompt.trim();
|
|
435
|
+
}
|
|
436
|
+
function wakeSessionKey(agentId, now = Date.now(), nonce = randomNonce()) {
|
|
437
|
+
return `agent:${agentId}:subagent:agentchat-wake-${utcStamp(now)}-${nonce}`;
|
|
485
438
|
}
|
|
486
439
|
function inviteSessionKey(agentId, inviteId) {
|
|
487
440
|
return `agent:${agentId}:subagent:agentchat-invite-${sanitizeKeyPart(inviteId)}`;
|
|
488
441
|
}
|
|
489
|
-
function
|
|
490
|
-
return `agentchat-
|
|
442
|
+
function integrationLane(accountId) {
|
|
443
|
+
return `agentchat-integration:${sanitizeKeyPart(accountId)}`;
|
|
491
444
|
}
|
|
492
445
|
function utcStamp(ms) {
|
|
493
446
|
return new Date(ms).toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
|
|
@@ -500,7 +453,7 @@ function sanitizeKeyPart(value) {
|
|
|
500
453
|
return clean.length > 0 ? clean : "x";
|
|
501
454
|
}
|
|
502
455
|
|
|
503
|
-
// src/
|
|
456
|
+
// src/integration/mcp.ts
|
|
504
457
|
var MCP_PATH = "/mcp";
|
|
505
458
|
var AUTH_HEADER_TEMPLATE = `Bearer \${${readEnv_js.API_KEY_ENV}}`;
|
|
506
459
|
var DEFAULT_API_BASE2 = "https://api.agentchat.me";
|
|
@@ -621,7 +574,7 @@ function readInitializeResult(text) {
|
|
|
621
574
|
return null;
|
|
622
575
|
}
|
|
623
576
|
|
|
624
|
-
// src/
|
|
577
|
+
// src/integration/runtime-holder.ts
|
|
625
578
|
var current = null;
|
|
626
579
|
function isUsablePluginRuntime(runtime) {
|
|
627
580
|
if (!runtime || typeof runtime !== "object" && typeof runtime !== "function") return false;
|
|
@@ -639,9 +592,11 @@ function getPluginRuntime() {
|
|
|
639
592
|
return current;
|
|
640
593
|
}
|
|
641
594
|
|
|
642
|
-
// src/
|
|
595
|
+
// src/integration/model.ts
|
|
643
596
|
var DEFAULT_AGENT_ID = "main";
|
|
644
597
|
var GATE_TEMPERATURE = 0;
|
|
598
|
+
var DEFAULT_GATE_MAX_TOKENS = 2048;
|
|
599
|
+
var DEFAULT_GATE_TIMEOUT_MS = 2e4;
|
|
645
600
|
var DEFAULT_TURN_WAIT_MS = 15 * 6e4;
|
|
646
601
|
var RuntimeUnavailableError = class extends Error {
|
|
647
602
|
constructor(what) {
|
|
@@ -649,13 +604,13 @@ var RuntimeUnavailableError = class extends Error {
|
|
|
649
604
|
this.name = "RuntimeUnavailableError";
|
|
650
605
|
}
|
|
651
606
|
};
|
|
652
|
-
function
|
|
607
|
+
function resolveIntegrationAgentId(params) {
|
|
653
608
|
try {
|
|
654
609
|
const route = params.channelRuntime?.routing?.resolveAgentRoute?.({
|
|
655
610
|
cfg: params.cfg,
|
|
656
611
|
channel: AGENTCHAT_CHANNEL_ID,
|
|
657
612
|
accountId: params.accountId,
|
|
658
|
-
peer: { kind: "direct", id: "
|
|
613
|
+
peer: { kind: "direct", id: "wake" }
|
|
659
614
|
});
|
|
660
615
|
const agentId = route?.agentId;
|
|
661
616
|
if (typeof agentId === "string" && agentId.trim().length > 0) return agentId.trim();
|
|
@@ -663,18 +618,19 @@ function resolveDoorbellAgentId(params) {
|
|
|
663
618
|
}
|
|
664
619
|
return DEFAULT_AGENT_ID;
|
|
665
620
|
}
|
|
666
|
-
function
|
|
621
|
+
function createRuntimeModelCall(params) {
|
|
667
622
|
const getRuntime = params.runtime ?? getPluginRuntime;
|
|
668
|
-
|
|
623
|
+
const maxTokens = params.maxTokens ?? DEFAULT_GATE_MAX_TOKENS;
|
|
624
|
+
const timeoutMs = params.timeoutMs ?? DEFAULT_GATE_TIMEOUT_MS;
|
|
625
|
+
return async (prompt) => {
|
|
669
626
|
const runtime = getRuntime();
|
|
670
627
|
if (!runtime) throw new RuntimeUnavailableError("the gate call");
|
|
671
628
|
const result = await runtime.llm.complete({
|
|
672
|
-
|
|
673
|
-
messages: [{ role: "user", content: userContent }],
|
|
629
|
+
messages: [{ role: "user", content: prompt }],
|
|
674
630
|
maxTokens,
|
|
675
631
|
temperature: GATE_TEMPERATURE,
|
|
676
632
|
...params.agentIdOverride ? { agentId: params.agentIdOverride } : {},
|
|
677
|
-
purpose: "AgentChat reply gate: the server's question about the server's cards",
|
|
633
|
+
purpose: "AgentChat reply gate: the server's question about the server's cards (tool-free triage)",
|
|
678
634
|
...Number.isFinite(timeoutMs) && timeoutMs > 0 ? { signal: AbortSignal.timeout(timeoutMs) } : {}
|
|
679
635
|
});
|
|
680
636
|
return typeof result?.text === "string" ? result.text : "";
|
|
@@ -704,7 +660,7 @@ function resolveGateAgent(params) {
|
|
|
704
660
|
const ambient = params.ambientAgentId?.trim().toLowerCase();
|
|
705
661
|
return { agentId: routed, agentIdOverride: routed === (ambient ?? routed) ? void 0 : routed };
|
|
706
662
|
}
|
|
707
|
-
function
|
|
663
|
+
function createRuntimeTurnStarter(params = {}) {
|
|
708
664
|
const getRuntime = params.runtime ?? getPluginRuntime;
|
|
709
665
|
const waitMs = params.waitMs ?? DEFAULT_TURN_WAIT_MS;
|
|
710
666
|
return async (request) => {
|
|
@@ -722,12 +678,12 @@ function createRuntimeTurnRunner(params = {}) {
|
|
|
722
678
|
} catch (err) {
|
|
723
679
|
return { ran: false, error: err instanceof Error ? err.message : String(err) };
|
|
724
680
|
}
|
|
725
|
-
|
|
726
|
-
|
|
727
|
-
|
|
728
|
-
|
|
729
|
-
|
|
730
|
-
}
|
|
681
|
+
const done = runtime.subagent.waitForRun({ runId, timeoutMs: waitMs }).then(
|
|
682
|
+
(waited) => ({ ran: true, runId, status: waited.status, ...waited.error ? { error: waited.error } : {} }),
|
|
683
|
+
// The run was admitted; only the wait failed. The turn is OpenClaw's now.
|
|
684
|
+
(err) => ({ ran: true, runId, status: "unknown", error: err instanceof Error ? err.message : String(err) })
|
|
685
|
+
);
|
|
686
|
+
return { ran: true, runId, done };
|
|
731
687
|
};
|
|
732
688
|
}
|
|
733
689
|
var HANDLE_PATTERN = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
|
|
@@ -736,7 +692,7 @@ function isValidHandleShape(value) {
|
|
|
736
692
|
}
|
|
737
693
|
var DOTENV_NAME = ".env";
|
|
738
694
|
function dotEnvPath(stateDir = openclawLayout_js.resolveOpenClawStateDir()) {
|
|
739
|
-
return
|
|
695
|
+
return path2__namespace.join(stateDir, DOTENV_NAME);
|
|
740
696
|
}
|
|
741
697
|
function placeApiKeyInDotEnv(apiKey, stateDir = openclawLayout_js.resolveOpenClawStateDir()) {
|
|
742
698
|
const trimmed = apiKey.trim();
|
|
@@ -805,7 +761,7 @@ function stripQuotes(value) {
|
|
|
805
761
|
}
|
|
806
762
|
return value;
|
|
807
763
|
}
|
|
808
|
-
function
|
|
764
|
+
function applyIntegrationConfig(cfg, params) {
|
|
809
765
|
const changes = [];
|
|
810
766
|
let next = cfg;
|
|
811
767
|
const bareHandle = (params.handle ?? "").trim().replace(/^@/, "");
|
|
@@ -828,13 +784,13 @@ function applyDoorbellConfig(cfg, params) {
|
|
|
828
784
|
function resolvePlacementAgentId(cfg, accountId) {
|
|
829
785
|
return openclawLayout_js.resolveBoundAgentId(cfg, AGENTCHAT_CHANNEL_ID, accountId) ?? openclawLayout_js.resolveOpenClawDefaultAgentId(cfg);
|
|
830
786
|
}
|
|
831
|
-
function
|
|
787
|
+
function stripIntegrationConfig(cfg, accountId) {
|
|
832
788
|
const apiBase = readAgentchatConfigField(cfg, accountId, "apiBase") ?? "https://api.agentchat.me";
|
|
833
789
|
const apiKey = readAgentchatConfigField(cfg, accountId, "apiKey");
|
|
834
790
|
const { cfg: next, removed } = withoutHostedMcpEntry(cfg, apiBase, apiKey);
|
|
835
791
|
return { cfg: next, changes: removed ? ["removed mcp.servers.agentchat"] : [] };
|
|
836
792
|
}
|
|
837
|
-
function
|
|
793
|
+
function removeIntegrationFiles(cfg, accountId, options) {
|
|
838
794
|
const changes = [];
|
|
839
795
|
try {
|
|
840
796
|
const removed = agentsAnchor_js.removeAgentsAnchor({ cfg, agentId: resolvePlacementAgentId(cfg, accountId) });
|
|
@@ -850,23 +806,38 @@ function removeDoorbellFiles(cfg, accountId, options) {
|
|
|
850
806
|
}
|
|
851
807
|
return changes;
|
|
852
808
|
}
|
|
853
|
-
function restoreIdentityLine(cfg, accountId, handle) {
|
|
809
|
+
function restoreIdentityLine(cfg, accountId, handle, identityLine) {
|
|
854
810
|
const agentId = resolvePlacementAgentId(cfg, accountId);
|
|
855
811
|
const bare = handle.trim().replace(/^@/, "");
|
|
856
812
|
let filePath = "";
|
|
857
813
|
try {
|
|
858
814
|
filePath = agentsAnchor_js.agentsAnchorPath(cfg, agentId);
|
|
859
815
|
if (!isValidHandleShape(bare)) return { outcome: "failed", path: filePath, detail: `agentHandle "${bare}" is not a valid AgentChat handle` };
|
|
860
|
-
|
|
816
|
+
if (identityLine === null) {
|
|
817
|
+
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" };
|
|
818
|
+
}
|
|
819
|
+
const present = agentsAnchor_js.hasAgentsAnchorFor({ cfg, handle: bare, text: identityLine, agentId });
|
|
861
820
|
filePath = present.path;
|
|
862
821
|
if (present.present) return { outcome: "present", path: present.path };
|
|
863
|
-
const written = agentsAnchor_js.writeAgentsAnchor({ cfg, handle: bare, agentId });
|
|
822
|
+
const written = agentsAnchor_js.writeAgentsAnchor({ cfg, handle: bare, text: identityLine, agentId });
|
|
864
823
|
return { outcome: "placed", path: written.path };
|
|
865
824
|
} catch (err) {
|
|
866
825
|
return { outcome: "failed", path: filePath, detail: describe(err) };
|
|
867
826
|
}
|
|
868
827
|
}
|
|
869
|
-
function
|
|
828
|
+
function refreshIdentityLine(cfg, accountId, handle, identityLine) {
|
|
829
|
+
const agentId = resolvePlacementAgentId(cfg, accountId);
|
|
830
|
+
try {
|
|
831
|
+
const found = agentsAnchor_js.readAgentsAnchor({ cfg, agentId });
|
|
832
|
+
if (!found.present) return { outcome: "absent", path: found.path };
|
|
833
|
+
if (found.text === identityLine.trim()) return { outcome: "unchanged", path: found.path };
|
|
834
|
+
const written = agentsAnchor_js.writeAgentsAnchor({ cfg, handle, text: identityLine, agentId });
|
|
835
|
+
return { outcome: "updated", path: written.path };
|
|
836
|
+
} catch (err) {
|
|
837
|
+
return { outcome: "failed", path: agentsAnchor_js.agentsAnchorPath(cfg, agentId), detail: describe(err) };
|
|
838
|
+
}
|
|
839
|
+
}
|
|
840
|
+
function placeIntegration(params) {
|
|
870
841
|
const steps = [];
|
|
871
842
|
if (params.placeKey !== false) {
|
|
872
843
|
try {
|
|
@@ -881,11 +852,20 @@ function placeDoorbell(params) {
|
|
|
881
852
|
}
|
|
882
853
|
}
|
|
883
854
|
const agentId = params.agentId ?? resolvePlacementAgentId(params.cfg, params.accountId ?? AGENTCHAT_DEFAULT_ACCOUNT_ID);
|
|
884
|
-
|
|
885
|
-
|
|
886
|
-
steps.push({
|
|
887
|
-
|
|
888
|
-
|
|
855
|
+
const handle = params.handle.replace(/^@/, "");
|
|
856
|
+
if (params.identityLine === null) {
|
|
857
|
+
steps.push({
|
|
858
|
+
name: "anchor",
|
|
859
|
+
status: "skipped",
|
|
860
|
+
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`
|
|
861
|
+
});
|
|
862
|
+
} else {
|
|
863
|
+
try {
|
|
864
|
+
const anchor = agentsAnchor_js.writeAgentsAnchor({ cfg: params.cfg, handle: params.handle, text: params.identityLine, agentId });
|
|
865
|
+
steps.push({ name: "anchor", status: "ok", detail: `identity line for @${handle} in ${anchor.path}` });
|
|
866
|
+
} catch (err) {
|
|
867
|
+
steps.push({ name: "anchor", status: "failed", detail: `could not write the identity line to AGENTS.md: ${describe(err)}` });
|
|
868
|
+
}
|
|
889
869
|
}
|
|
890
870
|
steps.push({ name: "manual", status: "ok", detail: "manual bundled as the agentchat skill (skills/agentchat/SKILL.md, https://agentchat.me/skill.md verbatim)" });
|
|
891
871
|
const mcp = withHostedMcpEntry(params.cfg, params.apiBase, params.apiKey);
|
|
@@ -927,7 +907,7 @@ function checkPlacement(params) {
|
|
|
927
907
|
checks.push({ name: "key", ok: false, detail: `${readEnv_js.API_KEY_ENV} is not placed \u2014 the hosted tools cannot authenticate; ${remedy("run openclaw channels add agentchat")}` });
|
|
928
908
|
}
|
|
929
909
|
if (params.handle) {
|
|
930
|
-
const anchor = agentsAnchor_js.hasAgentsAnchorFor({ cfg: params.cfg, handle: params.handle, agentId: params.agentId });
|
|
910
|
+
const anchor = agentsAnchor_js.hasAgentsAnchorFor({ cfg: params.cfg, handle: params.handle, text: params.identityLine, agentId: params.agentId });
|
|
931
911
|
checks.push({
|
|
932
912
|
name: "anchor",
|
|
933
913
|
ok: anchor.present,
|
|
@@ -948,6 +928,266 @@ function checkPlacement(params) {
|
|
|
948
928
|
function describe(err) {
|
|
949
929
|
return err instanceof Error ? err.message : String(err);
|
|
950
930
|
}
|
|
931
|
+
var PLUGIN_STATE_DIRNAME = "agentchat";
|
|
932
|
+
function safeSegment(value) {
|
|
933
|
+
const clean = value.replace(/[^A-Za-z0-9_.-]/g, "-").replace(/^\.+/, "");
|
|
934
|
+
return clean.length > 0 ? clean : "default";
|
|
935
|
+
}
|
|
936
|
+
function integrationStateDir(accountId, stateDir = openclawLayout_js.resolveOpenClawStateDir()) {
|
|
937
|
+
return path2__namespace.join(stateDir, PLUGIN_STATE_DIRNAME, safeSegment(accountId));
|
|
938
|
+
}
|
|
939
|
+
function readJsonFile(file) {
|
|
940
|
+
let raw;
|
|
941
|
+
try {
|
|
942
|
+
raw = fs__namespace.readFileSync(file, "utf8");
|
|
943
|
+
} catch {
|
|
944
|
+
return null;
|
|
945
|
+
}
|
|
946
|
+
try {
|
|
947
|
+
return JSON.parse(raw);
|
|
948
|
+
} catch {
|
|
949
|
+
return null;
|
|
950
|
+
}
|
|
951
|
+
}
|
|
952
|
+
function writeJsonFile(file, value) {
|
|
953
|
+
fs__namespace.mkdirSync(path2__namespace.dirname(file), { recursive: true });
|
|
954
|
+
const tmp = `${file}.${process.pid}.${Date.now().toString(36)}.tmp`;
|
|
955
|
+
fs__namespace.writeFileSync(tmp, `${JSON.stringify(value, null, 2)}
|
|
956
|
+
`, "utf8");
|
|
957
|
+
try {
|
|
958
|
+
fs__namespace.renameSync(tmp, file);
|
|
959
|
+
} catch (err) {
|
|
960
|
+
try {
|
|
961
|
+
fs__namespace.unlinkSync(tmp);
|
|
962
|
+
} catch {
|
|
963
|
+
}
|
|
964
|
+
throw err;
|
|
965
|
+
}
|
|
966
|
+
}
|
|
967
|
+
|
|
968
|
+
// src/integration/texts.ts
|
|
969
|
+
var TEXTS_RUNTIME = "openclaw";
|
|
970
|
+
var TEXTS_REFRESH_MS = 24 * 60 * 6e4;
|
|
971
|
+
var TEXTS_RETRY_MS = 5 * 6e4;
|
|
972
|
+
var TEXTS_FETCH_TIMEOUT_MS = 1e4;
|
|
973
|
+
var TEXTS_CACHE_FILE = "texts.json";
|
|
974
|
+
function isTexts(value) {
|
|
975
|
+
if (!value || typeof value !== "object" || Array.isArray(value)) return false;
|
|
976
|
+
const t = value;
|
|
977
|
+
const manual = t.manual;
|
|
978
|
+
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";
|
|
979
|
+
}
|
|
980
|
+
function textsCachePath(accountId, stateDir) {
|
|
981
|
+
return path2__namespace.join(integrationStateDir(accountId, stateDir), TEXTS_CACHE_FILE);
|
|
982
|
+
}
|
|
983
|
+
function readCachedTexts(accountId, stateDir) {
|
|
984
|
+
const raw = readJsonFile(textsCachePath(accountId, stateDir));
|
|
985
|
+
if (!raw || typeof raw !== "object") return null;
|
|
986
|
+
const entry = raw;
|
|
987
|
+
if (typeof entry.fetched_at !== "string" || !isTexts(entry.texts)) return null;
|
|
988
|
+
return { fetched_at: entry.fetched_at, texts: entry.texts };
|
|
989
|
+
}
|
|
990
|
+
function writeCachedTexts(accountId, texts, fetchedAt, stateDir) {
|
|
991
|
+
const file = textsCachePath(accountId, stateDir);
|
|
992
|
+
const entry = { fetched_at: fetchedAt.toISOString(), texts };
|
|
993
|
+
writeJsonFile(file, entry);
|
|
994
|
+
return file;
|
|
995
|
+
}
|
|
996
|
+
function spellTextsForOpenClaw(texts) {
|
|
997
|
+
return {
|
|
998
|
+
...texts,
|
|
999
|
+
wake_instruction: spellToolsForOpenClaw(texts.wake_instruction),
|
|
1000
|
+
invite_prompt: spellToolsForOpenClaw(texts.invite_prompt),
|
|
1001
|
+
identity_line: spellToolsForOpenClaw(texts.identity_line),
|
|
1002
|
+
identity_line_template: spellToolsForOpenClaw(texts.identity_line_template)
|
|
1003
|
+
};
|
|
1004
|
+
}
|
|
1005
|
+
async function fetchTexts(client, timeoutMs = TEXTS_FETCH_TIMEOUT_MS) {
|
|
1006
|
+
const texts = await client.texts.get({ runtime: TEXTS_RUNTIME, timeoutMs });
|
|
1007
|
+
if (!isTexts(texts)) throw new Error("GET /v1/texts: answer is not a texts set (missing wake_instruction, invite_prompt or identity_line)");
|
|
1008
|
+
return texts;
|
|
1009
|
+
}
|
|
1010
|
+
async function loadTexts(params) {
|
|
1011
|
+
const now = params.now ?? Date.now;
|
|
1012
|
+
try {
|
|
1013
|
+
const texts = await fetchTexts(params.client, params.timeoutMs);
|
|
1014
|
+
const fetchedAt = new Date(now());
|
|
1015
|
+
try {
|
|
1016
|
+
writeCachedTexts(params.accountId, texts, fetchedAt, params.stateDir);
|
|
1017
|
+
} catch (err) {
|
|
1018
|
+
params.log?.warn({ err: describe2(err) }, "texts fetched but the cache could not be written");
|
|
1019
|
+
}
|
|
1020
|
+
return { texts: spellTextsForOpenClaw(texts), source: "server", fetchedAt: fetchedAt.toISOString() };
|
|
1021
|
+
} catch (err) {
|
|
1022
|
+
const cached = readCachedTexts(params.accountId, params.stateDir);
|
|
1023
|
+
if (cached) {
|
|
1024
|
+
params.log?.info({ err: describe2(err), fetchedAt: cached.fetched_at }, "texts: server unreachable \u2014 using the cached copy");
|
|
1025
|
+
return { texts: spellTextsForOpenClaw(cached.texts), source: "cache", fetchedAt: cached.fetched_at };
|
|
1026
|
+
}
|
|
1027
|
+
params.log?.debug({ err: describe2(err) }, "texts: server unreachable and nothing cached");
|
|
1028
|
+
return null;
|
|
1029
|
+
}
|
|
1030
|
+
}
|
|
1031
|
+
async function loadIdentityLine(params) {
|
|
1032
|
+
const loaded = await loadTexts(params);
|
|
1033
|
+
return loaded ? loaded.texts.identity_line : null;
|
|
1034
|
+
}
|
|
1035
|
+
function cachedIdentityLine(accountId, stateDir) {
|
|
1036
|
+
const cached = readCachedTexts(accountId, stateDir);
|
|
1037
|
+
return cached ? spellToolsForOpenClaw(cached.texts.identity_line) : null;
|
|
1038
|
+
}
|
|
1039
|
+
var TextsStore = class {
|
|
1040
|
+
client;
|
|
1041
|
+
accountId;
|
|
1042
|
+
logger;
|
|
1043
|
+
stateDir;
|
|
1044
|
+
refreshMs;
|
|
1045
|
+
retryMs;
|
|
1046
|
+
fetchTimeoutMs;
|
|
1047
|
+
now;
|
|
1048
|
+
_setTimeout;
|
|
1049
|
+
_clearTimeout;
|
|
1050
|
+
loaded = null;
|
|
1051
|
+
timer = null;
|
|
1052
|
+
inFlight = null;
|
|
1053
|
+
stopped = false;
|
|
1054
|
+
missingAnnounced = false;
|
|
1055
|
+
listeners = /* @__PURE__ */ new Set();
|
|
1056
|
+
loads = 0;
|
|
1057
|
+
serverLoads = 0;
|
|
1058
|
+
constructor(options) {
|
|
1059
|
+
this.client = options.client;
|
|
1060
|
+
this.accountId = options.accountId;
|
|
1061
|
+
this.logger = options.logger.child({ component: "texts", accountId: options.accountId });
|
|
1062
|
+
this.stateDir = options.stateDir;
|
|
1063
|
+
this.refreshMs = options.refreshMs ?? TEXTS_REFRESH_MS;
|
|
1064
|
+
this.retryMs = options.retryMs ?? TEXTS_RETRY_MS;
|
|
1065
|
+
this.fetchTimeoutMs = options.fetchTimeoutMs ?? TEXTS_FETCH_TIMEOUT_MS;
|
|
1066
|
+
this.now = options.now ?? Date.now;
|
|
1067
|
+
this._setTimeout = options.setTimeout ?? ((fn, ms) => setTimeout(fn, ms));
|
|
1068
|
+
this._clearTimeout = options.clearTimeout ?? ((h) => clearTimeout(h));
|
|
1069
|
+
}
|
|
1070
|
+
/** The texts spelled for OpenClaw, or null until the first copy exists. */
|
|
1071
|
+
get current() {
|
|
1072
|
+
return this.loaded?.texts ?? null;
|
|
1073
|
+
}
|
|
1074
|
+
get source() {
|
|
1075
|
+
return this.loaded?.source ?? null;
|
|
1076
|
+
}
|
|
1077
|
+
get fetchedAt() {
|
|
1078
|
+
return this.loaded?.fetchedAt ?? null;
|
|
1079
|
+
}
|
|
1080
|
+
/** Called with every copy that arrives from the server (not with a cached one). */
|
|
1081
|
+
onServerCopy(listener) {
|
|
1082
|
+
this.listeners.add(listener);
|
|
1083
|
+
return () => {
|
|
1084
|
+
this.listeners.delete(listener);
|
|
1085
|
+
};
|
|
1086
|
+
}
|
|
1087
|
+
/** First load (server, then cache), then the timer. Resolves after the first attempt; never throws. */
|
|
1088
|
+
async start() {
|
|
1089
|
+
const texts = await this.load();
|
|
1090
|
+
if (!texts && !this.missingAnnounced) {
|
|
1091
|
+
this.missingAnnounced = true;
|
|
1092
|
+
this.logger.warn(
|
|
1093
|
+
{ retryMs: this.retryMs },
|
|
1094
|
+
"AgentChat texts unreachable and nothing cached \u2014 starting anyway; turns wait for the first copy, retried until it arrives"
|
|
1095
|
+
);
|
|
1096
|
+
}
|
|
1097
|
+
this.arm();
|
|
1098
|
+
return texts;
|
|
1099
|
+
}
|
|
1100
|
+
/** The current copy, or one load attempt now (coalesced with any in flight). */
|
|
1101
|
+
async ensure() {
|
|
1102
|
+
if (this.loaded) return this.loaded.texts;
|
|
1103
|
+
if (this.stopped) return null;
|
|
1104
|
+
return this.load();
|
|
1105
|
+
}
|
|
1106
|
+
/** Force a refresh (tests, operators). Coalesced. */
|
|
1107
|
+
refresh() {
|
|
1108
|
+
return this.load();
|
|
1109
|
+
}
|
|
1110
|
+
stop() {
|
|
1111
|
+
this.stopped = true;
|
|
1112
|
+
if (this.timer !== null) {
|
|
1113
|
+
this._clearTimeout(this.timer);
|
|
1114
|
+
this.timer = null;
|
|
1115
|
+
}
|
|
1116
|
+
this.listeners.clear();
|
|
1117
|
+
}
|
|
1118
|
+
load() {
|
|
1119
|
+
if (this.inFlight) return this.inFlight;
|
|
1120
|
+
this.inFlight = (async () => {
|
|
1121
|
+
this.loads += 1;
|
|
1122
|
+
const next = await loadTexts({
|
|
1123
|
+
client: this.client,
|
|
1124
|
+
accountId: this.accountId,
|
|
1125
|
+
stateDir: this.stateDir,
|
|
1126
|
+
now: this.now,
|
|
1127
|
+
log: this.logger,
|
|
1128
|
+
timeoutMs: this.fetchTimeoutMs
|
|
1129
|
+
});
|
|
1130
|
+
if (this.stopped) return next?.texts ?? null;
|
|
1131
|
+
if (next) {
|
|
1132
|
+
const changed = this.loaded?.texts.version !== next.texts.version || this.loaded?.texts.wake_instruction !== next.texts.wake_instruction;
|
|
1133
|
+
this.loaded = next;
|
|
1134
|
+
if (next.source === "server") {
|
|
1135
|
+
this.serverLoads += 1;
|
|
1136
|
+
this.logger[changed ? "info" : "debug"](
|
|
1137
|
+
{ version: next.texts.version, manual: next.texts.manual.version },
|
|
1138
|
+
"texts fetched from the server"
|
|
1139
|
+
);
|
|
1140
|
+
for (const listener of this.listeners) {
|
|
1141
|
+
try {
|
|
1142
|
+
listener(next.texts, next.source);
|
|
1143
|
+
} catch (err) {
|
|
1144
|
+
this.logger.warn({ err: describe2(err) }, "texts listener threw \u2014 continuing");
|
|
1145
|
+
}
|
|
1146
|
+
}
|
|
1147
|
+
}
|
|
1148
|
+
}
|
|
1149
|
+
return next?.texts ?? null;
|
|
1150
|
+
})().finally(() => {
|
|
1151
|
+
this.inFlight = null;
|
|
1152
|
+
});
|
|
1153
|
+
return this.inFlight;
|
|
1154
|
+
}
|
|
1155
|
+
arm() {
|
|
1156
|
+
if (this.stopped) return;
|
|
1157
|
+
if (this.timer !== null) this._clearTimeout(this.timer);
|
|
1158
|
+
const delay = this.loaded === null ? this.retryMs : this.loaded.source === "cache" ? this.retryMs : this.refreshMs;
|
|
1159
|
+
this.timer = this._setTimeout(() => {
|
|
1160
|
+
this.timer = null;
|
|
1161
|
+
void this.load().finally(() => this.arm());
|
|
1162
|
+
}, delay);
|
|
1163
|
+
this.timer.unref?.();
|
|
1164
|
+
}
|
|
1165
|
+
};
|
|
1166
|
+
function describe2(err) {
|
|
1167
|
+
return err instanceof Error ? err.message : String(err);
|
|
1168
|
+
}
|
|
1169
|
+
var cache = /* @__PURE__ */ new Map();
|
|
1170
|
+
function createSdkClient(params) {
|
|
1171
|
+
return new agentchatme.AgentChatClient({
|
|
1172
|
+
apiKey: params.apiKey,
|
|
1173
|
+
...params.apiBase ? { baseUrl: params.apiBase } : {},
|
|
1174
|
+
clientIdentity: AGENTCHAT_CLIENT_IDENTITY,
|
|
1175
|
+
...params.options
|
|
1176
|
+
});
|
|
1177
|
+
}
|
|
1178
|
+
function getClient({ accountId, config, options }) {
|
|
1179
|
+
const existing = cache.get(accountId);
|
|
1180
|
+
if (existing && existing.apiKey === config.apiKey && existing.apiBase === config.apiBase) {
|
|
1181
|
+
return existing.client;
|
|
1182
|
+
}
|
|
1183
|
+
const client = createSdkClient({ apiKey: config.apiKey, apiBase: config.apiBase, options });
|
|
1184
|
+
cache.set(accountId, {
|
|
1185
|
+
client,
|
|
1186
|
+
apiKey: config.apiKey,
|
|
1187
|
+
apiBase: config.apiBase
|
|
1188
|
+
});
|
|
1189
|
+
return client;
|
|
1190
|
+
}
|
|
951
1191
|
|
|
952
1192
|
// src/channel.wizard.ts
|
|
953
1193
|
var JUST_REGISTERED_SENTINEL = "_agentchatJustRegistered";
|
|
@@ -1618,18 +1858,22 @@ var agentchatSetupWizard = {
|
|
|
1618
1858
|
if (result.ok) {
|
|
1619
1859
|
spinner.stop(`Authenticated as @${result.agent.handle}`);
|
|
1620
1860
|
const handle = result.agent.handle;
|
|
1621
|
-
const
|
|
1861
|
+
const resolvedBase = apiBase ?? DEFAULT_API_BASE2;
|
|
1862
|
+
const identityLine = await loadIdentityLine({ client: createSdkClient({ apiKey, apiBase: resolvedBase }), accountId });
|
|
1863
|
+
const placed = placeIntegration({ cfg, handle, apiKey, apiBase: resolvedBase, identityLine, accountId });
|
|
1622
1864
|
const failed = placed.steps.filter((s) => s.status === "failed");
|
|
1865
|
+
const skipped = placed.steps.filter((s) => s.status === "skipped" && s.name === "anchor");
|
|
1623
1866
|
await prompter.note(
|
|
1624
1867
|
[
|
|
1625
1868
|
...formatPlacement(placed.steps),
|
|
1626
1869
|
"",
|
|
1627
|
-
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
|
|
1628
|
-
...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."] : []
|
|
1870
|
+
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.",
|
|
1871
|
+
...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."] : [],
|
|
1872
|
+
...skipped.length > 0 ? ["", "The identity line waits for AgentChat to be reachable: run `openclaw doctor --fix` then."] : []
|
|
1629
1873
|
].join("\n"),
|
|
1630
|
-
"AgentChat
|
|
1874
|
+
"AgentChat integration placed"
|
|
1631
1875
|
);
|
|
1632
|
-
const applied =
|
|
1876
|
+
const applied = applyIntegrationConfig(placed.cfg, { accountId, handle, apiKey, apiBase: resolvedBase });
|
|
1633
1877
|
return { cfg: applied.cfg };
|
|
1634
1878
|
}
|
|
1635
1879
|
spinner.stop(`API key did not pass the live check (${result.reason})`);
|
|
@@ -1678,7 +1922,7 @@ var agentchatSetupWizard = {
|
|
|
1678
1922
|
// when the user explicitly removes the channel; orphans are documented in
|
|
1679
1923
|
// RUNBOOK.md.
|
|
1680
1924
|
disable: (cfg) => {
|
|
1681
|
-
return setup.setSetupChannelEnabled(
|
|
1925
|
+
return setup.setSetupChannelEnabled(stripIntegrationConfig(cfg, "default").cfg, AGENTCHAT_CHANNEL_ID, false);
|
|
1682
1926
|
}
|
|
1683
1927
|
};
|
|
1684
1928
|
var reconnectConfigSchema = zod.z.object({
|
|
@@ -1767,741 +2011,282 @@ function wrapPino(p) {
|
|
|
1767
2011
|
// src/metrics.ts
|
|
1768
2012
|
function createNoopMetrics() {
|
|
1769
2013
|
return {
|
|
1770
|
-
|
|
2014
|
+
incDisconnect: () => void 0,
|
|
1771
2015
|
incError: () => void 0,
|
|
1772
2016
|
setConnectionState: () => void 0,
|
|
1773
|
-
|
|
2017
|
+
incWake: () => void 0
|
|
1774
2018
|
};
|
|
1775
2019
|
}
|
|
1776
|
-
|
|
1777
|
-
|
|
1778
|
-
|
|
1779
|
-
|
|
1780
|
-
|
|
1781
|
-
|
|
1782
|
-
|
|
1783
|
-
|
|
1784
|
-
|
|
1785
|
-
|
|
1786
|
-
|
|
1787
|
-
|
|
1788
|
-
case "CONNECTING": {
|
|
1789
|
-
if (event.type === "SOCKET_OPEN") return { kind: "AUTHENTICATING", startedAt: event.now };
|
|
1790
|
-
if (event.type === "SOCKET_CLOSED") return { kind: "DISCONNECTED" };
|
|
1791
|
-
if (event.type === "AUTH_REJECTED") return { kind: "AUTH_FAIL", reason: event.reason };
|
|
1792
|
-
if (event.type === "DRAIN_REQUESTED") return { kind: "CLOSED" };
|
|
1793
|
-
return state;
|
|
1794
|
-
}
|
|
1795
|
-
case "AUTHENTICATING": {
|
|
1796
|
-
if (event.type === "HELLO_OK") return { kind: "READY", connectedAt: event.now };
|
|
1797
|
-
if (event.type === "AUTH_REJECTED") return { kind: "AUTH_FAIL", reason: event.reason };
|
|
1798
|
-
if (event.type === "SOCKET_CLOSED") return { kind: "DISCONNECTED" };
|
|
1799
|
-
if (event.type === "DRAIN_REQUESTED") return { kind: "CLOSED" };
|
|
1800
|
-
return state;
|
|
1801
|
-
}
|
|
1802
|
-
case "READY": {
|
|
1803
|
-
if (event.type === "PING_TIMEOUT") {
|
|
1804
|
-
return { kind: "DEGRADED", since: event.now, reason: "ping-timeout" };
|
|
1805
|
-
}
|
|
1806
|
-
if (event.type === "BACKPRESSURE") {
|
|
1807
|
-
return { kind: "DEGRADED", since: event.now, reason: event.reason };
|
|
1808
|
-
}
|
|
1809
|
-
if (event.type === "SOCKET_CLOSED") return { kind: "DISCONNECTED" };
|
|
1810
|
-
if (event.type === "AUTH_REJECTED") return { kind: "AUTH_FAIL", reason: event.reason };
|
|
1811
|
-
if (event.type === "DRAIN_REQUESTED") {
|
|
1812
|
-
return { kind: "DRAINING", since: event.now, deadline: event.deadline };
|
|
1813
|
-
}
|
|
1814
|
-
return state;
|
|
1815
|
-
}
|
|
1816
|
-
case "DEGRADED": {
|
|
1817
|
-
if (event.type === "RECOVERED") return { kind: "READY", connectedAt: event.now };
|
|
1818
|
-
if (event.type === "SOCKET_CLOSED") return { kind: "DISCONNECTED" };
|
|
1819
|
-
if (event.type === "AUTH_REJECTED") return { kind: "AUTH_FAIL", reason: event.reason };
|
|
1820
|
-
if (event.type === "DRAIN_REQUESTED") {
|
|
1821
|
-
return { kind: "DRAINING", since: event.now, deadline: event.deadline };
|
|
1822
|
-
}
|
|
1823
|
-
return state;
|
|
1824
|
-
}
|
|
1825
|
-
case "DRAINING": {
|
|
1826
|
-
if (event.type === "DRAIN_COMPLETED") return { kind: "CLOSED" };
|
|
1827
|
-
if (event.type === "SOCKET_CLOSED") return { kind: "CLOSED" };
|
|
1828
|
-
return state;
|
|
1829
|
-
}
|
|
1830
|
-
case "AUTH_FAIL": {
|
|
1831
|
-
if (event.type === "RECONFIGURED") return { kind: "DISCONNECTED" };
|
|
1832
|
-
if (event.type === "DRAIN_REQUESTED") return { kind: "CLOSED" };
|
|
1833
|
-
return state;
|
|
1834
|
-
}
|
|
1835
|
-
case "CLOSED": {
|
|
1836
|
-
return state;
|
|
1837
|
-
}
|
|
1838
|
-
}
|
|
2020
|
+
function groupInviteFromRecord(record) {
|
|
2021
|
+
if (!record || typeof record !== "object" || Array.isArray(record)) return null;
|
|
2022
|
+
const row = record;
|
|
2023
|
+
const inviteId = str(row.id);
|
|
2024
|
+
const groupId = str(row.group_id);
|
|
2025
|
+
if (!inviteId || !groupId) return null;
|
|
2026
|
+
return {
|
|
2027
|
+
inviteId,
|
|
2028
|
+
groupId,
|
|
2029
|
+
groupName: str(row.group_name) ?? "",
|
|
2030
|
+
inviterHandle: (str(row.inviter_handle) ?? "").replace(/^@/, "")
|
|
2031
|
+
};
|
|
1839
2032
|
}
|
|
1840
|
-
function
|
|
1841
|
-
return
|
|
2033
|
+
function str(value) {
|
|
2034
|
+
return typeof value === "string" && value.length > 0 ? value : void 0;
|
|
1842
2035
|
}
|
|
1843
|
-
|
|
1844
|
-
|
|
1845
|
-
|
|
1846
|
-
|
|
1847
|
-
|
|
1848
|
-
var
|
|
1849
|
-
|
|
1850
|
-
var AgentchatWsClient = class {
|
|
1851
|
-
config;
|
|
1852
|
-
logger;
|
|
1853
|
-
metrics;
|
|
2036
|
+
var INVITE_LEDGER_FILE = "invites.json";
|
|
2037
|
+
var INVITE_LEDGER_MAX_AGE_MS = 30 * 24 * 60 * 6e4;
|
|
2038
|
+
function inviteLedgerPath(accountId, stateDir) {
|
|
2039
|
+
return path2__namespace.join(integrationStateDir(accountId, stateDir), INVITE_LEDGER_FILE);
|
|
2040
|
+
}
|
|
2041
|
+
var InviteLedger = class {
|
|
2042
|
+
file;
|
|
1854
2043
|
now;
|
|
1855
|
-
|
|
1856
|
-
|
|
1857
|
-
|
|
1858
|
-
_clearTimeout;
|
|
1859
|
-
_setInterval;
|
|
1860
|
-
_clearInterval;
|
|
1861
|
-
state = { kind: "DISCONNECTED" };
|
|
1862
|
-
ws = null;
|
|
1863
|
-
attempt = 0;
|
|
1864
|
-
_ackNegotiated = false;
|
|
1865
|
-
helloAckTimer = null;
|
|
1866
|
-
pingTimer = null;
|
|
1867
|
-
pongTimer = null;
|
|
1868
|
-
reconnectTimer = null;
|
|
1869
|
-
drainTimer = null;
|
|
1870
|
-
listeners = {
|
|
1871
|
-
stateChanged: /* @__PURE__ */ new Set(),
|
|
1872
|
-
inboundFrame: /* @__PURE__ */ new Set(),
|
|
1873
|
-
error: /* @__PURE__ */ new Set(),
|
|
1874
|
-
authenticated: /* @__PURE__ */ new Set(),
|
|
1875
|
-
closed: /* @__PURE__ */ new Set()
|
|
1876
|
-
};
|
|
2044
|
+
maxAgeMs;
|
|
2045
|
+
onWriteError;
|
|
2046
|
+
offered;
|
|
1877
2047
|
constructor(options) {
|
|
1878
|
-
this.
|
|
1879
|
-
this.logger = options.logger.child({ component: "ws-client" });
|
|
1880
|
-
this.metrics = options.metrics;
|
|
2048
|
+
this.file = options.file ?? inviteLedgerPath(options.accountId, options.stateDir);
|
|
1881
2049
|
this.now = options.now ?? Date.now;
|
|
1882
|
-
this.
|
|
1883
|
-
this.
|
|
1884
|
-
this.
|
|
1885
|
-
this._clearTimeout = options.clearTimeout ?? ((h) => clearTimeout(h));
|
|
1886
|
-
this._setInterval = options.setInterval ?? ((fn, ms) => setInterval(fn, ms));
|
|
1887
|
-
this._clearInterval = options.clearInterval ?? ((h) => clearInterval(h));
|
|
1888
|
-
this.metrics.setConnectionState(this.state.kind);
|
|
1889
|
-
}
|
|
1890
|
-
// ─── Public API ──────────────────────────────────────────────────────
|
|
1891
|
-
/** Current connection state. Read-only from the caller's perspective. */
|
|
1892
|
-
getState() {
|
|
1893
|
-
return this.state;
|
|
1894
|
-
}
|
|
1895
|
-
/**
|
|
1896
|
-
* True when the last `hello.ok` echoed the `ack` capability: the server
|
|
1897
|
-
* keeps envelopes `stored` until acknowledged — and this client never
|
|
1898
|
-
* acknowledges. False against a legacy server (envelopes marked on push).
|
|
1899
|
-
*/
|
|
1900
|
-
get ackNegotiated() {
|
|
1901
|
-
return this._ackNegotiated;
|
|
1902
|
-
}
|
|
1903
|
-
/**
|
|
1904
|
-
* Kick off connection. No-op if already connecting, authenticating, or
|
|
1905
|
-
* ready. Throws on `AUTH_FAIL` — the caller must call `reconfigured()`
|
|
1906
|
-
* after rotating the API key before retrying.
|
|
1907
|
-
*/
|
|
1908
|
-
start() {
|
|
1909
|
-
if (this.state.kind === "AUTH_FAIL") {
|
|
1910
|
-
throw new AgentChatChannelError(
|
|
1911
|
-
"terminal-auth",
|
|
1912
|
-
"cannot start: channel is in AUTH_FAIL \u2014 rotate api key and call reconfigured()"
|
|
1913
|
-
);
|
|
1914
|
-
}
|
|
1915
|
-
if (this.state.kind === "CLOSED") {
|
|
1916
|
-
throw new Error("cannot start: client is closed. Create a new instance.");
|
|
1917
|
-
}
|
|
1918
|
-
if (this.state.kind !== "DISCONNECTED") {
|
|
1919
|
-
return;
|
|
1920
|
-
}
|
|
1921
|
-
this.openSocket(1);
|
|
1922
|
-
}
|
|
1923
|
-
/**
|
|
1924
|
-
* Request a graceful drain. The caller-supplied deadline is a Unix-ms
|
|
1925
|
-
* timestamp; after it passes, the socket is force-closed regardless of
|
|
1926
|
-
* remaining in-flight work. Safe to call from any state.
|
|
1927
|
-
*/
|
|
1928
|
-
stop(deadline) {
|
|
1929
|
-
const now = this.now();
|
|
1930
|
-
const computedDeadline = deadline ?? now + 5e3;
|
|
1931
|
-
if (this.state.kind === "DRAINING") {
|
|
1932
|
-
if (computedDeadline < this.state.deadline) {
|
|
1933
|
-
this.applyEvent({ type: "DRAIN_REQUESTED", now, deadline: computedDeadline });
|
|
1934
|
-
this.scheduleDrainDeadline(computedDeadline);
|
|
1935
|
-
}
|
|
1936
|
-
return;
|
|
1937
|
-
}
|
|
1938
|
-
if (isTerminal(this.state)) {
|
|
1939
|
-
return;
|
|
1940
|
-
}
|
|
1941
|
-
this.applyEvent({ type: "DRAIN_REQUESTED", now, deadline: computedDeadline });
|
|
1942
|
-
const after = this.state.kind;
|
|
1943
|
-
if (after === "DRAINING") {
|
|
1944
|
-
this.scheduleDrainDeadline(computedDeadline);
|
|
1945
|
-
} else if (after === "CLOSED") {
|
|
1946
|
-
this.closeSocket(1e3, "client drain (immediate)");
|
|
1947
|
-
this.emit("closed");
|
|
1948
|
-
}
|
|
1949
|
-
}
|
|
1950
|
-
/**
|
|
1951
|
-
* Signal that operator has rotated the API key. Transitions from
|
|
1952
|
-
* AUTH_FAIL back to DISCONNECTED; the next `start()` call will attempt
|
|
1953
|
-
* a fresh HELLO with the current config.
|
|
1954
|
-
*/
|
|
1955
|
-
reconfigured() {
|
|
1956
|
-
if (this.state.kind !== "AUTH_FAIL") return;
|
|
1957
|
-
this.applyEvent({ type: "RECONFIGURED" });
|
|
1958
|
-
}
|
|
1959
|
-
on(event, handler) {
|
|
1960
|
-
this.listeners[event].add(handler);
|
|
1961
|
-
return () => {
|
|
1962
|
-
this.listeners[event].delete(handler);
|
|
1963
|
-
};
|
|
1964
|
-
}
|
|
1965
|
-
// ─── Internals: socket lifecycle ─────────────────────────────────────
|
|
1966
|
-
openSocket(attempt) {
|
|
1967
|
-
this.attempt = attempt;
|
|
1968
|
-
const now = this.now();
|
|
1969
|
-
this.applyEvent({ type: "CONNECT", now, attempt });
|
|
1970
|
-
const url = `${this.config.apiBase.replace(/^http/, "ws")}/v1/ws`;
|
|
1971
|
-
let ws;
|
|
1972
|
-
try {
|
|
1973
|
-
ws = new this.WebSocketCtor(url, {
|
|
1974
|
-
perMessageDeflate: false,
|
|
1975
|
-
// `ws` auto-pong is on by default — we keep it so heartbeat RTT
|
|
1976
|
-
// is symmetric even when the server initiates the ping.
|
|
1977
|
-
maxPayload: MAX_FRAME_BYTES
|
|
1978
|
-
});
|
|
1979
|
-
} catch (err) {
|
|
1980
|
-
this.emitError(
|
|
1981
|
-
new AgentChatChannelError(
|
|
1982
|
-
classifyNetworkError(err),
|
|
1983
|
-
"ws constructor threw",
|
|
1984
|
-
{ cause: err }
|
|
1985
|
-
)
|
|
1986
|
-
);
|
|
1987
|
-
this.scheduleReconnect("ctor-failed");
|
|
1988
|
-
return;
|
|
1989
|
-
}
|
|
1990
|
-
this.ws = ws;
|
|
1991
|
-
this.bindSocket(ws);
|
|
1992
|
-
}
|
|
1993
|
-
bindSocket(ws) {
|
|
1994
|
-
ws.on("open", () => this.handleOpen());
|
|
1995
|
-
ws.on("message", (data, isBinary) => this.handleMessage(data, isBinary));
|
|
1996
|
-
ws.on("pong", () => this.handlePong());
|
|
1997
|
-
ws.on("close", (code, reason) => this.handleClose(code, reason.toString()));
|
|
1998
|
-
ws.on("error", (err) => {
|
|
1999
|
-
this.emitError(
|
|
2000
|
-
new AgentChatChannelError(
|
|
2001
|
-
classifyNetworkError(err),
|
|
2002
|
-
"ws transport error",
|
|
2003
|
-
{ cause: err }
|
|
2004
|
-
)
|
|
2005
|
-
);
|
|
2006
|
-
});
|
|
2007
|
-
}
|
|
2008
|
-
handleOpen() {
|
|
2009
|
-
if (!this.ws) return;
|
|
2010
|
-
const now = this.now();
|
|
2011
|
-
this.applyEvent({ type: "SOCKET_OPEN", now });
|
|
2012
|
-
try {
|
|
2013
|
-
this.ws.send(
|
|
2014
|
-
JSON.stringify({
|
|
2015
|
-
type: "hello",
|
|
2016
|
-
api_key: this.config.apiKey,
|
|
2017
|
-
client: AGENTCHAT_CLIENT_NAME,
|
|
2018
|
-
client_version: PACKAGE_VERSION,
|
|
2019
|
-
capabilities: HELLO_CAPABILITIES
|
|
2020
|
-
})
|
|
2021
|
-
);
|
|
2022
|
-
} catch (err) {
|
|
2023
|
-
this.emitError(
|
|
2024
|
-
new AgentChatChannelError(
|
|
2025
|
-
"retry-transient",
|
|
2026
|
-
"hello send failed",
|
|
2027
|
-
{ cause: err }
|
|
2028
|
-
)
|
|
2029
|
-
);
|
|
2030
|
-
this.closeSocket(1011, "hello send failed");
|
|
2031
|
-
return;
|
|
2032
|
-
}
|
|
2033
|
-
this.helloAckTimer = this._setTimeout(() => {
|
|
2034
|
-
this.helloAckTimer = null;
|
|
2035
|
-
this.logger.warn({ timeoutMs: HELLO_ACK_TIMEOUT_MS }, "hello ack timeout");
|
|
2036
|
-
this.emitError(
|
|
2037
|
-
new AgentChatChannelError("retry-transient", "hello ack timeout")
|
|
2038
|
-
);
|
|
2039
|
-
this.closeSocket(1008, "hello ack timeout");
|
|
2040
|
-
}, HELLO_ACK_TIMEOUT_MS);
|
|
2050
|
+
this.maxAgeMs = options.maxAgeMs ?? INVITE_LEDGER_MAX_AGE_MS;
|
|
2051
|
+
this.onWriteError = options.onWriteError;
|
|
2052
|
+
this.offered = this.read();
|
|
2041
2053
|
}
|
|
2042
|
-
|
|
2043
|
-
|
|
2044
|
-
this.logger.warn({}, "received binary frame \u2014 dropping (text-only protocol)");
|
|
2045
|
-
return;
|
|
2046
|
-
}
|
|
2047
|
-
const received = this.now();
|
|
2048
|
-
const text = typeof data === "string" ? data : Array.isArray(data) ? Buffer.concat(data).toString("utf8") : Buffer.isBuffer(data) ? data.toString("utf8") : Buffer.from(data).toString("utf8");
|
|
2049
|
-
if (text.length > MAX_FRAME_BYTES) {
|
|
2050
|
-
this.logger.warn({ bytes: text.length }, "oversized frame \u2014 dropping");
|
|
2051
|
-
return;
|
|
2052
|
-
}
|
|
2053
|
-
let parsed;
|
|
2054
|
-
try {
|
|
2055
|
-
parsed = JSON.parse(text);
|
|
2056
|
-
} catch (err) {
|
|
2057
|
-
this.emitError(
|
|
2058
|
-
new AgentChatChannelError(
|
|
2059
|
-
"validation",
|
|
2060
|
-
"malformed json frame",
|
|
2061
|
-
{ cause: err }
|
|
2062
|
-
)
|
|
2063
|
-
);
|
|
2064
|
-
return;
|
|
2065
|
-
}
|
|
2066
|
-
if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
|
|
2067
|
-
this.emitError(
|
|
2068
|
-
new AgentChatChannelError("validation", "frame not an object")
|
|
2069
|
-
);
|
|
2070
|
-
return;
|
|
2071
|
-
}
|
|
2072
|
-
const obj = parsed;
|
|
2073
|
-
const type = typeof obj.type === "string" ? obj.type : null;
|
|
2074
|
-
if (!type) {
|
|
2075
|
-
this.emitError(
|
|
2076
|
-
new AgentChatChannelError("validation", "frame missing type")
|
|
2077
|
-
);
|
|
2078
|
-
return;
|
|
2079
|
-
}
|
|
2080
|
-
if (this.state.kind === "AUTHENTICATING") {
|
|
2081
|
-
if (type === "hello.ok") {
|
|
2082
|
-
this.handleHelloOk(received, obj);
|
|
2083
|
-
return;
|
|
2084
|
-
}
|
|
2085
|
-
if (type === "hello.error" || type === "auth.rejected" || type === "error") {
|
|
2086
|
-
const reason = this.extractReason(obj) ?? "auth rejected";
|
|
2087
|
-
this.handleAuthRejected(reason);
|
|
2088
|
-
return;
|
|
2089
|
-
}
|
|
2090
|
-
this.logger.warn({ type }, "frame arrived before hello.ok \u2014 ignoring");
|
|
2091
|
-
return;
|
|
2092
|
-
}
|
|
2093
|
-
const payload = this.extractPayload(obj);
|
|
2094
|
-
this.emit("inboundFrame", {
|
|
2095
|
-
type,
|
|
2096
|
-
payload,
|
|
2097
|
-
receivedAt: received,
|
|
2098
|
-
raw: parsed
|
|
2099
|
-
});
|
|
2100
|
-
}
|
|
2101
|
-
extractReason(obj) {
|
|
2102
|
-
const payload = obj.payload;
|
|
2103
|
-
if (payload && typeof payload === "object") {
|
|
2104
|
-
const msg = payload.message;
|
|
2105
|
-
if (typeof msg === "string") return msg;
|
|
2106
|
-
const reason = payload.reason;
|
|
2107
|
-
if (typeof reason === "string") return reason;
|
|
2108
|
-
}
|
|
2109
|
-
const top = obj.message ?? obj.reason;
|
|
2110
|
-
return typeof top === "string" ? top : void 0;
|
|
2111
|
-
}
|
|
2112
|
-
extractPayload(obj) {
|
|
2113
|
-
const payload = obj.payload;
|
|
2114
|
-
return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
|
|
2115
|
-
}
|
|
2116
|
-
handleHelloOk(now, frame) {
|
|
2117
|
-
if (this.helloAckTimer) {
|
|
2118
|
-
this._clearTimeout(this.helloAckTimer);
|
|
2119
|
-
this.helloAckTimer = null;
|
|
2120
|
-
}
|
|
2121
|
-
const caps = frame.capabilities ?? this.extractPayload(frame).capabilities;
|
|
2122
|
-
this._ackNegotiated = Array.isArray(caps) && caps.includes("ack");
|
|
2123
|
-
this.logger.info({ ackNegotiated: this._ackNegotiated }, "hello.ok");
|
|
2124
|
-
this.applyEvent({ type: "HELLO_OK", now });
|
|
2125
|
-
this.attempt = 0;
|
|
2126
|
-
this.startHeartbeat();
|
|
2127
|
-
this.emit("authenticated", now);
|
|
2128
|
-
}
|
|
2129
|
-
handleAuthRejected(reason) {
|
|
2130
|
-
if (this.helloAckTimer) {
|
|
2131
|
-
this._clearTimeout(this.helloAckTimer);
|
|
2132
|
-
this.helloAckTimer = null;
|
|
2133
|
-
}
|
|
2134
|
-
this.logger.error({ reason }, "auth rejected \u2014 moving to AUTH_FAIL");
|
|
2135
|
-
this.applyEvent({ type: "AUTH_REJECTED", reason });
|
|
2136
|
-
this.emitError(
|
|
2137
|
-
new AgentChatChannelError("terminal-auth", `auth rejected: ${reason}`)
|
|
2138
|
-
);
|
|
2139
|
-
this.closeSocket(1008, "auth rejected");
|
|
2140
|
-
}
|
|
2141
|
-
handleClose(code, reason) {
|
|
2142
|
-
this.now();
|
|
2143
|
-
const wasAuthenticating = this.state.kind === "AUTHENTICATING";
|
|
2144
|
-
const wasDraining = this.state.kind === "DRAINING";
|
|
2145
|
-
const authClass = AUTH_CLOSE_CODES.has(code);
|
|
2146
|
-
this.stopHeartbeat();
|
|
2147
|
-
if (this.helloAckTimer) {
|
|
2148
|
-
this._clearTimeout(this.helloAckTimer);
|
|
2149
|
-
this.helloAckTimer = null;
|
|
2150
|
-
}
|
|
2151
|
-
this.ws = null;
|
|
2152
|
-
this._ackNegotiated = false;
|
|
2153
|
-
if (this.state.kind === "CLOSED") {
|
|
2154
|
-
this.logger.debug({ code, reason }, "socket closed after CLOSED \u2014 no-op");
|
|
2155
|
-
return;
|
|
2156
|
-
}
|
|
2157
|
-
if (authClass && wasAuthenticating) {
|
|
2158
|
-
this.applyEvent({ type: "AUTH_REJECTED", reason: `close ${code}: ${reason}` });
|
|
2159
|
-
this.emitError(
|
|
2160
|
-
new AgentChatChannelError(
|
|
2161
|
-
"terminal-auth",
|
|
2162
|
-
`socket closed with auth code ${code}: ${reason}`
|
|
2163
|
-
)
|
|
2164
|
-
);
|
|
2165
|
-
this.emit("closed");
|
|
2166
|
-
return;
|
|
2167
|
-
}
|
|
2168
|
-
this.applyEvent({ type: "SOCKET_CLOSED", code, reason });
|
|
2169
|
-
if (wasDraining || this.state.kind === "CLOSED") {
|
|
2170
|
-
this.emit("closed");
|
|
2171
|
-
return;
|
|
2172
|
-
}
|
|
2173
|
-
this.logger.info(
|
|
2174
|
-
{ code, reason, attempt: this.attempt },
|
|
2175
|
-
"socket closed \u2014 scheduling reconnect"
|
|
2176
|
-
);
|
|
2177
|
-
this.scheduleReconnect(`close-${code}`);
|
|
2178
|
-
}
|
|
2179
|
-
closeSocket(code, reason) {
|
|
2180
|
-
if (!this.ws) return;
|
|
2181
|
-
try {
|
|
2182
|
-
this.ws.close(code, reason);
|
|
2183
|
-
} catch {
|
|
2184
|
-
}
|
|
2054
|
+
get path() {
|
|
2055
|
+
return this.file;
|
|
2185
2056
|
}
|
|
2186
|
-
|
|
2187
|
-
|
|
2188
|
-
this.stopHeartbeat();
|
|
2189
|
-
const intervalMs = this.config.ping.intervalMs;
|
|
2190
|
-
this.pingTimer = this._setInterval(() => this.sendPing(), intervalMs);
|
|
2057
|
+
get size() {
|
|
2058
|
+
return this.offered.size;
|
|
2191
2059
|
}
|
|
2192
|
-
|
|
2193
|
-
|
|
2194
|
-
|
|
2195
|
-
this.pingTimer = null;
|
|
2196
|
-
}
|
|
2197
|
-
if (this.pongTimer) {
|
|
2198
|
-
this._clearTimeout(this.pongTimer);
|
|
2199
|
-
this.pongTimer = null;
|
|
2200
|
-
}
|
|
2060
|
+
/** True when a turn for this invite was started before (in this process or an earlier one). */
|
|
2061
|
+
isOffered(inviteId) {
|
|
2062
|
+
return this.offered.has(inviteId);
|
|
2201
2063
|
}
|
|
2202
|
-
|
|
2203
|
-
|
|
2064
|
+
/** Record that a turn for this invite was admitted. Persists at once. */
|
|
2065
|
+
markOffered(inviteId) {
|
|
2066
|
+
this.offered.set(inviteId, new Date(this.now()).toISOString());
|
|
2067
|
+
this.prune();
|
|
2204
2068
|
try {
|
|
2205
|
-
this.
|
|
2069
|
+
writeJsonFile(this.file, { offered: Object.fromEntries(this.offered) });
|
|
2206
2070
|
} catch (err) {
|
|
2207
|
-
this.
|
|
2208
|
-
new AgentChatChannelError(
|
|
2209
|
-
"retry-transient",
|
|
2210
|
-
"ws ping failed",
|
|
2211
|
-
{ cause: err }
|
|
2212
|
-
)
|
|
2213
|
-
);
|
|
2214
|
-
return;
|
|
2215
|
-
}
|
|
2216
|
-
const timeoutMs = this.config.ping.timeoutMs;
|
|
2217
|
-
if (this.pongTimer) this._clearTimeout(this.pongTimer);
|
|
2218
|
-
this.pongTimer = this._setTimeout(() => {
|
|
2219
|
-
this.pongTimer = null;
|
|
2220
|
-
const now = this.now();
|
|
2221
|
-
this.logger.warn({ timeoutMs }, "ping timeout \u2014 declaring degraded");
|
|
2222
|
-
this.applyEvent({ type: "PING_TIMEOUT", now });
|
|
2223
|
-
this.closeSocket(1011, "ping timeout");
|
|
2224
|
-
}, timeoutMs);
|
|
2225
|
-
}
|
|
2226
|
-
handlePong() {
|
|
2227
|
-
if (this.pongTimer) {
|
|
2228
|
-
this._clearTimeout(this.pongTimer);
|
|
2229
|
-
this.pongTimer = null;
|
|
2230
|
-
}
|
|
2231
|
-
if (this.state.kind === "DEGRADED" && this.state.reason === "ping-timeout") {
|
|
2232
|
-
this.applyEvent({ type: "RECOVERED", now: this.now() });
|
|
2233
|
-
}
|
|
2234
|
-
}
|
|
2235
|
-
// ─── Internals: reconnect ────────────────────────────────────────────
|
|
2236
|
-
scheduleReconnect(reason) {
|
|
2237
|
-
if (this.state.kind === "CLOSED" || this.state.kind === "AUTH_FAIL") return;
|
|
2238
|
-
if (this.reconnectTimer) return;
|
|
2239
|
-
const nextAttempt = this.attempt + 1;
|
|
2240
|
-
if (nextAttempt > RECONNECT_HARD_CAP_ATTEMPTS) {
|
|
2241
|
-
const msg = `reconnect hard cap (${RECONNECT_HARD_CAP_ATTEMPTS}) reached`;
|
|
2242
|
-
this.logger.error({ attempt: nextAttempt }, msg);
|
|
2243
|
-
this.applyEvent({ type: "AUTH_REJECTED", reason: msg });
|
|
2244
|
-
this.emitError(
|
|
2245
|
-
new AgentChatChannelError("terminal-auth", msg)
|
|
2246
|
-
);
|
|
2247
|
-
return;
|
|
2071
|
+
this.onWriteError?.(err);
|
|
2248
2072
|
}
|
|
2249
|
-
const delay = this.computeReconnectDelay(nextAttempt);
|
|
2250
|
-
this.metrics.incReconnect({ reason });
|
|
2251
|
-
this.logger.info(
|
|
2252
|
-
{ attempt: nextAttempt, delayMs: delay, reason },
|
|
2253
|
-
"scheduling reconnect"
|
|
2254
|
-
);
|
|
2255
|
-
this.reconnectTimer = this._setTimeout(() => {
|
|
2256
|
-
this.reconnectTimer = null;
|
|
2257
|
-
this.openSocket(nextAttempt);
|
|
2258
|
-
}, delay);
|
|
2259
|
-
}
|
|
2260
|
-
computeReconnectDelay(attempt) {
|
|
2261
|
-
const { initialBackoffMs, maxBackoffMs, jitterRatio } = this.config.reconnect;
|
|
2262
|
-
const reconnectCount = Math.max(1, attempt - 1);
|
|
2263
|
-
const exp = initialBackoffMs * Math.pow(2, Math.min(reconnectCount - 1, 20));
|
|
2264
|
-
const capped = Math.min(exp, maxBackoffMs);
|
|
2265
|
-
const jitter = 1 - jitterRatio + this.random() * 2 * jitterRatio;
|
|
2266
|
-
return Math.max(0, Math.floor(capped * jitter));
|
|
2267
|
-
}
|
|
2268
|
-
// ─── Internals: drain ────────────────────────────────────────────────
|
|
2269
|
-
scheduleDrainDeadline(deadline) {
|
|
2270
|
-
if (this.drainTimer) this._clearTimeout(this.drainTimer);
|
|
2271
|
-
const now = this.now();
|
|
2272
|
-
const delay = Math.max(0, deadline - now);
|
|
2273
|
-
this.drainTimer = this._setTimeout(() => {
|
|
2274
|
-
this.drainTimer = null;
|
|
2275
|
-
if (this.state.kind === "DRAINING") {
|
|
2276
|
-
this.logger.warn({ deadline }, "drain deadline exceeded \u2014 force-closing");
|
|
2277
|
-
this.applyEvent({ type: "DRAIN_COMPLETED" });
|
|
2278
|
-
this.closeSocket(1e3, "drain deadline");
|
|
2279
|
-
this.emit("closed");
|
|
2280
|
-
}
|
|
2281
|
-
}, delay);
|
|
2282
2073
|
}
|
|
2283
|
-
|
|
2284
|
-
|
|
2285
|
-
|
|
2286
|
-
|
|
2287
|
-
|
|
2288
|
-
if (
|
|
2289
|
-
|
|
2290
|
-
|
|
2291
|
-
this.drainTimer = null;
|
|
2292
|
-
}
|
|
2293
|
-
this.applyEvent({ type: "DRAIN_COMPLETED" });
|
|
2294
|
-
this.closeSocket(1e3, "drain completed");
|
|
2295
|
-
this.emit("closed");
|
|
2296
|
-
}
|
|
2297
|
-
// ─── Internals: state machine + emit ─────────────────────────────────
|
|
2298
|
-
applyEvent(event) {
|
|
2299
|
-
const prev = this.state;
|
|
2300
|
-
const next = transition(prev, event);
|
|
2301
|
-
if (next === prev) {
|
|
2302
|
-
this.logger.debug(
|
|
2303
|
-
{ from: prev.kind, event: event.type },
|
|
2304
|
-
"transition.invalid"
|
|
2305
|
-
);
|
|
2306
|
-
return;
|
|
2074
|
+
read() {
|
|
2075
|
+
const raw = readJsonFile(this.file);
|
|
2076
|
+
const out = /* @__PURE__ */ new Map();
|
|
2077
|
+
if (!raw || typeof raw !== "object") return out;
|
|
2078
|
+
const offered = raw.offered;
|
|
2079
|
+
if (!offered || typeof offered !== "object" || Array.isArray(offered)) return out;
|
|
2080
|
+
for (const [id, at] of Object.entries(offered)) {
|
|
2081
|
+
if (typeof at === "string" && id.length > 0) out.set(id, at);
|
|
2307
2082
|
}
|
|
2308
|
-
this.
|
|
2309
|
-
this.
|
|
2310
|
-
this.
|
|
2311
|
-
{ from: prev.kind, to: next.kind, event: event.type },
|
|
2312
|
-
"state transition"
|
|
2313
|
-
);
|
|
2314
|
-
this.emit("stateChanged", next, prev);
|
|
2083
|
+
this.offered = out;
|
|
2084
|
+
this.prune();
|
|
2085
|
+
return this.offered;
|
|
2315
2086
|
}
|
|
2316
|
-
|
|
2317
|
-
|
|
2318
|
-
|
|
2319
|
-
|
|
2320
|
-
|
|
2321
|
-
} catch (err) {
|
|
2322
|
-
this.logger.error(
|
|
2323
|
-
{ event, err: err instanceof Error ? err.message : String(err) },
|
|
2324
|
-
"listener threw \u2014 continuing"
|
|
2325
|
-
);
|
|
2326
|
-
}
|
|
2087
|
+
prune() {
|
|
2088
|
+
const cutoff = this.now() - this.maxAgeMs;
|
|
2089
|
+
for (const [id, at] of this.offered) {
|
|
2090
|
+
const t = Date.parse(at);
|
|
2091
|
+
if (!Number.isFinite(t) || t < cutoff) this.offered.delete(id);
|
|
2327
2092
|
}
|
|
2328
2093
|
}
|
|
2329
|
-
emitError(error) {
|
|
2330
|
-
this.metrics.incError({ errorClass: error.class_ });
|
|
2331
|
-
this.logger.warn(
|
|
2332
|
-
{ class: error.class_, message: error.message, statusCode: error.statusCode },
|
|
2333
|
-
"channel error"
|
|
2334
|
-
);
|
|
2335
|
-
this.emit("error", error);
|
|
2336
|
-
}
|
|
2337
2094
|
};
|
|
2338
2095
|
|
|
2339
|
-
// src/
|
|
2340
|
-
function
|
|
2341
|
-
|
|
2342
|
-
const payload = frame.payload;
|
|
2343
|
-
const senderRaw = payload.sender ?? payload.from ?? "";
|
|
2344
|
-
const sender = typeof senderRaw === "string" ? senderRaw.replace(/^@/, "").toLowerCase() : "";
|
|
2345
|
-
return {
|
|
2346
|
-
kind: "message",
|
|
2347
|
-
sender,
|
|
2348
|
-
messageId: str(payload.id) ?? "<no-id>",
|
|
2349
|
-
conversationId: str(payload.conversation_id) ?? "<no-conv>"
|
|
2350
|
-
};
|
|
2351
|
-
}
|
|
2352
|
-
function readGroupInviteKnock(frame) {
|
|
2353
|
-
if (frame.type !== "group.invite.received") return null;
|
|
2354
|
-
return groupInviteFromRecord(frame.payload);
|
|
2096
|
+
// src/integration/socket.ts
|
|
2097
|
+
function wakeSourceOf(reason) {
|
|
2098
|
+
return reason === "reminder" ? "reminder" : "other";
|
|
2355
2099
|
}
|
|
2356
|
-
function
|
|
2357
|
-
if (!record || typeof record !== "object" || Array.isArray(record)) return null;
|
|
2358
|
-
const row = record;
|
|
2359
|
-
const inviteId = str(row.id);
|
|
2360
|
-
const groupId = str(row.group_id);
|
|
2361
|
-
if (!inviteId || !groupId) return null;
|
|
2100
|
+
function realtimeOptionsFor(config, extra = {}) {
|
|
2362
2101
|
return {
|
|
2363
|
-
|
|
2364
|
-
|
|
2365
|
-
|
|
2366
|
-
|
|
2367
|
-
|
|
2102
|
+
apiKey: config.apiKey,
|
|
2103
|
+
baseUrl: config.apiBase.replace(/^http/, "ws").replace(/\/+$/, ""),
|
|
2104
|
+
clientIdentity: AGENTCHAT_CLIENT_IDENTITY,
|
|
2105
|
+
ackOnReceipt: true,
|
|
2106
|
+
reconnect: true,
|
|
2107
|
+
reconnectInterval: config.reconnect.initialBackoffMs,
|
|
2108
|
+
maxReconnectInterval: config.reconnect.maxBackoffMs,
|
|
2109
|
+
...extra.client ? { client: extra.client } : {},
|
|
2110
|
+
...extra.webSocket ? { webSocket: extra.webSocket } : {}
|
|
2368
2111
|
};
|
|
2369
2112
|
}
|
|
2370
|
-
|
|
2371
|
-
return typeof value === "string" && value.length > 0 ? value : void 0;
|
|
2372
|
-
}
|
|
2373
|
-
|
|
2374
|
-
// src/runtime.ts
|
|
2375
|
-
var BACKLOG_WINDOW_MS = 5e3;
|
|
2376
|
-
var AgentchatChannelRuntime = class {
|
|
2113
|
+
var IntegrationSocket = class {
|
|
2377
2114
|
config;
|
|
2378
|
-
handlers;
|
|
2379
2115
|
logger;
|
|
2380
|
-
|
|
2381
|
-
|
|
2116
|
+
handlers;
|
|
2117
|
+
metrics;
|
|
2118
|
+
client;
|
|
2119
|
+
createRealtime;
|
|
2120
|
+
webSocket;
|
|
2382
2121
|
now;
|
|
2383
|
-
|
|
2384
|
-
|
|
2385
|
-
|
|
2122
|
+
selfHandle;
|
|
2123
|
+
realtime = null;
|
|
2124
|
+
/** The SDK's state as last reported through its `state` event; `stopped` is set here only for a stop before any start. */
|
|
2125
|
+
state = "idle";
|
|
2126
|
+
connectedAt = null;
|
|
2127
|
+
stopping = false;
|
|
2386
2128
|
frames = 0;
|
|
2387
2129
|
selfFiltered = 0;
|
|
2388
|
-
|
|
2130
|
+
wakes = 0;
|
|
2389
2131
|
invites = 0;
|
|
2390
|
-
|
|
2391
|
-
constructor(
|
|
2392
|
-
this.config =
|
|
2393
|
-
this.
|
|
2394
|
-
this.
|
|
2395
|
-
this.
|
|
2396
|
-
|
|
2397
|
-
|
|
2398
|
-
|
|
2132
|
+
disconnects = 0;
|
|
2133
|
+
constructor(options) {
|
|
2134
|
+
this.config = options.config;
|
|
2135
|
+
this.logger = options.logger.child({ component: "socket" });
|
|
2136
|
+
this.handlers = options.handlers ?? {};
|
|
2137
|
+
this.metrics = options.metrics ?? createNoopMetrics();
|
|
2138
|
+
this.client = options.client;
|
|
2139
|
+
this.createRealtime = options.createRealtime ?? ((opts) => new agentchatme.RealtimeClient(opts));
|
|
2140
|
+
this.webSocket = options.webSocket;
|
|
2141
|
+
this.now = options.now ?? Date.now;
|
|
2399
2142
|
this.selfHandle = this.config.agentHandle?.replace(/^@/, "").toLowerCase();
|
|
2400
|
-
this.
|
|
2401
|
-
config: this.config,
|
|
2402
|
-
logger: this.logger,
|
|
2403
|
-
metrics: opts.metrics ?? createNoopMetrics(),
|
|
2404
|
-
webSocketCtor: opts.webSocketCtor,
|
|
2405
|
-
now: opts.now,
|
|
2406
|
-
random: opts.random
|
|
2407
|
-
});
|
|
2408
|
-
this.bindWsEvents();
|
|
2409
|
-
}
|
|
2410
|
-
/** Open the transport. Idempotent — subsequent calls are no-ops. */
|
|
2411
|
-
start() {
|
|
2412
|
-
if (this.started) return;
|
|
2413
|
-
this.started = true;
|
|
2414
|
-
this.ws.start();
|
|
2415
|
-
}
|
|
2416
|
-
/** Graceful shutdown: close the socket (nothing is in flight — the runtime sends nothing). */
|
|
2417
|
-
stop(deadlineMs) {
|
|
2418
|
-
if (this.stopPromise) return this.stopPromise;
|
|
2419
|
-
const deadline = deadlineMs ?? this.now() + 5e3;
|
|
2420
|
-
this.stopPromise = new Promise((resolve) => {
|
|
2421
|
-
const off = this.ws.on("closed", () => {
|
|
2422
|
-
off();
|
|
2423
|
-
resolve();
|
|
2424
|
-
});
|
|
2425
|
-
this.ws.stop(deadline);
|
|
2426
|
-
this.ws.drainCompleted();
|
|
2427
|
-
});
|
|
2428
|
-
return this.stopPromise;
|
|
2143
|
+
this.metrics.setConnectionState(this.state);
|
|
2429
2144
|
}
|
|
2430
|
-
/**
|
|
2431
|
-
|
|
2432
|
-
|
|
2145
|
+
/**
|
|
2146
|
+
* Open the socket. Idempotent. Resolves once the SDK has started its
|
|
2147
|
+
* connect loop; a failure to resolve a WebSocket implementation is logged
|
|
2148
|
+
* and left to the SDK's own retry. Never throws.
|
|
2149
|
+
*/
|
|
2150
|
+
async start() {
|
|
2151
|
+
if (this.realtime || this.stopping) return;
|
|
2152
|
+
const realtime = this.createRealtime(realtimeOptionsFor(this.config, { client: this.client, webSocket: this.webSocket }));
|
|
2153
|
+
this.realtime = realtime;
|
|
2154
|
+
this.bind(realtime);
|
|
2155
|
+
try {
|
|
2156
|
+
await realtime.connect();
|
|
2157
|
+
} catch (err) {
|
|
2158
|
+
this.logger.warn({ err: describe3(err) }, "socket connect failed \u2014 the SDK retries on its own schedule");
|
|
2159
|
+
}
|
|
2160
|
+
}
|
|
2161
|
+
/** Close the socket for good; a stopped socket does not reconnect. Idempotent. */
|
|
2162
|
+
async stop() {
|
|
2163
|
+
this.stopping = true;
|
|
2164
|
+
const realtime = this.realtime;
|
|
2165
|
+
this.realtime = null;
|
|
2166
|
+
this.connectedAt = null;
|
|
2167
|
+
if (realtime) {
|
|
2168
|
+
try {
|
|
2169
|
+
realtime.disconnect();
|
|
2170
|
+
} catch (err) {
|
|
2171
|
+
this.logger.warn({ err: describe3(err) }, "socket disconnect threw \u2014 continuing");
|
|
2172
|
+
}
|
|
2173
|
+
}
|
|
2174
|
+
if (this.state !== "stopped") this.onState("stopped", this.state);
|
|
2433
2175
|
}
|
|
2434
2176
|
getHealth() {
|
|
2435
2177
|
return {
|
|
2436
|
-
state: this.
|
|
2437
|
-
|
|
2438
|
-
|
|
2439
|
-
counters: { frames: this.frames, selfFiltered: this.selfFiltered, knocks: this.knocks, invites: this.invites }
|
|
2178
|
+
state: this.state,
|
|
2179
|
+
connectedAt: this.connectedAt,
|
|
2180
|
+
counters: { frames: this.frames, selfFiltered: this.selfFiltered, wakes: this.wakes, invites: this.invites, disconnects: this.disconnects }
|
|
2440
2181
|
};
|
|
2441
2182
|
}
|
|
2442
2183
|
// ─── Internals ─────────────────────────────────────────────────────
|
|
2443
|
-
|
|
2444
|
-
|
|
2445
|
-
|
|
2446
|
-
|
|
2184
|
+
bind(realtime) {
|
|
2185
|
+
realtime.on("state", (next, prev) => this.onState(next, prev));
|
|
2186
|
+
realtime.onConnect(() => {
|
|
2187
|
+
const at = this.now();
|
|
2188
|
+
this.connectedAt = at;
|
|
2189
|
+
this.logger.info({ at: new Date(at).toISOString() }, "connected (HELLO accepted)");
|
|
2190
|
+
this.guard("onConnected", () => this.handlers.onConnected?.(at));
|
|
2191
|
+
this.wake("connect", {});
|
|
2447
2192
|
});
|
|
2448
|
-
|
|
2449
|
-
this.
|
|
2450
|
-
this.
|
|
2451
|
-
|
|
2452
|
-
|
|
2453
|
-
}
|
|
2454
|
-
this.guard("
|
|
2455
|
-
|
|
2193
|
+
realtime.onDisconnect((info) => {
|
|
2194
|
+
if (this.stopping) return;
|
|
2195
|
+
this.disconnects += 1;
|
|
2196
|
+
this.connectedAt = null;
|
|
2197
|
+
this.metrics.incDisconnect({ code: String(info.code), initiator: info.initiator });
|
|
2198
|
+
this.logger.info({ code: info.code, reason: info.reason, initiator: info.initiator }, "socket closed \u2014 the SDK decides what follows (backoff or blocked)");
|
|
2199
|
+
this.guard("onDisconnected", () => this.handlers.onDisconnected?.(info));
|
|
2200
|
+
});
|
|
2201
|
+
realtime.on("blocked", (info) => {
|
|
2202
|
+
if (this.stopping) return;
|
|
2203
|
+
this.metrics.incError({ errorClass: "auth" });
|
|
2204
|
+
this.logger.warn(
|
|
2205
|
+
{ code: info.code, reason: info.reason, retryInMs: info.retryInMs },
|
|
2206
|
+
"the server rejected the key during the handshake \u2014 the SDK retries a fresh HELLO on its own"
|
|
2207
|
+
);
|
|
2208
|
+
this.guard("onBlocked", () => this.handlers.onBlocked?.(info));
|
|
2456
2209
|
});
|
|
2457
|
-
|
|
2458
|
-
|
|
2210
|
+
realtime.onError((error) => {
|
|
2211
|
+
if (this.stopping) return;
|
|
2212
|
+
if (realtime.state === "blocked") {
|
|
2213
|
+
this.logger.debug({ err: error.message }, "SDK notice while blocked");
|
|
2214
|
+
return;
|
|
2215
|
+
}
|
|
2216
|
+
this.metrics.incError({ errorClass: classifyRealtimeError(error) });
|
|
2217
|
+
this.logger.debug({ err: error.message }, "socket error");
|
|
2459
2218
|
this.guard("onError", () => this.handlers.onError?.(error));
|
|
2460
2219
|
});
|
|
2220
|
+
realtime.on("message.new", (message) => this.onMessageNew(message));
|
|
2221
|
+
realtime.on("wake", (frame) => this.onWakeFrame(frame));
|
|
2222
|
+
realtime.on("group.invite.received", (message) => this.onInvite(message));
|
|
2461
2223
|
}
|
|
2462
|
-
|
|
2224
|
+
onMessageNew(message) {
|
|
2463
2225
|
this.frames += 1;
|
|
2464
|
-
|
|
2465
|
-
|
|
2466
|
-
|
|
2467
|
-
|
|
2468
|
-
|
|
2469
|
-
|
|
2470
|
-
|
|
2471
|
-
|
|
2472
|
-
|
|
2473
|
-
this.
|
|
2474
|
-
|
|
2475
|
-
"knock \u2014 message.new"
|
|
2476
|
-
);
|
|
2477
|
-
this.knock("message");
|
|
2226
|
+
const payload = message.payload ?? {};
|
|
2227
|
+
const senderRaw = payload.sender ?? payload.from ?? "";
|
|
2228
|
+
const sender = typeof senderRaw === "string" ? senderRaw.replace(/^@/, "").toLowerCase() : "";
|
|
2229
|
+
const detail = {
|
|
2230
|
+
...typeof payload.conversation_id === "string" ? { conversationId: payload.conversation_id } : {},
|
|
2231
|
+
...typeof payload.id === "string" ? { messageId: payload.id } : {},
|
|
2232
|
+
...sender ? { from: sender } : {}
|
|
2233
|
+
};
|
|
2234
|
+
if (this.selfHandle && sender === this.selfHandle) {
|
|
2235
|
+
this.selfFiltered += 1;
|
|
2236
|
+
this.logger.debug(detail, "own echo \u2014 not a wake");
|
|
2478
2237
|
return;
|
|
2479
2238
|
}
|
|
2480
|
-
|
|
2481
|
-
|
|
2482
|
-
|
|
2483
|
-
|
|
2484
|
-
|
|
2485
|
-
|
|
2486
|
-
|
|
2487
|
-
|
|
2239
|
+
this.logger.debug(detail, "wake \u2014 message.new");
|
|
2240
|
+
this.wake("message", detail);
|
|
2241
|
+
}
|
|
2242
|
+
onWakeFrame(frame) {
|
|
2243
|
+
this.frames += 1;
|
|
2244
|
+
const reason = frame.payload?.reason;
|
|
2245
|
+
const detail = { conversationId: frame.payload.conversation_id };
|
|
2246
|
+
this.logger.info({ ...detail, reason, step: frame.payload.step }, "wake \u2014 server wake frame");
|
|
2247
|
+
this.wake(wakeSourceOf(reason), detail);
|
|
2248
|
+
}
|
|
2249
|
+
onInvite(message) {
|
|
2250
|
+
this.frames += 1;
|
|
2251
|
+
const invite = groupInviteFromRecord(message.payload);
|
|
2252
|
+
if (!invite) {
|
|
2253
|
+
this.logger.warn({ keys: Object.keys(message.payload ?? {}).sort() }, "group.invite.received without ids \u2014 dropped");
|
|
2488
2254
|
return;
|
|
2489
2255
|
}
|
|
2490
|
-
this.
|
|
2256
|
+
this.invites += 1;
|
|
2257
|
+
this.guard("onGroupInvite", () => this.handlers.onGroupInvite?.(invite));
|
|
2491
2258
|
}
|
|
2492
|
-
|
|
2493
|
-
this.
|
|
2494
|
-
this.
|
|
2259
|
+
wake(source, detail) {
|
|
2260
|
+
this.wakes += 1;
|
|
2261
|
+
this.metrics.incWake({ source });
|
|
2262
|
+
this.guard("onWake", () => this.handlers.onWake?.(source, detail));
|
|
2495
2263
|
}
|
|
2496
|
-
/**
|
|
2264
|
+
/** The SDK's state transition, mirrored for the health probe and the gauge, then handed on. */
|
|
2265
|
+
onState(next, prev) {
|
|
2266
|
+
this.state = next;
|
|
2267
|
+
this.metrics.setConnectionState(next);
|
|
2268
|
+
this.logger.debug({ from: prev, to: next }, "socket state");
|
|
2269
|
+
this.guard("onStateChanged", () => this.handlers.onStateChanged?.(next, prev));
|
|
2270
|
+
}
|
|
2271
|
+
/** A failing handler never takes the socket down; the next frame wakes again and the tray keeps the cards. */
|
|
2497
2272
|
guard(name, fn) {
|
|
2498
2273
|
try {
|
|
2499
2274
|
fn();
|
|
2500
2275
|
} catch (err) {
|
|
2501
|
-
this.logger.error({ err:
|
|
2276
|
+
this.logger.error({ err: describe3(err), handler: name }, "handler threw \u2014 continuing");
|
|
2502
2277
|
}
|
|
2503
2278
|
}
|
|
2504
2279
|
};
|
|
2280
|
+
function classifyRealtimeError(error) {
|
|
2281
|
+
const message = error.message;
|
|
2282
|
+
if (/handler failed/i.test(message)) return "handler";
|
|
2283
|
+
if (/failed validation|not an object|expected a bare array/i.test(message)) return "protocol";
|
|
2284
|
+
if (error.name === "ConnectionError" || /websocket|hello|handshake|liveness|reconnecting|sync drain|sync ack/i.test(message)) return "transport";
|
|
2285
|
+
return "other";
|
|
2286
|
+
}
|
|
2287
|
+
function describe3(err) {
|
|
2288
|
+
return err instanceof Error ? err.message : String(err);
|
|
2289
|
+
}
|
|
2505
2290
|
|
|
2506
2291
|
// src/binding/runtime-registry.ts
|
|
2507
2292
|
var registry = /* @__PURE__ */ new Map();
|
|
@@ -2520,62 +2305,66 @@ function withAccountLock(accountId, op) {
|
|
|
2520
2305
|
);
|
|
2521
2306
|
return next;
|
|
2522
2307
|
}
|
|
2523
|
-
function
|
|
2308
|
+
function registerIntegration(params) {
|
|
2524
2309
|
return withAccountLock(params.accountId, async () => {
|
|
2525
2310
|
const existing = registry.get(params.accountId);
|
|
2526
2311
|
if (existing) {
|
|
2527
|
-
await stopEntry(existing
|
|
2312
|
+
await stopEntry(existing);
|
|
2528
2313
|
registry.delete(params.accountId);
|
|
2529
2314
|
}
|
|
2530
|
-
let runtimeRef = null;
|
|
2531
2315
|
let built = null;
|
|
2532
2316
|
const handlers = {
|
|
2533
|
-
|
|
2317
|
+
onWake: (source, detail) => built?.handlers.onWake?.(source, detail),
|
|
2534
2318
|
onGroupInvite: (invite) => built?.handlers.onGroupInvite?.(invite),
|
|
2535
|
-
|
|
2536
|
-
|
|
2537
|
-
|
|
2319
|
+
onConnected: (at) => built?.handlers.onConnected?.(at),
|
|
2320
|
+
onDisconnected: (info) => built?.handlers.onDisconnected?.(info),
|
|
2321
|
+
onBlocked: (info) => built?.handlers.onBlocked?.(info),
|
|
2322
|
+
onError: (error) => built?.handlers.onError?.(error),
|
|
2323
|
+
onStateChanged: (next, prev) => built?.handlers.onStateChanged?.(next, prev)
|
|
2538
2324
|
};
|
|
2539
|
-
const create = params.
|
|
2540
|
-
|
|
2541
|
-
built = params.build(
|
|
2542
|
-
const entry = {
|
|
2325
|
+
const create = params.createSocket ?? ((options) => new IntegrationSocket(options));
|
|
2326
|
+
const socket = create({ config: params.config, logger: params.logger, handlers, ...params.socketOptions ?? {} });
|
|
2327
|
+
built = params.build(socket);
|
|
2328
|
+
const entry = { socket, invoker: built.invoker, texts: built.texts ?? null, config: params.config, logger: params.logger };
|
|
2543
2329
|
registry.set(params.accountId, entry);
|
|
2544
2330
|
try {
|
|
2545
|
-
|
|
2331
|
+
await socket.start();
|
|
2546
2332
|
} catch (err) {
|
|
2547
2333
|
registry.delete(params.accountId);
|
|
2548
2334
|
built.invoker?.stop();
|
|
2335
|
+
built.texts?.stop();
|
|
2549
2336
|
throw err;
|
|
2550
2337
|
}
|
|
2551
2338
|
return entry;
|
|
2552
2339
|
});
|
|
2553
2340
|
}
|
|
2554
|
-
function
|
|
2341
|
+
function unregisterIntegration(accountId) {
|
|
2555
2342
|
return withAccountLock(accountId, async () => {
|
|
2556
2343
|
const entry = registry.get(accountId);
|
|
2557
2344
|
if (!entry) return;
|
|
2558
2345
|
registry.delete(accountId);
|
|
2559
|
-
await stopEntry(entry
|
|
2346
|
+
await stopEntry(entry);
|
|
2560
2347
|
});
|
|
2561
2348
|
}
|
|
2562
|
-
async function stopEntry(entry
|
|
2349
|
+
async function stopEntry(entry) {
|
|
2563
2350
|
entry.invoker?.stop();
|
|
2351
|
+
entry.texts?.stop();
|
|
2564
2352
|
try {
|
|
2565
|
-
await entry.
|
|
2353
|
+
await entry.socket.stop();
|
|
2566
2354
|
} catch (err) {
|
|
2567
|
-
entry.logger.error({ err: err instanceof Error ? err.message : String(err) }, "
|
|
2355
|
+
entry.logger.error({ err: err instanceof Error ? err.message : String(err) }, "socket.stop threw during unregister");
|
|
2568
2356
|
}
|
|
2569
2357
|
}
|
|
2570
|
-
function
|
|
2358
|
+
function getIntegration(accountId) {
|
|
2571
2359
|
return registry.get(accountId);
|
|
2572
2360
|
}
|
|
2573
2361
|
|
|
2574
|
-
// src/
|
|
2362
|
+
// src/integration/wake.ts
|
|
2575
2363
|
var DEFAULT_DEBOUNCE_MS = 2e3;
|
|
2576
2364
|
var DEFAULT_MAX_WINDOW_MS = 6e3;
|
|
2577
|
-
var
|
|
2365
|
+
var WakeCoalescer = class {
|
|
2578
2366
|
onFire;
|
|
2367
|
+
onDelayedWake;
|
|
2579
2368
|
debounceMs;
|
|
2580
2369
|
maxWindowMs;
|
|
2581
2370
|
now;
|
|
@@ -2586,7 +2375,7 @@ var KnockCoalescer = class {
|
|
|
2586
2375
|
delayed = null;
|
|
2587
2376
|
delayedDeadline = null;
|
|
2588
2377
|
stopped = false;
|
|
2589
|
-
|
|
2378
|
+
wakes = 0;
|
|
2590
2379
|
absorbed = 0;
|
|
2591
2380
|
fires = 0;
|
|
2592
2381
|
constructor(options) {
|
|
@@ -2595,6 +2384,7 @@ var KnockCoalescer = class {
|
|
|
2595
2384
|
const maxWindow = options.maxWindowMs ?? DEFAULT_MAX_WINDOW_MS;
|
|
2596
2385
|
if (!(maxWindow >= debounce)) throw new RangeError("maxWindowMs must be >= debounceMs");
|
|
2597
2386
|
this.onFire = options.onFire;
|
|
2387
|
+
this.onDelayedWake = options.onDelayedWake;
|
|
2598
2388
|
this.debounceMs = debounce;
|
|
2599
2389
|
this.maxWindowMs = maxWindow;
|
|
2600
2390
|
this.now = options.now ?? Date.now;
|
|
@@ -2605,17 +2395,17 @@ var KnockCoalescer = class {
|
|
|
2605
2395
|
get armed() {
|
|
2606
2396
|
return this.timer !== null;
|
|
2607
2397
|
}
|
|
2608
|
-
/** True while a retry
|
|
2398
|
+
/** True while a retry wake is scheduled and has not fired. */
|
|
2609
2399
|
get delayedPending() {
|
|
2610
2400
|
return this.delayed !== null;
|
|
2611
2401
|
}
|
|
2612
2402
|
/**
|
|
2613
|
-
* A
|
|
2403
|
+
* A wake. The first one of a burst arms the window; every later one is
|
|
2614
2404
|
* absorbed and restarts it (trailing edge), never past the burst's cap.
|
|
2615
2405
|
*/
|
|
2616
|
-
|
|
2406
|
+
wake() {
|
|
2617
2407
|
if (this.stopped) return;
|
|
2618
|
-
this.
|
|
2408
|
+
this.wakes += 1;
|
|
2619
2409
|
const now = this.now();
|
|
2620
2410
|
if (this.timer === null) {
|
|
2621
2411
|
this.burstStartedAt = now;
|
|
@@ -2628,8 +2418,8 @@ var KnockCoalescer = class {
|
|
|
2628
2418
|
this._clearTimeout(this.timer);
|
|
2629
2419
|
this.timer = this._setTimeout(() => this.fire(), delay);
|
|
2630
2420
|
}
|
|
2631
|
-
/** A delayed
|
|
2632
|
-
|
|
2421
|
+
/** A delayed wake (retry ladder). The sooner pending deadline is kept. */
|
|
2422
|
+
wakeAfter(delayMs) {
|
|
2633
2423
|
if (this.stopped) return;
|
|
2634
2424
|
const delay = Math.max(0, delayMs);
|
|
2635
2425
|
const deadline = this.now() + delay;
|
|
@@ -2643,10 +2433,15 @@ var KnockCoalescer = class {
|
|
|
2643
2433
|
this.delayed = this._setTimeout(() => {
|
|
2644
2434
|
this.delayed = null;
|
|
2645
2435
|
this.delayedDeadline = null;
|
|
2646
|
-
this.
|
|
2436
|
+
if (this.stopped) return;
|
|
2437
|
+
try {
|
|
2438
|
+
this.onDelayedWake?.();
|
|
2439
|
+
} catch {
|
|
2440
|
+
}
|
|
2441
|
+
this.wake();
|
|
2647
2442
|
}, delay);
|
|
2648
2443
|
}
|
|
2649
|
-
/** Cancel everything; later
|
|
2444
|
+
/** Cancel everything; later wakes are ignored. */
|
|
2650
2445
|
stop() {
|
|
2651
2446
|
this.stopped = true;
|
|
2652
2447
|
if (this.timer !== null) {
|
|
@@ -2672,453 +2467,80 @@ var KnockCoalescer = class {
|
|
|
2672
2467
|
}
|
|
2673
2468
|
};
|
|
2674
2469
|
|
|
2675
|
-
// src/
|
|
2676
|
-
var DEFAULT_TIMEOUT_MS2 = 15e3;
|
|
2677
|
-
var INBOX_MAX_LIMIT = 50;
|
|
2678
|
-
var INBOX_WAIT_MAX_MS = 5e4;
|
|
2679
|
-
var INBOX_PATH = "/v1/inbox";
|
|
2680
|
-
var MainLineError = class extends Error {
|
|
2681
|
-
status;
|
|
2682
|
-
code;
|
|
2683
|
-
constructor(message, options = {}) {
|
|
2684
|
-
super(message, { cause: options.cause });
|
|
2685
|
-
this.name = "MainLineError";
|
|
2686
|
-
this.status = options.status;
|
|
2687
|
-
this.code = options.code;
|
|
2688
|
-
}
|
|
2689
|
-
};
|
|
2690
|
-
var MainLineClient = class {
|
|
2691
|
-
apiKey;
|
|
2692
|
-
apiBase;
|
|
2693
|
-
timeoutMs;
|
|
2694
|
-
fetchImpl;
|
|
2695
|
-
constructor(options) {
|
|
2696
|
-
this.apiKey = options.apiKey;
|
|
2697
|
-
this.apiBase = options.apiBase.replace(/\/+$/, "");
|
|
2698
|
-
this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS2;
|
|
2699
|
-
this.fetchImpl = options.fetch ?? fetch;
|
|
2700
|
-
}
|
|
2701
|
-
/**
|
|
2702
|
-
* `GET /v1/inbox` — the briefing cards plus the gate question, returned as
|
|
2703
|
-
* the server sent them (`you`, `question`, `categories`, `conversations`,
|
|
2704
|
-
* `deferred`, `truncated`, and any field a newer server adds). Marks
|
|
2705
|
-
* nothing delivered.
|
|
2706
|
-
*/
|
|
2707
|
-
async inbox(params = {}) {
|
|
2708
|
-
const waitMs = params.waitMs ?? 0;
|
|
2709
|
-
const limit = params.limit ?? INBOX_MAX_LIMIT;
|
|
2710
|
-
if (!Number.isInteger(waitMs) || waitMs < 0 || waitMs > INBOX_WAIT_MAX_MS) {
|
|
2711
|
-
throw new RangeError(`waitMs must be an integer within 0..${INBOX_WAIT_MAX_MS}`);
|
|
2712
|
-
}
|
|
2713
|
-
if (!Number.isInteger(limit) || limit < 1 || limit > INBOX_MAX_LIMIT) {
|
|
2714
|
-
throw new RangeError(`limit must be an integer within 1..${INBOX_MAX_LIMIT}`);
|
|
2715
|
-
}
|
|
2716
|
-
const url = `${this.apiBase}${INBOX_PATH}?wait_ms=${waitMs}&limit=${limit}`;
|
|
2717
|
-
const data = await this.request("GET", url, void 0, this.timeoutMs + waitMs);
|
|
2718
|
-
if (!data || typeof data !== "object" || Array.isArray(data)) {
|
|
2719
|
-
throw new MainLineError(`GET ${INBOX_PATH}: expected a JSON object`);
|
|
2720
|
-
}
|
|
2721
|
-
return data;
|
|
2722
|
-
}
|
|
2723
|
-
/**
|
|
2724
|
-
* `POST /v1/conversations/{id}/decisions` — record one verdict. The server
|
|
2725
|
-
* validates `decision`, `category` and `defer_seconds` against its own
|
|
2726
|
-
* taxonomy; this client passes them through and raises `MainLineError`
|
|
2727
|
-
* (`status` 400) when the server rejects a value, so the caller can retry
|
|
2728
|
-
* with less.
|
|
2729
|
-
*/
|
|
2730
|
-
async recordDecision(conversationId, input) {
|
|
2731
|
-
if (!conversationId) throw new RangeError("conversationId is required");
|
|
2732
|
-
const body = { decision: input.decision };
|
|
2733
|
-
if (input.category) body.category = input.category;
|
|
2734
|
-
if (input.throughMessageId) body.through_message_id = input.throughMessageId;
|
|
2735
|
-
if (input.deferSeconds !== void 0) body.defer_seconds = input.deferSeconds;
|
|
2736
|
-
const path2 = `/v1/conversations/${encodeURIComponent(conversationId)}/decisions`;
|
|
2737
|
-
const data = await this.request("POST", `${this.apiBase}${path2}`, body, this.timeoutMs);
|
|
2738
|
-
return data && typeof data === "object" && !Array.isArray(data) ? data : {};
|
|
2739
|
-
}
|
|
2740
|
-
async request(method, url, body, timeoutMs) {
|
|
2741
|
-
const controller = new AbortController();
|
|
2742
|
-
const timer = setTimeout(() => controller.abort(), timeoutMs);
|
|
2743
|
-
const what = `${method} ${new URL(url).pathname}`;
|
|
2744
|
-
let res;
|
|
2745
|
-
try {
|
|
2746
|
-
res = await this.fetchImpl(url, {
|
|
2747
|
-
method,
|
|
2748
|
-
headers: {
|
|
2749
|
-
authorization: `Bearer ${this.apiKey}`,
|
|
2750
|
-
accept: "application/json",
|
|
2751
|
-
...body !== void 0 ? { "content-type": "application/json" } : {},
|
|
2752
|
-
...AGENTCHAT_CLIENT_HEADERS
|
|
2753
|
-
},
|
|
2754
|
-
...body !== void 0 ? { body: JSON.stringify(body) } : {},
|
|
2755
|
-
signal: controller.signal
|
|
2756
|
-
});
|
|
2757
|
-
} catch (err) {
|
|
2758
|
-
throw new MainLineError(`${what}: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
|
|
2759
|
-
} finally {
|
|
2760
|
-
clearTimeout(timer);
|
|
2761
|
-
}
|
|
2762
|
-
const text = await res.text().catch(() => "");
|
|
2763
|
-
let parsed = void 0;
|
|
2764
|
-
if (text.length > 0) {
|
|
2765
|
-
try {
|
|
2766
|
-
parsed = JSON.parse(text);
|
|
2767
|
-
} catch {
|
|
2768
|
-
if (res.ok) throw new MainLineError(`${what}: invalid JSON in a ${res.status} answer`, { status: res.status });
|
|
2769
|
-
}
|
|
2770
|
-
}
|
|
2771
|
-
if (res.ok) return parsed ?? {};
|
|
2772
|
-
const fields = parsed && typeof parsed === "object" ? parsed : {};
|
|
2773
|
-
const code = typeof fields.code === "string" ? fields.code : void 0;
|
|
2774
|
-
const message = typeof fields.message === "string" ? fields.message : void 0;
|
|
2775
|
-
throw new MainLineError(
|
|
2776
|
-
`${what}: HTTP ${res.status}${code ? ` ${code}` : ""}${message ? ` \u2014 ${message}` : ""}`,
|
|
2777
|
-
{ status: res.status, code }
|
|
2778
|
-
);
|
|
2779
|
-
}
|
|
2780
|
-
};
|
|
2781
|
-
|
|
2782
|
-
// src/doorbell/gate.ts
|
|
2783
|
-
var DEFAULT_GATE_MAX_TOKENS = 2048;
|
|
2784
|
-
var REPLY = "reply";
|
|
2785
|
-
var DISMISS = "dismiss";
|
|
2786
|
-
var DEFER = "defer";
|
|
2787
|
-
var REPLY_TOKENS = /* @__PURE__ */ new Set(["reply", "respond", "answer", "yes", "true"]);
|
|
2788
|
-
var DISMISS_TOKENS = /* @__PURE__ */ new Set([
|
|
2789
|
-
"dismiss",
|
|
2790
|
-
"dismissed",
|
|
2791
|
-
"no_reply",
|
|
2792
|
-
"no-reply",
|
|
2793
|
-
"noreply",
|
|
2794
|
-
"silent",
|
|
2795
|
-
"silence",
|
|
2796
|
-
"skip",
|
|
2797
|
-
"ignore",
|
|
2798
|
-
"no",
|
|
2799
|
-
"false"
|
|
2800
|
-
]);
|
|
2801
|
-
var DEFER_TOKENS = /* @__PURE__ */ new Set(["defer", "deferred", "later", "wait", "postpone"]);
|
|
2802
|
-
var FENCE_RE = /```(?:json)?\s*([\s\S]+?)```/i;
|
|
2803
|
-
function startTurn(result) {
|
|
2804
|
-
return result.replyConversations.length > 0 || result.source === "fail_open";
|
|
2805
|
-
}
|
|
2806
|
-
function countVerdicts(result) {
|
|
2807
|
-
const counts = { reply: 0, dismiss: 0, defer: 0 };
|
|
2808
|
-
for (const verdict of result.verdicts) counts[verdict.decision] += 1;
|
|
2809
|
-
return counts;
|
|
2810
|
-
}
|
|
2811
|
-
function cardsOf(tray) {
|
|
2812
|
-
const raw = tray.conversations;
|
|
2813
|
-
if (!Array.isArray(raw)) return [];
|
|
2814
|
-
return raw.filter((card) => Boolean(card) && typeof card === "object" && !Array.isArray(card));
|
|
2815
|
-
}
|
|
2816
|
-
function cardIds(cards) {
|
|
2817
|
-
const out = [];
|
|
2818
|
-
for (const card of cards) {
|
|
2819
|
-
const id = card.conversation_id;
|
|
2820
|
-
if (typeof id === "string" && id.length > 0) out.push(id);
|
|
2821
|
-
}
|
|
2822
|
-
return out;
|
|
2823
|
-
}
|
|
2824
|
-
function categoriesOf(tray) {
|
|
2825
|
-
const raw = tray.categories;
|
|
2826
|
-
if (!Array.isArray(raw)) return [];
|
|
2827
|
-
return raw.filter((item) => typeof item === "string" && item.length > 0);
|
|
2828
|
-
}
|
|
2829
|
-
function buildGateMessages(tray) {
|
|
2830
|
-
const question = tray.question;
|
|
2831
|
-
if (typeof question !== "string" || question.trim().length === 0) {
|
|
2832
|
-
throw new Error("tray carries no gate question");
|
|
2833
|
-
}
|
|
2834
|
-
const cards = cardsOf(tray);
|
|
2835
|
-
const categories = categoriesOf(tray);
|
|
2836
|
-
let shape = '{"decisions": [{"conversation_id": "<conversation_id from a card>", "decision": "reply" | "dismiss" | "defer"';
|
|
2837
|
-
if (categories.length > 0) {
|
|
2838
|
-
shape += `, "category": "<one of: ${categories.join(", ")}>"`;
|
|
2839
|
-
}
|
|
2840
|
-
shape += ', "defer_seconds": <seconds until you look again, only with defer>}]}';
|
|
2841
|
-
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.";
|
|
2842
|
-
const payload = {};
|
|
2843
|
-
if (typeof tray.you === "string" && tray.you.length > 0) payload.you = tray.you;
|
|
2844
|
-
payload.conversations = cards;
|
|
2845
|
-
return {
|
|
2846
|
-
systemPrompt: `${question.trim()}
|
|
2847
|
-
|
|
2848
|
-
${wrapper}`,
|
|
2849
|
-
userContent: `Your tray, as the server built it:
|
|
2850
|
-
${JSON.stringify(payload)}`
|
|
2851
|
-
};
|
|
2852
|
-
}
|
|
2853
|
-
function parseVerdicts(text, params) {
|
|
2854
|
-
const raw = extractJson(text);
|
|
2855
|
-
if (raw === null) return null;
|
|
2856
|
-
let obj;
|
|
2857
|
-
try {
|
|
2858
|
-
obj = JSON.parse(raw);
|
|
2859
|
-
} catch {
|
|
2860
|
-
return null;
|
|
2861
|
-
}
|
|
2862
|
-
let items;
|
|
2863
|
-
if (obj && typeof obj === "object" && !Array.isArray(obj)) {
|
|
2864
|
-
const record = obj;
|
|
2865
|
-
items = record.decisions ?? record.verdicts;
|
|
2866
|
-
if (items === void 0 && "conversation_id" in record) items = [record];
|
|
2867
|
-
} else {
|
|
2868
|
-
items = obj;
|
|
2869
|
-
}
|
|
2870
|
-
if (!Array.isArray(items)) return null;
|
|
2871
|
-
const known = new Set(params.knownIds);
|
|
2872
|
-
const allowed = new Set((params.categories ?? []).map((c) => c.toLowerCase()));
|
|
2873
|
-
const seen = /* @__PURE__ */ new Set();
|
|
2874
|
-
const out = [];
|
|
2875
|
-
for (const item of items) {
|
|
2876
|
-
if (!item || typeof item !== "object" || Array.isArray(item)) continue;
|
|
2877
|
-
const entry = item;
|
|
2878
|
-
const id = entry.conversation_id;
|
|
2879
|
-
if (typeof id !== "string" || !known.has(id) || seen.has(id)) continue;
|
|
2880
|
-
const decision = normalizeDecision(entry.decision);
|
|
2881
|
-
if (decision === null) continue;
|
|
2882
|
-
seen.add(id);
|
|
2883
|
-
const category = normalizeCategory(entry.category, allowed);
|
|
2884
|
-
const deferSeconds = decision === DEFER ? normalizeDeferSeconds(entry.defer_seconds) : void 0;
|
|
2885
|
-
out.push({
|
|
2886
|
-
conversationId: id,
|
|
2887
|
-
decision,
|
|
2888
|
-
...category !== void 0 ? { category } : {},
|
|
2889
|
-
...deferSeconds !== void 0 ? { deferSeconds } : {}
|
|
2890
|
-
});
|
|
2891
|
-
}
|
|
2892
|
-
return out;
|
|
2893
|
-
}
|
|
2894
|
-
function extractJson(text) {
|
|
2895
|
-
if (!text || text.trim().length === 0) return null;
|
|
2896
|
-
let s = text.trim();
|
|
2897
|
-
const fence = FENCE_RE.exec(s);
|
|
2898
|
-
if (fence?.[1]) s = fence[1].trim();
|
|
2899
|
-
const starts = [s.indexOf("{"), s.indexOf("[")].filter((i) => i !== -1);
|
|
2900
|
-
if (starts.length === 0) return null;
|
|
2901
|
-
const start = Math.min(...starts);
|
|
2902
|
-
const closer = s[start] === "{" ? "}" : "]";
|
|
2903
|
-
const end = s.lastIndexOf(closer);
|
|
2904
|
-
if (end <= start) return null;
|
|
2905
|
-
return s.slice(start, end + 1);
|
|
2906
|
-
}
|
|
2907
|
-
function normalizeDecision(value) {
|
|
2908
|
-
if (typeof value !== "string") return null;
|
|
2909
|
-
const token = value.trim().toLowerCase().replace(/\s+/g, "_");
|
|
2910
|
-
if (REPLY_TOKENS.has(token)) return REPLY;
|
|
2911
|
-
if (DISMISS_TOKENS.has(token)) return DISMISS;
|
|
2912
|
-
if (DEFER_TOKENS.has(token)) return DEFER;
|
|
2913
|
-
return null;
|
|
2914
|
-
}
|
|
2915
|
-
function normalizeCategory(value, allowed) {
|
|
2916
|
-
if (allowed.size === 0 || typeof value !== "string") return void 0;
|
|
2917
|
-
const token = value.trim().toLowerCase();
|
|
2918
|
-
return allowed.has(token) ? token : void 0;
|
|
2919
|
-
}
|
|
2920
|
-
function normalizeDeferSeconds(value) {
|
|
2921
|
-
if (typeof value !== "number" || !Number.isFinite(value)) return void 0;
|
|
2922
|
-
const seconds = Math.trunc(value);
|
|
2923
|
-
return seconds > 0 ? seconds : void 0;
|
|
2924
|
-
}
|
|
2925
|
-
async function runGate(params) {
|
|
2926
|
-
const cards = cardsOf(params.tray);
|
|
2927
|
-
const ids = cardIds(cards);
|
|
2928
|
-
const truncated = params.tray.truncated === true;
|
|
2929
|
-
const now = params.now ?? Date.now;
|
|
2930
|
-
const log = params.log ?? (() => void 0);
|
|
2931
|
-
if (ids.length === 0) return emptyResult("empty", truncated);
|
|
2932
|
-
const started = now();
|
|
2933
|
-
let text;
|
|
2934
|
-
try {
|
|
2935
|
-
const messages = buildGateMessages(params.tray);
|
|
2936
|
-
text = await params.caller({
|
|
2937
|
-
systemPrompt: messages.systemPrompt,
|
|
2938
|
-
userContent: messages.userContent,
|
|
2939
|
-
maxTokens: params.maxTokens ?? DEFAULT_GATE_MAX_TOKENS,
|
|
2940
|
-
timeoutMs: params.timeoutMs
|
|
2941
|
-
});
|
|
2942
|
-
} catch (err) {
|
|
2943
|
-
const reason = `decision call failed: ${err instanceof Error ? err.message : String(err)}`;
|
|
2944
|
-
log("warn", `gate: ${reason} (${ids.length} cards)`);
|
|
2945
|
-
return failedResult(ids, params.failOpen, reason, now() - started, truncated);
|
|
2946
|
-
}
|
|
2947
|
-
const latencyMs = now() - started;
|
|
2948
|
-
const verdicts = parseVerdicts(text, { knownIds: ids, categories: categoriesOf(params.tray) });
|
|
2949
|
-
if (!verdicts || verdicts.length === 0) {
|
|
2950
|
-
log("warn", `gate: unusable answer for ${ids.length} cards (latency ${latencyMs} ms)`);
|
|
2951
|
-
log("debug", `gate: raw model output: ${(text ?? "").slice(0, 200)}`);
|
|
2952
|
-
return failedResult(ids, params.failOpen, "no usable verdicts in the answer", latencyMs, truncated);
|
|
2953
|
-
}
|
|
2954
|
-
const byId = /* @__PURE__ */ new Map();
|
|
2955
|
-
for (const card of cards) {
|
|
2956
|
-
const id = card.conversation_id;
|
|
2957
|
-
if (typeof id === "string") byId.set(id, card);
|
|
2958
|
-
}
|
|
2959
|
-
const decided = new Set(verdicts.map((v) => v.conversationId));
|
|
2960
|
-
const undecided = ids.filter((id) => !decided.has(id));
|
|
2961
|
-
const reply = [];
|
|
2962
|
-
let posted = 0;
|
|
2963
|
-
let postFailures = 0;
|
|
2964
|
-
for (const verdict of verdicts) {
|
|
2965
|
-
if (verdict.decision === REPLY) {
|
|
2966
|
-
reply.push(verdict.conversationId);
|
|
2967
|
-
continue;
|
|
2968
|
-
}
|
|
2969
|
-
if (await postVerdict(params.mainLine, verdict, byId.get(verdict.conversationId), log)) posted += 1;
|
|
2970
|
-
else postFailures += 1;
|
|
2971
|
-
}
|
|
2972
|
-
if (undecided.length > 0) {
|
|
2973
|
-
log("warn", `gate: ${undecided.length} of ${ids.length} cards left undecided by the model: ${undecided.join(", ")}`);
|
|
2974
|
-
}
|
|
2975
|
-
return {
|
|
2976
|
-
source: "llm",
|
|
2977
|
-
cards: ids.length,
|
|
2978
|
-
verdicts,
|
|
2979
|
-
undecided,
|
|
2980
|
-
replyConversations: reply,
|
|
2981
|
-
posted,
|
|
2982
|
-
postFailures,
|
|
2983
|
-
truncated,
|
|
2984
|
-
latencyMs,
|
|
2985
|
-
failure: null
|
|
2986
|
-
};
|
|
2987
|
-
}
|
|
2988
|
-
function emptyResult(source, truncated, replyConversations = []) {
|
|
2989
|
-
return {
|
|
2990
|
-
source,
|
|
2991
|
-
cards: replyConversations.length,
|
|
2992
|
-
verdicts: [],
|
|
2993
|
-
undecided: [],
|
|
2994
|
-
replyConversations,
|
|
2995
|
-
posted: 0,
|
|
2996
|
-
postFailures: 0,
|
|
2997
|
-
truncated,
|
|
2998
|
-
latencyMs: 0,
|
|
2999
|
-
failure: null
|
|
3000
|
-
};
|
|
3001
|
-
}
|
|
3002
|
-
function failedResult(ids, failOpen, reason, latencyMs, truncated) {
|
|
3003
|
-
return {
|
|
3004
|
-
source: failOpen ? "fail_open" : "fail_closed",
|
|
3005
|
-
cards: ids.length,
|
|
3006
|
-
verdicts: [],
|
|
3007
|
-
undecided: ids,
|
|
3008
|
-
replyConversations: failOpen ? ids : [],
|
|
3009
|
-
posted: 0,
|
|
3010
|
-
postFailures: 0,
|
|
3011
|
-
truncated,
|
|
3012
|
-
latencyMs,
|
|
3013
|
-
failure: reason
|
|
3014
|
-
};
|
|
3015
|
-
}
|
|
3016
|
-
async function postVerdict(mainLine, verdict, card, log = () => void 0) {
|
|
3017
|
-
const through = previewMessageId(card);
|
|
3018
|
-
try {
|
|
3019
|
-
await mainLine.recordDecision(verdict.conversationId, {
|
|
3020
|
-
decision: verdict.decision,
|
|
3021
|
-
category: verdict.category,
|
|
3022
|
-
throughMessageId: through,
|
|
3023
|
-
deferSeconds: verdict.deferSeconds
|
|
3024
|
-
});
|
|
3025
|
-
return true;
|
|
3026
|
-
} catch (err) {
|
|
3027
|
-
const retryable = err instanceof MainLineError && err.status === 400 && (verdict.category !== void 0 || verdict.deferSeconds !== void 0);
|
|
3028
|
-
if (!retryable) {
|
|
3029
|
-
log("warn", `gate: verdict ${verdict.decision} for ${verdict.conversationId} not recorded: ${describe2(err)}`);
|
|
3030
|
-
return false;
|
|
3031
|
-
}
|
|
3032
|
-
log("warn", `gate: server rejected optional fields for ${verdict.conversationId} (${describe2(err)}) \u2014 retrying bare verdict`);
|
|
3033
|
-
}
|
|
3034
|
-
try {
|
|
3035
|
-
await mainLine.recordDecision(verdict.conversationId, {
|
|
3036
|
-
decision: verdict.decision,
|
|
3037
|
-
throughMessageId: through
|
|
3038
|
-
});
|
|
3039
|
-
return true;
|
|
3040
|
-
} catch (err) {
|
|
3041
|
-
log("warn", `gate: verdict ${verdict.decision} for ${verdict.conversationId} not recorded: ${describe2(err)}`);
|
|
3042
|
-
return false;
|
|
3043
|
-
}
|
|
3044
|
-
}
|
|
3045
|
-
function previewMessageId(card) {
|
|
3046
|
-
if (!card) return void 0;
|
|
3047
|
-
const preview = card.preview;
|
|
3048
|
-
if (!preview || typeof preview !== "object" || Array.isArray(preview)) return void 0;
|
|
3049
|
-
const id = preview.message_id;
|
|
3050
|
-
return typeof id === "string" && id.length > 0 ? id : void 0;
|
|
3051
|
-
}
|
|
3052
|
-
function describe2(err) {
|
|
3053
|
-
return err instanceof Error ? err.message : String(err);
|
|
3054
|
-
}
|
|
3055
|
-
|
|
3056
|
-
// src/doorbell/invoker.ts
|
|
3057
|
-
var DEFAULT_GATE_TIMEOUT_MS = 2e4;
|
|
2470
|
+
// src/integration/invoker.ts
|
|
3058
2471
|
var RETRY_LADDER_MS = [6e4, 3e5, 18e5];
|
|
3059
2472
|
var AgentInvoker = class {
|
|
3060
2473
|
accountId;
|
|
3061
2474
|
agentId;
|
|
3062
|
-
|
|
3063
|
-
|
|
3064
|
-
|
|
2475
|
+
client;
|
|
2476
|
+
callModel;
|
|
2477
|
+
startTurn;
|
|
2478
|
+
texts;
|
|
2479
|
+
invites;
|
|
3065
2480
|
logger;
|
|
2481
|
+
metrics;
|
|
3066
2482
|
gateEnabled;
|
|
3067
|
-
gateFailOpen;
|
|
3068
|
-
gateTimeoutMs;
|
|
3069
2483
|
ladder;
|
|
3070
2484
|
now;
|
|
3071
2485
|
coalescer;
|
|
3072
2486
|
cycleDue = false;
|
|
3073
2487
|
running = null;
|
|
3074
2488
|
stopped = false;
|
|
3075
|
-
|
|
3076
|
-
|
|
2489
|
+
pendingInvites = [];
|
|
2490
|
+
invitesDirty = false;
|
|
3077
2491
|
retryRung = 0;
|
|
2492
|
+
turnsInFlight = 0;
|
|
3078
2493
|
cycles = 0;
|
|
3079
2494
|
turns = 0;
|
|
3080
2495
|
inviteTurns = 0;
|
|
3081
2496
|
constructor(options) {
|
|
3082
2497
|
this.accountId = options.accountId;
|
|
3083
2498
|
this.agentId = options.agentId;
|
|
3084
|
-
this.
|
|
3085
|
-
this.
|
|
3086
|
-
this.
|
|
3087
|
-
this.
|
|
2499
|
+
this.client = options.client;
|
|
2500
|
+
this.callModel = options.callModel;
|
|
2501
|
+
this.startTurn = options.startTurn;
|
|
2502
|
+
this.texts = options.texts;
|
|
2503
|
+
this.invites = options.invites;
|
|
2504
|
+
this.logger = options.logger.child({ component: "integration", accountId: options.accountId });
|
|
2505
|
+
this.metrics = options.metrics ?? createNoopMetrics();
|
|
3088
2506
|
this.gateEnabled = options.gateEnabled ?? true;
|
|
3089
|
-
this.gateFailOpen = options.gateFailOpen ?? false;
|
|
3090
|
-
this.gateTimeoutMs = options.gateTimeoutMs ?? DEFAULT_GATE_TIMEOUT_MS;
|
|
3091
2507
|
this.ladder = options.retryLadderMs ?? RETRY_LADDER_MS;
|
|
3092
2508
|
this.now = options.now ?? Date.now;
|
|
3093
|
-
this.coalescer = new
|
|
3094
|
-
onFire: () => this.
|
|
2509
|
+
this.coalescer = new WakeCoalescer({
|
|
2510
|
+
onFire: () => this.onWakeFired(),
|
|
2511
|
+
onDelayedWake: () => {
|
|
2512
|
+
this.logger.debug({ source: "retry" }, "wake");
|
|
2513
|
+
this.metrics.incWake({ source: "retry" });
|
|
2514
|
+
},
|
|
3095
2515
|
debounceMs: options.debounceMs ?? DEFAULT_DEBOUNCE_MS,
|
|
3096
2516
|
now: this.now,
|
|
3097
2517
|
...options.setTimeout ? { setTimeout: options.setTimeout } : {},
|
|
3098
2518
|
...options.clearTimeout ? { clearTimeout: options.clearTimeout } : {}
|
|
3099
2519
|
});
|
|
3100
2520
|
}
|
|
3101
|
-
// ───
|
|
3102
|
-
/** A
|
|
3103
|
-
|
|
2521
|
+
// ─── wakes ──────────────────────────────────────────────────────────
|
|
2522
|
+
/** A wake from the socket (a frame, a connect, a reminder) or any other source. Coalesced, then cycled. */
|
|
2523
|
+
wake(source) {
|
|
3104
2524
|
if (this.stopped) return;
|
|
3105
|
-
this.logger.debug({ source }, "
|
|
3106
|
-
this.coalescer.
|
|
2525
|
+
this.logger.debug({ source }, "wake");
|
|
2526
|
+
this.coalescer.wake();
|
|
3107
2527
|
}
|
|
3108
2528
|
/**
|
|
3109
|
-
* The second
|
|
3110
|
-
*
|
|
3111
|
-
*
|
|
2529
|
+
* The second wake kind. An invite already offered (this process or an
|
|
2530
|
+
* earlier one, per the ledger) or already pending is ignored, so an
|
|
2531
|
+
* invite seen live and again on a connect-time catch-up is decided once.
|
|
2532
|
+
* Returns true when newly queued.
|
|
3112
2533
|
*/
|
|
3113
2534
|
groupInvite(invite, source) {
|
|
3114
2535
|
if (this.stopped) return false;
|
|
3115
|
-
if (this.
|
|
3116
|
-
this.
|
|
2536
|
+
if (this.invites.isOffered(invite.inviteId)) return false;
|
|
2537
|
+
if (this.pendingInvites.some((pending) => pending.inviteId === invite.inviteId)) return false;
|
|
3117
2538
|
this.logger.info(
|
|
3118
2539
|
{ groupId: invite.groupId, groupName: invite.groupName, inviter: invite.inviterHandle, inviteId: invite.inviteId, source },
|
|
3119
2540
|
"group invite \u2014 queuing one invite turn"
|
|
3120
2541
|
);
|
|
3121
|
-
this.
|
|
2542
|
+
this.pendingInvites.push(invite);
|
|
2543
|
+
this.invitesDirty = true;
|
|
3122
2544
|
this.schedule();
|
|
3123
2545
|
return true;
|
|
3124
2546
|
}
|
|
@@ -3127,7 +2549,7 @@ var AgentInvoker = class {
|
|
|
3127
2549
|
this.stopped = true;
|
|
3128
2550
|
this.coalescer.stop();
|
|
3129
2551
|
}
|
|
3130
|
-
/** The promise of the
|
|
2552
|
+
/** The promise of the work currently running, for tests and for graceful stops. */
|
|
3131
2553
|
settled() {
|
|
3132
2554
|
return this.running ?? Promise.resolve();
|
|
3133
2555
|
}
|
|
@@ -3136,14 +2558,17 @@ var AgentInvoker = class {
|
|
|
3136
2558
|
cycles: this.cycles,
|
|
3137
2559
|
turns: this.turns,
|
|
3138
2560
|
inviteTurns: this.inviteTurns,
|
|
3139
|
-
|
|
2561
|
+
turnsInFlight: this.turnsInFlight,
|
|
2562
|
+
wakes: this.coalescer.wakes,
|
|
3140
2563
|
absorbed: this.coalescer.absorbed,
|
|
3141
|
-
retryRung: this.retryRung
|
|
2564
|
+
retryRung: this.retryRung,
|
|
2565
|
+
pendingInvites: this.pendingInvites.length
|
|
3142
2566
|
};
|
|
3143
2567
|
}
|
|
3144
2568
|
// ─── worker ─────────────────────────────────────────────────────────
|
|
3145
|
-
|
|
2569
|
+
onWakeFired() {
|
|
3146
2570
|
this.cycleDue = true;
|
|
2571
|
+
if (this.pendingInvites.length > 0) this.invitesDirty = true;
|
|
3147
2572
|
this.schedule();
|
|
3148
2573
|
}
|
|
3149
2574
|
/** Run the worker if idle. One cycle at a time; work that lands mid-cycle runs afterwards. */
|
|
@@ -3151,14 +2576,14 @@ var AgentInvoker = class {
|
|
|
3151
2576
|
if (this.running) return;
|
|
3152
2577
|
this.running = this.drain().finally(() => {
|
|
3153
2578
|
this.running = null;
|
|
3154
|
-
if (!this.stopped && (this.cycleDue || this.
|
|
2579
|
+
if (!this.stopped && (this.cycleDue || this.invitesDirty)) this.schedule();
|
|
3155
2580
|
});
|
|
3156
2581
|
}
|
|
3157
2582
|
async drain() {
|
|
3158
2583
|
while (!this.stopped) {
|
|
3159
|
-
|
|
3160
|
-
|
|
3161
|
-
await this.
|
|
2584
|
+
if (this.invitesDirty) {
|
|
2585
|
+
this.invitesDirty = false;
|
|
2586
|
+
await this.runInviteTurns();
|
|
3162
2587
|
continue;
|
|
3163
2588
|
}
|
|
3164
2589
|
if (this.cycleDue) {
|
|
@@ -3166,8 +2591,7 @@ var AgentInvoker = class {
|
|
|
3166
2591
|
try {
|
|
3167
2592
|
await this.runCycle();
|
|
3168
2593
|
} catch (err) {
|
|
3169
|
-
this.logger.error({ err:
|
|
3170
|
-
this.scheduleRetry("unhandled error");
|
|
2594
|
+
this.logger.error({ err: describe4(err), ...this.retry() }, "cycle failed with an unhandled error \u2014 re-waking later");
|
|
3171
2595
|
}
|
|
3172
2596
|
continue;
|
|
3173
2597
|
}
|
|
@@ -3175,147 +2599,216 @@ var AgentInvoker = class {
|
|
|
3175
2599
|
}
|
|
3176
2600
|
}
|
|
3177
2601
|
// ─── one cycle ──────────────────────────────────────────────────────
|
|
3178
|
-
/** Read the tray, gate it, start a turn
|
|
2602
|
+
/** Read the tray, gate it, start a turn per reply. Public so tests can drive one cycle. */
|
|
3179
2603
|
async runCycle() {
|
|
3180
2604
|
this.cycles += 1;
|
|
2605
|
+
const started = this.now();
|
|
3181
2606
|
let tray;
|
|
3182
2607
|
try {
|
|
3183
|
-
tray = await this.
|
|
2608
|
+
tray = await this.client.inbox.tray({ waitMs: 0 });
|
|
3184
2609
|
} catch (err) {
|
|
3185
|
-
this.logger.warn({ err:
|
|
3186
|
-
this.
|
|
3187
|
-
return null;
|
|
2610
|
+
this.logger.warn({ err: describe4(err), ...this.retry() }, "tray read failed \u2014 re-waking later");
|
|
2611
|
+
return this.result("tray_failed", 0, false, started, describe4(err));
|
|
3188
2612
|
}
|
|
3189
|
-
const cards = cardsOf(tray);
|
|
2613
|
+
const cards = agentchatme.gate.cardsOf(tray);
|
|
3190
2614
|
const truncated = tray.truncated === true;
|
|
3191
2615
|
if (cards.length === 0) {
|
|
3192
2616
|
this.logger.info({ deferred: tray.deferred ?? 0 }, "tray empty \u2014 nothing to decide");
|
|
3193
2617
|
this.retryRung = 0;
|
|
3194
|
-
return
|
|
2618
|
+
return this.result("empty", 0, truncated, started);
|
|
2619
|
+
}
|
|
2620
|
+
const texts = await this.texts.ensure();
|
|
2621
|
+
if (!texts) {
|
|
2622
|
+
this.logger.warn({ cards: cards.length, ...this.retry() }, "served texts not available \u2014 not gating; the cards wait on the tray");
|
|
2623
|
+
return this.result("texts_missing", cards.length, truncated, started, "texts missing");
|
|
3195
2624
|
}
|
|
3196
2625
|
let result;
|
|
3197
2626
|
if (!this.gateEnabled) {
|
|
3198
|
-
this.
|
|
3199
|
-
result = emptyResult("disabled", truncated, cardIds(cards));
|
|
2627
|
+
result = await this.runUngated(cards.length, texts, truncated, started);
|
|
3200
2628
|
} else {
|
|
3201
|
-
result = await
|
|
3202
|
-
tray,
|
|
3203
|
-
mainLine: this.mainLine,
|
|
3204
|
-
caller: this.gateCaller,
|
|
3205
|
-
failOpen: this.gateFailOpen,
|
|
3206
|
-
timeoutMs: this.gateTimeoutMs,
|
|
3207
|
-
now: this.now,
|
|
3208
|
-
log: (level, message) => this.logger[level]({}, message)
|
|
3209
|
-
});
|
|
3210
|
-
const counts = countVerdicts(result);
|
|
3211
|
-
this.logger.info(
|
|
3212
|
-
{
|
|
3213
|
-
cards: result.cards,
|
|
3214
|
-
reply: counts.reply,
|
|
3215
|
-
dismiss: counts.dismiss,
|
|
3216
|
-
defer: counts.defer,
|
|
3217
|
-
undecided: result.undecided.length,
|
|
3218
|
-
posted: result.posted,
|
|
3219
|
-
postFailures: result.postFailures,
|
|
3220
|
-
source: result.source,
|
|
3221
|
-
latencyMs: result.latencyMs,
|
|
3222
|
-
...result.failure ? { failure: result.failure } : {}
|
|
3223
|
-
},
|
|
3224
|
-
"gate"
|
|
3225
|
-
);
|
|
2629
|
+
result = await this.runGated(tray, cards.length, texts, truncated, started);
|
|
3226
2630
|
}
|
|
3227
|
-
if (result.
|
|
3228
|
-
this.
|
|
3229
|
-
|
|
2631
|
+
if (truncated && result.outcome !== "fail_closed") {
|
|
2632
|
+
this.logger.info({}, "tray truncated \u2014 waking again for the rest");
|
|
2633
|
+
this.coalescer.wake();
|
|
3230
2634
|
}
|
|
3231
|
-
|
|
3232
|
-
|
|
3233
|
-
|
|
3234
|
-
|
|
3235
|
-
|
|
3236
|
-
|
|
3237
|
-
|
|
3238
|
-
|
|
2635
|
+
return result;
|
|
2636
|
+
}
|
|
2637
|
+
/** Gate off: the agent judges in-turn with the hosted tools. One turn, nothing recorded here. */
|
|
2638
|
+
async runUngated(cards, texts, truncated, started) {
|
|
2639
|
+
this.logger.info({ cards }, "gate off \u2014 starting one turn with the served wake instruction");
|
|
2640
|
+
const sessionKey = wakeSessionKey(this.agentId, this.now());
|
|
2641
|
+
this.logger.info({ sessionKey }, "turn start");
|
|
2642
|
+
const admission = await this.startTurn({ sessionKey, prompt: wakeTurnPrompt(texts), lane: integrationLane(this.accountId) });
|
|
2643
|
+
if (!admission.ran) {
|
|
2644
|
+
this.logger.warn({ sessionKey, error: admission.error, ...this.retry() }, "turn not started \u2014 re-waking later");
|
|
3239
2645
|
} else {
|
|
2646
|
+
this.admitted(sessionKey, admission, "turn complete (final text discarded; the send is a hosted-tool call)");
|
|
3240
2647
|
this.retryRung = 0;
|
|
3241
2648
|
}
|
|
3242
|
-
|
|
3243
|
-
this.
|
|
3244
|
-
|
|
2649
|
+
return {
|
|
2650
|
+
...this.result("gate_off", cards, truncated, started),
|
|
2651
|
+
turnsStarted: admission.ran ? 1 : 0,
|
|
2652
|
+
turnsRefused: admission.ran ? 0 : 1
|
|
2653
|
+
};
|
|
2654
|
+
}
|
|
2655
|
+
async runGated(tray, cards, texts, truncated, started) {
|
|
2656
|
+
const decided = await agentchatme.gate.run({ tray, callModel: this.callModel, client: this.client, toolNamer: OPENCLAW_TOOL_NAMER });
|
|
2657
|
+
const latencyMs = this.now() - started;
|
|
2658
|
+
const counts = { reply: 0, dismiss: 0, defer: 0 };
|
|
2659
|
+
for (const verdict of decided.verdicts) counts[verdict.decision] += 1;
|
|
2660
|
+
if (decided.outcome === "fail_closed") {
|
|
2661
|
+
this.logger.warn({ cards, failure: decided.failure, latencyMs, ...this.retry() }, "gate failed closed \u2014 nothing recorded, no turn started");
|
|
2662
|
+
return { ...this.result("fail_closed", cards, truncated, started, decided.failure), undecided: cards, latencyMs };
|
|
3245
2663
|
}
|
|
3246
|
-
|
|
2664
|
+
if (decided.outcome === "empty") {
|
|
2665
|
+
this.retryRung = 0;
|
|
2666
|
+
return this.result("empty", cards, truncated, started);
|
|
2667
|
+
}
|
|
2668
|
+
let turnsStarted = 0;
|
|
2669
|
+
let turnsRefused = 0;
|
|
2670
|
+
let recordFailures = decided.recordFailures.length;
|
|
2671
|
+
let recorded = decided.recorded;
|
|
2672
|
+
for (const entry of decided.reply) {
|
|
2673
|
+
const sessionKey = wakeSessionKey(this.agentId, this.now());
|
|
2674
|
+
this.logger.info({ sessionKey, conversationId: entry.conversationId }, "turn start");
|
|
2675
|
+
const admission = await this.startTurn({ sessionKey, prompt: wakeTurnPrompt(texts, entry.conversationId), lane: integrationLane(this.accountId) });
|
|
2676
|
+
if (!admission.ran) {
|
|
2677
|
+
turnsRefused += 1;
|
|
2678
|
+
this.logger.warn({ sessionKey, conversationId: entry.conversationId, error: admission.error }, "turn not started \u2014 reply not recorded; the conversation stays unread");
|
|
2679
|
+
continue;
|
|
2680
|
+
}
|
|
2681
|
+
turnsStarted += 1;
|
|
2682
|
+
this.admitted(sessionKey, admission, "turn complete (final text discarded; the send is a hosted-tool call)");
|
|
2683
|
+
try {
|
|
2684
|
+
await entry.record();
|
|
2685
|
+
recorded += 1;
|
|
2686
|
+
} catch (err) {
|
|
2687
|
+
recordFailures += 1;
|
|
2688
|
+
this.logger.warn({ conversationId: entry.conversationId, err: describe4(err) }, "reply verdict not recorded \u2014 the turn runs; the conversation stays unread until it decides");
|
|
2689
|
+
}
|
|
2690
|
+
}
|
|
2691
|
+
const summary = {
|
|
2692
|
+
cards,
|
|
2693
|
+
reply: counts.reply,
|
|
2694
|
+
dismiss: counts.dismiss,
|
|
2695
|
+
defer: counts.defer,
|
|
2696
|
+
undecided: decided.undecided.length,
|
|
2697
|
+
recorded,
|
|
2698
|
+
recordFailures,
|
|
2699
|
+
turnsStarted,
|
|
2700
|
+
turnsRefused,
|
|
2701
|
+
latencyMs
|
|
2702
|
+
};
|
|
2703
|
+
if (turnsRefused > 0) {
|
|
2704
|
+
this.logger.warn({ ...summary, ...this.retry() }, "gate \u2014 some turns were refused; re-waking later");
|
|
2705
|
+
} else if (recordFailures > 0 || decided.undecided.length > 0) {
|
|
2706
|
+
this.logger.warn({ ...summary, ...this.retry() }, "gate \u2014 cards left on the tray; re-waking later");
|
|
2707
|
+
} else {
|
|
2708
|
+
this.retryRung = 0;
|
|
2709
|
+
this.logger.info(summary, "gate");
|
|
2710
|
+
}
|
|
2711
|
+
return { ...this.result("decided", cards, truncated, started), ...summary };
|
|
2712
|
+
}
|
|
2713
|
+
result(outcome, cards, truncated, started, failure = null) {
|
|
2714
|
+
return {
|
|
2715
|
+
outcome,
|
|
2716
|
+
cards,
|
|
2717
|
+
reply: 0,
|
|
2718
|
+
dismiss: 0,
|
|
2719
|
+
defer: 0,
|
|
2720
|
+
undecided: 0,
|
|
2721
|
+
recorded: 0,
|
|
2722
|
+
recordFailures: 0,
|
|
2723
|
+
turnsStarted: 0,
|
|
2724
|
+
turnsRefused: 0,
|
|
2725
|
+
truncated,
|
|
2726
|
+
latencyMs: this.now() - started,
|
|
2727
|
+
failure
|
|
2728
|
+
};
|
|
3247
2729
|
}
|
|
3248
|
-
|
|
2730
|
+
/** Arm the next rung (or report why not). Returned as log fields so every caller writes ONE line. */
|
|
2731
|
+
retry() {
|
|
3249
2732
|
if (this.coalescer.delayedPending) {
|
|
3250
|
-
|
|
3251
|
-
return;
|
|
2733
|
+
return { retry: { kind: "pending" } };
|
|
3252
2734
|
}
|
|
3253
2735
|
if (this.retryRung >= this.ladder.length) {
|
|
3254
|
-
|
|
3255
|
-
return;
|
|
2736
|
+
return { retry: { kind: "exhausted" } };
|
|
3256
2737
|
}
|
|
3257
|
-
const
|
|
2738
|
+
const delayMs = this.ladder[this.retryRung] ?? this.ladder[this.ladder.length - 1] ?? 6e4;
|
|
3258
2739
|
this.retryRung += 1;
|
|
3259
|
-
this.
|
|
3260
|
-
this.
|
|
2740
|
+
this.coalescer.wakeAfter(delayMs);
|
|
2741
|
+
return { retry: { kind: "armed", delayMs, rung: this.retryRung } };
|
|
3261
2742
|
}
|
|
3262
2743
|
// ─── turns ──────────────────────────────────────────────────────────
|
|
3263
|
-
/**
|
|
3264
|
-
|
|
3265
|
-
|
|
3266
|
-
|
|
3267
|
-
|
|
3268
|
-
|
|
3269
|
-
|
|
3270
|
-
|
|
3271
|
-
|
|
3272
|
-
|
|
3273
|
-
|
|
3274
|
-
|
|
3275
|
-
|
|
3276
|
-
|
|
2744
|
+
/**
|
|
2745
|
+
* Book an admitted turn and log its end whenever it comes. The cycle moves
|
|
2746
|
+
* on at once; OpenClaw's lane keeps the runs of one account in order.
|
|
2747
|
+
*/
|
|
2748
|
+
admitted(sessionKey, admission, completeLine) {
|
|
2749
|
+
this.turns += 1;
|
|
2750
|
+
this.turnsInFlight += 1;
|
|
2751
|
+
void admission.done.then(
|
|
2752
|
+
(outcome) => {
|
|
2753
|
+
this.turnsInFlight -= 1;
|
|
2754
|
+
this.logger[outcome.error ? "warn" : "info"](
|
|
2755
|
+
{ sessionKey, runId: outcome.runId, status: outcome.status, ...outcome.error ? { error: outcome.error } : {} },
|
|
2756
|
+
completeLine
|
|
2757
|
+
);
|
|
2758
|
+
},
|
|
2759
|
+
(err) => {
|
|
2760
|
+
this.turnsInFlight -= 1;
|
|
2761
|
+
this.logger.warn({ sessionKey, runId: admission.runId, err: describe4(err) }, `${completeLine} \u2014 the wait failed`);
|
|
2762
|
+
}
|
|
3277
2763
|
);
|
|
3278
|
-
return outcome.ran;
|
|
3279
2764
|
}
|
|
3280
|
-
|
|
3281
|
-
|
|
3282
|
-
|
|
3283
|
-
|
|
3284
|
-
|
|
3285
|
-
|
|
3286
|
-
|
|
3287
|
-
|
|
3288
|
-
|
|
3289
|
-
|
|
3290
|
-
|
|
3291
|
-
|
|
2765
|
+
/**
|
|
2766
|
+
* Every pending invite gets one attempt. An invite leaves the pending list
|
|
2767
|
+
* only once its turn was admitted (and is then remembered in the ledger);
|
|
2768
|
+
* a refused one stays there for the next wake. Invites that arrive while
|
|
2769
|
+
* this runs are appended and get their pass on the next drain.
|
|
2770
|
+
*/
|
|
2771
|
+
async runInviteTurns() {
|
|
2772
|
+
const batch = [...this.pendingInvites];
|
|
2773
|
+
let texts = null;
|
|
2774
|
+
let refused = 0;
|
|
2775
|
+
let waitingForTexts = 0;
|
|
2776
|
+
for (const invite of batch) {
|
|
2777
|
+
if (this.stopped) return;
|
|
2778
|
+
texts ??= await this.texts.ensure();
|
|
2779
|
+
if (!texts) {
|
|
2780
|
+
waitingForTexts = batch.length;
|
|
2781
|
+
break;
|
|
2782
|
+
}
|
|
2783
|
+
const sessionKey = inviteSessionKey(this.agentId, invite.inviteId);
|
|
2784
|
+
this.logger.info({ sessionKey, groupId: invite.groupId, inviteId: invite.inviteId }, "group-invite turn start");
|
|
2785
|
+
let admission;
|
|
2786
|
+
try {
|
|
2787
|
+
admission = await this.startTurn({ sessionKey, prompt: inviteTurnPrompt(texts), lane: integrationLane(this.accountId) });
|
|
2788
|
+
} catch (err) {
|
|
2789
|
+
admission = { ran: false, error: describe4(err) };
|
|
2790
|
+
}
|
|
2791
|
+
if (!admission.ran) {
|
|
2792
|
+
refused += 1;
|
|
2793
|
+
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");
|
|
2794
|
+
continue;
|
|
2795
|
+
}
|
|
2796
|
+
this.inviteTurns += 1;
|
|
2797
|
+
this.invites.markOffered(invite.inviteId);
|
|
2798
|
+
this.pendingInvites = this.pendingInvites.filter((pending) => pending.inviteId !== invite.inviteId);
|
|
2799
|
+
this.admitted(sessionKey, admission, "group-invite turn complete");
|
|
2800
|
+
}
|
|
2801
|
+
if (this.stopped) return;
|
|
2802
|
+
if (waitingForTexts > 0) {
|
|
2803
|
+
this.logger.warn({ pending: waitingForTexts, ...this.retry() }, "served texts not available \u2014 invite turns wait; re-waking later");
|
|
2804
|
+
} else if (refused > 0) {
|
|
2805
|
+
this.logger.warn({ pending: refused, ...this.retry() }, "invite turns refused \u2014 re-waking later");
|
|
3292
2806
|
}
|
|
3293
2807
|
}
|
|
3294
2808
|
};
|
|
3295
|
-
function
|
|
2809
|
+
function describe4(err) {
|
|
3296
2810
|
return err instanceof Error ? err.message : String(err);
|
|
3297
2811
|
}
|
|
3298
|
-
var cache = /* @__PURE__ */ new Map();
|
|
3299
|
-
function getClient({ accountId, config, options }) {
|
|
3300
|
-
const existing = cache.get(accountId);
|
|
3301
|
-
if (existing && existing.apiKey === config.apiKey && existing.apiBase === config.apiBase) {
|
|
3302
|
-
return existing.client;
|
|
3303
|
-
}
|
|
3304
|
-
const client = new agentchatme.AgentChatClient({
|
|
3305
|
-
apiKey: config.apiKey,
|
|
3306
|
-
baseUrl: config.apiBase,
|
|
3307
|
-
...options,
|
|
3308
|
-
fetch: withAgentChatClientIdentity(options?.fetch ?? globalThis.fetch)
|
|
3309
|
-
});
|
|
3310
|
-
cache.set(accountId, {
|
|
3311
|
-
client,
|
|
3312
|
-
apiKey: config.apiKey,
|
|
3313
|
-
apiBase: config.apiBase
|
|
3314
|
-
});
|
|
3315
|
-
return client;
|
|
3316
|
-
}
|
|
3317
|
-
|
|
3318
|
-
// src/binding/gateway.ts
|
|
3319
2812
|
function adaptLog(log) {
|
|
3320
2813
|
if (!log) return void 0;
|
|
3321
2814
|
const adapted = {
|
|
@@ -3331,18 +2824,6 @@ function adaptLog(log) {
|
|
|
3331
2824
|
function withLifecycle(snapshot, lifecycle) {
|
|
3332
2825
|
return Object.assign({}, snapshot, { lifecycle });
|
|
3333
2826
|
}
|
|
3334
|
-
function statusStateFor(kind) {
|
|
3335
|
-
switch (kind) {
|
|
3336
|
-
case "READY":
|
|
3337
|
-
return "linked";
|
|
3338
|
-
case "AUTH_FAIL":
|
|
3339
|
-
return "not-linked";
|
|
3340
|
-
case "CLOSED":
|
|
3341
|
-
return "configured";
|
|
3342
|
-
default:
|
|
3343
|
-
return "unstable";
|
|
3344
|
-
}
|
|
3345
|
-
}
|
|
3346
2827
|
function formatLogLine(obj, msg) {
|
|
3347
2828
|
const head = msg ?? "";
|
|
3348
2829
|
const keys = Object.keys(obj);
|
|
@@ -3373,24 +2854,30 @@ var agentchatGatewayAdapter = {
|
|
|
3373
2854
|
const config = account.config;
|
|
3374
2855
|
const logger = adaptLog(ctx.log) ?? createLogger({ level: config.observability.logLevel, redactKeys: config.observability.redactKeys });
|
|
3375
2856
|
ctx.setStatus(withLifecycle({ ...ctx.getStatus(), running: true, connected: false }, "starting"));
|
|
3376
|
-
|
|
2857
|
+
const wakeMode = readEnv_js.readWakeModeFromEnv();
|
|
2858
|
+
if (wakeMode.mode === "off") {
|
|
3377
2859
|
ctx.log?.info?.(
|
|
3378
|
-
`[agentchat:${ctx.accountId}]
|
|
2860
|
+
`[agentchat:${ctx.accountId}] ${wakeMode.variable}=off \u2014 no socket, no wakes, no turns; the hosted tools and the manual stay placed` + (wakeMode.variable === readEnv_js.LEGACY_WAKE_MODE_ENV ? ` (${readEnv_js.LEGACY_WAKE_MODE_ENV} is the old spelling; ${readEnv_js.WAKE_MODE_ENV} is the new one)` : "")
|
|
3379
2861
|
);
|
|
3380
2862
|
ctx.setStatus(withLifecycle({ ...ctx.getStatus(), running: false, connected: false, linked: true, statusState: "disabled" }, "stopped"));
|
|
3381
2863
|
await waitUntilAbort(ctx.abortSignal, () => void 0);
|
|
3382
2864
|
return;
|
|
3383
2865
|
}
|
|
2866
|
+
if (readEnv_js.readLegacyReplyGateFailOpenFromEnv()) {
|
|
2867
|
+
ctx.log?.warn?.(
|
|
2868
|
+
`[agentchat:${ctx.accountId}] ${readEnv_js.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`
|
|
2869
|
+
);
|
|
2870
|
+
}
|
|
3384
2871
|
const refusal = multiAccountRefusal(ctx.cfg);
|
|
3385
2872
|
if (refusal) {
|
|
3386
|
-
ctx.log?.error?.(`[agentchat:${ctx.accountId}]
|
|
2873
|
+
ctx.log?.error?.(`[agentchat:${ctx.accountId}] integration not started \u2014 ${refusal}`);
|
|
3387
2874
|
ctx.setStatus(withLifecycle({ ...ctx.getStatus(), running: false, connected: false, statusState: "not-linked", lastDisconnect: { at: Date.now(), error: refusal } }, "blocked"));
|
|
3388
2875
|
await waitUntilAbort(ctx.abortSignal, () => void 0);
|
|
3389
2876
|
return;
|
|
3390
2877
|
}
|
|
3391
2878
|
const channelRuntime = ctx.channelRuntime;
|
|
3392
2879
|
const { agentId, agentIdOverride } = resolveGateAgent({
|
|
3393
|
-
routedAgentId:
|
|
2880
|
+
routedAgentId: resolveIntegrationAgentId({ cfg: ctx.cfg, accountId: ctx.accountId, channelRuntime }),
|
|
3394
2881
|
ambientAgentId: openclawLayout_js.resolveOpenClawDefaultAgentId(ctx.cfg)
|
|
3395
2882
|
});
|
|
3396
2883
|
if (agentIdOverride && !readLlmAgentOverrideOptIn(ctx.cfg)) {
|
|
@@ -3398,44 +2885,90 @@ var agentchatGatewayAdapter = {
|
|
|
3398
2885
|
`[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`
|
|
3399
2886
|
);
|
|
3400
2887
|
}
|
|
3401
|
-
const
|
|
2888
|
+
const client = getClient({ accountId: ctx.accountId, config });
|
|
3402
2889
|
const gateTimeoutMs = readEnv_js.readReplyGateTimeoutMsFromEnv();
|
|
3403
|
-
|
|
2890
|
+
const texts = new TextsStore({ client, accountId: ctx.accountId, logger });
|
|
2891
|
+
const handle = config.agentHandle;
|
|
2892
|
+
if (handle) {
|
|
2893
|
+
texts.onServerCopy((copy) => {
|
|
2894
|
+
const refreshed = refreshIdentityLine(ctx.cfg, ctx.accountId, handle, copy.identity_line);
|
|
2895
|
+
if (refreshed.outcome === "updated") ctx.log?.info?.(`[agentchat:${ctx.accountId}] identity line refreshed from the served texts in ${refreshed.path}`);
|
|
2896
|
+
else if (refreshed.outcome === "failed") ctx.log?.warn?.(`[agentchat:${ctx.accountId}] identity line could not be refreshed in ${refreshed.path}: ${refreshed.detail ?? "unknown error"}`);
|
|
2897
|
+
});
|
|
2898
|
+
}
|
|
2899
|
+
await texts.start();
|
|
2900
|
+
const invites = new InviteLedger({
|
|
2901
|
+
accountId: ctx.accountId,
|
|
2902
|
+
onWriteError: (err) => ctx.log?.warn?.(`[agentchat:${ctx.accountId}] invite ledger could not be written: ${err instanceof Error ? err.message : String(err)}`)
|
|
2903
|
+
});
|
|
2904
|
+
await registerIntegration({
|
|
3404
2905
|
accountId: ctx.accountId,
|
|
3405
2906
|
config,
|
|
3406
2907
|
logger,
|
|
3407
|
-
|
|
2908
|
+
socketOptions: { client },
|
|
2909
|
+
build: (socket) => {
|
|
3408
2910
|
const invoker = new AgentInvoker({
|
|
3409
2911
|
accountId: ctx.accountId,
|
|
3410
2912
|
agentId,
|
|
3411
|
-
|
|
3412
|
-
|
|
3413
|
-
|
|
2913
|
+
client,
|
|
2914
|
+
callModel: createRuntimeModelCall({ agentIdOverride, ...gateTimeoutMs !== void 0 ? { timeoutMs: gateTimeoutMs } : {} }),
|
|
2915
|
+
startTurn: createRuntimeTurnStarter(),
|
|
2916
|
+
texts,
|
|
2917
|
+
invites,
|
|
3414
2918
|
logger,
|
|
3415
|
-
gateEnabled: readEnv_js.readReplyGateEnabledFromEnv()
|
|
3416
|
-
gateFailOpen: readEnv_js.readReplyGateFailOpenFromEnv(),
|
|
3417
|
-
...gateTimeoutMs !== void 0 ? { gateTimeoutMs } : {}
|
|
2919
|
+
gateEnabled: readEnv_js.readReplyGateEnabledFromEnv()
|
|
3418
2920
|
});
|
|
2921
|
+
let blocked = false;
|
|
3419
2922
|
return {
|
|
3420
2923
|
invoker,
|
|
2924
|
+
texts,
|
|
3421
2925
|
handlers: {
|
|
3422
|
-
|
|
2926
|
+
onWake: (source) => invoker.wake(source),
|
|
3423
2927
|
onGroupInvite: (invite) => invoker.groupInvite(invite, "live"),
|
|
3424
|
-
|
|
3425
|
-
|
|
2928
|
+
onConnected: (at) => {
|
|
2929
|
+
if (blocked) {
|
|
2930
|
+
blocked = false;
|
|
2931
|
+
ctx.log?.info?.(`[agentchat:${ctx.accountId}] key accepted again \u2014 blocked cleared`);
|
|
2932
|
+
}
|
|
2933
|
+
ctx.log?.info?.(`[agentchat:${ctx.accountId}] connected at ${new Date(at).toISOString()} (agent ${agentId})`);
|
|
3426
2934
|
ctx.setStatus(withLifecycle({ ...ctx.getStatus(), running: true, connected: true, linked: true, statusState: "linked", lastConnectedAt: at }, "ready"));
|
|
3427
|
-
void catchUpInvites(ctx.accountId,
|
|
2935
|
+
void catchUpInvites(ctx.accountId, client, invoker, logger);
|
|
2936
|
+
},
|
|
2937
|
+
onBlocked: (info) => {
|
|
2938
|
+
const close = `close ${info.code}${info.reason ? ` ${info.reason}` : ""}`;
|
|
2939
|
+
const next = info.retryInMs === null ? "no retry scheduled" : `next HELLO in about ${Math.max(1, Math.round(info.retryInMs / 6e4))} min`;
|
|
2940
|
+
if (blocked) {
|
|
2941
|
+
ctx.log?.debug?.(`[agentchat:${ctx.accountId}] still blocked (${close}; ${next})`);
|
|
2942
|
+
return;
|
|
2943
|
+
}
|
|
2944
|
+
blocked = true;
|
|
2945
|
+
ctx.log?.error?.(
|
|
2946
|
+
`[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`
|
|
2947
|
+
);
|
|
2948
|
+
ctx.setStatus(
|
|
2949
|
+
withLifecycle(
|
|
2950
|
+
{ ...ctx.getStatus(), running: false, connected: false, statusState: "not-linked", lastDisconnect: { at: Date.now(), error: `key rejected: ${close}` } },
|
|
2951
|
+
"blocked"
|
|
2952
|
+
)
|
|
2953
|
+
);
|
|
3428
2954
|
},
|
|
3429
2955
|
onError: (err) => {
|
|
3430
|
-
ctx.log?.warn?.(`[agentchat:${ctx.accountId}]
|
|
2956
|
+
ctx.log?.[blocked ? "debug" : "warn"]?.(`[agentchat:${ctx.accountId}] socket error: ${err.message}`);
|
|
3431
2957
|
},
|
|
3432
|
-
onStateChanged: (next) => {
|
|
3433
|
-
|
|
3434
|
-
|
|
3435
|
-
|
|
3436
|
-
|
|
3437
|
-
|
|
3438
|
-
|
|
2958
|
+
onStateChanged: (next, prev) => {
|
|
2959
|
+
switch (next) {
|
|
2960
|
+
case "backoff":
|
|
2961
|
+
if (blocked) {
|
|
2962
|
+
ctx.log?.debug?.(`[agentchat:${ctx.accountId}] socket in backoff while blocked (from ${prev})`);
|
|
2963
|
+
return;
|
|
2964
|
+
}
|
|
2965
|
+
ctx.setStatus(withLifecycle({ ...ctx.getStatus(), running: true, connected: false, statusState: "unstable" }, "recovering"));
|
|
2966
|
+
return;
|
|
2967
|
+
case "stopped":
|
|
2968
|
+
ctx.setStatus(withLifecycle({ ...ctx.getStatus(), running: false, connected: false, statusState: "configured" }, "stopped"));
|
|
2969
|
+
return;
|
|
2970
|
+
default:
|
|
2971
|
+
return;
|
|
3439
2972
|
}
|
|
3440
2973
|
}
|
|
3441
2974
|
}
|
|
@@ -3444,20 +2977,19 @@ var agentchatGatewayAdapter = {
|
|
|
3444
2977
|
});
|
|
3445
2978
|
await waitUntilAbort(ctx.abortSignal, async () => {
|
|
3446
2979
|
try {
|
|
3447
|
-
await
|
|
2980
|
+
await unregisterIntegration(ctx.accountId);
|
|
3448
2981
|
} catch (err) {
|
|
3449
2982
|
ctx.log?.error?.(`[agentchat:${ctx.accountId}] unregister failed on abort: ${err instanceof Error ? err.message : String(err)}`);
|
|
3450
2983
|
}
|
|
3451
2984
|
});
|
|
3452
2985
|
},
|
|
3453
2986
|
async stopAccount(ctx) {
|
|
3454
|
-
await
|
|
2987
|
+
await unregisterIntegration(ctx.accountId);
|
|
3455
2988
|
ctx.setStatus(withLifecycle({ ...ctx.getStatus(), running: false, connected: false }, "stopped"));
|
|
3456
2989
|
}
|
|
3457
2990
|
};
|
|
3458
|
-
async function catchUpInvites(accountId,
|
|
2991
|
+
async function catchUpInvites(accountId, client, invoker, logger) {
|
|
3459
2992
|
try {
|
|
3460
|
-
const client = getClient({ accountId, config });
|
|
3461
2993
|
const invites = await client.listGroupInvites();
|
|
3462
2994
|
if (!Array.isArray(invites)) return;
|
|
3463
2995
|
let surfaced = 0;
|
|
@@ -3465,10 +2997,10 @@ async function catchUpInvites(accountId, config, invoker, logger) {
|
|
|
3465
2997
|
const invite = groupInviteFromRecord(row);
|
|
3466
2998
|
if (invite && invoker.groupInvite(invite, "catch-up")) surfaced += 1;
|
|
3467
2999
|
}
|
|
3468
|
-
if (surfaced > 0) logger.info({ surfaced }, "pending group invites surfaced on connect");
|
|
3000
|
+
if (surfaced > 0) logger.info({ accountId, surfaced }, "pending group invites surfaced on connect");
|
|
3469
3001
|
} catch (err) {
|
|
3470
3002
|
logger.warn(
|
|
3471
|
-
{ err: err instanceof Error ? err.message : String(err) },
|
|
3003
|
+
{ accountId, err: err instanceof Error ? err.message : String(err) },
|
|
3472
3004
|
"pending-invite catch-up failed \u2014 live invite frames are unaffected and the agent can still list invites with the hosted tools"
|
|
3473
3005
|
);
|
|
3474
3006
|
}
|
|
@@ -3503,28 +3035,30 @@ var agentchatStatusAdapter = {
|
|
|
3503
3035
|
handle: config.agentHandle ?? me.handle,
|
|
3504
3036
|
apiKey: config.apiKey,
|
|
3505
3037
|
apiBase: config.apiBase,
|
|
3038
|
+
identityLine: cachedIdentityLine(account.accountId),
|
|
3506
3039
|
agentId: resolvePlacementAgentId(cfg, account.accountId),
|
|
3507
3040
|
accountId: account.accountId
|
|
3508
3041
|
});
|
|
3509
3042
|
const enabled = account.enabled && isAgentchatAccountEnabled(cfg, account.accountId);
|
|
3510
|
-
const live =
|
|
3511
|
-
const health = live?.
|
|
3043
|
+
const live = getIntegration(account.accountId);
|
|
3044
|
+
const health = live?.socket.getHealth();
|
|
3512
3045
|
const counters = live?.invoker?.counters();
|
|
3513
|
-
const
|
|
3514
|
-
|
|
3515
|
-
|
|
3516
|
-
...
|
|
3046
|
+
const textsSource = live ? live.texts?.source ?? "missing" : void 0;
|
|
3047
|
+
const integration = {
|
|
3048
|
+
mode: readEnv_js.readWakeModeFromEnv().mode,
|
|
3049
|
+
...health ? { state: health.state } : {},
|
|
3050
|
+
...counters ? { wakes: counters.wakes, cycles: counters.cycles, turns: counters.turns } : {},
|
|
3051
|
+
...textsSource ? { texts: textsSource } : {}
|
|
3517
3052
|
};
|
|
3518
3053
|
const refusal = multiAccountRefusal(cfg);
|
|
3519
|
-
const legacyServer = health !== void 0 && health.authenticated && !health.ackNegotiated;
|
|
3520
3054
|
return {
|
|
3521
|
-
ok: enabled && me.status === "active" && mcp.ok && placement.every((c) => c.ok) && !refusal
|
|
3055
|
+
ok: enabled && me.status === "active" && mcp.ok && placement.every((c) => c.ok) && !refusal,
|
|
3522
3056
|
handle: me.handle,
|
|
3523
3057
|
status: me.status,
|
|
3524
3058
|
pausedByOwner: me.paused_by_owner ?? "none",
|
|
3525
3059
|
mcp,
|
|
3526
3060
|
placement,
|
|
3527
|
-
|
|
3061
|
+
integration,
|
|
3528
3062
|
...refusal ? { refusal } : {},
|
|
3529
3063
|
...enabled ? {} : { disabled: agentchatReenableHint(cfg, account.accountId) }
|
|
3530
3064
|
};
|
|
@@ -3547,22 +3081,21 @@ var agentchatStatusAdapter = {
|
|
|
3547
3081
|
for (const check of probe.placement ?? []) {
|
|
3548
3082
|
lines.push({ text: `${check.name}: ${check.detail}`, tone: check.ok ? "muted" : "warn" });
|
|
3549
3083
|
}
|
|
3550
|
-
if (probe.refusal) lines.push({ text: `
|
|
3551
|
-
if (probe.
|
|
3552
|
-
const d = probe.
|
|
3553
|
-
if (d.mode === "off") lines.push({ text:
|
|
3084
|
+
if (probe.refusal) lines.push({ text: `integration not started \u2014 ${probe.refusal}`, tone: "error" });
|
|
3085
|
+
if (probe.integration) {
|
|
3086
|
+
const d = probe.integration;
|
|
3087
|
+
if (d.mode === "off") lines.push({ text: `integration off (${readEnv_js.WAKE_MODE_ENV}=off or ${readEnv_js.LEGACY_WAKE_MODE_ENV}=off): no socket, no wakes, no turns`, tone: "warn" });
|
|
3554
3088
|
else if (d.state) {
|
|
3555
3089
|
lines.push({
|
|
3556
|
-
text: `
|
|
3557
|
-
tone: d.state === "
|
|
3090
|
+
text: `integration ${d.state} \u2014 wakes ${d.wakes ?? 0}, cycles ${d.cycles ?? 0}, turns ${d.turns ?? 0}`,
|
|
3091
|
+
tone: d.state === "ready" ? "success" : "warn"
|
|
3558
3092
|
});
|
|
3559
|
-
if (d.
|
|
3560
|
-
lines.push({
|
|
3561
|
-
|
|
3562
|
-
|
|
3563
|
-
});
|
|
3093
|
+
if (d.texts === "missing") {
|
|
3094
|
+
lines.push({ text: "served texts not available yet (AgentChat unreachable, nothing cached) \u2014 turns wait for the first copy", tone: "error" });
|
|
3095
|
+
} else if (d.texts === "cache") {
|
|
3096
|
+
lines.push({ text: "served texts from the cached copy \u2014 AgentChat was unreachable at start; refreshed when it is back", tone: "warn" });
|
|
3564
3097
|
}
|
|
3565
|
-
} else if (!probe.refusal) lines.push({ text: "
|
|
3098
|
+
} else if (!probe.refusal) lines.push({ text: "integration not running in this process", tone: "muted" });
|
|
3566
3099
|
}
|
|
3567
3100
|
return lines;
|
|
3568
3101
|
},
|
|
@@ -3577,7 +3110,7 @@ var agentchatDoctorAdapter = {
|
|
|
3577
3110
|
collectPreviewWarnings({ cfg, doctorFixCommand, env }) {
|
|
3578
3111
|
const warnings = [];
|
|
3579
3112
|
const refusal = multiAccountRefusal(cfg);
|
|
3580
|
-
if (refusal) warnings.push(`[${AGENTCHAT_CHANNEL_ID}]
|
|
3113
|
+
if (refusal) warnings.push(`[${AGENTCHAT_CHANNEL_ID}] integration will not start \u2014 ${refusal}`);
|
|
3581
3114
|
for (const accountId of listConfiguredAccountIds(cfg)) {
|
|
3582
3115
|
if (!isAgentchatAccountEnabled(cfg, accountId)) {
|
|
3583
3116
|
warnings.push(`[${AGENTCHAT_CHANNEL_ID}:${accountId}] ${agentchatReenableHint(cfg, accountId)}`);
|
|
@@ -3587,7 +3120,7 @@ var agentchatDoctorAdapter = {
|
|
|
3587
3120
|
const apiBase = readAgentchatConfigField(cfg, accountId, "apiBase") ?? DEFAULT_API_BASE2;
|
|
3588
3121
|
const handle = readAgentchatConfigField(cfg, accountId, "agentHandle");
|
|
3589
3122
|
const agentId = resolvePlacementAgentId(cfg, accountId);
|
|
3590
|
-
for (const check of checkPlacement({ cfg, handle, apiKey, apiBase, agentId, accountId, env })) {
|
|
3123
|
+
for (const check of checkPlacement({ cfg, handle, apiKey, apiBase, identityLine: cachedIdentityLine(accountId), agentId, accountId, env })) {
|
|
3591
3124
|
if (check.ok) continue;
|
|
3592
3125
|
const fix = check.name === "mcp" ? ` (${doctorFixCommand} adds it)` : "";
|
|
3593
3126
|
warnings.push(`[${AGENTCHAT_CHANNEL_ID}:${accountId}] ${check.name}: ${check.detail}${fix}`);
|
|
@@ -3635,9 +3168,11 @@ var agentchatDoctorAdapter = {
|
|
|
3635
3168
|
}
|
|
3636
3169
|
const handle = readAgentchatConfigField(next, accountId, "agentHandle");
|
|
3637
3170
|
if (apiKey && handle && placeIdentityLines) {
|
|
3638
|
-
const
|
|
3171
|
+
const identityLine = await loadIdentityLine({ client: createSdkClient({ apiKey, apiBase }), accountId });
|
|
3172
|
+
const restored = restoreIdentityLine(next, accountId, handle, identityLine);
|
|
3639
3173
|
if (restored.outcome === "placed") changes.push(`placed the identity line for @${handle.replace(/^@/, "")} in ${restored.path}`);
|
|
3640
3174
|
else if (restored.outcome === "failed") warnings.push(`[${AGENTCHAT_CHANNEL_ID}:${accountId}] could not place the identity line for @${handle.replace(/^@/, "")}: ${restored.detail ?? "unknown error"}`);
|
|
3175
|
+
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"}`);
|
|
3641
3176
|
}
|
|
3642
3177
|
}
|
|
3643
3178
|
for (const [apiBase, apiKey] of bases) {
|
|
@@ -3769,12 +3304,12 @@ var agentchatSetupAdapter = {
|
|
|
3769
3304
|
const apiKey = readAgentchatConfigField(withAccount, accountId, "apiKey");
|
|
3770
3305
|
if (!apiKey) return withAccount;
|
|
3771
3306
|
const apiBase = readAgentchatConfigField(withAccount, accountId, "apiBase") ?? DEFAULT_API_BASE2;
|
|
3772
|
-
return
|
|
3307
|
+
return applyIntegrationConfig(withAccount, { accountId, handle, apiKey, apiBase }).cfg;
|
|
3773
3308
|
},
|
|
3774
3309
|
/**
|
|
3775
|
-
* Files only: the key into OpenClaw's state-dir `.env`, the
|
|
3776
|
-
* into the bound agent's `AGENTS.md`. Reports through
|
|
3777
|
-
* Never throws: setup-time UX is "warn and proceed".
|
|
3310
|
+
* Files only: the key into OpenClaw's state-dir `.env`, the served
|
|
3311
|
+
* identity line into the bound agent's `AGENTS.md`. Reports through
|
|
3312
|
+
* `RuntimeEnv.log`. Never throws: setup-time UX is "warn and proceed".
|
|
3778
3313
|
*/
|
|
3779
3314
|
async afterAccountConfigWritten({ cfg, accountId, input, runtime }) {
|
|
3780
3315
|
const apiKey = typeof input.token === "string" ? input.token : readAgentchatConfigField(cfg, accountId, "apiKey");
|
|
@@ -3797,7 +3332,8 @@ var agentchatSetupAdapter = {
|
|
|
3797
3332
|
}
|
|
3798
3333
|
}
|
|
3799
3334
|
try {
|
|
3800
|
-
const
|
|
3335
|
+
const identityLine = await loadIdentityLine({ client: createSdkClient({ apiKey, apiBase }), accountId });
|
|
3336
|
+
const placed = placeIntegration({ cfg, handle, apiKey, apiBase, identityLine, accountId });
|
|
3801
3337
|
for (const line of formatPlacement(placed.steps.filter((s) => s.name !== "mcp"))) say(runtime, "log", `[agentchat:${accountId}] ${line}`);
|
|
3802
3338
|
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)`);
|
|
3803
3339
|
} catch (err) {
|
|
@@ -3806,11 +3342,11 @@ var agentchatSetupAdapter = {
|
|
|
3806
3342
|
}
|
|
3807
3343
|
};
|
|
3808
3344
|
function disableAccountConfig(cfg, accountId) {
|
|
3809
|
-
const stripped =
|
|
3345
|
+
const stripped = stripIntegrationConfig(cfg, accountId).cfg;
|
|
3810
3346
|
return channelPluginCommon.setAccountEnabledInConfigSection({ cfg: stripped, sectionKey: AGENTCHAT_CHANNEL_ID, accountId, enabled: false, allowTopLevel: true });
|
|
3811
3347
|
}
|
|
3812
3348
|
function deleteAccountConfig(cfg, accountId) {
|
|
3813
|
-
const stripped =
|
|
3349
|
+
const stripped = stripIntegrationConfig(cfg, accountId).cfg;
|
|
3814
3350
|
return channelPluginCommon.deleteAccountFromConfigSection({ cfg: stripped, sectionKey: AGENTCHAT_CHANNEL_ID, accountId, clearBaseFields: ["apiKey", "apiBase", "agentHandle"] });
|
|
3815
3351
|
}
|
|
3816
3352
|
function isAccountEnabled(cfg, accountId) {
|
|
@@ -3835,7 +3371,7 @@ var agentchatLifecycleAdapter = {
|
|
|
3835
3371
|
return;
|
|
3836
3372
|
}
|
|
3837
3373
|
if (!isEnabled) {
|
|
3838
|
-
for (const line of
|
|
3374
|
+
for (const line of removeIntegrationFiles(nextCfg, accountId, { clearKey: false })) say(runtime, "log", `[agentchat:${accountId}] ${line}`);
|
|
3839
3375
|
return;
|
|
3840
3376
|
}
|
|
3841
3377
|
const handle = validHandle(readAgentchatConfigField(nextCfg, accountId, "agentHandle"));
|
|
@@ -3843,12 +3379,16 @@ var agentchatLifecycleAdapter = {
|
|
|
3843
3379
|
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`);
|
|
3844
3380
|
return;
|
|
3845
3381
|
}
|
|
3846
|
-
const
|
|
3382
|
+
const apiKey = readAgentchatConfigField(nextCfg, accountId, "apiKey");
|
|
3383
|
+
const apiBase = readAgentchatConfigField(nextCfg, accountId, "apiBase") ?? DEFAULT_API_BASE2;
|
|
3384
|
+
const identityLine = apiKey ? await loadIdentityLine({ client: createSdkClient({ apiKey, apiBase }), accountId }) : null;
|
|
3385
|
+
const restored = restoreIdentityLine(nextCfg, accountId, handle, identityLine);
|
|
3847
3386
|
if (restored.outcome === "placed") say(runtime, "log", `[agentchat:${accountId}] placed the identity line for @${handle} in ${restored.path}`);
|
|
3387
|
+
else if (restored.outcome === "skipped") say(runtime, "log", `[agentchat:${accountId}] identity line for @${handle} not placed: ${restored.detail ?? "the served text is not available"}`);
|
|
3848
3388
|
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`);
|
|
3849
3389
|
},
|
|
3850
3390
|
async onAccountRemoved({ prevCfg, accountId, runtime }) {
|
|
3851
|
-
for (const line of
|
|
3391
|
+
for (const line of removeIntegrationFiles(prevCfg, accountId, { clearKey: true })) say(runtime, "log", `[agentchat:${accountId}] ${line}`);
|
|
3852
3392
|
}
|
|
3853
3393
|
};
|
|
3854
3394
|
var agentchatPlugin = {
|
|
@@ -3860,7 +3400,7 @@ var agentchatPlugin = {
|
|
|
3860
3400
|
detailLabel: "AgentChat",
|
|
3861
3401
|
docsPath: "/channels/agentchat",
|
|
3862
3402
|
docsLabel: "agentchat",
|
|
3863
|
-
blurb: "the AgentChat
|
|
3403
|
+
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.",
|
|
3864
3404
|
systemImage: "message",
|
|
3865
3405
|
markdownCapable: true,
|
|
3866
3406
|
order: 100
|
|
@@ -3952,7 +3492,7 @@ var agentchatPlugin = {
|
|
|
3952
3492
|
setup: agentchatSetupAdapter,
|
|
3953
3493
|
// ─── OpenClaw ↔ AgentChat binding ─────────────────────────────────────
|
|
3954
3494
|
//
|
|
3955
|
-
// gateway — holds the socket,
|
|
3495
|
+
// gateway — holds the socket, wakes, gates, starts turns (the integration).
|
|
3956
3496
|
// status — the doctor-style probe: key, hosted MCP reachability, placement.
|
|
3957
3497
|
// doctor — `openclaw doctor` warnings and the mcp.servers.agentchat repair.
|
|
3958
3498
|
//
|
|
@@ -3969,11 +3509,11 @@ var agentchatPlugin = {
|
|
|
3969
3509
|
channelCore.defineChannelPluginEntry({
|
|
3970
3510
|
id: AGENTCHAT_CHANNEL_ID,
|
|
3971
3511
|
name: "AgentChat",
|
|
3972
|
-
description: "The AgentChat
|
|
3512
|
+
description: "The AgentChat integration: wakes your OpenClaw agent when a peer writes on the messaging network for AI agents.",
|
|
3973
3513
|
plugin: agentchatPlugin,
|
|
3974
3514
|
// Called in every registration mode except cli-metadata and tool-discovery
|
|
3975
3515
|
// (docs.openclaw.ai/plugins/sdk-entrypoints/define-channel-plugin-entry).
|
|
3976
|
-
// The
|
|
3516
|
+
// The integration reads `runtime.llm.complete` (the gate on the agent's own
|
|
3977
3517
|
// model) and `runtime.subagent.run` (one turn, `deliver: false`) from it.
|
|
3978
3518
|
setRuntime: (runtime) => setPluginRuntime(runtime)
|
|
3979
3519
|
});
|