@hjd-hitsz/claudex-web 4.0.1 → 4.1.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +71 -0
- package/README.md +33 -55
- package/build-info.json +4 -4
- package/client/dist/app.js +95 -95
- package/client/dist/document-editor.js +96 -93
- package/client/dist/style.css +1 -1
- package/docs/architecture/backends.md +2 -0
- package/docs/architecture/behavior.md +34 -6
- package/docs/architecture.md +42 -5
- package/docs/deployment.md +34 -14
- package/docs/development.md +31 -4
- package/docs/images/desktop-dark.png +0 -0
- package/docs/images/desktop-light.png +0 -0
- package/docs/images/mobile.png +0 -0
- package/docs/releases/v4.1.0.md +21 -0
- package/docs/releases/v4.1.1.md +19 -0
- package/docs/versioning.md +10 -0
- package/package.json +25 -8
- package/packages/translation-engine/LICENSE +674 -0
- package/packages/translation-engine/README.md +69 -0
- package/packages/translation-engine/bin/tokenizer-linux-x64 +0 -0
- package/packages/translation-engine/bin/translate.mjs +29 -0
- package/packages/translation-engine/native/build.mjs +15 -0
- package/packages/translation-engine/native/tokenizer.c +73 -0
- package/packages/translation-engine/package.json +29 -0
- package/packages/translation-engine/src/catalog.mjs +103 -0
- package/packages/translation-engine/src/cpu-runtime.mjs +90 -0
- package/packages/translation-engine/src/download.mjs +94 -0
- package/packages/translation-engine/src/index.mjs +70 -0
- package/packages/translation-engine/src/inference.mjs +177 -0
- package/packages/translation-engine/src/model-store.mjs +197 -0
- package/packages/translation-engine/src/tokenizer.mjs +77 -0
- package/packages/translation-engine/src/worker.mjs +83 -0
- package/scripts/install-services.mjs +5 -4
- package/scripts/start-backend.mjs +7 -1
- package/server/src/application.mjs +40 -5
- package/server/src/backends/claude/catalogue.mjs +5 -3
- package/server/src/backends/claude/execution-session.mjs +7 -1
- package/server/src/backends/claude/messages.mjs +2 -1
- package/server/src/backends/claude/provider-environment.mjs +6 -4
- package/server/src/backends/claude/sessions.mjs +1 -0
- package/server/src/backends/claude/worker-client.mjs +13 -6
- package/server/src/backends/claude/worker-location.mjs +12 -0
- package/server/src/backends/cli-installation.mjs +28 -13
- package/server/src/backends/cli-package.mjs +116 -0
- package/server/src/backends/codex/adapter.mjs +2 -0
- package/server/src/backends/codex/events.mjs +1 -1
- package/server/src/backends/codex/token-usage.mjs +140 -0
- package/server/src/backends/manager.mjs +87 -21
- package/server/src/backends/provider-presets.mjs +1 -1
- package/server/src/backends/providers.mjs +6 -3
- package/server/src/backends/storage.mjs +7 -3
- package/server/src/config.mjs +7 -0
- package/server/src/http/maintenance.mjs +28 -0
- package/server/src/http/router.mjs +20 -2
- package/server/src/server.mjs +9 -0
- package/server/src/service-maintenance-worker.mjs +124 -0
- package/server/src/service-maintenance.mjs +222 -0
- package/server/src/summary-translation.mjs +42 -53
- package/server/src/token-usage-reconciliation.mjs +105 -0
- package/server/src/token-usage.mjs +208 -0
- package/server/src/translation-service.mjs +133 -0
|
@@ -32,7 +32,13 @@ export async function createExecutionSession({
|
|
|
32
32
|
beginActivity,
|
|
33
33
|
}) {
|
|
34
34
|
const threadId = session.id;
|
|
35
|
-
const usage = createTokenUsage({
|
|
35
|
+
const usage = createTokenUsage({
|
|
36
|
+
threadId,
|
|
37
|
+
session,
|
|
38
|
+
save,
|
|
39
|
+
emit: (method, params) =>
|
|
40
|
+
emit(method, { ...params, turnId: getCurrent()?.turn?.id }),
|
|
41
|
+
});
|
|
36
42
|
const provider = await providers.get(
|
|
37
43
|
backend.id,
|
|
38
44
|
queued.providerId ?? session.providerId,
|
|
@@ -169,9 +169,10 @@ export function isUserPrompt(message) {
|
|
|
169
169
|
!message.isVisibleInTranscriptOnly &&
|
|
170
170
|
!message.isSynthetic &&
|
|
171
171
|
message.origin?.kind !== "task-notification" &&
|
|
172
|
-
// SDK
|
|
172
|
+
// SDK 主对话附加记录仅继承入口;原生子代理任务由侧链及代理标识确认来源。
|
|
173
173
|
!(
|
|
174
174
|
message.entrypoint === "sdk-ts" &&
|
|
175
|
+
!(message.isSidechain === true && message.agentId) &&
|
|
175
176
|
message.promptId &&
|
|
176
177
|
!message.promptSource &&
|
|
177
178
|
!message.turnOrigin &&
|
|
@@ -11,6 +11,7 @@ export function claudeRuntimeEnvironment(backend) {
|
|
|
11
11
|
}
|
|
12
12
|
|
|
13
13
|
export function providerModelEnvironment(provider, model, effort) {
|
|
14
|
+
const selectedModel = model || provider.models[0];
|
|
14
15
|
const rules = Object.entries(provider.modelCapabilities || {}).flatMap(
|
|
15
16
|
([name, metadata]) => {
|
|
16
17
|
const capabilities = [];
|
|
@@ -33,9 +34,13 @@ export function providerModelEnvironment(provider, model, effort) {
|
|
|
33
34
|
},
|
|
34
35
|
);
|
|
35
36
|
return {
|
|
37
|
+
ANTHROPIC_MODEL: selectedModel,
|
|
38
|
+
ANTHROPIC_DEFAULT_OPUS_MODEL: selectedModel,
|
|
39
|
+
ANTHROPIC_DEFAULT_SONNET_MODEL: selectedModel,
|
|
40
|
+
ANTHROPIC_DEFAULT_HAIKU_MODEL: selectedModel,
|
|
36
41
|
CLAUDE_CODE_MODEL_CAPABILITIES: rules.join(";"),
|
|
37
42
|
CLAUDE_CODE_MAX_CONTEXT_TOKENS: String(
|
|
38
|
-
provider.modelCapabilities?.[
|
|
43
|
+
provider.modelCapabilities?.[selectedModel]?.contextWindow || "",
|
|
39
44
|
),
|
|
40
45
|
...((provider.protocol || "messages") === "messages" && {
|
|
41
46
|
CLAUDE_CODE_EFFORT_LEVEL: effort || "unset",
|
|
@@ -66,9 +71,6 @@ export function providerRuntimeEnvironment(
|
|
|
66
71
|
);
|
|
67
72
|
env.ANTHROPIC_BASE_URL = proxy?.url || provider.baseUrl;
|
|
68
73
|
env.ANTHROPIC_API_KEY = proxy?.token || provider.apiKey;
|
|
69
|
-
env.ANTHROPIC_MODEL = model || provider.models[0];
|
|
70
|
-
for (const level of ["OPUS", "SONNET", "HAIKU"])
|
|
71
|
-
env[`ANTHROPIC_DEFAULT_${level}_MODEL`] = env.ANTHROPIC_MODEL;
|
|
72
74
|
return env;
|
|
73
75
|
}
|
|
74
76
|
|
|
@@ -15,6 +15,7 @@ import {
|
|
|
15
15
|
import {
|
|
16
16
|
prepareWorkerDirectory,
|
|
17
17
|
verifyWorkerSocket,
|
|
18
|
+
workerConnectionError,
|
|
18
19
|
} from "./worker-location.mjs";
|
|
19
20
|
|
|
20
21
|
export function createClaudeWorkerAdapter({
|
|
@@ -147,12 +148,17 @@ export function createClaudeWorkerAdapter({
|
|
|
147
148
|
async function open() {
|
|
148
149
|
stopping = false;
|
|
149
150
|
await prepareWorkerDirectory(location.directory);
|
|
150
|
-
|
|
151
|
-
|
|
152
|
-
|
|
153
|
-
connection.
|
|
154
|
-
|
|
155
|
-
|
|
151
|
+
let connection;
|
|
152
|
+
try {
|
|
153
|
+
await verifyWorkerSocket(location.socket);
|
|
154
|
+
connection = net.connect(location.socket);
|
|
155
|
+
await new Promise((resolve, reject) => {
|
|
156
|
+
connection.once("connect", resolve);
|
|
157
|
+
connection.once("error", reject);
|
|
158
|
+
});
|
|
159
|
+
} catch (error) {
|
|
160
|
+
throw workerConnectionError(error);
|
|
161
|
+
}
|
|
156
162
|
socket = connection;
|
|
157
163
|
let input = "";
|
|
158
164
|
connection.setEncoding("utf8");
|
|
@@ -265,6 +271,7 @@ export function createClaudeWorkerAdapter({
|
|
|
265
271
|
try {
|
|
266
272
|
await connecting;
|
|
267
273
|
} catch (error) {
|
|
274
|
+
if (error.cause) console.error("Claude 后台服务连接失败:", error.cause);
|
|
268
275
|
snapshot = {
|
|
269
276
|
...snapshot,
|
|
270
277
|
params: { ...snapshot.params, ready: false, error: error.message },
|
|
@@ -29,3 +29,15 @@ export async function verifyWorkerSocket(path) {
|
|
|
29
29
|
if (!info.isSocket() || info.uid !== process.getuid() || info.mode & 0o077)
|
|
30
30
|
throw new Error("Claude IPC socket 必须由当前用户持有并使用0600权限。");
|
|
31
31
|
}
|
|
32
|
+
|
|
33
|
+
export function workerConnectionError(error) {
|
|
34
|
+
if (!["ENOENT", "ECONNREFUSED", "ECONNRESET", "EACCES"].includes(error.code))
|
|
35
|
+
return error;
|
|
36
|
+
const message =
|
|
37
|
+
error.code === "EACCES"
|
|
38
|
+
? "Claude 后台访问被拒绝,请检查服务权限。"
|
|
39
|
+
: "Claude 后台连接失败,正在重试";
|
|
40
|
+
const result = new Error(message, { cause: error });
|
|
41
|
+
result.code = error.code;
|
|
42
|
+
return result;
|
|
43
|
+
}
|
|
@@ -4,6 +4,11 @@ import { constants } from "node:fs";
|
|
|
4
4
|
import { dirname, delimiter, join } from "node:path";
|
|
5
5
|
import { homedir } from "node:os";
|
|
6
6
|
import { promisify } from "node:util";
|
|
7
|
+
import {
|
|
8
|
+
cliEnvironment,
|
|
9
|
+
cliFailure,
|
|
10
|
+
installCliPackage,
|
|
11
|
+
} from "./cli-package.mjs";
|
|
7
12
|
|
|
8
13
|
const execute = promisify(execFile);
|
|
9
14
|
const packages = {
|
|
@@ -64,6 +69,7 @@ export function createCliInstallation({
|
|
|
64
69
|
const executable = await locate(id);
|
|
65
70
|
const { stdout } = await run(executable, ["--version"], {
|
|
66
71
|
timeout: 10000,
|
|
72
|
+
env: cliEnvironment(),
|
|
67
73
|
});
|
|
68
74
|
const version = stdout.match(/\b\d+\.\d+\.\d+(?:-[\w.-]+)?\b/)?.[0];
|
|
69
75
|
if (!version) throw new Error("无法识别 CLI 版本:" + stdout.trim());
|
|
@@ -76,7 +82,16 @@ export function createCliInstallation({
|
|
|
76
82
|
installed: local.status === "fulfilled",
|
|
77
83
|
...(local.status === "fulfilled"
|
|
78
84
|
? local.value
|
|
79
|
-
: {
|
|
85
|
+
: {
|
|
86
|
+
currentVersion: "",
|
|
87
|
+
executable: null,
|
|
88
|
+
error: `${id === "codex" ? "Codex" : "Claude Code"} CLI 无法运行,可点击一键安装修复。`,
|
|
89
|
+
errorDetails:
|
|
90
|
+
local.reason.details ||
|
|
91
|
+
local.reason.stderr ||
|
|
92
|
+
local.reason.message,
|
|
93
|
+
}),
|
|
94
|
+
...(local.status === "fulfilled" && { errorDetails: "" }),
|
|
80
95
|
...(latest.status === "fulfilled"
|
|
81
96
|
? { latestVersion: latest.value }
|
|
82
97
|
: { latestError: latest.reason.message }),
|
|
@@ -88,23 +103,23 @@ export function createCliInstallation({
|
|
|
88
103
|
}
|
|
89
104
|
async function install(id) {
|
|
90
105
|
if (!packages[id]) throw new Error("未知后端");
|
|
91
|
-
patch(id, { installing: true, installError: "" });
|
|
106
|
+
patch(id, { installing: true, installError: "", installErrorDetails: "" });
|
|
92
107
|
try {
|
|
93
|
-
const
|
|
94
|
-
await run(npm, ["install", "--global", `${packages[id]}@latest`], {
|
|
95
|
-
timeout: 300000,
|
|
96
|
-
maxBuffer: 4 * 1024 * 1024,
|
|
97
|
-
env: {
|
|
98
|
-
...process.env,
|
|
99
|
-
PATH: `${dirname(process.execPath)}${delimiter}${process.env.PATH || ""}`,
|
|
100
|
-
},
|
|
101
|
-
});
|
|
108
|
+
const version = await installCliPackage(id, packages[id], run);
|
|
102
109
|
if (pending.has(id)) await pending.get(id);
|
|
103
110
|
await refresh(id);
|
|
104
|
-
if (!state(id).installed)
|
|
111
|
+
if (!state(id).installed)
|
|
112
|
+
throw cliFailure("安装后的 CLI 校验失败,可查看错误详情并重新安装。", {
|
|
113
|
+
details: state(id).errorDetails,
|
|
114
|
+
});
|
|
115
|
+
if (state(id).currentVersion !== version)
|
|
116
|
+
throw cliFailure("安装后的 CLI 版本不一致,可查看错误详情并重试。", {
|
|
117
|
+
details: `期望版本 ${version},实际版本 ${state(id).currentVersion}。`,
|
|
118
|
+
});
|
|
105
119
|
} catch (error) {
|
|
106
120
|
patch(id, {
|
|
107
|
-
installError:
|
|
121
|
+
installError: error.message,
|
|
122
|
+
installErrorDetails: error.details || error.stderr || error.message,
|
|
108
123
|
});
|
|
109
124
|
throw error;
|
|
110
125
|
} finally {
|
|
@@ -0,0 +1,116 @@
|
|
|
1
|
+
import { delimiter, dirname, join } from "node:path";
|
|
2
|
+
import { mkdtemp, rm } from "node:fs/promises";
|
|
3
|
+
import { tmpdir } from "node:os";
|
|
4
|
+
|
|
5
|
+
export function cliEnvironment() {
|
|
6
|
+
return {
|
|
7
|
+
...process.env,
|
|
8
|
+
PATH: `${dirname(process.execPath)}${delimiter}${process.env.PATH || ""}`,
|
|
9
|
+
};
|
|
10
|
+
}
|
|
11
|
+
|
|
12
|
+
export function cliFailure(message, cause) {
|
|
13
|
+
const error = new Error(message, { cause });
|
|
14
|
+
error.details =
|
|
15
|
+
cause.details ||
|
|
16
|
+
[cause.stderr, cause.stdout, cause.message]
|
|
17
|
+
.filter(Boolean)
|
|
18
|
+
.map((value) => String(value).trim())
|
|
19
|
+
.join("\n");
|
|
20
|
+
return error;
|
|
21
|
+
}
|
|
22
|
+
|
|
23
|
+
export function nativeCliDependency(
|
|
24
|
+
id,
|
|
25
|
+
manifest,
|
|
26
|
+
platform = process.platform,
|
|
27
|
+
arch = process.arch,
|
|
28
|
+
libc,
|
|
29
|
+
) {
|
|
30
|
+
const dependencies = manifest.optionalDependencies || {};
|
|
31
|
+
if (!Object.keys(dependencies).length) return null;
|
|
32
|
+
const prefix = id === "codex" ? "@openai/codex" : "@anthropic-ai/claude-code";
|
|
33
|
+
const suffix =
|
|
34
|
+
id === "claude" &&
|
|
35
|
+
platform === "linux" &&
|
|
36
|
+
(libc
|
|
37
|
+
? libc === "musl"
|
|
38
|
+
: !process.report.getReport().header.glibcVersionRuntime)
|
|
39
|
+
? "-musl"
|
|
40
|
+
: "";
|
|
41
|
+
const name = `${prefix}-${platform}-${arch}${suffix}`;
|
|
42
|
+
if (!dependencies[name])
|
|
43
|
+
throw new Error(`安装包未提供 ${platform}/${arch} 的原生组件。`);
|
|
44
|
+
return `${name}@${dependencies[name]}`;
|
|
45
|
+
}
|
|
46
|
+
|
|
47
|
+
export async function installCliPackage(id, packageName, run) {
|
|
48
|
+
const name = id === "codex" ? "Codex" : "Claude Code";
|
|
49
|
+
const npm = join(dirname(process.execPath), "npm");
|
|
50
|
+
const options = {
|
|
51
|
+
timeout: 20 * 60 * 1000,
|
|
52
|
+
maxBuffer: 4 * 1024 * 1024,
|
|
53
|
+
env: cliEnvironment(),
|
|
54
|
+
};
|
|
55
|
+
let manifest;
|
|
56
|
+
try {
|
|
57
|
+
const { stdout } = await run(
|
|
58
|
+
npm,
|
|
59
|
+
["view", `${packageName}@latest`, "--json"],
|
|
60
|
+
options,
|
|
61
|
+
);
|
|
62
|
+
manifest = JSON.parse(stdout);
|
|
63
|
+
if (typeof manifest.version !== "string")
|
|
64
|
+
throw new Error("npm 安装信息缺少版本号。");
|
|
65
|
+
} catch (error) {
|
|
66
|
+
throw cliFailure(
|
|
67
|
+
`读取 ${name} 安装信息失败,请查看错误详情后重试。`,
|
|
68
|
+
error,
|
|
69
|
+
);
|
|
70
|
+
}
|
|
71
|
+
const native = nativeCliDependency(id, manifest);
|
|
72
|
+
if (native) {
|
|
73
|
+
const directory = await mkdtemp(join(tmpdir(), "claudex-cli-native-"));
|
|
74
|
+
try {
|
|
75
|
+
// 平台二进制虽由上游声明为 optional,完整下载是 CLI 可用的前提。
|
|
76
|
+
await run(
|
|
77
|
+
npm,
|
|
78
|
+
[
|
|
79
|
+
"install",
|
|
80
|
+
"--prefix",
|
|
81
|
+
directory,
|
|
82
|
+
"--no-save",
|
|
83
|
+
"--package-lock=false",
|
|
84
|
+
"--ignore-scripts",
|
|
85
|
+
"--no-audit",
|
|
86
|
+
"--no-fund",
|
|
87
|
+
native,
|
|
88
|
+
],
|
|
89
|
+
options,
|
|
90
|
+
);
|
|
91
|
+
} catch (error) {
|
|
92
|
+
throw cliFailure(
|
|
93
|
+
`${name} 原生组件下载失败,请检查服务器网络或代理后重试。`,
|
|
94
|
+
error,
|
|
95
|
+
);
|
|
96
|
+
} finally {
|
|
97
|
+
await rm(directory, { recursive: true, force: true });
|
|
98
|
+
}
|
|
99
|
+
}
|
|
100
|
+
try {
|
|
101
|
+
await run(
|
|
102
|
+
npm,
|
|
103
|
+
[
|
|
104
|
+
"install",
|
|
105
|
+
"--global",
|
|
106
|
+
"--include=optional",
|
|
107
|
+
"--ignore-scripts=false",
|
|
108
|
+
`${packageName}@${manifest.version}`,
|
|
109
|
+
],
|
|
110
|
+
options,
|
|
111
|
+
);
|
|
112
|
+
} catch (error) {
|
|
113
|
+
throw cliFailure(`${name} 安装失败,请查看错误详情后重试。`, error);
|
|
114
|
+
}
|
|
115
|
+
return manifest.version;
|
|
116
|
+
}
|
|
@@ -10,6 +10,7 @@ import { createCompactionRecovery } from "./compaction-recovery.mjs";
|
|
|
10
10
|
import { createBridgeEvents } from "./events.mjs";
|
|
11
11
|
import { createRequestHandler } from "./requests.mjs";
|
|
12
12
|
import { createProductMethods } from "../../bridge/product-methods.mjs";
|
|
13
|
+
import { readCodexTokenUsage } from "./token-usage.mjs";
|
|
13
14
|
|
|
14
15
|
export function createCodexAdapter({
|
|
15
16
|
backend,
|
|
@@ -127,6 +128,7 @@ export function createCodexAdapter({
|
|
|
127
128
|
}
|
|
128
129
|
return {
|
|
129
130
|
capabilities: codexCapabilities,
|
|
131
|
+
readTokenUsage: (thread) => readCodexTokenUsage(thread, transport.call),
|
|
130
132
|
workspaceOwner: "backend",
|
|
131
133
|
state,
|
|
132
134
|
receive(client, message) {
|
|
@@ -111,7 +111,7 @@ export function createBridgeEvents({
|
|
|
111
111
|
}
|
|
112
112
|
if (!request.timedOut) send(request.client, { ...message, id: request.id });
|
|
113
113
|
releaseUnusedThreads();
|
|
114
|
-
if (!message.error && !request.timedOut) {
|
|
114
|
+
if (!message.error && !request.timedOut && !request.client?.readOnly) {
|
|
115
115
|
if (request.method === "turn/start")
|
|
116
116
|
threadNaming.schedule(
|
|
117
117
|
{ id: request.threadId },
|
|
@@ -0,0 +1,140 @@
|
|
|
1
|
+
import { open } from "node:fs/promises";
|
|
2
|
+
import { createReadStream } from "node:fs";
|
|
3
|
+
import { createZstdDecompress } from "node:zlib";
|
|
4
|
+
|
|
5
|
+
function parse(line) {
|
|
6
|
+
if (!line.includes('"token_count"') && !line.includes('"session_meta"'))
|
|
7
|
+
return null;
|
|
8
|
+
try {
|
|
9
|
+
return JSON.parse(line.toString("utf8"));
|
|
10
|
+
} catch {
|
|
11
|
+
return null;
|
|
12
|
+
}
|
|
13
|
+
}
|
|
14
|
+
|
|
15
|
+
// 分页分支的正文保存在祖先 rollout 中,读取范围由原生 history_base 指定。
|
|
16
|
+
// 每次从末尾读取 64 KiB,命中用量即停止,完整拼接记录后才解码 UTF-8。
|
|
17
|
+
async function scan(path, endByteOffset) {
|
|
18
|
+
const file = await open(path, "r");
|
|
19
|
+
try {
|
|
20
|
+
let position = (await file.stat()).size;
|
|
21
|
+
if (endByteOffset != null) position = Math.min(position, endByteOffset);
|
|
22
|
+
let remainder = Buffer.alloc(0);
|
|
23
|
+
let base = null;
|
|
24
|
+
function visit(line) {
|
|
25
|
+
const result = extract(parse(line));
|
|
26
|
+
if (result.base) base = result.base;
|
|
27
|
+
return result.tokenUsage ? result : null;
|
|
28
|
+
}
|
|
29
|
+
while (position > 0) {
|
|
30
|
+
const length = Math.min(position, 64 * 1024);
|
|
31
|
+
position -= length;
|
|
32
|
+
const buffer = Buffer.alloc(length);
|
|
33
|
+
const { bytesRead } = await file.read(buffer, 0, length, position);
|
|
34
|
+
const data = Buffer.concat([buffer.subarray(0, bytesRead), remainder]);
|
|
35
|
+
let end = data.length;
|
|
36
|
+
for (let index = data.length - 1; index >= 0; index--) {
|
|
37
|
+
if (data[index] !== 10) continue;
|
|
38
|
+
const usage = visit(data.subarray(index + 1, end));
|
|
39
|
+
if (usage) return usage;
|
|
40
|
+
end = index;
|
|
41
|
+
}
|
|
42
|
+
remainder = data.subarray(0, end);
|
|
43
|
+
}
|
|
44
|
+
return visit(remainder) || { base };
|
|
45
|
+
} finally {
|
|
46
|
+
await file.close();
|
|
47
|
+
}
|
|
48
|
+
}
|
|
49
|
+
|
|
50
|
+
function extract(record) {
|
|
51
|
+
const info =
|
|
52
|
+
record?.type === "event_msg" &&
|
|
53
|
+
record.payload?.type === "token_count" &&
|
|
54
|
+
record.payload.info;
|
|
55
|
+
if (!info?.last_token_usage || !info.total_token_usage)
|
|
56
|
+
return {
|
|
57
|
+
base:
|
|
58
|
+
record?.type === "session_meta" ? record.payload?.history_base : null,
|
|
59
|
+
};
|
|
60
|
+
const breakdown = (usage) => ({
|
|
61
|
+
totalTokens: usage.total_tokens,
|
|
62
|
+
inputTokens: usage.input_tokens,
|
|
63
|
+
cachedInputTokens: usage.cached_input_tokens,
|
|
64
|
+
cacheWriteInputTokens: usage.cache_write_input_tokens ?? 0,
|
|
65
|
+
outputTokens: usage.output_tokens,
|
|
66
|
+
reasoningOutputTokens: usage.reasoning_output_tokens,
|
|
67
|
+
});
|
|
68
|
+
return {
|
|
69
|
+
tokenUsage: {
|
|
70
|
+
total: breakdown(info.total_token_usage),
|
|
71
|
+
last: breakdown(info.last_token_usage),
|
|
72
|
+
modelContextWindow: info.model_context_window,
|
|
73
|
+
},
|
|
74
|
+
};
|
|
75
|
+
}
|
|
76
|
+
|
|
77
|
+
async function scanCompressed(path, endByteOffset) {
|
|
78
|
+
const source = createReadStream(path);
|
|
79
|
+
const stream = source.pipe(createZstdDecompress());
|
|
80
|
+
source.on("error", (error) => stream.destroy(error));
|
|
81
|
+
let remaining = endByteOffset ?? Infinity;
|
|
82
|
+
let remainder = Buffer.alloc(0);
|
|
83
|
+
let result = {};
|
|
84
|
+
function visit(line) {
|
|
85
|
+
const next = extract(parse(line));
|
|
86
|
+
if (next.tokenUsage || next.base) result = next;
|
|
87
|
+
}
|
|
88
|
+
try {
|
|
89
|
+
for await (const chunk of stream) {
|
|
90
|
+
const part = chunk.subarray(0, Math.min(remaining, chunk.length));
|
|
91
|
+
remaining -= part.length;
|
|
92
|
+
const data = Buffer.concat([remainder, part]);
|
|
93
|
+
let start = 0;
|
|
94
|
+
for (let index = 0; index < data.length; index++) {
|
|
95
|
+
if (data[index] !== 10) continue;
|
|
96
|
+
visit(data.subarray(start, index));
|
|
97
|
+
start = index + 1;
|
|
98
|
+
}
|
|
99
|
+
remainder = data.subarray(start);
|
|
100
|
+
if (remaining === 0) break;
|
|
101
|
+
}
|
|
102
|
+
visit(remainder);
|
|
103
|
+
return result;
|
|
104
|
+
} finally {
|
|
105
|
+
source.destroy();
|
|
106
|
+
stream.destroy();
|
|
107
|
+
}
|
|
108
|
+
}
|
|
109
|
+
|
|
110
|
+
async function readRollout(path, endByteOffset) {
|
|
111
|
+
if (path.endsWith(".zst")) return scanCompressed(path, endByteOffset);
|
|
112
|
+
try {
|
|
113
|
+
return await scan(path, endByteOffset);
|
|
114
|
+
} catch (error) {
|
|
115
|
+
if (error.code !== "ENOENT") throw error;
|
|
116
|
+
return scanCompressed(path + ".zst", endByteOffset);
|
|
117
|
+
}
|
|
118
|
+
}
|
|
119
|
+
|
|
120
|
+
export async function readCodexTokenUsage(thread, call) {
|
|
121
|
+
const visited = new Set();
|
|
122
|
+
async function read(thread, endByteOffset) {
|
|
123
|
+
if (!thread?.path || visited.has(thread.id)) return null;
|
|
124
|
+
visited.add(thread.id);
|
|
125
|
+
const result = await readRollout(thread.path, endByteOffset);
|
|
126
|
+
if (result.tokenUsage) return result;
|
|
127
|
+
if (
|
|
128
|
+
!result.base?.thread_id ||
|
|
129
|
+
!Number.isSafeInteger(result.base.end_byte_offset) ||
|
|
130
|
+
result.base.end_byte_offset < 0
|
|
131
|
+
)
|
|
132
|
+
return null;
|
|
133
|
+
const parent = await call("thread/read", {
|
|
134
|
+
threadId: result.base.thread_id,
|
|
135
|
+
includeTurns: false,
|
|
136
|
+
});
|
|
137
|
+
return read(parent.thread, result.base.end_byte_offset);
|
|
138
|
+
}
|
|
139
|
+
return read(thread);
|
|
140
|
+
}
|
|
@@ -1,4 +1,6 @@
|
|
|
1
1
|
import { createThreadFolders } from "../thread-folders.mjs";
|
|
2
|
+
import { createTokenUsageStore } from "../token-usage.mjs";
|
|
3
|
+
import { createTokenUsageReconciliation } from "../token-usage-reconciliation.mjs";
|
|
2
4
|
import { createCliInstallation } from "./cli-installation.mjs";
|
|
3
5
|
import { join } from "node:path";
|
|
4
6
|
import { readProjectlessDirectories } from "../thread-projects.mjs";
|
|
@@ -30,6 +32,7 @@ export function createBackendManager({
|
|
|
30
32
|
factories = {},
|
|
31
33
|
}) {
|
|
32
34
|
const folders = createThreadFolders(config.configDir);
|
|
35
|
+
const tokenUsage = createTokenUsageStore(config.configDir);
|
|
33
36
|
const workspace = createWorkspace({ broadcast, configDir: config.configDir });
|
|
34
37
|
const configuration = createBackendConfiguration(config);
|
|
35
38
|
const providers = createProviders(configuration);
|
|
@@ -47,6 +50,11 @@ export function createBackendManager({
|
|
|
47
50
|
closed = false,
|
|
48
51
|
sequence = 0;
|
|
49
52
|
let changing = Promise.resolve();
|
|
53
|
+
const usageReconciliation = createTokenUsageReconciliation({
|
|
54
|
+
store: tokenUsage,
|
|
55
|
+
call,
|
|
56
|
+
current: (entry) => !closed && instances.get(entry.backend.id) === entry,
|
|
57
|
+
});
|
|
50
58
|
const publicBackends = () =>
|
|
51
59
|
[...instances.values()].map(({ backend, adapter, error }) => ({
|
|
52
60
|
...backend,
|
|
@@ -119,18 +127,25 @@ export function createBackendManager({
|
|
|
119
127
|
},
|
|
120
128
|
broadcast(message) {
|
|
121
129
|
if (instances.get(backend.id) !== entry || closed) return;
|
|
122
|
-
if (message.method === "lan/state")
|
|
123
|
-
|
|
130
|
+
if (message.method === "lan/state") {
|
|
131
|
+
if (entry.adapter?.ready) entry.error = null;
|
|
132
|
+
usageReconciliation.start(entry);
|
|
133
|
+
return emitState();
|
|
134
|
+
}
|
|
135
|
+
const notification = {
|
|
124
136
|
...message,
|
|
125
137
|
...(backend.id !== "codex" && { backendId: backend.id }),
|
|
126
138
|
...(message.id !== undefined && {
|
|
127
139
|
id: resourceId(backend.id, message.id),
|
|
128
140
|
}),
|
|
129
141
|
params: mapResult(message.params, backend.id, message.method),
|
|
130
|
-
}
|
|
142
|
+
};
|
|
143
|
+
tokenUsage.observe(notification);
|
|
144
|
+
broadcast(notification);
|
|
131
145
|
},
|
|
132
146
|
});
|
|
133
147
|
await entry.adapter.connect();
|
|
148
|
+
usageReconciliation.start(entry);
|
|
134
149
|
} catch (error) {
|
|
135
150
|
entry.error = error.message;
|
|
136
151
|
}
|
|
@@ -158,15 +173,28 @@ export function createBackendManager({
|
|
|
158
173
|
return client.readyState;
|
|
159
174
|
},
|
|
160
175
|
methods,
|
|
161
|
-
deliver(message) {
|
|
162
|
-
const method =
|
|
176
|
+
async deliver(message) {
|
|
177
|
+
const { method, threadId, usageRevision, forkUsage } =
|
|
178
|
+
methods.get(message.id) || {};
|
|
163
179
|
methods.delete(message.id);
|
|
180
|
+
if (!message.error && method === "thread/delete")
|
|
181
|
+
tokenUsage.remove(threadId);
|
|
182
|
+
if (!message.error && method === "thread/archive")
|
|
183
|
+
tokenUsage.archive(threadId);
|
|
184
|
+
if (!message.error && method === "thread/unarchive")
|
|
185
|
+
tokenUsage.archive(threadId, false);
|
|
164
186
|
send(client, {
|
|
165
187
|
...message,
|
|
166
188
|
...(message.result && {
|
|
167
|
-
result:
|
|
168
|
-
|
|
189
|
+
result: await tokenUsage.result(
|
|
190
|
+
folders.result(
|
|
191
|
+
mapResult(message.result, entry.backend.id, method),
|
|
192
|
+
method,
|
|
193
|
+
),
|
|
169
194
|
method,
|
|
195
|
+
usageRevision,
|
|
196
|
+
forkUsage,
|
|
197
|
+
entry.adapter.readTokenUsage,
|
|
170
198
|
),
|
|
171
199
|
}),
|
|
172
200
|
});
|
|
@@ -175,29 +203,52 @@ export function createBackendManager({
|
|
|
175
203
|
}
|
|
176
204
|
return entry.proxies.get(client);
|
|
177
205
|
}
|
|
178
|
-
function call(entry, method, params) {
|
|
206
|
+
function call(entry, method, params, { signal } = {}) {
|
|
207
|
+
if (signal?.aborted) return Promise.reject(signal.reason);
|
|
208
|
+
const usageRevision = tokenUsage.revision(
|
|
209
|
+
params.threadId && resourceId(entry.backend.id, params.threadId),
|
|
210
|
+
);
|
|
179
211
|
return new Promise((resolve, reject) => {
|
|
180
212
|
const id = `manager-${++sequence}`;
|
|
181
|
-
const
|
|
213
|
+
const fail = (error) => {
|
|
214
|
+
clearTimeout(timer);
|
|
215
|
+
signal?.removeEventListener("abort", abort);
|
|
216
|
+
reject(error);
|
|
217
|
+
};
|
|
218
|
+
const abort = () => fail(signal.reason);
|
|
219
|
+
const timer = setTimeout(() => fail(new Error("后端读取超时")), 120000);
|
|
220
|
+
signal?.addEventListener("abort", abort, { once: true });
|
|
182
221
|
const client = {
|
|
183
222
|
readyState: 3,
|
|
184
|
-
|
|
223
|
+
readOnly: Boolean(signal),
|
|
224
|
+
async deliver(message) {
|
|
185
225
|
clearTimeout(timer);
|
|
186
|
-
|
|
187
|
-
|
|
188
|
-
|
|
189
|
-
|
|
190
|
-
|
|
191
|
-
|
|
192
|
-
|
|
193
|
-
|
|
226
|
+
signal?.removeEventListener("abort", abort);
|
|
227
|
+
if (signal?.aborted) return;
|
|
228
|
+
try {
|
|
229
|
+
if (message.error) reject(new Error(message.error.message));
|
|
230
|
+
else
|
|
231
|
+
resolve(
|
|
232
|
+
await tokenUsage.result(
|
|
233
|
+
folders.result(
|
|
234
|
+
mapResult(message.result, entry.backend.id, method),
|
|
235
|
+
method,
|
|
236
|
+
),
|
|
237
|
+
method,
|
|
238
|
+
usageRevision,
|
|
239
|
+
undefined,
|
|
240
|
+
entry.adapter.readTokenUsage,
|
|
241
|
+
),
|
|
242
|
+
);
|
|
243
|
+
} catch (error) {
|
|
244
|
+
reject(error);
|
|
245
|
+
}
|
|
194
246
|
},
|
|
195
247
|
};
|
|
196
248
|
Promise.resolve(
|
|
197
249
|
entry.adapter.receive(client, { id, method, params }),
|
|
198
250
|
).catch((error) => {
|
|
199
|
-
|
|
200
|
-
reject(error);
|
|
251
|
+
fail(error);
|
|
201
252
|
});
|
|
202
253
|
});
|
|
203
254
|
}
|
|
@@ -364,7 +415,19 @@ export function createBackendManager({
|
|
|
364
415
|
if (workspace.handles(method) && entry.adapter.workspaceOwner === "bridge")
|
|
365
416
|
return reply(await workspace.request(method, params));
|
|
366
417
|
const recipient = proxy(entry, client);
|
|
367
|
-
|
|
418
|
+
if (method === "thread/fork" && !(await tokenUsage.forkSource(params)))
|
|
419
|
+
await call(entry, "thread/read", {
|
|
420
|
+
threadId: target.nativeId,
|
|
421
|
+
includeTurns: false,
|
|
422
|
+
});
|
|
423
|
+
recipient.methods.set(message.id, {
|
|
424
|
+
method,
|
|
425
|
+
threadId: params.threadId,
|
|
426
|
+
usageRevision: tokenUsage.revision(params.threadId),
|
|
427
|
+
...(method === "thread/fork" && {
|
|
428
|
+
forkUsage: await tokenUsage.forkSource(params),
|
|
429
|
+
}),
|
|
430
|
+
});
|
|
368
431
|
await entry.adapter.receive(recipient, {
|
|
369
432
|
...message,
|
|
370
433
|
...(!method && { id: target.nativeId }),
|
|
@@ -396,14 +459,17 @@ export function createBackendManager({
|
|
|
396
459
|
ready: initialized,
|
|
397
460
|
activeTurns: params.activeTurns,
|
|
398
461
|
compactions: params.compactions,
|
|
462
|
+
tokenUsageReconciliation: usageReconciliation.snapshot(),
|
|
399
463
|
},
|
|
400
464
|
};
|
|
401
465
|
},
|
|
402
466
|
close() {
|
|
403
467
|
closed = true;
|
|
468
|
+
usageReconciliation.stop();
|
|
404
469
|
cli.close?.();
|
|
405
470
|
workspace.close();
|
|
406
471
|
for (const i of instances.values()) i.adapter?.close();
|
|
472
|
+
return usageReconciliation.flush().then(() => tokenUsage.flush());
|
|
407
473
|
},
|
|
408
474
|
get ready() {
|
|
409
475
|
return state().params.ready;
|