@pasko70/pibo 2.2.4 → 2.3.0

package/dist/debug/agents.js

@@ -0,0 +1,391 @@
+import { normalizePiboAgentObservationCursor, normalizePiboAgentObservationLimit, normalizePiboAgentObservationOrder, parsePiboAgentObservationTimestamp, piboAgentObservationDetails, piboAgentObservationKind, piboAgentObservationRole, piboAgentObservationText, } from "../subagents/observations.js";
+import { createDebugPayloadStore, hydrateDebugEventRow } from "./persisted-payloads.js";
+import { eventAttributes, eventPayload } from "./payloads.js";
+import { openReadOnlyDebugDatabase, withStorePath } from "./sql.js";
+import { resolveDebugStore } from "./stores.js";
+export async function runDebugAgentsCli(args) {
+    if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
+        printDebugAgentsDiscovery();
+        return;
+    }
+    const parentPiboSessionId = args[0];
+    const command = args[1];
+    if (!command || command === "--help" || command === "-h") {
+        printDebugAgentsDiscovery(parentPiboSessionId);
+        return;
+    }
+    if (command !== "list" && command !== "observe") {
+        throw new Error(`Unknown pibo debug agents command "${command}". Run pibo debug agents ${parentPiboSessionId} --help.`);
+    }
+    if (args.slice(2).some((arg) => arg === "--help" || arg === "-h")) {
+        printDebugAgentsCommandHelp(parentPiboSessionId, command);
+        return;
+    }
+    const parsed = parseAgentDebugOptions(args.slice(2));
+    validateAgentDebugOptions(command, parsed);
+    const store = resolveDebugStore("pibo-data");
+    if (command === "list") {
+        const agents = inspectDebugAgentList(parentPiboSessionId, store, {
+            name: parsed.names[0],
+            status: parsed.status,
+        });
+        if (parsed.json)
+            console.log(JSON.stringify({ parentPiboSessionId, agents }, null, 2));
+        else
+            console.log(formatDebugAgentList(parentPiboSessionId, agents));
+        return;
+    }
+    const result = inspectDebugAgentObservations(parentPiboSessionId, store, {
+        agentIds: parsed.agentIds.length ? parsed.agentIds : undefined,
+        names: parsed.names.length ? parsed.names : undefined,
+        threadKeys: parsed.threadKeys.length ? parsed.threadKeys : undefined,
+        eventTypes: parsed.eventTypes.length ? parsed.eventTypes : undefined,
+        kinds: parsed.kinds.length ? parsed.kinds : undefined,
+        since: parsed.since,
+        until: parsed.until,
+        textContains: parsed.textContains,
+        afterSequence: parsed.afterSequence,
+        order: parsed.order,
+        limit: parsed.limit,
+        includeDetails: parsed.details,
+    });
+    if (parsed.json)
+        console.log(JSON.stringify(result, null, 2));
+    else
+        console.log(formatDebugAgentObservations(result));
+}
+export function inspectDebugAgentList(parentPiboSessionId, store, options = {}) {
+    if (!store.exists)
+        throw new Error(`Debug store "pibo-data" not found at ${store.path}`);
+    const db = openReadOnlyDebugDatabase(store);
+    try {
+        return readOwnedAgents(db, parentPiboSessionId)
+            .filter((agent) => !options.name || agent.name === options.name)
+            .filter((agent) => !options.status || agent.status === options.status);
+    }
+    catch (error) {
+        throw withStorePath(error, store);
+    }
+    finally {
+        db.close();
+    }
+}
+export function inspectDebugAgentObservations(parentPiboSessionId, store, input = {}) {
+    if (!store.exists)
+        throw new Error(`Debug store "pibo-data" not found at ${store.path}`);
+    const db = openReadOnlyDebugDatabase(store);
+    try {
+        const order = normalizePiboAgentObservationOrder(input.order);
+        const limit = normalizePiboAgentObservationLimit(input.limit);
+        const afterSequence = normalizePiboAgentObservationCursor(input.afterSequence);
+        const since = parsePiboAgentObservationTimestamp(input.since, "since");
+        const until = parsePiboAgentObservationTimestamp(input.until, "until");
+        if (since !== undefined && until !== undefined && since > until)
+            throw new Error("Agent observation since must not be after until.");
+        const owned = readOwnedAgents(db, parentPiboSessionId);
+        const ownedById = new Map(owned.map((agent) => [agent.agentId, agent]));
+        for (const agentId of input.agentIds ?? []) {
+            if (!ownedById.has(agentId))
+                throw new Error(`Agent "${agentId}" is not owned by Pibo session "${parentPiboSessionId}".`);
+        }
+        const agentIds = input.agentIds ? new Set(input.agentIds) : undefined;
+        const names = input.names ? new Set(input.names) : undefined;
+        const threadKeys = input.threadKeys ? new Set(input.threadKeys) : undefined;
+        const eventTypes = input.eventTypes ? new Set(input.eventTypes) : undefined;
+        const kinds = input.kinds ? new Set(input.kinds) : undefined;
+        const payloadStore = createDebugPayloadStore(db, store);
+        const clauses = ["s.parent_id = ?", "s.channel = 'pibo.subagents'", "s.kind = 'subagent'", "s.deleted_at IS NULL"];
+        const values = [parentPiboSessionId];
+        if (afterSequence !== undefined) {
+            clauses.push("e.stream_id > ?");
+            values.push(afterSequence);
+        }
+        const scanOrder = afterSequence !== undefined ? "ASC" : order.toUpperCase();
+        const statement = db.prepare(`
+			SELECT e.stream_id, e.session_id, e.session_sequence, e.event_id, e.type, e.created_at,
+				e.payload_ref, e.preview_text, e.attributes_json, s.profile, s.metadata_json
+			FROM event_log e
+			JOIN sessions s ON s.id = e.session_id
+			WHERE ${clauses.join(" AND ")}
+			ORDER BY e.stream_id ${scanOrder}
+		`);
+        const textContains = input.textContains?.toLowerCase();
+        const matches = [];
+        for (const rawRow of statement.iterate(...values)) {
+            const agent = ownedById.get(rawRow.session_id ?? "");
+            if (!agent)
+                continue;
+            if (agentIds && !agentIds.has(agent.agentId))
+                continue;
+            if (names && !names.has(agent.name))
+                continue;
+            if (threadKeys && (!agent.threadKey || !threadKeys.has(agent.threadKey)))
+                continue;
+            if (eventTypes && !eventTypes.has(rawRow.type))
+                continue;
+            const kind = piboAgentObservationKind(rawRow.type);
+            if (kinds && !kinds.has(kind))
+                continue;
+            const createdAt = Date.parse(rawRow.created_at);
+            if (since !== undefined && createdAt < since)
+                continue;
+            if (until !== undefined && createdAt > until)
+                continue;
+            const row = hydrateDebugEventRow(rawRow, payloadStore);
+            const attributes = eventAttributes(row);
+            const payload = { ...attributes, ...eventPayload(row) };
+            const source = debugAgentObservationSource(row, attributes);
+            const text = piboAgentObservationText(source);
+            if (textContains && !(text ?? "").toLowerCase().includes(textContains))
+                continue;
+            const role = piboAgentObservationRole(source);
+            matches.push({
+                streamId: row.stream_id,
+                createdAt: row.created_at,
+                agentId: agent.agentId,
+                name: agent.name,
+                ...(agent.threadKey ? { threadKey: agent.threadKey } : {}),
+                eventType: row.type,
+                kind,
+                ...(role ? { role } : {}),
+                ...(text ? { text } : {}),
+                ...(typeof payload.toolName === "string" ? { toolName: payload.toolName } : {}),
+                ...(typeof payload.toolCallId === "string" ? { toolCallId: payload.toolCallId } : {}),
+                ...(row.type === "tool_execution_finished" ? { isError: payload.isError === true } : row.type === "session_error" ? { isError: true } : {}),
+                ...(input.includeDetails === true ? { details: piboAgentObservationDetails(debugAgentObservationDetails(row, payload)) } : {}),
+            });
+            if (matches.length > limit)
+                break;
+        }
+        const truncated = matches.length > limit;
+        const observations = matches.slice(0, limit);
+        if (afterSequence !== undefined && order === "desc")
+            observations.reverse();
+        return {
+            parentPiboSessionId,
+            filters: {
+                ...input,
+                ...(afterSequence !== undefined ? { afterSequence } : {}),
+                order,
+                limit,
+                includeDetails: input.includeDetails === true,
+            },
+            observations,
+            nextAfterSequence: observations.reduce((maximum, observation) => Math.max(maximum, observation.streamId), afterSequence ?? 0),
+            truncated,
+        };
+    }
+    catch (error) {
+        throw withStorePath(error, store);
+    }
+    finally {
+        db.close();
+    }
+}
+function readOwnedAgents(db, parentPiboSessionId) {
+    const rows = db.prepare(`
+		SELECT id, profile, status, metadata_json, active_model_json, created_at, updated_at
+		FROM sessions
+		WHERE parent_id = ? AND channel = 'pibo.subagents' AND kind = 'subagent' AND deleted_at IS NULL
+		ORDER BY updated_at DESC
+	`).all(parentPiboSessionId);
+    return rows.map((row) => {
+        const metadata = parseObject(row.metadata_json);
+        const killed = metadata.agentStatus === "killed";
+        return {
+            agentId: row.id,
+            name: typeof metadata.subagentName === "string" ? metadata.subagentName : row.profile,
+            profile: row.profile,
+            ...(typeof metadata.threadKey === "string" ? { threadKey: metadata.threadKey } : {}),
+            status: killed ? "killed" : isRunningStatus(row.status) ? "running" : "idle",
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+            ...(row.active_model_json ? { activeModel: JSON.parse(row.active_model_json) } : {}),
+        };
+    });
+}
+function debugAgentObservationSource(row, attributes) {
+    const inlinePayload = attributes.inlinePayload;
+    const source = {
+        eventType: row.type,
+        fallbackText: row.preview_text ?? row.type,
+        ...(typeof attributes.source === "string" ? { source: attributes.source } : {}),
+    };
+    if (row.type === "message_queued" || row.type === "message_steered" || row.type === "message_started") {
+        source.text = typeof attributes.inlineText === "string" ? attributes.inlineText : row.preview_text ?? undefined;
+    }
+    else if (row.type === "assistant_message" || row.type === "assistant_delta" || row.type === "thinking_delta" || row.type === "thinking_finished") {
+        source.text = typeof inlinePayload === "string" ? inlinePayload : row.preview_text ?? undefined;
+    }
+    else if (row.type === "session_error") {
+        source.error = attributes.error;
+    }
+    else if (row.type === "tool_call" || row.type === "tool_execution_started") {
+        source.args = inlinePayload;
+    }
+    else if (row.type === "tool_execution_updated") {
+        source.partialResult = inlinePayload;
+    }
+    else if (row.type === "tool_execution_finished" || row.type === "execution_result" || row.type === "compaction_end") {
+        source.result = inlinePayload;
+    }
+    if (row.type === "execution_result")
+        source.action = attributes.action;
+    if (row.type === "compaction_start" || row.type === "compaction_end")
+        source.reason = attributes.reason;
+    if (row.type === "subagent_session")
+        source.subagentName = attributes.subagentName;
+    return source;
+}
+function debugAgentObservationDetails(row, payload) {
+    return {
+        type: row.type,
+        ...(row.session_id ? { piboSessionId: row.session_id } : {}),
+        ...(row.event_id ? { eventId: row.event_id } : {}),
+        ...payload,
+    };
+}
+function parseObject(value) {
+    try {
+        const parsed = JSON.parse(value);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+function isRunningStatus(status) {
+    return ["running", "streaming", "queued", "starting", "waiting", "blocked", "retrying"].includes(status);
+}
+function formatDebugAgentList(parentPiboSessionId, agents) {
+    if (agents.length === 0)
+        return `parent: ${parentPiboSessionId}\nagents: 0`;
+    return [
+        `parent: ${parentPiboSessionId}`,
+        "agentId\tname\tprofile\tthreadKey\tstatus\tupdatedAt",
+        ...agents.map((agent) => `${agent.agentId}\t${agent.name}\t${agent.profile}\t${agent.threadKey ?? ""}\t${agent.status}\t${agent.updatedAt}`),
+        `agents: ${agents.length}`,
+    ].join("\n");
+}
+function formatDebugAgentObservations(result) {
+    if (result.observations.length === 0)
+        return `parent: ${result.parentPiboSessionId}\nobservations: 0\nnextAfterSequence: ${result.nextAfterSequence}`;
+    return [
+        `parent: ${result.parentPiboSessionId}`,
+        "streamId\tcreatedAt\tagentId\tname\teventType\tkind\ttext",
+        ...result.observations.map((observation) => `${observation.streamId}\t${observation.createdAt}\t${observation.agentId}\t${observation.name}\t${observation.eventType}\t${observation.kind}\t${(observation.text ?? "").replaceAll("\n", "\\n")}`),
+        `observations: ${result.observations.length}${result.truncated ? " (limited)" : ""}`,
+        `nextAfterSequence: ${result.nextAfterSequence}`,
+    ].join("\n");
+}
+function printDebugAgentsDiscovery(parentPiboSessionId = "<parent-session-id>") {
+    console.log(`pibo debug agents - inspect delegated child agents
+
+Usage:
+  pibo debug agents ${parentPiboSessionId} <command>
+
+Commands:
+  list      List child agents owned by the parent session.
+  observe   Read persisted child-agent observations.
+
+Next:
+  pibo debug agents ${parentPiboSessionId} list --help
+  pibo debug agents ${parentPiboSessionId} observe --help
+`);
+}
+function printDebugAgentsCommandHelp(parentPiboSessionId, command) {
+    if (command === "list") {
+        console.log(`pibo debug agents ${parentPiboSessionId} list
+
+Usage:
+  pibo debug agents ${parentPiboSessionId} list [--name name] [--status running|idle|killed] [--json]
+
+Filters use exact values. The command inspects only direct pibo.subagents children owned by the parent session.`);
+        return;
+    }
+    console.log(`pibo debug agents ${parentPiboSessionId} observe
+
+Usage:
+  pibo debug agents ${parentPiboSessionId} observe [--agent-id ps_...] [--name name] [--thread-key key]
+    [--event-type type] [--kind message|thinking|tool|error|lifecycle|event]
+    [--since iso] [--until iso] [--contains text] [--after-sequence n]
+    [--order asc|desc] [--limit 1..200] [--details] [--json]
+
+Repeat --agent-id, --name, --thread-key, --event-type, or --kind for OR within that field.
+Different fields combine with AND. With --after-sequence, pages always consume the oldest unseen rows;
+--order desc reverses only the returned page, so nextAfterSequence remains safe for polling.`);
+}
+function parseAgentDebugOptions(args) {
+    const parsed = { json: false, details: false, agentIds: [], names: [], threadKeys: [], eventTypes: [], kinds: [] };
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--json") {
+            parsed.json = true;
+            continue;
+        }
+        if (arg === "--details") {
+            parsed.details = true;
+            continue;
+        }
+        const value = args[index + 1];
+        if (!value)
+            throw new Error(`${arg} requires a value`);
+        if (arg === "--agent-id")
+            parsed.agentIds.push(value);
+        else if (arg === "--name")
+            parsed.names.push(value);
+        else if (arg === "--thread-key")
+            parsed.threadKeys.push(value);
+        else if (arg === "--event-type")
+            parsed.eventTypes.push(value);
+        else if (arg === "--kind") {
+            if (!["message", "thinking", "tool", "error", "lifecycle", "event"].includes(value))
+                throw new Error(`Invalid --kind "${value}"`);
+            parsed.kinds.push(value);
+        }
+        else if (arg === "--status") {
+            if (!["running", "idle", "killed"].includes(value))
+                throw new Error(`Invalid --status "${value}"`);
+            parsed.status = value;
+        }
+        else if (arg === "--since")
+            parsed.since = value;
+        else if (arg === "--until")
+            parsed.until = value;
+        else if (arg === "--contains")
+            parsed.textContains = value;
+        else if (arg === "--after-sequence")
+            parsed.afterSequence = parseNonNegativeInteger(value, arg);
+        else if (arg === "--order") {
+            if (value !== "asc" && value !== "desc")
+                throw new Error(`Invalid --order "${value}"`);
+            parsed.order = value;
+        }
+        else if (arg === "--limit")
+            parsed.limit = normalizePiboAgentObservationLimit(parseNonNegativeInteger(value, arg));
+        else
+            throw new Error(`Unknown pibo debug agents option "${arg}"`);
+        index += 1;
+    }
+    return parsed;
+}
+function validateAgentDebugOptions(command, parsed) {
+    if (command === "list") {
+        if (parsed.names.length > 1)
+            throw new Error("pibo debug agents list accepts at most one --name value");
+        if (parsed.details || parsed.agentIds.length > 0 || parsed.threadKeys.length > 0 || parsed.eventTypes.length > 0
+            || parsed.kinds.length > 0 || parsed.since !== undefined || parsed.until !== undefined
+            || parsed.textContains !== undefined || parsed.afterSequence !== undefined || parsed.order !== undefined
+            || parsed.limit !== undefined)
+            throw new Error("Unsupported option for pibo debug agents list. Run the list command with --help.");
+        return;
+    }
+    if (parsed.status !== undefined)
+        throw new Error("--status is supported only by pibo debug agents list");
+}
+function parseNonNegativeInteger(value, option) {
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed < 0)
+        throw new Error(`${option} requires a non-negative integer`);
+    return parsed;
+}

package/dist/debug/index.js

@@ -44,6 +44,11 @@ export async function runDebugCli(argv = process.argv) {
             await runDebugEvents(args.slice(1));
             return;
         }
+        if (args[0] === "agents") {
+            const { runDebugAgentsCli } = await import("./agents.js");
+            await runDebugAgentsCli(args.slice(1));
+            return;
+        }
         if (args[0] === "jobs") {
             await runDebugJobs(args.slice(1));
             return;
@@ -88,7 +93,8 @@ async function runDebugResources(args) {
     }
     const options = parseOptions(args);
     const { collectGatewayResourceSnapshot, renderGatewayResourceSnapshotText } = await import("../core/gateway-resource-guard.js");
-    const snapshot = await collectGatewayResourceSnapshot();
+    const { loadPiboGatewaySettings } = await import("../core/gateway-settings.js");
+    const snapshot = await collectGatewayResourceSnapshot({ gatewaySettings: loadPiboGatewaySettings() });
     if (options.json)
         console.log(JSON.stringify(snapshot, null, 2));
     else
@@ -1049,6 +1055,7 @@ Commands:
   final    Show the latest assistant message
   trace    Rebuild the Chat Web trace view for one Pibo Session
   events   Inspect compact event payload fields for one Pibo Session
+  agents   Inspect delegated child agents and their persisted activity
   tool     Inspect one grouped tool call
   failures List failed tool calls and trace/session errors
   jobs     Inspect durable Pibo jobs and DLQ
@@ -1066,6 +1073,7 @@ Next:
   pibo debug messages <pibo-session-id> list
   pibo debug trace <pibo-session-id> --running-only
   pibo debug events stream --topic pibo.output
+  pibo debug agents <parent-session-id> list
   pibo debug resources --json
   pibo debug signals tree ps_...
   pibo debug telemetry sessions --active
@@ -1088,9 +1096,13 @@ Environment:
   PIBO_GATEWAY_MIN_HEAP_AVAILABLE_BYTES=<bytes>
   PIBO_GATEWAY_MAX_RSS_BYTES=<bytes>
   PIBO_GATEWAY_KNOWN_DAEMON_WARNING_RSS_BYTES=<bytes>
-  PIBO_GATEWAY_MAX_CONCURRENT_YIELDED_RUNS=<count> (default: 1)
+  PIBO_GATEWAY_MAX_CONCURRENT_YIELDED_RUNS=<count> (default: 50)
+  PIBO_SESSION_CONCURRENT_YIELDED_RUNS=<count> (default: 10)
   PIBO_GATEWAY_YIELDED_RUN_MEMORY_RESERVATION_BYTES=<bytes> (default: 2147483648)
 
+Web settings:
+  Settings -> Concurrency persists overrides that apply to new yielded runs immediately.
+
 Next:
   pibo debug resources --json
   pibo compute health --json

package/dist/gateway/server.js

@@ -429,6 +429,8 @@ export class PiboGatewayServer {
             getProfiles: () => this.pluginRegistry.getProfileInfos(),
             createProfile: (name) => this.pluginRegistry.createProfile(name),
             getCapabilityCatalog: () => this.pluginRegistry.getCapabilityCatalog(),
+            getTranscriptionProviderInfos: () => this.pluginRegistry.getTranscriptionProviderInfos(),
+            transcribe: (providerId, input) => this.pluginRegistry.transcribe(providerId, input),
             inspectAgentRuntimeInstances: () => this.pluginRegistry.inspectAgentRuntimeInstances(),
             getAgentRuntimeAuthStatus: (runtimeInstanceId) => this.requireRouter().getAgentRuntimeAuthStatus(runtimeInstanceId),
             startAgentRuntimeAuth: (runtimeInstanceId, input) => this.requireRouter().startAgentRuntimeAuth(runtimeInstanceId, input),

package/dist/index.js

@@ -1,10 +1,15 @@
 export { createDefaultPiboProfile, createDefaultPiboPluginRegistry, createDefaultPiboPlugins, createGatewayProducerPiboPluginRegistry, createGatewayProducerPiboProfile, CODEX_NATIVE_PROFILE_NAME, CODEX_NATIVE_RUNTIME_INSTANCE_ID, piboCodexNativePlugin, OMP_PROFILE_NAME, OMP_RUNTIME_INSTANCE_ID, piboOmpPlugin, piboCorePlugin, piboGatewayProducerPlugin, } from "./plugins/builtin.js";
 export { createPiboBetterAuthPlugin } from "./plugins/better-auth.js";
 export { createPiboChatWebPlugin } from "./plugins/chat-web.js";
+export { createPiboOpenAiChatGptTranscriptionPlugin, piboOpenAiChatGptTranscriptionPlugin } from "./plugins/openai-chatgpt-transcription.js";
+export { createPiboOpenAiTranscriptionPlugin, piboOpenAiTranscriptionPlugin } from "./plugins/openai-transcription.js";
 export { createPiboContextFilesPlugin } from "./plugins/context-files.js";
 export { createPiboWebHostPlugin } from "./plugins/web.js";
 export { createChatWebApp } from "./apps/chat/web-app.js";
 export { createBetterAuthService } from "./auth/better-auth.js";
+export { DEFAULT_OPENAI_CHATGPT_TRANSCRIPTION_URL, DEFAULT_OPENAI_CHATGPT_USER_AGENT, OPENAI_CHATGPT_TRANSCRIPTION_PROVIDER_ID, OPENAI_CODEX_AUTH_PROVIDER_ID, createOpenAiChatGptTranscriptionProvider, } from "./transcription/openai-chatgpt.js";
+export { DEFAULT_OPENAI_TRANSCRIPTION_MODEL, DEFAULT_OPENAI_TRANSCRIPTION_URL, OPENAI_API_CREDENTIAL_PROVIDER_ID, OPENAI_TRANSCRIPTION_PROVIDER_ID, createOpenAiTranscriptionProvider, } from "./transcription/openai.js";
+export { PiboTranscriptionError } from "./transcription/types.js";
 export { DEFAULT_AGENT_RUNTIME_INSTANCE_ID, InitialSessionContext, InitialSessionContextBuilder, normalizeToolProfile, } from "./core/profiles.js";
 export { AgentRuntimeAdapterRegistry } from "./agent-runtime/registry.js";
 export { validateAgentRuntimeProfileCapabilities } from "./agent-runtime/profile-validation.js";
@@ -36,7 +41,7 @@ export { runGatewayClient } from "./gateway/client.js";
 export { LOCAL_TUI_CHANNEL_NAME, LocalRoutedTuiClient, createLocalRoutedTuiClient, createLocalRoutedTuiExtension, runLocalRoutedTui, } from "./local/tui.js";
 export { createWebHostChannel, DEFAULT_WEB_CHANNEL_HOST, DEFAULT_WEB_CHANNEL_PORT, WEB_CHANNEL_NAME } from "./web/channel.js";
 export { sendGatewayEvent, sendGatewayMessageAndWaitForReply } from "./gateway/request.js";
-export { createSubagentToolDefinitions, createSubagentToolName, } from "./subagents/tool.js";
+export { createAgentToolDefinitions, createSubagentToolDefinitions, createSubagentToolName, formatAvailableAgentsForPrompt, listAvailableAgents, PIBO_AGENT_TOOL_NAMES, } from "./subagents/tool.js";
 export { PiboSteeringUnavailableError } from "./core/events.js";
 export { RuntimeSessionBindingConflictError, RuntimeSessionBindingTransitionError, assertRuntimeSessionBindingTransition, createInitialRuntimeSessionBinding, createLegacyPiRuntimeSessionBinding, nextRuntimeSessionBinding, } from "./sessions/runtime-binding.js";
 export { InMemoryPiboSessionStore, createPiSessionId, createPiboSessionId, createPiboSession, } from "./sessions/store.js";

package/dist/plugins/builtin.js

@@ -13,6 +13,8 @@ import { piboCodexNativePlugin } from "./codex-native.js";
 import { addPiboNativeToolingContext, registerPiboNativeTooling } from "./native-tooling.js";
 import { piboWebAnnotationsPlugin } from "./web-annotations.js";
 import { piboOmpPlugin } from "./omp.js";
+import { piboOpenAiChatGptTranscriptionPlugin } from "./openai-chatgpt-transcription.js";
+import { piboOpenAiTranscriptionPlugin } from "./openai-transcription.js";
 import { definePiboPlugin, PiboPluginRegistry } from "./registry.js";
 import { PI_AGENT_RUNTIME_DRIVER } from "../agent-runtimes/pi/adapter.js";
 export { createDefaultPiboProfile, DEFAULT_PIBO_PROFILE_NAME } from "../core/default-profile.js";
@@ -589,11 +591,11 @@ export const piboGatewayProducerPlugin = definePiboPlugin({
     },
 });
 export function createDefaultPiboPlugins() {
-    return [piboCorePlugin, piboCodexNativePlugin, piboCodexCompatPlugin, piboWebAnnotationsPlugin, piboOmpPlugin];
+    return [piboCorePlugin, piboCodexNativePlugin, piboCodexCompatPlugin, piboWebAnnotationsPlugin, piboOmpPlugin, piboOpenAiChatGptTranscriptionPlugin, piboOpenAiTranscriptionPlugin];
 }
 export function createGatewayProducerPiboPluginRegistry() {
     return PiboPluginRegistry.create({
-        plugins: [piboCorePlugin, piboCodexNativePlugin, piboGatewayProducerPlugin, piboCodexCompatPlugin, piboWebAnnotationsPlugin, piboOmpPlugin],
+        plugins: [piboCorePlugin, piboCodexNativePlugin, piboGatewayProducerPlugin, piboCodexCompatPlugin, piboWebAnnotationsPlugin, piboOmpPlugin, piboOpenAiChatGptTranscriptionPlugin, piboOpenAiTranscriptionPlugin],
     });
 }
 export function createDefaultPiboPluginRegistry() {

package/dist/plugins/openai-chatgpt-transcription.js

@@ -0,0 +1,12 @@
+import { createOpenAiChatGptTranscriptionProvider, } from "../transcription/openai-chatgpt.js";
+import { definePiboPlugin } from "./registry.js";
+export function createPiboOpenAiChatGptTranscriptionPlugin(options = {}) {
+    return definePiboPlugin({
+        id: "pibo.transcription.openai-chatgpt",
+        name: "ChatGPT Subscription Transcription",
+        register(api) {
+            api.registerTranscriptionProvider(createOpenAiChatGptTranscriptionProvider(options));
+        },
+    });
+}
+export const piboOpenAiChatGptTranscriptionPlugin = createPiboOpenAiChatGptTranscriptionPlugin();

package/dist/plugins/openai-transcription.js

@@ -0,0 +1,12 @@
+import { createOpenAiTranscriptionProvider, } from "../transcription/openai.js";
+import { definePiboPlugin } from "./registry.js";
+export function createPiboOpenAiTranscriptionPlugin(options = {}) {
+    return definePiboPlugin({
+        id: "pibo.transcription.openai",
+        name: "OpenAI Transcription",
+        register(api) {
+            api.registerTranscriptionProvider(createOpenAiTranscriptionProvider(options));
+        },
+    });
+}
+export const piboOpenAiTranscriptionPlugin = createPiboOpenAiTranscriptionPlugin();

package/dist/plugins/registry.js

@@ -44,6 +44,7 @@ export class PiboPluginRegistry {
     gatewaySlashCommands = new Map();
     channels = new Map();
     authService;
+    transcriptionProviders = new Map();
     webApps = new Map();
     capabilityPackages = new Map();
     eventListeners = new Set();
@@ -181,6 +182,23 @@ export class PiboPluginRegistry {
         }
         this.authService = service;
     }
+    registerTranscriptionProvider(provider) {
+        this.addUnique(this.transcriptionProviders, provider.id, provider, "transcription provider");
+    }
+    async getTranscriptionProviderInfos() {
+        return await Promise.all([...this.transcriptionProviders.values()].map(async (provider) => ({
+            id: provider.id,
+            name: provider.name,
+            description: provider.description,
+            configured: provider.isConfigured ? await Promise.resolve(provider.isConfigured()).catch(() => false) : true,
+            pluginId: provider.pluginId,
+            pluginName: provider.pluginId ? this.pluginNames.get(provider.pluginId) : undefined,
+        })));
+    }
+    async transcribe(providerId, input) {
+        const provider = this.getRequired(this.transcriptionProviders, providerId, "transcription provider");
+        return { providerId, ...await provider.transcribe(input) };
+    }
     registerWebApp(app) {
         if (this.webApps.has(app.name)) {
             throw new Error(`Duplicate web app "${app.name}"`);
@@ -414,6 +432,10 @@ export class PiboPluginRegistry {
             toolNames: [...pkg.toolNames],
             pluginId: pkg.pluginId ?? pluginId,
         });
+        const withPluginTranscriptionProviderContext = (provider) => ({
+            ...provider,
+            pluginId: provider.pluginId ?? pluginId,
+        });
         return {
             registerAgentRuntimeDriver: (driver) => this.registerAgentRuntimeDriver(driver),
             registerAgentRuntimeInstance: (instance) => this.registerAgentRuntimeInstance(instance),
@@ -430,6 +452,7 @@ export class PiboPluginRegistry {
             registerGatewayAction: (action) => this.registerGatewayAction(action),
             registerChannel: (channel) => this.registerChannel(channel),
             registerAuthService: (service) => this.registerAuthService(service),
+            registerTranscriptionProvider: (provider) => this.registerTranscriptionProvider(withPluginTranscriptionProviderContext(provider)),
             registerWebApp: (app) => this.registerWebApp(app),
             registerCapabilityPackage: (pkg) => this.registerCapabilityPackage(withPluginPackageContext(pkg)),
             registerLoopStopCondition: (condition) => this.registerLoopStopCondition(condition, pluginId),

package/dist/session-ui/delegation.js

@@ -16,7 +16,8 @@ export function resolveAgentDelegationStatus(childSignal, fallbackStatus = "done
 }
 export function extractAgentDelegationName(input, title, summary) {
     const record = isRecord(input) ? input : undefined;
-    const rawName = stringValue(record?.subagentName)
+    const rawName = stringValue(record?.name)
+        ?? stringValue(record?.subagentName)
         ?? subagentNameFromToolName(title)
         ?? stringValue(summary)
         ?? stringValue(title)
@@ -68,10 +69,11 @@ function subagentNameFromToolName(value) {
     const name = nonEmpty(value);
     if (!name)
         return undefined;
-    return name.replace(/^pibo_subagent_/, "");
+    return name === "pibo_agents_send_message" ? undefined : name.replace(/^pibo_subagent_/, "");
 }
 function titleCaseAgentName(value) {
     return value
+        .replace(/^pibo_agents_send_message$/, "Agent")
         .replace(/^pibo_subagent_/, "")
         .split(/[\s_-]+/)
         .filter(Boolean)