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