@hyperdrive.bot/paseo-client 0.3.35 → 0.3.36

package/dist/daemon-client.d.ts

@@ -283,6 +283,97 @@ type LoopLogsPayload = Extract<SessionOutboundMessage, {
 type LoopStopPayload = Extract<SessionOutboundMessage, {
     type: "loop/stop/response";
 }>["payload"];
+type FleetListPayload = Extract<SessionOutboundMessage, {
+    type: "fleet/list/response";
+}>["payload"];
+type FleetInspectPayload = Extract<SessionOutboundMessage, {
+    type: "fleet/inspect/response";
+}>["payload"];
+type FleetRunNowPayload = Extract<SessionOutboundMessage, {
+    type: "fleet/run-now/response";
+}>["payload"];
+type FleetPausePayload = Extract<SessionOutboundMessage, {
+    type: "fleet/pause/response";
+}>["payload"];
+type FleetResumePayload = Extract<SessionOutboundMessage, {
+    type: "fleet/resume/response";
+}>["payload"];
+type FleetAskPayload = Extract<SessionOutboundMessage, {
+    type: "fleet/ask/response";
+}>["payload"];
+type FleetDecisionsPayload = Extract<SessionOutboundMessage, {
+    type: "fleet/decisions/response";
+}>["payload"];
+type FleetResolveDecisionPayload = Extract<SessionOutboundMessage, {
+    type: "fleet/resolve-decision/response";
+}>["payload"];
+type FleetSetParamsPayload = Extract<SessionOutboundMessage, {
+    type: "fleet/set-params/response";
+}>["payload"];
+type FleetSetModePayload = Extract<SessionOutboundMessage, {
+    type: "fleet/set-mode/response";
+}>["payload"];
+type FleetCreatePayload = Extract<SessionOutboundMessage, {
+    type: "fleet/create/response";
+}>["payload"];
+type FleetExecutionsPayload = Extract<SessionOutboundMessage, {
+    type: "fleet/executions/response";
+}>["payload"];
+export interface InspectFleetLoopOptions {
+    requestId?: string;
+    name: string;
+}
+export interface SetFleetLoopModeOptions {
+    requestId?: string;
+    name: string;
+    mode: "live" | "dry-run";
+}
+export interface AskFleetDecisionOptions {
+    requestId?: string;
+    name: string;
+    kind: "gate-approval" | "action-approval" | "outcome-review";
+    question: string;
+    posture: "blocking" | "deferring" | "advisory";
+    options: Array<{
+        id: string;
+        label: string;
+        effect: {
+            kind: "act" | "rehearse" | "defer" | "suppress";
+            reversibility: "reversible" | "compensable" | "irreversible";
+            compensatingAction?: string;
+        };
+    }>;
+    runId?: string;
+    itemKey?: string;
+    evidence?: string;
+    onExpiry?: string;
+    expiresInMs?: number;
+}
+export interface ListFleetDecisionsOptions {
+    requestId?: string;
+    name?: string;
+    includeResolved?: boolean;
+}
+export interface ResolveFleetDecisionOptions {
+    requestId?: string;
+    decisionId: string;
+    optionId: string;
+}
+export interface SetFleetLoopParamsOptions {
+    requestId?: string;
+    name: string;
+    values: Record<string, string | number | boolean | string[]>;
+}
+export interface CreateFleetLoopOptions {
+    requestId?: string;
+    name: string;
+    description: string;
+    cron: string;
+    action: string;
+    mode?: "live" | "dry-run";
+    rails?: string;
+    allowed?: string;
+}
 type ScheduleCreatePayload = Extract<SessionOutboundMessage, {
     type: "schedule/create/response";
 }>["payload"];
@@ -1105,6 +1196,23 @@ export declare class DaemonClient {
     waitForChatMessages(options: WaitForChatMessagesOptions): Promise<ChatWaitPayload>;
     scheduleCreate(options: CreateScheduleOptions): Promise<ScheduleCreatePayload>;
     scheduleList(requestId?: string): Promise<ScheduleListPayload>;
+    fleetList(requestId?: string): Promise<FleetListPayload>;
+    fleetInspect(options: InspectFleetLoopOptions): Promise<FleetInspectPayload>;
+    fleetRunNow(options: InspectFleetLoopOptions): Promise<FleetRunNowPayload>;
+    fleetPause(options: InspectFleetLoopOptions): Promise<FleetPausePayload>;
+    /** Raise a typed question from a loop. */
+    fleetAsk(options: AskFleetDecisionOptions): Promise<FleetAskPayload>;
+    /** Decisions loops are waiting on a person for, most urgent first. */
+    fleetDecisions(options?: ListFleetDecisionsOptions): Promise<FleetDecisionsPayload>;
+    /** Answer one decision as the human. */
+    fleetResolveDecision(options: ResolveFleetDecisionOptions): Promise<FleetResolveDecisionPayload>;
+    /** Persist a loop's declared parameters. */
+    fleetSetParams(options: SetFleetLoopParamsOptions): Promise<FleetSetParamsPayload>;
+    /** Promote a loop to live, or demote it to dry-run. */
+    fleetSetMode(options: SetFleetLoopModeOptions): Promise<FleetSetModePayload>;
+    fleetResume(options: InspectFleetLoopOptions): Promise<FleetResumePayload>;
+    fleetCreate(options: CreateFleetLoopOptions): Promise<FleetCreatePayload>;
+    fleetExecutions(options: InspectFleetLoopOptions): Promise<FleetExecutionsPayload>;
     scheduleInspect(options: InspectScheduleOptions): Promise<ScheduleInspectPayload>;
     scheduleLogs(options: InspectScheduleOptions): Promise<ScheduleLogsPayload>;
     schedulePause(options: InspectScheduleOptions): Promise<SchedulePausePayload>;

package/dist/daemon-client.js

@@ -3730,6 +3730,134 @@ export class DaemonClient {
             responseType: "schedule/list/response",
         });
     }
+    async fleetList(requestId) {
+        return this.sendCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "fleet/list",
+            },
+            responseType: "fleet/list/response",
+        });
+    }
+    async fleetInspect(options) {
+        return this.sendCorrelatedSessionRequest({
+            requestId: options.requestId,
+            message: {
+                type: "fleet/inspect",
+                name: options.name,
+            },
+            responseType: "fleet/inspect/response",
+        });
+    }
+    async fleetRunNow(options) {
+        return this.sendCorrelatedSessionRequest({
+            requestId: options.requestId,
+            message: {
+                type: "fleet/run-now",
+                name: options.name,
+            },
+            responseType: "fleet/run-now/response",
+        });
+    }
+    async fleetPause(options) {
+        return this.sendCorrelatedSessionRequest({
+            requestId: options.requestId,
+            message: {
+                type: "fleet/pause",
+                name: options.name,
+            },
+            responseType: "fleet/pause/response",
+        });
+    }
+    /** Raise a typed question from a loop. */
+    async fleetAsk(options) {
+        const { requestId, ...rest } = options;
+        return this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "fleet/ask", ...rest },
+            responseType: "fleet/ask/response",
+        });
+    }
+    /** Decisions loops are waiting on a person for, most urgent first. */
+    async fleetDecisions(options = {}) {
+        return this.sendCorrelatedSessionRequest({
+            requestId: options.requestId,
+            message: {
+                type: "fleet/decisions",
+                name: options.name,
+                includeResolved: options.includeResolved,
+            },
+            responseType: "fleet/decisions/response",
+        });
+    }
+    /** Answer one decision as the human. */
+    async fleetResolveDecision(options) {
+        return this.sendCorrelatedSessionRequest({
+            requestId: options.requestId,
+            message: {
+                type: "fleet/resolve-decision",
+                decisionId: options.decisionId,
+                optionId: options.optionId,
+            },
+            responseType: "fleet/resolve-decision/response",
+        });
+    }
+    /** Persist a loop's declared parameters. */
+    async fleetSetParams(options) {
+        return this.sendCorrelatedSessionRequest({
+            requestId: options.requestId,
+            message: { type: "fleet/set-params", name: options.name, values: options.values },
+            responseType: "fleet/set-params/response",
+        });
+    }
+    /** Promote a loop to live, or demote it to dry-run. */
+    async fleetSetMode(options) {
+        return this.sendCorrelatedSessionRequest({
+            requestId: options.requestId,
+            message: {
+                type: "fleet/set-mode",
+                name: options.name,
+                mode: options.mode,
+            },
+            responseType: "fleet/set-mode/response",
+        });
+    }
+    async fleetResume(options) {
+        return this.sendCorrelatedSessionRequest({
+            requestId: options.requestId,
+            message: {
+                type: "fleet/resume",
+                name: options.name,
+            },
+            responseType: "fleet/resume/response",
+        });
+    }
+    async fleetCreate(options) {
+        return this.sendCorrelatedSessionRequest({
+            requestId: options.requestId,
+            message: {
+                type: "fleet/create",
+                name: options.name,
+                description: options.description,
+                cron: options.cron,
+                action: options.action,
+                ...(options.mode !== undefined ? { mode: options.mode } : {}),
+                ...(options.rails !== undefined ? { rails: options.rails } : {}),
+                ...(options.allowed !== undefined ? { allowed: options.allowed } : {}),
+            },
+            responseType: "fleet/create/response",
+        });
+    }
+    async fleetExecutions(options) {
+        return this.sendCorrelatedSessionRequest({
+            requestId: options.requestId,
+            message: {
+                type: "fleet/executions",
+                name: options.name,
+            },
+            responseType: "fleet/executions/response",
+        });
+    }
     async scheduleInspect(options) {
         return this.sendCorrelatedSessionRequest({
             requestId: options.requestId,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyperdrive.bot/paseo-client",
-  "version": "0.3.35",
+  "version": "0.3.36",
   "description": "Paseo client SDK package",
   "files": [
     "dist",
@@ -35,8 +35,8 @@
     "test": "vitest run"
   },
   "dependencies": {
-    "@hyperdrive.bot/paseo-protocol": "0.3.35",
-    "@hyperdrive.bot/paseo-relay": "0.3.35",
+    "@hyperdrive.bot/paseo-protocol": "0.3.36",
+    "@hyperdrive.bot/paseo-relay": "0.3.36",
     "zod": "^4.4.3"
   },
   "devDependencies": {