ruflo 3.6.27 → 3.6.28

package/src/ruvocal/src/lib/components/chat/ChatWindow.svelte

@@ -338,9 +338,9 @@
 	let isFileUploadEnabled = $derived(activeMimeTypes.length > 0);
 	let focused = $state(false);
 
-	let activeRouterExamplePrompt = $state<string | null>(null);
+	let activeRouterExamplePrompt: string | null = $state(null);
 	// Use MCP examples when all base servers are enabled, otherwise use router examples
-	let activeExamples = $derived<RouterExample[]>(
+	let activeExamples: RouterExample[] = $derived(
 		$allBaseServersEnabled ? mcpExamples : routerExamples
 	);
 
@@ -431,7 +431,7 @@
 	}
 
 	// Pull tool names from the latest assistant message.
-	let lastAssistantToolNames = $derived<string[]>(() => {
+	let lastAssistantToolNames: string[] = $derived((() => {
 		for (let i = messages.length - 1; i >= 0; i--) {
 			const msg = messages[i];
 			if (msg.from !== "assistant") continue;
@@ -445,13 +445,13 @@
 			return names;
 		}
 		return [];
-	}());
+	})());
 
-	let dynamicFollowUps = $derived<RouterFollowUp[]>(
+	let dynamicFollowUps: RouterFollowUp[] = $derived(
 		dedupePrompts(lastAssistantToolNames.flatMap(followUpsForTool), 4)
 	);
 
-	let routerFollowUps = $derived<RouterFollowUp[]>(
+	let routerFollowUps: RouterFollowUp[] = $derived(
 		activeRouterExamplePrompt
 			? (activeExamples.find((ex) => ex.prompt === activeRouterExamplePrompt)?.followUps ?? [])
 			: []
@@ -459,7 +459,7 @@
 
 	// Combined: prefer static example follow-ups (curated by us); fall back to
 	// dynamic tool-derived follow-ups generated from the last assistant turn.
-	let effectiveFollowUps = $derived<RouterFollowUp[]>(
+	let effectiveFollowUps: RouterFollowUp[] = $derived(
 		routerFollowUps.length > 0 ? routerFollowUps : dynamicFollowUps
 	);
 
@@ -822,7 +822,7 @@
 									aria-label="Toggle autopilot mode"
 								>
 									<IconZap class="size-3.5" />
-									<span>{$settings.autopilotEnabled ? 'AUTO' : 'AUTO'}</span>
+									<span>{$settings.autopilotEnabled ? 'AUTO' : 'MANUAL'}</span>
 								</button>
 							{/if}
 							{#if transcriptionEnabled}

package/src/ruvocal/src/lib/server/mcp/clientPool.spec.ts

@@ -0,0 +1,175 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { StreamableHTTPError } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+
+// We mock the MCP SDK transports + Client so we can drive the connection
+// outcomes deterministically. The point of these tests is to verify that
+// clientPool.ts:
+//   1. Skips the SSE fallback when the first transport returns 4xx/5xx (e.g. 429)
+//      because retrying via SSE will hit the same upstream and produce the
+//      same rate-limit response.
+//   2. Surfaces a typed McpRateLimitedError on 429 with retryAfterMs derived
+//      from the upstream Retry-After header when present.
+//   3. Memoizes the failure for a cooldown window so subsequent getClient
+//      calls don't pound the upstream.
+//   4. Still falls back to SSE for transport-level / network errors that
+//      have no HTTP status (the "Streamable HTTP server is not running" path).
+
+const httpConnectMock = vi.fn();
+const sseConnectMock = vi.fn();
+
+vi.mock("@modelcontextprotocol/sdk/client", () => {
+	class MockClient {
+		private nextTransportIsHttp = true;
+		async connect(transport: unknown) {
+			// The transport instances are tagged below in the streamableHttp/sse mocks.
+			const isHttp = (transport as { __kind?: string }).__kind === "http";
+			if (isHttp) {
+				return httpConnectMock();
+			}
+			return sseConnectMock();
+		}
+		async close() {}
+		async callTool() {
+			return { content: [] };
+		}
+	}
+	return { Client: MockClient };
+});
+
+vi.mock("@modelcontextprotocol/sdk/client/streamableHttp.js", () => {
+	class StreamableHTTPError extends Error {
+		code: number;
+		constructor(code: number, message: string) {
+			super(`Streamable HTTP error: ${message}`);
+			this.code = code;
+			this.name = "StreamableHTTPError";
+		}
+	}
+	class StreamableHTTPClientTransport {
+		__kind = "http";
+		constructor(_url: URL, _opts: unknown) {}
+	}
+	return { StreamableHTTPError, StreamableHTTPClientTransport };
+});
+
+vi.mock("@modelcontextprotocol/sdk/client/sse.js", () => {
+	class SSEClientTransport {
+		__kind = "sse";
+		constructor(_url: URL, _opts: unknown) {}
+	}
+	return { SSEClientTransport };
+});
+
+// Import AFTER vi.mock declarations.
+import { getClient, drainPool, McpRateLimitedError } from "./clientPool";
+
+const server = { name: "test-server", url: "https://example.test/mcp", headers: {} };
+
+describe("clientPool — rate-limit and HTTP error handling", () => {
+	beforeEach(async () => {
+		await drainPool();
+		httpConnectMock.mockReset();
+		sseConnectMock.mockReset();
+	});
+
+	afterEach(async () => {
+		await drainPool();
+	});
+
+	it("skips SSE fallback on 429 and throws McpRateLimitedError", async () => {
+		httpConnectMock.mockRejectedValue(
+			new StreamableHTTPError(
+				429,
+				"Error POSTing to endpoint: Rate exceeded. Retry-After: 7"
+			)
+		);
+
+		await expect(getClient(server)).rejects.toBeInstanceOf(McpRateLimitedError);
+		// Critical: SSE was NOT attempted — would just hit the same upstream.
+		expect(sseConnectMock).not.toHaveBeenCalled();
+		expect(httpConnectMock).toHaveBeenCalledTimes(1);
+	});
+
+	it("honors Retry-After when present in the error message", async () => {
+		httpConnectMock.mockRejectedValue(
+			new StreamableHTTPError(
+				429,
+				"Error POSTing to endpoint: Rate exceeded. Retry-After: 12"
+			)
+		);
+
+		try {
+			await getClient(server);
+			throw new Error("should have thrown");
+		} catch (err) {
+			expect(err).toBeInstanceOf(McpRateLimitedError);
+			expect((err as McpRateLimitedError).retryAfterMs).toBe(12_000);
+			expect((err as McpRateLimitedError).status).toBe(429);
+			expect((err as McpRateLimitedError).serverName).toBe("test-server");
+		}
+	});
+
+	it("memoizes the 429 failure and skips network on subsequent calls during cooldown", async () => {
+		httpConnectMock.mockRejectedValue(
+			new StreamableHTTPError(429, "Error POSTing to endpoint: Rate exceeded. Retry-After: 5")
+		);
+
+		await expect(getClient(server)).rejects.toBeInstanceOf(McpRateLimitedError);
+		// Second call within the cooldown window: must NOT touch the upstream again.
+		await expect(getClient(server)).rejects.toBeInstanceOf(McpRateLimitedError);
+		expect(httpConnectMock).toHaveBeenCalledTimes(1);
+		expect(sseConnectMock).not.toHaveBeenCalled();
+	});
+
+	it("skips SSE fallback on 4xx (e.g. 401)", async () => {
+		httpConnectMock.mockRejectedValue(
+			new StreamableHTTPError(401, "Unauthorized")
+		);
+		await expect(getClient(server)).rejects.toThrow(/HTTP 401/);
+		expect(sseConnectMock).not.toHaveBeenCalled();
+	});
+
+	it("skips SSE fallback on 5xx (e.g. 503)", async () => {
+		httpConnectMock.mockRejectedValue(
+			new StreamableHTTPError(503, "Service Unavailable")
+		);
+		await expect(getClient(server)).rejects.toThrow(/HTTP 503/);
+		expect(sseConnectMock).not.toHaveBeenCalled();
+	});
+
+	it("falls back to SSE on transport-level / network errors with no HTTP status", async () => {
+		httpConnectMock.mockRejectedValue(new Error("ECONNREFUSED"));
+		sseConnectMock.mockResolvedValue(undefined);
+
+		const client = await getClient(server);
+		expect(client).toBeDefined();
+		expect(httpConnectMock).toHaveBeenCalledTimes(1);
+		expect(sseConnectMock).toHaveBeenCalledTimes(1);
+	});
+
+	it("falls back to SSE on 408 Request Timeout (recoverable)", async () => {
+		httpConnectMock.mockRejectedValue(
+			new StreamableHTTPError(408, "Request Timeout")
+		);
+		sseConnectMock.mockResolvedValue(undefined);
+
+		const client = await getClient(server);
+		expect(client).toBeDefined();
+		expect(sseConnectMock).toHaveBeenCalledTimes(1);
+	});
+
+	it("surfaces 429 even when the SSE fallback also reports 429", async () => {
+		httpConnectMock.mockRejectedValue(new Error("transport mismatch")); // forces SSE attempt
+		sseConnectMock.mockRejectedValue(
+			new Error("SSE error: Non-200 status code (429)")
+		);
+
+		try {
+			await getClient(server);
+			throw new Error("should have thrown");
+		} catch (err) {
+			expect(err).toBeInstanceOf(McpRateLimitedError);
+			expect((err as McpRateLimitedError).status).toBe(429);
+		}
+	});
+});

package/src/ruvocal/src/lib/server/textGeneration/index.ts

@@ -65,6 +65,7 @@ async function* textGenerationWithoutTitle(
 			abortController: ctx.abortController,
 			promptedAt: ctx.promptedAt,
 			autopilot: ctx.autopilot,
+			autopilotMaxSteps: ctx.autopilotMaxSteps,
 		});
 
 		let step = await mcpGen.next();

package/src/ruvocal/src/lib/server/textGeneration/mcp/runMcpFlow.ts

@@ -51,12 +51,14 @@ export async function* runMcpFlow({
 	abortController,
 	promptedAt,
 	autopilot,
+	autopilotMaxSteps,
 }: RunMcpFlowContext & {
 	preprompt?: string;
 	abortSignal?: AbortSignal;
 	abortController?: AbortController;
 	promptedAt?: Date;
 	autopilot?: boolean;
+	autopilotMaxSteps?: number;
 }): AsyncGenerator<MessageUpdate, McpFlowResult, undefined> {
 	// Helper to check if generation should be aborted via DB polling
 	// Also triggers the abort controller to cancel active streams/requests
@@ -460,7 +462,14 @@ export async function* runMcpFlow({
 			);
 		}
 
-		const maxLoops = autopilot ? 30 : 10;
+		// Autopilot loop cap is user-configurable (Settings.autopilotMaxSteps);
+		// fall back to 30 for back-compat when the client doesn't send a value.
+		// Non-autopilot mode keeps a tight 10-loop safety net regardless of caller input.
+		const autopilotCap =
+			typeof autopilotMaxSteps === "number" && autopilotMaxSteps > 0
+				? Math.min(autopilotMaxSteps, 100)
+				: 30;
+		const maxLoops = autopilot ? autopilotCap : 10;
 		for (let loop = 0; loop < maxLoops; loop += 1) {
 			// Check for abort at the start of each loop iteration
 			if (checkAborted()) {

package/src/ruvocal/src/lib/server/textGeneration/types.ts

@@ -21,6 +21,8 @@ export interface TextGenerationContext {
 	provider?: string;
 	locals: App.Locals | undefined;
 	abortController: AbortController;
-	/** Autopilot mode — auto-continue tool calls up to 30 iterations */
+	/** Autopilot mode — auto-continue tool calls up to autopilotMaxSteps iterations */
 	autopilot?: boolean;
+	/** User-configurable cap on autopilot tool-call loops; server falls back to 30 if undefined */
+	autopilotMaxSteps?: number;
 }

package/src/ruvocal/src/routes/api/v2/user/settings/+server.ts

@@ -23,6 +23,12 @@ const settingsSchema = z.object({
 	hapticsEnabled: z.boolean().default(true),
 	hidePromptExamples: z.record(z.boolean()).default({}),
 	autopilotEnabled: z.boolean().default(true),
+	autopilotMaxSteps: z
+		.number()
+		.int()
+		.min(1)
+		.max(100)
+		.default(DEFAULT_SETTINGS.autopilotMaxSteps),
 	billingOrganization: z.string().optional(),
 });
 
@@ -68,6 +74,7 @@ export const GET: RequestHandler = async ({ locals }) => {
 		toolsOverrides: settings?.toolsOverrides ?? {},
 		providerOverrides: settings?.providerOverrides ?? {},
 		autopilotEnabled: settings?.autopilotEnabled ?? DEFAULT_SETTINGS.autopilotEnabled,
+		autopilotMaxSteps: settings?.autopilotMaxSteps ?? DEFAULT_SETTINGS.autopilotMaxSteps,
 		billingOrganization: settings?.billingOrganization ?? undefined,
 	});
 };

package/src/ruvocal/src/routes/conversation/[id]/+page.svelte

@@ -233,6 +233,10 @@
 					})),
 					streamingMode,
 					autopilot: $settings.autopilotEnabled === true,
+					autopilotMaxSteps:
+						typeof $settings.autopilotMaxSteps === "number"
+							? $settings.autopilotMaxSteps
+							: undefined,
 				},
 				messageUpdatesAbortController.signal
 			).catch((err) => {

package/src/ruvocal/src/routes/conversation/[id]/+server.ts

@@ -130,6 +130,7 @@ export async function POST({ request, locals, params, getClientAddress }) {
 		selectedMcpServerNames,
 		selectedMcpServers,
 		autopilot,
+		autopilotMaxSteps,
 	} = z
 		.object({
 			id: z.string().uuid().refine(isMessageId).optional(), // parent message id to append to for a normal message, or the message id for a retry/continue
@@ -141,6 +142,8 @@ export async function POST({ request, locals, params, getClientAddress }) {
 			),
 			is_retry: z.optional(z.boolean()),
 			autopilot: z.optional(z.boolean()),
+			// User-configurable cap on autopilot tool-call loops. Server clamps to [1, 100].
+			autopilotMaxSteps: z.optional(z.number().int().min(1).max(100)),
 			selectedMcpServerNames: z.optional(z.array(z.string())),
 			selectedMcpServers: z
 				.optional(
@@ -575,6 +578,7 @@ export async function POST({ request, locals, params, getClientAddress }) {
 					locals,
 					abortController: ctrl,
 					autopilot: autopilot === true,
+					autopilotMaxSteps,
 				};
 				// run the text generation and send updates to the client
 				for await (const event of textGeneration(ctx)) await update(event);

package/src/ruvocal/src/routes/settings/(nav)/+server.ts

@@ -19,6 +19,12 @@ const settingsSchema = z.object({
 	hapticsEnabled: z.boolean().default(true),
 	hidePromptExamples: z.record(z.boolean()).default({}),
 	autopilotEnabled: z.boolean().default(true),
+	autopilotMaxSteps: z
+		.number()
+		.int()
+		.min(1)
+		.max(100)
+		.default(DEFAULT_SETTINGS.autopilotMaxSteps),
 	billingOrganization: z.string().optional(),
 });