@getpaseo/server 0.1.61 → 0.1.63

package/dist/server/server/agent/mcp-server.js

@@ -5,6 +5,7 @@ import { AgentPermissionRequestPayloadSchema, AgentListItemPayloadSchema, AgentP
 import { buildStoredAgentPayload, toAgentListItemPayload, toAgentPayload, } from "./agent-projections.js";
 import { curateAgentActivity } from "./activity-curator.js";
 import { ensureAgentLoaded } from "./agent-loading.js";
+import { isStoredAgentProviderAvailable } from "../persistence-hooks.js";
 import { appendTimelineItemIfAgentKnown, emitLiveTimelineItemIfAgentKnown, } from "./timeline-append.js";
 import { getPaseoWorktreesRoot } from "../../utils/worktree.js";
 import { archivePaseoWorktree, killTerminalsUnderPath, } from "../paseo-worktree-archive-service.js";
@@ -59,6 +60,34 @@ function parseTimestamp(value) {
 function resolveAgentListActivityTime(agent) {
     return Math.max(parseTimestamp(agent.updatedAt), parseTimestamp(agent.lastUserMessageAt), parseTimestamp(agent.attentionTimestamp), parseTimestamp(agent.archivedAt), parseTimestamp(agent.createdAt));
 }
+function resolveRegisteredProviderIds(agentManager, providerRegistry) {
+    return providerRegistry
+        ? Object.keys(providerRegistry)
+        : agentManager.getRegisteredProviderIds();
+}
+async function resolveProviderSummary(provider, logger) {
+    const base = {
+        id: provider.id,
+        label: provider.label,
+        description: provider.description,
+        modes: provider.modes,
+    };
+    if (!provider.enabled) {
+        return { ...base, enabled: false, status: "unavailable" };
+    }
+    try {
+        const available = await provider.createClient(logger).isAvailable();
+        return { ...base, enabled: true, status: available ? "available" : "unavailable" };
+    }
+    catch (availabilityError) {
+        return {
+            ...base,
+            enabled: true,
+            status: "unavailable",
+            error: availabilityError instanceof Error ? availabilityError.message : String(availabilityError),
+        };
+    }
+}
 function compareAgentListItems(a, b) {
     const attentionDelta = Number(b.requiresAttention ?? false) - Number(a.requiresAttention ?? false);
     if (attentionDelta !== 0) {
@@ -155,12 +184,6 @@ export async function createAgentMcpServer(options) {
         name: "agent-mcp",
         version: "2.0.0",
     });
-    const requireProviderRegistry = () => {
-        if (!providerRegistry) {
-            throw new Error("Provider registry is required to load stored agent records");
-        }
-        return providerRegistry;
-    };
     const resolveCallerAgent = () => {
         if (!callerAgentId) {
             return null;
@@ -171,7 +194,7 @@ export async function createAgentMcpServer(options) {
         }
         return parentAgent;
     };
-    const resolveScopedCwd = (requestedCwd, options) => {
+    const resolveScopedCwd = (requestedCwd, opts) => {
         const callerAgent = resolveCallerAgent();
         if (callerAgent) {
             return resolveChildAgentCwd({
@@ -183,66 +206,76 @@ export async function createAgentMcpServer(options) {
         }
         const trimmedCwd = requestedCwd?.trim();
         if (!trimmedCwd) {
-            if (options?.required) {
+            if (opts?.required) {
                 throw new Error("cwd is required");
             }
             throw new Error("cwd is required when no caller agent is available");
         }
         return expandUserPath(trimmedCwd);
     };
+    const buildCallerAgentScheduleConfigExtras = (callerAgent) => {
+        return {
+            ...(callerAgent.config.thinkingOptionId
+                ? { thinkingOptionId: callerAgent.config.thinkingOptionId }
+                : {}),
+            ...(callerAgent.config.approvalPolicy
+                ? { approvalPolicy: callerAgent.config.approvalPolicy }
+                : {}),
+            ...(callerAgent.config.sandboxMode ? { sandboxMode: callerAgent.config.sandboxMode } : {}),
+            ...(typeof callerAgent.config.networkAccess === "boolean"
+                ? { networkAccess: callerAgent.config.networkAccess }
+                : {}),
+            ...(typeof callerAgent.config.webSearch === "boolean"
+                ? { webSearch: callerAgent.config.webSearch }
+                : {}),
+            ...(callerAgent.config.title ? { title: callerAgent.config.title } : {}),
+            ...(callerAgent.config.extra ? { extra: callerAgent.config.extra } : {}),
+            ...(callerAgent.config.systemPrompt ? { systemPrompt: callerAgent.config.systemPrompt } : {}),
+            ...(callerAgent.config.mcpServers ? { mcpServers: callerAgent.config.mcpServers } : {}),
+        };
+    };
+    const buildCallerAgentScheduleConfig = (callerAgent, params) => {
+        const hasProviderOverride = params?.provider !== undefined;
+        const resolvedProviderModel = hasProviderOverride
+            ? resolveScheduleProviderAndModel({
+                provider: params?.provider,
+                defaultProvider: callerAgent.provider,
+            })
+            : null;
+        const resolvedProvider = resolvedProviderModel?.provider ?? callerAgent.provider;
+        let resolvedModel;
+        if (resolvedProviderModel?.model) {
+            resolvedModel = resolvedProviderModel.model;
+        }
+        else if (!hasProviderOverride && callerAgent.config.model) {
+            resolvedModel = callerAgent.config.model;
+        }
+        return {
+            provider: resolvedProvider,
+            cwd: params?.cwd?.trim() ? expandUserPath(params.cwd) : callerAgent.cwd,
+            ...(callerAgent.currentModeId
+                ? {
+                    modeId: mapModeAcrossProviders(callerAgent.currentModeId, callerAgent.provider, resolvedProvider),
+                }
+                : {}),
+            ...(resolvedModel ? { model: resolvedModel } : {}),
+            ...buildCallerAgentScheduleConfigExtras(callerAgent),
+        };
+    };
     const resolveNewAgentScheduleTarget = (params) => {
+        if (!params?.provider?.trim()) {
+            throw new Error("provider is required when target is new-agent");
+        }
         const callerAgent = resolveCallerAgent();
         if (callerAgent) {
-            const hasProviderOverride = params?.provider !== undefined;
-            const resolvedProviderModel = hasProviderOverride
-                ? resolveScheduleProviderAndModel({
-                    provider: params?.provider,
-                    defaultProvider: callerAgent.provider,
-                })
-                : null;
-            const resolvedProvider = resolvedProviderModel?.provider ?? callerAgent.provider;
             return {
                 type: "new-agent",
-                config: {
-                    provider: resolvedProvider,
-                    cwd: params?.cwd?.trim() ? expandUserPath(params.cwd) : callerAgent.cwd,
-                    ...(callerAgent.currentModeId
-                        ? {
-                            modeId: mapModeAcrossProviders(callerAgent.currentModeId, callerAgent.provider, resolvedProvider),
-                        }
-                        : {}),
-                    ...(resolvedProviderModel?.model
-                        ? { model: resolvedProviderModel.model }
-                        : !hasProviderOverride && callerAgent.config.model
-                            ? { model: callerAgent.config.model }
-                            : {}),
-                    ...(callerAgent.config.thinkingOptionId
-                        ? { thinkingOptionId: callerAgent.config.thinkingOptionId }
-                        : {}),
-                    ...(callerAgent.config.approvalPolicy
-                        ? { approvalPolicy: callerAgent.config.approvalPolicy }
-                        : {}),
-                    ...(callerAgent.config.sandboxMode
-                        ? { sandboxMode: callerAgent.config.sandboxMode }
-                        : {}),
-                    ...(typeof callerAgent.config.networkAccess === "boolean"
-                        ? { networkAccess: callerAgent.config.networkAccess }
-                        : {}),
-                    ...(typeof callerAgent.config.webSearch === "boolean"
-                        ? { webSearch: callerAgent.config.webSearch }
-                        : {}),
-                    ...(callerAgent.config.title ? { title: callerAgent.config.title } : {}),
-                    ...(callerAgent.config.extra ? { extra: callerAgent.config.extra } : {}),
-                    ...(callerAgent.config.systemPrompt
-                        ? { systemPrompt: callerAgent.config.systemPrompt }
-                        : {}),
-                    ...(callerAgent.config.mcpServers ? { mcpServers: callerAgent.config.mcpServers } : {}),
-                },
+                config: buildCallerAgentScheduleConfig(callerAgent, params),
             };
         }
         const resolvedProviderModel = resolveScheduleProviderAndModel({
             provider: params?.provider,
-            defaultProvider: "claude",
+            defaultProvider: params.provider,
         });
         return {
             type: "new-agent",
@@ -387,9 +420,87 @@ export async function createAgentMcpServer(options) {
     if (options.voiceOnly) {
         return server;
     }
+    const resolveCallerCreateAgentArgs = (args, parentAgentId) => {
+        const callerArgs = agentToAgentCreateAgentArgsSchema.parse(args);
+        const resolvedProviderModel = resolveRequiredProviderModel(callerArgs.provider);
+        const parentAgent = agentManager.getAgent(parentAgentId);
+        if (!parentAgent) {
+            throw new Error(`Parent agent ${parentAgentId} not found`);
+        }
+        const provider = resolvedProviderModel.provider;
+        const resolvedCwd = resolveChildAgentCwd({
+            parentCwd: parentAgent.cwd,
+            requestedCwd: callerArgs.cwd,
+            lockedCwd: callerContext?.lockedCwd,
+            allowCustomCwd: callerContext?.allowCustomCwd ?? true,
+        });
+        const parentMode = parentAgent.currentModeId;
+        const resolvedMode = parentMode
+            ? mapModeAcrossProviders(parentMode, parentAgent.provider, provider)
+            : undefined;
+        return {
+            provider,
+            initialPrompt: callerArgs.initialPrompt,
+            background: callerArgs.background ?? false,
+            normalizedTitle: callerArgs.title.trim(),
+            model: resolvedProviderModel.model,
+            thinking: callerArgs.thinking,
+            labels: callerArgs.labels,
+            notifyOnFinish: callerArgs.notifyOnFinish ?? false,
+            resolvedCwd,
+            resolvedMode,
+            worktreeConfig: undefined,
+            shouldBootstrapWorktree: undefined,
+        };
+    };
+    const resolveTopLevelCreateAgentArgs = async (args) => {
+        const topLevelArgs = topLevelCreateAgentArgsSchema.parse(args);
+        const resolvedProviderModel = resolveRequiredProviderModel(topLevelArgs.provider);
+        const { cwd, mode, worktreeName, baseBranch, refName, action, githubPrNumber } = topLevelArgs;
+        let resolvedCwd = expandUserPath(cwd);
+        let worktreeConfig;
+        let shouldBootstrapWorktree;
+        if (worktreeName) {
+            if (!baseBranch && !refName && !action && githubPrNumber === undefined) {
+                throw new Error("baseBranch is required when creating a worktree");
+            }
+            const createdWorktree = await createMcpWorktree({
+                input: {
+                    cwd: resolvedCwd,
+                    worktreeSlug: worktreeName,
+                    refName,
+                    action,
+                    githubPrNumber,
+                    runSetup: false,
+                    paseoHome: options.paseoHome,
+                },
+                createPaseoWorktree: options.createPaseoWorktree,
+                resolveDefaultBranch: baseBranch ? async () => baseBranch : undefined,
+                workspaceGitService: options.workspaceGitService,
+                logger: options.logger,
+            });
+            resolvedCwd = createdWorktree.worktree.worktreePath;
+            worktreeConfig = createdWorktree.worktree;
+            shouldBootstrapWorktree = createdWorktree.created;
+        }
+        return {
+            provider: resolvedProviderModel.provider,
+            initialPrompt: topLevelArgs.initialPrompt,
+            background: topLevelArgs.background ?? false,
+            normalizedTitle: topLevelArgs.title.trim(),
+            model: resolvedProviderModel.model,
+            thinking: topLevelArgs.thinking,
+            labels: topLevelArgs.labels,
+            notifyOnFinish: topLevelArgs.notifyOnFinish ?? false,
+            resolvedCwd,
+            resolvedMode: mode,
+            worktreeConfig,
+            shouldBootstrapWorktree,
+        };
+    };
     server.registerTool("create_agent", {
         title: "Create agent",
-        description: "Create an agent tied to a working directory. Requires provider/model, for example codex/gpt-5.4. Optionally run an initial prompt immediately or create a git worktree for the agent.",
+        description: "Create an agent tied to a working directory. Requires provider/model, for example codex/gpt-5.4. Do not guess; call list_providers and list_models first if uncertain. Optionally run an initial prompt immediately or create a git worktree for the agent.",
         inputSchema: createAgentInputSchema,
         outputSchema: {
             agentId: z.string(),
@@ -406,87 +517,15 @@ export async function createAgentMcpServer(options) {
             permission: AgentPermissionRequestPayloadSchema.nullable().optional(),
         },
     }, async (args) => {
-        let provider;
-        let initialPrompt;
-        let background = false;
-        let normalizedTitle;
-        let model;
-        let thinking;
-        let labels;
-        let notifyOnFinish = false;
-        let resolvedCwd;
-        let resolvedMode;
-        let worktreeConfig;
-        let shouldBootstrapWorktree;
-        if (callerAgentId) {
-            const callerArgs = agentToAgentCreateAgentArgsSchema.parse(args);
-            const resolvedProviderModel = resolveRequiredProviderModel(callerArgs.provider);
-            provider = resolvedProviderModel.provider;
-            model = resolvedProviderModel.model;
-            initialPrompt = callerArgs.initialPrompt;
-            background = callerArgs.background ?? false;
-            normalizedTitle = callerArgs.title.trim();
-            thinking = callerArgs.thinking;
-            labels = callerArgs.labels;
-            notifyOnFinish = callerArgs.notifyOnFinish ?? false;
-            const parentAgent = agentManager.getAgent(callerAgentId);
-            if (!parentAgent) {
-                throw new Error(`Parent agent ${callerAgentId} not found`);
-            }
-            resolvedCwd = resolveChildAgentCwd({
-                parentCwd: parentAgent.cwd,
-                requestedCwd: callerArgs.cwd,
-                lockedCwd: callerContext?.lockedCwd,
-                allowCustomCwd: callerContext?.allowCustomCwd ?? true,
-            });
-            const parentMode = parentAgent.currentModeId;
-            if (parentMode) {
-                resolvedMode = mapModeAcrossProviders(parentMode, parentAgent.provider, provider);
-            }
-        }
-        else {
-            const topLevelArgs = topLevelCreateAgentArgsSchema.parse(args);
-            const resolvedProviderModel = resolveRequiredProviderModel(topLevelArgs.provider);
-            provider = resolvedProviderModel.provider;
-            model = resolvedProviderModel.model;
-            initialPrompt = topLevelArgs.initialPrompt;
-            background = topLevelArgs.background ?? false;
-            normalizedTitle = topLevelArgs.title.trim();
-            thinking = topLevelArgs.thinking;
-            labels = topLevelArgs.labels;
-            notifyOnFinish = topLevelArgs.notifyOnFinish ?? false;
-            const { cwd, mode, worktreeName, baseBranch, refName, action, githubPrNumber } = topLevelArgs;
-            resolvedCwd = expandUserPath(cwd);
-            if (worktreeName) {
-                if (!baseBranch && !refName && !action && githubPrNumber === undefined) {
-                    throw new Error("baseBranch is required when creating a worktree");
-                }
-                const createdWorktree = await createMcpWorktree({
-                    input: {
-                        cwd: resolvedCwd,
-                        worktreeSlug: worktreeName,
-                        refName,
-                        action,
-                        githubPrNumber,
-                        runSetup: false,
-                        paseoHome: options.paseoHome,
-                    },
-                    createPaseoWorktree: options.createPaseoWorktree,
-                    resolveDefaultBranch: baseBranch ? async () => baseBranch : undefined,
-                    workspaceGitService: options.workspaceGitService,
-                    logger: options.logger,
-                });
-                resolvedCwd = createdWorktree.worktree.worktreePath;
-                worktreeConfig = createdWorktree.worktree;
-                shouldBootstrapWorktree = createdWorktree.created;
-            }
-            resolvedMode = mode;
-        }
+        const resolved = callerAgentId
+            ? resolveCallerCreateAgentArgs(args, callerAgentId)
+            : await resolveTopLevelCreateAgentArgs(args);
+        const { provider, initialPrompt, background, normalizedTitle, model, thinking, labels, notifyOnFinish, resolvedCwd, resolvedMode, worktreeConfig, shouldBootstrapWorktree, } = resolved;
         const childAgentDefaultLabels = callerContext?.childAgentDefaultLabels;
         const mergedLabels = {
             ...(callerAgentId ? { "paseo.parent-agent-id": callerAgentId } : {}),
-            ...(childAgentDefaultLabels ?? {}),
-            ...(labels ?? {}),
+            ...childAgentDefaultLabels,
+            ...labels,
         };
         const snapshot = await agentManager.createAgent({
             provider,
@@ -767,7 +806,7 @@ export async function createAgentMcpServer(options) {
         if (!record || record.internal) {
             throw new Error(`Agent ${agentId} not found`);
         }
-        const structuredSnapshot = buildStoredAgentPayload(record, requireProviderRegistry(), childLogger);
+        const structuredSnapshot = buildStoredAgentPayload(record, resolveRegisteredProviderIds(agentManager, providerRegistry));
         return {
             content: [],
             structuredContent: ensureValidJson({
@@ -804,10 +843,12 @@ export async function createAgentMcpServer(options) {
         const liveAgents = await Promise.all(liveSnapshots.map((snapshot) => serializeSnapshotWithMetadata(agentStorage, snapshot, childLogger)));
         const liveIds = new Set(liveSnapshots.map((snapshot) => snapshot.id));
         const storedRecords = await agentStorage.list();
+        const registeredProviderIds = resolveRegisteredProviderIds(agentManager, providerRegistry);
         const storedAgents = storedRecords
             .filter((record) => !record.internal && !liveIds.has(record.id))
             .filter((record) => includeArchived || !record.archivedAt)
-            .map((record) => buildStoredAgentPayload(record, requireProviderRegistry(), childLogger));
+            .filter((record) => includeArchived || isStoredAgentProviderAvailable(record, registeredProviderIds))
+            .map((record) => buildStoredAgentPayload(record, registeredProviderIds));
         const agents = [...liveAgents, ...storedAgents]
             .map(toAgentListItemPayload)
             .filter((agent) => !requestedCwd || isSameOrDescendantPath(requestedCwd, agent.cwd))
@@ -1213,25 +1254,18 @@ export async function createAgentMcpServer(options) {
     });
     server.registerTool("list_providers", {
         title: "List providers",
-        description: "List available agent providers and their modes.",
+        description: "List configured agent providers, availability, and their modes.",
         inputSchema: {},
         outputSchema: {
             providers: z.array(ProviderSummarySchema),
         },
-    }, async () => ({
-        content: [],
-        structuredContent: ensureValidJson({
-            providers: Object.values(providerRegistry ?? {}).map((provider) => ({
-                id: provider.id,
-                label: provider.label,
-                modes: provider.modes.map((mode) => ({
-                    id: mode.id,
-                    label: mode.label,
-                    ...(mode.description ? { description: mode.description } : {}),
-                })),
-            })),
-        }),
-    }));
+    }, async () => {
+        const providers = await Promise.all(Object.values(providerRegistry ?? {}).map((provider) => resolveProviderSummary(provider, childLogger)));
+        return {
+            content: [],
+            structuredContent: ensureValidJson({ providers }),
+        };
+    });
     server.registerTool("list_models", {
         title: "List models",
         description: "List models for an agent provider.",
@@ -1250,6 +1284,9 @@ export async function createAgentMcpServer(options) {
         if (!definition) {
             throw new Error(`Provider ${provider} is not configured`);
         }
+        if (!definition.enabled) {
+            throw new Error(`Provider '${provider}' is disabled`);
+        }
         const models = await definition.fetchModels({ cwd: resolveSnapshotCwd(), force: false });
         return {
             content: [],