@camerontaylor/paseo-server 0.8.0-fork.1

package/dist/server/server/agent/providers/pi/tool-call-mapper.js

@@ -0,0 +1,340 @@
+import { z } from "zod";
+const PiToolResultTextContentSchema = z.object({
+    type: z.literal("text"),
+    text: z.string(),
+});
+const PiToolResultUnknownContentSchema = z
+    .object({
+    type: z.string(),
+})
+    .passthrough();
+const PiToolResultContentSchema = z.union([
+    PiToolResultTextContentSchema,
+    PiToolResultUnknownContentSchema,
+]);
+const PiToolResultDetailsSchema = z
+    .object({
+    diff: z.string().optional(),
+})
+    .passthrough();
+const XdevExecuteDetailsSchema = z.object({
+    tool: z.string().trim().min(1),
+    mode: z.literal("execute"),
+    args: z.unknown().optional(),
+    inner: z.unknown().optional(),
+});
+const PiToolResultObjectSchema = z
+    .object({
+    output: z.string().optional(),
+    stdout: z.string().optional(),
+    text: z.string().optional(),
+    content: z.array(PiToolResultContentSchema).optional(),
+    exitCode: z.number().optional(),
+    code: z.number().optional(),
+    details: PiToolResultDetailsSchema.optional(),
+})
+    .passthrough();
+const PiToolResultSchema = z.union([z.string(), PiToolResultObjectSchema, z.null()]);
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readNonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+}
+const BashToolInputSchema = z.object({
+    command: z.string(),
+    timeout: z.number().optional(),
+});
+const ReadToolInputSchema = z.object({
+    path: z.string(),
+    offset: z.number().optional(),
+    limit: z.number().optional(),
+});
+const EditToolInputSchema = z.object({
+    path: z.string(),
+    edits: z.array(z.object({
+        oldText: z.string(),
+        newText: z.string(),
+    })),
+});
+const LegacyEditToolInputSchema = z.object({
+    path: z.string(),
+    old_string: z.string().optional(),
+    oldString: z.string().optional(),
+    new_string: z.string().optional(),
+    newString: z.string().optional(),
+});
+const WriteToolInputSchema = z.object({
+    path: z.string(),
+    content: z.string(),
+});
+const FindToolInputSchema = z.object({
+    pattern: z.string(),
+    path: z.string().optional(),
+    limit: z.number().optional(),
+});
+const GrepToolInputSchema = z.object({
+    pattern: z.string(),
+    path: z.string().optional(),
+    glob: z.string().optional(),
+    ignoreCase: z.boolean().optional(),
+    literal: z.boolean().optional(),
+    context: z.number().optional(),
+    limit: z.number().optional(),
+});
+const LsToolInputSchema = z.object({
+    path: z.string().optional(),
+    limit: z.number().optional(),
+});
+export function parseToolResult(rawResult) {
+    const parsed = PiToolResultSchema.safeParse(rawResult);
+    if (parsed.success) {
+        return parsed.data;
+    }
+    return null;
+}
+export function extractTextFromToolResult(result) {
+    if (typeof result === "string") {
+        return result;
+    }
+    if (!result) {
+        return undefined;
+    }
+    const directText = result.output ?? result.stdout ?? result.text;
+    if (directText) {
+        return directText;
+    }
+    if (!result.content) {
+        return undefined;
+    }
+    const textParts = [];
+    for (const block of result.content) {
+        if (block.type === "text" && "text" in block) {
+            textParts.push(block.text);
+        }
+    }
+    return textParts.length > 0 ? textParts.join("\n") : undefined;
+}
+export function parseToolArgs(toolName, rawArgs) {
+    if (toolName === "edit") {
+        return parseEditToolArgs(rawArgs);
+    }
+    const schema = SIMPLE_TOOL_SCHEMAS[toolName];
+    if (schema) {
+        const parsed = schema.safeParse(rawArgs);
+        if (parsed.success) {
+            return { kind: toolName, toolName, args: parsed.data };
+        }
+    }
+    return { kind: "unknown", toolName, args: rawArgs ?? null };
+}
+function stripMcpProxyPrefix(toolName, serverName) {
+    const prefix = `${serverName}_`;
+    return toolName.startsWith(prefix) ? toolName.slice(prefix.length) : toolName;
+}
+export function resolveToolCallName(toolCall, result) {
+    if (toolCall.kind === "write" && result && typeof result !== "string") {
+        const xdev = XdevExecuteDetailsSchema.safeParse(result.details?.xdev);
+        if (xdev.success) {
+            return xdev.data.tool;
+        }
+    }
+    if (toolCall.toolName !== "mcp") {
+        return toolCall.toolName;
+    }
+    if (result && typeof result !== "string") {
+        const serverName = readNonEmptyString(result.details?.server);
+        const toolName = readNonEmptyString(result.details?.tool);
+        if (serverName && toolName) {
+            return `${serverName}.${toolName}`;
+        }
+    }
+    if (isRecord(toolCall.args)) {
+        const requestedTool = readNonEmptyString(toolCall.args.tool);
+        const requestedServer = readNonEmptyString(toolCall.args.server);
+        if (requestedTool && requestedServer) {
+            return `${requestedServer}.${stripMcpProxyPrefix(requestedTool, requestedServer)}`;
+        }
+        if (requestedTool) {
+            const [serverName, ...toolParts] = requestedTool.split("_");
+            if (serverName && toolParts.length > 0) {
+                return `${serverName}.${toolParts.join("_")}`;
+            }
+        }
+    }
+    return toolCall.toolName;
+}
+export function mapToolDetail(toolCall, result) {
+    const parsedResult = result ?? null;
+    if (isTaskToolCall(toolCall)) {
+        return mapTaskToolDetail(toolCall.args, parsedResult);
+    }
+    switch (toolCall.kind) {
+        case "bash": {
+            const summary = resolveToolCallOutput(parsedResult);
+            return {
+                type: "shell",
+                command: toolCall.args.command,
+                output: summary.output,
+                exitCode: summary.exitCode,
+            };
+        }
+        case "read":
+            return {
+                type: "read",
+                filePath: toolCall.args.path,
+                content: extractTextFromToolResult(parsedResult),
+                offset: toolCall.args.offset,
+                limit: toolCall.args.limit,
+            };
+        case "edit": {
+            const firstEdit = toolCall.args.edits[0];
+            const unifiedDiff = parsedResult && typeof parsedResult !== "string" ? parsedResult.details?.diff : undefined;
+            return {
+                type: "edit",
+                filePath: toolCall.args.path,
+                oldString: firstEdit?.oldText,
+                newString: firstEdit?.newText,
+                unifiedDiff,
+            };
+        }
+        case "write":
+            return mapWriteToolDetail(toolCall.args, parsedResult);
+        case "find":
+            return mapFindToolDetail(toolCall.args, parsedResult);
+        case "grep":
+            return mapGrepToolDetail(toolCall.args, parsedResult);
+        case "ls":
+            return mapLsToolDetail(toolCall.args, parsedResult);
+        default:
+            return {
+                type: "unknown",
+                input: toolCall.args,
+                output: parsedResult,
+            };
+    }
+}
+function isTaskToolCall(toolCall) {
+    if (toolCall.toolName === "task") {
+        return true;
+    }
+    if (toolCall.toolName !== "subagent" || !isRecord(toolCall.args)) {
+        return false;
+    }
+    return (toolCall.args.action === undefined &&
+        (readNonEmptyString(toolCall.args.agent) !== undefined ||
+            readNonEmptyString(toolCall.args.task) !== undefined));
+}
+function mapTaskToolDetail(args, result) {
+    const argRecord = isRecord(args) ? args : {};
+    return {
+        type: "sub_agent",
+        subAgentType: readNonEmptyString(argRecord.agent),
+        description: readNonEmptyString(argRecord.task),
+        log: extractTextFromToolResult(result)?.trim() ?? "",
+    };
+}
+function mapWriteToolDetail(args, result) {
+    if (result && typeof result !== "string" && result.details && "xdev" in result.details) {
+        const xdev = XdevExecuteDetailsSchema.safeParse(result.details.xdev);
+        if (xdev.success) {
+            return {
+                type: "unknown",
+                input: xdev.data.args ?? null,
+                output: {
+                    ...result,
+                    details: xdev.data.inner ?? null,
+                },
+            };
+        }
+        return {
+            type: "unknown",
+            input: args,
+            output: result,
+        };
+    }
+    return {
+        type: "write",
+        filePath: args.path,
+        content: args.content,
+    };
+}
+function resolveToolCallOutput(result) {
+    if (typeof result === "string") {
+        return { output: result };
+    }
+    if (!result) {
+        return {};
+    }
+    const summary = {
+        output: extractTextFromToolResult(result),
+    };
+    if (typeof result.exitCode === "number") {
+        summary.exitCode = result.exitCode;
+        return summary;
+    }
+    if (typeof result.code === "number") {
+        summary.exitCode = result.code;
+        return summary;
+    }
+    summary.exitCode = null;
+    return summary;
+}
+function normalizeLegacyEditArgs(rawArgs) {
+    const parsed = LegacyEditToolInputSchema.safeParse(rawArgs);
+    if (!parsed.success) {
+        return null;
+    }
+    const oldText = parsed.data.old_string ?? parsed.data.oldString;
+    const newText = parsed.data.new_string ?? parsed.data.newString;
+    if (!oldText || newText === undefined) {
+        return null;
+    }
+    return {
+        path: parsed.data.path,
+        edits: [{ oldText, newText }],
+    };
+}
+function parseEditToolArgs(rawArgs) {
+    const parsed = EditToolInputSchema.safeParse(rawArgs);
+    if (parsed.success) {
+        return { kind: "edit", toolName: "edit", args: parsed.data };
+    }
+    const legacyArgs = normalizeLegacyEditArgs(rawArgs);
+    if (legacyArgs) {
+        return { kind: "edit", toolName: "edit", args: legacyArgs };
+    }
+    return { kind: "unknown", toolName: "edit", args: rawArgs ?? null };
+}
+const SIMPLE_TOOL_SCHEMAS = {
+    bash: BashToolInputSchema,
+    read: ReadToolInputSchema,
+    write: WriteToolInputSchema,
+    find: FindToolInputSchema,
+    grep: GrepToolInputSchema,
+    ls: LsToolInputSchema,
+};
+function mapFindToolDetail(args, result) {
+    return {
+        type: "search",
+        query: args.pattern,
+        toolName: "search",
+        content: typeof result === "string" ? result : undefined,
+    };
+}
+function mapGrepToolDetail(args, result) {
+    return {
+        type: "search",
+        query: args.pattern,
+        toolName: "grep",
+        content: typeof result === "string" ? result : undefined,
+    };
+}
+function mapLsToolDetail(args, result) {
+    return {
+        type: "search",
+        query: args.path ?? "ls",
+        content: typeof result === "string" ? result : undefined,
+    };
+}
+//# sourceMappingURL=tool-call-mapper.js.map

package/dist/server/server/agent/providers/pi/usage-poller.d.ts

@@ -0,0 +1,32 @@
+import type { AgentUsage } from "../../agent-sdk-types.js";
+import type { PiSessionStats } from "./rpc-types.js";
+export interface PiUsagePollScheduler {
+    schedulePoll(callback: () => void): () => void;
+}
+interface PiUsagePollerOptions {
+    readStats(): Promise<PiSessionStats>;
+    onUsage(usage: AgentUsage, turnId?: string): void;
+    onPollError(error: unknown): void;
+    scheduler?: PiUsagePollScheduler;
+}
+export declare class PiUsagePoller {
+    private readonly options;
+    private readonly scheduler;
+    private active;
+    private closed;
+    private generation;
+    private cancelScheduledPoll;
+    private lastUsage;
+    constructor(options: PiUsagePollerOptions);
+    startTurn(): void;
+    stopTurn(): void;
+    completeTurn(turnId?: string): Promise<void>;
+    close(): void;
+    private invalidatePendingWork;
+    private schedule;
+    private poll;
+    private takeChangedUsage;
+    private publishUsage;
+}
+export {};
+//# sourceMappingURL=usage-poller.d.ts.map

package/dist/server/server/agent/providers/pi/usage-poller.js

@@ -0,0 +1,141 @@
+function createScheduler() {
+    return {
+        schedulePoll: (callback) => {
+            const timer = setTimeout(callback, 3000);
+            return () => clearTimeout(timer);
+        },
+    };
+}
+function toAgentUsage(stats) {
+    const inputTokens = stats.tokens?.input ?? 0;
+    const cachedInputTokens = stats.tokens?.cacheRead ?? 0;
+    const outputTokens = stats.tokens?.output ?? 0;
+    const totalCostUsd = stats.cost ?? 0;
+    const contextWindowMaxTokens = stats.contextUsage?.contextWindow ?? undefined;
+    const contextWindowUsedTokens = stats.contextUsage?.tokens ?? undefined;
+    if (inputTokens === 0 &&
+        cachedInputTokens === 0 &&
+        outputTokens === 0 &&
+        totalCostUsd === 0 &&
+        contextWindowMaxTokens === undefined &&
+        contextWindowUsedTokens === undefined) {
+        return undefined;
+    }
+    return {
+        inputTokens,
+        cachedInputTokens,
+        outputTokens,
+        totalCostUsd,
+        ...(typeof contextWindowMaxTokens === "number" ? { contextWindowMaxTokens } : {}),
+        ...(typeof contextWindowUsedTokens === "number" ? { contextWindowUsedTokens } : {}),
+    };
+}
+function isSameUsage(left, right) {
+    return (left.inputTokens === right.inputTokens &&
+        left.cachedInputTokens === right.cachedInputTokens &&
+        left.outputTokens === right.outputTokens &&
+        left.totalCostUsd === right.totalCostUsd &&
+        left.contextWindowMaxTokens === right.contextWindowMaxTokens &&
+        left.contextWindowUsedTokens === right.contextWindowUsedTokens);
+}
+export class PiUsagePoller {
+    constructor(options) {
+        this.options = options;
+        this.active = false;
+        this.closed = false;
+        this.generation = 0;
+        this.cancelScheduledPoll = null;
+        this.lastUsage = null;
+        this.scheduler = options.scheduler ?? createScheduler();
+    }
+    startTurn() {
+        if (this.closed || this.active) {
+            return;
+        }
+        this.active = true;
+        this.generation += 1;
+        this.schedule(this.generation);
+    }
+    stopTurn() {
+        this.active = false;
+        this.invalidatePendingWork();
+    }
+    async completeTurn(turnId) {
+        if (this.closed) {
+            return;
+        }
+        this.active = false;
+        const completionGeneration = this.invalidatePendingWork();
+        let usage;
+        try {
+            usage = toAgentUsage(await this.options.readStats());
+        }
+        catch {
+            return;
+        }
+        if (this.closed || this.generation !== completionGeneration) {
+            return;
+        }
+        this.publishUsage(usage, turnId);
+    }
+    close() {
+        this.closed = true;
+        this.active = false;
+        this.invalidatePendingWork();
+    }
+    invalidatePendingWork() {
+        this.generation += 1;
+        this.cancelScheduledPoll?.();
+        this.cancelScheduledPoll = null;
+        return this.generation;
+    }
+    schedule(generation) {
+        this.cancelScheduledPoll = this.scheduler.schedulePoll(() => {
+            this.cancelScheduledPoll = null;
+            void this.poll(generation);
+        });
+    }
+    async poll(generation) {
+        let usage;
+        try {
+            usage = toAgentUsage(await this.options.readStats());
+        }
+        catch (error) {
+            try {
+                if (this.active && !this.closed && this.generation === generation) {
+                    this.options.onPollError(error);
+                }
+            }
+            finally {
+                if (this.active && !this.closed && this.generation === generation) {
+                    this.schedule(generation);
+                }
+            }
+            return;
+        }
+        try {
+            if (this.active && !this.closed && this.generation === generation) {
+                this.publishUsage(usage);
+            }
+        }
+        finally {
+            if (this.active && !this.closed && this.generation === generation) {
+                this.schedule(generation);
+            }
+        }
+    }
+    takeChangedUsage(usage) {
+        if (!usage || (this.lastUsage && isSameUsage(this.lastUsage, usage))) {
+            return undefined;
+        }
+        this.lastUsage = usage;
+        return usage;
+    }
+    publishUsage(usage, turnId) {
+        const changedUsage = this.takeChangedUsage(usage);
+        if (changedUsage) {
+            this.options.onUsage(changedUsage, turnId);
+        }
+    }
+}
+//# sourceMappingURL=usage-poller.js.map

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

@@ -0,0 +1,25 @@
+import type { AgentTimelineItem } from "../agent-sdk-types.js";
+export interface ProviderImageOutput {
+    path?: string | null;
+    url?: string | null;
+    data?: string | null;
+    mimeType?: string | null;
+    altText?: string | null;
+}
+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;
+        mimeType: string | null;
+    }) => MaterializedProviderImage;
+}
+export declare function renderProviderImageOutputAsAssistantMarkdown(image: ProviderImageOutput, options?: RenderProviderImageOutputOptions): AgentTimelineItem | null;
+export {};
+//# sourceMappingURL=provider-image-output.d.ts.map

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

@@ -0,0 +1,165 @@
+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";
+const PROVIDER_IMAGE_ATTACHMENT_DIR_PREFIX = `${PROVIDER_IMAGE_ATTACHMENT_DIR}-`;
+const PRIVATE_ATTACHMENT_DIR_MODE = 0o700;
+const MATERIALIZED_IMAGE_FILE_MODE = 0o600;
+let materializedImageAttachmentDir = null;
+function canReuseMaterializedImageAttachmentDir(dir) {
+    try {
+        const stats = fsSync.lstatSync(dir);
+        if (!stats.isDirectory()) {
+            return false;
+        }
+        fsSync.chmodSync(dir, PRIVATE_ATTACHMENT_DIR_MODE);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function getMaterializedImageAttachmentDir() {
+    if (materializedImageAttachmentDir &&
+        canReuseMaterializedImageAttachmentDir(materializedImageAttachmentDir)) {
+        return materializedImageAttachmentDir;
+    }
+    materializedImageAttachmentDir = fsSync.mkdtempSync(path.join(os.tmpdir(), PROVIDER_IMAGE_ATTACHMENT_DIR_PREFIX));
+    fsSync.chmodSync(materializedImageAttachmentDir, PRIVATE_ATTACHMENT_DIR_MODE);
+    return materializedImageAttachmentDir;
+}
+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
+// within a process reuses the existing temp file instead of leaking a fresh one
+// for repeated image blocks or history replay.
+export function materializeProviderImage(image) {
+    const attachmentsDir = getMaterializedImageAttachmentDir();
+    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, { mode: MATERIALIZED_IMAGE_FILE_MODE });
+    fsSync.chmodSync(filePath, MATERIALIZED_IMAGE_FILE_MODE);
+    return { path: filePath };
+}
+// Recognizes markdown rendered 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 during history replay. The
+// separator still accepts old doubled-backslash Windows history; new Windows output uses file URIs.
+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;
+}
+function isDataImageSource(source) {
+    return source.trim().toLowerCase().startsWith("data:image/");
+}
+function escapeMarkdownImageAlt(value) {
+    return value.replace(/\\/g, "\\\\").replace(/\]/g, "\\]");
+}
+function encodeFilePath(value) {
+    return value
+        .split("/")
+        .map((segment) => encodeURIComponent(segment))
+        .join("/");
+}
+function windowsFileUri(value) {
+    const isWindowsNetworkPath = value.startsWith("\\\\");
+    let normalizedPath = value.replace(/\\/g, "/");
+    if (/^\/\/\?\/UNC\//i.test(normalizedPath)) {
+        normalizedPath = `//${normalizedPath.slice(8)}`;
+    }
+    else if (/^\/\/\?\/[A-Za-z]:\//.test(normalizedPath)) {
+        normalizedPath = normalizedPath.slice(4);
+    }
+    if (/^[A-Za-z]:\//.test(normalizedPath)) {
+        const drive = normalizedPath.slice(0, 2);
+        return `file:///${drive}${encodeFilePath(normalizedPath.slice(2))}`;
+    }
+    if (isWindowsNetworkPath && normalizedPath.startsWith("//")) {
+        return `file:${encodeFilePath(normalizedPath)}`;
+    }
+    return null;
+}
+function markdownImageSource(value) {
+    const windowsUri = windowsFileUri(value);
+    if (windowsUri) {
+        return windowsUri;
+    }
+    if (value.startsWith("/")) {
+        return `file://${encodeFilePath(value)}`;
+    }
+    return value;
+}
+function escapeMarkdownImageSource(value) {
+    return markdownImageSource(value).replace(/\\/g, "\\\\").replace(/\)/g, "\\)");
+}
+export function renderProviderImageOutputAsAssistantMarkdown(image, options = {}) {
+    const source = nonEmptyString(image.path) ?? nonEmptyString(image.url);
+    if (source && !isDataImageSource(source)) {
+        const altText = escapeMarkdownImageAlt(nonEmptyString(image.altText) ?? "Image");
+        return {
+            type: "assistant_message",
+            text: `![${altText}](${escapeMarkdownImageSource(source)})`,
+        };
+    }
+    const data = nonEmptyString(image.data) ?? (source && isDataImageSource(source) ? source : null);
+    if (!data) {
+        return null;
+    }
+    let materialized = null;
+    try {
+        materialized = options.materialize
+            ? options.materialize({
+                data,
+                mimeType: nonEmptyString(image.mimeType),
+            })
+            : null;
+    }
+    catch {
+        materialized = null;
+    }
+    if (!materialized?.path || isDataImageSource(materialized.path)) {
+        return {
+            type: "assistant_message",
+            text: "Image output was omitted because it was not available as a file path or URL.",
+        };
+    }
+    const altText = escapeMarkdownImageAlt(nonEmptyString(image.altText) ?? "Image");
+    return {
+        type: "assistant_message",
+        text: `![${altText}](${escapeMarkdownImageSource(materialized.path)})`,
+    };
+}
+//# sourceMappingURL=provider-image-output.js.map