@hyperdrive.bot/paseo-server 0.2.6

package/dist/server/server/agent/session-digest-generator.d.ts

@@ -0,0 +1,37 @@
+import type { Logger } from "pino";
+import type { AgentManager } from "./agent-manager.js";
+import { generateStructuredAgentResponseWithFallback } from "./agent-response-loop.js";
+import { type StructuredGenerationDaemonConfig } from "./structured-generation-providers.js";
+import type { ProviderSnapshotManager } from "./provider-snapshot-manager.js";
+/**
+ * Daemon-side digest refresh. Triggered on the running→idle transition: derives
+ * keyFiles deterministically and generates summary/accomplishments via the same
+ * borrowed-provider rail that powers auto-title generation (no daemon API key).
+ * Self-reported fields (goal/nextStep/blockers/links) are preserved by the
+ * merge. See docs/session-digest.md §4.3 + §5.
+ */
+export interface SessionDigestGeneratorDeps {
+    generateStructuredAgentResponseWithFallback?: typeof generateStructuredAgentResponseWithFallback;
+}
+export interface SessionDigestRefreshOptions {
+    agentManager: AgentManager;
+    agentId: string;
+    cwd: string;
+    providerSnapshotManager?: Pick<ProviderSnapshotManager, "listProviders">;
+    daemonConfig?: StructuredGenerationDaemonConfig | null;
+    currentSelection?: {
+        provider?: string | null;
+        model?: string | null;
+        thinkingOptionId?: string | null;
+    };
+    logger: Logger;
+    deps?: SessionDigestGeneratorDeps;
+}
+export declare function generateAndApplySessionDigest(options: SessionDigestRefreshOptions): Promise<void>;
+/**
+ * Fire-and-forget, debounced digest refresh. Safe to call on every running→idle
+ * transition — coalesces concurrent calls and skips if refreshed within the
+ * debounce window.
+ */
+export declare function scheduleSessionDigestRefresh(options: SessionDigestRefreshOptions): void;
+//# sourceMappingURL=session-digest-generator.d.ts.map

package/dist/server/server/agent/session-digest-generator.js

@@ -0,0 +1,115 @@
+import { z } from "zod";
+import { StructuredAgentFallbackError, StructuredAgentResponseError, generateStructuredAgentResponseWithFallback, } from "./agent-response-loop.js";
+import { resolveStructuredGenerationProviders, } from "./structured-generation-providers.js";
+import { buildDigestSourceText, deriveKeyFilesFromTimeline, mergeDigest, } from "./session-digest.js";
+const SUMMARY_MAX_CHARS = 600;
+const ACCOMPLISHMENT_MAX = 10;
+const DIGEST_SUMMARY_SCHEMA = z.object({
+    summary: z.string().max(SUMMARY_MAX_CHARS),
+    accomplishments: z.array(z.string()).max(ACCOMPLISHMENT_MAX),
+});
+// Debounce: `idle` fires on every pause for input, so cap LLM regeneration at
+// one pass per window per agent and never run two concurrently. keyFiles is
+// deterministic + cheap and refreshes on every call. See docs/session-digest.md §5.
+const DIGEST_DEBOUNCE_MS = 10 * 60 * 1000;
+const lastDigestAt = new Map();
+const inFlight = new Set();
+function buildDigestPrompt(sourceText) {
+    return [
+        "You are summarizing a coding agent session so an orchestrator can understand it",
+        "without reading the full transcript. Return JSON with exactly two fields:",
+        `- summary: one paragraph (<= ${SUMMARY_MAX_CHARS} chars) describing what this session`,
+        "  is doing and its current state.",
+        `- accomplishments: up to ${ACCOMPLISHMENT_MAX} short strings, each a concrete thing done`,
+        "  (file changed, feature added, bug fixed). Be specific and factual; do not invent.",
+        "",
+        "Session transcript:",
+        sourceText,
+    ].join("\n");
+}
+export async function generateAndApplySessionDigest(options) {
+    const { agentManager, agentId, cwd, logger } = options;
+    const rows = await agentManager.getTimelineRows(agentId);
+    if (rows.length === 0) {
+        return;
+    }
+    // Deterministic, no LLM — always safe to refresh.
+    const keyFiles = deriveKeyFilesFromTimeline(rows);
+    const existing = agentManager.getAgent(agentId)?.digest;
+    let summaryPatch = {};
+    const sourceText = buildDigestSourceText(rows);
+    if (sourceText.trim().length > 0) {
+        const generator = options.deps?.generateStructuredAgentResponseWithFallback ??
+            generateStructuredAgentResponseWithFallback;
+        try {
+            const providers = options.providerSnapshotManager
+                ? await resolveStructuredGenerationProviders({
+                    cwd,
+                    providerSnapshotManager: options.providerSnapshotManager,
+                    daemonConfig: options.daemonConfig,
+                    currentSelection: options.currentSelection,
+                })
+                : [];
+            const result = await generator({
+                manager: agentManager,
+                cwd,
+                prompt: buildDigestPrompt(sourceText),
+                schema: DIGEST_SUMMARY_SCHEMA,
+                schemaName: "SessionDigestSummary",
+                maxRetries: 2,
+                providers,
+                persistSession: false,
+                logger,
+                agentConfigOverrides: {
+                    title: "Session digest generator",
+                    internal: true,
+                },
+            });
+            summaryPatch = {
+                summary: result.summary,
+                accomplishments: result.accomplishments,
+            };
+        }
+        catch (error) {
+            const attempts = error instanceof StructuredAgentFallbackError ? error.attempts : undefined;
+            logger.error({ err: error, agentId, attempts }, error instanceof StructuredAgentResponseError ||
+                error instanceof StructuredAgentFallbackError
+                ? "Session digest summary generation failed"
+                : "Session digest generation failed");
+            // Fall through — still persist the deterministic keyFiles + timestamp.
+        }
+    }
+    const next = mergeDigest(existing, {
+        keyFiles,
+        generatedAt: new Date().toISOString(),
+        ...summaryPatch,
+    });
+    await agentManager.updateAgentMetadata(agentId, { digest: next });
+}
+/**
+ * Fire-and-forget, debounced digest refresh. Safe to call on every running→idle
+ * transition — coalesces concurrent calls and skips if refreshed within the
+ * debounce window.
+ */
+export function scheduleSessionDigestRefresh(options) {
+    const { agentId } = options;
+    if (inFlight.has(agentId)) {
+        return;
+    }
+    const now = Date.now();
+    if (now - (lastDigestAt.get(agentId) ?? 0) < DIGEST_DEBOUNCE_MS) {
+        return;
+    }
+    lastDigestAt.set(agentId, now);
+    inFlight.add(agentId);
+    queueMicrotask(() => {
+        void generateAndApplySessionDigest(options)
+            .catch((error) => {
+            options.logger.error({ err: error, agentId }, "Session digest refresh crashed");
+        })
+            .finally(() => {
+            inFlight.delete(agentId);
+        });
+    });
+}
+//# sourceMappingURL=session-digest-generator.js.map

package/dist/server/server/agent/session-digest.d.ts

@@ -0,0 +1,35 @@
+import type { SessionDigest } from "../messages.js";
+import type { AgentTimelineItem } from "./agent-sdk-types.js";
+/**
+ * Pure helpers for the session digest feature. Kept free of I/O so they are
+ * trivially unit-testable. See docs/session-digest.md.
+ */
+export interface DigestTimelineRow {
+    item: AgentTimelineItem;
+}
+/**
+ * Deterministically derive the touched-files list from an agent's timeline —
+ * the filePath of every edit/write tool call, most-recently-touched first,
+ * de-duplicated, capped. No LLM, cannot drift from what the agent actually did.
+ * See docs/session-digest.md §4.2.
+ */
+export declare function deriveKeyFilesFromTimeline(rows: readonly DigestTimelineRow[], max?: number): string[];
+/**
+ * Assemble a compact transcript from the timeline for the digest summary LLM
+ * pass — user/assistant messages plus a one-line note per notable tool call.
+ * Keeps the most-recent tail within maxChars so the prompt stays bounded.
+ */
+export declare function buildDigestSourceText(rows: readonly DigestTimelineRow[], maxChars?: number): string;
+/**
+ * Merge a digest patch onto an existing digest, dropping undefined keys so a
+ * partial update never clobbers fields it doesn't set. Self-reported fields
+ * (goal/nextStep/blockers/links) and daemon-derived fields (keyFiles/summary/
+ * accomplishments) own disjoint keys, so the merge is conflict-free.
+ */
+export declare function mergeDigest(existing: SessionDigest | undefined, patch: Partial<SessionDigest>): SessionDigest;
+/**
+ * True when a digest carries no meaningful content (all fields empty/absent).
+ * Used to avoid emitting empty digest objects.
+ */
+export declare function isDigestEmpty(digest: SessionDigest | undefined): boolean;
+//# sourceMappingURL=session-digest.d.ts.map

package/dist/server/server/agent/session-digest.js

@@ -0,0 +1,104 @@
+const MAX_KEY_FILES = 20;
+const DEFAULT_TRANSCRIPT_MAX_CHARS = 6000;
+/**
+ * Deterministically derive the touched-files list from an agent's timeline —
+ * the filePath of every edit/write tool call, most-recently-touched first,
+ * de-duplicated, capped. No LLM, cannot drift from what the agent actually did.
+ * See docs/session-digest.md §4.2.
+ */
+export function deriveKeyFilesFromTimeline(rows, max = MAX_KEY_FILES) {
+    const seen = new Set();
+    const ordered = [];
+    for (let i = rows.length - 1; i >= 0; i--) {
+        const item = rows[i].item;
+        if (item.type !== "tool_call") {
+            continue;
+        }
+        const detail = item.detail;
+        if (detail.type !== "edit" && detail.type !== "write") {
+            continue;
+        }
+        const filePath = detail.filePath;
+        if (filePath.length === 0 || seen.has(filePath)) {
+            continue;
+        }
+        seen.add(filePath);
+        ordered.push(filePath);
+        if (ordered.length >= max) {
+            break;
+        }
+    }
+    return ordered;
+}
+/**
+ * Assemble a compact transcript from the timeline for the digest summary LLM
+ * pass — user/assistant messages plus a one-line note per notable tool call.
+ * Keeps the most-recent tail within maxChars so the prompt stays bounded.
+ */
+export function buildDigestSourceText(rows, maxChars = DEFAULT_TRANSCRIPT_MAX_CHARS) {
+    const lines = [];
+    for (const { item } of rows) {
+        if (item.type === "user_message") {
+            const text = item.text.trim();
+            if (text) {
+                lines.push(`User: ${text}`);
+            }
+        }
+        else if (item.type === "assistant_message") {
+            const text = item.text.trim();
+            if (text) {
+                lines.push(`Assistant: ${text}`);
+            }
+        }
+        else if (item.type === "tool_call") {
+            const detail = item.detail;
+            if (detail.type === "edit") {
+                lines.push(`[edited ${detail.filePath}]`);
+            }
+            else if (detail.type === "write") {
+                lines.push(`[wrote ${detail.filePath}]`);
+            }
+            else if (detail.type === "shell") {
+                lines.push(`[ran: ${detail.command}]`);
+            }
+        }
+    }
+    const joined = lines.join("\n");
+    if (joined.length <= maxChars) {
+        return joined;
+    }
+    // Keep the most-recent tail — that's where the current state lives.
+    return joined.slice(joined.length - maxChars);
+}
+/**
+ * Merge a digest patch onto an existing digest, dropping undefined keys so a
+ * partial update never clobbers fields it doesn't set. Self-reported fields
+ * (goal/nextStep/blockers/links) and daemon-derived fields (keyFiles/summary/
+ * accomplishments) own disjoint keys, so the merge is conflict-free.
+ */
+export function mergeDigest(existing, patch) {
+    const merged = { ...existing };
+    for (const [key, value] of Object.entries(patch)) {
+        if (value !== undefined) {
+            merged[key] = value;
+        }
+    }
+    return merged;
+}
+/**
+ * True when a digest carries no meaningful content (all fields empty/absent).
+ * Used to avoid emitting empty digest objects.
+ */
+export function isDigestEmpty(digest) {
+    if (!digest) {
+        return true;
+    }
+    return (!digest.goal &&
+        !digest.nextStep &&
+        !digest.summary &&
+        (digest.blockers?.length ?? 0) === 0 &&
+        (digest.links?.length ?? 0) === 0 &&
+        (digest.keyFiles?.length ?? 0) === 0 &&
+        (digest.accomplishments?.length ?? 0) === 0);
+}
+//# sourceMappingURL=session-digest.js.map

package/dist/server/server/agent/structured-generation-providers.d.ts

@@ -0,0 +1,29 @@
+import type { AgentProvider } from "./agent-sdk-types.js";
+import type { StructuredGenerationProvider } from "./agent-response-loop.js";
+import type { ProviderSnapshotManager } from "./provider-snapshot-manager.js";
+export interface StructuredGenerationDaemonConfig {
+    metadataGeneration?: {
+        providers?: Array<{
+            provider: string;
+            model?: string;
+            thinkingOptionId?: string;
+        }>;
+    };
+}
+export interface StructuredGenerationProviderIdentifier {
+    modelSubstring: string;
+    thinkingOptionId?: string;
+}
+export declare const DEFAULT_STRUCTURED_GENERATION_PROVIDERS: readonly StructuredGenerationProviderIdentifier[];
+export interface ResolveStructuredGenerationProvidersOptions {
+    cwd: string;
+    providerSnapshotManager: Pick<ProviderSnapshotManager, "listProviders">;
+    daemonConfig?: StructuredGenerationDaemonConfig | null;
+    currentSelection?: {
+        provider?: AgentProvider | null;
+        model?: string | null;
+        thinkingOptionId?: string | null;
+    };
+}
+export declare function resolveStructuredGenerationProviders(options: ResolveStructuredGenerationProvidersOptions): Promise<StructuredGenerationProvider[]>;
+//# sourceMappingURL=structured-generation-providers.d.ts.map

package/dist/server/server/agent/structured-generation-providers.js

@@ -0,0 +1,236 @@
+export const DEFAULT_STRUCTURED_GENERATION_PROVIDERS = [
+    { modelSubstring: "haiku" },
+    { modelSubstring: "gpt-5.4-mini", thinkingOptionId: "low" },
+    { modelSubstring: "minimax-m2.5" },
+    { modelSubstring: "nemotron-3-super" },
+];
+export async function resolveStructuredGenerationProviders(options) {
+    const configuredProviders = readConfiguredProviders(options.daemonConfig);
+    if (configuredProviders.length > 0) {
+        const explicitProviders = resolveExplicitConfiguredProviders(configuredProviders);
+        if (explicitProviders.length === configuredProviders.length) {
+            return dedupeProviders(explicitProviders);
+        }
+        const providerEntries = await options.providerSnapshotManager.listProviders({
+            cwd: options.cwd,
+            wait: false,
+        });
+        const providers = resolveConfiguredProviders(configuredProviders, providerEntries);
+        if (providers.length > 0) {
+            return dedupeProviders(providers);
+        }
+    }
+    const providerEntries = await options.providerSnapshotManager.listProviders({
+        cwd: options.cwd,
+        wait: true,
+    });
+    const enabledEntries = providerEntries.filter((entry) => entry.enabled);
+    const modelEntries = enabledEntries.filter((entry) => (entry.models?.length ?? 0) > 0);
+    const entriesByProvider = new Map(enabledEntries.map((entry) => [entry.provider, entry]));
+    const providers = [];
+    for (const configured of configuredProviders) {
+        const resolvedConfigured = resolveConfiguredCandidate(configured, modelEntries, entriesByProvider);
+        if (!resolvedConfigured) {
+            continue;
+        }
+        providers.push(resolvedConfigured);
+    }
+    for (const identifier of DEFAULT_STRUCTURED_GENERATION_PROVIDERS) {
+        const resolved = resolveByModelSubstring(modelEntries, identifier);
+        if (resolved) {
+            providers.push(resolved);
+        }
+    }
+    const currentSelection = resolveCurrentSelection(options.currentSelection, modelEntries, entriesByProvider);
+    if (currentSelection) {
+        providers.push(currentSelection);
+    }
+    return dedupeProviders(providers);
+}
+function resolveConfiguredProviders(configuredProviders, providerEntries) {
+    const enabledEntries = providerEntries.filter((entry) => entry.enabled);
+    const modelEntries = enabledEntries.filter((entry) => (entry.models?.length ?? 0) > 0);
+    const entriesByProvider = new Map(enabledEntries.map((entry) => [entry.provider, entry]));
+    const providers = [];
+    for (const configured of configuredProviders) {
+        const resolved = resolveConfiguredCandidate(configured, modelEntries, entriesByProvider);
+        if (resolved) {
+            providers.push(resolved);
+        }
+    }
+    return providers;
+}
+function resolveExplicitConfiguredProviders(configuredProviders) {
+    const providers = [];
+    for (const configured of configuredProviders) {
+        const provider = configured.provider.trim();
+        const model = configured.model?.trim();
+        if (!provider || !model) {
+            continue;
+        }
+        providers.push({
+            provider,
+            model,
+            ...(configured.thinkingOptionId ? { thinkingOptionId: configured.thinkingOptionId } : {}),
+        });
+    }
+    return providers;
+}
+function resolveCurrentSelection(selection, readyEntries, entriesByProvider) {
+    if (!selection) {
+        return null;
+    }
+    const provider = selection.provider?.trim();
+    if (!provider) {
+        return null;
+    }
+    const normalized = resolveConfiguredCandidate({
+        provider,
+        ...(selection.model ? { model: selection.model } : {}),
+        ...(selection.thinkingOptionId ? { thinkingOptionId: selection.thinkingOptionId } : {}),
+    }, readyEntries, entriesByProvider);
+    if (normalized) {
+        return normalized;
+    }
+    const explicitModel = selection.model?.trim();
+    if (explicitModel) {
+        return {
+            provider,
+            model: explicitModel,
+            ...(selection.thinkingOptionId ? { thinkingOptionId: selection.thinkingOptionId } : {}),
+        };
+    }
+    const model = selectDefaultModel(entriesByProvider.get(provider)?.models ?? []);
+    if (!model) {
+        return { provider };
+    }
+    const thinkingOptionId = resolveThinkingOptionId(model, selection.thinkingOptionId);
+    return {
+        provider,
+        model: model.id,
+        ...(thinkingOptionId ? { thinkingOptionId } : {}),
+    };
+}
+function resolveConfiguredCandidate(candidate, readyEntries, entriesByProvider) {
+    const provider = candidate.provider.trim();
+    if (!provider) {
+        return null;
+    }
+    const topLevelEntry = entriesByProvider.get(provider);
+    const configuredModel = candidate.model?.trim();
+    if (topLevelEntry) {
+        if (configuredModel) {
+            return {
+                provider,
+                model: configuredModel,
+                ...(candidate.thinkingOptionId ? { thinkingOptionId: candidate.thinkingOptionId } : {}),
+            };
+        }
+        const model = selectDefaultModel(topLevelEntry.models ?? []);
+        const thinkingOptionId = resolveThinkingOptionId(model, candidate.thinkingOptionId);
+        return {
+            provider,
+            ...(model ? { model: model.id } : {}),
+            ...(thinkingOptionId ? { thinkingOptionId } : {}),
+        };
+    }
+    if (!configuredModel) {
+        return {
+            provider,
+            ...(candidate.thinkingOptionId ? { thinkingOptionId: candidate.thinkingOptionId } : {}),
+        };
+    }
+    const nestedMatch = resolveNestedProviderModel(provider, configuredModel, readyEntries);
+    if (!nestedMatch) {
+        return {
+            provider,
+            model: configuredModel,
+            ...(candidate.thinkingOptionId ? { thinkingOptionId: candidate.thinkingOptionId } : {}),
+        };
+    }
+    const thinkingOptionId = resolveThinkingOptionId(nestedMatch.model, candidate.thinkingOptionId);
+    return {
+        provider: nestedMatch.provider,
+        model: nestedMatch.model.id,
+        ...(thinkingOptionId ? { thinkingOptionId } : {}),
+    };
+}
+function resolveNestedProviderModel(providerId, modelId, entries) {
+    const normalizedProviderId = providerId.trim().toLowerCase();
+    const normalizedModelId = modelId.trim().toLowerCase();
+    for (const entry of entries) {
+        for (const model of entry.models ?? []) {
+            const modelProviderId = readModelMetadataString(model, "providerId")?.toLowerCase();
+            const nestedModelId = readModelMetadataString(model, "modelId")?.toLowerCase();
+            if (modelProviderId !== normalizedProviderId) {
+                continue;
+            }
+            if (normalizedModelId === model.id.toLowerCase() ||
+                normalizedModelId === nestedModelId ||
+                model.id.toLowerCase() === `${normalizedProviderId}/${normalizedModelId}`) {
+                return { provider: entry.provider, model };
+            }
+        }
+    }
+    return null;
+}
+function resolveByModelSubstring(entries, identifier) {
+    const needle = identifier.modelSubstring.trim().toLowerCase();
+    if (!needle) {
+        return null;
+    }
+    for (const entry of entries) {
+        for (const model of entry.models ?? []) {
+            const haystacks = [model.id, model.label].map((value) => value.toLowerCase());
+            if (!haystacks.some((value) => value.includes(needle))) {
+                continue;
+            }
+            const thinkingOptionId = resolveThinkingOptionId(model, identifier.thinkingOptionId);
+            return {
+                provider: entry.provider,
+                model: model.id,
+                ...(thinkingOptionId ? { thinkingOptionId } : {}),
+            };
+        }
+    }
+    return null;
+}
+function readConfiguredProviders(daemonConfig) {
+    const metadataGeneration = daemonConfig?.metadataGeneration;
+    if (!metadataGeneration || typeof metadataGeneration !== "object") {
+        return [];
+    }
+    const providers = "providers" in metadataGeneration ? metadataGeneration.providers : undefined;
+    return Array.isArray(providers) ? providers : [];
+}
+function selectDefaultModel(models) {
+    return models.find((model) => model.isDefault) ?? models[0] ?? null;
+}
+function resolveThinkingOptionId(model, preferredThinkingOptionId) {
+    if (!model) {
+        return undefined;
+    }
+    if (preferredThinkingOptionId &&
+        model.thinkingOptions?.some((option) => option.id === preferredThinkingOptionId)) {
+        return preferredThinkingOptionId;
+    }
+    return model.defaultThinkingOptionId;
+}
+function dedupeProviders(providers) {
+    const seen = new Set();
+    const deduped = [];
+    for (const provider of providers) {
+        const key = [provider.provider, provider.model ?? "", provider.thinkingOptionId ?? ""].join("\0");
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        deduped.push(provider);
+    }
+    return deduped;
+}
+function readModelMetadataString(model, key) {
+    const value = model.metadata?.[key];
+    return typeof value === "string" && value.trim().length > 0 ? value : undefined;
+}
+//# sourceMappingURL=structured-generation-providers.js.map

package/dist/server/server/agent/stt-debug.d.ts

@@ -0,0 +1,10 @@
+import type pino from "pino";
+export interface DebugAudioMetadata {
+    sessionId: string;
+    agentId?: string;
+    requestId?: string;
+    label?: string;
+    format: string;
+}
+export declare function maybePersistDebugAudio(audio: Buffer, metadata: DebugAudioMetadata, logger: pino.Logger): Promise<string | null>;
+//# sourceMappingURL=stt-debug.d.ts.map

package/dist/server/server/agent/stt-debug.js

@@ -0,0 +1,33 @@
+import { mkdir, writeFile } from "fs/promises";
+import { join } from "path";
+import { inferAudioExtension, sanitizeForFilename } from "./audio-utils.js";
+import { resolveRecordingsDebugDir } from "./recordings-debug.js";
+const debugDir = resolveRecordingsDebugDir("STT_DEBUG_AUDIO_DIR");
+let announced = false;
+export async function maybePersistDebugAudio(audio, metadata, logger) {
+    if (!debugDir) {
+        return null;
+    }
+    if (!announced) {
+        logger.info({ debugDir }, "Raw audio capture enabled");
+        announced = true;
+    }
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const folder = join(debugDir, sanitizeForFilename(metadata.sessionId, "session"));
+    await mkdir(folder, { recursive: true });
+    const parts = [timestamp];
+    if (metadata.agentId) {
+        parts.push(sanitizeForFilename(metadata.agentId, "agent"));
+    }
+    if (metadata.label) {
+        parts.push(sanitizeForFilename(metadata.label, "source"));
+    }
+    if (metadata.requestId) {
+        parts.push(sanitizeForFilename(metadata.requestId, "request"));
+    }
+    const ext = inferAudioExtension(metadata.format);
+    const filePath = join(folder, `${parts.join("_")}.${ext}`);
+    await writeFile(filePath, audio);
+    return filePath;
+}
+//# sourceMappingURL=stt-debug.js.map

package/dist/server/server/agent/stt-manager.d.ts

@@ -0,0 +1,38 @@
+import type pino from "pino";
+import type { SpeechToTextProvider, TranscriptionResult } from "../speech/speech-provider.js";
+import { type Resolvable } from "../speech/provider-resolver.js";
+interface TranscriptionMetadata {
+    agentId?: string;
+    requestId?: string;
+    label?: string;
+}
+export interface SessionTranscriptionResult extends TranscriptionResult {
+    debugRecordingPath?: string;
+    byteLength: number;
+    format: string;
+}
+export interface STTManagerOptions {
+    language?: string;
+}
+/**
+ * Per-session STT manager
+ * Handles speech-to-text transcription
+ */
+export declare class STTManager {
+    private readonly sessionId;
+    private readonly logger;
+    private readonly resolveStt;
+    private readonly language;
+    constructor(sessionId: string, logger: pino.Logger, stt: Resolvable<SpeechToTextProvider | null>, options?: STTManagerOptions);
+    getProvider(): SpeechToTextProvider | null;
+    /**
+     * Transcribe audio buffer to text
+     */
+    transcribe(audio: Buffer, format: string, metadata?: TranscriptionMetadata): Promise<SessionTranscriptionResult>;
+    /**
+     * Cleanup (currently no-op, but provides extension point)
+     */
+    cleanup(): void;
+}
+export {};
+//# sourceMappingURL=stt-manager.d.ts.map