@netnodeag/kraftwerk 0.43.0 → 0.45.0

package/dist/inspector/chat/types.d.ts

@@ -42,30 +42,213 @@ export interface ChatMeta {
     scope: ChatScope;
     /** Slug of the vibeable open in this chat's preview pane (cwd is its folder while set). */
     vibeable?: string;
+    /**
+     * The agent's own session id per seat ("main", or the agent slug in a
+     * channel): after a restart or the idle reaper, the next backend resumes
+     * it (session/resume) so the agent keeps its context instead of starting
+     * over with the transcript as a summary.
+     */
+    sessions?: Record<string, string>;
     createdAt: string;
     updatedAt: string;
 }
-/** One thread event; `seq` orders them and drives SSE resume (?after=seq). */
-export type ChatEvent = {
+/** A context compaction the agent ran, as reported on its synthetic tool call (`_meta.contextCompaction`). */
+export interface Compaction {
+    trigger?: "manual" | "automatic";
+    preTokens?: number;
+    postTokens?: number;
+    durationMs?: number;
+    error?: string;
+}
+/**
+ * A failure the agent's session ran into, as the harness reports it
+ * (AIR `sessionFailure`): what broke, how bad, and what a human can do.
+ * The same `id` with a higher `revision` replaces an earlier report.
+ */
+export interface SessionFailure {
+    id: string;
+    revision: number;
+    category: "connection" | "access" | "limit" | "request" | "service" | "unknown";
+    severity: "warning" | "error";
+    title: string;
+    details?: string;
+    /** Machine-readable refinement of the failure (e.g. why a login was refused). */
+    reason?: string;
+    actions: Array<"retry" | "login" | "new_session">;
+}
+/** One step of the agent's plan (Claude's todo list), as ACP reports it. */
+export interface PlanEntry {
+    content: string;
+    priority: "high" | "medium" | "low";
+    status: "pending" | "in_progress" | "completed";
+}
+/** A slash command the agent offers (`available_commands_update`). */
+export interface AgentCommand {
+    name: string;
+    description: string;
+    /** What the command takes after its name, if anything. */
+    hint?: string;
+}
+/** One session setting the agent lets the client change (`configOptions`). */
+export type ConfigOption = {
+    id: string;
+    name: string;
+    description?: string;
+    /** model | thought_level | model_config | mode | ... (agent-defined) */
+    category?: string;
+} & ({
+    type: "select";
+    value: string;
+    choices: Array<{
+        value: string;
+        name: string;
+        description?: string;
+        group?: string;
+    }>;
+} | {
+    type: "boolean";
+    value: boolean;
+});
+/** Who the agent is signed in as (`_auth/status_update`). */
+export interface AuthStatus {
+    kind: "account" | "api_key" | "gateway" | "external" | "none";
+    label: string;
+    detail?: string;
+    email?: string;
+    organization?: string;
+    plan?: string;
+}
+/** One field of a question the agent asks (an ACP form elicitation, e.g. Claude's AskUserQuestion). */
+export interface ElicitationField {
+    key: string;
+    title?: string;
+    description?: string;
+    kind: "select" | "multiselect" | "text" | "number" | "boolean";
+    options?: Array<{
+        value: string;
+        label: string;
+        description?: string;
+    }>;
+    required?: boolean;
+    /** A free-text alternative to the select above it ("Other"). */
+    custom?: boolean;
+}
+/** A file that travels with a message (dropped or pasted into the composer); stored under the chat's folder. */
+export interface Attachment {
+    /** File name inside the chat's attachments/ folder (unique, safe). */
+    name: string;
+    mimeType: string;
+    size: number;
+}
+export type ElicitationAnswer = {
+    action: "accept";
+    content: Record<string, string | number | boolean | string[]>;
+} | {
+    action: "decline";
+} | {
+    action: "cancel";
+};
+/**
+ * One thread event; `seq` orders them and drives SSE resume (?after=seq).
+ * `subagent` on text/thought/tool events names the child session that
+ * produced them (see the `subagent` event); absent = the main agent.
+ */
+export type ChatEvent = 
+/** `steered`: handed into the running turn instead of starting the next one. */
+{
     type: "user_message";
     text: string;
+    steered?: boolean;
+    attachments?: Attachment[];
 } | {
     type: "text";
     text: string;
+    subagent?: string;
 } | {
     type: "thought";
     text: string;
+    subagent?: string;
 } | {
     type: "tool_call";
     callId: string;
     title: string;
     kind?: string;
     status?: string;
+    subagent?: string;
+    compaction?: Compaction;
 } | {
     type: "tool_update";
     callId: string;
     title?: string;
     status?: string;
+    subagent?: string;
+    compaction?: Compaction;
+}
+/** The agent delegated to a subagent running as its own session; its events follow tagged with `subagent: sessionId`. */
+ | {
+    type: "subagent";
+    sessionId: string;
+    name: string;
+    task: string;
+} | {
+    type: "subagent_state";
+    sessionId: string;
+    state: "completed" | "failed" | "cancelled" | "disconnected";
+}
+/** Background work the agent started (a backgrounded shell, a monitor, a workflow) — outlives the tool call that started it. */
+ | {
+    type: "task";
+    taskId: string;
+    name: string;
+    taskType: string;
+    description: string;
+    toolCallId?: string;
+    canStop?: boolean;
+} | ({
+    type: "failure";
+} & SessionFailure)
+/** The agent's current plan; null when it dropped it. Replaces the previous one. */
+ | {
+    type: "plan";
+    entries: PlanEntry[] | null;
+}
+/** Context window use (tokens used of size) and the session's cost so far. */
+ | {
+    type: "usage";
+    used: number;
+    size: number;
+    costUsd?: number;
+} | {
+    type: "commands";
+    commands: AgentCommand[];
+} | {
+    type: "config";
+    options: ConfigOption[];
+} | ({
+    type: "auth";
+} & AuthStatus)
+/** What the agent says it changed this turn (AIR file change report); `unavailable` names why there is no list. */
+ | {
+    type: "files_changed";
+    paths: string[];
+    complete: boolean;
+    uncertainty?: string;
+    unavailable?: string;
+} | {
+    type: "elicitation_request";
+    requestId: string;
+    message: string;
+    fields: ElicitationField[];
+} | ({
+    type: "elicitation_resolved";
+    requestId: string;
+} & ElicitationAnswer) | {
+    type: "task_update";
+    taskId: string;
+    state?: "running" | "paused" | "completed" | "failed" | "stopped";
+    description?: string;
+    summary?: string;
+    outputFilePath?: string;
 } | {
     type: "permission_request";
     requestId: string;

package/dist/inspector/runner.js

@@ -1,5 +1,5 @@
 import { spawn, spawnSync } from "node:child_process";
-import { mkdirSync, openSync, closeSync } from "node:fs";
+import { mkdirSync, openSync, closeSync, writeFileSync } from "node:fs";
 import path from "node:path";
 import { getProjectRoot } from "./context.js";
 import { RUN_ID_RE, getRun, safeRunDir } from "./runs.js";
@@ -28,6 +28,8 @@ export function dockerStatus() {
     });
     return { available: true, image: image.status === 0 };
 }
+/** Launchers this inspector started and that have not exited yet, by run id. */
+const live = new Map();
 export function triggerRun(opts) {
     if (opts.sandbox) {
         const docker = dockerStatus();
@@ -55,10 +57,21 @@ export function triggerRun(opts) {
     });
     child.unref();
     closeSync(log);
+    live.set(runId, child);
     // Detached, but as long as the inspector lives it still hears the exit:
     // that is when the run's outcome goes to the bell (read from the trace,
-    // the exit code alone does not say whether a gate blocked).
-    child.on("exit", () => {
+    // the exit code alone does not say whether a gate blocked). The exit
+    // code also lands in trigger.json, so a launcher that died before the
+    // framework wrote a trace (missing env var, npx failure) shows as failed
+    // instead of running until the stale timeout.
+    child.on("exit", (code, signal) => {
+        live.delete(runId);
+        try {
+            writeFileSync(path.join(runDir, "trigger.json"), JSON.stringify({ exitCode: code ?? 1, signal, finishedAt: new Date().toISOString() }, null, 2) + "\n");
+        }
+        catch {
+            /* run dir removed meanwhile */
+        }
         void getRun(runId)
             .then((run) => {
             const ok = run?.status === "ok";
@@ -76,8 +89,20 @@ export function triggerRun(opts) {
     return { runId };
 }
 export function stopRun(runId) {
-    // Sandboxed runs run in container kw-<runId>; docker stop ends them.
     if (!RUN_ID_RE.test(runId))
         return false;
+    // A local run this inspector launched: the launcher is detached into its
+    // own process group, so the negative pid ends npx and the framework under it.
+    const child = live.get(runId);
+    if (child?.pid && child.exitCode == null) {
+        try {
+            process.kill(-child.pid, "SIGTERM");
+            return true;
+        }
+        catch {
+            /* group already gone — fall through to docker */
+        }
+    }
+    // Sandboxed runs run in container kw-<runId>; docker stop ends them.
     return (spawnSync("docker", ["stop", `kw-${runId}`], { stdio: "ignore", timeout: 30_000 }).status === 0);
 }

package/dist/inspector/runs.d.ts

@@ -58,3 +58,8 @@ export declare function readRunFile(id: string, name: string): Promise<{
     absPath: string;
     size: number;
 } | null>;
+/**
+ * Remove a run folder. A run that still looks live is refused: its process
+ * would keep writing into a folder that no longer exists — stop it first.
+ */
+export declare function deleteRun(id: string): Promise<"deleted" | "running" | "missing">;

package/dist/inspector/runs.js

@@ -29,7 +29,7 @@ async function readTrace(runDir) {
     }
     return events;
 }
-function analyse(events) {
+function analyse(events, fallbackTs) {
     const runStart = events.find((e) => e.event === "run_start");
     const summary = events.find((e) => e.event === "run_summary");
     const phases = [];
@@ -118,42 +118,69 @@ function analyse(events) {
     }
     const failed = phases.some((p) => p.status === "failed" || p.status === "blocked");
     const lastTs = events.length ? events[events.length - 1].ts : undefined;
+    // A run folder without a trace (the launcher died before the framework
+    // wrote anything — missing env var, npx failure) has no event to age; the
+    // newest file in the folder stands in, so it cannot stay "running" forever.
+    const activityTs = lastTs ?? fallbackTs;
     let status;
     if (summary)
         status = failed ? "failed" : "ok";
     else if (failed)
         status = "failed";
-    else if (lastTs && Date.now() - Date.parse(lastTs) > STALE_MS)
-        status = "aborted";
+    else if (activityTs && Date.now() - Date.parse(activityTs) > STALE_MS)
+        status = events.length ? "aborted" : "failed";
     else
         status = "running";
     return { runStart, summary, phases, steps, status, lastTs };
 }
 /**
  * Sandboxed runs write runner.json (exit code recorded when the container
- * ends). If the trace looks "running" but the container already exited —
- * e.g. it crashed before any phase_end — trust the exit code instead of
- * waiting for the 15-minute stale timeout.
+ * ends) and UI-triggered runs write trigger.json (exit code of the launcher,
+ * see runner.ts). If the trace looks "running" but the process already
+ * exited — e.g. it crashed before any phase_end, or never wrote a trace —
+ * trust the exit code instead of waiting for the 15-minute stale timeout.
  */
 async function applyRunnerVerdict(runDir, a) {
     if (a.status !== "running")
         return a;
-    try {
-        const meta = JSON.parse(await fs.readFile(path.join(runDir, "runner.json"), "utf8"));
-        if (meta.exitCode != null) {
+    for (const name of ["runner.json", "trigger.json"]) {
+        try {
+            const meta = JSON.parse(await fs.readFile(path.join(runDir, name), "utf8"));
+            if (meta.exitCode == null)
+                continue;
             a.status = meta.exitCode === 0 ? "ok" : "failed";
             if (meta.exitCode !== 0) {
                 for (const p of a.phases)
                     if (p.status === "running")
                         p.status = "failed";
             }
+            return a;
+        }
+        catch {
+            /* file absent (local CLI run) or unreadable — try the next one */
         }
-    }
-    catch {
-        /* no runner.json (local run) or unreadable — keep trace-based status */
     }
     return a;
 }
+/** Newest mtime among the run folder's files — the age of a run that never wrote a trace. */
+async function newestFileTs(runDir) {
+    const names = await fs.readdir(runDir).catch(() => []);
+    let newest = 0;
+    for (const name of names) {
+        const st = await fs.stat(path.join(runDir, name)).catch(() => null);
+        if (st && st.mtimeMs > newest)
+            newest = st.mtimeMs;
+    }
+    return newest ? new Date(newest).toISOString() : undefined;
+}
+/**
+ * The workflow slug baked into the run id ("2026-08-25-1432-07-<slug>", see
+ * newRunId) — the only name a run has when the trace was never written.
+ */
+function workflowFromId(id) {
+    const m = /^\d{4}-\d{2}-\d{2}-\d{4}-\d{2}-(.+)$/.exec(id);
+    return m?.[1];
+}
 function shortenPath(p) {
     const parts = p.split("/");
     return parts.length > 2 ? parts.slice(-2).join("/") : p;
@@ -171,12 +198,12 @@ export async function listRuns() {
         if (!st?.isDirectory())
             return null;
         const events = await readTrace(runDir);
-        const { runStart, summary, phases, steps, status, lastTs } = await applyRunnerVerdict(runDir, analyse(events));
+        const { runStart, summary, phases, steps, status, lastTs } = await applyRunnerVerdict(runDir, analyse(events, events.length ? undefined : await newestFileTs(runDir)));
         const done = phases.filter((p) => p.status === "ok").length;
         const current = phases.find((p) => p.status === "running")?.phase;
         return {
             id,
-            workflow: runStart?.workflow,
+            workflow: runStart?.workflow ?? workflowFromId(id),
             request: runStart?.request,
             status,
             startedAt: events[0]?.ts,
@@ -207,7 +234,7 @@ export async function getRun(id) {
     if (!st?.isDirectory())
         return null;
     const events = await readTrace(runDir);
-    const { runStart, summary, phases, steps, status, lastTs } = await applyRunnerVerdict(runDir, analyse(events));
+    const { runStart, summary, phases, steps, status, lastTs } = await applyRunnerVerdict(runDir, analyse(events, events.length ? undefined : await newestFileTs(runDir)));
     const names = await fs.readdir(runDir);
     const files = [];
     for (const name of names) {
@@ -218,7 +245,7 @@ export async function getRun(id) {
     files.sort((a, b) => a.name.localeCompare(b.name));
     return {
         id,
-        workflow: runStart?.workflow,
+        workflow: runStart?.workflow ?? workflowFromId(id),
         description: runStart?.description,
         request: runStart?.request,
         status,
@@ -244,3 +271,16 @@ export async function readRunFile(id, name) {
         return null;
     return { absPath, size: st.size };
 }
+/**
+ * Remove a run folder. A run that still looks live is refused: its process
+ * would keep writing into a folder that no longer exists — stop it first.
+ */
+export async function deleteRun(id) {
+    const run = await getRun(id);
+    if (!run)
+        return "missing";
+    if (run.status === "running")
+        return "running";
+    await fs.rm(safeRunDir(id), { recursive: true, force: true });
+    return "deleted";
+}

package/dist/inspector/server.js

@@ -1,15 +1,16 @@
 import { existsSync, promises as fs } from "node:fs";
 import http from "node:http";
 import path from "node:path";
+import { attachmentPath, saveAttachment } from "./chat/store.js";
 import { setOutputDir, setProjectRoot, getOutputDir, getProjectRoot } from "./context.js";
 import { resolveProject } from "../config.js";
-import { listRuns, getRun, readRunFile } from "./runs.js";
+import { listRuns, getRun, readRunFile, deleteRun } from "./runs.js";
 import { listWorkflows, getWorkflow } from "./workflows.js";
 import { dockerStatus, triggerRun, stopRun } from "./runner.js";
 import { clearNotifications, listNotifications, markNotificationsRead } from "./notifications.js";
 import { startDiagnosis } from "./diagnose.js";
 import { deleteChannel, getChannel, listChannels, saveChannel, channelsRoot } from "./channels.js";
-import { cancelChat, createChat, deleteChat, disposeAllBackends, getChat, listChats, postMessage, resolvePermission, setChatVibeable, subscribeChat, convertChatToChannel, dropChannelSeats, ensureChannelChat } from "./chat/sessions.js";
+import { cancelChat, createChat, forkChat, resetSession, answerElicitation, steerChat, stopChatTask, setChatConfig, listAgentSessionsFor, deleteChat, disposeAllBackends, getChat, listChats, postMessage, resolvePermission, setChatVibeable, subscribeChat, convertChatToChannel, dropChannelSeats, ensureChannelChat } from "./chat/sessions.js";
 import { bundleDetail, conceptDetail, createBundle, knowledgeIndex, putConcept, verifyFromUi, } from "./knowledge.js";
 import { deleteAgent, getAgent, listAgents, saveAgent, setAgentArchived, agentsRoot, } from "./agents.js";
 import { deleteAgentSkill, getSkill, listAgentSkills, listSkills, readSkill, saveAgentSkill, skillsRoot, } from "./skills.js";
@@ -54,6 +55,24 @@ function json(res, body, status = 200) {
     res.writeHead(status, { "content-type": "application/json; charset=utf-8", "cache-control": "no-store" });
     res.end(JSON.stringify(body));
 }
+/** A raw upload body (attachments), capped at `max` bytes. */
+function readRawBody(req, max) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        let size = 0;
+        req.on("data", (c) => {
+            size += c.length;
+            if (size > max) {
+                reject(new Error(`file too large (max ${Math.round(max / 1_000_000)} MB)`));
+                req.destroy();
+                return;
+            }
+            chunks.push(c);
+        });
+        req.on("end", () => resolve(Buffer.concat(chunks)));
+        req.on("error", reject);
+    });
+}
 function readBody(req) {
     return new Promise((resolve, reject) => {
         let data = "";
@@ -618,7 +637,22 @@ async function handleApi(req, res, url) {
     if (seg.length === 4 && seg[1] === "runs" && seg[3] === "stop" && method === "POST") {
         return stopRun(seg[2])
             ? json(res, { stopped: true })
-            : json(res, { error: "no running sandbox container for this run (local runs cannot be stopped here)" }, 404);
+            : json(res, { error: "nothing to stop: no launcher of this inspector and no sandbox container for this run" }, 404);
+    }
+    // DELETE /api/runs/:id — refused while the run is live (stop it first)
+    if (seg.length === 3 && seg[1] === "runs" && method === "DELETE") {
+        let outcome;
+        try {
+            outcome = await deleteRun(seg[2]);
+        }
+        catch {
+            return json(res, { error: "invalid run id" }, 400);
+        }
+        if (outcome === "missing")
+            return json(res, { error: "not found" }, 404);
+        if (outcome === "running")
+            return json(res, { error: "run is still running — stop it first" }, 409);
+        return json(res, { deleted: true });
     }
     // GET /api/workflows
     if (seg.length === 2 && seg[1] === "workflows" && method === "GET") {
@@ -902,13 +936,25 @@ async function handleApi(req, res, url) {
                 return json(res, { error: "agent must be claude, codex, or pi" }, 400);
             }
             try {
-                return json(res, await createChat({ agent, scope }));
+                return json(res, await createChat({ agent, scope, ...(typeof body.resume === "string" && body.resume ? { resume: body.resume } : {}) }));
             }
             catch (err) {
                 return json(res, { error: err.message }, 400);
             }
         }
     }
+    // GET /api/agent-sessions?agent=claude|codex — the agent's own sessions in the project root
+    if (seg.length === 2 && seg[1] === "agent-sessions" && method === "GET") {
+        const agent = url.searchParams.get("agent") ?? "claude";
+        if (!["claude", "codex", "pi"].includes(agent))
+            return json(res, { error: "agent must be claude, codex, or pi" }, 400);
+        try {
+            return json(res, { sessions: await listAgentSessionsFor(agent) });
+        }
+        catch (err) {
+            return json(res, { error: err.message }, 502);
+        }
+    }
     // DELETE /api/chats/:id
     if (seg.length === 3 && seg[1] === "chats" && method === "DELETE") {
         try {
@@ -968,6 +1014,60 @@ async function handleApi(req, res, url) {
             return json(res, { error: err.message }, 400);
         }
     }
+    // POST /api/chats/:id/fork — a new chat continuing a copy of this one's session
+    if (seg.length === 4 && seg[1] === "chats" && seg[3] === "fork" && method === "POST") {
+        try {
+            const result = await forkChat(seg[2]);
+            return result.error ? json(res, { error: result.error }, result.status ?? 400) : json(res, result.meta);
+        }
+        catch (err) {
+            return json(res, { error: err.message }, 400);
+        }
+    }
+    // POST /api/chats/:id/attachments — raw file body; x-file-name names it. Returns the stored attachment.
+    if (seg.length === 4 && seg[1] === "chats" && seg[3] === "attachments" && method === "POST") {
+        try {
+            if (!(await getChat(seg[2])))
+                return json(res, { error: "not found" }, 404);
+            const data = await readRawBody(req, 25_000_000);
+            if (data.length === 0)
+                return json(res, { error: "empty file" }, 400);
+            const mimeType = (req.headers["content-type"] ?? "application/octet-stream").split(";")[0].trim();
+            const name = await saveAttachment(seg[2], decodeURIComponent(String(req.headers["x-file-name"] ?? "file")), data);
+            return json(res, { name, mimeType, size: data.length });
+        }
+        catch (err) {
+            return json(res, { error: err.message }, 400);
+        }
+    }
+    // GET /api/chats/:id/attachments/:name — the stored file
+    if (seg.length === 5 && seg[1] === "chats" && seg[3] === "attachments" && method === "GET") {
+        try {
+            const file = attachmentPath(seg[2], seg[4]);
+            const ext = path.extname(file).toLowerCase();
+            const data = await fs.readFile(file);
+            res.writeHead(200, {
+                "content-type": MIME[ext] ?? "application/octet-stream",
+                "content-length": data.length,
+                "cache-control": "private, max-age=86400",
+                "x-content-type-options": "nosniff",
+            });
+            return void res.end(data);
+        }
+        catch {
+            return json(res, { error: "not found" }, 404);
+        }
+    }
+    // POST /api/chats/:id/reset-session — forget the agent's session; the next message starts fresh
+    if (seg.length === 4 && seg[1] === "chats" && seg[3] === "reset-session" && method === "POST") {
+        try {
+            const result = await resetSession(seg[2]);
+            return result.error ? json(res, { error: result.error }, result.status ?? 400) : json(res, result.meta);
+        }
+        catch (err) {
+            return json(res, { error: err.message }, 400);
+        }
+    }
     // POST /api/chats/:id/{message,permission,cancel}
     if (seg.length === 4 && seg[1] === "chats" && method === "POST") {
         let body = {};
@@ -981,18 +1081,44 @@ async function handleApi(req, res, url) {
         }
         try {
             let result;
+            const attachments = Array.isArray(body.attachments)
+                ? body.attachments
+                    .filter((a) => a && typeof a.name === "string" && typeof a.mimeType === "string")
+                    .map((a) => ({ name: String(a.name), mimeType: String(a.mimeType), size: Number(a.size) || 0 }))
+                : [];
             if (seg[3] === "message") {
                 const text = String(body.text ?? "").trim();
-                if (!text)
+                if (!text && attachments.length === 0)
                     return json(res, { error: "text is required" }, 400);
                 // Channels: the poster's display name signs the message.
-                result = await postMessage(seg[2], text, { from: typeof body.from === "string" ? body.from : undefined });
+                result = await postMessage(seg[2], text || "(see attached)", { from: typeof body.from === "string" ? body.from : undefined, attachments });
             }
             else if (seg[3] === "permission") {
                 result = await resolvePermission(seg[2], String(body.requestId ?? ""), body.optionId == null ? null : String(body.optionId));
             }
             else if (seg[3] === "cancel") {
-                result = await cancelChat(seg[2]);
+                // Channels: `agent` stops one member; without it every agent in the chat.
+                result = await cancelChat(seg[2], typeof body.agent === "string" && body.agent ? body.agent : undefined);
+            }
+            else if (seg[3] === "steer") {
+                const text = String(body.text ?? "").trim();
+                if (!text && attachments.length === 0)
+                    return json(res, { error: "text is required" }, 400);
+                result = await steerChat(seg[2], text || "(see attached)", attachments);
+            }
+            else if (seg[3] === "elicitation") {
+                const action = body.action === "accept" || body.action === "decline" || body.action === "cancel" ? body.action : null;
+                if (!action)
+                    return json(res, { error: "action must be accept, decline, or cancel" }, 400);
+                const content = body.content && typeof body.content === "object" ? body.content : {};
+                result = await answerElicitation(seg[2], String(body.requestId ?? ""), action === "accept" ? { action, content } : { action });
+            }
+            else if (seg[3] === "task-stop") {
+                result = await stopChatTask(seg[2], String(body.taskId ?? ""));
+            }
+            else if (seg[3] === "config") {
+                const value = typeof body.value === "boolean" ? body.value : String(body.value ?? "");
+                result = await setChatConfig(seg[2], String(body.configId ?? ""), value);
             }
             else {
                 return json(res, { error: "not found" }, 404);