feat: OpenRouter image generation

.github/workflows/server.yaml

@@ -5,14 +5,15 @@ on:
     tags-ignore: ["v*"]
     paths:
       - "server/**"
+      - "server-new/**"
       - "web/**"
       - Dockerfile
   pull_request:
     types: [opened, synchronize, reopened]
 env:
   REGISTRY: ghcr.io
   IMAGE_NAME: ${{ github.repository }}
-  RUST_VERSION: "1.90"
+  RUST_VERSION: "1.96"
   NODE_VERSION: 22
 
 jobs:
@@ -23,14 +24,14 @@ jobs:
       run:
         working-directory: ./web
     steps:
-      - uses: actions/checkout@v4
-      - uses: pnpm/action-setup@v4
+      - uses: actions/checkout@v6
+      - uses: pnpm/action-setup@v6
         name: Install pnpm
         with:
           package_json_file: web/package.json
           run_install: false
       - name: Install Node.js
-        uses: actions/setup-node@v4
+        uses: actions/setup-node@v6
         with:
           node-version: ${{ env.NODE_VERSION }}
           cache: "pnpm"
@@ -46,35 +47,25 @@ jobs:
         run: pnpm build
 
   build-server:
-    strategy:
-      matrix:
-        os: [ubuntu-latest, macos-latest]
-    name: Build server on ${{ matrix.os }}
-    runs-on: ${{ matrix.os }}
+    name: Build server
+    runs-on: ubuntu-latest
     defaults:
       run:
-        working-directory: ./server
+        working-directory: ./server-new
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
       - name: Install Rust toolchain
         run: rustup toolchain install ${{ env.RUST_VERSION }} --profile minimal --no-self-update && rustup default ${{ env.RUST_VERSION }}
-      - name: Setup build dependencies on macOS
-        if: startsWith(runner.os, 'macOS')
-        run: brew link --force libpq
       - name: Setup rust-cache
         uses: Swatinem/rust-cache@v2
         with:
-          workspaces: ./server
-      # - name: Install nextest
-      #   uses: taiki-e/install-action@v2
-      #   with:
-      #     tool: nextest@0.9
+          workspaces: ./server-new
 
       - name: Run cargo check
-        run: cargo check --profile ci
+        run: cargo check
 
       - name: Run cargo build
-        run: PQ_LIB_DIR="$(brew --prefix libpq)/lib" cargo build --profile ci
+        run: cargo build
 
       # - name: Test crate
       #   run: cargo nextest run --all-features --profile ci

.gitignore

@@ -35,6 +35,7 @@ Desktop.ini
 *.pfx
 secrets.json
 config/secrets.yml
+.docker/
 .secrets/
 
 # Dependency Directories

ARCHITECTURE.md

@@ -29,14 +29,10 @@ RsChat uses a hybrid streaming architecture that provides both real-time perform
 
 ### Key Components
 
-#### 1. LlmStreamWriter (`server/src/stream/llm_writer.rs`)
+#### 1. LlmClientStreamer (`server/src/stream/streamer.rs`)
 
 The core component that processes LLM provider streams and manages Redis stream output.
 
-**Key Features:**
-- **Batching**: Accumulates chunks from the provider stream, up to a max length or timeout, and adds them to the Redis stream
-- **Background Pings**: Sends regular keepalive pings
-
 #### 2. Redis and SSE Stream Structure
 
 **Redis Key for Chat Streams**: `user:{user_id}:chat:{session_id}`
@@ -68,32 +64,29 @@ Stream End → Database Save → Redis DEL
 
 #### Cross-Instance Support
 - Redis streams provide shared state across server instances
-- Background ping tasks maintain stream liveness
-- Stream cancellation detected via Redis XADD failures
+- Stream cancellation detection
 
 ## Data Flow
 
 ### 1. New Chat Request
 ```
 Client → POST /api/chat/{session_id}
        → Send request to LLM Provider
-       → LLM response received, streamed to Redis with the `LlmStreamWriter`
-       → GET /api/chat/{session_id}/stream to connect to the stream and stream the response
+       → LLM response received, streamed to Redis with the `LlmClientStreamer`
 ```
 
 ### 2. Stream Processing
 ```
 LLM Chunk → Process text, tool calls, usage, and error chunks
           → Batching Logic
-          → Redis XADD (if conditions met)
-          → Client(s) receive the new chunks
+          → Add chunks to Redis via `tinistream` service
+          → Client(s) receive the new chunks from `tinistream`
 ```
 
 ### 3. Stream Completion
 ```
 LLM End → Final Database Save
-        → Redis Stream End Event
-        → Redis Stream Cleanup
+        → `tinistream` End Event
         → SSE Connection Close
 ```
 

README.md

@@ -1,6 +1,6 @@
 # RsChat 🤖💬
 
-A fast, secure, self-hostable chat application built with Rust, TypeScript, and React. Chat with multiple AI providers using your own API keys, with real-time streaming built-in.
+A lightweight, secure, open-source, self-hostable chat application built with Rust, TypeScript, and React. Stream chats with multiple AI providers using your own API keys.
 
 Demo link: https://rs-chat.fly.dev/ (⚠️ This is a demo - don't expect your account/chats to be there when you come back. It may intermittently delete all data. Please also don't enter any sensitive information or confidential data)
 
@@ -11,21 +11,20 @@ Demo link: https://rs-chat.fly.dev/ (⚠️ This is a demo - don't expect your a
 - **Multiple AI Providers**: Chat with AI models from OpenAI, Anthropic, and OpenRouter
 - **Streaming**: Streams responses using SSE (Server-Sent Events)
 - **Concurrent Streaming**: Seamlessly switch between multiple AI conversations streamed at the same time
-- **Resumable Conversations**: Resume the conversation if your connection is lost or the page is refreshed
+- **Resilient Streams**: Streaming continues if your connection is lost or the page is refreshed
 - **Code Highlighting**: Beautiful syntax highlighting for code blocks using [`rehype-highlight`](https://github.com/rehypejs/rehype-highlight)
 - **Dark Mode**: Dark/light theme support
 - **Responsive Design**: Mobile-friendly layout
 - **Search Chats**: Full-text search of chat session titles and messages
 - **Fast and Memory Efficient**: Rust backend using the [Rocket framework](https://rocket.rs/)
 - **Users & Authentication**: Login via OAuth providers (Google, GitHub, etc.), custom OIDC, and SSO header authentication
-- **API Key Access and OpenAPI Docs**: API key access and documentation at `/api/docs` for developers to integrate with RsChat
+- **Documented API**: API key access and documentation at `/api/docs` for developers to integrate with RsChat
 - **Fully Type-Safe**: End-to-end type safety with auto-generated client from OpenAPI spec
 
 ### ⚡ Convenience Features
 
 - **Smart Titles**: Auto-generation of chat titles
-- **Smart Scrolling**: Auto-scroll during streaming and when opening previous chats
-- **Secure Key Storage**: Your API keys are saved and encrypted
+- **Auto Scrolling**: Auto-scroll during streaming and when opening previous chats
 
 ## 🏗️ Architecture
 
@@ -45,14 +44,17 @@ rs-chat/
 │   │   ├── auth/          # Authentication services
 │   │   ├── db/            # Database models and services
 │   │   ├── provider/      # AI provider integrations
-│   │   ├── utils/         # Utility functions
-│   │   ├── config.rs      # Reading configuration / env variables
+│   │   ├── storage/       # File storage services
+│   │   ├── stream/        # Streaming utilities
+│   │   ├── tools/         # AI chat tools
+│   │   ├── utils/         # Other utilities
+│   │   ├── config.rs      # Configuration / environment variables
 │   │   ├── lib.rs         # Server setup
 │   │   ├── main.rs        # Server entry point
 │   │   └── ...            # Other modules
 │   ├── migrations/         # Database migrations
 │   └── Cargo.toml          # Rust dependencies
-├── web/                    # Vite / React frontend
+├── web/                    # Vite / React / TanStack Router frontend
 │   ├── src/
 │   │   ├── components/   # React components
 │   │   ├── routes/       # TanStack Router routes
@@ -90,9 +92,9 @@ Your API keys are encrypted and stored in the database.
    cd rs-chat
    ```
 
-2. **Start development databases**
+2. **Start development services**
    ```bash
-   docker compose up -d db redis
+   docker compose up -d db redis stream
    ```
 
 3. **Set up the backend**
@@ -145,33 +147,47 @@ You'll need an environment with PostgreSQL and Redis (or Redis-compatible databa
 services:
   rschat:
     image: ghcr.io/fa-sharp/rs-chat:latest
-    # ports:
-    #   - "8080:8080"
+    ports:
+      - "8080:8080"
     environment:
       RUST_LOG: warn   # 'info' or 'debug' for more logs
       RS_CHAT_SERVER_ADDRESS: https://mydomain.com # where you're hosting the app
       RS_CHAT_DATABASE_URL: postgres://user:pass@mypostgres/mydb # Your PostgreSQL URL
       RS_CHAT_REDIS_URL: redis://myredis:6379 # Your Redis URL
       RS_CHAT_SECRET_KEY: your-secret-key-for-encryption # 64-character hex string
+      RS_CHAT_TINISTREAM_URL: http://tinistream:8081
+      RS_CHAT_TINISTREAM_API_KEY: tinistream-api-key # API key for the tinistream service
+
       ## For GitHub login: callback URL should be {your_server_address}/api/auth/login/github/callback
       # RS_CHAT_GITHUB_CLIENT_ID: your-github-client-id
       # RS_CHAT_GITHUB_CLIENT_SECRET: your-github-client-secret
       ## Similar config for other OAuth providers - see server/src/auth/oauth/ folder
       # RS_CHAT_DISCORD_CLIENT_ID: your-discord-client-id
       # ...
+
       ## For SSO header auth - see server/src/auth/sso_header.rs for all config options
       # RS_CHAT_SSO_HEADER_ENABLED: true
       # RS_CHAT_SSO_USERNAME_HEADER: X-Remote-User
       # ...
+
       ## For running code on a remote Docker host
       # DOCKER_HOST: tcp://remote-docker-host:port
       # DOCKER_TLS_VERIFY: 1
       # DOCKER_CERT_PATH: /certs
     volumes:
-      ## For running code on local Docker host
-      # - /var/run/docker.sock:/var/run/docker.sock:ro
-      ## Certificates for remote Docker host
-      # - ./path/to/certs:/certs
+      # - /var/run/docker.sock:/var/run/docker.sock:ro  # To run code on local Docker
+      # - ./path/to/certs:/certs  # Certificates for remote Docker host
+  tinistream:
+    image: ghcr.io/fa-sharp/tinistream:latest
+    container_name: tinistream
+    ports:
+      - "8081:8081"
+    environment:
+      STREAMER_PORT: 8081
+      STREAMER_SERVER_ADDRESS: http://localhost:8081
+      STREAMER_REDIS_URL: redis://myredis:6379 # Your Redis URL
+      STREAMER_API_KEY: tinistream-api-key # should match the RS_CHAT_TINISTREAM_API_KEY above
+      STREAMER_SECRET_KEY: your-secret-key-for-encryption # 64-character hex string
 ```
 
 ## 🔒 Security & Privacy

docker-compose.yml

@@ -12,48 +12,65 @@ services:
       - postgres_data:/var/lib/postgresql/data
 
   redis:
-    image: valkey/valkey:7-alpine
+    image: valkey/valkey:8-alpine
     container_name: redis
     ports:
       - "6379:6379"
     volumes:
       - redis_data:/data
 
   stream:
-    image: ghcr.io/fa-sharp/tinistream:0.1.9
-    platform: linux/amd64
+    image: tinistream
     container_name: tinistream
     ports:
       - "8081:8081"
     environment:
       STREAMER_PORT: 8081
-      STREAMER_SERVER_ADDRESS: http://localhost:8081
+      STREAMER_API_KEY: dev-streamer-api-key
+      STREAMER_BASE_URL: http://localhost:8081
       STREAMER_REDIS_URL: redis://redis:6379
-      STREAMER_TTL: 360
-    env_file: server/.env
+      STREAMER_KEY_PREFIX: "rs-chat:"
+    env_file: server-new/.env
     depends_on:
       - redis
 
-  rschat:
-    build:
-      context: .
-    ports:
-      - "8080:8080"
-    environment:
-      RUST_LOG: info
-      RS_CHAT_SERVER_ADDRESS: http://localhost:8080
-      RS_CHAT_DATABASE_URL: postgres://postgres:postgres@postgres/postgres
-      RS_CHAT_REDIS_URL: redis://redis:6379
-      RS_CHAT_DATA_DIR: /data
-      RS_CHAT_TINISTREAM_URL: http://tinistream:8081
-    env_file: server/.env
-    volumes:
-      - ./.docker:/certs
-      - rschat_data:/data
-    depends_on:
-      - db
-      - redis
-      - stream
+  # runner:
+  #   image: ghcr.io/fa-sharp/tinirun:0.1.1
+  #   container_name: tinirun
+  #   ports:
+  #     - "8082:8082"
+  #   environment:
+  #     RUNNER_HOST: 0.0.0.0
+  #     RUNNER_PORT: 8082
+  #     RUNNER_LOG_LEVEL: info
+  #     RUNNER_REDIS_URL: redis://redis:6379
+  #   env_file: server/.env
+  #   depends_on:
+  #     - redis
+  #   volumes:
+  #     - /var/run/docker.sock:/var/run/docker.sock
+
+  # rschat:
+  #   build:
+  #     context: .
+  #   ports:
+  #     - "8080:8080"
+  #   environment:
+  #     RUST_LOG: info
+  #     RS_CHAT_SERVER_ADDRESS: http://localhost:8080
+  #     RS_CHAT_DATABASE_URL: postgres://postgres:postgres@postgres/postgres
+  #     RS_CHAT_REDIS_URL: redis://redis:6379
+  #     RS_CHAT_DATA_DIR: /data
+  #     RS_CHAT_TINISTREAM_URL: http://tinistream:8081
+  #     RS_CHAT_TINIRUN_URL: http://tinirun:8082
+  #   env_file: server/.env
+  #   volumes:
+  #     - rschat_data:/data
+  #   depends_on:
+  #     - db
+  #     - redis
+  #     - stream
+  #     - runner
 
 volumes:
   postgres_data:

examples/compose/compose.yml

@@ -0,0 +1 @@
+# TODO

examples/compose/config.toml

@@ -0,0 +1,40 @@
+[server]
+host = "0.0.0.0"
+port = 8080
+base_url = "https://example.com"  # set to domain & path where you're hosting
+log_level = "info"
+request_id_header = "x-request-id"
+
+[database]
+url = "postgres://user:pass@mydb:5432"
+
+[redis]
+url = "redis://pass@myredis:6379"
+pool_size = 4
+timeout = 10
+
+[services]
+streamer_url = "http://tinistream:8081"
+streamer_api_key = "tinistream-api-key"
+
+[auth]
+cookie_name = "auth-rs-chat"
+session_length = 604800  # seconds
+
+# Configure GitHub / Discord / Google login
+[auth.github]
+client_id = ""
+client_secret = ""
+
+# Configure forward header authentication
+# ⚠️ Only use with a secure proxy like Authelia or Tinyauth
+[auth.proxy]
+enabled = false
+username_header = "Remote-User"
+name_header = "Remote-Name"
+groups_header = "Remote-Groups"
+
+# Configure various security settings
+[security]
+body_limit = 2097152  # bytes
+request_timeout = 120  # seconds