@getpaseo/server 0.9.2 → 0.10.0

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

@@ -0,0 +1,159 @@
+import { z } from "zod";
+import { extractTextFromToolResult } from "../../tool-call-mapper.js";
+const SpawnArgs = z
+    .object({
+    subagent_type: z.string().trim().min(1),
+    prompt: z.string().trim().min(1),
+    description: z.string().optional(),
+})
+    .passthrough();
+const FollowupArgs = z.object({ agent_id: z.string().trim().min(1) }).passthrough();
+const Details = z
+    .object({
+    agentId: z.string().trim().min(1),
+    status: z.string(),
+    displayName: z.string().optional(),
+    description: z.string().optional(),
+    transcriptPath: z.string().trim().min(1).optional(),
+})
+    .passthrough();
+const Notification = z
+    .object({
+    id: z.string().trim().min(1),
+    status: z.string(),
+    description: z.string().optional(),
+    outputFile: z.string().trim().min(1).optional(),
+})
+    .passthrough();
+const status = (value) => {
+    if (value === "completed")
+        return "completed";
+    if (value === "error")
+        return "failed";
+    if (value === "aborted" || value === "stopped")
+        return "canceled";
+    return "running";
+};
+export const gotgenesPiSubagents = {
+    id: "@gotgenes/pi-subagents",
+    createSession: () => {
+        const callsByAgent = new Map();
+        const readSessions = new Set();
+        const mapSpawn = (call) => {
+            const args = SpawnArgs.safeParse(call.args);
+            if (!args.success)
+                return undefined;
+            const details = Details.safeParse(typeof call.result === "object" ? call.result?.details : null);
+            const title = args.data.subagent_type;
+            const description = args.data.description ?? args.data.prompt;
+            const detail = {
+                type: "sub_agent",
+                subAgentType: title,
+                description,
+                log: extractTextFromToolResult(call.result)?.trim() ?? "",
+            };
+            if (call.status === "running")
+                return {
+                    detail,
+                    subagents: [
+                        {
+                            type: "upsert",
+                            id: call.callId,
+                            title,
+                            description,
+                            toolCallId: call.callId,
+                            status: "running",
+                        },
+                    ],
+                };
+            if (!details.success)
+                return call.status === "failed"
+                    ? {
+                        detail,
+                        subagents: [{ type: "upsert", id: call.callId, status: "failed" }],
+                    }
+                    : { detail };
+            callsByAgent.set(details.data.agentId, call.callId);
+            return {
+                detail,
+                subagents: [
+                    {
+                        type: "upsert",
+                        id: call.callId,
+                        title,
+                        description,
+                        toolCallId: call.callId,
+                        status: status(details.data.status),
+                    },
+                ],
+            };
+        };
+        const mapFollowup = (call) => {
+            const args = FollowupArgs.safeParse(call.args);
+            if (!args.success)
+                return undefined;
+            const id = callsByAgent.get(args.data.agent_id);
+            if (!id)
+                return undefined;
+            const details = Details.safeParse(typeof call.result === "object" ? call.result?.details : null);
+            const detail = {
+                type: "sub_agent",
+                description: details.success ? details.data.description : undefined,
+                log: extractTextFromToolResult(call.result)?.trim() ?? "",
+            };
+            if (call.status === "running" || !details.success)
+                return { detail };
+            const file = details.data.transcriptPath;
+            const childSessions = file && status(details.data.status) !== "running" && !readSessions.has(file)
+                ? [{ id, file }]
+                : [];
+            if (childSessions.length && file)
+                readSessions.add(file);
+            return {
+                detail,
+                subagents: [{ type: "upsert", id, status: status(details.data.status) }],
+                childSessions,
+            };
+        };
+        return {
+            mapToolCall(call) {
+                // This fork's result details resemble tintinweb's, but its spawn tool is `subagent` and its
+                // follow-up result shape differs. Keep each parser at its own package boundary.
+                if (call.toolName === "subagent")
+                    return mapSpawn(call);
+                if (call.toolName === "get_subagent_result" || call.toolName === "steer_subagent")
+                    return mapFollowup(call);
+                return undefined;
+            },
+            mapCustomMessage(message) {
+                if (message.customType !== "subagent-notification" &&
+                    message.customType !== "subagent-update")
+                    return undefined;
+                const details = Notification.safeParse(message.details);
+                if (!details.success)
+                    return undefined;
+                const id = callsByAgent.get(details.data.id);
+                if (!id)
+                    return undefined;
+                const file = details.data.outputFile;
+                const childSessions = file && status(details.data.status) !== "running" && !readSessions.has(file)
+                    ? [{ id, file }]
+                    : [];
+                if (childSessions.length && file)
+                    readSessions.add(file);
+                return {
+                    subagents: [
+                        {
+                            type: "upsert",
+                            id,
+                            description: details.data.description,
+                            status: status(details.data.status),
+                        },
+                    ],
+                    childSessions,
+                };
+            },
+        };
+    },
+};
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,28 @@
+import type { Logger } from "pino";
+import type { AgentPermissionRequest, AgentPermissionResponse, AgentStreamEvent } from "../../../agent-sdk-types.js";
+import type { PiAgentMessage } from "../rpc-types.js";
+import { mapPiChildSession } from "./child-session.js";
+import type { PiExtension, PiExtensionCustomMapping, PiExtensionDialog, PiExtensionDialogMapping, PiExtensionToolCall, PiExtensionToolMapping, PiExtensionUiReply } from "./contract.js";
+export type PiExtensionOutput<T> = T & {
+    events: AgentStreamEvent[];
+    hydration: Promise<AgentStreamEvent[]>;
+};
+export type PiExtensionEventOutput = PiExtensionOutput<PiExtensionToolMapping | PiExtensionCustomMapping>;
+export declare class PiExtensionHost {
+    private readonly logger?;
+    private readonly readChildSession;
+    private readonly sessions;
+    private remainingHydrationBytes;
+    constructor(extensions: readonly PiExtension[], logger?: Pick<Logger, "warn"> | undefined, hydrationByteBudget?: number, readChildSession?: typeof mapPiChildSession);
+    private safe;
+    mapToolCall(call: PiExtensionToolCall): PiExtensionOutput<PiExtensionToolMapping> | undefined;
+    mapCustomMessage(message: Extract<PiAgentMessage, {
+        role: "custom";
+    }>): PiExtensionOutput<PiExtensionCustomMapping> | undefined;
+    private prepare;
+    onToolStart(call: PiExtensionToolCall, provider?: string): AgentPermissionRequest | undefined;
+    onToolEnd(call: PiExtensionToolCall): void;
+    mapDialog(dialog: PiExtensionDialog, provider: string): PiExtensionDialogMapping | undefined;
+    respondToPermission(request: AgentPermissionRequest, response: AgentPermissionResponse): PiExtensionUiReply | undefined;
+}
+//# sourceMappingURL=host.d.ts.map

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

@@ -0,0 +1,94 @@
+import { mapPiChildSession } from "./child-session.js";
+export class PiExtensionHost {
+    constructor(extensions, logger, hydrationByteBudget = Number.POSITIVE_INFINITY, readChildSession = mapPiChildSession) {
+        this.logger = logger;
+        this.readChildSession = readChildSession;
+        this.sessions = [];
+        this.remainingHydrationBytes = hydrationByteBudget;
+        for (const extension of extensions) {
+            const adapter = this.safe(extension.id, "createSession", () => extension.createSession());
+            if (adapter)
+                this.sessions.push({ id: extension.id, adapter });
+        }
+    }
+    safe(id, operation, call) {
+        try {
+            return call();
+        }
+        catch (error) {
+            this.logger?.warn({ err: error, extensionId: id, operation }, "Pi extension adapter failed");
+            return undefined;
+        }
+    }
+    mapToolCall(call) {
+        for (const { id, adapter } of this.sessions) {
+            const mapping = this.safe(id, "mapToolCall", () => adapter.mapToolCall?.(call));
+            if (mapping) {
+                const prepared = this.safe(id, "prepare", () => this.prepare(id, mapping));
+                if (prepared)
+                    return prepared;
+            }
+        }
+        return undefined;
+    }
+    mapCustomMessage(message) {
+        for (const { id, adapter } of this.sessions) {
+            const mapping = this.safe(id, "mapCustomMessage", () => adapter.mapCustomMessage?.(message));
+            if (mapping) {
+                const prepared = this.safe(id, "prepare", () => this.prepare(id, mapping));
+                if (prepared)
+                    return prepared;
+            }
+        }
+        return undefined;
+    }
+    prepare(id, mapping) {
+        const events = [
+            ...("timeline" in mapping ? (mapping.timeline ?? []) : []).map((item) => ({ type: "timeline", provider: "pi", item })),
+            ...(mapping.subagents ?? []).map((event) => ({ type: "provider_subagent", provider: "pi", event })),
+        ];
+        const hydration = Promise.all((mapping.childSessions ?? []).map(async ({ id: childId, file }) => {
+            const bytes = Math.min(this.remainingHydrationBytes, 2 * 1024 * 1024);
+            if (bytes <= 0)
+                return [];
+            this.remainingHydrationBytes -= bytes;
+            return (await this.readChildSession(childId, file, bytes)).map((event) => ({ type: "provider_subagent", provider: "pi", event }));
+        }))
+            .then((groups) => groups.flat())
+            .catch((error) => {
+            this.logger?.warn({ err: error, extensionId: id, operation: "hydrate" }, "Pi extension adapter failed");
+            return [];
+        });
+        return { ...mapping, events, hydration };
+    }
+    onToolStart(call, provider = "pi") {
+        let request;
+        for (const { id, adapter } of this.sessions) {
+            const candidate = this.safe(id, "onToolStart", () => adapter.onToolStart?.(call, provider));
+            request ?? (request = candidate);
+        }
+        return request;
+    }
+    onToolEnd(call) {
+        for (const { id, adapter } of this.sessions) {
+            this.safe(id, "onToolEnd", () => adapter.onToolEnd?.(call));
+        }
+    }
+    mapDialog(dialog, provider) {
+        for (const { id, adapter } of this.sessions) {
+            const mapping = this.safe(id, "mapDialog", () => adapter.mapDialog?.(dialog, provider));
+            if (mapping)
+                return mapping;
+        }
+        return undefined;
+    }
+    respondToPermission(request, response) {
+        for (const { id, adapter } of this.sessions) {
+            const mapped = this.safe(id, "respondToPermission", () => adapter.respondToPermission?.(request, response));
+            if (mapped)
+                return mapped;
+        }
+        return undefined;
+    }
+}
+//# sourceMappingURL=host.js.map

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

@@ -0,0 +1,7 @@
+import { PiExtensionHost } from "./host.js";
+import type { Logger } from "pino";
+import type { PiExtension } from "./contract.js";
+export type { PiExtensionHost } from "./host.js";
+export type { PiExtensionEventOutput } from "./host.js";
+export declare function createPiExtensionHost(logger?: Pick<Logger, "warn">, extensions?: readonly PiExtension[], hydrationByteBudget?: number): PiExtensionHost;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,6 @@
+import { PiExtensionHost } from "./host.js";
+import { piExtensions } from "./registry.js";
+export function createPiExtensionHost(logger, extensions = piExtensions, hydrationByteBudget) {
+    return new PiExtensionHost(extensions, logger, hydrationByteBudget);
+}
+//# sourceMappingURL=index.js.map

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

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

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

@@ -0,0 +1,138 @@
+import { z } from "zod";
+const QUESTION_RESPONSE_HEADER = "Response";
+const QUESTION_COMMENT_HEADER = "Comment";
+const FREEFORM_SENTINEL = "✏️ Type custom response...";
+const COMBINED_METADATA = "ask_user_select_optional_comment";
+const Args = z
+    .object({
+    allowComment: z.boolean().catch(false),
+    allowFreeform: z.boolean().catch(true),
+    allowMultiple: z.boolean().catch(false),
+})
+    .passthrough();
+const Select = z
+    .object({ title: z.string().optional(), options: z.array(z.string()).optional() })
+    .passthrough();
+const Input = z.object({ placeholder: z.string().optional() }).passthrough();
+function answer(input, header) {
+    const answers = input?.answers;
+    if (!answers || typeof answers !== "object" || Array.isArray(answers))
+        return null;
+    const value = Reflect.get(answers, header);
+    return typeof value === "string" ? value : null;
+}
+function optionalInput(placeholder) {
+    return /\boptional\b|\bskip\b/i.test(placeholder ?? "");
+}
+function combinedPermission(dialog, provider, options, allowFreeform, question) {
+    const visibleOptions = options.filter((option) => option !== FREEFORM_SENTINEL);
+    const allowOther = allowFreeform || visibleOptions.length !== options.length;
+    return {
+        id: dialog.id,
+        provider,
+        name: "Pi ask_user",
+        kind: "question",
+        title: question,
+        input: {
+            questions: [
+                {
+                    question,
+                    header: QUESTION_RESPONSE_HEADER,
+                    options: visibleOptions.map((label) => ({ label })),
+                    multiSelect: false,
+                    ...(allowOther ? { allowOther: true } : {}),
+                },
+                {
+                    question: "Optional comment",
+                    header: QUESTION_COMMENT_HEADER,
+                    options: [],
+                    multiSelect: false,
+                    placeholder: "Optional comment (press Enter to skip)...",
+                    allowEmpty: true,
+                },
+            ],
+        },
+        metadata: {
+            extensionUiMethod: dialog.method,
+            answerHeader: QUESTION_RESPONSE_HEADER,
+            commentHeader: QUESTION_COMMENT_HEADER,
+            combinedAskUser: COMBINED_METADATA,
+            selectOptions: visibleOptions,
+            ...(allowOther ? { freeformSentinel: FREEFORM_SENTINEL } : {}),
+        },
+    };
+}
+export const piAskUser = {
+    id: "pi-ask-user",
+    createSession() {
+        let active = null;
+        let pending = null;
+        return {
+            onToolStart(call) {
+                active = call.toolName === "ask_user" ? (Args.safeParse(call.args).data ?? null) : null;
+                return undefined;
+            },
+            onToolEnd(call) {
+                if (call.toolName === "ask_user") {
+                    active = null;
+                    pending = null;
+                }
+            },
+            mapDialog(dialog, provider) {
+                if (pending && dialog.method === "input") {
+                    const input = Input.safeParse(dialog);
+                    const placeholder = input.success ? input.data.placeholder : undefined;
+                    if (pending.freeform !== null && !optionalInput(placeholder)) {
+                        const value = pending.freeform;
+                        pending = { ...pending, freeform: null };
+                        return { type: "response", response: { value } };
+                    }
+                    if (optionalInput(placeholder)) {
+                        const value = pending.comment;
+                        pending = null;
+                        return { type: "response", response: { value } };
+                    }
+                }
+                if (dialog.method !== "select" || !active?.allowComment || active.allowMultiple)
+                    return undefined;
+                const select = Select.safeParse(dialog);
+                const options = select.success ? (select.data.options ?? []) : [];
+                const question = select.success
+                    ? (select.data.title ?? "Select an option")
+                    : "Select an option";
+                return {
+                    type: "permission",
+                    request: combinedPermission(dialog, provider, options, active.allowFreeform, question),
+                };
+            },
+            respondToPermission(request, response) {
+                if (request.metadata?.combinedAskUser !== COMBINED_METADATA)
+                    return undefined;
+                if (response.behavior === "deny") {
+                    pending = null;
+                    return { responses: [{ id: request.id, response: { cancelled: true } }] };
+                }
+                const selected = answer(response.updatedInput, QUESTION_RESPONSE_HEADER);
+                if (selected === null) {
+                    pending = null;
+                    return { responses: [{ id: request.id, response: { cancelled: true } }] };
+                }
+                const selectOptions = Array.isArray(request.metadata?.selectOptions)
+                    ? request.metadata.selectOptions.filter((item) => typeof item === "string")
+                    : [];
+                const sentinel = typeof request.metadata?.freeformSentinel === "string"
+                    ? request.metadata.freeformSentinel
+                    : undefined;
+                const isFreeform = Boolean(sentinel) && !selectOptions.includes(selected);
+                pending = {
+                    comment: answer(response.updatedInput, QUESTION_COMMENT_HEADER) ?? "",
+                    freeform: isFreeform ? selected : null,
+                };
+                return {
+                    responses: [{ id: request.id, response: { value: isFreeform ? sentinel : selected } }],
+                };
+            },
+        };
+    },
+};
+//# sourceMappingURL=index.js.map

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

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

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

@@ -0,0 +1,38 @@
+import { z } from "zod";
+const Details = z.object({
+    action: z.enum(["list", "add", "toggle", "clear"]),
+    nextId: z.number().int(),
+    todos: z.array(z.object({ id: z.number().int(), text: z.string(), done: z.boolean() })),
+    error: z.string().optional(),
+});
+export const piExampleTodo = {
+    id: "pi-example-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.todos.map((todo) => ({
+                                id: String(todo.id),
+                                text: todo.text,
+                                status: todo.done ? "completed" : "pending",
+                                completed: todo.done,
+                            })),
+                        },
+                    ],
+            };
+        },
+    }),
+};
+//# sourceMappingURL=index.js.map

package/dist/server/server/agent/providers/pi/extensions/pi-goal-x/index.d.ts

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

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

@@ -0,0 +1,63 @@
+import { z } from "zod";
+const Task = z.lazy(() => z.object({
+    id: z.string(),
+    title: z.string(),
+    status: z.enum(["pending", "complete", "skipped"]),
+    subtasks: z.array(Task).optional(),
+}));
+const Details = z.object({
+    version: z.literal(3),
+    goal: z
+        .object({
+        currentTaskId: z.string().optional(),
+        taskList: z.object({ tasks: z.array(Task) }).optional(),
+    })
+        .nullable(),
+});
+const toolNames = new Set([
+    "create_goal",
+    "get_goal",
+    "update_goal",
+    "set_goal_tasks",
+    "update_goal_task",
+]);
+function toItems(tasks, currentTaskId) {
+    return tasks.flatMap((task) => {
+        let status = "pending";
+        if (task.status !== "pending")
+            status = "completed";
+        else if (task.id === currentTaskId)
+            status = "in_progress";
+        return [
+            {
+                id: task.id,
+                text: task.title,
+                status,
+                completed: task.status !== "pending",
+            },
+            ...toItems(task.subtasks ?? [], currentTaskId),
+        ];
+    });
+}
+export const piGoalX = {
+    id: "pi-goal-x",
+    createSession: () => ({
+        mapToolCall(call) {
+            if (!toolNames.has(call.toolName) ||
+                call.status !== "completed" ||
+                !call.result ||
+                typeof call.result === "string")
+                return undefined;
+            const parsed = Details.safeParse(call.result.details);
+            if (!parsed.success)
+                return undefined;
+            const goal = parsed.data.goal;
+            if (!goal?.taskList)
+                return undefined;
+            return {
+                timeline: [{ type: "todo", items: toItems(goal.taskList.tasks, goal.currentTaskId) }],
+            };
+        },
+    }),
+};
+//# sourceMappingURL=index.js.map

package/dist/server/server/agent/providers/pi/extensions/pi-mcp-adapter/index.d.ts

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

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

@@ -0,0 +1,48 @@
+import { z } from "zod";
+const Args = z
+    .object({
+    tool: z.string().optional().catch(undefined),
+    server: z.string().optional().catch(undefined),
+})
+    .passthrough();
+const Details = z
+    .object({
+    server: z.string().optional().catch(undefined),
+    tool: z.string().optional().catch(undefined),
+})
+    .passthrough();
+const nonEmpty = (value) => value?.trim() || undefined;
+export const piMcpAdapter = {
+    id: "pi-mcp-adapter",
+    createSession: () => ({
+        mapToolCall(call) {
+            if (call.toolName !== "mcp")
+                return undefined;
+            if (call.result && typeof call.result !== "string") {
+                const details = Details.safeParse(call.result.details);
+                if (details.success) {
+                    const server = nonEmpty(details.data.server);
+                    const tool = nonEmpty(details.data.tool);
+                    if (server && tool)
+                        return { name: `${server}.${tool}` };
+                }
+            }
+            const args = Args.safeParse(call.args);
+            if (!args.success)
+                return undefined;
+            const tool = nonEmpty(args.data.tool);
+            const server = nonEmpty(args.data.server);
+            if (tool && server)
+                return {
+                    name: `${server}.${tool.startsWith(`${server}_`) ? tool.slice(server.length + 1) : tool}`,
+                };
+            if (tool) {
+                const [prefix, ...rest] = tool.split("_");
+                if (prefix && rest.length > 0)
+                    return { name: `${prefix}.${rest.join("_")}` };
+            }
+            return undefined;
+        },
+    }),
+};
+//# sourceMappingURL=index.js.map

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

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