Diagram test

I’m collecting concepts that we definitely have here with the intention of creating some kind of interactive diagram pipeline machine later.

System Architecture ASCII

                      ┌───────────────────────────────────────┐
                      │               Memory                  │
                      │                                       │
                      │  ┌─────────┐       ┌────────────┐    │
                      │  │Messages │       │LevelStates │    │
                      │  └─────────┘       └────────────┘    │
                      │       ▲                 ▲            │
                      │       │                 │            │
                      │  ┌────┴─────┐     ┌─────┴────┐       │
┌──────────┐          │  │ Message  │     │Evaluation│       │    ┌────────────┐
│  User    │◀─────────┼──┤Processing│     │  Engine  │       │    │   Level    │
│Interface │          │  │          │     │          │       │    │Components  │
└──────────┘          │  └──────────┘     └──────────┘       │    └────────────┘
     │                │       │                 │            │         │
     │                │       │                 │            │         │
     ▼                │  ┌────▼─────┐     ┌─────▼────┐       │         │
┌──────────┐    ┌─────┴─▶│   ask()  │     │ evaluate │◀──────┼─────────┘
│ Input/   │    │     │  │ Function │     │ Function │       │
│ Output   │────┘     │  └──────────┘     └──────────┘       │
└──────────┘          │                                       │
                      └───────────────────────────────────────┘

classDiagram
direction TD
    class Memory {
      +settings
      +scenario : Scenario
      +messages : Message[*]
      +systemMessages : Message[*]
      +levelStates : LevelState[*]
      +changeLevel(level)
      +createMessage(role, content, level)
      +addMessage(msg)
      +addSystemMessage(msg)
      +prepareLevelContext(level)
      +evaluateLevel()
      +reviewPerformance()
      +adaptPersona(Persona)
      +reset()
      +clearLevel(level)
      -refreshSummaries(level)
      -summariseLevel(level)
    }

    class Scenario {
      +preferences : Preferences
      +systemNpc : Persona
      +humanNpc : Persona
      +levels : Level[1..*]
      +levelNumber
    }

    class Persona {
      +name
      +description
      +voice
      +meta
    }

    class Preferences {
      +difficulty
    }

    class Level {
      +type : LevelType
      +title
      +description
      +briefing
      +winCondition
      +lossCondition
      +system
      +capabilities : LevelCapabilities
    }

    class LevelState {
      +summary : string
      +evaluation : Evaluation
    }

    class Evaluation {
      +levelComplete
      +levelFailed
      +progress
      +feedback
    }

    class LevelType {
      chat
      systemChat
      humanMatcher
      dateBuilder
      voiceBuilder
    }

    class LevelCapabilities {
      +text : boolean
      +voice : boolean
    }

    class Message {
      +role
      +content
      +contentJson
      +ooc
      +settings
      +input
      +level
      +usage
      +costs
    }

    class ContentJson {
      +reply
      +innerMonologue
      +mood
      +progress
      +levelComplete
      +levelFailed
    }

    class Prompts {
      +promptHumanChat()
      +promptSystemChat()
      +promptSystemEvaluation()
      +promptSystemReview()
      +promptHumanImage()
    }

  <<enumeration>> LevelType

    PromptTemplates : +promptHumanChat()

    Memory --> Scenario
    Scenario <-- Level
    Scenario <-- Persona
    LevelState --> Evaluation
    Level --> LevelCapabilities
    Message --> ContentJson

flowchart TD
    Start([evaluateLevel])
    Check{Summaries up-to-date?}
    Refresh[Summarise level]
    Prompt[Build evaluation prompt]
    LLM[Call LLM]
    Eval[Parse LLM response]
    Save[Update memory.levelState]

    Start --> Check
    Check -- Yes --> Prompt
    Check -- No --> Refresh --> Check
    Prompt --Message--> LLM --> Eval --LevelState--> Save