@getpaseo/server 0.1.99 → 0.1.101

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

@@ -1,3 +1,4 @@
+import { createOpencodeClient, } from "@opencode-ai/sdk/v2/client";
 import { createPathEquivalenceMatcher } from "../../../utils/path.js";
 import pLimit from "p-limit";
 import { z } from "zod";
@@ -9,12 +10,11 @@ import { withTimeout } from "../../../utils/promise-timeout.js";
 import { execCommand } from "../../../utils/spawn.js";
 import { buildToolCallDisplayModel } from "@getpaseo/protocol/tool-call-display";
 import { mapOpencodeToolCall } from "./opencode/tool-call-mapper.js";
-import { OpenCodeServerManager } from "./opencode/server-manager.js";
+import { OpenCodeServerManager, } from "./opencode/server-manager.js";
 import { formatProviderDiagnostic, formatProviderDiagnosticError, buildBinaryDiagnosticRows, buildCommandResolutionDiagnosticRows, toDiagnosticErrorMessage, } from "./diagnostic-utils.js";
 import { runProviderTurn } from "./provider-runner.js";
 import { renderPromptAttachmentAsText } from "../prompt-attachments.js";
 import { composeSystemPromptParts } from "../system-prompt.js";
-import { createSdkOpenCodeClient, } from "./opencode/runtime.js";
 import { normalizeProviderReplayTimestamp } from "../provider-history-timestamps.js";
 import { revertOpenCodeConversationAndFiles } from "./opencode/rewind.js";
 const OPENCODE_CAPABILITIES = {
@@ -851,22 +851,8 @@ export const __openCodeInternals = {
         return OpenCodeAgentSession;
     },
 };
-class ProductionOpenCodeRuntime {
-    constructor(serverManager) {
-        this.serverManager = serverManager;
-    }
-    async acquireServer(options) {
-        return this.serverManager.acquire(options);
-    }
-    async ensureServerRunning() {
-        return this.serverManager.ensureRunning();
-    }
-    createClient(options) {
-        return createSdkOpenCodeClient(options);
-    }
-    async shutdown() {
-        await this.serverManager.shutdown();
-    }
+function createSdkOpenCodeClient(options) {
+    return createOpencodeClient(options);
 }
 export class OpenCodeAgentClient {
     constructor(logger, runtimeSettings, deps = {}) {
@@ -877,20 +863,20 @@ export class OpenCodeAgentClient {
         this.modelContextWindows = new Map();
         this.logger = logger.child({ module: "agent", provider: "opencode" });
         this.runtimeSettings = runtimeSettings;
-        this.runtime =
-            deps.runtime ??
-                new ProductionOpenCodeRuntime(OpenCodeServerManager.getInstance(this.logger, runtimeSettings, {
+        this.serverManager =
+            deps.serverManager ??
+                OpenCodeServerManager.getInstance(this.logger, runtimeSettings, {
                     managedProcesses: deps.managedProcesses,
-                }));
+                });
+        this.createOpenCodeClient = deps.createClient ?? createSdkOpenCodeClient;
     }
     async createSession(config, launchContext, options) {
         const openCodeConfig = this.assertConfig(config);
-        const acquisition = await this.runtime.acquireServer({
-            force: false,
-            env: launchContext?.env,
-        });
+        const acquisition = launchContext?.env
+            ? await this.serverManager.acquireDedicated(launchContext.env)
+            : await this.serverManager.acquireCurrent();
         const { url } = acquisition.server;
-        const client = this.runtime.createClient({
+        const client = this.createOpenCodeClient({
             baseUrl: url,
             directory: openCodeConfig.cwd,
         });
@@ -924,9 +910,9 @@ export class OpenCodeAgentClient {
             cwd,
         };
         const openCodeConfig = this.assertConfig(config);
-        const acquisition = await this.runtime.acquireServer({ force: false });
+        const acquisition = await this.serverManager.acquireCurrent();
         const { url } = acquisition.server;
-        const client = this.runtime.createClient({
+        const client = this.createOpenCodeClient({
             baseUrl: url,
             directory: openCodeConfig.cwd,
         });
@@ -940,10 +926,12 @@ export class OpenCodeAgentClient {
         }
     }
     async fetchCatalog(options) {
-        const acquisition = await this.runtime.acquireServer({ force: options.force });
+        const acquisition = options.force
+            ? await this.serverManager.acquireNew()
+            : await this.serverManager.acquireCurrent();
         const { url } = acquisition.server;
         const directory = options.cwd;
-        const client = this.runtime.createClient({ baseUrl: url, directory });
+        const client = this.createOpenCodeClient({ baseUrl: url, directory });
         try {
             const [models, modes] = await Promise.all([
                 this.fetchModelsFromClient(client, directory),
@@ -957,9 +945,9 @@ export class OpenCodeAgentClient {
     }
     async listCommands(config) {
         const openCodeConfig = this.assertConfig(config);
-        const acquisition = await this.runtime.acquireServer({ force: false });
+        const acquisition = await this.serverManager.acquireCurrent();
         const { url } = acquisition.server;
-        const client = this.runtime.createClient({
+        const client = this.createOpenCodeClient({
             baseUrl: url,
             directory: openCodeConfig.cwd,
         });
@@ -974,9 +962,9 @@ export class OpenCodeAgentClient {
         return [buildOpenCodeAutoAcceptFeature(this.assertConfig(config))];
     }
     async listImportableSessions(options) {
-        const acquisition = await this.runtime.acquireServer({ force: false });
+        const acquisition = await this.serverManager.acquireCurrent();
         const { url } = acquisition.server;
-        const client = this.runtime.createClient({
+        const client = this.createOpenCodeClient({
             baseUrl: url,
             directory: options?.cwd ?? "",
         });
@@ -988,9 +976,9 @@ export class OpenCodeAgentClient {
         }
     }
     async importSession(input, context) {
-        const acquisition = await this.runtime.acquireServer({ force: false });
+        const acquisition = await this.serverManager.acquireCurrent();
         const { url } = acquisition.server;
-        const client = this.runtime.createClient({
+        const client = this.createOpenCodeClient({
             baseUrl: url,
             directory: input.cwd,
         });
@@ -1031,7 +1019,7 @@ export class OpenCodeAgentClient {
         return availability.available;
     }
     async shutdown() {
-        await this.runtime.shutdown();
+        await this.serverManager.shutdown();
     }
     async getDiagnostic() {
         try {

package/dist/server/server/agent/providers/pi/agent.d.ts

@@ -1,9 +1,9 @@
 import type { Logger } from "pino";
 import { z } from "zod";
-import { type AgentCapabilityFlags, type AgentClient, type AgentLaunchContext, type AgentMode, type AgentModelDefinition, type AgentPermissionRequest, type AgentPermissionResponse, type AgentPersistenceHandle, type AgentPromptInput, type AgentRunOptions, type AgentRunResult, type AgentRuntimeInfo, type AgentSession, type AgentSessionConfig, type AgentSlashCommand, type AgentStreamEvent, type FetchCatalogOptions, type ImportableProviderSession, type ImportProviderSessionContext, type ImportProviderSessionInput, type ListImportableSessionsOptions, type ProviderCatalog } from "../../agent-sdk-types.js";
+import { type AgentCapabilityFlags, type AgentClient, type AgentFeature, type AgentLaunchContext, type AgentMode, type AgentModelDefinition, type AgentPermissionRequest, type AgentPermissionResponse, type AgentPersistenceHandle, type AgentPromptInput, type AgentRunOptions, type AgentRunResult, type AgentRuntimeInfo, type AgentSession, type AgentSessionConfig, type AgentSlashCommand, type AgentStreamEvent, type FetchCatalogOptions, type ImportableProviderSession, type ImportProviderSessionContext, type ImportProviderSessionInput, type ListImportableSessionsOptions, type ProviderCatalog } from "../../agent-sdk-types.js";
 import { type ProviderRuntimeSettings } from "../../provider-launch-config.js";
 import type { PiRuntime, PiRuntimeSession } from "./runtime.js";
-import type { PiSessionState } from "./rpc-types.js";
+import type { PiCommandsRpcType, PiSessionState } from "./rpc-types.js";
 export declare const PiProviderParamsSchema: z.ZodObject<{
     sessionDir: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
@@ -11,6 +11,7 @@ interface PiRpcAgentClientOptions {
     logger: Logger;
     runtimeSettings?: ProviderRuntimeSettings;
     providerParams?: unknown;
+    commandsRpcType?: PiCommandsRpcType;
     runtime?: PiRuntime;
 }
 interface StartTurnResult {
@@ -113,6 +114,7 @@ export declare class PiRpcAgentClient implements AgentClient {
     createSession(config: AgentSessionConfig, launchContext?: AgentLaunchContext): Promise<AgentSession>;
     resumeSession(handle: AgentPersistenceHandle, overrides?: Partial<AgentSessionConfig>, _launchContext?: AgentLaunchContext): Promise<AgentSession>;
     fetchCatalog(options: FetchCatalogOptions): Promise<ProviderCatalog>;
+    listFeatures(_config: AgentSessionConfig): Promise<AgentFeature[]>;
     listImportableSessions(options?: ListImportableSessionsOptions): Promise<ImportableProviderSession[]>;
     importSession(input: ImportProviderSessionInput, context: ImportProviderSessionContext): Promise<import("../../agent-sdk-types.js").ImportedProviderSession>;
     isAvailable(): Promise<boolean>;

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

@@ -685,8 +685,8 @@ function mapPiModel(model) {
         defaultThinkingOptionId: model.reasoning ? DEFAULT_PI_THINKING_LEVEL : undefined,
     };
 }
-function createRuntime(logger, runtimeSettings) {
-    return new PiCliRuntime({ logger, runtimeSettings });
+function createRuntime(logger, runtimeSettings, commandsRpcType) {
+    return new PiCliRuntime({ logger, runtimeSettings, commandsRpcType });
 }
 export class PiRpcAgentSession {
     constructor(options) {
@@ -1458,7 +1458,9 @@ export class PiRpcAgentClient {
         this.logger = options.logger;
         this.runtimeSettings = options.runtimeSettings;
         this.providerParams = PiProviderParamsSchema.parse(options.providerParams ?? {});
-        this.runtime = options.runtime ?? createRuntime(options.logger, options.runtimeSettings);
+        this.runtime =
+            options.runtime ??
+                createRuntime(options.logger, options.runtimeSettings, options.commandsRpcType);
     }
     async createSession(config, launchContext) {
         const mcpConfig = await this.prepareMcpConfig(config.cwd, config.mcpServers);
@@ -1548,6 +1550,9 @@ export class PiRpcAgentClient {
             await runtimeSession.close();
         }
     }
+    async listFeatures(_config) {
+        return [];
+    }
     async listImportableSessions(options) {
         return await listPiImportableSessions({
             ...options,

package/dist/server/server/agent/providers/pi/cli-runtime.d.ts

@@ -2,15 +2,18 @@ import { type ChildProcessWithoutNullStreams } from "node:child_process";
 import type { Logger } from "pino";
 import type { ProviderRuntimeSettings } from "../../provider-launch-config.js";
 import { type PiRuntime, type PiRuntimeLaunch, type PiRuntimeSession, type PiStartSessionInput } from "./runtime.js";
+import type { PiCommandsRpcType } from "./rpc-types.js";
 export interface PiCliRuntimeOptions {
     logger: Logger;
     runtimeSettings?: ProviderRuntimeSettings;
     command?: [string, ...string[]];
+    commandsRpcType?: PiCommandsRpcType;
     spawnProcess?: (launch: PiRuntimeLaunch) => ChildProcessWithoutNullStreams;
 }
 export declare class PiCliRuntime implements PiRuntime {
     private readonly options;
     private readonly command;
+    private readonly commandsRpcType;
     private readonly spawnProcess;
     constructor(options: PiCliRuntimeOptions);
     startSession(input: PiStartSessionInput): Promise<PiRuntimeSession>;

package/dist/server/server/agent/providers/pi/cli-runtime.js

@@ -5,6 +5,7 @@ const DEFAULT_PI_COMMAND = [
     process.env.PI_COMMAND ?? process.env.PI_ACP_PI_COMMAND ?? "pi",
 ];
 const DEFAULT_TIMEOUT_MS = 30000;
+const DEFAULT_COMMANDS_RPC_TYPE = "get_commands";
 const STDERR_BUFFER_LIMIT = 8192;
 const GRACEFUL_SHUTDOWN_TIMEOUT_MS = 2000;
 const FORCE_SHUTDOWN_TIMEOUT_MS = 1000;
@@ -17,6 +18,7 @@ export class PiCliRuntime {
     constructor(options) {
         this.options = options;
         this.command = options.command ?? DEFAULT_PI_COMMAND;
+        this.commandsRpcType = options.commandsRpcType ?? DEFAULT_COMMANDS_RPC_TYPE;
         this.spawnProcess =
             options.spawnProcess ??
                 ((launch) => {
@@ -36,13 +38,14 @@ export class PiCliRuntime {
             runtimeSettings: this.options.runtimeSettings,
             session: input,
         });
-        return new PiCliRuntimeSession(launch, this.spawnProcess(launch), this.options.logger);
+        return new PiCliRuntimeSession(launch, this.spawnProcess(launch), this.options.logger, this.commandsRpcType);
     }
 }
 class PiCliRuntimeSession {
-    constructor(_launch, child, logger) {
+    constructor(_launch, child, logger, commandsRpcType) {
         this.child = child;
         this.logger = logger;
+        this.commandsRpcType = commandsRpcType;
         this.pending = new Map();
         this.subscribers = new Set();
         this.stderrBuffer = "";
@@ -109,7 +112,7 @@ class PiCliRuntimeSession {
         return (await this.request({ type: "get_session_stats" }));
     }
     async getCommands() {
-        const data = (await this.request({ type: "get_commands" }));
+        const data = (await this.request({ type: this.commandsRpcType }));
         return data.commands ?? [];
     }
     respondToExtensionUiRequest(id, response) {

package/dist/server/server/agent/providers/pi/rpc-types.d.ts

@@ -94,6 +94,7 @@ export interface PiRpcSlashCommand {
     source: "extension" | "prompt" | "skill";
     sourceInfo?: Record<string, unknown>;
 }
+export type PiCommandsRpcType = "get_commands" | "get_available_commands";
 export type PiRpcCommand = {
     id?: string;
     type: "prompt";
@@ -133,7 +134,7 @@ export type PiRpcCommand = {
     type: "get_session_stats";
 } | {
     id?: string;
-    type: "get_commands";
+    type: PiCommandsRpcType;
 };
 export interface PiRpcResponse {
     id?: string;

package/dist/server/server/agent/providers/provider-image-output.d.ts

@@ -9,6 +9,11 @@ export interface ProviderImageOutput {
 export interface MaterializedProviderImage {
     path: string;
 }
+export declare function materializeProviderImage(image: {
+    data: string;
+    mimeType: string | null;
+}): MaterializedProviderImage;
+export declare function isProviderImageMarkdown(text: string): boolean;
 interface RenderProviderImageOutputOptions {
     materialize?: (image: {
         data: string;

package/dist/server/server/agent/providers/provider-image-output.js

@@ -1,3 +1,58 @@
+import { createHash } from "node:crypto";
+import * as fsSync from "node:fs";
+import os from "node:os";
+import path from "node:path";
+const PROVIDER_IMAGE_ATTACHMENT_DIR = "paseo-attachments";
+function getImageExtension(mimeType) {
+    switch (mimeType) {
+        case "image/jpeg":
+            return "jpg";
+        case "image/png":
+            return "png";
+        case "image/webp":
+            return "webp";
+        case "image/gif":
+            return "gif";
+        case "image/bmp":
+            return "bmp";
+        case "image/tiff":
+            return "tiff";
+        default:
+            return "bin";
+    }
+}
+function normalizeImageData(mimeType, data) {
+    if (data.startsWith("data:")) {
+        const match = data.match(/^data:([^;]+);base64,(.*)$/);
+        if (match) {
+            return { mimeType: match[1], data: match[2] };
+        }
+    }
+    return { mimeType, data };
+}
+// Filenames are a content hash of the bytes so re-materializing the same image
+// is idempotent: history replay reuses the existing temp file instead of leaking
+// a fresh one on every load.
+export function materializeProviderImage(image) {
+    const attachmentsDir = path.join(os.tmpdir(), PROVIDER_IMAGE_ATTACHMENT_DIR);
+    fsSync.mkdirSync(attachmentsDir, { recursive: true });
+    const normalized = normalizeImageData(image.mimeType ?? "image/png", image.data);
+    const bytes = Buffer.from(normalized.data, "base64");
+    const extension = getImageExtension(normalized.mimeType);
+    const hash = createHash("sha256").update(bytes).digest("hex");
+    const filePath = path.join(attachmentsDir, `${hash}.${extension}`);
+    fsSync.writeFileSync(filePath, bytes);
+    return { path: filePath };
+}
+// Recognizes the markdown renderProviderImageOutputAsAssistantMarkdown emits for a materialized
+// provider image: its source is a content-hashed file in the attachments dir. Matching the full
+// <hash>.<ext> shape (not just a leading "![") keeps user-authored text from being mistaken for a
+// provider image when it reaches the history-replay filter. The separator class allows one-or-more
+// because on Windows the path uses "\\" and escapeMarkdownImageSource doubles each backslash.
+const PROVIDER_IMAGE_MARKDOWN = new RegExp(`^!\\[[^\\]]*\\]\\([^)]*${PROVIDER_IMAGE_ATTACHMENT_DIR}[/\\\\]+[0-9a-f]{64}\\.[a-z0-9]+\\)`);
+export function isProviderImageMarkdown(text) {
+    return PROVIDER_IMAGE_MARKDOWN.test(text);
+}
 function nonEmptyString(value) {
     const trimmed = value?.trim();
     return trimmed ? trimmed : null;

package/dist/server/server/agent/tools/paseo-tools.d.ts

@@ -0,0 +1,48 @@
+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";
+import type { PaseoToolCatalog } from "./types.js";
+export interface PaseoToolHostDependencies {
+    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 using this tool catalog.
+     * 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;
+}
+export declare function createPaseoToolCatalog(options: PaseoToolHostDependencies): PaseoToolCatalog;
+//# sourceMappingURL=paseo-tools.d.ts.map