@bytetrue/byspace 0.1.0

package/node_modules/@bytetrue/byspace-server/dist/server/server/agent/mcp-shared.d.ts

@@ -0,0 +1,179 @@
+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 "@bytetrue/byspace-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";
+    idle: "idle";
+    running: "running";
+    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" | "idle" | "running" | "initializing" | "closed";
+    capabilities: import("@bytetrue/byspace-protocol/agent-types").AgentCapabilityFlags;
+    currentModeId: string | null;
+    availableModes: import("@bytetrue/byspace-protocol/agent-types").AgentMode[];
+    pendingPermissions: import("@bytetrue/byspace-protocol/agent-types").AgentPermissionRequest[];
+    persistence: import("@bytetrue/byspace-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("@bytetrue/byspace-protocol/agent-types").AgentRuntimeInfo | undefined;
+    lastUsage?: import("@bytetrue/byspace-protocol/agent-types").AgentUsage | undefined;
+    lastError?: string | undefined;
+    requiresAttention?: boolean | undefined;
+    attentionReason?: "finished" | "error" | "permission" | null | undefined;
+    attentionTimestamp?: string | null | undefined;
+    archivedAt?: string | null | undefined;
+    providerUnavailable?: 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;
+    };
+    target: {
+        type: "agent";
+        agentId: string;
+    } | {
+        type: "new-agent";
+        config: {
+            provider: string;
+            cwd: string;
+            modeId?: string | undefined;
+            model?: string | undefined;
+            thinkingOptionId?: string | undefined;
+            archiveOnFinish?: boolean | undefined;
+            isolation?: "worktree" | "local" | 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/node_modules/@bytetrue/byspace-server/dist/server/server/agent/mcp-shared.js

@@ -0,0 +1,197 @@
+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 - it is still running. Call get_agent_status to check on it, or continue with other work if you will receive a finish notification.\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+)([smh])/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;
+        }
+    }
+    if (!hasMatch) {
+        throw new Error(`Invalid duration format: ${input}. Use formats like: 5m, 30s, 1h, 2h30m`);
+    }
+    return totalMs;
+}
+export function toScheduleSummary(schedule) {
+    const { runs: _runs, ...summary } = schedule;
+    return summary;
+}
+//# sourceMappingURL=mcp-shared.js.map

package/node_modules/@bytetrue/byspace-server/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/node_modules/@bytetrue/byspace-server/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/node_modules/@bytetrue/byspace-server/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/node_modules/@bytetrue/byspace-server/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");
+        await startAgentRun(agentManager, agentId, result.followUpPrompt, logger, {
+            replaceRunning: true,
+        });
+    }
+}
+//# sourceMappingURL=permission-response.js.map

package/node_modules/@bytetrue/byspace-server/dist/server/server/agent/prompt-attachments.d.ts

@@ -0,0 +1,12 @@
+import type { AgentAttachment } from "@bytetrue/byspace-protocol/messages";
+import type { AgentPromptInput } from "./agent-sdk-types.js";
+export declare function buildAgentPrompt(text: string, images?: Array<{
+    data: string;
+    mimeType: string;
+}>, attachments?: AgentAttachment[]): AgentPromptInput;
+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

package/node_modules/@bytetrue/byspace-server/dist/server/server/agent/prompt-attachments.js

@@ -0,0 +1,111 @@
+const REVIEW_LINE_MARKERS = { add: "+", remove: "-", context: " " };
+export function buildAgentPrompt(text, images, attachments) {
+    const normalized = text.trim();
+    const hasImages = (images?.length ?? 0) > 0;
+    const hasAttachments = (attachments?.length ?? 0) > 0;
+    if (!hasImages && !hasAttachments) {
+        return normalized;
+    }
+    const chatHistoryAttachments = [];
+    const otherAttachments = [];
+    for (const attachment of attachments ?? []) {
+        if (attachment.type === "text" && attachment.contextKind === "chat_history") {
+            chatHistoryAttachments.push(attachment);
+        }
+        else {
+            otherAttachments.push(attachment);
+        }
+    }
+    const blocks = [...chatHistoryAttachments];
+    if (normalized.length > 0) {
+        blocks.push({ type: "text", text: normalized });
+    }
+    for (const image of images ?? []) {
+        blocks.push({ type: "image", data: image.data, mimeType: image.mimeType });
+    }
+    blocks.push(...otherAttachments);
+    return blocks;
+}
+export function renderPromptAttachmentAsText(attachment) {
+    switch (attachment.type) {
+        case "github_pr": {
+            const lines = [`GitHub PR #${attachment.number}: ${attachment.title}`, attachment.url];
+            if (attachment.baseRefName) {
+                lines.push(`Base: ${attachment.baseRefName}`);
+            }
+            if (attachment.headRefName) {
+                lines.push(`Head: ${attachment.headRefName}`);
+            }
+            if (attachment.body) {
+                lines.push("", attachment.body);
+            }
+            return lines.join("\n");
+        }
+        case "github_issue": {
+            const lines = [`GitHub Issue #${attachment.number}: ${attachment.title}`, attachment.url];
+            if (attachment.body) {
+                lines.push("", attachment.body);
+            }
+            return lines.join("\n");
+        }
+        case "text": {
+            return attachment.text;
+        }
+        case "review": {
+            const lines = [`BySpace review attachment (${attachment.mode})`, `CWD: ${attachment.cwd}`];
+            if (attachment.baseRef) {
+                lines.push(`Base: ${attachment.baseRef}`);
+            }
+            attachment.comments.forEach((comment, index) => {
+                lines.push("", `Comment ${index + 1}: ${comment.filePath}:${comment.side}:${comment.lineNumber}`, comment.body, comment.context.hunkHeader);
+                const target = comment.context.targetLine;
+                for (const line of comment.context.lines) {
+                    const isTarget = line.oldLineNumber === target.oldLineNumber &&
+                        line.newLineNumber === target.newLineNumber &&
+                        line.type === target.type &&
+                        line.content === target.content;
+                    const prefix = isTarget ? "> " : "  ";
+                    const oldLn = padLineNumber(line.oldLineNumber);
+                    const newLn = padLineNumber(line.newLineNumber);
+                    lines.push(`${prefix}${oldLn} ${newLn} ${REVIEW_LINE_MARKERS[line.type]}${line.content}`);
+                }
+            });
+            return lines.join("\n");
+        }
+        case "uploaded_file": {
+            return [
+                `Uploaded file: ${attachment.fileName}`,
+                `Path: ${attachment.path}`,
+                `MIME: ${attachment.mimeType}`,
+                `Size: ${attachment.size} bytes`,
+            ].join("\n");
+        }
+        default:
+            throw new Error("unreachable");
+    }
+}
+function padLineNumber(lineNumber) {
+    return (lineNumber?.toString() ?? "-").padStart(2);
+}
+export function buildAgentBranchNameSeed(firstAgentContext) {
+    if (!firstAgentContext) {
+        return undefined;
+    }
+    const parts = [];
+    const prompt = firstAgentContext.prompt?.trim();
+    if (prompt) {
+        parts.push(["<user-prompt>", prompt, "</user-prompt>"].join("\n"));
+    }
+    const renderedAttachments = [];
+    for (const attachment of firstAgentContext.attachments ?? []) {
+        const rendered = renderPromptAttachmentAsText(attachment).trim();
+        if (rendered) {
+            renderedAttachments.push(rendered);
+        }
+    }
+    if (renderedAttachments.length > 0) {
+        parts.push(["<attachments>", renderedAttachments.join("\n\n"), "</attachments>"].join("\n"));
+    }
+    return parts.length > 0 ? parts.join("\n\n") : undefined;
+}
+//# sourceMappingURL=prompt-attachments.js.map

package/node_modules/@bytetrue/byspace-server/dist/server/server/agent/provider-history-timestamps.d.ts

@@ -0,0 +1,2 @@
+export declare function normalizeProviderReplayTimestamp(value: unknown): string | null;
+//# sourceMappingURL=provider-history-timestamps.d.ts.map

package/node_modules/@bytetrue/byspace-server/dist/server/server/agent/provider-history-timestamps.js

@@ -0,0 +1,16 @@
+export function normalizeProviderReplayTimestamp(value) {
+    if (typeof value === "string") {
+        const timestamp = value.trim();
+        if (!timestamp || Number.isNaN(Date.parse(timestamp))) {
+            return null;
+        }
+        return timestamp;
+    }
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        return null;
+    }
+    const timestampMs = value > 1000000000000 ? value : value * 1000;
+    const date = new Date(timestampMs);
+    return Number.isNaN(date.getTime()) ? null : date.toISOString();
+}
+//# sourceMappingURL=provider-history-timestamps.js.map

package/node_modules/@bytetrue/byspace-server/dist/server/server/agent/provider-launch-config.d.ts

@@ -0,0 +1,43 @@
+import { type ProcessEnvRecord } from "../byspace-env.js";
+export { AgentProviderRuntimeSettingsMapSchema, ProviderCommandSchema, ProviderOverrideSchema, ProviderOverridesSchema, ProviderProfileModelSchema, ProviderRuntimeSettingsSchema, type AgentProviderRuntimeSettingsMap, type ProviderCommand, type ProviderOverride, type ProviderOverrides, type ProviderProfileModel, type ProviderRuntimeSettings, } from "@bytetrue/byspace-protocol/provider-config";
+import { type ProviderCommand, type ProviderOverrides, type ProviderRuntimeSettings } from "@bytetrue/byspace-protocol/provider-config";
+export interface ProviderCommandPrefix {
+    command: string;
+    args: string[];
+}
+export type ProviderLaunchSource = "default" | "append" | "override";
+export interface ResolvedProviderLaunch {
+    command: string;
+    args: string[];
+    source: ProviderLaunchSource;
+}
+export interface ProviderLaunchAvailability {
+    available: boolean;
+    resolvedPath: string | null;
+}
+export interface ProviderLaunchDefault {
+    command: string;
+    resolvePath?: () => Promise<string | null>;
+}
+export interface ResolveProviderLaunchOptions {
+    commandConfig?: ProviderCommand;
+    defaultBinary?: string | ProviderLaunchDefault;
+}
+export declare function resolveProviderLaunch({ commandConfig, defaultBinary, }: ResolveProviderLaunchOptions): Promise<ResolvedProviderLaunch>;
+export declare function checkProviderLaunchAvailable(launch: ResolvedProviderLaunch, defaultBinary?: ProviderLaunchDefault): Promise<ProviderLaunchAvailability>;
+export declare function resolveProviderCommandPrefix(commandConfig: ProviderCommand | undefined, resolveDefaultCommand: () => string | Promise<string>): Promise<ProviderCommandPrefix>;
+export declare function resolveShellEnv(): Record<string, string>;
+export declare function migrateProviderSettings(raw: Record<string, unknown>, builtinProviderIds: string[]): ProviderOverrides;
+export interface ProviderEnvOptions {
+    baseEnv?: ProcessEnvRecord;
+    runtimeSettings?: ProviderRuntimeSettings;
+    overlays?: Array<ProcessEnvRecord | undefined>;
+}
+export interface ProviderEnvSpec {
+    baseEnv?: ProcessEnvRecord;
+    envOverlay: ProcessEnvRecord;
+}
+export declare function createProviderEnvSpec(options?: ProviderEnvOptions): ProviderEnvSpec;
+export declare function createProviderEnv(options?: ProviderEnvOptions): NodeJS.ProcessEnv;
+export declare function isProviderCommandAvailable(commandConfig: ProviderCommand | undefined, resolveDefaultCommand: () => string | Promise<string>): Promise<boolean>;
+//# sourceMappingURL=provider-launch-config.d.ts.map