Intimacy Boundary Guide

Required key.

Add this in your Lovable project under Settings → Secrets before pasting the prompt below.

Paste into a fresh Lovable project. Make sure the key above is set first. read the build strategy →

Build "Intimacy Boundary Guide" as a ONE-SHOT Lovable build. The participant has only
5 credits — this single message must produce a working demo with no follow-ups.
Single-page TanStack Start app. Cut scope ruthlessly.

CONCEPT
Lovable AI drafts consent check-ins so coordinators ensure safety; ElevenLabs speaks it.
Discipline: Theater & Live Performance (intimacy coordination).
Recipe: Lovable AI brain + Conversational Voice Agent (live conversation) as the voice surface.
Why this voice surface: A gentle, conversational voice helps normalize and guide sensitive, real-time discussions about physical boundaries during rehearsal.

LOVABLE BUDGET (HARD CAP: ONE-SHOT, ~5 CREDITS TOTAL):
The participant has FIVE Lovable credits for the whole build. This prompt MUST
ship a working demo on the FIRST message with zero follow-ups. Engineer for that.
- ONE TanStack Start app, ONE route (`src/routes/index.tsx`). No extra pages, no auth, no nav.
- TWO TanStack server functions max: one for the Lovable AI call (the brain),
  one for the ElevenLabs call (the voice). Fold them into one if the voice
  primitive does not need server-side text generation.
- ONE client surface (a button, a mic, or a prompt box) wired to those server fns.
- NO database, NO Lovable Cloud, NO auth, NO file uploads, NO extra integrations.
- NO tests, NO docs pages, NO settings screens, NO theming toggles.
- Libraries: template defaults + `ai` + `@ai-sdk/openai-compatible` + `zod`,
  plus (only if the voice kernel needs it) `@elevenlabs/react`. Nothing else.
- Keep the diff small enough to land in one build pass. If a feature is not on
  screen in the user flow below, do not build it. Cut scope before adding scope.

STACK
- TanStack Start app, the index route only.
- Lovable AI Gateway (the brain) + ElevenLabs (the voice). All calls live
  inside `createServerFn` handlers so both keys stay on the server.
- Client surface fits the kernel: a prompt box for TTS / music / SFX, a mic
  for agents, a live caption strip for scribe. Render markdown from the brain
  with `react-markdown` if you show the text on screen.
- Tailwind + shadcn. Editorial look: gold accent on a dark or warm-cream
  background, generous type, one strong headline, one primary action.
- Footer renders: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

BRAIN — Lovable AI Gateway (free for participants, no key prompt needed):
```ts
// src/lib/ai-gateway.server.ts
import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
export function gateway() {
  return createOpenAICompatible({
    name: "lovable",
    baseURL: "https://ai.gateway.lovable.dev/v1",
    headers: {
      "Lovable-API-Key": process.env.LOVABLE_API_KEY!,
      "X-Lovable-AIG-SDK": "vercel-ai-sdk",
    },
  });
}
```
Default model: `google/gemini-3-flash-preview`. Use `generateText` (or
`streamText` for long output) from `ai`. Keep prompts and model calls inside
the server function — never call the gateway from client code.

SERVER FUNCTION (src/lib/agent.functions.ts) — mint a single-use token:
```ts
import { createServerFn } from "@tanstack/react-start";
import { z } from "zod";

/** Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14 */
export const mintAgentToken = createServerFn({ method: "POST" })
  .inputValidator((d) => z.object({ agentId: z.string() }).parse(d))
  .handler(async ({ data }) => {
    const r = await fetch(
      `https://api.elevenlabs.io/v1/convai/conversation/token?agent_id=${data.agentId}`,
      { headers: { "xi-api-key": process.env.ELEVENLABS_API_KEY! } },
    );
    const { token } = await r.json();
    return { token };
  });
```

CLIENT (`bun add @elevenlabs/react` first):
```tsx
import { useConversation } from "@elevenlabs/react";
import { useServerFn } from "@tanstack/react-start";
import { mintAgentToken } from "@/lib/agent.functions";

const c = useConversation({ onMessage: (m) => console.log(m) });
const getToken = useServerFn(mintAgentToken);

const start = async (language: string) => {
  await navigator.mediaDevices.getUserMedia({ audio: true });
  const { token } = await getToken({ data: { agentId: import.meta.env.VITE_AGENT_ID } });
  await c.startSession({
    conversationToken: token,
    connectionType: "webrtc",
    overrides: { agent: { language } }, // ElevenLabs handles translation in-flight
  });
};
```

AGENT SETUP: create the agent at https://elevenlabs.io/app/agents. Its system
prompt is the BRAIN for this build — write it for the intimacy coordination use case (e.g.
"You are a senior intimacy coordination mentor. Ask one focused question at a time."). Enable
language overrides. Copy the agent id into `VITE_AGENT_ID` (public env).

TRANSLATION — included by default:
Add a language `<Select>` to the UI (English, Español, Français, Deutsch,
Português, हिंदी, 日本語). Before sending the AI output to ElevenLabs,
ask the gateway to translate it into the chosen language in the same server
function. Then pass the translated text to ElevenLabs with
`model_id: "eleven_multilingual_v2"` so the voice speaks naturally in that
language. Default the select to English so the demo works without a click.

USER FLOW (the entire app — nothing else exists)
1. Land on the page; the headline previews what the demo does for intimacy coordination.
2. The primary action (a microphone button that opens a back-and-forth voice conversation with an agent tuned for the discipline) is one tap away; the rest of the layout supports it.
3. Lovable AI does the thinking, ElevenLabs handles the voice surface, and the
   result (audio + any text) stays on screen so the user can retry or share.

KEYS — both already provided to participants for free:
1. `LOVABLE_API_KEY` (the AI brain). Auto-injected in every Lovable project.
   Read it only on the server via `process.env.LOVABLE_API_KEY`. Never prefix
   with `VITE_` and never expose to the client.
2. `ELEVENLABS_API_KEY` (the voice). Best path: ask Lovable to connect the
   ElevenLabs standard connector — it syncs the key automatically and rotates
   from the dashboard. Fallback: paste a key from
   https://elevenlabs.io/app/settings/api-keys into Project Settings -> Secrets.
   Read it only on the server, header `xi-api-key`, never prefix with `VITE_`.

CREDIT (must appear in UI footer AND as JSDoc on the server function):
Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14

Market sizing.

Indicative figures for hackathon pitches — refine with your own research before raising.