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 22, 18:15 UTC
feat(usage): include Muse Code session history (#22443)
Co-authored-by: Theo Browne <me@theo.li> Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Wiktor Golicz committed
Oct 24, 2026 at 07:12 UTC
c89335361870087b64a2fc6ba0f7f3459aa23f39
17 files changed
+926
-7
apps/mobile/src/features/usage/usageProviders.ts
+3
@@ -9,6 +9,7 @@ export const PROVIDER_ORDER: readonly UsageProviderKind[] = [
9
"opencode",
10
"antigravity",
11
"pi",
12
+ "muse",
13
];
14
15
/** The usage series a provider driver reports under, or null for drivers without one. */
@@ -25,6 +26,7 @@ export const PROVIDER_LABEL: Record<UsageProviderKind, string> = {
26
opencode: "OpenCode",
27
antigravity: "Antigravity",
28
pi: "Pi",
29
+ muse: "Muse Code",
30
};
31
32
export function useProviderColors(): Record<UsageProviderKind, string> {
@@ -37,6 +39,7 @@ export function useProviderColors(): Record<UsageProviderKind, string> {
39
opencode: "#5b9bbd",
40
antigravity: "#8c7bd1",
41
pi: "#4d9f8a",
42
+ muse: "#0866ff",
43
};
44
}
45
apps/server/src/provider/builtInDrivers.ts
+3
-1
@@ -45,7 +45,8 @@ export type BuiltInUsageReadersEnv =
45
| ProviderUsageReaderEnv<typeof OpenCodeDriver>
46
| ProviderUsageReaderEnv<typeof AntigravityDriver>
47
| ProviderUsageReaderEnv<typeof CursorDriver>
48
- | ProviderUsageReaderEnv<typeof PiDriver>;
48
+ | ProviderUsageReaderEnv<typeof PiDriver>
49
+ | ProviderUsageReaderEnv<typeof MuseDriver>;
50
51
/**
52
* Aggregation keeps the first copy of a duplicate record, so the order is part
@@ -59,6 +60,7 @@ export const BUILT_IN_USAGE_DRIVERS: ReadonlyArray<
60
GrokDriver,
61
PiDriver,
62
OpenCodeDriver,
63
+ MuseDriver,
64
AntigravityDriver,
65
CursorDriver,
66
];
apps/server/src/server.ts
+2
@@ -168,6 +168,7 @@ import * as ResourceMonitorBinary from "./resourceTelemetry/ResourceMonitorBinar
168
import * as ProcessGroupMetrics from "./resourceTelemetry/ProcessGroupMetrics.ts";
169
import * as ResourceTelemetry from "./resourceTelemetry/ResourceTelemetry.ts";
170
import * as AntigravityUsage from "./provider/Drivers/AntigravityUsage.ts";
171
+import { MuseUsageHome } from "@t3tools/provider-muse/server";
172
import * as CursorAccountReader from "@t3tools/provider-cursor/server/CursorAccountReader";
173
import * as CursorKeychain from "@t3tools/provider-cursor/server/CursorKeychain";
174
import * as CursorUsageAccounts from "@t3tools/provider-cursor/server/CursorUsageAccounts";
@@ -269,6 +270,7 @@ const layerUsage = UsageService.layer.pipe(
270
Layer.provide(
271
Layer.mergeAll(
272
AntigravityUsage.layer,
273
+ MuseUsageHome.layer,
274
CodexUsageHistory.layer,
275
CursorUsageAccounts.layer.pipe(
276
Layer.provide(CursorAccountReader.layer.pipe(Layer.provide(CursorKeychain.layer))),
apps/server/src/usage/UsageService.test.ts
+232
@@ -48,9 +48,19 @@ import * as AntigravityUsage from "../provider/Drivers/AntigravityUsage.ts";
48
import * as ProviderHostLive from "../provider/ProviderHostLive.ts";
49
import { totalTokens, type UsageRecord } from "@t3tools/provider-core/server/usage";
50
import * as UsageService from "./UsageService.ts";
51
+import * as MuseSdk from "../../../../packages/provider-muse/src/server/sdk.ts";
52
+import { MuseUsageHome } from "@t3tools/provider-muse/server";
53
import { encodeScanCache, SCAN_CACHE_FILE_NAME } from "./usageScanCache.ts";
54
55
vi.mock("node:fs/promises", { spy: true });
56
+vi.mock("../../../../packages/provider-muse/src/server/sdk.ts", async (importOriginal) => ({
57
+ ...(await importOriginal<typeof MuseSdk>()),
58
+ createMuseSdkHostEffect: vi.fn(() =>
59
+ Effect.try(() => {
60
+ throw new Error("Muse is not installed in this test");
61
+ }),
62
+ ),
63
+}));
64
65
const encodeUnknownJson = Schema.encodeEffect(Schema.fromJsonString(Schema.Unknown));
66
const encodeUnknownJsonString = Schema.encodeSync(Schema.fromJsonString(Schema.Unknown));
@@ -137,6 +147,7 @@ const layerService = (input: {
147
CursorAccountReader.layer.pipe(Layer.provide(CursorKeychain.layer)),
148
).pipe(
149
Layer.provideMerge(AntigravityUsage.layer),
150
+ Layer.provideMerge(MuseUsageHome.layer),
151
Layer.provideMerge(ProviderHostLive.layer),
152
Layer.provideMerge(CodexUsageHistory.layer.pipe(Layer.provideMerge(Sqlite.layerMemory))),
153
Layer.provideMerge(Layer.mock(BackgroundPolicy.BackgroundPolicy)({})),
@@ -797,6 +808,227 @@ describe("UsageService", () => {
808
}).pipe(Effect.scoped),
809
);
810
811
+ it.live(
812
+ "reads Muse inference history once, persists appended usage, and reprices unknown models",
813
+ () =>
814
+ Effect.gen(function* () {
815
+ const { home, settings } = yield* setup;
816
+ const museHome = NodePath.join(home, "configured-data", "muse");
817
+ const dir = NodePath.join(museHome, "sessions", "2026", "08", "01", "parent");
818
+ const child = NodePath.join(dir, "subagent", "child");
819
+ const entry = (
820
+ id: string,
821
+ sessionId = "parent",
822
+ timestamp = "2026-08-01T00:00:00Z",
823
+ model = "muse-unknown",
824
+ ) => ({
825
+ schema_version: 1,
826
+ record_type: "event",
827
+ payload_type: "runtime.session",
828
+ payload_schema_version: 1,
829
+ id,
830
+ recorded_at: Date.parse(timestamp) * 1000 + 999,
831
+ stream: { kind: "session", id: sessionId },
832
+ payload: {
833
+ source_run_record_id: id,
834
+ event: {
835
+ kind: "model_completed",
836
+ model,
837
+ usage: {
838
+ input_tokens: 100,
839
+ cached_tokens: 60,
840
+ cache_read_tokens: 60,
841
+ cache_write_tokens: 10,
842
+ output_tokens: 20,
843
+ reasoning_tokens: 8,
844
+ },
845
+ },
846
+ },
847
+ });
848
+ const parent = entry("inference-1");
849
+ const review = {
850
+ ...entry("review", "child"),
851
+ payload_schema_version: 3,
852
+ payload: {
853
+ event: {
854
+ ...parent.payload.event,
855
+ kind: "automated_review_completed",
856
+ model: { model_id: "priced-model" },
857
+ usage: {
858
+ input_tokens: 100,
859
+ cached_input_tokens: 60,
860
+ output_tokens: 20,
861
+ reasoning_tokens: 8,
862
+ },
863
+ },
864
+ },
865
+ };
866
+ yield* Effect.promise(async () => {
867
+ await NodeFSP.mkdir(child, { recursive: true });
868
+ await NodeFSP.writeFile(
869
+ NodePath.join(dir, "session.jsonl"),
870
+ [
871
+ parent,
872
+ parent,
873
+ {
874
+ ...parent,
875
+ payload: { event: { ...parent.payload.event, kind: "workflow_completed" } },
876
+ },
877
+ { ...parent, payload_type: "goal_usage_attribution" },
878
+ entry("before", "parent", "2026-07-31T23:59:59.999Z"),
879
+ entry("after", "parent", "2026-08-02T00:00:00Z"),
880
+ ]
881
+ .map((line) => encodeUnknownJsonString(line))
882
+ .join("\n") + "\n{broken}\n",
883
+ );
884
+ await NodeFSP.writeFile(
885
+ NodePath.join(child, "session.jsonl"),
886
+ [
887
+ { ...parent, id: "copied-envelope", stream: { kind: "session", id: "child" } },
888
+ entry("child-inference", "child"),
889
+ review,
890
+ ]
891
+ .map((line) => encodeUnknownJsonString(line))
892
+ .join("\n") + "\n",
893
+ );
894
+ await NodeFSP.writeFile(
895
+ NodePath.join(child, "telemetry.jsonl"),
896
+ encodeUnknownJsonString(entry("not-a-session")) + "\n",
897
+ );
898
+ });
899
+ using _create = vi.spyOn(MuseSdk, "createMuseSdkHostEffect").mockImplementation((options) =>
900
+ Effect.succeed({
901
+ initializeResult: {
902
+ grantedCapabilities: [],
903
+ museHome: NodePath.join(options.environment?.XDG_DATA_HOME ?? home, "muse"),
904
+ },
905
+ close: async () => {},
906
+ } as unknown as MuseSdk.MuseSdkHost),
907
+ );
908
+ yield* Effect.gen(function* () {
909
+ const service = yield* UsageService.make;
910
+ const window = {
911
+ timeZone: "UTC",
912
+ sinceDay: UsageDay.make("2026-08-01"),
913
+ untilDay: UsageDay.make("2026-08-01"),
914
+ };
915
+ const muse = (summary: UsageSummary) =>
916
+ summary.buckets.filter((bucket) => bucket.provider === "muse");
917
+ const first = yield* service.readSummary(window);
918
+ const buckets = muse(first);
919
+ assert.strictEqual(
920
+ buckets.reduce((sum, b) => sum + b.records, 0),
921
+ 3,
922
+ );
923
+ assert.strictEqual(
924
+ buckets.reduce((sum, b) => sum + totalTokens(b.totals), 0),
925
+ 360,
926
+ );
927
+ const unknown = buckets.find((b) => b.model === "muse-unknown");
928
+ assert.strictEqual(unknown?.costSource, "unpriced");
929
+ assert.strictEqual(unknown?.unpricedRecords, 2);
930
+ assert.deepStrictEqual(unknown?.totals, {
931
+ uncachedInputTokens: 60,
932
+ cachedInputTokens: 120,
933
+ cacheCreationTokens: 20,
934
+ outputTokens: 40,
935
+ reasoningTokens: 16,
936
+ });
937
+ const priced = buckets.find((b) => b.model === "priced-model");
938
+ assert.strictEqual(priced?.costSource, "modelPriced");
939
+ assert.closeTo(priced?.costUsd ?? NaN, 0.000172, 1e-12);
940
+ assert.closeTo(priced?.cacheSavingsUsd ?? NaN, 0.000108, 1e-12);
941
+ const sources = first.sources.filter((source) => source.fingerprint.provider === "muse");
942
+ assert.strictEqual(sources.length, 1);
943
+ assert.strictEqual(sources[0]?.scannedFiles, 2);
944
+ assert.strictEqual(sources[0]?.distinctSessions, 2);
945
+ const local = muse(
946
+ yield* service.readSummary({ ...window, timeZone: "America/Los_Angeles" }),
947
+ );
948
+ assert.strictEqual(
949
+ local.reduce((sum, b) => sum + b.records, 0),
950
+ 1,
951
+ );
952
+ assert.strictEqual(local[0]?.day, "2026-08-01");
953
+ const hourly = muse(
954
+ yield* service.readSummary({
955
+ ...window,
956
+ resolution: "hour",
957
+ sinceTime: "2026-08-01T00:00:00.000Z",
958
+ untilTime: "2026-08-02T00:00:00.000Z",
959
+ }),
960
+ );
961
+ assert.strictEqual(
962
+ hourly.reduce((sum, b) => sum + b.records, 0),
963
+ 3,
964
+ );
965
+ const appended = encodeUnknownJsonString(entry("appended", "child"));
966
+ const file = NodePath.join(child, "session.jsonl");
967
+ yield* Effect.promise(() => NodeFSP.appendFile(file, appended.slice(0, -10)));
968
+ assert.deepStrictEqual(muse(yield* service.readSummary(window)), buckets);
969
+ yield* service.awaitPersisted;
970
+ const restarted = yield* UsageService.make;
971
+ yield* Effect.promise(() => NodeFSP.appendFile(file, appended.slice(-10) + "\n"));
972
+ const grown = muse(yield* restarted.readSummary(window));
973
+ assert.strictEqual(
974
+ grown.reduce((sum, b) => sum + b.records, 0),
975
+ 4,
976
+ );
977
+ assert.strictEqual(
978
+ grown.reduce((sum, b) => sum + totalTokens(b.totals), 0),
979
+ 480,
980
+ );
981
+ const settingsService = yield* ServerSettings.ServerSettingsService;
982
+ yield* settingsService.updateSettings({
983
+ usagePriceOverrides: {
984
+ "muse-unknown": {
985
+ inputCostPerMillionTokens: 2,
986
+ outputCostPerMillionTokens: 4,
987
+ cacheReadCostPerMillionTokens: 0.2,
988
+ cacheWriteCostPerMillionTokens: 1,
989
+ },
990
+ },
991
+ });
992
+ const repriced = muse(yield* restarted.readSummary(window)).find(
993
+ (b) => b.model === "muse-unknown",
994
+ );
995
+ assert.strictEqual(repriced?.unpricedRecords, 0);
996
+ assert.closeTo(repriced?.costUsd ?? NaN, 0.000486, 1e-12);
997
+ }).pipe(
998
+ Effect.scoped,
999
+ Effect.provide(
1000
+ layerService({
1001
+ prefix: "usage-muse",
1002
+ home,
1003
+ environment: { XDG_DATA_HOME: NodePath.dirname(museHome) },
1004
+ settings: {
1005
+ ...settings,
1006
+ providerInstances: {
1007
+ ...settings.providerInstances,
1008
+ [ProviderInstanceId.make("muse")]: {
1009
+ driver: ProviderDriverKind.make("muse"),
1010
+ enabled: false,
1011
+ },
1012
+ [ProviderInstanceId.make("muse-alias")]: {
1013
+ driver: ProviderDriverKind.make("muse"),
1014
+ enabled: false,
1015
+ },
1016
+ },
1017
+ },
1018
+ ratesDocument: {
1019
+ "priced-model": {
1020
+ input_cost_per_token: 0.000002,
1021
+ output_cost_per_token: 0.000004,
1022
+ cache_read_input_token_cost: 0.0000002,
1023
+ cache_creation_input_token_cost: 0.0000002,
1024
+ },
1025
+ },
1026
+ }),
1027
+ ),
1028
+ );
1029
+ }).pipe(Effect.scoped),
1030
+ );
1031
+
1032
it.live("reports missing Pi history and skips malformed records without losing valid usage", () =>
1033
Effect.gen(function* () {
1034
const { home, settings } = yield* setup;
apps/server/src/usage/usageTestFormats.ts
+3
-1
@@ -2,18 +2,20 @@ import type { UsageProviderKind } from "@t3tools/contracts";
2
import type { TranscriptUsageFormat } from "@t3tools/provider-core/server/usage";
3
import { piUsageFormat } from "@t3tools/provider-pi/server/usage";
4
import { grokUsageFormat } from "@t3tools/provider-grok/server/usage";
5
+import { museUsageFormat } from "@t3tools/provider-muse/server/usage";
6
7
import { claudeUsageFormat } from "../provider/Drivers/claudeUsage.ts";
8
import { codexUsageFormat } from "../provider/Drivers/codexUsage.ts";
9
10
export const TEST_FORMATS: Record<
10
- "claude" | "codex" | "grok" | "pi",
11
+ "claude" | "codex" | "grok" | "pi" | "muse",
12
TranscriptUsageFormat<unknown>
13
> = {
14
claude: claudeUsageFormat,
15
codex: codexUsageFormat,
16
grok: grokUsageFormat,
17
pi: piUsageFormat,
18
+ muse: museUsageFormat,
19
};
20
21
export const TEST_FORMAT_MAP = new Map<UsageProviderKind, TranscriptUsageFormat<unknown>>(
apps/server/src/usage/usageTranscriptStreaming.test.ts
+47
@@ -108,6 +108,53 @@ async function scan(
108
}
109
110
describe("large usage records", () => {
111
+ it("streams Muse completion envelopes and resumes a partial appended event", async () => {
112
+ const entry = {
113
+ schema_version: 1,
114
+ record_type: "event",
115
+ payload_type: "runtime.session",
116
+ payload_schema_version: 3,
117
+ id: "envelope-1",
118
+ recorded_at: 1_785_578_400_123_456,
119
+ stream: { kind: "session", id: "parent" },
120
+ payload: {
121
+ source_run_record_id: "inference-1",
122
+ event: {
123
+ kind: "automated_review_completed",
124
+ model: { model_id: "review-model" },
125
+ usage: {
126
+ input_tokens: 100,
127
+ cached_input_tokens: 60,
128
+ output_tokens: 20,
129
+ reasoning_tokens: 8,
130
+ },
131
+ },
132
+ },
133
+ };
134
+ const small = await scan([entry], "muse", "small-muse");
135
+ expect(small.records[0]?.totals).toMatchObject({
136
+ uncachedInputTokens: 40,
137
+ cachedInputTokens: 60,
138
+ });
139
+ const path = NodePath.join(dir, "large-muse.jsonl");
140
+ await NodeFSP.writeFile(path, JSON.stringify({ ...entry, discarded: { content } }) + "\n");
141
+ const large = await readTranscriptRecords(path, "muse");
142
+ expect(large?.records).toEqual(small.records);
143
+ const appended = JSON.stringify({
144
+ ...entry,
145
+ id: "envelope-2",
146
+ payload: { ...entry.payload, source_run_record_id: "inference-2" },
147
+ });
148
+ await NodeFSP.appendFile(path, appended.slice(0, -7));
149
+ const partial = await readTranscriptRecords(path, "muse", large!.position);
150
+ expect(partial?.records).toEqual([]);
151
+ await NodeFSP.appendFile(path, appended.slice(-7) + "\n");
152
+ const completed = await readTranscriptRecords(path, "muse", partial!.position);
153
+ expect(completed?.records).toHaveLength(1);
154
+ expect(completed?.records[0]?.dedupeKey).not.toBe(large?.records[0]?.dedupeKey);
155
+ expect(completed?.records[0]?.totals).toEqual(small.records[0]?.totals);
156
+ });
157
+
158
it("keeps Pi model, cost, and fork identity after large assistant content", async () => {
159
const entry = {
160
type: "message",
apps/web/src/components/usage/UsageProviderChart.test.ts
+4
-2
@@ -9,12 +9,13 @@ describe("buildPeriodColumns", () => {
9
"2026-08-01",
10
{
11
day: "2026-08-01",
12
- costUsd: 35,
13
- totalTokens: 350,
12
+ costUsd: 42,
13
+ totalTokens: 420,
14
byProvider: new Map([
15
["codex" as const, { costUsd: 10, totalTokens: 100 }],
16
["claude" as const, { costUsd: 20, totalTokens: 200 }],
17
["pi" as const, { costUsd: 5, totalTokens: 50 }],
18
+ ["muse" as const, { costUsd: 7, totalTokens: 70 }],
19
]),
20
},
21
],
@@ -40,6 +41,7 @@ describe("buildPeriodColumns", () => {
41
{ provider: "opencode", value: 0 },
42
{ provider: "antigravity", value: 0 },
43
{ provider: "pi", value: 5 },
44
+ { provider: "muse", value: 7 },
45
]);
46
});
47
});
apps/web/src/components/usage/usageProviders.ts
+5
@@ -40,6 +40,11 @@ export const PROVIDER_PRESENTATION = {
40
color: "#4d9f8a",
41
driverKind: ProviderDriverKind.make("pi"),
42
},
43
+ muse: {
44
+ label: "Muse Code",
45
+ color: "#0866ff",
46
+ driverKind: ProviderDriverKind.make("muse"),
47
+ },
48
} satisfies Record<UsageProviderKind, UsageProviderPresentation>;
49
50
export const PROVIDER_ORDER = Object.keys(PROVIDER_PRESENTATION) as UsageProviderKind[];
docs/user/usage.md
+4
-1
@@ -6,7 +6,7 @@ desktop when the terminal is not focused. Customize `usage.open` in
6
7
## Understand your usage
8
9
-**Usage** combines Codex, Claude Code, Grok Build, OpenCode, Antigravity, Pi, and Cursor history
9
+**Usage** combines Codex, Claude Code, Grok Build, OpenCode, Antigravity, Pi, Muse Code, and Cursor history
10
from your connected environments. It shows token use, cache savings, model breakdowns, and estimated API-equivalent
11
cost, split by token type and by speed. These estimates are not your subscription bill.
12
**Premium** is what Fast and Ultrafast requests cost above standard rates. Cost that cannot be
@@ -34,6 +34,9 @@ variable. Pi reads `~/.pi/agent/sessions`, or the `sessions` directory under
34
`PI_CODING_AGENT_DIR`. Set `PI_CODING_AGENT_SESSION_DIR` to read a different session directory.
35
To include sessions saved through `--session-dir` or Pi's `sessionDir` setting, set this environment
36
variable to the same directory. Pi includes recorded tool and summary costs under `Tools/summaries`.
37
+Muse Code reads native session history, including child sessions, from the home reported by the
38
+configured Muse CLI. Its environment settings, including `XDG_DATA_HOME`, apply. Models without
39
+known prices still contribute tokens and appear as unpriced; set custom prices to estimate their cost.
40
Use absolute paths or `~/` paths in the account's environment settings; relative environment paths
41
depend on each project's working directory and cannot be reliably discovered by Usage. Accounts
42
sharing a history directory count once.
packages/contracts/src/usage.ts
+1
@@ -19,6 +19,7 @@ export const UsageProviderKind = Schema.Literals([
19
"opencode",
20
"antigravity",
21
"pi",
22
+ "muse",
23
]);
24
export type UsageProviderKind = typeof UsageProviderKind.Type;
25
packages/provider-muse/package.json
+4
@@ -15,6 +15,10 @@
15
"types": "./src/server.ts",
16
"import": "./src/server.ts"
17
},
18
+ "./server/usage": {
19
+ "types": "./src/server/usage.ts",
20
+ "import": "./src/server/usage.ts"
21
+ },
22
"./testing": {
23
"types": "./src/testing.ts",
24
"import": "./src/testing.ts"
packages/provider-muse/src/server.ts
+1
@@ -1,2 +1,3 @@
1
export { MuseDriver, type MuseDriverEnv } from "./server/driver.ts";
2
+export * as MuseUsageHome from "./server/MuseUsageHome.ts";
3
export { makeMuseAdapterV2, type MuseAdapterV2Options } from "./server/adapter.ts";
packages/provider-muse/src/server/MuseUsageHome.ts
new
+58
@@ -0,0 +1,58 @@
1
+import * as Cache from "effect/Cache";
2
+import * as Context from "effect/Context";
3
+import * as Duration from "effect/Duration";
4
+import * as Effect from "effect/Effect";
5
+import * as Exit from "effect/Exit";
6
+import * as Layer from "effect/Layer";
7
+
8
+import { createMuseSdkHostEffect } from "./sdk.ts";
9
+
10
+export class MuseUsageHome extends Context.Service<
11
+ MuseUsageHome,
12
+ {
13
+ readonly resolve: (input: {
14
+ readonly binaryPath: string;
15
+ readonly environment: NodeJS.ProcessEnv;
16
+ }) => Effect.Effect<string | undefined>;
17
+ }
18
+>()("@t3tools/provider-muse/server/MuseUsageHome") {}
19
+
20
+const make = Effect.gen(function* () {
21
+ const cache = yield* Cache.makeWith(
22
+ Effect.fn("MuseUsageHome.initialize")(function* (
23
+ input: Parameters<MuseUsageHome["Service"]["resolve"]>[0],
24
+ ) {
25
+ return yield* Effect.scoped(
26
+ Effect.gen(function* () {
27
+ const host = yield* Effect.acquireRelease(
28
+ createMuseSdkHostEffect({ ...input, readOnly: true, startupTimeoutMs: 5_000 }),
29
+ (host) => Effect.tryPromise(() => host.close()).pipe(Effect.ignore),
30
+ { interruptible: true },
31
+ );
32
+ return host.initializeResult.museHome;
33
+ }),
34
+ );
35
+ }),
36
+ {
37
+ capacity: 32,
38
+ // Retry unavailable installations, but keep resolved homes across scans.
39
+ timeToLive: (exit) =>
40
+ Exit.isSuccess(exit) && exit.value ? Duration.infinity : Duration.seconds(30),
41
+ },
42
+ );
43
+ const resolve: MuseUsageHome["Service"]["resolve"] = Effect.fn("MuseUsageHome.resolve")(
44
+ function* ({ binaryPath, environment }) {
45
+ // Cache keys compare structurally. Omitted and undefined variables both
46
+ // disappear from the child process environment and must share an entry.
47
+ return yield* Cache.get(cache, {
48
+ binaryPath,
49
+ environment: Object.fromEntries(
50
+ Object.entries(environment).filter(([, value]) => value !== undefined),
51
+ ),
52
+ }).pipe(Effect.orElseSucceed(() => undefined));
53
+ },
54
+ );
55
+ return MuseUsageHome.of({ resolve });
56
+});
57
+
58
+export const layer = Layer.effect(MuseUsageHome, make);
packages/provider-muse/src/server/driver.ts
+8
-1
@@ -22,6 +22,8 @@ import * as ProviderEventLoggers from "@t3tools/provider-core/server/ProviderEve
22
import { makeManagedServerProvider } from "@t3tools/provider-core/server/managedProvider";
23
import { enrichMuseSnapshot, latestMuseVersion, museMaintenance } from "./maintenance.ts";
24
import { makeMuseEnvironment } from "./sdk.ts";
25
+import { museUsageReader } from "./usage.ts";
26
+import type * as MuseUsageHome from "./MuseUsageHome.ts";
27
import {
28
defaultProviderContinuationIdentity,
29
type ProviderDriver,
@@ -53,9 +55,14 @@ export type MuseDriverEnv =
55
| Path.Path
56
| ProviderEventLoggers.ProviderEventLoggers;
57
56
-export const MuseDriver: ProviderDriver<MuseSettings, MuseDriverEnv> = {
58
+export const MuseDriver: ProviderDriver<
59
+ MuseSettings,
60
+ MuseDriverEnv,
61
+ Path.Path | MuseUsageHome.MuseUsageHome
62
+> = {
63
driverKind: DRIVER_KIND,
64
metadata: { displayName: "Muse Code", supportsMultipleInstances: true },
65
+ usage: museUsageReader,
66
configSchema: MuseSettings,
67
defaultConfig: () => decodeMuseSettings({}),
68
create: Effect.fn("MuseDriver.create")(function* ({
packages/provider-muse/src/server/sdk.ts
+2
-1
@@ -25,7 +25,8 @@ export interface MuseSdkHost {
25
| "onProtocolError"
26
| "closed"
27
>;
28
- readonly initializeResult: Pick<SpawnedMspConnection["initializeResult"], "grantedCapabilities">;
28
+ readonly initializeResult: Pick<SpawnedMspConnection["initializeResult"], "grantedCapabilities"> &
29
+ Partial<Pick<SpawnedMspConnection["initializeResult"], "museHome">>;
30
readonly exited: Promise<ProcessExit>;
31
readonly stderrTail?: () => ReadonlyArray<string>;
32
readonly close: () => Promise<void>;
packages/provider-muse/src/server/usage.test.ts
new
+409
@@ -0,0 +1,409 @@
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 * as Effect from "effect/Effect";
6
+import * as Deferred from "effect/Deferred";
7
+import * as Fiber from "effect/Fiber";
8
+import * as TestClock from "effect/testing/TestClock";
9
+import * as Path from "effect/Path";
10
+import * as Schema from "effect/Schema";
11
+import { it } from "@effect/vitest";
12
+import { describe, expect, vi } from "vite-plus/test";
13
+import { MuseSettings } from "../settings.ts";
14
+import * as MuseSdk from "./sdk.ts";
15
+import * as MuseUsageHome from "./MuseUsageHome.ts";
16
+import { museUsageFormat, museUsageReader } from "./usage.ts";
17
+
18
+vi.mock("./sdk.ts", { spy: true });
19
+
20
+const entry = () => ({
21
+ schema_version: 1,
22
+ record_type: "event",
23
+ payload_type: "runtime.session",
24
+ payload_schema_version: 1,
25
+ id: "envelope-1",
26
+ recorded_at: 1_785_578_400_123_456,
27
+ stream: { kind: "session", id: "session-1" },
28
+ payload: {
29
+ source_run_record_id: "inference-1",
30
+ event: {
31
+ kind: "model_completed",
32
+ model: "muse-wonder-full-1.0",
33
+ usage: {
34
+ input_tokens: 100,
35
+ cached_tokens: 60,
36
+ cache_read_tokens: 60,
37
+ cache_write_tokens: 10,
38
+ output_tokens: 20,
39
+ reasoning_tokens: 8,
40
+ },
41
+ },
42
+ },
43
+});
44
+const decodeSettings = Schema.decodeSync(MuseSettings);
45
+const parse = (value: unknown) => museUsageFormat.parseLine(JSON.stringify(value), undefined);
46
+
47
+it("normalizes inclusive cache and reasoning counters without doubling the subsets", () => {
48
+ const [record] = parse(entry());
49
+ expect(record).toMatchObject({
50
+ provider: "muse",
51
+ timestampMs: Date.parse("2026-08-01T10:00:00.123Z"),
52
+ sessionId: "session-1",
53
+ model: "muse-wonder-full-1.0",
54
+ reportedCostUsd: null,
55
+ totals: {
56
+ uncachedInputTokens: 30,
57
+ cachedInputTokens: 60,
58
+ cacheCreationTokens: 10,
59
+ outputTokens: 20,
60
+ reasoningTokens: 8,
61
+ },
62
+ });
63
+ expect(totalTokens(record!.totals)).toBe(120);
64
+ const value = entry();
65
+ const { cache_read_tokens: _read, ...usage } = value.payload.event.usage;
66
+ expect(
67
+ parse({ ...value, payload: { ...value.payload, event: { ...value.payload.event, usage } } }),
68
+ ).toEqual([record]);
69
+});
70
+
71
+it("keeps individual inference identity across copied parent/child envelopes", () => {
72
+ const original = entry();
73
+ const [first] = parse(original);
74
+ const [copy] = parse({ ...original, id: "copy", stream: { kind: "session", id: "child" } });
75
+ expect(copy?.dedupeKey).toBe(first?.dedupeKey);
76
+ const next = entry();
77
+ next.payload.source_run_record_id = "inference-2";
78
+ expect(parse(next)[0]?.dedupeKey).not.toBe(first?.dedupeKey);
79
+ const { source_run_record_id: _source, ...payload } = original.payload;
80
+ const fallback = parse({ ...original, payload });
81
+ expect(fallback[0]?.dedupeKey).toBe(JSON.stringify(["muse", original.id]));
82
+});
83
+
84
+it("includes automated review inference models and ignores workflow and telemetry rollups", () => {
85
+ const value = entry();
86
+ expect(
87
+ parse({
88
+ ...value,
89
+ payload: {
90
+ ...value.payload,
91
+ event: {
92
+ ...value.payload.event,
93
+ kind: "automated_review_completed",
94
+ model: { model_id: "review-model", provider_id: "meta" },
95
+ },
96
+ },
97
+ })[0]?.model,
98
+ ).toBe("review-model");
99
+ for (const kind of [
100
+ "workflow_completed",
101
+ "goal_usage_attribution",
102
+ "turn_completed",
103
+ "usage_summary",
104
+ ]) {
105
+ expect(
106
+ parse({ ...value, payload: { ...value.payload, event: { ...value.payload.event, kind } } }),
107
+ ).toEqual([]);
108
+ }
109
+ expect(parse({ ...value, payload_type: "run.telemetry" })).toEqual([]);
110
+ expect(parse({ ...value, record_type: "snapshot" })).toEqual([]);
111
+ expect(parse({ ...value, stream: { kind: "run", id: "run-1" } })).toEqual([]);
112
+});
113
+
114
+it("includes native version 3 automated review inferences", () => {
115
+ const value = entry();
116
+ const review = {
117
+ ...value,
118
+ payload_schema_version: 3,
119
+ payload: {
120
+ ...value.payload,
121
+ event: {
122
+ ...value.payload.event,
123
+ kind: "automated_review_completed",
124
+ model: { provider_id: "meta", model_id: "review-model", reasoning_effort: "high" },
125
+ usage: {
126
+ input_tokens: 100,
127
+ cached_input_tokens: 60,
128
+ output_tokens: 20,
129
+ reasoning_tokens: 8,
130
+ },
131
+ },
132
+ },
133
+ };
134
+ expect(parse(review)).toEqual([
135
+ {
136
+ ...parse(value)[0],
137
+ model: "review-model",
138
+ totals: {
139
+ uncachedInputTokens: 40,
140
+ cachedInputTokens: 60,
141
+ cacheCreationTokens: 0,
142
+ outputTokens: 20,
143
+ reasoningTokens: 8,
144
+ },
145
+ },
146
+ ]);
147
+ expect(museUsageFormat.parseProjected(review, undefined)).toEqual(parse(review));
148
+});
149
+
150
+it("handles malformed and partial data and rejects unsupported timestamps or schemas", () => {
151
+ expect(museUsageFormat.parseLine("not json", undefined)).toEqual([]);
152
+ expect(museUsageFormat.parseLine(JSON.stringify(entry()).slice(0, -1), undefined)).toEqual([]);
153
+ for (const recorded_at of [NaN, Infinity, -1, "1785578400123456", Number.MAX_SAFE_INTEGER + 1]) {
154
+ expect(museUsageFormat.parseProjected({ ...entry(), recorded_at }, undefined)).toEqual([]);
155
+ }
156
+ expect(parse({ ...entry(), schema_version: 2 })).toEqual([]);
157
+ expect(parse({ ...entry(), payload_schema_version: 2 })).toEqual([]);
158
+ expect(parse({ ...entry(), id: "" })).toEqual([]);
159
+ expect(parse({ ...entry(), payload: { event: { kind: "model_completed" } } })).toEqual([]);
160
+ const value = entry();
161
+ const result = parse({
162
+ ...value,
163
+ payload: {
164
+ event: {
165
+ ...value.payload.event,
166
+ usage: {
167
+ input_tokens: 10,
168
+ cache_read_tokens: 20,
169
+ cache_write_tokens: 8,
170
+ output_tokens: 3,
171
+ reasoning_tokens: 9,
172
+ },
173
+ },
174
+ },
175
+ });
176
+ expect(result[0]?.totals).toEqual({
177
+ uncachedInputTokens: 0,
178
+ cachedInputTokens: 10,
179
+ cacheCreationTokens: 0,
180
+ outputTokens: 3,
181
+ reasoningTokens: 3,
182
+ });
183
+ expect(
184
+ parse({
185
+ ...value,
186
+ payload: {
187
+ event: { ...value.payload.event, usage: { input_tokens: -5, output_tokens: "20" } },
188
+ },
189
+ }),
190
+ ).toEqual([]);
191
+});
192
+
193
+describe("Muse history discovery", () => {
194
+ it.effect.each([undefined, "/custom/xdg-data"])(
195
+ "uses the initialized home with XDG_DATA_HOME=%s and closes without starting a session",
196
+ (xdg) =>
197
+ Effect.gen(function* () {
198
+ const path = yield* Path.Path;
199
+ const close = vi.fn(async () => {});
200
+ using create = vi.spyOn(MuseSdk, "createMuseSdkHostEffect").mockReturnValue(
201
+ Effect.succeed({
202
+ initializeResult: { grantedCapabilities: [], museHome: "/native/configured-home" },
203
+ close,
204
+ } as unknown as MuseSdk.MuseSdkHost),
205
+ );
206
+ if (museUsageReader.kind !== "transcripts") throw new Error("Expected a transcript reader");
207
+ const directories = yield* museUsageReader.directories({
208
+ instanceId: ProviderInstanceId.make("muse-other"),
209
+ configured: true,
210
+ config: decodeSettings({ binaryPath: "~/bin/custom-muse" }),
211
+ environment: { XDG_DATA_HOME: xdg, MUSE_NO_AUTO_UPDATE: "0" },
212
+ });
213
+ expect(directories).toEqual([
214
+ { dir: path.join("/native/configured-home", "sessions"), fileName: "session.jsonl" },
215
+ ]);
216
+ expect(create).toHaveBeenCalledWith({
217
+ binaryPath: path.join("/test-home", "bin/custom-muse"),
218
+ environment: {
219
+ PATH: "/host/bin",
220
+ XDG_DATA_HOME: xdg ?? "/host/data",
221
+ MUSE_NO_AUTO_UPDATE: "1",
222
+ },
223
+ readOnly: true,
224
+ startupTimeoutMs: 5_000,
225
+ });
226
+ expect(close).toHaveBeenCalledOnce();
227
+ }).pipe(
228
+ Effect.provide([NodeServices.layer, MuseUsageHome.layer]),
229
+ Effect.provideService(HostProcess.HomeDirectory, "/test-home"),
230
+ Effect.provideService(HostProcess.Environment, {
231
+ PATH: "/host/bin",
232
+ XDG_DATA_HOME: "/host/data",
233
+ }),
234
+ ),
235
+ );
236
+
237
+ it.effect("does not guess a directory when initialization fails", () =>
238
+ Effect.gen(function* () {
239
+ using _create = vi.spyOn(MuseSdk, "createMuseSdkHostEffect").mockReturnValue(
240
+ Effect.try(() => {
241
+ throw new Error("not installed");
242
+ }),
243
+ );
244
+ if (museUsageReader.kind !== "transcripts") throw new Error("Expected a transcript reader");
245
+ const directories = yield* museUsageReader.directories({
246
+ instanceId: ProviderInstanceId.make("muse"),
247
+ configured: false,
248
+ config: undefined,
249
+ environment: {},
250
+ });
251
+ expect(directories).toEqual([]);
252
+ }).pipe(Effect.provide([NodeServices.layer, MuseUsageHome.layer])),
253
+ );
254
+
255
+ it.effect(
256
+ "reuses discovery across accounts, date scans, and equivalent effective environments",
257
+ () =>
258
+ Effect.gen(function* () {
259
+ const path = yield* Path.Path;
260
+ const close = vi.fn(async () => {});
261
+ using create = vi.spyOn(MuseSdk, "createMuseSdkHostEffect").mockReturnValue(
262
+ Effect.succeed({
263
+ initializeResult: { museHome: "/native/home" },
264
+ close,
265
+ } as unknown as MuseSdk.MuseSdkHost),
266
+ );
267
+ if (museUsageReader.kind !== "transcripts") throw new Error("Expected a transcript reader");
268
+ const instance = {
269
+ instanceId: ProviderInstanceId.make("disabled-muse"),
270
+ configured: true,
271
+ config: decodeSettings({ binaryPath: "~/bin/muse", enabled: false }),
272
+ environment: { PATH: "/bin", XDG_DATA_HOME: "/data" },
273
+ };
274
+ const first = yield* museUsageReader.directories(instance);
275
+ const second = yield* museUsageReader.directories({
276
+ ...instance,
277
+ instanceId: ProviderInstanceId.make("another-account"),
278
+ config: decodeSettings({
279
+ binaryPath: path.join("/test-home", "bin/muse"),
280
+ enabled: true,
281
+ }),
282
+ environment: {
283
+ XDG_DATA_HOME: "/data",
284
+ PATH: "/bin",
285
+ UNUSED: undefined,
286
+ META_API_KEY: "ignored",
287
+ },
288
+ });
289
+ expect(second).toEqual(first);
290
+ expect(first).toEqual([
291
+ { dir: path.join("/native/home", "sessions"), fileName: "session.jsonl" },
292
+ ]);
293
+ expect(create).toHaveBeenCalledOnce();
294
+ expect(close).toHaveBeenCalledOnce();
295
+ }).pipe(
296
+ Effect.provide([NodeServices.layer, MuseUsageHome.layer]),
297
+ Effect.provideService(HostProcess.HomeDirectory, "/test-home"),
298
+ Effect.provideService(HostProcess.Environment, {}),
299
+ ),
300
+ );
301
+
302
+ it.effect(
303
+ "rediscovers when the binary, instance environment, or inherited environment changes",
304
+ () =>
305
+ Effect.gen(function* () {
306
+ using create = vi.spyOn(MuseSdk, "createMuseSdkHostEffect").mockImplementation((options) =>
307
+ Effect.succeed({
308
+ initializeResult: { museHome: options.environment?.XDG_DATA_HOME },
309
+ close: async () => {},
310
+ } as unknown as MuseSdk.MuseSdkHost),
311
+ );
312
+ if (museUsageReader.kind !== "transcripts") throw new Error("Expected a transcript reader");
313
+ const instance = {
314
+ instanceId: ProviderInstanceId.make("muse"),
315
+ configured: true,
316
+ config: undefined,
317
+ environment: {},
318
+ };
319
+ const first = yield* museUsageReader.directories(instance);
320
+ expect(
321
+ yield* museUsageReader.directories({
322
+ ...instance,
323
+ config: decodeSettings({ binaryPath: "custom-muse" }),
324
+ }),
325
+ ).toEqual(first);
326
+ const changed = yield* museUsageReader.directories({
327
+ ...instance,
328
+ environment: { XDG_DATA_HOME: "/other-data" },
329
+ });
330
+ expect(changed).not.toEqual(first);
331
+ const inherited = yield* museUsageReader
332
+ .directories(instance)
333
+ .pipe(
334
+ Effect.provideService(HostProcess.Environment, { XDG_DATA_HOME: "/new-host-data" }),
335
+ );
336
+ expect(inherited).not.toEqual(first);
337
+ expect(inherited).not.toEqual(changed);
338
+ expect(create).toHaveBeenCalledTimes(4);
339
+ }).pipe(
340
+ Effect.provide([NodeServices.layer, MuseUsageHome.layer]),
341
+ Effect.provideService(HostProcess.Environment, { XDG_DATA_HOME: "/host-data" }),
342
+ ),
343
+ );
344
+
345
+ it.effect("shares pending initialization across concurrent directory reads", () =>
346
+ Effect.gen(function* () {
347
+ const started = yield* Deferred.make<void>();
348
+ const ready = yield* Deferred.make<MuseSdk.MuseSdkHost>();
349
+ using create = vi
350
+ .spyOn(MuseSdk, "createMuseSdkHostEffect")
351
+ .mockImplementation(() =>
352
+ Deferred.succeed(started, undefined).pipe(Effect.andThen(Deferred.await(ready))),
353
+ );
354
+ const close = vi.fn(async () => {});
355
+ if (museUsageReader.kind !== "transcripts") throw new Error("Expected a transcript reader");
356
+ const instance = {
357
+ instanceId: ProviderInstanceId.make("muse"),
358
+ configured: true,
359
+ config: undefined,
360
+ environment: {},
361
+ };
362
+ const reads = yield* Effect.all(
363
+ [museUsageReader.directories(instance), museUsageReader.directories(instance)],
364
+ { concurrency: "unbounded" },
365
+ ).pipe(Effect.forkChild);
366
+ yield* Deferred.await(started);
367
+ yield* Deferred.succeed(ready, {
368
+ initializeResult: { museHome: "/native/home" },
369
+ close,
370
+ } as unknown as MuseSdk.MuseSdkHost);
371
+ const [first, second] = yield* Fiber.join(reads);
372
+ expect(first).toEqual(second);
373
+ expect(first).toHaveLength(1);
374
+ expect(create).toHaveBeenCalledOnce();
375
+ expect(close).toHaveBeenCalledOnce();
376
+ }).pipe(Effect.provide([NodeServices.layer, MuseUsageHome.layer])),
377
+ );
378
+
379
+ it.effect("briefly caches failed discovery and retries after installation recovers", () =>
380
+ Effect.gen(function* () {
381
+ using create = vi
382
+ .spyOn(MuseSdk, "createMuseSdkHostEffect")
383
+ .mockReturnValueOnce(
384
+ Effect.try(() => {
385
+ throw new Error("not installed");
386
+ }),
387
+ )
388
+ .mockReturnValue(
389
+ Effect.succeed({
390
+ initializeResult: { museHome: "/installed/home" },
391
+ close: async () => {},
392
+ } as unknown as MuseSdk.MuseSdkHost),
393
+ );
394
+ if (museUsageReader.kind !== "transcripts") throw new Error("Expected a transcript reader");
395
+ const instance = {
396
+ instanceId: ProviderInstanceId.make("muse"),
397
+ configured: false,
398
+ config: undefined,
399
+ environment: {},
400
+ };
401
+ expect(yield* museUsageReader.directories(instance)).toEqual([]);
402
+ expect(yield* museUsageReader.directories(instance)).toEqual([]);
403
+ expect(create).toHaveBeenCalledOnce();
404
+ yield* TestClock.adjust("30 seconds");
405
+ expect(yield* museUsageReader.directories(instance)).toHaveLength(1);
406
+ expect(create).toHaveBeenCalledTimes(2);
407
+ }).pipe(Effect.provide([NodeServices.layer, MuseUsageHome.layer])),
408
+ );
409
+});
packages/provider-muse/src/server/usage.ts
new
+140
@@ -0,0 +1,140 @@
1
+import * as Effect from "effect/Effect";
2
+import * as Option from "effect/Option";
3
+import * as Path from "effect/Path";
4
+import * as Schema from "effect/Schema";
5
+
6
+import { mergeProviderInstanceEnvironment } from "@t3tools/provider-core/server/instanceEnvironment";
7
+import { expandHomePath } from "@t3tools/provider-core/server/pathExpansion";
8
+import {
9
+ tokenCount,
10
+ totalTokens,
11
+ type ProviderUsageReader,
12
+ type TranscriptUsageFormat,
13
+ type UsageRecord,
14
+} from "@t3tools/provider-core/server/usage";
15
+import * as HostProcess from "@t3tools/shared/HostProcess";
16
+import type { MuseSettings } from "../settings.ts";
17
+import { makeMuseEnvironment } from "./sdk.ts";
18
+import * as MuseUsageHome from "./MuseUsageHome.ts";
19
+
20
+const Entry = Schema.Struct({
21
+ schema_version: Schema.Literal(1),
22
+ record_type: Schema.Literal("event"),
23
+ payload_type: Schema.Literal("runtime.session"),
24
+ // Native automated review completions use session payload version 3.
25
+ payload_schema_version: Schema.Literals([1, 3]),
26
+ id: Schema.NonEmptyString,
27
+ recorded_at: Schema.Number,
28
+ stream: Schema.Struct({ kind: Schema.Literal("session"), id: Schema.NonEmptyString }),
29
+ payload: Schema.Struct({
30
+ source_run_record_id: Schema.optional(Schema.NonEmptyString),
31
+ event: Schema.Struct({
32
+ kind: Schema.Literals(["model_completed", "automated_review_completed"]),
33
+ model: Schema.Union([
34
+ Schema.NonEmptyString,
35
+ Schema.Struct({ model_id: Schema.NonEmptyString }),
36
+ ]),
37
+ usage: Schema.Struct({
38
+ input_tokens: Schema.optional(Schema.Unknown),
39
+ output_tokens: Schema.optional(Schema.Unknown),
40
+ cached_tokens: Schema.optional(Schema.Unknown),
41
+ cached_input_tokens: Schema.optional(Schema.Unknown),
42
+ cache_read_tokens: Schema.optional(Schema.Unknown),
43
+ cache_write_tokens: Schema.optional(Schema.Unknown),
44
+ reasoning_tokens: Schema.optional(Schema.Unknown),
45
+ }),
46
+ }),
47
+ }),
48
+});
49
+const decodeEntry = Schema.decodeUnknownOption(Entry);
50
+
51
+function parseRecord(parsed: unknown): readonly UsageRecord[] {
52
+ const decoded = decodeEntry(parsed);
53
+ if (Option.isNone(decoded)) return [];
54
+ const entry = decoded.value;
55
+ if (!Number.isSafeInteger(entry.recorded_at) || entry.recorded_at < 0) return [];
56
+ const { event } = entry.payload;
57
+ const { usage } = event;
58
+ const input = tokenCount(usage.input_tokens);
59
+ const cachedInputTokens = Math.min(
60
+ input,
61
+ tokenCount(usage.cache_read_tokens ?? usage.cached_input_tokens ?? usage.cached_tokens),
62
+ );
63
+ const cacheCreationTokens = Math.min(
64
+ input - cachedInputTokens,
65
+ tokenCount(usage.cache_write_tokens),
66
+ );
67
+ const outputTokens = tokenCount(usage.output_tokens);
68
+ const totals = {
69
+ // Muse's cache counters are subsets of input; reasoning is a subset of output.
70
+ uncachedInputTokens: input - cachedInputTokens - cacheCreationTokens,
71
+ cachedInputTokens,
72
+ cacheCreationTokens,
73
+ outputTokens,
74
+ reasoningTokens: Math.min(outputTokens, tokenCount(usage.reasoning_tokens)),
75
+ };
76
+ if (totalTokens(totals) === 0) return [];
77
+ return [
78
+ {
79
+ provider: "muse",
80
+ timestampMs: Math.trunc(entry.recorded_at / 1_000),
81
+ model: typeof event.model === "string" ? event.model : event.model.model_id,
82
+ sessionId: entry.stream.id,
83
+ totals,
84
+ reportedCostUsd: null,
85
+ speed: "standard",
86
+ // Runtime envelopes can be copied into another session. The source record
87
+ // identifies the inference even when the enclosing envelope has a new ID.
88
+ dedupeKey: JSON.stringify(["muse", entry.payload.source_run_record_id ?? entry.id]),
89
+ },
90
+ ];
91
+}
92
+
93
+export const museUsageFormat: TranscriptUsageFormat<unknown> = {
94
+ selectFields: {
95
+ schema_version: true,
96
+ record_type: true,
97
+ payload_type: true,
98
+ payload_schema_version: true,
99
+ id: true,
100
+ recorded_at: true,
101
+ stream: { kind: true, id: true },
102
+ payload: { source_run_record_id: true, event: { kind: true, model: true, usage: true } },
103
+ },
104
+ usageMarkers: ['"model_completed"', '"automated_review_completed"'],
105
+ parseLine: (line) => {
106
+ let parsed: unknown;
107
+ try {
108
+ parsed = JSON.parse(line);
109
+ } catch {
110
+ return [];
111
+ }
112
+ return parseRecord(parsed);
113
+ },
114
+ parseProjected: parseRecord,
115
+};
116
+
117
+export const museUsageReader: ProviderUsageReader<
118
+ MuseSettings,
119
+ Path.Path | MuseUsageHome.MuseUsageHome
120
+> = {
121
+ kind: "transcripts",
122
+ provider: "muse",
123
+ format: museUsageFormat,
124
+ directories: Effect.fn("museUsageReader.directories")(function* ({ config, environment }) {
125
+ const path = yield* Path.Path;
126
+ const home = yield* HostProcess.HomeDirectory;
127
+ const usageHome = yield* MuseUsageHome.MuseUsageHome;
128
+ const processEnvironment = yield* mergeProviderInstanceEnvironment(
129
+ Object.entries(environment).flatMap(([name, value]) =>
130
+ value === undefined ? [] : [{ name, value, sensitive: false }],
131
+ ),
132
+ yield* HostProcess.Environment,
133
+ );
134
+ const museHome = yield* usageHome.resolve({
135
+ binaryPath: expandHomePath(config?.binaryPath ?? "muse", home),
136
+ environment: makeMuseEnvironment(processEnvironment),
137
+ });
138
+ return museHome ? [{ dir: path.join(museHome, "sessions"), fileName: "session.jsonl" }] : [];
139
+ }),
140
+};