kipina-node: automaattinen Ollama-instanssien haku + konttituki

Skripti skannaa localhost, 127.0.0.1, ollama, host.docker.internal
ja tarjoaa valikon jos useampi löytyy. Ei vaadi enää paikallista
ollama-binääriä — toimii myös Docker-konttia tai remote-instanssia
vasten. OLLAMA_URL välitetään Rust-binäärille.

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

.gitignore

@@ -34,3 +34,9 @@ Cargo.lock
 *.pdb
 
 # End of https://www.toptal.com/developers/gitignore/api/rust,linux
+
+# Ajonaikaiset tietokannat
+*.db
+
+# Wanha versio
+temp/

network-poc/AGENTBUILDER.md

@@ -0,0 +1,215 @@
+# Kipinä Agent Builder — Suunnitelma
+
+Käyttäjä voi rakentaa omia agentteja "hahmolomakkeella": valitsee avatarin, roolin, kielimallin ja muokkaa prompteja. Agentit tallentuvat localStorageen ja ovat käytettävissä pipelineissa.
+
+## Nykytila
+
+```js
+// Kovakoodattu agentPrompts-objekti
+const agentPrompts = {
+    manager: { name: 'Manageri', model: 'qwen2.5-coder:7b', default: '...' },
+    coder:   { name: 'Koodari', model: 'qwen2.5-coder:7b', default: '...' },
+    tofuist: { name: 'Tofuist', model: 'qwen2.5-coder:7b', docs: '/docs/tofu-cheatsheet.md', default: '...' },
+    // ...
+};
+```
+
+**Ongelma:** Uuden agentin lisääminen vaatii koodimuutoksen index.html:ään.
+
+## Tavoite
+
+```
+┌─────────────────────────────────────────────────────┐
+│  Agent Builder -lomake                              │
+│                                                     │
+│  ┌─────────┐  Nimi: [Tofuist          ]             │
+│  │ 🦎      │  Rooli: [IaC / Infra    ▼]            │
+│  │ avatar  │  Malli: [qwen2.5-coder:7b ▼]          │
+│  └─────────┘  Docs:  [/docs/tofu-cheatsheet.md]    │
+│                                                     │
+│  System Prompt:                                     │
+│  ┌─────────────────────────────────────────────┐    │
+│  │ You are an OpenTofu/Terraform IaC specialist│    │
+│  │ ...                                         │    │
+│  └─────────────────────────────────────────────┘    │
+│                                                     │
+│  LLM-parametrit:                                    │
+│  Temperature: [0.7]  Top-k: [40]  Max tokens: [512]│
+│                                                     │
+│  [💾 Tallenna]  [🗑️ Poista]  [📤 Export JSON]       │
+└─────────────────────────────────────────────────────┘
+```
+
+## Building Blocks
+
+### 1. Agenttiskeema
+
+```js
+{
+    id: 'tofuist',                          // uniikki tunniste
+    name: 'Tofuist',                        // näyttönimi
+    avatar: '/avatars/gecko_notext.png',     // avatar-kuvan polku
+    role: 'iac',                             // rooli-template
+    model: 'qwen2.5-coder:7b',             // eksakti Ollama-mallinimi
+    color: '#e3a336',                        // teemaväri UI:ssa
+    docs: '/docs/tofu-cheatsheet.md',        // valinnainen referenssidokumentti
+    prompt: 'You are an OpenTofu...',        // system prompt
+    params: {                                // LLM-parametrit
+        temperature: 0.7,
+        top_k: 40,
+        max_tokens: 512,
+        repetition_penalty: 1.15
+    }
+}
+```
+
+### 2. Rooli-templatet (alasvetovalikko)
+
+Valmiit pohjat jotka tuovat oletuspromptit ja parametrit:
+
+| Rooli | Oletusprompt | Parametrit |
+|-------|-------------|------------|
+| Koodari | "Kirjoita selkeää, testattavaa koodia" | temp 0.7, max 512 |
+| QA / Testaus | "Kirjoita testejä, etsi virheitä" | temp 0.4, max 512 |
+| DevOps | "Dockerfile, Compose, CI/CD" | temp 0.5, max 512 |
+| DevSecOps | "Tietoturva-auditointi, OWASP" | temp 0.3, max 512 |
+| Arkkitehti | "Järjestelmäsuunnittelu, rajapinnat" | temp 0.6, max 512 |
+| IaC / Infra | "OpenTofu/Terraform HCL-koodi" | temp 0.5, max 512 |
+| Data | "Tietokannat, SQL, datamallit" | temp 0.5, max 512 |
+| Manageri | "Tehtävien jako ja koordinointi" | temp 0.8, max 200 |
+| Kirjoittaja | "Dokumentaatio, README, ohjeet" | temp 0.8, max 512 |
+| Vapaa | (tyhjä, käyttäjä kirjoittaa) | temp 0.7, max 512 |
+
+### 3. Malli-valitsin
+
+Lista saatavilla olevista malleista — haetaan dynaamisesti:
+
+```
+Hub-kysely: GET /api/models → palauttaa yhdistettyjen solmujen mallit
+
+Tai staattinen lista:
+- qwen2.5-coder:7b    (oletus, natiivi GPU)
+- qwen2.5-coder:1.5b  (kevyt)
+- qwen2.5-coder:0.5b  (selain Wasm)
+- deepseek-r1          (reasoning)
+- llama3.2:3b          (yleiskäyttö)
+```
+
+Pitkän aikavälin tavoite: hub ilmoittaa WebSocketin kautta mitkä mallit ovat saatavilla.
+
+### 4. Avatar-valitsin
+
+Valmiit avatarit + mahdollisuus ladata oma:
+
+| Hahmo | Tiedosto | Eläin |
+|-------|----------|-------|
+| Asiakas | kettu_notext.png | Kettu |
+| Manageri | karhunpentu.png | Karhunpentu |
+| Koodari | kipina_notext.png | Salamanteri |
+| Data | pesukarhu_notext.png | Pesukarhu |
+| QA | susi_notext.png | Pikkususi |
+| DevOps | laiskiainen_notext.png | Laiskiainen |
+| Tarkkailija | aikuinen_susi.png | Aikuinen susi |
+| Tofuist | gecko_notext.png | Gecko/Lisko |
+| Arkkitehti | ??? | (tulossa) |
+| DevSecOps | ??? | (tulossa) |
+
+### 5. Docs-kenttä (referenssidokumentti)
+
+Agentti voi viitata ulkoiseen dokumenttiin joka ladataan promptiin:
+
+```
+docs: '/docs/tofu-cheatsheet.md'  →  haetaan fetch():llä, cachetetaan _docsCache-kenttään
+```
+
+**Toiminta:**
+1. Ensimmäisellä `kpnRun`-kutsulla ladataan docs-URL
+2. Sisältö cachetetaan `agent._docsCache`-kenttään
+3. Liitetään promptiin: `"Reference:\n" + docsContent`
+4. Ei ladata uudelleen saman session aikana
+
+**Rajoitukset:**
+- Max ~3000 tokenia (~10 KB) — pidempi docs tiivistetään
+- Vain tekstitiedostot (.md, .txt)
+
+### 6. Tallennus (localStorage)
+
+```js
+// Tallennusavain
+'kpn-custom-agents' → JSON.stringify([ agentSkeema1, agentSkeema2, ... ])
+
+// Ladattaessa
+const customAgents = JSON.parse(localStorage.getItem('kpn-custom-agents') || '[]');
+const defaultAgents = { manager: {...}, coder: {...}, ... };
+const agentPrompts = { ...defaultAgents };
+for (const agent of customAgents) {
+    agentPrompts[agent.id] = agent;
+}
+```
+
+**Oletusagentit** (manager, coder, tester, qa, data) ovat aina mukana — niitä ei voi poistaa, mutta prompteja voi muokata.
+
+**Käyttäjäagentit** (tofuist, arkkitehti, devsecops, ...) tallentuvat localStorageen ja latautuvat käynnistyksessä.
+
+### 7. Export / Import
+
+```js
+// Export — JSON-tiedosto
+const blob = new Blob([JSON.stringify(agent, null, 2)], { type: 'application/json' });
+// → agent-tofuist.json
+
+// Import — tiedoston valinta tai drag & drop
+// Validoidaan skeema, lisätään agentPrompts-objektiin
+```
+
+Mahdollistaa agenttien jakamisen tiimin kesken.
+
+## Toteutusvaiheet
+
+### Vaihe 1: Hahmolomake UI
+- Avatar-grid valitsin
+- Rooli-template alasvetovalikko (täyttää oletuspromptit)
+- Malli-valitsin
+- System prompt -tekstikenttä
+- LLM-parametrit (temperature, top-k, max_tokens)
+- Tallenna/Poista-napit
+
+### Vaihe 2: Dynaaminen agenttirekisteri
+- `agentPrompts` ladataan localStoragesta
+- Oletusagentit + käyttäjän agentit yhdistetään
+- Avatar-kortit renderöidään dynaamisesti (ei HTML:ssä)
+- Värimapit generoidaan agenttiskeemasta
+
+### Vaihe 3: Pipeline käyttää dynaamisia agentteja
+- Pipeline-vaiheet viittaavat agentin id:hen (ei kovakoodattuun nimeen)
+- Käyttäjä voi valita mitkä agentit osallistuvat pipelineen
+- Tofuist voi korvata DevOpsin IaC-projekteissa
+
+### Vaihe 4: Mallirekisteri (hub-integraatio)
+- Hub tarjoaa `/api/models`-endpointin
+- Saatavilla olevat mallit näkyvät valitsimessa reaaliajassa
+- Solmun liittyessä/poistuessa mallit päivittyvät
+
+## Arkkitehtuurikaavio
+
+```
+┌──────────────────────────────────────────────────┐
+│  Agent Builder UI                                │
+│  ┌──────────┐ ┌──────────┐ ┌──────────────────┐  │
+│  │ Avatar   │ │ Rooli    │ │ Malli-valitsin   │  │
+│  │ Grid     │ │ Template │ │ (hub/staattinen) │  │
+│  └────┬─────┘ └────┬─────┘ └────────┬─────────┘  │
+│       └─────────────┼───────────────┘             │
+│                     ▼                             │
+│  ┌──────────────────────────────────────────────┐ │
+│  │  Agent Schema  { id, name, avatar, model,   │ │
+│  │                  role, color, docs, prompt,  │ │
+│  │                  params }                    │ │
+│  └──────────────────┬───────────────────────────┘ │
+│                     │                             │
+│       ┌─────────────┼─────────────┐               │
+│       ▼             ▼             ▼               │
+│  localStorage   Org Chart    Pipeline             │
+│  (persist)      (render)     (execute)            │
+└──────────────────────────────────────────────────┘
+```

network-poc/Dockerfile.native

@@ -0,0 +1,21 @@
+# Native-node: Rust + Ollama-client (ei GPU-tunnistusta)
+FROM rust:slim AS builder
+RUN apt-get update && apt-get install -y pkg-config libssl-dev && rm -rf /var/lib/apt/lists/*
+WORKDIR /app
+COPY Cargo.toml Cargo.lock* ./
+COPY native-node/Cargo.toml native-node/Cargo.toml
+COPY native-node/src native-node/src
+# Dummy-cratet workspace-yhteensopivuuteen
+COPY hub/Cargo.toml hub/Cargo.toml
+COPY node/Cargo.toml node/Cargo.toml
+COPY cli/Cargo.toml cli/Cargo.toml
+RUN mkdir -p hub/src node/src cli/src && touch hub/src/main.rs node/src/lib.rs cli/src/main.rs
+RUN --mount=type=cache,target=/usr/local/cargo/registry \
+    --mount=type=cache,target=/app/target \
+    cargo build --release -p native-node --no-default-features \
+    && cp /app/target/release/native-node /usr/local/bin/native-node
+
+FROM debian:bookworm-slim
+RUN apt-get update && apt-get install -y ca-certificates && rm -rf /var/lib/apt/lists/*
+COPY --from=builder /usr/local/bin/native-node /usr/local/bin/native-node
+CMD ["native-node"]

network-poc/Dockerfile.native-node

@@ -1,30 +1,36 @@
 FROM rust:slim AS builder
 
 RUN apt-get update && apt-get install -y \
-    pkg-config libssl-dev g++ \
+    pkg-config libssl-dev g++ libvulkan-dev \
     && rm -rf /var/lib/apt/lists/*
 
 WORKDIR /app
-COPY Cargo.toml Cargo.lock ./
+COPY Cargo.toml ./
+COPY Cargo.loc[k] ./
 COPY hub/Cargo.toml hub/Cargo.toml
 COPY node/Cargo.toml node/Cargo.toml
 COPY native-node/Cargo.toml native-node/Cargo.toml
+COPY cli/Cargo.toml cli/Cargo.toml
 
 # Tyhjät src-tiedostot riippuvuuksien esikääntämistä varten
-RUN mkdir -p hub/src node/src native-node/src \
+RUN mkdir -p hub/src node/src native-node/src cli/src \
     && echo "fn main(){}" > hub/src/main.rs \
     && echo "" > node/src/lib.rs \
     && echo "fn main(){}" > native-node/src/main.rs \
+    && echo "fn main(){}" > cli/src/main.rs \
     && cargo build --release -p native-node 2>/dev/null || true
 
 COPY native-node/src native-node/src
-RUN cargo build --release -p native-node
+# Touch pakottaa rekompilauksen dummy-binaryn yli
+RUN touch native-node/src/main.rs && cargo build --release -p native-node
 
 FROM debian:bookworm-slim
-RUN apt-get update && apt-get install -y ca-certificates && rm -rf /var/lib/apt/lists/*
+RUN apt-get update && apt-get install -y ca-certificates libvulkan1 && rm -rf /var/lib/apt/lists/*
 COPY --from=builder /app/target/release/native-node /usr/local/bin/native-node
 
-ENV HUB_URL=ws://hub:3000/ws
+ENV HUB_URL=ws://agentic-poc:3000/ws
+ENV OLLAMA_URL=http://ollama:11434
+ENV OLLAMA_MODEL=qwen2.5-coder:7b
 ENV ALLOCATED_GB=4
 
 CMD ["native-node"]

network-poc/Dockerfile.prod

@@ -1,47 +1,63 @@
 # syntax=docker/dockerfile:1
-FROM rust:slim AS builder
 
-RUN apt-get update && apt-get install -y \
+# --- Vaihe 1: Frontend (Astro) ---
-    curl pkg-config libssl-dev g++ \
+FROM node:22-slim AS frontend
-    && rm -rf /var/lib/apt/lists/*
+WORKDIR /app/frontend
+# Riippuvuudet ensin → cache-kerros (muuttuu harvoin)
+COPY frontend/package.json frontend/package-lock.json* ./
+RUN npm install --silent
+# Lähdekoodi → muuttuu usein, mutta npm install on cachessa
+COPY frontend/ .
+RUN npm run build
 
+# --- Vaihe 2: Wasm (wasm-pack) ---
+FROM rust:slim AS wasm-builder
+RUN apt-get update && apt-get install -y curl pkg-config libssl-dev g++ && rm -rf /var/lib/apt/lists/*
 RUN curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh
-
 WORKDIR /app
-
+COPY Cargo.toml Cargo.lock* ./
-# Kopioi kaikki Cargo-tiedostot
+COPY node/Cargo.toml node/Cargo.toml
-COPY Cargo.toml ./
+COPY node/src node/src
-COPY Cargo.lock* ./
+# Dummy-cratet jotta workspace Cargo.toml on tyytyväinen
 COPY hub/Cargo.toml hub/Cargo.toml
+COPY native-node/Cargo.toml native-node/Cargo.toml
+COPY cli/Cargo.toml cli/Cargo.toml
+RUN mkdir -p hub/src native-node/src cli/src && touch hub/src/main.rs native-node/src/main.rs cli/src/main.rs
+RUN --mount=type=cache,target=/usr/local/cargo/registry \
+    --mount=type=cache,target=/app/target \
+    cd node && wasm-pack build --target web --out-dir /app/wasm-pkg
+
+# --- Vaihe 3: Hub (Rust) ---
+FROM rust:slim AS hub-builder
+RUN apt-get update && apt-get install -y pkg-config libssl-dev && rm -rf /var/lib/apt/lists/*
+WORKDIR /app
+COPY Cargo.toml Cargo.lock* ./
+COPY hub/Cargo.toml hub/Cargo.toml
+COPY hub/src hub/src
+# Tarvitaan dummy-cratet jotta workspace kompiloi
 COPY node/Cargo.toml node/Cargo.toml
 COPY native-node/Cargo.toml native-node/Cargo.toml
 COPY cli/Cargo.toml cli/Cargo.toml
-
+RUN mkdir -p node/src native-node/src cli/src && touch node/src/lib.rs native-node/src/main.rs cli/src/main.rs
-# Kopioi lähdekoodi
-COPY hub/src hub/src
-COPY node/src node/src
-COPY native-node/src native-node/src
-COPY cli/src cli/src
-COPY static static
-
-# Rakenna Wasm — cache mount pitää Cargo-rekisterin ja target-kansion buildien välillä
-RUN --mount=type=cache,target=/usr/local/cargo/registry \
-    --mount=type=cache,target=/app/target \
-    cd node && wasm-pack build --target web --out-dir ../static/pkg
-
-# Rakenna Hub
 RUN --mount=type=cache,target=/usr/local/cargo/registry \
     --mount=type=cache,target=/app/target \
     cargo build --release -p hub \
     && cp /app/target/release/hub /usr/local/bin/hub
 
+# --- Vaihe 4: Tuotantoimage ---
 FROM debian:bookworm-slim
 RUN apt-get update && apt-get install -y ca-certificates && rm -rf /var/lib/apt/lists/*
 
-COPY --from=builder /usr/local/bin/hub /usr/local/bin/hub
+COPY --from=hub-builder /usr/local/bin/hub /usr/local/bin/hub
-COPY --from=builder /app/static /app/static
+COPY --from=frontend /app/frontend/dist /app/frontend/dist
+COPY --from=wasm-builder /app/wasm-pkg /app/frontend/dist/pkg
+
+# Kopioidaan GUIDE.md ja templates
+COPY frontend/public/GUIDE.md /app/frontend/dist/GUIDE.md
+COPY frontend/public/templates /app/frontend/dist/templates
+COPY frontend/public/avatars /app/frontend/dist/avatars
 
 WORKDIR /app
-ENV STATIC_DIR=/app/static
+ENV STATIC_DIR=/app/frontend/dist
 EXPOSE 3000
 CMD ["hub"]

network-poc/TODO.md

@@ -0,0 +1,26 @@
+# TODO — Kipinä Agentic Network
+
+## Turvallisuus
+- [ ] **Tulosten validointi** — solmu voi palauttaa haitallista koodia. Tarvitaan proof-of-work tai challenge-response -mekanismi
+- [ ] **Reputaatiojärjestelmä** — solmujen luotettavuuden seuranta: onnistuneet tehtävät, vasteaika, laatu
+- [ ] **Koodin sandboxaus** — generoitu koodi pitää ajaa eristetyssä ympäristössä ennen käyttäjälle näyttämistä
+- [ ] **Solmun identiteetti** — rekisteröityminen ja tunnistautuminen (API-avain / token)
+
+## Yksityisyys
+- [ ] **Promptien salaus** — käyttäjän promptit menevät tuntemattomalle solmulle selkotekstinä
+- [ ] **End-to-end enkryptio** — hub ei näe promptin sisältöä, vain reitittää
+- [ ] **Tietosuojaseloste** — käyttäjille kerrottava miten data kulkee ja kuka sen näkee
+- [ ] **Opt-in malli** — käyttäjä valitsee haluaako käyttää yhteisösolmuja vai vain omaa
+
+## Väärinkäytön esto
+- [ ] **Rate limiting per käyttäjä** — nykyinen IP-pohjainen ei riitä, tarvitaan autentikointi
+- [ ] **Solmun kuormitusraja** — solmu voi asettaa max tehtävät/minuutti
+- [ ] **Token-talous** — laskentaresurssien käyttö vaatii Kipinä-tokeneita (gamification jo aloitettu)
+- [ ] **Abuse reporting** — mekanismi haitallisten solmujen ilmiantamiseen
+
+## Seuraavat ominaisuudet
+- [ ] Agenttien välinen keskustelu (manageri ohjaa dynaamisesti)
+- [ ] Tehtävähistoria ja tulosten tallennus
+- [ ] Prometheus/OpenTelemetry -metriikat
+- [ ] Solmujen terveystarkistukset (ping/pong)
+- [ ] Streaming-vastaukset Ollaman kautta

network-poc/build-binaries.sh

@@ -0,0 +1,38 @@
+#!/bin/bash
+# Käännä kipina-node binäärit kaikille alustoille
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+OUT="$SCRIPT_DIR/frontend/public/download"
+mkdir -p "$OUT"
+
+echo "=== Kipinä Node — Binary Build ==="
+
+# macOS ARM (natiivi)
+echo "[1/3] macOS ARM64..."
+cd "$SCRIPT_DIR"
+cargo build --release -p native-node --no-default-features 2>&1 | tail -1
+cp target/release/native-node "$OUT/kipina-node-macos-arm64"
+echo "      $(ls -lh "$OUT/kipina-node-macos-arm64" | awk '{print $5}')"
+
+# Linux x86_64 (Docker)
+echo "[2/3] Linux x86_64..."
+docker run --rm \
+    -v "$SCRIPT_DIR":/app -w /app \
+    --platform linux/amd64 \
+    rust:slim \
+    bash -c "apt-get update -qq && apt-get install -y -qq pkg-config libssl-dev >/dev/null 2>&1 && cargo build --release -p native-node --no-default-features 2>&1 | tail -1 && cp target/release/native-node /app/frontend/public/download/kipina-node-linux-x86_64"
+echo "      $(ls -lh "$OUT/kipina-node-linux-x86_64" | awk '{print $5}')"
+
+# Linux ARM64 (Docker)
+echo "[3/3] Linux ARM64..."
+docker run --rm \
+    -v "$SCRIPT_DIR":/app -w /app \
+    --platform linux/arm64 \
+    rust:slim \
+    bash -c "apt-get update -qq && apt-get install -y -qq pkg-config libssl-dev >/dev/null 2>&1 && cargo build --release -p native-node --no-default-features 2>&1 | tail -1 && cp target/release/native-node /app/frontend/public/download/kipina-node-linux-arm64"
+echo "      $(ls -lh "$OUT/kipina-node-linux-arm64" | awk '{print $5}')"
+
+echo ""
+echo "=== Binäärit valmiina ==="
+ls -lh "$OUT"/kipina-node-*

network-poc/deploy-fast.sh

@@ -0,0 +1,28 @@
+#!/bin/bash
+# Nopea deploy: päivittää vain frontendin (ei kontin uudelleenkäynnistystä)
+# Hub-binäärin päivitys: käytä deploy.sh tai deploy-light.sh
+set -e
+
+SERVER="ubuntu@86.50.252.98"
+REMOTE_DIR="~/code/agentic-studio/network-poc"
+SSH_OPTS="-o StrictHostKeyChecking=no"
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+
+echo "=== Kipinä Studio — Frontend Deploy ==="
+
+# 1. Buildaa frontend paikallisesti
+echo "[1/2] Rakennetaan frontend..."
+cd "$SCRIPT_DIR/frontend"
+[ -d node_modules ] || npm install --silent
+npm run build --silent 2>&1 | tail -1
+
+# 2. Synkataan dist/ palvelimelle (vain muuttuneet tiedostot)
+echo "[2/2] Synkataan dist/ → palvelin..."
+ssh $SSH_OPTS $SERVER "mkdir -p $REMOTE_DIR/frontend/dist"
+rsync -az --delete -e "ssh $SSH_OPTS" "$SCRIPT_DIR/frontend/dist/" "$SERVER:$REMOTE_DIR/frontend/dist/"
+
+echo ""
+echo "=== Valmis! Frontend päivitetty — ei uudelleenkäynnistystä ==="
+echo "    https://kipina.studio"
+echo ""
+echo "Huom: Jos Rust-koodi (hub/) muuttui, aja: ./deploy.sh"

network-poc/deploy-light.sh

@@ -0,0 +1,33 @@
+#!/bin/bash
+# Kevyt deploy: lähetetään vain koodi, palvelin buildaa itse
+set -e
+
+SERVER="ubuntu@86.50.252.98"
+REMOTE_DIR="~/code/agentic-studio/network-poc"
+SSH_OPTS="-o StrictHostKeyChecking=no"
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+
+echo "=== Kipinä Studio Deploy (remote build) ==="
+
+# 1. Synkataan koodi palvelimelle (vain muuttuneet tiedostot)
+echo "[1/3] Synkataan koodi..."
+rsync -az --delete \
+    --exclude 'target/' \
+    --exclude 'node_modules/' \
+    --exclude 'dist/' \
+    --exclude '.astro/' \
+    --exclude 'temp/' \
+    --exclude '*.db' \
+    --exclude '.git/' \
+    "$SCRIPT_DIR/" "$SERVER:$REMOTE_DIR/"
+
+# 2. Rakennetaan image palvelimella
+echo "[2/3] Rakennetaan image palvelimella..."
+ssh $SSH_OPTS $SERVER "cd $REMOTE_DIR && docker build -f Dockerfile.prod -t kipina-agentic:latest ."
+
+# 3. Käynnistetään
+echo "[3/3] Käynnistetään..."
+ssh $SSH_OPTS $SERVER "cd $REMOTE_DIR && docker compose -f docker-compose.prod.yml down && docker compose -f docker-compose.prod.yml up -d"
+
+echo "=== Valmis! https://kipina.studio ==="

network-poc/docker-compose.client.yml

@@ -1,13 +1,12 @@
 services:
-  # NVIDIA GPU -solmu
+  # Ollama NVIDIA GPU:lla
-  native-node-nvidia:
+  ollama-nvidia:
-    build:
+    image: ollama/ollama:latest
-      context: .
+    container_name: kipina-ollama
-      dockerfile: Dockerfile.native-node
+    ports:
-    container_name: kipina-node-nvidia
+      - "11434:11434"
-    environment:
+    volumes:
-      - HUB_URL=wss://kipina.studio/ws
+      - ollama-models:/root/.ollama
-      - ALLOCATED_GB=4
     restart: unless-stopped
     deploy:
       resources:
@@ -16,6 +15,65 @@ services:
             - driver: nvidia
               count: all
               capabilities: [gpu]
+    networks:
+      default:
+        aliases:
+          - ollama
+    profiles:
+      - nvidia
+
+  # Ollama AMD ROCm GPU:lla
+  ollama-amd:
+    image: ollama/ollama:rocm
+    container_name: kipina-ollama
+    ports:
+      - "11434:11434"
+    volumes:
+      - ollama-models:/root/.ollama
+    restart: unless-stopped
+    devices:
+      - /dev/kfd:/dev/kfd
+      - /dev/dri:/dev/dri
+    group_add:
+      - video
+      - render
+    networks:
+      default:
+        aliases:
+          - ollama
+    profiles:
+      - amd
+
+  # Ollama CPU:lla
+  ollama-cpu:
+    image: ollama/ollama:latest
+    container_name: kipina-ollama
+    ports:
+      - "11434:11434"
+    volumes:
+      - ollama-models:/root/.ollama
+    restart: unless-stopped
+    networks:
+      default:
+        aliases:
+          - ollama
+    profiles:
+      - cpu
+
+  # NVIDIA GPU -solmu
+  native-node-nvidia:
+    build:
+      context: .
+      dockerfile: Dockerfile.native-node
+    container_name: kipina-node-nvidia
+    environment:
+      - HUB_URL=wss://kipina.studio/ws
+      - OLLAMA_URL=http://ollama:11434
+      - OLLAMA_MODEL=qwen2.5-coder:7b
+      - ALLOCATED_GB=4
+    restart: unless-stopped
+    depends_on:
+      - ollama-nvidia
     profiles:
       - nvidia
 
@@ -27,14 +85,12 @@ services:
     container_name: kipina-node-amd
     environment:
       - HUB_URL=wss://kipina.studio/ws
+      - OLLAMA_URL=http://ollama:11434
+      - OLLAMA_MODEL=qwen2.5-coder:7b
       - ALLOCATED_GB=4
     restart: unless-stopped
-    devices:
+    depends_on:
-      - /dev/kfd:/dev/kfd
+      - ollama-amd
-      - /dev/dri:/dev/dri
-    group_add:
-      - video
-      - render
     profiles:
       - amd
 
@@ -46,7 +102,14 @@ services:
     container_name: kipina-node-cpu
     environment:
       - HUB_URL=wss://kipina.studio/ws
+      - OLLAMA_URL=http://ollama:11434
+      - OLLAMA_MODEL=qwen2.5-coder:7b
       - ALLOCATED_GB=2
     restart: unless-stopped
+    depends_on:
+      - ollama-cpu
     profiles:
       - cpu
+
+volumes:
+  ollama-models:

network-poc/docker-compose.prod.yml

@@ -19,8 +19,12 @@ services:
     restart: unless-stopped
     environment:
       - DATABASE_PATH=/data/nodes.db
+      - STATIC_DIR=/app/frontend/dist
+      - ADMIN_PASSWORD=${ADMIN_PASSWORD:-}
+      - NODE_API_KEY=${NODE_API_KEY:-}
     volumes:
       - hub_data:/data
+      - ./frontend/dist:/app/frontend/dist:ro
 
 volumes:
   caddy_data:

network-poc/docker-compose.yml

@@ -11,24 +11,37 @@ services:
     # Käännetään aina käynnistyksen yhteydessä varmuuden vuoksi Wasm uusimmista koodeista, ja päälle pyöräytetään Hub!
     command: bash -c "cd node && wasm-pack build --release --target web --out-dir ../static/pkg && cd ../hub && cargo run"
 
-  # Valinnainen natiivi-solmu — kerää oikeat laitteistotiedot (nvidia-smi-taso)
+  # Ollama — LLM-inferenssi
+  # NVIDIA: vaihda image → ollama/ollama:latest ja lisää deploy.resources (ks. README)
+  # CPU: vaihda image → ollama/ollama:latest ja poista devices
+  ollama:
+    image: ollama/ollama:rocm
+    container_name: kipina_ollama
+    ports:
+      - "11434:11434"
+    volumes:
+      - ollama-models:/root/.ollama
+    devices:
+      - /dev/kfd
+      - /dev/dri
+    profiles:
+      - native
+
+  # Natiivisolmu — yhdistää hubiin ja käyttää Ollamaa inferenssiin
   native-node:
     build:
       context: .
       dockerfile: Dockerfile.native-node
     container_name: kipina_native_node
     environment:
-      - HUB_URL=ws://agentic-poc:3000/ws
+      - HUB_URL=wss://kipina.studio/ws
+      - OLLAMA_URL=http://ollama:11434
+      - OLLAMA_MODEL=qwen2.5-coder:7b
       - ALLOCATED_GB=4
     depends_on:
-      - agentic-poc
+      - ollama
-    # GPU passthrough (valinnainen — toimii myös ilman)
-    deploy:
-      resources:
-        reservations:
-          devices:
-            - driver: nvidia
-              count: all
-              capabilities: [gpu]
     profiles:
       - native
+
+volumes:
+  ollama-models:

network-poc/frontend/.gitignore

@@ -0,0 +1,3 @@
+node_modules/
+dist/
+.astro/

network-poc/frontend/astro.config.mjs

@@ -0,0 +1,2 @@
+import { defineConfig } from 'astro/config';
+export default defineConfig({});

network-poc/frontend/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "kipina-frontend",
+  "type": "module",
+  "version": "0.1.0",
+  "scripts": {
+    "dev": "astro dev",
+    "build": "astro build",
+    "preview": "astro preview"
+  },
+  "dependencies": {
+    "astro": "^6.1.5"
+  }
+}

network-poc/frontend/public/GUIDE.md

@@ -36,29 +36,13 @@ sanan osa, kokonainen sana tai välilyönti. Tokenisaatio tehdään
 BPE-algoritmilla (Byte Pair Encoding) joka oppii yleisimmät
 merkkijonot harjoitusdatasta.
 
-### Esimerkki: koodi
-
-```
-"print('Hello')" → [print] [(' ] [Hello] [')]  = 4 tokenia
-"tulosta('Hei')" → [tul] [osta] [(' ] [He] [i] [')]  = 6 tokenia
-```
-
-Koodi tokenisoidaan tehokkaasti koska `print`, `def`, `return` yms.
-ovat kokonaisia tokeneita. Suomenkielinen `tulosta` joudutaan pilkkomaan
-osiin koska se ei esiinny harjoitusdatassa kokonaisena.
-
 ### Esimerkki: suomi vs. englanti
 
-Sama lause kahdella kielellä Qwen2.5-Coder -tokenisaattorilla:
+Alla oikea tokenisointitulos Qwen2.5-Coder-tokenisaattorilla. Jokainen
+värikoodattu lohko on yksi tokeni — huomaa miten suomi vaatii enemmän
+tokeneita saman merkityksen välittämiseen:
 
-| | Teksti | Tokenit | Määrä | Merkkejä/token |
+![Tokenisointivertailu EN/FI](/images/tokenization-example.png)
-|---|---|---|---|---|
-| EN | The cat sat on the mat | [The] [ cat] [ sat] [ on] [ the] [ mat] | **6** | 3.7 |
-| FI | Kissa istui matolla | [K] [issa] [ ist] [ui] [ mat] [olla] | **6** | 3.2 |
-| EN | Distributed computing in the browser | [Dist] [ributed] [ computing] [ in] [ the] [ browser] | **6** | 6.0 |
-| FI | Hajautettu laskenta selaimessa | [H] [aj] [au] [tettu] [ las] [kenta] [ sel] [aim] [essa] | **9** | 3.3 |
-| EN | Write a function that sorts a list | [Write] [ a] [ function] [ that] [ sorts] [ a] [ list] | **7** | 5.0 |
-| FI | Kirjoita funktio joka lajittelee listan | [K] [irj] [oita] [ funkt] [io] [ joka] [ laj] [ittel] [ee] [ listan] | **10** | 4.0 |
 
 **Huomaa miten:**
 - Englannin yleiset sanat (`the`, `in`, `a`, `function`) ovat kokonaisia tokeneita

network-poc/frontend/public/join.sh

@@ -0,0 +1,73 @@
+#!/bin/bash
+# Kipinä — liitä koneesi laskentaverkkoon
+set -e
+
+HUB_URL="${KIPINA_HUB:-wss://kipina.studio/ws}"
+MODEL="${KIPINA_MODEL:-qwen2.5-coder:3b}"
+
+echo ""
+echo "  ╔══════════════════════════════════════╗"
+echo "  ║  Kipinä Agentic Network — Node Join  ║"
+echo "  ╚══════════════════════════════════════╝"
+echo ""
+
+# 1. Ollama
+if command -v ollama &>/dev/null; then
+    echo "  ✓ Ollama löytyi: $(ollama --version 2>/dev/null || echo 'asennettu')"
+else
+    echo "  Ollama ei ole asennettu."
+    echo ""
+    read -p "  Asennetaanko Ollama? (k/e) " -n 1 -r; echo
+    if [[ $REPLY =~ ^[Kk]$ ]]; then
+        echo "  Asennetaan Ollama..."
+        curl -fsSL https://ollama.ai/install.sh | sh
+    else
+        echo "  Ollama vaaditaan laskentaan. Asenna: https://ollama.ai"
+        exit 1
+    fi
+fi
+
+# 2. Varmistetaan että Ollama on käynnissä
+if ! curl -s http://localhost:11434/api/tags &>/dev/null; then
+    echo "  Käynnistetään Ollama..."
+    ollama serve &>/dev/null &
+    sleep 3
+    if ! curl -s http://localhost:11434/api/tags &>/dev/null; then
+        echo "  ✗ Ollama ei käynnistynyt. Aja: ollama serve"
+        exit 1
+    fi
+fi
+echo "  ✓ Ollama käynnissä"
+
+# 3. Malli
+if ollama list 2>/dev/null | grep -q "$MODEL"; then
+    echo "  ✓ Malli $MODEL ladattu"
+else
+    echo "  Ladataan malli $MODEL..."
+    ollama pull "$MODEL"
+fi
+
+# 4. Native-node
+echo ""
+echo "  Yhdistetään hubiin: $HUB_URL"
+echo "  Malli: $MODEL"
+echo "  Ctrl+C pysäyttää"
+echo ""
+
+# Tarkistetaan onko native-node käännetty
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+NATIVE_BIN="$SCRIPT_DIR/target/release/native-node"
+
+if [ -f "$NATIVE_BIN" ]; then
+    HUB_URL="$HUB_URL" OLLAMA_MODEL="$MODEL" "$NATIVE_BIN"
+elif command -v cargo &>/dev/null && [ -f "$SCRIPT_DIR/native-node/Cargo.toml" ]; then
+    echo "  Käännetään native-node..."
+    cd "$SCRIPT_DIR"
+    cargo build --release -p native-node --no-default-features 2>&1 | tail -1
+    HUB_URL="$HUB_URL" OLLAMA_MODEL="$MODEL" "$NATIVE_BIN"
+else
+    echo "  ✗ native-node binääriä ei löydy eikä Rust ole asennettu."
+    echo "  Asenna Rust: curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh"
+    echo "  Tai lataa valmis binääri: https://kipina.studio/download"
+    exit 1
+fi

network-poc/frontend/public/kipina-node

@@ -0,0 +1,121 @@
+#!/bin/bash
+# Kipinä Node — lataa oikea binääri ja käynnistä
+set -e
+
+BASE_URL="https://kipina.studio/download"
+HUB_URL="${KIPINA_HUB:-wss://kipina.studio/ws}"
+MODEL="${KIPINA_MODEL:-qwen2.5-coder:3b}"
+OLLAMA_URL="${OLLAMA_URL:-http://localhost:11434}"
+
+# Tunnista OS ja arkkitehtuuri
+OS=$(uname -s | tr '[:upper:]' '[:lower:]')
+ARCH=$(uname -m)
+
+case "$OS-$ARCH" in
+    darwin-arm64)  BINARY="kipina-node-macos-arm64" ;;
+    darwin-x86_64) BINARY="kipina-node-macos-arm64" ;; # Rosetta
+    linux-x86_64)  BINARY="kipina-node-linux-x86_64" ;;
+    linux-aarch64) BINARY="kipina-node-linux-arm64" ;;
+    *) echo "Ei tuettu: $OS-$ARCH"; exit 1 ;;
+esac
+
+echo ""
+echo "  ╔══════════════════════════════════════╗"
+echo "  ║       Kipinä Agentic Node            ║"
+echo "  ╚══════════════════════════════════════╝"
+echo ""
+echo "  OS: $OS ($ARCH)"
+echo ""
+
+# Etsi Ollama-instanssit
+CANDIDATES=(
+    "http://localhost:11434"
+    "http://127.0.0.1:11434"
+    "http://ollama:11434"
+    "http://host.docker.internal:11434"
+)
+
+# Lisää OLLAMA_URL listaan jos asetettu ja ei jo mukana
+if [ -n "$OLLAMA_URL" ]; then
+    ALREADY=false
+    for c in "${CANDIDATES[@]}"; do
+        [ "$c" = "$OLLAMA_URL" ] && ALREADY=true
+    done
+    $ALREADY || CANDIDATES=("$OLLAMA_URL" "${CANDIDATES[@]}")
+fi
+
+echo "  Etsitään Ollama-instansseja..."
+FOUND=()
+for url in "${CANDIDATES[@]}"; do
+    if curl -s --connect-timeout 1 "$url/api/tags" &>/dev/null; then
+        FOUND+=("$url")
+    fi
+done
+
+if [ ${#FOUND[@]} -eq 0 ]; then
+    # Ei löytynyt — yritä käynnistää lokaali
+    if command -v ollama &>/dev/null; then
+        echo "  Käynnistetään Ollama..."
+        ollama serve &>/dev/null &
+        sleep 3
+        if curl -s --connect-timeout 1 "http://localhost:11434/api/tags" &>/dev/null; then
+            OLLAMA_URL="http://localhost:11434"
+            echo "  ✓ Ollama käynnistetty ($OLLAMA_URL)"
+        else
+            echo "  ✗ Ollaman käynnistys epäonnistui."
+            exit 1
+        fi
+    else
+        echo ""
+        echo "  ✗ Ollamaa ei löytynyt."
+        echo "    Kontti/remote: OLLAMA_URL=http://HOST:11434 ./kipina-node"
+        echo "    Asenna:        curl -fsSL https://ollama.ai/install.sh | sh"
+        exit 1
+    fi
+elif [ ${#FOUND[@]} -eq 1 ]; then
+    OLLAMA_URL="${FOUND[0]}"
+    echo "  ✓ Ollama löytyi: $OLLAMA_URL"
+else
+    echo ""
+    echo "  Löytyi ${#FOUND[@]} Ollama-instanssia:"
+    echo ""
+    for i in "${!FOUND[@]}"; do
+        echo "    $((i+1))) ${FOUND[$i]}"
+    done
+    echo ""
+    read -p "  Valitse [1-${#FOUND[@]}]: " -r CHOICE
+    if [[ "$CHOICE" =~ ^[0-9]+$ ]] && [ "$CHOICE" -ge 1 ] && [ "$CHOICE" -le ${#FOUND[@]} ]; then
+        OLLAMA_URL="${FOUND[$((CHOICE-1))]}"
+    else
+        OLLAMA_URL="${FOUND[0]}"
+        echo "  Käytetään oletusta: $OLLAMA_URL"
+    fi
+    echo "  ✓ Valittu: $OLLAMA_URL"
+fi
+
+echo ""
+echo "  Hub: $HUB_URL"
+echo "  Ollama: $OLLAMA_URL"
+echo "  Malli: $MODEL"
+
+# Lataa malli (toimii sekä lokaalilla binäärillä että API:n kautta)
+if ! curl -s "$OLLAMA_URL/api/tags" | grep -q "$MODEL"; then
+    echo "  Ladataan $MODEL..."
+    curl -s "$OLLAMA_URL/api/pull" -d "{\"name\":\"$MODEL\"}" > /dev/null
+fi
+echo "  ✓ Malli $MODEL valmis"
+
+# Lataa binääri
+BIN_PATH="./kipina-node-bin"
+if [ ! -f "$BIN_PATH" ]; then
+    echo "  Ladataan $BINARY..."
+    curl -sSL "$BASE_URL/$BINARY" -o "$BIN_PATH"
+    chmod +x "$BIN_PATH"
+fi
+
+echo ""
+echo "  ✓ Yhdistetään laskentaverkkoon..."
+echo "    Ctrl+C pysäyttää"
+echo ""
+
+HUB_URL="$HUB_URL" OLLAMA_URL="$OLLAMA_URL" OLLAMA_MODEL="$MODEL" exec "$BIN_PATH"

network-poc/frontend/public/pkg/node.d.ts

@@ -0,0 +1,63 @@
+/* tslint:disable */
+/* eslint-disable */
+
+export function set_auto_tasks(enabled: boolean): void;
+
+export function set_gpu_load(load: number): void;
+
+export function start_agent_node(hub_url: string, has_webgpu: boolean, device_info_json: string, task_id: number): Promise<void>;
+
+/**
+ * JS-exportti: tokenisoi tekstin ja palauttaa JSON-merkkijonon
+ * Tokenizer ladataan IndexedDB:stä (täytyy olla ladattu aiemmin)
+ */
+export function tokenize_js(text: string): Promise<string>;
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly set_auto_tasks: (a: number) => void;
+    readonly set_gpu_load: (a: number) => void;
+    readonly start_agent_node: (a: number, b: number, c: number, d: number, e: number, f: number) => any;
+    readonly tokenize_js: (a: number, b: number) => any;
+    readonly wasm_bindgen__convert__closures_____invoke__h6ec112f0342d232e: (a: number, b: number, c: any) => [number, number];
+    readonly wasm_bindgen__convert__closures_____invoke__h737e63bacb96714d: (a: number, b: number, c: any, d: any) => void;
+    readonly wasm_bindgen__convert__closures_____invoke__ha390eb51fa5285b4: (a: number, b: number, c: any) => void;
+    readonly wasm_bindgen__convert__closures_____invoke__h9cacd8a9a6ca46c2: (a: number, b: number, c: any) => void;
+    readonly wasm_bindgen__convert__closures_____invoke__ha390eb51fa5285b4_3: (a: number, b: number, c: any) => void;
+    readonly wasm_bindgen__convert__closures_____invoke__h0afc19def95e993a: (a: number, b: number, c: any) => void;
+    readonly wasm_bindgen__convert__closures_____invoke__h0afc19def95e993a_5: (a: number, b: number, c: any) => void;
+    readonly wasm_bindgen__convert__closures_____invoke__h698aa4c8c2e7db1b: (a: number, b: number) => void;
+    readonly __wbindgen_malloc: (a: number, b: number) => number;
+    readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+    readonly __wbindgen_exn_store: (a: number) => void;
+    readonly __externref_table_alloc: () => number;
+    readonly __wbindgen_externrefs: WebAssembly.Table;
+    readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+    readonly __wbindgen_destroy_closure: (a: number, b: number) => void;
+    readonly __externref_table_dealloc: (a: number) => void;
+    readonly __wbindgen_start: () => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;

network-poc/frontend/public/pkg/node_bg.wasm.d.ts

@@ -0,0 +1,24 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const set_auto_tasks: (a: number) => void;
+export const set_gpu_load: (a: number) => void;
+export const start_agent_node: (a: number, b: number, c: number, d: number, e: number, f: number) => any;
+export const tokenize_js: (a: number, b: number) => any;
+export const wasm_bindgen__convert__closures_____invoke__h6ec112f0342d232e: (a: number, b: number, c: any) => [number, number];
+export const wasm_bindgen__convert__closures_____invoke__h737e63bacb96714d: (a: number, b: number, c: any, d: any) => void;
+export const wasm_bindgen__convert__closures_____invoke__ha390eb51fa5285b4: (a: number, b: number, c: any) => void;
+export const wasm_bindgen__convert__closures_____invoke__h9cacd8a9a6ca46c2: (a: number, b: number, c: any) => void;
+export const wasm_bindgen__convert__closures_____invoke__ha390eb51fa5285b4_3: (a: number, b: number, c: any) => void;
+export const wasm_bindgen__convert__closures_____invoke__h0afc19def95e993a: (a: number, b: number, c: any) => void;
+export const wasm_bindgen__convert__closures_____invoke__h0afc19def95e993a_5: (a: number, b: number, c: any) => void;
+export const wasm_bindgen__convert__closures_____invoke__h698aa4c8c2e7db1b: (a: number, b: number) => void;
+export const __wbindgen_malloc: (a: number, b: number) => number;
+export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+export const __wbindgen_exn_store: (a: number) => void;
+export const __externref_table_alloc: () => number;
+export const __wbindgen_externrefs: WebAssembly.Table;
+export const __wbindgen_free: (a: number, b: number, c: number) => void;
+export const __wbindgen_destroy_closure: (a: number, b: number) => void;
+export const __externref_table_dealloc: (a: number) => void;
+export const __wbindgen_start: () => void;

network-poc/frontend/public/pkg/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "node",
+  "type": "module",
+  "version": "0.1.0",
+  "files": [
+    "node_bg.wasm",
+    "node.js",
+    "node.d.ts"
+  ],
+  "main": "node.js",
+  "types": "node.d.ts",
+  "sideEffects": [
+    "./snippets/*"
+  ]
+}

network-poc/frontend/public/templates/fastapi-crud.json

@@ -0,0 +1,27 @@
+{
+  "name": "FastAPI CRUD",
+  "description": "REST API with SQLite database",
+  "files": {
+    "models.py": {
+      "description": "SQLAlchemy models, engine, and session",
+      "example": "from sqlalchemy import create_engine, Column, Integer, String\nfrom sqlalchemy.ext.declarative import declarative_base\nfrom sqlalchemy.orm import sessionmaker\n\nDATABASE_URL = \"sqlite:///./app.db\"\nengine = create_engine(DATABASE_URL, connect_args={\"check_same_thread\": False})\nSessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)\nBase = declarative_base()\n\nclass Item(Base):\n    __tablename__ = \"items\"\n    id = Column(Integer, primary_key=True, index=True)\n    name = Column(String(100), nullable=False)\n    description = Column(String(500))",
+      "instructions": "Define the SQLAlchemy model based on the project description. Always include:\n- engine with check_same_thread=False for SQLite\n- SessionLocal with autocommit=False\n- Base = declarative_base()\n- Model class with __tablename__, primary key, and fields"
+    },
+    "schemas.py": {
+      "description": "Pydantic request/response schemas",
+      "example": "from pydantic import BaseModel\n\nclass ItemCreate(BaseModel):\n    name: str\n    description: str | None = None\n\nclass ItemResponse(ItemCreate):\n    id: int\n\n    class Config:\n        from_attributes = True",
+      "instructions": "Create Pydantic schemas that match the SQLAlchemy model:\n- Create schema: fields without id (user provides these)\n- Response schema: inherits from Create, adds id\n- Add class Config with from_attributes = True (required for SQLAlchemy ORM)"
+    },
+    "main.py": {
+      "description": "FastAPI app with CRUD endpoints",
+      "example": "from fastapi import FastAPI, Depends, HTTPException\nfrom sqlalchemy.orm import Session\nfrom models import Base, engine, SessionLocal, Item\nfrom schemas import ItemCreate, ItemResponse\n\nBase.metadata.create_all(bind=engine)\napp = FastAPI()\n\ndef get_db():\n    db = SessionLocal()\n    try:\n        yield db\n    finally:\n        db.close()\n\n@app.post(\"/items/\", response_model=ItemResponse, status_code=201)\ndef create_item(item: ItemCreate, db: Session = Depends(get_db)):\n    db_item = Item(**item.model_dump())\n    db.add(db_item)\n    db.commit()\n    db.refresh(db_item)\n    return db_item\n\n@app.get(\"/items/\", response_model=list[ItemResponse])\ndef list_items(db: Session = Depends(get_db)):\n    return db.query(Item).all()\n\n@app.get(\"/items/{item_id}\", response_model=ItemResponse)\ndef get_item(item_id: int, db: Session = Depends(get_db)):\n    item = db.query(Item).filter(Item.id == item_id).first()\n    if not item:\n        raise HTTPException(status_code=404, detail=\"Not found\")\n    return item\n\n@app.put(\"/items/{item_id}\", response_model=ItemResponse)\ndef update_item(item_id: int, item: ItemCreate, db: Session = Depends(get_db)):\n    db_item = db.query(Item).filter(Item.id == item_id).first()\n    if not db_item:\n        raise HTTPException(status_code=404, detail=\"Not found\")\n    for key, value in item.model_dump().items():\n        setattr(db_item, key, value)\n    db.commit()\n    db.refresh(db_item)\n    return db_item\n\n@app.delete(\"/items/{item_id}\", status_code=204)\ndef delete_item(item_id: int, db: Session = Depends(get_db)):\n    db_item = db.query(Item).filter(Item.id == item_id).first()\n    if not db_item:\n        raise HTTPException(status_code=404, detail=\"Not found\")\n    db.delete(db_item)\n    db.commit()",
+      "instructions": "Create the FastAPI app with all CRUD endpoints:\n- Import from models.py and schemas.py (use exact class names)\n- create_all(bind=engine) at module level\n- get_db dependency with yield pattern\n- POST (201), GET list, GET by id, PUT, DELETE (204)\n- Use response_model for type safety\n- Use model_dump() not dict() (Pydantic v2)"
+    },
+    "pyproject.toml": {
+      "description": "Project dependencies",
+      "example": "[project]\nname = \"myapp\"\nversion = \"0.1.0\"\nrequires-python = \">=3.11\"\ndependencies = [\n    \"fastapi\",\n    \"uvicorn[standard]\",\n    \"sqlalchemy\",\n]\n\n[project.scripts]\ndev = \"uvicorn main:app --reload\"",
+      "instructions": "Use [project] format (PEP 621, compatible with uv). List dependencies under [project.dependencies]. Add [project.scripts] with dev command. Never use requirements.txt or Poetry format. Run with: uv run uvicorn main:app --reload"
+    }
+  },
+  "order": ["models.py", "schemas.py", "main.py", "pyproject.toml"]
+}

network-poc/frontend/src/components/AgentBar.astro

@@ -0,0 +1,79 @@
+<!-- Agenttigalleria + konfigurointipaneeli -->
+<div style="display:flex;gap:16px;padding:10px 0;align-items:flex-start">
+    <!-- Agenttilista (drag & drop) -->
+    <div id="agent-bar" style="display:flex;gap:6px;align-items:flex-end;flex-wrap:wrap">
+        <!-- Renderöidään JS:stä -->
+    </div>
+    <!-- + Lisää agentti -->
+    <div id="add-agent-btn" class="agent-avatar" onclick="addCustomAgent()" title="Lisää oma agentti" style="opacity:0.4">
+        <div style="width:48px;height:48px;border-radius:50%;border:2px dashed var(--border);display:flex;align-items:center;justify-content:center;font-size:24px;color:var(--border)">+</div>
+        <span style="font-size:10px;color:#8b949e;text-align:center;display:block">Lisää</span>
+    </div>
+</div>
+
+<!-- Agentin konfigurointipaneeli (avautuu klikkaamalla avataria) -->
+<div id="agent-config" style="display:none;background:var(--panel);border:1px solid var(--border);border-radius:6px;padding:16px;margin-bottom:10px">
+    <div style="display:flex;justify-content:space-between;align-items:center;margin-bottom:12px">
+        <div style="display:flex;align-items:center;gap:10px">
+            <img id="config-avatar" src="" style="width:40px;height:40px;border-radius:50%">
+            <div>
+                <input id="config-name" style="background:transparent;border:none;color:var(--text);font-size:16px;font-weight:600;outline:none;width:200px" placeholder="Agentin nimi">
+                <div id="config-role" style="font-size:11px;color:#8b949e"></div>
+            </div>
+        </div>
+        <div style="display:flex;gap:6px">
+            <button class="btn btn-red" onclick="deleteAgent()" title="Poista agentti">Poista</button>
+            <button class="btn btn-muted" onclick="closeAgentConfig()">Sulje</button>
+        </div>
+    </div>
+
+    <!-- Malli -->
+    <div style="margin-bottom:10px">
+        <label style="font-size:12px;color:#8b949e;display:block;margin-bottom:4px">Kielimalli</label>
+        <select id="config-model" style="background:var(--bg);color:var(--text);border:1px solid var(--border);border-radius:4px;padding:6px 10px;font-size:13px;width:100%">
+            <option value="qwen-coder">Qwen2.5-Coder:0.5B (selain)</option>
+            <option value="qwen-coder-3b">Qwen2.5-Coder:3B (Ollama)</option>
+            <option value="qwen2.5-coder:7b">Qwen2.5-Coder:7B (Ollama)</option>
+            <option value="qwen2.5-coder:1.5b">Qwen2.5-Coder:1.5B (Ollama)</option>
+        </select>
+    </div>
+
+    <!-- System prompt -->
+    <div style="margin-bottom:10px" title="Agentin perusohje joka lähetetään kielimallille jokaisessa pyynnössä.&#10;&#10;Hyvän promptin rakenne:&#10;1. Rooli: 'You are an expert...'&#10;2. Säännöt: RULES/CRITICAL RULES listana&#10;3. Esimerkit: EXAMPLE OUTPUT&#10;4. Kiellot: NEVER-lista&#10;&#10;Vinkki: käytä englantia — malli ymmärtää sen paremmin ja se kuluttaa vähemmän tokeneita.">
+        <label style="font-size:12px;color:#8b949e;display:block;margin-bottom:4px;cursor:help">System prompt 💡</label>
+        <textarea id="config-prompt" style="width:100%;background:var(--bg);color:var(--text);border:1px solid var(--border);border-radius:4px;padding:8px;font-size:13px;font-family:'Courier New',monospace;resize:vertical;overflow:hidden;min-height:60px" placeholder="Kuvaa agentin rooli ja käyttäytyminen..."></textarea>
+    </div>
+
+    <!-- Sampling-parametrit -->
+    <div style="margin-bottom:10px">
+        <label style="font-size:12px;color:#8b949e;display:block;margin-bottom:8px">Sampling-parametrit</label>
+        <div style="display:grid;grid-template-columns:1fr 1fr;gap:10px">
+            <div title="Kontrolloi 'luovuutta'. Matala arvo (0.2-0.4) tuottaa ennustettavaa, toistettavaa koodia — hyvä testaajille ja reviewereille. Keskiarvo (0.6-0.8) on paras koodin generointiin. Korkea arvo (1.0+) lisää vaihtelua mutta myös virheitä.&#10;&#10;Suositus:&#10;• Manageri: 0.5 (tarkat tiedostolistat)&#10;• Koodari: 0.7 (toimiva koodi + vaihtelu)&#10;• Testaaja: 0.3 (deterministinen arviointi)">
+                <label style="font-size:11px;color:#8b949e;cursor:help">Temperature 💡 <span id="config-temp-val" style="color:var(--accent);float:right">0.7</span></label>
+                <input type="range" id="config-temperature" min="0" max="1.5" step="0.1" value="0.7" style="width:100%;accent-color:var(--accent)">
+                <div style="font-size:10px;color:#30363d">0=tarkka · 0.7=oletus · 1.5=luova</div>
+            </div>
+            <div title="Vastauksen maksimipituus tokeneina (~1 token ≈ 4 merkkiä).&#10;&#10;Suositus:&#10;• Manageri: 256-512 (lyhyet tiedostolistat)&#10;• Koodari: 1024-2048 (täydet tiedostot, CRUD-endpointit)&#10;• Testaaja: 256-512 (lyhyet arvioinnit)&#10;&#10;Jos koodi katkeaa kesken, nosta tätä. Jos malli tuottaa turhaa toistoa, laske.">
+                <label style="font-size:11px;color:#8b949e;cursor:help">Max tokens 💡 <span id="config-maxtok-val" style="color:var(--accent);float:right">1024</span></label>
+                <input type="range" id="config-maxtokens" min="64" max="4096" step="64" value="1024" style="width:100%;accent-color:var(--accent)">
+                <div style="font-size:10px;color:#30363d">Vastauksen maksimipituus</div>
+            </div>
+            <div title="Montako todennäköisintä tokenia huomioidaan valinnassa. Pieni arvo (1-10) tekee vastauksesta deterministisen. Suuri arvo (50-100) sallii harvinaisempia sanoja.&#10;&#10;Suositus:&#10;• Boilerplate-koodi: 20-30 (tutut patternit)&#10;• Yleiskoodi: 40 (hyvä oletus)&#10;• Luova teksti: 60-80&#10;&#10;Yleensä ei tarvitse muuttaa oletuksesta.">
+                <label style="font-size:11px;color:#8b949e;cursor:help">Top-K 💡 <span id="config-topk-val" style="color:var(--accent);float:right">40</span></label>
+                <input type="range" id="config-topk" min="1" max="100" step="1" value="40" style="width:100%;accent-color:var(--accent)">
+                <div style="font-size:10px;color:#30363d">1=greedy · 40=oletus · 100=laaja</div>
+            </div>
+            <div title="Vähentää jo tuotettujen sanojen todennäköisyyttä. Estää mallia toistamasta samaa lausetta. Liian korkea arvo (>1.5) voi rikkoa koodin koska samat avainsanat (return, if, def) ovat tarpeellisia.&#10;&#10;Suositus:&#10;• Koodi: 1.1-1.2 (lievä, sallii toiston)&#10;• Teksti: 1.15-1.3 (vahvempi)&#10;• Review: 1.0-1.1 (ei rangaistusta, lyhyet vastaukset)">
+                <label style="font-size:11px;color:#8b949e;cursor:help">Repetition penalty 💡 <span id="config-rep-val" style="color:var(--accent);float:right">1.15</span></label>
+                <input type="range" id="config-repeat" min="1.0" max="2.0" step="0.05" value="1.15" style="width:100%;accent-color:var(--accent)">
+                <div style="font-size:10px;color:#30363d">1.0=ei · 1.15=oletus · 2.0=vahva</div>
+            </div>
+        </div>
+    </div>
+
+    <!-- Pipeline-järjestys -->
+    <div>
+        <label style="font-size:12px;color:#8b949e;display:block;margin-bottom:4px">Pipeline-järjestys <span style="color:var(--border)">(vedä järjestääksesi)</span></label>
+        <div id="config-pipeline" style="display:flex;gap:4px;flex-wrap:wrap"></div>
+    </div>
+</div>

network-poc/frontend/src/components/Editor.astro

@@ -0,0 +1,15 @@
+<!-- Monaco Editor paneeli -->
+<div id="panel-editor" class="panel">
+    <div style="display:flex;height:calc(100vh - 200px);gap:0;border:1px solid var(--border);border-radius:6px;overflow:hidden">
+        <div id="editor-filetree" style="width:200px;min-width:150px;background:var(--bg);border-right:1px solid var(--border);overflow-y:auto;font-family:'Courier New',monospace;font-size:13px">
+            <div style="padding:10px 12px;color:#8b949e;font-size:11px;text-transform:uppercase;letter-spacing:0.5px;border-bottom:1px solid var(--border)">Tiedostot</div>
+            <div id="editor-file-list" style="padding:4px 0">
+                <div style="padding:8px 16px;color:#8b949e;font-size:12px">Generoi projekti:<br><code style="color:var(--accent)">kpn project "..."</code></div>
+            </div>
+        </div>
+        <div style="flex:1;display:flex;flex-direction:column">
+            <div id="editor-tabs" style="display:flex;background:var(--bg);border-bottom:1px solid var(--border);min-height:35px;align-items:flex-end;padding:0 8px;gap:2px;overflow-x:auto"></div>
+            <div id="monaco-container" style="flex:1"></div>
+        </div>
+    </div>
+</div>

network-poc/frontend/src/components/Guide.astro

@@ -0,0 +1,6 @@
+<!-- Opas-paneeli: ladataan GUIDE.md fetchillä -->
+<div id="panel-guide" class="panel">
+    <div id="guide-content" style="max-width:800px;margin:0 auto;padding:20px;line-height:1.7;font-size:15px">
+        <p style="color:#8b949e">Ladataan opasta...</p>
+    </div>
+</div>

network-poc/frontend/src/components/Settings.astro

@@ -0,0 +1,67 @@
+<!-- Asetukset-paneeli: kaikki LLM-parametrit muokattavissa -->
+<div id="panel-settings" class="panel">
+    <div style="max-width:800px;margin:0 auto;padding:20px">
+        <h2 style="color:#e6edf3;margin-bottom:16px">Asetukset</h2>
+        <p style="color:#8b949e;margin-bottom:20px;font-size:14px">Kaikki kielimallin toimintaan vaikuttavat parametrit. Muutokset tallentuvat automaattisesti.</p>
+
+        <!-- System prompt -->
+        <div class="settings-section">
+            <h3 class="settings-title">System Prompt</h3>
+            <p class="settings-desc">Kielimallin perusohje joka lähetetään jokaisessa pyynnössä. Määrittää mallin käyttäytymisen.</p>
+            <textarea id="set-system-prompt" class="settings-textarea" rows="4"></textarea>
+        </div>
+
+        <!-- Sampling -->
+        <div class="settings-section">
+            <h3 class="settings-title">Sampling-parametrit</h3>
+            <p class="settings-desc">Kontrolloi miten malli valitsee seuraavan tokenin. <a href="#guide" onclick="switchTab('guide')" style="color:var(--accent)">Lue lisää oppaasta.</a></p>
+            <div class="settings-grid">
+                <div>
+                    <label class="settings-label">Temperature <span id="set-temp-val" class="settings-val">0.7</span></label>
+                    <input type="range" id="set-temperature" min="0" max="1.5" step="0.1" value="0.7" class="settings-slider">
+                    <div class="settings-hint">0 = deterministic, 0.7 = balanced, 1.5 = creative</div>
+                </div>
+                <div>
+                    <label class="settings-label">Top-K <span id="set-topk-val" class="settings-val">40</span></label>
+                    <input type="range" id="set-topk" min="1" max="100" step="1" value="40" class="settings-slider">
+                    <div class="settings-hint">Montako tokenia huomioidaan. 1 = greedy, 40 = oletus</div>
+                </div>
+                <div>
+                    <label class="settings-label">Repetition Penalty <span id="set-rep-val" class="settings-val">1.15</span></label>
+                    <input type="range" id="set-repeat" min="1.0" max="2.0" step="0.05" value="1.15" class="settings-slider">
+                    <div class="settings-hint">Estää toistoa. 1.0 = ei rangaistusta, 1.15 = oletus</div>
+                </div>
+                <div>
+                    <label class="settings-label">Max Tokens <span id="set-maxtok-val" class="settings-val">1024</span></label>
+                    <input type="range" id="set-maxtokens" min="64" max="4096" step="64" value="1024" class="settings-slider">
+                    <div class="settings-hint">Vastauksen maksimipituus tokeneina</div>
+                </div>
+            </div>
+        </div>
+
+        <!-- Stop-sekvenssit -->
+        <div class="settings-section">
+            <h3 class="settings-title">Stop-sekvenssit</h3>
+            <p class="settings-desc">Generointi katkeaa kun malli tuottaa jonkin näistä. Yksi per rivi.</p>
+            <textarea id="set-stop-sequences" class="settings-textarea" rows="4"></textarea>
+        </div>
+
+        <!-- Malli -->
+        <div class="settings-section">
+            <h3 class="settings-title">Malli (Ollama)</h3>
+            <p class="settings-desc">Natiivisolmun käyttämä kielimalli. Muutos vaatii native-noden uudelleenkäynnistyksen.</p>
+            <select id="set-model" class="settings-select">
+                <option value="qwen2.5-coder:1.5b">Qwen2.5-Coder:1.5B (~80 tok/s, ~1GB)</option>
+                <option value="qwen2.5-coder:3b">Qwen2.5-Coder:3B (~50 tok/s, ~2GB)</option>
+                <option value="qwen2.5-coder:7b-instruct-q4_K_M">Qwen2.5-Coder:7B Q4 (~30 tok/s, ~4GB)</option>
+                <option value="qwen2.5-coder:7b">Qwen2.5-Coder:7B (~20 tok/s, ~7GB)</option>
+            </select>
+        </div>
+
+        <!-- Reset -->
+        <div style="margin-top:24px;padding-top:16px;border-top:1px solid var(--border)">
+            <button class="btn btn-red" onclick="resetSettings()" style="padding:6px 16px">Palauta oletukset</button>
+            <span style="color:#8b949e;font-size:12px;margin-left:8px">Palauttaa kaikki parametrit oletusarvoihin</span>
+        </div>
+    </div>
+</div>

network-poc/frontend/src/components/StatusBar.astro

@@ -0,0 +1,48 @@
+<!-- Hub-yhteys + laskentasolmun tila -->
+<div class="status-bar">
+    <span class="status-group" title="Hub-yhteyden tila">
+        <span id="hub-dot" class="status-dot" style="background:#d29922"></span>
+        <span style="color:#8b949e">Hub:</span>
+        <span id="hub-label" style="color:#d29922">Yhdistetään...</span>
+    </span>
+    <span class="status-separator">│</span>
+    <span class="status-group">
+        <span id="compute-dot" class="status-dot" style="background:#30363d"></span>
+        <span style="color:#8b949e">Laskenta:</span>
+        <span id="compute-label" style="color:#8b949e">—</span>
+        <button id="compute-btn" class="btn btn-accent" title="Käynnistä kielimalli selaimessa">Alusta</button>
+    </span>
+    <span class="status-separator">│</span>
+    <span class="status-group">
+        <button id="join-btn" class="btn btn-green" onclick="showJoinDialog()" title="Liitä oma koneesi laskentaverkkoon (natiivi, nopea)">+ Liitä koneesi</button>
+    </span>
+</div>
+
+<!-- Join-dialogi -->
+<div id="join-dialog" style="display:none;margin-top:8px;padding:16px;background:var(--panel);border:1px solid var(--border);border-radius:6px;font-size:14px">
+    <div style="display:flex;justify-content:space-between;align-items:center;margin-bottom:12px">
+        <span style="color:#e6edf3;font-weight:600;font-size:16px">Liitä koneesi laskentaverkkoon</span>
+        <button onclick="document.getElementById('join-dialog').style.display='none'" style="background:none;border:none;color:#8b949e;cursor:pointer;font-size:18px">✕</button>
+    </div>
+    <p style="color:#8b949e;margin-bottom:16px">Koneesi suorittaa tehtäviä ~10-50x nopeammin kuin selainlaskenta. Kaksi vaihetta:</p>
+
+    <!-- Vaihe 1: Ollama -->
+    <div style="margin-bottom:14px;padding:12px;background:var(--bg);border-radius:4px;border-left:3px solid var(--accent)">
+        <div style="color:#e6edf3;font-weight:600;margin-bottom:6px">1. Asenna Ollama <span style="color:#8b949e;font-weight:normal">(kielimallimoottori)</span></div>
+        <div style="display:flex;gap:6px;align-items:center;margin-bottom:6px">
+            <code style="flex:1;background:#010409;padding:8px 12px;border-radius:4px;color:var(--green);font-family:'Courier New',monospace;font-size:13px;user-select:all">curl -fsSL https://ollama.ai/install.sh | sh</code>
+            <button onclick="navigator.clipboard.writeText('curl -fsSL https://ollama.ai/install.sh | sh');this.textContent='✓';setTimeout(()=>this.textContent='Kopioi',1500)" class="btn btn-accent" style="padding:6px 10px">Kopioi</button>
+        </div>
+        <div style="color:#8b949e;font-size:12px">macOS: <code style="color:var(--accent)">brew install ollama</code> · Windows: <a href="https://ollama.ai/download" target="_blank" style="color:var(--accent)">ollama.ai/download</a> · Jos jo asennettu → siirry vaiheeseen 2.</div>
+    </div>
+
+    <!-- Vaihe 2: Kipinä-node -->
+    <div style="padding:12px;background:var(--bg);border-radius:4px;border-left:3px solid var(--green)">
+        <div style="color:#e6edf3;font-weight:600;margin-bottom:6px">2. Käynnistä Kipinä-node</div>
+        <div style="display:flex;gap:6px;align-items:center;margin-bottom:6px">
+            <code style="flex:1;background:#010409;padding:8px 12px;border-radius:4px;color:var(--green);font-family:'Courier New',monospace;font-size:13px;user-select:all">curl -sSL https://kipina.studio/kipina-node -o kipina-node && chmod +x kipina-node && ./kipina-node</code>
+            <button onclick="navigator.clipboard.writeText('curl -sSL https://kipina.studio/kipina-node -o kipina-node && chmod +x kipina-node && ./kipina-node');this.textContent='✓';setTimeout(()=>this.textContent='Kopioi',1500)" class="btn btn-green" style="padding:6px 10px">Kopioi</button>
+        </div>
+        <div style="color:#8b949e;font-size:12px">Lataa kielimallin (~2GB) automaattisesti ensimmäisellä kerralla. Ctrl+C pysäyttää.</div>
+    </div>
+</div>

network-poc/frontend/src/components/Terminal.astro

@@ -0,0 +1,10 @@
+<!-- Pipeline-palkki + Terminaali + Input -->
+<div id="pipeline-bar" class="pipeline-bar"></div>
+<div id="terminal" class="terminal"></div>
+<div class="terminal-input-row">
+    <span class="terminal-prompt">$</span>
+    <input id="term-input" class="terminal-input" type="text"
+        placeholder='kpn run coder "hello world in python"'
+        spellcheck="false" autocomplete="off">
+    <div id="term-dropdown" class="terminal-dropdown"></div>
+</div>

network-poc/frontend/src/styles/global.css

@@ -0,0 +1,200 @@
+:root {
+    --bg: #0d1117;
+    --panel: #161b22;
+    --text: #c9d1d9;
+    --accent: #58a6ff;
+    --green: #3fb950;
+    --yellow: #d29922;
+    --red: #f85149;
+    --purple: #a371f7;
+    --border: #30363d;
+}
+
+* { box-sizing: border-box; margin: 0; padding: 0; }
+
+body {
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+    font-size: 16px;
+    background: var(--bg);
+    color: var(--text);
+    min-height: 100vh;
+}
+
+.container { max-width: 1600px; margin: 0 auto; padding: 20px 40px; }
+
+/* Tabs */
+.tabs { display: flex; gap: 4px; margin-bottom: 16px; }
+.tab {
+    padding: 10px 20px; border-radius: 6px 6px 0 0; cursor: pointer;
+    border: 1px solid var(--border); border-bottom: none;
+    background: var(--bg); color: #8b949e; font-size: 15px;
+}
+.tab.active { background: var(--panel); color: var(--accent); border-color: var(--border); }
+
+/* Panels */
+.panel { display: none; }
+.panel.active { display: block; }
+
+/* Status bar */
+.status-bar {
+    display: flex; align-items: center; gap: 12px;
+    padding: 10px 16px; background: var(--bg);
+    border: 1px solid var(--border); border-radius: 6px 6px 0 0;
+    font-family: 'Courier New', monospace; font-size: 14px;
+}
+.status-dot {
+    width: 8px; height: 8px; border-radius: 50%; display: inline-block;
+}
+.status-group { display: flex; align-items: center; gap: 6px; }
+.status-separator { color: var(--border); }
+
+/* Terminal */
+.terminal {
+    background: #010409; border: 1px solid var(--border); border-top: none;
+    font-family: 'Courier New', monospace; font-size: 16px;
+    min-height: 400px; max-height: 70vh; overflow-y: auto;
+    padding: 12px 16px;
+}
+.terminal-line { padding: 1px 0; white-space: pre-wrap; word-break: break-word; }
+.terminal-prompt { color: var(--yellow); margin-right: 8px; }
+.terminal-input-row {
+    display: flex; align-items: center; position: relative;
+    background: #0d1117; border: 1px solid var(--accent); border-top: none;
+    border-radius: 0 0 6px 6px; padding: 10px 14px;
+    font-family: 'Courier New', monospace; font-size: 15px;
+    box-shadow: 0 2px 8px rgba(88,166,255,0.1);
+}
+.terminal-input {
+    flex: 1; background: transparent; border: none; outline: none;
+    color: var(--green); font-family: inherit; font-size: 16px;
+}
+.terminal-dropdown {
+    display: none; position: absolute; bottom: 100%; left: 30px;
+    background: var(--panel); border: 1px solid var(--border);
+    border-radius: 6px; max-height: 200px; overflow-y: auto;
+    font-size: 13px; min-width: 200px; z-index: 100;
+    box-shadow: 0 4px 12px rgba(0,0,0,0.4);
+}
+.dd-item {
+    padding: 6px 12px; cursor: pointer; color: var(--text);
+    white-space: nowrap; border-bottom: 1px solid #21262d;
+}
+.dd-item:hover, .dd-item.active { background: var(--border); color: var(--accent); }
+
+/* Pipeline progress */
+.pipeline-bar {
+    display: none; padding: 8px 14px; background: var(--bg);
+    border: 1px solid var(--border); border-top: none;
+    font-family: 'Courier New', monospace; font-size: 12px;
+    overflow-x: auto; white-space: nowrap;
+}
+
+/* Project card */
+.project-card {
+    margin: 8px 0; border: 1px solid var(--border);
+    border-radius: 6px; background: var(--panel); overflow: hidden;
+}
+.project-header {
+    display: flex; align-items: center; justify-content: space-between;
+    padding: 8px 12px; background: var(--bg); border-bottom: 1px solid var(--border);
+}
+.project-tabs { display: flex; gap: 2px; padding: 6px 8px 0; background: var(--bg); }
+.project-tab {
+    padding: 4px 10px; cursor: pointer; border-radius: 4px 4px 0 0;
+    font-size: 12px; color: #8b949e;
+}
+.project-tab.active { background: var(--panel); color: var(--accent); border: 1px solid var(--border); border-bottom: none; }
+
+/* Buttons */
+.btn {
+    padding: 2px 10px; border-radius: 4px;
+    border: 1px solid var(--border); background: var(--panel);
+    font-size: 12px; font-family: inherit; cursor: pointer;
+}
+.btn-accent { color: var(--accent); }
+.btn-green { color: var(--green); border-color: var(--green); }
+.btn-red { color: var(--red); border-color: var(--red); }
+.btn-muted { color: #8b949e; background: none; }
+
+/* Code display */
+.code-block {
+    font-family: 'Courier New', monospace; background: #010409;
+    border: 1px solid var(--border); border-radius: 6px;
+    padding: 14px; font-size: 13px; line-height: 1.6;
+    white-space: pre-wrap; overflow-x: auto; max-height: 400px; overflow-y: auto;
+}
+.code-block .hljs { background: transparent; padding: 0; }
+
+/* Agent avatars */
+.agent-avatar {
+    background: linear-gradient(145deg, rgba(33,38,45,0.4) 0%, rgba(13,17,23,0.8) 100%);
+    backdrop-filter: blur(12px);
+    border: 1px solid rgba(240,246,252,0.1);
+    border-radius: 14px;
+    padding: 8px 8px 6px;
+    text-align: center;
+    width: 90px;
+    opacity: 0.8;
+    cursor: pointer;
+    transition: all 0.4s cubic-bezier(0.175, 0.885, 0.32, 1.275);
+    box-shadow: 0 4px 8px rgba(0,0,0,0.3);
+}
+.agent-avatar:hover {
+    opacity: 0.85;
+    transform: translateY(-2px) scale(1.02);
+    border-color: rgba(240,246,252,0.3);
+    box-shadow: 0 8px 14px rgba(0,0,0,0.4);
+}
+.agent-avatar img {
+    width: 64px; height: 64px; border-radius: 14px;
+    margin-bottom: 4px; border: 2px solid rgba(240,246,252,0.1);
+    transition: all 0.4s ease; object-fit: cover;
+}
+.agent-avatar .avatar-name {
+    font-size: 11px; color: #8b949e; white-space: nowrap;
+    overflow: hidden; text-overflow: ellipsis;
+}
+.agent-avatar.active {
+    opacity: 1;
+    transform: translateY(-8px) scale(1.05);
+    border-color: var(--accent);
+    background: linear-gradient(145deg, rgba(88,166,255,0.15) 0%, rgba(13,17,23,0.9) 100%);
+    box-shadow: 0 16px 24px rgba(0,0,0,0.5), 0 0 20px rgba(88,166,255,0.3);
+    z-index: 2;
+}
+.agent-avatar.active img {
+    border-color: var(--accent);
+    box-shadow: 0 0 25px rgba(88,166,255,0.8);
+}
+
+/* Settings */
+.settings-section {
+    margin-bottom: 24px; padding: 16px; background: var(--panel);
+    border: 1px solid var(--border); border-radius: 6px;
+}
+.settings-title { color: #e6edf3; font-size: 15px; margin-bottom: 4px; }
+.settings-desc { color: #8b949e; font-size: 13px; margin-bottom: 12px; }
+.settings-label { color: var(--text); font-size: 13px; display: block; margin-bottom: 4px; }
+.settings-val { color: var(--accent); font-weight: 600; float: right; }
+.settings-hint { color: #8b949e; font-size: 11px; margin-top: 2px; }
+.settings-textarea {
+    width: 100%; background: var(--bg); color: var(--text);
+    border: 1px solid var(--border); border-radius: 4px;
+    padding: 8px; font-size: 13px; font-family: 'Courier New', monospace;
+    resize: vertical;
+}
+.settings-select {
+    width: 100%; background: var(--bg); color: var(--text);
+    border: 1px solid var(--border); border-radius: 4px;
+    padding: 8px; font-size: 13px;
+}
+.settings-slider {
+    width: 100%; accent-color: var(--accent);
+}
+.settings-grid {
+    display: grid; grid-template-columns: 1fr 1fr; gap: 16px;
+}
+
+/* Animations */
+@keyframes blink { 0%,100% { opacity:1 } 50% { opacity:0 } }
+@keyframes spin { to { transform: rotate(360deg) } }

network-poc/frontend/tsconfig.json

@@ -0,0 +1 @@
+{ "extends": "astro/tsconfigs/strict" }

network-poc/hub/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "hub"
-version = "0.2.0"
+version = "0.3.1"
 edition = "2024"
 
 [dependencies]
@@ -16,3 +16,4 @@ futures = "0.3"
 rusqlite = { version = "0.31", features = ["bundled"] }
 chrono = "0.4"
 base64 = "0.22"
+reqwest = { version = "0.12", features = ["json"] }

network-poc/hub/src/db.rs

@@ -26,6 +26,29 @@ impl NodeDb {
                 INSERT INTO _schema_version VALUES (2);
             ");
         }
+        if version < 3 {
+            let _ = conn.execute_batch("
+                CREATE TABLE IF NOT EXISTS agents (
+                    id TEXT PRIMARY KEY,
+                    name TEXT NOT NULL,
+                    avatar TEXT NOT NULL DEFAULT '/avatars/kipina_notext.png',
+                    role TEXT NOT NULL DEFAULT 'coder',
+                    model TEXT NOT NULL DEFAULT 'qwen2.5-coder:7b',
+                    color TEXT NOT NULL DEFAULT '#3fb950',
+                    docs TEXT,
+                    prompt TEXT NOT NULL DEFAULT '',
+                    temperature REAL DEFAULT 0.7,
+                    top_k INTEGER DEFAULT 40,
+                    max_tokens INTEGER DEFAULT 512,
+                    repetition_penalty REAL DEFAULT 1.15,
+                    is_default BOOLEAN DEFAULT 0,
+                    created_at TEXT NOT NULL,
+                    updated_at TEXT NOT NULL
+                );
+                DELETE FROM _schema_version;
+                INSERT INTO _schema_version VALUES (3);
+            ");
+        }
 
         conn.execute_batch("
             CREATE TABLE IF NOT EXISTS node_sessions (
@@ -279,6 +302,82 @@ impl NodeDb {
         })
     }
 
+    // ── Agents CRUD ──
+
+    pub fn upsert_agent(&self, agent: &serde_json::Value) -> Result<(), String> {
+        let conn = self.conn.lock().unwrap_or_else(|e| e.into_inner());
+        let now = chrono::Utc::now().to_rfc3339();
+        let id = agent.get("id").and_then(|v| v.as_str()).ok_or("id puuttuu")?;
+        let name = agent.get("name").and_then(|v| v.as_str()).ok_or("name puuttuu")?;
+        conn.execute(
+            "INSERT INTO agents (id, name, avatar, role, model, color, docs, prompt,
+                temperature, top_k, max_tokens, repetition_penalty, is_default, created_at, updated_at)
+             VALUES (?1,?2,?3,?4,?5,?6,?7,?8,?9,?10,?11,?12,?13,?14,?14)
+             ON CONFLICT(id) DO UPDATE SET
+                name=?2, avatar=?3, role=?4, model=?5, color=?6, docs=?7, prompt=?8,
+                temperature=?9, top_k=?10, max_tokens=?11, repetition_penalty=?12, updated_at=?14",
+            params![
+                id, name,
+                agent.get("avatar").and_then(|v| v.as_str()).unwrap_or("/avatars/kipina_notext.png"),
+                agent.get("role").and_then(|v| v.as_str()).unwrap_or("coder"),
+                agent.get("model").and_then(|v| v.as_str()).unwrap_or("qwen2.5-coder:7b"),
+                agent.get("color").and_then(|v| v.as_str()).unwrap_or("#3fb950"),
+                agent.get("docs").and_then(|v| v.as_str()),
+                agent.get("prompt").and_then(|v| v.as_str()).unwrap_or(""),
+                agent.get("temperature").and_then(|v| v.as_f64()).unwrap_or(0.7),
+                agent.get("top_k").and_then(|v| v.as_u64()).unwrap_or(40) as i64,
+                agent.get("max_tokens").and_then(|v| v.as_u64()).unwrap_or(512) as i64,
+                agent.get("repetition_penalty").and_then(|v| v.as_f64()).unwrap_or(1.15),
+                agent.get("is_default").and_then(|v| v.as_bool()).unwrap_or(false),
+                now,
+            ],
+        ).map_err(|e| format!("Agent upsert: {}", e))?;
+        Ok(())
+    }
+
+    pub fn get_agents(&self) -> Vec<serde_json::Value> {
+        let conn = self.conn.lock().unwrap_or_else(|e| e.into_inner());
+        let mut stmt = conn.prepare(
+            "SELECT id, name, avatar, role, model, color, docs, prompt,
+                    temperature, top_k, max_tokens, repetition_penalty, is_default,
+                    created_at, updated_at
+             FROM agents ORDER BY is_default DESC, name"
+        ).unwrap();
+
+        stmt.query_map([], |row| {
+            Ok(serde_json::json!({
+                "id": row.get::<_, String>(0)?,
+                "name": row.get::<_, String>(1)?,
+                "avatar": row.get::<_, String>(2)?,
+                "role": row.get::<_, String>(3)?,
+                "model": row.get::<_, String>(4)?,
+                "color": row.get::<_, String>(5)?,
+                "docs": row.get::<_, Option<String>>(6)?,
+                "prompt": row.get::<_, String>(7)?,
+                "temperature": row.get::<_, f64>(8)?,
+                "top_k": row.get::<_, i64>(9)?,
+                "max_tokens": row.get::<_, i64>(10)?,
+                "repetition_penalty": row.get::<_, f64>(11)?,
+                "is_default": row.get::<_, bool>(12)?,
+                "created_at": row.get::<_, String>(13)?,
+                "updated_at": row.get::<_, String>(14)?,
+            }))
+        }).unwrap().filter_map(|r| r.ok()).collect()
+    }
+
+    pub fn delete_agent(&self, id: &str) -> Result<(), String> {
+        let conn = self.conn.lock().unwrap_or_else(|e| e.into_inner());
+        let deleted = conn.execute(
+            "DELETE FROM agents WHERE id = ?1 AND is_default = 0",
+            params![id],
+        ).map_err(|e| format!("Agent delete: {}", e))?;
+        if deleted == 0 {
+            Err("Agenttia ei löydy tai se on oletusagentti".to_string())
+        } else {
+            Ok(())
+        }
+    }
+
     pub fn insert_pair_result(
         &self,
         node_id: u64,

network-poc/hub/src/main.rs

@@ -34,11 +34,12 @@ struct AppState {
     total_tasks: Mutex<u64>,
     stats_tx: broadcast::Sender<String>,
     node_channels: tokio::sync::RwLock<HashMap<u64, tokio::sync::mpsc::UnboundedSender<String>>>, // Kohdennettu reititys
-    pending_consensus: tokio::sync::RwLock<HashMap<String, Vec<serde_json::Value>>>, // Proof of Compute -konsensus
+    _pending_consensus: tokio::sync::RwLock<HashMap<String, Vec<serde_json::Value>>>, // Proof of Compute -konsensus
     feature_flags: tokio::sync::RwLock<HashMap<String, bool>>, // Tuntee TODO.md:n ruksit lennosta
     ip_connections: Mutex<HashMap<IpAddr, u32>>,
     node_ips: Mutex<HashMap<u64, IpAddr>>,
     node_tasks: Mutex<HashMap<u64, String>>,  // node_id → selected_task
+    node_types: Mutex<HashMap<u64, String>>,  // node_id → "native" | "browser"
     node_busy: Mutex<std::collections::HashSet<u64>>,  // Solmut joilla on aktiivinen tehtävä
     pending_task_ids: Mutex<std::collections::HashSet<String>>,  // Hubin jakamat task_id:t (gamification-validointi)
     api_rate_limits: Mutex<HashMap<IpAddr, (std::time::Instant, u32)>>,  // IP → (ikkuna-alku, pyyntömäärä)
@@ -255,11 +256,12 @@ async fn main() {
         total_tasks: Mutex::new(0),
         stats_tx: stats_tx.clone(),
         node_channels: tokio::sync::RwLock::new(HashMap::new()),
-        pending_consensus: tokio::sync::RwLock::new(HashMap::new()),
+        _pending_consensus: tokio::sync::RwLock::new(HashMap::new()),
         feature_flags: tokio::sync::RwLock::new(HashMap::new()),
         ip_connections: Mutex::new(HashMap::new()),
         node_ips: Mutex::new(HashMap::new()),
         node_tasks: Mutex::new(HashMap::new()),
+        node_types: Mutex::new(HashMap::new()),
         node_busy: Mutex::new(std::collections::HashSet::new()),
         pending_task_ids: Mutex::new(std::collections::HashSet::new()),
         api_rate_limits: Mutex::new(HashMap::new()),
@@ -328,15 +330,6 @@ async fn main() {
             let idx = (rng_state as usize) % pairs.len();
             let (en, fi) = pairs[idx];
 
-            // Tokenisointiparit
-            let pair_msg = serde_json::json!({
-                "type": "pair_task",
-                "en": en,
-                "fi": fi,
-            });
-            let _ = state_for_task.stats_tx.send(pair_msg.to_string());
-
-            // LLM-promptit
             let llm_prompts = vec![
                 "Tell me a short joke.",
                 "What is WebGPU in one sentence?",
@@ -346,33 +339,39 @@ async fn main() {
             ];
             let llm_idx = (rng_state as usize / 7) % llm_prompts.len();
 
-            // SmolLM-prompt
+            // Smart Routing: Lähetetään vain niille, jotka valittuna ja idle
-            let smollm_msg = serde_json::json!({
+            let mut sends = Vec::new();
-                "type": "llm_prompt",
+            {
-                "prompt": llm_prompts[llm_idx],
+                let channels = state_for_task.node_channels.read().await;
-                "model": "smollm-135m",
+                let tasks = state_for_task.node_tasks.lock().unwrap();
-            });
+                let mut busy = state_for_task.node_busy.lock().unwrap();
-            let _ = state_for_task.stats_tx.send(smollm_msg.to_string());
 
-            // Qwen-prompt (sama prompti, eri malli-tagi)
+                for (node_id, task) in tasks.iter() {
-            let qwen_msg = serde_json::json!({
+                    if !busy.contains(node_id) {
-                "type": "llm_prompt",
+                        // Vapaa node -> lähetetään oikea tehtävä
-                "prompt": llm_prompts[llm_idx],
+                        let msg = match task.as_str() {
-                "model": "qwen-05b",
+                            "tokenize" => Some(serde_json::json!({ "type": "pair_task", "en": en, "fi": fi })),
-            });
+                            "smollm-135m" => Some(serde_json::json!({ "type": "llm_prompt", "prompt": llm_prompts[llm_idx], "model": "smollm-135m" })),
-            let _ = state_for_task.stats_tx.send(qwen_msg.to_string());
+                            "qwen-05b" => Some(serde_json::json!({ "type": "llm_prompt", "prompt": llm_prompts[llm_idx], "model": "qwen-05b" })),
+                            "phi3-mini" => Some(serde_json::json!({ "type": "llm_prompt", "prompt": llm_prompts[llm_idx], "model": "phi3-mini" })),
+                            _ => None, // Coder ja viewer ei saa auto-tehtäviä
+                        };
 
-            // Phi-3 prompt
+                        if let Some(payload) = msg {
-            let phi3_msg = serde_json::json!({
+                            if let Some(ch) = channels.get(node_id) {
-                "type": "llm_prompt",
+                                sends.push((ch.clone(), payload.to_string()));
-                "prompt": llm_prompts[llm_idx],
+                                busy.insert(*node_id);
-                "model": "phi3-mini",
+                            }
-            });
+                        }
-            let _ = state_for_task.stats_tx.send(phi3_msg.to_string());
+                    }
+                }
+            }
 
-            // Coder ei saa automaattisia tehtäviä — vain käyttäjän user_text
+            for (ch, msg_str) in sends {
+                let _ = ch.send(msg_str);
+            }
 
-            tracing::debug!("Tehtävät lähetetty: pair + smollm + qwen + phi3");
+            // tracing::debug!("Tehtävät lähetetty reititetysti idle-nodeille");
         }
     });
 
@@ -382,9 +381,14 @@ async fn main() {
         .route("/api/pairs", get(api_pairs))
         .route("/api/stats", get(api_stats))
         .route("/api/v1/chat/completions", axum::routing::post(api_chat_completions))
+        .route("/api/v1/model", axum::routing::post(api_change_model))
+        .route("/api/v1/hardware", get(api_hardware))
+        .route("/api/v1/ollama/tags", get(api_ollama_tags))
+        .route("/api/v1/agents", get(api_get_agents).post(api_upsert_agent))
+        .route("/api/v1/agents/:id", axum::routing::delete(api_delete_agent))
         .route("/admin", get(admin_page))
         .nest_service("/", {
-            let static_dir = std::env::var("STATIC_DIR").unwrap_or_else(|_| "../static".to_string());
+            let static_dir = std::env::var("STATIC_DIR").unwrap_or_else(|_| "../frontend/dist".to_string());
             ServeDir::new(&static_dir).fallback(ServeFile::new(format!("{}/index.html", static_dir)))
         })
         .with_state(state);
@@ -457,6 +461,34 @@ fn admin_unauthorized() -> axum::response::Response {
         .unwrap()
 }
 
+// ── Agents API ──
+
+async fn api_get_agents(
+    axum::extract::State(state): axum::extract::State<Arc<AppState>>,
+) -> axum::response::Response {
+    axum::Json(state.db.get_agents()).into_response()
+}
+
+async fn api_upsert_agent(
+    axum::extract::State(state): axum::extract::State<Arc<AppState>>,
+    axum::Json(payload): axum::Json<serde_json::Value>,
+) -> axum::response::Response {
+    match state.db.upsert_agent(&payload) {
+        Ok(()) => axum::Json(serde_json::json!({"ok": true})).into_response(),
+        Err(e) => (axum::http::StatusCode::BAD_REQUEST, e).into_response(),
+    }
+}
+
+async fn api_delete_agent(
+    axum::extract::State(state): axum::extract::State<Arc<AppState>>,
+    axum::extract::Path(id): axum::extract::Path<String>,
+) -> axum::response::Response {
+    match state.db.delete_agent(&id) {
+        Ok(()) => axum::Json(serde_json::json!({"ok": true})).into_response(),
+        Err(e) => (axum::http::StatusCode::BAD_REQUEST, e).into_response(),
+    }
+}
+
 async fn admin_page(headers: axum::http::HeaderMap) -> axum::response::Response {
     if !check_admin_auth(&headers) { return admin_unauthorized(); }
     axum::response::Html(ADMIN_HTML).into_response()
@@ -470,7 +502,12 @@ async fn ws_handler(
 ) -> impl IntoResponse {
     // Origin-tarkistus — estää cross-site WebSocket hijackingin
     if let Some(origin) = headers.get("origin").and_then(|v| v.to_str().ok()) {
-        if !ALLOWED_ORIGINS.iter().any(|&allowed| origin == allowed) {
+        let is_allowed = ALLOWED_ORIGINS.iter().any(|&allowed| origin == allowed)
+            || origin.starts_with("http://192.168.")
+            || origin.starts_with("http://10.")
+            || origin.starts_with("http://172."); // LAN-avaruudet
+            
+        if !is_allowed {
             tracing::warn!("Estetty yhteys väärällä originilla: {}", origin);
             return (
                 axum::http::StatusCode::FORBIDDEN,
@@ -486,16 +523,19 @@ async fn ws_handler(
         .and_then(|s| s.trim().parse::<IpAddr>().ok())
         .unwrap_or_else(|| addr.ip());
 
-    // Max yhteyttä per IP: jokainen selain tarvitsee 2 (UI + coder-node)
+    // Max yhteyttä per IP (ei rajoiteta localhost/127.0.0.1)
     {
-        let conns = state.ip_connections.lock().unwrap();
+        let is_local = ip.is_loopback();
-        let count = conns.get(&ip).copied().unwrap_or(0);
+        if !is_local {
-        if count >= 10 {
+            let conns = state.ip_connections.lock().unwrap();
-            tracing::warn!("IP {} ylitti yhteysrajan ({}/10) — estetty", ip, count);
+            let count = conns.get(&ip).copied().unwrap_or(0);
-            return (
+            if count >= 20 {
-                axum::http::StatusCode::TOO_MANY_REQUESTS,
+                tracing::warn!("IP {} ylitti yhteysrajan ({}/20) — estetty", ip, count);
-                "Max 10 yhteyttä per IP",
+                return (
-            ).into_response();
+                    axum::http::StatusCode::TOO_MANY_REQUESTS,
+                    "Max 20 yhteyttä per IP",
+                ).into_response();
+            }
         }
     }
 
@@ -656,6 +696,18 @@ async fn handle_socket(socket: WebSocket, state: Arc<AppState>, ip: IpAddr) {
                 let allocated = json.get("allocated_gb").and_then(|v| v.as_u64()).unwrap_or(4) as u32;
                 let node_type = json.get("node_type").and_then(|v| v.as_str()).unwrap_or("browser");
 
+                // API-avain vaaditaan natiivisolmuilta (ei selaimilta)
+                if node_type == "native" {
+                    let required_key = std::env::var("NODE_API_KEY").unwrap_or_default();
+                    if !required_key.is_empty() {
+                        let provided_key = json.get("api_key").and_then(|v| v.as_str()).unwrap_or("");
+                        if provided_key != required_key {
+                            tracing::warn!("Solmu {} ({}) hylätty: virheellinen API-avain", node_id, ip);
+                            break; // Suljetaan WebSocket
+                        }
+                    }
+                }
+
                 {
                     let mut map = state.nodes_vram.lock().unwrap();
                     map.insert(node_id, allocated);
@@ -677,6 +729,7 @@ async fn handle_socket(socket: WebSocket, state: Arc<AppState>, ip: IpAddr) {
                     state.db.insert_session(node_id, &ip.to_string(), node_type, &json);
                 }
                 state.node_tasks.lock().unwrap().insert(node_id, selected_task);
+                state.node_types.lock().unwrap().insert(node_id, node_type.to_string());
 
                 if node_type == "native" {
                     let sys = json.get("system");
@@ -735,6 +788,7 @@ async fn handle_socket(socket: WebSocket, state: Arc<AppState>, ip: IpAddr) {
             }
             broadcast_stats(&state).await;
         } else if msg_type == "pair_done" {
+            state.node_busy.lock().unwrap().remove(&node_id);
             {
                 let mut json = json; // Siirretään omistajuus muokkausta varten
                 if let Some(obj) = json.as_object_mut() {
@@ -934,6 +988,7 @@ async fn handle_socket(socket: WebSocket, state: Arc<AppState>, ip: IpAddr) {
         ips.remove(&node_id);
         vram.remove(&node_id);
     }
+    state.node_types.lock().unwrap().remove(&node_id);
     tracing::info!("Solmu {} ({}) poistui verkosta.", node_id, ip);
     broadcast_stats(&state).await;
     sender_task.abort();
@@ -943,6 +998,8 @@ struct ChatCompletionRequest {
     model: String,
     prompt: String,
     task_id: String,
+    #[serde(default)]
+    max_tokens: Option<u64>,
 }
 
 #[derive(serde::Serialize)]
@@ -952,6 +1009,78 @@ struct ChatCompletionResponse {
     tokens_generated: u64,
 }
 
+async fn api_ollama_tags() -> axum::response::Response {
+    let ollama_url = std::env::var("OLLAMA_URL").unwrap_or_else(|_| "http://ollama:11434".to_string());
+    match reqwest::get(format!("{}/api/tags", ollama_url)).await {
+        Ok(resp) => {
+            if let Ok(body) = resp.json::<serde_json::Value>().await {
+                axum::Json(body).into_response()
+            } else {
+                axum::Json(serde_json::json!({ "models": [] })).into_response()
+            }
+        }
+        Err(_) => axum::Json(serde_json::json!({ "models": [] })).into_response(),
+    }
+}
+
+async fn api_hardware(
+    axum::extract::State(state): axum::extract::State<Arc<AppState>>,
+) -> axum::response::Response {
+    // Etsitään natiivisolmun GPU-tiedot sessiosta
+    let sessions = state.db.get_sessions(50);
+    let native = sessions.iter().find(|s| {
+        s.get("node_type").and_then(|v| v.as_str()) == Some("native")
+    });
+
+    let (mut vram_mb, mut gpu_name, ram_mb) = if let Some(s) = native {
+        let gpus = s.get("gpus").and_then(|v| v.as_array());
+        let gpu = gpus.and_then(|g| g.first());
+        let vram = gpu.and_then(|g| g.get("vram_total_mb")).and_then(|v| v.as_u64()).unwrap_or(0);
+        let name = gpu.and_then(|g| g.get("name")).and_then(|v| v.as_str()).unwrap_or("").to_string();
+        let ram = s.get("system").and_then(|v| v.get("ram_total_mb")).and_then(|v| v.as_u64()).unwrap_or(0);
+        (vram, name, ram)
+    } else {
+        (0, String::new(), 0)
+    };
+
+    // Fallback: kysytään Ollamalta onko malleja ladattu (= Ollama on käynnissä)
+    if vram_mb == 0 {
+        let ollama_url = std::env::var("OLLAMA_URL").unwrap_or_else(|_| "http://ollama:11434".to_string());
+        if let Ok(resp) = reqwest::get(format!("{}/api/tags", ollama_url)).await {
+            if let Ok(body) = resp.json::<serde_json::Value>().await {
+                let models = body["models"].as_array().map(|a| a.len()).unwrap_or(0);
+                if models > 0 {
+                    gpu_name = "Ollama (GPU/CPU)".to_string();
+                    // Natiivisolmun RAM fallbackina
+                    vram_mb = if ram_mb > 0 { ram_mb } else { 0 };
+                }
+            }
+        }
+    }
+
+    if gpu_name.is_empty() { gpu_name = "ei natiivisolmua".to_string(); }
+
+    axum::Json(serde_json::json!({
+        "gpu_name": gpu_name,
+        "vram_mb": vram_mb,
+        "ram_mb": ram_mb,
+    })).into_response()
+}
+
+async fn api_change_model(
+    axum::extract::State(state): axum::extract::State<Arc<AppState>>,
+    axum::Json(payload): axum::Json<serde_json::Value>,
+) -> axum::response::Response {
+    let model = payload.get("model").and_then(|v| v.as_str()).unwrap_or("");
+    if model.is_empty() {
+        return (axum::http::StatusCode::BAD_REQUEST, "model puuttuu").into_response();
+    }
+    tracing::info!("Mallin vaihto: {}", model);
+    let msg = serde_json::json!({ "type": "change_model", "model": model });
+    let _ = state.stats_tx.send(msg.to_string());
+    axum::Json(serde_json::json!({ "status": "ok", "model": model })).into_response()
+}
+
 async fn api_chat_completions(
     axum::extract::State(state): axum::extract::State<Arc<AppState>>,
     ConnectInfo(addr): ConnectInfo<SocketAddr>,
@@ -966,105 +1095,71 @@ async fn api_chat_completions(
             *entry = (now, 1); // Uusi ikkuna
         } else {
             entry.1 += 1;
-            if entry.1 > 10 {
+            if entry.1 > 30 {
                 return (axum::http::StatusCode::TOO_MANY_REQUESTS, "Liian monta pyyntöä — yritä minuutin kuluttua").into_response();
             }
         }
     }
 
-    // Etsitään vapaa tai varattu solmu, joka vastaa pyydettyä mallia
+    // Etsitään vapaa solmu — priorisoidaan natiivisolmut (GPU) selaimen edelle
-    let (target_node_free, target_node_any, total_matching) = {
+    let (target_node, _total_matching) = {
         let tasks = state.node_tasks.lock().unwrap();
-        let busy = state.node_busy.lock().unwrap();
+        let _busy = state.node_busy.lock().unwrap();
+        let node_types = state.node_types.lock().unwrap();
         let matching: Vec<u64> = tasks.iter().filter(|(_, task)| {
-            if payload.model == "qwen-coder" {
+            // Eksakti match tai qwen-perheen yhteensopivuus (selain: qwen-coder-05b, natiivi: qwen2.5-coder:7b)
-                task.starts_with("qwen-coder")
+            let req_model = payload.model.to_lowercase();
+            let node_task = task.to_lowercase();
+            if req_model.starts_with("qwen") {
+                node_task.starts_with("qwen")
+            } else if req_model.starts_with("phi") {
+                node_task.starts_with("phi")
             } else {
                 **task == payload.model
             }
         }).map(|(k, _)| *k).collect();
-        let free = matching.iter().find(|id| !busy.contains(id)).copied();
+        // Etsitään mikä tahansa matchaava solmu (natiivi priorisoidaan)
-        let any = matching.first().copied();
+        let native = matching.iter().find(|id| {
-        (free, any, matching.len())
+            node_types.get(id).map(|t| t == "native").unwrap_or(false)
+        }).copied();
+        let any = native.or_else(|| matching.first().copied());
+        (any, matching.len())
     };
 
-    // Broadcastataan reititystila UI:lle
     let task_id = payload.task_id.clone();
 
-    if target_node_any.is_none() {
+    let target_node_id = match target_node {
-        // Ei yhtään solmua tälle mallille
+        Some(id) => id,
-        return (axum::http::StatusCode::SERVICE_UNAVAILABLE, "Ei solmua tälle mallille (käynnistä malli selaimessa)").into_response();
+        None => {
-    }
+            return (axum::http::StatusCode::SERVICE_UNAVAILABLE, "Ei solmua tälle mallille (käynnistä malli selaimessa)").into_response();
+        }
+    };
 
-    let target_node_id;
+    // Reititystila UI:lle
-    if let Some(free_id) = target_node_free {
+    {
-        // Vapaa solmu löytyi — reititetään suoraan
-        target_node_id = free_id;
-        let node_type = if state.node_tasks.lock().unwrap().get(&free_id).map(|t| t.contains("native")).unwrap_or(false) { "natiivi" } else { "selain" };
         let routing_msg = serde_json::json!({
             "type": "task_routed",
             "task_id": task_id,
-            "node_id": free_id,
+            "node_id": target_node_id,
-            "node_type": node_type,
             "status": "routed",
-            "message": format!("Reititetty solmulle #{}", free_id),
+            "message": format!("Reititetty solmulle #{}", target_node_id),
         });
         let _ = state.stats_tx.send(routing_msg.to_string());
-    } else {
+    }
-        // Kaikki solmut varattuja — odotetaan vapautumista (max 30s)
-        let queue_msg = serde_json::json!({
-            "type": "task_routed",
-            "task_id": task_id,
-            "status": "queued",
-            "message": format!("Kaikki {} solmua varattuja — odotetaan vapautumista...", total_matching),
-        });
-        let _ = state.stats_tx.send(queue_msg.to_string());
-
-        // Pollaa busy-tilaa 500ms välein, max 30s
-        let mut waited = 0u32;
-        loop {
-            tokio::time::sleep(std::time::Duration::from_millis(500)).await;
-            waited += 500;
-            let free = {
-                let tasks = state.node_tasks.lock().unwrap();
-                let busy = state.node_busy.lock().unwrap();
-                tasks.iter().find(|(node_id, task)| {
-                    let model_match = if payload.model == "qwen-coder" {
-                        *task == "qwen-coder-05b" || *task == "qwen-coder"
-                    } else {
-                        **task == payload.model
-                    };
-                    model_match && !busy.contains(node_id)
-                }).map(|(k, _)| *k)
-            };
-            if let Some(id) = free {
-                target_node_id = id;
-                let routing_msg = serde_json::json!({
-                    "type": "task_routed",
-                    "task_id": task_id,
-                    "node_id": id,
-                    "status": "routed",
-                    "message": format!("Solmu #{} vapautui — reititetään ({:.1}s jonossa)", id, waited as f64 / 1000.0),
-                });
-                let _ = state.stats_tx.send(routing_msg.to_string());
-                break;
-            }
-            if waited >= 30000 {
-                return (axum::http::StatusCode::SERVICE_UNAVAILABLE, "Aikakatkaisu: kaikki solmut varattuja 30s ajan").into_response();
-            }
-        }
-    };
 
     // Merkitään solmu varatuksi ja task_id jaetuksi
     state.node_busy.lock().unwrap().insert(target_node_id);
     state.pending_task_ids.lock().unwrap().insert(payload.task_id.clone());
 
-    let msg = serde_json::json!({
+    let mut msg = serde_json::json!({
         "type": "llm_prompt",
         "prompt": payload.prompt,
         "model": payload.model,
         "task_id": payload.task_id,
     });
+    if let Some(mt) = payload.max_tokens {
+        msg.as_object_mut().unwrap().insert("max_tokens".to_string(), serde_json::json!(mt));
+    }
 
     // Odotuskanava valmiiksi (solmu palauttaa tuloksen stats_tx kautta)
     let mut rx = state.stats_tx.subscribe();

network-poc/install.sh

@@ -0,0 +1,59 @@
+#!/bin/bash
+# Kipinä Agentic Studio — asennusskripti (Debian/Ubuntu)
+set -e
+
+echo "=== Kipinä Agentic Studio — Asennus ==="
+echo ""
+
+# Tarkistetaan käyttöjärjestelmä
+if [ ! -f /etc/debian_version ]; then
+    echo "⚠ Tämä skripti on suunniteltu Debian/Ubuntu-järjestelmille."
+    echo "  Muilla jakeluilla voit asentaa riippuvuudet manuaalisesti."
+    read -p "  Jatketaanko? (k/e) " -n 1 -r; echo
+    [[ $REPLY =~ ^[Kk]$ ]] || exit 1
+fi
+
+echo "[1/6] Päivitetään pakettilistaus..."
+sudo apt-get update -qq
+
+echo "[2/6] Asennetaan peruspaketteja..."
+sudo apt-get install -y -qq curl git build-essential pkg-config libssl-dev
+
+# Rust
+if command -v rustc &>/dev/null; then
+    echo "[3/6] Rust löytyi: $(rustc --version)"
+else
+    echo "[3/6] Asennetaan Rust..."
+    curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
+    source "$HOME/.cargo/env"
+fi
+
+# Node.js (Astro-frontend vaatii)
+if command -v node &>/dev/null; then
+    echo "[4/6] Node.js löytyi: $(node --version)"
+else
+    echo "[4/6] Asennetaan Node.js 22..."
+    curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash -
+    sudo apt-get install -y -qq nodejs
+fi
+
+# Ollama
+if command -v ollama &>/dev/null; then
+    echo "[5/6] Ollama löytyi"
+else
+    echo "[5/6] Asennetaan Ollama..."
+    curl -fsSL https://ollama.ai/install.sh | sh
+fi
+
+# Malli
+echo "[6/6] Ladataan kielimalli (qwen2.5-coder:3b)..."
+ollama pull qwen2.5-coder:3b
+
+echo ""
+echo "=== Asennus valmis! ==="
+echo ""
+echo "Käynnistä:"
+echo "  cd $(pwd)"
+echo "  ./network-poc/local.sh"
+echo ""
+echo "Avaa selaimessa: http://localhost:3000"

network-poc/local.sh

@@ -0,0 +1,37 @@
+#!/bin/bash
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+echo "=== Kipinä Studio Local Development ==="
+
+# Frontend
+echo "[1/3] Rakennetaan frontend..."
+cd "$SCRIPT_DIR/frontend"
+[ -d node_modules ] || npm install --silent
+npm run build --silent 2>&1 | tail -1
+
+# Hub
+echo "[2/3] Käynnistetään hub..."
+cd "$SCRIPT_DIR/hub"
+cargo run &
+HUB_PID=$!
+sleep 3
+
+# Native-node (jos Ollama on käynnissä)
+if curl -s http://localhost:11434/api/tags >/dev/null 2>&1; then
+    echo "[3/3] Ollama löytyi — käynnistetään native-node..."
+    cd "$SCRIPT_DIR/native-node"
+    HUB_URL=ws://localhost:3000/ws cargo run --no-default-features &
+    NODE_PID=$!
+    echo "      Native-node PID: $NODE_PID"
+else
+    echo "[3/3] Ollama ei käynnissä — käytetään selaimen Wasm-laskentaa"
+    echo "      Nopeampi: ollama serve & ollama pull qwen2.5-coder:7b && ./local.sh"
+fi
+
+echo ""
+echo "=== http://localhost:3000 ==="
+echo "    Ctrl+C pysäyttää"
+
+# Odotetaan hub-prosessia
+wait $HUB_PID

network-poc/native-node/Cargo.toml

@@ -1,8 +1,12 @@
 [package]
 name = "native-node"
-version = "0.1.0"
+version = "0.2.2"
 edition = "2024"
 
+[features]
+default = ["gpu-detect"]
+gpu-detect = ["nvml-wrapper", "wgpu"]
+
 [dependencies]
 tokio = { version = "1.36", features = ["full"] }
 tokio-tungstenite = { version = "0.21", features = ["native-tls"] }
@@ -10,12 +14,8 @@ futures-util = "0.3"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 sysinfo = "0.30"
-nvml-wrapper = "0.10"
+nvml-wrapper = { version = "0.10", optional = true }
-wgpu = "24"
+wgpu = { version = "24", optional = true }
-candle-core = { version = "0.8", features = ["cuda"] }
+reqwest = { version = "0.12", features = ["json"] }
-candle-nn = "0.8"
-candle-transformers = "0.8"
-hf-hub = "0.4"
-tokenizers = "0.19"
 tracing = "0.1"
 tracing-subscriber = { version = "0.3", features = ["env-filter"] }

network-poc/native-node/src/inference.rs

@@ -1,292 +1,166 @@
-use candle_core::{Device, Tensor, DType};
-use candle_nn::VarBuilder;
-use candle_transformers::models::qwen2::{Config as QwenConfig, ModelForCausalLM as QwenModel};
-use hf_hub::{api::sync::Api, Repo, RepoType};
 use std::time::Instant;
-
+use std::cell::RefCell;
-/// Top-k sampling with temperature and repetition penalty
-fn sample_top_k(logits: &Tensor, k: usize, temperature: f64, generated_tokens: &[u32], repetition_penalty: f64, rng_state: &mut u64) -> Result<u32, String> {
-    let mut logits_vec: Vec<f32> = logits.to_vec1::<f32>().map_err(|e| format!("to_vec1: {}", e))?;
-    if logits_vec.is_empty() { return Err("Tyhjä logits".to_string()); }
-
-    // Repetition penalty: rankaisee jo generoituja tokeneita
-    for &token_id in generated_tokens {
-        if (token_id as usize) < logits_vec.len() {
-            let logit = &mut logits_vec[token_id as usize];
-            if *logit > 0.0 {
-                *logit /= repetition_penalty as f32;
-            } else {
-                *logit *= repetition_penalty as f32;
-            }
-        }
-    }
-
-    // Temperature scaling
-    if temperature > 0.0 && temperature != 1.0 {
-        for logit in logits_vec.iter_mut() {
-            *logit /= temperature as f32;
-        }
-    }
-
-    // Top-k: etsitään k suurinta
-    let mut indexed: Vec<(usize, f32)> = logits_vec.iter().enumerate().map(|(i, &v)| (i, v)).collect();
-    indexed.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap_or(std::cmp::Ordering::Equal));
-    indexed.truncate(k);
-
-    if k == 1 || temperature == 0.0 {
-        return Ok(indexed[0].0 as u32);
-    }
-
-    // Softmax top-k:lle
-    let max_logit = indexed[0].1;
-    let exps: Vec<f32> = indexed.iter().map(|x| (x.1 - max_logit).exp()).collect();
-    let sum: f32 = exps.iter().sum();
-    let probs: Vec<f32> = exps.iter().map(|e| e / sum).collect();
-
-    // XorShift64 RNG
-    *rng_state ^= *rng_state << 13;
-    *rng_state ^= *rng_state >> 7;
-    *rng_state ^= *rng_state << 17;
-    let rand_val = (*rng_state % 10000) as f32 / 10000.0;
-
-    let mut cumulative = 0.0;
-    for (i, p) in probs.iter().enumerate() {
-        cumulative += p;
-        if rand_val < cumulative {
-            return Ok(indexed[i].0 as u32);
-        }
-    }
-
-    Ok(indexed[0].0 as u32)
-}
 
 pub struct LlmEngine {
-    tokenizer: tokenizers::Tokenizer,
+    ollama_url: String,
-    model: QwenModel,
+    model: RefCell<String>,
-    device: Device,
+    client: reqwest::Client,
-    eos_token: u32,
 }
 
 impl LlmEngine {
-    pub fn load() -> Result<Self, String> {
+    pub async fn load() -> Result<Self, String> {
-        let device = Device::cuda_if_available(0).map_err(|e| format!("Device: {}", e))?;
+        let model = std::env::var("OLLAMA_MODEL").unwrap_or_else(|_| "qwen2.5-coder:3b".to_string());
-        let device_name = if device.is_cuda() { "CUDA" } else { "CPU" };
-        tracing::info!("LLM device: {}", device_name);
 
-        let dtype = if device.is_cuda() { DType::F16 } else { DType::F32 };
+        let client = reqwest::Client::builder()
+            .timeout(std::time::Duration::from_secs(600))
+            .connect_timeout(std::time::Duration::from_secs(3))
+            .build()
+            .map_err(|e| format!("HTTP client: {}", e))?;
 
-        tracing::info!("Ladataan Qwen2.5-Coder-0.5B-Instruct...");
+        // Jos OLLAMA_URL on asetettu, käytetään sitä suoraan
-        let api = Api::new().map_err(|e| format!("HF API: {}", e))?;
+        let ollama_url = if let Ok(url) = std::env::var("OLLAMA_URL") {
-        let repo = api.repo(Repo::with_revision(
+            tracing::info!("Ollama backend (env): {}", url);
-            "Qwen/Qwen2.5-Coder-0.5B-Instruct".to_string(),
+            url
-            RepoType::Model,
-            "main".to_string(),
-        ));
-
-        let tokenizer_path = repo.get("tokenizer.json").map_err(|e| format!("Tokenizer lataus: {}", e))?;
-        let model_path = repo.get("model.safetensors").map_err(|e| format!("Malli lataus: {}", e))?;
-
-        tracing::info!("Ladataan tokenizer: {:?}", tokenizer_path);
-        let tokenizer = tokenizers::Tokenizer::from_file(&tokenizer_path)
-            .map_err(|e| format!("Tokenizer: {}", e))?;
-
-        let config = QwenConfig {
-            vocab_size: 151936,
-            hidden_size: 896,
-            intermediate_size: 4864,
-            num_hidden_layers: 24,
-            num_attention_heads: 14,
-            num_key_value_heads: 2,
-            max_position_embeddings: 32768,
-            sliding_window: 32768,
-            max_window_layers: 21,
-            tie_word_embeddings: true,
-            rope_theta: 1000000.0,
-            rms_norm_eps: 1e-6,
-            use_sliding_window: false,
-            hidden_act: candle_nn::Activation::Silu,
-        };
-
-        let start = Instant::now();
-        let vb = unsafe {
-            VarBuilder::from_mmaped_safetensors(&[model_path.clone()], dtype, &device)
-                .map_err(|e| format!("VarBuilder: {}", e))?
-        };
-        let model = QwenModel::new(&config, vb).map_err(|e| format!("Malli: {}", e))?;
-        tracing::info!("Malli ladattu ({:.1}s) — {}", start.elapsed().as_secs_f64(), device_name);
-
-        Ok(LlmEngine {
-            tokenizer,
-            model,
-            device,
-            eos_token: 151645,
-        })
-    }
-
-    pub fn generate(&mut self, prompt: &str, max_tokens: usize) -> Result<GenerateResult, String> {
-        // Prefill: aloitetaan vastaus ```-koodiblokkilla → malli jatkaa suoraan koodilla
-        let formatted = format!("<|im_start|>system\nYou are a coding assistant. Respond with ONLY code. No explanations, no markdown, no comments unless asked.<|im_end|>\n<|im_start|>user\n{}<|im_end|>\n<|im_start|>assistant\n```\n", prompt);
-
-        let encoding = self.tokenizer.encode(formatted.as_str(), true)
-            .map_err(|e| format!("Encode: {}", e))?;
-        let input_ids: Vec<u32> = encoding.get_ids().to_vec();
-        let input_len = input_ids.len();
-
-        // Nollataan KV-cache edellisestä promptista
-        self.model.clear_kv_cache();
-
-        // Sampling-parametrit
-        let temperature = 0.7;
-        let top_k = 40;
-        let repetition_penalty = 1.15;
-        let mut rng_state: u64 = std::time::SystemTime::now()
-            .duration_since(std::time::UNIX_EPOCH)
-            .unwrap()
-            .as_nanos() as u64;
-
-        let start = Instant::now();
-
-        // Prefill
-        let input = Tensor::new(input_ids.as_slice(), &self.device)
-            .and_then(|t| t.unsqueeze(0))
-            .map_err(|e| format!("Tensor: {}", e))?;
-
-        let logits = self.model.forward(&input, 0)
-            .map_err(|e| format!("Forward prefill: {}", e))?;
-
-        let logits = logits.squeeze(0).map_err(|e| format!("Squeeze: {}", e))?;
-        let logits = if logits.dims().len() == 2 {
-            let seq_len = logits.dim(0).map_err(|e| format!("Dim: {}", e))?;
-            if seq_len == 0 { return Err("Tyhjä tensori".to_string()); }
-            logits.get(seq_len - 1).map_err(|e| format!("Get: {}", e))?
         } else {
-            logits
+            // Haistellaan Ollamaa tunnetuista osoitteista
-        };
+            let candidates = [
-
+                "http://localhost:11434",
-        let mut generated_text = String::new();
+                "http://127.0.0.1:11434",
-        let mut tokens_generated: usize = 0;
+                "http://ollama:11434",
-        let mut all_tokens: Vec<u32> = Vec::new();
+                "http://host.docker.internal:11434",
-
+            ];
-        let mut next_token = sample_top_k(&logits, top_k, temperature, &all_tokens, repetition_penalty, &mut rng_state)?;
+            let mut found = None;
-
+            for url in &candidates {
-        if next_token != self.eos_token {
+                let probe = reqwest::Client::builder()
-            if let Ok(text) = self.tokenizer.decode(&[next_token], true) {
+                    .connect_timeout(std::time::Duration::from_secs(2))
-                generated_text.push_str(&text);
+                    .build().unwrap_or(client.clone());
-            }
+                if let Ok(resp) = probe.get(format!("{}/api/version", url)).send().await {
-            all_tokens.push(next_token);
+                    if resp.status().is_success() {
-            tokens_generated += 1;
+                        tracing::info!("Ollama löytyi osoitteesta: {}", url);
-        }
+                        found = Some(url.to_string());
-
+                        break;
-        // Autoregressive
-        let mut pos = input_len;
-        for _ in 1..max_tokens {
-            if next_token == self.eos_token { break; }
-
-            let input = Tensor::new(&[next_token], &self.device)
-                .and_then(|t| t.unsqueeze(0))
-                .map_err(|e| format!("Tensor: {}", e))?;
-
-            let logits = self.model.forward(&input, pos)
-                .map_err(|e| format!("Forward pos {}: {}", pos, e))?;
-
-            let logits = logits.squeeze(0).map_err(|e| format!("Squeeze: {}", e))?;
-            let logits = if logits.dims().len() == 2 {
-                let seq_len = logits.dim(0).map_err(|e| format!("Dim: {}", e))?;
-                if seq_len == 0 { break; }
-                logits.get(seq_len - 1).map_err(|e| format!("Get: {}", e))?
-            } else {
-                logits
-            };
-            next_token = sample_top_k(&logits, top_k, temperature, &all_tokens, repetition_penalty, &mut rng_state)?;
-            pos += 1;
-
-            if next_token == self.eos_token { break; }
-
-            if let Ok(text) = self.tokenizer.decode(&[next_token], true) {
-                generated_text.push_str(&text);
-
-                // Stop-sekvenssit: katkaistaan kun malli alkaa selittää
-                let lower = generated_text.to_lowercase();
-                if lower.contains("\n###") || lower.contains("\nexplanation") || lower.contains("\nnote:") || lower.contains("\noutput:") || lower.contains("\n```\n\n") || lower.contains("\n// example") || lower.contains("\n# example") {
-                    for stop in &["\n###", "\nExplanation", "\nNote:", "\nOutput:", "\n```\n\n", "\n// Example", "\n// example", "\n# Example", "\n# example"] {
-                        if let Some(pos) = generated_text.find(stop) {
-                            generated_text.truncate(pos);
-                        }
                     }
-                    break;
                 }
             }
-            all_tokens.push(next_token);
+            found.unwrap_or_else(|| {
-            tokens_generated += 1;
+                tracing::warn!("Ollamaa ei löytynyt — käytetään oletusta http://localhost:11434");
+                "http://localhost:11434".to_string()
+            })
+        };
+
+        tracing::info!("Ollama backend: {} | malli: {}", ollama_url, model);
+        Ok(LlmEngine { ollama_url, model: RefCell::new(model), client })
+    }
+
+    pub fn model_name(&self) -> String {
+        self.model.borrow().clone()
+    }
+
+    pub fn set_model(&self, new_model: String) {
+        *self.model.borrow_mut() = new_model;
+    }
+
+    /// Varmistaa että malli on ladattu Ollamaan (ollama pull)
+    pub async fn ensure_model(&self) -> Result<(), String> {
+        let model = self.model.borrow().clone();
+        tracing::info!("Tarkistetaan malli {}...", model);
+        let resp = self.client.post(format!("{}/api/pull", self.ollama_url))
+            .json(&serde_json::json!({ "name": model, "stream": false }))
+            .send()
+            .await
+            .map_err(|e| format!("Ollama pull: {}", e))?;
+
+        if resp.status().is_success() {
+            tracing::info!("Malli {} valmis", model);
+            Ok(())
+        } else {
+            Err(format!("Ollama pull epäonnistui: {}", resp.status()))
+        }
+    }
+
+    pub async fn generate(&self, prompt: &str, max_tokens: usize) -> Result<GenerateResult, String> {
+        // System prompt tulee agentin konfiguraatiosta (frontend lähettää sen osana promptia).
+        // Tässä ei yliajeta sitä — Ollama saa vain prompt-kentän.
+        let model = self.model.borrow().clone();
+
+        let start = Instant::now();
+        let resp = self.client.post(format!("{}/api/generate", self.ollama_url))
+            .json(&serde_json::json!({
+                "model": model,
+                "prompt": prompt,
+                "stream": false,
+                "options": {
+                    "num_predict": max_tokens,
+                    "temperature": 0.7,
+                    "top_k": 40,
+                    "repeat_penalty": 1.15,
+                    "stop": ["<|im_end|>", "\n###", "\nExplanation", "\nNote:", "\nPlease note", "\nThis is", "\n```\n\n", "\n// Example", "\n# Example"]
+                }
+            }))
+            .send()
+            .await
+            .map_err(|e| format!("Ollama generate: {}", e))?;
+
+        if !resp.status().is_success() {
+            return Err(format!("Ollama HTTP {}", resp.status()));
         }
 
-        let gen_time = start.elapsed();
+        let body: serde_json::Value = resp.json().await
-        let tokens_per_sec = if gen_time.as_secs_f64() > 0.0 {
+            .map_err(|e| format!("Ollama JSON: {}", e))?;
-            tokens_generated as f64 / gen_time.as_secs_f64()
+
+        let text = body["response"].as_str().unwrap_or("").to_string();
+        let _total_duration_ns = body["total_duration"].as_u64().unwrap_or(0);
+        let eval_count = body["eval_count"].as_u64().unwrap_or(0) as usize;
+        let eval_duration_ns = body["eval_duration"].as_u64().unwrap_or(1);
+
+        let duration_ms = start.elapsed().as_millis() as f64;
+        let tokens_per_sec = if eval_duration_ns > 0 {
+            eval_count as f64 / (eval_duration_ns as f64 / 1_000_000_000.0)
         } else { 0.0 };
 
         Ok(GenerateResult {
-            text: strip_markdown_wrapper(&generated_text),
+            text: strip_code_fences(&text),
-            tokens_generated,
+            tokens_generated: eval_count,
-            duration_ms: gen_time.as_millis() as f64,
+            duration_ms,
             tokens_per_sec,
         })
     }
 }
 
-const LANG_TAGS: &[&str] = &[
+/// Siivoa markdown-koodiblokki-merkit ja selitystekstit
-    "python", "py", "rust", "rs", "javascript", "js", "typescript", "ts",
+fn strip_code_fences(text: &str) -> String {
-    "java", "kotlin", "scala", "go", "ruby", "rb", "php", "swift",
+    // Poistetaan kaikki ```-rivit ja kielitunnisteet (```python, ```rust jne.)
-    "c", "cpp", "c++", "c#", "csharp", "r", "sql", "bash", "sh", "zsh",
+    let lines: Vec<&str> = text.lines().collect();
-    "html", "css", "json", "yaml", "yml", "toml", "xml", "markdown", "md",
+    let filtered: Vec<&str> = lines.into_iter().filter(|line| {
-    "lua", "perl", "dart", "elixir", "haskell", "hs", "ocaml", "zig",
+        let trimmed = line.trim();
-    "plaintext", "text", "txt",
+        // Poista rivit jotka ovat pelkkiä ``` tai ```kielitunniste
-];
+        if trimmed.starts_with("```") {
+            return false;
+        }
+        true
+    }).collect();
+    let mut result = filtered.join("\n").trim().to_string();
 
-/// Siivoa mallin tuottama vastaus (prefill-yhteensopiva).
+    // Poista selitysteksti lopusta (kaikki rivin "\nPlease note" jälkeen jne.)
-fn strip_markdown_wrapper(text: &str) -> String {
+    let lower = result.to_lowercase();
-    let mut result = text.trim().to_string();
+    for stop in &["\nplease note", "\nthis is a basic", "\nthis code", "\nnote that", "\nremember to", "\nyou can", "\nto run"] {
-
+        if let Some(pos) = lower.find(stop) {
-    // 1. Kielitunniste — VAIN tunnettu kieli
+            result = result[..pos].trim_end().to_string();
-    if let Some(nl) = result.find('\n') {
-        let first = result[..nl].trim().to_lowercase();
-        if LANG_TAGS.contains(&first.as_str()) {
-            result = result[nl + 1..].to_string();
         }
     }
 
-    // 2. Sulkeva ``` — VAIN omalla rivillään lopussa
+    // Poista johdantolauseet alusta
-    let trimmed = result.trim_end();
+    let lower = result.to_lowercase();
-    if trimmed.ends_with("```") {
-        let before = &trimmed[..trimmed.len() - 3];
-        if before.is_empty() || before.ends_with('\n') {
-            result = before.trim_end().to_string();
-        }
-    }
-
-    // 3. Johdantolauseet
-    let lower = result.trim().to_lowercase();
     for prefix in &["sure!", "here is", "here's", "certainly!", "below is"] {
         if lower.starts_with(prefix) {
-            if let Some(nl) = result.find('\n') { result = result[nl + 1..].to_string(); }
+            if let Some(nl) = result.find('\n') {
+                result = result[nl + 1..].to_string();
+            }
             break;
         }
     }
 
-    // 4. Selityskommentit alusta
+    result.trim().to_string()
-    let mut lines: Vec<&str> = result.trim().lines().collect();
-    while !lines.is_empty() {
-        let first = lines[0].trim();
-        let is_preamble = first.starts_with("# ") && !first.starts_with("#!")
-            && (first.to_lowercase().contains("this is")
-                || first.to_lowercase().contains("simple")
-                || first.to_lowercase().contains("program that")
-                || first.to_lowercase().contains("here is")
-                || first.to_lowercase().contains("the following")
-                || first.to_lowercase().contains("below"));
-        if is_preamble { lines.remove(0); } else { break; }
-    }
-    lines.join("\n").trim().to_string()
 }
 
 pub struct GenerateResult {

network-poc/native-node/src/main.rs

@@ -33,6 +33,7 @@ impl GpuInfo {
     }
 }
 
+#[cfg(feature = "gpu-detect")]
 /// Tunnistaa kaikki GPU:t wgpu:lla (NVIDIA/AMD/Apple/Intel)
 fn collect_gpus_wgpu() -> Vec<GpuInfo> {
     let instance = wgpu::Instance::new(&wgpu::InstanceDescriptor {
@@ -84,6 +85,7 @@ fn collect_gpus_wgpu() -> Vec<GpuInfo> {
     gpus
 }
 
+#[cfg(feature = "gpu-detect")]
 /// Täydentää NVIDIA-GPU:iden tiedot NVML:llä (VRAM, lämpötila, kuormitus)
 fn enrich_nvidia_gpus(gpus: &mut [GpuInfo]) {
     let Ok(nvml) = nvml_wrapper::Nvml::init() else { return };
@@ -109,6 +111,7 @@ fn enrich_nvidia_gpus(gpus: &mut [GpuInfo]) {
     }
 }
 
+#[cfg(feature = "gpu-detect")]
 /// AMD GPU-tiedot Linuxin sysfs:stä (/sys/class/drm/)
 fn enrich_amd_gpus(gpus: &mut [GpuInfo]) {
     let Ok(entries) = std::fs::read_dir("/sys/class/drm") else { return };
@@ -150,10 +153,12 @@ fn enrich_amd_gpus(gpus: &mut [GpuInfo]) {
     }
 }
 
+#[cfg(feature = "gpu-detect")]
 fn read_sysfs_u64(path: &std::path::Path) -> Option<u64> {
     std::fs::read_to_string(path).ok()?.trim().parse().ok()
 }
 
+#[cfg(feature = "gpu-detect")]
 fn find_hwmon_temp(device_path: &std::path::Path) -> Option<u64> {
     let hwmon_dir = device_path.join("hwmon");
     let entries = std::fs::read_dir(&hwmon_dir).ok()?;
@@ -166,8 +171,8 @@ fn find_hwmon_temp(device_path: &std::path::Path) -> Option<u64> {
     None
 }
 
+#[cfg(feature = "gpu-detect")]
 /// Apple GPU-tiedot — wgpu/Metal antaa nimen, tarkempaa dataa ei saa ilman IOKit:ia
-/// mutta Metal adapter_info sisältää jo olennaiset tiedot
 fn enrich_apple_gpus(gpus: &mut [GpuInfo]) {
     // Apple Silicon -koneiden unified memory: koko RAM on GPU:n käytettävissä
     // Arvioidaan system RAM:sta
@@ -187,13 +192,18 @@ fn enrich_apple_gpus(gpus: &mut [GpuInfo]) {
 
 /// Kerää kaikki GPU:t ja täydentää valmistajakohtaiset tiedot
 fn collect_all_gpus() -> Vec<GpuInfo> {
-    let mut gpus = collect_gpus_wgpu();
+    #[cfg(feature = "gpu-detect")]
-
+    {
-    enrich_nvidia_gpus(&mut gpus);
+        let mut gpus = collect_gpus_wgpu();
-    enrich_amd_gpus(&mut gpus);
+        enrich_nvidia_gpus(&mut gpus);
-    enrich_apple_gpus(&mut gpus);
+        enrich_amd_gpus(&mut gpus);
-
+        enrich_apple_gpus(&mut gpus);
-    gpus
+        return gpus;
+    }
+    #[cfg(not(feature = "gpu-detect"))]
+    {
+        Vec::new()
+    }
 }
 
 /// Kerää järjestelmätiedot (CPU, RAM, OS)
@@ -222,15 +232,21 @@ fn build_auth_message(allocated_gb: u32) -> String {
         v
     }).collect();
 
+    let api_key = std::env::var("NODE_API_KEY").unwrap_or_default();
+
     let mut msg = json!({
         "type": "auth",
         "status": "agent_ready",
         "node_type": "native",
         "allocated_gb": allocated_gb,
-        "selected_task": "qwen-coder-05b",
+        "selected_task": "qwen2.5-coder:7b",
         "system": sys,
     });
 
+    if !api_key.is_empty() {
+        msg.as_object_mut().unwrap().insert("api_key".to_string(), json!(api_key));
+    }
+
     if !gpu_json.is_empty() {
         msg.as_object_mut().unwrap().insert("gpus".to_string(), json!(gpu_json));
     }
@@ -269,6 +285,9 @@ async fn main() {
 
     let gpus = collect_all_gpus();
     if gpus.is_empty() {
+        #[cfg(not(feature = "gpu-detect"))]
+        tracing::info!("GPU-tunnistus ei käytössä (--no-default-features). Ollama käyttää GPU:ta automaattisesti jos saatavilla.");
+        #[cfg(feature = "gpu-detect")]
         tracing::info!("GPU:ta ei havaittu — toimitaan CPU-moodissa");
     } else {
         for (i, gpu) in gpus.iter().enumerate() {
@@ -285,15 +304,19 @@ async fn main() {
         }
     }
 
-    // Ladataan LLM-malli
+    // Ollama-backend
-    tracing::info!("Ladataan LLM-mallia...");
+    tracing::info!("Alustetaan Ollama-yhteyttä...");
-    let mut llm = match inference::LlmEngine::load() {
+    let llm = match inference::LlmEngine::load().await {
         Ok(engine) => {
-            tracing::info!("LLM valmis inferenssiin!");
+            // Varmistetaan malli (ollama pull) — odotetaan kunnes valmis
+            match engine.ensure_model().await {
+                Ok(()) => tracing::info!("Ollama valmis inferenssiin!"),
+                Err(e) => tracing::warn!("Mallin lataus: {} — yritetään silti", e),
+            }
             Some(engine)
         }
         Err(e) => {
-            tracing::warn!("LLM-lataus epäonnistui: {} — toimitaan ilman inferenssiä", e);
+            tracing::warn!("Ollama-alustus epäonnistui: {} — toimitaan ilman inferenssiä", e);
             None
         }
     };
@@ -311,37 +334,40 @@ async fn main() {
                     continue;
                 }
 
-                let mut busy = false;
-
                 while let Some(Ok(msg)) = read.next().await {
                     if let Message::Text(text) = msg {
                         // LLM-promptit
-                        if text.contains("llm_prompt") && !busy {
+                        if text.contains("llm_prompt") {
                             if let Ok(task) = serde_json::from_str::<serde_json::Value>(&text) {
                                 let prompt = task.get("prompt").and_then(|v| v.as_str()).unwrap_or("");
                                 let task_id = task.get("task_id").and_then(|v| v.as_str()).unwrap_or("?");
                                 let msg_model = task.get("model").and_then(|v| v.as_str()).unwrap_or("");
                                 
-                                if !prompt.is_empty() && msg_model.starts_with("qwen-coder") {
+                                if !prompt.is_empty() && (msg_model.starts_with("qwen-coder") || msg_model.starts_with("qwen2.5-coder")) {
 
-                                    if let Some(ref mut engine) = llm {
+                                    if let Some(ref engine) = llm {
-                                        busy = true;
+                                        let max_tokens = task.get("max_tokens").and_then(|v| v.as_u64()).unwrap_or(1024) as usize;
-                                        tracing::info!("Generoidaan (task_id: {}): \"{}\"", task_id, prompt);
+                                        let prompt_lines = prompt.lines().count();
+                                        let prompt_last: String = prompt.lines().last().unwrap_or("").chars().take(60).collect();
+                                        tracing::info!("→ task_id:{} | {}r prompti | \"{}...\"", task_id, prompt_lines, prompt_last);
 
-                                        match engine.generate(prompt, 64) {
+                                        let model_name = engine.model_name();
+                                        match engine.generate(prompt, max_tokens).await {
                                             Ok(result) => {
                                                 tracing::info!(
-                                                    "Tulos: {} tokenia | {:.0}ms | {:.1} tok/s | \"{}\"",
+                                                    "✓ {} | {} tok | {:.0}ms | {:.1} tok/s",
+                                                    model_name,
                                                     result.tokens_generated,
                                                     result.duration_ms,
                                                     result.tokens_per_sec,
-                                                    &result.text[..result.text.len().min(80)]
                                                 );
 
+                                                // Lähetetään vain lyhyt prompti-esikatselu (ei koko kontekstia)
+                                                let prompt_short: String = prompt.lines().last().unwrap_or("").chars().take(100).collect();
                                                 let done = json!({
                                                     "type": "llm_done",
-                                                    "prompt": prompt,
+                                                    "prompt": prompt_short,
-                                                    "model": "Qwen2.5-Coder-0.5B (native/GPU)",
+                                                    "model": format!("{} (Ollama)", model_name),
                                                     "response": result.text,
                                                     "tokens_generated": result.tokens_generated,
                                                     "duration_ms": result.duration_ms,
@@ -355,12 +381,25 @@ async fn main() {
                                                 tracing::error!("Inferenssivirhe: {}", e);
                                             }
                                         }
-                                        busy = false;
                                     }
                                 }
                             }
                         }
-                        // Ohitetaan pair_task, stats jne.
+                        // Mallin vaihto lennossa
+                        if text.contains("change_model") {
+                            if let Ok(task) = serde_json::from_str::<serde_json::Value>(&text) {
+                                if let Some(new_model) = task.get("model").and_then(|v| v.as_str()) {
+                                    if let Some(ref engine) = llm {
+                                        tracing::info!("Vaihdetaan malli: {}", new_model);
+                                        engine.set_model(new_model.to_string());
+                                        match engine.ensure_model().await {
+                                            Ok(()) => tracing::info!("Malli {} valmis!", new_model),
+                                            Err(e) => tracing::error!("Mallin lataus epäonnistui: {}", e),
+                                        }
+                                    }
+                                }
+                            }
+                        }
                     }
                 }
                 tracing::warn!("Yhteys hubiin katkesi — yritetään uudelleen 5s...");

network-poc/node/src/lib.rs

@@ -38,17 +38,50 @@ pub fn set_gpu_load(load: u32) {
     console_log!("[Wasm] GPU Kuormitusraja vaihdettu -> {}%", load);
 }
 
-// Asynkroninen odotus WebAssemblylle
+// Worker-yhteensopiva setTimeout — toimii sekä Window- että Worker-kontekstissa
-async fn sleep_ms(ms: i32) {
+#[wasm_bindgen]
+extern "C" {
+    #[wasm_bindgen(js_name = setTimeout)]
+    fn set_timeout(closure: &js_sys::Function, ms: i32);
+}
+
+// Asynkroninen odotus WebAssemblylle (Window + Worker)
+pub async fn sleep_ms(ms: i32) {
     let promise = js_sys::Promise::new(&mut |resolve, _| {
-        web_sys::window()
+        set_timeout(&resolve, ms);
-            .unwrap()
-            .set_timeout_with_callback_and_timeout_and_arguments_0(&resolve, ms)
-            .unwrap();
     });
     let _ = wasm_bindgen_futures::JsFuture::from(promise).await;
 }
 
+// Worker-yhteensopiva Performance — käyttää globalThis.performance
+pub fn perf_now() -> f64 {
+    js_sys::Reflect::get(&js_sys::global(), &"performance".into())
+        .ok()
+        .and_then(|p| js_sys::Reflect::get(&p, &"now".into()).ok())
+        .and_then(|f| f.dyn_into::<js_sys::Function>().ok())
+        .and_then(|f| {
+            let perf = js_sys::Reflect::get(&js_sys::global(), &"performance".into()).unwrap();
+            f.call0(&perf).ok()
+        })
+        .and_then(|v| v.as_f64())
+        .unwrap_or(0.0)
+}
+
+// Worker-yhteensopiva fetch — käyttää globalThis.fetch
+pub async fn worker_fetch(url: &str) -> Result<web_sys::Response, String> {
+    let promise = js_sys::Reflect::get(&js_sys::global(), &"fetch".into())
+        .map_err(|_| "fetch ei saatavilla".to_string())?
+        .dyn_into::<js_sys::Function>()
+        .map_err(|_| "fetch ei funktio".to_string())?
+        .call1(&JsValue::NULL, &url.into())
+        .map_err(|e| format!("fetch: {:?}", e))?;
+    let resp = wasm_bindgen_futures::JsFuture::from(js_sys::Promise::from(promise))
+        .await
+        .map_err(|e| format!("fetch await: {:?}", e))?;
+    resp.dyn_into::<web_sys::Response>()
+        .map_err(|_| "ei Response".to_string())
+}
+
 // Geneerinen tensorilaskenta — toimii millä tahansa Burn-backendillä
 fn run_matmul<B: burn::tensor::backend::Backend>(size: usize) -> String {
     let device = Default::default();
@@ -85,6 +118,27 @@ async fn run_ai_tensor_inference(difficulty: usize) -> String {
     format!("PoC {} Matmul ({}x{}) >> {}", backend_name, active_workload_size, active_workload_size, result)
 }
 
+/// JS-exportti: tokenisoi tekstin ja palauttaa JSON-merkkijonon
+/// Tokenizer ladataan IndexedDB:stä (täytyy olla ladattu aiemmin)
+#[wasm_bindgen]
+pub async fn tokenize_js(text: String) -> Result<String, JsValue> {
+    let cached_tok = storage::load_from_idb("tokenizer.json").await.unwrap_or(None);
+    let Some(bytes) = cached_tok else {
+        // Yritetään ladata verkosta
+        let resp = reqwest::get("https://huggingface.co/Qwen/Qwen2.5-Coder-0.5B/resolve/main/tokenizer.json").await
+            .map_err(|e| JsValue::from_str(&format!("Tokenizer-lataus epäonnistui: {}", e)))?;
+        let bytes = resp.bytes().await
+            .map_err(|e| JsValue::from_str(&format!("Tokenizer-lataus epäonnistui: {}", e)))?;
+        let _ = storage::save_to_idb("tokenizer.json", &bytes).await;
+        let tokenizer = tokenizers::Tokenizer::from_bytes(&bytes)
+            .map_err(|e| JsValue::from_str(&format!("Tokenizer-parsinta: {}", e)))?;
+        return Ok(tokenize_text(&tokenizer, &text).to_string());
+    };
+    let tokenizer = tokenizers::Tokenizer::from_bytes(&bytes)
+        .map_err(|e| JsValue::from_str(&format!("Tokenizer-parsinta: {}", e)))?;
+    Ok(tokenize_text(&tokenizer, &text).to_string())
+}
+
 /// Tokenisoi yhden tekstin ja palauttaa metriikat
 fn tokenize_text(tokenizer: &tokenizers::Tokenizer, text: &str) -> serde_json::Value {
     let char_count = text.chars().count();
@@ -123,10 +177,9 @@ async fn run_single_tokenize(text: String, ws: Rc<RefCell<WebSocket>>) {
     let Some(bytes) = cached_tok else { return; };
     let Ok(tokenizer) = tokenizers::Tokenizer::from_bytes(&bytes) else { return; };
 
-    let perf = web_sys::window().unwrap().performance().unwrap();
+    let start = perf_now();
-    let start = perf.now();
     let result = tokenize_text(&tokenizer, &text);
-    let duration_ms = perf.now() - start;
+    let duration_ms = perf_now() - start;
 
     let token_count = result["token_count"].as_u64().unwrap_or(0);
     let cpt = result["chars_per_token"].as_f64().unwrap_or(0.0);
@@ -157,11 +210,10 @@ async fn run_pair_comparison(en_text: String, fi_text: String, ws: Rc<RefCell<We
         return;
     };
 
-    let perf = web_sys::window().unwrap().performance().unwrap();
+    let start_time = perf_now();
-    let start_time = perf.now();
     let en_result = tokenize_text(&tokenizer, &en_text);
     let fi_result = tokenize_text(&tokenizer, &fi_text);
-    let duration_ms = perf.now() - start_time; // millisekunteja desimaalitarkkuudella
+    let duration_ms = perf_now() - start_time;
 
     let en_cpt = en_result["chars_per_token"].as_f64().unwrap_or(0.0);
     let fi_cpt = fi_result["chars_per_token"].as_f64().unwrap_or(0.0);
@@ -296,7 +348,9 @@ pub async fn start_agent_node(hub_url: String, has_webgpu: bool, device_info_jso
                         });
                     }
                 }
-            } else if msg.contains("llm_prompt") && (current_task == 4 || current_task == 5) {
+            } else if msg.contains("llm_prompt") {
+                console_log!("[DEBUG] llm_prompt vastaanotettu! current_task={}, busy={}", current_task, LLM_BUSY.load(Ordering::SeqCst));
+                if current_task == 4 || current_task == 5 {
                 // Qwen2.5-Coder: 4 = 0.5B, 5 = 3B
                 if let Ok(task) = serde_json::from_str::<serde_json::Value>(&msg) {
                     let prompt = task.get("prompt").and_then(|v| v.as_str()).unwrap_or("").to_string();
@@ -324,6 +378,7 @@ pub async fn start_agent_node(hub_url: String, has_webgpu: bool, device_info_jso
                         }
                     }
                 }
+                } // current_task == 4 || 5
             } else if msg.contains("ai_task") {
                 console_log!("Hub task vastaanotettu, ajetaan GPU:lla...");
                 let ws_for_async = ws_clone.clone();

network-poc/node/src/qwen.rs

@@ -24,10 +24,7 @@ async fn ensure_cached(key: &str, url: &str, ws: &Rc<RefCell<WebSocket>>) -> Res
 
     console_log!("[Qwen] Ladataan {}...", key);
 
-    let window = web_sys::window().unwrap();
+    let resp = crate::worker_fetch(url).await?;
-    let resp_val = wasm_bindgen_futures::JsFuture::from(window.fetch_with_str(url))
-        .await.map_err(|e| format!("Fetch epäonnistui: {:?}", e))?;
-    let resp: web_sys::Response = resp_val.dyn_into().map_err(|_| "Ei Response".to_string())?;
     if !resp.ok() { return Err(format!("HTTP {}", resp.status())); }
 
     let total_size: usize = resp.headers()
@@ -71,7 +68,7 @@ async fn ensure_cached(key: &str, url: &str, ws: &Rc<RefCell<WebSocket>>) -> Res
 }
 
 pub async fn run_qwen_inference(prompt: String, ws: Rc<RefCell<WebSocket>>) {
-    let perf = web_sys::window().unwrap().performance().unwrap();
+    // performance via crate::perf_now()
 
     let tok_bytes = match ensure_cached("qwen05b-tokenizer.json", TOKENIZER_URL, &ws).await {
         Ok(b) => b,
@@ -88,7 +85,7 @@ pub async fn run_qwen_inference(prompt: String, ws: Rc<RefCell<WebSocket>>) {
     };
 
     console_log!("[Qwen] Rakennetaan mallia...");
-    let start_load = perf.now();
+    let start_load = crate::perf_now();
     let device = Device::Cpu;
     let dtype = DType::F32;
 
@@ -120,7 +117,7 @@ pub async fn run_qwen_inference(prompt: String, ws: Rc<RefCell<WebSocket>>) {
         Err(e) => { console_log!("[Qwen] Mallin lataus: {}", e); return; }
     };
 
-    let load_time = perf.now() - start_load;
+    let load_time = crate::perf_now() - start_load;
     console_log!("[Qwen] Malli ladattu ({:.0}ms). Generoidaan...", load_time);
 
     let encoding = match tokenizer.encode(prompt.as_str(), true) {
@@ -131,7 +128,7 @@ pub async fn run_qwen_inference(prompt: String, ws: Rc<RefCell<WebSocket>>) {
     let input_len = input_ids.len();
     console_log!("[Qwen] Syöte: {} tokenia", input_len);
 
-    let start_gen = perf.now();
+    let start_gen = crate::perf_now();
     let max_new_tokens = 32;
     let mut generated_text = String::new();
     let mut tokens_generated: usize = 0;
@@ -202,7 +199,7 @@ pub async fn run_qwen_inference(prompt: String, ws: Rc<RefCell<WebSocket>>) {
         crate::sleep_ms(0).await;
     }
 
-    let gen_time = perf.now() - start_gen;
+    let gen_time = crate::perf_now() - start_gen;
     let tokens_per_sec = if gen_time > 0.0 { (tokens_generated as f64 / gen_time) * 1000.0 } else { 0.0 };
     console_log!("[Qwen] {} tokenia | {:.0}ms | {:.1} tok/s", tokens_generated, gen_time, tokens_per_sec);
 

network-poc/node/src/qwen_coder.rs

@@ -140,10 +140,7 @@ async fn ensure_cached(key: &str, url: &str, ws: &Rc<RefCell<WebSocket>>) -> Res
 
     console_log!("[Coder] Ladataan {}...", key);
 
-    let window = web_sys::window().unwrap();
+    let resp = crate::worker_fetch(url).await?;
-    let resp_val = wasm_bindgen_futures::JsFuture::from(window.fetch_with_str(url))
-        .await.map_err(|e| format!("Fetch: {:?}", e))?;
-    let resp: web_sys::Response = resp_val.dyn_into().map_err(|_| "Ei Response".to_string())?;
     if !resp.ok() { return Err(format!("HTTP {}", resp.status())); }
 
     let total_size: usize = resp.headers()
@@ -251,17 +248,19 @@ async fn get_or_build_model(use_3b: bool, ws: &Rc<RefCell<WebSocket>>) -> Result
 
 /// use_3b: false = 0.5B (nopea), true = 3B (laadukas)
 pub async fn run_coder_inference(prompt: String, ws: Rc<RefCell<WebSocket>>, use_3b: bool, task_id: Option<String>) {
-    let perf = web_sys::window().unwrap().performance().unwrap();
+    console_log!("[Coder] run_coder_inference alkaa! prompt={}", &prompt[..prompt.len().min(50)]);
     let size_label = if use_3b { "3B" } else { "0.5B" };
 
-    let start_load = perf.now();
+    let start_load = crate::perf_now();
 
+    console_log!("[Coder] Kutsutaan get_or_build_model...");
     if let Err(e) = get_or_build_model(use_3b, &ws).await {
-        console_log!("[Coder] Mallin lataus: {}", e);
+        console_log!("[Coder] Mallin lataus epäonnistui: {}", e);
         return;
     }
+    console_log!("[Coder] Malli valmis, aloitetaan inferenssi");
 
-    let load_time = perf.now() - start_load;
+    let load_time = crate::perf_now() - start_load;
     if load_time > 100.0 {
         console_log!("[Coder] Malli ladattu ({:.0}ms). Generoidaan...", load_time);
     }
@@ -297,7 +296,7 @@ pub async fn run_coder_inference(prompt: String, ws: Rc<RefCell<WebSocket>>, use
         console_log!("[Coder] Syöte: {} tokenia", input_len);
 
         let device = Device::Cpu;
-        let start_gen = perf.now();
+        let start_gen = crate::perf_now();
         let eos_token = 151645u32;
         let temperature: f32 = 0.7;
         let top_k: usize = 40;
@@ -324,7 +323,11 @@ pub async fn run_coder_inference(prompt: String, ws: Rc<RefCell<WebSocket>>, use
             if let Ok(text) = cached.tokenizer.decode(&[next_token], true) {
                 generated_text.push_str(&text);
                 let mut chunk = serde_json::json!({ "type": "llm_chunk", "token": text, "prompt": prompt, "model": "Qwen2.5-Coder" });
-                if let Some(ref tid) = task_id { chunk.as_object_mut().unwrap().insert("task_id".to_string(), serde_json::json!(tid)); }
+                if let Some(ref tid) = task_id { 
+                    if let Some(obj) = chunk.as_object_mut() {
+                        obj.insert("task_id".to_string(), serde_json::json!(tid)); 
+                    }
+                }
                 let _ = ws.borrow().send_with_str(&chunk.to_string());
             }
             all_generated.push(next_token);
@@ -366,14 +369,18 @@ pub async fn run_coder_inference(prompt: String, ws: Rc<RefCell<WebSocket>>, use
                 }
 
                 let mut chunk = serde_json::json!({ "type": "llm_chunk", "token": text, "prompt": prompt, "model": "Qwen2.5-Coder" });
-                if let Some(ref tid) = task_id { chunk.as_object_mut().unwrap().insert("task_id".to_string(), serde_json::json!(tid)); }
+                if let Some(ref tid) = task_id { 
+                    if let Some(obj) = chunk.as_object_mut() {
+                        obj.insert("task_id".to_string(), serde_json::json!(tid));
+                    }
+                }
                 let _ = ws.borrow().send_with_str(&chunk.to_string());
             }
             all_generated.push(next_token);
             tokens_generated += 1;
         }
 
-        let gen_time = perf.now() - start_gen;
+        let gen_time = crate::perf_now() - start_gen;
 
         // Siivotaan vastaus: poista markdown-koodiblokit ja johdantotekstit
         let cleaned = strip_markdown_wrapper(&generated_text);
@@ -395,7 +402,9 @@ pub async fn run_coder_inference(prompt: String, ws: Rc<RefCell<WebSocket>>, use
         "load_time_ms": (load_time * 100.0).round() / 100.0,
     });
     if let Some(tid) = task_id {
-        done.as_object_mut().unwrap().insert("task_id".to_string(), serde_json::json!(tid));
+        if let Some(obj) = done.as_object_mut() {
+            obj.insert("task_id".to_string(), serde_json::json!(tid));
+        }
     }
     let _ = ws.borrow().send_with_str(&done.to_string());
 }

network-poc/node/src/smollm.rs

@@ -28,10 +28,7 @@ async fn ensure_cached(key: &str, url: &str, ws: &Rc<RefCell<WebSocket>>) -> Res
     send_progress(ws, key, 0, 0, 0);
 
     // Fetch API:lla saadaan Content-Length ja streaming-luku
-    let window = web_sys::window().unwrap();
+    let resp = crate::worker_fetch(url).await?;
-    let resp_val = wasm_bindgen_futures::JsFuture::from(window.fetch_with_str(url))
-        .await.map_err(|e| format!("Fetch epäonnistui: {:?}", e))?;
-    let resp: web_sys::Response = resp_val.dyn_into().map_err(|_| "Ei Response-objekti".to_string())?;
 
     if !resp.ok() {
         return Err(format!("HTTP {}", resp.status()));
@@ -99,7 +96,7 @@ fn send_progress(ws: &Rc<RefCell<WebSocket>>, file: &str, pct: u32, loaded: usiz
 
 /// Lataa malli ja tokenizer, suorita inferenssi ja streamaa tokenit hubille
 pub async fn run_smollm_inference(prompt: String, ws: Rc<RefCell<WebSocket>>) {
-    let perf = web_sys::window().unwrap().performance().unwrap();
+    // performance via crate::perf_now()
 
     // 1. Lataa tokenizer
     let tok_bytes = match ensure_cached("smollm-tokenizer.json", TOKENIZER_URL, &ws).await {
@@ -122,7 +119,7 @@ pub async fn run_smollm_inference(prompt: String, ws: Rc<RefCell<WebSocket>>) {
     // Burn 0.21-pre.2 cubecl-runtime ei käänny Wasmille (println! puuttuu)
     // → NdArray kunnes Burn 0.21 stable + Wasm-tuki
     console_log!("[SmolLM] Burn NdArray (CPU) inferenssi...");
-    run_burn_inference::<burn::backend::NdArray>(prompt, model_bytes, tokenizer, ws, perf.clone()).await;
+    run_burn_inference::<burn::backend::NdArray>(prompt, model_bytes, tokenizer, ws).await;
 }
 
 async fn run_burn_inference<B: burn::tensor::backend::Backend>(
@@ -130,9 +127,8 @@ async fn run_burn_inference<B: burn::tensor::backend::Backend>(
     model_bytes: Vec<u8>,
     tokenizer: tokenizers::Tokenizer,
     ws: Rc<RefCell<WebSocket>>,
-    perf: web_sys::Performance, // Korjattu Wasm-performanssi välitettäväksi
 ) {
-    let start_load = perf.now();
+    let start_load = crate::perf_now();
 
     let device = Default::default();
     let config = crate::burn_smollm::config::SmolLMConfig::default();
@@ -143,7 +139,7 @@ async fn run_burn_inference<B: burn::tensor::backend::Backend>(
         Err(e) => { console_log!("[SmolLM] Lataus epäonnistui: {}", e); return; }
     };
 
-    let load_time = perf.now() - start_load;
+    let load_time = crate::perf_now() - start_load;
     console_log!("[SmolLM] Burn-malli ladattu ({:.0}ms). Generoidaan...", load_time);
 
     let formatted_prompt = format!("<|im_start|>user\n{}<|im_end|>\n<|im_start|>assistant\n", prompt);
@@ -156,7 +152,7 @@ async fn run_burn_inference<B: burn::tensor::backend::Backend>(
     let input_len = input_ids.len();
     console_log!("[SmolLM] Syöte: {} tokenia", input_len);
 
-    let start_gen = perf.now();
+    let start_gen = crate::perf_now();
     let max_new_tokens = 32;
     let mut generated_text = String::new();
     let mut tokens_generated: usize = 0;
@@ -219,7 +215,7 @@ async fn run_burn_inference<B: burn::tensor::backend::Backend>(
         tokens_generated += 1;
     }
 
-    let gen_time = perf.now() - start_gen;
+    let gen_time = crate::perf_now() - start_gen;
     let tokens_per_sec = if gen_time > 0.0 { (tokens_generated as f64 / gen_time) * 1000.0 } else { 0.0 };
 
     let done = serde_json::json!({

network-poc/target-check/.rustc_info.json

@@ -0,0 +1 @@
+{"rustc_fingerprint":15841952146704291179,"outputs":{"17747080675513052775":{"success":true,"status":"","code":0,"stdout":"rustc 1.94.1 (e408947bf 2026-03-25)\nbinary: rustc\ncommit-hash: e408947bfd200af42db322daf0fadfe7e26d3bd1\ncommit-date: 2026-03-25\nhost: x86_64-unknown-linux-gnu\nrelease: 1.94.1\nLLVM version: 21.1.8\n","stderr":""},"7971740275564407648":{"success":true,"status":"","code":0,"stdout":"___\nlib___.rlib\nlib___.so\nlib___.so\nlib___.a\nlib___.so\n/home/jaakko/.rustup/toolchains/stable-x86_64-unknown-linux-gnu\noff\npacked\nunpacked\n___\ndebug_assertions\npanic=\"unwind\"\nproc_macro\ntarget_abi=\"\"\ntarget_arch=\"x86_64\"\ntarget_endian=\"little\"\ntarget_env=\"gnu\"\ntarget_family=\"unix\"\ntarget_feature=\"fxsr\"\ntarget_feature=\"sse\"\ntarget_feature=\"sse2\"\ntarget_has_atomic=\"16\"\ntarget_has_atomic=\"32\"\ntarget_has_atomic=\"64\"\ntarget_has_atomic=\"8\"\ntarget_has_atomic=\"ptr\"\ntarget_os=\"linux\"\ntarget_pointer_width=\"64\"\ntarget_vendor=\"unknown\"\nunix\n","stderr":""}},"successes":{}}

network-poc/target-check/CACHEDIR.TAG

@@ -0,0 +1,3 @@
+Signature: 8a477f597d28d172789f06886806bc55
+# This file is a cache directory tag created by cargo.
+# For information about cache directory tags see https://bford.info/cachedir/

network-poc/temp/frontend-old/.gitignore

@@ -0,0 +1,24 @@
+# build output
+dist/
+# generated types
+.astro/
+
+# dependencies
+node_modules/
+
+# logs
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+
+
+# environment variables
+.env
+.env.production
+
+# macOS-specific files
+.DS_Store
+
+# jetbrains setting folder
+.idea/

network-poc/temp/frontend-old/.vscode/extensions.json

@@ -0,0 +1,4 @@
+{
+  "recommendations": ["astro-build.astro-vscode"],
+  "unwantedRecommendations": []
+}

network-poc/temp/frontend-old/.vscode/launch.json

@@ -0,0 +1,11 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "command": "./node_modules/.bin/astro dev",
+      "name": "Development server",
+      "request": "launch",
+      "type": "node-terminal"
+    }
+  ]
+}

network-poc/temp/frontend-old/README.md

@@ -0,0 +1,43 @@
+# Astro Starter Kit: Minimal
+
+```sh
+npm create astro@latest -- --template minimal
+```
+
+> 🧑‍🚀 **Seasoned astronaut?** Delete this file. Have fun!
+
+## 🚀 Project Structure
+
+Inside of your Astro project, you'll see the following folders and files:
+
+```text
+/
+├── public/
+├── src/
+│   └── pages/
+│       └── index.astro
+└── package.json
+```
+
+Astro looks for `.astro` or `.md` files in the `src/pages/` directory. Each page is exposed as a route based on its file name.
+
+There's nothing special about `src/components/`, but that's where we like to put any Astro/React/Vue/Svelte/Preact components.
+
+Any static assets, like images, can be placed in the `public/` directory.
+
+## 🧞 Commands
+
+All commands are run from the root of the project, from a terminal:
+
+| Command                   | Action                                           |
+| :------------------------ | :----------------------------------------------- |
+| `npm install`             | Installs dependencies                            |
+| `npm run dev`             | Starts local dev server at `localhost:4321`      |
+| `npm run build`           | Build your production site to `./dist/`          |
+| `npm run preview`         | Preview your build locally, before deploying     |
+| `npm run astro ...`       | Run CLI commands like `astro add`, `astro check` |
+| `npm run astro -- --help` | Get help using the Astro CLI                     |
+
+## 👀 Want to learn more?
+
+Feel free to check [our documentation](https://docs.astro.build) or jump into our [Discord server](https://astro.build/chat).

network-poc/temp/frontend-old/astro.config.mjs

@@ -0,0 +1,5 @@
+// @ts-check
+import { defineConfig } from 'astro/config';
+
+// https://astro.build/config
+export default defineConfig({});

network-poc/temp/frontend-old/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "frontend",
+  "type": "module",
+  "version": "0.0.1",
+  "engines": {
+    "node": ">=22.12.0"
+  },
+  "scripts": {
+    "dev": "astro dev",
+    "build": "astro build",
+    "preview": "astro preview",
+    "astro": "astro"
+  },
+  "dependencies": {
+    "astro": "^6.1.5",
+    "three": "^0.183.2"
+  }
+}

network-poc/temp/frontend-old/public/avatars/README.md

@@ -0,0 +1,34 @@
+# Kipinä Agentic Playground - Animaatioiden käyttöönotto
+
+Koska Kipinä-verkon agenttien avatarit tällä erää ovat staattisia PNG-kuvatiedostoja, käyttöliittymä hyödyntää CSS-pohjaista pomppimisilmiötä (sekä pulppuavaa 💬 puhekuplaa) "puhumisen" merkkinä. Olemme kuitenkin koodanneet taustalle piilotetun tuen aivioiduille videoloopeille myöhempää käyttöä varten!
+
+Näin saat UI:n tukemaan oikeasti animoituja kasvoja/videoita.
+
+## 1. Luo Animoidut GIF-tiedostot
+Valitse mikä tahansa ulkoinen AI-työkalu (kuten HeyGen, Pika v1.0, tai Midjourney+Runway yhdistelmä) ja muunna avatar-kuvat (esim. `kettu_notext.png`) 3-5 sekunnin kestäviksi GIF-loopeiksi. Hahmon leuka tulisi pyöriä tai naama vääntyillä puhuessaan.
+
+## 2. Nimeä Tiedostot Oikein ja Lisää Ne Kansioon
+Siirrä uudet GIF-animaatiot samaan kansioon alkuperäisten kuvien kanssa. Muuta niiden nimi siten, että se päättyy tunnisteeseen `_puhuva.gif`.
+
+Esimerkkejä:
+- Koodari `kipina_notext.png` → `kipina_notext_puhuva.gif`
+- Manageri `karhunpentu.png` → `karhunpentu_puhuva.gif`
+- Asiakas `kettu_notext.png` → `kettu_notext_puhuva.gif`
+
+## 3. Aktivoi Koodi
+Käännä Kipinä Playground -ohjaimen JavaScript-koodista piilotettu ominaisuus päälle.
+
+Etsi tiedostosta `../index.html` (noin riviltä 1084, `updatePromptEditor`-funktiosta):
+```javascript
+// Piilotettu ominaisuus: Puhuvien videoiden / gif-animaatioiden kytkentä
+window.USE_ANIMATED_GIFS = false;
+```
+Muuta tuo `false` arvoon `true`:
+```javascript
+window.USE_ANIMATED_GIFS = true;
+```
+
+**Mitä logiikka tekee?**
+Aina kun valitset agentin kaaviosta, koodi korvaa aktiivisen kuvakkeen lopussa olevan `.png` -päätteen sanalla `_puhuva.gif` – lennosta! Jos poistut agentin valinnasta tai valitset jonkun toisen, koodi vaihtaa kuvan välittömästi takaisin staattiseen `.png`-versioon ja sulkee ilmentymän suun.
+
+Näin saat kaikkien asiantuntijoiden face-track looppeja hallittua yhdellä kädenkäänteellä.