@getpaseo/protocol 0.7.0-beta.1 → 0.7.0-beta.3

package/dist/messages.js

@@ -16,6 +16,18 @@ export { PaseoConfigRawSchema, PaseoLifecycleCommandRawSchema, PaseoMetadataGene
 // ---------------------------------------------------------------------------
 // Mutable daemon config schemas (shared between server store and client)
 // ---------------------------------------------------------------------------
+export const DAEMON_PERMISSIONS = [
+    "daemon.read",
+    "daemon.manage",
+    "tunnel.manage",
+    "access.manage",
+    "workspace.read",
+    "workspace.write",
+    "workspace.manage",
+    "automation.manage",
+    "hub.execute",
+];
+export const DaemonPermissionSchema = z.enum(DAEMON_PERMISSIONS);
 const MutableDaemonProviderModelSchema = z
     .object({
     id: z.string().min(1),
@@ -1150,6 +1162,7 @@ export const HubManagementDaemonConnectRequestSchema = z.object({
     requestId: z.string(),
     hubUrl: z.string(),
     token: z.string(),
+    permissions: z.array(DaemonPermissionSchema).default([]),
 });
 export const HubManagementDaemonGetStatusRequestSchema = z.object({
     type: z.literal("hub.management.daemon.get_status.request"),
@@ -1160,6 +1173,12 @@ export const HubManagementDaemonDisconnectRequestSchema = z.object({
     requestId: z.string(),
     force: z.boolean().optional(),
 });
+export const HubManagementDaemonPermissionsUpdateRequestSchema = z.object({
+    type: z.literal("hub.management.daemon.permissions.update.request"),
+    requestId: z.string(),
+    grant: z.array(DaemonPermissionSchema).default([]),
+    revoke: z.array(DaemonPermissionSchema).default([]),
+});
 export const DiagnosticsRequestSchema = z.object({
     type: z.literal("diagnostics.request"),
     requestId: z.string(),
@@ -2544,6 +2563,7 @@ export const SessionInboundMessageSchema = z.discriminatedUnion("type", [
     HubManagementDaemonConnectRequestSchema,
     HubManagementDaemonGetStatusRequestSchema,
     HubManagementDaemonDisconnectRequestSchema,
+    HubManagementDaemonPermissionsUpdateRequestSchema,
     DiagnosticsRequestSchema,
     PluginCatalogGetRequestSchema,
     PluginListRequestSchema,
@@ -2837,6 +2857,8 @@ export const ServerInfoStatusPayloadSchema = z
     serverId: z.string().trim().min(1),
     hostname: ServerInfoHostnameSchema.optional(),
     version: ServerInfoVersionSchema.optional(),
+    // COMPAT(sessionPermissions): optional while clients support older daemons.
+    permissions: z.array(DaemonPermissionSchema).optional(),
     // COMPAT(desktopManaged): added in v0.1.X, remove optional parsing after 2027-01-16.
     desktopManaged: z.boolean().optional(),
     capabilities: ServerCapabilitiesFromUnknownSchema.optional(),
@@ -4007,7 +4029,7 @@ export const HubRelationshipStatusSchema = z.object({
     ]),
     daemonId: z.string().nullable(),
     hubOrigin: z.string().nullable(),
-    scopes: z.array(z.string()),
+    permissions: z.array(DaemonPermissionSchema),
     connectedAt: z.string().nullable(),
     lastError: z.string().nullable(),
 });
@@ -4027,6 +4049,10 @@ export const HubManagementDaemonDisconnectResponseSchema = z.object({
         warning: z.string().optional(),
     }),
 });
+export const HubManagementDaemonPermissionsUpdateResponseSchema = z.object({
+    type: z.literal("hub.management.daemon.permissions.update.response"),
+    payload: z.object({ requestId: z.string(), status: HubRelationshipStatusSchema }),
+});
 export const DaemonGetPairingOfferResponseSchema = z.object({
     type: z.literal("daemon.get_pairing_offer.response"),
     payload: z
@@ -5563,6 +5589,7 @@ export const SessionOutboundMessageSchema = z.discriminatedUnion("type", [
     HubManagementDaemonConnectResponseSchema,
     HubManagementDaemonGetStatusResponseSchema,
     HubManagementDaemonDisconnectResponseSchema,
+    HubManagementDaemonPermissionsUpdateResponseSchema,
     DiagnosticsResponseSchema,
     GetDaemonConfigResponseMessageSchema,
     SetDaemonConfigResponseMessageSchema,
@@ -5692,7 +5719,7 @@ export const WSPongMessageSchema = z.object({
 export const WSHelloMessageSchema = z.object({
     type: z.literal("hello"),
     clientId: z.string().min(1),
-    clientType: z.enum(["mobile", "browser", "cli", "mcp"]),
+    clientType: z.enum(["mobile", "browser", "cli", "mcp", "hub"]),
     protocolVersion: z.number().int(),
     appVersion: z.string().optional(),
     capabilities: z

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/ssh-transport.d.ts

@@ -0,0 +1,11 @@
+export declare const DEFAULT_SSH_DAEMON_PORT = 6767;
+export interface SshTransportTarget {
+    host: string;
+    sshPort?: number;
+    daemonPort: number;
+}
+export declare function validatePort(value: string | number, label: string): number;
+export declare function validateSshHost(host: string): string;
+export declare function parseSshTransportUri(value: string): SshTransportTarget;
+export declare function buildSshTunnelArgs(target: SshTransportTarget): string[];
+//# sourceMappingURL=ssh-transport.d.ts.map

package/dist/ssh-transport.js

@@ -0,0 +1,72 @@
+export const DEFAULT_SSH_DAEMON_PORT = 6767;
+export function validatePort(value, label) {
+    const port = Number(value);
+    if (!Number.isInteger(port) || port < 1 || port > 65535) {
+        throw new Error(`${label} must be between 1 and 65535`);
+    }
+    return port;
+}
+export function validateSshHost(host) {
+    const normalized = host.trim();
+    if (!normalized)
+        throw new Error("SSH host is required");
+    if (/\s/u.test(normalized) || normalized.startsWith("-")) {
+        throw new Error("SSH host is invalid");
+    }
+    return normalized;
+}
+export function parseSshTransportUri(value) {
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch (error) {
+        throw new Error("Invalid SSH host URI", { cause: error });
+    }
+    if (url.protocol !== "ssh:" || url.password || (url.pathname !== "" && url.pathname !== "/")) {
+        throw new Error("Invalid SSH host URI");
+    }
+    if (url.hash)
+        throw new Error("SSH host URI does not support fragments");
+    for (const key of url.searchParams.keys()) {
+        if (key !== "daemonPort")
+            throw new Error(`Unsupported SSH host option: ${key}`);
+    }
+    const daemonPorts = url.searchParams.getAll("daemonPort");
+    if (daemonPorts.length > 1)
+        throw new Error("daemonPort may only be specified once");
+    const urlHostname = url.hostname;
+    const hostname = validateSshHost(urlHostname.startsWith("[") && urlHostname.endsWith("]")
+        ? urlHostname.slice(1, -1)
+        : urlHostname);
+    const username = decodeURIComponent(url.username);
+    const host = validateSshHost(username ? `${username}@${hostname}` : hostname);
+    return {
+        host,
+        ...(url.port ? { sshPort: validatePort(url.port, "SSH port") } : {}),
+        daemonPort: daemonPorts[0] === undefined
+            ? DEFAULT_SSH_DAEMON_PORT
+            : validatePort(daemonPorts[0], "Daemon port"),
+    };
+}
+export function buildSshTunnelArgs(target) {
+    const host = validateSshHost(target.host);
+    const daemonPort = validatePort(target.daemonPort, "Daemon port");
+    const args = [
+        "-T",
+        "-o",
+        "BatchMode=yes",
+        "-o",
+        "ConnectTimeout=10",
+        "-o",
+        "ClearAllForwardings=yes",
+        "-o",
+        "ExitOnForwardFailure=yes",
+    ];
+    if (target.sshPort !== undefined) {
+        args.push("-p", String(validatePort(target.sshPort, "SSH port")));
+    }
+    args.push("-W", `127.0.0.1:${daemonPort}`, host);
+    return args;
+}
+//# sourceMappingURL=ssh-transport.js.map

package/dist/tool-call-display.js

@@ -24,8 +24,9 @@ function humanizeToolName(name) {
         .replace(/[._-]+/g, " ")
         .split(" ")
         .filter((segment) => segment.length > 0)
-        .map((segment) => `${segment[0]?.toUpperCase() ?? ""}${segment.slice(1)}`)
-        .join(" ");
+        .join(" ")
+        .toLowerCase()
+        .replace(/^./, (character) => character.toUpperCase());
 }
 function formatErrorText(error) {
     if (error === null || error === undefined) {
@@ -75,7 +76,7 @@ function buildCanonicalDetailDisplay(input) {
             };
         case "worktree_setup":
             return {
-                displayName: "Worktree Setup",
+                displayName: "Worktree setup",
                 summary: input.detail.branchName,
             };
         case "sub_agent":

package/dist/validation/ws-outbound-schema-metadata.d.ts

@@ -4650,7 +4650,17 @@ export declare const WSOutboundMessageSchema: {
                     }>;
                     daemonId: import("zod").ZodNullable<import("zod").ZodString>;
                     hubOrigin: import("zod").ZodNullable<import("zod").ZodString>;
-                    scopes: import("zod").ZodArray<import("zod").ZodString>;
+                    permissions: import("zod").ZodArray<import("zod").ZodEnum<{
+                        "daemon.read": "daemon.read";
+                        "daemon.manage": "daemon.manage";
+                        "tunnel.manage": "tunnel.manage";
+                        "access.manage": "access.manage";
+                        "workspace.read": "workspace.read";
+                        "workspace.write": "workspace.write";
+                        "workspace.manage": "workspace.manage";
+                        "automation.manage": "automation.manage";
+                        "hub.execute": "hub.execute";
+                    }>>;
                     connectedAt: import("zod").ZodNullable<import("zod").ZodString>;
                     lastError: import("zod").ZodNullable<import("zod").ZodString>;
                 }, import("zod/v4/core").$strip>;
@@ -4670,7 +4680,17 @@ export declare const WSOutboundMessageSchema: {
                     }>;
                     daemonId: import("zod").ZodNullable<import("zod").ZodString>;
                     hubOrigin: import("zod").ZodNullable<import("zod").ZodString>;
-                    scopes: import("zod").ZodArray<import("zod").ZodString>;
+                    permissions: import("zod").ZodArray<import("zod").ZodEnum<{
+                        "daemon.read": "daemon.read";
+                        "daemon.manage": "daemon.manage";
+                        "tunnel.manage": "tunnel.manage";
+                        "access.manage": "access.manage";
+                        "workspace.read": "workspace.read";
+                        "workspace.write": "workspace.write";
+                        "workspace.manage": "workspace.manage";
+                        "automation.manage": "automation.manage";
+                        "hub.execute": "hub.execute";
+                    }>>;
                     connectedAt: import("zod").ZodNullable<import("zod").ZodString>;
                     lastError: import("zod").ZodNullable<import("zod").ZodString>;
                 }, import("zod/v4/core").$strip>;
@@ -4690,12 +4710,52 @@ export declare const WSOutboundMessageSchema: {
                     }>;
                     daemonId: import("zod").ZodNullable<import("zod").ZodString>;
                     hubOrigin: import("zod").ZodNullable<import("zod").ZodString>;
-                    scopes: import("zod").ZodArray<import("zod").ZodString>;
+                    permissions: import("zod").ZodArray<import("zod").ZodEnum<{
+                        "daemon.read": "daemon.read";
+                        "daemon.manage": "daemon.manage";
+                        "tunnel.manage": "tunnel.manage";
+                        "access.manage": "access.manage";
+                        "workspace.read": "workspace.read";
+                        "workspace.write": "workspace.write";
+                        "workspace.manage": "workspace.manage";
+                        "automation.manage": "automation.manage";
+                        "hub.execute": "hub.execute";
+                    }>>;
                     connectedAt: import("zod").ZodNullable<import("zod").ZodString>;
                     lastError: import("zod").ZodNullable<import("zod").ZodString>;
                 }, import("zod/v4/core").$strip>;
                 warning: import("zod").ZodOptional<import("zod").ZodString>;
             }, import("zod/v4/core").$strip>;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            type: import("zod").ZodLiteral<"hub.management.daemon.permissions.update.response">;
+            payload: import("zod").ZodObject<{
+                requestId: import("zod").ZodString;
+                status: import("zod").ZodObject<{
+                    state: import("zod").ZodEnum<{
+                        not_connected: "not_connected";
+                        connecting: "connecting";
+                        connected: "connected";
+                        reconnecting: "reconnecting";
+                        disconnecting: "disconnecting";
+                        revoked: "revoked";
+                    }>;
+                    daemonId: import("zod").ZodNullable<import("zod").ZodString>;
+                    hubOrigin: import("zod").ZodNullable<import("zod").ZodString>;
+                    permissions: import("zod").ZodArray<import("zod").ZodEnum<{
+                        "daemon.read": "daemon.read";
+                        "daemon.manage": "daemon.manage";
+                        "tunnel.manage": "tunnel.manage";
+                        "access.manage": "access.manage";
+                        "workspace.read": "workspace.read";
+                        "workspace.write": "workspace.write";
+                        "workspace.manage": "workspace.manage";
+                        "automation.manage": "automation.manage";
+                        "hub.execute": "hub.execute";
+                    }>>;
+                    connectedAt: import("zod").ZodNullable<import("zod").ZodString>;
+                    lastError: import("zod").ZodNullable<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip>;
+            }, import("zod/v4/core").$strip>;
         }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
             type: import("zod").ZodLiteral<"diagnostics.response">;
             payload: import("zod").ZodObject<{

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getpaseo/protocol",
-  "version": "0.7.0-beta.1",
+  "version": "0.7.0-beta.3",
   "description": "Paseo shared protocol schemas and wire types",
   "files": [
     "dist",