@getpaseo/server 0.1.96 → 0.1.97-beta.1

package/dist/server/server/agent/providers/acp-agent.d.ts

@@ -1,4 +1,5 @@
 import { type ChildProcessWithoutNullStreams } from "node:child_process";
+import type { ProcessTerminator } from "../../../utils/tree-kill.js";
 import type { ReadableStream as NodeReadableStream, WritableStream as NodeWritableStream } from "node:stream/web";
 import { ClientSideConnection, type Client as ACPClient, type CreateTerminalRequest, type InitializeResponse, type KillTerminalRequest, type LoadSessionResponse, type NewSessionResponse, type ReadTextFileRequest, type RequestPermissionRequest, type RequestPermissionResponse, type ResumeSessionResponse, type SessionConfigOption, type SessionMode, type SessionModelState, type SessionNotification, type TerminalOutputRequest, type TerminalOutputResponse, type ToolCallContent, type ToolCallLocation, type ToolCallStatus, type ToolKind, type Usage, type WaitForTerminalExitRequest, type WriteTextFileRequest, type Stream as ACPStream } from "@agentclientprotocol/sdk";
 import type { Logger } from "pino";
@@ -31,6 +32,7 @@ interface ACPAgentClientOptions {
     capabilities?: AgentCapabilityFlags;
     waitForInitialCommands?: boolean;
     initialCommandsWaitTimeoutMs?: number;
+    terminateProcess?: ProcessTerminator;
 }
 interface ACPAgentSessionOptions {
     provider: string;
@@ -52,6 +54,7 @@ interface ACPAgentSessionOptions {
     launchEnv?: Record<string, string>;
     waitForInitialCommands?: boolean;
     initialCommandsWaitTimeoutMs?: number;
+    terminateProcess?: ProcessTerminator;
 }
 export interface SpawnedACPProcess {
     child: ChildProcessWithoutNullStreams;
@@ -148,6 +151,7 @@ export declare class ACPAgentClient implements AgentClient {
     private readonly thinkingOptionWriter?;
     private readonly waitForInitialCommands;
     private readonly initialCommandsWaitTimeoutMs;
+    protected readonly terminateProcess: ProcessTerminator;
     constructor(options: ACPAgentClientOptions);
     createSession(config: AgentSessionConfig, launchContext?: AgentLaunchContext): Promise<AgentSession>;
     resumeSession(handle: AgentPersistenceHandle, overrides?: Partial<AgentSessionConfig>, launchContext?: AgentLaunchContext): Promise<AgentSession>;
@@ -218,6 +222,7 @@ export declare class ACPAgentSession implements AgentSession, ACPClient {
     private historyPending;
     private replayingHistory;
     private bootstrapThreadEventPending;
+    private readonly terminateProcess;
     constructor(config: AgentSessionConfig, options: ACPAgentSessionOptions);
     get id(): string | null;
     initializeNewSession(): Promise<void>;

package/dist/server/server/agent/providers/acp-agent.js

@@ -2,6 +2,7 @@ import { randomUUID } from "node:crypto";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { Readable, Writable } from "node:stream";
+import { terminateWithTreeKill } from "../../../utils/tree-kill.js";
 import { ClientSideConnection, PROTOCOL_VERSION, } from "@agentclientprotocol/sdk";
 import { getAgentStreamEventTurnId, } from "../agent-sdk-types.js";
 import { importSessionFromPersistence } from "../provider-session-import.js";
@@ -72,6 +73,10 @@ function resolveTerminalCommand(command, args) {
 export const DEFAULT_ACP_CAPABILITIES = {
     supportsStreaming: true,
     supportsSessionPersistence: true,
+    // ACP agents can list prior sessions via `session/list`. The runtime probe in
+    // listImportableSessions returns nothing for agents that don't advertise the
+    // capability, so enabling this here only makes the daemon query them.
+    supportsSessionListing: true,
     supportsDynamicModes: true,
     supportsMcpServers: true,
     supportsReasoningStream: true,
@@ -255,6 +260,7 @@ export function deriveModelDefinitionsFromACP(provider, models, configOptions) {
 export class ACPAgentClient {
     constructor(options) {
         this.provider = options.provider;
+        this.terminateProcess = options.terminateProcess ?? terminateWithTreeKill;
         this.capabilities = options.capabilities ?? DEFAULT_ACP_CAPABILITIES;
         this.logger = options.logger.child({
             module: "agent",
@@ -379,7 +385,13 @@ export class ACPAgentClient {
             const sessions = [];
             let cursor;
             for (;;) {
-                const page = await this.runACPRequest(() => probe.connection.listSessions(cursor ? { cursor } : {}));
+                const page = await this.runACPRequest(() => probe.connection.listSessions({
+                    ...(cursor ? { cursor } : {}),
+                    // Filter by working directory at the source. Without this the agent
+                    // returns globally-recent sessions, which the `limit` below can
+                    // truncate before the current directory's sessions are reached.
+                    ...(options?.cwd ? { cwd: options.cwd } : {}),
+                }));
                 for (const session of page.sessions) {
                     sessions.push({
                         providerHandleId: session.sessionId,
@@ -463,7 +475,7 @@ export class ACPAgentClient {
             ]));
         }
         catch (error) {
-            await terminateChildProcess(child, 2000);
+            await terminateChildProcess(child, 2000, this.terminateProcess);
             throw error;
         }
         finally {
@@ -500,7 +512,7 @@ export class ACPAgentClient {
             }
         }
         finally {
-            await terminateChildProcess(probe.child, 2000);
+            await terminateChildProcess(probe.child, 2000, this.terminateProcess);
         }
     }
     async runACPRequest(request) {
@@ -572,6 +584,7 @@ export class ACPAgentSession {
         this.replayingHistory = false;
         this.bootstrapThreadEventPending = false;
         this.provider = options.provider;
+        this.terminateProcess = options.terminateProcess ?? terminateWithTreeKill;
         this.capabilities = options.capabilities;
         this.logger = options.logger.child({ module: "agent", provider: options.provider });
         this.runtimeSettings = options.runtimeSettings;
@@ -1106,13 +1119,14 @@ export class ACPAgentSession {
                 this.logger.debug({ err: error }, "ACP closeSession failed during shutdown");
             }
         }
-        for (const terminal of this.terminalEntries.values()) {
-            terminal.child.kill("SIGTERM");
-        }
+        const terminalTerminations = Array.from(this.terminalEntries.values(), (terminal) => this.terminateProcess(terminal.child, {
+            gracefulTimeoutMs: 2000,
+            forceTimeoutMs: 2000,
+        }));
+        await Promise.all(terminalTerminations);
         this.terminalEntries.clear();
         if (this.child) {
-            this.child.kill("SIGTERM");
-            await waitForChildExit(this.child, 2000);
+            await this.terminateProcess(this.child, { gracefulTimeoutMs: 2000, forceTimeoutMs: 2000 });
         }
         this.subscribers.clear();
         this.connection = null;
@@ -1260,14 +1274,14 @@ export class ACPAgentSession {
     async releaseTerminal(params) {
         const entry = this.getTerminalEntry(params.terminalId);
         if (!entry.exit) {
-            entry.child.kill("SIGTERM");
+            await this.terminateProcess(entry.child, { gracefulTimeoutMs: 2000, forceTimeoutMs: 2000 });
         }
         this.terminalEntries.delete(params.terminalId);
     }
     async killTerminal(params) {
         const entry = this.getTerminalEntry(params.terminalId);
         if (!entry.exit) {
-            entry.child.kill("SIGTERM");
+            await this.terminateProcess(entry.child, { gracefulTimeoutMs: 2000, forceTimeoutMs: 2000 });
         }
         return {};
     }
@@ -2099,23 +2113,14 @@ function coerceSessionConfigMetadata(metadata) {
     }
     return metadata;
 }
-async function waitForChildExit(child, timeoutMs) {
-    if (child.exitCode !== null || child.signalCode !== null) {
-        return;
+async function terminateChildProcess(child, timeoutMs, terminate) {
+    try {
+        await terminate(child, { gracefulTimeoutMs: timeoutMs, forceTimeoutMs: timeoutMs });
     }
-    await Promise.race([
-        new Promise((resolve) => child.once("exit", () => resolve())),
-        new Promise((resolve) => setTimeout(resolve, timeoutMs)),
-    ]);
-    if (child.exitCode === null && child.signalCode === null) {
-        child.kill("SIGKILL");
+    finally {
+        child.stdin.destroy();
+        child.stdout.destroy();
+        child.stderr.destroy();
     }
 }
-async function terminateChildProcess(child, timeoutMs) {
-    child.kill("SIGTERM");
-    child.stdin.destroy();
-    child.stdout.destroy();
-    child.stderr.destroy();
-    await waitForChildExit(child, timeoutMs);
-}
 //# sourceMappingURL=acp-agent.js.map

package/dist/server/server/agent/providers/claude/agent.js

@@ -381,6 +381,9 @@ function isClaudeNoResponsePlaceholderText(value) {
     return normalizeClaudeTranscriptText(value) === NO_RESPONSE_REQUESTED_PLACEHOLDER;
 }
 const LOCAL_COMMAND_STDOUT_PATTERN = /^\s*<local-command-stdout>[\s\S]*<\/local-command-stdout>\s*$/;
+const CLAUDE_COMMAND_MESSAGE_PATTERN = /<command-message>([\s\S]*?)<\/command-message>/;
+const CLAUDE_COMMAND_ARGS_PATTERN = /<command-args>([\s\S]*?)<\/command-args>/;
+const CLAUDE_COMMAND_NAME_PATTERN = /<command-name>([\s\S]*?)<\/command-name>/;
 function isClaudeLocalCommandStdout(value) {
     const normalized = normalizeClaudeTranscriptText(value);
     return normalized !== null && LOCAL_COMMAND_STDOUT_PATTERN.test(normalized);
@@ -426,7 +429,7 @@ export function extractUserMessageText(content) {
         if (!normalized || isClaudeTranscriptNoiseText(normalized)) {
             return null;
         }
-        return normalized;
+        return normalizeClaudeUserPromptText(normalized);
     }
     if (!Array.isArray(content)) {
         return null;
@@ -440,7 +443,10 @@ export function extractUserMessageText(content) {
         if (text && text.trim()) {
             const trimmed = text.trim();
             if (!isClaudeTranscriptNoiseText(trimmed)) {
-                parts.push(trimmed);
+                const normalized = normalizeClaudeUserPromptText(trimmed);
+                if (normalized) {
+                    parts.push(normalized);
+                }
             }
             continue;
         }
@@ -448,7 +454,10 @@ export function extractUserMessageText(content) {
         if (input && input.trim()) {
             const trimmed = input.trim();
             if (!isClaudeTranscriptNoiseText(trimmed)) {
-                parts.push(trimmed);
+                const normalized = normalizeClaudeUserPromptText(trimmed);
+                if (normalized) {
+                    parts.push(normalized);
+                }
             }
         }
     }
@@ -4074,6 +4083,32 @@ function normalizeImportablePromptPreview(text) {
         return null;
     return normalized.length > 160 ? normalized.slice(0, 160) : normalized;
 }
+function normalizeClaudeUserPromptText(text) {
+    const normalized = text.trim();
+    if (!CLAUDE_COMMAND_MESSAGE_PATTERN.test(normalized)) {
+        return normalized || null;
+    }
+    const command = readClaudeCommandPromptName(normalized);
+    if (!command) {
+        return null;
+    }
+    const commandArgs = normalized.match(CLAUDE_COMMAND_ARGS_PATTERN)?.[1]?.trim();
+    if (commandArgs) {
+        return `${command} ${commandArgs}`;
+    }
+    return command;
+}
+function readClaudeCommandPromptName(text) {
+    const commandName = text.match(CLAUDE_COMMAND_NAME_PATTERN)?.[1]?.trim();
+    if (commandName) {
+        return commandName.startsWith("/") ? commandName : `/${commandName}`;
+    }
+    const commandMessage = text.match(CLAUDE_COMMAND_MESSAGE_PATTERN)?.[1]?.trim();
+    if (!commandMessage) {
+        return null;
+    }
+    return commandMessage.startsWith("/") ? commandMessage : `/${commandMessage}`;
+}
 function extractClaudeUserText(messageRaw) {
     const message = toObjectRecord(messageRaw);
     if (!message) {
@@ -4081,11 +4116,15 @@ function extractClaudeUserText(messageRaw) {
     }
     if (typeof message.content === "string") {
         const normalized = message.content.trim();
-        return normalized && !isClaudeTranscriptNoiseText(normalized) ? normalized : null;
+        if (!normalized || isClaudeTranscriptNoiseText(normalized))
+            return null;
+        return normalizeClaudeUserPromptText(normalized);
     }
     if (typeof message.text === "string") {
         const normalized = message.text.trim();
-        return normalized && !isClaudeTranscriptNoiseText(normalized) ? normalized : null;
+        if (!normalized || isClaudeTranscriptNoiseText(normalized))
+            return null;
+        return normalizeClaudeUserPromptText(normalized);
     }
     if (isUnknownArray(message.content)) {
         for (const block of message.content) {
@@ -4093,7 +4132,7 @@ function extractClaudeUserText(messageRaw) {
             if (blockRecord && typeof blockRecord.text === "string") {
                 const normalized = blockRecord.text.trim();
                 if (normalized && !isClaudeTranscriptNoiseText(normalized)) {
-                    return normalized;
+                    return normalizeClaudeUserPromptText(normalized);
                 }
             }
         }

package/dist/server/server/agent/providers/codex-app-server-agent.js

@@ -12,7 +12,7 @@ import { composeSystemPromptParts } from "../system-prompt.js";
 import { curateAgentActivity } from "../activity-curator.js";
 import { mapCodexToolCallEnvelope, mapCodexToolCallFromThreadItem, } from "./codex/tool-call-mapper.js";
 import { checkProviderLaunchAvailable, createProviderEnv, createProviderEnvSpec, resolveProviderLaunch, } from "../provider-launch-config.js";
-import { findExecutable, probeExecutable } from "../../../utils/executable.js";
+import { findExecutable, probeExecutable, } from "../../../executable-resolution/executable-resolution.js";
 import { createPathEquivalenceMatcher } from "../../../utils/path.js";
 import { spawnProcess } from "../../../utils/spawn.js";
 import { extractCodexTerminalSessionId, nonEmptyString } from "./tool-call-mapper-utils.js";

package/dist/server/server/agent/providers/copilot-acp-agent.js

@@ -5,6 +5,7 @@ import { formatDiagnosticStatus, formatProviderDiagnostic, formatProviderDiagnos
 const COPILOT_CAPABILITIES = {
     supportsStreaming: true,
     supportsSessionPersistence: true,
+    supportsSessionListing: true,
     supportsDynamicModes: true,
     supportsMcpServers: true,
     supportsReasoningStream: true,

package/dist/server/server/agent/providers/cursor-acp-agent.d.ts

@@ -1,5 +1,4 @@
 import type { Logger } from "pino";
-import type { AgentModelDefinition, ListModelsOptions } from "../agent-sdk-types.js";
 import { GenericACPAgentClient } from "./generic-acp-agent.js";
 interface CursorACPAgentClientOptions {
     logger: Logger;
@@ -10,13 +9,7 @@ interface CursorACPAgentClientOptions {
     providerParams?: unknown;
 }
 export declare class CursorACPAgentClient extends GenericACPAgentClient {
-    private readonly cursorCommand;
-    private readonly env?;
     constructor(options: CursorACPAgentClientOptions);
-    listModels(options: ListModelsOptions): Promise<AgentModelDefinition[]>;
-    private canUseCursorModelsFallback;
-    private listCursorModelsFallback;
 }
-export declare function parseCursorAgentModelsOutput(output: string): AgentModelDefinition[];
 export {};
 //# sourceMappingURL=cursor-acp-agent.d.ts.map

package/dist/server/server/agent/providers/cursor-acp-agent.js

@@ -1,9 +1,5 @@
-import { basename } from "node:path";
-import * as spawnUtils from "../../../utils/spawn.js";
 import { GenericACPAgentClient } from "./generic-acp-agent.js";
-const CURSOR_MODELS_TIMEOUT_MS = 10000;
 const CURSOR_INITIAL_COMMANDS_WAIT_TIMEOUT_MS = 10000;
-const CURSOR_MODEL_MARKER_PATTERN = /\s+\((?:default|current)\)$/;
 export class CursorACPAgentClient extends GenericACPAgentClient {
     constructor(options) {
         super({
@@ -17,80 +13,6 @@ export class CursorACPAgentClient extends GenericACPAgentClient {
             waitForInitialCommands: true,
             initialCommandsWaitTimeoutMs: CURSOR_INITIAL_COMMANDS_WAIT_TIMEOUT_MS,
         });
-        this.cursorCommand = options.command;
-        this.env = options.env;
     }
-    async listModels(options) {
-        const acpModels = await super.listModels(options);
-        if (acpModels.length > 0) {
-            return acpModels;
-        }
-        if (this.canUseCursorModelsFallback()) {
-            return this.listCursorModelsFallback(acpModels);
-        }
-        return acpModels;
-    }
-    canUseCursorModelsFallback() {
-        return basename(this.cursorCommand[0]) === "cursor-agent";
-    }
-    async listCursorModelsFallback(acpModels) {
-        try {
-            const { stdout } = await spawnUtils.execCommand(this.cursorCommand[0], ["models"], {
-                envOverlay: this.env,
-                timeout: CURSOR_MODELS_TIMEOUT_MS,
-                maxBuffer: 1024 * 1024,
-            });
-            const fallbackModels = parseCursorAgentModelsOutput(stdout);
-            if (fallbackModels.length === 0) {
-                this.logger.warn({ provider: "cursor" }, "Cursor ACP model fallback returned no parseable models");
-                return acpModels;
-            }
-            return fallbackModels;
-        }
-        catch (error) {
-            this.logger.warn({ err: error, provider: "cursor" }, "Failed to list Cursor models via cursor-agent models fallback");
-            return acpModels;
-        }
-    }
-}
-export function parseCursorAgentModelsOutput(output) {
-    const parsed = output
-        .split(/\r?\n/)
-        .map((line) => line.trim())
-        .filter((line) => line && line !== "Available models" && !line.startsWith("Tip:"))
-        .map((line) => {
-        const separatorIndex = line.indexOf(" - ");
-        if (separatorIndex <= 0) {
-            return null;
-        }
-        const id = line.slice(0, separatorIndex).trim();
-        const rawLabel = line.slice(separatorIndex + 3).trim();
-        if (!id || !rawLabel) {
-            return null;
-        }
-        let marker = null;
-        if (rawLabel.endsWith(" (default)")) {
-            marker = "default";
-        }
-        else if (rawLabel.endsWith(" (current)")) {
-            marker = "current";
-        }
-        return {
-            provider: "acp",
-            id,
-            label: rawLabel.replace(CURSOR_MODEL_MARKER_PATTERN, ""),
-            marker,
-        };
-    })
-        .filter((model) => model !== null);
-    const defaultModelId = parsed.find((model) => model.marker === "default")?.id ??
-        parsed.find((model) => model.marker === "current")?.id ??
-        parsed[0]?.id;
-    return parsed.map((model) => ({
-        provider: model.provider,
-        id: model.id,
-        label: model.label,
-        isDefault: model.id === defaultModelId,
-    }));
 }
 //# sourceMappingURL=cursor-acp-agent.js.map

package/dist/server/server/agent/providers/mock-load-test-agent.d.ts

@@ -67,6 +67,8 @@ export declare class MockLoadTestAgentSession implements AgentSession {
     private scheduleStressTurn;
     private schedulePlanApprovalTurn;
     private scheduleQuestionPromptTurn;
+    private scheduleStructuredJsonTurn;
+    private emitStructuredJsonTurn;
     private emitPlanApprovalTurn;
     private emitQuestionPromptTurn;
     private emitStressTurn;

package/dist/server/server/agent/providers/mock-load-test-agent.js

@@ -165,6 +165,35 @@ function parseAgentStreamStressPrompt(prompt) {
         coalesced: Boolean(match[2]),
     };
 }
+function parseStructuredBranchNamePrompt(prompt) {
+    const text = promptToText(prompt);
+    const hasBranchNamePrompt = text.includes("Generate a git branch name for a coding agent") &&
+        (text.includes("Return JSON only with fields 'title' and 'branch'.") ||
+            text.includes('"title"') ||
+            text.includes('"branch"'));
+    if (!hasBranchNamePrompt &&
+        !(text.includes("You must respond with JSON only that matches this JSON Schema") &&
+            text.includes('"title"') &&
+            text.includes('"branch"'))) {
+        return null;
+    }
+    const seed = text.split("User context:\n").at(-1)?.trim() ?? "";
+    const firstLine = seed
+        .split("\n")
+        .find((line) => line.trim().length > 0)
+        ?.trim() ?? "Mock task";
+    const title = firstLine
+        .replace(/^["'`]+|["'`]+$/g, "")
+        .replace(/\s+/g, " ")
+        .slice(0, 80)
+        .trim();
+    const branch = title
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 100) || "mock-task";
+    return { title: title || "Mock task", branch };
+}
 function buildRepeatedPayload(bytes, prefix) {
     const line = `${prefix} ${"x".repeat(96)}\n`;
     let output = "";
@@ -446,7 +475,11 @@ export class MockLoadTestAgentSession {
         const largePayload = parseLargeAgentStreamPayloadPrompt(prompt);
         const stress = parseAgentStreamStressPrompt(prompt);
         const questionPrompt = parseMockQuestionPrompt(prompt);
-        if (shouldEmitPlanApprovalPrompt(prompt)) {
+        const structuredBranchName = parseStructuredBranchNamePrompt(prompt);
+        if (structuredBranchName) {
+            this.scheduleStructuredJsonTurn(turn, structuredBranchName);
+        }
+        else if (shouldEmitPlanApprovalPrompt(prompt)) {
             this.schedulePlanApprovalTurn(turn);
         }
         else if (questionPrompt) {
@@ -600,6 +633,45 @@ export class MockLoadTestAgentSession {
         }, 0);
         turn.timer.unref?.();
     }
+    scheduleStructuredJsonTurn(turn, result) {
+        turn.timer = setTimeout(() => {
+            this.emitStructuredJsonTurn(turn, result);
+        }, 0);
+        turn.timer.unref?.();
+    }
+    emitStructuredJsonTurn(turn, result) {
+        if (this.activeTurn !== turn) {
+            return;
+        }
+        this.clearTurnTimer(turn);
+        this.emit({
+            type: "turn_started",
+            provider: this.provider,
+            turnId: turn.turnId,
+        });
+        const finalText = JSON.stringify(result);
+        this.emitTimeline(turn.turnId, {
+            type: "assistant_message",
+            text: finalText,
+        });
+        this.activeTurn = null;
+        this.emit({
+            type: "turn_completed",
+            provider: this.provider,
+            turnId: turn.turnId,
+        });
+        turn.resolve({
+            sessionId: this.id,
+            finalText,
+            timeline: [
+                {
+                    type: "assistant_message",
+                    text: finalText,
+                },
+            ],
+            canceled: false,
+        });
+    }
     emitPlanApprovalTurn(turn) {
         if (this.activeTurn !== turn) {
             return;

package/dist/server/server/agent/providers/opencode/server-manager.js

@@ -1,5 +1,5 @@
 import net from "node:net";
-import { findExecutable } from "../../../../utils/executable.js";
+import { findExecutable } from "../../../../executable-resolution/executable-resolution.js";
 import { spawnProcess } from "../../../../utils/spawn.js";
 import { terminateWithTreeKill } from "../../../../utils/tree-kill.js";
 import { createProviderEnvSpec, resolveProviderCommandPrefix, } from "../../provider-launch-config.js";

package/dist/server/server/agent/structured-generation-providers.js

@@ -5,6 +5,21 @@ export const DEFAULT_STRUCTURED_GENERATION_PROVIDERS = [
     { modelSubstring: "nemotron-3-super" },
 ];
 export async function resolveStructuredGenerationProviders(options) {
+    const configuredProviders = readConfiguredProviders(options.daemonConfig);
+    if (configuredProviders.length > 0) {
+        const explicitProviders = resolveExplicitConfiguredProviders(configuredProviders);
+        if (explicitProviders.length === configuredProviders.length) {
+            return dedupeProviders(explicitProviders);
+        }
+        const providerEntries = await options.providerSnapshotManager.listProviders({
+            cwd: options.cwd,
+            wait: false,
+        });
+        const providers = resolveConfiguredProviders(configuredProviders, providerEntries);
+        if (providers.length > 0) {
+            return dedupeProviders(providers);
+        }
+    }
     const providerEntries = await options.providerSnapshotManager.listProviders({
         cwd: options.cwd,
         wait: true,
@@ -13,7 +28,7 @@ export async function resolveStructuredGenerationProviders(options) {
     const modelEntries = enabledEntries.filter((entry) => (entry.models?.length ?? 0) > 0);
     const entriesByProvider = new Map(enabledEntries.map((entry) => [entry.provider, entry]));
     const providers = [];
-    for (const configured of readConfiguredProviders(options.daemonConfig)) {
+    for (const configured of configuredProviders) {
         const resolvedConfigured = resolveConfiguredCandidate(configured, modelEntries, entriesByProvider);
         if (!resolvedConfigured) {
             continue;
@@ -32,6 +47,35 @@ export async function resolveStructuredGenerationProviders(options) {
     }
     return dedupeProviders(providers);
 }
+function resolveConfiguredProviders(configuredProviders, providerEntries) {
+    const enabledEntries = providerEntries.filter((entry) => entry.enabled);
+    const modelEntries = enabledEntries.filter((entry) => (entry.models?.length ?? 0) > 0);
+    const entriesByProvider = new Map(enabledEntries.map((entry) => [entry.provider, entry]));
+    const providers = [];
+    for (const configured of configuredProviders) {
+        const resolved = resolveConfiguredCandidate(configured, modelEntries, entriesByProvider);
+        if (resolved) {
+            providers.push(resolved);
+        }
+    }
+    return providers;
+}
+function resolveExplicitConfiguredProviders(configuredProviders) {
+    const providers = [];
+    for (const configured of configuredProviders) {
+        const provider = configured.provider.trim();
+        const model = configured.model?.trim();
+        if (!provider || !model) {
+            continue;
+        }
+        providers.push({
+            provider,
+            model,
+            ...(configured.thinkingOptionId ? { thinkingOptionId: configured.thinkingOptionId } : {}),
+        });
+    }
+    return providers;
+}
 function resolveCurrentSelection(selection, readyEntries, entriesByProvider) {
     if (!selection) {
         return null;

package/dist/server/server/agent-attention-policy.d.ts

@@ -4,17 +4,26 @@ export interface ClientPresenceState {
     appVisible: boolean;
     lastActivityAtMs: number | null;
     focusedAgentId: string | null;
+    focusedTerminalId: string | null;
 }
+export type AttentionFocusTarget = {
+    kind: "agent";
+    id: string;
+} | {
+    kind: "terminal";
+    id: string;
+};
 export interface NotificationPlan {
     inAppRecipientIndex: number | null;
     shouldPush: boolean;
 }
 interface ComputeNotificationPlanInput {
     allStates: ClientPresenceState[];
-    agentId: string;
-    reason: AgentAttentionReason;
+    focusTarget: AttentionFocusTarget | null;
+    pushEligible: boolean;
     nowMs: number;
 }
-export declare function computeNotificationPlan({ allStates, agentId, reason, nowMs, }: ComputeNotificationPlanInput): NotificationPlan;
+export declare function computeNotificationPlan({ allStates, focusTarget, pushEligible, nowMs, }: ComputeNotificationPlanInput): NotificationPlan;
+export declare function isPushEligibleAttentionReason(reason: AgentAttentionReason): boolean;
 export {};
 //# sourceMappingURL=agent-attention-policy.d.ts.map

package/dist/server/server/agent-attention-policy.js

@@ -1,5 +1,14 @@
 export const PRESENCE_THRESHOLD_MS = 180000;
-export function computeNotificationPlan({ allStates, agentId, reason, nowMs, }) {
+function isFocusedOnTarget(state, target) {
+    if (target === null) {
+        return false;
+    }
+    if (target.kind === "agent") {
+        return state.focusedAgentId === target.id;
+    }
+    return state.focusedTerminalId === target.id;
+}
+export function computeNotificationPlan({ allStates, focusTarget, pushEligible, nowMs, }) {
     let mostRecentPresentIndex = null;
     let mostRecentPresentAtMs = Number.NEGATIVE_INFINITY;
     for (const [clientIndex, state] of allStates.entries()) {
@@ -8,7 +17,7 @@ export function computeNotificationPlan({ allStates, agentId, reason, nowMs, })
         if (!isPresent) {
             continue;
         }
-        if (state.appVisible && state.focusedAgentId === agentId) {
+        if (state.appVisible && isFocusedOnTarget(state, focusTarget)) {
             return { inAppRecipientIndex: null, shouldPush: false };
         }
         if (clampedActivityAtMs > mostRecentPresentAtMs) {
@@ -19,6 +28,9 @@ export function computeNotificationPlan({ allStates, agentId, reason, nowMs, })
     if (mostRecentPresentIndex !== null) {
         return { inAppRecipientIndex: mostRecentPresentIndex, shouldPush: false };
     }
-    return { inAppRecipientIndex: null, shouldPush: reason !== "error" };
+    return { inAppRecipientIndex: null, shouldPush: pushEligible };
+}
+export function isPushEligibleAttentionReason(reason) {
+    return reason !== "error";
 }
 //# sourceMappingURL=agent-attention-policy.js.map