palmier 1.1.25 → 1.1.26

package/README.md

@@ -53,7 +53,6 @@ Every task Palmier runs gets these capabilities automatically. Their usage is wr
 | Capability | Description |
 |------------|-------------|
 | `notify` | Send a push notification to the user's device |
-| `request-choice` | Ask the user a question with a fixed set of options and return the one picked; a single option serves as a confirmation (blocks until response; aborting aborts the task) |
 | `fill-password` | Fill a saved password or PIN into the active browser session and submit the form, prompting the user if unknown (the secret is never revealed to the agent) |
 | `device-geolocation` | Get GPS location of the user's mobile device |
 | `read-contacts` | Read the contact list from the user's device |
@@ -76,7 +75,7 @@ All device tools work while the Palmier Android app is in the background — the
 
 ### Asking the User
 
-When an agent needs an answer it can't get from a fixed list, it writes its question as its final message and ends with the `[PALMIER_TASK_NEED_INPUT]` marker. The agent CLI then exits and the run moves to a "needs input" state, with a push notification that opens the run. The user answers in the run view's message box, or aborts from there.
+When an agent needs something from the user, it writes its question as its final message and ends with the `[PALMIER_TASK_NEED_INPUT]` marker. The agent CLI then exits and the run moves to a "needs input" state, with a push notification that opens the run. The user answers in the run view's message box, or aborts from there.
 
 `palmier run` stays alive during the wait, so anything the agent left running, such as its browser, stays open. Palmier polls for the reply and resumes the same agent session with it, repeating until the agent reports success or failure. An unanswered question fails the run after 24 hours. The reply is handed over through a file in the run directory, so a daemon restart doesn't lose the wait.
 

package/dist/agent-tools.js

@@ -2,7 +2,6 @@ import { registerPending } from "./pending-requests.js";
 import { getLinkedDevice } from "./linked-device.js";
 import { getNotifications } from "./notification-store.js";
 import { getSmsMessages } from "./sms-store.js";
-import { getTaskDir, readHistory, spliceUserMessage } from "./task.js";
 import { lookupPassword, savePassword, normalizeOrigin } from "./password-store.js";
 import { fillPasswordInBrowser } from "./playwright-fill.js";
 export class ToolError extends Error {
@@ -41,27 +40,6 @@ const notifyTool = {
         throw new ToolError(result.error ?? "Push notification failed", 502);
     },
 };
-/** Splice the user's answer into the run file so history shows it even if the agent never echoes it. */
-function recordUserResponseToRun(ctx, content) {
-    const taskId = ctx.taskId;
-    const taskDir = getTaskDir(ctx.config.projectRoot, taskId);
-    const { entries } = readHistory(ctx.config.projectRoot, { task_id: taskId, limit: 1 });
-    const runId = entries[0]?.run_id;
-    if (!runId)
-        return;
-    try {
-        spliceUserMessage(taskDir, runId, {
-            role: "user",
-            time: Date.now(),
-            content,
-            type: "input",
-        });
-        void ctx.publishEvent(taskId, { event_type: "result-updated", run_id: runId });
-    }
-    catch {
-        // Run file missing or unwritable — best-effort, do not fail the tool call.
-    }
-}
 export const requestConfirmationTool = {
     name: "request-confirmation",
     description: [
@@ -80,7 +58,7 @@ export const requestConfirmationTool = {
         const { description } = args;
         if (!description)
             throw new ToolError("description is required", 400);
-        const pendingPromise = registerPending(ctx.taskId, "confirmation", undefined, {
+        const pendingPromise = registerPending(ctx.taskId, "confirmation", {
             session_id: ctx.taskId,
             description,
         });
@@ -103,66 +81,6 @@ export const requestConfirmationTool = {
         return { confirmed };
     },
 };
-const requestChoiceTool = {
-    name: "request-choice",
-    description: [
-        "Ask the user a question with a fixed set of answers and let them pick one.",
-        "The request blocks until the user picks an option or aborts the task.",
-        'Response: `{"choice": "<option>"}` with the selected option, or `{"aborted": true}` if the user aborts.',
-        "Use this whenever the possible answers are known in advance.",
-        "An abort option that ends the task is always shown, so to ask for confirmation before continuing, pass a single option naming the action (e.g. [\"Send email\"]). Add a decline option only if declining should let the task continue differently.",
-    ],
-    inputSchema: {
-        type: "object",
-        properties: {
-            question: { type: "string", description: "The question to ask" },
-            options: {
-                type: "array",
-                items: { type: "string" },
-                description: 'Unique option labels, in display order (e.g. ["Reply now", "Reply later"])',
-                minItems: 1,
-            },
-        },
-        required: ["question", "options"],
-    },
-    async handler(args, ctx) {
-        const { question, options } = args;
-        if (!question)
-            throw new ToolError("question is required", 400);
-        if (!Array.isArray(options) || options.length < 1 || options.some((o) => typeof o !== "string" || !o.trim())) {
-            throw new ToolError("options must contain at least 1 non-empty string", 400);
-        }
-        if (new Set(options).size !== options.length)
-            throw new ToolError("options must be unique", 400);
-        const pendingPromise = registerPending(ctx.taskId, "choice", options, {
-            session_id: ctx.taskId,
-            description: question,
-        });
-        await ctx.publishEvent("_choice", {
-            event_type: "choice-request",
-            host_id: ctx.config.hostId,
-            session_id: ctx.taskId,
-            description: question,
-            options,
-        });
-        // Clients answer with the option index so no label can collide with the "aborted" sentinel.
-        const response = await pendingPromise;
-        const choice = /^\d+$/.test(response[0] ?? "") ? options[Number(response[0])] : undefined;
-        const aborted = choice === undefined;
-        recordUserResponseToRun(ctx, aborted ? "Aborted" : `**${question}**\n\n${choice}`);
-        await ctx.publishEvent("_choice", {
-            event_type: "choice-resolved",
-            host_id: ctx.config.hostId,
-            session_id: ctx.taskId,
-            status: aborted ? "aborted" : "chosen",
-        });
-        if (aborted) {
-            await ctx.abortTask();
-            return { aborted: true };
-        }
-        return { choice };
-    },
-};
 const fillPasswordTool = {
     name: "fill-password",
     description: [
@@ -190,26 +108,21 @@ const fillPasswordTool = {
         const origin = normalizeOrigin(url);
         let password = lookupPassword(origin, username);
         if (password === undefined) {
-            const question = `Password or PIN for ${username} on ${origin}`;
             const description = `Enter the password or PIN to sign in as ${username} on ${origin}.`;
-            const pendingPromise = registerPending(ctx.taskId, "input", [question], {
+            const pendingPromise = registerPending(ctx.taskId, "password", {
                 session_id: ctx.taskId,
                 description,
-                input_questions: [question],
-                secret: true,
             });
-            await ctx.publishEvent("_input", {
-                event_type: "input-request",
+            await ctx.publishEvent("_password", {
+                event_type: "password-request",
                 host_id: ctx.config.hostId,
                 session_id: ctx.taskId,
                 description,
-                input_questions: [question],
-                secret: true,
             });
             const response = await pendingPromise;
             const aborted = response.length === 1 && response[0] === "aborted";
-            await ctx.publishEvent("_input", {
-                event_type: "input-resolved", host_id: ctx.config.hostId,
+            await ctx.publishEvent("_password", {
+                event_type: "password-resolved", host_id: ctx.config.hostId,
                 session_id: ctx.taskId, status: aborted ? "aborted" : "provided",
             });
             // Never record the secret to the task run file.
@@ -218,8 +131,7 @@ const fillPasswordTool = {
                 return { aborted: true };
             }
             password = response[0];
-            // The PWA appends a "save"/"nosave" flag for password prompts; persist
-            // unless the user opted out via the dialog's checkbox.
+            // The PWA appends a "save"/"nosave" flag; persist unless the user opted out.
             if (response[1] !== "nosave")
                 savePassword(origin, username, password);
         }
@@ -722,7 +634,7 @@ const sendEmailTool = {
         return result;
     },
 };
-export const agentTools = [notifyTool, requestChoiceTool, fillPasswordTool, deviceGeolocationTool, readContactsTool, createContactTool, readCalendarTool, createCalendarEventTool, sendSmsTool, sendEmailTool, sendAlarmTool, readBatteryTool, setRingerModeTool];
+export const agentTools = [notifyTool, fillPasswordTool, deviceGeolocationTool, readContactsTool, createContactTool, readCalendarTool, createCalendarEventTool, sendSmsTool, sendEmailTool, sendAlarmTool, readBatteryTool, setRingerModeTool];
 export const agentToolMap = new Map(agentTools.map((t) => [t.name, t]));
 const deviceNotificationsResource = {
     name: "Device Notifications",

package/dist/agents/agent-instructions.md

@@ -25,9 +25,9 @@ Do this at the end of every response, including responses to follow-up messages.
 
 ## Asking the User
 
-When you need information from the user (answers to questions, preferences, clarifications, etc.), do not guess or fail. Write your questions in full as your final message, then end it with `[PALMIER_TASK_NEED_INPUT]`. Your process will exit, and the user's reply will arrive as the next message in this same session. Anything you left running, such as a browser, stays open, so leave it as it is.
+When you need something from the user (answers to questions, preferences, confirmation before acting, clarifications, etc.), do not guess or fail. Write your questions in full as your final message, then end it with `[PALMIER_TASK_NEED_INPUT]`. Your process will exit, and the user's reply will arrive as the next message in this same session. Anything you left running, such as a browser, stays open, so leave it as it is.
 
-If the possible answers are known in advance, use the `request-choice` endpoint instead. For passwords and PINs, use `fill-password`.
+If the possible answers are known in advance, list them in your question. For passwords and PINs, use `fill-password` instead.
 
 ## Browsers
 

package/dist/pending-requests.d.ts

@@ -3,15 +3,10 @@ export interface PendingRequestMeta {
     session_id?: string;
     session_name?: string;
     description?: string;
-    input_questions?: string[];
-    /** Render the input field(s) masked (password entry). */
-    secret?: boolean;
 }
 export interface PendingRequest {
-    type: "confirmation" | "input" | "choice";
+    type: "confirmation" | "password";
     resolve: (value: string[]) => void;
-    /** Input descriptions (for 'input') or option labels (for 'choice'). */
-    params?: string[];
     /** Display context for PWAs that connect while this request is already open. */
     meta?: PendingRequestMeta;
 }
@@ -19,7 +14,7 @@ export interface PendingRequest {
  * Keyed by taskId. Only one pending request per key at a time. `meta` is surfaced
  * via host.info so a freshly-connected PWA can render the modal without replaying events.
  */
-export declare function registerPending(key: string, type: PendingRequest["type"], params?: PendingRequest["params"], meta?: PendingRequestMeta): Promise<string[]>;
+export declare function registerPending(key: string, type: PendingRequest["type"], meta?: PendingRequestMeta): Promise<string[]>;
 export declare function resolvePending(key: string, value: string[]): boolean;
 export declare function getPending(key: string): PendingRequest | undefined;
 export declare function removePending(key: string): void;
@@ -27,6 +22,5 @@ export declare function removePending(key: string): void;
 export declare function listPending(): Array<{
     key: string;
     type: PendingRequest["type"];
-    params?: PendingRequest["params"];
     meta?: PendingRequestMeta;
 }>;

package/dist/pending-requests.js

@@ -3,12 +3,12 @@ const pending = new Map();
  * Keyed by taskId. Only one pending request per key at a time. `meta` is surfaced
  * via host.info so a freshly-connected PWA can render the modal without replaying events.
  */
-export function registerPending(key, type, params, meta) {
+export function registerPending(key, type, meta) {
     if (pending.has(key)) {
         return Promise.reject(new Error(`Key ${key} already has a pending request`));
     }
     return new Promise((resolve) => {
-        pending.set(key, { type, resolve, params, meta });
+        pending.set(key, { type, resolve, meta });
     });
 }
 export function resolvePending(key, value) {
@@ -30,7 +30,6 @@ export function listPending() {
     return [...pending.entries()].map(([key, entry]) => ({
         key,
         type: entry.type,
-        params: entry.params,
         meta: entry.meta,
     }));
 }