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