@getpaseo/server 0.1.100 → 0.1.102-beta.2

package/dist/scripts/supervisor.js

@@ -11,7 +11,11 @@ function parseLifecycleMessage(msg) {
     }
     const type = msg.type;
     if (type === "paseo:shutdown") {
-        return { type: "paseo:shutdown" };
+        const reason = msg.reason;
+        return {
+            type: "paseo:shutdown",
+            ...(typeof reason === "string" && reason.trim().length > 0 ? { reason } : {}),
+        };
     }
     if (type === "paseo:ready") {
         const listen = msg.listen;
@@ -169,12 +173,14 @@ export function runSupervisor(options) {
                 return;
             }
             if (lifecycleMessage.type === "paseo:shutdown") {
-                writeLifecycleLog("Worker requested shutdown");
-                requestShutdown("Shutdown requested by worker");
+                const reason = lifecycleMessage.reason ?? "worker_requested_shutdown";
+                writeLifecycleLog("Worker requested shutdown", { reason });
+                requestShutdown(reason);
                 return;
             }
-            writeLifecycleLog("Worker requested restart", lifecycleMessage.reason ? { reason: lifecycleMessage.reason } : {});
-            requestRestart("Restart requested by worker");
+            const reason = lifecycleMessage.reason ?? "worker_requested_restart";
+            writeLifecycleLog("Worker requested restart", { reason });
+            requestRestart(reason);
         });
         child.on("close", (code, signal) => {
             clearInterval(heartbeat);
@@ -199,6 +205,18 @@ export function runSupervisor(options) {
             exitSupervisor(typeof code === "number" ? code : 1);
         });
     };
+    const signalWorker = (signal, reason) => {
+        if (!child) {
+            return;
+        }
+        writeLifecycleLog("Supervisor sending signal to worker", {
+            reason,
+            signal,
+            supervisorPid: process.pid,
+            workerPid: child.pid ?? null,
+        });
+        child.kill(signal);
+    };
     const requestRestart = (reason) => {
         if (!child || restarting || shuttingDown) {
             return;
@@ -206,7 +224,7 @@ export function runSupervisor(options) {
         restarting = true;
         writeLifecycleLog("Restart requested", { reason });
         log(`${reason}. Stopping worker for restart...`);
-        child.kill("SIGTERM");
+        signalWorker("SIGTERM", reason);
     };
     const requestShutdown = (reason) => {
         if (shuttingDown) {
@@ -220,10 +238,10 @@ export function runSupervisor(options) {
             exitSupervisor(0);
             return;
         }
-        child.kill("SIGTERM");
+        signalWorker("SIGTERM", reason);
     };
     const forwardSignal = (signal) => {
-        requestShutdown(`Received ${signal}`);
+        requestShutdown(`supervisor_received_${signal}`);
     };
     process.on("SIGINT", () => forwardSignal("SIGINT"));
     process.on("SIGTERM", () => forwardSignal("SIGTERM"));

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/activity-curator.d.ts

@@ -1,11 +1,28 @@
 import type { AgentTimelineItem } from "./agent-sdk-types.js";
+import type { AgentAttachment } from "@getpaseo/protocol/messages";
+import type { AgentTimelineRow } from "./agent-timeline-store-types.js";
 interface ActivityCuratorOptions {
     maxItems?: number;
     labelAssistantMessages?: boolean;
+    includeKinds?: readonly AgentTimelineItem["type"][];
+    includeExternalToolInput?: boolean;
 }
+type TextAgentAttachment = Extract<AgentAttachment, {
+    type: "text";
+}>;
 /**
  * Convert normalized agent timeline items into a concise text summary.
  */
 export declare function curateAgentActivity(timeline: AgentTimelineItem[], options?: ActivityCuratorOptions): string;
+export declare function buildAgentForkContextAttachment(input: {
+    rows: readonly AgentTimelineRow[];
+    boundaryMessageId?: string | null;
+    agentTitle?: string | null;
+    cwd?: string | null;
+}): {
+    attachment: TextAgentAttachment;
+    itemCount: number;
+    boundaryMessageId: string | null;
+};
 export {};
 //# sourceMappingURL=activity-curator.d.ts.map

package/dist/server/server/agent/activity-curator.js

@@ -71,16 +71,42 @@ function projectForCuration(items) {
     }));
     return projectTimelineRows({ rows, mode: "projected" }).map((entry) => entry.item);
 }
-function curateAgentActivityEntries(timeline, options) {
-    if (timeline.length === 0) {
+function shouldIncludeItem(item, options) {
+    if (!options?.includeKinds) {
+        return true;
+    }
+    return options.includeKinds.includes(item.type);
+}
+function formatToolCallEntry(item, options) {
+    const inputJson = formatToolInputJson(inputFromUnknownDetail(item.detail));
+    const display = buildToolCallDisplayModel({
+        name: item.name,
+        status: item.status,
+        error: item.error,
+        detail: item.detail,
+        metadata: item.metadata,
+    });
+    const displayName = display.displayName;
+    const summary = formatToolSummary(display.summary);
+    if ((options?.includeExternalToolInput ?? true) &&
+        isLikelyExternalToolName(item.name) &&
+        inputJson) {
+        return activityEntry(`[${displayName}] ${inputJson}`);
+    }
+    return activityEntry(summary ? `[${displayName}] ${summary}` : `[${displayName}]`);
+}
+function curateProjectedActivityEntries(items, options) {
+    if (items.length === 0) {
         return [];
     }
-    const collapsed = projectForCuration(timeline);
     const maxItems = options?.maxItems ?? DEFAULT_MAX_ITEMS;
-    const recentItems = maxItems > 0 && collapsed.length > maxItems ? collapsed.slice(-maxItems) : collapsed;
+    const recentItems = maxItems > 0 && items.length > maxItems ? items.slice(-maxItems) : items;
     const entries = [];
     const buffers = { message: "", thought: "" };
     for (const item of recentItems) {
+        if (!shouldIncludeItem(item, options)) {
+            continue;
+        }
         switch (item.type) {
             case "user_message":
                 flushBuffers(entries, buffers, options);
@@ -94,26 +120,7 @@ function curateAgentActivityEntries(timeline, options) {
                 break;
             case "tool_call": {
                 flushBuffers(entries, buffers, options);
-                const inputJson = formatToolInputJson(inputFromUnknownDetail(item.detail));
-                const display = buildToolCallDisplayModel({
-                    name: item.name,
-                    status: item.status,
-                    error: item.error,
-                    detail: item.detail,
-                    metadata: item.metadata,
-                });
-                const displayName = display.displayName;
-                const summary = formatToolSummary(display.summary);
-                if (isLikelyExternalToolName(item.name) && inputJson) {
-                    entries.push(activityEntry(`[${displayName}] ${inputJson}`));
-                    break;
-                }
-                if (summary) {
-                    entries.push(activityEntry(`[${displayName}] ${summary}`));
-                }
-                else {
-                    entries.push(activityEntry(`[${displayName}]`));
-                }
+                entries.push(formatToolCallEntry(item, options));
                 break;
             }
             case "todo":
@@ -138,6 +145,10 @@ function curateAgentActivityEntries(timeline, options) {
     flushBuffers(entries, buffers, options);
     return entries;
 }
+function curateAgentActivityEntries(timeline, options) {
+    const collapsed = projectForCuration(timeline);
+    return curateProjectedActivityEntries(collapsed, options);
+}
 /**
  * Convert normalized agent timeline items into a concise text summary.
  */
@@ -147,4 +158,70 @@ export function curateAgentActivity(timeline, options) {
         ? entries.map((entry) => entry.text).join("\n")
         : "No activity to display.";
 }
+function selectForkContextRows(input) {
+    const boundaryMessageId = input.boundaryMessageId?.trim() || null;
+    if (!boundaryMessageId) {
+        const projected = projectTimelineRows({ rows: input.rows, mode: "projected" });
+        return {
+            items: projected.map((entry) => entry.item),
+            boundaryMessageId: null,
+        };
+    }
+    const boundaryIndex = input.rows.findLastIndex((row) => row.item.type === "assistant_message" && row.item.messageId === boundaryMessageId);
+    if (boundaryIndex < 0) {
+        throw new Error("Selected assistant message is no longer available.");
+    }
+    const selectedRows = input.rows.slice(0, boundaryIndex + 1);
+    const projected = projectTimelineRows({ rows: selectedRows, mode: "projected" });
+    return {
+        items: projected.map((entry) => entry.item),
+        boundaryMessageId,
+    };
+}
+function trimContextMetadata(value) {
+    const trimmed = value?.trim();
+    return trimmed ? trimmed : null;
+}
+function buildForkContextText(input) {
+    const header = ["Chat history from a previous Paseo agent."];
+    const agentTitle = trimContextMetadata(input.agentTitle);
+    const cwd = trimContextMetadata(input.cwd);
+    if (agentTitle) {
+        header.push(`Source agent: ${agentTitle}`);
+    }
+    if (cwd) {
+        header.push(`Source directory: ${cwd}`);
+    }
+    return `${header.join("\n")}\n\n${input.body}`;
+}
+export function buildAgentForkContextAttachment(input) {
+    const selected = selectForkContextRows({
+        rows: input.rows,
+        boundaryMessageId: input.boundaryMessageId,
+    });
+    const entries = curateProjectedActivityEntries(selected.items, {
+        maxItems: 0,
+        labelAssistantMessages: true,
+        includeKinds: ["user_message", "assistant_message", "tool_call"],
+        includeExternalToolInput: false,
+    });
+    const body = entries.length > 0
+        ? entries.map((entry) => entry.text).join("\n")
+        : "No chat history to display.";
+    return {
+        attachment: {
+            type: "text",
+            mimeType: "text/plain",
+            contextKind: "chat_history",
+            title: "Chat history",
+            text: buildForkContextText({
+                body,
+                agentTitle: input.agentTitle,
+                cwd: input.cwd,
+            }),
+        },
+        itemCount: selected.items.length,
+        boundaryMessageId: selected.boundaryMessageId,
+    };
+}
 //# sourceMappingURL=activity-curator.js.map

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,24 @@ 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({
+                scope: "workspace",
+                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 +2656,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 {
     /**
@@ -578,10 +585,16 @@ export interface AgentSession {
         }): Promise<void>;
     } | null;
 }
-export interface FetchCatalogOptions {
+export type FetchCatalogOptions = {
+    scope: "global";
+    force: boolean;
+    timeoutMs?: number;
+} | {
+    scope: "workspace";
     cwd: string;
     force: boolean;
-}
+    timeoutMs?: number;
+};
 export interface ProviderCatalog {
     models: AgentModelDefinition[];
     modes: AgentMode[];

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