@getpaseo/server 0.1.100 → 0.1.101

package/dist/server/executable-resolution/windows.js

@@ -41,6 +41,9 @@ async function findFirstProbeable(candidates, options) {
             continue;
         }
         seen.add(candidate);
+        if (!options.exists(candidate)) {
+            continue;
+        }
         if (await options.probeExecutable(candidate, options.probeTimeoutMs)) {
             return candidate;
         }

package/dist/server/server/agent/agent-manager.d.ts

@@ -6,6 +6,7 @@ import type { StoredAgentRecord, AgentStorage } from "./agent-storage.js";
 import type { AgentTimelineFetchOptions, AgentTimelineFetchResult, AgentTimelineRow, AgentTimelineStore } from "./agent-timeline-store-types.js";
 import { type ForegroundTurnWaiter } from "./foreground-run-state.js";
 import { type RewindMode } from "./rewind/rewind.js";
+import type { PaseoToolCatalogFactory } from "./tools/types.js";
 export { AGENT_LIFECYCLE_STATUSES, type AgentLifecycleStatus };
 export type { AgentTimelineCursor, AgentTimelineFetchDirection, AgentTimelineFetchOptions, AgentTimelineFetchResult, AgentTimelineRow, AgentTimelineWindow, } from "./agent-timeline-store-types.js";
 export type AgentManagerEvent = {
@@ -72,6 +73,8 @@ export interface AgentManagerOptions {
     terminalManager?: TerminalManager | null;
     mcpBaseUrl?: string;
     mcpAuthToken?: string;
+    paseoToolsEnabled?: boolean;
+    paseoToolCatalogFactory?: PaseoToolCatalogFactory;
     appendSystemPrompt?: string;
     agentStreamCoalesceWindowMs?: number;
     rescueTimeouts?: AgentManagerRescueTimeouts;
@@ -190,6 +193,8 @@ export declare class AgentManager {
     private readonly agentStreamCoalescer;
     private mcpBaseUrl;
     private readonly mcpAuthToken;
+    private paseoToolsEnabled;
+    private paseoToolCatalogFactory;
     private appendSystemPrompt;
     private onAgentAttention?;
     private onAgentArchived?;
@@ -197,6 +202,7 @@ export declare class AgentManager {
     private logger;
     private readonly rescueTimeouts;
     constructor(options: AgentManagerOptions);
+    private configurePaseoTools;
     registerClient(provider: AgentProvider, client: AgentClient): void;
     updateProviderRegistry(input: {
         providerDefinitions: ProviderEnabledMap;
@@ -206,6 +212,8 @@ export declare class AgentManager {
     setAgentAttentionCallback(callback: AgentAttentionCallback): void;
     setAgentArchivedCallback(callback: AgentArchivedCallback): void;
     setMcpBaseUrl(url: string | null): void;
+    setPaseoToolsEnabled(enabled: boolean): void;
+    setPaseoToolCatalogFactory(factory: PaseoToolCatalogFactory | null): void;
     /**
      * Capability token the daemon's own MCP clients must present to the Agent MCP
      * endpoint when a daemon password is configured. Read by the per-client
@@ -372,9 +380,11 @@ export declare class AgentManager {
     private dispatchStream;
     private dispatch;
     private normalizeConfig;
+    private resolveDefaultModelId;
     private prepareSessionConfig;
     private applyDaemonAppendSystemPrompt;
     private buildLaunchContext;
+    private resolveProviderLaunchConfig;
     private requireAvailableClient;
     private requireEnabledProvider;
     private getConfiguredProviderIds;

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

@@ -185,6 +185,8 @@ export class AgentManager {
         this.subscribers = new Set();
         this.previousStatuses = new Map();
         this.backgroundTasks = new Set();
+        this.paseoToolsEnabled = true;
+        this.paseoToolCatalogFactory = null;
         this.idFactory = options?.idFactory ?? (() => randomUUID());
         this.registry = options?.registry;
         this.durableTimelineStore = options?.durableTimelineStore;
@@ -192,6 +194,7 @@ export class AgentManager {
         this.onWorkspaceStateMayHaveChanged = options?.onWorkspaceStateMayHaveChanged;
         this.mcpBaseUrl = options?.mcpBaseUrl ?? null;
         this.mcpAuthToken = options?.mcpAuthToken ?? null;
+        this.configurePaseoTools(options);
         this.appendSystemPrompt = options.appendSystemPrompt ?? "";
         this.logger = options.logger.child({ module: "agent", component: "agent-manager" });
         this.rescueTimeouts = {
@@ -211,6 +214,10 @@ export class AgentManager {
             clients: options.clients ?? {},
         });
     }
+    configurePaseoTools(options) {
+        this.paseoToolsEnabled = options.paseoToolsEnabled ?? true;
+        this.paseoToolCatalogFactory = options.paseoToolCatalogFactory ?? null;
+    }
     registerClient(provider, client) {
         this.clients.set(provider, client);
     }
@@ -238,6 +245,12 @@ export class AgentManager {
     setMcpBaseUrl(url) {
         this.mcpBaseUrl = url;
     }
+    setPaseoToolsEnabled(enabled) {
+        this.paseoToolsEnabled = enabled;
+    }
+    setPaseoToolCatalogFactory(factory) {
+        this.paseoToolCatalogFactory = factory;
+    }
     /**
      * Capability token the daemon's own MCP clients must present to the Agent MCP
      * endpoint when a daemon password is configured. Read by the per-client
@@ -403,8 +416,11 @@ export class AgentManager {
         }
     }
     async listDraftCommands(config) {
-        const normalizedConfig = await this.normalizeConfig(config);
+        const normalizedConfig = await this.normalizeConfig(config, { resolveDefaultModel: false });
         const client = this.requireClient(normalizedConfig.provider);
+        if (!normalizedConfig.model) {
+            return [];
+        }
         const available = await client.isAvailable();
         if (!available) {
             throw new Error(`Provider '${normalizedConfig.provider}' is not available. Please ensure the CLI is installed.`);
@@ -429,8 +445,11 @@ export class AgentManager {
         }
     }
     async listDraftFeatures(config) {
-        const normalizedConfig = await this.normalizeConfig(config);
+        const normalizedConfig = await this.normalizeConfig(config, { resolveDefaultModel: false });
         const client = this.requireClient(normalizedConfig.provider);
+        if (!normalizedConfig.model) {
+            return [];
+        }
         const available = await client.isAvailable();
         if (!available) {
             throw new Error(`Provider '${normalizedConfig.provider}' is not available. Please ensure the CLI is installed.`);
@@ -474,12 +493,13 @@ export class AgentManager {
         const resolvedAgentId = validateAgentId(agentId ?? this.idFactory(), "createAgent");
         const { storedConfig, launchConfig } = await this.prepareSessionConfig(config, resolvedAgentId);
         this.requireEnabledProvider(storedConfig.provider);
-        const launchContext = this.buildLaunchContext(resolvedAgentId, options?.env);
         const client = await this.requireAvailableClient({
             provider: storedConfig.provider,
         });
+        const launchContext = await this.buildLaunchContext(resolvedAgentId, client, options?.env);
+        const providerLaunchConfig = this.resolveProviderLaunchConfig(launchConfig, launchContext);
         const createOptions = this.buildCreateSessionOptions(options);
-        const session = await client.createSession(launchConfig, launchContext, createOptions);
+        const session = await client.createSession(providerLaunchConfig, launchContext, createOptions);
         return this.registerSession(session, storedConfig, resolvedAgentId, {
             labels: options?.labels,
             initialTitle: options?.initialTitle,
@@ -502,13 +522,14 @@ export class AgentManager {
             provider: handle.provider,
         };
         const { storedConfig, launchConfig } = await this.prepareSessionConfig(mergedConfig, resolvedAgentId);
-        const launchContext = this.buildLaunchContext(resolvedAgentId);
         const client = this.requireClient(handle.provider);
         const available = await client.isAvailable();
         if (!available) {
             throw new Error(`Provider '${handle.provider}' is not available. Please ensure the CLI is installed.`);
         }
-        const session = await client.resumeSession(handle, launchConfig, launchContext);
+        const launchContext = await this.buildLaunchContext(resolvedAgentId, client);
+        const providerLaunchConfig = this.resolveProviderLaunchConfig(launchConfig, launchContext);
+        const session = await client.resumeSession(handle, providerLaunchConfig, launchContext);
         return this.registerSession(session, storedConfig, resolvedAgentId, options);
     }
     async importProviderSession(input) {
@@ -522,11 +543,12 @@ export class AgentManager {
             provider: input.provider,
             cwd: input.cwd,
         }, resolvedAgentId);
-        const launchContext = this.buildLaunchContext(resolvedAgentId);
+        const launchContext = await this.buildLaunchContext(resolvedAgentId, client);
+        const providerLaunchConfig = this.resolveProviderLaunchConfig(launchConfig, launchContext);
         const imported = await client.importSession({
             providerHandleId: input.providerHandleId,
             cwd: input.cwd,
-        }, { config: launchConfig, storedConfig, launchContext });
+        }, { config: providerLaunchConfig, storedConfig, launchContext });
         const importedConfig = await this.normalizeConfig(stripInternalPaseoMcpServer(imported.config));
         const timelineRows = buildImportedTimelineRows(imported.timeline);
         const initialTitle = resolveImportedAgentTitle(importedConfig, timelineRows);
@@ -567,10 +589,11 @@ export class AgentManager {
             provider,
         };
         const { storedConfig, launchConfig } = await this.prepareSessionConfig(refreshConfig, agentId);
-        const launchContext = this.buildLaunchContext(agentId);
+        const launchContext = await this.buildLaunchContext(agentId, client);
+        const providerLaunchConfig = this.resolveProviderLaunchConfig(launchConfig, launchContext);
         const session = handle
-            ? await client.resumeSession(handle, launchConfig, launchContext)
-            : await client.createSession(launchConfig, launchContext);
+            ? await client.resumeSession(handle, providerLaunchConfig, launchContext)
+            : await client.createSession(providerLaunchConfig, launchContext);
         this.agentStreamCoalescer.flushAndDiscard(agentId);
         // Remove the existing agent entry before swapping sessions
         this.agents.delete(agentId);
@@ -2549,7 +2572,7 @@ export class AgentManager {
             subscriber.callback(event);
         }
     }
-    async normalizeConfig(config) {
+    async normalizeConfig(config, options = {}) {
         const normalized = { ...config };
         // Always resolve cwd to absolute path for consistent history file lookup
         if (normalized.cwd) {
@@ -2576,19 +2599,11 @@ export class AgentManager {
             const trimmed = normalized.model.trim();
             normalized.model = trimmed.length > 0 && trimmed !== "default" ? trimmed : undefined;
         }
-        if (!normalized.model) {
-            const client = this.clients.get(normalized.provider);
-            if (client) {
-                try {
-                    const catalog = await client.fetchCatalog({ cwd: normalized.cwd, force: false });
-                    const defaultModel = catalog.models.find((model) => model.isDefault) ?? catalog.models[0];
-                    if (defaultModel) {
-                        normalized.model = defaultModel.id;
-                    }
-                }
-                catch {
-                    // Provider may not support model listing — leave model undefined
-                }
+        const shouldResolveDefaultModel = options.resolveDefaultModel ?? true;
+        if (shouldResolveDefaultModel && !normalized.model) {
+            const defaultModelId = await this.resolveDefaultModelId(normalized);
+            if (defaultModelId) {
+                normalized.model = defaultModelId;
             }
         }
         if (!normalized.modeId) {
@@ -2602,6 +2617,20 @@ export class AgentManager {
         }
         return normalized;
     }
+    async resolveDefaultModelId(config) {
+        const client = this.clients.get(config.provider);
+        if (!client) {
+            return undefined;
+        }
+        try {
+            const catalog = await client.fetchCatalog({ cwd: config.cwd, force: false });
+            return (catalog.models.find((model) => model.isDefault) ?? catalog.models[0])?.id;
+        }
+        catch {
+            // Provider may not support model listing — leave model undefined.
+            return undefined;
+        }
+    }
     async prepareSessionConfig(config, agentId) {
         const storedConfig = await this.normalizeConfig(stripInternalPaseoMcpServer(config));
         const launchConfig = this.applyDaemonAppendSystemPrompt(withRuntimePaseoMcpServer({
@@ -2623,14 +2652,23 @@ export class AgentManager {
             }
             : next;
     }
-    buildLaunchContext(agentId, env) {
-        return {
+    async buildLaunchContext(agentId, client, env) {
+        const context = {
             agentId,
             env: {
                 ...env,
                 PASEO_AGENT_ID: agentId,
             },
         };
+        if (this.paseoToolsEnabled &&
+            client.capabilities.supportsNativePaseoTools &&
+            this.paseoToolCatalogFactory) {
+            context.paseoTools = await this.paseoToolCatalogFactory({ callerAgentId: agentId });
+        }
+        return context;
+    }
+    resolveProviderLaunchConfig(launchConfig, launchContext) {
+        return launchContext.paseoTools ? stripInternalPaseoMcpServer(launchConfig) : launchConfig;
     }
     async requireAvailableClient(options) {
         const client = this.clients.get(options.provider);

package/dist/server/server/agent/agent-sdk-types.d.ts

@@ -1,6 +1,7 @@
 import type { Options as ClaudeAgentOptions } from "@anthropic-ai/claude-agent-sdk";
 import type { AgentProviderNotice } from "@getpaseo/protocol/agent-types";
 import type { AgentAttachment } from "@getpaseo/protocol/messages";
+import type { PaseoToolCatalog } from "./tools/types.js";
 export type { AgentProviderNotice };
 export type AgentProvider = string;
 export interface AgentMetadata {
@@ -141,6 +142,7 @@ export interface AgentCapabilityFlags {
     supportsSessionListing?: boolean;
     supportsDynamicModes: boolean;
     supportsMcpServers: boolean;
+    supportsNativePaseoTools?: boolean;
     supportsReasoningStream: boolean;
     supportsToolInvocations: boolean;
     supportsRewindConversation?: boolean;
@@ -516,6 +518,11 @@ export interface AgentSessionConfig {
 export interface AgentLaunchContext {
     agentId?: string;
     env?: Record<string, string>;
+    /**
+     * Runtime-only internal Paseo tools. This must never be persisted into
+     * AgentSessionConfig; providers may adapt it to their native tool surface.
+     */
+    paseoTools?: PaseoToolCatalog;
 }
 export interface AgentCreateSessionOptions {
     /**
@@ -581,6 +588,7 @@ export interface AgentSession {
 export interface FetchCatalogOptions {
     cwd: string;
     force: boolean;
+    timeoutMs?: number;
 }
 export interface ProviderCatalog {
     models: AgentModelDefinition[];

package/dist/server/server/agent/mcp-server.d.ts

@@ -1,48 +1,5 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import type { Logger } from "pino";
-import type { AgentManager } from "./agent-manager.js";
-import type { AgentStorage } from "./agent-storage.js";
-import { type ArchiveDependencies } from "../workspace-archive-service.js";
-import type { VoiceCallerContext, VoiceSpeakHandler } from "../voice-types.js";
-import type { TerminalManager } from "../../terminal/terminal-manager.js";
-import type { CreatePaseoWorktreeWorkflowFn } from "../worktree-session.js";
-import type { ScheduleService } from "../schedule/service.js";
-import { type ProviderSnapshotManager } from "./provider-snapshot-manager.js";
-import type { GitHubService } from "../../services/github-service.js";
-import type { WorkspaceGitService } from "../workspace-git-service.js";
-export interface AgentMcpServerOptions {
-    agentManager: AgentManager;
-    agentStorage: AgentStorage;
-    terminalManager?: TerminalManager | null;
-    getDaemonTcpPort?: () => number | null;
-    scheduleService?: ScheduleService | null;
-    providerSnapshotManager: ProviderSnapshotManager;
-    github?: GitHubService;
-    workspaceGitService?: Pick<WorkspaceGitService, "getSnapshot" | "listWorktrees" | "resolveRepoRoot">;
-    findWorkspaceIdForCwd?: ArchiveDependencies["findWorkspaceIdForCwd"];
-    listActiveWorkspaces?: ArchiveDependencies["listActiveWorkspaces"];
-    archiveWorkspaceRecord?: ArchiveDependencies["archiveWorkspaceRecord"];
-    emitWorkspaceUpdatesForWorkspaceIds?: ArchiveDependencies["emitWorkspaceUpdatesForWorkspaceIds"];
-    markWorkspaceArchiving?: ArchiveDependencies["markWorkspaceArchiving"];
-    clearWorkspaceArchiving?: ArchiveDependencies["clearWorkspaceArchiving"];
-    createPaseoWorktree?: CreatePaseoWorktreeWorkflowFn;
-    ensureWorkspaceForCreate?: (cwd: string) => Promise<string>;
-    paseoHome?: string;
-    worktreesRoot?: string;
-    /**
-     * ID of the agent that is connecting to this MCP server.
-     * Used for cwd/mode inheritance when agents spawn child agents.
-     */
-    callerAgentId?: string;
-    /**
-     * Optional resolver for session-bound speak handlers.
-     * Used by hidden voice agents to narrate through daemon-managed TTS.
-     */
-    resolveSpeakHandler?: (callerAgentId: string) => VoiceSpeakHandler | null;
-    resolveCallerContext?: (callerAgentId: string) => VoiceCallerContext | null;
-    enableVoiceTools?: boolean;
-    voiceOnly?: boolean;
-    logger: Logger;
-}
+import { type PaseoToolHostDependencies } from "./tools/paseo-tools.js";
+export type AgentMcpServerOptions = PaseoToolHostDependencies;
 export declare function createAgentMcpServer(options: AgentMcpServerOptions): Promise<McpServer>;
 //# sourceMappingURL=mcp-server.d.ts.map