@chainingintention/pi-web-cn 2.202610.5 → 2.202611.1

package/dist/pi-packages/session-naming/extensions/index.js

@@ -0,0 +1,74 @@
+// Generated from pi-packages/session-naming/extensions/index.ts. Do not edit directly.
+import { loadSessionNamingConfig, sessionNamingAgentDir } from "../config.js";
+import { fallbackSessionName, generateShortSessionName } from "../generator.js";
+export default function sessionNaming(pi) {
+    registerSessionNaming(pi, {
+        loadConfig: () => loadSessionNamingConfig(sessionNamingAgentDir()),
+        warn: (error) => { console.warn("[session-naming] Automatic naming failed; using the first request as a fallback:", error); },
+    });
+}
+export function registerSessionNaming(pi, dependencies) {
+    const attempted = new Set();
+    let generation = 0;
+    let active;
+    const cancel = () => {
+        generation++;
+        active?.abort();
+        active = undefined;
+    };
+    pi.on("session_shutdown", cancel);
+    pi.on("session_before_tree", cancel);
+    pi.on("session_start", cancel);
+    // A name set and subsequently cleared while the request is pending still wins.
+    pi.on("session_info_changed", cancel);
+    pi.on("before_agent_start", (event, ctx) => {
+        if (event.messageType !== "user")
+            return;
+        const id = ctx.sessionManager.getSessionId();
+        if (attempted.has(id) || active || hasName(pi, ctx)
+            || ctx.sessionManager.getEntries().some((entry) => entry.type === "message"))
+            return;
+        attempted.add(id);
+        const model = ctx.model;
+        const requestSignal = ctx.signal;
+        const token = ++generation;
+        const controller = new AbortController();
+        active = controller;
+        const signal = requestSignal === undefined ? controller.signal : AbortSignal.any([controller.signal, requestSignal]);
+        const current = () => !signal.aborted && generation === token
+            && ctx.sessionManager.getSessionId() === id && !hasName(pi, ctx);
+        // Deliberately detached: before_agent_start must never await config or a provider.
+        const nameSession = async () => {
+            let name;
+            try {
+                const config = await dependencies.loadConfig();
+                if (!current())
+                    return;
+                const selected = config.model === undefined ? model : (() => {
+                    const slash = config.model.indexOf("/");
+                    return ctx.modelRegistry.find(config.model.slice(0, slash), config.model.slice(slash + 1));
+                })();
+                if (!selected)
+                    throw new Error(`Session naming model unavailable: ${config.model ?? "session model"}`);
+                name = await generateShortSessionName(ctx.modelRegistry, selected, event.prompt, config, signal);
+                if (name === undefined)
+                    throw new Error("Session naming model returned an empty title");
+            }
+            catch (error) {
+                if (!current())
+                    return;
+                dependencies.warn(error);
+                name = fallbackSessionName(event.prompt);
+            }
+            if (current() && name !== undefined)
+                pi.setSessionName(name);
+        };
+        void nameSession().catch(dependencies.warn).finally(() => {
+            if (generation === token)
+                active = undefined;
+        });
+    });
+}
+function hasName(pi, ctx) {
+    return (pi.getSessionName() ?? "") !== "" || (ctx.sessionManager.getSessionName() ?? "") !== "";
+}

package/dist/pi-packages/session-naming/generator.js

@@ -0,0 +1,76 @@
+// Generated from pi-packages/session-naming/generator.ts. Do not edit directly.
+/** Runs through the session registry so provider resolution and authentication stay Pi-owned. */
+export async function generateShortSessionName(registry, model, firstMessage, config, signal) {
+    const controller = new AbortController();
+    const cancel = () => { controller.abort(signal.reason); };
+    signal.addEventListener("abort", cancel, { once: true });
+    if (signal.aborted)
+        cancel();
+    const timer = setTimeout(() => { controller.abort(new Error("Session naming timed out")); }, config.timeoutMs);
+    let rejectAbort;
+    const aborted = new Promise((_resolve, reject) => {
+        rejectAbort = () => {
+            const reason = controller.signal.reason;
+            reject(reason instanceof Error ? reason : new Error("Session naming cancelled"));
+        };
+        controller.signal.addEventListener("abort", rejectAbort, { once: true });
+        if (controller.signal.aborted)
+            rejectAbort();
+    });
+    try {
+        // Race the stream as well as sending its signal: a provider that ignores abort
+        // must not leave naming pending forever or write a late title after timeout.
+        return await Promise.race([aborted, (async () => {
+                controller.signal.throwIfAborted();
+                const stream = registry.streamSimple(model, {
+                    systemPrompt: "Generate a concise title for a coding-agent chat session. Return only the title, with no quotes or punctuation wrapper.",
+                    messages: [{
+                            role: "user",
+                            content: `Create a 2-6 word title for this request:\n\n${firstMessage.length <= 4_000 ? firstMessage : `${firstMessage.slice(0, 4_000)}…`}`,
+                            timestamp: Date.now(),
+                        }],
+                }, {
+                    maxTokens: config.maxTokens,
+                    ...(config.thinkingLevel === "off" ? {} : { reasoning: config.thinkingLevel }),
+                    signal: controller.signal,
+                });
+                let streamedText = "";
+                let finalMessage;
+                for await (const event of stream) {
+                    if (event.type === "text_delta")
+                        streamedText += event.delta;
+                    if (event.type === "done")
+                        finalMessage = event.message;
+                    if (event.type === "error")
+                        throw new Error(event.error.errorMessage ?? "Session naming provider failed");
+                }
+                return cleanSessionName(finalMessage === undefined ? streamedText : finalMessage.content
+                    .filter((part) => part.type === "text").map((part) => part.text).join(""));
+            })()]);
+    }
+    finally {
+        clearTimeout(timer);
+        signal.removeEventListener("abort", cancel);
+        if (rejectAbort)
+            controller.signal.removeEventListener("abort", rejectAbort);
+    }
+}
+export function fallbackSessionName(firstMessage) {
+    if (typeof firstMessage !== "string")
+        return undefined;
+    return cleanSessionName(firstMessage
+        .replace(/<skill name="[^"]+" location="[^"]+">[\s\S]*?<\/skill>/g, "")
+        .replace(/```[\s\S]*?```/g, " ")
+        .replace(/[`*_#[\](){}<>]/g, " ")
+        .split(/\s+/).filter(Boolean).slice(0, 6).join(" "));
+}
+export function cleanSessionName(value) {
+    const title = (value.split("\n", 1)[0] ?? "")
+        .replace(/^\s*(title|session title)\s*:\s*/i, "")
+        .replace(/^\s*["'`]+|["'`.]+\s*$/g, "")
+        // Provider output and fallback names must remain safe session metadata.
+        // eslint-disable-next-line no-control-regex -- remove unsafe metadata characters.
+        .replace(/[\u0000-\u001f\u007f]/gu, " ")
+        .replace(/\s+/g, " ").trim().slice(0, 60).trim();
+    return title === "" ? undefined : title;
+}

package/dist/pi-packages/session-naming/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@jmfederico/pi-session-naming",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "license": "MIT",
+  "description": "Name new Pi conversations from their first prompt without changing the conversation model.",
+  "keywords": ["pi-package"],
+  "pi": { "extensions": ["./extensions"] },
+  "peerDependencies": {
+    "@earendil-works/pi-ai": "*",
+    "@earendil-works/pi-agent-core": "*",
+    "@earendil-works/pi-coding-agent": "*"
+  }
+}

package/dist/pi-packages/workflows/browser/pi-web-plugin.js

@@ -1,13 +1,16 @@
 // Generated from pi-packages/workflows/browser/pi-web-plugin.ts. Do not edit directly.
 import { openWorktreeDialog } from "./worktreeDialog.js";
+import definitions from "./workflows.messages.js";
 function canCreateWorktree({ state, backend }) {
     return state.selectedProject !== undefined && backend !== undefined;
 }
 const plugin = {
     apiVersion: 5,
     name: "Workflows",
-    activate: ({ lifetimeSignal, selection, translate }) => {
-        const t = translate ?? ((_key, fallback) => fallback);
+    activate: ({ lifetimeSignal, selection, localization }) => {
+        if (!localization)
+            throw new Error("The Workflows plugin requires a localization-capable PI WEB host");
+        const messages = localization.registerMessages("worktree", definitions);
         let closeDialog;
         let unsubscribe;
         const close = () => { closeDialog?.(); closeDialog = undefined; unsubscribe?.(); unsubscribe = undefined; };
@@ -16,18 +19,18 @@ const plugin = {
             contributions: {
                 actions: [{
                         id: "worktree.create",
-                        title: t("bundled.workflows.create.worktree", "Create Worktree"),
-                        description: t("bundled.workflows.create.description", "Choose a base branch and purpose, then start a new conversation in the main workspace"),
-                        group: t("bundled.workflows.group", "Workflows"),
+                        get title() { return messages.t("action"); },
+                        get description() { return messages.t("actionDescription"); },
+                        get group() { return messages.t("group"); },
                         enabled: canCreateWorktree,
-                        disabledReason: () => t("bundled.workflows.select.project", "Select a project with the Workflows backend available first."),
+                        disabledReason: () => messages.t("disabled"),
                         run: (context) => {
                             const project = context.state.selectedProject;
                             if (!project || !context.backend || lifetimeSignal.aborted)
                                 return;
                             close();
                             const peer = context.backend.forScope({ kind: "project", projectId: project.id });
-                            closeDialog = openWorktreeDialog(context, peer, () => { closeDialog = undefined; unsubscribe?.(); unsubscribe = undefined; }, translate);
+                            closeDialog = openWorktreeDialog(context, peer, localization, messages, () => { closeDialog = undefined; unsubscribe?.(); unsubscribe = undefined; });
                             unsubscribe = selection?.subscribe((snapshot) => {
                                 if (snapshot.selectedProject?.id !== project.id || snapshot.selectedMachine?.id !== context.catalog.machineId)
                                     close();

package/dist/pi-packages/workflows/browser/workflows.messages.js

@@ -0,0 +1,32 @@
+// Generated from pi-packages/workflows/browser/workflows.messages.ts. Do not edit directly.
+function text(message, description) {
+    return { message, description };
+}
+export default {
+    action: text("Create Worktree", "Action palette command to open the worktree creation dialog"),
+    actionDescription: text("Choose a base branch and purpose, then start a new conversation in the main workspace", "Description of the worktree creation action"),
+    group: text("Workflows", "Action palette group for the Workflows plugin"),
+    disabled: text("Select a project with the Workflows backend available first.", "Why worktree creation is unavailable"),
+    title: text("Create worktree", "Dialog heading and submit action"),
+    target: text("Project: {project}. Starts a new conversation in its main workspace; your current conversation and draft stay unchanged.", "Explain where worktree creation starts; project name is unmodified user data"),
+    loading: text("Loading branches…", "Status while reading available base branches"),
+    base: text("Base branch", "Worktree base branch field label"),
+    baseHelp: text("Choose a local or remote branch. HEAD uses the main workspace’s current commit.", "Base branch help; HEAD is a literal Git identifier"),
+    description: text("Purpose or description", "Worktree purpose field label"),
+    descriptionHelp: text("The agent uses this to name the branch and worktree.", "Worktree purpose field help"),
+    cancel: text("Cancel", "Dismiss the dialog before dispatch"),
+    close: text("Close", "Dismiss the dialog after a failed or uncertain dispatch"),
+    required: text("Enter a base branch and a purpose or description.", "Inline validation for empty or whitespace-only fields"),
+    starting: text("Starting a new conversation…", "Dispatch in progress"),
+    opening: text("Conversation started. Opening it…", "Navigation to newly created conversation in progress"),
+    started: text("Conversation started.", "Dispatch succeeded but navigation failed"),
+    uncertain: text("Dispatch could not be confirmed.", "Dispatch outcome unknown; no automatic retry"),
+    openSession: text("{error} Open conversation {session} in Sessions.", "Navigation failure recovery; error and session ID remain unchanged"),
+    checkSessions: text("{error} Check Sessions before trying again; a conversation may already have started.", "Uncertain dispatch recovery; backend error remains unchanged"),
+    workspace: text("Main workspace: {path}", "Prepared workspace location; path remains unchanged"),
+    loadFailed: text("Could not load worktree options.", "Status after preparing the dialog fails"),
+    invalidBranches: text("Invalid branch list from Workflows.", "Malformed backend branch list detected by the browser"),
+    invalidResponse: text("Invalid response from Workflows.", "Malformed backend response detected by the browser"),
+    noProject: text("Select a project first.", "Dialog cannot open without a selected project"),
+    noRequests: text("Workflows backend does not support requests.", "Dialog cannot open without backend request support"),
+};

package/dist/pi-packages/workflows/browser/worktreeDialog.js

@@ -1,41 +1,43 @@
 // Generated from pi-packages/workflows/browser/worktreeDialog.ts. Do not edit directly.
 /** Plugin-owned UI; all machine operations go through the captured public backend. */
-export function openWorktreeDialog(context, peer, onClose, translate = (_key, fallback, parameters = {}) => fallback.replace(/\{([a-zA-Z]+)\}/gu, (placeholder, key) => String(parameters[key] ?? placeholder))) {
-    const machineId = context.catalog.machineId;
+export function openWorktreeDialog(context, peer, localization, messages, onClose) {
+    const t = messages.t.bind(messages);
     const project = context.state.selectedProject;
     if (!project)
-        throw new Error(translate("bundled.workflows.project.required", "Select a project first."));
+        throw new Error(t("noProject"));
     if (!peer.request)
-        throw new Error(translate("bundled.workflows.backend.required", "Workflows backend does not support requests."));
+        throw new Error(t("noRequests"));
     const request = peer.request.bind(peer);
+    const projectName = project.name;
     const previousFocus = document.activeElement;
     const host = document.createElement("div");
     const root = host.attachShadow({ mode: "open" });
     root.innerHTML = `
     <style>
-      dialog { color:var(--pi-text, #eee); background:var(--pi-bg, #202124); border:1px solid var(--pi-border, #666); border-radius:8px; padding:24px; width:min(480px, calc(100vw - 64px)); font:14px system-ui; }
+      dialog { box-sizing:border-box; max-width:calc(100vw - 24px); overflow-wrap:anywhere; color:var(--pi-text, #eee); background:var(--pi-bg, #202124); border:1px solid var(--pi-border, #666); border-radius:12px; padding:24px; width:min(480px, calc(100vw - 64px)); font:14px system-ui; }
       dialog::backdrop { background:rgb(0 0 0 / .55); }
       h2 { margin-top:0; font-size:20px; } p { line-height:1.5; overflow-wrap:anywhere; }
       label { display:block; margin:16px 0 6px; font-weight:600; }
       input, textarea { box-sizing:border-box; width:100%; padding:10px; font:inherit; color:inherit; background:var(--pi-bg, #202124); border:1px solid var(--pi-border, #888); border-radius:6px; }
       textarea { resize:vertical; min-height:100px; } button { font:inherit; padding:8px 14px; cursor:pointer; border-radius:6px; }
-      button:disabled { cursor:default; opacity:.6; } footer { display:flex; justify-content:flex-end; gap:10px; margin-top:20px; }
+      button:disabled { cursor:default; opacity:.6; } footer { display:flex; flex-wrap:wrap; justify-content:flex-end; gap:10px; margin-top:20px; }
+      input { direction:ltr; text-align:start; } textarea { unicode-bidi:plaintext; }
       [role=alert] { color:var(--pi-error, #ffaaaa); } small { display:block; margin-top:6px; line-height:1.5; }
     </style>
     <dialog aria-labelledby="title" aria-describedby="target">
-      <h2 id="title">Create worktree</h2>
+      <h2 id="title"></h2>
       <p id="target"></p>
-      <p id="status" role="status">Loading branches…</p>
+      <p id="status" role="status"></p>
       <form>
-        <label for="base">Base branch</label>
+        <label for="base"></label>
         <input id="base" name="base" list="branches" required maxlength="512" disabled>
         <datalist id="branches"></datalist>
-        <small id="base-help">Choose a local or remote branch. HEAD uses the main workspace’s current commit.</small>
-        <label for="description">Purpose or description</label>
-        <textarea id="description" name="description" required maxlength="8000" disabled aria-describedby="description-help"></textarea>
-        <small id="description-help">The agent uses this to name the branch and worktree.</small>
+        <small id="base-help"></small>
+        <label for="description"></label>
+        <textarea id="description" dir="auto" name="description" required maxlength="8000" disabled aria-describedby="description-help"></textarea>
+        <small id="description-help"></small>
         <p id="error" role="alert" hidden></p>
-        <footer><button type="button" id="cancel">Cancel</button><button type="submit" disabled>Create worktree</button></footer>
+        <footer><button type="button" id="cancel"></button><button type="submit" disabled></button></footer>
       </form>
     </dialog>`;
     function element(selector, constructor) {
@@ -52,29 +54,44 @@ export function openWorktreeDialog(context, peer, onClose, translate = (_key, fa
     const cancel = element("#cancel", HTMLButtonElement);
     const status = element("#status", HTMLParagraphElement);
     const error = element("#error", HTMLParagraphElement);
-    element("#title", HTMLHeadingElement).textContent = translate("bundled.workflows.dialog.title", "Create worktree");
-    element('label[for="base"]', HTMLLabelElement).textContent = translate("bundled.workflows.base", "Base branch");
-    element('label[for="description"]', HTMLLabelElement).textContent = translate("bundled.workflows.purpose", "Purpose or description");
-    element("#base-help", HTMLElement).textContent = translate("bundled.workflows.base.help", "Choose a local or remote branch. HEAD uses the main workspace's current commit.");
-    element("#description-help", HTMLElement).textContent = translate("bundled.workflows.purpose.help", "The agent uses this to name the branch and worktree.");
-    status.textContent = translate("bundled.workflows.loading", "Loading branches...");
-    cancel.textContent = translate("bundled.workflows.cancel", "Cancel");
-    submit.textContent = translate("bundled.workflows.dialog.title", "Create worktree");
     const controller = new AbortController();
     let dispatching = false;
     let dispatched;
-    element("#target", HTMLParagraphElement).textContent = translate("bundled.workflows.target", "Project: {project}. Starts a new conversation in its main workspace; your current conversation and draft stay unchanged.", { project: project.name });
+    let statusText = () => t("loading");
+    let errorText = () => "";
+    let closeLabel = false;
+    function updateText() {
+        host.lang = localization.language;
+        host.dir = localization.direction;
+        const labels = [
+            ["#title", t("title")], ["label[for=base]", t("base")], ["#base-help", t("baseHelp")],
+            ["label[for=description]", t("description")], ["#description-help", t("descriptionHelp")],
+            ["#target", t("target", { project: projectName })],
+        ];
+        for (const [selector, value] of labels)
+            element(selector, HTMLElement).textContent = value;
+        submit.textContent = t("title");
+        cancel.textContent = t(closeLabel ? "close" : "cancel");
+        status.textContent = statusText();
+        error.textContent = errorText();
+    }
+    updateText();
+    const unsubscribe = localization.subscribe(updateText);
     base.setAttribute("aria-describedby", "base-help");
     function close() {
         if (controller.signal.aborted)
             return;
         controller.abort();
+        unsubscribe();
         host.remove();
         if (previousFocus instanceof HTMLElement && previousFocus.isConnected)
             previousFocus.focus();
         onClose();
     }
-    function showError(message) { error.textContent = message; error.hidden = false; }
+    function showError(value) { errorText = value; updateText(); error.hidden = false; }
+    function setStatus(value) { statusText = value; updateText(); }
+    // Browser-authored protocol failures retain identity; backend errors are never matched by English text.
+    function errorMessage(cause) { return cause instanceof ResponseError ? t(cause.key) : message(cause); }
     cancel.addEventListener("click", close);
     dialog.addEventListener("cancel", (event) => { event.preventDefault(); if (!dispatching)
         close(); });
@@ -84,7 +101,7 @@ export function openWorktreeDialog(context, peer, onClose, translate = (_key, fa
         if (submit.disabled || controller.signal.aborted || dispatching)
             return;
         if (!description.value.trim() || !base.value.trim()) {
-            showError(translate("bundled.workflows.input.required", "Enter a base branch and a purpose or description."));
+            showError(() => t("required"));
             return;
         }
         dispatching = true;
@@ -93,29 +110,26 @@ export function openWorktreeDialog(context, peer, onClose, translate = (_key, fa
         base.disabled = true;
         description.disabled = true;
         error.hidden = true;
-        status.textContent = translate("bundled.workflows.starting", "Starting a new conversation...");
+        setStatus(() => t("starting"));
         void (async () => {
             try {
-                const result = object(await request("dispatch", { base: base.value.trim(), description: description.value.trim() }, { signal: controller.signal }), translate);
-                dispatched = { workspaceId: text(result["workspaceId"], translate), sessionId: text(result["sessionId"], translate) };
+                const result = object(await request("dispatch", { base: base.value.trim(), description: description.value.trim() }, { signal: controller.signal }));
+                dispatched = { workspaceId: text(result["workspaceId"]), sessionId: text(result["sessionId"]) };
                 if (controller.signal.aborted)
                     return;
-                status.textContent = translate("bundled.workflows.opening", "Conversation started. Opening it...");
-                await context.navigate({ machineId, projectId: project.id, workspaceId: dispatched.workspaceId, sessionId: dispatched.sessionId, view: "chat" });
+                setStatus(() => t("opening"));
+                await context.navigate({ machineId: context.catalog.machineId, projectId: project.id, workspaceId: dispatched.workspaceId, sessionId: dispatched.sessionId, view: "chat" });
                 close();
             }
             catch (cause) {
                 if (controller.signal.aborted)
                     return;
-                status.textContent = dispatched
-                    ? translate("bundled.workflows.started", "Conversation started.")
-                    : translate("bundled.workflows.uncertain", "Dispatch could not be confirmed.");
-                const recovery = dispatched
-                    ? translate("bundled.workflows.recover.session", "Open conversation {sessionId} in Sessions.", { sessionId: dispatched.sessionId })
-                    : translate("bundled.workflows.recover.uncertain", "Check Sessions before trying again; a conversation may already have started.");
-                showError(`${message(cause)} ${recovery}`);
+                closeLabel = true;
+                setStatus(() => t(dispatched ? "started" : "uncertain"));
+                showError(() => dispatched
+                    ? t("openSession", { error: errorMessage(cause), session: dispatched.sessionId })
+                    : t("checkSessions", { error: errorMessage(cause) }));
                 // Do not retry an uncertain submission automatically or from this dialog.
-                cancel.textContent = translate("bundled.workflows.close", "Close");
             }
             finally {
                 dispatching = false;
@@ -127,13 +141,13 @@ export function openWorktreeDialog(context, peer, onClose, translate = (_key, fa
     dialog.showModal();
     void (async () => {
         try {
-            const result = object(await request("prepare", null, { signal: controller.signal }), translate);
+            const result = object(await request("prepare", null, { signal: controller.signal }));
             const branches = result["branches"];
             if (!Array.isArray(branches) || !branches.every((branch) => typeof branch === "string"))
-                throw new Error(translate("bundled.workflows.branches.invalid", "Invalid branch list from Workflows."));
-            const defaultBase = text(result["defaultBase"], translate);
-            const workspacePath = text(result["workspacePath"], translate);
-            text(result["workspaceId"], translate);
+                throw new ResponseError("invalidBranches");
+            const defaultBase = text(result["defaultBase"]);
+            const workspacePath = text(result["workspacePath"]);
+            text(result["workspaceId"]);
             if (controller.signal.aborted)
                 return;
             const options = branches.map((branch) => { const option = document.createElement("option"); option.value = branch; return option; });
@@ -142,29 +156,36 @@ export function openWorktreeDialog(context, peer, onClose, translate = (_key, fa
             base.disabled = false;
             description.disabled = false;
             submit.disabled = false;
-            status.textContent = translate("bundled.workflows.main.workspace", "Main workspace: {path}", { path: workspacePath });
+            setStatus(() => t("workspace", { path: workspacePath }));
             description.focus();
         }
         catch (cause) {
             if (controller.signal.aborted)
                 return;
-            status.textContent = translate("bundled.workflows.prepare.failed", "Could not load worktree options.");
-            showError(message(cause));
+            setStatus(() => t("loadFailed"));
+            showError(() => errorMessage(cause));
         }
     })();
     return close;
 }
+class ResponseError extends Error {
+    key;
+    constructor(key) {
+        super(key);
+        this.key = key;
+    }
+}
 function isObject(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function object(value, translate) {
+function object(value) {
     if (!isObject(value))
-        throw new Error(translate("bundled.workflows.response.invalid", "Invalid response from Workflows."));
+        throw new ResponseError("invalidResponse");
     return value;
 }
-function text(value, translate) {
+function text(value) {
     if (typeof value !== "string" || value === "")
-        throw new Error(translate("bundled.workflows.response.invalid", "Invalid response from Workflows."));
+        throw new ResponseError("invalidResponse");
     return value;
 }
 function message(cause) { return cause instanceof Error ? cause.message : String(cause); }