@hyperdrive.bot/fleet-server 0.3.99

package/dist/server/server/agent/mcp-shared.d.ts

@@ -0,0 +1,239 @@
+import { z } from "zod";
+import type { Logger } from "pino";
+import type { AgentPermissionRequest } from "./agent-sdk-types.js";
+import type { AgentManager, ManagedAgent, WaitForAgentResult } from "./agent-manager.js";
+import type { AgentStorage } from "./agent-storage.js";
+import { StoredScheduleSchema } from "@hyperdrive.bot/fleet-protocol/schedule/types";
+import type { AgentProvider } from "./agent-sdk-types.js";
+export declare const AgentProviderEnum: z.ZodString;
+export declare const AgentStatusEnum: z.ZodEnum<{
+    error: "error";
+    running: "running";
+    idle: "idle";
+    initializing: "initializing";
+    closed: "closed";
+}>;
+export declare const ProviderModeSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    icon: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    colorTier: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$loose>;
+export declare const ProviderSummarySchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    modes: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        icon: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        colorTier: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$loose>>>>;
+}, z.core.$loose>;
+export declare const AgentSelectOptionSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    isDefault: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    metadata: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+}, z.core.$loose>;
+export declare const AgentModelSchema: z.ZodObject<{
+    provider: z.ZodString;
+    id: z.ZodString;
+    label: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    isDefault: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    metadata: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    thinkingOptions: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        isDefault: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        metadata: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    }, z.core.$loose>>>>;
+    defaultThinkingOptionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$loose>;
+export declare const AGENT_WAIT_TIMEOUT_MS = 30000;
+export interface ResolvedProviderModel {
+    provider: AgentProvider;
+    model: string | undefined;
+}
+export declare function resolveRequiredProviderModel(providerValue: string): Required<ResolvedProviderModel>;
+/**
+ * Wraps agentManager.waitForAgentEvent with a self-imposed timeout.
+ * Returns a friendly message when timeout occurs, rather than letting
+ * the SDK tool timeout trigger a generic "tool failed" error.
+ */
+export declare function waitForAgentWithTimeout(agentManager: AgentManager, agentId: string, options?: {
+    signal?: AbortSignal;
+    waitForActive?: boolean;
+}): Promise<WaitForAgentResult>;
+export declare function sanitizePermissionRequest(permission: AgentPermissionRequest): AgentPermissionRequest;
+export declare function sanitizePermissionRequest(permission: null | undefined): null;
+export declare function sanitizePermissionRequest(permission: AgentPermissionRequest | null | undefined): AgentPermissionRequest | null;
+export declare function resolveAgentTitle(agentStorage: AgentStorage, agentId: string, logger: Logger): Promise<string | null>;
+export declare function serializeSnapshotWithMetadata(agentStorage: AgentStorage, snapshot: ManagedAgent, logger: Logger): Promise<{
+    id: string;
+    provider: string;
+    cwd: string;
+    model: string | null;
+    createdAt: string;
+    updatedAt: string;
+    lastUserMessageAt: string | null;
+    status: "error" | "running" | "idle" | "initializing" | "closed";
+    capabilities: import("@hyperdrive.bot/fleet-protocol/agent-types").AgentCapabilityFlags;
+    currentModeId: string | null;
+    availableModes: import("@hyperdrive.bot/fleet-protocol/agent-types").AgentMode[];
+    pendingPermissions: import("@hyperdrive.bot/fleet-protocol/agent-types").AgentPermissionRequest[];
+    persistence: import("@hyperdrive.bot/fleet-protocol/agent-types").AgentPersistenceHandle | null;
+    title: string | null;
+    labels: Record<string, string>;
+    workspaceId?: string | undefined;
+    features?: ({
+        type: "toggle";
+        id: string;
+        label: string;
+        value: boolean;
+        description?: string | undefined;
+        tooltip?: string | undefined;
+        icon?: string | undefined;
+    } | {
+        type: "select";
+        id: string;
+        label: string;
+        value: string | null;
+        options: {
+            id: string;
+            label: string;
+            description?: string | undefined;
+            isDefault?: boolean | undefined;
+            metadata?: Record<string, unknown> | undefined;
+        }[];
+        description?: string | undefined;
+        tooltip?: string | undefined;
+        icon?: string | undefined;
+    })[] | undefined;
+    thinkingOptionId?: string | null | undefined;
+    effectiveThinkingOptionId?: string | null | undefined;
+    runtimeInfo?: import("@hyperdrive.bot/fleet-protocol/agent-types").AgentRuntimeInfo | undefined;
+    lastUsage?: import("@hyperdrive.bot/fleet-protocol/agent-types").AgentUsage | undefined;
+    lastError?: string | undefined;
+    digest?: {
+        goal?: string | undefined;
+        nextStep?: string | undefined;
+        blockers?: string[] | undefined;
+        links?: {
+            kind: "other" | "pr" | "mr" | "issue" | "deploy" | "preview" | "doc";
+            url: string;
+            label?: string | undefined;
+        }[] | undefined;
+        secrets?: {
+            label: string;
+            value: string;
+            masked: boolean;
+            source?: string | undefined;
+            discoveredAt?: string | undefined;
+        }[] | undefined;
+        keyFiles?: string[] | undefined;
+        summary?: string | undefined;
+        accomplishments?: string[] | undefined;
+        pendingDecisions?: {
+            id: string;
+            question: string;
+            options: {
+                id: string;
+                label: string;
+                detail?: string | undefined;
+                pros?: string[] | undefined;
+                cons?: string[] | undefined;
+                impact?: string | undefined;
+                recommended?: boolean | undefined;
+            }[];
+            askedAt: string;
+            context?: string | undefined;
+            blocking?: boolean | undefined;
+            urgency?: "low" | "normal" | "high" | undefined;
+            deadline?: string | undefined;
+            answeredAt?: string | undefined;
+            chosenOptionId?: string | undefined;
+            answerNote?: string | undefined;
+            answeredBy?: "agent" | "timeout" | "user" | undefined;
+        }[] | undefined;
+        selfReportedAt?: string | undefined;
+        generatedAt?: string | undefined;
+        derivedNextStep?: string | undefined;
+        derivedBlockers?: string[] | undefined;
+        urgency?: "low" | "normal" | "high" | undefined;
+        deadline?: string | undefined;
+        derivedDeadline?: string | undefined;
+    } | undefined;
+    requiresAttention?: boolean | undefined;
+    attentionReason?: "finished" | "error" | "permission" | null | undefined;
+    attentionTimestamp?: string | null | undefined;
+    archivedAt?: string | null | undefined;
+    activeBackgroundTaskCount?: number | undefined;
+    providerUnavailable?: boolean | undefined;
+    hasSystemPrompt?: boolean | undefined;
+    goal?: string | undefined;
+    jobToBeDone?: string | undefined;
+    allowedTools?: string[] | null | undefined;
+    mcpServerNames?: string[] | undefined;
+    nextFireAt?: string | null | undefined;
+    hasRoutine?: boolean | undefined;
+}>;
+export declare function parseDurationString(input: string): number;
+export declare function toScheduleSummary(schedule: z.infer<typeof StoredScheduleSchema>): {
+    id: string;
+    name: string | null;
+    prompt: string;
+    cadence: {
+        type: "every";
+        everyMs: number;
+    } | {
+        type: "cron";
+        expression: string;
+        timezone?: string | undefined;
+    } | {
+        type: "source";
+        sourceId: string;
+        filterId: string;
+        pollEveryMs?: number | undefined;
+    };
+    target: {
+        type: "agent";
+        agentId: string;
+    } | {
+        type: "new-agent";
+        config: {
+            provider: string;
+            cwd: string;
+            modeId?: string | undefined;
+            model?: string | undefined;
+            thinkingOptionId?: string | undefined;
+            title?: string | null | undefined;
+            approvalPolicy?: string | undefined;
+            sandboxMode?: string | undefined;
+            networkAccess?: boolean | undefined;
+            webSearch?: boolean | undefined;
+            featureValues?: Record<string, unknown> | undefined;
+            extra?: {
+                codex?: Record<string, unknown> | undefined;
+                claude?: Record<string, unknown> | undefined;
+            } | undefined;
+            systemPrompt?: string | undefined;
+            mcpServers?: Record<string, unknown> | undefined;
+        };
+    };
+    status: "completed" | "active" | "paused";
+    createdAt: string;
+    updatedAt: string;
+    nextRunAt: string | null;
+    lastRunAt: string | null;
+    pausedAt: string | null;
+    expiresAt: string | null;
+    maxRuns: number | null;
+};
+//# sourceMappingURL=mcp-shared.d.ts.map

package/dist/server/server/agent/mcp-shared.js

@@ -0,0 +1,200 @@
+import { z } from "zod";
+import { curateAgentActivity } from "./activity-curator.js";
+import { selectItemsByProjectedLimit } from "./timeline-projection.js";
+import { serializeAgentSnapshot } from "../messages.js";
+export const AgentProviderEnum = z.string();
+export const AgentStatusEnum = z.enum(["initializing", "idle", "running", "error", "closed"]);
+export const ProviderModeSchema = z
+    .object({
+    id: z.string(),
+    label: z.string().nullish(),
+    description: z.string().nullish(),
+    icon: z.string().nullish(),
+    colorTier: z.string().nullish(),
+})
+    .passthrough();
+export const ProviderSummarySchema = z
+    .object({
+    id: z.string(),
+    label: z.string().nullish(),
+    description: z.string().nullish(),
+    enabled: z.boolean().optional().default(true),
+    modes: z.array(ProviderModeSchema).nullish(),
+})
+    .passthrough();
+export const AgentSelectOptionSchema = z
+    .object({
+    id: z.string(),
+    label: z.string().nullish(),
+    description: z.string().nullish(),
+    isDefault: z.boolean().nullish(),
+    metadata: z.record(z.string(), z.unknown()).nullish(),
+})
+    .passthrough();
+export const AgentModelSchema = z
+    .object({
+    provider: z.string(),
+    id: z.string(),
+    label: z.string().nullish(),
+    description: z.string().nullish(),
+    isDefault: z.boolean().nullish(),
+    metadata: z.record(z.string(), z.unknown()).nullish(),
+    thinkingOptions: z.array(AgentSelectOptionSchema).nullish(),
+    defaultThinkingOptionId: z.string().nullish(),
+})
+    .passthrough();
+// 30 seconds - surface friendly message before SDK tool timeout (~60s)
+export const AGENT_WAIT_TIMEOUT_MS = 30000;
+export function resolveRequiredProviderModel(providerValue) {
+    const providerInput = providerValue.trim();
+    const slashIndex = providerInput.indexOf("/");
+    if (slashIndex <= 0 || slashIndex === providerInput.length - 1) {
+        throw new Error("provider must be provider/model, for example codex/gpt-5.4");
+    }
+    const provider = providerInput.slice(0, slashIndex).trim();
+    const model = providerInput.slice(slashIndex + 1).trim();
+    if (!provider || !model) {
+        throw new Error("provider must be provider/model, for example codex/gpt-5.4");
+    }
+    return {
+        provider: provider,
+        model,
+    };
+}
+/**
+ * Wraps agentManager.waitForAgentEvent with a self-imposed timeout.
+ * Returns a friendly message when timeout occurs, rather than letting
+ * the SDK tool timeout trigger a generic "tool failed" error.
+ */
+export async function waitForAgentWithTimeout(agentManager, agentId, options) {
+    const timeoutController = new AbortController();
+    const combinedController = new AbortController();
+    const timeoutId = setTimeout(() => {
+        timeoutController.abort(new Error("wait timeout"));
+    }, AGENT_WAIT_TIMEOUT_MS);
+    const forwardAbort = (reason) => {
+        if (!combinedController.signal.aborted) {
+            combinedController.abort(reason);
+        }
+    };
+    if (options?.signal) {
+        if (options.signal.aborted) {
+            forwardAbort(options.signal.reason);
+        }
+        else {
+            options.signal.addEventListener("abort", () => forwardAbort(options.signal.reason), {
+                once: true,
+            });
+        }
+    }
+    timeoutController.signal.addEventListener("abort", () => forwardAbort(timeoutController.signal.reason), { once: true });
+    try {
+        const result = await agentManager.waitForAgentEvent(agentId, {
+            signal: combinedController.signal,
+            waitForActive: options?.waitForActive,
+        });
+        return result;
+    }
+    catch (error) {
+        if (error instanceof Error && error.message === "wait timeout") {
+            const snapshot = agentManager.getAgent(agentId);
+            const timeline = agentManager.getTimeline(agentId);
+            const recent = selectItemsByProjectedLimit({
+                items: timeline,
+                direction: "tail",
+                limit: 5,
+            });
+            const recentActivity = curateAgentActivity(recent.items);
+            const waitedSeconds = Math.round(AGENT_WAIT_TIMEOUT_MS / 1000);
+            const message = `Awaiting the agent timed out after ${waitedSeconds}s. This does not mean the agent failed - call wait_for_agent again to continue waiting.\n\nRecent activity:\n${recentActivity}`;
+            return {
+                status: snapshot?.lifecycle ?? "idle",
+                permission: null,
+                lastMessage: message,
+            };
+        }
+        throw error;
+    }
+    finally {
+        clearTimeout(timeoutId);
+    }
+}
+export function sanitizePermissionRequest(permission) {
+    if (!permission) {
+        return null;
+    }
+    const sanitized = { ...permission };
+    if (sanitized.title === undefined) {
+        delete sanitized.title;
+    }
+    if (sanitized.description === undefined) {
+        delete sanitized.description;
+    }
+    if (sanitized.input === undefined) {
+        delete sanitized.input;
+    }
+    if (sanitized.detail === undefined) {
+        delete sanitized.detail;
+    }
+    if (sanitized.suggestions === undefined) {
+        delete sanitized.suggestions;
+    }
+    if (sanitized.actions === undefined) {
+        delete sanitized.actions;
+    }
+    if (sanitized.metadata === undefined) {
+        delete sanitized.metadata;
+    }
+    return sanitized;
+}
+export async function resolveAgentTitle(agentStorage, agentId, logger) {
+    try {
+        const record = await agentStorage.get(agentId);
+        return record?.title ?? null;
+    }
+    catch (error) {
+        logger.error({ err: error, agentId }, "Failed to load agent title");
+        return null;
+    }
+}
+export async function serializeSnapshotWithMetadata(agentStorage, snapshot, logger) {
+    const title = await resolveAgentTitle(agentStorage, snapshot.id, logger);
+    return serializeAgentSnapshot(snapshot, { title });
+}
+export function parseDurationString(input) {
+    const trimmed = input.trim();
+    if (/^\d+$/.test(trimmed)) {
+        return Number.parseInt(trimmed, 10) * 1000;
+    }
+    let totalMs = 0;
+    let hasMatch = false;
+    const regex = /(\d+)([smhd])/g;
+    let match;
+    while ((match = regex.exec(trimmed)) !== null) {
+        hasMatch = true;
+        const value = Number.parseInt(match[1], 10);
+        switch (match[2]) {
+            case "s":
+                totalMs += value * 1000;
+                break;
+            case "m":
+                totalMs += value * 60 * 1000;
+                break;
+            case "h":
+                totalMs += value * 60 * 60 * 1000;
+                break;
+            case "d":
+                totalMs += value * 24 * 60 * 60 * 1000;
+                break;
+        }
+    }
+    if (!hasMatch) {
+        throw new Error(`Invalid duration format: ${input}. Use formats like: 5m, 30s, 1h, 2h30m, 1d`);
+    }
+    return totalMs;
+}
+export function toScheduleSummary(schedule) {
+    const { runs: _runs, ...summary } = schedule;
+    return summary;
+}
+//# sourceMappingURL=mcp-shared.js.map

package/dist/server/server/agent/output-language.d.ts

@@ -0,0 +1,16 @@
+export declare const OUTPUT_LANGUAGE_BLOCK_START = "<paseo_output_language>";
+export declare const OUTPUT_LANGUAGE_BLOCK_END = "</paseo_output_language>";
+/**
+ * Build the instruction body for a language tag, without the wrapping block.
+ * Exported for tests that assert on the sentence rather than the markup.
+ */
+export declare function buildOutputLanguageInstruction(label: string, tag: string): string;
+/**
+ * Compose the output-language system-prompt block for a session.
+ *
+ * Returns undefined when no usable language is configured, so the caller can
+ * pass it straight into `composeSystemPromptParts` (which drops empty parts)
+ * and the pre-existing "model mirrors the user" behaviour is preserved.
+ */
+export declare function buildOutputLanguagePrompt(outputLanguage: string | null | undefined): string | undefined;
+//# sourceMappingURL=output-language.d.ts.map

package/dist/server/server/agent/output-language.js

@@ -0,0 +1,62 @@
+// Output-language instruction for the agent's system prompt.
+//
+// This is the leg that did not exist before: paseo could already be told which
+// language to TRANSCRIBE (`speech/providers/local/config.ts` resolves a per-mode
+// STT language), but nothing ever told the MODEL which language to answer in.
+// Without an instruction an LLM simply mirrors the language of the input, so
+// speaking Portuguese produced Portuguese replies even when the repo, the
+// commits and the docs are English.
+//
+// The block is composed at prompt-build time from the structured
+// `AgentSessionConfig.outputLanguage` field and appended alongside the user's
+// own system prompt, NOT stored inside it. That matters: voice mode rewrites
+// `systemPrompt` by regex every time it toggles (`stripVoiceModeSystemPrompt`
+// in voice-config.ts), so prose parked in that string is prose living in a
+// field another feature edits. Keeping the tag structured also lets the app
+// render "this agent works in English" without regex-parsing a prompt.
+//
+// Applies to every session and every transport, because it is composed inside
+// the shared `composeSystemPromptParts` call each provider already makes. For
+// the Claude provider that single call covers both the SDK transport and the
+// PTY transport (`agent.ts` feeds `buildAppendedSystemPrompt()` to both).
+import { isKnownLanguage, languageLabel, normalizeLanguageTag, } from "@hyperdrive.bot/fleet-protocol/language";
+export const OUTPUT_LANGUAGE_BLOCK_START = "<paseo_output_language>";
+export const OUTPUT_LANGUAGE_BLOCK_END = "</paseo_output_language>";
+/**
+ * Build the instruction body for a language tag, without the wrapping block.
+ * Exported for tests that assert on the sentence rather than the markup.
+ */
+export function buildOutputLanguageInstruction(label, tag) {
+    return [
+        `Write and speak all user-facing output in ${label}, BCP-47 language tag ${tag}.`,
+        "This applies to chat replies, spoken replies through the speak tool, questions you ask, summaries, and explanations.",
+        `Do this regardless of which language the user writes or speaks to you in: the user may deliberately speak a different language than the one they want back, so match ${label}, not their input.`,
+        "Leave code, identifiers, file paths, command output, quoted file contents, and commit messages exactly as they are; do not translate them.",
+    ].join(" ");
+}
+/**
+ * Compose the output-language system-prompt block for a session.
+ *
+ * Returns undefined when no usable language is configured, so the caller can
+ * pass it straight into `composeSystemPromptParts` (which drops empty parts)
+ * and the pre-existing "model mirrors the user" behaviour is preserved.
+ */
+export function buildOutputLanguagePrompt(outputLanguage) {
+    const tag = normalizeLanguageTag(outputLanguage);
+    // Gate on a NAMED language, not merely a well-shaped tag: a typo like
+    // "not-a-language" is shape-valid and would otherwise instruct the model to
+    // write everything in "not". No instruction beats a wrong one.
+    if (!tag || !isKnownLanguage(tag)) {
+        return undefined;
+    }
+    const label = languageLabel(tag);
+    if (!label) {
+        return undefined;
+    }
+    return [
+        OUTPUT_LANGUAGE_BLOCK_START,
+        buildOutputLanguageInstruction(label, tag),
+        OUTPUT_LANGUAGE_BLOCK_END,
+    ].join("\n");
+}
+//# sourceMappingURL=output-language.js.map

package/dist/server/server/agent/pcm16-resampler.d.ts

@@ -0,0 +1,14 @@
+export declare class Pcm16MonoResampler {
+    private readonly inputRate;
+    private readonly outputRate;
+    private readonly step;
+    private pos;
+    private carrySample;
+    constructor(params: {
+        inputRate: number;
+        outputRate: number;
+    });
+    reset(): void;
+    processChunk(pcm16le: Buffer): Buffer;
+}
+//# sourceMappingURL=pcm16-resampler.d.ts.map

package/dist/server/server/agent/pcm16-resampler.js

@@ -0,0 +1,63 @@
+export class Pcm16MonoResampler {
+    constructor(params) {
+        this.inputRate = params.inputRate;
+        this.outputRate = params.outputRate;
+        this.step = this.inputRate / this.outputRate;
+        this.pos = 0;
+        this.carrySample = null;
+    }
+    reset() {
+        this.pos = 0;
+        this.carrySample = null;
+    }
+    processChunk(pcm16le) {
+        if (pcm16le.length === 0) {
+            return Buffer.alloc(0);
+        }
+        if (pcm16le.length % 2 !== 0) {
+            throw new Error(`PCM16 chunk byteLength must be even, got ${pcm16le.length}`);
+        }
+        const srcChunk = new Int16Array(pcm16le.buffer, pcm16le.byteOffset, pcm16le.byteLength / 2);
+        const hasCarry = this.carrySample !== null;
+        const srcLen = srcChunk.length + (hasCarry ? 1 : 0);
+        if (srcLen < 2) {
+            this.carrySample = srcChunk.length ? srcChunk[srcChunk.length - 1] : this.carrySample;
+            return Buffer.alloc(0);
+        }
+        const src = new Float32Array(srcLen);
+        let offset = 0;
+        if (hasCarry) {
+            src[0] = this.carrySample / 32768;
+            offset = 1;
+        }
+        for (let i = 0; i < srcChunk.length; i += 1) {
+            src[offset + i] = srcChunk[i] / 32768;
+        }
+        const out = [];
+        const maxPos = src.length - 1;
+        while (this.pos < maxPos) {
+            const i = Math.floor(this.pos);
+            const frac = this.pos - i;
+            const s0 = src[i];
+            const s1 = src[i + 1];
+            const sample = s0 + (s1 - s0) * frac;
+            const clamped = Math.max(-1, Math.min(1, sample));
+            const int16 = Math.round(clamped * 32767);
+            out.push(int16);
+            this.pos += this.step;
+        }
+        // Keep the last input sample as carry for the next chunk.
+        const lastInput = srcChunk[srcChunk.length - 1];
+        this.carrySample = lastInput;
+        // Shift position so next chunk (which will include carry sample) continues smoothly.
+        const shift = src.length - 1;
+        this.pos = this.pos - shift;
+        if (this.pos < 0) {
+            // Guard against floating point drift.
+            this.pos = 0;
+        }
+        const outArr = Int16Array.from(out);
+        return Buffer.from(outArr.buffer, outArr.byteOffset, outArr.byteLength);
+    }
+}
+//# sourceMappingURL=pcm16-resampler.js.map

package/dist/server/server/agent/permission-response.d.ts

@@ -0,0 +1,15 @@
+import type { Logger } from "pino";
+import type { AgentPermissionResponse, AgentPermissionResult } from "./agent-sdk-types.js";
+import { type AgentRunController } from "./agent-prompt.js";
+export interface PermissionResponseAgentManager extends AgentRunController {
+    respondToPermission(agentId: string, requestId: string, response: AgentPermissionResponse): Promise<AgentPermissionResult | void>;
+}
+export interface RespondToAgentPermissionParams {
+    agentManager: PermissionResponseAgentManager;
+    agentId: string;
+    requestId: string;
+    response: AgentPermissionResponse;
+    logger: Logger;
+}
+export declare function respondToAgentPermission(params: RespondToAgentPermissionParams): Promise<void>;
+//# sourceMappingURL=permission-response.d.ts.map

package/dist/server/server/agent/permission-response.js

@@ -0,0 +1,14 @@
+import { startAgentRun } from "./agent-prompt.js";
+export async function respondToAgentPermission(params) {
+    const { agentManager, agentId, requestId, response, logger } = params;
+    logger.debug({ agentId, requestId }, `Handling permission response for agent ${agentId}, request ${requestId}`);
+    const result = await agentManager.respondToPermission(agentId, requestId, response);
+    logger.debug({ agentId }, `Permission response forwarded to agent ${agentId}`);
+    if (result?.followUpPrompt) {
+        logger.debug({ agentId }, "Permission response requires follow-up turn, starting agent stream");
+        startAgentRun(agentManager, agentId, result.followUpPrompt, logger, {
+            replaceRunning: true,
+        });
+    }
+}
+//# sourceMappingURL=permission-response.js.map

package/dist/server/server/agent/prompt-attachments.d.ts

@@ -0,0 +1,7 @@
+import type { AgentAttachment } from "@hyperdrive.bot/fleet-protocol/messages";
+export declare function renderPromptAttachmentAsText(attachment: AgentAttachment): string;
+export declare function buildAgentBranchNameSeed(firstAgentContext: {
+    prompt?: string;
+    attachments?: readonly AgentAttachment[];
+} | undefined): string | undefined;
+//# sourceMappingURL=prompt-attachments.d.ts.map