@getpaseo/server 0.1.100 → 0.1.101

package/dist/server/server/agent/providers/codex-app-server-agent.js

@@ -1,7 +1,6 @@
 import { getAgentStreamEventTurnId, } from "../agent-sdk-types.js";
 import { importSessionFromPersistence } from "../provider-session-import.js";
 import { randomUUID } from "node:crypto";
-import * as fsSync from "node:fs";
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
@@ -18,7 +17,7 @@ import { extractCodexTerminalSessionId, nonEmptyString } from "./tool-call-mappe
 import { buildCodexFeatures, codexModelSupportsFastMode } from "./codex-feature-definitions.js";
 import { CodexAppServerClient, parseCodexThreadForkResponse, parseCodexThreadRollbackResponse, } from "./codex/app-server-transport.js";
 import { revertCodexConversation } from "./codex/rewind.js";
-import { renderProviderImageOutputAsAssistantMarkdown, } from "./provider-image-output.js";
+import { materializeProviderImage, renderProviderImageOutputAsAssistantMarkdown, } from "./provider-image-output.js";
 import { normalizeProviderReplayTimestamp } from "../provider-history-timestamps.js";
 import { formatProviderDiagnostic, formatProviderDiagnosticError, buildBinaryDiagnosticRows, buildCommandResolutionDiagnosticRows, resolveBinaryVersion, } from "./diagnostic-utils.js";
 import { runProviderTurn } from "./provider-runner.js";
@@ -38,7 +37,6 @@ function isCodexAlreadyUnarchivedError(error, threadId) {
 const TURN_START_TIMEOUT_MS = 90 * 1000;
 const INTERRUPT_TIMEOUT_MS = 2000;
 const CODEX_PROVIDER = "codex";
-const CODEX_IMAGE_ATTACHMENT_DIR = "paseo-attachments";
 // Codex treats most app-server client names as the model-request originator.
 // This reserved Codex name is non-originating, so requests keep Codex's default
 // CLI identity instead of showing up as Paseo in provider usage logs.
@@ -1220,21 +1218,6 @@ function codexImageOutputFromResult(result) {
         mimeType: firstStringField(resultRecord, ["mimeType", "mime_type"]),
     };
 }
-function writeImageAttachmentSync(mimeType, data) {
-    const attachmentsDir = path.join(os.tmpdir(), CODEX_IMAGE_ATTACHMENT_DIR);
-    fsSync.mkdirSync(attachmentsDir, { recursive: true });
-    const normalized = normalizeImageData(mimeType, data);
-    const extension = getImageExtension(normalized.mimeType);
-    const filename = `${randomUUID()}.${extension}`;
-    const filePath = path.join(attachmentsDir, filename);
-    fsSync.writeFileSync(filePath, Buffer.from(normalized.data, "base64"));
-    return filePath;
-}
-function materializeCodexImageOutput(image) {
-    return {
-        path: writeImageAttachmentSync(image.mimeType ?? "image/png", image.data),
-    };
-}
 function mapCodexThreadImageItem(normalizedType, normalizedItem) {
     if (normalizedType === "imageView") {
         return renderProviderImageOutputAsAssistantMarkdown({
@@ -1248,7 +1231,7 @@ function mapCodexThreadImageItem(normalizedType, normalizedItem) {
         url: result?.url ?? null,
         data: result?.data ?? null,
         mimeType: result?.mimeType ?? null,
-    }, { materialize: materializeCodexImageOutput });
+    }, { materialize: materializeProviderImage });
 }
 export function threadItemToTimeline(item, options) {
     const itemRecord = toObjectRecord(item);
@@ -1357,33 +1340,6 @@ function toSandboxPolicy(type, networkAccess) {
             return { type: "workspaceWrite", networkAccess: networkAccess ?? false };
     }
 }
-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 };
-}
 const ThreadStartedNotificationSchema = z
     .object({
     thread: z.object({ id: z.string() }).passthrough(),
@@ -2008,16 +1964,6 @@ const CodexNotificationSchema = z.union([
         .object({ method: z.string(), params: z.unknown() })
         .transform(({ method, params }) => ({ kind: "unknown_method", method, params })),
 ]);
-async function writeImageAttachment(mimeType, data) {
-    const attachmentsDir = path.join(os.tmpdir(), CODEX_IMAGE_ATTACHMENT_DIR);
-    await fs.mkdir(attachmentsDir, { recursive: true });
-    const normalized = normalizeImageData(mimeType, data);
-    const extension = getImageExtension(normalized.mimeType);
-    const filename = `${randomUUID()}.${extension}`;
-    const filePath = path.join(attachmentsDir, filename);
-    await fs.writeFile(filePath, Buffer.from(normalized.data, "base64"));
-    return filePath;
-}
 async function readCodexConfiguredDefaults(client, logger) {
     let savedConfigDefaults = {};
     try {
@@ -2071,7 +2017,10 @@ export async function codexAppServerTurnInputFromPrompt(prompt, logger) {
         }
         if (block.type === "image") {
             try {
-                const filePath = await writeImageAttachment(block.mimeType, block.data);
+                const filePath = materializeProviderImage({
+                    data: block.data,
+                    mimeType: block.mimeType,
+                }).path;
                 output.push({ type: "localImage", path: filePath });
             }
             catch (error) {

package/dist/server/server/agent/providers/diagnostic-utils.d.ts

@@ -10,6 +10,7 @@ export declare function formatDiagnosticStatus(available: boolean, error?: {
     source: string;
     cause: unknown;
 }): string;
+export declare function truncateForDiagnostic(value: string): string;
 export declare function toDiagnosticErrorMessage(error: unknown): string;
 export declare function resolveBinaryVersion(binaryPath: string): Promise<string>;
 export interface BinaryDiagnosticVersionCommand {

package/dist/server/server/agent/providers/diagnostic-utils.js

@@ -24,7 +24,7 @@ export function formatDiagnosticStatus(available, error) {
     return formatAvailabilityStatus(available);
 }
 const DIAGNOSTIC_OUTPUT_CAP = 4096;
-function truncateForDiagnostic(value) {
+export function truncateForDiagnostic(value) {
     const trimmed = value.trim();
     if (trimmed.length <= DIAGNOSTIC_OUTPUT_CAP) {
         return trimmed;

package/dist/server/server/agent/providers/generic-acp-agent.d.ts

@@ -13,11 +13,13 @@ interface GenericACPAgentClientOptions {
     providerParams?: unknown;
     waitForInitialCommands?: boolean;
     initialCommandsWaitTimeoutMs?: number;
+    diagnosticPhaseTimeoutMs?: number;
 }
 export declare class GenericACPAgentClient extends ACPAgentClient {
     private readonly command;
     private readonly providerId?;
     private readonly label?;
+    private readonly diagnosticPhaseTimeoutMs?;
     constructor(options: GenericACPAgentClientOptions);
     protected resolveLaunchCommand(): Promise<{
         command: string;
@@ -28,6 +30,7 @@ export declare class GenericACPAgentClient extends ACPAgentClient {
         diagnostic: string;
     }>;
     private resolveConfiguredLaunch;
+    private getACPProbeRowsForDiagnostic;
 }
 export interface CommandInvocation {
     command: string;

package/dist/server/server/agent/providers/generic-acp-agent.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { checkProviderLaunchAvailable, resolveProviderLaunch } from "../provider-launch-config.js";
 import { ACPAgentClient, DEFAULT_ACP_CAPABILITIES } from "./acp-agent.js";
-import { formatProviderDiagnostic, formatProviderDiagnosticError, buildBinaryDiagnosticRows, } from "./diagnostic-utils.js";
+import { buildBinaryDiagnosticRows, formatProviderDiagnostic, toDiagnosticErrorMessage, } from "./diagnostic-utils.js";
 export const GenericACPProviderParamsSchema = z
     .object({
     supportsMcpServers: z.boolean().optional(),
@@ -23,6 +23,7 @@ export class GenericACPAgentClient extends ACPAgentClient {
         this.command = options.command;
         this.providerId = options.providerId;
         this.label = options.label;
+        this.diagnosticPhaseTimeoutMs = options.diagnosticPhaseTimeoutMs;
     }
     async resolveLaunchCommand() {
         return {
@@ -37,34 +38,36 @@ export class GenericACPAgentClient extends ACPAgentClient {
     }
     async getDiagnostic() {
         const providerName = formatProviderName(this.label, this.providerId);
+        const entries = [
+            { label: "Provider ID", value: this.providerId ?? "unknown" },
+            { label: "Configured command", value: this.command.join(" ") },
+        ];
+        const versionProbe = buildVersionProbeCommand(this.command);
         try {
             const launch = await this.resolveConfiguredLaunch();
             const availability = await checkProviderLaunchAvailable(launch);
-            const versionProbe = buildVersionProbeCommand(this.command);
-            return {
-                diagnostic: formatProviderDiagnostic(providerName, [
-                    { label: "Provider ID", value: this.providerId ?? "unknown" },
-                    { label: "Configured command", value: this.command.join(" ") },
-                    ...(await buildBinaryDiagnosticRows(launch, availability, {
-                        binaryLabel: "Launcher binary",
-                        versionCommand: {
-                            command: versionProbe.command,
-                            args: versionProbe.args,
-                            env: this.runtimeSettings?.env,
-                        },
-                    })),
-                    {
-                        label: "Version command",
-                        value: formatCommand(versionProbe.command, versionProbe.args),
-                    },
-                ]),
-            };
+            entries.push(...(await buildBinaryDiagnosticRows(launch, availability, {
+                binaryLabel: "Launcher binary",
+                versionCommand: {
+                    command: versionProbe.command,
+                    args: versionProbe.args,
+                    env: this.runtimeSettings?.env,
+                },
+            })));
         }
         catch (error) {
-            return {
-                diagnostic: formatProviderDiagnosticError(providerName, error),
-            };
+            entries.push({
+                label: "Launcher binary",
+                value: `error: ${toDiagnosticErrorMessage(error)}`,
+            });
         }
+        entries.push({
+            label: "Version command",
+            value: formatCommand(versionProbe.command, versionProbe.args),
+        }, ...(await this.getACPProbeRowsForDiagnostic()));
+        return {
+            diagnostic: formatProviderDiagnostic(providerName, entries),
+        };
     }
     async resolveConfiguredLaunch() {
         return resolveProviderLaunch({
@@ -72,6 +75,21 @@ export class GenericACPAgentClient extends ACPAgentClient {
             defaultBinary: this.command[0],
         });
     }
+    async getACPProbeRowsForDiagnostic() {
+        try {
+            return await this.buildACPProbeDiagnosticRows({
+                phaseTimeoutMs: this.diagnosticPhaseTimeoutMs,
+            });
+        }
+        catch (error) {
+            return [
+                {
+                    label: "ACP probe",
+                    value: `error: ${toDiagnosticErrorMessage(error)}`,
+                },
+            ];
+        }
+    }
 }
 function buildGenericACPCapabilities(options) {
     const params = parseGenericACPProviderParams(options.providerParams);

package/dist/server/server/agent/providers/mock-load-test-agent.js

@@ -167,7 +167,7 @@ function parseAgentStreamStressPrompt(prompt) {
 }
 function parseStructuredBranchNamePrompt(prompt) {
     const text = promptToText(prompt);
-    const hasBranchNamePrompt = text.includes("Generate a git branch name for a coding agent") &&
+    const hasBranchNamePrompt = text.includes("Generate a title and a git branch name for a coding agent") &&
         (text.includes("Return JSON only with fields 'title' and 'branch'.") ||
             text.includes('"title"') ||
             text.includes('"branch"'));
@@ -177,7 +177,9 @@ function parseStructuredBranchNamePrompt(prompt) {
             text.includes('"branch"'))) {
         return null;
     }
-    const seed = text.split("User context:\n").at(-1)?.trim() ?? "";
+    const seed = text.match(/<user-prompt>\n([\s\S]*?)\n<\/user-prompt>/)?.[1]?.trim() ??
+        text.match(/<attachments>\n([\s\S]*?)\n<\/attachments>/)?.[1]?.trim() ??
+        "";
     const firstLine = seed
         .split("\n")
         .find((line) => line.trim().length > 0)

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

@@ -1,6 +1,6 @@
 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 { PiCommandsRpcType, PiSessionState } from "./rpc-types.js";
@@ -114,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

@@ -1550,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/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