@getpaseo/cli 0.2.3 → 0.2.4

package/dist/commands/agent/index.js

@@ -46,9 +46,10 @@ export function createAgentCommand() {
         .argument("<id>", "Agent ID, prefix, or name")).action(withOutput(runDetachCommand));
     addJsonAndDaemonHostOptions(agent
         .command("update")
-        .description("Update an agent's metadata")
+        .description("Update an agent's settings or metadata")
         .argument("<id>", "Agent ID (or prefix)")
         .option("--name <name>", "Update the agent's display name")
+        .option("--thinking <id>", "Update the agent's thinking option ID")
         .option("--label <label>", "Add/set label(s) on the agent (can be used multiple times or comma-separated)", collectMultiple, [])).action(withOutput(runUpdateCommand));
     return agent;
 }

package/dist/commands/agent/update.d.ts

@@ -1,18 +1,51 @@
 import type { Command } from "commander";
+import type { AgentProviderNotice } from "@getpaseo/protocol/agent-types";
+import type { AgentSnapshotPayload } from "@getpaseo/protocol/messages";
 import type { CommandOptions, SingleResult, OutputSchema } from "../../output/index.js";
 /** Result type for agent update command */
 export interface AgentUpdateResult {
     agentId: string;
     name: string | null;
     labels: string;
+    thinkingOptionId: string | null;
+    noticeType: AgentProviderNotice["type"] | null;
+    notice: string | null;
 }
 /** Schema for update command output */
 export declare const updateSchema: OutputSchema<AgentUpdateResult>;
 export interface AgentUpdateOptions extends CommandOptions {
     name?: string;
     label?: string[];
+    thinking?: string;
     host?: string;
 }
 export type AgentUpdateCommandResult = SingleResult<AgentUpdateResult>;
+export interface AgentMetadataChanges {
+    name?: string;
+    labels?: Record<string, string>;
+}
+interface AgentUpdateServerInfo {
+    features?: {
+        agentThinkingUpdate?: boolean;
+    };
+}
+export interface AgentUpdateClient {
+    getLastServerInfoMessage(): AgentUpdateServerInfo | null;
+    updateAgent(agentId: string, updates: AgentMetadataChanges): Promise<void>;
+    setAgentThinkingOption(agentId: string, thinkingOptionId: string): Promise<AgentProviderNotice | null>;
+}
+export type AgentChanges = {
+    type: "metadata";
+    updates: AgentMetadataChanges;
+} | {
+    type: "thinking";
+    thinkingOptionId: string;
+};
+export interface AppliedAgentChanges {
+    notice: AgentProviderNotice | null;
+}
+export declare function toAgentUpdateResult(agent: Pick<AgentSnapshotPayload, "id" | "title" | "labels" | "effectiveThinkingOptionId">, appliedChanges: AppliedAgentChanges): AgentUpdateResult;
+export declare function applyAgentChanges(client: AgentUpdateClient, agentId: string, changes: AgentChanges): Promise<AppliedAgentChanges>;
 export declare function runUpdateCommand(agentIdArg: string, options: AgentUpdateOptions, _command: Command): Promise<AgentUpdateCommandResult>;
+export {};
 //# sourceMappingURL=update.d.ts.map

package/dist/commands/agent/update.js

@@ -6,8 +6,35 @@ export const updateSchema = {
         { header: "AGENT ID", field: "agentId" },
         { header: "NAME", field: "name" },
         { header: "LABELS", field: "labels" },
+        { header: "THINKING", field: "thinkingOptionId" },
+        { header: "NOTICE", field: "notice" },
     ],
 };
+export function toAgentUpdateResult(agent, appliedChanges) {
+    return {
+        agentId: agent.id,
+        name: agent.title,
+        labels: formatLabels(agent.labels),
+        thinkingOptionId: agent.effectiveThinkingOptionId ?? null,
+        noticeType: appliedChanges.notice?.type ?? null,
+        notice: appliedChanges.notice?.message ?? null,
+    };
+}
+export async function applyAgentChanges(client, agentId, changes) {
+    if (changes.type === "thinking") {
+        // COMPAT(agentThinkingUpdate): added in v0.2.4, remove gate after 2027-01-28.
+        if (client.getLastServerInfoMessage()?.features?.agentThinkingUpdate !== true) {
+            throw {
+                code: "DAEMON_UPDATE_REQUIRED",
+                message: "Update the host to use agent thinking updates.",
+            };
+        }
+        const notice = await client.setAgentThinkingOption(agentId, changes.thinkingOptionId);
+        return { notice };
+    }
+    await client.updateAgent(agentId, changes.updates);
+    return { notice: null };
+}
 function parseLabelOptions(labels) {
     const parsed = {};
     if (!labels) {
@@ -50,35 +77,62 @@ function formatLabels(labels) {
     }
     return entries.map(([key, value]) => `${key}=${value}`).join(",");
 }
-export async function runUpdateCommand(agentIdArg, options, _command) {
-    const host = getDaemonHost({ host: options.host });
-    // Validate arguments
-    if (!agentIdArg || agentIdArg.trim().length === 0) {
-        const error = {
-            code: "MISSING_AGENT_ID",
-            message: "Agent ID is required",
-            details: "Usage: paseo agent update <id> [--name <name>] [--label <key=value>]",
-        };
-        throw error;
-    }
+function parseAgentChanges(options) {
     const name = options.name?.trim();
     if (options.name !== undefined && !name) {
-        const error = {
+        throw {
             code: "INVALID_NAME",
             message: "Name cannot be empty",
             details: "Use --name <name> with a non-empty value",
         };
-        throw error;
     }
     const labels = parseLabelOptions(options.label);
-    if (!name && Object.keys(labels).length === 0) {
-        const error = {
+    const thinkingOptionId = options.thinking?.trim();
+    if (options.thinking !== undefined && !thinkingOptionId) {
+        throw {
+            code: "INVALID_THINKING_OPTION",
+            message: "--thinking cannot be empty",
+            details: 'Provide a thinking option ID. Use "paseo provider models <provider> --thinking" to list valid IDs.',
+        };
+    }
+    const hasMetadataUpdates = Boolean(name) || Object.keys(labels).length > 0;
+    if (hasMetadataUpdates && thinkingOptionId) {
+        throw {
+            code: "INVALID_OPTIONS",
+            message: "--thinking cannot be combined with --name or --label",
+            details: "Run separate agent update commands for runtime settings and metadata.",
+        };
+    }
+    if (!hasMetadataUpdates && !thinkingOptionId) {
+        throw {
             code: "NO_CHANGES_PROVIDED",
             message: "Nothing to update",
-            details: "Provide at least one of: --name <name>, --label <key=value>",
+            details: "Provide at least one of: --name <name>, --label <key=value>, --thinking <id>",
+        };
+    }
+    if (thinkingOptionId) {
+        return { type: "thinking", thinkingOptionId };
+    }
+    return {
+        type: "metadata",
+        updates: {
+            ...(name ? { name } : {}),
+            ...(Object.keys(labels).length > 0 ? { labels } : {}),
+        },
+    };
+}
+export async function runUpdateCommand(agentIdArg, options, _command) {
+    const host = getDaemonHost({ host: options.host });
+    // Validate arguments
+    if (!agentIdArg || agentIdArg.trim().length === 0) {
+        const error = {
+            code: "MISSING_AGENT_ID",
+            message: "Agent ID is required",
+            details: "Usage: paseo agent update <id> [--name <name>] [--label <key=value>]",
         };
         throw error;
     }
+    const changes = parseAgentChanges(options);
     let client;
     try {
         client = await connectToDaemon({ host: options.host });
@@ -103,10 +157,7 @@ export async function runUpdateCommand(agentIdArg, options, _command) {
             throw error;
         }
         const agentId = fetchResult.agent.id;
-        await client.updateAgent(agentId, {
-            ...(name ? { name } : {}),
-            ...(Object.keys(labels).length > 0 ? { labels } : {}),
-        });
+        const appliedChanges = await applyAgentChanges(client, agentId, changes);
         const updatedResult = await client.fetchAgent({ agentId });
         if (!updatedResult) {
             throw new Error(`Agent not found after update: ${agentId}`);
@@ -114,11 +165,7 @@ export async function runUpdateCommand(agentIdArg, options, _command) {
         await client.close();
         return {
             type: "single",
-            data: {
-                agentId,
-                name: updatedResult.agent.title,
-                labels: formatLabels(updatedResult.agent.labels),
-            },
+            data: toAgentUpdateResult(updatedResult.agent, appliedChanges),
             schema: updateSchema,
         };
     }

package/dist/commands/schedule/create.d.ts

@@ -9,6 +9,7 @@ export interface ScheduleCreateOptions extends ScheduleCommandOptions {
     target?: string;
     provider?: string;
     mode?: string;
+    thinking?: string;
     cwd?: string;
     maxRuns?: string;
     expiresIn?: string;

package/dist/commands/schedule/create.js

@@ -12,6 +12,7 @@ export async function runCreateCommand(prompt, options, command) {
         target: options.target,
         provider: options.provider,
         mode: options.mode,
+        thinking: options.thinking,
         cwd: options.cwd,
         host: options.host,
         maxRuns: options.maxRuns,

package/dist/commands/schedule/index.js

@@ -23,6 +23,7 @@ export function createScheduleCommand() {
         .addOption(new Option("--target <target>", "Legacy schedule target").hideHelp())
         .option("--provider <provider>", "Agent provider, or provider/model (e.g. codex or codex/gpt-5.4)")
         .option("--mode <mode>", "Provider-specific mode (e.g. claude bypassPermissions, opencode build)")
+        .option("--thinking <id>", "Thinking option ID for new-agent runs")
         .option("--cwd <path>", "Working directory (default: current; required with --host)")
         .option("--run-now", "Fire one immediate run on creation")
         .option("--max-runs <n>", "Maximum number of runs")

package/dist/commands/schedule/shared.d.ts

@@ -21,6 +21,7 @@ export declare function parseScheduleCreateInput(options: {
     target?: string;
     provider?: string;
     mode?: string;
+    thinking?: string;
     cwd?: string;
     host?: string;
     maxRuns?: string;

package/dist/commands/schedule/shared.js

@@ -82,7 +82,7 @@ function resolveScheduleTarget(args) {
     if (hasExplicitNewAgentOption) {
         throw {
             code: "INVALID_TARGET",
-            message: "--provider/--mode can only be used with a new-agent target",
+            message: "--provider/--mode/--thinking can only be used with a new-agent target",
             details: "Use --target new-agent or omit --target to create a new agent schedule",
         };
     }
@@ -125,7 +125,14 @@ export function parseScheduleCreateInput(options) {
     const runOnCreate = resolveRunOnCreate(options.runNow, cadence.type);
     const targetValue = options.target?.trim();
     const modeId = options.mode?.trim();
-    const hasExplicitNewAgentOption = options.provider !== undefined || options.mode !== undefined;
+    const thinkingOptionId = options.thinking?.trim();
+    if (options.thinking !== undefined && !thinkingOptionId) {
+        throw {
+            code: "INVALID_THINKING_OPTION",
+            message: "--thinking cannot be empty",
+        };
+    }
+    const hasExplicitNewAgentOption = options.provider !== undefined || options.mode !== undefined || options.thinking !== undefined;
     const createNewAgentTarget = () => {
         const resolvedProviderModel = resolveProviderAndModel({
             provider: options.provider,
@@ -137,6 +144,7 @@ export function parseScheduleCreateInput(options) {
                 cwd: cwdInput ?? process.cwd(),
                 ...(resolvedProviderModel.model ? { model: resolvedProviderModel.model } : {}),
                 ...(modeId ? { modeId } : {}),
+                ...(thinkingOptionId ? { thinkingOptionId } : {}),
             },
         };
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getpaseo/cli",
-  "version": "0.2.3",
+  "version": "0.2.4",
   "description": "Paseo CLI - control your AI coding agents from the command line",
   "bin": {
     "paseo": "bin/paseo"
@@ -28,9 +28,9 @@
   },
   "dependencies": {
     "@clack/prompts": "^1.0.0",
-    "@getpaseo/client": "0.2.3",
-    "@getpaseo/protocol": "0.2.3",
-    "@getpaseo/server": "0.2.3",
+    "@getpaseo/client": "0.2.4",
+    "@getpaseo/protocol": "0.2.4",
+    "@getpaseo/server": "0.2.4",
     "chalk": "^5.3.0",
     "commander": "^12.0.0",
     "mime-types": "^2.1.35",