@pasko70/pibo 2.2.4 → 2.2.5

package/dist/agent-runtime/capabilities.js

@@ -27,6 +27,9 @@ const BOOLEAN_CAPABILITY_PATHS = [
     "nativeSubagents.supported",
     "nativeSubagents.configurable",
     "nativeSubagents.enabledByDefault",
+    "tools.intentTracing.supported",
+    "tools.intentTracing.configurable",
+    "tools.intentTracing.enabledByDefault",
     "historyImport",
     "auth.status",
     "auth.cancel",
@@ -121,7 +124,7 @@ export function validateAgentRuntimeCapabilities(value) {
     if (reasoningSupported === false && Array.isArray(reasoningValues) && reasoningValues.length > 0) {
         errors.push("reasoning.values must be omitted or empty when reasoning is unsupported");
     }
-    for (const feature of ["contextDiscovery", "nativeSubagents"]) {
+    for (const feature of ["contextDiscovery", "nativeSubagents", "tools.intentTracing"]) {
         const supported = readPath(value, `${feature}.supported`);
         const configurable = readPath(value, `${feature}.configurable`);
         const enabledByDefault = readPath(value, `${feature}.enabledByDefault`);
@@ -243,6 +246,11 @@ export function createMinimalAgentRuntimeCapabilities() {
             piboManaged: unavailable,
             nativeToolInspection: unavailable,
             nativeToolYielding: unavailable,
+            intentTracing: {
+                supported: false,
+                configurable: false,
+                enabledByDefault: false,
+            },
         },
         mcp: {
             externalServers: unavailable,

package/dist/agent-runtimes/codex-native/adapter.js

@@ -51,6 +51,11 @@ function codexNativeCapabilities(structuredUserInput) {
                 reason: "Stable Codex App Server 0.147.0 does not expose a complete pre-turn native-tool inventory; Pibo reports selected MCP tools immediately and harness-native tools after stable item notifications prove they are active.",
             },
             nativeToolYielding: unsupportedAgentRuntimeCapability("Codex native tools remain harness-owned and are not wrapped as Pibo yielded tools."),
+            intentTracing: {
+                supported: false,
+                configurable: false,
+                enabledByDefault: false,
+            },
         },
         mcp: {
             externalServers: { support: "mcp", transports: ["streamable-http", "stdio"] },

package/dist/agent-runtimes/omp/adapter.js

@@ -50,6 +50,11 @@ function ompCapabilities() {
                 reason: "OMP exposes its native tool inventory via get_state.dumpTools and runtime tool_execution items; a complete pre-turn inventory is only partially exposed through RPC.",
             },
             nativeToolYielding: unsupportedAgentRuntimeCapability("OMP native tools remain harness-owned and are not wrapped as Pibo yielded tools."),
+            intentTracing: {
+                supported: true,
+                configurable: false,
+                enabledByDefault: true,
+            },
         },
         mcp: {
             externalServers: { support: "unsupported", reason: "OMP manages its own MCP; external MCP delivery is not wired in the initial OMP adapter." },

package/dist/agent-runtimes/omp/turn.js

@@ -238,11 +238,13 @@ export class OmpRpcTurnController {
             return;
         }
         if (frame.type === "tool_execution_start") {
+            const intent = typeof frame.intent === "string" ? frame.intent.trim() : "";
             this.emit({
                 type: "tool_execution_started",
                 toolCallId: frame.toolCallId,
                 toolName: frame.toolName,
                 args: frame.args,
+                ...(intent ? { intent } : {}),
             });
             return;
         }

package/dist/agent-runtimes/pi/adapter.js

@@ -10,6 +10,7 @@ import { loadModelCatalog as loadPiModelCatalog, piAgentRuntimeModelCatalog, } f
 import { inspectPiAgentRuntimeHistory, readPiAgentRuntimeHistory, } from "./history.js";
 import { PiAgentRuntimeAuthController } from "./auth.js";
 import { importPortableHistoryIntoPi } from "./portable-history.js";
+import { piIntentTracingEnabled } from "./intent-tracing.js";
 const PI_ADAPTER_ID = "pi";
 export const PI_PROTOCOL_VERSION = "0.84.2";
 export const PI_AGENT_RUNTIME_CAPABILITIES = {
@@ -43,6 +44,11 @@ export const PI_AGENT_RUNTIME_CAPABILITIES = {
         piboManaged: { support: "direct" },
         nativeToolInspection: { support: "native" },
         nativeToolYielding: { support: "native" },
+        intentTracing: {
+            supported: true,
+            configurable: true,
+            enabledByDefault: false,
+        },
     },
     mcp: {
         externalServers: { support: "materialized", modes: ["isolated-pibo-mcp-config"] },
@@ -165,7 +171,7 @@ function nativeSessionInfoFromPi(runtimeInstanceId, info) {
         firstMessage: info.firstMessage,
     };
 }
-function semanticEventFromPibo(event) {
+export function semanticEventFromPibo(event) {
     switch (event.type) {
         case "message_started":
             return { type: "turn_started", turnId: event.eventId };
@@ -188,6 +194,7 @@ function semanticEventFromPibo(event) {
                 toolName: event.toolName,
                 args: event.args,
                 argsComplete: event.argsComplete,
+                ...(event.intent ? { intent: event.intent } : {}),
             };
         case "tool_execution_started":
             return { ...event, type: "tool_execution_started" };
@@ -519,12 +526,23 @@ class PiAgentRuntimeAdapter {
                 message: `Profile "${input.profile.profileName}" selects runtime instance "${input.profile.runtimeInstanceId}", not "${this.instanceId}".`,
             });
         }
-        if (Object.keys(input.profile.runtimeOptions).length > 0) {
+        const runtimeOptionKeys = Object.keys(input.profile.runtimeOptions);
+        for (const key of runtimeOptionKeys) {
+            if (key === "intentTracing")
+                continue;
+            diagnostics.push({
+                severity: "error",
+                code: "pi_runtime_option_unsupported",
+                message: `The Pi runtime does not accept profile option "${key}".`,
+                path: `runtimeOptions.${key}`,
+            });
+        }
+        if ("intentTracing" in input.profile.runtimeOptions && typeof input.profile.runtimeOptions["intentTracing"] !== "boolean") {
             diagnostics.push({
                 severity: "error",
-                code: "pi_runtime_options_unsupported",
-                message: "The Pi runtime does not accept adapter-specific profile options.",
-                path: "runtimeOptions",
+                code: "pi_intent_tracing_invalid",
+                message: "Pi intentTracing must be a boolean.",
+                path: "runtimeOptions.intentTracing",
             });
         }
         const profileProvidesBash = input.profile.toolPackages.runControl === true
@@ -582,10 +600,12 @@ class PiAgentRuntimeAdapter {
             throw new Error("Pi portable history import requires a new native session.");
         }
         const compatibility = input.services?.compatibility;
+        const profile = cloneProfileForPiSession(input);
+        const intentTracing = piIntentTracingEnabled(profile.runtimeOptions);
         const runtime = await createPiboRuntime({
             cwd: input.workspace,
             persistSession: compatibility?.persistSession,
-            profile: cloneProfileForPiSession(input),
+            profile,
             thinkingLevel: compatibility?.thinkingLevel,
             retryDefaults: compatibility?.retryDefaults,
             extensionFactories: compatibility?.extensionFactories,
@@ -631,6 +651,7 @@ class PiAgentRuntimeAdapter {
             metadata: {
                 ...(input.binding?.metadata ?? {}),
                 persistent: compatibility?.persistSession !== false,
+                intentTracing,
                 nativePresenceExpected: compatibility?.persistSession !== false
                     && runtime.session.sessionManager.buildSessionContext().messages.length > 0,
             },

package/dist/agent-runtimes/pi/intent-tracing.js

@@ -0,0 +1,120 @@
+export const PI_TOOL_INTENT_FIELD = "i";
+const PI_TOOL_INTENT_FALLBACK_FIELD = "__pibo_intent";
+const intentTracingSessions = new WeakMap();
+const PI_TOOL_INTENT_SCHEMA = {
+    type: "string",
+    minLength: 1,
+    description: "Capitalized 2–6-word present-participle intent describing why this tool is being called; no period.",
+};
+export function piIntentTracingEnabled(runtimeOptions) {
+    return runtimeOptions["intentTracing"] === true;
+}
+export function splitPiToolIntentArguments(value, intentField = PI_TOOL_INTENT_FIELD) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return { args: value };
+    const record = value;
+    const intentValue = record[intentField];
+    const intent = typeof intentValue === "string" && intentValue.trim() ? intentValue.trim() : undefined;
+    const { [intentField]: _intent, ...args } = record;
+    return intent ? { args, intent } : { args };
+}
+export function piToolIntentFieldForSchema(schema) {
+    if (!schema || typeof schema !== "object" || Array.isArray(schema))
+        return PI_TOOL_INTENT_FIELD;
+    const record = schema;
+    if (record.type !== "object")
+        return PI_TOOL_INTENT_FIELD;
+    const properties = record.properties && typeof record.properties === "object" && !Array.isArray(record.properties)
+        ? record.properties
+        : {};
+    const required = new Set(Array.isArray(record.required)
+        ? record.required.filter((name) => typeof name === "string")
+        : []);
+    const fieldIsUsed = (field) => Object.prototype.hasOwnProperty.call(properties, field) || required.has(field);
+    if (!fieldIsUsed(PI_TOOL_INTENT_FIELD))
+        return PI_TOOL_INTENT_FIELD;
+    let candidate = PI_TOOL_INTENT_FALLBACK_FIELD;
+    let suffix = 2;
+    while (fieldIsUsed(candidate))
+        candidate = `${PI_TOOL_INTENT_FALLBACK_FIELD}_${suffix++}`;
+    return candidate;
+}
+export function injectPiToolIntentSchema(schema) {
+    if (!schema || typeof schema !== "object" || Array.isArray(schema))
+        return schema;
+    const record = schema;
+    if (record.type !== "object")
+        return schema;
+    const properties = record.properties && typeof record.properties === "object" && !Array.isArray(record.properties)
+        ? record.properties
+        : {};
+    const intentField = piToolIntentFieldForSchema(schema);
+    const required = Array.isArray(record.required)
+        ? record.required.filter((name) => typeof name === "string" && name !== intentField)
+        : [];
+    return {
+        ...record,
+        properties: {
+            [intentField]: PI_TOOL_INTENT_SCHEMA,
+            ...properties,
+        },
+        required: [intentField, ...required],
+    };
+}
+export function piIntentTracingInstalled(session) {
+    return intentTracingSessions.has(session);
+}
+export function piToolIntentField(session, toolName) {
+    return intentTracingSessions.get(session)?.get(toolName);
+}
+export function installPiIntentTracing(session) {
+    if (intentTracingSessions.has(session))
+        return;
+    const intentFields = new Map();
+    const wrappedTools = new WeakMap();
+    const wrapActiveTools = () => {
+        session.agent.state.tools = session.agent.state.tools.map((tool) => {
+            const existing = wrappedTools.get(tool);
+            if (existing) {
+                intentFields.set(tool.name, existing.intentField);
+                return existing.tool;
+            }
+            const wrapped = wrapPiToolWithIntent(tool);
+            wrappedTools.set(tool, wrapped);
+            intentFields.set(tool.name, wrapped.intentField);
+            return wrapped.tool;
+        });
+    };
+    const setActiveToolsByName = session.setActiveToolsByName.bind(session);
+    session.setActiveToolsByName = (toolNames) => {
+        setActiveToolsByName(toolNames);
+        wrapActiveTools();
+    };
+    intentTracingSessions.set(session, intentFields);
+    wrapActiveTools();
+}
+function wrapPiToolWithIntent(tool) {
+    const prepareArguments = tool.prepareArguments;
+    const intentField = piToolIntentFieldForSchema(tool.parameters);
+    return {
+        intentField,
+        tool: {
+            ...tool,
+            parameters: injectPiToolIntentSchema(tool.parameters),
+            prepareArguments: (rawArgs) => {
+                const { args, intent } = splitPiToolIntentArguments(rawArgs, intentField);
+                const prepared = prepareArguments ? prepareArguments(args) : args;
+                if (!prepared || typeof prepared !== "object" || Array.isArray(prepared))
+                    return prepared;
+                return {
+                    ...prepared,
+                    ...(intent ? { [intentField]: intent } : {}),
+                };
+            },
+            execute: async (toolCallId, params, signal, onUpdate) => {
+                const { args } = splitPiToolIntentArguments(params, intentField);
+                return await tool.execute(toolCallId, args, signal, onUpdate);
+            },
+        },
+    };
+}

package/dist/agent-runtimes/pi/routed-session.js

@@ -6,6 +6,7 @@ import { expandInlineSkills } from "../../core/skill-expansion.js";
 import { PIBO_CONTEXT_GUARD_RESUME_MESSAGE_TYPE, PIBO_CONTEXT_GUARD_RESUME_PROMPT, cancelPiboAssistantContextGuardRecovery, claimPiboAssistantContextGuardRecovery, waitForPiboAssistantContextGuardRecovery, } from "../../core/context-guard.js";
 import { PIBO_PROVIDER_RECOVERY_MESSAGE_TYPE, PIBO_PROVIDER_RECOVERY_PROMPT, PiboProviderRecoveryCancelledError, isRetryablePiboAssistantError, isRetryablePiboProviderError, resolvePiboProviderRecoverySettings, waitForPiboProviderRecovery, } from "../../core/provider-recovery.js";
 import { PiAgentRuntimeAuthController } from "./auth.js";
+import { piIntentTracingInstalled, piToolIntentField, splitPiToolIntentArguments } from "./intent-tracing.js";
 import { loadModelCatalog as loadPiModelCatalog } from "./model-catalog.js";
 import { PIBO_TRANSCRIPT_INTEGRITY_RESUME_MESSAGE_TYPE, PIBO_TRANSCRIPT_INTEGRITY_RESUME_PROMPT, PiboTranscriptIntegrityError, claimPiboTranscriptIntegrityContinuation, settlePiboTranscriptIntegrityContinuation, } from "../../core/transcript-integrity.js";
 const FAST_SERVICE_TIER = "priority";
@@ -175,45 +176,57 @@ function toolCallFromAssistantEvent(candidate) {
     }
     return toolCallFromMessage(candidate.message, candidate.assistantMessageEvent?.contentIndex);
 }
-function normalizeToolCallEvent(piboSessionId, candidate) {
+function normalizeToolCallEvent(piboSessionId, candidate, context) {
     if (candidate.type === "message_update" &&
         (candidate.assistantMessageEvent?.type === "toolcall_start" ||
             candidate.assistantMessageEvent?.type === "toolcall_end")) {
         const toolCall = toolCallFromAssistantEvent(candidate);
         if (!toolCall)
             return undefined;
+        const { args, intent } = context?.intentTracing
+            ? splitPiToolIntentArguments(toolCall.args, context.intentFieldForTool?.(toolCall.name))
+            : { args: toolCall.args };
         return {
             type: "tool_call",
             piboSessionId,
             toolCallId: toolCall.id,
             toolName: toolCall.name,
-            args: toolCall.args,
+            args,
             argsComplete: candidate.assistantMessageEvent.type === "toolcall_end",
+            ...(intent ? { intent } : {}),
         };
     }
     return undefined;
 }
-function normalizeToolExecutionEvent(piboSessionId, candidate) {
+function normalizeToolExecutionEvent(piboSessionId, candidate, context) {
     if (typeof candidate.toolCallId !== "string" || typeof candidate.toolName !== "string") {
         return undefined;
     }
     if (candidate.type === "tool_execution_start") {
+        const { args, intent } = context?.intentTracing
+            ? splitPiToolIntentArguments(candidate.args, context.intentFieldForTool?.(candidate.toolName))
+            : { args: candidate.args };
         return {
             type: "tool_execution_started",
             piboSessionId,
             toolCallId: candidate.toolCallId,
             toolName: candidate.toolName,
-            args: candidate.args,
+            args,
+            ...(intent ? { intent } : {}),
         };
     }
     if (candidate.type === "tool_execution_update") {
+        const { args, intent } = context?.intentTracing
+            ? splitPiToolIntentArguments(candidate.args, context.intentFieldForTool?.(candidate.toolName))
+            : { args: candidate.args };
         return {
             type: "tool_execution_updated",
             piboSessionId,
             toolCallId: candidate.toolCallId,
             toolName: candidate.toolName,
-            args: candidate.args,
+            args,
             partialResult: candidate.partialResult,
+            ...(intent ? { intent } : {}),
         };
     }
     if (candidate.type === "tool_execution_end") {
@@ -332,10 +345,10 @@ export function normalizePiEvent(piboSessionId, event, context) {
             ? { type: "thinking_finished", piboSessionId, contentIndex: messageContentIndex(candidate) }
             : { type: "thinking_finished", piboSessionId, contentIndex: messageContentIndex(candidate), text };
     }
-    const toolCallEvent = normalizeToolCallEvent(piboSessionId, candidate);
+    const toolCallEvent = normalizeToolCallEvent(piboSessionId, candidate, context);
     if (toolCallEvent)
         return toolCallEvent;
-    const toolExecutionEvent = normalizeToolExecutionEvent(piboSessionId, candidate);
+    const toolExecutionEvent = normalizeToolExecutionEvent(piboSessionId, candidate, context);
     if (toolExecutionEvent)
         return toolExecutionEvent;
     if (candidate.type === "message_end") {
@@ -553,7 +566,11 @@ export class RoutedSession {
         this.unsubscribe = session.subscribe((event) => {
             this.onPiEventTelemetry?.(this.piboSessionId, event, { status: this.getStatus(), activeEventId: this.activeMessage?.id ?? this.activeExecutionEvent?.id });
             const model = this.runtime.session.model;
-            const normalized = normalizePiEvent(this.piboSessionId, event, { contextWindow: numberValue(model?.contextWindow) });
+            const normalized = normalizePiEvent(this.piboSessionId, event, {
+                contextWindow: numberValue(model?.contextWindow),
+                intentTracing: piIntentTracingInstalled(session),
+                intentFieldForTool: (toolName) => piToolIntentField(session, toolName),
+            });
             const candidate = event && typeof event === "object" ? event : undefined;
             const assistantMessageEnded = candidate?.type === "message_end" && isAssistantMessage(candidate.message);
             const usageEvent = assistantMessageEnded ? normalizeAssistantUsageEvent(this.piboSessionId, candidate?.message) : undefined;

package/dist/agent-runtimes/pi/runtime.js

@@ -28,6 +28,7 @@ import { compactValidationToolResultForContext } from "../../core/test-output-co
 import { installPiboTranscriptIntegrity } from "../../core/transcript-integrity.js";
 import { normalizePiboToolDefinition, } from "../../tools/contract.js";
 import { compilePiboToolForPi } from "./tool-compiler.js";
+import { installPiIntentTracing, piIntentTracingEnabled } from "./intent-tracing.js";
 import { createPiboSessionToolDefinitions, isCodexBrowserToolProfile as isCodexBrowserTool, isEnabledCodexBrowserToolProfile as isEnabledCodexBrowserTool, isEnabledRuntimeToolProfile as isEnabledRuntimeTool, isGeneratedPiboTool, isRuntimeToolProfile as isRuntimeTool, } from "../../tools/session-tool-set.js";
 function hasOwnRetrySetting(settings, key) {
     return settings !== undefined && settings !== null && Object.prototype.hasOwnProperty.call(settings, key);
@@ -306,6 +307,8 @@ export async function createPiboRuntime(options = {}) {
             noTools: profile.builtinTools === "disabled" ? "builtin" : undefined,
             tools: getBuiltinToolAllowlist(profile, piboToolDefinitions),
         });
+        if (piIntentTracingEnabled(profile.runtimeOptions))
+            installPiIntentTracing(created.session);
         installPiboTranscriptIntegrity(created.session);
         installValidationOutputCompaction(created.session.agent);
         registerPiboAssistantContextGuardRecovery(created.session, contextGuardRecovery);

package/dist/apps/chat/chat-settings-routes.js

@@ -1,7 +1,8 @@
 import { readPiboBasePrompt, savePiboCustomBasePrompt, setPiboBasePromptMode } from "../../core/base-prompt.js";
 import { readPiboCompactionPrompt, savePiboCustomCompactionPrompt, setPiboCompactionPromptMode } from "../../core/compaction-prompt.js";
+import { loadPiboGatewaySettings, sanitizeConcurrentYieldedRuns, updatePiboGatewaySettings, } from "../../core/gateway-settings.js";
 import { sanitizeTelemetryRetentionDays, sanitizeTelemetryRetentionSettings } from "../../core/telemetry-retention-settings.js";
-import { loadPiboUserSettings, sanitizeShortcutSettings, sanitizeTimezone, updatePiboUserSettings, updateTelemetryRetentionLastPrunedAt } from "../../core/user-settings.js";
+import { loadPiboUserSettings, sanitizeShortcutSettings, sanitizeTimezone, sanitizeTranscriptionProviderId, updatePiboUserSettings, updateTelemetryRetentionLastPrunedAt } from "../../core/user-settings.js";
 import { PiboWebHttpError, readJsonBody, responseJson } from "../../web/http.js";
 import { CHAT_WEB_API_PREFIX } from "./chat-api-routes.js";
 import { normalizeBasePromptMarkdown, normalizeBasePromptMode, normalizeCompactionPromptMarkdown, normalizeCompactionPromptMode, updateChatModelDefaults, } from "./chat-request-normalizers.js";
@@ -13,6 +14,10 @@ export function chatSettingsRoute(pathname, method) {
         return { kind: "user-settings", action: "read" };
     if (pathname === `${CHAT_WEB_API_PREFIX}/user-settings` && method === "PATCH")
         return { kind: "user-settings", action: "update" };
+    if (pathname === `${CHAT_WEB_API_PREFIX}/gateway-settings` && method === "GET")
+        return { kind: "gateway-settings", action: "read" };
+    if (pathname === `${CHAT_WEB_API_PREFIX}/gateway-settings` && method === "PATCH")
+        return { kind: "gateway-settings", action: "update" };
     if (pathname === `${CHAT_WEB_API_PREFIX}/telemetry-retention/prune` && method === "POST")
         return { kind: "telemetry-retention", action: "prune" };
     if (pathname === `${CHAT_WEB_API_PREFIX}/base-prompt` && method === "GET")
@@ -46,7 +51,13 @@ export async function handleChatSettingsRoute(input) {
         if (route.action === "read")
             return responseJson({ userSettings: loadPiboUserSettings() });
         const body = await readJsonBody(request);
-        return responseJson({ userSettings: updatePiboUserSettings(userSettingsPatch(body)) });
+        return responseJson({ userSettings: updatePiboUserSettings(userSettingsPatch(body, input.transcriptionProviderIds)) });
+    }
+    if (route.kind === "gateway-settings") {
+        if (route.action === "read")
+            return responseJson({ gatewaySettings: loadPiboGatewaySettings() });
+        const body = await readJsonBody(request);
+        return responseJson({ gatewaySettings: updatePiboGatewaySettings(gatewaySettingsPatch(body)) });
     }
     if (route.kind === "telemetry-retention") {
         if (!input.dataStore)
@@ -77,7 +88,25 @@ export async function handleChatSettingsRoute(input) {
     }
     return responseJson({ compactionPrompt: await savePiboCustomCompactionPrompt(normalizeCompactionPromptMarkdown(body.markdown), cwd) });
 }
-function userSettingsPatch(body) {
+function gatewaySettingsPatch(body) {
+    const patch = {};
+    if (body.maxConcurrentYieldedRuns !== undefined) {
+        const value = sanitizeConcurrentYieldedRuns(body.maxConcurrentYieldedRuns);
+        if (!value)
+            throw new PiboWebHttpError("Invalid gateway yielded-run concurrency", 400);
+        patch.maxConcurrentYieldedRuns = value;
+    }
+    if (body.sessionConcurrentYieldedRuns !== undefined) {
+        const value = sanitizeConcurrentYieldedRuns(body.sessionConcurrentYieldedRuns);
+        if (!value)
+            throw new PiboWebHttpError("Invalid session yielded-run concurrency", 400);
+        patch.sessionConcurrentYieldedRuns = value;
+    }
+    if (Object.keys(patch).length === 0)
+        throw new PiboWebHttpError("No gateway settings provided", 400);
+    return patch;
+}
+function userSettingsPatch(body, transcriptionProviderIds) {
     const patch = {};
     if (body.timezone !== undefined) {
         const timezone = sanitizeTimezone(body.timezone);
@@ -87,6 +116,18 @@ function userSettingsPatch(body) {
     }
     if (body.shortcuts !== undefined)
         patch.shortcuts = sanitizeShortcutSettings(body.shortcuts);
+    if (body.transcription !== undefined) {
+        const raw = body.transcription && typeof body.transcription === "object" && !Array.isArray(body.transcription)
+            ? body.transcription
+            : {};
+        const providerId = sanitizeTranscriptionProviderId(raw.providerId);
+        if (!providerId)
+            throw new PiboWebHttpError("Invalid transcription provider", 400);
+        if (transcriptionProviderIds && !transcriptionProviderIds.includes(providerId)) {
+            throw new PiboWebHttpError(`Unknown transcription provider "${providerId}"`, 400);
+        }
+        patch.transcription = { providerId };
+    }
     if (body.telemetryRetention !== undefined) {
         const current = loadPiboUserSettings().telemetryRetention;
         patch.telemetryRetention = {

package/dist/apps/chat/chat-transcription.js

@@ -0,0 +1,85 @@
+import { basename } from "node:path";
+import { loadPiboUserSettings } from "../../core/user-settings.js";
+import { PiboTranscriptionError, } from "../../transcription/types.js";
+import { PiboWebHttpError, responseJson } from "../../web/http.js";
+export const CHAT_TRANSCRIPTION_MAX_BYTES = 25 * 1024 * 1024;
+export async function responseChatTranscriptionProviders(context) {
+    const providers = await requireProviderInfos(context);
+    return responseJson({
+        providers,
+        selectedProviderId: loadPiboUserSettings().transcription.providerId,
+    });
+}
+export async function responseChatTranscription(request, context) {
+    const transcribe = context.channelContext.transcribe;
+    if (!transcribe)
+        throw new PiboWebHttpError("Transcription is not available", 503);
+    const providerId = loadPiboUserSettings().transcription.providerId;
+    const providers = await requireProviderInfos(context);
+    if (!providers.some((provider) => provider.id === providerId)) {
+        throw new PiboWebHttpError(`Transcription provider "${providerId}" is not registered`, 409);
+    }
+    const audio = await readTranscriptionAudio(request);
+    let result;
+    try {
+        result = await transcribe(providerId, audio);
+    }
+    catch (error) {
+        if (error instanceof PiboTranscriptionError) {
+            throw new PiboWebHttpError(error.message, transcriptionErrorStatus(error));
+        }
+        throw new PiboWebHttpError(error instanceof Error ? error.message : "Transcription failed", 502);
+    }
+    return responseJson({ transcription: result });
+}
+async function requireProviderInfos(context) {
+    const getProviderInfos = context.channelContext.getTranscriptionProviderInfos;
+    if (!getProviderInfos)
+        throw new PiboWebHttpError("Transcription providers are not available", 503);
+    return await getProviderInfos();
+}
+async function readTranscriptionAudio(request) {
+    const form = await request.formData();
+    const file = form.get("file");
+    if (!isUploadedAudioFile(file))
+        throw new PiboWebHttpError("An audio file is required", 400);
+    if (file.size === 0)
+        throw new PiboWebHttpError("The audio recording is empty", 400);
+    if (file.size > CHAT_TRANSCRIPTION_MAX_BYTES) {
+        throw new PiboWebHttpError("The audio recording exceeds the 25 MiB limit", 413);
+    }
+    const filename = sanitizeAudioFilename(file.name);
+    return {
+        audio: {
+            bytes: new Uint8Array(await file.arrayBuffer()),
+            filename,
+            mimeType: file.type || "application/octet-stream",
+        },
+        clientUserAgent: sanitizeClientUserAgent(request.headers.get("user-agent")),
+    };
+}
+function isUploadedAudioFile(value) {
+    return typeof value === "object"
+        && value !== null
+        && typeof value.name === "string"
+        && typeof value.size === "number"
+        && typeof value.type === "string"
+        && typeof value.arrayBuffer === "function";
+}
+function sanitizeAudioFilename(value) {
+    const filename = basename(value).replace(/[\u0000-\u001f\u007f]/g, "").trim();
+    return filename && !/^\.+$/.test(filename) ? filename : `recording-${Date.now()}.webm`;
+}
+function sanitizeClientUserAgent(value) {
+    if (!value)
+        return undefined;
+    const userAgent = value.replace(/[\u0000-\u001f\u007f]/g, "").trim();
+    return userAgent ? userAgent.slice(0, 512) : undefined;
+}
+function transcriptionErrorStatus(error) {
+    if (error.code === "invalid_audio")
+        return 400;
+    if (error.code === "not_configured")
+        return 409;
+    return 502;
+}

package/dist/apps/chat/data/chat-data-mappers.js

@@ -46,13 +46,13 @@ function outputPayloadFromV2Row(row, attributes, persistedPayload) {
         });
     }
     if (row.type === "tool_call")
-        return { ...base, type: "tool_call", toolCallId: stringAttribute(attributes, "toolCallId") ?? row.event_id ?? `tool_${row.stream_id}`, toolName: row.preview_text ?? stringAttribute(attributes, "toolName") ?? "tool", args: inlinePayload ?? null, argsComplete: booleanAttribute(attributes, "argsComplete") ?? true };
+        return compactObject({ ...base, type: "tool_call", toolCallId: stringAttribute(attributes, "toolCallId") ?? row.event_id ?? `tool_${row.stream_id}`, toolName: row.preview_text ?? stringAttribute(attributes, "toolName") ?? "tool", args: inlinePayload ?? null, argsComplete: booleanAttribute(attributes, "argsComplete") ?? true, intent: stringAttribute(attributes, "intent") });
     if (row.type === "tool_execution_started")
-        return { ...base, type: "tool_execution_started", toolCallId: stringAttribute(attributes, "toolCallId") ?? row.event_id ?? `tool_${row.stream_id}`, toolName: row.preview_text ?? stringAttribute(attributes, "toolName") ?? "tool", args: inlinePayload ?? null };
+        return compactObject({ ...base, type: "tool_execution_started", toolCallId: stringAttribute(attributes, "toolCallId") ?? row.event_id ?? `tool_${row.stream_id}`, toolName: row.preview_text ?? stringAttribute(attributes, "toolName") ?? "tool", args: inlinePayload ?? null, intent: stringAttribute(attributes, "intent") });
     if (row.type === "tool_execution_updated")
-        return { ...base, type: "tool_execution_updated", toolCallId: stringAttribute(attributes, "toolCallId") ?? row.event_id ?? `tool_${row.stream_id}`, toolName: row.preview_text ?? stringAttribute(attributes, "toolName") ?? "tool", args: null, partialResult: inlinePayload ?? null };
+        return compactObject({ ...base, type: "tool_execution_updated", toolCallId: stringAttribute(attributes, "toolCallId") ?? row.event_id ?? `tool_${row.stream_id}`, toolName: row.preview_text ?? stringAttribute(attributes, "toolName") ?? "tool", args: null, partialResult: inlinePayload ?? null, intent: stringAttribute(attributes, "intent") });
     if (row.type === "tool_execution_finished")
-        return { ...base, type: "tool_execution_finished", toolCallId: stringAttribute(attributes, "toolCallId") ?? row.event_id ?? `tool_${row.stream_id}`, toolName: row.preview_text ?? stringAttribute(attributes, "toolName") ?? "tool", result: inlinePayload ?? null, isError: booleanAttribute(attributes, "isError") ?? false };
+        return compactObject({ ...base, type: "tool_execution_finished", toolCallId: stringAttribute(attributes, "toolCallId") ?? row.event_id ?? `tool_${row.stream_id}`, toolName: row.preview_text ?? stringAttribute(attributes, "toolName") ?? "tool", result: inlinePayload ?? null, isError: booleanAttribute(attributes, "isError") ?? false, intent: stringAttribute(attributes, "intent") });
     if (row.type === "subagent_session") {
         const toolName = stringAttribute(attributes, "toolName");
         const subagentName = stringAttribute(attributes, "subagentName");

package/dist/apps/chat/stream.js

@@ -58,36 +58,49 @@ export function chatStreamFramesFromOutputEvent(event, state, options = {}) {
             }
             break;
         case "tool_call":
-            ensureToolCallStarted(frames, state, event.toolCallId, event.toolName, event.args, eventId);
+            ensureToolCallStarted(frames, state, event.toolCallId, event.toolName, event.args, event.intent, eventId);
             frames.push({
                 type: "TOOL_CALL_ARGS",
                 toolCallId: event.toolCallId,
                 toolName: event.toolName,
                 args: event.args,
                 argsComplete: event.argsComplete,
+                ...(event.intent ? { intent: event.intent } : {}),
                 runId: eventId,
                 sourceEventType: "tool_call",
             });
             break;
-        case "tool_execution_started":
-            ensureToolCallStarted(frames, state, event.toolCallId, event.toolName, event.args, eventId);
+        case "tool_execution_started": {
+            const started = ensureToolCallStarted(frames, state, event.toolCallId, event.toolName, event.args, event.intent, eventId);
+            if (!started && event.intent) {
+                frames.push({
+                    type: "TOOL_CALL_START",
+                    toolCallId: event.toolCallId,
+                    toolName: event.toolName,
+                    args: event.args,
+                    intent: event.intent,
+                    runId: eventId,
+                });
+            }
             break;
+        }
         case "tool_execution_updated":
-            ensureToolCallStarted(frames, state, event.toolCallId, event.toolName, event.args, eventId);
+            ensureToolCallStarted(frames, state, event.toolCallId, event.toolName, event.args, event.intent, eventId);
             frames.push({
                 type: "TOOL_CALL_ARGS",
                 toolCallId: event.toolCallId,
                 toolName: event.toolName,
                 args: event.args,
                 argsComplete: true,
+                ...(event.intent ? { intent: event.intent } : {}),
                 runId: eventId,
                 partialResult: event.partialResult,
                 sourceEventType: "tool_execution_updated",
             });
             break;
         case "tool_execution_finished":
-            ensureToolCallStarted(frames, state, event.toolCallId, event.toolName, undefined, eventId);
-            frames.push({ type: "TOOL_CALL_RESULT", toolCallId: event.toolCallId, toolName: event.toolName, result: event.result, isError: event.isError, runId: eventId });
+            ensureToolCallStarted(frames, state, event.toolCallId, event.toolName, undefined, event.intent, eventId);
+            frames.push({ type: "TOOL_CALL_RESULT", toolCallId: event.toolCallId, toolName: event.toolName, result: event.result, isError: event.isError, ...(event.intent ? { intent: event.intent } : {}), runId: eventId });
             break;
         case "subagent_session":
             frames.push({
@@ -149,9 +162,10 @@ function ensureReasoningStarted(frames, state, messageId, runId) {
     state.reasoningMessageIds.add(messageId);
     frames.push({ type: "REASONING_MESSAGE_START", messageId, runId });
 }
-function ensureToolCallStarted(frames, state, toolCallId, toolName, args, runId) {
+function ensureToolCallStarted(frames, state, toolCallId, toolName, args, intent, runId) {
     if (state.toolCallIds.has(toolCallId))
-        return;
+        return false;
     state.toolCallIds.add(toolCallId);
-    frames.push({ type: "TOOL_CALL_START", toolCallId, toolName, args, runId });
+    frames.push({ type: "TOOL_CALL_START", toolCallId, toolName, args, ...(intent ? { intent } : {}), runId });
+    return true;
 }