@jangmanj/pi-mcp-ext 0.0.0-stage → 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/src/index.ts ADDED
@@ -0,0 +1,1546 @@
1
+ /**
2
+ * Pi extension entry for @jangmanj/pi-mcp-ext.
3
+ *
4
+ * Runs alongside builtin:mcp without replacing /mcp or registering built-in MCP tool names.
5
+ * Registers mcp_events, mcp_tasks, message renderers, and session lifecycle handlers.
6
+ */
7
+
8
+ import { StringEnum, type TextContent } from "@earendil-works/pi-ai";
9
+ import type {
10
+ AgentBeforeSettleEvent,
11
+ AgentBeforeSettleEventResult,
12
+ AgentToolResult,
13
+ ExtensionAPI,
14
+ ExtensionContext,
15
+ ExtensionToolContext,
16
+ MessageRenderOptions,
17
+ MessageRenderer,
18
+ RegisteredMcpServer,
19
+ Theme,
20
+ ToolResultEvent,
21
+ ToolResultEventResult,
22
+ } from "@earendil-works/pi-coding-agent";
23
+ import { Type, type Static, type TUnsafe } from "typebox";
24
+
25
+ import { createServerClient } from "./client.ts";
26
+ import { createAuthResolver, loadServerConfigs } from "./config.ts";
27
+ import { createEventsEngine } from "./events.ts";
28
+ import { createTasksEngine } from "./tasks.ts";
29
+ import {
30
+ EXT_TASKS,
31
+ MESSAGE_EVENT,
32
+ MESSAGE_TASK,
33
+ McpTransportError,
34
+ type AuthResolver,
35
+ type ConfigLoadOptions,
36
+ type ConfigWarning,
37
+ type DeliveryPreference,
38
+ type EngineHost,
39
+ type EventDescriptor,
40
+ type EventsEngineApi,
41
+ type JsonObject,
42
+ type PollEventsParams,
43
+ type ProviderTokenLookup,
44
+ type ResolvedServer,
45
+ type ServerClient,
46
+ type ServerState,
47
+ type SubscribeRequest,
48
+ type TasksEngineApi,
49
+ } from "./types.ts";
50
+
51
+ const STATUS_KEY = "mcp-ext";
52
+ const SETTLE_POLL_MS = 250;
53
+
54
+ interface DeclaredSubscriptionItem {
55
+ name: string;
56
+ arguments?: JsonObject;
57
+ delivery?: DeliveryPreference;
58
+ maxAgeMs?: number;
59
+ holdSettle?: boolean;
60
+ }
61
+
62
+ type ConfiguredServerEntry = ResolvedServer & {
63
+ subscribe?: readonly DeclaredSubscriptionItem[];
64
+ };
65
+
66
+ interface SessionRuntime {
67
+ readonly controller: AbortController;
68
+ cwd: string;
69
+ latestCtx: ExtensionContext | undefined;
70
+ readonly host: EngineHost;
71
+ readonly events: EventsEngineApi;
72
+ readonly tasks: TasksEngineApi;
73
+ readonly configuredServers: Map<string, ConfiguredServerEntry>;
74
+ readonly clients: Map<string, ServerClient>;
75
+ readonly probePromises: Map<string, Promise<void>>;
76
+ readonly activationPromises: Map<string, Promise<void>>;
77
+ readonly loggedWarnings: Set<string>;
78
+ readonly wakeListeners: Set<() => void>;
79
+ readonly cleanups: Array<() => void>;
80
+ configLoadChain: Promise<void>;
81
+ wakeCount: number;
82
+ shutdownPromise: Promise<void> | undefined;
83
+ }
84
+
85
+ function stringEnum<const T extends readonly string[]>(
86
+ values: T,
87
+ options?: { description?: string; default?: T[number] },
88
+ ): TUnsafe<T[number]> {
89
+ return Type.Unsafe<T[number]>(StringEnum(values, options));
90
+ }
91
+
92
+ const McpEventsParams = Type.Object(
93
+ {
94
+ action: stringEnum(["servers", "list", "subscribe", "unsubscribe", "subscriptions", "poll"], {
95
+ description: "Events operation to perform.",
96
+ }),
97
+ server: Type.Optional(
98
+ Type.String({
99
+ minLength: 1,
100
+ description: "Target MCP server name (required for list, subscribe, unsubscribe, poll).",
101
+ }),
102
+ ),
103
+ name: Type.Optional(
104
+ Type.String({
105
+ minLength: 1,
106
+ description: "Event type name (required for subscribe, unsubscribe, poll).",
107
+ }),
108
+ ),
109
+ arguments: Type.Optional(
110
+ Type.Record(Type.String(), Type.Unknown(), {
111
+ description: "Subscription filter or event arguments.",
112
+ }),
113
+ ),
114
+ delivery: Type.Optional(
115
+ stringEnum(["auto", "push", "poll"], {
116
+ description: "Delivery mode preference (default: auto).",
117
+ }),
118
+ ),
119
+ cursor: Type.Optional(
120
+ Type.Union([Type.String(), Type.Null()], {
121
+ description: "Starting cursor (null starts from now; omit to use persisted cursor).",
122
+ }),
123
+ ),
124
+ maxAgeMs: Type.Optional(
125
+ Type.Integer({
126
+ minimum: 0,
127
+ description: "Replay age limit in integer milliseconds.",
128
+ }),
129
+ ),
130
+ maxEvents: Type.Optional(
131
+ Type.Integer({
132
+ minimum: 1,
133
+ description: "Maximum events to return in a single poll batch.",
134
+ }),
135
+ ),
136
+ holdSettle: Type.Optional(
137
+ Type.Boolean({
138
+ description:
139
+ "Hold print/json settlement open until an event arrives or unsubscribe is called.",
140
+ }),
141
+ ),
142
+ },
143
+ { additionalProperties: false },
144
+ );
145
+
146
+ type McpEventsInput = Static<typeof McpEventsParams>;
147
+
148
+ const McpTasksParams = Type.Object(
149
+ {
150
+ action: stringEnum(["call", "get", "update", "cancel", "active"], {
151
+ description: "Task operation to perform.",
152
+ }),
153
+ server: Type.Optional(
154
+ Type.String({
155
+ minLength: 1,
156
+ description: "Target MCP server name (required for call, get, update, cancel).",
157
+ }),
158
+ ),
159
+ tool: Type.Optional(
160
+ Type.String({
161
+ minLength: 1,
162
+ description: "MCP tool name on the server (required for call).",
163
+ }),
164
+ ),
165
+ arguments: Type.Optional(
166
+ Type.Record(Type.String(), Type.Unknown(), {
167
+ description: "Tool call arguments for action 'call'.",
168
+ }),
169
+ ),
170
+ taskId: Type.Optional(
171
+ Type.String({
172
+ minLength: 1,
173
+ description: "Task identifier (required for get, update, cancel).",
174
+ }),
175
+ ),
176
+ inputResponses: Type.Optional(
177
+ Type.Record(Type.String(), Type.Unknown(), {
178
+ description: "Responses keyed by inputRequests identifier (required for update).",
179
+ }),
180
+ ),
181
+ },
182
+ { additionalProperties: false },
183
+ );
184
+
185
+ type McpTasksInput = Static<typeof McpTasksParams>;
186
+
187
+ function isPlainObject(value: unknown): value is JsonObject {
188
+ return typeof value === "object" && value !== null && !Array.isArray(value);
189
+ }
190
+
191
+ function errorMessage(error: unknown): string {
192
+ return error instanceof Error ? error.message : String(error);
193
+ }
194
+
195
+ function jsonResult<T>(data: T): AgentToolResult<T> {
196
+ return {
197
+ content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
198
+ details: data,
199
+ };
200
+ }
201
+
202
+ function toSessionServers(
203
+ entries: readonly RegisteredMcpServer[],
204
+ ): Array<{ name: string; config: JsonObject }> {
205
+ return entries.map((entry: RegisteredMcpServer) => ({
206
+ name: entry.name,
207
+ config: { ...(entry.config as unknown as JsonObject) },
208
+ }));
209
+ }
210
+
211
+ function formatFooterStatus(taskCount: number, streamCount: number): string | undefined {
212
+ if (taskCount <= 0 && streamCount <= 0) return undefined;
213
+ const taskLabel = taskCount === 1 ? "task" : "tasks";
214
+ const streamLabel = streamCount === 1 ? "stream" : "streams";
215
+ return `mcp: ${taskCount} ${taskLabel} · ${streamCount} ${streamLabel}`;
216
+ }
217
+
218
+ function updateFooter(session: SessionRuntime | undefined, ctxOverride?: ExtensionContext): void {
219
+ const ctx = ctxOverride ?? session?.latestCtx;
220
+ if (!ctx?.hasUI) return;
221
+ if (!session || session.controller.signal.aborted) {
222
+ ctx.ui.setStatus(STATUS_KEY, undefined);
223
+ return;
224
+ }
225
+ const taskCount = session.tasks.active().length;
226
+ const streamCount = session.events.activeStreams();
227
+ ctx.ui.setStatus(STATUS_KEY, formatFooterStatus(taskCount, streamCount));
228
+ }
229
+
230
+ function formatConfigWarning(warning: ConfigWarning): string {
231
+ const scopePrefix = warning.server
232
+ ? `MCP config (${warning.scope}, server "${warning.server}")`
233
+ : `MCP config (${warning.scope})`;
234
+ return `${scopePrefix}: ${warning.message}`;
235
+ }
236
+
237
+ function disabledServerState(server: ConfiguredServerEntry): ServerState {
238
+ return {
239
+ name: server.name,
240
+ transport: server.transport,
241
+ era: "disabled",
242
+ events: false,
243
+ eventsListChanged: false,
244
+ tasks: false,
245
+ };
246
+ }
247
+
248
+ function configuredNamesList(session: SessionRuntime): string {
249
+ const names = [...session.configuredServers.keys()];
250
+ return names.length > 0 ? names.join(", ") : "none";
251
+ }
252
+
253
+ function raceWithSignals<T>(promise: Promise<T>, signals: readonly (AbortSignal | undefined)[]): Promise<T | undefined> {
254
+ const activeSignals = signals.filter((s): s is AbortSignal => s !== undefined);
255
+ if (activeSignals.some((s) => s.aborted)) {
256
+ return Promise.resolve(undefined);
257
+ }
258
+ if (activeSignals.length === 0) {
259
+ return promise;
260
+ }
261
+ return new Promise<T | undefined>((resolve, reject) => {
262
+ const cleanups: Array<() => void> = [];
263
+ const done = (fn: () => void) => {
264
+ for (const cleanup of cleanups) cleanup();
265
+ fn();
266
+ };
267
+ for (const sig of activeSignals) {
268
+ const onAbort = () => done(() => resolve(undefined));
269
+ sig.addEventListener("abort", onAbort, { once: true });
270
+ cleanups.push(() => sig.removeEventListener("abort", onAbort));
271
+ }
272
+ promise.then(
273
+ (val) => done(() => resolve(val)),
274
+ (err) => done(() => reject(err)),
275
+ );
276
+ });
277
+ }
278
+
279
+ async function ensureModernCapability(
280
+ session: SessionRuntime,
281
+ serverName: string,
282
+ capability: "events" | "tasks",
283
+ signal: AbortSignal | undefined,
284
+ ): Promise<ServerClient> {
285
+ await raceWithSignals(session.configLoadChain, [signal, session.controller.signal]);
286
+ if (signal?.aborted || session.controller.signal.aborted) {
287
+ throw new Error(`Operation aborted while waiting for MCP server "${serverName}".`);
288
+ }
289
+
290
+ const configured = session.configuredServers.get(serverName);
291
+ if (!configured) {
292
+ throw new Error(
293
+ `Unknown MCP server "${serverName}". Configured servers: ${configuredNamesList(session)}.`,
294
+ );
295
+ }
296
+ if (!configured.enabled) {
297
+ throw new Error(`MCP server "${serverName}" is disabled.`);
298
+ }
299
+
300
+ const probe = session.probePromises.get(serverName);
301
+ if (probe) {
302
+ await raceWithSignals(probe, [signal, session.controller.signal]);
303
+ }
304
+ if (signal?.aborted || session.controller.signal.aborted) {
305
+ throw new Error(`Operation aborted while probing MCP server "${serverName}".`);
306
+ }
307
+
308
+ const client = session.clients.get(serverName);
309
+ if (!client) {
310
+ throw new Error(`MCP server "${serverName}" has no active client.`);
311
+ }
312
+
313
+ const state = client.state;
314
+ switch (state.era) {
315
+ case "modern": {
316
+ if (capability === "events" && !state.events) {
317
+ throw new Error(
318
+ `MCP server "${serverName}" does not advertise io.modelcontextprotocol/events.`,
319
+ );
320
+ }
321
+ if (capability === "tasks" && !state.tasks) {
322
+ throw new Error(
323
+ `MCP server "${serverName}" does not advertise io.modelcontextprotocol/tasks.`,
324
+ );
325
+ }
326
+ return client;
327
+ }
328
+ case "needs-auth":
329
+ throw new Error(`MCP server "${serverName}" requires sign-in; run /mcp login ${serverName}`);
330
+ case "modern-dormant":
331
+ throw new Error(
332
+ `MCP server "${serverName}" does not advertise io.modelcontextprotocol/${capability}.`,
333
+ );
334
+ case "unsupported-modern-version": {
335
+ const supported = state.supportedVersions?.length
336
+ ? ` (supported: ${state.supportedVersions.join(", ")})`
337
+ : "";
338
+ throw new Error(
339
+ `MCP server "${serverName}" does not support MCP protocol version 2026-07-28${supported}.`,
340
+ );
341
+ }
342
+ case "legacy":
343
+ throw new Error(
344
+ `MCP server "${serverName}" speaks legacy MCP (pre-2026-07-28); use its standard MCP tools instead of ${capability === "events" ? "mcp_events" : "mcp_tasks"}.`,
345
+ );
346
+ case "disabled":
347
+ throw new Error(`MCP server "${serverName}" is disabled.`);
348
+ case "error":
349
+ throw new Error(
350
+ `MCP server "${serverName}" failed discovery${state.error ? `: ${state.error}` : ""}.`,
351
+ );
352
+ case "unknown":
353
+ case "probing":
354
+ throw new Error(`MCP server "${serverName}" has not finished discovery yet.`);
355
+ }
356
+ }
357
+
358
+ function normalizeServerCallError(serverName: string, err: unknown): Error {
359
+ if (err instanceof McpTransportError && err.kind === "needs-auth") {
360
+ return new Error(`MCP server "${serverName}" requires sign-in; run /mcp login ${serverName}`);
361
+ }
362
+ return err instanceof Error ? err : new Error(String(err));
363
+ }
364
+
365
+ async function activateDeclaredSubscriptions(
366
+ session: SessionRuntime,
367
+ serverName: string,
368
+ declared: readonly DeclaredSubscriptionItem[],
369
+ ): Promise<void> {
370
+ const signal = session.controller.signal;
371
+ if (signal.aborted) return;
372
+
373
+ let descriptors: EventDescriptor[];
374
+ try {
375
+ descriptors = await session.events.list(serverName);
376
+ } catch (err) {
377
+ if (!signal.aborted) {
378
+ session.host.log(
379
+ "warn",
380
+ `MCP server "${serverName}": failed to list events for declarative subscribe: ${errorMessage(err)}`,
381
+ );
382
+ }
383
+ return;
384
+ }
385
+ if (signal.aborted) return;
386
+
387
+ const byName = new Map<string, EventDescriptor>();
388
+ for (const descriptor of descriptors) {
389
+ byName.set(descriptor.name, descriptor);
390
+ }
391
+
392
+ const supportsClientDelivery = (descriptor: EventDescriptor): boolean =>
393
+ descriptor.delivery.includes("push") || descriptor.delivery.includes("poll");
394
+
395
+ for (const item of declared) {
396
+ if (signal.aborted) return;
397
+ const delivery: DeliveryPreference = item.delivery ?? "auto";
398
+ const holdSettle = item.holdSettle ?? false;
399
+
400
+ if (item.name === "*") {
401
+ for (const descriptor of descriptors) {
402
+ if (signal.aborted) return;
403
+ if (!supportsClientDelivery(descriptor)) continue;
404
+ try {
405
+ await session.events.subscribe({
406
+ server: serverName,
407
+ name: descriptor.name,
408
+ ...(item.arguments !== undefined ? { arguments: item.arguments } : {}),
409
+ delivery,
410
+ cursor: undefined,
411
+ ...(item.maxAgeMs !== undefined ? { maxAgeMs: item.maxAgeMs } : {}),
412
+ holdSettle,
413
+ });
414
+ } catch (err) {
415
+ if (!signal.aborted) {
416
+ session.host.log(
417
+ "warn",
418
+ `MCP server "${serverName}": failed to subscribe to "${descriptor.name}": ${errorMessage(err)}`,
419
+ );
420
+ }
421
+ }
422
+ }
423
+ continue;
424
+ }
425
+
426
+ const descriptor = byName.get(item.name);
427
+ if (!descriptor) {
428
+ session.host.log(
429
+ "warn",
430
+ `MCP server "${serverName}": declared event "${item.name}" was not found in events/list; skipping.`,
431
+ );
432
+ continue;
433
+ }
434
+
435
+ if (!supportsClientDelivery(descriptor)) {
436
+ session.host.log(
437
+ "warn",
438
+ `MCP server "${serverName}": declared event "${item.name}" only supports webhook delivery; skipping.`,
439
+ );
440
+ continue;
441
+ }
442
+
443
+ try {
444
+ await session.events.subscribe({
445
+ server: serverName,
446
+ name: item.name,
447
+ ...(item.arguments !== undefined ? { arguments: item.arguments } : {}),
448
+ delivery,
449
+ cursor: undefined,
450
+ ...(item.maxAgeMs !== undefined ? { maxAgeMs: item.maxAgeMs } : {}),
451
+ holdSettle,
452
+ });
453
+ } catch (err) {
454
+ if (!signal.aborted) {
455
+ session.host.log(
456
+ "warn",
457
+ `MCP server "${serverName}": failed to subscribe to "${item.name}": ${errorMessage(err)}`,
458
+ );
459
+ }
460
+ }
461
+ }
462
+ }
463
+
464
+ function startServerProbe(
465
+ session: SessionRuntime,
466
+ server: ConfiguredServerEntry,
467
+ client: ServerClient,
468
+ ): void {
469
+ const signal = session.controller.signal;
470
+ const probePromise = (async (): Promise<void> => {
471
+ try {
472
+ const state = await client.discover();
473
+ if (signal.aborted) return;
474
+ updateFooter(session);
475
+ if (state.era !== "modern") return;
476
+ if (state.events) {
477
+ session.events.serverReady(server.name);
478
+ }
479
+ if (state.tasks) {
480
+ session.tasks.serverReady(server.name);
481
+ }
482
+ updateFooter(session);
483
+ } catch (err) {
484
+ if (!signal.aborted) {
485
+ session.host.log(
486
+ "warn",
487
+ `MCP server "${server.name}" discovery failed: ${errorMessage(err)}`,
488
+ );
489
+ }
490
+ }
491
+ })();
492
+
493
+ session.probePromises.set(server.name, probePromise);
494
+
495
+ if (server.subscribe && server.subscribe.length > 0) {
496
+ const declared = server.subscribe;
497
+ const activationPromise = probePromise
498
+ .then(async () => {
499
+ if (signal.aborted) return;
500
+ const state = client.state;
501
+ if (state.era !== "modern" || !state.events) return;
502
+ await activateDeclaredSubscriptions(session, server.name, declared);
503
+ updateFooter(session);
504
+ })
505
+ .finally(() => {
506
+ if (session.activationPromises.get(server.name) === activationPromise) {
507
+ session.activationPromises.delete(server.name);
508
+ }
509
+ });
510
+ session.activationPromises.set(server.name, activationPromise);
511
+ }
512
+ }
513
+
514
+ function attachConfiguredServers(
515
+ session: SessionRuntime,
516
+ servers: readonly ConfiguredServerEntry[],
517
+ warnings: readonly ConfigWarning[],
518
+ ): void {
519
+ if (session.controller.signal.aborted) return;
520
+
521
+ for (const warning of warnings) {
522
+ const formatted = formatConfigWarning(warning);
523
+ if (!session.loggedWarnings.has(formatted)) {
524
+ session.loggedWarnings.add(formatted);
525
+ session.host.log("warn", formatted);
526
+ }
527
+ }
528
+
529
+ const providerToken: ProviderTokenLookup = async (
530
+ provider: string,
531
+ ): Promise<string | undefined> => {
532
+ const activeCtx = session.latestCtx;
533
+ if (!activeCtx) return undefined;
534
+ try {
535
+ const resolved = await activeCtx.modelRegistry.getProviderAuth(provider);
536
+ return resolved?.auth.apiKey;
537
+ } catch {
538
+ return undefined;
539
+ }
540
+ };
541
+
542
+ for (const server of servers) {
543
+ const existingConfig = session.configuredServers.get(server.name);
544
+ session.configuredServers.set(server.name, server);
545
+
546
+ if (!server.enabled) {
547
+ continue;
548
+ }
549
+
550
+ if (session.clients.has(server.name)) {
551
+ // Already connected/probing; keep existing client.
552
+ void existingConfig;
553
+ continue;
554
+ }
555
+
556
+ const auth: AuthResolver | undefined =
557
+ server.transport === "http" ? createAuthResolver(server, providerToken) : undefined;
558
+
559
+ const client: ServerClient = createServerClient(server, {
560
+ cwd: session.cwd,
561
+ ...(auth ? { auth } : {}),
562
+ log: (level: "info" | "warn" | "error", msg: string) => {
563
+ session.host.log(level, msg);
564
+ },
565
+ });
566
+
567
+ session.clients.set(server.name, client);
568
+ const offListen = client.onListenState(() => {
569
+ updateFooter(session);
570
+ });
571
+ session.cleanups.push(offListen);
572
+
573
+ startServerProbe(session, server, client);
574
+ }
575
+ }
576
+
577
+ function queueConfigReload(
578
+ session: SessionRuntime,
579
+ options: ConfigLoadOptions,
580
+ ): Promise<void> {
581
+ const next = session.configLoadChain.then(async () => {
582
+ if (session.controller.signal.aborted) return;
583
+ const loaded: { servers: ConfiguredServerEntry[]; warnings: ConfigWarning[] } =
584
+ await loadServerConfigs(options);
585
+ if (session.controller.signal.aborted) return;
586
+ attachConfiguredServers(session, loaded.servers, loaded.warnings);
587
+ updateFooter(session);
588
+ });
589
+ session.configLoadChain = next.catch(() => undefined);
590
+ return next;
591
+ }
592
+
593
+ function createSessionRuntime(pi: ExtensionAPI, ctx: ExtensionContext): SessionRuntime {
594
+ const controller = new AbortController();
595
+ const configuredServers = new Map<string, ConfiguredServerEntry>();
596
+ const clients = new Map<string, ServerClient>();
597
+ const probePromises = new Map<string, Promise<void>>();
598
+ const activationPromises = new Map<string, Promise<void>>();
599
+ const loggedWarnings = new Set<string>();
600
+ const wakeListeners = new Set<() => void>();
601
+ const cleanups: Array<() => void> = [];
602
+
603
+ let runtimeRef: SessionRuntime | undefined;
604
+
605
+ const host: EngineHost = {
606
+ getClient(server: string): ServerClient | undefined {
607
+ const client = clients.get(server);
608
+ if (!client || client.state.era !== "modern") return undefined;
609
+ return client;
610
+ },
611
+ appendEntry(customType: string, data: unknown): void {
612
+ try {
613
+ pi.appendEntry(customType, data);
614
+ } catch {
615
+ // Session runtime already torn down.
616
+ }
617
+ },
618
+ wake(
619
+ customType: typeof MESSAGE_EVENT | typeof MESSAGE_TASK,
620
+ content: string,
621
+ details: unknown,
622
+ ): void {
623
+ if (controller.signal.aborted) return;
624
+ if (runtimeRef) {
625
+ runtimeRef.wakeCount += 1;
626
+ }
627
+ pi.sendMessage(
628
+ {
629
+ customType,
630
+ content,
631
+ display: true,
632
+ details,
633
+ },
634
+ {
635
+ triggerTurn: true,
636
+ deliverAs: "steer",
637
+ },
638
+ );
639
+ updateFooter(runtimeRef);
640
+ for (const listener of wakeListeners) {
641
+ listener();
642
+ }
643
+ },
644
+ log(level: "info" | "warn" | "error", message: string): void {
645
+ updateFooter(runtimeRef);
646
+ if (controller.signal.aborted) return;
647
+ const activeCtx = runtimeRef?.latestCtx;
648
+ if (activeCtx?.hasUI && (level === "warn" || level === "error")) {
649
+ activeCtx.ui.notify(message, level === "warn" ? "warning" : "error");
650
+ }
651
+ },
652
+ get signal(): AbortSignal {
653
+ return controller.signal;
654
+ },
655
+ };
656
+
657
+ const events: EventsEngineApi = createEventsEngine(host);
658
+ const tasks: TasksEngineApi = createTasksEngine(host);
659
+
660
+ const session: SessionRuntime = {
661
+ controller,
662
+ cwd: ctx.cwd,
663
+ latestCtx: ctx,
664
+ host,
665
+ events,
666
+ tasks,
667
+ configuredServers,
668
+ clients,
669
+ probePromises,
670
+ activationPromises,
671
+ loggedWarnings,
672
+ wakeListeners,
673
+ cleanups,
674
+ configLoadChain: Promise.resolve(),
675
+ wakeCount: 0,
676
+ shutdownPromise: undefined,
677
+ };
678
+ runtimeRef = session;
679
+
680
+ cleanups.push(
681
+ events.onWake(() => {
682
+ updateFooter(session);
683
+ for (const listener of wakeListeners) {
684
+ listener();
685
+ }
686
+ }),
687
+ );
688
+ cleanups.push(
689
+ tasks.onWake(() => {
690
+ updateFooter(session);
691
+ for (const listener of wakeListeners) {
692
+ listener();
693
+ }
694
+ }),
695
+ );
696
+
697
+ return session;
698
+ }
699
+
700
+ function shutdownSession(
701
+ session: SessionRuntime | undefined,
702
+ ctx?: ExtensionContext,
703
+ ): Promise<void> {
704
+ if (!session) {
705
+ if (ctx?.hasUI) {
706
+ ctx.ui.setStatus(STATUS_KEY, undefined);
707
+ }
708
+ return Promise.resolve();
709
+ }
710
+ if (session.shutdownPromise) {
711
+ if (ctx?.hasUI) {
712
+ ctx.ui.setStatus(STATUS_KEY, undefined);
713
+ }
714
+ return session.shutdownPromise;
715
+ }
716
+
717
+ session.shutdownPromise = (async (): Promise<void> => {
718
+ session.controller.abort();
719
+ const uiCtx = ctx ?? session.latestCtx;
720
+ if (uiCtx?.hasUI) {
721
+ uiCtx.ui.setStatus(STATUS_KEY, undefined);
722
+ }
723
+
724
+ const cleanups = session.cleanups.splice(0, session.cleanups.length);
725
+ for (const cleanup of cleanups) {
726
+ try {
727
+ cleanup();
728
+ } catch {
729
+ // Ignore listener cleanup errors.
730
+ }
731
+ }
732
+ session.wakeListeners.clear();
733
+
734
+ await Promise.allSettled([session.events.shutdown(), session.tasks.shutdown()]);
735
+ await Promise.allSettled(
736
+ [...session.clients.values()].map((client: ServerClient) => client.close()),
737
+ );
738
+ session.clients.clear();
739
+ session.probePromises.clear();
740
+ session.activationPromises.clear();
741
+
742
+ if (uiCtx?.hasUI) {
743
+ uiCtx.ui.setStatus(STATUS_KEY, undefined);
744
+ }
745
+ })();
746
+
747
+ return session.shutdownPromise;
748
+ }
749
+
750
+ // ---------------------------------------------------------------------------------------------
751
+ // Custom message rendering ('mcp-event' & 'mcp-task')
752
+ // ---------------------------------------------------------------------------------------------
753
+
754
+ const ANSI_ESCAPE_RE = /\x1b(?:\[[0-9;]*[A-Za-z]|_.*?\x07|\].*?(?:\x07|\x1b\\))/g;
755
+
756
+ type RenderedCustomMessage = Parameters<MessageRenderer>[0];
757
+
758
+ function stripAnsi(text: string): string {
759
+ return text.replace(ANSI_ESCAPE_RE, "");
760
+ }
761
+
762
+ function extractMessageText(content: RenderedCustomMessage["content"]): string {
763
+ if (typeof content === "string") return content;
764
+ return content
765
+ .filter((block): block is TextContent => block.type === "text")
766
+ .map((block: TextContent) => block.text)
767
+ .join("\n");
768
+ }
769
+
770
+ function singleLineFallback(content: RenderedCustomMessage["content"]): string {
771
+ const first = extractMessageText(content)
772
+ .split(/\r?\n/)
773
+ .map((line: string) => line.trim())
774
+ .find((line: string) => line.length > 0);
775
+ return first ?? "delivery";
776
+ }
777
+
778
+ function summarizeEventDetails(message: RenderedCustomMessage): string {
779
+ const details = message.details;
780
+ if (Array.isArray(details) && details.length > 0) {
781
+ let count = 0;
782
+ const sources: string[] = [];
783
+ for (const entry of details) {
784
+ if (isPlainObject(entry)) {
785
+ const occ = Array.isArray(entry.occurrences) ? entry.occurrences.length : 1;
786
+ count += occ;
787
+ if (typeof entry.server === "string" && typeof entry.name === "string") {
788
+ sources.push(`${entry.server}/${entry.name}`);
789
+ }
790
+ }
791
+ }
792
+ if (sources.length > 0) {
793
+ return `${sources.join(", ")} (${count} ${count === 1 ? "event" : "events"})`;
794
+ }
795
+ }
796
+ if (isPlainObject(details)) {
797
+ if (Array.isArray(details.deliveries) && details.deliveries.length > 0) {
798
+ let count = 0;
799
+ const names: string[] = [];
800
+ for (const d of details.deliveries) {
801
+ if (isPlainObject(d)) {
802
+ count += Array.isArray(d.occurrences) ? d.occurrences.length : 1;
803
+ if (typeof d.server === "string" && typeof d.name === "string") {
804
+ names.push(`${d.server}/${d.name}`);
805
+ }
806
+ }
807
+ }
808
+ if (names.length > 0) {
809
+ return `${names.join(", ")} (${count} ${count === 1 ? "event" : "events"})`;
810
+ }
811
+ }
812
+ const server = typeof details.server === "string" ? details.server : undefined;
813
+ const name = typeof details.name === "string" ? details.name : undefined;
814
+ if (Array.isArray(details.occurrences)) {
815
+ const count = details.occurrences.length;
816
+ const target = server && name ? `${server}/${name}` : (name ?? server ?? "stream");
817
+ const trunc = details.truncated === true ? ", truncated" : "";
818
+ return `${target}: ${count} ${count === 1 ? "event" : "events"}${trunc}`;
819
+ }
820
+ if (server || name) {
821
+ const target = server && name ? `${server}/${name}` : (server ?? name ?? "event");
822
+ const note =
823
+ typeof details.reason === "string"
824
+ ? ` (${details.reason})`
825
+ : typeof details.message === "string"
826
+ ? `: ${details.message}`
827
+ : "";
828
+ return `${target}${note}`;
829
+ }
830
+ }
831
+ return singleLineFallback(message.content).replace(/\s+/g, " ");
832
+ }
833
+
834
+ function summarizeTaskDetails(message: RenderedCustomMessage): string {
835
+ const details = message.details;
836
+ if (isPlainObject(details)) {
837
+ const taskObj = isPlainObject(details.task) ? details.task : details;
838
+ const server = typeof details.server === "string" ? details.server : undefined;
839
+ const tool =
840
+ typeof details.toolName === "string"
841
+ ? details.toolName
842
+ : typeof details.tool === "string"
843
+ ? details.tool
844
+ : undefined;
845
+ const taskId =
846
+ typeof details.taskId === "string"
847
+ ? details.taskId
848
+ : typeof taskObj.taskId === "string"
849
+ ? taskObj.taskId
850
+ : undefined;
851
+ const status =
852
+ typeof details.status === "string"
853
+ ? details.status
854
+ : typeof taskObj.status === "string"
855
+ ? taskObj.status
856
+ : undefined;
857
+
858
+ if (server || tool || taskId || status) {
859
+ const head =
860
+ server && tool ? `${server}/${tool}` : (server ?? tool ?? "task");
861
+ const idPart = taskId ? ` #${taskId}` : "";
862
+ const statusPart = status ? ` -> ${status}` : "";
863
+ return `${head}${idPart}${statusPart}`;
864
+ }
865
+ }
866
+ return singleLineFallback(message.content).replace(/\s+/g, " ");
867
+ }
868
+
869
+ function clampPlainText(text: string, maxCols: number): string {
870
+ if (maxCols <= 0) return "";
871
+ if (text.length <= maxCols) return text;
872
+ if (maxCols === 1) return "…";
873
+ return `${text.slice(0, maxCols - 1)}…`;
874
+ }
875
+
876
+ function splitPlainWidth(line: string, maxCols: number): string[] {
877
+ const safeWidth = Math.max(1, maxCols);
878
+ if (line.length <= safeWidth) return [line];
879
+ const chunks: string[] = [];
880
+ for (let offset = 0; offset < line.length; offset += safeWidth) {
881
+ chunks.push(line.slice(offset, offset + safeWidth));
882
+ }
883
+ return chunks;
884
+ }
885
+
886
+ function createExpandableJsonRenderer(
887
+ badgeLabel: string,
888
+ summarize: (message: RenderedCustomMessage) => string,
889
+ ): MessageRenderer {
890
+ return (
891
+ message: RenderedCustomMessage,
892
+ options: MessageRenderOptions,
893
+ theme: Theme,
894
+ ): NonNullable<ReturnType<MessageRenderer>> => {
895
+ const summaryPlain = summarize(message).replace(/[\r\n\t]+/g, " ").trim();
896
+ const jsonSource =
897
+ message.details !== undefined
898
+ ? message.details
899
+ : { customType: message.customType, content: extractMessageText(message.content) };
900
+ const jsonFormatted = JSON.stringify(jsonSource, null, 2) ?? "null";
901
+
902
+ return {
903
+ invalidate(): void {},
904
+ render(width: number): string[] {
905
+ const totalWidth = Math.max(1, width);
906
+ const padCount = Math.min(
907
+ Math.max(0, options.outputPad ?? 0),
908
+ Math.max(0, Math.floor((totalWidth - 1) / 2)),
909
+ );
910
+ const pad = " ".repeat(padCount);
911
+ const innerWidth = Math.max(1, totalWidth - padCount * 2);
912
+ const rawBadge = `[${badgeLabel}]`;
913
+
914
+ if (!options.expanded) {
915
+ const expandHint = options.keyHint("app.tools.expand", "to expand");
916
+ const hintVisible = stripAnsi(expandHint);
917
+ const hintSuffixPlain = hintVisible.length > 0 ? ` (${hintVisible})` : "";
918
+ const badgeAndSpace = rawBadge.length + 1;
919
+
920
+ if (innerWidth <= rawBadge.length) {
921
+ const clipped = clampPlainText(rawBadge, innerWidth);
922
+ return [
923
+ theme.bg(
924
+ "customMessageBg",
925
+ pad + theme.fg("customMessageLabel", theme.bold(clipped)) + " ".repeat(Math.max(0, totalWidth - padCount - clipped.length)),
926
+ ),
927
+ ];
928
+ }
929
+
930
+ const includeHint =
931
+ hintSuffixPlain.length > 0 &&
932
+ innerWidth > badgeAndSpace + hintSuffixPlain.length + 4;
933
+ const summaryBudget =
934
+ innerWidth - badgeAndSpace - (includeHint ? hintSuffixPlain.length : 0);
935
+ const clampedSummary = clampPlainText(summaryPlain, summaryBudget);
936
+ const hintRendered = includeHint
937
+ ? ` ${theme.fg("muted", "(")}${expandHint}${theme.fg("muted", ")")}`
938
+ : "";
939
+ const visibleContentLen =
940
+ rawBadge.length +
941
+ 1 +
942
+ clampedSummary.length +
943
+ (includeHint ? hintSuffixPlain.length : 0);
944
+ const trailingSpaces = " ".repeat(Math.max(0, totalWidth - padCount - visibleContentLen));
945
+ const styledLine =
946
+ pad +
947
+ theme.fg("customMessageLabel", theme.bold(rawBadge)) +
948
+ " " +
949
+ theme.fg("customMessageText", clampedSummary) +
950
+ hintRendered +
951
+ trailingSpaces;
952
+ return [theme.bg("customMessageBg", styledLine)];
953
+ }
954
+
955
+ const lines: string[] = [];
956
+ const headerSummary = clampPlainText(
957
+ summaryPlain,
958
+ Math.max(0, innerWidth - rawBadge.length - 1),
959
+ );
960
+ const headerVisibleLen =
961
+ rawBadge.length + (headerSummary.length > 0 ? 1 + headerSummary.length : 0);
962
+ const headerTrailing = " ".repeat(Math.max(0, totalWidth - padCount - headerVisibleLen));
963
+ const headerLine =
964
+ pad +
965
+ theme.fg("customMessageLabel", theme.bold(rawBadge)) +
966
+ (headerSummary.length > 0 ? ` ${theme.fg("customMessageText", headerSummary)}` : "") +
967
+ headerTrailing;
968
+ lines.push(theme.bg("customMessageBg", headerLine));
969
+
970
+ for (const rawJsonLine of jsonFormatted.replace(/\t/g, " ").split("\n")) {
971
+ for (const chunk of splitPlainWidth(rawJsonLine, innerWidth)) {
972
+ const rightPad = " ".repeat(Math.max(0, totalWidth - padCount - chunk.length));
973
+ lines.push(
974
+ theme.bg(
975
+ "customMessageBg",
976
+ `${pad}${theme.fg("customMessageText", chunk)}${rightPad}`,
977
+ ),
978
+ );
979
+ }
980
+ }
981
+ return lines;
982
+ },
983
+ };
984
+ };
985
+ }
986
+
987
+ // ---------------------------------------------------------------------------------------------
988
+ // Extension entry
989
+ // ---------------------------------------------------------------------------------------------
990
+
991
+ export default function extension(pi: ExtensionAPI): void {
992
+ let currentSession: SessionRuntime | undefined;
993
+
994
+ function requireActiveSession(): SessionRuntime {
995
+ if (!currentSession || currentSession.controller.signal.aborted) {
996
+ throw new Error("MCP extension session is not active.");
997
+ }
998
+ return currentSession;
999
+ }
1000
+
1001
+ pi.registerMessageRenderer(
1002
+ MESSAGE_EVENT,
1003
+ createExpandableJsonRenderer(MESSAGE_EVENT, summarizeEventDetails),
1004
+ );
1005
+ pi.registerMessageRenderer(
1006
+ MESSAGE_TASK,
1007
+ createExpandableJsonRenderer(MESSAGE_TASK, summarizeTaskDetails),
1008
+ );
1009
+
1010
+ pi.registerTool({
1011
+ name: "mcp_events",
1012
+ label: "MCP Events",
1013
+ description:
1014
+ "Inspect MCP 2026-07-28 servers, list event types, manage event subscriptions, or poll events once.",
1015
+ exposure: "direct",
1016
+ parameters: McpEventsParams,
1017
+ async execute(
1018
+ _toolCallId: string,
1019
+ params: McpEventsInput,
1020
+ signal: AbortSignal | undefined,
1021
+ _onUpdate: unknown,
1022
+ ctx: ExtensionToolContext,
1023
+ ): Promise<AgentToolResult<unknown>> {
1024
+ if (currentSession && ctx) {
1025
+ currentSession.latestCtx = ctx;
1026
+ }
1027
+
1028
+ switch (params.action) {
1029
+ case "servers": {
1030
+ if (!currentSession || currentSession.controller.signal.aborted) {
1031
+ return jsonResult<ServerState[]>([]);
1032
+ }
1033
+ const session = currentSession;
1034
+ await raceWithSignals(session.configLoadChain, [signal, session.controller.signal]);
1035
+ if (session.probePromises.size > 0) {
1036
+ await raceWithSignals(
1037
+ Promise.allSettled([...session.probePromises.values()]),
1038
+ [signal, session.controller.signal],
1039
+ );
1040
+ }
1041
+ const states: ServerState[] = [];
1042
+ for (const [name, cfg] of session.configuredServers) {
1043
+ const client = session.clients.get(name);
1044
+ states.push(client ? { ...client.state } : disabledServerState(cfg));
1045
+ }
1046
+ updateFooter(session, ctx);
1047
+ return jsonResult(states);
1048
+ }
1049
+
1050
+ case "subscriptions": {
1051
+ if (!currentSession || currentSession.controller.signal.aborted) {
1052
+ return jsonResult([]);
1053
+ }
1054
+ const session = currentSession;
1055
+ await raceWithSignals(session.configLoadChain, [signal, session.controller.signal]);
1056
+ if (session.activationPromises.size > 0) {
1057
+ await raceWithSignals(
1058
+ Promise.allSettled([...session.activationPromises.values()]),
1059
+ [signal, session.controller.signal],
1060
+ );
1061
+ }
1062
+ const all = session.events.subscriptions();
1063
+ const filtered = params.server
1064
+ ? all.filter((sub) => sub.server === params.server)
1065
+ : all;
1066
+ updateFooter(session, ctx);
1067
+ return jsonResult(filtered);
1068
+ }
1069
+
1070
+ case "list": {
1071
+ if (!params.server) {
1072
+ throw new Error('mcp_events action "list" requires parameter "server".');
1073
+ }
1074
+ const session = requireActiveSession();
1075
+ await ensureModernCapability(session, params.server, "events", signal);
1076
+ try {
1077
+ const list = await session.events.list(params.server);
1078
+ updateFooter(session, ctx);
1079
+ return jsonResult(list);
1080
+ } catch (err) {
1081
+ throw normalizeServerCallError(params.server, err);
1082
+ }
1083
+ }
1084
+
1085
+ case "subscribe": {
1086
+ if (!params.server) {
1087
+ throw new Error('mcp_events action "subscribe" requires parameter "server".');
1088
+ }
1089
+ if (!params.name) {
1090
+ throw new Error('mcp_events action "subscribe" requires parameter "name".');
1091
+ }
1092
+ const session = requireActiveSession();
1093
+ await ensureModernCapability(session, params.server, "events", signal);
1094
+ const mode = ctx?.mode ?? session.latestCtx?.mode;
1095
+ const defaultHoldSettle = mode === "print" || mode === "json";
1096
+ const req: SubscribeRequest = {
1097
+ server: params.server,
1098
+ name: params.name,
1099
+ ...(params.arguments !== undefined ? { arguments: params.arguments } : {}),
1100
+ delivery: params.delivery ?? "auto",
1101
+ ...(params.cursor !== undefined ? { cursor: params.cursor } : {}),
1102
+ ...(params.maxAgeMs !== undefined ? { maxAgeMs: params.maxAgeMs } : {}),
1103
+ holdSettle: params.holdSettle ?? defaultHoldSettle,
1104
+ };
1105
+ try {
1106
+ const subscription = await session.events.subscribe(req);
1107
+ updateFooter(session, ctx);
1108
+ return jsonResult(subscription);
1109
+ } catch (err) {
1110
+ throw normalizeServerCallError(params.server, err);
1111
+ }
1112
+ }
1113
+
1114
+ case "unsubscribe": {
1115
+ if (!params.server) {
1116
+ throw new Error('mcp_events action "unsubscribe" requires parameter "server".');
1117
+ }
1118
+ if (!params.name) {
1119
+ throw new Error('mcp_events action "unsubscribe" requires parameter "name".');
1120
+ }
1121
+ const session = requireActiveSession();
1122
+ await raceWithSignals(session.configLoadChain, [signal, session.controller.signal]);
1123
+ const probe = session.probePromises.get(params.server);
1124
+ if (probe) {
1125
+ await raceWithSignals(probe, [signal, session.controller.signal]);
1126
+ }
1127
+ const hasPersisted = session.events
1128
+ .subscriptions()
1129
+ .some((sub) => sub.server === params.server);
1130
+ if (!session.configuredServers.has(params.server) && !hasPersisted) {
1131
+ throw new Error(
1132
+ `Unknown MCP server "${params.server}". Configured servers: ${configuredNamesList(session)}.`,
1133
+ );
1134
+ }
1135
+ try {
1136
+ const removed = await session.events.unsubscribe(
1137
+ params.server,
1138
+ params.name,
1139
+ params.arguments,
1140
+ );
1141
+ updateFooter(session, ctx);
1142
+ return jsonResult({
1143
+ server: params.server,
1144
+ name: params.name,
1145
+ removed,
1146
+ });
1147
+ } catch (err) {
1148
+ throw normalizeServerCallError(params.server, err);
1149
+ }
1150
+ }
1151
+
1152
+ case "poll": {
1153
+ if (!params.server) {
1154
+ throw new Error('mcp_events action "poll" requires parameter "server".');
1155
+ }
1156
+ if (!params.name) {
1157
+ throw new Error('mcp_events action "poll" requires parameter "name".');
1158
+ }
1159
+ const session = requireActiveSession();
1160
+ await ensureModernCapability(session, params.server, "events", signal);
1161
+ const pollParams: PollEventsParams = {
1162
+ name: params.name,
1163
+ ...(params.arguments !== undefined ? { arguments: params.arguments } : {}),
1164
+ cursor: params.cursor ?? null,
1165
+ ...(params.maxAgeMs !== undefined ? { maxAgeMs: params.maxAgeMs } : {}),
1166
+ ...(params.maxEvents !== undefined ? { maxEvents: params.maxEvents } : {}),
1167
+ };
1168
+ try {
1169
+ const result = await session.events.poll(params.server, pollParams);
1170
+ updateFooter(session, ctx);
1171
+ return jsonResult(result);
1172
+ } catch (err) {
1173
+ throw normalizeServerCallError(params.server, err);
1174
+ }
1175
+ }
1176
+ }
1177
+ },
1178
+ });
1179
+
1180
+ pi.registerTool({
1181
+ name: "mcp_tasks",
1182
+ label: "MCP Tasks",
1183
+ description:
1184
+ "Call MCP tools with 2026-07-28 task support, inspect or answer inputRequests, cancel tasks, or list active session tasks.",
1185
+ exposure: "direct",
1186
+ parameters: McpTasksParams,
1187
+ async execute(
1188
+ _toolCallId: string,
1189
+ params: McpTasksInput,
1190
+ signal: AbortSignal | undefined,
1191
+ _onUpdate: unknown,
1192
+ ctx: ExtensionToolContext,
1193
+ ): Promise<AgentToolResult<unknown>> {
1194
+ if (currentSession && ctx) {
1195
+ currentSession.latestCtx = ctx;
1196
+ }
1197
+
1198
+ switch (params.action) {
1199
+ case "active": {
1200
+ if (!currentSession || currentSession.controller.signal.aborted) {
1201
+ return jsonResult([]);
1202
+ }
1203
+ const session = currentSession;
1204
+ const active = session.tasks.active();
1205
+ const filtered = params.server
1206
+ ? active.filter((task) => task.server === params.server)
1207
+ : active;
1208
+ updateFooter(session, ctx);
1209
+ return jsonResult(filtered);
1210
+ }
1211
+
1212
+ case "call": {
1213
+ if (!params.server) {
1214
+ throw new Error('mcp_tasks action "call" requires parameter "server".');
1215
+ }
1216
+ if (!params.tool) {
1217
+ throw new Error('mcp_tasks action "call" requires parameter "tool".');
1218
+ }
1219
+ const session = requireActiveSession();
1220
+ await ensureModernCapability(session, params.server, "tasks", signal);
1221
+ try {
1222
+ const outcome = await session.tasks.call(
1223
+ params.server,
1224
+ params.tool,
1225
+ params.arguments,
1226
+ signal,
1227
+ );
1228
+ updateFooter(session, ctx);
1229
+ return jsonResult(outcome);
1230
+ } catch (err) {
1231
+ throw normalizeServerCallError(params.server, err);
1232
+ }
1233
+ }
1234
+
1235
+ case "get": {
1236
+ if (!params.server) {
1237
+ throw new Error('mcp_tasks action "get" requires parameter "server".');
1238
+ }
1239
+ if (!params.taskId) {
1240
+ throw new Error('mcp_tasks action "get" requires parameter "taskId".');
1241
+ }
1242
+ const session = requireActiveSession();
1243
+ await ensureModernCapability(session, params.server, "tasks", signal);
1244
+ try {
1245
+ const task = await session.tasks.get(params.server, params.taskId);
1246
+ updateFooter(session, ctx);
1247
+ return jsonResult(task);
1248
+ } catch (err) {
1249
+ throw normalizeServerCallError(params.server, err);
1250
+ }
1251
+ }
1252
+
1253
+ case "update": {
1254
+ if (!params.server) {
1255
+ throw new Error('mcp_tasks action "update" requires parameter "server".');
1256
+ }
1257
+ if (!params.taskId) {
1258
+ throw new Error('mcp_tasks action "update" requires parameter "taskId".');
1259
+ }
1260
+ if (!params.inputResponses) {
1261
+ throw new Error(
1262
+ 'mcp_tasks action "update" requires parameter "inputResponses".',
1263
+ );
1264
+ }
1265
+ const session = requireActiveSession();
1266
+ await ensureModernCapability(session, params.server, "tasks", signal);
1267
+ try {
1268
+ await session.tasks.update(params.server, params.taskId, params.inputResponses);
1269
+ updateFooter(session, ctx);
1270
+ return jsonResult({
1271
+ server: params.server,
1272
+ taskId: params.taskId,
1273
+ updated: true,
1274
+ });
1275
+ } catch (err) {
1276
+ throw normalizeServerCallError(params.server, err);
1277
+ }
1278
+ }
1279
+
1280
+ case "cancel": {
1281
+ if (!params.server) {
1282
+ throw new Error('mcp_tasks action "cancel" requires parameter "server".');
1283
+ }
1284
+ if (!params.taskId) {
1285
+ throw new Error('mcp_tasks action "cancel" requires parameter "taskId".');
1286
+ }
1287
+ const session = requireActiveSession();
1288
+ await ensureModernCapability(session, params.server, "tasks", signal);
1289
+ try {
1290
+ await session.tasks.cancel(params.server, params.taskId);
1291
+ updateFooter(session, ctx);
1292
+ return jsonResult({
1293
+ server: params.server,
1294
+ taskId: params.taskId,
1295
+ cancelled: true,
1296
+ });
1297
+ } catch (err) {
1298
+ throw normalizeServerCallError(params.server, err);
1299
+ }
1300
+ }
1301
+ }
1302
+ },
1303
+ });
1304
+
1305
+ pi.on("session_start", async (_event, ctx) => {
1306
+ if (currentSession) {
1307
+ await shutdownSession(currentSession, ctx);
1308
+ }
1309
+
1310
+ const session = createSessionRuntime(pi, ctx);
1311
+ currentSession = session;
1312
+
1313
+ const branchEntries = ctx.sessionManager.getBranch();
1314
+ const allEntries = ctx.sessionManager.getEntries();
1315
+ session.events.restore(branchEntries, allEntries);
1316
+ session.tasks.restore(allEntries);
1317
+ updateFooter(session, ctx);
1318
+
1319
+ await queueConfigReload(session, {
1320
+ cwd: ctx.cwd,
1321
+ isProjectTrusted: ctx.isProjectTrusted(),
1322
+ sessionServers: toSessionServers(pi.getMcpServers()),
1323
+ });
1324
+ });
1325
+
1326
+ pi.on("mcp_servers_change", async (event, ctx) => {
1327
+ const session = currentSession;
1328
+ if (!session || session.controller.signal.aborted) return;
1329
+ session.latestCtx = ctx;
1330
+ session.cwd = ctx.cwd;
1331
+
1332
+ await queueConfigReload(session, {
1333
+ cwd: ctx.cwd,
1334
+ isProjectTrusted: ctx.isProjectTrusted(),
1335
+ sessionServers: toSessionServers(event.servers ?? pi.getMcpServers()),
1336
+ });
1337
+ });
1338
+
1339
+ pi.on("session_tree", (_event, ctx) => {
1340
+ const session = currentSession;
1341
+ if (!session || session.controller.signal.aborted) return;
1342
+ session.latestCtx = ctx;
1343
+ session.events.restore(ctx.sessionManager.getBranch(), ctx.sessionManager.getEntries());
1344
+ updateFooter(session, ctx);
1345
+ });
1346
+
1347
+ pi.on("tool_result", async (event: ToolResultEvent, ctx): Promise<ToolResultEventResult | undefined> => {
1348
+ const session = currentSession;
1349
+ if (!session || session.controller.signal.aborted) return undefined;
1350
+ session.latestCtx = ctx;
1351
+
1352
+ if (!event.isError || !event.toolName.startsWith("mcp__")) {
1353
+ return undefined;
1354
+ }
1355
+
1356
+ const errorText = event.content
1357
+ .filter((block): block is TextContent => block.type === "text")
1358
+ .map((block: TextContent) => block.text)
1359
+ .join("\n");
1360
+ if (!errorText.includes("-32021") || !errorText.includes(EXT_TASKS)) {
1361
+ return undefined;
1362
+ }
1363
+
1364
+ await raceWithSignals(session.configLoadChain, [ctx.signal, session.controller.signal]);
1365
+
1366
+ let serverName: string | undefined;
1367
+ let toolName: string | undefined;
1368
+
1369
+ if (
1370
+ "details" in event &&
1371
+ isPlainObject(event.details) &&
1372
+ typeof event.details.server === "string" &&
1373
+ typeof event.details.tool === "string"
1374
+ ) {
1375
+ serverName = event.details.server;
1376
+ toolName = event.details.tool;
1377
+ } else {
1378
+ const candidates = [...session.configuredServers.values()]
1379
+ .filter(
1380
+ (cfg: ConfiguredServerEntry) =>
1381
+ event.toolName.startsWith(`${cfg.namespace}__`) &&
1382
+ event.toolName.length > cfg.namespace.length + 2,
1383
+ )
1384
+ .sort(
1385
+ (a: ConfiguredServerEntry, b: ConfiguredServerEntry) =>
1386
+ b.namespace.length - a.namespace.length,
1387
+ );
1388
+ const matched = candidates[0];
1389
+ if (matched) {
1390
+ serverName = matched.name;
1391
+ toolName = event.toolName.slice(matched.namespace.length + 2);
1392
+ }
1393
+ }
1394
+
1395
+ if (!serverName || !toolName) return undefined;
1396
+
1397
+ const probe = session.probePromises.get(serverName);
1398
+ if (probe) {
1399
+ await raceWithSignals(probe, [ctx.signal, session.controller.signal]);
1400
+ }
1401
+
1402
+ const client = session.clients.get(serverName);
1403
+ if (!client || client.state.era !== "modern" || !client.state.tasks) {
1404
+ return undefined;
1405
+ }
1406
+
1407
+ const callSpec = JSON.stringify({
1408
+ action: "call",
1409
+ server: serverName,
1410
+ tool: toolName,
1411
+ arguments: event.input,
1412
+ });
1413
+ const hint = `Hint: Tool "${toolName}" on MCP server "${serverName}" requires ${EXT_TASKS}; use mcp_tasks ${callSpec}.`;
1414
+
1415
+ const nextContent = [...event.content];
1416
+ const lastIdx = nextContent.length - 1;
1417
+ const lastBlock = lastIdx >= 0 ? nextContent[lastIdx] : undefined;
1418
+ if (lastBlock && lastBlock.type === "text") {
1419
+ nextContent[lastIdx] = { ...lastBlock, text: `${lastBlock.text}\n${hint}` };
1420
+ } else {
1421
+ nextContent.push({ type: "text", text: hint });
1422
+ }
1423
+
1424
+ return {
1425
+ content: nextContent,
1426
+ ...(event.structuredContent !== undefined
1427
+ ? { structuredContent: event.structuredContent }
1428
+ : {}),
1429
+ };
1430
+ });
1431
+
1432
+ pi.on(
1433
+ "agent_before_settle",
1434
+ async (
1435
+ event: AgentBeforeSettleEvent,
1436
+ ctx: ExtensionContext,
1437
+ ): Promise<AgentBeforeSettleEventResult | undefined> => {
1438
+ if (ctx.mode !== "print" && ctx.mode !== "json") {
1439
+ return undefined;
1440
+ }
1441
+ if (
1442
+ event.outcome === "aborted" ||
1443
+ event.outcome === "error" ||
1444
+ ctx.signal?.aborted
1445
+ ) {
1446
+ return undefined;
1447
+ }
1448
+
1449
+ const session = currentSession;
1450
+ if (!session || session.controller.signal.aborted) {
1451
+ return undefined;
1452
+ }
1453
+ session.latestCtx = ctx;
1454
+
1455
+ await raceWithSignals(session.configLoadChain, [ctx.signal, session.controller.signal]);
1456
+ if (session.activationPromises.size > 0) {
1457
+ await raceWithSignals(
1458
+ Promise.allSettled([...session.activationPromises.values()]),
1459
+ [ctx.signal, session.controller.signal],
1460
+ );
1461
+ }
1462
+ if (ctx.signal?.aborted || session.controller.signal.aborted) {
1463
+ return undefined;
1464
+ }
1465
+
1466
+ const isHolding = (): boolean =>
1467
+ session.tasks.hasPending() || session.events.holdsSettle();
1468
+
1469
+ if (!isHolding() || ctx.hasPendingMessages()) {
1470
+ return undefined;
1471
+ }
1472
+
1473
+ const startWakeCount = session.wakeCount;
1474
+
1475
+ const outcome = await new Promise<"woke" | "drained" | "aborted">((resolve) => {
1476
+ let settled = false;
1477
+ let pollTimer: ReturnType<typeof setInterval> | undefined;
1478
+ let offWake: (() => void) | undefined;
1479
+ const abortCleanups: Array<() => void> = [];
1480
+
1481
+ const finish = (reason: "woke" | "drained" | "aborted") => {
1482
+ if (settled) return;
1483
+ settled = true;
1484
+ if (pollTimer !== undefined) {
1485
+ clearInterval(pollTimer);
1486
+ }
1487
+ offWake?.();
1488
+ for (const cleanup of abortCleanups) cleanup();
1489
+ resolve(reason);
1490
+ };
1491
+
1492
+ const onWake = () => finish("woke");
1493
+ session.wakeListeners.add(onWake);
1494
+ offWake = () => {
1495
+ session.wakeListeners.delete(onWake);
1496
+ };
1497
+
1498
+ for (const sig of [session.controller.signal, ctx.signal]) {
1499
+ if (!sig) continue;
1500
+ if (sig.aborted) {
1501
+ finish("aborted");
1502
+ return;
1503
+ }
1504
+ const onAbort = () => finish("aborted");
1505
+ sig.addEventListener("abort", onAbort, { once: true });
1506
+ abortCleanups.push(() => sig.removeEventListener("abort", onAbort));
1507
+ }
1508
+
1509
+ if (session.wakeCount !== startWakeCount || ctx.hasPendingMessages()) {
1510
+ finish("woke");
1511
+ return;
1512
+ }
1513
+ if (!isHolding()) {
1514
+ finish("drained");
1515
+ return;
1516
+ }
1517
+
1518
+ pollTimer = setInterval(() => {
1519
+ if (session.controller.signal.aborted || ctx.signal?.aborted) {
1520
+ finish("aborted");
1521
+ return;
1522
+ }
1523
+ if (session.wakeCount !== startWakeCount || ctx.hasPendingMessages()) {
1524
+ finish("woke");
1525
+ return;
1526
+ }
1527
+ if (!isHolding()) {
1528
+ finish("drained");
1529
+ }
1530
+ }, SETTLE_POLL_MS);
1531
+ pollTimer.unref?.();
1532
+ });
1533
+
1534
+ if (outcome === "woke") {
1535
+ return { continue: true };
1536
+ }
1537
+ return undefined;
1538
+ },
1539
+ );
1540
+
1541
+ pi.on("session_shutdown", async (_event, ctx) => {
1542
+ const session = currentSession;
1543
+ currentSession = undefined;
1544
+ await shutdownSession(session, ctx);
1545
+ });
1546
+ }