@getpaseo/server 0.9.2 → 0.10.0-beta.1

package/dist/server/server/agent/providers/pi/extensions/pi-subagents/index.js

@@ -0,0 +1,131 @@
+import { z } from "zod";
+import { extractTextFromToolResult } from "../../tool-call-mapper.js";
+const Args = z
+    .object({
+    agent: z.string().trim().min(1).optional(),
+    task: z.string().trim().min(1).optional(),
+    async: z.boolean().optional(),
+    action: z.unknown().optional(),
+})
+    .passthrough();
+const Row = z
+    .object({
+    index: z.number().int().nonnegative().optional(),
+    agent: z.string().trim().min(1),
+    exitCode: z.number().optional(),
+    success: z.boolean().optional(),
+    sessionFile: z.string().trim().min(1).optional(),
+})
+    .passthrough();
+const Completion = z
+    .object({ runId: z.string().trim().min(1), results: z.array(Row) })
+    .passthrough();
+const Details = z
+    .object({
+    mode: z.string(),
+    runId: z.string().optional(),
+    asyncId: z.string().optional(),
+    results: z.array(Row),
+    completions: z.array(Completion).optional(),
+})
+    .passthrough();
+export const piSubagents = {
+    id: "pi-subagents",
+    createSession: () => {
+        const callsByRun = new Map();
+        const readSessions = new Set();
+        const collectRows = (owner, rows, description, failed = false) => {
+            const subagents = [];
+            const childSessions = [];
+            for (const [index, row] of rows.entries()) {
+                const id = rows.length === 1 ? owner : `${owner}:${row.index ?? index}`;
+                subagents.push({
+                    type: "upsert",
+                    id,
+                    title: row.agent,
+                    description,
+                    toolCallId: owner,
+                    status: failed || row.success === false || (row.success !== true && row.exitCode !== 0)
+                        ? "failed"
+                        : "completed",
+                });
+                if (row.sessionFile && !readSessions.has(row.sessionFile)) {
+                    readSessions.add(row.sessionFile);
+                    childSessions.push({ id, file: row.sessionFile });
+                }
+            }
+            return { subagents, childSessions };
+        };
+        const mapWait = (call) => {
+            if (call.status === "running")
+                return undefined;
+            const details = Details.safeParse(typeof call.result === "object" ? call.result?.details : null);
+            if (!details.success || !details.data.completions)
+                return undefined;
+            const subagents = [];
+            const childSessions = [];
+            for (const completion of details.data.completions) {
+                const owner = callsByRun.get(completion.runId);
+                if (!owner)
+                    continue;
+                const mapped = collectRows(owner, completion.results);
+                subagents.push(...mapped.subagents);
+                childSessions.push(...mapped.childSessions);
+            }
+            return subagents.length ? { subagents, childSessions } : undefined;
+        };
+        const mapSpawn = (call) => {
+            const args = Args.safeParse(call.args);
+            if (!args.success || args.data.action !== undefined || !args.data.agent || !args.data.task)
+                return undefined;
+            const detail = {
+                type: "sub_agent",
+                subAgentType: args.data.agent,
+                description: args.data.task,
+                log: extractTextFromToolResult(call.result)?.trim() ?? "",
+            };
+            const base = {
+                type: "upsert",
+                id: call.callId,
+                title: args.data.agent,
+                description: args.data.task,
+                toolCallId: call.callId,
+            };
+            if (call.status === "running")
+                return { detail, subagents: [{ ...base, status: "running" }] };
+            const details = Details.safeParse(typeof call.result === "object" ? call.result?.details : null);
+            if (!details.success || details.data.mode === "management")
+                return call.status === "failed"
+                    ? { detail, subagents: [{ ...base, status: "failed" }] }
+                    : { detail };
+            if (details.data.runId)
+                callsByRun.set(details.data.runId, call.callId);
+            if (details.data.results.length === 0 && (details.data.asyncId || args.data.async))
+                return {
+                    detail,
+                    subagents: [
+                        {
+                            ...base,
+                            status: call.status === "failed" ? "failed" : "running",
+                        },
+                    ],
+                };
+            if (details.data.results.length === 0 && call.status === "failed")
+                return { detail, subagents: [{ ...base, status: "failed" }] };
+            return {
+                detail,
+                ...collectRows(call.callId, details.data.results, args.data.task, call.status === "failed"),
+            };
+        };
+        return {
+            mapToolCall(call) {
+                if (call.toolName === "bg_wait")
+                    return mapWait(call);
+                if (call.toolName === "subagent")
+                    return mapSpawn(call);
+                return undefined;
+            },
+        };
+    },
+};
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,2 @@
+export declare const piExtensions: import("./contract.js").PiExtension[];
+//# sourceMappingURL=registry.d.ts.map

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

@@ -0,0 +1,21 @@
+import { piAskUser } from "./pi-ask-user/index.js";
+import { piSubagents } from "./pi-subagents/index.js";
+import { piMcpAdapter } from "./pi-mcp-adapter/index.js";
+import { rpivTodo } from "./rpiv-todo/index.js";
+import { piExampleTodo } from "./pi-example-todo/index.js";
+import { piGoalX } from "./pi-goal-x/index.js";
+import { tintinwebPiSubagents } from "./tintinweb-pi-subagents/index.js";
+import { gotgenesPiSubagents } from "./gotgenes-pi-subagents/index.js";
+import { rpivAskUserQuestion } from "./rpiv-ask-user-question/index.js";
+export const piExtensions = [
+    piAskUser, // Dialog correlation
+    piSubagents, // Delegation calls
+    tintinwebPiSubagents,
+    gotgenesPiSubagents,
+    piMcpAdapter, // MCP proxy names
+    rpivTodo,
+    piExampleTodo,
+    piGoalX,
+    rpivAskUserQuestion,
+];
+//# sourceMappingURL=registry.js.map

package/dist/server/server/agent/providers/pi/extensions/rpiv-ask-user-question/index.d.ts

@@ -0,0 +1,3 @@
+import type { PiExtension } from "../contract.js";
+export declare const rpivAskUserQuestion: PiExtension;
+//# sourceMappingURL=index.d.ts.map

package/dist/server/server/agent/providers/pi/extensions/rpiv-ask-user-question/index.js

@@ -0,0 +1,180 @@
+import { z } from "zod";
+const Params = z
+    .object({
+    questions: z
+        .array(z.object({
+        question: z.string(),
+        header: z.string(),
+        options: z
+            .array(z.object({
+            label: z.string(),
+            description: z.string(),
+            preview: z.string().optional(),
+        }))
+            .min(2)
+            .max(4),
+        multiSelect: z.boolean().optional(),
+    }))
+        .min(1)
+        .max(4),
+})
+    .refine(({ questions }) => {
+    const texts = questions.map((question) => question.question);
+    return (new Set(texts).size === texts.length &&
+        questions.every((question) => {
+            const labels = question.options.map((option) => option.label);
+            return (new Set(labels).size === labels.length &&
+                labels.every((label) => label !== "Other" && label !== "Type something." && label !== "Next"));
+        }));
+});
+const Result = z.object({
+    answers: z.array(z.object({
+        question: z.string(),
+        kind: z.enum(["option", "custom", "multi"]),
+        answer: z.string().nullable(),
+        selected: z.array(z.string()).optional(),
+    })),
+    cancelled: z.boolean(),
+    error: z.string().optional(),
+});
+const PERMISSION_PREFIX = "rpiv-question:";
+function answerFor(answers, question) {
+    const answer = answers[question.header];
+    return typeof answer === "string" ? answer : null;
+}
+function replyToDialog(dialog, question, answer, customInput) {
+    const options = z.array(z.string()).safeParse(dialog.options).data;
+    if (customInput)
+        return { response: { value: answer }, customInput: false };
+    if (question.multiSelect) {
+        const labels = answer.split(", ");
+        const indices = labels.map((label) => question.options.findIndex((option) => option.label === label));
+        if (indices.every((index) => index >= 0)) {
+            return {
+                response: { value: indices.map((index) => index + 1).join(",") },
+                customInput: false,
+            };
+        }
+        return { response: { value: answer }, customInput: false };
+    }
+    const index = question.options.findIndex((option) => option.label === answer);
+    if (index >= 0) {
+        return {
+            response: {
+                value: options?.[index] ?? `${index + 1}. ${answer} — ${question.options[index].description}`,
+            },
+            customInput: false,
+        };
+    }
+    return {
+        response: {
+            value: options?.[question.options.length] ?? `${question.options.length + 1}. Type something.`,
+        },
+        customInput: true,
+    };
+}
+export const rpivAskUserQuestion = {
+    id: "rpiv-ask-user-question",
+    createSession() {
+        let active = null;
+        function answerDialog(dialog) {
+            if (!active || active.cancelled)
+                return { cancelled: true };
+            const question = active.questions[active.index];
+            if (!question || !active.answers)
+                return { cancelled: true };
+            const answer = answerFor(active.answers, question);
+            if (answer === null)
+                return { cancelled: true };
+            const mapped = replyToDialog(dialog, question, answer, active.customInput);
+            active.customInput = mapped.customInput;
+            if (!active.customInput)
+                active.index++;
+            return mapped.response;
+        }
+        return {
+            onToolStart(call, provider) {
+                if (call.toolName !== "ask_user_question")
+                    return undefined;
+                const parsed = Params.safeParse(call.args);
+                if (!parsed.success)
+                    return undefined;
+                active = {
+                    callId: call.callId,
+                    questions: parsed.data.questions,
+                    answers: null,
+                    cancelled: false,
+                    index: 0,
+                    customInput: false,
+                    deferred: null,
+                };
+                return {
+                    id: `${PERMISSION_PREFIX}${call.callId}`,
+                    provider,
+                    name: "Pi ask_user_question",
+                    kind: "question",
+                    title: parsed.data.questions[0].question,
+                    input: {
+                        questions: parsed.data.questions.map((question) => ({
+                            question: question.question,
+                            header: question.header,
+                            options: question.options,
+                            multiSelect: question.multiSelect ?? false,
+                            allowOther: true,
+                        })),
+                    },
+                };
+            },
+            onToolEnd(call) {
+                if (active?.callId === call.callId)
+                    active = null;
+            },
+            mapDialog(dialog) {
+                if (!active || (dialog.method !== "select" && dialog.method !== "input"))
+                    return undefined;
+                if (!active.answers && !active.cancelled) {
+                    active.deferred = dialog;
+                    return { type: "deferred" };
+                }
+                return { type: "response", response: answerDialog(dialog) };
+            },
+            respondToPermission(request, response) {
+                if (!active || request.id !== `${PERMISSION_PREFIX}${active.callId}`)
+                    return undefined;
+                const answers = response.behavior === "allow" ? response.updatedInput?.answers : undefined;
+                active.answers =
+                    answers && typeof answers === "object" && !Array.isArray(answers)
+                        ? answers
+                        : null;
+                active.cancelled = response.behavior === "deny" || !active.answers;
+                const deferred = active.deferred;
+                active.deferred = null;
+                return {
+                    responses: deferred ? [{ id: deferred.id, response: answerDialog(deferred) }] : [],
+                };
+            },
+            mapToolCall(call) {
+                if (call.toolName !== "ask_user_question" ||
+                    !call.result ||
+                    typeof call.result === "string")
+                    return undefined;
+                const result = Result.safeParse(call.result.details);
+                if (!result.success)
+                    return undefined;
+                return {
+                    detail: {
+                        type: "plain_text",
+                        label: "Questions",
+                        text: result.data.error ??
+                            (result.data.cancelled
+                                ? "Cancelled"
+                                : result.data.answers
+                                    .map((answer) => `${answer.question}: ${answer.kind === "multi" ? (answer.selected ?? []).join(", ") : (answer.answer ?? "")}`)
+                                    .join("\n")),
+                    },
+                };
+            },
+        };
+    },
+};
+//# sourceMappingURL=index.js.map

package/dist/server/server/agent/providers/pi/extensions/rpiv-todo/index.d.ts

@@ -0,0 +1,3 @@
+import type { PiExtension } from "../contract.js";
+export declare const rpivTodo: PiExtension;
+//# sourceMappingURL=index.d.ts.map

package/dist/server/server/agent/providers/pi/extensions/rpiv-todo/index.js

@@ -0,0 +1,51 @@
+import { z } from "zod";
+const Details = z.object({
+    action: z.enum(["create", "update", "list", "get", "delete", "clear"]),
+    params: z.record(z.string(), z.unknown()),
+    nextId: z.number().int(),
+    tasks: z.array(z.object({
+        id: z.number().int(),
+        subject: z.string(),
+        status: z.enum(["pending", "in_progress", "completed", "deleted"]),
+        activeForm: z.string().optional(),
+    })),
+    error: z.string().optional(),
+});
+export const rpivTodo = {
+    id: "rpiv-todo",
+    createSession: () => ({
+        mapToolCall(call) {
+            if (call.toolName !== "todo" ||
+                call.status !== "completed" ||
+                !call.result ||
+                typeof call.result === "string")
+                return undefined;
+            const parsed = Details.safeParse(call.result.details);
+            if (!parsed.success)
+                return undefined;
+            return {
+                timeline: parsed.data.error
+                    ? []
+                    : [
+                        {
+                            type: "todo",
+                            items: parsed.data.tasks.flatMap((task) => {
+                                if (task.status === "deleted")
+                                    return [];
+                                const item = {
+                                    id: String(task.id),
+                                    text: task.subject,
+                                    status: task.status,
+                                    completed: task.status === "completed",
+                                };
+                                if (task.activeForm)
+                                    item.activeForm = task.activeForm;
+                                return [item];
+                            }),
+                        },
+                    ],
+            };
+        },
+    }),
+};
+//# sourceMappingURL=index.js.map

package/dist/server/server/agent/providers/pi/extensions/subagent-fixture-test.d.ts

@@ -0,0 +1,22 @@
+import type { AgentStreamEvent } from "../../../agent-sdk-types.js";
+import type { PiAgentMessage, PiAgentSessionEvent } from "../rpc-types.js";
+interface Fixture {
+    provenance: {
+        package: string;
+        version: string;
+        sourceCommit: string;
+        piVersion: string;
+        captureDate: string;
+    };
+    events: PiAgentSessionEvent[];
+    messages: PiAgentMessage[];
+}
+export declare function readSubagentFixture(path: URL, replaceSessionFile?: {
+    from: string;
+    to: string;
+}): Fixture;
+export declare function verifySubagentFixture(fixture: Fixture): Promise<Extract<AgentStreamEvent, {
+    type: "provider_subagent";
+}>[]>;
+export {};
+//# sourceMappingURL=subagent-fixture-test.d.ts.map

package/dist/server/server/agent/providers/pi/extensions/subagent-fixture-test.js

@@ -0,0 +1,66 @@
+import { readFileSync } from "node:fs";
+import pino from "pino";
+import { expect, vi } from "vitest";
+import { PiRpcAgentClient } from "../agent.js";
+import { streamPiHistory } from "../history-mapper.js";
+import { FakePi } from "../test-utils/fake-pi.js";
+export function readSubagentFixture(path, replaceSessionFile) {
+    let source = readFileSync(path, "utf8");
+    if (replaceSessionFile)
+        source = source.replaceAll(replaceSessionFile.from, JSON.stringify(replaceSessionFile.to).slice(1, -1));
+    const fixture = JSON.parse(source);
+    expect(fixture.provenance).toEqual({
+        package: expect.any(String),
+        version: expect.any(String),
+        sourceCommit: expect.any(String),
+        piVersion: expect.any(String),
+        captureDate: expect.any(String),
+    });
+    return fixture;
+}
+export async function verifySubagentFixture(fixture) {
+    const pi = new FakePi();
+    const client = new PiRpcAgentClient({ logger: pino({ level: "silent" }), runtime: pi });
+    const session = await client.createSession({
+        provider: "pi",
+        cwd: "/tmp/paseo-pi-subagent-fixture",
+    });
+    const live = [];
+    session.subscribe((event) => live.push(event));
+    try {
+        await session.startTurn("Delegate work");
+        for (const event of fixture.events)
+            pi.latestSession().emit(event);
+        const immediate = live.filter((event) => event.type === "provider_subagent");
+        expect(immediate.some((event) => event.event.type === "timeline")).toBe(false);
+        pi.latestSession().finishTurn();
+        const replay = [];
+        for await (const event of streamPiHistory("pi", fixture.messages))
+            replay.push(event);
+        const replaySubagents = replay.filter((event) => event.type === "provider_subagent");
+        await vi.waitFor(() => {
+            expect(live.filter((event) => event.type === "provider_subagent")).toEqual(replaySubagents);
+        });
+        for (const message of fixture.messages) {
+            if (message.role !== "custom" || typeof message.content !== "string")
+                continue;
+            const assistantText = {
+                type: "assistant_message",
+                text: message.content,
+            };
+            expect(live).toContainEqual(expect.objectContaining({ type: "timeline", item: assistantText }));
+            expect(replay).toContainEqual(expect.objectContaining({ type: "timeline", item: assistantText }));
+        }
+        const liveSubagents = live.filter((event) => event.type === "provider_subagent");
+        const firstTimeline = liveSubagents.findIndex((event) => event.event.type === "timeline");
+        if (firstTimeline !== -1) {
+            expect(liveSubagents.slice(0, firstTimeline).some((event) => event.event.type === "upsert")).toBe(true);
+        }
+        expect(liveSubagents).toEqual(replaySubagents);
+        return liveSubagents;
+    }
+    finally {
+        await session.close();
+    }
+}
+//# sourceMappingURL=subagent-fixture-test.js.map

package/dist/server/server/agent/providers/pi/extensions/task-fixture-test.d.ts

@@ -0,0 +1,4 @@
+import type { PiExtensionToolCall } from "./contract.js";
+export declare function capturedToolCall(path: URL, index?: number): PiExtensionToolCall;
+export declare function verifyTaskFixture(path: URL, expectedStatuses: string[]): Promise<void>;
+//# sourceMappingURL=task-fixture-test.d.ts.map

package/dist/server/server/agent/providers/pi/extensions/task-fixture-test.js

@@ -0,0 +1,79 @@
+import { readFileSync } from "node:fs";
+import pino from "pino";
+import { expect } from "vitest";
+import { PiRpcAgentClient } from "../agent.js";
+import { PiHistoryMapper } from "../history-mapper.js";
+import { FakePi } from "../test-utils/fake-pi.js";
+import { parseToolResult } from "../tool-call-mapper.js";
+import { createPiExtensionHost } from "./index.js";
+function todos(events) {
+    return events.flatMap((event) => event.type === "timeline" && event.item.type === "todo" ? [event.item] : []);
+}
+export function capturedToolCall(path, index = 0) {
+    const fixture = JSON.parse(readFileSync(path, "utf8"));
+    const ends = fixture.events.filter((event) => event.type === "tool_execution_end");
+    const end = ends[index];
+    if (!end)
+        throw new Error(`Missing captured tool result ${index}`);
+    const start = fixture.events.find((event) => event.type === "tool_execution_start" && event.toolCallId === end.toolCallId);
+    if (!start || start.type !== "tool_execution_start")
+        throw new Error("Missing captured tool start");
+    return {
+        callId: end.toolCallId,
+        toolName: end.toolName,
+        args: start.args,
+        status: end.isError ? "failed" : "completed",
+        result: parseToolResult(end.result),
+    };
+}
+export async function verifyTaskFixture(path, expectedStatuses) {
+    const fixture = JSON.parse(readFileSync(path, "utf8"));
+    expect(fixture.provenance).toEqual(expect.objectContaining({
+        package: expect.any(String),
+        version: expect.any(String),
+        sourceCommit: expect.any(String),
+        piVersion: expect.any(String),
+        captureDate: expect.any(String),
+    }));
+    const host = createPiExtensionHost();
+    const starts = new Map();
+    const mapped = [];
+    for (const event of fixture.events) {
+        if (event.type === "tool_execution_start")
+            starts.set(event.toolCallId, event);
+        if (event.type !== "tool_execution_end")
+            continue;
+        const start = starts.get(event.toolCallId);
+        expect(start).toBeDefined();
+        const mapping = host.mapToolCall({
+            callId: event.toolCallId,
+            toolName: event.toolName,
+            args: start?.args,
+            status: event.isError ? "failed" : "completed",
+            result: parseToolResult(event.result),
+        });
+        mapped.push(...(mapping?.timeline ?? []).filter((item) => item.type === "todo"));
+    }
+    expect(mapped.map((item) => item.items.map((task) => task.status))).toEqual(expectedStatuses.map((status) => status.split(",")));
+    const pi = new FakePi();
+    const client = new PiRpcAgentClient({ logger: pino({ level: "silent" }), runtime: pi });
+    const session = await client.createSession({ provider: "pi", cwd: "/tmp/paseo-pi-task-fixture" });
+    const live = [];
+    session.subscribe((event) => live.push(event));
+    try {
+        await session.startTurn("Use tasks");
+        for (const event of fixture.events)
+            pi.latestSession().emit(event);
+        pi.latestSession().finishTurn();
+        expect(todos(live)).toEqual(mapped);
+        const replay = new PiHistoryMapper("pi").mapMessages(fixture.messages);
+        expect(todos(replay)).toEqual(mapped);
+        expect(replay.filter((event) => event.type === "timeline" &&
+            event.item.type === "tool_call" &&
+            event.item.status === "completed")).toHaveLength(fixture.events.filter((event) => event.type === "tool_execution_end").length);
+    }
+    finally {
+        await session.close();
+    }
+}
+//# sourceMappingURL=task-fixture-test.js.map

package/dist/server/server/agent/providers/pi/extensions/tintinweb-pi-subagents/index.d.ts

@@ -0,0 +1,3 @@
+import type { PiExtension } from "../contract.js";
+export declare const tintinwebPiSubagents: PiExtension;
+//# sourceMappingURL=index.d.ts.map