@devries-cameron20 / t3code Mirror · read-only
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 21, 04:45 UTC

main
ts 473 lines 17.2 KB
Raw
1 import * as NodeServices from "@effect/platform-node/NodeServices";
2 import { ProviderInstanceId } from "@t3tools/contracts";
3 import { totalTokens } from "@t3tools/provider-core/server/usage";
4 import * as HostProcess from "@t3tools/shared/HostProcess";
5 import { SpawnExecutableResolution } from "@t3tools/shared/shell";
6 import * as Effect from "effect/Effect";
7 import * as Deferred from "effect/Deferred";
8 import * as Fiber from "effect/Fiber";
9 import * as TestClock from "effect/testing/TestClock";
10 import * as Path from "effect/Path";
11 import * as Schema from "effect/Schema";
12 import { it } from "@effect/vitest";
13 import { describe, expect, vi } from "vite-plus/test";
14 import { MuseSettings } from "../settings.ts";
15 import * as MuseSdk from "./sdk.ts";
16 import * as MuseUsageHome from "./MuseUsageHome.ts";
17 import { museUsageFormat, museUsageReader } from "./usage.ts";
18
19 vi.mock("./sdk.ts", { spy: true });
20
21 const entry = () => ({
22 schema_version: 1,
23 record_type: "event",
24 payload_type: "runtime.session",
25 payload_schema_version: 1,
26 id: "envelope-1",
27 recorded_at: 1_785_578_400_123_456,
28 stream: { kind: "session", id: "session-1" },
29 payload: {
30 source_run_record_id: "inference-1",
31 event: {
32 kind: "model_completed",
33 model: "muse-wonder-full-1.0",
34 usage: {
35 input_tokens: 100,
36 cached_tokens: 60,
37 cache_read_tokens: 60,
38 cache_write_tokens: 10,
39 output_tokens: 20,
40 reasoning_tokens: 8,
41 },
42 },
43 },
44 });
45 const decodeSettings = Schema.decodeSync(MuseSettings);
46 const parse = (value: unknown) => museUsageFormat.parseLine(JSON.stringify(value), undefined);
47
48 it("normalizes inclusive cache and reasoning counters without doubling the subsets", () => {
49 const [record] = parse(entry());
50 expect(record).toMatchObject({
51 provider: "muse",
52 timestampMs: Date.parse("2026-08-01T10:00:00.123Z"),
53 sessionId: "session-1",
54 model: "muse-wonder-full-1.0",
55 reportedCostUsd: null,
56 totals: {
57 uncachedInputTokens: 30,
58 cachedInputTokens: 60,
59 cacheCreationTokens: 10,
60 outputTokens: 20,
61 reasoningTokens: 8,
62 },
63 });
64 expect(totalTokens(record!.totals)).toBe(120);
65 const value = entry();
66 const { cache_read_tokens: _read, ...usage } = value.payload.event.usage;
67 expect(
68 parse({ ...value, payload: { ...value.payload, event: { ...value.payload.event, usage } } }),
69 ).toEqual([record]);
70 });
71
72 it("keeps individual inference identity across copied parent/child envelopes", () => {
73 const original = entry();
74 const [first] = parse(original);
75 const [copy] = parse({ ...original, id: "copy", stream: { kind: "session", id: "child" } });
76 expect(copy?.dedupeKey).toBe(first?.dedupeKey);
77 const next = entry();
78 next.payload.source_run_record_id = "inference-2";
79 expect(parse(next)[0]?.dedupeKey).not.toBe(first?.dedupeKey);
80 const { source_run_record_id: _source, ...payload } = original.payload;
81 const fallback = parse({ ...original, payload });
82 expect(fallback[0]?.dedupeKey).toBe(JSON.stringify(["muse", original.id]));
83 });
84
85 it("includes automated review inference models and ignores workflow and telemetry rollups", () => {
86 const value = entry();
87 expect(
88 parse({
89 ...value,
90 payload: {
91 ...value.payload,
92 event: {
93 ...value.payload.event,
94 kind: "automated_review_completed",
95 model: { model_id: "review-model", provider_id: "meta" },
96 },
97 },
98 })[0]?.model,
99 ).toBe("review-model");
100 for (const kind of [
101 "workflow_completed",
102 "goal_usage_attribution",
103 "turn_completed",
104 "usage_summary",
105 ]) {
106 expect(
107 parse({ ...value, payload: { ...value.payload, event: { ...value.payload.event, kind } } }),
108 ).toEqual([]);
109 }
110 expect(parse({ ...value, payload_type: "run.telemetry" })).toEqual([]);
111 expect(parse({ ...value, record_type: "snapshot" })).toEqual([]);
112 expect(parse({ ...value, stream: { kind: "run", id: "run-1" } })).toEqual([]);
113 });
114
115 it("includes native version 3 automated review inferences", () => {
116 const value = entry();
117 const review = {
118 ...value,
119 payload_schema_version: 3,
120 payload: {
121 ...value.payload,
122 event: {
123 ...value.payload.event,
124 kind: "automated_review_completed",
125 model: { provider_id: "meta", model_id: "review-model", reasoning_effort: "high" },
126 usage: {
127 input_tokens: 100,
128 cached_input_tokens: 60,
129 output_tokens: 20,
130 reasoning_tokens: 8,
131 },
132 },
133 },
134 };
135 expect(parse(review)).toEqual([
136 {
137 ...parse(value)[0],
138 model: "review-model",
139 totals: {
140 uncachedInputTokens: 40,
141 cachedInputTokens: 60,
142 cacheCreationTokens: 0,
143 outputTokens: 20,
144 reasoningTokens: 8,
145 },
146 },
147 ]);
148 expect(museUsageFormat.parseProjected(review, undefined)).toEqual(parse(review));
149 });
150
151 it("handles malformed and partial data and rejects unsupported timestamps or schemas", () => {
152 expect(museUsageFormat.parseLine("not json", undefined)).toEqual([]);
153 expect(museUsageFormat.parseLine(JSON.stringify(entry()).slice(0, -1), undefined)).toEqual([]);
154 for (const recorded_at of [NaN, Infinity, -1, "1785578400123456", Number.MAX_SAFE_INTEGER + 1]) {
155 expect(museUsageFormat.parseProjected({ ...entry(), recorded_at }, undefined)).toEqual([]);
156 }
157 expect(parse({ ...entry(), schema_version: 2 })).toEqual([]);
158 expect(parse({ ...entry(), payload_schema_version: 2 })).toEqual([]);
159 expect(parse({ ...entry(), id: "" })).toEqual([]);
160 expect(parse({ ...entry(), payload: { event: { kind: "model_completed" } } })).toEqual([]);
161 const value = entry();
162 const result = parse({
163 ...value,
164 payload: {
165 event: {
166 ...value.payload.event,
167 usage: {
168 input_tokens: 10,
169 cache_read_tokens: 20,
170 cache_write_tokens: 8,
171 output_tokens: 3,
172 reasoning_tokens: 9,
173 },
174 },
175 },
176 });
177 expect(result[0]?.totals).toEqual({
178 uncachedInputTokens: 0,
179 cachedInputTokens: 10,
180 cacheCreationTokens: 0,
181 outputTokens: 3,
182 reasoningTokens: 3,
183 });
184 expect(
185 parse({
186 ...value,
187 payload: {
188 event: { ...value.payload.event, usage: { input_tokens: -5, output_tokens: "20" } },
189 },
190 }),
191 ).toEqual([]);
192 });
193
194 const AWAIT_REFRESH = { awaitRefresh: true };
195 const onPath = Effect.provideService(SpawnExecutableResolution, (command: string) => command);
196
197 describe("Muse history discovery", () => {
198 it.effect.each([undefined, "/custom/xdg-data"])(
199 "uses the initialized home with XDG_DATA_HOME=%s and closes without starting a session",
200 (xdg) =>
201 Effect.gen(function* () {
202 const path = yield* Path.Path;
203 const close = vi.fn(async () => {});
204 using create = vi.spyOn(MuseSdk, "createMuseSdkHostEffect").mockReturnValue(
205 Effect.succeed({
206 initializeResult: { grantedCapabilities: [], museHome: "/native/configured-home" },
207 close,
208 } as unknown as MuseSdk.MuseSdkHost),
209 );
210 if (museUsageReader.kind !== "transcripts") throw new Error("Expected a transcript reader");
211 const directories = yield* museUsageReader.directories(
212 {
213 instanceId: ProviderInstanceId.make("muse-other"),
214 configured: true,
215 config: decodeSettings({ binaryPath: "~/bin/custom-muse" }),
216 environment: { XDG_DATA_HOME: xdg, MUSE_NO_AUTO_UPDATE: "0" },
217 },
218 AWAIT_REFRESH,
219 );
220 expect(directories).toEqual([
221 { dir: path.join("/native/configured-home", "sessions"), fileName: "session.jsonl" },
222 ]);
223 expect(create).toHaveBeenCalledWith({
224 binaryPath: path.join("/test-home", "bin/custom-muse"),
225 environment: {
226 PATH: "/host/bin",
227 XDG_DATA_HOME: xdg ?? "/host/data",
228 MUSE_NO_AUTO_UPDATE: "1",
229 MISE_OFFLINE: "1",
230 },
231 readOnly: true,
232 startupTimeoutMs: 5_000,
233 });
234 expect(close).toHaveBeenCalledOnce();
235 }).pipe(
236 Effect.provide([NodeServices.layer, MuseUsageHome.layer]),
237 onPath,
238 Effect.provideService(HostProcess.HomeDirectory, "/test-home"),
239 Effect.provideService(HostProcess.Environment, {
240 PATH: "/host/bin",
241 XDG_DATA_HOME: "/host/data",
242 }),
243 ),
244 );
245
246 it.effect("reports no history without starting Muse when its CLI is not installed", () =>
247 Effect.gen(function* () {
248 using create = vi.spyOn(MuseSdk, "createMuseSdkHostEffect");
249 if (museUsageReader.kind !== "transcripts") throw new Error("Expected a transcript reader");
250 const directories = yield* museUsageReader.directories(
251 {
252 instanceId: ProviderInstanceId.make("muse"),
253 configured: false,
254 config: undefined,
255 environment: {},
256 },
257 { awaitRefresh: false },
258 );
259 expect(directories).toEqual([]);
260 expect(create).not.toHaveBeenCalled();
261 }).pipe(
262 Effect.provide([NodeServices.layer, MuseUsageHome.layer]),
263 Effect.provideService(SpawnExecutableResolution, () => undefined),
264 ),
265 );
266
267 it.effect("does not guess a directory when initialization fails", () =>
268 Effect.gen(function* () {
269 using _create = vi
270 .spyOn(MuseSdk, "createMuseSdkHostEffect")
271 .mockReturnValue(
272 Effect.fail(
273 new MuseSdk.MuseSdkError({ operation: "start", cause: new Error("not installed") }),
274 ),
275 );
276 if (museUsageReader.kind !== "transcripts") throw new Error("Expected a transcript reader");
277 const directories = yield* museUsageReader.directories(
278 {
279 instanceId: ProviderInstanceId.make("muse"),
280 configured: false,
281 config: undefined,
282 environment: {},
283 },
284 AWAIT_REFRESH,
285 );
286 expect(directories).toEqual([]);
287 }).pipe(Effect.provide([NodeServices.layer, MuseUsageHome.layer]), onPath),
288 );
289
290 it.effect(
291 "reuses discovery across accounts, date scans, and equivalent effective environments",
292 () =>
293 Effect.gen(function* () {
294 const path = yield* Path.Path;
295 const close = vi.fn(async () => {});
296 using create = vi.spyOn(MuseSdk, "createMuseSdkHostEffect").mockReturnValue(
297 Effect.succeed({
298 initializeResult: { museHome: "/native/home" },
299 close,
300 } as unknown as MuseSdk.MuseSdkHost),
301 );
302 if (museUsageReader.kind !== "transcripts") throw new Error("Expected a transcript reader");
303 const instance = {
304 instanceId: ProviderInstanceId.make("disabled-muse"),
305 configured: true,
306 config: decodeSettings({ binaryPath: "~/bin/muse", enabled: false }),
307 environment: { PATH: "/bin", XDG_DATA_HOME: "/data" },
308 };
309 const first = yield* museUsageReader.directories(instance, AWAIT_REFRESH);
310 const second = yield* museUsageReader.directories(
311 {
312 ...instance,
313 instanceId: ProviderInstanceId.make("another-account"),
314 config: decodeSettings({
315 binaryPath: path.join("/test-home", "bin/muse"),
316 enabled: true,
317 }),
318 environment: {
319 XDG_DATA_HOME: "/data",
320 PATH: "/bin",
321 UNUSED: undefined,
322 META_API_KEY: "ignored",
323 },
324 },
325 AWAIT_REFRESH,
326 );
327 expect(second).toEqual(first);
328 expect(first).toEqual([
329 { dir: path.join("/native/home", "sessions"), fileName: "session.jsonl" },
330 ]);
331 expect(create).toHaveBeenCalledOnce();
332 expect(close).toHaveBeenCalledOnce();
333 }).pipe(
334 Effect.provide([NodeServices.layer, MuseUsageHome.layer]),
335 onPath,
336 Effect.provideService(HostProcess.HomeDirectory, "/test-home"),
337 Effect.provideService(HostProcess.Environment, {}),
338 ),
339 );
340
341 it.effect(
342 "rediscovers when the binary, instance environment, or inherited environment changes",
343 () =>
344 Effect.gen(function* () {
345 using create = vi.spyOn(MuseSdk, "createMuseSdkHostEffect").mockImplementation((options) =>
346 Effect.succeed({
347 initializeResult: { museHome: options.environment?.XDG_DATA_HOME },
348 close: async () => {},
349 } as unknown as MuseSdk.MuseSdkHost),
350 );
351 if (museUsageReader.kind !== "transcripts") throw new Error("Expected a transcript reader");
352 const instance = {
353 instanceId: ProviderInstanceId.make("muse"),
354 configured: true,
355 config: undefined,
356 environment: {},
357 };
358 const first = yield* museUsageReader.directories(instance, AWAIT_REFRESH);
359 expect(
360 yield* museUsageReader.directories(
361 {
362 ...instance,
363 config: decodeSettings({ binaryPath: "custom-muse" }),
364 },
365 AWAIT_REFRESH,
366 ),
367 ).toEqual(first);
368 const changed = yield* museUsageReader.directories(
369 {
370 ...instance,
371 environment: { XDG_DATA_HOME: "/other-data" },
372 },
373 AWAIT_REFRESH,
374 );
375 expect(changed).not.toEqual(first);
376 const inherited = yield* museUsageReader
377 .directories(instance, AWAIT_REFRESH)
378 .pipe(
379 Effect.provideService(HostProcess.Environment, { XDG_DATA_HOME: "/new-host-data" }),
380 );
381 expect(inherited).not.toEqual(first);
382 expect(inherited).not.toEqual(changed);
383 expect(create).toHaveBeenCalledTimes(4);
384 }).pipe(
385 Effect.provide([NodeServices.layer, MuseUsageHome.layer]),
386 onPath,
387 Effect.provideService(HostProcess.Environment, { XDG_DATA_HOME: "/host-data" }),
388 ),
389 );
390
391 it.effect("reports pending discovery without waiting and shares it with awaiting reads", () =>
392 Effect.gen(function* () {
393 const started = yield* Deferred.make<void>();
394 const ready = yield* Deferred.make<MuseSdk.MuseSdkHost>();
395 using create = vi
396 .spyOn(MuseSdk, "createMuseSdkHostEffect")
397 .mockImplementation(() =>
398 Deferred.succeed(started, undefined).pipe(Effect.andThen(Deferred.await(ready))),
399 );
400 const close = vi.fn(async () => {});
401 if (museUsageReader.kind !== "transcripts") throw new Error("Expected a transcript reader");
402 const instance = {
403 instanceId: ProviderInstanceId.make("muse"),
404 configured: true,
405 config: undefined,
406 environment: {},
407 };
408 const pending = [{ dir: "muse", refreshing: true }];
409 expect(yield* museUsageReader.directories(instance, { awaitRefresh: false })).toEqual(
410 pending,
411 );
412 yield* Deferred.await(started);
413 const reads = yield* Effect.all(
414 [
415 museUsageReader.directories(instance, AWAIT_REFRESH),
416 museUsageReader.directories(instance, AWAIT_REFRESH),
417 ],
418 { concurrency: "unbounded" },
419 ).pipe(Effect.forkChild);
420 expect(yield* museUsageReader.directories(instance, { awaitRefresh: false })).toEqual(
421 pending,
422 );
423 yield* Deferred.succeed(ready, {
424 initializeResult: { museHome: "/native/home" },
425 close,
426 } as unknown as MuseSdk.MuseSdkHost);
427 const [first, second] = yield* Fiber.join(reads);
428 expect(first).toEqual(second);
429 expect(first).toHaveLength(1);
430 expect(yield* museUsageReader.directories(instance, { awaitRefresh: false })).toEqual(first);
431 const uninstalled = Effect.provideService(SpawnExecutableResolution, () => undefined);
432 expect(
433 yield* museUsageReader.directories(instance, { awaitRefresh: false }).pipe(uninstalled),
434 ).toEqual(first);
435 expect(yield* museUsageReader.directories(instance, AWAIT_REFRESH).pipe(uninstalled)).toEqual(
436 first,
437 );
438 expect(create).toHaveBeenCalledOnce();
439 expect(close).toHaveBeenCalledOnce();
440 }).pipe(Effect.provide([NodeServices.layer, MuseUsageHome.layer]), onPath),
441 );
442
443 it.effect("briefly caches failed discovery and retries after installation recovers", () =>
444 Effect.gen(function* () {
445 using create = vi
446 .spyOn(MuseSdk, "createMuseSdkHostEffect")
447 .mockReturnValueOnce(
448 Effect.fail(
449 new MuseSdk.MuseSdkError({ operation: "start", cause: new Error("not installed") }),
450 ),
451 )
452 .mockReturnValue(
453 Effect.succeed({
454 initializeResult: { museHome: "/installed/home" },
455 close: async () => {},
456 } as unknown as MuseSdk.MuseSdkHost),
457 );
458 if (museUsageReader.kind !== "transcripts") throw new Error("Expected a transcript reader");
459 const instance = {
460 instanceId: ProviderInstanceId.make("muse"),
461 configured: false,
462 config: undefined,
463 environment: {},
464 };
465 expect(yield* museUsageReader.directories(instance, AWAIT_REFRESH)).toEqual([]);
466 expect(yield* museUsageReader.directories(instance, { awaitRefresh: false })).toEqual([]);
467 expect(create).toHaveBeenCalledOnce();
468 yield* TestClock.adjust("30 seconds");
469 expect(yield* museUsageReader.directories(instance, AWAIT_REFRESH)).toHaveLength(1);
470 expect(create).toHaveBeenCalledTimes(2);
471 }).pipe(Effect.provide([NodeServices.layer, MuseUsageHome.layer]), onPath),
472 );
473 });