@camerontaylor/paseo-protocol 0.8.0-fork.1

package/dist/paseo-config-schema.d.ts

@@ -0,0 +1,138 @@
+import { z } from "zod";
+export declare const PaseoServicePortAllocationSchema: z.ZodObject<{
+    range: z.ZodOptional<z.ZodString>;
+    portScript: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare function normalizeLifecycleCommands(commands: unknown): string[];
+export declare const PaseoLifecycleCommandRawSchema: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+export declare const PaseoScriptEntryRawSchema: z.ZodObject<{
+    type: z.ZodOptional<z.ZodUnknown>;
+    command: z.ZodOptional<z.ZodUnknown>;
+    port: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$loose>;
+export declare const PaseoWorktreeConfigRawSchema: z.ZodObject<{
+    setup: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    teardown: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    terminals: z.ZodOptional<z.ZodUnknown>;
+    servicePorts: z.ZodOptional<z.ZodObject<{
+        range: z.ZodOptional<z.ZodString>;
+        portScript: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$loose>;
+export declare const PaseoMetadataGenerationEntrySchema: z.ZodCatch<z.ZodObject<{
+    instructions: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>>;
+export declare const PaseoMetadataGenerationSchema: z.ZodCatch<z.ZodObject<{
+    title: z.ZodOptional<z.ZodCatch<z.ZodObject<{
+        instructions: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>>;
+    branchName: z.ZodOptional<z.ZodCatch<z.ZodObject<{
+        instructions: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>>;
+    commitMessage: z.ZodOptional<z.ZodCatch<z.ZodObject<{
+        instructions: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>>;
+    pullRequest: z.ZodOptional<z.ZodCatch<z.ZodObject<{
+        instructions: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>>;
+}, z.core.$loose>>;
+export declare const PaseoConfigRawSchema: z.ZodObject<{
+    worktree: z.ZodOptional<z.ZodObject<{
+        setup: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+        teardown: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+        terminals: z.ZodOptional<z.ZodUnknown>;
+        servicePorts: z.ZodOptional<z.ZodObject<{
+            range: z.ZodOptional<z.ZodString>;
+            portScript: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$loose>>;
+    scripts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        type: z.ZodOptional<z.ZodUnknown>;
+        command: z.ZodOptional<z.ZodUnknown>;
+        port: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
+    metadataGeneration: z.ZodOptional<z.ZodCatch<z.ZodObject<{
+        title: z.ZodOptional<z.ZodCatch<z.ZodObject<{
+            instructions: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>>>;
+        branchName: z.ZodOptional<z.ZodCatch<z.ZodObject<{
+            instructions: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>>>;
+        commitMessage: z.ZodOptional<z.ZodCatch<z.ZodObject<{
+            instructions: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>>>;
+        pullRequest: z.ZodOptional<z.ZodCatch<z.ZodObject<{
+            instructions: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>>>;
+    }, z.core.$loose>>>;
+}, z.core.$loose>;
+export declare const WorktreeConfigSchema: z.ZodCatch<z.ZodObject<{
+    terminals: z.ZodOptional<z.ZodUnknown>;
+    servicePorts: z.ZodOptional<z.ZodObject<{
+        range: z.ZodOptional<z.ZodString>;
+        portScript: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    setup: z.ZodPipe<z.ZodOptional<z.ZodUnknown>, z.ZodTransform<string[], unknown>>;
+    teardown: z.ZodPipe<z.ZodOptional<z.ZodUnknown>, z.ZodTransform<string[], unknown>>;
+}, z.core.$loose>>;
+export declare const ScriptEntrySchema: z.ZodCatch<z.ZodObject<{
+    type: z.ZodOptional<z.ZodUnknown>;
+    command: z.ZodOptional<z.ZodUnknown>;
+    port: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$loose>>;
+export declare const PaseoConfigSchema: z.ZodCatch<z.ZodObject<{
+    worktree: z.ZodOptional<z.ZodCatch<z.ZodObject<{
+        terminals: z.ZodOptional<z.ZodUnknown>;
+        servicePorts: z.ZodOptional<z.ZodObject<{
+            range: z.ZodOptional<z.ZodString>;
+            portScript: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        setup: z.ZodPipe<z.ZodOptional<z.ZodUnknown>, z.ZodTransform<string[], unknown>>;
+        teardown: z.ZodPipe<z.ZodOptional<z.ZodUnknown>, z.ZodTransform<string[], unknown>>;
+    }, z.core.$loose>>>;
+    scripts: z.ZodCatch<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodCatch<z.ZodObject<{
+        type: z.ZodOptional<z.ZodUnknown>;
+        command: z.ZodOptional<z.ZodUnknown>;
+        port: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>>>;
+    metadataGeneration: z.ZodOptional<z.ZodCatch<z.ZodObject<{
+        title: z.ZodOptional<z.ZodCatch<z.ZodObject<{
+            instructions: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>>>;
+        branchName: z.ZodOptional<z.ZodCatch<z.ZodObject<{
+            instructions: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>>>;
+        commitMessage: z.ZodOptional<z.ZodCatch<z.ZodObject<{
+            instructions: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>>>;
+        pullRequest: z.ZodOptional<z.ZodCatch<z.ZodObject<{
+            instructions: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>>>;
+    }, z.core.$loose>>>;
+}, z.core.$loose>>;
+export declare const PaseoConfigRevisionSchema: z.ZodObject<{
+    mtimeMs: z.ZodNumber;
+    size: z.ZodNumber;
+}, z.core.$strip>;
+export declare const ProjectConfigRpcErrorSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    code: z.ZodLiteral<"project_not_found">;
+}, z.core.$strip>, z.ZodObject<{
+    code: z.ZodLiteral<"invalid_project_config">;
+}, z.core.$strip>, z.ZodObject<{
+    code: z.ZodLiteral<"stale_project_config">;
+    currentRevision: z.ZodNullable<z.ZodObject<{
+        mtimeMs: z.ZodNumber;
+        size: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    code: z.ZodLiteral<"write_failed">;
+}, z.core.$strip>], "code">;
+export type PaseoScriptEntryRaw = z.infer<typeof PaseoScriptEntryRawSchema>;
+export type PaseoMetadataGenerationEntry = z.infer<typeof PaseoMetadataGenerationEntrySchema>;
+export type PaseoMetadataGeneration = z.infer<typeof PaseoMetadataGenerationSchema>;
+export type PaseoServicePortAllocation = z.infer<typeof PaseoServicePortAllocationSchema>;
+export type PaseoConfigRaw = z.infer<typeof PaseoConfigRawSchema>;
+export type PaseoConfig = z.infer<typeof PaseoConfigSchema>;
+export type PaseoConfigRevision = z.infer<typeof PaseoConfigRevisionSchema>;
+export type ProjectConfigRpcError = z.infer<typeof ProjectConfigRpcErrorSchema>;
+//# sourceMappingURL=paseo-config-schema.d.ts.map

package/dist/paseo-config-schema.js

@@ -0,0 +1,98 @@
+import { z } from "zod";
+const TCP_PORT_RANGE_PATTERN = /^(\d{1,5})-(\d{1,5})$/;
+export const PaseoServicePortAllocationSchema = z
+    .object({
+    range: z.string().trim().regex(TCP_PORT_RANGE_PATTERN).optional(),
+    portScript: z.string().trim().min(1).optional(),
+})
+    .strict()
+    .refine((value) => value.range !== undefined || value.portScript !== undefined, "Expected range or portScript")
+    .refine((value) => {
+    if (!value.range)
+        return true;
+    const match = TCP_PORT_RANGE_PATTERN.exec(value.range);
+    if (!match)
+        return false;
+    const start = Number(match[1]);
+    const end = Number(match[2]);
+    return start >= 1 && end <= 65535 && start <= end;
+}, "Expected an inclusive TCP port range from 1-65535");
+export function normalizeLifecycleCommands(commands) {
+    if (typeof commands === "string") {
+        return commands.trim().length > 0 ? [commands] : [];
+    }
+    if (!Array.isArray(commands)) {
+        return [];
+    }
+    return commands.filter((command) => {
+        return typeof command === "string" && command.trim().length > 0;
+    });
+}
+export const PaseoLifecycleCommandRawSchema = z.union([z.string(), z.array(z.string())]);
+export const PaseoScriptEntryRawSchema = z
+    .object({
+    type: z.unknown().optional(),
+    command: z.unknown().optional(),
+    port: z.unknown().optional(),
+})
+    .passthrough();
+export const PaseoWorktreeConfigRawSchema = z
+    .object({
+    setup: PaseoLifecycleCommandRawSchema.optional(),
+    teardown: PaseoLifecycleCommandRawSchema.optional(),
+    terminals: z.unknown().optional(),
+    servicePorts: PaseoServicePortAllocationSchema.optional(),
+})
+    .passthrough();
+export const PaseoMetadataGenerationEntrySchema = z
+    .object({
+    instructions: z.string().optional(),
+})
+    .passthrough()
+    .catch({});
+export const PaseoMetadataGenerationSchema = z
+    .object({
+    title: PaseoMetadataGenerationEntrySchema.optional(),
+    branchName: PaseoMetadataGenerationEntrySchema.optional(),
+    commitMessage: PaseoMetadataGenerationEntrySchema.optional(),
+    pullRequest: PaseoMetadataGenerationEntrySchema.optional(),
+})
+    // COMPAT(projectMetadataAgentTitle): `agentTitle` project metadata prompts were removed
+    // in v0.1.96; keep legacy paseo.json parseable until 2026-12-16.
+    .passthrough()
+    .catch({});
+export const PaseoConfigRawSchema = z
+    .object({
+    worktree: PaseoWorktreeConfigRawSchema.optional(),
+    scripts: z.record(z.string(), PaseoScriptEntryRawSchema).optional(),
+    metadataGeneration: PaseoMetadataGenerationSchema.optional(),
+})
+    .passthrough();
+export const WorktreeConfigSchema = PaseoWorktreeConfigRawSchema.extend({
+    setup: z.unknown().optional().transform(normalizeLifecycleCommands),
+    teardown: z.unknown().optional().transform(normalizeLifecycleCommands),
+})
+    .passthrough()
+    .catch({ setup: [], teardown: [] });
+export const ScriptEntrySchema = PaseoScriptEntryRawSchema.catch({});
+export const PaseoConfigSchema = PaseoConfigRawSchema.extend({
+    worktree: WorktreeConfigSchema.optional(),
+    scripts: z.record(z.string(), ScriptEntrySchema).optional().catch({}),
+    metadataGeneration: PaseoMetadataGenerationSchema.optional(),
+})
+    .passthrough()
+    .catch({});
+export const PaseoConfigRevisionSchema = z.object({
+    mtimeMs: z.number(),
+    size: z.number(),
+});
+export const ProjectConfigRpcErrorSchema = z.discriminatedUnion("code", [
+    z.object({ code: z.literal("project_not_found") }),
+    z.object({ code: z.literal("invalid_project_config") }),
+    z.object({
+        code: z.literal("stale_project_config"),
+        currentRevision: PaseoConfigRevisionSchema.nullable(),
+    }),
+    z.object({ code: z.literal("write_failed") }),
+]);
+//# sourceMappingURL=paseo-config-schema.js.map

package/dist/paseo-tool-call-detail.d.ts

@@ -0,0 +1,15 @@
+export interface PaseoToolDetailField {
+    label: string;
+    value: string;
+}
+export type PaseoToolDetailSection = {
+    kind: "prose";
+    title: string;
+    text: string;
+} | {
+    kind: "fields";
+    title: string;
+    fields: PaseoToolDetailField[];
+};
+export declare function buildPaseoToolDetailSections(toolName: string, input: unknown, output: unknown): PaseoToolDetailSection[] | null;
+//# sourceMappingURL=paseo-tool-call-detail.d.ts.map

package/dist/paseo-tool-call-detail.js

@@ -0,0 +1,305 @@
+import { getPaseoToolLeafName } from "./tool-name-normalization.js";
+const WORKSPACE_FIELDS = [
+    "title",
+    "workspaceId",
+    "projectId",
+    "isolation",
+    "path",
+    "mode",
+    "worktreeSlug",
+    "branchName",
+    "baseBranch",
+    "branch",
+    "prNumber",
+    "forge",
+];
+const AGENT_FIELDS = [
+    "title",
+    "agentId",
+    "provider",
+    "workspaceId",
+    "cwd",
+    "sessionMode",
+    "modeId",
+    "background",
+    "notifyOnFinish",
+    "settings",
+    "labels",
+];
+const AUTOMATION_FIELDS = [
+    "name",
+    "id",
+    "cron",
+    "timezone",
+    "provider",
+    "cwd",
+    "isolation",
+    "maxRuns",
+    "expiresIn",
+    "clearExpires",
+];
+const BROWSER_FIELDS = [
+    "browserId",
+    "url",
+    "ref",
+    "sourceRef",
+    "targetRef",
+    "value",
+    "text",
+    "key",
+    "button",
+    "doubleClick",
+    "modifiers",
+    "filePaths",
+    "fullPage",
+    "maxEntries",
+    "timeoutMs",
+    "deltaX",
+    "deltaY",
+    "width",
+    "height",
+    "function",
+];
+const TOOL_SPECS = {
+    create_workspace: {
+        inputOrder: WORKSPACE_FIELDS,
+        outputFields: ["workspaceId", "projectId"],
+    },
+    list_workspaces: {},
+    archive_workspace: {
+        inputOrder: ["workspaceId"],
+        outputFields: ["workspaceId", "archivedAgentIds", "removedDirectory"],
+    },
+    rename_workspace: { inputOrder: ["title", "workspaceId"] },
+    create_agent: {
+        promptField: "initialPrompt",
+        inputOrder: AGENT_FIELDS,
+        outputFields: ["agentId", "status", "currentModeId", "cwd"],
+    },
+    send_agent_prompt: {
+        promptField: "prompt",
+        inputOrder: AGENT_FIELDS,
+        outputFields: ["status", "lastMessage", "permission"],
+    },
+    get_agent_status: { inputOrder: ["agentId"] },
+    list_agents: { inputOrder: ["cwd", "statuses", "sinceHours", "limit", "includeArchived"] },
+    cancel_agent: { inputOrder: ["agentId"] },
+    archive_agent: { inputOrder: ["agentId"] },
+    kill_agent: { inputOrder: ["agentId"] },
+    update_agent: { inputOrder: AGENT_FIELDS },
+    get_agent_activity: { inputOrder: ["agentId", "limit"] },
+    set_agent_mode: { inputOrder: ["agentId", "modeId"] },
+    list_workspace_scripts: { inputOrder: ["workspaceId"] },
+    start_workspace_script: { inputOrder: ["workspaceId", "scriptName"] },
+    stop_workspace_script: { inputOrder: ["workspaceId", "scriptName"] },
+    list_terminals: { inputOrder: ["cwd", "all"] },
+    create_terminal: { inputOrder: ["cwd", "workspaceId", "name", "command"] },
+    kill_terminal: { inputOrder: ["terminalId"] },
+    capture_terminal: { inputOrder: ["terminalId", "lines"] },
+    send_terminal_keys: { inputOrder: ["terminalId", "keys", "literal"] },
+    create_schedule: {
+        promptField: "prompt",
+        inputOrder: AUTOMATION_FIELDS,
+        outputFields: ["id", "status", "nextRunAt", "expiresAt"],
+    },
+    create_heartbeat: {
+        promptField: "prompt",
+        inputOrder: AUTOMATION_FIELDS,
+        outputFields: ["id", "status", "nextRunAt", "expiresAt"],
+    },
+    delete_heartbeat: { inputOrder: ["id"] },
+    list_schedules: {},
+    inspect_schedule: { inputOrder: ["id"] },
+    pause_schedule: { inputOrder: ["id"] },
+    resume_schedule: { inputOrder: ["id"] },
+    delete_schedule: { inputOrder: ["id"] },
+    update_schedule: { promptField: "prompt", inputOrder: AUTOMATION_FIELDS },
+    schedule_logs: { inputOrder: ["id"] },
+    run_schedule_once: { inputOrder: ["id"] },
+    list_providers: {},
+    list_models: { inputOrder: ["provider"] },
+    list_profiles: {},
+    inspect_provider: { inputOrder: ["provider", "cwd", "settings"] },
+    list_pending_permissions: {},
+    respond_to_permission: { inputOrder: ["agentId", "requestId", "response"] },
+    browser_list_tabs: {},
+    browser_new_tab: { inputOrder: BROWSER_FIELDS },
+    browser_snapshot: { inputOrder: BROWSER_FIELDS },
+    browser_click: { inputOrder: BROWSER_FIELDS },
+    browser_fill: { inputOrder: BROWSER_FIELDS },
+    browser_wait: { inputOrder: BROWSER_FIELDS },
+    browser_type: { inputOrder: BROWSER_FIELDS },
+    browser_keypress: { inputOrder: BROWSER_FIELDS },
+    browser_navigate: { inputOrder: BROWSER_FIELDS },
+    browser_back: { inputOrder: BROWSER_FIELDS },
+    browser_forward: { inputOrder: BROWSER_FIELDS },
+    browser_reload: { inputOrder: BROWSER_FIELDS },
+    browser_screenshot: { inputOrder: BROWSER_FIELDS },
+    browser_upload: { inputOrder: BROWSER_FIELDS },
+    browser_hover: { inputOrder: BROWSER_FIELDS },
+    browser_select: { inputOrder: BROWSER_FIELDS },
+    browser_drag: { inputOrder: BROWSER_FIELDS },
+    browser_logs: { inputOrder: BROWSER_FIELDS },
+    browser_evaluate: { inputOrder: BROWSER_FIELDS },
+    browser_scroll: { inputOrder: BROWSER_FIELDS },
+    browser_resize: { inputOrder: BROWSER_FIELDS },
+    browser_close_tab: { inputOrder: BROWSER_FIELDS },
+};
+const FIELD_LABELS = {
+    agentId: "Agent",
+    archivedAgentIds: "Archived agents",
+    baseBranch: "Base branch",
+    branchName: "New branch",
+    browserId: "Browser tab",
+    clearExpires: "Clear expiry",
+    currentModeId: "Current mode",
+    cwd: "Working directory",
+    deltaX: "Horizontal delta",
+    deltaY: "Vertical delta",
+    doubleClick: "Double click",
+    expiresIn: "Expires in",
+    expiresAt: "Expires",
+    filePaths: "Files",
+    fullPage: "Full page",
+    initialPrompt: "Prompt",
+    id: "ID",
+    lastMessage: "Last message",
+    maxEntries: "Maximum entries",
+    maxRuns: "Maximum runs",
+    modeId: "Mode",
+    newMode: "New mode",
+    nextRunAt: "Next run",
+    notifyOnFinish: "Notify on finish",
+    prNumber: "Change request",
+    projectId: "Project",
+    removedDirectory: "Removed directory",
+    requestId: "Request",
+    scriptName: "Script",
+    sessionMode: "Session mode",
+    sinceHours: "Since (hours)",
+    sourceRef: "Source",
+    targetRef: "Target",
+    terminalId: "Terminal",
+    thinkingOptionId: "Thinking",
+    timeoutMs: "Timeout (ms)",
+    updateCount: "Updates",
+    workspaceId: "Workspace",
+    worktreeSlug: "Worktree",
+};
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function humanizeKey(key) {
+    const known = FIELD_LABELS[key];
+    if (known)
+        return known;
+    const words = key
+        .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+        .replace(/[._-]+/g, " ")
+        .split(" ")
+        .filter(Boolean);
+    const sentence = words.join(" ").toLowerCase();
+    return `${sentence[0]?.toUpperCase() ?? ""}${sentence.slice(1)}`;
+}
+function formatValue(value, depth = 0) {
+    if (value === null)
+        return "None";
+    if (value === undefined)
+        return "";
+    if (typeof value === "boolean")
+        return value ? "Yes" : "No";
+    if (typeof value === "string" || typeof value === "number" || typeof value === "bigint") {
+        return String(value);
+    }
+    if (Array.isArray(value)) {
+        if (value.length === 0)
+            return "None";
+        return value.map((item) => `• ${indentMultiline(formatValue(item, depth + 1), 2)}`).join("\n");
+    }
+    if (isRecord(value)) {
+        const entries = Object.entries(value).filter(([, child]) => child !== undefined);
+        if (entries.length === 0)
+            return "None";
+        return entries
+            .map(([key, child]) => {
+            const formatted = formatValue(child, depth + 1);
+            return `${humanizeKey(key)}: ${indentMultiline(formatted, 2)}`;
+        })
+            .join("\n");
+    }
+    return String(value);
+}
+function indentMultiline(value, spaces) {
+    const indentation = " ".repeat(spaces);
+    return value.replace(/\n/g, `\n${indentation}`);
+}
+function orderedEntries(value, order = [], omittedKey, includedKeys) {
+    const included = includedKeys ? new Set(includedKeys) : null;
+    const keys = Object.keys(value).filter((key) => key !== omittedKey && value[key] !== undefined && (!included || included.has(key)));
+    const rank = new Map(order.map((key, index) => [key, index]));
+    keys.sort((left, right) => {
+        const leftRank = rank.get(left) ?? Number.MAX_SAFE_INTEGER;
+        const rightRank = rank.get(right) ?? Number.MAX_SAFE_INTEGER;
+        return leftRank - rightRank || left.localeCompare(right);
+    });
+    return keys.map((key) => [key, value[key]]);
+}
+function fieldsFromValue(value, order, omittedKey, includedKeys) {
+    if (value === null || value === undefined)
+        return [];
+    if (!isRecord(value)) {
+        const formatted = formatValue(value);
+        return formatted ? [{ label: "Value", value: formatted }] : [];
+    }
+    return orderedEntries(value, order, omittedKey, includedKeys).map(([key, child]) => ({
+        label: humanizeKey(key),
+        value: formatValue(child),
+    }));
+}
+function parseJsonText(value) {
+    if (typeof value !== "string")
+        return undefined;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+function unwrapMcpResult(output) {
+    if (!isRecord(output))
+        return output;
+    if (output.structuredContent !== undefined) {
+        return output.structuredContent;
+    }
+    if (Array.isArray(output.content) && output.content.length === 1) {
+        const item = output.content[0];
+        if (isRecord(item) && item.type === "text") {
+            return parseJsonText(item.text) ?? item.text;
+        }
+    }
+    return output;
+}
+export function buildPaseoToolDetailSections(toolName, input, output) {
+    const leafName = getPaseoToolLeafName(toolName);
+    if (!leafName)
+        return null;
+    const spec = TOOL_SPECS[leafName] ?? {};
+    const sections = [];
+    if (spec.promptField && isRecord(input)) {
+        const prompt = input[spec.promptField];
+        if (typeof prompt === "string" && prompt.length > 0) {
+            sections.push({ kind: "prose", title: "Prompt", text: prompt });
+        }
+    }
+    const inputFields = fieldsFromValue(input, spec.inputOrder, spec.promptField);
+    if (inputFields.length > 0) {
+        sections.push({ kind: "fields", title: "Details", fields: inputFields });
+    }
+    const outputFields = fieldsFromValue(unwrapMcpResult(output), spec.outputFields, undefined, spec.outputFields);
+    if (outputFields.length > 0) {
+        sections.push({ kind: "fields", title: "Result", fields: outputFields });
+    }
+    return sections;
+}
+//# sourceMappingURL=paseo-tool-call-detail.js.map

package/dist/path-utils.d.ts

@@ -0,0 +1,2 @@
+export declare function stripCwdPrefix(filePath: string, cwd?: string): string;
+//# sourceMappingURL=path-utils.d.ts.map

package/dist/path-utils.js

@@ -0,0 +1,16 @@
+export function stripCwdPrefix(filePath, cwd) {
+    if (!cwd || !filePath) {
+        return filePath;
+    }
+    const normalizedCwd = cwd.replace(/\\/g, "/").replace(/\/+$/, "");
+    const normalizedPath = filePath.replace(/\\/g, "/");
+    const prefix = `${normalizedCwd}/`;
+    if (normalizedPath.startsWith(prefix)) {
+        return normalizedPath.slice(prefix.length);
+    }
+    if (normalizedPath === normalizedCwd) {
+        return ".";
+    }
+    return filePath;
+}
+//# sourceMappingURL=path-utils.js.map

package/dist/plugin-requirements.d.ts

@@ -0,0 +1,11 @@
+import type { PluginRequirements } from "./messages.js";
+export declare function validatePluginRequirements(requirements: PluginRequirements | undefined): void;
+interface PluginCompatibilityInput {
+    id: string;
+    requirements?: PluginRequirements;
+    version: string | null;
+    runtime: "daemon" | "app";
+}
+export declare function assertPluginCompatibility(input: PluginCompatibilityInput): void;
+export {};
+//# sourceMappingURL=plugin-requirements.d.ts.map

package/dist/plugin-requirements.js

@@ -0,0 +1,26 @@
+import parse from "semver/functions/parse.js";
+import validRange from "semver/ranges/valid.js";
+import satisfies from "semver/functions/satisfies.js";
+export function validatePluginRequirements(requirements) {
+    const range = requirements?.paseo;
+    if (range !== undefined && (!range.trim() || validRange(range) === null)) {
+        throw new Error(`Invalid requirements.paseo: ${JSON.stringify(range)}. Use an npm semver range such as ">=0.8.0".`);
+    }
+}
+export function assertPluginCompatibility(input) {
+    validatePluginRequirements(input.requirements);
+    // COMPAT(plugin-requirements): added in v0.8.0-beta.1; remove after 2027-03-07 once pre-0.8 plugins and catalogs are unsupported. The legacy range excludes 0.8 prereleases and their stable core.
+    const range = input.requirements?.paseo ?? "<0.8.0";
+    const version = input.version ? parse(input.version) : null;
+    if (!version) {
+        throw new Error(`Cannot check plugin "${input.id}" requirements: Paseo ${input.runtime} version is unknown. Update the ${input.runtime}.`);
+    }
+    const stableCore = `${version.major}.${version.minor}.${version.patch}`;
+    if (satisfies(version, range) || satisfies(stableCore, range))
+        return;
+    const action = input.requirements?.paseo === undefined
+        ? "This plugin has no requirements.paseo and targets Paseo before 0.8. Ask its author to migrate it: https://paseo.sh/docs/plugins/v0.8/migration"
+        : `Use a compatible plugin version or update the ${input.runtime}.`;
+    throw new Error(`Plugin "${input.id}" requires Paseo ${range}. Your ${input.runtime} is ${input.version}. ${action}`);
+}
+//# sourceMappingURL=plugin-requirements.js.map

package/dist/plugin-source-reference.d.ts

@@ -0,0 +1,7 @@
+export interface PluginSourceReference {
+    source: string;
+    pluginPath: string | undefined;
+}
+export declare function parsePluginSourceReference(reference: string): PluginSourceReference;
+export declare function formatPluginSourceReference(source: string, pluginPath: string | undefined): string;
+//# sourceMappingURL=plugin-source-reference.d.ts.map

package/dist/plugin-source-reference.js

@@ -0,0 +1,41 @@
+export function parsePluginSourceReference(reference) {
+    const separator = reference.lastIndexOf(":");
+    if (separator === -1)
+        return { source: reference, pluginPath: undefined };
+    const pluginPath = reference.slice(separator + 1);
+    if (!isPortableRelativePluginPath(pluginPath)) {
+        return { source: reference, pluginPath: undefined };
+    }
+    const scheme = reference.indexOf("://");
+    if (scheme !== -1) {
+        const pathStart = reference.indexOf("/", scheme + 3);
+        if (pathStart === -1 || separator < pathStart) {
+            return { source: reference, pluginPath: undefined };
+        }
+    }
+    else {
+        const scpSeparator = reference.match(/^[^/@\s]+@[^:\s]+:/)?.[0].length;
+        if (scpSeparator !== undefined && separator === scpSeparator - 1) {
+            return { source: reference, pluginPath: undefined };
+        }
+    }
+    return { source: reference.slice(0, separator), pluginPath };
+}
+export function formatPluginSourceReference(source, pluginPath) {
+    if (pluginPath === undefined)
+        return source;
+    if (!isPortableRelativePluginPath(pluginPath)) {
+        throw new Error("Plugin path must be a portable path relative to the repository");
+    }
+    return `${source}:${pluginPath}`;
+}
+function isPortableRelativePluginPath(pluginPath) {
+    if (pluginPath === ".")
+        return true;
+    if (!pluginPath || pluginPath.startsWith("/") || pluginPath.startsWith("\\"))
+        return false;
+    if (/^[A-Za-z]:/.test(pluginPath) || pluginPath.includes(":"))
+        return false;
+    return pluginPath.split(/[\\/]/).every((part) => part !== "" && part !== "." && part !== "..");
+}
+//# sourceMappingURL=plugin-source-reference.js.map