@mevdragon/vidfarm-devcli 0.5.3 → 0.6.0

package/dist/src/services/auth.js

@@ -0,0 +1,152 @@
+import { randomInt } from "node:crypto";
+import { config } from "../config.js";
+import { encryptString, hashPassword, hashSecret, safeEqualHash, verifyPassword } from "../lib/crypto.js";
+import { displayNameFromEmail } from "../lib/display-name.js";
+import { createId } from "../lib/ids.js";
+import { addSeconds, nowIso } from "../lib/time.js";
+import { ServerlessAuthService } from "./serverless-auth.js";
+export class AuthService {
+    serverless = new ServerlessAuthService();
+    async requestOtp(email) {
+        const code = `${randomInt(100000, 999999)}`;
+        await this.serverless.insertOtpChallenge({
+            id: createId("otp"),
+            email,
+            codeHash: hashSecret(code),
+            expiresAt: addSeconds(new Date(), 600)
+        });
+        if (config.RESEND_API_KEY) {
+            const response = await fetch("https://api.resend.com/emails", {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${config.RESEND_API_KEY}`
+                },
+                body: JSON.stringify({
+                    from: config.RESEND_FROM_EMAIL,
+                    to: email,
+                    subject: "Your Vidfarm login code",
+                    text: `Your login code is ${code}. It expires in 10 minutes.`
+                })
+            });
+            if (!response.ok) {
+                const body = await response.text();
+                throw new Error(`Unable to send OTP email (${response.status}): ${body || "empty response body"}`);
+            }
+            return {
+                delivery: "email"
+            };
+        }
+        else {
+            console.log(`[vidfarm] OTP for ${email}: ${code}`);
+            return {
+                delivery: "console",
+                code: config.isProduction ? undefined : code
+            };
+        }
+    }
+    async verifyOtp(email, code, name) {
+        const challenge = await this.serverless.findLatestOtpChallenge(email);
+        if (!challenge) {
+            throw new Error("No OTP challenge found for that email.");
+        }
+        if (challenge.consumed_at) {
+            throw new Error("OTP challenge already used.");
+        }
+        if (new Date(String(challenge.expires_at)).getTime() < Date.now()) {
+            throw new Error("OTP challenge expired.");
+        }
+        if (!safeEqualHash(code, String(challenge.code_hash))) {
+            throw new Error("Invalid OTP code.");
+        }
+        await this.serverless.consumeOtpChallenge(email, String(challenge.id));
+        const existing = await this.serverless.getCustomerByEmailPublic(email);
+        const normalizedEmail = email.trim().toLowerCase();
+        const customer = await this.serverless.upsertCustomer({
+            id: existing?.id ?? createId("cus"),
+            email: normalizedEmail,
+            name: name?.trim() || existing?.name || displayNameFromEmail(normalizedEmail),
+            defaultWebhookUrl: existing?.defaultWebhookUrl ?? null,
+            isDeveloper: existing?.isDeveloper || config.adminEmails.includes(normalizedEmail),
+            isPaidPlan: existing?.isPaidPlan ?? false,
+            planTier: existing?.planTier ?? "client"
+        });
+        const rawApiKey = `vf_${createId("key")}`;
+        await this.serverless.insertApiKey({
+            id: createId("api"),
+            customerId: customer.id,
+            keyHash: hashSecret(rawApiKey + config.API_KEY_SALT),
+            rawValue: rawApiKey,
+            label: `Issued ${nowIso()}`
+        });
+        return { customer, apiKey: rawApiKey };
+    }
+    authenticate(apiKey) {
+        throw new Error("Use authenticateAsync; DynamoDB authentication is asynchronous.");
+    }
+    async authenticateAsync(apiKey) {
+        return this.serverless.authenticate(apiKey);
+    }
+    async verifyOtpForBrowserLogin(email, code, name) {
+        const result = await this.verifyOtp(email, code, name);
+        if (!result.customer.isPaidPlan) {
+            return {
+                status: "pricing",
+                customer: result.customer
+            };
+        }
+        return {
+            status: "authenticated",
+            customer: result.customer
+        };
+    }
+    async authenticateWithPassword(email, password) {
+        const row = await this.serverless.getCustomerAuthByEmail(email);
+        if (!row || !row.password_hash || !verifyPassword(password, String(row.password_hash))) {
+            throw new Error("Invalid email or password.");
+        }
+        const customer = await this.serverless.getCustomerById(String(row.customer_id ?? row.id));
+        if (!customer) {
+            throw new Error("Customer not found.");
+        }
+        await this.serverless.updateCustomerPassword(customer.id, String(row.password_hash), encryptString(password, config.ENCRYPTION_SECRET));
+        if (!customer.isPaidPlan) {
+            return {
+                status: "pricing",
+                customer
+            };
+        }
+        return {
+            status: "authenticated",
+            customer
+        };
+    }
+    async createPasswordUser(input) {
+        const normalizedEmail = input.email.trim().toLowerCase();
+        const existing = await this.serverless.getCustomerByEmailPublic(normalizedEmail);
+        return this.serverless.upsertCustomer({
+            id: existing?.id ?? createId("cus"),
+            email: normalizedEmail,
+            name: input.name?.trim() || existing?.name || displayNameFromEmail(normalizedEmail),
+            defaultWebhookUrl: existing?.defaultWebhookUrl ?? null,
+            isDeveloper: existing?.isDeveloper || config.adminEmails.includes(normalizedEmail),
+            isPaidPlan: true,
+            planTier: input.planTier ?? existing?.planTier ?? "client",
+            passwordHash: hashPassword(input.password),
+            encryptedPassword: encryptString(input.password, config.ENCRYPTION_SECRET)
+        });
+    }
+}
+function normalizePlanTier(value) {
+    if (value === "client" || value === "standalone" || value === "agency") {
+        return value;
+    }
+    if (value === "invisible" || value === "starter") {
+        return "client";
+    }
+    if (value === "standard") {
+        return "standalone";
+    }
+    return "client";
+}
+//# sourceMappingURL=auth.js.map

package/dist/src/services/billing-pricing.js

@@ -0,0 +1,39 @@
+// Single source of truth for the render/compute billing markup.
+//
+// The billing lambda debits the wallet by `base_provider_cost * markup` (see
+// infra/lambda/billing.ts). Every surface that *displays* a render's cost — and
+// every place that pre-computes the marked-up `chargeUsd` stashed in render
+// metadata — must apply the SAME markup, otherwise the number shown to the user
+// diverges from what their wallet is actually charged.
+//
+// The markup is expressed in basis points so it matches the billing lambda's
+// integer micros math exactly. It is overridable per-environment via
+// `VIDFARM_BILLING_MARKUP_BPS`; keep that env var in sync across the billing,
+// job-runner, and api lambdas so display and charge never drift.
+export const DEFAULT_MARKUP_BPS = 12_000; // 1.2x
+const BPS_DENOMINATOR = 10_000;
+// Resolve the active markup (basis points). Falls back to the default when the
+// env var is unset, empty, or not a positive integer.
+export function resolveMarkupBps() {
+    const raw = process.env.VIDFARM_BILLING_MARKUP_BPS;
+    if (raw === undefined || raw === null || raw.trim() === "") {
+        return DEFAULT_MARKUP_BPS;
+    }
+    const parsed = Number.parseInt(raw, 10);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        return DEFAULT_MARKUP_BPS;
+    }
+    return parsed;
+}
+export function roundUsd(value) {
+    return Number(value.toFixed(4));
+}
+// Convert a raw provider cost (USD) into the amount the wallet is actually
+// charged. Non-positive or non-finite inputs yield 0 (nothing to bill).
+export function applyMarkupUsd(baseCostUsd, markupBps = resolveMarkupBps()) {
+    if (!Number.isFinite(baseCostUsd) || baseCostUsd <= 0) {
+        return 0;
+    }
+    return roundUsd((baseCostUsd * markupBps) / BPS_DENOMINATOR);
+}
+//# sourceMappingURL=billing-pricing.js.map

package/dist/src/services/billing.js

@@ -0,0 +1,228 @@
+import { createHash } from "node:crypto";
+import { serverlessRecords } from "./serverless-records.js";
+import { createId } from "../lib/ids.js";
+import { config } from "../config.js";
+const BILLING_COST_EVENTS_PATH = "/v1/cost-events";
+const BILLING_WALLET_GRANTS_PATH = "/v1/wallet-grants";
+const PAID_SIGNUP_BONUS_GRANT_TYPE = "paid_signup_bonus";
+const PAID_SIGNUP_BONUS_USD = 5;
+export class BillingService {
+    async getWalletSummary(customerId) {
+        if (!config.VIDFARM_BILLING_URL || !config.VIDFARM_BILLING_SECRET) {
+            throw new Error("Billing service is not configured.");
+        }
+        const response = await fetch(new URL(`/v1/wallets/${encodeURIComponent(customerId)}`, config.VIDFARM_BILLING_URL), {
+            headers: {
+                "x-vidfarm-billing-secret": config.VIDFARM_BILLING_SECRET
+            }
+        });
+        if (!response.ok) {
+            const body = await response.text().catch(() => "");
+            throw new Error(`Billing wallet lookup failed (${response.status}): ${body || response.statusText}`);
+        }
+        const payload = await response.json();
+        return {
+            currency: typeof payload.currency === "string" ? payload.currency : "USD",
+            balanceUsd: Number(payload.balance_usd ?? 0),
+            balanceMicrosUsd: Number(payload.balance_micros_usd ?? 0)
+        };
+    }
+    async getJobBillingSummary(input) {
+        if (!config.VIDFARM_BILLING_URL || !config.VIDFARM_BILLING_SECRET) {
+            return {
+                currency: "USD",
+                eventCount: 0,
+                totalBaseCostUsd: 0,
+                totalChargeUsd: 0,
+                unavailableReason: "Billing service is not configured."
+            };
+        }
+        const url = new URL(`/v1/jobs/${encodeURIComponent(input.jobId)}/billing`, config.VIDFARM_BILLING_URL);
+        url.searchParams.set("customer_id", input.customerId);
+        if (input.templateId) {
+            url.searchParams.set("template_id", input.templateId);
+        }
+        const response = await fetch(url, {
+            headers: {
+                "x-vidfarm-billing-secret": config.VIDFARM_BILLING_SECRET
+            }
+        });
+        if (!response.ok) {
+            const body = await response.text().catch(() => "");
+            throw new Error(`Billing job summary lookup failed (${response.status}): ${body || response.statusText}`);
+        }
+        const payload = await response.json();
+        return {
+            currency: typeof payload.currency === "string" ? payload.currency : "USD",
+            eventCount: Number(payload.event_count ?? 0),
+            totalBaseCostUsd: Number(payload.total_base_cost_usd ?? 0),
+            totalChargeUsd: Number(payload.total_charge_usd ?? 0),
+            unavailableReason: null
+        };
+    }
+    async record(input) {
+        const normalizedCostCenterSlug = resolveCostCenterSlug(input);
+        const normalizedIdempotencyKey = resolveIdempotencyKey(input, normalizedCostCenterSlug);
+        const remoteEventCostCenterSlug = normalizedCostCenterSlug ?? null;
+        if (!remoteEventCostCenterSlug) {
+            return;
+        }
+        if (!config.VIDFARM_BILLING_URL || !config.VIDFARM_BILLING_SECRET) {
+            throw new Error(`Billing URL/secret missing for cost center ${remoteEventCostCenterSlug}.`);
+        }
+        const response = await fetch(new URL(BILLING_COST_EVENTS_PATH, config.VIDFARM_BILLING_URL), {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                "x-vidfarm-billing-secret": config.VIDFARM_BILLING_SECRET
+            },
+            body: JSON.stringify({
+                idempotency_key: normalizedIdempotencyKey ?? `${remoteEventCostCenterSlug}:${input.jobId}:${input.templateId}:${input.type}`,
+                customer_id: input.customerId,
+                job_id: input.jobId,
+                tracer: input.tracer,
+                cost_center_slug: remoteEventCostCenterSlug,
+                base_cost_usd: input.costUsd,
+                metadata: {
+                    ...input.metadata,
+                    template_id: input.templateId,
+                    local_charge_usd: input.chargeUsd
+                },
+                occurred_at_ms: input.occurredAtMs ?? Date.now()
+            })
+        });
+        if (!response.ok) {
+            const body = await response.text().catch(() => "");
+            throw new Error(`Billing service rejected cost event (${response.status}): ${body || response.statusText}`);
+        }
+        await response.json().catch(() => ({}));
+    }
+    async grantPaidSignupBonus(customerId, metadata) {
+        const customer = await serverlessRecords.getCustomerById(customerId);
+        if (!customer) {
+            throw new Error("Customer not found.");
+        }
+        if (!customer.isPaidPlan) {
+            return { granted: false, reason: "customer_not_paid" };
+        }
+        if (await serverlessRecords.hasCustomerCreditGrant(customerId, PAID_SIGNUP_BONUS_GRANT_TYPE)) {
+            return { granted: false, reason: "already_granted" };
+        }
+        if (!config.VIDFARM_BILLING_URL || !config.VIDFARM_BILLING_SECRET) {
+            throw new Error("Billing service is not configured.");
+        }
+        const response = await fetch(new URL(BILLING_WALLET_GRANTS_PATH, config.VIDFARM_BILLING_URL), {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                "x-vidfarm-billing-secret": config.VIDFARM_BILLING_SECRET
+            },
+            body: JSON.stringify({
+                idempotency_key: `${PAID_SIGNUP_BONUS_GRANT_TYPE}:${customerId}`,
+                customer_id: customerId,
+                amount_usd: PAID_SIGNUP_BONUS_USD,
+                grant_type: PAID_SIGNUP_BONUS_GRANT_TYPE,
+                occurred_at_ms: Date.now(),
+                metadata: {
+                    ...(metadata ?? {}),
+                    grant_type: PAID_SIGNUP_BONUS_GRANT_TYPE
+                }
+            })
+        });
+        if (!response.ok) {
+            const body = await response.text().catch(() => "");
+            throw new Error(`Billing service rejected signup wallet grant (${response.status}): ${body || response.statusText}`);
+        }
+        try {
+            await serverlessRecords.insertCustomerCreditGrant({
+                id: createId("grant"),
+                customerId,
+                grantType: PAID_SIGNUP_BONUS_GRANT_TYPE,
+                amountUsd: PAID_SIGNUP_BONUS_USD,
+                metadata: metadata ?? {}
+            });
+        }
+        catch (error) {
+            if (!isUniqueConstraintError(error)) {
+                throw error;
+            }
+        }
+        return {
+            granted: true,
+            reason: "granted",
+            amountUsd: PAID_SIGNUP_BONUS_USD,
+            grantType: PAID_SIGNUP_BONUS_GRANT_TYPE
+        };
+    }
+}
+function resolveCostCenterSlug(input) {
+    if (input.costCenterSlug?.trim()) {
+        const explicitSlug = input.costCenterSlug.trim();
+        return explicitSlug === "hyperframes_lambda"
+            || explicitSlug === "video_normalization"
+            || explicitSlug === "rapidapi_video_download"
+            || explicitSlug === "video_download_lambda"
+            || explicitSlug === "rapidapi_remove_background"
+            || explicitSlug === "primitive_media_lambda"
+            || explicitSlug === "job_runner_lambda"
+            || explicitSlug === "step_functions_standard"
+            ? explicitSlug
+            : null;
+    }
+    return null;
+}
+function resolveIdempotencyKey(input, costCenterSlug) {
+    if (input.idempotencyKey?.trim()) {
+        return input.idempotencyKey.trim();
+    }
+    const renderId = typeof input.metadata?.render_id === "string"
+        ? input.metadata.render_id
+        : typeof input.metadata?.renderId === "string"
+            ? input.metadata.renderId
+            : null;
+    if (costCenterSlug === "hyperframes_lambda" && renderId) {
+        return `hyperframes_lambda:${renderId}`;
+    }
+    return buildBillingEventFingerprint(input, costCenterSlug);
+}
+function buildBillingEventFingerprint(input, costCenterSlug) {
+    const fingerprintPayload = {
+        customerId: input.customerId,
+        jobId: input.jobId,
+        templateId: input.templateId,
+        tracer: input.tracer ?? null,
+        type: input.type,
+        costCenterSlug,
+        costUsd: roundUsd(input.costUsd),
+        chargeUsd: input.chargeUsd == null ? null : roundUsd(input.chargeUsd),
+        occurredAtMs: input.occurredAtMs ?? null,
+        metadata: sortJsonValue(input.metadata ?? {})
+    };
+    const digest = createHash("sha256")
+        .update(JSON.stringify(fingerprintPayload))
+        .digest("hex")
+        .slice(0, 24);
+    return `${costCenterSlug ?? input.type}:${input.jobId}:${digest}`;
+}
+function sortJsonValue(value) {
+    if (Array.isArray(value)) {
+        return value.map(sortJsonValue);
+    }
+    if (value && typeof value === "object") {
+        return Object.entries(value)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .reduce((acc, [key, nestedValue]) => {
+            acc[key] = sortJsonValue(nestedValue);
+            return acc;
+        }, {});
+    }
+    return value;
+}
+function roundUsd(value) {
+    return Number(value.toFixed(6));
+}
+function isUniqueConstraintError(error) {
+    return Boolean(error instanceof Error && /unique constraint/i.test(error.message));
+}
+export { PAID_SIGNUP_BONUS_GRANT_TYPE, PAID_SIGNUP_BONUS_USD, resolveCostCenterSlug, resolveIdempotencyKey };
+//# sourceMappingURL=billing.js.map

package/dist/src/services/cast.js

@@ -0,0 +1,127 @@
+import { extractVideoFrameAsset } from "./media-processing.js";
+// ==========================================================================
+// Cast pass state — persisted per fork under
+//   compositions/forks/{forkId}/working/cast.json
+// and copied on fork/clone/version so the identified cast (and its reference
+// stills) travel with every descendant composition. Drives the async
+// /cast-poll flow, mirroring the ghostcut.json state machine: /auto-decompose
+// seeds it "pending", and /cast-poll advances it one unit of work per call
+// (analyze -> per-member still -> per-member isolation -> done).
+//
+// The cast/ reference images live under the same public fork prefix, so their
+// URLs are directly fetchable by every user and by AI generation primitives
+// (as input_references / prompt_attachments) without a proxy hop.
+// ==========================================================================
+export const CAST_STATE_VERSION = 1;
+export function buildPendingCastState(input) {
+    return {
+        version: CAST_STATE_VERSION,
+        status: "pending",
+        stage: "analyze",
+        savedAtMs: Date.now(),
+        compositionId: input.compositionId,
+        sourceUrl: input.sourceUrl,
+        title: input.title,
+        provider: null,
+        model: null,
+        durationSeconds: 0,
+        width: 0,
+        height: 0,
+        members: []
+    };
+}
+export function castMemberFromRaw(raw) {
+    return {
+        slug: raw.slug,
+        name: raw.name,
+        role: raw.role,
+        description: raw.description,
+        wardrobe: raw.wardrobe,
+        appears_in: raw.appears_in,
+        best_frame_ms: Math.max(0, Math.round(raw.best_frame_seconds * 1000)),
+        bbox: raw.bbox,
+        is_primary: raw.is_primary,
+        still_url: null,
+        reference_url: null,
+        status: "pending"
+    };
+}
+// The registry's default image model per provider is module-private; mirror it
+// here so the cast isolation edit picks a supported model without importing
+// the whole primitive registry.
+function defaultImageModelForProvider(provider) {
+    switch (provider) {
+        case "gemini":
+            return "gemini-2.5-flash-image";
+        case "openrouter":
+            return "google/gemini-2.5-flash-image-preview";
+        default:
+            return "gpt-image-2";
+    }
+}
+// Pick the customer's best available image-capable provider. Order mirrors the
+// vision fallback (gemini -> openai -> openrouter). perplexity has no image
+// capability so it's never a candidate.
+export function pickImageProvider(keys) {
+    if (keys.gemini)
+        return "gemini";
+    if (keys.openai)
+        return "openai";
+    if (keys.openrouter)
+        return "openrouter";
+    return null;
+}
+function describeBbox(bbox) {
+    if (!bbox)
+        return "";
+    const pct = (v) => `${Math.round(v * 100)}%`;
+    const cx = bbox.x + bbox.width / 2;
+    const horizontal = cx < 0.34 ? "on the left" : cx > 0.66 ? "on the right" : "in the center";
+    return ` They are located ${horizontal} of the frame (roughly x=${pct(bbox.x)}, y=${pct(bbox.y)}, width=${pct(bbox.width)}, height=${pct(bbox.height)}).`;
+}
+export function buildCastIsolationInstruction(member) {
+    const wardrobe = member.wardrobe ? ` They are wearing: ${member.wardrobe}.` : "";
+    return [
+        `Isolate ONLY the single person described as: ${member.description}.${wardrobe}${describeBbox(member.bbox)}`,
+        "Cut that one person out cleanly and place them on a fully transparent background.",
+        "Preserve their exact face, hairstyle, skin tone, body proportions, and clothing without alteration.",
+        "Remove every other person and the entire original background. If multiple people are present, keep only the described one.",
+        "Output a single-subject cutout suitable for reuse as a character reference."
+    ].join(" ");
+}
+// Extracts the best-frame still for a member and stores it under the fork's
+// public working/cast/ prefix. Returns the public URL (or null if the key is
+// not in a public prefix, which shouldn't happen for fork keys).
+export async function extractCastStill(input) {
+    const frame = await extractVideoFrameAsset({
+        sourceUrl: input.sourceUrl,
+        atMs: input.member.best_frame_ms,
+        format: "png"
+    });
+    const key = input.storage.compositionForkWorkingKey(input.forkId, `cast/${input.member.slug}-still.png`);
+    const stored = await input.storage.putBuffer(key, frame.bytes, frame.contentType);
+    return { url: stored.url ?? input.storage.getPublicUrl(key) };
+}
+// Runs the image-edit "isolate this person on transparent background" pass over
+// the extracted still and stores the cutout under the fork's public prefix.
+// There is no true person-segmentation primitive in the platform, so this
+// approximates instance masking via a prompt-driven edit (bbox-guided).
+export async function isolateCastMember(input) {
+    const provider = pickImageProvider(input.keys);
+    if (!provider) {
+        throw new Error("No image-capable provider key available for cast isolation");
+    }
+    const edited = await input.providers.editImage({
+        customerId: input.customerId,
+        jobId: input.jobId,
+        workerId: `cast-isolate:${input.member.slug}`,
+        provider,
+        model: defaultImageModelForProvider(provider),
+        sourceImageUrl: input.stillUrl,
+        instruction: buildCastIsolationInstruction(input.member)
+    });
+    const key = input.storage.compositionForkWorkingKey(input.forkId, `cast/${input.member.slug}.png`);
+    const stored = await input.storage.putBuffer(key, edited.bytes, edited.contentType ?? "image/png");
+    return { url: stored.url ?? input.storage.getPublicUrl(key) };
+}
+//# sourceMappingURL=cast.js.map

package/dist/src/services/chat-threads.js

@@ -0,0 +1,92 @@
+import { createId } from "../lib/ids.js";
+import { nowIso } from "../lib/time.js";
+import { serverlessRecords } from "./serverless-records.js";
+import { StorageService } from "./storage.js";
+const storage = new StorageService();
+function normalizeTracerList(values) {
+    return [...new Set(values.map((value) => value.trim()).filter(Boolean))];
+}
+function buildThreadStoragePrefix(customerId, templateId, threadId) {
+    return storage.developerScopedKey(customerId, "chat-threads", templateId, threadId);
+}
+function buildThreadChunkKey(prefix, createdAt) {
+    const sortableTime = createdAt.replace(/[^0-9]/g, "");
+    return `${prefix}/chunks/${sortableTime}-${createId("chunk")}.json`;
+}
+async function readChunkMessages(key) {
+    const raw = await storage.readText(key);
+    if (!raw) {
+        return [];
+    }
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed.messages) ? parsed.messages : [];
+}
+export const chatThreads = {
+    async listThreads(input) {
+        const threads = await serverlessRecords.listChatThreadMetas(input);
+        if (input.includeMessages === false) {
+            return threads;
+        }
+        const withMessages = await Promise.all(threads.map(async (thread) => ({
+            ...thread,
+            messages: await this.loadThreadMessages(thread)
+        })));
+        return withMessages;
+    },
+    async getThread(input) {
+        const thread = await serverlessRecords.getChatThreadMeta(input.customerId, input.threadId);
+        if (!thread) {
+            return null;
+        }
+        return {
+            ...thread,
+            messages: await this.loadThreadMessages(thread)
+        };
+    },
+    async appendExchange(input) {
+        const createdAt = nowIso();
+        const storagePrefix = buildThreadStoragePrefix(input.customerId, input.templateId, input.threadId);
+        const chunk = {
+            version: 1,
+            threadId: input.threadId,
+            customerId: input.customerId,
+            templateId: input.templateId,
+            createdAt,
+            messages: input.messages
+        };
+        await storage.putJson(buildThreadChunkKey(storagePrefix, createdAt), chunk);
+        const updated = await serverlessRecords.appendChatThreadMessages({
+            threadId: input.threadId,
+            customerId: input.customerId,
+            title: input.title || "New chat",
+            templateId: input.templateId,
+            storagePrefix,
+            tracers: normalizeTracerList(input.tracers),
+            messageCountDelta: input.messages.length,
+            lastMessageAt: createdAt
+        });
+        return updated ? this.getThread({ customerId: input.customerId, threadId: updated.id }) : null;
+    },
+    async updateThread(input) {
+        const updated = await serverlessRecords.updateChatThreadState({
+            ...input,
+            tracers: input.tracers ? normalizeTracerList(input.tracers) : undefined
+        });
+        return updated ? this.getThread({ customerId: input.customerId, threadId: updated.id }) : null;
+    },
+    async deleteThread(input) {
+        const existing = await serverlessRecords.deleteChatThread(input.customerId, input.threadId);
+        if (!existing) {
+            return null;
+        }
+        const keys = await storage.listKeys(`${existing.storagePrefix}/`);
+        await Promise.all(keys.map((key) => storage.deleteObject(key)));
+        return existing;
+    },
+    async loadThreadMessages(thread) {
+        const keys = (await storage.listKeys(`${thread.storagePrefix}/chunks/`)).sort();
+        const messageGroups = await Promise.all(keys.map((key) => readChunkMessages(key)));
+        return messageGroups.flat();
+    }
+};
+//# sourceMappingURL=chat-threads.js.map