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