pi2web 0.2.6 → 0.2.8

package/dist/server.js

@@ -8,6 +8,7 @@ import { AgentManager } from './agents.js';
 import { createSdkBackend } from './sdk-backend.js';
 import { TerminalManager } from './terminals.js';
 import { MetadataStore } from './metadata-store.js';
+import { SottoSttService } from './sotto-stt.js';
 import { CollabHub } from './collab/hub.js';
 import { CollabStore } from './collab/store.js';
 import { CollabRouter } from './collab/routes.js';
@@ -54,6 +55,7 @@ export class RemotePiServer {
     sessionIndexJobs = new Map();
     agentIndexJobs = new Map();
     voice;
+    sottoStt;
     sessionNamer;
     mailNotifier;
     loginLimiter = new LoginLimiter();
@@ -64,6 +66,7 @@ export class RemotePiServer {
         this.dataDir = options.dataDir ?? defaultDataDir();
         this.auth = new AuthStore(this.dataDir);
         this.metadata = new MetadataStore(this.dataDir);
+        this.sottoStt = new SottoSttService(this.metadata);
         this.templates = new AgentTemplateStore(path.join(this.dataDir, AGENT_TEMPLATES_DIR));
         this.workspaces = options.workspaces ?? new WorkspaceStore();
         this.voice = options.voice;
@@ -115,6 +118,7 @@ export class RemotePiServer {
             console.warn('WARNING: --allow-insecure-no-auth disables loopback bind and Host/Origin restrictions. Anyone who can reach this server, including through a web page, can access workspaces and control agents and terminals without a pairing code. Use only on a trusted, access-controlled network.');
         const first = this.noAuth ? {} : await this.auth.init();
         this.metadata.init();
+        this.sottoStt.load();
         this.collab.init();
         this.unsubscribeCollab = this.collab.subscribe(event => this.collabNotification(event));
         this.collabStallTimer = setInterval(() => {
@@ -343,7 +347,10 @@ export class RemotePiServer {
                 .map(x => x.trim())
                 .find(x => x.startsWith('access-token.'))
                 ?.slice(13);
-        const pathname = new URL(req.url ?? '/', `http://${req.headers.host ?? 'localhost'}`).pathname, isSocket = pathname === '/api/v1/ws' || /^\/api\/v1\/terminals\/[^/]+\/ws$/.test(pathname);
+        const pathname = new URL(req.url ?? '/', `http://${req.headers.host ?? 'localhost'}`).pathname, voiceMatch = pathname.match(/^\/api\/v1\/agents\/([^/]+)\/transcribe\/ws$/), isTranscription = pathname === '/api/v1/transcribe/ws', isSocket = pathname === '/api/v1/ws' ||
+            /^\/api\/v1\/terminals\/[^/]+\/ws$/.test(pathname) ||
+            !!voiceMatch ||
+            isTranscription;
         if (!isSocket) {
             socket.write('HTTP/1.1 401 Unauthorized\r\n\r\n');
             socket.destroy();
@@ -374,6 +381,24 @@ export class RemotePiServer {
             return;
         }
         this.loginLimiter.clear(key);
+        if (voiceMatch || isTranscription) {
+            try {
+                if (voiceMatch)
+                    this.agents.get(decodeURIComponent(voiceMatch[1]));
+                this.sottoStt.streamUrl();
+            }
+            catch {
+                socket.write('HTTP/1.1 404 Not Found\r\n\r\n');
+                socket.destroy();
+                return;
+            }
+            this.wss.handleUpgrade(req, socket, head, ws => {
+                this.clients.add(ws);
+                ws.on('close', () => this.clients.delete(ws));
+                this.sottoStt.stream(ws);
+            });
+            return;
+        }
         this.wss.handleUpgrade(req, socket, head, ws => this.wss.emit('connection', ws, req));
     }
     clientKey(req) {
@@ -575,12 +600,36 @@ export class RemotePiServer {
                         terminalCount: this.terminals.list().length,
                         webSocketConnections: this.clients.size,
                         voiceEnabled: !!this.voice,
-                        voiceCapabilities: this.voice?.capabilities() ?? { tts: false, stt: false },
+                        voiceCapabilities: {
+                            tts: this.voice?.capabilities().tts ?? false,
+                            stt: (this.voice?.capabilities().stt ?? false) || this.sottoStt.getSettings().enabled
+                        },
+                        sottoStt: this.sottoStt.getSettings(),
                         sessionNamingEnabled: !!this.sessionNamer,
                         mailNotificationsConfigured: !!this.mailNotifier,
                         mailNotificationsEnabled: this.mailNotifier?.getSettings().enabled ?? false
                     }
                 });
+            if (u.pathname === '/api/v1/sotto-stt') {
+                if (req.method === 'GET')
+                    return json(res, 200, { data: this.sottoStt.getSettings() });
+                if (req.method === 'PUT')
+                    return json(res, 200, { data: await this.sottoStt.update(await readJsonBody(req)) });
+            }
+            if (req.method === 'POST' && u.pathname === '/api/v1/transcribe') {
+                const mime = String(req.headers['content-type'] ?? 'audio/webm').split(';')[0];
+                if (this.sottoStt.getSettings().enabled) {
+                    if (mime !== 'application/octet-stream')
+                        throw Object.assign(new Error('Sotto requires 16 kHz float32 PCM'), { code: 'INVALID_REQUEST' });
+                    return json(res, 200, { data: await this.sottoStt.transcribe(await readBinaryBody(req)) });
+                }
+                if (!this.voice)
+                    throw Object.assign(new Error('Voice service is disabled'), { code: 'VOICE_DISABLED' });
+                const filename = String(req.headers['x-audio-filename'] ?? 'recording.webm');
+                return json(res, 200, {
+                    data: await this.voice.transcribe(await readBinaryBody(req), mime, filename)
+                });
+            }
             if (await handleMailSettingsRoutes({ mailNotifier: this.mailNotifier, metadata: this.metadata }, req, res, u))
                 return;
             const workspaceContext = {
@@ -599,6 +648,7 @@ export class RemotePiServer {
                 metadata: this.metadata,
                 workspaces: this.workspaces,
                 voice: this.voice,
+                sottoStt: this.sottoStt,
                 sessionNamer: this.sessionNamer,
                 ensureSessionIndex: (workspace, cwd, force) => this.ensureSessionIndex(workspace, cwd, force),
                 indexAgentSession: (agentId) => this.indexAgentSession(agentId),

package/dist/session-performance.js

@@ -0,0 +1,137 @@
+export const PERFORMANCE_ENTRY = 'pi2web.performance.v1';
+/** Wall-clock spans, collected on the host running Pi. Parallel tool spans deliberately overlap. */
+export class SessionPerformanceTracker {
+    save;
+    now;
+    run = null;
+    model = null;
+    tools = new Map();
+    other = null;
+    constructor(save, now = Date.now) {
+        this.save = save;
+        this.now = now;
+    }
+    finish(span, at) {
+        if (span)
+            span.end = at;
+    }
+    span(kind, at, name) {
+        const span = { kind, start: at, end: at };
+        if (name)
+            span.name = name;
+        this.run.spans.push(span);
+        return span;
+    }
+    apply(event) {
+        const at = this.now(), e = event;
+        if (event.type === 'agent_start' && !this.run)
+            this.run = { start: at, spans: [] };
+        if (!this.run)
+            return;
+        switch (event.type) {
+            case 'turn_start':
+                if (this.other?.kind === 'retry') {
+                    this.finish(this.other, at);
+                    this.other = null;
+                }
+                this.finish(this.model, at);
+                this.model = this.span('model', at);
+                break;
+            case 'message_update':
+                if (this.model && this.model.firstResponse === undefined)
+                    this.model.firstResponse = at;
+                break;
+            case 'message_end':
+                if (e.message?.role === 'assistant') {
+                    this.finish(this.model, at);
+                    this.model = null;
+                }
+                break;
+            case 'tool_execution_start':
+                if (e.parentToolCallId)
+                    break; // nested tools are included in their parent's wall-clock span
+                if (this.model) {
+                    this.finish(this.model, at);
+                    this.model = null;
+                }
+                if (e.toolCallId) {
+                    const span = this.span('tool', at, String(e.toolName ?? 'tool'));
+                    span.toolCallId = String(e.toolCallId);
+                    this.tools.set(span.toolCallId, span);
+                }
+                break;
+            case 'tool_execution_end': {
+                const span = this.tools.get(String(e.toolCallId));
+                if (span) {
+                    this.finish(span, at);
+                    this.tools.delete(String(e.toolCallId));
+                }
+                break;
+            }
+            case 'compaction_start':
+            case 'auto_retry_start':
+                this.finish(this.other, at);
+                this.other = this.span(event.type === 'compaction_start' ? 'compaction' : 'retry', at);
+                break;
+            case 'compaction_end':
+            case 'auto_retry_end':
+                this.finish(this.other, at);
+                this.other = null;
+                if (event.type === 'auto_retry_end' && e.finalError === 'Retry cancelled')
+                    this.run.incomplete = true;
+                break;
+            case 'agent_end':
+                this.finish(this.model, at);
+                this.model = null;
+                if (e.aborted)
+                    this.run.incomplete = true;
+                break;
+            case 'agent_settled':
+                // Unlike agent_end, this also follows post-run compaction or a cancelled retry delay.
+                this.finish(this.model, at);
+                this.finish(this.other, at);
+                for (const span of this.tools.values()) {
+                    this.finish(span, at);
+                    span.incomplete = true;
+                }
+                this.save({
+                    start: this.run.start,
+                    end: at,
+                    spans: this.run.spans,
+                    ...(this.run.incomplete ? { incomplete: true } : {})
+                });
+                this.run = null;
+                this.model = this.other = null;
+                this.tools.clear();
+        }
+    }
+}
+/** Current branch only. Earlier sessions have tool timestamps but no model-call spans. */
+export function sessionPerformance(entries) {
+    const runs = [];
+    const legacyTools = [];
+    for (const entry of entries) {
+        const e = entry;
+        if (e.type === 'custom' &&
+            e.customType === PERFORMANCE_ENTRY &&
+            e.data?.spans &&
+            Number.isFinite(e.data.start) &&
+            Number.isFinite(e.data.end)) {
+            runs.push(e.data);
+        }
+    }
+    for (const entry of entries) {
+        const e = entry;
+        if (e.type !== 'message' || e.message?.role !== 'toolResult')
+            continue;
+        const duration = Number(e.message.durationMs);
+        const end = Number(e.message.timestamp) || Date.parse(e.timestamp ?? '');
+        if (!Number.isFinite(duration) ||
+            duration < 0 ||
+            !Number.isFinite(end) ||
+            runs.some(run => end >= run.start && end <= run.end))
+            continue;
+        legacyTools.push({ kind: 'tool', start: end - duration, end, name: String(e.message.toolName ?? 'tool') });
+    }
+    return { runs, legacyTools };
+}

package/dist/sotto-stt.js

@@ -0,0 +1,217 @@
+import { WebSocket } from 'ws';
+export const DEFAULT_SOTTO_ENDPOINT = 'http://127.0.0.1:8766';
+const invalid = (message, code = 'INVALID_SOTTO_SETTINGS') => Object.assign(new Error(message), { code });
+/** No arbitrary URLs: the Sotto Web API is local-only, and this server is the authenticated proxy. */
+export function validateSottoEndpoint(value) {
+    if (typeof value !== 'string')
+        throw invalid('Sotto endpoint must be a loopback HTTP URL');
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        throw invalid('Sotto endpoint must be a valid URL');
+    }
+    if (url.protocol !== 'http:' ||
+        url.hostname !== '127.0.0.1' ||
+        !url.port ||
+        url.username ||
+        url.password ||
+        (url.pathname !== '/' && url.pathname !== '') ||
+        url.search ||
+        url.hash)
+        throw invalid('Sotto endpoint must be http://127.0.0.1:<port> with no path or credentials');
+    return url.origin;
+}
+/** An authenticated browser socket relays only audio and start/stop, never a Sotto control API. */
+function proxySottoStream(client, url) {
+    const upstream = new WebSocket(url, { handshakeTimeout: 5000, maxPayload: 65536 });
+    let started = false, finished = false, closed = false;
+    let timer;
+    const close = () => {
+        closed = true;
+        clearTimeout(timer);
+        if (upstream.readyState === WebSocket.OPEN)
+            upstream.close();
+        else if (upstream.readyState === WebSocket.CONNECTING)
+            upstream.terminate();
+    };
+    const fail = (message, code = 1011) => {
+        if (closed)
+            return;
+        if (client.readyState === WebSocket.OPEN) {
+            client.send(JSON.stringify({ type: 'error', message }));
+            client.close(code);
+        }
+        close();
+    };
+    // Silence still contains PCM. Only a stalled capture/connection times out, not a long dictation.
+    const touch = () => {
+        clearTimeout(timer);
+        timer = setTimeout(() => fail('Audio stream stalled: no microphone frames received for 30 seconds'), 30000);
+    };
+    touch();
+    client.on('close', close);
+    client.on('error', close);
+    upstream.on('error', () => fail('Sotto streaming service is unavailable'));
+    upstream.on('close', code => {
+        if (closed)
+            return;
+        if (!finished || code !== 1000)
+            fail('Sotto streaming connection closed unexpectedly');
+        else {
+            clearTimeout(timer);
+            if (client.readyState === WebSocket.OPEN)
+                client.close(1000);
+        }
+    });
+    upstream.on('message', (data, binary) => {
+        if (closed || binary || client.readyState !== WebSocket.OPEN)
+            return;
+        if (client.bufferedAmount > 1_000_000) {
+            fail('Transcription receiver is too slow', 1009);
+            return;
+        }
+        client.send(data.toString());
+    });
+    client.on('message', (data, binary) => {
+        if (closed || finished || client.readyState !== WebSocket.OPEN)
+            return;
+        const length = data.byteLength;
+        if (upstream.readyState !== WebSocket.OPEN) {
+            fail('Sotto streaming service is not ready');
+            return;
+        }
+        if (!binary) {
+            try {
+                const value = JSON.parse(data.toString());
+                if (!started &&
+                    value.type === 'start' &&
+                    value.format === 'float32' &&
+                    Number.isInteger(value.sample_rate) &&
+                    value.sample_rate >= 16000 &&
+                    value.sample_rate <= 96000) {
+                    started = true;
+                    upstream.send(JSON.stringify({ type: 'start', format: 'float32', sample_rate: value.sample_rate }));
+                    touch();
+                }
+                else if (started && value.type === 'stop') {
+                    finished = true;
+                    upstream.send(JSON.stringify({ type: 'stop' }));
+                }
+                else
+                    fail('Invalid audio protocol', 1008);
+            }
+            catch {
+                fail('Invalid audio protocol', 1008);
+            }
+        }
+        else if (started &&
+            length > 0 &&
+            length % 4 === 0 &&
+            length <= 32768 &&
+            upstream.bufferedAmount < 1_000_000) {
+            upstream.send(data, { binary: true });
+            touch();
+        }
+        else
+            fail('Invalid audio frame or Sotto cannot keep up with microphone audio', 1009);
+    });
+    return fail;
+}
+export class SottoSttService {
+    metadata;
+    fetcher;
+    streams = new Set();
+    settings = { enabled: false, endpoint: DEFAULT_SOTTO_ENDPOINT };
+    /** Bumped by every update, so a slow enable probe cannot overwrite a newer choice. */
+    updates = 0;
+    constructor(metadata, fetcher = fetch) {
+        this.metadata = metadata;
+        this.fetcher = fetcher;
+    }
+    load() {
+        const saved = this.metadata.getSetting('sottoStt');
+        if (saved && typeof saved.enabled === 'boolean') {
+            try {
+                this.settings = { enabled: saved.enabled, endpoint: validateSottoEndpoint(saved.endpoint) };
+            }
+            catch {
+                /* Corrupt or obsolete settings must not enable an untrusted destination. */
+            }
+        }
+    }
+    getSettings() {
+        return { ...this.settings };
+    }
+    streamUrl() {
+        if (!this.settings.enabled)
+            throw invalid('Sotto transcription is disabled', 'SOTTO_DISABLED');
+        const port = Number(new URL(this.settings.endpoint).port) + 2;
+        if (port > 65535)
+            throw invalid('Invalid Sotto streaming port');
+        return `ws://127.0.0.1:${port}/asr`;
+    }
+    stream(client) {
+        const stop = proxySottoStream(client, this.streamUrl());
+        this.streams.add(stop);
+        client.once('close', () => this.streams.delete(stop));
+    }
+    async request(endpoint, path, init, timeoutMs) {
+        const response = await this.fetcher(`${endpoint}${path}`, {
+            ...init,
+            redirect: 'error',
+            signal: AbortSignal.timeout(timeoutMs)
+        }).catch(error => {
+            throw invalid(`Cannot reach local Sotto: ${error.message}`, 'SOTTO_UNAVAILABLE');
+        });
+        if (!response.ok) {
+            const message = (await response.json().catch(() => ({})));
+            throw invalid(message.error || `Sotto returned HTTP ${response.status}`, 'SOTTO_UNAVAILABLE');
+        }
+        return response;
+    }
+    async update(input) {
+        if (!input || typeof input !== 'object')
+            throw invalid('enabled and endpoint are required');
+        const { enabled, endpoint } = input;
+        if (typeof enabled !== 'boolean')
+            throw invalid('enabled must be a boolean');
+        const next = { enabled, endpoint: validateSottoEndpoint(endpoint) };
+        const update = ++this.updates;
+        if (enabled) {
+            const capabilities = await (await this.request(next.endpoint, '/api/capabilities', { method: 'GET' }, 4000)).json();
+            if (capabilities?.stt !== true ||
+                capabilities?.format !== 'pcm-f32le' ||
+                capabilities?.sample_rate !== 16000 ||
+                capabilities?.stream_port !== Number(new URL(next.endpoint).port) + 2)
+                throw invalid('Sotto does not support live PCM transcription', 'SOTTO_UNAVAILABLE');
+            if (update !== this.updates)
+                throw invalid('Sotto settings were changed by a newer request', 'SOTTO_SETTINGS_SUPERSEDED');
+        }
+        this.metadata.setSetting('sottoStt', next);
+        const changed = !next.enabled || next.endpoint !== this.settings.endpoint;
+        this.settings = next;
+        if (changed) {
+            for (const stop of this.streams)
+                stop('Sotto 语音输入已关闭或服务地址已更改');
+            this.streams.clear();
+        }
+        return this.getSettings();
+    }
+    async transcribe(audio) {
+        if (!this.settings.enabled)
+            throw invalid('Sotto transcription is disabled', 'SOTTO_DISABLED');
+        if (!audio.length || audio.length % 4 || audio.length > 16000 * 4 * 60)
+            throw invalid('Expected at most 60 seconds of 16 kHz float32 PCM');
+        const response = await this.request(this.settings.endpoint, '/api/transcribe', {
+            method: 'POST',
+            headers: { 'content-type': 'application/octet-stream' },
+            body: new Uint8Array(audio)
+        }, 120000);
+        const body = (await response.json());
+        if (typeof body.text !== 'string')
+            throw invalid('Invalid response from Sotto', 'SOTTO_UNAVAILABLE');
+        return { text: body.text };
+    }
+}

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "pi2web",
-  "version": "0.2.6",
+  "version": "0.2.8",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "pi2web",
-      "version": "0.2.6",
+      "version": "0.2.8",
       "license": "MIT",
       "dependencies": {
         "@earendil-works/chord": "1.1.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi2web",
-  "version": "0.2.6",
+  "version": "0.2.8",
   "description": "Secure remote web client server for Pi coding agent",
   "type": "module",
   "author": "sxwxs",

package/packages/protocol/openapi.yaml

@@ -21,8 +21,26 @@ paths:
     post: {operationId: createAgent, requestBody: {$ref: '#/components/requestBodies/Json'}, responses: {'201': {$ref: '#/components/responses/Success'}}}
   /agents/{id}/timeline:
     get: {operationId: agentTimeline, description: 'Older history as display items (see timelineItem in websocket.schema.json): about `limit` items before item `before`, never splitting a tool call from its result. Data {sessionId, items, total, start, hasMore}. Viewers get the newest page from the WebSocket focus snapshot. 404 when `before` is not on the current branch.', parameters: [{$ref: '#/components/parameters/Id'}, {name: limit, in: query, schema: {type: integer, minimum: 1, maximum: 500, default: 50}}, {name: before, in: query, schema: {type: string}}], responses: {'200': {$ref: '#/components/responses/Success'}}}
+  /agents/{id}/performance:
+    get: {operationId: agentPerformance, description: 'Current branch wall-clock model and tool spans recorded by recent runs; older sessions return only available tool durations. Data {sessionId, runs, legacyTools}. Parallel tools overlap.', parameters: [{$ref: '#/components/parameters/Id'}], responses: {'200': {$ref: '#/components/responses/Success'}}}
   /agents/{id}/sessions/{sessionId}/items/{itemId}:
     get: {operationId: agentTimelineItem, description: 'Full body of one timeline item, data {id, body}. Items never change, so it is served with Cache-Control private, max-age=31536000, immutable. 404 when the Agent is no longer on that session or branch.', parameters: [{$ref: '#/components/parameters/Id'}, {name: sessionId, in: path, required: true, schema: {type: string}}, {name: itemId, in: path, required: true, schema: {type: string}}], responses: {'200': {$ref: '#/components/responses/Success'}}}
+  /agents/{id}/system-prompt:
+    get: {operationId: getAgentSystemPrompt, parameters: [{$ref: '#/components/parameters/Id'}], responses: {'200': {$ref: '#/components/responses/Success'}}}
+    post: {operationId: changeAgentSystemPrompt, description: 'Only before the first conversation message; body {templateId?: string}, empty ID selects the Pi default.', parameters: [{$ref: '#/components/parameters/Id'}], requestBody: {$ref: '#/components/requestBodies/Json'}, responses: {'200': {$ref: '#/components/responses/Success'}}}
+  /sotto-stt:
+    get: {operationId: getSottoSttSettings, description: 'Backend-wide Sotto transcription setting; disabled by default, endpoint defaults to http://127.0.0.1:8766.', responses: {'200': {$ref: '#/components/responses/Success'}}}
+    put: {operationId: setSottoSttSettings, description: 'Body {enabled: boolean, endpoint: http://127.0.0.1:<port>}; probes local Sotto capabilities before enabling. Requires full access token.', requestBody: {$ref: '#/components/requestBodies/Json'}, responses: {'200': {$ref: '#/components/responses/Success'}}}
+  /transcribe:
+    post: {operationId: transcribeDraft, description: 'Backend-wide authenticated transcription, not tied to an Agent. Audio format follows the configured Sotto or STT service; returns {data:{text}}.', responses: {'200': {$ref: '#/components/responses/Success'}}}
+  /transcribe/ws:
+    get: {operationId: streamSottoTranscription, description: 'Authenticated backend-wide Sotto transcription WebSocket; start/PCM/stop protocol matches the Agent route.', responses: {'101': {description: 'WebSocket upgrade'}}}
+  /agents/{id}/transcribe:
+    post: {operationId: transcribeAgentDraft, description: 'When Sotto is enabled, body is 16 kHz mono float32 little-endian PCM (application/octet-stream; max 60 s); otherwise uses configured OpenAI-compatible STT audio. Returns {data:{text}} without submitting to the Agent.', parameters: [{$ref: '#/components/parameters/Id'}], responses: {'200': {$ref: '#/components/responses/Success'}}}
+  /agents/{id}/transcribe/ws:
+    get: {operationId: streamSottoDraft, description: 'Authenticated WebSocket: start {type:start,format:float32,sample_rate}, binary mono PCM chunks, stop {type:stop}; forwards Sotto ready/partial/final/error messages. Only when Sotto is enabled; never submits to Agent.', parameters: [{$ref: '#/components/parameters/Id'}], responses: {'101': {description: 'WebSocket upgrade'}}}
+  /agents/{id}/queue/move:
+    post: {operationId: moveQueuedMessage, description: 'Move one unconsumed message to the other queue during a run. Body {from: steering|followUp, index: integer, expected: string}; rejects stale entries.', parameters: [{$ref: '#/components/parameters/Id'}], requestBody: {$ref: '#/components/requestBodies/Json'}, responses: {'200': {$ref: '#/components/responses/Success'}}}
   /agents/{id}/{action}:
     get: {operationId: getAgentResource, parameters: [{$ref: '#/components/parameters/Id'}, {name: action, in: path, required: true, schema: {enum: [state,capabilities,session]}}], responses: {'200': {$ref: '#/components/responses/Success'}}}
     post: {operationId: agentCommand, parameters: [{$ref: '#/components/parameters/Id'}, {name: action, in: path, required: true, schema: {enum: [prompt,steer,follow-up,abort,compact,model,thinking,session-name,navigate,fork,extension-response]}}], requestBody: {$ref: '#/components/requestBodies/Json'}, responses: {'200': {$ref: '#/components/responses/Success'}}}