pi-dual-engine 0.0.0-stage → 0.2.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.
Files changed (46) hide show
  1. package/README.md +103 -2
  2. package/biome.json +22 -0
  3. package/dist/index.js +1089 -0
  4. package/package.json +27 -4
  5. package/scripts/smoke.ts +141 -0
  6. package/src/assignment.ts +176 -0
  7. package/src/breaker.ts +33 -0
  8. package/src/config.ts +55 -0
  9. package/src/engine-pool.ts +163 -0
  10. package/src/families.ts +58 -0
  11. package/src/handles.ts +31 -0
  12. package/src/headroom-http.ts +58 -0
  13. package/src/index.ts +96 -0
  14. package/src/lifecycle.ts +145 -0
  15. package/src/locks.ts +93 -0
  16. package/src/probe.ts +154 -0
  17. package/src/providers.ts +71 -0
  18. package/src/retrieve.ts +65 -0
  19. package/src/session.ts +150 -0
  20. package/src/setup.ts +230 -0
  21. package/src/state.ts +49 -0
  22. package/src/status.ts +64 -0
  23. package/src/types.ts +47 -0
  24. package/test/assignment.test.ts +193 -0
  25. package/test/boot.ts +84 -0
  26. package/test/breaker.test.ts +92 -0
  27. package/test/coldstart.test.ts +133 -0
  28. package/test/defaults.test.ts +16 -0
  29. package/test/degradation.test.ts +69 -0
  30. package/test/factory.test.ts +158 -0
  31. package/test/fakes.ts +155 -0
  32. package/test/handles.test.ts +37 -0
  33. package/test/harness.ts +39 -0
  34. package/test/headroom-http.test.ts +99 -0
  35. package/test/lifecycle.test.ts +75 -0
  36. package/test/optin.test.ts +41 -0
  37. package/test/ownership.test.ts +160 -0
  38. package/test/probe.test.ts +195 -0
  39. package/test/providers.test.ts +156 -0
  40. package/test/retrieve.test.ts +137 -0
  41. package/test/windows-spawn.test.ts +93 -0
  42. package/tsconfig.json +17 -0
  43. package/wiki/01-getting-started.md +17 -0
  44. package/wiki/02-guides-and-workflows.md +22 -0
  45. package/wiki/03-architecture-and-internals.md +15 -0
  46. package/wiki/index.md +15 -0
package/dist/index.js ADDED
@@ -0,0 +1,1089 @@
1
+ // src/breaker.ts
2
+ async function onProviderResponse(state, input) {
3
+ if (input.event.status < 400)
4
+ return;
5
+ const model = input.model;
6
+ if (!model)
7
+ return;
8
+ const provider = model.provider;
9
+ const direct = state.directModels.get(provider);
10
+ if (!direct || state.tripped.has(provider))
11
+ return;
12
+ state.tripped.add(provider);
13
+ const restored = await input.setModel(direct);
14
+ state.notify(`Proxy route for "${provider}" failed with ${input.event.status}; ${restored ? "the selected model now uses its direct endpoint" : "restore the direct endpoint manually"}. This provider stays direct for the session.`);
15
+ }
16
+
17
+ // src/assignment.ts
18
+ var PREFERENCE = {
19
+ openai: ["headroom", "caveman"],
20
+ anthropic: ["headroom", "caveman"],
21
+ gemini: ["caveman", "headroom"]
22
+ };
23
+ function familiesOf(group, familyOf, hostOf) {
24
+ const seen = new Map;
25
+ for (const model of group.models) {
26
+ const family = familyOf(model.api);
27
+ const host = hostOf(model.baseUrl);
28
+ if (!family || !host)
29
+ continue;
30
+ seen.set(`${family}|${host}`, { family, host, url: model.baseUrl ?? "" });
31
+ }
32
+ return [...seen.values()];
33
+ }
34
+ function proves(engine, target) {
35
+ return engine.upstreams.some((upstream) => upstream.family === target.family && upstream.host === target.host);
36
+ }
37
+ function chooseEngine(engines, targets) {
38
+ let best;
39
+ for (const engine of engines) {
40
+ const covered = targets.filter((target) => proves(engine, target)).length;
41
+ if (covered === 0)
42
+ continue;
43
+ const rank = targets.reduce((sum, target) => {
44
+ const order = PREFERENCE[target.family];
45
+ const index = order.indexOf(engine.engine);
46
+ return sum + (index === -1 ? order.length : index);
47
+ }, 0);
48
+ const candidate = { engine: engine.engine, covered, rank };
49
+ if (!best || candidate.covered > best.covered || candidate.covered === best.covered && candidate.rank < best.rank) {
50
+ best = candidate;
51
+ }
52
+ }
53
+ return best?.engine;
54
+ }
55
+ function resolveOverrides(overrides) {
56
+ const notices = [];
57
+ const valid = new Map;
58
+ const counts = new Map;
59
+ for (const entry of overrides) {
60
+ counts.set(entry.provider, (counts.get(entry.provider) ?? 0) + 1);
61
+ }
62
+ for (const entry of overrides) {
63
+ if ((counts.get(entry.provider) ?? 0) > 1) {
64
+ if (!notices.some((notice) => notice.includes(`Conflicting assignments for provider "${entry.provider}"`))) {
65
+ notices.push(`Conflicting assignments for provider "${entry.provider}": the derived engine applies.`);
66
+ }
67
+ continue;
68
+ }
69
+ if (entry.engine !== "caveman" && entry.engine !== "headroom") {
70
+ notices.push(`Unknown engine "${entry.engine}" for provider "${entry.provider}": the derived engine applies.`);
71
+ continue;
72
+ }
73
+ valid.set(entry.provider, entry.engine);
74
+ }
75
+ return { valid, notices };
76
+ }
77
+ function deriveAssignments(groups, engines, overrides, helpers) {
78
+ const { valid, notices: overrideNotices } = resolveOverrides(overrides);
79
+ const notices = [...overrideNotices];
80
+ const plans = [];
81
+ for (const group of groups) {
82
+ const targets = familiesOf(group, helpers.familyOf, helpers.hostOf);
83
+ if (targets.length === 0) {
84
+ notices.push(`Provider "${group.provider}" serves no wire family an engine can carry: running direct.`);
85
+ continue;
86
+ }
87
+ const engine = valid.get(group.provider) ?? chooseEngine(engines, targets);
88
+ if (!engine) {
89
+ notices.push(`Provider "${group.provider}" serves ${targets.map((t) => t.family).join(", ")} with no engine that can carry it: running direct.`);
90
+ continue;
91
+ }
92
+ const state = engines.find((candidate) => candidate.engine === engine);
93
+ const carried = [];
94
+ const direct = [];
95
+ for (const target of targets) {
96
+ const already = carried.some((entry) => entry.family === target.family);
97
+ if (state && proves(state, target) && !already)
98
+ carried.push({ family: target.family, url: target.url });
99
+ else if (!direct.includes(target.family))
100
+ direct.push(target.family);
101
+ }
102
+ if (carried.length === 0) {
103
+ notices.push(`Provider "${group.provider}" cannot be carried by ${engine}: remaining direct.`);
104
+ continue;
105
+ }
106
+ if (direct.length > 0) {
107
+ notices.push(`Provider "${group.provider}": ${direct.join(", ")} routed direct because ${engine} cannot carry that family.`);
108
+ }
109
+ plans.push({
110
+ provider: group.provider,
111
+ engine,
112
+ families: carried.map((entry) => entry.family),
113
+ direct,
114
+ upstreams: carried
115
+ });
116
+ }
117
+ return { plans, notices };
118
+ }
119
+
120
+ // src/families.ts
121
+ var FAMILY_TOKENS = [
122
+ ["anthropic", "anthropic"],
123
+ ["google", "gemini"],
124
+ ["gemini", "gemini"],
125
+ ["openai", "openai"]
126
+ ];
127
+ function familyOf(api) {
128
+ const value = api.toLowerCase();
129
+ for (const [token, family] of FAMILY_TOKENS) {
130
+ if (value.includes(token))
131
+ return family;
132
+ }
133
+ return;
134
+ }
135
+ function hostOf(baseUrl) {
136
+ if (!baseUrl)
137
+ return "";
138
+ try {
139
+ return new URL(baseUrl).host;
140
+ } catch {
141
+ return "";
142
+ }
143
+ }
144
+ function cavemanFamilyOf(key, compat) {
145
+ return compat ? "openai" : familyOf(key);
146
+ }
147
+ var RETRIEVAL_TOOL_CANDIDATES = {
148
+ caveman: ["caveman_retrieve"],
149
+ headroom: ["mcp__headroom__headroom_retrieve", "headroom_retrieve"]
150
+ };
151
+ function resolveRetrievalTool(engine, callable) {
152
+ const candidates = RETRIEVAL_TOOL_CANDIDATES[engine];
153
+ return candidates.find((name) => callable.some((tool) => tool.name === name)) ?? candidates[0];
154
+ }
155
+
156
+ // src/locks.ts
157
+ import { execFileSync } from "node:child_process";
158
+ import { mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
159
+ import { join } from "node:path";
160
+ var CAVEMAN_DEFAULT_PORT = 8787;
161
+ var HEADROOM_BASE_PORT = 8788;
162
+ function isAlive(pid) {
163
+ try {
164
+ process.kill(pid, 0);
165
+ return true;
166
+ } catch {
167
+ return false;
168
+ }
169
+ }
170
+ function readLock(path) {
171
+ try {
172
+ const parsed = JSON.parse(readFileSync(path, "utf8"));
173
+ if (typeof parsed.pid !== "number" || typeof parsed.port !== "number")
174
+ return;
175
+ return { pid: parsed.pid, port: parsed.port, startedAt: parsed.startedAt ?? 0 };
176
+ } catch {
177
+ return;
178
+ }
179
+ }
180
+ function writeLock(path, lock) {
181
+ mkdirSync(join(path, ".."), { recursive: true });
182
+ const temp = `${path}.${process.pid}.tmp`;
183
+ writeFileSync(temp, JSON.stringify(lock), "utf8");
184
+ renameSync(temp, path);
185
+ }
186
+ function takeLock(path, port, now) {
187
+ const existing = readLock(path);
188
+ if (existing && existing.pid !== process.pid && isAlive(existing.pid))
189
+ return false;
190
+ writeLock(path, { pid: process.pid, port, startedAt: now() });
191
+ return true;
192
+ }
193
+ function releaseLock(path) {
194
+ const existing = readLock(path);
195
+ if (existing && existing.pid !== process.pid)
196
+ return;
197
+ rmSync(path, { force: true });
198
+ }
199
+ function removeLock(path) {
200
+ rmSync(path, { force: true });
201
+ }
202
+ function lockPath(stateDir, engine, key) {
203
+ return join(stateDir, "locks", `${engine}-${key}.json`);
204
+ }
205
+ function portForKey(base, key) {
206
+ let hash = 0;
207
+ for (const char of key)
208
+ hash = (hash * 31 + char.charCodeAt(0)) % 100;
209
+ return base + hash;
210
+ }
211
+ function listeningPid(port) {
212
+ try {
213
+ const output = execFileSync("lsof", ["-ti", `tcp:${port}`, "-sTCP:LISTEN"], { encoding: "utf8" });
214
+ const pid = Number(output.trim().split(`
215
+ `)[0]);
216
+ return Number.isInteger(pid) && pid > 0 ? pid : undefined;
217
+ } catch {
218
+ return;
219
+ }
220
+ }
221
+
222
+ // src/lifecycle.ts
223
+ function engineKey(request) {
224
+ return request.engine === "caveman" ? "main" : request.key;
225
+ }
226
+ function expected(request) {
227
+ if (request.engine === "caveman")
228
+ return [];
229
+ return request.upstreams.map((upstream) => ({ family: upstream.family, host: hostOf(upstream.url) })).filter((upstream) => upstream.host !== "");
230
+ }
231
+ function enginePort(request) {
232
+ return request.engine === "caveman" ? CAVEMAN_DEFAULT_PORT : portForKey(HEADROOM_BASE_PORT, request.key);
233
+ }
234
+ function spawnEngine(request, port, deps) {
235
+ if (request.engine === "caveman")
236
+ return deps.spawn("caveman", ["enable", "pi"]);
237
+ const args = ["proxy", "--port", String(port)];
238
+ const seen = new Set;
239
+ for (const upstream of request.upstreams) {
240
+ if (seen.has(upstream.family))
241
+ continue;
242
+ seen.add(upstream.family);
243
+ args.push(`--${upstream.family}-api-url`, upstream.url);
244
+ }
245
+ return deps.spawn("headroom", args);
246
+ }
247
+ async function waitForVerified(request, port, deps) {
248
+ const deadline = deps.now() + deps.timeoutMs;
249
+ for (;; ) {
250
+ const result = request.engine === "caveman" ? await deps.probeCaveman({ port, home: deps.cavemanHome, timeoutMs: 2000, owned: true }) : await deps.probeHeadroom({
251
+ port,
252
+ timeoutMs: 2000,
253
+ owned: true,
254
+ expect: expected(request)
255
+ });
256
+ if (result.ok)
257
+ return result.state;
258
+ if (deps.now() >= deadline)
259
+ return;
260
+ await deps.sleep(250);
261
+ }
262
+ }
263
+ async function ensureEngine(request, deps) {
264
+ const port = enginePort(request);
265
+ const adopted = request.engine === "caveman" ? await deps.probeCaveman({ port, home: deps.cavemanHome, timeoutMs: 2000, owned: false }) : await deps.probeHeadroom({ port, timeoutMs: 2000, owned: false, expect: expected(request) });
266
+ if (adopted.ok)
267
+ return adopted;
268
+ if (adopted.occupied)
269
+ return adopted;
270
+ if (!request.start)
271
+ return adopted;
272
+ const path = lockPath(deps.stateDir, request.engine, engineKey(request));
273
+ const recorded = readLock(path);
274
+ if (!takeLock(path, port, deps.now))
275
+ return { ok: false, reason: `another session holds ${path}` };
276
+ const child = spawnEngine(request, port, deps);
277
+ const state = await waitForVerified(request, port, deps);
278
+ if (state) {
279
+ const pid = request.engine === "headroom" ? listeningPid(port) ?? child.pid : child.pid;
280
+ writeLock(path, { pid: pid ?? -1, port, startedAt: deps.now() });
281
+ const tagged = request.engine === "caveman" ? { ...state, shutdown: "caveman", key: engineKey(request) } : { ...state, key: engineKey(request) };
282
+ return { ok: true, state: tagged };
283
+ }
284
+ if (child.pid !== undefined)
285
+ deps.kill(child.pid);
286
+ if (recorded?.pid === undefined)
287
+ releaseLock(path);
288
+ return { ok: false, reason: `${request.engine} did not verify within ${deps.timeoutMs} ms` };
289
+ }
290
+ function stopOwned(state, deps) {
291
+ if (!state.owned)
292
+ return;
293
+ const path = lockPath(deps.stateDir, state.engine, state.key ?? (state.engine === "caveman" ? "main" : String(state.port)));
294
+ const lock = readLock(path);
295
+ if (state.shutdown === "caveman")
296
+ deps.cavemanStop?.();
297
+ else if (lock && lock.pid > 0 && isAlive(lock.pid))
298
+ deps.kill(lock.pid);
299
+ removeLock(path);
300
+ }
301
+
302
+ // src/providers.ts
303
+ function planProviderConfig(plan, group, proxyUrl, extras = new Map) {
304
+ const chat = group.models.map((model) => {
305
+ const family = familyOf(model.api);
306
+ const carried = family !== undefined && plan.families.includes(family);
307
+ return {
308
+ ...model,
309
+ baseUrl: carried ? proxyUrl : model.baseUrl
310
+ };
311
+ });
312
+ const rest = extras.get(plan.provider) ?? [];
313
+ return { baseUrl: proxyUrl, models: [...chat, ...rest] };
314
+ }
315
+ function planRegistrations(plans, groups, ports, extras = new Map) {
316
+ const registrations = [];
317
+ for (const plan of plans) {
318
+ const port = ports.get(plan.provider);
319
+ const group = groups.find((candidate) => candidate.provider === plan.provider);
320
+ if (port === undefined || !group)
321
+ continue;
322
+ const config = planProviderConfig(plan, group, `http://127.0.0.1:${port}`, extras);
323
+ registrations.push({ provider: plan.provider, engine: plan.engine, config });
324
+ }
325
+ return registrations;
326
+ }
327
+ function registerAll(api, registrations, onError) {
328
+ for (const registration of registrations) {
329
+ try {
330
+ api.registerProvider(registration.provider, registration.config);
331
+ } catch (error) {
332
+ onError?.(`Could not register "${registration.provider}": ${error.message}. Its models run direct.`);
333
+ }
334
+ }
335
+ }
336
+
337
+ // src/engine-pool.ts
338
+ async function discoverEngines(groups, deps) {
339
+ const engines = [];
340
+ const headroom = new Map;
341
+ const failures = new Map;
342
+ const caveman = await ensureEngine({ engine: "caveman", start: false }, deps.lifecycle);
343
+ if (caveman.ok)
344
+ engines.push(caveman.state);
345
+ else
346
+ failures.set("caveman", caveman.reason);
347
+ for (const group of groups) {
348
+ const upstreams = group.models.map((model) => ({ family: familyOf(model.api), url: model.baseUrl ?? "" })).filter((entry) => Boolean(entry.family && entry.url)).map((entry) => ({ family: entry.family, url: entry.url }));
349
+ const probe = await ensureEngine({ engine: "headroom", key: group.provider, start: false, upstreams }, deps.lifecycle);
350
+ if (probe.ok)
351
+ headroom.set(group.provider, probe.state);
352
+ else
353
+ failures.set("headroom", probe.reason);
354
+ }
355
+ engines.push(...headroom.values());
356
+ return { engines, headroom, failures };
357
+ }
358
+ async function startNeeded(groups, currentProvider, discovered, deps) {
359
+ const families = new Map;
360
+ for (const group of groups) {
361
+ families.set(group.provider, group.models.map((model) => ({ family: familyOf(model.api), url: model.baseUrl ?? "" })).filter((entry) => Boolean(entry.family && entry.url)));
362
+ }
363
+ const wantsCaveman = [...families.values()].some((list) => list.some((entry) => PREFERENCE[entry.family][0] === "caveman"));
364
+ if (wantsCaveman && !hasEngine(discovered, "caveman") && deps.start.caveman) {
365
+ await startCaveman(discovered, deps);
366
+ }
367
+ if (currentProvider !== undefined)
368
+ await startHeadroom(currentProvider, families.get(currentProvider) ?? [], discovered, deps);
369
+ }
370
+ function hasEngine(discovered, engine) {
371
+ return discovered.engines.some((state) => state.engine === engine);
372
+ }
373
+ async function startCaveman(discovered, deps) {
374
+ const probe = await ensureEngine({ engine: "caveman", start: true }, deps.lifecycle);
375
+ if (probe.ok) {
376
+ discovered.engines.push(probe.state);
377
+ discovered.failures.delete("caveman");
378
+ } else {
379
+ discovered.failures.set("caveman", probe.reason);
380
+ }
381
+ }
382
+ async function startHeadroom(provider, families, discovered, deps) {
383
+ if (discovered.headroom.has(provider) || !deps.start.headroom)
384
+ return;
385
+ if (!families.some((entry) => PREFERENCE[entry.family][0] === "headroom"))
386
+ return;
387
+ const upstreams = [...new Map(families.map((entry) => [entry.family, entry])).values()];
388
+ const probe = await ensureEngine({ engine: "headroom", key: provider, start: true, upstreams }, deps.lifecycle);
389
+ if (probe.ok) {
390
+ discovered.headroom.set(provider, probe.state);
391
+ discovered.engines.push(probe.state);
392
+ discovered.failures.delete("headroom");
393
+ } else {
394
+ discovered.failures.set("headroom", probe.reason);
395
+ }
396
+ }
397
+ async function ensureProvider(api, state, provider, deps) {
398
+ const group = state.groups.find((entry) => entry.provider === provider);
399
+ const families = (group?.models ?? []).map((model) => ({ family: familyOf(model.api), url: model.baseUrl ?? "" })).filter((entry) => Boolean(entry.family && entry.url));
400
+ const wanted = families.some((entry) => PREFERENCE[entry.family][0] === "headroom");
401
+ if (!wanted || state.ports.has(provider))
402
+ return;
403
+ const upstreams = [...new Map(families.map((entry) => [entry.family, entry])).values()];
404
+ const probe = await ensureEngine({ engine: "headroom", key: provider, start: deps.start.headroom, upstreams }, deps.lifecycle);
405
+ if (!probe.ok) {
406
+ deps.notify("warning", `headroom could not start for "${provider}" (${probe.reason}); its models run direct.`);
407
+ return;
408
+ }
409
+ state.engines.push(probe.state);
410
+ state.ports.set(provider, probe.state.port);
411
+ if (!state.counters.has("headroom"))
412
+ state.counters.set("headroom", { requests: 0, failures: 0 });
413
+ const derived = deriveAssignments(state.groups, state.engines, deps.overrides, { familyOf, hostOf });
414
+ const updated = derived.plans.find((plan) => plan.provider === provider);
415
+ if (!updated)
416
+ return;
417
+ const index = state.plans.findIndex((plan) => plan.provider === provider);
418
+ if (index >= 0)
419
+ state.plans[index] = updated;
420
+ if (updated.engine !== "headroom")
421
+ return;
422
+ registerAll(api, planRegistrations([updated], state.groups, new Map([[provider, probe.state.port]]), state.extras), (message) => deps.notify("warning", message));
423
+ }
424
+
425
+ // src/retrieve.ts
426
+ import { Type } from "typebox";
427
+
428
+ // src/handles.ts
429
+ var CAVEMAN_HANDLE = /^ccr_[A-Za-z0-9_]+$/;
430
+ var HEADROOM_HANDLE = /^[a-f0-9]{12,24}$/;
431
+ var CAVEMAN_MARKER = /^<<ccr:(.+)>>$/;
432
+ var CCR_SCHEME = /^ccr:\/\//;
433
+ function normalizeHandle(raw) {
434
+ let value = raw.trim();
435
+ const marker = CAVEMAN_MARKER.exec(value);
436
+ if (marker?.[1])
437
+ value = marker[1].trim();
438
+ return value.replace(CCR_SCHEME, "");
439
+ }
440
+ function dispatchHandle(raw) {
441
+ const handle = normalizeHandle(raw);
442
+ if (CAVEMAN_HANDLE.test(handle))
443
+ return { engine: "caveman", handle };
444
+ if (HEADROOM_HANDLE.test(handle))
445
+ return { engine: "headroom", handle };
446
+ return {
447
+ error: `Unrecognized recovery handle: "${handle}". Expected a Caveman handle (ccr_...) or a Headroom handle (12-24 lowercase hex).`
448
+ };
449
+ }
450
+
451
+ // src/retrieve.ts
452
+ var parameters = Type.Object({
453
+ handle: Type.String({
454
+ description: "Recovery handle from a compression marker: ccr_... or 12-24 lowercase hex."
455
+ })
456
+ });
457
+ function text(value) {
458
+ return { content: [{ type: "text", text: value }], details: undefined };
459
+ }
460
+ function createRetrieveTool(deps) {
461
+ return {
462
+ name: "retrieve",
463
+ label: "Retrieve",
464
+ description: "Restore an original compressed by Caveman or Headroom. Pass the recovery handle exactly as it appeared in the marker.",
465
+ parameters,
466
+ prepareLoadout: (loadout) => ({
467
+ hiddenDeclarations: Object.values(RETRIEVAL_TOOL_CANDIDATES).flat().filter((name) => loadout.registered.some((tool) => tool.name === name))
468
+ }),
469
+ async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
470
+ const target = dispatchHandle(params.handle);
471
+ if ("error" in target) {
472
+ const failure = text(target.error);
473
+ return { content: failure.content, details: undefined, isError: true };
474
+ }
475
+ const outcome = await deps.resolve(target.engine, target.handle, ctx);
476
+ return { content: outcome.content, details: undefined, isError: outcome.isError };
477
+ }
478
+ };
479
+ }
480
+ async function executeEngineTool(ctx, engine, handle) {
481
+ const callable = Array.isArray(ctx.tools) ? ctx.tools : [];
482
+ const outcome = await ctx.executeTool(resolveRetrievalTool(engine, callable), { recovery_handle: handle });
483
+ return { content: outcome.result.content, isError: outcome.isError };
484
+ }
485
+
486
+ // src/headroom-http.ts
487
+ var RETRIEVE_TIMEOUT_MS = 2000;
488
+ function text2(value) {
489
+ return [{ type: "text", text: value }];
490
+ }
491
+ async function retrieveFromHeadroom(ports, handle, timeoutMs = RETRIEVE_TIMEOUT_MS) {
492
+ if (ports.length === 0) {
493
+ return {
494
+ content: text2(`No Headroom instance is running this session, so ${handle} cannot be recovered.`),
495
+ isError: true
496
+ };
497
+ }
498
+ let lastError = "no instance answered";
499
+ for (const port of ports) {
500
+ let response;
501
+ try {
502
+ response = await fetch(`http://127.0.0.1:${port}/v1/retrieve`, {
503
+ method: "POST",
504
+ headers: { "content-type": "application/json" },
505
+ body: JSON.stringify({ hash: handle }),
506
+ signal: AbortSignal.timeout(timeoutMs)
507
+ });
508
+ } catch (error) {
509
+ lastError = `Headroom on port ${port} did not answer: ${error.message}`;
510
+ continue;
511
+ }
512
+ const body = await response.json().catch(() => {
513
+ return;
514
+ });
515
+ if (response.ok && typeof body?.original_content === "string") {
516
+ return { content: text2(body.original_content), isError: false };
517
+ }
518
+ const detail = typeof body?.detail === "string" ? body.detail : `HTTP ${response.status}`;
519
+ return { content: text2(`Headroom could not recover ${handle}: ${detail}`), isError: true };
520
+ }
521
+ return { content: text2(`No Headroom instance answered for ${handle} (${lastError}).`), isError: true };
522
+ }
523
+
524
+ // src/session.ts
525
+ import { writeFileSync as writeFileSync2 } from "node:fs";
526
+ import { join as join2 } from "node:path";
527
+
528
+ // src/state.ts
529
+ async function groupChatModels(ctx) {
530
+ const grouped = new Map;
531
+ const models = await ctx.modelRegistry.getAvailableOfType("chat").catch(() => ctx.modelRegistry.getModelsOfType("chat"));
532
+ for (const model of models) {
533
+ const list = grouped.get(model.provider) ?? [];
534
+ list.push({
535
+ id: model.id,
536
+ name: model.name,
537
+ api: model.api,
538
+ baseUrl: model.baseUrl,
539
+ reasoning: model.reasoning,
540
+ input: model.input,
541
+ cost: model.cost,
542
+ contextWindow: model.contextWindow,
543
+ maxTokens: model.maxTokens
544
+ });
545
+ grouped.set(model.provider, list);
546
+ }
547
+ return [...grouped.entries()].map(([provider, models]) => ({ provider, models }));
548
+ }
549
+
550
+ // src/session.ts
551
+ var STATE_ORDER = ["caveman", "headroom"];
552
+ function collectExtras(ctx) {
553
+ const extras = new Map;
554
+ for (const type of ["image", "classifier"]) {
555
+ for (const model of ctx.modelRegistry.getModelsOfType(type)) {
556
+ const list = extras.get(model.provider) ?? [];
557
+ list.push(model);
558
+ extras.set(model.provider, list);
559
+ }
560
+ }
561
+ return extras;
562
+ }
563
+ async function openSession(api, ctx, deps) {
564
+ const groups = await groupChatModels(ctx);
565
+ const extras = collectExtras(ctx);
566
+ const directModels = new Map;
567
+ for (const model of ctx.modelRegistry.getModelsOfType("chat")) {
568
+ if (!directModels.has(model.provider))
569
+ directModels.set(model.provider, model);
570
+ }
571
+ const discovered = await discoverEngines(groups, deps);
572
+ await startNeeded(groups, ctx.model?.provider, discovered, deps);
573
+ const derived = deriveAssignments(groups, discovered.engines, deps.overrides, { familyOf, hostOf });
574
+ for (const notice of derived.notices)
575
+ deps.notify("warning", notice);
576
+ reportUncompressedResponses(groups, derived.plans, deps);
577
+ writeAssignmentReport(deps, groups, derived.plans, extras);
578
+ const ports = new Map;
579
+ for (const [provider, state] of discovered.headroom)
580
+ ports.set(provider, state.port);
581
+ registerAll(api, planRegistrations(derived.plans.filter((plan) => plan.engine === "headroom" && ports.has(plan.provider)), groups, ports, extras), (message) => deps.notify("warning", message));
582
+ reportDegradation(deps, discovered.engines, discovered.failures);
583
+ return {
584
+ engines: discovered.engines,
585
+ ports,
586
+ directModels,
587
+ counters: new Map(discovered.engines.map((engine) => [engine.engine, { requests: 0, failures: 0 }])),
588
+ tripped: new Set,
589
+ failures: discovered.failures,
590
+ plans: [...derived.plans],
591
+ groups,
592
+ extras
593
+ };
594
+ }
595
+ function writeAssignmentReport(deps, groups, plans, extras) {
596
+ const chat = groups.map((group) => {
597
+ const plan = plans.find((entry) => entry.provider === group.provider);
598
+ return {
599
+ provider: group.provider,
600
+ engine: plan?.engine ?? null,
601
+ families: plan?.families ?? [],
602
+ direct: plan?.direct ?? [...new Set(group.models.map((model) => model.api))]
603
+ };
604
+ });
605
+ const named = new Set(chat.map((entry) => entry.provider));
606
+ const chatless = [...extras.keys()].filter((provider) => !named.has(provider));
607
+ if (chatless.length > 0) {
608
+ deps.notify("info", `Non-chat providers (${chatless.join(", ")}) are never routed through a compression engine.`);
609
+ }
610
+ const report = {
611
+ providers: [
612
+ ...chat,
613
+ ...chatless.map((provider) => ({ provider, engine: null, families: [], direct: [] }))
614
+ ]
615
+ };
616
+ try {
617
+ writeFileSync2(join2(deps.lifecycle.stateDir, "assignment.json"), JSON.stringify(report, null, 2), "utf8");
618
+ } catch {
619
+ deps.notify("warning", "Could not write the assignment report; the session continues.");
620
+ }
621
+ }
622
+ function reportUncompressedResponses(groups, plans, deps) {
623
+ const responses = groups.filter((group) => plans.some((plan) => plan.provider === group.provider && plan.engine === "headroom")).flatMap((group) => group.models.filter((model) => /responses/i.test(model.api)).map((model) => `${group.provider}/${model.id}`));
624
+ if (responses.length === 0)
625
+ return;
626
+ deps.notify("info", `OpenAI Responses models (${responses.join(", ")}) are not compressed by default: set HEADROOM_COMPRESS_PASSTHROUGH=1 for the Headroom process to opt in.`);
627
+ }
628
+ function reportDegradation(deps, engines, failures) {
629
+ for (const engine of STATE_ORDER) {
630
+ if (engines.some((candidate) => candidate.engine === engine))
631
+ continue;
632
+ const reason = failures.get(engine);
633
+ if (!reason)
634
+ continue;
635
+ deps.notify("warning", `${engine} is unavailable (${reason}). The session continues without it.`);
636
+ }
637
+ }
638
+ function closeSession(state, deps) {
639
+ for (const engine of state.engines)
640
+ stopOwned(engine, deps.lifecycle);
641
+ }
642
+
643
+ // src/setup.ts
644
+ import { spawn as spawnProcess } from "node:child_process";
645
+ import { existsSync, readFileSync as readFileSync4, statSync } from "node:fs";
646
+ import { homedir } from "node:os";
647
+ import { dirname, extname, isAbsolute, join as join5, resolve } from "node:path";
648
+
649
+ // src/config.ts
650
+ import { readFileSync as readFileSync2 } from "node:fs";
651
+ import { join as join3 } from "node:path";
652
+
653
+ // src/types.ts
654
+ var DEFAULT_CONFIG = {
655
+ start: { caveman: true, headroom: true },
656
+ assignment: [],
657
+ timeoutMs: 30000
658
+ };
659
+
660
+ // src/config.ts
661
+ function isRecord(value) {
662
+ return Boolean(value) && typeof value === "object" && !Array.isArray(value);
663
+ }
664
+ function decode(raw, notices) {
665
+ if (!isRecord(raw)) {
666
+ if (raw !== undefined)
667
+ notices.push("Coordinator configuration is not an object: defaults apply.");
668
+ return DEFAULT_CONFIG;
669
+ }
670
+ const start = isRecord(raw.start) ? raw.start : {};
671
+ const assignment = [];
672
+ if (Array.isArray(raw.assignment)) {
673
+ for (const entry of raw.assignment) {
674
+ if (isRecord(entry) && typeof entry.provider === "string" && typeof entry.engine === "string") {
675
+ assignment.push({ provider: entry.provider, engine: entry.engine });
676
+ } else {
677
+ notices.push("Skipped a malformed assignment entry: an entry needs a provider and an engine.");
678
+ }
679
+ }
680
+ }
681
+ const timeoutMs = typeof raw.timeoutMs === "number" && raw.timeoutMs > 0 ? raw.timeoutMs : DEFAULT_CONFIG.timeoutMs;
682
+ return {
683
+ start: {
684
+ caveman: typeof start.caveman === "boolean" ? start.caveman : DEFAULT_CONFIG.start.caveman,
685
+ headroom: typeof start.headroom === "boolean" ? start.headroom : DEFAULT_CONFIG.start.headroom
686
+ },
687
+ assignment,
688
+ timeoutMs
689
+ };
690
+ }
691
+ function loadConfig(stateDir, notices = []) {
692
+ const path = join3(stateDir, "config.json");
693
+ let raw;
694
+ try {
695
+ raw = JSON.parse(readFileSync2(path, "utf8"));
696
+ } catch {
697
+ return { config: DEFAULT_CONFIG, notices };
698
+ }
699
+ return { config: decode(raw, notices), notices };
700
+ }
701
+
702
+ // src/probe.ts
703
+ import { readFileSync as readFileSync3 } from "node:fs";
704
+ import { join as join4 } from "node:path";
705
+ var HEADROOM_SERVICE = "headroom-proxy";
706
+ var CAVEMAN_INSTANCE_HEADER = "x-caveman-instance";
707
+ var FAMILY_CONFIG_KEYS = [
708
+ ["anthropic_api_url", "anthropic"],
709
+ ["openai_api_url", "openai"],
710
+ ["gemini_api_url", "gemini"]
711
+ ];
712
+ function readJson(path) {
713
+ try {
714
+ const parsed = JSON.parse(readFileSync3(path, "utf8"));
715
+ return parsed && typeof parsed === "object" ? parsed : undefined;
716
+ } catch {
717
+ return;
718
+ }
719
+ }
720
+ async function getJson(url, timeoutMs) {
721
+ const response = await fetch(url, { signal: AbortSignal.timeout(timeoutMs) });
722
+ if (!response.ok)
723
+ throw new Error(`${url} answered ${response.status}`);
724
+ return await response.json();
725
+ }
726
+ function upstreamsFromTable(table, compat) {
727
+ if (!table || typeof table !== "object")
728
+ return [];
729
+ const out = [];
730
+ for (const [key, value] of Object.entries(table)) {
731
+ if (typeof value !== "string")
732
+ continue;
733
+ const family = cavemanFamilyOf(key, compat);
734
+ const host = hostOf(value);
735
+ if (family && host)
736
+ out.push({ family, host });
737
+ }
738
+ return out;
739
+ }
740
+ function cavemanStatePath(home, port) {
741
+ return join4(home, "run", `${port}.json`);
742
+ }
743
+ async function probeCaveman(options) {
744
+ const statePath = cavemanStatePath(options.home, options.port);
745
+ const recorded = readJson(statePath);
746
+ if (!recorded)
747
+ return { ok: false, reason: `no Caveman run state at ${statePath}` };
748
+ if (recorded.recovery_via_mcp !== true)
749
+ return { ok: false, reason: "Caveman run state reports recovery_via_mcp false" };
750
+ let headers;
751
+ try {
752
+ const response = await fetch(`http://127.0.0.1:${options.port}/health/live`, {
753
+ signal: AbortSignal.timeout(options.timeoutMs)
754
+ });
755
+ if (!response.ok)
756
+ return { ok: false, reason: `Caveman health answered ${response.status}` };
757
+ headers = response.headers;
758
+ } catch (error) {
759
+ return { ok: false, reason: `Caveman health unreachable: ${error.message}` };
760
+ }
761
+ const token = headers.get(CAVEMAN_INSTANCE_HEADER);
762
+ if (!token || token !== recorded.instance_token) {
763
+ return {
764
+ ok: false,
765
+ occupied: true,
766
+ reason: `port ${options.port} answers, but its instance token does not match the Caveman run state`
767
+ };
768
+ }
769
+ const upstreams = [
770
+ ...upstreamsFromTable(recorded.provider_upstreams, false),
771
+ ...upstreamsFromTable(recorded.compat_upstreams, true)
772
+ ];
773
+ return { ok: true, state: { engine: "caveman", port: options.port, upstreams, owned: options.owned } };
774
+ }
775
+ async function probeHeadroom(options) {
776
+ const base = `http://127.0.0.1:${options.port}`;
777
+ try {
778
+ const live = await getJson(`${base}/livez`, options.timeoutMs);
779
+ if (live.service !== HEADROOM_SERVICE) {
780
+ return {
781
+ ok: false,
782
+ occupied: true,
783
+ reason: `port ${options.port} answers but is not a Headroom proxy`
784
+ };
785
+ }
786
+ const health = await getJson(`${base}/health`, options.timeoutMs);
787
+ if (health.service !== HEADROOM_SERVICE) {
788
+ return { ok: false, reason: `port ${options.port} is not a Headroom proxy` };
789
+ }
790
+ const config = health.config ?? {};
791
+ const upstreams = [];
792
+ for (const [key, family] of FAMILY_CONFIG_KEYS) {
793
+ const host = hostOf(typeof config[key] === "string" ? config[key] : undefined);
794
+ if (host)
795
+ upstreams.push({ family, host });
796
+ }
797
+ if (upstreams.length === 0) {
798
+ return { ok: false, occupied: true, reason: `Headroom on port ${options.port} names no upstream` };
799
+ }
800
+ const served = (upstream) => `${upstream.family}@${upstream.host}`;
801
+ const missing = (options.expect ?? []).filter((expected) => !upstreams.some((upstream) => upstream.family === expected.family && upstream.host === expected.host));
802
+ if (missing.length > 0) {
803
+ return {
804
+ ok: false,
805
+ occupied: true,
806
+ reason: `Headroom on port ${options.port} serves ${upstreams.map(served).join(", ")}; expected ${missing.map(served).join(", ")}`
807
+ };
808
+ }
809
+ return { ok: true, state: { engine: "headroom", port: options.port, upstreams, owned: options.owned } };
810
+ } catch (error) {
811
+ return { ok: false, reason: `Headroom unreachable: ${error.message}` };
812
+ }
813
+ }
814
+
815
+ // src/setup.ts
816
+ var HEADROOM_MCP = "headroom";
817
+ function canHideDeclarations(pi) {
818
+ try {
819
+ return pi.getAllTools().some((tool) => typeof tool.exposure === "string");
820
+ } catch {
821
+ return false;
822
+ }
823
+ }
824
+ function resolvePaths(options) {
825
+ return {
826
+ stateDir: options.stateDir ?? process.env.DUAL_ENGINE_HOME ?? join5(homedir(), ".pi", "agent", "dual-engine"),
827
+ cavemanHome: options.cavemanHome ?? process.env.CAVEMAN_HOME ?? join5(homedir(), ".caveman"),
828
+ agentDir: options.agentDir ?? process.env.PI_CODING_AGENT_DIR ?? join5(homedir(), ".pi", "agent")
829
+ };
830
+ }
831
+ var WINDOWS_SHIM_MAX_BYTES = 256 * 1024;
832
+ var WINDOWS_SHIM_MAX_DEPTH = 4;
833
+ function parseWindowsNestedShim(source) {
834
+ const match = source.match(/"([^"\r\n]+\.(?:cmd|bat))"[ \t]+%\*/i);
835
+ return match?.[1] ?? null;
836
+ }
837
+ function parseWindowsNodeShim(source) {
838
+ const match = source.match(/["']?%_prog%["']?[ \t]+["']?%dp0%[\\/]([^"'\r\n]+)["']?[ \t]+%\*/i);
839
+ return match?.[1] ?? null;
840
+ }
841
+ function parseWindowsExeShim(source) {
842
+ const match = source.match(/["']?%dp0%[\\/]([^"'\r\n]+\.exe)["']?[ \t]+%\*/i);
843
+ return match?.[1] ?? null;
844
+ }
845
+ function resolveWindowsNodeShim(executable, depth = 0, seen = new Set) {
846
+ if (depth > WINDOWS_SHIM_MAX_DEPTH)
847
+ throw new Error("Windows command shim nesting too deep");
848
+ const normalized = resolve(executable);
849
+ const key = normalized.toLowerCase();
850
+ if (seen.has(key))
851
+ throw new Error("Windows command shim cycle");
852
+ seen.add(key);
853
+ const stat = statSync(normalized);
854
+ if (!stat.isFile() || stat.size > WINDOWS_SHIM_MAX_BYTES) {
855
+ throw new Error(`cannot safely launch Windows command shim: ${normalized}`);
856
+ }
857
+ const source = readFileSync4(normalized, "utf8");
858
+ const forwardsToBatch = /"[^"\r\n]+\.(?:cmd|bat)"[ \t]+%\*/i.test(source);
859
+ const jsTarget = forwardsToBatch ? null : parseWindowsNodeShim(source);
860
+ const nested = parseWindowsNestedShim(source);
861
+ const exeTarget = forwardsToBatch || jsTarget ? null : parseWindowsExeShim(source);
862
+ const child = jsTarget ?? nested ?? exeTarget;
863
+ if (!child)
864
+ throw new Error(`cannot safely launch non-Node Windows command shim: ${normalized}`);
865
+ const target = /^[A-Za-z]:[\\/]/.test(child) || isAbsolute(child) ? child : resolve(dirname(normalized), ...child.split(/[\\/]+/));
866
+ if (!existsSync(target) || !statSync(target).isFile()) {
867
+ throw new Error(`Windows command shim target is missing: ${target}`);
868
+ }
869
+ if (jsTarget || !nested && exeTarget)
870
+ return target;
871
+ return resolveWindowsNodeShim(target, depth + 1, seen);
872
+ }
873
+ function resolveWindowsCommand(command, env = process.env) {
874
+ const pathExt = env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD";
875
+ const names = extname(command) ? [command] : pathExt.split(";").map((ext) => command + (ext.startsWith(".") ? ext : `.${ext}`));
876
+ if (isAbsolute(command) || /[\\/]/.test(command)) {
877
+ for (const name of names)
878
+ if (existsSync(name))
879
+ return name;
880
+ return existsSync(command) ? command : undefined;
881
+ }
882
+ for (const directory of (env.PATH ?? "").split(";")) {
883
+ if (!directory)
884
+ continue;
885
+ for (const name of names) {
886
+ const candidate = join5(directory, name);
887
+ if (existsSync(candidate))
888
+ return candidate;
889
+ }
890
+ }
891
+ return;
892
+ }
893
+ function portableInvocation(command, args, platform = process.platform, env = process.env) {
894
+ if (platform !== "win32")
895
+ return { command, args: [...args] };
896
+ const executable = resolveWindowsCommand(command, env) ?? command;
897
+ if (!/\.(?:cmd|bat)$/i.test(executable))
898
+ return { command: executable, args: [...args] };
899
+ try {
900
+ const target = resolveWindowsNodeShim(executable);
901
+ return /\.exe$/i.test(target) ? { command: target, args: [...args] } : { command: process.execPath, args: [target, ...args] };
902
+ } catch {
903
+ return { command: executable, args: [...args] };
904
+ }
905
+ }
906
+ function spawnDaemon(command, args) {
907
+ try {
908
+ const inv = portableInvocation(command, args);
909
+ const child = spawnProcess(inv.command, inv.args, {
910
+ stdio: "ignore",
911
+ detached: true,
912
+ shell: false,
913
+ windowsHide: true
914
+ });
915
+ child.on("error", () => {});
916
+ child.unref();
917
+ return { pid: child.pid };
918
+ } catch {
919
+ return { pid: undefined };
920
+ }
921
+ }
922
+ function buildDeps(options) {
923
+ const { stateDir, cavemanHome } = resolvePaths(options);
924
+ const { config } = loadConfig(stateDir);
925
+ const pending = [];
926
+ const seen = new Set;
927
+ const notify = (type, message) => {
928
+ if (seen.has(message))
929
+ return;
930
+ seen.add(message);
931
+ pending.push({ type, message });
932
+ };
933
+ const base = {
934
+ start: config.start,
935
+ overrides: config.assignment,
936
+ notify,
937
+ lifecycle: {
938
+ stateDir,
939
+ cavemanHome,
940
+ timeoutMs: config.timeoutMs,
941
+ spawn: (command, args) => {
942
+ return spawnDaemon(command, args);
943
+ },
944
+ cavemanStop: () => {
945
+ spawnDaemon("caveman", ["stop"]);
946
+ },
947
+ kill: (pid) => {
948
+ try {
949
+ process.kill(-pid);
950
+ } catch {
951
+ try {
952
+ process.kill(pid);
953
+ } catch {}
954
+ }
955
+ },
956
+ now: () => Date.now(),
957
+ sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
958
+ probeCaveman,
959
+ probeHeadroom
960
+ }
961
+ };
962
+ return {
963
+ deps: { ...base, ...options.deps, notify: options.deps?.notify ?? notify },
964
+ flush: (ctx) => {
965
+ for (const entry of pending.splice(0))
966
+ ctx.ui.notify(entry.message, entry.type);
967
+ }
968
+ };
969
+ }
970
+ function userDeclaresHeadroom(agentDir) {
971
+ const mcpPath = join5(agentDir, "mcp.json");
972
+ try {
973
+ const raw = JSON.parse(readFileSync4(mcpPath, "utf8"));
974
+ return raw.mcpServers?.[HEADROOM_MCP] ? mcpPath : undefined;
975
+ } catch {
976
+ return;
977
+ }
978
+ }
979
+ function registerHeadroomMcp(pi, ctx, port, agentDir) {
980
+ const declared = userDeclaresHeadroom(agentDir);
981
+ if (declared) {
982
+ ctx.ui.notify(`${declared} declares "${HEADROOM_MCP}"; the user declaration takes precedence.`, "info");
983
+ }
984
+ pi.registerMcpServer(HEADROOM_MCP, {
985
+ command: "headroom",
986
+ args: ["mcp", "serve", "--proxy-url", `http://127.0.0.1:${port}`],
987
+ exposure: "codemode",
988
+ toolExposure: { headroom_retrieve: "codemode" }
989
+ });
990
+ }
991
+
992
+ // src/status.ts
993
+ function buildStatus(input) {
994
+ const sections = input.engines.map((engine) => {
995
+ const counters = input.counters.get(engine.engine) ?? { requests: 0, failures: 0 };
996
+ return {
997
+ engine: engine.engine,
998
+ port: engine.port,
999
+ mode: engine.owned ? "started" : "adopted",
1000
+ upstreams: engine.upstreams.map((upstream) => `${upstream.family}@${upstream.host}`),
1001
+ providers: input.assignments.filter((entry) => entry.engine === engine.engine).map((entry) => entry.provider),
1002
+ requests: counters.requests,
1003
+ failures: counters.failures
1004
+ };
1005
+ });
1006
+ return { sections };
1007
+ }
1008
+ function formatStatus(report) {
1009
+ if (report.sections.length === 0)
1010
+ return "dual-engine: no engine is active; every provider runs direct.";
1011
+ return report.sections.map((section) => {
1012
+ const providers = section.providers.length > 0 ? section.providers.join(", ") : "none";
1013
+ const upstreams = section.upstreams.length > 0 ? section.upstreams.join(", ") : "none";
1014
+ return [
1015
+ `${section.engine} (${section.mode}, port ${section.port})`,
1016
+ ` providers: ${providers}`,
1017
+ ` upstreams: ${upstreams}`,
1018
+ ` requests: ${section.requests} failures: ${section.failures}`
1019
+ ].join(`
1020
+ `);
1021
+ }).join(`
1022
+ `);
1023
+ }
1024
+
1025
+ // src/index.ts
1026
+ var NO_HIDE_NOTICE = "This pi version cannot hide tool declarations, so the single retrieval tool was not registered. Caveman and Headroom keep their own retrieval tools.";
1027
+ function createDualEngine(options = {}) {
1028
+ return function dualEngine(pi) {
1029
+ const { deps, flush } = buildDeps(options);
1030
+ const { agentDir } = resolvePaths(options);
1031
+ let session;
1032
+ let registered = false;
1033
+ const headroomPorts = () => session ? [...new Set(session.ports.values())] : [];
1034
+ pi.registerCommand("dual-engine", {
1035
+ description: "Report each compression engine separately: owner, port, providers, requests.",
1036
+ handler: async (_args, ctx) => {
1037
+ const report = session ? buildStatus({ engines: session.engines, assignments: session.plans, counters: session.counters }) : undefined;
1038
+ ctx.ui.notify(report ? formatStatus(report) : "dual-engine: no session state yet.", "info");
1039
+ }
1040
+ });
1041
+ pi.on("session_start", async (_event, ctx) => {
1042
+ flush(ctx);
1043
+ const capable = canHideDeclarations(pi);
1044
+ if (!capable) {
1045
+ ctx.ui.notify(NO_HIDE_NOTICE, "error");
1046
+ } else if (!registered) {
1047
+ registered = true;
1048
+ pi.registerTool(createRetrieveTool({
1049
+ resolve: (engine, handle, toolCtx) => engine === "headroom" ? retrieveFromHeadroom(headroomPorts(), handle) : executeEngineTool(toolCtx, engine, handle)
1050
+ }));
1051
+ }
1052
+ session = await openSession(pi, ctx, deps);
1053
+ const port = [...session.ports.values()][0];
1054
+ if (port !== undefined)
1055
+ registerHeadroomMcp(pi, ctx, port, agentDir);
1056
+ });
1057
+ pi.on("model_select", async (event) => {
1058
+ if (session)
1059
+ await ensureProvider(pi, session, event.model.provider, deps);
1060
+ });
1061
+ pi.on("after_provider_response", async (event, ctx) => {
1062
+ if (!session)
1063
+ return;
1064
+ const plan = session.plans.find((entry) => entry.provider === ctx.model?.provider);
1065
+ if (plan) {
1066
+ const counters = session.counters.get(plan.engine) ?? { requests: 0, failures: 0 };
1067
+ counters.requests += 1;
1068
+ if (event.status >= 400)
1069
+ counters.failures += 1;
1070
+ session.counters.set(plan.engine, counters);
1071
+ }
1072
+ await onProviderResponse({
1073
+ tripped: session.tripped,
1074
+ directModels: session.directModels,
1075
+ notify: (message) => ctx.ui.notify(message, "warning")
1076
+ }, { event, model: ctx.model, setModel: (model) => pi.setModel(model) });
1077
+ });
1078
+ pi.on("session_shutdown", async () => {
1079
+ if (session)
1080
+ closeSession(session, deps);
1081
+ session = undefined;
1082
+ });
1083
+ };
1084
+ }
1085
+ var src_default = createDualEngine();
1086
+ export {
1087
+ createDualEngine,
1088
+ src_default as default
1089
+ };