palmier 1.1.24 → 1.1.26

package/README.md

@@ -53,8 +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-input` | Request input from the user (blocks until response; aborting the prompt aborts the task) |
-| `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 |
@@ -75,6 +73,12 @@ Every task Palmier runs gets these capabilities automatically. Their usage is wr
 
 All device tools work while the Palmier Android app is in the background — they communicate via FCM data messages which wake the app's service even when it's not in the foreground. Each host has one **linked device**: the phone the host uses for SMS, contacts, location, and other device capabilities. Choose it at pair time (the "Link the host to this device" checkbox) or later from the drawer. Each capability must be enabled and its Android permission granted via toggles in the linked device's drawer.
 
+### Asking the User
+
+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.
+
 ### Files in Agent Output
 
 Agents run with the task's run directory (`~/palmier/tasks/<task-id>/<run-id>/`) as their working directory and are instructed to link any file they produce with a relative markdown link, e.g. `[View report](report.md)` or `![Chart](chart.png)`. The app opens these links over whichever transport is in use (local, relay, or auto-LAN). It fetches the file through the `task.file` RPC in 512 KiB chunks, so large files fit within the relay's message size. Markdown files render in-app, with their own relative links and images resolved from the file's location. Text and images are previewed, and other file types are offered as a browser download. The host only serves files whose real path (after resolving symlinks) is inside that task's directory, up to 25 MB. A run whose output links an existing file triggers a "report ready" push notification.

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,84 +40,6 @@ const notifyTool = {
         throw new ToolError(result.error ?? "Push notification failed", 502);
     },
 };
-const requestInputTool = {
-    name: "request-input",
-    description: [
-        "Request input from the user.",
-        "The request blocks until the user responds.",
-        'Response: `{"values": ["answer1", "answer2"]}` on success, or `{"aborted": true}` if the user declines.',
-        "When you need information from the user (credentials, answers to questions, preferences, clarifications, etc.), do not guess, fail, or prompt via stdout, even in a non-interactive environment — use this instead.",
-    ],
-    inputSchema: {
-        type: "object",
-        properties: {
-            description: { type: "string", description: "Context or heading for the input request" },
-            questions: {
-                type: "array",
-                items: { type: "string" },
-                description: "Questions to present to the user",
-                minItems: 1,
-            },
-        },
-        required: ["questions"],
-    },
-    async handler(args, ctx) {
-        const { description, questions } = args;
-        if (!questions?.length)
-            throw new ToolError("questions is required", 400);
-        const pendingPromise = registerPending(ctx.taskId, "input", questions, {
-            session_id: ctx.taskId,
-            description,
-            input_questions: questions,
-        });
-        await ctx.publishEvent("_input", {
-            event_type: "input-request",
-            host_id: ctx.config.hostId,
-            session_id: ctx.taskId,
-            description,
-            input_questions: questions,
-        });
-        const response = await pendingPromise;
-        const aborted = response.length === 1 && response[0] === "aborted";
-        recordUserResponseToRun(ctx, aborted
-            ? "Aborted"
-            : questions.map((q, i) => `**${q}**\n\n${response[i] ?? ""}`).join("\n\n"));
-        if (aborted) {
-            await ctx.publishEvent("_input", {
-                event_type: "input-resolved", host_id: ctx.config.hostId,
-                session_id: ctx.taskId, status: "aborted",
-            });
-            await ctx.abortTask();
-            return { aborted: true };
-        }
-        await ctx.publishEvent("_input", {
-            event_type: "input-resolved", host_id: ctx.config.hostId,
-            session_id: ctx.taskId, status: "provided",
-        });
-        return { values: response };
-    },
-};
-/** 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: [
@@ -137,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,
         });
@@ -160,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 instead of request-input 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: [
@@ -247,36 +108,30 @@ 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 (unlike request-input).
+            // Never record the secret to the task run file.
             if (aborted) {
                 await ctx.abortTask();
                 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);
         }
@@ -779,7 +634,7 @@ const sendEmailTool = {
         return result;
     },
 };
-export const agentTools = [notifyTool, requestInputTool, 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

@@ -13,22 +13,29 @@ The user reads your output on a different device and can only open files you lin
 
 ## Completion
 
-When you are done, output exactly one of these markers as the very last line on stdout (no other text on the same line):
+When you stop, output exactly one of these markers as the very last line on stdout (no other text on the same line):
 [PALMIER_TASK_SUCCESS]
 [PALMIER_TASK_FAILURE]
+[PALMIER_TASK_NEED_INPUT]
 
 On the line right before that marker, in the same final message, print the model you are running as, using the exact model name or ID from your system prompt (skip this line if you do not know it rather than guessing):
 [PALMIER_AGENT_MODEL] <model>
 
 Do this at the end of every response, including responses to follow-up messages.
 
+## Asking the User
+
+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, list them in your question. For passwords and PINs, use `fill-password` instead.
+
 ## Browsers
 
 Whenever the task needs a browser, launch it with the Playwright CLI (`playwright-cli open`). Do not use any other browser tool, automation library, or launch method.
 
 When launching, always pass `--headed` (never run headless) and `--persistent` (reuse a persistent profile so logins and cookies survive across runs).
 
-When the task is finished, close any browser you opened with the Playwright CLI `close` command (pass the same `-s=<session>` if you used one) before printing the completion marker.
+When the task has succeeded or failed, close any browser you opened with the Playwright CLI `close` command (pass the same `-s=<session>` if you used one) before printing the completion marker. Do not close it when you are stopping to ask the user for input.
 
 ## HTTP Endpoints
 

package/dist/agents/agent.js

@@ -10,10 +10,8 @@ import { kimiAgent } from "./kimi.js";
 import { gooseAgent } from "./goose.js";
 import { openCodeAgent } from "./opencode.js";
 import { deepAgentsAgent } from "./deepagents.js";
-import { aiderAgent } from "./aider.js";
 import { cursorAgent } from "./cursor.js";
 import { kiroAgent } from "./kiro.js";
-import { clineAgent } from "./cline.js";
 import { qoderAgent } from "./qoder.js";
 import { hermesAgent } from "./hermes.js";
 import { grokAgent } from "./grok.js";
@@ -66,10 +64,8 @@ const agentRegistry = {
     goose: gooseAgent,
     opencode: openCodeAgent,
     deepagents: deepAgentsAgent,
-    aider: aiderAgent,
     cursor: cursorAgent,
     kiro: kiroAgent,
-    cline: clineAgent,
     openclaw: openClawAgent,
     hermes: hermesAgent,
 };

package/dist/agents/shared-prompt.d.ts

@@ -2,4 +2,7 @@ import type { ParsedTask } from "../types.js";
 export declare function getAgentInstructions(task: ParsedTask): string;
 export declare const TASK_SUCCESS_MARKER = "[PALMIER_TASK_SUCCESS]";
 export declare const TASK_FAILURE_MARKER = "[PALMIER_TASK_FAILURE]";
+export declare const TASK_NEED_INPUT_MARKER = "[PALMIER_TASK_NEED_INPUT]";
 export declare const AGENT_MODEL_PREFIX = "[PALMIER_AGENT_MODEL]";
+/** A resumed session may have lost the original instructions to compaction, and a missing marker silently ends the run. */
+export declare function getResumePrompt(userMessage: string): string;

package/dist/agents/shared-prompt.js

@@ -14,4 +14,9 @@ export function getAgentInstructions(task) {
 }
 export const TASK_SUCCESS_MARKER = "[PALMIER_TASK_SUCCESS]";
 export const TASK_FAILURE_MARKER = "[PALMIER_TASK_FAILURE]";
+export const TASK_NEED_INPUT_MARKER = "[PALMIER_TASK_NEED_INPUT]";
 export const AGENT_MODEL_PREFIX = "[PALMIER_AGENT_MODEL]";
+/** A resumed session may have lost the original instructions to compaction, and a missing marker silently ends the run. */
+export function getResumePrompt(userMessage) {
+    return `${userMessage}\n\n---\nEnd your response with exactly one of these as the very last line on stdout: ${TASK_SUCCESS_MARKER}, ${TASK_FAILURE_MARKER}, or ${TASK_NEED_INPUT_MARKER} if you need more from the user.`;
+}

package/dist/commands/run.d.ts

@@ -7,5 +7,5 @@ export declare function listLinkedTaskFiles(taskDir: string, runId: string, outp
 export declare function parseAgentModel(output: string): string | undefined;
 /** Returns a function that accumulates stderr chunks and yields the model once the CLI banner reveals it. */
 export declare function createCliModelCapture(agent: AgentTool): (stderrChunk: string) => string | undefined;
-/** Falls back to "finished" if no success/failure marker is found. */
+/** Falls back to "finished" if no outcome marker is found. */
 export declare function parseTaskOutcome(output: string): TaskRunningState;

package/dist/commands/run.js

@@ -2,17 +2,17 @@ import * as fs from "fs";
 import * as path from "path";
 import { spawnCommand } from "../spawn-command.js";
 import { loadConfig } from "../config.js";
-import { parseTaskFile, taskDisplayName, getTaskDir, writeTaskStatus, readTaskStatus, appendHistory, createRunDir, claimPendingRun, appendRunMessage, getRunDir, beginStreamingMessage, formatAgentModelComment } from "../task.js";
+import { parseTaskFile, taskDisplayName, getTaskDir, writeTaskStatus, readTaskStatus, appendHistory, createRunDir, claimPendingRun, appendRunMessage, getRunDir, beginStreamingMessage, formatAgentModelComment, takeUserReply } from "../task.js";
 import { getAgent } from "../agents/agent.js";
 import { getPlatform } from "../platform/index.js";
-import { TASK_SUCCESS_MARKER, TASK_FAILURE_MARKER, AGENT_MODEL_PREFIX } from "../agents/shared-prompt.js";
+import { TASK_SUCCESS_MARKER, TASK_FAILURE_MARKER, TASK_NEED_INPUT_MARKER, AGENT_MODEL_PREFIX, getResumePrompt } from "../agents/shared-prompt.js";
 import { extractFileLinks, resolveTaskFile } from "../task-files.js";
 import { publishHostEvent } from "../events.js";
 /**
  * `invokeTask` is the ParsedTask whose prompt is passed to the agent (for
  * triggered tasks this is the per-trigger augmented task).
  */
-async function invokeAgent(ctx, invokeTask) {
+async function invokeAgent(ctx, invokeTask, followupPrompt) {
     let writer;
     let activeStream;
     const lineBufs = { stdout: "", stderr: "" };
@@ -77,7 +77,7 @@ async function invokeAgent(ctx, invokeTask) {
             ensureWriter(stream).write(trailing);
         }
     }
-    const { args, stdin, env: agentEnv, files } = ctx.agent.getTaskRunCommandLine(invokeTask);
+    const { args, stdin, env: agentEnv, files } = ctx.agent.getTaskRunCommandLine(invokeTask, followupPrompt);
     const command = ctx.agent.command;
     const runDir = getRunDir(ctx.taskDir, ctx.runId);
     if (files) {
@@ -130,6 +130,47 @@ function resolveOutcome(taskDir, outcome) {
         return "aborted";
     return outcome;
 }
+const USER_REPLY_POLL_MS = 500;
+// A recurring task can't fire again while this run is waiting, so an unanswered question can't hold it forever.
+const USER_REPLY_TIMEOUT_MS = 24 * 60 * 60 * 1000;
+async function waitForUserReply(runDir) {
+    const deadline = Date.now() + USER_REPLY_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+        const reply = takeUserReply(runDir);
+        if (reply)
+            return reply;
+        await new Promise((resolve) => setTimeout(resolve, USER_REPLY_POLL_MS));
+    }
+    return undefined;
+}
+/**
+ * Only the agent CLI exits while the user answers. This process stays alive because
+ * the OS scheduler would otherwise clean up what the agent left running, like its browser.
+ */
+async function invokeAgentUntilDone(ctx, invokeTask) {
+    const taskName = taskDisplayName(ctx.task.frontmatter);
+    const runDir = getRunDir(ctx.taskDir, ctx.runId);
+    let result = await invokeAgent(ctx, invokeTask);
+    while (resolveOutcome(ctx.taskDir, result.outcome) === "needs_input") {
+        appendRunMessage(ctx.taskDir, ctx.runId, { role: "status", time: Date.now(), content: "", type: "needs_input" });
+        await publishTaskEvent(ctx.taskDir, ctx.taskId, "needs_input", taskName, ctx.runId);
+        const reply = await waitForUserReply(runDir);
+        if (!reply) {
+            await appendAndNotify(ctx, {
+                role: "assistant",
+                time: Date.now(),
+                content: "The task stopped because no reply arrived within 24 hours.",
+            });
+            return { outcome: "failed" };
+        }
+        appendRunMessage(ctx.taskDir, ctx.runId, { role: "user", time: Date.now(), content: reply, type: "input" });
+        appendRunMessage(ctx.taskDir, ctx.runId, { role: "status", time: Date.now(), content: "", type: "started" });
+        await publishTaskEvent(ctx.taskDir, ctx.taskId, "started", taskName, ctx.runId);
+        await publishHostEvent(ctx.taskId, { event_type: "result-updated", run_id: ctx.runId });
+        result = await invokeAgent(ctx, invokeTask, getResumePrompt(reply));
+    }
+    return result;
+}
 export async function runCommand(taskId) {
     const config = loadConfig();
     const taskDir = getTaskDir(config.projectRoot, taskId);
@@ -196,7 +237,7 @@ export async function runCommand(taskId) {
                 time: Date.now(),
                 content: task.frontmatter.user_prompt,
             });
-            const result = await invokeAgent(ctx, task);
+            const result = await invokeAgentUntilDone(ctx, task);
             const outcome = resolveOutcome(taskDir, result.outcome);
             appendRunMessage(taskDir, runId, { role: "status", time: Date.now(), content: "", type: outcome });
             await publishTaskEvent(taskDir, taskId, outcome, taskName, runId);
@@ -257,7 +298,7 @@ async function runEventTriggeredMode(ctx) {
             const perEventTask = {
                 frontmatter: { ...ctx.task.frontmatter, user_prompt: perEventPrompt },
             };
-            const result = await invokeAgent(ctx, perEventTask);
+            const result = await invokeAgentUntilDone(ctx, perEventTask);
             lastOutcome = result.outcome;
         }
     }
@@ -273,7 +314,8 @@ async function publishTaskEvent(taskDir, taskId, eventType, taskName, runId) {
     writeTaskStatus(taskDir, {
         running_state: eventType,
         time_stamp: Date.now(),
-        ...(eventType === "started" ? { pid: process.pid } : {}),
+        ...(eventType === "started" || eventType === "needs_input" ? { pid: process.pid } : {}),
+        ...(eventType === "needs_input" ? { run_id: runId } : {}),
     });
     const payload = { event_type: "running-state", running_state: eventType };
     if (taskName)
@@ -344,10 +386,10 @@ function sanitizeAgentModel(raw) {
         return undefined;
     return model;
 }
-/** Falls back to "finished" if no success/failure marker is found. */
+/** Falls back to "finished" if no outcome marker is found. */
 export function parseTaskOutcome(output) {
     const lastChunk = output.slice(-500);
-    const regex = new RegExp(`^\\${TASK_FAILURE_MARKER}$|^\\${TASK_SUCCESS_MARKER}$`, "gm");
+    const regex = new RegExp(`^\\${TASK_FAILURE_MARKER}$|^\\${TASK_SUCCESS_MARKER}$|^\\${TASK_NEED_INPUT_MARKER}$`, "gm");
     let last = null;
     let match;
     while ((match = regex.exec(lastChunk)) !== null) {
@@ -355,6 +397,8 @@ export function parseTaskOutcome(output) {
     }
     if (last === TASK_FAILURE_MARKER)
         return "failed";
+    if (last === TASK_NEED_INPUT_MARKER)
+        return "needs_input";
     if (last === TASK_SUCCESS_MARKER)
         return "finished";
     return "finished";

package/dist/commands/serve.js

@@ -42,7 +42,9 @@ async function checkStaleTasks(config) {
         catch {
             continue;
         }
-        if (status.running_state === "started" && !platform.isTaskRunning(taskId)) {
+        // Follow-up turns also end in needs_input, but no process is held open for them.
+        const isWaitingRun = status.running_state === "needs_input" && status.pid !== undefined;
+        if ((status.running_state === "started" || isWaitingRun) && !platform.isTaskRunning(taskId)) {
             console.log(`[monitor] Task ${taskId} process exited unexpectedly, marking as failed.`);
             const endTime = Date.now();
             writeTaskStatus(taskDir, { running_state: "failed", time_stamp: endTime });
@@ -64,7 +66,7 @@ async function checkStaleTasks(config) {
                 name: taskDisplayName(task.frontmatter) || taskId,
             });
         }
-        if (task.frontmatter.one_off && status.running_state !== "started") {
+        if (task.frontmatter.one_off && status.running_state !== "started" && !isWaitingRun) {
             try {
                 platform.removeTaskTimer(taskId);
             }

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,
     }));
 }