@getpaseo/server 0.1.91-beta.2 → 0.1.92

package/dist/server/server/agent/providers/pi/test-utils/fake-pi.d.ts

@@ -15,6 +15,10 @@ export declare class FakePiSession implements PiRuntimeSession {
         message: string;
         imageCount: number;
     }>;
+    readonly compactRequests: Array<{
+        customInstructions?: string;
+    }>;
+    readonly setAutoCompactionRequests: boolean[];
     readonly setModelRequests: Array<{
         provider: string;
         modelId: string;
@@ -41,6 +45,8 @@ export declare class FakePiSession implements PiRuntimeSession {
     messages: PiAgentMessage[];
     stats: PiSessionStats;
     commands: PiRpcSlashCommand[];
+    compactError: Error | null;
+    emitCompactEnd: boolean;
     state: PiSessionState;
     private readonly subscribers;
     constructor(launch: PiRuntimeLaunch);
@@ -50,6 +56,8 @@ export declare class FakePiSession implements PiRuntimeSession {
         data: string;
         mimeType: string;
     }>): Promise<void>;
+    compact(customInstructions?: string): Promise<void>;
+    setAutoCompaction(enabled: boolean): Promise<void>;
     abort(): Promise<void>;
     getState(): Promise<PiSessionState>;
     getMessages(): Promise<PiAgentMessage[]>;

package/dist/server/server/agent/providers/pi/test-utils/fake-pi.js

@@ -31,6 +31,8 @@ export class FakePi {
 export class FakePiSession {
     constructor(launch) {
         this.prompts = [];
+        this.compactRequests = [];
+        this.setAutoCompactionRequests = [];
         this.setModelRequests = [];
         this.setThinkingLevelRequests = [];
         this.treeNavigationRequests = [];
@@ -46,12 +48,15 @@ export class FakePiSession {
             cost: 0,
         };
         this.commands = [];
+        this.compactError = null;
+        this.emitCompactEnd = true;
         this.subscribers = new Set();
         this.state = {
             model: null,
             thinkingLevel: "medium",
             isStreaming: false,
             isCompacting: false,
+            autoCompactionEnabled: true,
             sessionFile: launch.session ?? "/tmp/pi-session",
             sessionId: "pi-session-1",
             messageCount: 0,
@@ -69,6 +74,23 @@ export class FakePiSession {
         this.handleTreeNavigationCommand(message);
         this.handleEntryCaptureCommand(message);
     }
+    async compact(customInstructions) {
+        this.compactRequests.push(customInstructions === undefined ? {} : { customInstructions });
+        this.emit({ type: "compaction_start", reason: "manual" });
+        if (this.emitCompactEnd) {
+            this.emit({ type: "compaction_end", reason: "manual" });
+        }
+        if (this.compactError) {
+            throw this.compactError;
+        }
+    }
+    async setAutoCompaction(enabled) {
+        this.setAutoCompactionRequests.push(enabled);
+        this.state = {
+            ...this.state,
+            autoCompactionEnabled: enabled,
+        };
+    }
     async abort() {
         this.abortRequested = true;
     }

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

@@ -0,0 +1,8 @@
+import type { AgentSessionConfig } from "./agent-sdk-types.js";
+export declare function stripInternalPaseoMcpServer(config: AgentSessionConfig): AgentSessionConfig;
+export declare function withRuntimePaseoMcpServer(params: {
+    config: AgentSessionConfig;
+    agentId: string;
+    mcpBaseUrl: string | null;
+}): AgentSessionConfig;
+//# sourceMappingURL=runtime-mcp-config.d.ts.map

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

@@ -0,0 +1,50 @@
+const PASEO_MCP_SERVER_NAME = "paseo";
+const PASEO_MCP_PATHNAME = "/mcp/agents";
+export function stripInternalPaseoMcpServer(config) {
+    const mcpServers = config.mcpServers;
+    if (!mcpServers) {
+        return config;
+    }
+    const paseoServer = mcpServers[PASEO_MCP_SERVER_NAME];
+    if (!paseoServer || !isInternalPaseoMcpServer(paseoServer)) {
+        return config;
+    }
+    const nextMcpServers = { ...mcpServers };
+    delete nextMcpServers[PASEO_MCP_SERVER_NAME];
+    const next = { ...config };
+    if (Object.keys(nextMcpServers).length > 0) {
+        next.mcpServers = nextMcpServers;
+    }
+    else {
+        delete next.mcpServers;
+    }
+    return next;
+}
+export function withRuntimePaseoMcpServer(params) {
+    const storedConfig = stripInternalPaseoMcpServer(params.config);
+    if (!params.mcpBaseUrl || storedConfig.mcpServers?.[PASEO_MCP_SERVER_NAME]) {
+        return storedConfig;
+    }
+    return {
+        ...storedConfig,
+        mcpServers: {
+            [PASEO_MCP_SERVER_NAME]: {
+                type: "http",
+                url: `${params.mcpBaseUrl}?callerAgentId=${params.agentId}`,
+            },
+            ...storedConfig.mcpServers,
+        },
+    };
+}
+function isInternalPaseoMcpServer(config) {
+    if (config.type !== "http" && config.type !== "sse") {
+        return false;
+    }
+    try {
+        return new URL(config.url).pathname === PASEO_MCP_PATHNAME;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=runtime-mcp-config.js.map

package/dist/server/server/auto-archive-on-merge/archive-if-safe.js

@@ -34,10 +34,10 @@ export async function archiveIfSafe(input) {
         if (!snapshot) {
             return;
         }
-        if (snapshot.git.isDirty === true || snapshot.git.aheadOfOrigin === null) {
+        if (snapshot.git.isDirty === true) {
             return;
         }
-        if (snapshot.git.aheadOfOrigin > 0) {
+        if (typeof snapshot.git.aheadOfOrigin === "number" && snapshot.git.aheadOfOrigin > 0) {
             return;
         }
         const ownership = await deps.isPaseoOwnedWorktreeCwd(cwd, {

package/dist/server/server/daemon-worker.js

@@ -1,8 +1,39 @@
+import { appendFileSync, mkdirSync } from "node:fs";
+import path from "node:path";
 import { createPaseoDaemon } from "./bootstrap.js";
 import { loadConfig } from "./config.js";
 import { resolvePaseoHome } from "./paseo-home.js";
 import { createRootLogger } from "./logger.js";
 process.title = "Paseo Daemon";
+function isPidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        if (typeof err === "object" && err !== null && "code" in err && err.code === "EPERM") {
+            return true;
+        }
+        return false;
+    }
+}
+function writeWorkerLifecycleLog(paseoHome, message, fields = {}) {
+    try {
+        const logPath = path.join(paseoHome, "daemon.log");
+        mkdirSync(path.dirname(logPath), { recursive: true });
+        appendFileSync(logPath, `${JSON.stringify({
+            level: "warn",
+            time: new Date().toISOString(),
+            pid: process.pid,
+            name: "DaemonWorker",
+            msg: message,
+            ...fields,
+        })}\n`, "utf8");
+    }
+    catch {
+        // Exit-reason logging must never prevent the worker from exiting.
+    }
+}
 function bootstrapFromEnvironment() {
     try {
         const paseoHome = resolvePaseoHome();
@@ -31,7 +62,7 @@ function applyCliFlagOverrides(config) {
     }
 }
 async function main() {
-    const { logger, config } = bootstrapFromEnvironment();
+    const { paseoHome, logger, config } = bootstrapFromEnvironment();
     let daemon = null;
     let shutdownPromise = null;
     let exitHookInstalled = false;
@@ -107,6 +138,58 @@ async function main() {
         }
         beginShutdown("restart lifecycle intent", { successExitCode: 0 });
     };
+    const installSupervisorLivenessGuard = () => {
+        if (typeof process.send !== "function") {
+            return;
+        }
+        const supervisorPid = process.ppid;
+        let lastSupervisorHeartbeatAt = Date.now();
+        let supervisorExitRequested = false;
+        const exitAfterSupervisorLoss = (reason) => {
+            if (supervisorExitRequested) {
+                return;
+            }
+            supervisorExitRequested = true;
+            writeWorkerLifecycleLog(paseoHome, "Supervisor liveness lost; worker exiting", {
+                reason,
+                supervisorPid,
+                currentParentPid: process.ppid,
+                ipcConnected: typeof process.connected === "boolean" ? process.connected : null,
+                heartbeatAgeMs: Date.now() - lastSupervisorHeartbeatAt,
+            });
+            // The supervisor owns the worker's stdout/stderr pipes. Once it is gone,
+            // logging during graceful shutdown can block on the broken pipe and leave
+            // the daemon orphaned, so supervisor loss is a hard process boundary.
+            process.exit(0);
+        };
+        process.on("message", (message) => {
+            if (typeof message === "object" &&
+                message !== null &&
+                "type" in message &&
+                message.type === "paseo:supervisor-heartbeat") {
+                lastSupervisorHeartbeatAt = Date.now();
+            }
+        });
+        process.on("disconnect", () => exitAfterSupervisorLoss("ipc_disconnect_event"));
+        const timer = setInterval(() => {
+            const ipcConnected = typeof process.connected === "boolean" ? process.connected : true;
+            const heartbeatExpired = Date.now() - lastSupervisorHeartbeatAt > 3500;
+            const supervisorChanged = process.ppid !== supervisorPid;
+            if (ipcConnected === false) {
+                exitAfterSupervisorLoss("ipc_disconnected");
+                return;
+            }
+            if (supervisorChanged) {
+                exitAfterSupervisorLoss("supervisor_parent_pid_changed");
+                return;
+            }
+            if (heartbeatExpired && !isPidAlive(supervisorPid)) {
+                exitAfterSupervisorLoss("supervisor_pid_dead");
+            }
+        }, 1000);
+        timer.unref();
+    };
+    installSupervisorLivenessGuard();
     try {
         daemon = await createPaseoDaemon({
             ...config,

package/dist/server/server/file-upload/index.d.ts

@@ -0,0 +1,27 @@
+import { type FileTransferFrame } from "@getpaseo/protocol/binary-frames/index";
+import type { FileUploadRequest, FileUploadResponse } from "../messages.js";
+interface FileUploadStoreOptions {
+    paseoHome: string;
+    staleUploadTimeoutMs?: number;
+}
+export declare class FileUploadStore {
+    private static readonly defaultStaleUploadTimeoutMs;
+    private readonly paseoHome;
+    private readonly staleUploadTimeoutMs;
+    private readonly pending;
+    constructor(options: FileUploadStoreOptions);
+    beginUpload(request: FileUploadRequest): void;
+    receiveFrame(frame: FileTransferFrame): Promise<FileUploadResponse | null>;
+    private applyFrame;
+    private startWriting;
+    private writeChunk;
+    private completeUpload;
+    private createStaleUploadTimeout;
+    private refreshStaleUploadTimeout;
+    private expireStaleUpload;
+    private clearPendingUpload;
+    private removeFailedUpload;
+    private removeUploadDirectory;
+}
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/server/server/file-upload/index.js

@@ -0,0 +1,158 @@
+import { appendFile, mkdir, rm, writeFile } from "node:fs/promises";
+import { basename, join } from "node:path";
+import { FileTransferOpcode } from "@getpaseo/protocol/binary-frames/index";
+import { getErrorMessage } from "@getpaseo/protocol/error-utils";
+export class FileUploadStore {
+    constructor(options) {
+        this.pending = new Map();
+        this.paseoHome = options.paseoHome;
+        this.staleUploadTimeoutMs =
+            options.staleUploadTimeoutMs ?? FileUploadStore.defaultStaleUploadTimeoutMs;
+    }
+    beginUpload(request) {
+        const existingUpload = this.pending.get(request.requestId);
+        if (existingUpload) {
+            this.clearPendingUpload(existingUpload);
+            void existingUpload.queue.then(() => this.removeUploadDirectory(existingUpload));
+        }
+        const fileName = sanitizeFileName(request.fileName);
+        const attempt = existingUpload ? existingUpload.attempt + 1 : 1;
+        const id = buildUploadId(request.requestId, attempt);
+        const uploadDir = join(this.paseoHome, "uploads", id);
+        const upload = {
+            requestId: request.requestId,
+            id,
+            attempt,
+            fileName,
+            mimeType: request.mimeType,
+            size: request.size,
+            path: join(uploadDir, fileName),
+            receivedBytes: 0,
+            started: false,
+            staleTimeout: this.createStaleUploadTimeout(request.requestId),
+            queue: Promise.resolve(),
+        };
+        this.pending.set(request.requestId, upload);
+    }
+    async receiveFrame(frame) {
+        const upload = this.pending.get(frame.requestId);
+        if (!upload) {
+            return null;
+        }
+        this.refreshStaleUploadTimeout(upload);
+        const operation = upload.queue.then(() => this.applyFrame(upload, frame));
+        upload.queue = operation.then(() => undefined, () => undefined);
+        return operation;
+    }
+    async applyFrame(upload, frame) {
+        if (this.pending.get(upload.requestId) !== upload) {
+            return null;
+        }
+        try {
+            if (frame.opcode === FileTransferOpcode.FileBegin) {
+                await this.startWriting(upload);
+                return null;
+            }
+            if (frame.opcode === FileTransferOpcode.FileChunk) {
+                await this.writeChunk(upload, frame.payload);
+                return null;
+            }
+            return await this.completeUpload(upload);
+        }
+        catch (error) {
+            await this.removeFailedUpload(upload);
+            return buildUploadResponse(upload, getErrorMessage(error));
+        }
+    }
+    async startWriting(upload) {
+        await mkdir(join(this.paseoHome, "uploads", upload.id), { recursive: true });
+        await writeFile(upload.path, new Uint8Array());
+        upload.started = true;
+    }
+    async writeChunk(upload, bytes) {
+        if (!upload.started) {
+            throw new Error("Upload chunks arrived before file begin.");
+        }
+        const nextReceivedBytes = upload.receivedBytes + bytes.byteLength;
+        if (nextReceivedBytes > upload.size) {
+            throw new Error(`Upload exceeded declared size: expected ${upload.size}, received ${nextReceivedBytes}.`);
+        }
+        await appendFile(upload.path, bytes);
+        upload.receivedBytes += bytes.byteLength;
+    }
+    async completeUpload(upload) {
+        this.clearPendingUpload(upload);
+        if (upload.receivedBytes !== upload.size) {
+            await this.removeUploadDirectory(upload);
+            return buildUploadResponse(upload, `Upload size mismatch: expected ${upload.size}, received ${upload.receivedBytes}.`);
+        }
+        return buildUploadResponse(upload, null);
+    }
+    createStaleUploadTimeout(requestId) {
+        const timeout = setTimeout(() => {
+            this.expireStaleUpload(requestId);
+        }, this.staleUploadTimeoutMs);
+        timeout.unref?.();
+        return timeout;
+    }
+    refreshStaleUploadTimeout(upload) {
+        clearTimeout(upload.staleTimeout);
+        upload.staleTimeout = this.createStaleUploadTimeout(upload.requestId);
+    }
+    expireStaleUpload(requestId) {
+        const upload = this.pending.get(requestId);
+        if (!upload) {
+            return;
+        }
+        this.clearPendingUpload(upload);
+        const cleanup = upload.queue.then(() => this.removeUploadDirectory(upload), () => this.removeUploadDirectory(upload));
+        upload.queue = cleanup.then(() => undefined, () => undefined);
+    }
+    clearPendingUpload(upload) {
+        clearTimeout(upload.staleTimeout);
+        if (this.pending.get(upload.requestId) === upload) {
+            this.pending.delete(upload.requestId);
+        }
+    }
+    async removeFailedUpload(upload) {
+        this.clearPendingUpload(upload);
+        await this.removeUploadDirectory(upload);
+    }
+    async removeUploadDirectory(upload) {
+        await rm(join(this.paseoHome, "uploads", upload.id), { recursive: true, force: true }).catch(() => undefined);
+    }
+}
+FileUploadStore.defaultStaleUploadTimeoutMs = 10 * 60 * 1000;
+function buildUploadResponse(upload, error) {
+    return {
+        type: "file.upload.response",
+        payload: {
+            requestId: upload.requestId,
+            file: error
+                ? null
+                : {
+                    type: "uploaded_file",
+                    id: upload.id,
+                    fileName: upload.fileName,
+                    mimeType: upload.mimeType,
+                    size: upload.size,
+                    path: upload.path,
+                },
+            error,
+        },
+    };
+}
+function sanitizeUploadId(value) {
+    return value.replace(/[^a-zA-Z0-9._-]/g, "_") || "file";
+}
+function buildUploadId(requestId, attempt) {
+    const baseId = `upload_${sanitizeUploadId(requestId)}`;
+    return attempt === 1 ? baseId : `${baseId}_${attempt}`;
+}
+function sanitizeFileName(value) {
+    const name = basename(value)
+        .replace(/[^a-zA-Z0-9._ -]/g, "_")
+        .trim();
+    return name.length > 0 && name !== "." && name !== ".." ? name : "upload";
+}
+//# sourceMappingURL=index.js.map

package/dist/server/server/loop-service.d.ts

@@ -13,16 +13,16 @@ declare const LoopLogEntrySchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     text: string;
     level: "error" | "info";
-    source: "worker" | "loop" | "verifier" | "verify-check";
-    timestamp: string;
     seq: number;
+    timestamp: string;
+    source: "worker" | "loop" | "verifier" | "verify-check";
     iteration: number | null;
 }, {
     text: string;
     level: "error" | "info";
-    source: "worker" | "loop" | "verifier" | "verify-check";
-    timestamp: string;
     seq: number;
+    timestamp: string;
+    source: "worker" | "loop" | "verifier" | "verify-check";
     iteration: number | null;
 }>;
 declare const LoopVerifyCheckResultSchema: z.ZodObject<{
@@ -312,16 +312,16 @@ declare const LoopRecordSchema: z.ZodObject<{
     }, "strip", z.ZodTypeAny, {
         text: string;
         level: "error" | "info";
-        source: "worker" | "loop" | "verifier" | "verify-check";
-        timestamp: string;
         seq: number;
+        timestamp: string;
+        source: "worker" | "loop" | "verifier" | "verify-check";
         iteration: number | null;
     }, {
         text: string;
         level: "error" | "info";
-        source: "worker" | "loop" | "verifier" | "verify-check";
-        timestamp: string;
         seq: number;
+        timestamp: string;
+        source: "worker" | "loop" | "verifier" | "verify-check";
         iteration: number | null;
     }>, "many">;
     nextLogSeq: z.ZodNumber;
@@ -382,9 +382,9 @@ declare const LoopRecordSchema: z.ZodObject<{
     logs: {
         text: string;
         level: "error" | "info";
-        source: "worker" | "loop" | "verifier" | "verify-check";
-        timestamp: string;
         seq: number;
+        timestamp: string;
+        source: "worker" | "loop" | "verifier" | "verify-check";
         iteration: number | null;
     }[];
     nextLogSeq: number;
@@ -443,9 +443,9 @@ declare const LoopRecordSchema: z.ZodObject<{
     logs: {
         text: string;
         level: "error" | "info";
-        source: "worker" | "loop" | "verifier" | "verify-check";
-        timestamp: string;
         seq: number;
+        timestamp: string;
+        source: "worker" | "loop" | "verifier" | "verify-check";
         iteration: number | null;
     }[];
     nextLogSeq: number;

package/dist/server/server/persisted-config.d.ts

@@ -230,6 +230,7 @@ export declare const PersistedConfigSchema: z.ZodObject<{
             description: z.ZodOptional<z.ZodString>;
             command: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
             env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
             models: z.ZodOptional<z.ZodArray<z.ZodObject<{
                 id: z.ZodString;
                 label: z.ZodString;
@@ -323,6 +324,7 @@ export declare const PersistedConfigSchema: z.ZodObject<{
             order: z.ZodOptional<z.ZodNumber>;
         }, "strip", z.ZodTypeAny, {
             description?: string | undefined;
+            params?: Record<string, unknown> | undefined;
             label?: string | undefined;
             enabled?: boolean | undefined;
             command?: string[] | undefined;
@@ -356,6 +358,7 @@ export declare const PersistedConfigSchema: z.ZodObject<{
             order?: number | undefined;
         }, {
             description?: string | undefined;
+            params?: Record<string, unknown> | undefined;
             label?: string | undefined;
             enabled?: boolean | undefined;
             command?: string[] | undefined;
@@ -389,6 +392,7 @@ export declare const PersistedConfigSchema: z.ZodObject<{
             order?: number | undefined;
         }>>, Record<string, {
             description?: string | undefined;
+            params?: Record<string, unknown> | undefined;
             label?: string | undefined;
             enabled?: boolean | undefined;
             command?: string[] | undefined;
@@ -422,6 +426,7 @@ export declare const PersistedConfigSchema: z.ZodObject<{
             order?: number | undefined;
         }>, Record<string, {
             description?: string | undefined;
+            params?: Record<string, unknown> | undefined;
             label?: string | undefined;
             enabled?: boolean | undefined;
             command?: string[] | undefined;
@@ -455,6 +460,7 @@ export declare const PersistedConfigSchema: z.ZodObject<{
             order?: number | undefined;
         }>>, Record<string, {
             description?: string | undefined;
+            params?: Record<string, unknown> | undefined;
             label?: string | undefined;
             enabled?: boolean | undefined;
             command?: string[] | undefined;
@@ -524,6 +530,7 @@ export declare const PersistedConfigSchema: z.ZodObject<{
         } | undefined;
         providers?: Record<string, {
             description?: string | undefined;
+            params?: Record<string, unknown> | undefined;
             label?: string | undefined;
             enabled?: boolean | undefined;
             command?: string[] | undefined;
@@ -925,6 +932,7 @@ export declare const PersistedConfigSchema: z.ZodObject<{
         } | undefined;
         providers?: Record<string, {
             description?: string | undefined;
+            params?: Record<string, unknown> | undefined;
             label?: string | undefined;
             enabled?: boolean | undefined;
             command?: string[] | undefined;

package/dist/server/server/persisted-config.js

@@ -129,7 +129,7 @@ const AgentMetadataGenerationSchema = z
     providers: z.array(StructuredGenerationProviderConfigSchema).optional(),
 })
     .strict();
-const BUILTIN_PROVIDER_IDS = ["claude", "codex", "copilot", "opencode", "pi"];
+const BUILTIN_PROVIDER_IDS = ["claude", "codex", "copilot", "opencode", "pi", "omp"];
 function isLegacyProviderEntry(value) {
     if (!value || typeof value !== "object" || Array.isArray(value)) {
         return false;

package/dist/server/server/persistence-hooks.js

@@ -1,3 +1,4 @@
+import { stripInternalPaseoMcpServer } from "./agent/runtime-mcp-config.js";
 function getLogger(logger) {
     return logger.child({ module: "persistence" });
 }
@@ -21,7 +22,8 @@ export function attachAgentStoragePersistence(logger, agentManager, storage) {
     return unsubscribe;
 }
 export function buildConfigOverrides(record) {
-    return {
+    return stripInternalPaseoMcpServer({
+        provider: record.provider,
         cwd: record.cwd,
         modeId: record.lastModeId ?? record.config?.modeId ?? undefined,
         model: record.config?.model ?? undefined,
@@ -30,7 +32,7 @@ export function buildConfigOverrides(record) {
         extra: record.config?.extra ?? undefined,
         systemPrompt: record.config?.systemPrompt ?? undefined,
         mcpServers: record.config?.mcpServers ?? undefined,
-    };
+    });
 }
 export function buildSessionConfig(record, options) {
     const validProviders = options?.validProviders;
@@ -39,7 +41,7 @@ export function buildSessionConfig(record, options) {
         return null;
     }
     const overrides = buildConfigOverrides(record);
-    return {
+    return stripInternalPaseoMcpServer({
         provider: record.provider,
         cwd: record.cwd,
         modeId: overrides.modeId,
@@ -49,7 +51,7 @@ export function buildSessionConfig(record, options) {
         extra: overrides.extra,
         systemPrompt: overrides.systemPrompt,
         mcpServers: overrides.mcpServers,
-    };
+    });
 }
 export function isStoredAgentProviderAvailable(record, validProviders) {
     return buildSessionConfig(record, { validProviders }) !== null;

package/dist/server/server/session.d.ts

@@ -1,7 +1,7 @@
 import { type ClientCapability } from "@getpaseo/protocol/client-capabilities";
 import { type AgentSnapshotPayload, type SessionInboundMessage, type SessionOutboundMessage, type WorkspaceSetupSnapshot } from "./messages.js";
 import type { TerminalManager } from "../terminal/terminal-manager.js";
-import { type TerminalStreamFrame } from "@getpaseo/protocol/binary-frames/index";
+import { type BinaryFrame } from "@getpaseo/protocol/binary-frames/index";
 import type { SpeechToTextProvider, TextToSpeechProvider } from "./speech/speech-provider.js";
 import type { TurnDetectionProvider } from "./speech/turn-detection-provider.js";
 import type { VoiceCallerContext, VoiceSpeakHandler } from "./voice-types.js";
@@ -181,6 +181,7 @@ export declare class Session {
     private readonly workspaceSetupSnapshots;
     private readonly workspaceGitFetchSubscriptions;
     private readonly workspaceGitSubscriptions;
+    private readonly fileUploads;
     private readonly workspaceDirectory;
     private registerVoiceSpeakHandler?;
     private unregisterVoiceSpeakHandler?;
@@ -286,7 +287,7 @@ export declare class Session {
     private dispatchScheduleMessage;
     private dispatchMiscMessage;
     resetPeakInflight(): void;
-    handleBinaryFrame(frame: TerminalStreamFrame): void;
+    handleBinaryFrame(binaryFrame: BinaryFrame): Promise<void>;
     private handleRestartServerRequest;
     private handleShutdownServerRequest;
     private emitLifecycleIntent;
@@ -420,6 +421,8 @@ export declare class Session {
      * Handle read-only file explorer requests scoped to a workspace cwd
      */
     private handleFileExplorerRequest;
+    private handleFileUploadRequest;
+    private handleFileTransferFrame;
     /**
      * Handle project icon request for a given cwd
      */