Prepare 1.19.2 release

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

.github/workflows/ci.yml

@@ -0,0 +1,26 @@
+name: CI
+on:
+  workflow_dispatch:
+  pull_request:
+    branches: [ "main" ]
+  push:
+    branches:
+      - "**"
+    tags: [ "v*" ]
+permissions:
+  contents: read
+  pull-requests: read
+concurrency:
+  group: ci-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+jobs:
+  test-and-clippy:
+    name: Unit testing and linting
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+      - uses: dtolnay/rust-toolchain@1.93.0
+      - name: Install SQLite3
+        run: sudo apt-get update && sudo apt-get install -y libsqlite3-dev
+      - run: cargo test --all-features
+      - run: cargo clippy

.github/workflows/publish.yml

@@ -0,0 +1,124 @@
+name: Publish
+on:
+  workflow_run:
+    workflows: [ "CI" ]
+    types: [ "completed" ]
+permissions:
+  contents: read
+concurrency:
+  group: publish-${{ github.event.workflow_run.id || github.ref }}
+  cancel-in-progress: false
+jobs:
+  docker-clean-metadata:
+    if: |
+      github.event.workflow_run.conclusion == 'success' &&
+      github.event.workflow_run.event == 'push' &&
+      (
+        github.event.workflow_run.head_branch == 'main' ||
+        startsWith(github.event.workflow_run.head_branch || '', 'v')
+      )
+    runs-on: ubuntu-latest
+    outputs:
+      json: ${{ steps.meta.outputs.json }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v6
+        with:
+          ref: ${{ github.event.workflow_run.head_sha }}
+          fetch-depth: 0
+      - name: Extract metadata (tags, labels) for Docker
+        id: meta
+        uses: docker/metadata-action@v6
+        with:
+          images: |
+            ghcr.io/${{ github.repository }}
+          tags: |
+            type=raw,value=latest,enable=${{ github.event.workflow_run.head_branch == 'main' }}
+            type=semver,pattern={{raw}},value=${{ github.event.workflow_run.head_branch }},enable=${{ startsWith(github.event.workflow_run.head_branch || '', 'v') }}
+
+  docker-build:
+    if: |
+      github.event.workflow_run.conclusion == 'success' &&
+      github.event.workflow_run.event == 'push' &&
+      (
+        github.event.workflow_run.head_branch == 'main' ||
+        startsWith(github.event.workflow_run.head_branch || '', 'v')
+      )
+    permissions:
+      contents: read
+      packages: write
+      attestations: write
+      id-token: write
+    strategy:
+      matrix:
+        include:
+          - os: self-hosted
+            arch: amd64
+          - os: ubuntu-24.04-arm
+            arch: arm64
+
+    runs-on: ${{ matrix.os }}
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v6
+        with:
+          ref: ${{ github.event.workflow_run.head_sha }}
+          fetch-depth: 0
+      - name: Log in to the GitHub Container registry
+        uses: docker/login-action@v4
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+      - name: Extract metadata (tags, labels) for Docker
+        id: meta
+        uses: docker/metadata-action@v6
+        with:
+          tags: |
+            type=raw,value=latest,enable=${{ github.event.workflow_run.head_branch == 'main' }}
+            type=semver,pattern={{raw}},value=${{ github.event.workflow_run.head_branch }},enable=${{ startsWith(github.event.workflow_run.head_branch || '', 'v') }}
+          flavor: |
+            latest=auto
+            suffix=-${{ matrix.arch }},onlatest=true
+          images: |
+            ghcr.io/${{ github.repository }}
+
+      - name: Build and push Docker images
+        uses: docker/build-push-action@v7
+        with:
+          push: true
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
+
+  docker-manifest:
+    if: |
+      github.event.workflow_run.conclusion == 'success' &&
+      github.event.workflow_run.event == 'push' &&
+      (
+        github.event.workflow_run.head_branch == 'main' ||
+        startsWith(github.event.workflow_run.head_branch || '', 'v')
+      )
+    permissions:
+      contents: read
+      packages: write
+    needs:
+      - docker-build
+      - docker-clean-metadata
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        image: ${{ fromJson(needs.docker-clean-metadata.outputs.json).tags }}
+
+    steps:
+      - name: Log in to the GitHub Container registry
+        uses: docker/login-action@v4
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Create and push manifest
+        run: |
+          docker buildx imagetools create -t ${{ matrix.image }} ${{ matrix.image }}-amd64 ${{ matrix.image }}-arm64

.github/workflows/workflow.yml

@@ -1,107 +0,0 @@
-name: CI (main and tags)
-on:
-  push:
-    branches: [ "main" ]
-    tags: [ "v*" ]
-permissions:
-  checks: write
-  contents: write
-  packages: write
-  pull-requests: read
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: false
-jobs:
-  test-and-clippy:
-    name: Unit testing and linting
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: dtolnay/rust-toolchain@stable
-      - name: Install SQLite3
-        run: sudo apt-get update && sudo apt-get install -y libsqlite3-dev
-      - run: cargo test --all-features
-      - run: cargo clippy
-
-  docker-clean-metadata:
-    runs-on: ubuntu-latest
-    outputs:
-      json: ${{ steps.meta.outputs.json }}
-    steps:
-      - name: Extract metadata (tags, labels) for Docker
-        id: meta
-        uses: docker/metadata-action@v5
-        with:
-          images: |
-            ghcr.io/${{ github.repository }}
-          tags: |
-            type=raw,value=latest,enable=${{ github.ref_name == 'main' }}
-            type=semver,pattern={{raw}}
-
-  docker-build:
-    permissions:
-      contents: read
-      packages: write
-      attestations: write
-      id-token: write
-    strategy:
-      matrix:
-        include:
-          - os: self-hosted
-            arch: amd64
-          - os: ubuntu-24.04-arm
-            arch: arm64
-
-    runs-on: ${{ matrix.os }}
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-      - name: Log in to the GitHub Container registry
-        uses: docker/login-action@v3
-        with:
-          registry: ghcr.io
-          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-      - name: Extract metadata (tags, labels) for Docker
-        id: meta
-        uses: docker/metadata-action@v5
-        with:
-          tags: |
-            type=raw,value=latest,enable=${{ github.ref_name == 'main' }}
-            type=semver,pattern={{raw}}
-          flavor: |
-            latest=auto
-            suffix=-${{ matrix.arch }},onlatest=true
-          images: |
-            ghcr.io/${{ github.repository }}
-
-      - name: Build and push Docker images
-        uses: docker/build-push-action@v6
-        with:
-          push: true
-          tags: ${{ steps.meta.outputs.tags }}
-          labels: ${{ steps.meta.outputs.labels }}
-
-  docker-manifest:
-    needs:
-      - docker-build
-      - docker-clean-metadata
-    runs-on: ubuntu-latest
-
-    strategy:
-      matrix:
-        image: ${{ fromJson(needs.docker-clean-metadata.outputs.json).tags }}
-
-    steps:
-      - name: Log in to the GitHub Container registry
-        uses: docker/login-action@v3
-        with:
-          registry: ghcr.io
-          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Create and push manifest
-        run: |
-          docker manifest create ${{ matrix.image }} ${{ matrix.image }}-amd64 ${{ matrix.image }}-arm64
-          docker manifest push ${{ matrix.image }}

.pre-commit-config.yaml

@@ -0,0 +1,36 @@
+repos:
+  # Fast built-in hooks (Rust-native, no dependencies)
+  - repo: builtin
+    hooks:
+      - id: trailing-whitespace
+      - id: end-of-file-fixer
+      - id: check-yaml
+      - id: check-merge-conflict
+      - id: check-added-large-files
+        args: ['--maxkb=1024']
+
+  # Local hooks that run project-specific tools
+  - repo: local
+    hooks:
+      - id: cargo-fmt-check
+        name: Cargo Format Check
+        entry: cargo fmt --all -- --check
+        language: system
+        files: '\.rs$'
+        pass_filenames: false
+
+      - id: cargo-clippy
+        name: Cargo Clippy
+        entry: cargo clippy -- -D warnings
+        language: system
+        files: '\.rs$'
+        pass_filenames: false
+        priority: 100
+
+      - id: test-unit
+        name: Unit Tests
+        entry: just test
+        language: system
+        files: '\.rs$'
+        pass_filenames: false
+        priority: 100

CHANGELOG.md

@@ -1,3 +1,91 @@
+# (2026-05-21) Version 1.19.2
+
+- (**Internal Improvement**) Update [async-openai](https://crates.io/crates/async-openai) to 0.40.0.
+
+- (**Internal Improvement**) Dependency updates.
+
+
+# (2026-05-09) Version 1.19.1
+
+- (**Internal Improvement**) Update [async-openai](https://crates.io/crates/async-openai) to 0.38.0.
+
+- (**Internal Improvement**) Dependency updates.
+
+
+# (2026-05-09) Version 1.19.0
+
+- (**Internal Improvement**) Update [matrix-sdk](https://crates.io/crates/matrix-sdk) from 0.16 to 0.17 and [mxlink](https://crates.io/crates/mxlink) to 1.14.0. matrix-sdk 0.17 dropped its `native-tls` feature and now uses [rustls](https://github.com/rustls/rustls) exclusively as its TLS backend.
+
+- (**Internal Improvement**) Bump the pinned Rust toolchain from 1.93.0 to 1.95.0 (in `rust-toolchain.toml` and the Docker build images).
+
+- (**Internal Improvement**) Dependency updates.
+
+
+# (2026-04-11) Version 1.18.0
+
+- (**Bugfix**) Fix the bot not sending a welcome message when joining a room on homeservers (like [Continuwuity](https://continuwuity.org/)) that place the join membership event in the sync response's `state` block rather than the `timeline` block, via [mxlink](https://crates.io/crates/mxlink) 1.13.1
+
+- (**Improvement**) Update [tiktoken-rs](https://crates.io/crates/tiktoken-rs) to 0.11, adding tokenization support for newer GPT models (gpt-5.x, codex, etc.) and fixing context sizes for o1-mini/chatgpt-4o/gpt-4.5
+
+- (**Internal Improvement**) Dependency updates
+
+
+# (2026-03-25) Version 1.17.0
+
+- (**Feature**) Add `text-generation sender-context-mode` for attaching sender metadata to conversation messages. See the [💬 Text Generation](./docs/configuration/text-generation.md#-sender-context-mode) documentation for details. Thanks to [kschwank](https://github.com/kschwank) for the contribution in [#104](https://github.com/etkecc/baibot/pull/104)!
+
+
+# (2026-03-24) Version 1.16.1
+
+- (**Bugfix**) Fix compatibility with [async-openai](https://crates.io/crates/async-openai) 0.34.0 by populating the new `phase` field required for OpenAI Responses API message inputs. baibot does not currently distinguish between assistant `commentary` and `final_answer` turns, so using `None` preserves the previous behavior while remaining compatible with the updated crate.
+
+- (**Internal Improvement**) Dependency updates.
+
+
+# (2026-03-20) Version 1.16.0
+
+- (**Feature**) Add support for file attachments (`m.file` Matrix messages) in conversations. Files like PDFs, text documents, spreadsheets, code files, etc. are now downloaded and forwarded to the LLM alongside the conversation context, similar to how images (`m.image`) are already handled. See the [💬 Text Generation](./docs/features.md#-text-generation) documentation for details and known limitations.
+
+- (**Improvement**) Use the [mime_guess](https://crates.io/crates/mime_guess) crate for MIME type detection from file extensions, replacing a hand-maintained mapping. This covers hundreds of file extensions out of the box.
+
+
+
+# (2026-03-07) Version 1.15.0
+
+- (**Feature**) Add support for authentication via access tokens (for [Matrix Authentication Service](https://github.com/element-hq/matrix-authentication-service)/OIDC-enabled homeservers) as an alternative to password authentication. See [🔐 Authentication](./docs/configuration/authentication.md) for setup details. Thanks to [Taylor Southwick](https://github.com/twsouthwick) for the contribution in [#83](https://github.com/etkecc/baibot/pull/83)!
+
+- (**Internal Improvement**) Pin the Rust toolchain to `1.93.0` in both CI and local development to avoid `matrix-sdk` build failures on newer stable toolchains.
+
+- (**Internal Improvement**) Documentation updates.
+
+- (**Internal Improvement**) Dependency updates.
+
+
+# (2026-02-18) Version 1.14.3
+
+- (**Internal Improvement**) Add [Renovate](https://docs.renovatebot.com/) configuration for automated dependency updates
+
+- (**Internal Improvement**) Dependency updates
+
+
+# (2026-02-18) Version 1.14.2
+
+- (**Internal Improvement**) Dependency updates
+
+- (**Internal Improvement**) Reorganize the development environment to support [Continuwuity](https://continuwuity.org/) as a homeserver choice (in addition to [Synapse](https://github.com/element-hq/synapse)). Continuwuity is now the default for its lighter footprint (no external database required). See [development docs](./docs/development.md) for details.
+
+
+# (2026-02-10) Version 1.14.1
+
+- (**Security**) Dependency updates to fix security vulnerabilities ([time](https://crates.io/crates/time) stack exhaustion DoS, [bytes](https://crates.io/crates/bytes) integer overflow), via [mxlink](https://crates.io/crates/mxlink) 1.12.0
+
+- (**Internal Improvement**) Switch from deprecated [serde_yaml](https://crates.io/crates/serde_yaml) to its maintained fork [serde_yaml_ng](https://crates.io/crates/serde_yaml_ng)
+
+- (**Internal Improvement**) Add [prek](https://github.com/nicholasgasior/prek) pre-commit hooks via [mise](https://mise.jdx.dev/) for automated code quality checks (formatting, clippy, tests)
+
+- (**Internal Improvement**) Fix clippy warnings and formatting issues
+
+
 # (2026-02-04) Version 1.14.0
 
 - (**Feature**) The `openai` provider now uses OpenAI's [Responses API](https://platform.openai.com/docs/api-reference/responses) (instead of the older Chat Completions API), adding support for [🛠️ built-in tools](./docs/features.md#️-built-in-tools-openai-only) (`web_search` and `code_interpreter`). These tools are **disabled by default** and can be enabled via the `text_generation.tools` configuration (see the [sample configuration](https://github.com/etkecc/baibot/blob/c70387b0c38d8d0f30bba2179a2a21a3710dbeaf/docs/sample-provider-configs/openai.yml#L12-L15)). To enable tools on an existing agent, you need to [update the agent](./docs/agents.md#updating-agents) to re-create it with the `text_generation.tools` section added and enable the tools you need. Thanks to [Layla Manley](https://github.com/yeslayla) for the contribution in [#62](https://github.com/etkecc/baibot/pull/62)!

Cargo.toml

@@ -7,7 +7,7 @@ license = "AGPL-3.0-or-later"
 readme = "README.md"
 keywords = ["matrix", "chat", "bot", "AI", "LLM"]
 include = ["/etc/assets/baibot-torso-768.png", "/src", "/README.md", "/CHANGELOG.md", "/LICENSE"]
-version = "1.14.0"
+version = "1.19.2"
 edition = "2024"
 
 [lib]
@@ -17,24 +17,23 @@ path = "src/lib.rs"
 [dependencies]
 anthropic = { git = "https://github.com/etkecc/anthropic-rs.git", branch = "fix-content-block-image" }
 anyhow = "1.0.*"
-async-openai = { version = "0.32.3", features = ["audio", "chat-completion", "image", "responses"] }
+async-openai = { version = "0.40.0", features = ["audio", "chat-completion", "image", "responses"] }
 base64 = "0.22.*"
 chrono = { version = "0.4.*", default-features = false, features = ["std", "now"] }
 # We'd rather not depend on this, but we cannot use the ruma-events EventContent macro without it.
-# We add the `native-tls` feature, because of https://github.com/etkecc/rust-mxlink/issues/1
-matrix-sdk = { version = "0.16.0", default-features = false, features = ["native-tls"] }
+matrix-sdk = { version = "0.17.0", default-features = false }
 mime_guess = "2.0.*"
 mxidwc = "1.0.*"
-mxlink = ">=1.11.0"
+mxlink = ">=1.14.0"
 etke_openai_api_rust = "0.1.*"
 quick_cache = "0.6.*"
 regex = "1.12.*"
 serde = { version = "1.0.*", features = ["derive"], default-features = false }
 serde_json = "1.0.*"
-serde_yaml = "0.9.*"
-tempfile = "3.24.*"
-tiktoken-rs = { version = "0.9.*", default-features = false }
-tokio = { version = "1.49.*", features = ["rt", "rt-multi-thread", "macros"] }
+serde_yaml_ng = "0.10.*"
+tempfile = "3.27.*"
+tiktoken-rs = { version = "0.11.*", default-features = false }
+tokio = { version = "1.52.*", features = ["rt", "rt-multi-thread", "macros"] }
 tracing = "0.1.*"
 tracing-subscriber = { version = "0.3.*", features = ["env-filter"] }
 url = "2.5.*"

Dockerfile

@@ -4,7 +4,7 @@
 #                                     #
 #######################################
 
-FROM docker.io/rust:1.93.0-slim-trixie AS build
+FROM docker.io/rust:1.95.0-slim-trixie AS build
 
 RUN apt-get update && apt-get install -y build-essential pkg-config libssl-dev libsqlite3-dev
 

Dockerfile.ci

@@ -4,7 +4,7 @@
 #                                     #
 #######################################
 
-FROM docker.io/rust:1.93.0-slim-trixie AS build
+FROM docker.io/rust:1.95.0-slim-trixie AS build
 
 RUN apt-get update && apt-get install -y build-essential pkg-config libssl-dev libsqlite3-dev
 

docs/configuration/README.md

@@ -22,6 +22,8 @@ You can see the list of supported environment variables in the [🦀 src/entity/
 > [!WARNING]
 > The static configuration contains an `initial_global_config` key, which is used to populate the bot's global configuration (stored as [dynamic configuration](#dynamic-configuration)) the first time the bot starts. Modifying this subsequently will not have any effect. After initial global configuration creation, it's expected to be managed dynamically via chat commands.
 
+For Matrix-account authentication setup, see [🔐 Authentication](./authentication.md).
+
 
 ### Dynamic configuration
 

docs/configuration/authentication.md

@@ -0,0 +1,23 @@
+## 🔐 Authentication
+
+baibot supports 2 authentication modes for the Matrix account (`user.*` keys in config).
+
+Set **exactly one** mode. If both are set (or neither is set), startup validation fails.
+
+### Password authentication
+
+- Config key: `user.password`
+- Environment variable: `BAIBOT_USER_PASSWORD`
+
+### Access token authentication
+
+- Config keys: `user.access_token` + `user.device_id`
+- Environment variables: `BAIBOT_USER_ACCESS_TOKEN` + `BAIBOT_USER_DEVICE_ID`
+
+Access-token authentication is useful for OIDC-enabled homeservers (e.g. those using [Matrix Authentication Service](https://github.com/element-hq/matrix-authentication-service)).
+
+Example token-generation command:
+
+```sh
+mas-cli manage issue-compatibility-token <username> [device_id]
+```

docs/configuration/handlers.md

@@ -8,7 +8,7 @@ You can also use **different models within the same room** (e.g. [💬 text-gene
 
 The bot supports the following use-purposes:
 
-- [💬 text-generation](../features.md#-text-generation): communicating with you via text (though certain models may "see" images as well)
+- [💬 text-generation](../features.md#-text-generation): communicating with you via text (though certain models may also process images and files)
 - [🦻 speech-to-text](../features.md#-speech-to-text): turning your voice messages into text
 - [🗣️ text-to-speech](../features.md#️-text-to-speech): turning bot or users text messages into voice messages
 - [🖌️ image-generation](../features.md#image-generation): generating images based on instructions

docs/configuration/text-generation.md

@@ -57,6 +57,25 @@ This feature relies on [tokenization](https://en.wikipedia.org/wiki/Large_langua
 This setting is **disabled by default**, but can be enabled via `!bai config room text-generation set-context-management-enabled true` (this can also be set globally, see [🛠️ Room Settings](./README.md#room-settings)).
 
 
+### 👤 Sender Context Mode
+
+In multi-user rooms, it may be useful for the model to know which participant sent each message in the conversation context.
+
+To support this, the bot has a `text-generation sender-context-mode` setting, which can be set to:
+
+- (default) `disabled`: do not attach sender metadata to messages before sending them to the model
+
+- `matrix_user_id`: prefix text messages with the sender's Matrix user ID, for example: `[sender=@alice:example.com] Hello bot`
+
+- `matrix_user_id_and_timestamp`: prefix text messages with the sender's Matrix user ID and the message timestamp, for example: `[sender=@alice:example.com sent_at=2026-03-23T14:30:00Z] Hello bot`
+
+This sender metadata is attached to conversation messages before they are sent to the model provider. It applies to user and assistant text messages, but not to system prompts or non-text content.
+
+⚠️ Enabling this sends Matrix user IDs, and optionally timestamps, to the model provider.
+
+Example: `!bai config room text-generation set-sender-context-mode matrix_user_id` (this can also be set globally, see [🛠️ Room Settings](./README.md#room-settings))
+
+
 ### ⌨️ Prompt Override
 
 You can override the [system prompt](https://huggingface.co/docs/transformers/en/tasks/prompting) configured at the [🤖 agent](../agents.md) level.

docs/development.md

@@ -18,6 +18,27 @@ For local development, we run all dependency services in [🐋 Docker](https://w
 - (Optional) an API key for some Large Language Model [☁️ provider](./providers.md) (e.g. [OpenAI](./providers.md#openai)), though we recommend using [LocalAI](#localai) or [Ollama](#ollama) for local development
 
 
+### Choosing a homeserver
+
+The development environment supports two homeserver implementations:
+
+- **[Continuwuity](https://continuwuity.org/)** (default) — lightweight, no external database required. Good for most development needs.
+- **[Synapse](https://github.com/element-hq/synapse)** — the reference implementation, bundled with Postgres. Use this if you need Synapse-specific behavior.
+
+To choose a homeserver (optional — defaults to Continuwuity if skipped):
+
+```sh
+just homeserver-init continuwuity  # or: just homeserver-init synapse
+```
+
+The choice is stored in `var/homeserver` and affects all subsequent commands.
+
+> **Note:** If you switch homeservers after initial setup, you will need to:
+> - Delete `var/app/local/` and/or `var/app/container/` (app config and data)
+> - Delete `var/services/element-web/` (to regenerate its config)
+> - Re-run the prepare and user registration steps
+
+
 ### Getting started guide
 
 Developing [locally](#running-locally) is possible, but requires a [Rust](https://www.rust-lang.org/) toolchain.
@@ -28,11 +49,12 @@ In any case, you will need [🐋 Docker](https://www.docker.com/) as [dependency
 
 #### Running locally
 
-1. Start the core dependency services (Postgres, Synapse, Element Web): `just services-start`
-2. (Only the first time around) Prepare initial app configuration in `var/app/local/config.yml`: `just app-local-prepare`
-3. (Only the first time around) [Prepare your configuration file](#prepare-your-configuration-file)
-4. (Only the first time around) Prepare initial default Matrix user accounts (`admin` and `baibot`): `just users-prepare`
-5. (Optional) Start additional services depending on which [agent provider you've chosen](#choosing-an-agent-provider):
+1. (Optional) Choose a homeserver: `just homeserver-init continuwuity` (or `synapse`). Default is `continuwuity`.
+2. Start the homeserver and Element Web: `just services-start`
+3. (Only the first time around) Prepare initial app configuration in `var/app/local/config.yml`: `just app-local-prepare`
+4. (Only the first time around) [Prepare your configuration file](#prepare-your-configuration-file)
+5. (Only the first time around) Prepare initial default Matrix user accounts (`admin` and `baibot`): `just users-prepare`
+6. (Optional) Start additional services depending on which [agent provider you've chosen](#choosing-an-agent-provider):
   - for [LocalAI](#localai):
     - Start services: `just localai-start`
 	- Wait a while for LocalAI to start up. It has a lot of models to download. Monitor progress using `just localai-tail-logs`
@@ -40,12 +62,12 @@ In any case, you will need [🐋 Docker](https://www.docker.com/) as [dependency
   - for [Ollama](#ollama):
     - Start services: `just ollama-start`
     - (Only the first time around) Pull the model configured in `agents.static_definitions` in the configuration file: `just ollama-pull-model gemma2:2b`
-6. Start the bot: `just run-locally`
-7. Go to http://element.127.0.0.1.nip.io:42025/ and login with `admin` / `admin`
-8. Create a new room and invite `@baibot:synapse.127.0.0.1.nip.io`
-9. When done, stop the bot (`Ctrl` + `C`)
-10. Stop the core dependency services: `just services-stop`
-11. (Optional) Stop additional services:
+7. Start the bot: `just run-locally`
+8. Go to http://element.127.0.0.1.nip.io:42025/ and login with `admin` / `admin`
+9. Create a new room and invite `@baibot:continuwuity.127.0.0.1.nip.io` (or `@baibot:synapse.127.0.0.1.nip.io` if using Synapse)
+10. When done, stop the bot (`Ctrl` + `C`)
+11. Stop the services: `just services-stop`
+12. (Optional) Stop additional services:
   - for [LocalAI](#localai): `just localai-stop`
   - for [Ollama](#ollama): `just ollama-stop`
 
@@ -54,11 +76,12 @@ In any case, you will need [🐋 Docker](https://www.docker.com/) as [dependency
 
 You can avoid having a [Rust](https://www.rust-lang.org/) toolchain installed locally and build/run this in a container.
 
-1. Start the core dependency services (Postgres, Synapse, Element Web): `just services-start`
-2. (Only the first time around) Prepare initial app configuration in `var/app/container/config.yml`: `just app-container-prepare`
-3. (Only the first time around) [Prepare your configuration file](#prepare-your-configuration-file)
-4. (Only the first time around) Prepare initial default Matrix user accounts (`admin` and `baibot`): `just users-prepare`
-5. (Optional) Start additional services depending on which [agent provider you've chosen](#choosing-an-agent-provider):
+1. (Optional) Choose a homeserver: `just homeserver-init continuwuity` (or `synapse`). Default is `continuwuity`.
+2. Start the homeserver and Element Web: `just services-start`
+3. (Only the first time around) Prepare initial app configuration in `var/app/container/config.yml`: `just app-container-prepare`
+4. (Only the first time around) [Prepare your configuration file](#prepare-your-configuration-file)
+5. (Only the first time around) Prepare initial default Matrix user accounts (`admin` and `baibot`): `just users-prepare`
+6. (Optional) Start additional services depending on which [agent provider you've chosen](#choosing-an-agent-provider):
   - for [LocalAI](#localai):
     - Start services: `just localai-start`
 	- Wait a while for LocalAI to start up. It has a lot of models to download. Monitor progress using `just localai-tail-logs`
@@ -66,12 +89,12 @@ You can avoid having a [Rust](https://www.rust-lang.org/) toolchain installed lo
   - for [Ollama](#ollama):
     - Start services: `just ollama-start`
     - (Only the first time around) Pull the model configured in `agents.static_definitions` in the configuration file: `just ollama-pull-model gemma2:2b`
-6. Start the bot: `just run-in-container`
-7. Go to http://element.127.0.0.1.nip.io:42025/ and login with `admin` / `admin`
-8. Create a new room and invite `@baibot:synapse.127.0.0.1.nip.io`
-9. When done, stop the bot (`Ctrl` + `C`)
-10. Stop the dependency services: `just services-stop`
-11. (Optional) Stop additional services:
+7. Start the bot: `just run-in-container`
+8. Go to http://element.127.0.0.1.nip.io:42025/ and login with `admin` / `admin`
+9. Create a new room and invite `@baibot:continuwuity.127.0.0.1.nip.io` (or `@baibot:synapse.127.0.0.1.nip.io` if using Synapse)
+10. When done, stop the bot (`Ctrl` + `C`)
+11. Stop the services: `just services-stop`
+12. (Optional) Stop additional services:
   - for [LocalAI](#localai): `just localai-stop`
   - for [Ollama](#ollama): `just ollama-stop`
 

docs/features.md

@@ -8,7 +8,7 @@ You can also use **different models within the same room** (e.g. [💬 text-gene
 
 The bot supports the following use-purposes:
 
-- [💬 text-generation](#-text-generation): communicating with you via text (though certain models may "see" images as well)
+- [💬 text-generation](#-text-generation): communicating with you via text (though certain models may also process images and files)
 - [🦻 speech-to-text](#-speech-to-text): turning your voice messages into text
 - [🗣️ text-to-speech](#%EF%B8%8F-text-to-speech): turning bot or users text messages into voice messages
 - [🖌️ image-generation](#%EF%B8%8F-image-generation): generating images based on instructions
@@ -26,12 +26,14 @@ Text Generation is the bot's ability to **respond to users' messages with text**
 
 ![Screenshot of Text Generation - a user sends a message and the bot replies in a new conversation thread](./screenshots/text-generation.webp)
 
-Some models also support vision, so you may be able to mix text and images in the same conversation.
+Some models also support vision and document understanding, so you may be able to mix text, images, and files (PDFs, text documents, etc.) in the same conversation. Note that certain providers may not support all file types or may have issues with specific files (e.g. scanned/image-based PDFs). If a file is rejected by the provider, the conversation thread may become unusable — start a new thread to work around this.
 
 In multi-user (group) rooms, to avoid disturbing the normal conversation between people, the bot is auto-configured to only respond to messages starting with the command prefix (`!bai`) or direct mentions via the [💬 Text Generation / 🗟 Prefix Requirement Type](./configuration/text-generation.md#-prefix-requirement-type) setting.
 
 Normally, the bot only responds to allowed [👥 Users](./access.md#-users). In certain cases, it's useful for an allowed user to provoke the bot to respond even in foreign threads or reply chains. You can learn more about this feature in the [On-demand involvement](./features.md#on-demand-involvement) section below.
 
+If needed, the bot can also attach sender metadata to conversation messages before sending them to the model, which can help the model distinguish between participants in multi-user rooms. See [🛠️ Configuration / 💬 Text Generation / 👤 Sender Context Mode](./configuration/text-generation.md#-sender-context-mode).
+
 A few other features (like [🗣️ Text-to-Speech](#️-text-to-speech) and [🦻 Speech-to-Text](#-speech-to-text)) combine well with Text Generation, so you **don't necessarily need to communicate with the bot via text** (with [Seamless voice interaction](#seamless-voice-interaction), you can communicate only with voice).
 
 You may also wish to see:

docs/sample-provider-configs/openai.yml

@@ -1,7 +1,7 @@
 base_url: https://api.openai.com/v1
 api_key: YOUR_API_KEY_HERE
 text_generation:
-  model_id: gpt-5.2
+  model_id: gpt-5.4
   prompt: "You are a brief, but helpful bot called {{ baibot_name }} powered by the {{ baibot_model_id }} model. The date/time of this conversation's start is: {{ baibot_conversation_start_time_utc }}."
   temperature: 1.0
   # Reasoning models need to use `max_completion_tokens` instead of `max_response_tokens`.

docs/usage.md

@@ -11,7 +11,7 @@ This is related to the [💬 Text Generation](./features.md#-text-generation) fe
 
 If there's a text-generation handler agent configured, the bot **may** respond to messages sent in the room.
 
-Some models also support vision, so you may be able to mix text and images in the same conversation.
+Some models also support vision and document understanding, so you may be able to mix text, images, and files (PDFs, text documents, etc.) in the same conversation.
 
 See screenshots of:
 

etc/app/config.yml.dist

@@ -1,12 +1,21 @@
 homeserver:
   # The canonical homeserver domain name
-  server_name: synapse.127.0.0.1.nip.io
-  url: http://synapse.127.0.0.1.nip.io:42020
+  server_name: __HOMESERVER_SERVER_NAME__
+  url: __HOMESERVER_URL__
 
 user:
   mxid_localpart: baibot
+
+  # Authentication: set EITHER password OR access_token + device_id.
+  #
+  # Password-based login (traditional homeservers):
   password: baibot
 
+  # Access token login (for Matrix Authentication Service/OIDC-enabled homeservers):
+  # Generate a token via: mas-cli manage issue-compatibility-token <username> [device_id]
+  # access_token: null
+  # device_id: null
+
   # The name the bot uses as a display name and when it refers to itself.
   # Leave empty to use the default (baibot).
   name: baibot
@@ -45,7 +54,7 @@ room:
 access:
   # Space-separated list of MXID patterns which specify who is an admin.
   admin_patterns:
-    - "@admin:synapse.127.0.0.1.nip.io"
+    - "@admin:__HOMESERVER_SERVER_NAME__"
 
 persistence:
   # This is unset here, because we expect the configuration to come from an environment variable (BAIBOT_PERSISTENCE_DATA_DIR_PATH).
@@ -82,7 +91,7 @@ agents:
     #     base_url: https://api.openai.com/v1
     #     api_key: ""
     #     text_generation:
-    #       model_id: gpt-5.2
+    #       model_id: gpt-5.4
     #       prompt: "You are a brief, but helpful bot called {{ baibot_name }} powered by the {{ baibot_model_id }} model. The date/time of this conversation's start is: {{ baibot_conversation_start_time_utc }}."
     #       temperature: 1.0
     #       # Reasoning models need to use `max_completion_tokens` instead of `max_response_tokens`.
@@ -157,7 +166,7 @@ initial_global_config:
   # Space-separated list of MXID patterns which specify who can use the bot.
   # By default, we let anyone on the homeserver use the bot.
   user_patterns:
-    - "@*:synapse.127.0.0.1.nip.io"
+    - "@*:__HOMESERVER_SERVER_NAME__"
 
 # Controls logging.
 #

etc/services/continuwuity/compose.yml

@@ -0,0 +1,23 @@
+services:
+  continuwuity:
+    image: forgejo.ellis.link/continuwuation/continuwuity:v0.5.9
+    user: "${UID}:${GID}"
+    restart: unless-stopped
+    cap_drop:
+      - ALL
+    read_only: true
+    environment:
+      CONDUWUIT_CONFIG: /etc/continuwuity/continuwuity.toml
+      CONDUWUIT_DATABASE_PATH: /var/lib/continuwuity
+    ports:
+      - "${SERVICE_CONTINUWUITY_BIND_PORT_CLIENT_API}:6167"
+    volumes:
+      - ../../etc/services/continuwuity/config:/etc/continuwuity:ro
+      - ./continuwuity/data:/var/lib/continuwuity
+    tmpfs:
+      - /tmp:rw,noexec,nosuid,size=500m
+
+networks:
+  default:
+    name: ${NETWORK_NAME}
+    external: true

etc/services/continuwuity/config/continuwuity.toml

@@ -0,0 +1,19 @@
+[global]
+server_name = "continuwuity.127.0.0.1.nip.io"
+
+address = "0.0.0.0"
+port = 6167
+
+database_path = "/var/lib/continuwuity"
+
+allow_registration = true
+yes_i_am_very_very_sure_i_want_an_open_registration_server_prone_to_abuse = true
+
+new_user_displayname_suffix = ""
+
+max_request_size = 20_000_000
+
+allow_federation = false
+trusted_servers = ["matrix.org"]
+
+log = "info,state_res=warn,rocket=off,_=off,sled=off"

etc/services/continuwuity/register-user.sh

@@ -0,0 +1,48 @@
+#!/bin/sh
+set -eu
+
+if [ $# -ne 3 ]; then
+	echo "Usage: $0 <env-file> <username> <password>"
+	exit 1
+fi
+
+ENV_FILE="$1"
+USERNAME="$2"
+PASSWORD="$3"
+
+SERVER="http://$(grep '^SERVICE_CONTINUWUITY_BIND_PORT_CLIENT_API=' "${ENV_FILE}" | cut -d= -f2)"
+REGISTER_URL="${SERVER}/_matrix/client/v3/register"
+
+echo "Registering user '${USERNAME}' on ${SERVER}..."
+
+SESSION_RESPONSE=$(curl -s -X POST "${REGISTER_URL}" \
+	-H 'Content-Type: application/json' \
+	-d "{\"username\": \"${USERNAME}\", \"password\": \"${PASSWORD}\"}")
+
+SESSION_ID=$(echo "${SESSION_RESPONSE}" | grep -o '"session":"[^"]*"' | head -1 | cut -d'"' -f4)
+if [ -z "${SESSION_ID}" ]; then
+	echo "Error: Could not get session ID. Response: ${SESSION_RESPONSE}"
+	exit 1
+fi
+
+# Determine the required auth flow from the server response.
+# The first user requires m.login.registration_token (bootstrap token from logs).
+# Subsequent users use m.login.dummy (open registration).
+if echo "${SESSION_RESPONSE}" | grep -q 'm.login.registration_token'; then
+	CONTAINER_ID=$(docker ps -q --filter name=baibot-continuwuity-continuwuity)
+	REG_TOKEN=$(docker logs "${CONTAINER_ID}" 2>&1 | sed 's/\x1b\[[0-9;]*m//g' | grep 'using the registration token' | grep -oP 'registration token \K[A-Za-z0-9]+' | head -1)
+	AUTH_BODY="{\"type\": \"m.login.registration_token\", \"token\": \"${REG_TOKEN}\", \"session\": \"${SESSION_ID}\"}"
+else
+	AUTH_BODY="{\"type\": \"m.login.dummy\", \"session\": \"${SESSION_ID}\"}"
+fi
+
+RESULT=$(curl -s -X POST "${REGISTER_URL}" \
+	-H 'Content-Type: application/json' \
+	-d "{\"username\": \"${USERNAME}\", \"password\": \"${PASSWORD}\", \"auth\": ${AUTH_BODY}}")
+
+if echo "${RESULT}" | grep -q '"user_id"'; then
+	echo "Successfully registered user: $(echo "${RESULT}" | grep -o '"user_id":"[^"]*"' | cut -d'"' -f4)"
+else
+	echo "Registration failed. Response: ${RESULT}"
+	exit 1
+fi

etc/services/element-web/compose.yml

@@ -0,0 +1,21 @@
+services:
+  element-web:
+    image: ghcr.io/element-hq/element-web:v1.12.18
+    user: "${UID}:${GID}"
+    restart: unless-stopped
+    environment:
+      ELEMENT_WEB_PORT: 8080
+    ports:
+      - "${SERVICE_ELEMENT_WEB_BIND_PORT_HTTP}:8080"
+    volumes:
+    - ./element-web/config.json:/app/config.json:ro
+    tmpfs:
+      - /var/cache/nginx:rw,mode=777
+      - /var/run:rw,mode=777
+      - /tmp/element-web-config:rw,mode=777
+      - /etc/nginx/conf.d:rw,mode=777
+
+networks:
+  default:
+    name: ${NETWORK_NAME}
+    external: true

etc/services/element-web/config.json.dist

@@ -1,5 +1,5 @@
 {
-    "default_hs_url": "http://synapse.127.0.0.1.nip.io:42020",
+    "default_hs_url": "__HOMESERVER_CLIENT_URL__",
     "default_is_url": "https://vector.im",
     "integrations_ui_url": "https://scalar.vector.im/",
     "integrations_rest_url": "https://scalar.vector.im/api",

etc/services/env.dist

@@ -3,6 +3,8 @@ SERVICE_SYNAPSE_BIND_PORT_FEDERATION_API=127.0.0.1:42028
 
 SERVICE_ELEMENT_WEB_BIND_PORT_HTTP=127.0.0.1:42025
 
+SERVICE_CONTINUWUITY_BIND_PORT_CLIENT_API=127.0.0.1:42030
+
 SERVICE_OLLAMA_BIND_PORT_HTTP=127.0.0.1:42026
 
 # See https://localai.io/basics/container/#all-in-one-images for the list of available images

etc/services/ollama/compose.yml

@@ -1,6 +1,6 @@
 services:
   ollama:
-    image: docker.io/ollama/ollama:0.15.4
+    image: docker.io/ollama/ollama:0.24.0
     restart: unless-stopped
     ports:
       - "${SERVICE_OLLAMA_BIND_PORT_HTTP}:11434"

etc/services/synapse/compose.yml

@@ -1,6 +1,6 @@
 services:
   postgres:
-    image: docker.io/postgres:18.1-alpine
+    image: docker.io/postgres:18.4-alpine
     user: ${UID}:${GID}
     restart: unless-stopped
     environment:
@@ -14,7 +14,7 @@ services:
     - /etc/passwd:/etc/passwd:ro
 
   synapse:
-    image: ghcr.io/element-hq/synapse:v1.146.0
+    image: ghcr.io/element-hq/synapse:v1.153.0
     user: "${UID}:${GID}"
     restart: unless-stopped
     entrypoint: python
@@ -23,25 +23,9 @@ services:
     - "${SERVICE_SYNAPSE_BIND_PORT_CLIENT_API}:8008"
     - "${SERVICE_SYNAPSE_BIND_PORT_FEDERATION_API}:8008"
     volumes:
-    - ../../etc/services/core/synapse/config:/config:ro
+    - ../../etc/services/synapse/config:/config:ro
     - ./synapse/media-store:/media-store
 
-  element-web:
-    image: ghcr.io/element-hq/element-web:v1.12.9
-    user: "${UID}:${GID}"
-    restart: unless-stopped
-    environment:
-      ELEMENT_WEB_PORT: 8080
-    ports:
-      - "${SERVICE_ELEMENT_WEB_BIND_PORT_HTTP}:8080"
-    volumes:
-    - ../../etc/services/core/element-web/config.json:/app/config.json:ro
-    tmpfs:
-      - /var/cache/nginx:rw,mode=777
-      - /var/run:rw,mode=777
-      - /tmp/element-web-config:rw,mode=777
-      - /etc/nginx/conf.d:rw,mode=777
-
 networks:
   default:
     name: ${NETWORK_NAME}

justfile

@@ -2,10 +2,33 @@ project_name := "baibot"
 container_image_name := "localhost/baibot"
 project_container_network := "baibot"
 
+admin_username := "admin"
+admin_password := "admin"
+bot_username := "baibot"
+bot_password := "baibot"
+
+homeserver := `cat var/homeserver 2>/dev/null || echo continuwuity`
+
+mise_data_dir := env("MISE_DATA_DIR", justfile_directory() / "var/mise")
+mise_trusted_config_paths := justfile_directory() / "mise.toml"
+
 # Show help by default
 default:
 	@just --list --justfile {{ justfile() }}
 
+# Selects which homeserver implementation to use (continuwuity or synapse)
+homeserver-init value:
+	#!/bin/sh
+	mkdir -p {{ justfile_directory() }}/var
+	echo {{ value }} > {{ justfile_directory() }}/var/homeserver
+	echo ""
+	echo "⚠️  If you had already prepared your app configuration (var/app/local/config.yml or var/app/container/config.yml),"
+	echo "    you will need to update it manually or delete it and re-run the prepare step."
+	echo "    You should also delete var/app/local/data and/or var/app/container/data,"
+	echo "    as old application state is not compatible across homeserver implementations."
+	echo ""
+	echo "⚠️  If Element Web was already prepared, delete var/services/element-web/ to regenerate its config."
+
 # Builds and runs a development binary
 run-locally *extra_args: app-local-prepare
 	RUST_BACKTRACE=1 \
@@ -65,9 +88,13 @@ docker-compose services_type *extra_args:
 	-p {{ project_name }}-{{ services_type }} \
 	{{ extra_args }}
 
-# Runs a docker-compose command against the core services
-docker-compose-core *extra_args:
-	just docker-compose core {{ extra_args }}
+# Runs a docker-compose command against the synapse services
+docker-compose-synapse *extra_args:
+	just docker-compose synapse {{ extra_args }}
+
+# Runs a docker-compose command against the element-web services
+docker-compose-element-web *extra_args:
+	just docker-compose element-web {{ extra_args }}
 
 # Runs a docker-compose command against the localai services
 docker-compose-localai *extra_args:
@@ -77,17 +104,52 @@ docker-compose-localai *extra_args:
 docker-compose-ollama *extra_args:
 	just docker-compose ollama {{ extra_args }}
 
-# Runs all core dependency components (in the background)
-services-start: services-prepare (docker-compose-core "up" "-d")
+# Runs a docker-compose command against the continuwuity services
+docker-compose-continuwuity *extra_args:
+	just docker-compose continuwuity {{ extra_args }}
 
-# Stops all core dependency components
-services-stop: (docker-compose-core "down")
+# Runs the homeserver and Element Web (in the background)
+services-start: services-prepare
+	just -f {{ justfile_directory() }}/justfile {{ homeserver }}-start
+	just -f {{ justfile_directory() }}/justfile element-web-start
 
-# Tails the logs for all running core services
-services-tail-logs: (docker-compose-core "logs" "-f")
+# Stops Element Web and the homeserver
+services-stop:
+	just -f {{ justfile_directory() }}/justfile element-web-stop
+	just -f {{ justfile_directory() }}/justfile {{ homeserver }}-stop
 
-# Prepares the core services for running
-services-prepare: _prepare-var-services-env _prepare-var-services-postgres _prepare-var-services-synapse _prepare-container-network
+# Tails the logs for the homeserver and Element Web
+services-tail-logs:
+	just -f {{ justfile_directory() }}/justfile {{ homeserver }}-tail-logs
+
+# Prepares the homeserver and Element Web for running
+services-prepare:
+	just -f {{ justfile_directory() }}/justfile {{ homeserver }}-prepare
+	just -f {{ justfile_directory() }}/justfile element-web-prepare
+
+# Runs Synapse (in the background)
+synapse-start: synapse-prepare (docker-compose-synapse "up" "-d")
+
+# Stops Synapse
+synapse-stop: (docker-compose-synapse "down")
+
+# Tails the logs for Synapse
+synapse-tail-logs: (docker-compose-synapse "logs" "-f")
+
+# Prepares Synapse for running
+synapse-prepare: _prepare-var-services-env _prepare-var-services-postgres _prepare-var-services-synapse _prepare-container-network
+
+# Runs Element Web (in the background)
+element-web-start: element-web-prepare (docker-compose-element-web "up" "-d")
+
+# Stops Element Web
+element-web-stop: (docker-compose-element-web "down")
+
+# Tails the logs for Element Web
+element-web-tail-logs: (docker-compose-element-web "logs" "-f")
+
+# Prepares Element Web for running
+element-web-prepare: _prepare-var-services-env _prepare-var-services-element-web _prepare-container-network
 
 # Runs LocalAI (in the background)
 localai-start: localai-prepare (docker-compose-localai "up" "-d")
@@ -113,6 +175,27 @@ ollama-tail-logs: (docker-compose-ollama "logs" "-f")
 # Prepares Ollama for running
 ollama-prepare: _prepare-var-services-env _prepare-var-services-ollama _prepare-container-network
 
+# Runs Continuwuity (in the background)
+continuwuity-start: continuwuity-prepare (docker-compose-continuwuity "up" "-d")
+
+# Stops Continuwuity
+continuwuity-stop: (docker-compose-continuwuity "down")
+
+# Tails the logs for Continuwuity
+continuwuity-tail-logs: (docker-compose-continuwuity "logs" "-f")
+
+# Prepares Continuwuity for running
+continuwuity-prepare: _prepare-var-services-env _prepare-var-services-continuwuity _prepare-container-network
+
+# Registers a user on Continuwuity via the Matrix Client-Server API
+continuwuity-register-user username password:
+	{{ justfile_directory() }}/etc/services/continuwuity/register-user.sh {{ justfile_directory() }}/var/services/env {{ username }} {{ password }}
+
+# Prepares the Continuwuity user accounts
+continuwuity-users-prepare: continuwuity-prepare
+	just -f {{ justfile_directory() }}/justfile continuwuity-register-user "{{ admin_username }}" "{{ admin_password }}"
+	just -f {{ justfile_directory() }}/justfile continuwuity-register-user "{{ bot_username }}" "{{ bot_password }}"
+
 # Pulls an Ollama model
 ollama-pull-model model_id:
 	just -f {{ justfile_directory() }}/justfile docker-compose-ollama \
@@ -126,16 +209,20 @@ app-local-prepare: _prepare-var-app-local-config_yml _prepare-var-app-local-data
 app-container-prepare: _prepare-var-app-container-config_yml _prepare-var-app-container-data
 
 # Prepares the user accounts
-users-prepare: services-prepare
-	just -f {{ justfile_directory() }}/justfile synapse-register-admin-user "admin" "admin"
-	just -f {{ justfile_directory() }}/justfile synapse-register-regular-user "baibot" "baibot"
+users-prepare:
+	just -f {{ justfile_directory() }}/justfile {{ homeserver }}-users-prepare
+
+# Prepares the Synapse user accounts
+synapse-users-prepare: synapse-prepare
+	just -f {{ justfile_directory() }}/justfile synapse-register-admin-user "{{ admin_username }}" "{{ admin_password }}"
+	just -f {{ justfile_directory() }}/justfile synapse-register-regular-user "{{ bot_username }}" "{{ bot_password }}"
 
 # Starts a Postgres CLI (psql)
-postgres-cli: services-prepare (docker-compose-core "exec" "postgres" "/bin/sh" "-c" "'PGUSER=synapse PGPASSWORD=synapse-password PGDATABASE=homeserver psql -h postgres'")
+postgres-cli: synapse-prepare (docker-compose-synapse "exec" "postgres" "/bin/sh" "-c" "'PGUSER=synapse PGPASSWORD=synapse-password PGDATABASE=homeserver psql -h postgres'")
 
-# Creates an administrator user
-synapse-register-admin-user username password: services-prepare
-	just -f {{ justfile_directory() }}/justfile docker-compose-core \
+# Creates an administrator user on Synapse
+synapse-register-admin-user username password: synapse-prepare
+	just -f {{ justfile_directory() }}/justfile docker-compose-synapse \
 		exec synapse \
 		register_new_matrix_user \
 		--admin \
@@ -144,9 +231,9 @@ synapse-register-admin-user username password: services-prepare
 		-c /config/homeserver.yaml \
 		http://localhost:8008
 
-# Create a regular user
-synapse-register-regular-user username password: services-prepare
-	just -f {{ justfile_directory() }}/justfile docker-compose-core \
+# Creates a regular user on Synapse
+synapse-register-regular-user username password: synapse-prepare
+	just -f {{ justfile_directory() }}/justfile docker-compose-synapse \
 		exec synapse \
 		register_new_matrix_user \
 		--no-admin \
@@ -159,6 +246,44 @@ synapse-register-regular-user username password: services-prepare
 clippy *extra_args:
 	cargo clippy {{ extra_args }}
 
+# Checks that the code compiles without building
+check:
+	cargo check
+
+# Invokes mise with the project-local data directory
+mise *args: _ensure_mise_data_directory
+	#!/bin/sh
+	export MISE_DATA_DIR="{{ mise_data_dir }}"
+	export MISE_TRUSTED_CONFIG_PATHS="{{ mise_trusted_config_paths }}"
+	mise {{ args }}
+
+# Runs prek (pre-commit hooks manager) with the given arguments
+prek *args: _ensure_mise_tools_installed
+	@just --justfile {{ justfile() }} mise exec -- prek {{ args }}
+
+# Runs pre-commit hooks on staged files
+prek-run-on-staged *args: _ensure_mise_tools_installed
+	@just --justfile {{ justfile() }} mise exec -- prek run {{ args }}
+
+# Runs pre-commit hooks on all files
+prek-run-on-all *args: _ensure_mise_tools_installed
+	@just --justfile {{ justfile() }} mise exec -- prek run --all-files {{ args }}
+
+# Installs the git pre-commit hook (runs prek automatically before each commit)
+prek-install-git-pre-commit-hook: _ensure_mise_tools_installed
+	@just --justfile {{ justfile() }} mise exec -- prek install
+
+# Internal - ensures var/mise directory exists
+_ensure_mise_data_directory:
+	#!/bin/sh
+	if [ ! -d "{{ mise_data_dir }}" ]; then
+		mkdir -p "{{ mise_data_dir }}"
+	fi
+
+# Internal - ensures mise tools are installed
+_ensure_mise_tools_installed: _ensure_mise_data_directory
+	@just --justfile {{ justfile() }} mise install --quiet
+
 _prepare-var-services-env:
 	#!/bin/sh
 	cd {{ justfile_directory() }};
@@ -188,6 +313,22 @@ _prepare-var-services-synapse:
 		mkdir -p var/services/synapse/media-store
 	fi
 
+_prepare-var-services-element-web:
+	#!/bin/sh
+	cd {{ justfile_directory() }};
+
+	if [ ! -f var/services/element-web/config.json ]; then
+		mkdir -p var/services/element-web
+		cp {{ justfile_directory() }}/etc/services/element-web/config.json.dist var/services/element-web/config.json
+
+		homeserver="{{ homeserver }}"
+		if [ "$homeserver" = "continuwuity" ]; then
+			sed --in-place 's|__HOMESERVER_CLIENT_URL__|http://continuwuity.127.0.0.1.nip.io:42030|g' var/services/element-web/config.json
+		elif [ "$homeserver" = "synapse" ]; then
+			sed --in-place 's|__HOMESERVER_CLIENT_URL__|http://synapse.127.0.0.1.nip.io:42020|g' var/services/element-web/config.json
+		fi
+	fi
+
 _prepare-var-services-ollama:
 	#!/bin/sh
 	cd {{ justfile_directory() }};
@@ -196,6 +337,14 @@ _prepare-var-services-ollama:
 		mkdir -p var/services/ollama
 	fi
 
+_prepare-var-services-continuwuity:
+	#!/bin/sh
+	cd {{ justfile_directory() }};
+
+	if [ ! -f var/services/continuwuity ]; then
+		mkdir -p var/services/continuwuity/data
+	fi
+
 _prepare-var-services-localai:
 	#!/bin/sh
 	cd {{ justfile_directory() }};
@@ -219,6 +368,15 @@ _prepare-var-app-local-config_yml:
 	if [ ! -f var/app/local/config.yml ]; then
 		mkdir -p var/app/local
 		cp {{ justfile_directory() }}/etc/app/config.yml.dist var/app/local/config.yml
+
+		homeserver="{{ homeserver }}"
+		if [ "$homeserver" = "continuwuity" ]; then
+			sed --in-place 's/__HOMESERVER_SERVER_NAME__/continuwuity.127.0.0.1.nip.io/g' var/app/local/config.yml
+			sed --in-place 's|__HOMESERVER_URL__|http://continuwuity.127.0.0.1.nip.io:42030|g' var/app/local/config.yml
+		elif [ "$homeserver" = "synapse" ]; then
+			sed --in-place 's/__HOMESERVER_SERVER_NAME__/synapse.127.0.0.1.nip.io/g' var/app/local/config.yml
+			sed --in-place 's|__HOMESERVER_URL__|http://synapse.127.0.0.1.nip.io:42020|g' var/app/local/config.yml
+		fi
 	fi
 
 _prepare-var-app-local-data:
@@ -236,7 +394,18 @@ _prepare-var-app-container-config_yml:
 	if [ ! -f var/app/container/config.yml ]; then
 		mkdir -p var/app/container
 		cp {{ justfile_directory() }}/etc/app/config.yml.dist var/app/container/config.yml
-		sed --in-place 's/synapse.127.0.0.1.nip.io:42020/synapse:8008/g' var/app/container/config.yml
+
+		homeserver="{{ homeserver }}"
+		if [ "$homeserver" = "continuwuity" ]; then
+			sed --in-place 's/__HOMESERVER_SERVER_NAME__/continuwuity.127.0.0.1.nip.io/g' var/app/container/config.yml
+			sed --in-place 's|__HOMESERVER_URL__|http://continuwuity.127.0.0.1.nip.io:42030|g' var/app/container/config.yml
+			sed --in-place 's/continuwuity.127.0.0.1.nip.io:42030/continuwuity:6167/g' var/app/container/config.yml
+		elif [ "$homeserver" = "synapse" ]; then
+			sed --in-place 's/__HOMESERVER_SERVER_NAME__/synapse.127.0.0.1.nip.io/g' var/app/container/config.yml
+			sed --in-place 's|__HOMESERVER_URL__|http://synapse.127.0.0.1.nip.io:42020|g' var/app/container/config.yml
+			sed --in-place 's/synapse.127.0.0.1.nip.io:42020/synapse:8008/g' var/app/container/config.yml
+		fi
+
 		sed --in-place 's/127.0.0.1:42026/ollama:11434/g' var/app/container/config.yml
 		sed --in-place 's/127.0.0.1:42027/localai:8080/g' var/app/container/config.yml
 	fi
@@ -248,4 +417,3 @@ _prepare-var-app-container-data:
 	if [ ! -f var/app/container/data ]; then
 		mkdir -p var/app/container/data
 	fi
-

mise.toml

@@ -0,0 +1,6 @@
+[tools]
+prek = "0.4.1"
+
+[settings]
+# Disable automatic trust prompts - we trust this config
+yes = true

renovate.json

@@ -0,0 +1,9 @@
+{
+	"$schema": "https://docs.renovatebot.com/renovate-schema.json",
+	"extends": [
+		"config:recommended"
+	],
+	"labels": [
+		"dependencies"
+	]
+}

rust-toolchain.toml

@@ -0,0 +1,4 @@
+[toolchain]
+channel = "1.95.0"
+components = ["rustfmt", "clippy"]
+profile = "default"

src/agent/definition.rs

@@ -33,11 +33,11 @@ pub struct AgentDefinition {
     )]
     pub provider: AgentProvider,
 
-    pub config: serde_yaml::Value,
+    pub config: serde_yaml_ng::Value,
 }
 
 impl AgentDefinition {
-    pub fn new(id: String, provider: AgentProvider, config: serde_yaml::Value) -> Self {
+    pub fn new(id: String, provider: AgentProvider, config: serde_yaml_ng::Value) -> Self {
         Self {
             id,
             provider,

src/agent/instantiation.rs

@@ -15,7 +15,7 @@ pub enum Error {
     // Contains the error from the constructor function
     ConstructionFailed(anyhow::Error),
     // Contains the error from the YAML deserialization function
-    Yaml(serde_yaml::Error),
+    Yaml(serde_yaml_ng::Error),
 }
 
 pub type Result<T> = std::result::Result<T, Error>;
@@ -69,7 +69,7 @@ pub(super) fn create(
 pub fn create_from_provider_and_yaml_value_config(
     provider: &AgentProvider,
     identifier: &PublicIdentifier,
-    config: serde_yaml::Value,
+    config: serde_yaml_ng::Value,
 ) -> Result<AgentInstance> {
     let definition = AgentDefinition::new(identifier.prefixless(), provider.to_owned(), config);
 
@@ -79,7 +79,7 @@ pub fn create_from_provider_and_yaml_value_config(
 fn create_controller_from_provider_and_json_value_config(
     agent_id: &str,
     provider: &AgentProvider,
-    config: serde_yaml::Value,
+    config: serde_yaml_ng::Value,
 ) -> Result<ControllerType> {
     match provider {
         AgentProvider::Anthropic => {
@@ -112,43 +112,43 @@ fn create_controller_from_provider_and_json_value_config(
     }
 }
 
-pub fn default_config_for_provider(provider: &AgentProvider) -> serde_yaml::Value {
+pub fn default_config_for_provider(provider: &AgentProvider) -> serde_yaml_ng::Value {
     match provider {
         AgentProvider::Anthropic => {
             let config = super::provider::anthropic::default_config();
-            serde_yaml::to_value(config).expect("Failed to serialize config")
+            serde_yaml_ng::to_value(config).expect("Failed to serialize config")
         }
         AgentProvider::Groq => {
             let config = super::provider::groq::default_config();
-            serde_yaml::to_value(config).expect("Failed to serialize config")
+            serde_yaml_ng::to_value(config).expect("Failed to serialize config")
         }
         AgentProvider::LocalAI => {
             let config = super::provider::localai::default_config();
-            serde_yaml::to_value(config).expect("Failed to serialize config")
+            serde_yaml_ng::to_value(config).expect("Failed to serialize config")
         }
         AgentProvider::Mistral => {
             let config = super::provider::mistral::default_config();
-            serde_yaml::to_value(config).expect("Failed to serialize config")
+            serde_yaml_ng::to_value(config).expect("Failed to serialize config")
         }
         AgentProvider::Ollama => {
             let config = super::provider::ollama::default_config();
-            serde_yaml::to_value(config).expect("Failed to serialize config")
+            serde_yaml_ng::to_value(config).expect("Failed to serialize config")
         }
         AgentProvider::OpenAI => {
             let config = super::provider::openai::default_config();
-            serde_yaml::to_value(config).expect("Failed to serialize config")
+            serde_yaml_ng::to_value(config).expect("Failed to serialize config")
         }
         AgentProvider::OpenAICompat => {
             let config = super::provider::openai_compat::default_config();
-            serde_yaml::to_value(config).expect("Failed to serialize config")
+            serde_yaml_ng::to_value(config).expect("Failed to serialize config")
         }
         AgentProvider::OpenRouter => {
             let config = super::provider::openrouter::default_config();
-            serde_yaml::to_value(config).expect("Failed to serialize config")
+            serde_yaml_ng::to_value(config).expect("Failed to serialize config")
         }
         AgentProvider::TogetherAI => {
             let config = super::provider::togetherai::default_config();
-            serde_yaml::to_value(config).expect("Failed to serialize config")
+            serde_yaml_ng::to_value(config).expect("Failed to serialize config")
         }
     }
 }

src/agent/provider/anthropic/controller.rs

@@ -71,6 +71,7 @@ impl ControllerTrait for Controller {
 
         let messages = vec![LLMMessage {
             author: LLMAuthor::User,
+            sender_id: None,
             content: LLMMessageContent::Text("Hello!".to_string()),
             timestamp: chrono::Utc::now(),
         }];
@@ -108,6 +109,7 @@ impl ControllerTrait for Controller {
         } else {
             Some(LLMMessage {
                 author: LLMAuthor::Prompt,
+                sender_id: None,
                 content: LLMMessageContent::Text(prompt_text),
                 timestamp: chrono::Utc::now(),
             })
@@ -146,10 +148,10 @@ impl ControllerTrait for Controller {
             .temperature_override
             .unwrap_or(text_generation_config.temperature);
 
-        if let Some(prompt_message) = prompt_message {
-            if let LLMMessageContent::Text(text) = &prompt_message.content {
-                request.system = text.clone();
-            }
+        if let Some(prompt_message) = prompt_message
+            && let LLMMessageContent::Text(text) = &prompt_message.content
+        {
+            request.system = text.clone();
         }
 
         request.model = text_generation_config.model_id.clone();

src/agent/provider/anthropic/mod.rs

@@ -12,12 +12,12 @@ use super::controller::ControllerType;
 
 pub fn create_controller_from_yaml_value_config(
     agent_id: &str,
-    config: serde_yaml::Value,
+    config: serde_yaml_ng::Value,
 ) -> AgentInstantiationResult<ControllerType> {
     let config = match &config {
-        serde_yaml::Value::Mapping(_) => {
+        serde_yaml_ng::Value::Mapping(_) => {
             let config: Config =
-                serde_yaml::from_value(config).map_err(AgentInstantiationError::Yaml)?;
+                serde_yaml_ng::from_value(config).map_err(AgentInstantiationError::Yaml)?;
 
             config
                 .validate()

src/agent/provider/anthropic/utils.rs

@@ -28,6 +28,13 @@ pub(super) fn create_anthropic_message_request(llm_messages: Vec<LLMMessage>) ->
                     },
                 }]
             }
+            LLMMessageContent::File(file_details) => {
+                tracing::warn!(
+                    "The Anthropic provider's library does not support file/document content. This file message ({}) will be skipped.",
+                    file_details.filename(),
+                );
+                continue;
+            }
         };
 
         let message = Message { role, content };

src/agent/provider/openai/config.rs

@@ -84,7 +84,7 @@ impl Default for TextGenerationConfig {
 }
 
 fn default_text_model_id() -> String {
-    "gpt-5.2".to_owned()
+    "gpt-5.4".to_owned()
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, Default)]

src/agent/provider/openai/controller.rs

@@ -5,14 +5,14 @@ use async_openai::{
     config::OpenAIConfig,
     types::{
         audio::{AudioInput, CreateSpeechRequestArgs, CreateTranscriptionRequestArgs},
+        images::{
+            CreateImageEditRequestArgs, CreateImageRequestArgs, Image, ImageInput, ImageModel,
+            ImageResponseFormat,
+        },
         responses::{
             CodeInterpreterContainerAuto, CodeInterpreterTool, CodeInterpreterToolContainer,
             CreateResponseArgs, OutputItem, OutputMessageContent, Tool, WebSearchTool,
         },
-        images::{
-            CreateImageEditRequestArgs, CreateImageRequestArgs,
-            Image, ImageInput, ImageModel, ImageResponseFormat,
-        },
     },
 };
 
@@ -32,8 +32,8 @@ use crate::{
     agent::{
         AgentPurpose,
         provider::entity::{
-            ImageEditResult, ImageGenerationResult, ImageSource, PingResult,
-            TextToSpeechParams, TextToSpeechResult,
+            ImageEditResult, ImageGenerationResult, ImageSource, PingResult, TextToSpeechParams,
+            TextToSpeechResult,
         },
     },
     strings,
@@ -67,6 +67,7 @@ impl ControllerTrait for Controller {
 
         let messages = vec![LLMMessage {
             author: LLMAuthor::User,
+            sender_id: None,
             content: LLMMessageContent::Text("Hello!".to_string()),
             timestamp: chrono::Utc::now(),
         }];
@@ -104,6 +105,7 @@ impl ControllerTrait for Controller {
         } else {
             Some(LLMMessage {
                 author: LLMAuthor::Prompt,
+                sender_id: None,
                 content: LLMMessageContent::Text(prompt_text),
                 timestamp: chrono::Utc::now(),
             })
@@ -129,7 +131,8 @@ impl ControllerTrait for Controller {
             conversation_messages.insert(0, prompt_message);
         }
 
-        let input = super::utils::convert_llm_messages_to_openai_response_input(conversation_messages);
+        let input =
+            super::utils::convert_llm_messages_to_openai_response_input(conversation_messages);
 
         let messages_count = match &input {
             async_openai::types::responses::InputParam::Items(items) => items.len(),
@@ -182,10 +185,7 @@ impl ControllerTrait for Controller {
 
         let response = self.client.responses().create(request).await?;
 
-        tracing::trace!(
-            ?response,
-            "Got response from the OpenAI response API"
-        );
+        tracing::trace!(?response, "Got response from the OpenAI response API");
 
         for item in response.output {
             if let OutputItem::Message(message) = item {
@@ -271,9 +271,7 @@ impl ControllerTrait for Controller {
                 ImageModel::GptImage1 => ImageModel::GptImage1Mini,
                 ImageModel::GptImage1dot5 => ImageModel::GptImage1Mini,
                 ImageModel::GptImage1Mini => ImageModel::GptImage1Mini,
-                ImageModel::Other(_) => {
-                    ImageModel::DallE2
-                }
+                ImageModel::Other(_) => ImageModel::DallE2,
             }
         } else {
             original_model
@@ -408,9 +406,15 @@ impl ControllerTrait for Controller {
         }
 
         let dalle2_size = match image_generation_config.size {
-            Some(async_openai::types::images::ImageSize::S256x256) => Some(async_openai::types::images::ImageSize::S256x256),
-            Some(async_openai::types::images::ImageSize::S512x512) => Some(async_openai::types::images::ImageSize::S512x512),
-            Some(async_openai::types::images::ImageSize::S1024x1024) => Some(async_openai::types::images::ImageSize::S1024x1024),
+            Some(async_openai::types::images::ImageSize::S256x256) => {
+                Some(async_openai::types::images::ImageSize::S256x256)
+            }
+            Some(async_openai::types::images::ImageSize::S512x512) => {
+                Some(async_openai::types::images::ImageSize::S512x512)
+            }
+            Some(async_openai::types::images::ImageSize::S1024x1024) => {
+                Some(async_openai::types::images::ImageSize::S1024x1024)
+            }
             _ => None,
         };
 
@@ -419,12 +423,8 @@ impl ControllerTrait for Controller {
             .map_err(|err| anyhow::anyhow!(err))?;
 
         let response_format = match model.clone() {
-            ImageModel::DallE2 => {
-                Some(ImageResponseFormat::B64Json)
-            }
-            ImageModel::DallE3 => {
-                Some(ImageResponseFormat::B64Json)
-            }
+            ImageModel::DallE2 => Some(ImageResponseFormat::B64Json),
+            ImageModel::DallE3 => Some(ImageResponseFormat::B64Json),
             // gpt-image-1 only outputs base64 and we don't need to specify the response format.
             // In fact, specifying the response format results in an error.
             ImageModel::GptImage1 => None,

src/agent/provider/openai/mod.rs

@@ -20,12 +20,12 @@ pub const OPENAI_IMAGE_MODEL_GPT_IMAGE_1_DOT_5: &str = "gpt-image-1.5";
 
 pub fn create_controller_from_yaml_value_config(
     agent_id: &str,
-    config: serde_yaml::Value,
+    config: serde_yaml_ng::Value,
 ) -> AgentInstantiationResult<ControllerType> {
     let config = match &config {
-        serde_yaml::Value::Mapping(_) => {
+        serde_yaml_ng::Value::Mapping(_) => {
             let config: Config =
-                serde_yaml::from_value(config).map_err(AgentInstantiationError::Yaml)?;
+                serde_yaml_ng::from_value(config).map_err(AgentInstantiationError::Yaml)?;
 
             config
                 .validate()

src/agent/provider/openai/utils.rs

@@ -1,6 +1,6 @@
 use async_openai::types::responses::{
-    EasyInputContent, EasyInputMessage, ImageDetail, InputContent, InputImageContent, InputItem,
-    InputParam, MessageType, Role,
+    EasyInputContent, EasyInputMessage, ImageDetail, InputContent, InputFileArgs,
+    InputImageContent, InputItem, InputParam, MessageType, Role,
 };
 
 use crate::conversation::llm::{
@@ -35,12 +35,28 @@ pub fn convert_llm_messages_to_openai_response_input(
                     file_id: None,
                 })])
             }
+            LLMMessageContent::File(file_details) => {
+                let file_data = format!(
+                    "data:{};base64,{}",
+                    file_details.mime,
+                    base64_encode(&file_details.data)
+                );
+
+                let file_content = InputFileArgs::default()
+                    .file_data(file_data)
+                    .filename(file_details.filename())
+                    .build()
+                    .expect("Failed to build InputFileContent");
+
+                EasyInputContent::ContentList(vec![InputContent::InputFile(file_content)])
+            }
         };
 
         items.push(InputItem::EasyMessage(EasyInputMessage {
             r#type: MessageType::Message,
             role,
             content,
+            phase: None,
         }));
     }
 

src/agent/provider/openai_compat/config.rs

@@ -162,13 +162,14 @@ impl TryInto<OpenAITextToSpeechConfig> for TextToSpeechConfig {
     type Error = String;
 
     fn try_into(self) -> Result<OpenAITextToSpeechConfig, Self::Error> {
-        let model_id = convert_string_to_enum::<async_openai::types::audio::SpeechModel>(&self.model_id)?;
+        let model_id =
+            convert_string_to_enum::<async_openai::types::audio::SpeechModel>(&self.model_id)?;
 
         let voice = convert_string_to_enum::<async_openai::types::audio::Voice>(&self.voice)?;
 
-        let response_format = convert_string_to_enum::<async_openai::types::audio::SpeechResponseFormat>(
-            &self.response_format,
-        )?;
+        let response_format = convert_string_to_enum::<
+            async_openai::types::audio::SpeechResponseFormat,
+        >(&self.response_format)?;
 
         Ok(OpenAITextToSpeechConfig {
             model_id,
@@ -225,25 +226,25 @@ impl TryInto<OpenAIImageGenerationConfig> for ImageGenerationConfig {
 
     fn try_into(self) -> Result<OpenAIImageGenerationConfig, Self::Error> {
         let size = if let Some(size) = &self.size {
-            Some(convert_string_to_enum::<async_openai::types::images::ImageSize>(
-                size,
-            )?)
+            Some(convert_string_to_enum::<
+                async_openai::types::images::ImageSize,
+            >(size)?)
         } else {
             None
         };
 
         let style = if let Some(style) = &self.style {
-            Some(convert_string_to_enum::<async_openai::types::images::ImageStyle>(
-                style,
-            )?)
+            Some(convert_string_to_enum::<
+                async_openai::types::images::ImageStyle,
+            >(style)?)
         } else {
             None
         };
 
         let quality = if let Some(quality) = &self.quality {
-            Some(convert_string_to_enum::<async_openai::types::images::ImageQuality>(
-                quality,
-            )?)
+            Some(convert_string_to_enum::<
+                async_openai::types::images::ImageQuality,
+            >(quality)?)
         } else {
             None
         };

src/agent/provider/openai_compat/controller.rs

@@ -64,6 +64,7 @@ impl ControllerTrait for Controller {
 
         let messages = vec![LLMMessage {
             author: LLMAuthor::User,
+            sender_id: None,
             content: LLMMessageContent::Text("Hello!".to_string()),
             timestamp: chrono::Utc::now(),
         }];
@@ -101,6 +102,7 @@ impl ControllerTrait for Controller {
         } else {
             Some(LLMMessage {
                 author: LLMAuthor::Prompt,
+                sender_id: None,
                 content: LLMMessageContent::Text(prompt_text),
                 timestamp: chrono::Utc::now(),
             })

src/agent/provider/openai_compat/mod.rs

@@ -26,12 +26,12 @@ use super::controller::ControllerType;
 
 pub fn create_controller_from_yaml_value_config(
     agent_id: &str,
-    config: serde_yaml::Value,
+    config: serde_yaml_ng::Value,
 ) -> AgentInstantiationResult<ControllerType> {
     let config = match &config {
-        serde_yaml::Value::Mapping(_) => {
+        serde_yaml_ng::Value::Mapping(_) => {
             let config: Config =
-                serde_yaml::from_value(config).map_err(AgentInstantiationError::Yaml)?;
+                serde_yaml_ng::from_value(config).map_err(AgentInstantiationError::Yaml)?;
 
             config
                 .validate()

src/agent/provider/openai_compat/utils.rs

@@ -40,6 +40,12 @@ fn convert_llm_message_to_openai_message(llm_message: LLMMessage) -> Option<Mess
             );
             None
         }
+        LLMMessageContent::File(_file_details) => {
+            tracing::warn!(
+                "The OpenAI-compat provider's library does not support file content. This file message will be skipped."
+            );
+            None
+        }
     }
 }
 

src/bot/implementation.rs

@@ -4,10 +4,10 @@ use std::{future::Future, pin::Pin};
 
 use mxlink::matrix_sdk::Room;
 use mxlink::matrix_sdk::media::{MediaFormat, MediaRequestParameters};
+use mxlink::matrix_sdk::ruma::api::client::profile::{AvatarUrl, DisplayName};
 use mxlink::matrix_sdk::ruma::{
     MilliSecondsSinceUnixEpoch, OwnedUserId, events::room::MediaSource,
 };
-use mxlink::matrix_sdk::ruma::api::client::profile::{AvatarUrl, DisplayName};
 
 use mxlink::{
     InitConfig, LoginConfig, LoginCredentials, LoginEncryption, MatrixLink, PersistenceConfig,
@@ -25,7 +25,7 @@ use crate::agent::Manager as AgentManager;
 use crate::entity::catch_up_marker::{
     CatchUpMarker, CatchUpMarkerManager, DelayedCatchUpMarkerManager,
 };
-use crate::entity::cfg::{Avatar, Config};
+use crate::entity::cfg::{Avatar, Config, ConfigUserAuth};
 use crate::entity::globalconfig::{GlobalConfig, GlobalConfigurationManager};
 use crate::entity::roomconfig::{RoomConfig, RoomConfigurationManager};
 
@@ -395,10 +395,22 @@ async fn create_matrix_link(config: &Config) -> anyhow::Result<MatrixLink> {
     let session_encryption_key = config.persistence.session_encryption_key()?;
     let db_dir_path: std::path::PathBuf = config.persistence.db_dir_path()?;
 
-    let login_creds = LoginCredentials::UserPassword(
-        config.user.mxid_localpart.to_owned(),
-        config.user.password.to_owned(),
-    );
+    let user_auth = config.user.auth_config(&config.homeserver.server_name)?;
+
+    let login_creds = match user_auth {
+        ConfigUserAuth::UserPassword { username, password } => {
+            LoginCredentials::UserPassword(username, password)
+        }
+        ConfigUserAuth::AccessToken {
+            user_id,
+            device_id,
+            access_token,
+        } => LoginCredentials::AccessToken {
+            user_id,
+            device_id,
+            access_token,
+        },
+    };
 
     let login_encryption = LoginEncryption::new(
         config.user.encryption.recovery_passphrase.clone(),

src/bot/load_config.rs

@@ -21,7 +21,7 @@ pub fn load() -> anyhow::Result<Config> {
     }
 
     let config_str = std::fs::read_to_string(config_file_path)?;
-    let mut config: Config = serde_yaml::from_str(&config_str)?;
+    let mut config: Config = serde_yaml_ng::from_str(&config_str)?;
 
     // Allow environment variables to override some configuration keys
     for (key, value) in env::vars() {
@@ -29,7 +29,15 @@ pub fn load() -> anyhow::Result<Config> {
             cfg_env::BAIBOT_HOMESERVER_SERVER_NAME => config.homeserver.server_name = value,
             cfg_env::BAIBOT_HOMESERVER_URL => config.homeserver.url = value,
             cfg_env::BAIBOT_USER_MXID_LOCALPART => config.user.mxid_localpart = value,
-            cfg_env::BAIBOT_USER_PASSWORD => config.user.password = value,
+            cfg_env::BAIBOT_USER_PASSWORD => {
+                config.user.password = optional_non_empty(value);
+            }
+            cfg_env::BAIBOT_USER_ACCESS_TOKEN => {
+                config.user.access_token = optional_non_empty(value);
+            }
+            cfg_env::BAIBOT_USER_DEVICE_ID => {
+                config.user.device_id = optional_non_empty(value);
+            }
             cfg_env::BAIBOT_USER_ENCRYPTION_RECOVERY_PASSPHRASE => {
                 config.user.encryption.recovery_passphrase = Some(value);
             }
@@ -120,3 +128,7 @@ pub fn load() -> anyhow::Result<Config> {
 
     Ok(config)
 }
+
+fn optional_non_empty(value: String) -> Option<String> {
+    if value.is_empty() { None } else { Some(value) }
+}

src/controller/access/room_local_agent_managers.rs

@@ -28,18 +28,18 @@ pub async fn handle_set(
     message_context: &MessageContext,
     patterns: &Option<Vec<String>>,
 ) -> anyhow::Result<()> {
-    if let Some(patterns) = patterns {
-        if let Err(err) = mxidwc::parse_patterns_vector(patterns) {
-            bot.messaging()
-                .send_error_markdown_no_fail(
-                    message_context.room(),
-                    &strings::access::failed_to_parse_patterns(&err.to_string()),
-                    MessageResponseType::Reply(message_context.thread_info().root_event_id.clone()),
-                )
-                .await;
+    if let Some(patterns) = patterns
+        && let Err(err) = mxidwc::parse_patterns_vector(patterns)
+    {
+        bot.messaging()
+            .send_error_markdown_no_fail(
+                message_context.room(),
+                &strings::access::failed_to_parse_patterns(&err.to_string()),
+                MessageResponseType::Reply(message_context.thread_info().root_event_id.clone()),
+            )
+            .await;
 
-            return Ok(());
-        }
+        return Ok(());
     }
 
     let mut global_config_manager_guard = bot.global_config_manager().lock().await;

src/controller/access/users.rs

@@ -24,18 +24,18 @@ pub async fn handle_set(
     message_context: &MessageContext,
     patterns: &Option<Vec<String>>,
 ) -> anyhow::Result<()> {
-    if let Some(patterns) = patterns {
-        if let Err(err) = mxidwc::parse_patterns_vector(patterns) {
-            bot.messaging()
-                .send_error_markdown_no_fail(
-                    message_context.room(),
-                    &strings::access::failed_to_parse_patterns(&err.to_string()),
-                    MessageResponseType::Reply(message_context.thread_info().root_event_id.clone()),
-                )
-                .await;
+    if let Some(patterns) = patterns
+        && let Err(err) = mxidwc::parse_patterns_vector(patterns)
+    {
+        bot.messaging()
+            .send_error_markdown_no_fail(
+                message_context.room(),
+                &strings::access::failed_to_parse_patterns(&err.to_string()),
+                MessageResponseType::Reply(message_context.thread_info().root_event_id.clone()),
+            )
+            .await;
 
-            return Ok(());
-        }
+        return Ok(());
     }
 
     let mut global_config_manager_guard = bot.global_config_manager().lock().await;

src/controller/agent/create/mod.rs

@@ -15,7 +15,7 @@ use crate::{Bot, entity::MessageContext};
 
 struct ParsedAgentConfig {
     agent: AgentInstance,
-    config: serde_yaml::Value,
+    config: serde_yaml_ng::Value,
 }
 
 pub async fn handle_room_local(
@@ -250,7 +250,7 @@ async fn send_guide(
     provider: &AgentProvider,
 ) -> anyhow::Result<()> {
     let sample_config = crate::agent::default_config_for_provider(provider);
-    let sample_config_pretty_yaml = serde_yaml::to_string(&sample_config)?;
+    let sample_config_pretty_yaml = serde_yaml_ng::to_string(&sample_config)?;
 
     bot.messaging()
         .send_text_markdown_no_fail(
@@ -263,7 +263,7 @@ async fn send_guide(
     Ok(())
 }
 
-fn parse_from_message_to_yaml_value(text: &str) -> Result<serde_yaml::Value, String> {
+fn parse_from_message_to_yaml_value(text: &str) -> Result<serde_yaml_ng::Value, String> {
     let mut text = text.trim();
 
     if text.starts_with("```") {
@@ -274,10 +274,10 @@ fn parse_from_message_to_yaml_value(text: &str) -> Result<serde_yaml::Value, Str
         text = text.trim_end_matches("```");
     }
 
-    let config: serde_yaml::Value = serde_yaml::from_str(text).map_err(|e| e.to_string())?;
+    let config: serde_yaml_ng::Value = serde_yaml_ng::from_str(text).map_err(|e| e.to_string())?;
 
     match config {
-        serde_yaml::Value::Mapping(_) => {}
+        serde_yaml_ng::Value::Mapping(_) => {}
         _ => {
             return Err("Not a valid YAML hashmap".to_owned());
         }

src/controller/agent/create/tests.rs

@@ -2,12 +2,12 @@
 fn agent_config_parsing_works() {
     struct TestCase {
         input: String,
-        expected: Option<serde_yaml::Value>,
+        expected: Option<serde_yaml_ng::Value>,
     }
 
     let provider = crate::agent::AgentProvider::OpenAI;
     let sample_config = crate::agent::default_config_for_provider(&provider);
-    let sample_config_pretty_yaml = serde_yaml::to_string(&sample_config).unwrap();
+    let sample_config_pretty_yaml = serde_yaml_ng::to_string(&sample_config).unwrap();
 
     let test_cases = vec![
         // Invalid input

src/controller/agent/details/mod.rs

@@ -64,7 +64,7 @@ pub async fn handle(
         PublicIdentifier::Static(_) => {}
     };
 
-    let config_yaml_pretty = serde_yaml::to_string(&agent.definition().config)?;
+    let config_yaml_pretty = serde_yaml_ng::to_string(&agent.definition().config)?;
 
     bot.messaging()
         .send_text_markdown_no_fail(

src/controller/cfg/controller_type.rs

@@ -3,7 +3,8 @@ use crate::{
     entity::roomconfig::{
         SpeechToTextFlowType, SpeechToTextMessageTypeForNonThreadedOnlyTranscribedMessages,
         TextGenerationAutoUsage, TextGenerationPrefixRequirementType,
-        TextToSpeechBotMessagesFlowType, TextToSpeechUserMessagesFlowType,
+        TextGenerationSenderContextMode, TextToSpeechBotMessagesFlowType,
+        TextToSpeechUserMessagesFlowType,
     },
 };
 
@@ -48,6 +49,9 @@ pub enum ConfigTextGenerationSettingRelatedControllerType {
 
     GetTemperatureOverride,
     SetTemperatureOverride(Option<f32>),
+
+    GetSenderContextMode,
+    SetSenderContextMode(Option<TextGenerationSenderContextMode>),
 }
 
 #[derive(Debug, PartialEq)]

src/controller/cfg/determination/tests.rs

@@ -163,6 +163,26 @@ fn determine_controller() {
                 ),
             )),
         },
+        TestCase {
+            name: "per-room text-generation/sender-context-mode getter",
+            input: "room text-generation sender-context-mode",
+            expected: super::ControllerType::Config(controller_type::ConfigControllerType::SettingsRelated(
+                controller_type::SettingsStorageSource::Room,
+                controller_type::ConfigSettingRelatedControllerType::TextGeneration(
+                    controller_type::ConfigTextGenerationSettingRelatedControllerType::GetSenderContextMode,
+                ),
+            )),
+        },
+        TestCase {
+            name: "global text-generation/sender-context-mode getter",
+            input: "global text-generation sender-context-mode",
+            expected: super::ControllerType::Config(controller_type::ConfigControllerType::SettingsRelated(
+                controller_type::SettingsStorageSource::Global,
+                controller_type::ConfigSettingRelatedControllerType::TextGeneration(
+                    controller_type::ConfigTextGenerationSettingRelatedControllerType::GetSenderContextMode,
+                ),
+            )),
+        },
         TestCase {
             name: "per-room text-to-speech/speed-override getter",
             input: "room text-to-speech speed-override",

src/controller/cfg/determination/text_generation/mod.rs

@@ -3,7 +3,10 @@ mod tests;
 
 use crate::{
     controller::ControllerType,
-    entity::roomconfig::{TextGenerationAutoUsage, TextGenerationPrefixRequirementType},
+    entity::roomconfig::{
+        TextGenerationAutoUsage, TextGenerationPrefixRequirementType,
+        TextGenerationSenderContextMode,
+    },
     strings,
 };
 
@@ -197,5 +200,43 @@ pub(super) fn determine(
         );
     }
 
+    if let Some(remaining_text) = text.strip_prefix("sender-context-mode") {
+        let remaining_text = remaining_text.trim();
+
+        if !remaining_text.is_empty() {
+            return Err(ControllerType::Error(
+                strings::cfg::configuration_getter_used_with_extra_text(
+                    "sender-context-mode",
+                    remaining_text,
+                )
+                .to_owned(),
+            ));
+        }
+
+        return Ok(ConfigTextGenerationSettingRelatedControllerType::GetSenderContextMode);
+    }
+
+    if let Some(value_string) = text.strip_prefix("set-sender-context-mode") {
+        let value_string = value_string.trim().to_owned();
+        let value_choice = if value_string.is_empty() {
+            None
+        } else {
+            let value_choice =
+                TextGenerationSenderContextMode::from_str(&value_string.to_lowercase());
+
+            if value_choice.is_none() {
+                return Err(ControllerType::Error(
+                    strings::cfg::configuration_value_unrecognized(&value_string).to_owned(),
+                ));
+            }
+
+            value_choice
+        };
+
+        return Ok(
+            ConfigTextGenerationSettingRelatedControllerType::SetSenderContextMode(value_choice),
+        );
+    }
+
     Err(ControllerType::Unknown)
 }

src/controller/cfg/determination/text_generation/tests.rs

@@ -90,6 +90,74 @@ fn determine_controller_context_management() {
     }
 }
 
+#[test]
+fn determine_controller_sender_context() {
+    use super::ConfigTextGenerationSettingRelatedControllerType;
+    use super::ControllerType;
+    use crate::entity::roomconfig::TextGenerationSenderContextMode;
+
+    struct TestCase {
+        name: &'static str,
+        input: &'static str,
+        expected: Result<ConfigTextGenerationSettingRelatedControllerType, ControllerType>,
+    }
+
+    let test_cases = vec![
+        TestCase {
+            name: "sender-context-mode getter ok",
+            input: "sender-context-mode",
+            expected: Ok(ConfigTextGenerationSettingRelatedControllerType::GetSenderContextMode),
+        },
+        TestCase {
+            name: "sender-context-mode getter extra args",
+            input: "sender-context-mode some values here",
+            expected: Err(ControllerType::Error(
+                crate::strings::cfg::configuration_getter_used_with_extra_text(
+                    "sender-context-mode",
+                    "some values here",
+                ),
+            )),
+        },
+        TestCase {
+            name: "sender-context-mode setter matrix_user_id",
+            input: "set-sender-context-mode matrix_user_id",
+            expected: Ok(
+                ConfigTextGenerationSettingRelatedControllerType::SetSenderContextMode(Some(
+                    TextGenerationSenderContextMode::MatrixUserId,
+                )),
+            ),
+        },
+        TestCase {
+            name: "sender-context-mode setter uppercase",
+            input: "set-sender-context-mode MATRIX_USER_ID_AND_TIMESTAMP",
+            expected: Ok(
+                ConfigTextGenerationSettingRelatedControllerType::SetSenderContextMode(Some(
+                    TextGenerationSenderContextMode::MatrixUserIdAndTimestamp,
+                )),
+            ),
+        },
+        TestCase {
+            name: "sender-context-mode setter invalid",
+            input: "set-sender-context-mode non-Enum-Value",
+            expected: Err(ControllerType::Error(
+                crate::strings::cfg::configuration_value_unrecognized("non-Enum-Value"),
+            )),
+        },
+        TestCase {
+            name: "sender-context-mode unsetter",
+            input: "set-sender-context-mode",
+            expected: Ok(
+                ConfigTextGenerationSettingRelatedControllerType::SetSenderContextMode(None),
+            ),
+        },
+    ];
+
+    for test_case in test_cases {
+        let result = super::determine(test_case.input);
+        assert_eq!(result, test_case.expected, "Test case: {}", test_case.name);
+    }
+}
+
 #[test]
 fn determine_controller_prefix_requirement_type() {
     use super::ConfigTextGenerationSettingRelatedControllerType;

src/controller/cfg/dispatching/mod.rs

@@ -39,18 +39,18 @@ async fn dispatch_config_related_handler(
     message_context: &MessageContext,
     bot: &Bot,
 ) -> anyhow::Result<()> {
-    if let SettingsStorageSource::Global = config_type {
-        if !message_context.sender_can_manage_global_config() {
-            bot.messaging()
-                .send_error_markdown_no_fail(
-                    message_context.room(),
-                    strings::global_config::no_permissions_to_administrate(),
-                    MessageResponseType::Reply(message_context.thread_info().root_event_id.clone()),
-                )
-                .await;
-            return Ok(());
-        }
-    };
+    if let SettingsStorageSource::Global = config_type
+        && !message_context.sender_can_manage_global_config()
+    {
+        bot.messaging()
+            .send_error_markdown_no_fail(
+                message_context.room(),
+                strings::global_config::no_permissions_to_administrate(),
+                MessageResponseType::Reply(message_context.thread_info().root_event_id.clone()),
+            )
+            .await;
+        return Ok(());
+    }
 
     let room_settings = match config_type {
         SettingsStorageSource::Room => &message_context.room_config().settings,

src/controller/cfg/dispatching/text_generation.rs

@@ -1,5 +1,6 @@
 use crate::entity::roomconfig::{
     RoomSettings, TextGenerationAutoUsage, TextGenerationPrefixRequirementType,
+    TextGenerationSenderContextMode,
 };
 use crate::{Bot, entity::MessageContext};
 
@@ -151,5 +152,38 @@ pub(super) async fn dispatch(
                 }
             }
         }
+
+        ConfigTextGenerationSettingRelatedControllerType::GetSenderContextMode => {
+            let value = &room_settings.text_generation.sender_context_mode;
+            setting_get::<TextGenerationSenderContextMode>(bot, message_context, value).await
+        }
+        ConfigTextGenerationSettingRelatedControllerType::SetSenderContextMode(value) => {
+            let value = value.to_owned();
+
+            let setter_callback = Box::new(move |room_settings: &mut RoomSettings| {
+                room_settings.text_generation.sender_context_mode = value;
+            });
+
+            match config_type {
+                SettingsStorageSource::Room => {
+                    room_setting_set::<TextGenerationSenderContextMode>(
+                        bot,
+                        message_context,
+                        &value,
+                        setter_callback,
+                    )
+                    .await
+                }
+                SettingsStorageSource::Global => {
+                    global_setting_set::<TextGenerationSenderContextMode>(
+                        bot,
+                        message_context,
+                        &value,
+                        setter_callback,
+                    )
+                    .await
+                }
+            }
+        }
     }
 }

src/controller/cfg/help.rs

@@ -7,7 +7,8 @@ use crate::{
         roomconfig::{
             SpeechToTextFlowType, SpeechToTextMessageTypeForNonThreadedOnlyTranscribedMessages,
             TextGenerationAutoUsage, TextGenerationPrefixRequirementType,
-            TextToSpeechBotMessagesFlowType, TextToSpeechUserMessagesFlowType,
+            TextGenerationSenderContextMode, TextToSpeechBotMessagesFlowType,
+            TextToSpeechUserMessagesFlowType,
         },
     },
     strings,
@@ -233,6 +234,46 @@ fn build_section_text_generation(command_prefix: &str, bot_username: &str) -> St
     ));
     message.push_str("\n\n");
 
+    // Sender Context
+
+    message.push_str(&format!(
+        "#### {}",
+        strings::help::cfg::text_generation_sender_context_heading()
+    ));
+    message.push_str("\n\n");
+    message.push_str(&strings::help::cfg::text_generation_sender_context_intro());
+    message.push('\n');
+    message.push_str(
+        &strings::help::cfg::the_following_configuration_values_are_recognized(
+            TextGenerationSenderContextMode::choices(),
+        ),
+    );
+    message.push_str("\n\n");
+    message.push_str(&format!(
+        "- {}",
+        &strings::help::cfg::current_setting_show(
+            command_prefix,
+            "text-generation sender-context-mode"
+        )
+    ));
+    message.push('\n');
+    message.push_str(&format!(
+        "- {}",
+        &strings::help::cfg::current_setting_set(
+            command_prefix,
+            "text-generation set-sender-context-mode VALUE"
+        )
+    ));
+    message.push('\n');
+    message.push_str(&format!(
+        "- {}",
+        &strings::help::cfg::current_setting_unset(
+            command_prefix,
+            "text-generation set-sender-context-mode"
+        )
+    ));
+    message.push_str("\n\n");
+
     // Prompt override
 
     message.push_str(&format!(

src/controller/cfg/status.rs

@@ -359,6 +359,33 @@ async fn generate_text_generation_section(
         ),
     );
 
+    // Sender Context
+
+    let effective_sender_context = room_config_context.text_generation_sender_context_mode();
+    let room_config_sender_context = room_config_context
+        .room_config
+        .settings
+        .text_generation
+        .sender_context_mode;
+    let global_config_sender_context = room_config_context
+        .global_config
+        .fallback_room_settings
+        .text_generation
+        .sender_context_mode;
+
+    let sender_context_set_where = if room_config_sender_context.is_some() {
+        strings::cfg::status_badge_set_in_room_config()
+    } else if global_config_sender_context.is_some() {
+        strings::cfg::status_badge_set_in_global_config()
+    } else {
+        strings::cfg::status_badge_using_hardcoded_default()
+    };
+
+    message.push_str(&strings::cfg::status_text_generation_entry_sender_context(
+        effective_sender_context,
+        sender_context_set_where,
+    ));
+
     // Prompt override
 
     let text_agent_prompt = if let Some(text_generation_agent) = &text_generation_agent {

src/controller/chat_completion/mod.rs

@@ -15,7 +15,8 @@ use crate::conversation::matrix::MatrixMessageProcessingParams;
 use crate::entity::MessagePayload;
 use crate::entity::roomconfig::{
     SpeechToTextFlowType, SpeechToTextMessageTypeForNonThreadedOnlyTranscribedMessages,
-    TextToSpeechBotMessagesFlowType, TextToSpeechUserMessagesFlowType,
+    TextGenerationSenderContextMode, TextToSpeechBotMessagesFlowType,
+    TextToSpeechUserMessagesFlowType,
 };
 use crate::strings;
 use crate::utils::text_to_speech::create_transcribed_message_text;
@@ -23,6 +24,7 @@ use crate::{
     Bot,
     conversation::{
         create_llm_conversation_for_matrix_reply_chain, create_llm_conversation_for_matrix_thread,
+        llm::{Author, Conversation, MessageContent},
         matrix::create_list_of_bot_user_prefixes_to_strip,
     },
     entity::MessageContext,
@@ -41,6 +43,8 @@ pub enum ChatCompletionControllerType {
 
     Image,
 
+    File,
+
     ThreadMention,
     ReplyMention,
 }
@@ -419,7 +423,8 @@ async fn handle_stage_text_generation(
         | ChatCompletionControllerType::TextMention
         | ChatCompletionControllerType::TextDirect
         | ChatCompletionControllerType::Audio
-        | ChatCompletionControllerType::Image => {
+        | ChatCompletionControllerType::Image
+        | ChatCompletionControllerType::File => {
             Some(message_context.combined_admin_and_user_regexes())
         }
 
@@ -483,6 +488,13 @@ async fn handle_stage_text_generation(
         }
     };
 
+    let conversation = inject_sender_context(
+        conversation,
+        message_context
+            .room_config_context()
+            .text_generation_sender_context_mode(),
+    );
+
     tracing::debug!(
         agent_id = agent.identifier().as_string(),
         provider = format!("{}", agent.definition().provider.clone()),
@@ -758,3 +770,238 @@ async fn generate_and_send_tts_for_message(
     )
     .await
 }
+
+fn inject_sender_context(
+    conversation: Conversation,
+    sender_context_mode: TextGenerationSenderContextMode,
+) -> Conversation {
+    if sender_context_mode == TextGenerationSenderContextMode::Disabled {
+        return conversation;
+    }
+
+    let include_timestamp =
+        sender_context_mode == TextGenerationSenderContextMode::MatrixUserIdAndTimestamp;
+
+    let messages = conversation
+        .messages
+        .into_iter()
+        .map(|mut message| {
+            if message.author == Author::Prompt {
+                return message;
+            }
+
+            let Some(sender_id) = &message.sender_id else {
+                return message;
+            };
+
+            if let MessageContent::Text(ref mut text) = message.content {
+                *text = if include_timestamp {
+                    let timestamp = message.timestamp.format("%Y-%m-%dT%H:%M:%SZ");
+                    format!("[sender={} sent_at={}] {}", sender_id, timestamp, text)
+                } else {
+                    format!("[sender={}] {}", sender_id, text)
+                };
+            }
+
+            message
+        })
+        .collect();
+
+    Conversation { messages }
+}
+
+#[cfg(test)]
+mod sender_context_tests {
+    use super::inject_sender_context;
+    use crate::conversation::llm::{Author, Conversation, ImageDetails, Message, MessageContent};
+    use crate::entity::roomconfig::TextGenerationSenderContextMode;
+    use chrono::{TimeZone, Utc};
+    use mxlink::matrix_sdk::ruma::events::room::message::ImageMessageEventContent;
+    use mxlink::matrix_sdk::ruma::{OwnedMxcUri, OwnedUserId};
+    use mxlink::mime;
+
+    #[test]
+    fn test_inject_sender_context_prefixes_text_messages() {
+        let timestamp = Utc.with_ymd_and_hms(2026, 3, 23, 14, 30, 0).unwrap();
+        let user_id = OwnedUserId::try_from("@alice:example.com").unwrap();
+
+        let conversation = Conversation {
+            messages: vec![Message {
+                author: Author::User,
+                sender_id: Some(user_id),
+                timestamp,
+                content: MessageContent::Text("Hello bot".to_string()),
+            }],
+        };
+
+        let result = inject_sender_context(
+            conversation,
+            TextGenerationSenderContextMode::MatrixUserIdAndTimestamp,
+        );
+
+        assert_eq!(result.messages.len(), 1);
+        assert_eq!(
+            result.messages[0].content,
+            MessageContent::Text(
+                "[sender=@alice:example.com sent_at=2026-03-23T14:30:00Z] Hello bot".to_string()
+            )
+        );
+    }
+
+    #[test]
+    fn test_inject_sender_context_can_prefix_without_timestamp() {
+        let timestamp = Utc.with_ymd_and_hms(2026, 3, 23, 14, 30, 0).unwrap();
+        let user_id = OwnedUserId::try_from("@alice:example.com").unwrap();
+
+        let conversation = Conversation {
+            messages: vec![Message {
+                author: Author::User,
+                sender_id: Some(user_id),
+                timestamp,
+                content: MessageContent::Text("Hello bot".to_string()),
+            }],
+        };
+
+        let result =
+            inject_sender_context(conversation, TextGenerationSenderContextMode::MatrixUserId);
+
+        assert_eq!(result.messages.len(), 1);
+        assert_eq!(
+            result.messages[0].content,
+            MessageContent::Text("[sender=@alice:example.com] Hello bot".to_string())
+        );
+    }
+
+    #[test]
+    fn test_inject_sender_context_prefixes_assistant_messages() {
+        let timestamp = Utc.with_ymd_and_hms(2026, 3, 23, 14, 30, 0).unwrap();
+        let user_id = OwnedUserId::try_from("@baibot:example.com").unwrap();
+
+        let conversation = Conversation {
+            messages: vec![Message {
+                author: Author::Assistant,
+                sender_id: Some(user_id),
+                timestamp,
+                content: MessageContent::Text("Hello human".to_string()),
+            }],
+        };
+
+        let result = inject_sender_context(
+            conversation,
+            TextGenerationSenderContextMode::MatrixUserIdAndTimestamp,
+        );
+
+        assert_eq!(result.messages.len(), 1);
+        assert_eq!(
+            result.messages[0].content,
+            MessageContent::Text(
+                "[sender=@baibot:example.com sent_at=2026-03-23T14:30:00Z] Hello human".to_string()
+            )
+        );
+    }
+
+    #[test]
+    fn test_inject_sender_context_skips_prompt_messages() {
+        let timestamp = Utc.with_ymd_and_hms(2026, 3, 23, 14, 30, 0).unwrap();
+
+        let conversation = Conversation {
+            messages: vec![Message {
+                author: Author::Prompt,
+                sender_id: None,
+                timestamp,
+                content: MessageContent::Text("You are a bot".to_string()),
+            }],
+        };
+
+        let result =
+            inject_sender_context(conversation, TextGenerationSenderContextMode::MatrixUserId);
+
+        assert_eq!(
+            result.messages[0].content,
+            MessageContent::Text("You are a bot".to_string())
+        );
+    }
+
+    #[test]
+    fn test_inject_sender_context_skips_messages_without_sender_id() {
+        let timestamp = Utc.with_ymd_and_hms(2026, 3, 23, 14, 30, 0).unwrap();
+
+        let conversation = Conversation {
+            messages: vec![Message {
+                author: Author::User,
+                sender_id: None,
+                timestamp,
+                content: MessageContent::Text("Transcribed text".to_string()),
+            }],
+        };
+
+        let result = inject_sender_context(
+            conversation,
+            TextGenerationSenderContextMode::MatrixUserIdAndTimestamp,
+        );
+
+        assert_eq!(
+            result.messages[0].content,
+            MessageContent::Text("Transcribed text".to_string())
+        );
+    }
+
+    #[test]
+    fn test_inject_sender_context_leaves_non_text_content_unchanged() {
+        let timestamp = Utc.with_ymd_and_hms(2026, 3, 23, 14, 30, 0).unwrap();
+        let user_id = OwnedUserId::try_from("@alice:example.com").unwrap();
+        let image_event_content = ImageMessageEventContent::plain(
+            "image.png".to_string(),
+            OwnedMxcUri::from("mxc://example.com/1234567890"),
+        );
+
+        let conversation = Conversation {
+            messages: vec![Message {
+                author: Author::User,
+                sender_id: Some(user_id),
+                timestamp,
+                content: MessageContent::Image(ImageDetails::new(
+                    image_event_content.clone(),
+                    mime::IMAGE_PNG,
+                    vec![],
+                )),
+            }],
+        };
+
+        let result = inject_sender_context(
+            conversation,
+            TextGenerationSenderContextMode::MatrixUserIdAndTimestamp,
+        );
+
+        assert_eq!(
+            result.messages[0].content,
+            MessageContent::Image(ImageDetails::new(
+                image_event_content,
+                mime::IMAGE_PNG,
+                vec![]
+            ))
+        );
+    }
+
+    #[test]
+    fn test_inject_sender_context_none_leaves_text_unchanged() {
+        let timestamp = Utc.with_ymd_and_hms(2026, 3, 23, 14, 30, 0).unwrap();
+        let user_id = OwnedUserId::try_from("@alice:example.com").unwrap();
+
+        let conversation = Conversation {
+            messages: vec![Message {
+                author: Author::User,
+                sender_id: Some(user_id),
+                timestamp,
+                content: MessageContent::Text("Hello bot".to_string()),
+            }],
+        };
+
+        let result = inject_sender_context(conversation, TextGenerationSenderContextMode::Disabled);
+
+        assert_eq!(
+            result.messages[0].content,
+            MessageContent::Text("Hello bot".to_string())
+        );
+    }
+}

src/controller/determination/mod.rs

@@ -58,6 +58,18 @@ pub fn determine_controller(
                 )
             }
         }
+        MessagePayload::File(_file_message_content) => {
+            let prefix_requirement_type = message_context
+                .room_config_context()
+                .text_generation_prefix_requirement_type();
+
+            match prefix_requirement_type {
+                TextGenerationPrefixRequirementType::CommandPrefix => ControllerType::Ignore,
+                TextGenerationPrefixRequirementType::No => {
+                    ControllerType::ChatCompletion(ChatCompletionControllerType::File)
+                }
+            }
+        }
         MessagePayload::Audio(_) => {
             ControllerType::ChatCompletion(ChatCompletionControllerType::Audio)
         }

src/controller/image/prompt.rs

@@ -64,6 +64,7 @@ mod tests {
                 original_prompt: "Generate a picture of a dog",
                 messages: vec![Message {
                     author: Author::User,
+                    sender_id: None,
                     content: MessageContent::Text("Must be blue".to_owned()),
                     timestamp,
                 }],
@@ -75,16 +76,19 @@ mod tests {
                 messages: vec![
                     Message {
                         author: Author::User,
+                        sender_id: None,
                         content: MessageContent::Text("Must be blue".to_owned()),
                         timestamp,
                     },
                     Message {
                         author: Author::Assistant,
+                        sender_id: None,
                         content: MessageContent::Text("Whatever".to_owned()),
                         timestamp,
                     },
                     Message {
                         author: Author::User,
+                        sender_id: None,
                         content: MessageContent::Text(
                             "Must be 3-legged.\nMust be flying.".to_owned(),
                         ),
@@ -99,21 +103,25 @@ mod tests {
                 messages: vec![
                     Message {
                         author: Author::User,
+                        sender_id: None,
                         content: MessageContent::Text("Must be blue".to_owned()),
                         timestamp,
                     },
                     Message {
                         author: Author::Assistant,
+                        sender_id: None,
                         content: MessageContent::Text("Whatever".to_owned()),
                         timestamp,
                     },
                     Message {
                         author: Author::User,
+                        sender_id: None,
                         content: MessageContent::Text("Again".to_owned()),
                         timestamp,
                     },
                     Message {
                         author: Author::User,
+                        sender_id: None,
                         content: MessageContent::Text("again".to_owned()),
                         timestamp,
                     },

src/conversation/llm/entity.rs

@@ -1,5 +1,8 @@
 use chrono::{DateTime, Utc};
-use mxlink::matrix_sdk::ruma::events::room::message::ImageMessageEventContent;
+use mxlink::matrix_sdk::ruma::OwnedUserId;
+use mxlink::matrix_sdk::ruma::events::room::message::{
+    FileMessageEventContent, ImageMessageEventContent,
+};
 use mxlink::mime::Mime;
 
 use crate::agent::provider::ImageSource;
@@ -14,6 +17,7 @@ pub enum Author {
 #[derive(Debug, Clone)]
 pub struct Message {
     pub author: Author,
+    pub sender_id: Option<OwnedUserId>,
     pub timestamp: DateTime<Utc>,
     pub content: MessageContent,
 }
@@ -48,10 +52,35 @@ impl From<ImageDetails> for ImageSource {
     }
 }
 
+#[derive(Debug, Clone)]
+pub struct FileDetails {
+    pub event_content: FileMessageEventContent,
+    pub mime: Mime,
+    pub data: Vec<u8>,
+}
+
+impl FileDetails {
+    pub fn new(event_content: FileMessageEventContent, mime: Mime, data: Vec<u8>) -> Self {
+        Self {
+            event_content,
+            mime,
+            data,
+        }
+    }
+
+    pub fn filename(&self) -> String {
+        self.event_content
+            .filename
+            .clone()
+            .unwrap_or(self.event_content.body.clone())
+    }
+}
+
 #[derive(Debug, Clone)]
 pub enum MessageContent {
     Text(String),
     Image(ImageDetails),
+    File(FileDetails),
 }
 
 impl PartialEq for MessageContent {
@@ -62,6 +91,7 @@ impl PartialEq for MessageContent {
                 // We can probably do better than this by inspecting `.event_conten1t.source`, but for now this is good enough.
                 a.filename() == b.filename()
             }
+            (MessageContent::File(a), MessageContent::File(b)) => a.filename() == b.filename(),
             _ => false,
         }
     }
@@ -76,6 +106,11 @@ impl Conversation {
     ///
     /// Certain models (like Anthropic) cannot tolerate consecutive messages by the same author,
     /// so combining them helps avoid issues.
+    ///
+    /// When multiple text messages by the same author are merged, the resulting message keeps a
+    /// `sender_id` only if all merged messages came from the same sender. Mixed-sender merges are
+    /// possible for user turns in multi-user rooms, so `sender_id` is cleared in that case to
+    /// avoid incorrectly attributing the whole merged turn to the first sender.
     /// See: https://github.com/etkecc/baibot/issues/13
     pub fn combine_consecutive_messages(&self) -> Conversation {
         // We'll likely get fewer messages, but let's reserve the maximum we expect.
@@ -106,6 +141,10 @@ impl Conversation {
                 text.push('\n');
                 text.push_str(message_text_content);
             }
+
+            if last_message.sender_id != message.sender_id {
+                last_message.sender_id = None;
+            }
         }
 
         Conversation {
@@ -122,7 +161,7 @@ impl Conversation {
 mod tests {
     use super::*;
     use chrono::{TimeZone, Utc};
-    use mxlink::matrix_sdk::ruma::OwnedMxcUri;
+    use mxlink::matrix_sdk::ruma::{OwnedMxcUri, OwnedUserId};
     use mxlink::mime;
 
     #[test]
@@ -145,21 +184,25 @@ mod tests {
                 // User's turn
                 Message {
                     author: Author::User,
+                    sender_id: None,
                     content: MessageContent::Text("Hello".to_string()),
                     timestamp: timestamp_1,
                 },
                 Message {
                     author: Author::User,
+                    sender_id: None,
                     content: MessageContent::Text("How are you?".to_string()),
                     timestamp: timestamp_2,
                 },
                 Message {
                     author: Author::User,
+                    sender_id: None,
                     content: MessageContent::Text("I'm OK, btw.".to_string()),
                     timestamp: timestamp_3,
                 },
                 Message {
                     author: Author::User,
+                    sender_id: None,
                     content: MessageContent::Image(ImageDetails::new(
                         image_event_content.clone(),
                         mime::IMAGE_PNG,
@@ -169,28 +212,33 @@ mod tests {
                 },
                 Message {
                     author: Author::User,
+                    sender_id: None,
                     content: MessageContent::Text("Above is an image.".to_string()),
                     timestamp: timestamp_4,
                 },
                 Message {
                     author: Author::User,
+                    sender_id: None,
                     content: MessageContent::Text("Would you take a look at it?".to_string()),
                     timestamp: timestamp_4,
                 },
                 // Assistant's turn
                 Message {
                     author: Author::Assistant,
+                    sender_id: None,
                     content: MessageContent::Text("Hi there!".to_string()),
                     timestamp: timestamp_2,
                 },
                 Message {
                     author: Author::Assistant,
+                    sender_id: None,
                     content: MessageContent::Text("I'm doing well, thank you.".to_string()),
                     timestamp: timestamp_3,
                 },
                 // User's turn
                 Message {
                     author: Author::User,
+                    sender_id: None,
                     content: MessageContent::Text("That's great!".to_string()),
                     timestamp: timestamp_3,
                 },
@@ -239,4 +287,39 @@ mod tests {
         );
         assert_eq!(conversation.messages[4].timestamp, timestamp_3);
     }
+
+    #[test]
+    fn combine_consecutive_messages_clears_sender_id_for_mixed_sender_turns() {
+        let timestamp_1 = Utc.with_ymd_and_hms(2024, 9, 20, 18, 34, 15).unwrap();
+        let timestamp_2 = Utc.with_ymd_and_hms(2024, 9, 20, 18, 34, 16).unwrap();
+        let sender_1 = OwnedUserId::try_from("@alice:example.com").unwrap();
+        let sender_2 = OwnedUserId::try_from("@bob:example.com").unwrap();
+
+        let conversation = Conversation {
+            messages: vec![
+                Message {
+                    author: Author::User,
+                    sender_id: Some(sender_1),
+                    content: MessageContent::Text("Hello".to_string()),
+                    timestamp: timestamp_1,
+                },
+                Message {
+                    author: Author::User,
+                    sender_id: Some(sender_2),
+                    content: MessageContent::Text("Hi there".to_string()),
+                    timestamp: timestamp_2,
+                },
+            ],
+        };
+
+        let conversation = conversation.combine_consecutive_messages();
+
+        assert_eq!(conversation.messages.len(), 1);
+        assert_eq!(conversation.messages[0].sender_id, None);
+        assert_eq!(
+            conversation.messages[0].content,
+            MessageContent::Text("Hello\nHi there".to_string())
+        );
+        assert_eq!(conversation.messages[0].timestamp, timestamp_1);
+    }
 }

src/conversation/llm/tests.rs

@@ -20,6 +20,7 @@ fn test_messages_by_the_bot_are_identified_correctly() {
     let llm_message = convert_matrix_message_to_llm_message(&matrix_message, &bot_user_id).unwrap();
 
     assert_eq!(llm_message.author, Author::Assistant);
+    assert_eq!(llm_message.sender_id, Some(bot_user_id.clone()));
     assert_eq!(
         llm_message.content,
         MessageContent::Text("Hello!".to_string())
@@ -47,6 +48,7 @@ fn test_notice_messages_by_bot_with_speech_to_text_prefix_are_cleaned_up_and_con
     let llm_message = convert_matrix_message_to_llm_message(&matrix_message, &bot_user_id).unwrap();
 
     assert_eq!(llm_message.author, Author::User);
+    assert_eq!(llm_message.sender_id, None);
     assert_eq!(
         llm_message.content,
         MessageContent::Text(source_message_text.to_string())
@@ -75,6 +77,30 @@ fn test_notice_error_messages_by_bot_are_ignored() {
     assert!(llm_message.is_none());
 }
 
+#[test]
+fn test_user_messages_preserve_sender_id() {
+    let bot_user_id =
+        OwnedUserId::try_from("@bot:example.com").expect("Failed to parse bot user ID");
+
+    let user_id = OwnedUserId::try_from("@alice:example.com").expect("Failed to parse user ID");
+
+    let matrix_message = super::super::matrix::MatrixMessage {
+        sender_id: user_id.clone(),
+        content: super::super::matrix::MatrixMessageContent::Text("Hello!".to_owned()),
+        mentioned_users: vec![],
+        timestamp: chrono::Utc::now(),
+    };
+
+    let llm_message = convert_matrix_message_to_llm_message(&matrix_message, &bot_user_id).unwrap();
+
+    assert_eq!(llm_message.author, Author::User);
+    assert_eq!(llm_message.sender_id, Some(user_id));
+    assert_eq!(
+        llm_message.content,
+        MessageContent::Text("Hello!".to_string())
+    );
+}
+
 #[test]
 fn test_other_notice_messages_by_the_bot_are_ignored() {
     // Also see `test_notice_error_messages_by_bot_are_ignored()`.

src/conversation/llm/tokenization.rs

@@ -1,15 +1,15 @@
 use tiktoken_rs::CoreBPE;
-use tiktoken_rs::get_bpe_from_tokenizer;
+use tiktoken_rs::bpe_for_tokenizer;
 use tiktoken_rs::tokenizer;
 
 use super::{Author, Message, MessageContent};
 
-fn get_bpe_for_model(model: &str) -> CoreBPE {
+fn get_bpe_for_model(model: &str) -> &'static CoreBPE {
     let tokenizer = tokenizer::get_tokenizer(model)
         .or_else(|| tokenizer::get_tokenizer("gpt-4"))
         .unwrap();
 
-    get_bpe_from_tokenizer(tokenizer).unwrap()
+    bpe_for_tokenizer(tokenizer).unwrap()
 }
 
 pub fn shorten_messages_list_to_context_size(
@@ -26,7 +26,7 @@ pub fn shorten_messages_list_to_context_size(
     // We want to retain the prompt in all cases, so we always count it first.
     // We also always reserve enough tokens for the maximum response we expect.
     let mut current_context_length: u32 = if let Some(prompt_message) = prompt_message {
-        calculate_token_size_for_message(&bpe, model, prompt_message)
+        calculate_token_size_for_message(bpe, model, prompt_message)
             + max_response_tokens.unwrap_or(0)
     } else {
         0
@@ -37,7 +37,7 @@ pub fn shorten_messages_list_to_context_size(
     let mut messages_to_keep: Vec<Message> = Vec::new();
 
     for message in messages {
-        let tokens_for_message = calculate_token_size_for_message(&bpe, model, &message);
+        let tokens_for_message = calculate_token_size_for_message(bpe, model, &message);
 
         if current_context_length + tokens_for_message > max_context_tokens {
             break;
@@ -74,6 +74,7 @@ fn calculate_token_size_for_message(bpe: &CoreBPE, model: &str, message: &Messag
     let text_length = match &message.content {
         MessageContent::Text(text) => bpe.encode_with_special_tokens(text).len() as i32,
         MessageContent::Image(..) => 0,
+        MessageContent::File(..) => 0,
     };
 
     (text_length + role_length + tokens_per_message + tokens_per_name) as u32
@@ -88,11 +89,12 @@ pub mod test {
 
         let message = super::Message {
             author: super::Author::User,
+            sender_id: None,
             content: super::MessageContent::Text("Hello there!".to_string()),
             timestamp: chrono::Utc::now(),
         };
 
-        let tokens = super::calculate_token_size_for_message(&bpe, model, &message);
+        let tokens = super::calculate_token_size_for_message(bpe, model, &message);
 
         assert_eq!(8, tokens);
     }
@@ -107,6 +109,7 @@ pub mod test {
 
         let prompt = super::Message {
             author: super::Author::Prompt,
+            sender_id: None,
             content: super::MessageContent::Text("You are a bot!".to_string()),
             timestamp: chrono::Utc::now(),
         };
@@ -114,13 +117,14 @@ pub mod test {
 
         assert_eq!(
             prompt_length,
-            super::calculate_token_size_for_message(&bpe, model, &prompt)
+            super::calculate_token_size_for_message(bpe, model, &prompt)
         );
 
         let mut conversation_messages = Vec::new();
 
         let first = super::Message {
             author: super::Author::User,
+            sender_id: None,
             content: super::MessageContent::Text("Hello there!".to_string()),
             timestamp: chrono::Utc::now(),
         };
@@ -128,13 +132,14 @@ pub mod test {
 
         assert_eq!(
             first_length,
-            super::calculate_token_size_for_message(&bpe, model, &first)
+            super::calculate_token_size_for_message(bpe, model, &first)
         );
 
         conversation_messages.push(first);
 
         let second = super::Message {
             author: super::Author::Assistant,
+            sender_id: None,
             content: super::MessageContent::Text("Hello!".to_string()),
             timestamp: chrono::Utc::now(),
         };
@@ -142,13 +147,14 @@ pub mod test {
 
         assert_eq!(
             second_length,
-            super::calculate_token_size_for_message(&bpe, model, &second)
+            super::calculate_token_size_for_message(bpe, model, &second)
         );
 
         conversation_messages.push(second);
 
         let third = super::Message {
             author: super::Author::User,
+            sender_id: None,
             content: super::MessageContent::Text(
                 "This is the 3rd message in this conversation. It shall be preserved.".to_owned(),
             ),
@@ -158,13 +164,14 @@ pub mod test {
 
         assert_eq!(
             third_length,
-            super::calculate_token_size_for_message(&bpe, model, &third)
+            super::calculate_token_size_for_message(bpe, model, &third)
         );
 
         conversation_messages.push(third.clone());
 
         let forth = super::Message {
             author: super::Author::Assistant,
+            sender_id: None,
             content: super::MessageContent::Text(
                 "This is yet another message that shall be preserved.".to_owned(),
             ),
@@ -174,7 +181,7 @@ pub mod test {
 
         assert_eq!(
             forth_length,
-            super::calculate_token_size_for_message(&bpe, model, &forth)
+            super::calculate_token_size_for_message(bpe, model, &forth)
         );
 
         conversation_messages.push(forth.clone());
@@ -212,6 +219,7 @@ pub mod test {
 
         let prompt = super::Message {
             author: super::Author::User,
+            sender_id: None,
             content: super::MessageContent::Text("あなたはボットです。".to_string()),
             timestamp: chrono::Utc::now(),
         };
@@ -219,13 +227,14 @@ pub mod test {
 
         assert_eq!(
             prompt_length,
-            super::calculate_token_size_for_message(&bpe, model, &prompt)
+            super::calculate_token_size_for_message(bpe, model, &prompt)
         );
 
         let mut conversation_messages = Vec::new();
 
         let first = super::Message {
             author: super::Author::User,
+            sender_id: None,
             content: super::MessageContent::Text("こんにちは!".to_string()),
             timestamp: chrono::Utc::now(),
         };
@@ -233,13 +242,14 @@ pub mod test {
 
         assert_eq!(
             first_length,
-            super::calculate_token_size_for_message(&bpe, model, &first)
+            super::calculate_token_size_for_message(bpe, model, &first)
         );
 
         conversation_messages.push(first);
 
         let second = super::Message {
             author: super::Author::Assistant,
+            sender_id: None,
             content: super::MessageContent::Text("こんにちは。今日は元気ですか。".to_string()),
             timestamp: chrono::Utc::now(),
         };
@@ -247,13 +257,14 @@ pub mod test {
 
         assert_eq!(
             second_length,
-            super::calculate_token_size_for_message(&bpe, model, &second)
+            super::calculate_token_size_for_message(bpe, model, &second)
         );
 
         conversation_messages.push(second);
 
         let third = super::Message {
             author: super::Author::User,
+            sender_id: None,
             content: super::MessageContent::Text(
                 "これは第3のメッセージなので、保存されます。".to_string(),
             ),
@@ -263,13 +274,14 @@ pub mod test {
 
         assert_eq!(
             third_length,
-            super::calculate_token_size_for_message(&bpe, model, &third)
+            super::calculate_token_size_for_message(bpe, model, &third)
         );
 
         conversation_messages.push(third.clone());
 
         let forth = super::Message {
             author: super::Author::Assistant,
+            sender_id: None,
             content: super::MessageContent::Text(
                 "これはもう一つの保存されますメッセージです。".to_string(),
             ),
@@ -279,7 +291,7 @@ pub mod test {
 
         assert_eq!(
             forth_length,
-            super::calculate_token_size_for_message(&bpe, model, &forth)
+            super::calculate_token_size_for_message(bpe, model, &forth)
         );
 
         conversation_messages.push(forth.clone());

src/conversation/llm/utils.rs

@@ -1,6 +1,6 @@
 use mxlink::matrix_sdk::ruma::OwnedUserId;
 
-use super::entity::{Author, ImageDetails, Message, MessageContent};
+use super::entity::{Author, FileDetails, ImageDetails, Message, MessageContent};
 use crate::conversation::matrix::{MatrixMessage, MatrixMessageContent};
 use crate::utils::text_to_speech as text_to_speech_utils;
 
@@ -17,14 +17,17 @@ pub fn convert_matrix_message_to_llm_message(
 
 fn convert_bot_message(matrix_message: &MatrixMessage) -> Option<Message> {
     match &matrix_message.content {
-        MatrixMessageContent::Text(text) => {
-            convert_bot_text_message(text, &matrix_message.timestamp)
-        }
+        MatrixMessageContent::Text(text) => convert_bot_text_message(
+            text,
+            &matrix_message.timestamp,
+            matrix_message.sender_id.clone(),
+        ),
         MatrixMessageContent::Notice(text) => {
             convert_bot_notice_message(text, &matrix_message.timestamp)
         }
         MatrixMessageContent::Image(image_content, mime_type, media_bytes) => Some(Message {
             author: Author::Assistant,
+            sender_id: Some(matrix_message.sender_id.clone()),
             content: MessageContent::Image(ImageDetails::new(
                 image_content.clone(),
                 mime_type.clone(),
@@ -32,15 +35,27 @@ fn convert_bot_message(matrix_message: &MatrixMessage) -> Option<Message> {
             )),
             timestamp: matrix_message.timestamp.to_owned(),
         }),
+        MatrixMessageContent::File(file_content, mime_type, media_bytes) => Some(Message {
+            author: Author::Assistant,
+            sender_id: Some(matrix_message.sender_id.clone()),
+            content: MessageContent::File(FileDetails::new(
+                file_content.clone(),
+                mime_type.clone(),
+                media_bytes.clone(),
+            )),
+            timestamp: matrix_message.timestamp.to_owned(),
+        }),
     }
 }
 
 fn convert_bot_text_message(
     text: &str,
     timestamp: &chrono::DateTime<chrono::Utc>,
+    sender_id: OwnedUserId,
 ) -> Option<Message> {
     Some(Message {
         author: Author::Assistant,
+        sender_id: Some(sender_id),
         content: MessageContent::Text(text.to_owned()),
         timestamp: timestamp.to_owned(),
     })
@@ -59,8 +74,10 @@ fn convert_bot_notice_message(
 
     if let Some(text) = text_to_speech_utils::parse_transcribed_message_text(text) {
         // This is a transcription message. We remove the prefix and consider it as a message sent by the user.
+        // sender_id is None because the original speaker is unknown.
         return Some(Message {
             author: Author::User,
+            sender_id: None,
             content: MessageContent::Text(text.to_owned()),
             timestamp: timestamp.to_owned(),
         });
@@ -73,16 +90,19 @@ fn convert_user_message(matrix_message: &MatrixMessage) -> Option<Message> {
     match &matrix_message.content {
         MatrixMessageContent::Text(text) => Some(Message {
             author: Author::User,
+            sender_id: Some(matrix_message.sender_id.clone()),
             content: MessageContent::Text(text.clone()),
             timestamp: matrix_message.timestamp.to_owned(),
         }),
         MatrixMessageContent::Notice(text) => Some(Message {
             author: Author::User,
+            sender_id: Some(matrix_message.sender_id.clone()),
             content: MessageContent::Text(text.clone()),
             timestamp: matrix_message.timestamp.to_owned(),
         }),
         MatrixMessageContent::Image(image_content, mime_type, media_bytes) => Some(Message {
             author: Author::User,
+            sender_id: Some(matrix_message.sender_id.clone()),
             content: MessageContent::Image(ImageDetails::new(
                 image_content.clone(),
                 mime_type.clone(),
@@ -90,5 +110,15 @@ fn convert_user_message(matrix_message: &MatrixMessage) -> Option<Message> {
             )),
             timestamp: matrix_message.timestamp.to_owned(),
         }),
+        MatrixMessageContent::File(file_content, mime_type, media_bytes) => Some(Message {
+            author: Author::User,
+            sender_id: Some(matrix_message.sender_id.clone()),
+            content: MessageContent::File(FileDetails::new(
+                file_content.clone(),
+                mime_type.clone(),
+                media_bytes.clone(),
+            )),
+            timestamp: matrix_message.timestamp.to_owned(),
+        }),
     }
 }

src/conversation/matrix/entity.rs

@@ -2,7 +2,9 @@ use chrono::{DateTime, Utc};
 use regex::Regex;
 
 use mxlink::matrix_sdk::ruma::OwnedUserId;
-use mxlink::matrix_sdk::ruma::events::room::message::ImageMessageEventContent;
+use mxlink::matrix_sdk::ruma::events::room::message::{
+    FileMessageEventContent, ImageMessageEventContent,
+};
 use mxlink::mime::Mime;
 
 #[derive(Clone)]
@@ -18,6 +20,7 @@ pub enum MatrixMessageContent {
     Text(String),
     Notice(String),
     Image(ImageMessageEventContent, Mime, Vec<u8>),
+    File(FileMessageEventContent, Mime, Vec<u8>),
 }
 
 #[derive(Clone)]

src/conversation/matrix/utils/mod.rs

@@ -119,7 +119,7 @@ async fn get_matrix_messages_in_reply_chain_native(
             AnySyncMessageLikeEvent::RoomMessage(room_message) => {
                 if let SyncMessageLikeEvent::Original(room_message_original) = room_message {
                     match room_message_original.content.relates_to {
-                        Some(Relation::Reply { in_reply_to }) => Some(in_reply_to.event_id.clone()),
+                        Some(Relation::Reply(reply)) => Some(reply.in_reply_to.event_id.clone()),
                         _ => None,
                     }
                 } else {
@@ -154,35 +154,35 @@ pub async fn process_matrix_messages(
 
         let mut message = message.clone();
 
-        if i == 0 && !params.first_message_prefixes_to_strip.is_empty() {
-            if let MatrixMessageContent::Text(message_text) = &message.content {
-                let mut message_text = message_text.clone();
+        if i == 0
+            && !params.first_message_prefixes_to_strip.is_empty()
+            && let MatrixMessageContent::Text(message_text) = &message.content
+        {
+            let mut message_text = message_text.clone();
 
-                for prefix in &params.first_message_prefixes_to_strip {
-                    if let Some(message_text_stripped) = message_text.strip_prefix(prefix) {
-                        message_text = message_text_stripped.to_owned();
-                    }
+            for prefix in &params.first_message_prefixes_to_strip {
+                if let Some(message_text_stripped) = message_text.strip_prefix(prefix) {
+                    message_text = message_text_stripped.to_owned();
                 }
-
-                message.content = MatrixMessageContent::Text(message_text.trim().to_owned());
             }
+
+            message.content = MatrixMessageContent::Text(message_text.trim().to_owned());
         }
 
         // We only strip `bot_user_prefixes_to_strip`-defined prefixes from messages that mention the bot user.
         if !params.bot_user_prefixes_to_strip.is_empty()
             && message.mentioned_users.contains(&params.bot_user_id)
+            && let MatrixMessageContent::Text(message_text) = &message.content
         {
-            if let MatrixMessageContent::Text(message_text) = &message.content {
-                let mut message_text = message_text.clone();
+            let mut message_text = message_text.clone();
 
-                for prefix in &params.bot_user_prefixes_to_strip {
-                    if let Some(message_text_stripped) = message_text.strip_prefix(prefix) {
-                        message_text = message_text_stripped.to_owned();
-                    }
+            for prefix in &params.bot_user_prefixes_to_strip {
+                if let Some(message_text_stripped) = message_text.strip_prefix(prefix) {
+                    message_text = message_text_stripped.to_owned();
                 }
-
-                message.content = MatrixMessageContent::Text(message_text.trim().to_owned());
             }
+
+            message.content = MatrixMessageContent::Text(message_text.trim().to_owned());
         }
 
         messages_filtered.push(message);
@@ -234,6 +234,7 @@ pub async fn convert_matrix_native_event_to_matrix_message(
         MessageType::Text(text_content) => (text_content.body.clone(), false),
         MessageType::Notice(notice_content) => (notice_content.body.clone(), true),
         MessageType::Image(image_content) => (image_content.body.clone(), false),
+        MessageType::File(file_content) => (file_content.body.clone(), false),
         _ => return Ok(None),
     };
 
@@ -291,6 +292,67 @@ pub async fn convert_matrix_native_event_to_matrix_message(
         }));
     }
 
+    if let MessageType::File(file_content) = &room_message.msgtype {
+        let media_request = mxlink::matrix_sdk::media::MediaRequestParameters {
+            source: file_content.source.to_owned(),
+            format: mxlink::matrix_sdk::media::MediaFormat::File,
+        };
+
+        let file_name = file_content
+            .filename
+            .clone()
+            .unwrap_or(file_content.body.clone());
+
+        let mime_type = file_content
+            .info
+            .as_ref()
+            .and_then(|info| info.mimetype.clone())
+            .and_then(|mimetype| mimetype.parse::<mxlink::mime::Mime>().ok())
+            .unwrap_or_else(|| get_mime_type_from_file_name(&file_name));
+
+        tracing::debug!("Determined mime type {} for file {}", mime_type, file_name);
+
+        if mime_type == mxlink::mime::APPLICATION_OCTET_STREAM {
+            tracing::debug!(
+                "Skipping file {} with unsupported MIME type {}. It will be represented as a text message.",
+                file_name,
+                mime_type,
+            );
+
+            return Ok(Some(MatrixMessage {
+                sender_id: matrix_native_event.sender().to_owned(),
+                content: MatrixMessageContent::Text(format!(
+                    "[A file ({}) was attached but skipped because its content type ({}) is not supported. Let the user know.]",
+                    file_name, mime_type,
+                )),
+                mentioned_users,
+                timestamp,
+            }));
+        }
+
+        let span = tracing::debug_span!("get_media_content", file_name = %file_name, mime_type = %mime_type);
+
+        let media_bytes = matrix_link
+            .client()
+            .media()
+            .get_media_content(&media_request, true)
+            .instrument(span)
+            .await?;
+
+        tracing::debug!(
+            "Downloaded {} bytes for file {}",
+            media_bytes.len(),
+            file_name
+        );
+
+        return Ok(Some(MatrixMessage {
+            sender_id: matrix_native_event.sender().to_owned(),
+            content: MatrixMessageContent::File(file_content.clone(), mime_type, media_bytes),
+            mentioned_users,
+            timestamp,
+        }));
+    }
+
     Ok(Some(MatrixMessage {
         sender_id: matrix_native_event.sender().to_owned(),
         content: if is_notice {
@@ -358,11 +420,11 @@ pub async fn determine_interaction_context_for_room_event(
             )
             .await
         }
-        Relation::Reply { in_reply_to } => {
+        Relation::Reply(reply) => {
             determine_interaction_context_for_room_event_related_to_reply(
                 current_event,
                 current_event_is_mentioning_bot,
-                in_reply_to.event_id.clone(),
+                reply.in_reply_to.event_id.clone(),
             )
             .await
         }

src/entity/cfg/config.rs

@@ -1,6 +1,7 @@
 use std::path::PathBuf;
 
 use mxlink::helpers::encryption::EncryptionKey;
+use mxlink::matrix_sdk::ruma::{OwnedDeviceId, OwnedUserId};
 use serde::{Deserialize, Deserializer, Serialize};
 
 use crate::{
@@ -38,7 +39,7 @@ pub struct Config {
 impl Config {
     pub fn validate(&self) -> anyhow::Result<()> {
         self.homeserver.validate()?;
-        self.user.validate()?;
+        self.user.validate(&self.homeserver.server_name)?;
         self.persistence.validate()?;
         self.room.validate()?;
         self.access.validate()?;
@@ -57,6 +58,19 @@ impl Config {
     }
 }
 
+#[derive(Debug)]
+pub enum ConfigUserAuth {
+    UserPassword {
+        username: String,
+        password: String,
+    },
+    AccessToken {
+        user_id: OwnedUserId,
+        device_id: OwnedDeviceId,
+        access_token: String,
+    },
+}
+
 #[derive(Debug, Serialize, Deserialize)]
 pub struct ConfigHomeserver {
     pub server_name: String,
@@ -88,9 +102,10 @@ impl ConfigHomeserver {
 /// - `Default`: Use the built-in default avatar (null, empty string, or missing in config)
 /// - `Keep`: Don't touch the avatar, keep whatever is already set ("keep" in config)
 /// - `Custom(String)`: Use a custom avatar from the specified file path
-#[derive(Debug, Clone, PartialEq, Serialize)]
+#[derive(Debug, Clone, Default, PartialEq, Serialize)]
 pub enum Avatar {
     /// Use the built-in default avatar
+    #[default]
     Default,
     /// Keep the current avatar, don't change it
     Keep,
@@ -98,12 +113,6 @@ pub enum Avatar {
     Custom(String),
 }
 
-impl Default for Avatar {
-    fn default() -> Self {
-        Avatar::Default
-    }
-}
-
 impl<'de> Deserialize<'de> for Avatar {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
@@ -132,7 +141,15 @@ impl Avatar {
 #[derive(Debug, Serialize, Deserialize)]
 pub struct ConfigUser {
     pub mxid_localpart: String,
-    pub password: String,
+
+    #[serde(default)]
+    pub password: Option<String>,
+
+    #[serde(default)]
+    pub access_token: Option<String>,
+
+    #[serde(default)]
+    pub device_id: Option<String>,
 
     #[serde(default = "super::defaults::name")]
     pub name: String,
@@ -145,7 +162,7 @@ pub struct ConfigUser {
 }
 
 impl ConfigUser {
-    pub fn validate(&self) -> anyhow::Result<()> {
+    pub fn validate(&self, homeserver_server_name: &str) -> anyhow::Result<()> {
         if self.mxid_localpart.is_empty() {
             return Err(anyhow::anyhow!(
                 "The user.mxid_localpart ({}) configuration must be set",
@@ -153,12 +170,7 @@ impl ConfigUser {
             ));
         }
 
-        if self.password.is_empty() {
-            return Err(anyhow::anyhow!(
-                "The user.password ({}) configuration must be set",
-                super::env::BAIBOT_USER_PASSWORD
-            ));
-        }
+        self.auth_config(homeserver_server_name)?;
 
         if self.name.is_empty() {
             return Err(anyhow::anyhow!(
@@ -171,6 +183,57 @@ impl ConfigUser {
 
         Ok(())
     }
+
+    pub fn auth_config(&self, homeserver_server_name: &str) -> anyhow::Result<ConfigUserAuth> {
+        let password = self.password.as_deref().filter(|value| !value.is_empty());
+        let access_token = self
+            .access_token
+            .as_deref()
+            .filter(|value| !value.is_empty());
+
+        match (password, access_token) {
+            (Some(_), Some(_)) => Err(anyhow::anyhow!(
+                "Set exactly one authentication method: either user.password ({}) OR user.access_token ({}) + user.device_id ({})",
+                super::env::BAIBOT_USER_PASSWORD,
+                super::env::BAIBOT_USER_ACCESS_TOKEN,
+                super::env::BAIBOT_USER_DEVICE_ID
+            )),
+            (None, None) => Err(anyhow::anyhow!(
+                "Set one authentication method: either user.password ({}) OR user.access_token ({}) + user.device_id ({})",
+                super::env::BAIBOT_USER_PASSWORD,
+                super::env::BAIBOT_USER_ACCESS_TOKEN,
+                super::env::BAIBOT_USER_DEVICE_ID
+            )),
+            (Some(password), None) => Ok(ConfigUserAuth::UserPassword {
+                username: self.mxid_localpart.to_owned(),
+                password: password.to_owned(),
+            }),
+            (None, Some(access_token)) => {
+                let device_id = self
+                    .device_id
+                    .as_deref()
+                    .filter(|value| !value.is_empty())
+                    .ok_or_else(|| {
+                        anyhow::anyhow!(
+                            "user.device_id ({}) must be set when using access token authentication",
+                            super::env::BAIBOT_USER_DEVICE_ID
+                        )
+                    })?;
+
+                let user_id = OwnedUserId::try_from(format!(
+                    "@{}:{}",
+                    self.mxid_localpart, homeserver_server_name
+                ))
+                .map_err(|e| anyhow::anyhow!("Invalid user ID: {e}"))?;
+
+                Ok(ConfigUserAuth::AccessToken {
+                    user_id,
+                    device_id: OwnedDeviceId::from(device_id),
+                    access_token: access_token.to_owned(),
+                })
+            }
+        }
+    }
 }
 
 #[derive(Debug, Default, Serialize, Deserialize)]
@@ -181,13 +244,13 @@ pub struct ConfigUserEncryption {
 
 impl ConfigUserEncryption {
     pub fn validate(&self) -> anyhow::Result<()> {
-        if let Some(passphrase) = &self.recovery_passphrase {
-            if passphrase.is_empty() {
-                return Err(anyhow::anyhow!(
-                    "The user.encryption.recovery_passphrase ({}) configuration must either be null or set to a non-empty passphrase",
-                    super::env::BAIBOT_USER_ENCRYPTION_RECOVERY_PASSPHRASE
-                ));
-            }
+        if let Some(passphrase) = &self.recovery_passphrase
+            && passphrase.is_empty()
+        {
+            return Err(anyhow::anyhow!(
+                "The user.encryption.recovery_passphrase ({}) configuration must either be null or set to a non-empty passphrase",
+                super::env::BAIBOT_USER_ENCRYPTION_RECOVERY_PASSPHRASE
+            ));
         }
 
         Ok(())
@@ -473,3 +536,7 @@ impl TryInto<GlobalConfig> for ConfigInitialGlobalConfig {
         Ok(entity)
     }
 }
+
+#[cfg(test)]
+#[path = "config_tests.rs"]
+mod config_tests;

src/entity/cfg/config_tests.rs

@@ -0,0 +1,117 @@
+use super::{Avatar, ConfigUser, ConfigUserAuth, ConfigUserEncryption};
+use crate::entity::cfg::env;
+
+fn base_user() -> ConfigUser {
+    ConfigUser {
+        mxid_localpart: "baibot".to_owned(),
+        password: None,
+        access_token: None,
+        device_id: None,
+        name: "baibot".to_owned(),
+        encryption: ConfigUserEncryption {
+            recovery_passphrase: None,
+            recovery_reset_allowed: false,
+        },
+        avatar: Avatar::Default,
+    }
+}
+
+#[test]
+fn auth_config_uses_password_mode() {
+    let mut user = base_user();
+    user.password = Some("secret".to_owned());
+
+    let auth = user
+        .auth_config("example.com")
+        .expect("password auth should be valid");
+
+    match auth {
+        ConfigUserAuth::UserPassword { username, password } => {
+            assert_eq!(username, "baibot");
+            assert_eq!(password, "secret");
+        }
+        ConfigUserAuth::AccessToken { .. } => {
+            panic!("expected password auth mode");
+        }
+    }
+}
+
+#[test]
+fn auth_config_uses_access_token_mode() {
+    let mut user = base_user();
+    user.access_token = Some("token123".to_owned());
+    user.device_id = Some("DEVICE1".to_owned());
+
+    let auth = user
+        .auth_config("example.com")
+        .expect("access token auth should be valid");
+
+    match auth {
+        ConfigUserAuth::AccessToken {
+            user_id,
+            device_id,
+            access_token,
+        } => {
+            assert_eq!(user_id.as_str(), "@baibot:example.com");
+            assert_eq!(device_id.as_str(), "DEVICE1");
+            assert_eq!(access_token, "token123");
+        }
+        ConfigUserAuth::UserPassword { .. } => {
+            panic!("expected access token auth mode");
+        }
+    }
+}
+
+#[test]
+fn auth_config_rejects_both_auth_methods() {
+    let mut user = base_user();
+    user.password = Some("secret".to_owned());
+    user.access_token = Some("token123".to_owned());
+    user.device_id = Some("DEVICE1".to_owned());
+
+    let err = user
+        .auth_config("example.com")
+        .expect_err("both auth methods should be rejected");
+
+    assert!(
+        err.to_string()
+            .contains("exactly one authentication method")
+    );
+}
+
+#[test]
+fn auth_config_rejects_missing_auth() {
+    let user = base_user();
+
+    let err = user
+        .auth_config("example.com")
+        .expect_err("missing auth should be rejected");
+
+    assert!(err.to_string().contains("Set one authentication method"));
+}
+
+#[test]
+fn auth_config_rejects_access_token_without_device_id() {
+    let mut user = base_user();
+    user.access_token = Some("token123".to_owned());
+
+    let err = user
+        .auth_config("example.com")
+        .expect_err("access token mode without device_id should be rejected");
+
+    assert!(err.to_string().contains(env::BAIBOT_USER_DEVICE_ID));
+}
+
+#[test]
+fn auth_config_treats_empty_strings_as_unset() {
+    let mut user = base_user();
+    user.password = Some(String::new());
+    user.access_token = Some(String::new());
+    user.device_id = Some(String::new());
+
+    let err = user
+        .auth_config("example.com")
+        .expect_err("empty auth values should be treated as unset");
+
+    assert!(err.to_string().contains("Set one authentication method"));
+}

src/entity/cfg/env.rs

@@ -5,6 +5,8 @@ pub const BAIBOT_HOMESERVER_URL: &str = "BAIBOT_HOMESERVER_URL";
 
 pub const BAIBOT_USER_MXID_LOCALPART: &str = "BAIBOT_USER_MXID_LOCALPART";
 pub const BAIBOT_USER_PASSWORD: &str = "BAIBOT_USER_PASSWORD";
+pub const BAIBOT_USER_ACCESS_TOKEN: &str = "BAIBOT_USER_ACCESS_TOKEN";
+pub const BAIBOT_USER_DEVICE_ID: &str = "BAIBOT_USER_DEVICE_ID";
 pub const BAIBOT_USER_NAME: &str = "BAIBOT_USER_NAME";
 pub const BAIBOT_USER_AVATAR: &str = "BAIBOT_USER_AVATAR";
 pub const BAIBOT_USER_ENCRYPTION_RECOVERY_PASSPHRASE: &str =

src/entity/cfg/mod.rs

@@ -2,4 +2,4 @@ mod config;
 pub mod defaults;
 pub mod env;
 
-pub use config::{Avatar, Config};
+pub use config::{Avatar, Config, ConfigUserAuth};

src/entity/message_payload.rs

@@ -1,5 +1,6 @@
 use mxlink::matrix_sdk::ruma::events::room::message::{
-    AudioMessageEventContent, ImageMessageEventContent, MessageType, TextMessageEventContent,
+    AudioMessageEventContent, FileMessageEventContent, ImageMessageEventContent, MessageType,
+    TextMessageEventContent,
 };
 use mxlink::matrix_sdk::ruma::{OwnedEventId, OwnedUserId};
 
@@ -30,6 +31,7 @@ pub enum MessagePayload {
     Text(TextMessageEventContent),
     Audio(AudioMessageEventContent),
     Image(ImageMessageEventContent),
+    File(FileMessageEventContent),
 
     Reaction {
         key: String,
@@ -57,6 +59,7 @@ impl TryInto<MessagePayload> for MessageType {
                 MessagePayload::Audio(audio_content)
             }
             MessageType::Image(image_content) => MessagePayload::Image(image_content),
+            MessageType::File(file_content) => MessagePayload::File(file_content),
             other => {
                 return Err(format!("Unsupported message type: {:?}", other));
             }

src/entity/room_config_context.rs

@@ -5,8 +5,9 @@ use super::roomconfig::RoomConfig;
 
 use crate::entity::roomconfig::{
     SpeechToTextFlowType, SpeechToTextMessageTypeForNonThreadedOnlyTranscribedMessages,
-    TextGenerationAutoUsage, TextGenerationPrefixRequirementType, TextToSpeechBotMessagesFlowType,
-    TextToSpeechUserMessagesFlowType, defaults as roomconfig_defaults,
+    TextGenerationAutoUsage, TextGenerationPrefixRequirementType, TextGenerationSenderContextMode,
+    TextToSpeechBotMessagesFlowType, TextToSpeechUserMessagesFlowType,
+    defaults as roomconfig_defaults,
 };
 
 #[derive(Debug)]
@@ -135,6 +136,20 @@ impl RoomConfigContext {
             .unwrap_or(false)
     }
 
+    pub fn text_generation_sender_context_mode(&self) -> TextGenerationSenderContextMode {
+        self.room_config
+            .settings
+            .text_generation
+            .sender_context_mode
+            .or({
+                self.global_config
+                    .fallback_room_settings
+                    .text_generation
+                    .sender_context_mode
+            })
+            .unwrap_or(roomconfig_defaults::TEXT_GENERATION_SENDER_CONTEXT_MODE)
+    }
+
     pub fn text_generation_prefix_requirement_type(&self) -> TextGenerationPrefixRequirementType {
         self.room_config
             .settings

src/entity/roomconfig/defaults.rs

@@ -1,5 +1,7 @@
 use super::{SpeechToTextFlowType, SpeechToTextMessageTypeForNonThreadedOnlyTranscribedMessages};
-use super::{TextGenerationAutoUsage, TextGenerationPrefixRequirementType};
+use super::{
+    TextGenerationAutoUsage, TextGenerationPrefixRequirementType, TextGenerationSenderContextMode,
+};
 use super::{TextToSpeechBotMessagesFlowType, TextToSpeechUserMessagesFlowType};
 
 pub const TEXT_GENERATION_PREFIX_REQUIREMENT_TYPE: TextGenerationPrefixRequirementType =
@@ -7,6 +9,9 @@ pub const TEXT_GENERATION_PREFIX_REQUIREMENT_TYPE: TextGenerationPrefixRequireme
 
 pub const TEXT_GENERATION_AUTO_USAGE: TextGenerationAutoUsage = TextGenerationAutoUsage::Always;
 
+pub const TEXT_GENERATION_SENDER_CONTEXT_MODE: TextGenerationSenderContextMode =
+    TextGenerationSenderContextMode::Disabled;
+
 pub const TEXT_TO_SPEECH_BOT_MESSAGES_FLOW_TYPE: TextToSpeechBotMessagesFlowType =
     TextToSpeechBotMessagesFlowType::OnDemandForVoice;
 

src/entity/roomconfig/entity/mod.rs

@@ -16,7 +16,9 @@ pub use handler::RoomSettingsHandler;
 pub use speech_to_text::{
     SpeechToTextFlowType, SpeechToTextMessageTypeForNonThreadedOnlyTranscribedMessages,
 };
-pub use text_generation::{TextGenerationAutoUsage, TextGenerationPrefixRequirementType};
+pub use text_generation::{
+    TextGenerationAutoUsage, TextGenerationPrefixRequirementType, TextGenerationSenderContextMode,
+};
 pub use text_to_speech::{TextToSpeechBotMessagesFlowType, TextToSpeechUserMessagesFlowType};
 
 #[derive(Clone, Debug, Deserialize, Serialize, EventContent)]

src/entity/roomconfig/entity/text_generation.rs

@@ -14,6 +14,9 @@ pub struct RoomSettingsTextGeneration {
     /// When enabled, the bot will automatically tokenize messages and try to shorten the message context intelligently.
     pub context_management_enabled: Option<bool>,
 
+    /// Controls how each message in the conversation context is annotated with sender metadata.
+    pub sender_context_mode: Option<TextGenerationSenderContextMode>,
+
     /// Allows customizing the system prompt that the agent would use
     pub prompt_override: Option<String>,
 
@@ -111,3 +114,46 @@ impl std::fmt::Display for TextGenerationAutoUsage {
         }
     }
 }
+
+#[derive(Clone, Copy, Debug, Deserialize, Serialize, PartialEq)]
+pub enum TextGenerationSenderContextMode {
+    #[serde(rename = "disabled")]
+    Disabled,
+
+    #[serde(rename = "matrix_user_id")]
+    MatrixUserId,
+
+    #[serde(rename = "matrix_user_id_and_timestamp")]
+    MatrixUserIdAndTimestamp,
+}
+
+impl TextGenerationSenderContextMode {
+    pub fn choices() -> Vec<Self> {
+        vec![
+            Self::Disabled,
+            Self::MatrixUserId,
+            Self::MatrixUserIdAndTimestamp,
+        ]
+    }
+
+    pub fn from_str(s: &str) -> Option<Self> {
+        match s {
+            "disabled" => Some(Self::Disabled),
+            "matrix_user_id" => Some(Self::MatrixUserId),
+            "matrix_user_id_and_timestamp" => Some(Self::MatrixUserIdAndTimestamp),
+            _ => None,
+        }
+    }
+}
+
+impl std::fmt::Display for TextGenerationSenderContextMode {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            TextGenerationSenderContextMode::Disabled => write!(f, "disabled"),
+            TextGenerationSenderContextMode::MatrixUserId => write!(f, "matrix_user_id"),
+            TextGenerationSenderContextMode::MatrixUserIdAndTimestamp => {
+                write!(f, "matrix_user_id_and_timestamp")
+            }
+        }
+    }
+}

src/entity/roomconfig/mod.rs

@@ -6,8 +6,8 @@ use mxlink::helpers::account_data_config::RoomConfigManager as AccountDataRoomCo
 pub use entity::{RoomConfig, RoomConfigCarrierContent, RoomSettings, RoomSettingsHandler};
 pub use entity::{
     SpeechToTextFlowType, SpeechToTextMessageTypeForNonThreadedOnlyTranscribedMessages,
-    TextGenerationAutoUsage, TextGenerationPrefixRequirementType, TextToSpeechBotMessagesFlowType,
-    TextToSpeechUserMessagesFlowType,
+    TextGenerationAutoUsage, TextGenerationPrefixRequirementType, TextGenerationSenderContextMode,
+    TextToSpeechBotMessagesFlowType, TextToSpeechUserMessagesFlowType,
 };
 
 pub type RoomConfigurationManager =

src/lib.rs

@@ -1,3 +1,9 @@
+// rustc 1.94+ trips a query-depth overflow when computing async layouts in
+// the matrix-sdk timeline future graph. matrix-rust-sdk PR #6489 raises the
+// limit, but `recursion_limit` is per-crate and applies to the crate currently
+// being compiled — so the consumer has to repeat it.
+#![recursion_limit = "256"]
+
 mod agent;
 mod bot;
 mod controller;

src/strings/cfg.rs

@@ -249,6 +249,13 @@ pub fn status_text_generation_entry_context_management(value: bool, set_where: &
     format!("- ♻️ Context management: `{}` ({})\n", value, set_where)
 }
 
+pub fn status_text_generation_entry_sender_context(
+    value: impl std::fmt::Display,
+    set_where: &str,
+) -> String {
+    format!("- 👤 Sender context mode: `{}` ({})\n", value, set_where)
+}
+
 pub fn status_text_generation_entry_prompt(value: &str, set_where: &str) -> String {
     let value = value.trim();
 

src/strings/help/cfg.rs

@@ -132,6 +132,18 @@ pub fn text_generation_context_management_intro() -> String {
     )
 }
 
+pub fn text_generation_sender_context_heading() -> &'static str {
+    "👤 Sender Context Mode"
+}
+
+pub fn text_generation_sender_context_intro() -> String {
+    format!(
+        "{}\n{}",
+        "Controls whether the bot attaches sender information to conversation messages before sending them to the model.",
+        "`disabled` leaves messages unchanged, `matrix_user_id` adds `[sender=@alice:example.com]`, and `matrix_user_id_and_timestamp` adds `[sender=@alice:example.com sent_at=2026-03-23T14:30:00Z]`. Enabling this sends Matrix user IDs, and optionally timestamps, to the model provider.",
+    )
+}
+
 pub fn text_generation_prompt_override_heading() -> &'static str {
     "⌨️ Prompt Override"
 }

src/utils/mime.rs

@@ -17,18 +17,7 @@ pub fn get_file_extension(mime_type: &mime::Mime) -> String {
 }
 
 pub fn get_mime_type_from_file_name(file_name: &str) -> mime::Mime {
-    let extension = file_name.rsplit('.').next().unwrap_or("");
-
-    match extension.to_lowercase().as_str() {
-        "jpg" | "jpeg" => mime::IMAGE_JPEG,
-        "png" => mime::IMAGE_PNG,
-        "gif" => mime::IMAGE_GIF,
-        "webp" => "image/webp".parse().unwrap(),
-        "svg" => mime::IMAGE_SVG,
-        "tiff" | "tif" => "image/tiff".parse().unwrap(),
-        "bmp" => "image/bmp".parse().unwrap(),
-        "heic" | "heif" => "image/heic".parse().unwrap(),
-        "avif" => "image/avif".parse().unwrap(),
-        _ => mime::APPLICATION_OCTET_STREAM,
-    }
+    mime_guess::from_path(file_name)
+        .first()
+        .unwrap_or(mime::APPLICATION_OCTET_STREAM)
 }