Initial Oneironauts MVP: text input, branching at depth 4, closing scene + journal interpretation

.gitignore

@@ -0,0 +1,9 @@
+__pycache__/
+*.pyc
+.venv/
+venv/
+.env
+.modal.toml
+hello_modal.py
+gpu_test.py
+llama_test.py

README.md

@@ -0,0 +1,33 @@
+---
+title: Oneironauts
+emoji: 🌙
+colorFrom: purple
+colorTo: indigo
+sdk: gradio
+sdk_version: 4.44.1
+app_file: app.py
+pinned: false
+license: mit
+short_description: A fragment of a dream becomes a branching exploration.
+tags:
+  - gradio
+  - build-small-hackathon
+  - llama
+  - modal
+---
+
+# Oneironauts
+
+A fragment of a half-remembered dream becomes a branching, exploratory narrative. Type a fragment, walk through scenes the dream weaver generates, make choices that shape where the dream goes, and end with a journal-voice interpretation.
+
+Built for the Hugging Face Build Small Hackathon, Track 2.
+
+## Stack
+
+- **Llama 3.2 3B Instruct** served as a persistent Modal endpoint (A10G)
+- **Gradio** frontend
+- Branching state managed via `gr.State`, 4-level depth
+
+## Status
+
+Work in progress — voice input (Whisper) and UI polish coming.

app.py

@@ -0,0 +1,165 @@
+import gradio as gr
+import modal
+
+import os
+if not os.getenv("MODAL_TOKEN_ID") and not os.path.exists(os.path.expanduser("~/.modal.toml")):
+    raise RuntimeError(
+        "Modal credentials missing. Set MODAL_TOKEN_ID and MODAL_TOKEN_SECRET, "
+        "or run `modal token new` locally."
+    )
+
+print("[oneironauts] connecting to Modal endpoint...")
+DreamWeaver = modal.Cls.from_name("oneironauts", "DreamWeaver")
+weaver = DreamWeaver()
+print("[oneironauts] ready")
+
+MAX_DEPTH = 4
+
+
+def start_dream(fragment, state):
+    if not fragment.strip():
+        return (
+            state,
+            gr.update(value="Please enter a dream fragment first.", visible=True),
+            "—", "—", "—",
+            gr.update(visible=False),
+            gr.update(visible=True),
+            gr.update(visible=False),
+            "", "",
+        )
+
+    print(f"[oneironauts] generating opening scene...")
+    result = weaver.generate.remote(fragment)
+    print(f"[oneironauts] opening done")
+
+    state = {
+        "fragment": fragment,
+        "history": [result["scene"]],
+        "depth": 1,
+    }
+    choices = result["choices"]
+    return (
+        state,
+        gr.update(value=result["scene"], visible=True),
+        choices[0], choices[1], choices[2],
+        gr.update(visible=True),
+        gr.update(visible=False),
+        gr.update(visible=False),
+        "", "",
+    )
+
+
+def pick_choice(choice_text, state):
+    state["history"].append(f"Chose: {choice_text}")
+
+    if state["depth"] >= MAX_DEPTH:
+        print(f"[oneironauts] closing dream...")
+        closing = weaver.close_dream.remote(
+            state["fragment"],
+            state["history"],
+            choice_text,
+        )
+        print(f"[oneironauts] closing done")
+        return (
+            state,
+            gr.update(value=closing["scene"], visible=True),
+            "—", "—", "—",
+            gr.update(visible=False),
+            gr.update(visible=True),
+            closing["interpretation"],
+        )
+
+    print(f"[oneironauts] continuing at depth {state['depth']}...")
+    result = weaver.continue_dream.remote(
+        state["fragment"],
+        state["history"],
+        choice_text,
+    )
+    state["history"].append(result["scene"])
+    state["depth"] += 1
+    choices = result["choices"]
+    return (
+        state,
+        gr.update(value=result["scene"], visible=True),
+        choices[0], choices[1], choices[2],
+        gr.update(visible=True),
+        gr.update(visible=False),
+        "",
+    )
+
+
+def reset_dream():
+    return (
+        {},
+        gr.update(visible=True),
+        gr.update(visible=False),
+        gr.update(visible=False),
+        gr.update(value="", visible=False),
+        "",
+        "",
+    )
+
+
+with gr.Blocks(title="Oneironauts") as demo:
+    gr.Markdown("# Oneironauts\nA fragment of a dream becomes a branching exploration.")
+
+    state = gr.State({})
+
+    with gr.Column(visible=True) as input_panel:
+        fragment_box = gr.Textbox(
+            label="Describe a fragment of a dream",
+            placeholder="I was walking down stairs that wouldn't end...",
+            lines=3,
+        )
+        start_btn = gr.Button("Begin", variant="primary")
+
+    scene = gr.Markdown(visible=False)
+
+    with gr.Column(visible=False) as choices_panel:
+        gr.Markdown("**Where do you go?**")
+        btn_a = gr.Button("A")
+        btn_b = gr.Button("B")
+        btn_c = gr.Button("C")
+
+    with gr.Column(visible=False) as ending_panel:
+        gr.Markdown("---")
+        gr.Markdown("### Dream journal")
+        interpretation_box = gr.Markdown()
+        reset_btn = gr.Button("Begin a new dream", variant="primary")
+
+    start_btn.click(
+        start_dream,
+        inputs=[fragment_box, state],
+        outputs=[
+            state, scene,
+            btn_a, btn_b, btn_c,
+            choices_panel, input_panel, ending_panel,
+            interpretation_box, fragment_box,
+        ],
+    )
+
+    for btn in (btn_a, btn_b, btn_c):
+        btn.click(
+            pick_choice,
+            inputs=[btn, state],
+            outputs=[
+                state, scene,
+                btn_a, btn_b, btn_c,
+                choices_panel, ending_panel,
+                interpretation_box,
+            ],
+        )
+
+    reset_btn.click(
+        reset_dream,
+        inputs=[],
+        outputs=[
+            state,
+            input_panel, choices_panel, ending_panel,
+            scene, interpretation_box, fragment_box,
+        ],
+    )
+
+
+if __name__ == "__main__":
+    demo.launch()

llama_endpoint.py

@@ -0,0 +1,214 @@
+import modal
+
+image = (
+    modal.Image.debian_slim()
+    .pip_install(
+        "torch==2.4.0",
+        "transformers==4.45.0",
+        "accelerate==1.0.0",
+        "huggingface_hub==0.25.0",
+        "fastapi[standard]",
+    )
+)
+
+app = modal.App("oneironauts")
+
+
+@app.cls(
+    image=image,
+    gpu="A10G",
+    secrets=[modal.Secret.from_name("huggingface-secret")],
+    scaledown_window=300,
+    timeout=600,
+)
+class DreamWeaver:
+    @modal.enter()
+    def load(self):
+        import torch
+        from transformers import AutoModelForCausalLM, AutoTokenizer
+
+        model_id = "meta-llama/Llama-3.2-3B-Instruct"
+        self.tokenizer = AutoTokenizer.from_pretrained(model_id)
+        self.model = AutoModelForCausalLM.from_pretrained(
+            model_id,
+            torch_dtype=torch.bfloat16,
+            device_map="auto",
+        )
+
+    def _parse(self, raw: str):
+        if "CHOICES:" not in raw:
+            return {"scene": raw.strip(), "choices": []}
+
+        scene_part, choices_part = raw.split("CHOICES:", 1)
+        scene = scene_part.replace("SCENE:", "").strip()
+
+        choices = []
+        for line in choices_part.strip().splitlines():
+            line = line.strip()
+            if not line:
+                continue
+            for prefix in ("A)", "B)", "C)", "A.", "B.", "C."):
+                if line.startswith(prefix):
+                    choices.append(line[len(prefix):].strip())
+                    break
+        return {"scene": scene, "choices": choices[:3]}
+
+    @modal.method()
+    def generate(self, dream_fragment: str) -> dict:
+        system_prompt = (
+            "You are a dream weaver. Given a fragment of a dream, write a vivid, "
+            "atmospheric scene that expands on it. The scene must be EXACTLY 2 short "
+            "paragraphs, 3-4 sentences each. Then provide exactly 3 choices the "
+            "dreamer can take next, each ONE short sentence (max 15 words).\n\n"
+            "Format:\n"
+            "SCENE:\n<scene text>\n\nCHOICES:\nA) <choice>\nB) <choice>\nC) <choice>"
+        )
+
+        messages = [
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": f"Dream fragment: {dream_fragment}"},
+        ]
+
+        inputs = self.tokenizer(
+            self.tokenizer.apply_chat_template(messages, add_generation_prompt=True, tokenize=False),
+            return_tensors="pt",
+        ).to(self.model.device)
+
+        outputs = self.model.generate(
+            **inputs,
+            max_new_tokens=600,
+            do_sample=True,
+            temperature=0.9,
+            top_p=0.95,
+            pad_token_id=self.tokenizer.eos_token_id,
+        )
+
+        raw = self.tokenizer.decode(
+            outputs[0][inputs.input_ids.shape[1]:],
+            skip_special_tokens=True,
+        )
+        return self._parse(raw)
+    @modal.method()
+    def continue_dream(self, original_fragment: str, history: list, choice: str) -> dict:
+        system_prompt = (
+            "You are a dream weaver continuing an ongoing dream. The dreamer made "
+            "a choice and the dream must continue from that choice, growing stranger "
+            "and more dreamlike. Settings can morph mid-scene. Logic can bend. "
+            "Things should NOT resolve helpfully — complications deepen.\n\n"
+            "Write EXACTLY 2 short paragraphs (3-4 sentences each), then 3 new "
+            "choices, each ONE short sentence (max 15 words).\n\n"
+            "Format:\n"
+            "SCENE:\n<scene text>\n\nCHOICES:\nA) <choice>\nB) <choice>\nC) <choice>"
+        )
+
+        history_text = "\n".join(
+            f"- {entry}" for entry in history
+        )
+
+        user_msg = (
+            f"Original dream fragment: {original_fragment}\n\n"
+            f"What has happened so far:\n{history_text}\n\n"
+            f"The dreamer just chose: {choice}\n\n"
+            f"Continue the dream from this choice."
+        )
+
+        messages = [
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": user_msg},
+        ]
+
+        inputs = self.tokenizer(
+            self.tokenizer.apply_chat_template(messages, add_generation_prompt=True, tokenize=False),
+            return_tensors="pt",
+        ).to(self.model.device)
+
+        outputs = self.model.generate(
+            **inputs,
+            max_new_tokens=600,
+            do_sample=True,
+            temperature=0.95,
+            top_p=0.95,
+            pad_token_id=self.tokenizer.eos_token_id,
+        )
+
+        raw = self.tokenizer.decode(
+            outputs[0][inputs.input_ids.shape[1]:],
+            skip_special_tokens=True,
+        )
+        return self._parse(raw)
+    @modal.method()
+    def close_dream(self, original_fragment: str, history: list, final_choice: str) -> dict:
+        system_prompt = (
+            "You are a dream weaver bringing a dream to its end. The dreamer just "
+            "made a final choice. Write ONE closing scene that uses their choice and "
+            "ends the dream the way dreams actually end — fading, dissolving, or "
+            "hitting a moment of strange clarity before slipping away. Do NOT resolve "
+            "the story logically. Do NOT add choices at the end.\n\n"
+            "Then, on a new section, write a short interpretation in the voice of "
+            "someone writing in their dream journal the next morning, 2-3 sentences, "
+            "reflective and a little uncertain. Reference what the dreamer chose.\n\n"
+            "Format:\n"
+            "SCENE:\n<closing scene, 2 short paragraphs>\n\n"
+            "INTERPRETATION:\n<2-3 sentences in journal voice>"
+        )
+
+        history_text = "\n".join(f"- {entry}" for entry in history)
+
+        user_msg = (
+            f"Original dream fragment: {original_fragment}\n\n"
+            f"What has happened so far:\n{history_text}\n\n"
+            f"The dreamer's final choice: {final_choice}\n\n"
+            f"End the dream."
+        )
+
+        messages = [
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": user_msg},
+        ]
+
+        inputs = self.tokenizer(
+            self.tokenizer.apply_chat_template(messages, add_generation_prompt=True, tokenize=False),
+            return_tensors="pt",
+        ).to(self.model.device)
+
+        outputs = self.model.generate(
+            **inputs,
+            max_new_tokens=500,
+            do_sample=True,
+            temperature=0.85,
+            top_p=0.95,
+            pad_token_id=self.tokenizer.eos_token_id,
+        )
+
+        raw = self.tokenizer.decode(
+            outputs[0][inputs.input_ids.shape[1]:],
+            skip_special_tokens=True,
+        )
+        return self._parse_closing(raw)
+
+    def _parse_closing(self, raw: str):
+        if "INTERPRETATION:" not in raw:
+            return {"scene": raw.strip(), "interpretation": ""}
+
+        scene_part, interp_part = raw.split("INTERPRETATION:", 1)
+        scene = scene_part.replace("SCENE:", "").strip()
+        interpretation = interp_part.strip()
+        return {"scene": scene, "interpretation": interpretation}
+
+
+@app.local_entrypoint()
+def main():
+    import json
+    weaver = DreamWeaver()
+    fragment = "I was in an elevator that kept going up past my floor, and the buttons rearranged themselves every time I looked away"
+
+    print("=== OPENING ===")
+    opening = weaver.generate.remote(fragment)
+    print(json.dumps(opening, indent=2))
+
+    print("\n=== DEPTH 1 ===")
+    choice = opening["choices"][2]
+    history = [opening["scene"], f"Chose: {choice}"]
+    next_scene = weaver.continue_dream.remote(fragment, history, choice)
+    print(f"Chose: {choice}\n")
+    print(json.dumps(next_scene, indent=2))

requirements.txt

@@ -0,0 +1,2 @@
+gradio==4.44.1
+modal==0.66.0