@juanbenjumea/pi-agy 0.7.9 → 0.7.11

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.
@@ -34,6 +34,7 @@ import {
34
34
  } from "@modelcontextprotocol/sdk/types.js";
35
35
 
36
36
  import { getDefaultConfigPath } from "./config.js";
37
+ import { isBridgeInputWithinBudget } from "./bridge-input-budget.js";
37
38
  import { checkAgyUsage, formatAgyUsage } from "./cli.js";
38
39
  import {
39
40
  FALLBACK_PROVIDER_MODELS,
@@ -173,8 +174,10 @@ export interface McpBridgeHandle {
173
174
  completePark: (callId: string, result: BridgeToolResult) => boolean;
174
175
  /** Fail every parked call (teardown, cancelled turns). */
175
176
  failAllParks: (message: string) => void;
177
+ /** Release call IDs whose owning provider operation can no longer poll them. */
178
+ discardParks: (callIds: Iterable<string>) => void;
176
179
  /** Point-in-time description for status surfaces. */
177
- describe: () => { configDir: string; url: string; toolCount: number };
180
+ describe: () => { configDir: string; url: string; toolCount: number; pendingResults: number };
178
181
  }
179
182
 
180
183
  /** A Pi tool projected for agy: MCP-safe advertised name, real Pi identity. */
@@ -217,6 +220,8 @@ interface CatalogCache {
217
220
 
218
221
  export interface StartMcpBridgeOptions {
219
222
  escalateAfterMs?: number;
223
+ sessionCap?: number;
224
+ sessionIdleMs?: number;
220
225
  }
221
226
 
222
227
  /**
@@ -230,12 +235,6 @@ export async function startMcpBridge(
230
235
  const token = randomBytes(32).toString("hex");
231
236
  const escalateAfterMs = options?.escalateAfterMs ?? DEFAULT_PARK_ESCALATE_MS;
232
237
  let catalogCache: CatalogCache | undefined;
233
-
234
- const mcp = new McpServer(
235
- { name: "pi-agy-bridge", version: "1" },
236
- { capabilities: { tools: {} } },
237
- );
238
-
239
238
  let bridgedTools: BridgeToolDef[] = [];
240
239
  let parkHandler: BridgeParkHandler | undefined;
241
240
  const parks = new Map<string, (result: BridgeToolResult) => void>();
@@ -244,7 +243,25 @@ export async function startMcpBridge(
244
243
  { name: string; state: "running" | "done" | "failed"; result?: BridgeToolResult; reason?: string }
245
244
  >();
246
245
 
247
- mcp.setRequestHandler(ListToolsRequestSchema, () => {
246
+ interface BridgeSession {
247
+ transport: StreamableHTTPServerTransport;
248
+ mcp: McpServer;
249
+ last: number;
250
+ active: number;
251
+ parks: number;
252
+ closing: boolean;
253
+ }
254
+ const sessions = new Map<string, BridgeSession>();
255
+ const pendingSessions = new Set<BridgeSession>();
256
+ const parkOwners = new Map<string, BridgeSession>();
257
+
258
+ const createMcpServer = (session: BridgeSession): McpServer => {
259
+ const mcp = new McpServer(
260
+ { name: "pi-agy-bridge", version: "1" },
261
+ { capabilities: { tools: {} } },
262
+ );
263
+
264
+ mcp.setRequestHandler(ListToolsRequestSchema, () => {
248
265
  const skills = scanSkills(dir);
249
266
  return {
250
267
  tools: [
@@ -410,8 +427,10 @@ export async function startMcpBridge(
410
427
  }
411
428
  let escalateTimer: NodeJS.Timeout | undefined;
412
429
  let didEscalate = false;
430
+ let settled = false;
413
431
  const parked = await new Promise<BridgeToolResult | undefined>((resolve) => {
414
432
  parks.set(callId, (res) => {
433
+ settled = true;
415
434
  if (escalateTimer) clearTimeout(escalateTimer);
416
435
  if (didEscalate) {
417
436
  const record = escalations.get(callId);
@@ -423,6 +442,8 @@ export async function startMcpBridge(
423
442
  resolve(res);
424
443
  }
425
444
  });
445
+ session.parks += 1;
446
+ parkOwners.set(callId, session);
426
447
  let accepted = false;
427
448
  try {
428
449
  accepted = handler({ callId, toolName: bridged.piName, args: callArgs });
@@ -431,9 +452,14 @@ export async function startMcpBridge(
431
452
  }
432
453
  if (!accepted) {
433
454
  parks.delete(callId);
455
+ if (parkOwners.get(callId) === session) {
456
+ parkOwners.delete(callId);
457
+ session.parks = Math.max(0, session.parks - 1);
458
+ }
434
459
  resolve(undefined);
435
460
  return;
436
461
  }
462
+ if (settled) return;
437
463
  // Early-ack escalation: if the tool runs longer than escalateAfterMs,
438
464
  // settle the MCP request with STILL RUNNING so agy avoids its 180s timeout.
439
465
  escalateTimer = setTimeout(() => {
@@ -467,18 +493,100 @@ export async function startMcpBridge(
467
493
  }
468
494
  });
469
495
 
470
- // Stateful: one transport serves many agy sessions, routed by the
471
- // session id header. The default (no generator) is stateless and rejects
472
- // any second request on the same transport.
473
- const transport = new StreamableHTTPServerTransport({
474
- sessionIdGenerator: () => randomUUID(),
475
- });
496
+ return mcp;
497
+ };
498
+
499
+ let stopping = false;
500
+ const sessionCap = Number.isFinite(options?.sessionCap) && (options?.sessionCap ?? 16) > 0 ? Math.floor(options?.sessionCap ?? 16) : 16;
501
+ const sessionIdleMs = Number.isFinite(options?.sessionIdleMs) && (options?.sessionIdleMs ?? 300_000) > 0 ? options?.sessionIdleMs ?? 300_000 : 300_000;
502
+ const closeSession = async (id: string, session: BridgeSession) => {
503
+ if (sessions.get(id) !== session) return;
504
+ sessions.delete(id);
505
+ session.closing = true;
506
+ for (const [callId, owner] of parkOwners) {
507
+ if (owner !== session) continue;
508
+ parkOwners.delete(callId);
509
+ session.parks = Math.max(0, session.parks - 1);
510
+ const resolve = parks.get(callId);
511
+ parks.delete(callId);
512
+ resolve?.({ text: "MCP session closed.", isError: true });
513
+ const escalation = escalations.get(callId);
514
+ if (escalation?.state === "running") {
515
+ escalation.state = "failed";
516
+ escalation.reason = "MCP session closed.";
517
+ }
518
+ }
519
+ await session.transport.close().catch(() => undefined);
520
+ await session.mcp.close().catch(() => undefined);
521
+ };
522
+ const sweep = setInterval(() => {
523
+ const now = Date.now();
524
+ for (const [id, session] of sessions) {
525
+ if (session.active === 0 && session.parks === 0 && now - session.last >= sessionIdleMs) void closeSession(id, session);
526
+ }
527
+ }, Math.max(50, Math.min(sessionIdleMs, 60_000)));
528
+ sweep.unref();
529
+
476
530
  const configDir = allocateBridgeConfigDir();
477
531
  // Filled after bind; the request handler validates Host against it
478
532
  // (defense-in-depth against DNS rebinding past the loopback bind).
479
533
  const bound = { port: 0 };
480
534
  const http = createServer((req, res) => {
481
- void handleBridgeRequest(req, res, transport, token, bound.port).catch(() => {
535
+ void handleBridgeRequest(req, res, token, bound.port, async (request, body) => {
536
+ const requested = request.headers["mcp-session-id"];
537
+ if (typeof requested === "string") {
538
+ const session = sessions.get(requested);
539
+ if (!session) return undefined;
540
+ session.last = Date.now();
541
+ session.active += 1;
542
+ return { transport: session.transport, session };
543
+ }
544
+ if (!body || typeof body !== "object" || (body as { method?: string }).method !== "initialize") return undefined;
545
+ if (stopping || sessions.size + pendingSessions.size >= sessionCap) return undefined;
546
+ let removeSession = (): void => undefined;
547
+ let session!: BridgeSession;
548
+ const transport = new StreamableHTTPServerTransport({
549
+ sessionIdGenerator: () => randomUUID(),
550
+ onsessioninitialized: (id) => {
551
+ pendingSessions.delete(session);
552
+ if (!stopping && !session.closing) sessions.set(id, session);
553
+ },
554
+ onsessionclosed: () => removeSession(),
555
+ });
556
+ session = { transport, mcp: undefined as never, last: Date.now(), active: 1, parks: 0, closing: false };
557
+ session.mcp = createMcpServer(session);
558
+ pendingSessions.add(session);
559
+ removeSession = () => {
560
+ const id = session.transport.sessionId;
561
+ if (id) void closeSession(id, session);
562
+ else {
563
+ pendingSessions.delete(session);
564
+ session.closing = true;
565
+ void session.transport.close().catch(() => undefined);
566
+ void session.mcp.close().catch(() => undefined);
567
+ }
568
+ };
569
+ session.transport.onclose = removeSession;
570
+ try {
571
+ await session.mcp.connect(session.transport);
572
+ return { transport: session.transport, session };
573
+ } catch {
574
+ await session.transport.close().catch(() => undefined);
575
+ await session.mcp.close().catch(() => undefined);
576
+ return undefined;
577
+ }
578
+ }, (session) => {
579
+ const id = session.transport.sessionId;
580
+ if (id && sessions.get(id) === session) return;
581
+ pendingSessions.delete(session);
582
+ if (id && !session.closing && !stopping) {
583
+ sessions.set(id, session);
584
+ } else if (!session.closing) {
585
+ session.closing = true;
586
+ void session.transport.close().catch(() => undefined);
587
+ void session.mcp.close().catch(() => undefined);
588
+ }
589
+ }).catch(() => {
482
590
  // handleBridgeRequest guards every response path; this is unreachable
483
591
  // belt-and-braces so a client error can never crash Pi.
484
592
  if (!res.headersSent) {
@@ -512,9 +620,14 @@ export async function startMcpBridge(
512
620
  }
513
621
  }
514
622
  if (parks.size === 0) return;
515
- const pending = [...parks.values()];
623
+ const pending = [...parks.entries()];
516
624
  parks.clear();
517
- for (const resolve of pending) {
625
+ for (const [callId, resolve] of pending) {
626
+ const owner = parkOwners.get(callId);
627
+ if (owner) {
628
+ parkOwners.delete(callId);
629
+ owner.parks = Math.max(0, owner.parks - 1);
630
+ }
518
631
  try {
519
632
  resolve({ text: message, isError: true });
520
633
  } catch {
@@ -524,6 +637,12 @@ export async function startMcpBridge(
524
637
  };
525
638
 
526
639
  const completePark = (callId: string, result: BridgeToolResult): boolean => {
640
+ const owner = parkOwners.get(callId);
641
+ if (owner) {
642
+ parkOwners.delete(callId);
643
+ owner.parks = Math.max(0, owner.parks - 1);
644
+ owner.last = Date.now();
645
+ }
527
646
  const esc = escalations.get(callId);
528
647
  if (esc && esc.state === "running") {
529
648
  esc.state = "done";
@@ -542,18 +661,32 @@ export async function startMcpBridge(
542
661
  return true;
543
662
  };
544
663
 
664
+ const discardParks = (callIds: Iterable<string>): void => {
665
+ for (const callId of callIds) {
666
+ const resolve = parks.get(callId);
667
+ parks.delete(callId);
668
+ const owner = parkOwners.get(callId);
669
+ if (owner) {
670
+ parkOwners.delete(callId);
671
+ owner.parks = Math.max(0, owner.parks - 1);
672
+ }
673
+ // Settle any outstanding HTTP request, then drop its poll payload too.
674
+ resolve?.({ text: "Pi provider operation completed.", isError: true });
675
+ escalations.delete(callId);
676
+ }
677
+ };
678
+
545
679
  const stop = async (): Promise<void> => {
680
+ stopping = true;
546
681
  failAllParks("Pi tool bridge stopped.");
547
- try {
548
- await transport.close();
549
- } catch {
550
- // Best effort.
551
- }
552
- try {
553
- await mcp.close();
554
- } catch {
555
- // Best effort.
682
+ clearInterval(sweep);
683
+ await Promise.all([...sessions].map(([id, session]) => closeSession(id, session)));
684
+ for (const session of pendingSessions) {
685
+ session.closing = true;
686
+ await session.transport.close().catch(() => undefined);
687
+ await session.mcp.close().catch(() => undefined);
556
688
  }
689
+ pendingSessions.clear();
557
690
  // close() alone waits out keep-alive/SSE sockets; destroy them and
558
691
  // bound the wait so session shutdown can never hang on a lingerer.
559
692
  try {
@@ -584,7 +717,6 @@ export async function startMcpBridge(
584
717
  const address = http.address();
585
718
  const port = typeof address === "object" && address ? address.port : 0;
586
719
  if (!port) throw new Error("bridge bound no port");
587
- await mcp.connect(transport);
588
720
  await writeBridgeConfig(configDir, port, token);
589
721
  bound.port = port;
590
722
  return {
@@ -595,6 +727,7 @@ export async function startMcpBridge(
595
727
  configDir,
596
728
  url: `http://127.0.0.1:${port}${BRIDGE_MCP_PATH}`,
597
729
  toolCount: bridgedTools.length + BUILTIN_TOOL_COUNT,
730
+ pendingResults: escalations.size,
598
731
  }),
599
732
  setTools: (tools: BridgeToolDef[]) => {
600
733
  bridgedTools = tools;
@@ -604,6 +737,7 @@ export async function startMcpBridge(
604
737
  },
605
738
  completePark,
606
739
  failAllParks,
740
+ discardParks,
607
741
  };
608
742
  } catch {
609
743
  try {
@@ -654,9 +788,10 @@ async function readBody(req: IncomingMessage): Promise<{ body?: unknown; tooLarg
654
788
  async function handleBridgeRequest(
655
789
  req: IncomingMessage,
656
790
  res: ServerResponse,
657
- transport: StreamableHTTPServerTransport,
658
791
  token: string,
659
792
  port: number,
793
+ resolveTransport: (req: IncomingMessage, body?: unknown) => Promise<{ transport: StreamableHTTPServerTransport; session: { transport: StreamableHTTPServerTransport; mcp: McpServer; last: number; active: number; parks: number; closing: boolean } } | undefined>,
794
+ registerSession: (session: { transport: StreamableHTTPServerTransport; mcp: McpServer; last: number; active: number; parks: number; closing: boolean }) => void,
660
795
  ): Promise<void> {
661
796
  try {
662
797
  const url = new URL(req.url ?? "/", "http://127.0.0.1");
@@ -702,10 +837,40 @@ async function handleBridgeRequest(
702
837
  res.writeHead(400).end();
703
838
  return;
704
839
  }
705
- await transport.handleRequest(req, res, body);
840
+ // The SDK receives a pre-parsed body, bypassing its own body reader.
841
+ // Bound structure before even resolving/allocating an MCP session.
842
+ if (!isBridgeInputWithinBudget(body)) {
843
+ res.writeHead(413, { "Content-Type": "application/json" }).end(JSON.stringify({
844
+ error: "Request structure exceeds bridge limits",
845
+ }));
846
+ return;
847
+ }
848
+ const resolved = await resolveTransport(req, body);
849
+ if (!resolved) {
850
+ res.writeHead(req.headers["mcp-session-id"] ? 404 : 503).end();
851
+ return;
852
+ }
853
+ try {
854
+ await resolved.transport.handleRequest(req, res, body);
855
+ } finally {
856
+ resolved.session.active -= 1;
857
+ resolved.session.last = Date.now();
858
+ const id = resolved.transport.sessionId;
859
+ registerSession(resolved.session as { transport: StreamableHTTPServerTransport; mcp: McpServer; last: number; active: number; parks: number; closing: boolean });
860
+ }
861
+ return;
862
+ }
863
+ const resolved = await resolveTransport(req);
864
+ if (!resolved) {
865
+ res.writeHead(req.headers["mcp-session-id"] ? 404 : 400).end();
706
866
  return;
707
867
  }
708
- await transport.handleRequest(req, res);
868
+ try {
869
+ await resolved.transport.handleRequest(req, res);
870
+ } finally {
871
+ resolved.session.active -= 1;
872
+ resolved.session.last = Date.now();
873
+ }
709
874
  } catch {
710
875
  if (!res.headersSent) {
711
876
  try {