Ship reliable v0-like Studio flow

.env.example

@@ -70,9 +70,11 @@ CRON_SECRET=
 DROPS_PLATFORM_HEALTH_OPERATOR_SECRET=
 # Optional integer from 5 through 240; defaults to 20 minutes.
 DROPS_STUDIO_SANDBOX_IDLE_MINUTES=
-# Set to "1" only to opt into the live Sandbox contract test.
+# Set by `npm run test:live:sandbox`. Never enable it in the standard unit suite;
+# the test creates a billable external Sandbox and requires runtime credentials.
 DROPS_STUDIO_LIVE_SANDBOX=
-# Set to "1" only to opt into the full live install/build/preview/browser/checkpoint flow.
+# Set by `npm run test:live:builder`. The test creates billable external runtime
+# resources and also requires a configured browser snapshot.
 DROPS_STUDIO_LIVE_BUILDER=
 
 # Agent Intelligence v2. The JSON flag object contains booleans only; no credentials.

app/api/access/route.ts

@@ -5,11 +5,18 @@ import {
   GUEST_USAGE_COOKIE,
   memberProjectSyncReadiness,
   platformAiReadiness,
+  projectV2SyncReadiness,
   resolveFundedBuildQuota,
   resolveGuestAccess,
   resolveStudioAccount,
+  resolveStudioProjectActor,
   STUDIO_ACCOUNT_COOKIE,
 } from "../../../lib/access-tier.ts";
+import {
+  PROJECT_STORE_SCOPE_COOKIE,
+  projectStoreScopeCookieValue,
+  type ProjectStoreScope,
+} from "../../../lib/project-store.ts";
 import { readRequestLimitState } from "../../../lib/request-rate-limit.ts";
 
 export const runtime = "nodejs";
@@ -21,6 +28,23 @@ function requestOidcToken(request: NextRequest): string | undefined {
     : undefined;
 }
 
+function setProjectStoreScope(
+  response: NextResponse,
+  scope: ProjectStoreScope,
+): void {
+  response.cookies.set(
+    PROJECT_STORE_SCOPE_COOKIE,
+    projectStoreScopeCookieValue(scope),
+    {
+      httpOnly: false,
+      sameSite: "lax",
+      secure: process.env.NODE_ENV === "production",
+      maxAge: 60 * 60 * 24 * 90,
+      path: "/",
+    },
+  );
+}
+
 export async function GET(request: NextRequest) {
   const oidcToken = requestOidcToken(request);
   const readinessEnvironment = oidcToken
@@ -42,19 +66,27 @@ export async function GET(request: NextRequest) {
         })
       : { status: "unavailable" as const, count: null, remaining: null };
     const platformAvailable = readiness.available && quota.status !== "unavailable" && quota.count !== null;
-    return NextResponse.json(
+    const projectStoreScope = {
+      kind: "member" as const,
+      identity: account.identity,
+    };
+    const response = NextResponse.json(
       {
         access: accessMetadata({
           tier: platformAvailable ? memberTier : "fallback",
           used: quota.count ?? 0,
           account,
-          projectSyncAvailable: memberProjectSyncReadiness(readinessEnvironment),
+          projectSyncAvailable: projectV2SyncReadiness(readinessEnvironment),
+          accountProjectSyncAvailable: memberProjectSyncReadiness(readinessEnvironment),
           platformLimit: memberLimit,
         }),
+        projectStoreScope,
         quotaSigningConfigured: readiness.signingConfigured,
       },
       { headers: { "cache-control": "no-store" } },
     );
+    setProjectStoreScope(response, projectStoreScope);
+    return response;
   }
   const context = resolveGuestAccess({
     identityCookie: request.cookies.get(GUEST_IDENTITY_COOKIE)?.value,
@@ -66,11 +98,23 @@ export async function GET(request: NextRequest) {
     tier: context.configured && readiness.available ? "guest" : "fallback",
     used: context.used,
     projectSyncAvailable: context.configured
-      && memberProjectSyncReadiness(readinessEnvironment),
+      && projectV2SyncReadiness(readinessEnvironment),
   });
+  const signedGuestCookie = context.identityCookie
+    ?? request.cookies.get(GUEST_IDENTITY_COOKIE)?.value;
+  const actor = signedGuestCookie
+    ? resolveStudioProjectActor(
+        { guestCookie: signedGuestCookie },
+        readinessEnvironment,
+      )
+    : null;
+  const projectStoreScope = actor?.kind === "guest"
+    ? { kind: "guest" as const, identity: actor.identity }
+    : null;
   const response = NextResponse.json(
     {
       access,
+      ...(projectStoreScope ? { projectStoreScope } : {}),
       quotaSigningConfigured: readiness.signingConfigured,
     },
     { headers: { "cache-control": "no-store" } },
@@ -84,5 +128,6 @@ export async function GET(request: NextRequest) {
       path: "/",
     });
   }
+  if (projectStoreScope) setProjectStoreScope(response, projectStoreScope);
   return response;
 }

app/api/agent/chat/route.ts

@@ -1,4 +1,4 @@
-import { generateText, type LanguageModel } from "ai";
+import { generateText, streamText, type LanguageModel } from "ai";
 import { NextRequest } from "next/server.js";
 import { z } from "zod";
 
@@ -12,6 +12,7 @@ import type {
 import { ProjectRuntimeProviderError } from "../../../../lib/project-runtime-adapter.ts";
 import {
   builderActor,
+  BUILDER_NO_STORE_HEADERS,
   builderJson,
   builderRouteError,
   consumeBuilderLimit,
@@ -53,6 +54,12 @@ interface GenerateChatInput {
   abortSignal: AbortSignal;
 }
 
+interface StreamChatResult {
+  toTextStreamResponse(init?: ResponseInit): Response;
+}
+
+const MAX_STREAM_LINE_CHARACTERS = 16_384;
+
 export interface AgentChatRouteDependencies {
   modelResolver?: BuilderModelResolver;
   rememberConnection?: (
@@ -63,6 +70,14 @@ export interface AgentChatRouteDependencies {
     selection: BuilderProviderSelection;
   }>;
   generate?: (input: GenerateChatInput) => Promise<{ text: string }>;
+  stream?: (input: GenerateChatInput) => StreamChatResult;
+}
+
+function acceptsTextStream(request: NextRequest): boolean {
+  if (request.headers.get("x-drops-stream")?.trim() === "1") return true;
+  return (request.headers.get("accept") ?? "")
+    .split(",")
+    .some((value) => value.trim().split(";", 1)[0]?.toLowerCase() === "text/plain");
 }
 
 function safeProviderFailure(error: unknown): ProjectRuntimeProviderError {
@@ -72,6 +87,80 @@ function safeProviderFailure(error: unknown): ProjectRuntimeProviderError {
   );
 }
 
+function secretSafeTextStreamResponse(response: Response): Response {
+  if (!response.body) return response;
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  const encoder = new TextEncoder();
+  let pending = "";
+  let scanContext = "";
+  const stream = new ReadableStream<Uint8Array>({
+    async pull(controller) {
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          pending += decoder.decode(value, { stream: !done });
+          let enqueued = false;
+          let newline = pending.indexOf("\n");
+          while (newline >= 0) {
+            const line = pending.slice(0, newline + 1);
+            pending = pending.slice(newline + 1);
+            if (
+              line.length > MAX_STREAM_LINE_CHARACTERS
+              || findArtifactSecrets(`${scanContext}${line}`, "agent chat stream").length
+            ) {
+              throw new ProjectRuntimeProviderError(
+                "The selected AI model returned an unsafe streaming response. The project was not changed.",
+              );
+            }
+            scanContext = `${scanContext}${line}`.slice(-512);
+            controller.enqueue(encoder.encode(line));
+            enqueued = true;
+            newline = pending.indexOf("\n");
+          }
+          if (pending.length > MAX_STREAM_LINE_CHARACTERS) {
+            throw new ProjectRuntimeProviderError(
+              "The selected AI model returned an unsafe or oversized streaming response. The project was not changed.",
+            );
+          }
+          if (done) {
+            if (
+              pending
+              && findArtifactSecrets(`${scanContext}${pending}`, "agent chat stream").length
+            ) {
+              throw new ProjectRuntimeProviderError(
+                "The selected AI model returned an unsafe streaming response. The project was not changed.",
+              );
+            }
+            if (pending) controller.enqueue(encoder.encode(pending));
+            pending = "";
+            controller.close();
+            reader.releaseLock();
+            return;
+          }
+          if (enqueued) return;
+        }
+      } catch (error) {
+        await reader.cancel().catch(() => undefined);
+        try {
+          reader.releaseLock();
+        } catch {
+          // The reader can already be detached after cancellation.
+        }
+        controller.error(safeProviderFailure(error));
+      }
+    },
+    async cancel(reason) {
+      await reader.cancel(reason).catch(() => undefined);
+    },
+  });
+  return new Response(stream, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers,
+  });
+}
+
 export async function handleAgentChatRequest(
   request: NextRequest,
   dependencies: AgentChatRouteDependencies = {},
@@ -117,8 +206,47 @@ export async function handleAgentChatRequest(
       remembered.selection,
       remembered.credentials,
     );
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), 30_000);
+    const abortSignal = AbortSignal.any([
+      request.signal,
+      AbortSignal.timeout(30_000),
+    ]);
+    const generationInput: GenerateChatInput = {
+      model: resolved.model,
+      system:
+        "You are Drops Agent inside one existing crypto product project. Answer in the language of the latest user message. Use only the supplied project context. Be concise and practical. Never claim a file edit, build, deployment, Telegram delivery, connection, or external action unless the context explicitly proves it. Never request or repeat API keys, tokens, private keys, or credentials. If the user asks for a change, explain that a change request will run through the verified file-edit flow; this endpoint is conversation-only.",
+      prompt: JSON.stringify({
+        project: parsed.data.context,
+        latestUserMessage: parsed.data.message,
+      }),
+      abortSignal,
+    };
+
+    if (acceptsTextStream(request)) {
+      try {
+        const result = (dependencies.stream ?? ((input) => streamText({
+          model: input.model,
+          system: input.system,
+          prompt: input.prompt,
+          abortSignal: input.abortSignal,
+          maxOutputTokens: 1_200,
+          maxRetries: 1,
+          onError: ({ error }) => {
+            console.error(
+              "[agent-chat] provider stream failed",
+              error instanceof Error ? error.name : "unknown",
+            );
+          },
+        })))(generationInput);
+        return secretSafeTextStreamResponse(
+          result.toTextStreamResponse({
+            headers: BUILDER_NO_STORE_HEADERS,
+          }),
+        );
+      } catch (error) {
+        throw safeProviderFailure(error);
+      }
+    }
+
     let result: { text: string };
     try {
       result = await (dependencies.generate ?? (async (input) => generateText({
@@ -128,22 +256,9 @@ export async function handleAgentChatRequest(
         abortSignal: input.abortSignal,
         maxOutputTokens: 1_200,
         maxRetries: 1,
-      })))(
-        {
-          model: resolved.model,
-          system:
-            "You are Drops Agent inside one existing crypto product project. Answer in the language of the latest user message. Use only the supplied project context. Be concise and practical. Never claim a file edit, build, deployment, Telegram delivery, connection, or external action unless the context explicitly proves it. Never request or repeat API keys, tokens, private keys, or credentials. If the user asks for a change, explain that a change request will run through the verified file-edit flow; this endpoint is conversation-only.",
-          prompt: JSON.stringify({
-            project: parsed.data.context,
-            latestUserMessage: parsed.data.message,
-          }),
-          abortSignal: controller.signal,
-        },
-      );
+      })))(generationInput);
     } catch (error) {
       throw safeProviderFailure(error);
-    } finally {
-      clearTimeout(timer);
     }
     const reply = result.text.trim();
     if (!reply || findArtifactSecrets(reply, "agent chat response").length) {

app/api/auth/google/callback/route.ts

@@ -11,6 +11,10 @@ import {
   GOOGLE_OIDC_TRANSACTION_COOKIE,
   readGoogleOidcTransaction,
 } from "@/lib/google-oidc";
+import {
+  PROJECT_STORE_SCOPE_COOKIE,
+  projectStoreScopeCookieValue,
+} from "@/lib/project-store";
 
 export const dynamic = "force-dynamic";
 export const runtime = "nodejs";
@@ -78,6 +82,20 @@ export async function GET(request: NextRequest) {
       maxAge: 60 * 60 * 24 * 90,
       path: "/",
     });
+    response.cookies.set(
+      PROJECT_STORE_SCOPE_COOKIE,
+      projectStoreScopeCookieValue({
+        kind: "member",
+        identity: account.identity,
+      }),
+      {
+        httpOnly: false,
+        sameSite: "lax",
+        secure: process.env.NODE_ENV === "production",
+        maxAge: 60 * 60 * 24 * 90,
+        path: "/",
+      },
+    );
     clearTransaction(response);
     response.headers.set("cache-control", "no-store");
     return response;

app/api/auth/openrouter/exchange/route.ts

@@ -8,6 +8,10 @@ import {
 } from "../../../../../lib/access-tier.ts";
 import { saveStudioConnection } from "../../../../../db/studio-account-state.ts";
 import { consumeRequestLimit, requestIdentity } from "../../../../../lib/request-rate-limit.ts";
+import {
+  PROJECT_STORE_SCOPE_COOKIE,
+  projectStoreScopeCookieValue,
+} from "../../../../../lib/project-store.ts";
 
 export const runtime = "nodejs";
 
@@ -139,6 +143,22 @@ export async function POST(request: NextRequest) {
         path: "/",
       });
     }
+    if (account) {
+      result.cookies.set(
+        PROJECT_STORE_SCOPE_COOKIE,
+        projectStoreScopeCookieValue({
+          kind: "member",
+          identity: account.identity,
+        }),
+        {
+          httpOnly: false,
+          sameSite: "lax",
+          secure: process.env.NODE_ENV === "production",
+          maxAge: 60 * 60 * 24 * 90,
+          path: "/",
+        },
+      );
+    }
     return result;
   } catch (error) {
     console.error("[openrouter-auth] key exchange failed", error);