root/fusion
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(FN-1191): hot-swap active executor sessions on model changes

Browse Source 
- Show resolved default executor, validator, and planning models in the task Model tab
- Pass merged settings into the Model tab from TaskDetailModal so default badges reflect effective runtime resolution
- Hot-swap active single-session executor models when task overrides change, including fallback to project defaults when overrides are cleared
- Add dashboard and executor tests for default model display, hot-swap behavior, fallback logic, and failure logging
- Document hot-swap behavior and limitations in AGENTS.md and add a patch changeset for @gsxdsm/fusion
This commit is contained in:
gsxdsm
2026-04-08 01:18:01 -07:00
parent bd601959b6
commit d30419d70b
7 changed files with 428 additions and 10 deletions
Download Patch File Download Diff File Expand all files Collapse all files

65
packages/dashboard/app/components/ModelSelectorTab.tsx
View File

@@ -1,7 +1,7 @@
import { useState, useEffect, useCallback, useMemo, useRef } from "react";
import { fetchModels, updateTask, updateGlobalSettings } from "../api";
import type { ModelInfo } from "../api";
import type { Task, TaskDetail } from "@fusion/core";
import type { Settings, Task, TaskDetail } from "@fusion/core";
import type { ToastType } from "../hooks/useToast";
import { CustomModelDropdown } from "./CustomModelDropdown";
import { ProviderIcon } from "./ProviderIcon";
@@ -10,6 +10,7 @@ interface ModelSelectorTabProps {
task: Task | TaskDetail;
addToast: (message: string, type?: ToastType) => void;
onTaskUpdated?: (task: Task) => void;
settings?: Settings;
}
interface ModelSelection {
@@ -42,6 +43,51 @@ function getPlanningSelection(task: Task | TaskDetail): ModelSelection {
};
}
function resolveEffectiveExecutor(
task: Task | TaskDetail,
settings?: Settings,
): ModelSelection {
if (task.modelProvider && task.modelId) {
return { provider: task.modelProvider, modelId: task.modelId };
}
if (settings?.defaultProvider && settings.defaultModelId) {
return { provider: settings.defaultProvider, modelId: settings.defaultModelId };
}
return {};
}
function resolveEffectiveValidator(
task: Task | TaskDetail,
settings?: Settings,
): ModelSelection {
if (task.validatorModelProvider && task.validatorModelId) {
return { provider: task.validatorModelProvider, modelId: task.validatorModelId };
}
if (settings?.validatorProvider && settings.validatorModelId) {
return { provider: settings.validatorProvider, modelId: settings.validatorModelId };
}
if (settings?.defaultProvider && settings.defaultModelId) {
return { provider: settings.defaultProvider, modelId: settings.defaultModelId };
}
return {};
}
function resolveEffectivePlanning(
task: Task | TaskDetail,
settings?: Settings,
): ModelSelection {
if (task.planningModelProvider && task.planningModelId) {
return { provider: task.planningModelProvider, modelId: task.planningModelId };
}
if (settings?.planningProvider && settings.planningModelId) {
return { provider: settings.planningProvider, modelId: settings.planningModelId };
}
if (settings?.defaultProvider && settings.defaultModelId) {
return { provider: settings.defaultProvider, modelId: settings.defaultModelId };
}
return {};
}
function parseModelValue(value: string): ModelSelection {
if (!value) {
return { provider: undefined, modelId: undefined };
@@ -79,7 +125,7 @@ function getSuccessToastMessage(target: "executor" | "validator" | "planning", s
return `${label} model set to ${selection.provider}/${selection.modelId}`;
}
export function ModelSelectorTab({ task, addToast, onTaskUpdated }: ModelSelectorTabProps) {
export function ModelSelectorTab({ task, addToast, onTaskUpdated, settings }: ModelSelectorTabProps) {
const [availableModels, setAvailableModels] = useState<ModelInfo[]>([]);
const [favoriteProviders, setFavoriteProviders] = useState<string[]>([]);
const [favoriteModels, setFavoriteModels] = useState<string[]>([]);
@@ -176,6 +222,9 @@ export function ModelSelectorTab({ task, addToast, onTaskUpdated }: ModelSelecto
const executorValue = useMemo(() => getDropdownValue(selectedExecutor), [selectedExecutor]);
const validatorValue = useMemo(() => getDropdownValue(selectedValidator), [selectedValidator]);
const planningValue = useMemo(() => getDropdownValue(selectedPlanning), [selectedPlanning]);
const effectiveExecutor = useMemo(() => resolveEffectiveExecutor(task, settings), [task, settings]);
const effectiveValidator = useMemo(() => resolveEffectiveValidator(task, settings), [task, settings]);
const effectivePlanning = useMemo(() => resolveEffectivePlanning(task, settings), [task, settings]);
const isSaving = savingTarget !== null;
const saveSelection = useCallback(
@@ -389,7 +438,9 @@ export function ModelSelectorTab({ task, addToast, onTaskUpdated }: ModelSelecto
<label htmlFor="executorModel">Executor Model</label>
<div className="model-selector-current">
{executorUsingDefault ? (
<span className="model-badge model-badge-default">Using default</span>
<span className="model-badge model-badge-default">
Using default{effectiveExecutor.provider && effectiveExecutor.modelId ? ` (${effectiveExecutor.provider}/${effectiveExecutor.modelId})` : ""}
</span>
) : (
<span className="model-badge model-badge-custom">
{savedExecutor.provider && <ProviderIcon provider={savedExecutor.provider} size="sm" />}
@@ -417,7 +468,9 @@ export function ModelSelectorTab({ task, addToast, onTaskUpdated }: ModelSelecto
<label htmlFor="validatorModel">Validator Model</label>
<div className="model-selector-current">
{validatorUsingDefault ? (
<span className="model-badge model-badge-default">Using default</span>
<span className="model-badge model-badge-default">
Using default{effectiveValidator.provider && effectiveValidator.modelId ? ` (${effectiveValidator.provider}/${effectiveValidator.modelId})` : ""}
</span>
) : (
<span className="model-badge model-badge-custom">
{savedValidator.provider && <ProviderIcon provider={savedValidator.provider} size="sm" />}
@@ -445,7 +498,9 @@ export function ModelSelectorTab({ task, addToast, onTaskUpdated }: ModelSelecto
<label htmlFor="planningModel">Planning Model</label>
<div className="model-selector-current">
{planningUsingDefault ? (
<span className="model-badge model-badge-default">Using default</span>
<span className="model-badge model-badge-default">
Using default{effectivePlanning.provider && effectivePlanning.modelId ? ` (${effectivePlanning.provider}/${effectivePlanning.modelId})` : ""}
</span>
) : (
<span className="model-badge model-badge-custom">
{savedPlanning.provider && <ProviderIcon provider={savedPlanning.provider} size="sm" />}

2
packages/dashboard/app/components/TaskDetailModal.tsx
View File

@@ -929,7 +929,7 @@ export function TaskDetailModal({
</div>
) : activeTab === "model" ? (
<div className="detail-section">
<ModelSelectorTab task={task} addToast={addToast} onTaskUpdated={onTaskUpdated} />
<ModelSelectorTab task={task} addToast={addToast} onTaskUpdated={onTaskUpdated} settings={settings} />
</div>
) : activeTab === "logs" ? (
<div className={`detail-section${logSubview === "agent-log" ? " detail-section--agent-log" : ""}`}>

102
packages/dashboard/app/components/__tests__/ModelSelectorTab.test.tsx
View File

@@ -142,6 +142,108 @@ describe("ModelSelectorTab", () => {
expect(within(planningSection!).getByText("Using default")).toBeInTheDocument();
});
it("shows resolved default model in badge when settings are provided", async () => {
render(
<ModelSelectorTab
task={FAKE_TASK}
addToast={mockAddToast}
settings={{
defaultProvider: "anthropic",
defaultModelId: "claude-sonnet-4-5",
}}
/>,
);
await waitForSelectors();
const executorSection = getSection("Executor Model");
expect(within(executorSection!).getByText("Using default (anthropic/claude-sonnet-4-5)")).toBeInTheDocument();
});
it("shows 'Using default' without resolution when settings prop is undefined", async () => {
render(<ModelSelectorTab task={FAKE_TASK} addToast={mockAddToast} />);
await waitForSelectors();
const executorSection = getSection("Executor Model");
expect(within(executorSection!).getByText("Using default")).toBeInTheDocument();
expect(within(executorSection!).queryByText(/Using default \(.+\)/)).not.toBeInTheDocument();
});
it("shows validator resolved model using validator settings then default fallback", async () => {
render(
<ModelSelectorTab
task={FAKE_TASK}
addToast={mockAddToast}
settings={{
validatorProvider: "openai",
validatorModelId: "gpt-4o",
defaultProvider: "anthropic",
defaultModelId: "claude-sonnet-4-5",
}}
/>,
);
await waitForSelectors();
const validatorSection = getSection("Validator Model");
expect(within(validatorSection!).getByText("Using default (openai/gpt-4o)")).toBeInTheDocument();
});
it("shows planning resolved model using planning settings then default fallback", async () => {
render(
<ModelSelectorTab
task={FAKE_TASK}
addToast={mockAddToast}
settings={{
planningProvider: "google",
planningModelId: "gemini-2.5-pro",
defaultProvider: "anthropic",
defaultModelId: "claude-sonnet-4-5",
}}
/>,
);
await waitForSelectors();
const planningSection = getSection("Planning Model");
expect(within(planningSection!).getByText("Using default (google/gemini-2.5-pro)")).toBeInTheDocument();
});
it("updates resolved model when settings change", async () => {
const { rerender } = render(
<ModelSelectorTab
task={FAKE_TASK}
addToast={mockAddToast}
settings={{
defaultProvider: "anthropic",
defaultModelId: "claude-sonnet-4-5",
}}
/>,
);
await waitForSelectors();
const executorSection = getSection("Executor Model");
expect(within(executorSection!).getByText("Using default (anthropic/claude-sonnet-4-5)")).toBeInTheDocument();
rerender(
<ModelSelectorTab
task={FAKE_TASK}
addToast={mockAddToast}
settings={{
defaultProvider: "openai",
defaultModelId: "gpt-4o",
}}
/>,
);
await waitFor(() => {
const nextExecutorSection = getSection("Executor Model");
expect(within(nextExecutorSection!).getByText("Using default (openai/gpt-4o)")).toBeInTheDocument();
});
});
it("shows current custom model when overrides are set", async () => {
const taskWithModels = {
...FAKE_TASK,

198
packages/engine/src/executor.test.ts
View File

@@ -88,6 +88,14 @@ vi.mock("@mariozechner/pi-coding-agent", () => {
open: vi.fn().mockReturnValue(mockSessionManager),
inMemory: vi.fn().mockReturnValue(mockSessionManager),
},
ModelRegistry: vi.fn().mockImplementation(() => ({
find: vi.fn(),
refresh: vi.fn(),
})),
AuthStorage: {
create: vi.fn().mockReturnValue({}),
},
getAgentDir: vi.fn().mockReturnValue("/tmp/agent-dir"),
};
});
@@ -2812,6 +2820,196 @@ describe("TaskExecutor pause behavior", () => {
});
});
describe("TaskExecutor executor model hot-swap", () => {
const buildUpdatedTask = (overrides: Partial<Task> = {}): Task => ({
id: "FN-001",
title: "Model task",
description: "Test model updates",
column: "in-progress",
paused: false,
dependencies: [],
steps: [],
currentStep: 0,
log: [],
createdAt: new Date().toISOString(),
updatedAt: new Date().toISOString(),
...overrides,
});
const flushTaskUpdated = async () => {
await new Promise((resolve) => setTimeout(resolve, 20));
};
beforeEach(() => {
vi.clearAllMocks();
});
it("hot-swaps executor model on active session when modelProvider/modelId change", async () => {
const store = createMockStore();
const setModel = vi.fn().mockResolvedValue(undefined);
const findModel = vi.fn().mockReturnValue({
provider: { name: "openai" },
id: "gpt-4o",
name: "GPT-4o",
});
const executor = new TaskExecutor(store, "/tmp/test");
(executor as any)._modelRegistry = { find: findModel };
(executor as any).activeSessions.set("FN-001", {
session: { setModel, dispose: vi.fn() },
seenSteeringIds: new Set(),
lastModelProvider: "anthropic",
lastModelId: "claude-sonnet-4-5",
});
store._trigger("task:updated", buildUpdatedTask({
modelProvider: "openai",
modelId: "gpt-4o",
}));
await flushTaskUpdated();
expect(setModel).toHaveBeenCalledTimes(1);
expect(setModel).toHaveBeenCalledWith(expect.objectContaining({
provider: expect.objectContaining({ name: "openai" }),
id: "gpt-4o",
}));
expect(store.logEntry).toHaveBeenCalledWith("FN-001", "Model changed to openai/gpt-4o");
});
it("does not attempt hot-swap when no active session exists", async () => {
const store = createMockStore();
const setModel = vi.fn().mockResolvedValue(undefined);
new TaskExecutor(store, "/tmp/test");
store._trigger("task:updated", buildUpdatedTask({
modelProvider: "openai",
modelId: "gpt-4o",
}));
await flushTaskUpdated();
expect(setModel).not.toHaveBeenCalled();
});
it("does not hot-swap when model fields are unchanged", async () => {
const store = createMockStore();
const setModel = vi.fn().mockResolvedValue(undefined);
const findModel = vi.fn();
const executor = new TaskExecutor(store, "/tmp/test");
(executor as any)._modelRegistry = { find: findModel };
(executor as any).activeSessions.set("FN-001", {
session: { setModel, dispose: vi.fn() },
seenSteeringIds: new Set(),
lastModelProvider: "anthropic",
lastModelId: "claude-sonnet-4-5",
});
store._trigger("task:updated", buildUpdatedTask({
modelProvider: "anthropic",
modelId: "claude-sonnet-4-5",
}));
await flushTaskUpdated();
expect(findModel).not.toHaveBeenCalled();
expect(setModel).not.toHaveBeenCalled();
});
it("hot-swaps to settings default when override is cleared", async () => {
const store = createMockStore();
const setModel = vi.fn().mockResolvedValue(undefined);
const findModel = vi.fn().mockReturnValue({
provider: { name: "openai" },
id: "gpt-4o",
name: "GPT-4o",
});
store.getSettings.mockResolvedValue({
defaultProvider: "openai",
defaultModelId: "gpt-4o",
});
const executor = new TaskExecutor(store, "/tmp/test");
(executor as any)._modelRegistry = { find: findModel };
(executor as any).activeSessions.set("FN-001", {
session: { setModel, dispose: vi.fn() },
seenSteeringIds: new Set(),
lastModelProvider: "anthropic",
lastModelId: "claude-sonnet-4-5",
});
store._trigger("task:updated", buildUpdatedTask({
modelProvider: undefined,
modelId: undefined,
}));
await flushTaskUpdated();
expect(findModel).toHaveBeenCalledWith("openai", "gpt-4o");
expect(setModel).toHaveBeenCalledTimes(1);
});
it("logs error and continues when setModel fails", async () => {
const store = createMockStore();
const setModel = vi.fn().mockRejectedValue(new Error("API key not found"));
const findModel = vi.fn().mockReturnValue({
provider: { name: "openai" },
id: "gpt-4o",
name: "GPT-4o",
});
const executor = new TaskExecutor(store, "/tmp/test");
(executor as any)._modelRegistry = { find: findModel };
(executor as any).activeSessions.set("FN-001", {
session: { setModel, dispose: vi.fn() },
seenSteeringIds: new Set(),
lastModelProvider: "anthropic",
lastModelId: "claude-sonnet-4-5",
});
store._trigger("task:updated", buildUpdatedTask({
modelProvider: "openai",
modelId: "gpt-4o",
}));
await flushTaskUpdated();
expect(store.logEntry).toHaveBeenCalledWith("FN-001", "Model change failed: API key not found");
expect((executor as any).activeSessions.has("FN-001")).toBe(true);
});
it("does not attempt hot-swap on paused task", async () => {
const store = createMockStore();
const setModel = vi.fn().mockResolvedValue(undefined);
const dispose = vi.fn();
const findModel = vi.fn();
const executor = new TaskExecutor(store, "/tmp/test");
(executor as any)._modelRegistry = { find: findModel };
(executor as any).activeSessions.set("FN-001", {
session: { setModel, dispose },
seenSteeringIds: new Set(),
lastModelProvider: "anthropic",
lastModelId: "claude-sonnet-4-5",
});
store._trigger("task:updated", buildUpdatedTask({
paused: true,
modelProvider: "openai",
modelId: "gpt-4o",
}));
await flushTaskUpdated();
expect(dispose).toHaveBeenCalledTimes(1);
expect(findModel).not.toHaveBeenCalled();
expect(setModel).not.toHaveBeenCalled();
});
});
describe("TaskExecutor global pause behavior", () => {
beforeEach(() => {
vi.clearAllMocks();

64
packages/engine/src/executor.ts
View File

@@ -9,7 +9,7 @@ import { generateWorktreeName, slugify } from "./worktree-names.js";
import { Type, type Static } from "@mariozechner/pi-ai";
import { createKbAgent, describeModel, promptWithFallback, compactSessionContext } from "./pi.js";
import { reviewStep, type ReviewVerdict } from "./reviewer.js";
import { SessionManager, type ToolDefinition, type AgentSession } from "@mariozechner/pi-coding-agent";
import { AuthStorage, ModelRegistry, SessionManager, getAgentDir, type ToolDefinition, type AgentSession } from "@mariozechner/pi-coding-agent";
import { PRIORITY_EXECUTE, type AgentSemaphore } from "./concurrency.js";
import type { WorktreePool } from "./worktree-pool.js";
import { AgentLogger } from "./agent-logger.js";
@@ -241,6 +241,8 @@ export class TaskExecutor {
private activeSessions = new Map<string, {
session: AgentSession;
seenSteeringIds: Set<string>;
lastModelProvider?: string | null;
lastModelId?: string | null;
}>();
/** Active step-session executors per task (mutually exclusive with activeSessions). */
private activeStepExecutors = new Map<string, StepSessionExecutor>();
@@ -262,6 +264,16 @@ export class TaskExecutor {
private totalSpawnedCount = 0;
/** Token cap detector for proactive context compaction. */
private tokenCapDetector = new TokenCapDetector();
private _modelRegistry?: InstanceType<typeof ModelRegistry>;
private get modelRegistry(): InstanceType<typeof ModelRegistry> {
if (!this._modelRegistry) {
const authStorage = AuthStorage.create();
this._modelRegistry = new ModelRegistry(authStorage, join(getAgentDir(), "models.json"));
this._modelRegistry.refresh();
}
return this._modelRegistry;
}
/** Returns the set of task IDs currently being executed. */
getExecutingTaskIds(): Set<string> {
@@ -344,6 +356,42 @@ export class TaskExecutor {
return;
}
// Handle executor model hot-swap on active single-session executions
if (this.activeSessions.has(task.id) && !task.paused) {
const activeEntry = this.activeSessions.get(task.id)!;
const providerChanged = task.modelProvider !== activeEntry.lastModelProvider;
const modelIdChanged = task.modelId !== activeEntry.lastModelId;
if (providerChanged || modelIdChanged) {
activeEntry.lastModelProvider = task.modelProvider;
activeEntry.lastModelId = task.modelId;
const settings = await this.store.getSettings();
const newProvider = task.modelProvider && task.modelId
? task.modelProvider
: settings?.defaultProvider;
const newModelId = task.modelProvider && task.modelId
? task.modelId
: settings?.defaultModelId;
if (newProvider && newModelId) {
try {
const model = this.modelRegistry.find(newProvider, newModelId);
if (model) {
await activeEntry.session.setModel(model);
executorLog.log(`${task.id}: executor model hot-swapped to ${newProvider}/${newModelId}`);
await this.store.logEntry(task.id, `Model changed to ${newProvider}/${newModelId}`);
} else {
executorLog.log(`${task.id}: model ${newProvider}/${newModelId} not found in registry for hot-swap`);
}
} catch (err: any) {
executorLog.error(`${task.id}: failed to hot-swap model: ${err.message}`);
await this.store.logEntry(task.id, `Model change failed: ${err.message}`);
}
}
}
}
// Handle steering comments - inject new ones into the running session
// Only process if session is active (activeSessions check is sufficient
// since entries are only added when a task is in-progress)
@@ -1061,7 +1109,12 @@ export class TaskExecutor {
seenSteeringIds.add(comment.id);
}
}
this.activeSessions.set(task.id, { session, seenSteeringIds });
this.activeSessions.set(task.id, {
session,
seenSteeringIds,
lastModelProvider: detail.modelProvider,
lastModelId: detail.modelId,
});
// Register with stuck task detector for heartbeat monitoring
stuckDetector?.trackTask(task.id, session);
@@ -1232,7 +1285,12 @@ export class TaskExecutor {
// Reassign so finally{} disposes the correct session
session = retrySession;
sessionRef.current = retrySession;
this.activeSessions.set(task.id, { session: retrySession, seenSteeringIds });
this.activeSessions.set(task.id, {
session: retrySession,
seenSteeringIds,
lastModelProvider: detail.modelProvider,
lastModelId: detail.modelId,
});
stuckDetector?.trackTask(task.id, retrySession);
const retryPrompt = [