pilotswarm-sdk 0.5.63 → 0.5.64

package/dist/managed-session.js

@@ -1,3 +1,4 @@
+import { isNativeChildEvent, settleNativeSubagents, guardNativeExternalTools } from "./native-subagents.js";
 import { defineTool } from "@github/copilot-sdk";
 import { normalizeCanvasResponseContract as normalizeCanvasContractShared } from "./canvas-app-manifest.js";
 // One list gates BOTH halves of every manager tool: the declaration in the
@@ -7,6 +8,7 @@ import { holdsManagerBundle } from "./agent-manager-tools.js";
 // the declarations in systemToolDefs() and the handlers in runTurn().
 import { holdsProviderTools, providerToolDefs, providerToolsUnavailable } from "./provider-tools.js";
 import { LiveTurnCoalescer } from "./live-turn.js";
+import { NativeTaskObserver } from "./native-task-observer.js";
 const DEFAULT_WAIT_TOOL_DESCRIPTION = "The ONLY way to wait, pause, delay, or pause-before-retry inside a turn: a durable timer that survives " +
     "restarts and may resume on a different worker (set preserveWorkerAffinity=true for node-local work). " +
     "NEVER use bash sleep, setTimeout, setInterval, or any other external timing mechanism. " +
@@ -615,6 +617,16 @@ export class ManagedSession {
     }
     /** Set for the duration of runTurn(); read by the lock-bypassing stop path. */
     activeTurn = null;
+    nativeFeatureRevoked = false;
+    canAdmitNativeTask() {
+        return this.config.nativeSubagents === "sync" && !this.nativeFeatureRevoked
+            && (this.config.nativeFeatureAllowed?.() ?? false);
+    }
+    /** A cached OFF is sticky for this turn, even if the next poll is ON. */
+    refreshNativeFeaturePolicy() {
+        if (this.activeTurn && !this.canAdmitNativeTask())
+            this.nativeFeatureRevoked = true;
+    }
     /** Set only by requestStop(); classifies the turn unwind as "stopped". */
     stopRequest = null;
     /** Resolver for the current turn's completion promise — hang escalation hook. */
@@ -1124,9 +1136,29 @@ export class ManagedSession {
      * misclassified as a retryable error.
      */
     async runTurn(prompt, opts) {
+        this.nativeFeatureRevoked = false;
         this.activeTurn = { turnIndex: opts?.turnIndex ?? -1, startedAt: Date.now() };
+        let result;
+        let turnError;
+        let failed = false;
         try {
-            const result = await this._runTurnInner(prompt, opts);
+            try {
+                // Also retire native tasks restored from an interrupted worker.
+                if (this.config.nativeSubagents === "sync")
+                    await settleNativeSubagents(this.copilotSession);
+                result = await this._runTurnInner(prompt, opts);
+            }
+            catch (err) {
+                failed = true;
+                turnError = err;
+            }
+            // Cleanup failures must escape stop/error classification: the
+            // activity cannot commit a snapshot with native work still live.
+            if (this.config.nativeSubagents === "sync")
+                await settleNativeSubagents(this.copilotSession, {
+                    rejectRunning: result?.type === "completed" && !this.stopRequest,
+                });
+            // A stop can arrive DURING cleanup. Classify only after it settles.
             if (this.stopRequest) {
                 return {
                     type: "stopped",
@@ -1134,14 +1166,10 @@ export class ManagedSession {
                     ...(result?.events ? { events: result.events } : {}),
                 };
             }
+            if (failed)
+                throw turnError;
             return result;
         }
-        catch (err) {
-            if (this.stopRequest) {
-                return { type: "stopped", reason: this.stopRequest.reason };
-            }
-            throw err;
-        }
         finally {
             this.activeTurn = null;
             this.stopRequest = null;
@@ -2500,7 +2528,8 @@ export class ManagedSession {
         // registerTools from the public types (it was always @internal) but
         // ships it unchanged in dist/session.js — cast until a public
         // handler-refresh API exists.
-        this.copilotSession.registerTools(allTools);
+        this.copilotSession.registerTools(this.config.nativeSubagents === "sync"
+            ? guardNativeExternalTools(allTools, this.copilotSession.sessionId) : allTools);
         // Collect the final assistant content and all events via on()
         let finalContent;
         const collectedEvents = [];
@@ -2531,6 +2560,19 @@ export class ManagedSession {
                 catch { }
             })
             : null;
+        const nativeTasks = this.config.nativeSubagents === "sync"
+            ? new NativeTaskObserver(this.copilotSession, {
+                turnIndex: opts?.turnIndex,
+                emit: (event) => {
+                    if (event.eventType !== "session.native_tasks_tick")
+                        collectedEvents.push(event);
+                    try {
+                        opts?.onEvent?.(event);
+                    }
+                    catch { }
+                },
+            })
+            : null;
         // Note: we used to emit a synthetic `assistant.streaming_progress`
         // heartbeat into CMS for the activity pane. The user found those
         // rows noisy compared to the actual reasoning snapshots, so the
@@ -2657,6 +2699,30 @@ export class ManagedSession {
                         eventData.durableSessionId = durableSessionId;
                     }
                 }
+                nativeTasks?.observe({ ...event, data: eventData });
+                // This empty ephemeral event only invalidates the CLI task
+                // registry. It is neither activity nor durable history.
+                if (eventType === "session.background_tasks_changed")
+                    return;
+                if (isNativeChildEvent(event)) {
+                    // Child events share the parent subscription. Keep usage
+                    // in the existing accounting stream, but namespace child
+                    // transcript/tools so they cannot settle parent state or
+                    // satisfy a required parent tool invocation.
+                    if (/delta|streaming/.test(eventType))
+                        return;
+                    const nativeEvent = {
+                        eventType: eventType === "assistant.usage" || eventType.startsWith("subagent.")
+                            ? eventType : `native.${eventType}`,
+                        data: { ...eventData, nativeAgentId: event.agentId ?? eventData.nativeAgentId ?? eventData.parentToolCallId },
+                    };
+                    collectedEvents.push(nativeEvent);
+                    try {
+                        opts?.onEvent?.(nativeEvent);
+                    }
+                    catch { }
+                    return;
+                }
                 const captured = { eventType, data: eventData };
                 if (eventType === "session.error" && isBenignPostCompletionQueryError(eventData)) {
                     deferredSessionError = captured;
@@ -2782,6 +2848,8 @@ export class ManagedSession {
                 }
             }));
             unsubscribers.push(this.copilotSession.on("assistant.reasoning", (event) => {
+                if (isNativeChildEvent(event))
+                    return;
                 currentReasoning = String(extractReasoningText(event?.data ?? event) || "").trim();
                 if (currentReasoning) {
                     lastPublishedReasoning = currentReasoning;
@@ -2790,6 +2858,8 @@ export class ManagedSession {
             }));
             for (const eventType of ["assistant.reasoning_delta", "reasoning_delta"]) {
                 unsubscribers.push(this.copilotSession.on(eventType, (event) => {
+                    if (isNativeChildEvent(event))
+                        return;
                     currentReasoning = mergeReasoningText(currentReasoning, extractReasoningText(event?.data ?? event));
                     publishReasoningSnapshot(eventType);
                 }));
@@ -2797,6 +2867,8 @@ export class ManagedSession {
             // Stream deltas to the caller if requested
             if (opts?.onDelta) {
                 unsubscribers.push(this.copilotSession.on("assistant.message_delta", (event) => {
+                    if (isNativeChildEvent(event))
+                        return;
                     if (opts.requiredTool && !hasInvokedTool(collectedEvents, opts.requiredTool))
                         return;
                     if (event.data?.deltaContent) {
@@ -2807,11 +2879,15 @@ export class ManagedSession {
             // Notify caller of tool execution starts
             if (opts?.onToolStart) {
                 unsubscribers.push(this.copilotSession.on("tool.execution_start", (event) => {
+                    if (isNativeChildEvent(event))
+                        return;
                     opts.onToolStart(event.data?.toolName ?? "unknown", event.data?.toolArgs);
                 }));
             }
             // session.idle = turn finished (normal completion or post-abort)
-            unsubscribers.push(this.copilotSession.on("session.idle", () => {
+            unsubscribers.push(this.copilotSession.on("session.idle", (event) => {
+                if (isNativeChildEvent(event))
+                    return;
                 flushStreamingProgress(true);
                 publishReasoningSnapshot("session.idle", true);
                 liveTurn?.finishTurn();
@@ -2862,7 +2938,9 @@ export class ManagedSession {
         // the model's response to a mid-turn correction without tearing down the
         // event subscriptions set up above.
         const waitForNextIdle = () => new Promise((resolve) => {
-            const unsub = this.copilotSession.on("session.idle", () => {
+            const unsub = this.copilotSession.on("session.idle", (event) => {
+                if (isNativeChildEvent(event))
+                    return;
                 flushStreamingProgress(true);
                 publishReasoningSnapshot("session.idle", true);
                 liveTurn?.finishTurn();
@@ -3062,6 +3140,7 @@ export class ManagedSession {
             // live row anyway so reconnecting viewers cannot see stale text.
             liveTurn?.finishTurn();
             liveTurn?.dispose();
+            nativeTasks?.finish(this.stopRequest ? "cancelled" : "interrupted");
             // Always clean up subscriptions
             for (const unsub of unsubscribers)
                 unsub();
@@ -3149,6 +3228,10 @@ export class ManagedSession {
      * Update configuration for the next turn.
      */
     updateConfig(config) {
+        if (config.nativeFeatureAllowed !== undefined)
+            this.config.nativeFeatureAllowed = config.nativeFeatureAllowed;
+        if (config.featureToolFingerprint !== undefined)
+            this.config.featureToolFingerprint = config.featureToolFingerprint;
         if (config.model !== undefined)
             this.config.model = config.model;
         if (Object.prototype.hasOwnProperty.call(config, "reasoningEffort"))
@@ -3183,6 +3266,12 @@ export class ManagedSession {
         const nextProviderFingerprint = config.providerFingerprint !== undefined
             ? config.providerFingerprint ?? null
             : currentProviderFingerprint;
+        if (config.nativeSubagents !== undefined
+            && config.nativeSubagents !== (this.config.nativeSubagents ?? "off"))
+            return true;
+        if (config.featureToolFingerprint !== undefined
+            && config.featureToolFingerprint !== this.config.featureToolFingerprint)
+            return true;
         return Boolean((currentModel || nextModel)
             && (currentModel !== nextModel
                 || currentReasoningEffort !== nextReasoningEffort