Core integration

# glados/core.py
from typing import Callable, Optional

Transcriber = Callable[[str], str]
Thinker = Callable[[str, list[dict]], str]

class GladOSCore:
    def __init__(self, stt: Optional[Transcriber] = None,
                 llm: Optional[Thinker] = None) -> None:
        self.stt = stt
        self.llm = llm
        self.history: list[dict] = []

    def process(self, audio_path: str) -> str:
        if self.stt is None:
            return ""
        return self.stt(audio_path)

    def respond(self, text: str) -> str:
        if self.llm is None:
            return f"[GLaDOS] Received: {text}"
        return self.llm(text, self.history)

if __name__ == "__main__":
    core = GladOSCore()
    print(repr(core.process("glados/data/heard.wav")))
    print(core.respond("hello"))

$ uv run python glados/core.py
''
[GLaDOS] Received: hello

The first version of the core is deliberately the emptiest one: no arguments passed, no models installed, and it still produces output. process returning "" when there is no listener is a promise the rest of the loop will lean on, because "no listener" and "five seconds of room tone" should behave identically downstream. The repr() in the demo lets you see the empty string instead of a blank line.

Speaker = Callable[[str], None]

class GladOSCore:
    def __init__(self, stt: Optional[Transcriber] = None,
                 llm: Optional[Thinker] = None,
                 tts: Optional[Speaker] = None) -> None:
        self.stt = stt
        self.llm = llm
        self.tts = tts
        self.history: list[dict] = []

    def speak(self, text: str) -> None:
        if self.tts is None:
            print(f"[TTS] {text}")
            return
        self.tts(text)

if __name__ == "__main__":
    GladOSCore().speak("No voice engine wired in yet.")

$ uv run python glados/core.py
[TTS] No voice engine wired in yet.

Each fallback answers a design question about what absence should mean. For a missing listener, silence. For a missing brain, an echo you can recognise as a placeholder. For a missing voice, a printed line, because raising here would make the loop unrunnable on any machine without F5-TTS loaded, and that is most machines most of the time. The prefix [TTS] keeps a headless transcript readable beside a spoken one.

MAX_TURNS = 20

    def run_turn(self, audio_path: str) -> bool:
        text = self.process(audio_path)
        if not text.strip():
            return False
        print(f"You: {text}")
        reply = self.respond(text)
        print(f"GLaDOS: {reply}")
        self.speak(reply)
        self.history.append({"role": "user", "content": text})
        self.history.append({"role": "assistant", "content": reply})
        self.history = self.history[-2 * MAX_TURNS:]
        return True

if __name__ == "__main__":
    def fake_stt(path: str) -> str:
        return "Hello GLaDOS"

    def fake_llm(text: str, history: list[dict]) -> str:
        return f"Oh. It's you again. ({len(history)} messages remembered)"

    def fake_tts(text: str) -> None:
        print(f"[SPEAKING] {text}")

    core = GladOSCore(stt=fake_stt, llm=fake_llm, tts=fake_tts)
    core.run_turn("glados/data/heard.wav")
    core.run_turn("glados/data/heard.wav")
    print(f"history holds {len(core.history)} messages")

$ uv run python glados/core.py
You: Hello GLaDOS
GLaDOS: Oh. It's you again. (0 messages remembered)
[SPEAKING] Oh. It's you again. (0 messages remembered)
You: Hello GLaDOS
GLaDOS: Oh. It's you again. (2 messages remembered)
[SPEAKING] Oh. It's you again. (2 messages remembered)
history holds 4 messages

A complete conversational turn just ran twice with no model on the machine, in the time it took Python to start. Three details carry weight. The empty-transcript guard returns False instead of None, so a caller can count real turns without inspecting anything else. History stores one message per speaker in the role-and-content form Ollama expects, so it can be passed straight through to a chat call with no translation at the boundary. And the slice from chapter 29 caps it: forty messages, twenty exchanges, evicted oldest-first by the same one-line trick that bounded the sensor log. Nothing here says the word Whisper, and the fake brain proves history reaches the brain by counting it.

# labs/wire_core.py
import json
from pathlib import Path

import ollama
import sounddevice as sd
import soundfile as sf
from f5_tts.api import F5TTS
from faster_whisper import WhisperModel

from glados.core import GladOSCore
from labs.system_config import SystemConfig, build_default_config

from labs.glados_voice import REF_FILE, REF_TEXT
AUDIO_OUT = "glados/data/glados_says.wav"

def build_core(config: SystemConfig) -> GladOSCore:
    stt_cfg = config.get_component("stt").settings
    llm_cfg = config.get_component("llm").settings
    tts_cfg = config.get_component("tts").settings
    persona = json.loads(Path("configs/personality.json").read_text())

    print(f"Loading whisper {stt_cfg['model']} on {stt_cfg['device']}...")
    whisper = WhisperModel(stt_cfg["model"], device=stt_cfg["device"],
                           compute_type=stt_cfg["compute_type"])
    print("Loading F5-TTS...")
    tts = F5TTS(device=tts_cfg.get("device"))

    def transcribe(path: str) -> str:
        segments, _ = whisper.transcribe(path, language="en")
        return " ".join(s.text.strip() for s in segments)

    def think(text: str, history: list[dict]) -> str:
        messages = [{"role": "system", "content": persona["system_prompt"]}]
        messages += history + [{"role": "user", "content": text}]
        response = ollama.chat(model=llm_cfg["model"], messages=messages)
        return response["message"]["content"]

    def synthesize(text: str) -> None:
        tts.infer(ref_file=REF_FILE, ref_text=REF_TEXT, gen_text=text,
                  file_wave=AUDIO_OUT, remove_silence=True)
        data, sample_rate = sf.read(AUDIO_OUT)
        sd.play(data, sample_rate)
        sd.wait()

    return GladOSCore(stt=transcribe, llm=think, tts=synthesize)

if __name__ == "__main__":
    core = build_core(build_default_config())
    core.run_turn("glados/data/heard.wav")

$ uv run python labs/wire_core.py
Loading whisper base on cpu...
Loading F5-TTS...
You: Are you awake in there?
GLaDOS: I was. Then you spoke.

Every import that costs a gigabyte lives in this file, and none of them live in glados/core.py. build_core is the composition root: the one place that knows which concrete engines exist, reads their settings out of the registry, constructs them once, and closes over them in three small functions with the signatures the core expects. Your reply text will differ from the one above, and so will your timings; the wiring will not. Note what the closures buy you. transcribe captures whisper, so the model loads once even though the function runs every turn, and the core never learns a model was involved.