@aexol/spectral 0.1.5 → 0.1.8

package/dist/commands/serve.js

@@ -38,7 +38,7 @@ import { fileURLToPath } from "node:url";
 import { getConfigDir } from "../config.js";
 import { requireLogin } from "../preflight.js";
 import { RelayClient } from "../relay/client.js";
-import { detachAllSubscribers, handleClientMessage, handleRestRequest, handleSubscribe, } from "../relay/dispatcher.js";
+import { detachAllSubscribers, handleCancelTurn, handleClientMessage, handleRestRequest, handleSubscribe, } from "../relay/dispatcher.js";
 import { ensureMachineRegistered } from "../relay/registration.js";
 import { SessionStreamManager } from "../server/session-stream.js";
 import { gracefulShutdown } from "../server/shutdown.js";
@@ -252,6 +252,10 @@ export async function runServe(opts = {}) {
             });
             return;
         }
+        if (frame.kind === "cancel_turn") {
+            handleCancelTurn(frame, { manager });
+            return;
+        }
         // Other frames (error, machine_disconnected addressed to us, etc.)
         // are ignored at this layer. Future batches may surface them in
         // structured logs.

package/dist/relay/dispatcher.js

@@ -466,10 +466,9 @@ export function handleClientMessage(frame, deps) {
     //    against the team-scoped whitelist; the CLI resolves it via pi's
     //    own model registry inside the manager → bridge.
     //
-    //    When `loop: true` is set on the message, route to the spectral-loop
-    //    user model instead of the default session model.
-    const effectiveModelId = isLoop ? "__spectral_loop__" : modelId;
-    manager.prompt(sessionId, content, effectiveModelId, validImages).catch((err) => {
+    //    When `loop: true`, loop state is set before prompting; the normal
+    //    model is used — loop replay is handled by session-stream on agent_end.
+    manager.prompt(sessionId, content, modelId, validImages).catch((err) => {
         logger.error?.(`[dispatcher] manager.prompt failed for ${sessionId}:`, err);
     });
 }
@@ -533,6 +532,16 @@ export function handleSubscribe(frame, deps) {
         });
     }
 }
+/**
+ * Dispatch a `cancel_turn` frame. Disposes the session's pi bridge and
+ * removes the stream so the next user message creates a fresh one. The
+ * bridge dispose triggers `agent_end` broadcast to all subscribers.
+ *
+ * Idempotent: no-ops when no stream exists for the session.
+ */
+export function handleCancelTurn(frame, deps) {
+    deps.manager.cancelTurn(frame.sessionId);
+}
 /**
  * Detach every subscriber the dispatcher has attached. Called by
  * `serve.ts` on relay disconnect / shutdown so the underlying pi

package/dist/server/pi-bridge.js

@@ -70,7 +70,6 @@ import { fetchAllowedModels as defaultFetchAllowedModels, } from "../relay/model
 const SPECTRAL_PROXY_ANTHROPIC = "spectral-proxy-anthropic";
 const SPECTRAL_PROXY_OPENAI = "spectral-proxy-openai";
 const SPECTRAL_PROXY_USER_MODEL = "spectral-proxy-user-model";
-const SPECTRAL_PROXY_LOOP = "spectral-proxy-loop";
 /**
  * Concatenate text from an `AssistantMessage.content` array. Returns the
  * empty string when no text blocks are present (tool-only turns) or when
@@ -388,30 +387,6 @@ export class PiBridge {
                 })),
             });
         }
-        // Loop model — dedicated endpoint for Spectral agent loop toggle.
-        // Routes to /models/built-in/loop/v1 using machine JWT auth.
-        {
-            const loopBaseUrl = `${this.opts.backendUrl.replace(/\/$/, "")}/models/built-in/loop/v1`;
-            this.modelRegistry.registerProvider(SPECTRAL_PROXY_LOOP, {
-                baseUrl: loopBaseUrl,
-                apiKey: this.opts.machineJwt,
-                authHeader: true,
-                api: "openai-completions",
-                models: [
-                    {
-                        id: "__spectral_loop__",
-                        name: "Spectral Loop",
-                        api: "openai-completions",
-                        baseUrl: loopBaseUrl,
-                        reasoning: false,
-                        input: ["text", "image"],
-                        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-                        contextWindow: 0,
-                        maxTokens: 0,
-                    },
-                ],
-            });
-        }
     }
     /**
      * Apply a sticky model selection to the underlying pi session, if it

package/dist/server/session-stream.js

@@ -147,9 +147,52 @@ export class SessionStreamManager {
     async prompt(sessionId, content, modelId, images) {
         if (this.disposed)
             throw new Error("SessionStreamManager disposed");
-        const stream = this.streams.get(sessionId);
+        let stream = this.streams.get(sessionId);
         if (!stream)
             throw new Error(`No active stream for session: ${sessionId}`);
+        // If the bridge was disposed (e.g. by cancelTurn), recreate it before
+        // proceeding. We rebuild only the bridge inside the existing stream so
+        // subscribers, cwd, and other metadata are preserved.
+        if (stream.startError) {
+            const history = this.store.getSession(sessionId)?.messages;
+            const bridgeOpts = {
+                cwd: stream.cwd,
+                agentDir: this.agentDir,
+                backendUrl: this.backendUrl,
+                machineJwt: this.machineJwt,
+                history,
+                emit: (event) => this.handleBridgeEvent(stream, event),
+                onAssistantMessageComplete: ({ messageId, content, eventsJsonl }) => {
+                    try {
+                        this.store.appendMessage(sessionId, {
+                            id: messageId,
+                            role: "assistant",
+                            content,
+                            eventsJsonl,
+                        });
+                    }
+                    catch (err) {
+                        console.error(`[spectral] error: failed to persist assistant message: ${err instanceof Error ? err.message : String(err)}`);
+                    }
+                },
+                onError: (err) => {
+                    console.error(`[spectral] error: pi bridge error: ${err.message}`);
+                },
+            };
+            stream.bridge = this.bridgeFactory(bridgeOpts);
+            stream.startError = null;
+            stream.ready = stream.bridge
+                .start()
+                .catch((err) => {
+                const e = err instanceof Error ? err : new Error(String(err));
+                stream.startError = e;
+                this.broadcast(stream, {
+                    type: "error",
+                    message: `Failed to start agent: ${e.message}`,
+                });
+                throw e;
+            });
+        }
         // Wait for pi to be ready before we persist + invoke. If start failed,
         // surface to all subscribers instead of throwing into the route handler.
         try {
@@ -272,6 +315,49 @@ export class SessionStreamManager {
         }
         return n;
     }
+    /**
+     * Cancel the in-flight turn for a session (user pressed Stop in the UI).
+     * Disposes the pi bridge and broadcasts `agent_end` so all subscribers
+     * see the turn close. The stream itself is kept alive — the next user
+     * message (via `prompt()`) will lazily create a fresh bridge.
+     *
+     * Idempotent: if no stream exists for the session, or no turn is in
+     * flight, this is a no-op.
+     */
+    cancelTurn(sessionId) {
+        const stream = this.streams.get(sessionId);
+        if (!stream)
+            return;
+        // Stop any active loop before disposing — if the loop was mid-iteration
+        // the next agent_end would otherwise trigger another prompt.
+        stream.loopActive = false;
+        stream.loopOriginalPrompt = null;
+        stream.loopIterationCount = 0;
+        // Dispose the pi bridge immediately — this tears down pi's session and
+        // unsubscribe. The bridge's own event handler is detached; no further
+        // events will flow. We broadcast agent_end ourselves below.
+        try {
+            stream.bridge.dispose();
+        }
+        catch {
+            // ignore
+        }
+        // Set startError so any late `await stream.ready` in the loop path
+        // (if the loop was between iterations when we disposed) rejects cleanly
+        // instead of hanging. Also prevents the next prompt() from waiting on
+        // a dead bridge's ready promise.
+        stream.startError = new Error("Turn cancelled");
+        // Broadcast agent_end so all subscribers close their open turn and
+        // re-enable their composers.
+        if (stream.currentTurn) {
+            this.broadcast(stream, { type: "agent_end" });
+            stream.currentTurn = null;
+        }
+        // Don't delete the stream — the subscribers are still attached and the
+        // next `prompt()` call will create a fresh bridge via `createStream()`.
+        // We just need to signal that the bridge is gone so `prompt()` knows to
+        // recreate one.
+    }
     /**
      * Tear down a single session's stream — disposes the pi bridge and clears
      * subscribers. Idempotent. Called by the routes layer right before

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aexol/spectral",
-  "version": "0.1.5",
+  "version": "0.1.8",
   "description": "Always-on coding agent for Aexol — branded pi wrapper with relay-based browser access.",
   "type": "module",
   "private": false,