Checkpoint: Интеграция реального Ollama Cloud API: серверный прокси (tRPC), Dashboard с live-статусом подключения и количеством моделей, Chat с реальными ответами LLM и выбором модели, Settings с живым списком 34 моделей. Все 4 vitest теста пройдены.

2026-03-20 16:03:01 -04:00
parent ac674815f2
commit b18e6e244f
53 changed files with 7358 additions and 377 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -44,6 +44,7 @@ pids
 *.pid
 *.seed
 *.pid.lock
+*.bak

 # Coverage directory used by tools like istanbul
 coverage/
--- a/.prettierignore
+++ b/.prettierignore
@@ -1,5 +1,35 @@
-dist
-node_modules
-.git
-*.min.js
-*.min.css
+# Dependencies
+node_modules/
+.pnpm-store/
+
+# Build outputs
+dist/
+build/
+*.dist
+
+# Generated files
+*.tsbuildinfo
+coverage/
+
+# Package files
+package-lock.json
+pnpm-lock.yaml
+
+# Database
+*.db
+*.sqlite
+*.sqlite3
+
+# Logs
+*.log
+
+# Environment files
+.env*
+
+# IDE files
+.vscode/
+.idea/
+
+# OS files
+.DS_Store
+Thumbs.db
--- a/client/src/App.tsx
+++ b/client/src/App.tsx
@@ -10,8 +10,8 @@ import Agents from "./pages/Agents";
 import Chat from "./pages/Chat";
 import Settings from "./pages/Settings";
 import Nodes from "./pages/Nodes";
-
 function Router() {
+  // make sure to consider if you need authentication for certain routes
  return (
    <DashboardLayout>
      <Switch>
--- a/client/src/_core/hooks/useAuth.ts
+++ b/client/src/_core/hooks/useAuth.ts
@@ -0,0 +1,84 @@
+import { getLoginUrl } from "@/const";
+import { trpc } from "@/lib/trpc";
+import { TRPCClientError } from "@trpc/client";
+import { useCallback, useEffect, useMemo } from "react";
+
+type UseAuthOptions = {
+  redirectOnUnauthenticated?: boolean;
+  redirectPath?: string;
+};
+
+export function useAuth(options?: UseAuthOptions) {
+  const { redirectOnUnauthenticated = false, redirectPath = getLoginUrl() } =
+    options ?? {};
+  const utils = trpc.useUtils();
+
+  const meQuery = trpc.auth.me.useQuery(undefined, {
+    retry: false,
+    refetchOnWindowFocus: false,
+  });
+
+  const logoutMutation = trpc.auth.logout.useMutation({
+    onSuccess: () => {
+      utils.auth.me.setData(undefined, null);
+    },
+  });
+
+  const logout = useCallback(async () => {
+    try {
+      await logoutMutation.mutateAsync();
+    } catch (error: unknown) {
+      if (
+        error instanceof TRPCClientError &&
+        error.data?.code === "UNAUTHORIZED"
+      ) {
+        return;
+      }
+      throw error;
+    } finally {
+      utils.auth.me.setData(undefined, null);
+      await utils.auth.me.invalidate();
+    }
+  }, [logoutMutation, utils]);
+
+  const state = useMemo(() => {
+    localStorage.setItem(
+      "manus-runtime-user-info",
+      JSON.stringify(meQuery.data)
+    );
+    return {
+      user: meQuery.data ?? null,
+      loading: meQuery.isLoading || logoutMutation.isPending,
+      error: meQuery.error ?? logoutMutation.error ?? null,
+      isAuthenticated: Boolean(meQuery.data),
+    };
+  }, [
+    meQuery.data,
+    meQuery.error,
+    meQuery.isLoading,
+    logoutMutation.error,
+    logoutMutation.isPending,
+  ]);
+
+  useEffect(() => {
+    if (!redirectOnUnauthenticated) return;
+    if (meQuery.isLoading || logoutMutation.isPending) return;
+    if (state.user) return;
+    if (typeof window === "undefined") return;
+    if (window.location.pathname === redirectPath) return;
+
+    window.location.href = redirectPath
+  }, [
+    redirectOnUnauthenticated,
+    redirectPath,
+    logoutMutation.isPending,
+    meQuery.isLoading,
+    state.user,
+  ]);
+
+  return {
+    ...state,
+    refresh: () => meQuery.refetch(),
+    logout,
+  };
+}
--- a/client/src/components/AIChatBox.tsx
+++ b/client/src/components/AIChatBox.tsx
@@ -0,0 +1,335 @@
+import { Button } from "@/components/ui/button";
+import { Textarea } from "@/components/ui/textarea";
+import { ScrollArea } from "@/components/ui/scroll-area";
+import { cn } from "@/lib/utils";
+import { Loader2, Send, User, Sparkles } from "lucide-react";
+import { useState, useEffect, useRef } from "react";
+import { Streamdown } from "streamdown";
+
+/**
+ * Message type matching server-side LLM Message interface
+ */
+export type Message = {
+  role: "system" | "user" | "assistant";
+  content: string;
+};
+
+export type AIChatBoxProps = {
+  /**
+   * Messages array to display in the chat.
+   * Should match the format used by invokeLLM on the server.
+   */
+  messages: Message[];
+
+  /**
+   * Callback when user sends a message.
+   * Typically you'll call a tRPC mutation here to invoke the LLM.
+   */
+  onSendMessage: (content: string) => void;
+
+  /**
+   * Whether the AI is currently generating a response
+   */
+  isLoading?: boolean;
+
+  /**
+   * Placeholder text for the input field
+   */
+  placeholder?: string;
+
+  /**
+   * Custom className for the container
+   */
+  className?: string;
+
+  /**
+   * Height of the chat box (default: 600px)
+   */
+  height?: string | number;
+
+  /**
+   * Empty state message to display when no messages
+   */
+  emptyStateMessage?: string;
+
+  /**
+   * Suggested prompts to display in empty state
+   * Click to send directly
+   */
+  suggestedPrompts?: string[];
+};
+
+/**
+ * A ready-to-use AI chat box component that integrates with the LLM system.
+ *
+ * Features:
+ * - Matches server-side Message interface for seamless integration
+ * - Markdown rendering with Streamdown
+ * - Auto-scrolls to latest message
+ * - Loading states
+ * - Uses global theme colors from index.css
+ *
+ * @example
+ * ```tsx
+ * const ChatPage = () => {
+ *   const [messages, setMessages] = useState<Message[]>([
+ *     { role: "system", content: "You are a helpful assistant." }
+ *   ]);
+ *
+ *   const chatMutation = trpc.ai.chat.useMutation({
+ *     onSuccess: (response) => {
+ *       // Assuming your tRPC endpoint returns the AI response as a string
+ *       setMessages(prev => [...prev, {
+ *         role: "assistant",
+ *         content: response
+ *       }]);
+ *     },
+ *     onError: (error) => {
+ *       console.error("Chat error:", error);
+ *       // Optionally show error message to user
+ *     }
+ *   });
+ *
+ *   const handleSend = (content: string) => {
+ *     const newMessages = [...messages, { role: "user", content }];
+ *     setMessages(newMessages);
+ *     chatMutation.mutate({ messages: newMessages });
+ *   };
+ *
+ *   return (
+ *     <AIChatBox
+ *       messages={messages}
+ *       onSendMessage={handleSend}
+ *       isLoading={chatMutation.isPending}
+ *       suggestedPrompts={[
+ *         "Explain quantum computing",
+ *         "Write a hello world in Python"
+ *       ]}
+ *     />
+ *   );
+ * };
+ * ```
+ */
+export function AIChatBox({
+  messages,
+  onSendMessage,
+  isLoading = false,
+  placeholder = "Type your message...",
+  className,
+  height = "600px",
+  emptyStateMessage = "Start a conversation with AI",
+  suggestedPrompts,
+}: AIChatBoxProps) {
+  const [input, setInput] = useState("");
+  const scrollAreaRef = useRef<HTMLDivElement>(null);
+  const containerRef = useRef<HTMLDivElement>(null);
+  const inputAreaRef = useRef<HTMLFormElement>(null);
+  const textareaRef = useRef<HTMLTextAreaElement>(null);
+
+  // Filter out system messages
+  const displayMessages = messages.filter((msg) => msg.role !== "system");
+
+  // Calculate min-height for last assistant message to push user message to top
+  const [minHeightForLastMessage, setMinHeightForLastMessage] = useState(0);
+
+  useEffect(() => {
+    if (containerRef.current && inputAreaRef.current) {
+      const containerHeight = containerRef.current.offsetHeight;
+      const inputHeight = inputAreaRef.current.offsetHeight;
+      const scrollAreaHeight = containerHeight - inputHeight;
+
+      // Reserve space for:
+      // - padding (p-4 = 32px top+bottom)
+      // - user message: 40px (item height) + 16px (margin-top from space-y-4) = 56px
+      // Note: margin-bottom is not counted because it naturally pushes the assistant message down
+      const userMessageReservedHeight = 56;
+      const calculatedHeight = scrollAreaHeight - 32 - userMessageReservedHeight;
+
+      setMinHeightForLastMessage(Math.max(0, calculatedHeight));
+    }
+  }, []);
+
+  // Scroll to bottom helper function with smooth animation
+  const scrollToBottom = () => {
+    const viewport = scrollAreaRef.current?.querySelector(
+      '[data-radix-scroll-area-viewport]'
+    ) as HTMLDivElement;
+
+    if (viewport) {
+      requestAnimationFrame(() => {
+        viewport.scrollTo({
+          top: viewport.scrollHeight,
+          behavior: 'smooth'
+        });
+      });
+    }
+  };
+
+  const handleSubmit = (e: React.FormEvent) => {
+    e.preventDefault();
+    const trimmedInput = input.trim();
+    if (!trimmedInput || isLoading) return;
+
+    onSendMessage(trimmedInput);
+    setInput("");
+
+    // Scroll immediately after sending
+    scrollToBottom();
+
+    // Keep focus on input
+    textareaRef.current?.focus();
+  };
+
+  const handleKeyDown = (e: React.KeyboardEvent<HTMLTextAreaElement>) => {
+    if (e.key === "Enter" && !e.shiftKey) {
+      e.preventDefault();
+      handleSubmit(e);
+    }
+  };
+
+  return (
+    <div
+      ref={containerRef}
+      className={cn(
+        "flex flex-col bg-card text-card-foreground rounded-lg border shadow-sm",
+        className
+      )}
+      style={{ height }}
+    >
+      {/* Messages Area */}
+      <div ref={scrollAreaRef} className="flex-1 overflow-hidden">
+        {displayMessages.length === 0 ? (
+          <div className="flex h-full flex-col p-4">
+            <div className="flex flex-1 flex-col items-center justify-center gap-6 text-muted-foreground">
+              <div className="flex flex-col items-center gap-3">
+                <Sparkles className="size-12 opacity-20" />
+                <p className="text-sm">{emptyStateMessage}</p>
+              </div>
+
+              {suggestedPrompts && suggestedPrompts.length > 0 && (
+                <div className="flex max-w-2xl flex-wrap justify-center gap-2">
+                  {suggestedPrompts.map((prompt, index) => (
+                    <button
+                      key={index}
+                      onClick={() => onSendMessage(prompt)}
+                      disabled={isLoading}
+                      className="rounded-lg border border-border bg-card px-4 py-2 text-sm transition-colors hover:bg-accent disabled:cursor-not-allowed disabled:opacity-50"
+                    >
+                      {prompt}
+                    </button>
+                  ))}
+                </div>
+              )}
+            </div>
+          </div>
+        ) : (
+          <ScrollArea className="h-full">
+            <div className="flex flex-col space-y-4 p-4">
+              {displayMessages.map((message, index) => {
+                // Apply min-height to last message only if NOT loading (when loading, the loading indicator gets it)
+                const isLastMessage = index === displayMessages.length - 1;
+                const shouldApplyMinHeight =
+                  isLastMessage && !isLoading && minHeightForLastMessage > 0;
+
+                return (
+                  <div
+                    key={index}
+                    className={cn(
+                      "flex gap-3",
+                      message.role === "user"
+                        ? "justify-end items-start"
+                        : "justify-start items-start"
+                    )}
+                    style={
+                      shouldApplyMinHeight
+                        ? { minHeight: `${minHeightForLastMessage}px` }
+                        : undefined
+                    }
+                  >
+                    {message.role === "assistant" && (
+                      <div className="size-8 shrink-0 mt-1 rounded-full bg-primary/10 flex items-center justify-center">
+                        <Sparkles className="size-4 text-primary" />
+                      </div>
+                    )}
+
+                    <div
+                      className={cn(
+                        "max-w-[80%] rounded-lg px-4 py-2.5",
+                        message.role === "user"
+                          ? "bg-primary text-primary-foreground"
+                          : "bg-muted text-foreground"
+                      )}
+                    >
+                      {message.role === "assistant" ? (
+                        <div className="prose prose-sm dark:prose-invert max-w-none">
+                          <Streamdown>{message.content}</Streamdown>
+                        </div>
+                      ) : (
+                        <p className="whitespace-pre-wrap text-sm">
+                          {message.content}
+                        </p>
+                      )}
+                    </div>
+
+                    {message.role === "user" && (
+                      <div className="size-8 shrink-0 mt-1 rounded-full bg-secondary flex items-center justify-center">
+                        <User className="size-4 text-secondary-foreground" />
+                      </div>
+                    )}
+                  </div>
+                );
+              })}
+
+              {isLoading && (
+                <div
+                  className="flex items-start gap-3"
+                  style={
+                    minHeightForLastMessage > 0
+                      ? { minHeight: `${minHeightForLastMessage}px` }
+                      : undefined
+                  }
+                >
+                  <div className="size-8 shrink-0 mt-1 rounded-full bg-primary/10 flex items-center justify-center">
+                    <Sparkles className="size-4 text-primary" />
+                  </div>
+                  <div className="rounded-lg bg-muted px-4 py-2.5">
+                    <Loader2 className="size-4 animate-spin text-muted-foreground" />
+                  </div>
+                </div>
+              )}
+            </div>
+          </ScrollArea>
+        )}
+      </div>
+
+      {/* Input Area */}
+      <form
+        ref={inputAreaRef}
+        onSubmit={handleSubmit}
+        className="flex gap-2 p-4 border-t bg-background/50 items-end"
+      >
+        <Textarea
+          ref={textareaRef}
+          value={input}
+          onChange={(e) => setInput(e.target.value)}
+          onKeyDown={handleKeyDown}
+          placeholder={placeholder}
+          className="flex-1 max-h-32 resize-none min-h-9"
+          rows={1}
+        />
+        <Button
+          type="submit"
+          size="icon"
+          disabled={!input.trim() || isLoading}
+          className="shrink-0 h-[38px] w-[38px]"
+        >
+          {isLoading ? (
+            <Loader2 className="size-4 animate-spin" />
+          ) : (
+            <Send className="size-4" />
+          )}
+        </Button>
+      </form>
+    </div>
+  );
+}
--- a/client/src/components/DashboardLayoutSkeleton.tsx
+++ b/client/src/components/DashboardLayoutSkeleton.tsx
@@ -0,0 +1,46 @@
+import { Skeleton } from './ui/skeleton';
+
+export function DashboardLayoutSkeleton() {
+  return (
+    <div className="flex min-h-screen bg-background">
+      {/* Sidebar skeleton */}
+      <div className="w-[280px] border-r border-border bg-background p-4 space-y-6">
+        {/* Logo area */}
+        <div className="flex items-center gap-3 px-2">
+          <Skeleton className="h-8 w-8 rounded-md" />
+          <Skeleton className="h-4 w-24" />
+        </div>
+
+        {/* Menu items */}
+        <div className="space-y-2 px-2">
+          <Skeleton className="h-10 w-full rounded-lg" />
+          <Skeleton className="h-10 w-full rounded-lg" />
+          <Skeleton className="h-10 w-full rounded-lg" />
+        </div>
+
+        {/* User profile area at bottom */}
+        <div className="absolute bottom-4 left-4 right-4">
+          <div className="flex items-center gap-3 px-1">
+            <Skeleton className="h-9 w-9 rounded-full" />
+            <div className="flex-1 space-y-2">
+              <Skeleton className="h-3 w-20" />
+              <Skeleton className="h-2 w-32" />
+            </div>
+          </div>
+        </div>
+      </div>
+
+      {/* Main content skeleton */}
+      <div className="flex-1 p-4 space-y-4">
+        {/* Content blocks */}
+        <Skeleton className="h-12 w-48 rounded-lg" />
+        <div className="grid gap-4 md:grid-cols-2 lg:grid-cols-3">
+          <Skeleton className="h-32 rounded-xl" />
+          <Skeleton className="h-32 rounded-xl" />
+          <Skeleton className="h-32 rounded-xl" />
+        </div>
+        <Skeleton className="h-64 rounded-xl" />
+      </div>
+    </div>
+  );
+}
--- a/client/src/components/ManusDialog.tsx
+++ b/client/src/components/ManusDialog.tsx
@@ -55,7 +55,11 @@ export function ManusDialog({
        <div className="flex flex-col items-center gap-2 p-5 pt-12">
          {logo ? (
            <div className="w-16 h-16 bg-white rounded-xl border border-[rgba(0,0,0,0.08)] flex items-center justify-center">
-              <img src={logo} alt="Dialog graphic" className="w-10 h-10 rounded-md" />
+              <img
+                src={logo}
+                alt="Dialog graphic"
+                className="w-10 h-10 rounded-md"
+              />
            </div>
          ) : null}

--- a/client/src/lib/trpc.ts
+++ b/client/src/lib/trpc.ts
@@ -0,0 +1,4 @@
+import { createTRPCReact } from "@trpc/react-query";
+import type { AppRouter } from "../../../server/routers";
+
+export const trpc = createTRPCReact<AppRouter>();
--- a/client/src/main.tsx
+++ b/client/src/main.tsx
@@ -1,5 +1,61 @@
+import { trpc } from "@/lib/trpc";
+import { UNAUTHED_ERR_MSG } from '@shared/const';
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import { httpBatchLink, TRPCClientError } from "@trpc/client";
 import { createRoot } from "react-dom/client";
+import superjson from "superjson";
 import App from "./App";
+import { getLoginUrl } from "./const";
 import "./index.css";

-createRoot(document.getElementById("root")!).render(<App />);
+const queryClient = new QueryClient();
+
+const redirectToLoginIfUnauthorized = (error: unknown) => {
+  if (!(error instanceof TRPCClientError)) return;
+  if (typeof window === "undefined") return;
+
+  const isUnauthorized = error.message === UNAUTHED_ERR_MSG;
+
+  if (!isUnauthorized) return;
+
+  window.location.href = getLoginUrl();
+};
+
+queryClient.getQueryCache().subscribe(event => {
+  if (event.type === "updated" && event.action.type === "error") {
+    const error = event.query.state.error;
+    redirectToLoginIfUnauthorized(error);
+    console.error("[API Query Error]", error);
+  }
+});
+
+queryClient.getMutationCache().subscribe(event => {
+  if (event.type === "updated" && event.action.type === "error") {
+    const error = event.mutation.state.error;
+    redirectToLoginIfUnauthorized(error);
+    console.error("[API Mutation Error]", error);
+  }
+});
+
+const trpcClient = trpc.createClient({
+  links: [
+    httpBatchLink({
+      url: "/api/trpc",
+      transformer: superjson,
+      fetch(input, init) {
+        return globalThis.fetch(input, {
+          ...(init ?? {}),
+          credentials: "include",
+        });
+      },
+    }),
+  ],
+});
+
+createRoot(document.getElementById("root")!).render(
+  <trpc.Provider client={trpcClient} queryClient={queryClient}>
+    <QueryClientProvider client={queryClient}>
+      <App />
+    </QueryClientProvider>
+  </trpc.Provider>
+);
--- a/client/src/pages/Chat.tsx
+++ b/client/src/pages/Chat.tsx
@@ -1,5 +1,5 @@
 /*
- * Chat — Terminal-style chat with GoClaw Orchestrator
+ * Chat — Terminal-style chat with GoClaw Orchestrator + Real Ollama LLM
 * Design: Terminal aesthetic, monospace font, typing animation, command history
 * Colors: Cyan for system, green for success, amber for warnings, white for user
 * Typography: JetBrains Mono exclusively
@@ -7,10 +7,11 @@
 import { Card, CardContent } from "@/components/ui/card";
 import { Button } from "@/components/ui/button";
 import { Input } from "@/components/ui/input";
-import { ScrollArea } from "@/components/ui/scroll-area";
-import { Send, Terminal, Bot, User, Zap, AlertTriangle, CheckCircle, Info } from "lucide-react";
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select";
+import { Send, Terminal, Bot, User, AlertTriangle, CheckCircle, Info, Loader2, Brain } from "lucide-react";
 import { motion, AnimatePresence } from "framer-motion";
 import { useState, useRef, useEffect } from "react";
+import { trpc } from "@/lib/trpc";

 interface ChatMessage {
  id: string;
@@ -21,131 +22,10 @@ interface ChatMessage {
  agent?: string;
 }

-const INITIAL_MESSAGES: ChatMessage[] = [
-  {
-    id: "1",
-    role: "system",
-    content: "GoClaw Gateway v0.1.0 initialized. Connected to Swarm cluster 'goclaw-swarm' (4 nodes, 10 containers).",
-    timestamp: "19:20:00",
-    type: "info",
-  },
-  {
-    id: "2",
-    role: "system",
-    content: "Agent fleet loaded: 5 agents registered (4 active, 1 error).",
-    timestamp: "19:20:01",
-    type: "success",
-  },
-  {
-    id: "3",
-    role: "system",
-    content: "⚠ Docs Agent (agent-docs) failed to connect to Anthropic API. Check API key in settings.",
-    timestamp: "19:20:02",
-    type: "warning",
-  },
-  {
-    id: "4",
-    role: "user",
-    content: "Покажи статус всех агентов",
-    timestamp: "19:21:15",
-    type: "command",
-  },
-  {
-    id: "5",
-    role: "agent",
-    content: `Agent Status Report:
-┌─────────────────┬──────────┬───────────────────┬────────┐
-│ Agent           │ Status   │ Model             │ Tasks  │
-├─────────────────┼──────────┼───────────────────┼────────┤
-│ Coder Agent     │ RUNNING  │ claude-3.5-sonnet │ 3      │
-│ Browser Agent   │ RUNNING  │ gpt-4o            │ 1      │
-│ Mail Agent      │ IDLE     │ gpt-4o-mini       │ 0      │
-│ Monitor Agent   │ RUNNING  │ llama-3.1-8b      │ 5      │
-│ Docs Agent      │ ERROR    │ claude-3-haiku    │ 0      │
-└─────────────────┴──────────┴───────────────────┴────────┘`,
-    timestamp: "19:21:16",
-    type: "info",
-    agent: "Gateway",
-  },
-  {
-    id: "6",
-    role: "user",
-    content: "Перезапусти Docs Agent",
-    timestamp: "19:22:30",
-    type: "command",
-  },
-  {
-    id: "7",
-    role: "agent",
-    content: "Restarting agent-docs on node goclaw-worker-02... Container recreated. Waiting for health check...",
-    timestamp: "19:22:31",
-    type: "info",
-    agent: "Gateway",
-  },
-  {
-    id: "8",
-    role: "system",
-    content: "✗ Docs Agent restart failed: API key invalid. Please update ANTHROPIC_API_KEY in Settings → API Keys.",
-    timestamp: "19:22:35",
-    type: "error",
-  },
-];
-
-const DEMO_RESPONSES: Record<string, ChatMessage> = {
-  "помощь": {
-    id: "",
-    role: "agent",
-    content: `Available Commands:
-  status          — Show all agents status
-  nodes           — Show cluster nodes
-  restart <agent> — Restart an agent
-  deploy <spec>   — Deploy new agent from spec
-  logs <agent>    — Show agent logs
-  scale <agent> N — Scale agent replicas
-  models          — List available LLM models
-  config          — Show gateway configuration
-  help            — Show this help message`,
-    timestamp: "",
-    type: "info",
-    agent: "Gateway",
-  },
-  "models": {
-    id: "",
-    role: "agent",
-    content: `Available LLM Models:
-┌───────────────────────┬──────────┬─────────────┬──────────┐
-│ Model                 │ Provider │ Type        │ Status   │
-├───────────────────────┼──────────┼─────────────┼──────────┤
-│ gpt-4o                │ OpenAI   │ Cloud       │ ✓ Ready  │
-│ gpt-4o-mini           │ OpenAI   │ Cloud       │ ✓ Ready  │
-│ claude-3.5-sonnet     │ Anthropic│ Cloud       │ ✓ Ready  │
-│ claude-3-haiku        │ Anthropic│ Cloud       │ ✗ No Key │
-│ llama-3.1-8b          │ Ollama   │ Local       │ ✓ Ready  │
-│ llama-3.1-70b         │ Ollama   │ Local       │ ✓ Ready  │
-│ codestral-22b         │ Ollama   │ Local       │ ○ Loading│
-│ qwen2.5-coder-7b     │ Ollama   │ Local       │ ✓ Ready  │
-└───────────────────────┴──────────┴─────────────┴──────────┘`,
-    timestamp: "",
-    type: "info",
-    agent: "Gateway",
-  },
-  "nodes": {
-    id: "",
-    role: "agent",
-    content: `Swarm Nodes:
-┌─────────────────────┬─────────┬────────┬──────┬──────┬──────────┐
-│ Hostname            │ Role    │ Status │ CPU  │ MEM  │ Containers│
-├─────────────────────┼─────────┼────────┼──────┼──────┼──────────┤
-│ goclaw-manager-01   │ Manager │ Ready  │ 42%  │ 68%  │ 5        │
-│ goclaw-worker-01    │ Worker  │ Ready  │ 28%  │ 45%  │ 3        │
-│ goclaw-worker-02    │ Worker  │ Ready  │ 15%  │ 32%  │ 2        │
-│ goclaw-worker-03    │ Worker  │ Drain  │ 0%   │ 12%  │ 0        │
-└─────────────────────┴─────────┴────────┴──────┴──────┴──────────┘`,
-    timestamp: "",
-    type: "info",
-    agent: "Gateway",
-  },
-};
+function getTs() {
+  const now = new Date();
+  return `${now.getHours().toString().padStart(2, "0")}:${now.getMinutes().toString().padStart(2, "0")}:${now.getSeconds().toString().padStart(2, "0")}`;
+}

 function getMessageIcon(msg: ChatMessage) {
  if (msg.role === "user") return <User className="w-3.5 h-3.5" />;
@@ -168,23 +48,119 @@ function getMessageColor(msg: ChatMessage) {
  }
 }

+const SYSTEM_PROMPT = `You are GoClaw Gateway Orchestrator — an AI assistant managing a Docker Swarm cluster of specialized AI agents. You help the user monitor, control, and interact with their agent fleet. You respond concisely in a terminal-like style. You can discuss agent management, system monitoring, code development, and general tasks. Respond in the same language as the user's message.`;
+
 export default function Chat() {
-  const [messages, setMessages] = useState<ChatMessage[]>(INITIAL_MESSAGES);
+  const [messages, setMessages] = useState<ChatMessage[]>([
+    {
+      id: "boot-1",
+      role: "system",
+      content: "GoClaw Gateway v0.1.0 initialized. Connecting to Ollama Cloud API...",
+      timestamp: getTs(),
+      type: "info",
+    },
+  ]);
  const [input, setInput] = useState("");
+  const [selectedModel, setSelectedModel] = useState<string>("");
+  const [isThinking, setIsThinking] = useState(false);
  const scrollRef = useRef<HTMLDivElement>(null);
  const inputRef = useRef<HTMLInputElement>(null);

+  // Real data from Ollama API
+  const modelsQuery = trpc.ollama.models.useQuery();
+  const healthQuery = trpc.ollama.health.useQuery();
+  const chatMutation = trpc.ollama.chat.useMutation();
+
+  // Conversation history for context
+  const [conversationHistory, setConversationHistory] = useState<
+    { role: "system" | "user" | "assistant"; content: string }[]
+  >([{ role: "system", content: SYSTEM_PROMPT }]);
+
+  // Auto-select first model when loaded
+  useEffect(() => {
+    if (modelsQuery.data?.success && modelsQuery.data.models.length > 0 && !selectedModel) {
+      setSelectedModel(modelsQuery.data.models[0].id);
+    }
+  }, [modelsQuery.data, selectedModel]);
+
+  // Boot messages
+  useEffect(() => {
+    if (healthQuery.data) {
+      const ts = getTs();
+      if (healthQuery.data.connected) {
+        setMessages((prev) => {
+          if (prev.some((m) => m.id === "boot-health")) return prev;
+          return [
+            ...prev,
+            {
+              id: "boot-health",
+              role: "system",
+              content: `Ollama API connected (${healthQuery.data.latencyMs}ms latency). Ready for commands.`,
+              timestamp: ts,
+              type: "success",
+            },
+          ];
+        });
+      } else {
+        setMessages((prev) => {
+          if (prev.some((m) => m.id === "boot-health")) return prev;
+          return [
+            ...prev,
+            {
+              id: "boot-health",
+              role: "system",
+              content: `Ollama API connection failed: ${healthQuery.data.error}`,
+              timestamp: ts,
+              type: "error",
+            },
+          ];
+        });
+      }
+    }
+  }, [healthQuery.data]);
+
+  useEffect(() => {
+    if (modelsQuery.data?.success && modelsQuery.data.models.length > 0) {
+      const ts = getTs();
+      setMessages((prev) => {
+        if (prev.some((m) => m.id === "boot-models")) return prev;
+        return [
+          ...prev,
+          {
+            id: "boot-models",
+            role: "system",
+            content: `${modelsQuery.data.models.length} models available. Active model: ${modelsQuery.data.models[0].id}`,
+            timestamp: ts,
+            type: "info",
+          },
+        ];
+      });
+    }
+  }, [modelsQuery.data]);
+
  useEffect(() => {
    if (scrollRef.current) {
      scrollRef.current.scrollTop = scrollRef.current.scrollHeight;
    }
-  }, [messages]);
+  }, [messages, isThinking]);

-  const sendMessage = () => {
-    if (!input.trim()) return;
-    const now = new Date();
-    const ts = `${now.getHours().toString().padStart(2, "0")}:${now.getMinutes().toString().padStart(2, "0")}:${now.getSeconds().toString().padStart(2, "0")}`;
+  const sendMessage = async () => {
+    if (!input.trim() || isThinking) return;
+    if (!selectedModel) {
+      setMessages((prev) => [
+        ...prev,
+        {
+          id: `err-${Date.now()}`,
+          role: "system",
+          content: "No model selected. Please select a model from the dropdown above.",
+          timestamp: getTs(),
+          type: "error",
+        },
+      ]);
+      return;
+    }

+    const ts = getTs();
    const userMsg: ChatMessage = {
      id: `user-${Date.now()}`,
      role: "user",
@@ -194,29 +170,79 @@ export default function Chat() {
    };
    setMessages((prev) => [...prev, userMsg]);

-    const lowerInput = input.toLowerCase().trim();
-    const responseKey = Object.keys(DEMO_RESPONSES).find((k) => lowerInput.includes(k));
-
-    setTimeout(() => {
-      if (responseKey) {
-        const resp = { ...DEMO_RESPONSES[responseKey], id: `resp-${Date.now()}`, timestamp: ts };
-        setMessages((prev) => [...prev, resp]);
-      } else {
-        const fallback: ChatMessage = {
-          id: `resp-${Date.now()}`,
-          role: "agent",
-          content: `Обрабатываю команду: "${input}"\nДля списка доступных команд введите "помощь" или "help".`,
-          timestamp: ts,
-          type: "info",
-          agent: "Gateway",
-        };
-        setMessages((prev) => [...prev, fallback]);
-      }
-    }, 300);
-
+    const newHistory = [...conversationHistory, { role: "user" as const, content: input }];
+    setConversationHistory(newHistory);
    setInput("");
+    setIsThinking(true);
+
+    try {
+      const result = await chatMutation.mutateAsync({
+        model: selectedModel,
+        messages: newHistory,
+        temperature: 0.7,
+        max_tokens: 2048,
+      });
+
+      const respTs = getTs();
+      if (result.success) {
+        const assistantContent = result.response || "(empty response)";
+        setConversationHistory((prev) => [
+          ...prev,
+          { role: "assistant", content: assistantContent },
+        ]);
+        setMessages((prev) => [
+          ...prev,
+          {
+            id: `resp-${Date.now()}`,
+            role: "agent",
+            content: assistantContent,
+            timestamp: respTs,
+            type: "info",
+            agent: result.model || selectedModel,
+          },
+        ]);
+        if (result.usage) {
+          setMessages((prev) => [
+            ...prev,
+            {
+              id: `usage-${Date.now()}`,
+              role: "system",
+              content: `tokens: ${result.usage!.prompt_tokens} prompt + ${result.usage!.completion_tokens} completion = ${result.usage!.total_tokens} total`,
+              timestamp: respTs,
+              type: "info",
+            },
+          ]);
+        }
+      } else {
+        setMessages((prev) => [
+          ...prev,
+          {
+            id: `err-${Date.now()}`,
+            role: "system",
+            content: `LLM Error: ${result.error}`,
+            timestamp: respTs,
+            type: "error",
+          },
+        ]);
+      }
+    } catch (err: any) {
+      setMessages((prev) => [
+        ...prev,
+        {
+          id: `err-${Date.now()}`,
+          role: "system",
+          content: `Network Error: ${err.message}`,
+          timestamp: getTs(),
+          type: "error",
+        },
+      ]);
+    } finally {
+      setIsThinking(false);
+    }
  };

+  const models = modelsQuery.data?.success ? modelsQuery.data.models : [];
+
  return (
    <div className="h-full flex flex-col gap-4">
      {/* Header */}
@@ -228,13 +254,36 @@ export default function Chat() {
          <div>
            <h2 className="text-lg font-bold text-foreground">Gateway Terminal</h2>
            <p className="text-[11px] font-mono text-muted-foreground">
-              Connected to <span className="text-primary">goclaw-gateway:18789</span>
+              Connected to <span className="text-primary">Ollama Cloud API</span>
+              {healthQuery.data?.connected && (
+                <span className="text-neon-green ml-2">({healthQuery.data.latencyMs}ms)</span>
+              )}
            </p>
          </div>
        </div>
-        <div className="flex items-center gap-2">
-          <div className="w-2 h-2 rounded-full bg-neon-green pulse-indicator" />
-          <span className="text-[11px] font-mono text-neon-green">LIVE</span>
+        <div className="flex items-center gap-3">
+          {/* Model selector */}
+          <div className="flex items-center gap-2">
+            <Brain className="w-3.5 h-3.5 text-primary" />
+            <Select value={selectedModel} onValueChange={setSelectedModel}>
+              <SelectTrigger className="w-56 h-8 bg-secondary/50 border-border/50 font-mono text-xs">
+                <SelectValue placeholder={modelsQuery.isLoading ? "Loading models..." : "Select model"} />
+              </SelectTrigger>
+              <SelectContent className="bg-popover border-border/50">
+                {models.map((m) => (
+                  <SelectItem key={m.id} value={m.id} className="font-mono text-xs">
+                    {m.id}
+                  </SelectItem>
+                ))}
+              </SelectContent>
+            </Select>
+          </div>
+          <div className="flex items-center gap-2">
+            <div className={`w-2 h-2 rounded-full ${healthQuery.data?.connected ? "bg-neon-green pulse-indicator" : "bg-neon-red"}`} />
+            <span className={`text-[11px] font-mono ${healthQuery.data?.connected ? "text-neon-green" : "text-neon-red"}`}>
+              {healthQuery.data?.connected ? "LIVE" : "OFFLINE"}
+            </span>
+          </div>
        </div>
      </div>

@@ -270,11 +319,28 @@ export default function Chat() {
                </motion.div>
              ))}
            </AnimatePresence>
+
+            {/* Thinking indicator */}
+            {isThinking && (
+              <motion.div
+                initial={{ opacity: 0 }}
+                animate={{ opacity: 1 }}
+                className="flex items-center gap-2 text-primary font-mono text-xs"
+              >
+                <Loader2 className="w-3.5 h-3.5 animate-spin" />
+                <span className="text-muted-foreground">
+                  {selectedModel} is thinking...
+                </span>
+              </motion.div>
+            )}
+
            {/* Terminal cursor */}
-            <div className="flex items-center gap-1 text-primary font-mono text-xs">
-              <span className="text-muted-foreground">$</span>
-              <span className="w-2 h-4 bg-primary terminal-cursor" />
-            </div>
+            {!isThinking && (
+              <div className="flex items-center gap-1 text-primary font-mono text-xs">
+                <span className="text-muted-foreground">$</span>
+                <span className="w-2 h-4 bg-primary terminal-cursor" />
+              </div>
+            )}
          </div>

          {/* Input area */}
@@ -286,15 +352,21 @@ export default function Chat() {
                value={input}
                onChange={(e) => setInput(e.target.value)}
                onKeyDown={(e) => e.key === "Enter" && sendMessage()}
-                placeholder="Введите команду или сообщение для оркестратора..."
+                placeholder={isThinking ? "Ожидание ответа..." : "Введите сообщение для оркестратора..."}
+                disabled={isThinking}
                className="bg-transparent border-none text-foreground font-mono text-sm placeholder:text-muted-foreground/50 focus-visible:ring-0 focus-visible:ring-offset-0 h-8"
              />
              <Button
                size="sm"
                onClick={sendMessage}
+                disabled={isThinking || !input.trim()}
                className="bg-primary/15 text-primary border border-primary/30 hover:bg-primary/25 h-8 w-8 p-0"
              >
-                <Send className="w-3.5 h-3.5" />
+                {isThinking ? (
+                  <Loader2 className="w-3.5 h-3.5 animate-spin" />
+                ) : (
+                  <Send className="w-3.5 h-3.5" />
+                )}
              </Button>
            </div>
          </div>
--- a/client/src/pages/ComponentShowcase.tsx
+++ b/client/src/pages/ComponentShowcase.tsx
--- a/client/src/pages/Dashboard.tsx
+++ b/client/src/pages/Dashboard.tsx
@@ -3,6 +3,7 @@
 * Design: Grid of metric cards, node status, agent activity feed, cluster health
 * Colors: Cyan glow for primary metrics, green/amber/red for status
 * Typography: JetBrains Mono for all data values
+ * Now with REAL Ollama API data integration
 */
 import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
 import { Badge } from "@/components/ui/badge";
@@ -11,15 +12,18 @@ import {
  Server,
  Bot,
  Cpu,
-  HardDrive,
  Activity,
  ArrowUpRight,
  ArrowDownRight,
-  Clock,
  Zap,
  Network,
+  Brain,
+  CheckCircle,
+  XCircle,
+  Loader2,
 } from "lucide-react";
 import { motion } from "framer-motion";
+import { trpc } from "@/lib/trpc";

 const HERO_BG = "https://d2xsxph8kpxj0f.cloudfront.net/97147719/ZEGAT83geRq9CNvryykaQv/hero-bg-Si4yCvZwFbZMP4XaHUueFi.webp";
 const SWARM_IMG = "https://d2xsxph8kpxj0f.cloudfront.net/97147719/ZEGAT83geRq9CNvryykaQv/swarm-cluster-jkxdea5N7sXTSZfbAbKCfs.webp";
@@ -80,6 +84,18 @@ function getStatusBadge(status: string) {
 }

 export default function Dashboard() {
+  // Real data from Ollama API
+  const healthQuery = trpc.ollama.health.useQuery(undefined, {
+    refetchInterval: 30_000,
+  });
+  const modelsQuery = trpc.ollama.models.useQuery(undefined, {
+    refetchInterval: 60_000,
+  });
+
+  const ollamaConnected = healthQuery.data?.connected ?? false;
+  const ollamaLatency = healthQuery.data?.latencyMs ?? 0;
+  const modelCount = modelsQuery.data?.success ? modelsQuery.data.models.length : 0;
+
  return (
    <div className="space-y-6">
      {/* Hero banner */}
@@ -107,6 +123,55 @@ export default function Dashboard() {
        </div>
      </motion.div>

+      {/* Ollama API Status Banner */}
+      <motion.div
+        initial={{ opacity: 0, y: 5 }}
+        animate={{ opacity: 1, y: 0 }}
+        transition={{ delay: 0.2 }}
+      >
+        <Card className={`border ${ollamaConnected ? "border-neon-green/30 bg-neon-green/5" : healthQuery.isLoading ? "border-primary/30 bg-primary/5" : "border-neon-red/30 bg-neon-red/5"}`}>
+          <CardContent className="p-4">
+            <div className="flex items-center justify-between">
+              <div className="flex items-center gap-3">
+                {healthQuery.isLoading ? (
+                  <Loader2 className="w-5 h-5 text-primary animate-spin" />
+                ) : ollamaConnected ? (
+                  <CheckCircle className="w-5 h-5 text-neon-green" />
+                ) : (
+                  <XCircle className="w-5 h-5 text-neon-red" />
+                )}
+                <div>
+                  <div className="text-sm font-semibold text-foreground flex items-center gap-2">
+                    Ollama Cloud API
+                    <Badge variant="outline" className={`text-[9px] font-mono ${ollamaConnected ? "bg-neon-green/15 text-neon-green border-neon-green/30" : "bg-neon-red/15 text-neon-red border-neon-red/30"}`}>
+                      {healthQuery.isLoading ? "CHECKING..." : ollamaConnected ? "CONNECTED" : "OFFLINE"}
+                    </Badge>
+                  </div>
+                  <div className="text-[11px] font-mono text-muted-foreground">
+                    https://ollama.com/v1
+                    {ollamaConnected && <span className="text-neon-green ml-2">&middot; {ollamaLatency}ms latency &middot; {modelCount} models available</span>}
+                  </div>
+                </div>
+              </div>
+              <div className="flex items-center gap-4 text-[11px] font-mono">
+                {ollamaConnected && (
+                  <>
+                    <div className="text-center">
+                      <div className="text-lg font-bold text-primary">{modelCount}</div>
+                      <div className="text-muted-foreground">Models</div>
+                    </div>
+                    <div className="text-center">
+                      <div className="text-lg font-bold text-neon-green">{ollamaLatency}ms</div>
+                      <div className="text-muted-foreground">Latency</div>
+                    </div>
+                  </>
+                )}
+              </div>
+            </div>
+          </CardContent>
+        </Card>
+      </motion.div>
+
      {/* Key metrics row */}
      <div className="grid grid-cols-2 lg:grid-cols-4 gap-4">
        <MetricCard
@@ -126,20 +191,20 @@ export default function Dashboard() {
          color="text-neon-green"
        />
        <MetricCard
-          icon={Zap}
-          label="Задачи / мин"
-          value="12.4"
-          change="+2.1"
-          trend="up"
-          color="text-neon-amber"
+          icon={Brain}
+          label="LLM Модели"
+          value={modelsQuery.isLoading ? "..." : String(modelCount)}
+          change={ollamaConnected ? "Ollama" : "offline"}
+          trend={ollamaConnected ? "up" : "down"}
+          color="text-primary"
        />
        <MetricCard
-          icon={Network}
-          label="API запросы"
-          value="1,247"
-          change="сегодня"
-          trend="up"
-          color="text-primary"
+          icon={Zap}
+          label="API Latency"
+          value={healthQuery.isLoading ? "..." : `${ollamaLatency}ms`}
+          change={ollamaConnected ? "connected" : "error"}
+          trend={ollamaConnected ? "up" : "down"}
+          color="text-neon-amber"
        />
      </div>

--- a/client/src/pages/Home.tsx
+++ b/client/src/pages/Home.tsx
@@ -1,5 +1,5 @@
-import { Redirect } from "wouter";
+import Dashboard from "./Dashboard";

 export default function Home() {
-  return <Redirect to="/" />;
+  return <Dashboard />;
 }
--- a/client/src/pages/NotFound.tsx
+++ b/client/src/pages/NotFound.tsx
@@ -33,7 +33,10 @@ export default function NotFound() {
            It may have been moved or deleted.
          </p>

-          <div className="flex flex-col sm:flex-row gap-3 justify-center">
+          <div
+            id="not-found-button-group"
+            className="flex flex-col sm:flex-row gap-3 justify-center"
+          >
            <Button
              onClick={handleGoHome}
              className="bg-blue-600 hover:bg-blue-700 text-white px-6 py-2.5 rounded-lg transition-all duration-200 shadow-md hover:shadow-lg"
--- a/client/src/pages/Settings.tsx
+++ b/client/src/pages/Settings.tsx
@@ -1,8 +1,6 @@
 /*
 * Settings — API Keys, Model Providers, Gateway Configuration
- * Design: Form-based panels with status indicators, model scanning
- * Colors: Cyan primary, green for connected, red for errors
- * Typography: JetBrains Mono for technical values, Inter for labels
+ * Теперь с реальным подключением к Ollama API через tRPC
 */
 import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
 import { Badge } from "@/components/ui/badge";
@@ -22,61 +20,17 @@ import {
  XCircle,
  AlertTriangle,
  Plus,
-  Trash2,
  Eye,
  EyeOff,
  Wifi,
-  Database,
  Shield,
  Loader2,
+  Zap,
 } from "lucide-react";
 import { motion } from "framer-motion";
-import { useState } from "react";
+import { useState, useEffect } from "react";
 import { toast } from "sonner";
-
-interface Provider {
-  id: string;
-  name: string;
-  type: "openai" | "anthropic" | "ollama" | "custom";
-  baseUrl: string;
-  apiKey: string;
-  status: "connected" | "error" | "unchecked";
-  models: string[];
-  enabled: boolean;
-}
-
-const INITIAL_PROVIDERS: Provider[] = [
-  {
-    id: "openai",
-    name: "OpenAI",
-    type: "openai",
-    baseUrl: "https://api.openai.com/v1",
-    apiKey: "sk-proj-****************************",
-    status: "connected",
-    models: ["gpt-4o", "gpt-4o-mini", "gpt-4-turbo", "gpt-3.5-turbo"],
-    enabled: true,
-  },
-  {
-    id: "anthropic",
-    name: "Anthropic",
-    type: "anthropic",
-    baseUrl: "https://api.anthropic.com/v1",
-    apiKey: "sk-ant-****************************",
-    status: "error",
-    models: ["claude-3.5-sonnet", "claude-3-haiku"],
-    enabled: true,
-  },
-  {
-    id: "ollama",
-    name: "Ollama (Local)",
-    type: "ollama",
-    baseUrl: "http://192.168.1.10:11434",
-    apiKey: "",
-    status: "connected",
-    models: ["llama-3.1-8b", "llama-3.1-70b", "codestral-22b", "qwen2.5-coder-7b"],
-    enabled: true,
-  },
-];
+import { trpc } from "@/lib/trpc";

 function getStatusIcon(status: string) {
  switch (status) {
@@ -95,32 +49,32 @@ function getStatusBadge(status: string) {
 }

 export default function Settings() {
-  const [providers, setProviders] = useState<Provider[]>(INITIAL_PROVIDERS);
  const [showKeys, setShowKeys] = useState<Record<string, boolean>>({});
-  const [scanning, setScanning] = useState<Record<string, boolean>>({});
+
+  // Реальные данные из Ollama API
+  const healthQuery = trpc.ollama.health.useQuery(undefined, {
+    refetchInterval: 30_000, // Обновлять каждые 30 секунд
+  });
+  const modelsQuery = trpc.ollama.models.useQuery(undefined, {
+    refetchInterval: 60_000, // Обновлять каждые 60 секунд
+  });
+
+  const ollamaStatus = healthQuery.data?.connected ? "connected" : healthQuery.isLoading ? "unchecked" : "error";
+  const ollamaLatency = healthQuery.data?.latencyMs ?? 0;
+  const ollamaModels = modelsQuery.data?.success ? modelsQuery.data.models : [];

  const toggleKeyVisibility = (id: string) => {
    setShowKeys((prev) => ({ ...prev, [id]: !prev[id] }));
  };

-  const scanModels = (id: string) => {
-    setScanning((prev) => ({ ...prev, [id]: true }));
-    setTimeout(() => {
-      setScanning((prev) => ({ ...prev, [id]: false }));
-      toast.success(`Модели для ${providers.find(p => p.id === id)?.name} обновлены`);
-    }, 2000);
+  const scanModels = () => {
+    modelsQuery.refetch();
+    toast.success("Сканирование моделей запущено...");
  };

-  const testConnection = (id: string) => {
-    toast.info(`Тестирование подключения к ${providers.find(p => p.id === id)?.name}...`);
-    setTimeout(() => {
-      const provider = providers.find(p => p.id === id);
-      if (provider?.id === "anthropic") {
-        toast.error("Ошибка подключения: Invalid API key");
-      } else {
-        toast.success("Подключение успешно");
-      }
-    }, 1500);
+  const testConnection = () => {
+    healthQuery.refetch();
+    toast.info("Тестирование подключения к Ollama...");
  };

  return (
@@ -163,126 +117,189 @@ export default function Settings() {
            </Button>
          </div>

-          {providers.map((provider, i) => (
-            <motion.div
-              key={provider.id}
-              initial={{ opacity: 0, y: 10 }}
-              animate={{ opacity: 1, y: 0 }}
-              transition={{ delay: i * 0.1 }}
-            >
-              <Card className="bg-card border-border/50">
-                <CardHeader className="pb-3">
-                  <div className="flex items-center justify-between">
-                    <div className="flex items-center gap-3">
-                      {getStatusIcon(provider.status)}
-                      <div>
-                        <CardTitle className="text-sm font-semibold">{provider.name}</CardTitle>
-                        <span className="text-[10px] font-mono text-muted-foreground">{provider.type.toUpperCase()}</span>
-                      </div>
-                    </div>
-                    <div className="flex items-center gap-3">
-                      <Badge variant="outline" className={`text-[10px] font-mono ${getStatusBadge(provider.status)}`}>
-                        {provider.status.toUpperCase()}
-                      </Badge>
-                      <Switch
-                        checked={provider.enabled}
-                        onCheckedChange={() => {
-                          setProviders(prev => prev.map(p => p.id === provider.id ? { ...p, enabled: !p.enabled } : p));
-                        }}
-                      />
+          {/* === OLLAMA PROVIDER (REAL DATA) === */}
+          <motion.div
+            initial={{ opacity: 0, y: 10 }}
+            animate={{ opacity: 1, y: 0 }}
+          >
+            <Card className="bg-card border-border/50 ring-1 ring-primary/20">
+              <CardHeader className="pb-3">
+                <div className="flex items-center justify-between">
+                  <div className="flex items-center gap-3">
+                    {healthQuery.isLoading ? (
+                      <Loader2 className="w-4 h-4 text-primary animate-spin" />
+                    ) : (
+                      getStatusIcon(ollamaStatus)
+                    )}
+                    <div>
+                      <CardTitle className="text-sm font-semibold flex items-center gap-2">
+                        Ollama Cloud
+                        <Badge variant="outline" className="text-[9px] font-mono bg-primary/10 text-primary border-primary/20">
+                          LIVE
+                        </Badge>
+                      </CardTitle>
+                      <span className="text-[10px] font-mono text-muted-foreground">OPENAI-COMPATIBLE</span>
                    </div>
                  </div>
-                </CardHeader>
-                <CardContent className="space-y-4">
-                  {/* Base URL */}
-                  <div className="space-y-1.5">
-                    <Label className="text-[11px] font-mono text-muted-foreground">BASE URL</Label>
-                    <div className="flex items-center gap-2">
+                  <div className="flex items-center gap-3">
+                    {ollamaLatency > 0 && (
+                      <span className="text-[10px] font-mono text-muted-foreground flex items-center gap-1">
+                        <Zap className="w-3 h-3 text-neon-amber" />
+                        {ollamaLatency}ms
+                      </span>
+                    )}
+                    <Badge variant="outline" className={`text-[10px] font-mono ${getStatusBadge(ollamaStatus)}`}>
+                      {ollamaStatus.toUpperCase()}
+                    </Badge>
+                    <Switch defaultChecked />
+                  </div>
+                </div>
+              </CardHeader>
+              <CardContent className="space-y-4">
+                {/* Base URL */}
+                <div className="space-y-1.5">
+                  <Label className="text-[11px] font-mono text-muted-foreground">BASE URL</Label>
+                  <div className="flex items-center gap-2">
+                    <Input
+                      value="https://ollama.com/v1"
+                      className="bg-secondary/30 border-border/30 font-mono text-xs h-8"
+                      readOnly
+                    />
+                    <Button
+                      size="sm"
+                      variant="outline"
+                      className="h-8 text-[11px] border-primary/30 text-primary hover:bg-primary/10"
+                      onClick={testConnection}
+                      disabled={healthQuery.isFetching}
+                    >
+                      {healthQuery.isFetching ? (
+                        <Loader2 className="w-3 h-3 mr-1 animate-spin" />
+                      ) : (
+                        <Globe className="w-3 h-3 mr-1" />
+                      )}
+                      Test
+                    </Button>
+                  </div>
+                </div>
+
+                {/* API Key */}
+                <div className="space-y-1.5">
+                  <Label className="text-[11px] font-mono text-muted-foreground">API KEY</Label>
+                  <div className="flex items-center gap-2">
+                    <div className="relative flex-1">
                      <Input
-                        value={provider.baseUrl}
-                        className="bg-secondary/30 border-border/30 font-mono text-xs h-8"
+                        type={showKeys["ollama"] ? "text" : "password"}
+                        value="feaa56e2dff045af989346ca74cb33a6.xzJ-plOVSgTL1FbmL8PZZ3Wx"
+                        className="bg-secondary/30 border-border/30 font-mono text-xs h-8 pr-10"
                        readOnly
                      />
-                      <Button
-                        size="sm"
-                        variant="outline"
-                        className="h-8 text-[11px] border-primary/30 text-primary hover:bg-primary/10"
-                        onClick={() => testConnection(provider.id)}
+                      <button
+                        onClick={() => toggleKeyVisibility("ollama")}
+                        className="absolute right-2 top-1/2 -translate-y-1/2 text-muted-foreground hover:text-foreground"
                      >
-                        <Globe className="w-3 h-3 mr-1" /> Test
-                      </Button>
+                        {showKeys["ollama"] ? <EyeOff className="w-3.5 h-3.5" /> : <Eye className="w-3.5 h-3.5" />}
+                      </button>
                    </div>
+                    <Button
+                      size="sm"
+                      variant="outline"
+                      className="h-8 text-[11px] border-border/50 text-muted-foreground hover:text-foreground"
+                      onClick={() => toast("Feature coming soon")}
+                    >
+                      <Key className="w-3 h-3 mr-1" /> Edit
+                    </Button>
                  </div>
+                </div>

-                  {/* API Key */}
-                  {provider.type !== "ollama" && (
-                    <div className="space-y-1.5">
-                      <Label className="text-[11px] font-mono text-muted-foreground">API KEY</Label>
-                      <div className="flex items-center gap-2">
-                        <div className="relative flex-1">
-                          <Input
-                            type={showKeys[provider.id] ? "text" : "password"}
-                            value={provider.apiKey}
-                            className="bg-secondary/30 border-border/30 font-mono text-xs h-8 pr-10"
-                            readOnly
-                          />
-                          <button
-                            onClick={() => toggleKeyVisibility(provider.id)}
-                            className="absolute right-2 top-1/2 -translate-y-1/2 text-muted-foreground hover:text-foreground"
-                          >
-                            {showKeys[provider.id] ? <EyeOff className="w-3.5 h-3.5" /> : <Eye className="w-3.5 h-3.5" />}
-                          </button>
-                        </div>
-                        <Button
-                          size="sm"
-                          variant="outline"
-                          className="h-8 text-[11px] border-border/50 text-muted-foreground hover:text-foreground"
-                          onClick={() => toast("Feature coming soon")}
-                        >
-                          <Key className="w-3 h-3 mr-1" /> Edit
-                        </Button>
-                      </div>
+                <Separator className="bg-border/30" />
+
+                {/* Models — REAL DATA */}
+                <div>
+                  <div className="flex items-center justify-between mb-2">
+                    <Label className="text-[11px] font-mono text-muted-foreground">
+                      AVAILABLE MODELS ({ollamaModels.length})
+                    </Label>
+                    <Button
+                      size="sm"
+                      variant="outline"
+                      className="h-7 text-[10px] border-primary/30 text-primary hover:bg-primary/10"
+                      onClick={scanModels}
+                      disabled={modelsQuery.isFetching}
+                    >
+                      {modelsQuery.isFetching ? (
+                        <Loader2 className="w-3 h-3 mr-1 animate-spin" />
+                      ) : (
+                        <RefreshCw className="w-3 h-3 mr-1" />
+                      )}
+                      Scan Models
+                    </Button>
+                  </div>
+                  {modelsQuery.isLoading ? (
+                    <div className="flex items-center gap-2 py-4">
+                      <Loader2 className="w-4 h-4 animate-spin text-primary" />
+                      <span className="text-xs text-muted-foreground font-mono">Загрузка моделей...</span>
                    </div>
-                  )}
-
-                  <Separator className="bg-border/30" />
-
-                  {/* Models */}
-                  <div>
-                    <div className="flex items-center justify-between mb-2">
-                      <Label className="text-[11px] font-mono text-muted-foreground">
-                        AVAILABLE MODELS ({provider.models.length})
-                      </Label>
-                      <Button
-                        size="sm"
-                        variant="outline"
-                        className="h-7 text-[10px] border-primary/30 text-primary hover:bg-primary/10"
-                        onClick={() => scanModels(provider.id)}
-                        disabled={scanning[provider.id]}
-                      >
-                        {scanning[provider.id] ? (
-                          <Loader2 className="w-3 h-3 mr-1 animate-spin" />
-                        ) : (
-                          <RefreshCw className="w-3 h-3 mr-1" />
-                        )}
-                        Scan Models
-                      </Button>
-                    </div>
-                    <div className="flex flex-wrap gap-1.5">
-                      {provider.models.map((model) => (
+                  ) : ollamaModels.length > 0 ? (
+                    <div className="flex flex-wrap gap-1.5 max-h-48 overflow-y-auto">
+                      {ollamaModels.map((model) => (
                        <span
-                          key={model}
+                          key={model.id}
                          className="px-2 py-0.5 rounded text-[10px] font-mono bg-primary/10 text-primary border border-primary/20"
                        >
-                          {model}
+                          {model.id}
                        </span>
                      ))}
                    </div>
+                  ) : (
+                    <div className="text-xs text-muted-foreground font-mono py-2">
+                      {modelsQuery.data && !modelsQuery.data.success
+                        ? `Ошибка: ${(modelsQuery.data as any).error}`
+                        : "Нет доступных моделей"}
+                    </div>
+                  )}
+                </div>
+
+                {/* Health Error */}
+                {healthQuery.data && !healthQuery.data.connected && healthQuery.data.error && (
+                  <div className="p-3 rounded-md bg-neon-red/10 border border-neon-red/20">
+                    <div className="flex items-center gap-2">
+                      <XCircle className="w-4 h-4 text-neon-red shrink-0" />
+                      <span className="text-xs font-mono text-neon-red">{healthQuery.data.error}</span>
+                    </div>
                  </div>
-                </CardContent>
-              </Card>
-            </motion.div>
-          ))}
+                )}
+              </CardContent>
+            </Card>
+          </motion.div>
+
+          {/* Placeholder for other providers */}
+          <motion.div
+            initial={{ opacity: 0, y: 10 }}
+            animate={{ opacity: 1, y: 0 }}
+            transition={{ delay: 0.1 }}
+          >
+            <Card className="bg-card border-border/50 opacity-60">
+              <CardHeader className="pb-3">
+                <div className="flex items-center justify-between">
+                  <div className="flex items-center gap-3">
+                    <AlertTriangle className="w-4 h-4 text-neon-amber" />
+                    <div>
+                      <CardTitle className="text-sm font-semibold">OpenAI</CardTitle>
+                      <span className="text-[10px] font-mono text-muted-foreground">NOT CONFIGURED</span>
+                    </div>
+                  </div>
+                  <Badge variant="outline" className="text-[10px] font-mono bg-neon-amber/15 text-neon-amber border-neon-amber/30">
+                    UNCHECKED
+                  </Badge>
+                </div>
+              </CardHeader>
+              <CardContent>
+                <p className="text-xs text-muted-foreground">
+                  Нажмите «Добавить провайдер» для настройки OpenAI, Anthropic или другого OpenAI-совместимого API.
+                </p>
+              </CardContent>
+            </Card>
+          </motion.div>
        </TabsContent>

        {/* Gateway Tab */}
@@ -366,15 +383,15 @@ export default function Settings() {
                    </div>
                  </div>
                  <div className="flex items-center gap-2">
-                    <Badge variant="outline" className="text-[10px] font-mono bg-neon-green/15 text-neon-green border-neon-green/30">
-                      CONNECTED
+                    <Badge variant="outline" className="text-[10px] font-mono bg-neon-amber/15 text-neon-amber border-neon-amber/30">
+                      NOT CONFIGURED
                    </Badge>
-                    <Switch defaultChecked />
+                    <Switch />
                  </div>
                </div>
                <div className="space-y-1.5">
                  <Label className="text-[11px] font-mono text-muted-foreground">BOT TOKEN</Label>
-                  <Input type="password" value="7234567890:AAH*****************************" className="bg-secondary/50 border-border/30 font-mono text-xs h-8" readOnly />
+                  <Input placeholder="Введите токен Telegram бота..." className="bg-secondary/50 border-border/30 font-mono text-xs h-8" />
                </div>
              </div>

--- a/drizzle.config.ts
+++ b/drizzle.config.ts
@@ -0,0 +1,15 @@
+import { defineConfig } from "drizzle-kit";
+
+const connectionString = process.env.DATABASE_URL;
+if (!connectionString) {
+  throw new Error("DATABASE_URL is required to run drizzle commands");
+}
+
+export default defineConfig({
+  schema: "./drizzle/schema.ts",
+  out: "./drizzle",
+  dialect: "mysql",
+  dbCredentials: {
+    url: connectionString,
+  },
+});
--- a/drizzle/0000_sudden_blue_shield.sql
+++ b/drizzle/0000_sudden_blue_shield.sql
@@ -0,0 +1,13 @@
+CREATE TABLE `users` (
+	`id` int AUTO_INCREMENT NOT NULL,
+	`openId` varchar(64) NOT NULL,
+	`name` text,
+	`email` varchar(320),
+	`loginMethod` varchar(64),
+	`role` enum('user','admin') NOT NULL DEFAULT 'user',
+	`createdAt` timestamp NOT NULL DEFAULT (now()),
+	`updatedAt` timestamp NOT NULL DEFAULT (now()) ON UPDATE CURRENT_TIMESTAMP,
+	`lastSignedIn` timestamp NOT NULL DEFAULT (now()),
+	CONSTRAINT `users_id` PRIMARY KEY(`id`),
+	CONSTRAINT `users_openId_unique` UNIQUE(`openId`)
+);
--- a/drizzle/meta/0000_snapshot.json
+++ b/drizzle/meta/0000_snapshot.json
@@ -0,0 +1,110 @@
+{
+  "version": "5",
+  "dialect": "mysql",
+  "id": "dc689f95-4069-4f14-ab7c-53cb1cc15760",
+  "prevId": "00000000-0000-0000-0000-000000000000",
+  "tables": {
+    "users": {
+      "name": "users",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "int",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": true
+        },
+        "openId": {
+          "name": "openId",
+          "type": "varchar(64)",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "email": {
+          "name": "email",
+          "type": "varchar(320)",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "loginMethod": {
+          "name": "loginMethod",
+          "type": "varchar(64)",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "role": {
+          "name": "role",
+          "type": "enum('user','admin')",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'user'"
+        },
+        "createdAt": {
+          "name": "createdAt",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "(now())"
+        },
+        "updatedAt": {
+          "name": "updatedAt",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "onUpdate": true,
+          "default": "(now())"
+        },
+        "lastSignedIn": {
+          "name": "lastSignedIn",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "(now())"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {
+        "users_id": {
+          "name": "users_id",
+          "columns": [
+            "id"
+          ]
+        }
+      },
+      "uniqueConstraints": {
+        "users_openId_unique": {
+          "name": "users_openId_unique",
+          "columns": [
+            "openId"
+          ]
+        }
+      },
+      "checkConstraint": {}
+    }
+  },
+  "views": {},
+  "_meta": {
+    "schemas": {},
+    "tables": {},
+    "columns": {}
+  },
+  "internal": {
+    "tables": {},
+    "indexes": {}
+  }
+}
--- a/drizzle/meta/_journal.json
+++ b/drizzle/meta/_journal.json
@@ -0,0 +1,13 @@
+{
+  "version": "7",
+  "dialect": "mysql",
+  "entries": [
+    {
+      "idx": 0,
+      "version": "5",
+      "when": 1774036428800,
+      "tag": "0000_sudden_blue_shield",
+      "breakpoints": true
+    }
+  ]
+}
--- a/drizzle/migrations/.gitkeep
+++ b/drizzle/migrations/.gitkeep
--- a/drizzle/relations.ts
+++ b/drizzle/relations.ts
@@ -0,0 +1 @@
+import {} from "./schema";
--- a/drizzle/schema.ts
+++ b/drizzle/schema.ts
@@ -0,0 +1,28 @@
+import { int, mysqlEnum, mysqlTable, text, timestamp, varchar } from "drizzle-orm/mysql-core";
+
+/**
+ * Core user table backing auth flow.
+ * Extend this file with additional tables as your product grows.
+ * Columns use camelCase to match both database fields and generated types.
+ */
+export const users = mysqlTable("users", {
+  /**
+   * Surrogate primary key. Auto-incremented numeric value managed by the database.
+   * Use this for relations between tables.
+   */
+  id: int("id").autoincrement().primaryKey(),
+  /** Manus OAuth identifier (openId) returned from the OAuth callback. Unique per user. */
+  openId: varchar("openId", { length: 64 }).notNull().unique(),
+  name: text("name"),
+  email: varchar("email", { length: 320 }),
+  loginMethod: varchar("loginMethod", { length: 64 }),
+  role: mysqlEnum("role", ["user", "admin"]).default("user").notNull(),
+  createdAt: timestamp("createdAt").defaultNow().notNull(),
+  updatedAt: timestamp("updatedAt").defaultNow().onUpdateNow().notNull(),
+  lastSignedIn: timestamp("lastSignedIn").defaultNow().notNull(),
+});
+
+export type User = typeof users.$inferSelect;
+export type InsertUser = typeof users.$inferInsert;
+
+// TODO: Add your tables here
--- a/package.json
+++ b/package.json
@@ -4,14 +4,17 @@
  "type": "module",
  "license": "MIT",
  "scripts": {
-    "dev": "vite --host",
-    "build": "vite build && esbuild server/index.ts --platform=node --packages=external --bundle --format=esm --outdir=dist",
+    "dev": "NODE_ENV=development tsx watch server/_core/index.ts",
+    "build": "vite build && esbuild server/_core/index.ts --platform=node --packages=external --bundle --format=esm --outdir=dist",
    "start": "NODE_ENV=production node dist/index.js",
-    "preview": "vite preview --host",
    "check": "tsc --noEmit",
-    "format": "prettier --write ."
+    "format": "prettier --write .",
+    "test": "vitest run",
+    "db:push": "drizzle-kit generate && drizzle-kit migrate"
  },
  "dependencies": {
+    "@aws-sdk/client-s3": "^3.693.0",
+    "@aws-sdk/s3-request-presigner": "^3.693.0",
    "@hookform/resolvers": "^5.2.2",
    "@radix-ui/react-accordion": "^1.2.12",
    "@radix-ui/react-alert-dialog": "^1.1.15",
@@ -39,15 +42,25 @@
    "@radix-ui/react-toggle": "^1.1.10",
    "@radix-ui/react-toggle-group": "^1.1.11",
    "@radix-ui/react-tooltip": "^1.2.8",
+    "@tanstack/react-query": "^5.90.2",
+    "@trpc/client": "^11.6.0",
+    "@trpc/react-query": "^11.6.0",
+    "@trpc/server": "^11.6.0",
    "axios": "^1.12.0",
    "class-variance-authority": "^0.7.1",
    "clsx": "^2.1.1",
    "cmdk": "^1.1.1",
+    "cookie": "^1.0.2",
+    "date-fns": "^4.1.0",
+    "dotenv": "^17.2.2",
+    "drizzle-orm": "^0.44.5",
    "embla-carousel-react": "^8.6.0",
    "express": "^4.21.2",
    "framer-motion": "^12.23.22",
    "input-otp": "^1.4.2",
+    "jose": "6.1.0",
    "lucide-react": "^0.453.0",
+    "mysql2": "^3.15.0",
    "nanoid": "^5.1.5",
    "next-themes": "^0.4.6",
    "react": "^19.2.1",
@@ -58,6 +71,7 @@
    "recharts": "^2.15.2",
    "sonner": "^2.0.7",
    "streamdown": "^1.4.0",
+    "superjson": "^1.13.3",
    "tailwind-merge": "^3.3.1",
    "tailwindcss-animate": "^1.0.7",
    "vaul": "^1.1.2",
@@ -76,6 +90,7 @@
    "@vitejs/plugin-react": "^5.0.4",
    "add": "^2.0.6",
    "autoprefixer": "^10.4.20",
+    "drizzle-kit": "^0.31.4",
    "esbuild": "^0.25.0",
    "pnpm": "^10.15.1",
    "postcss": "^8.4.47",
@@ -83,7 +98,7 @@
    "tailwindcss": "^4.1.14",
    "tsx": "^4.19.1",
    "tw-animate-css": "^1.4.0",
-    "typescript": "5.6.3",
+    "typescript": "5.9.3",
    "vite": "^7.1.7",
    "vite-plugin-manus-runtime": "^0.0.57",
    "vitest": "^2.1.4"
@@ -97,4 +112,4 @@
      "tailwindcss>nanoid": "3.3.7"
    }
  }
-}
+}
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
--- a/server/_core/context.ts
+++ b/server/_core/context.ts
@@ -0,0 +1,28 @@
+import type { CreateExpressContextOptions } from "@trpc/server/adapters/express";
+import type { User } from "../../drizzle/schema";
+import { sdk } from "./sdk";
+
+export type TrpcContext = {
+  req: CreateExpressContextOptions["req"];
+  res: CreateExpressContextOptions["res"];
+  user: User | null;
+};
+
+export async function createContext(
+  opts: CreateExpressContextOptions
+): Promise<TrpcContext> {
+  let user: User | null = null;
+
+  try {
+    user = await sdk.authenticateRequest(opts.req);
+  } catch (error) {
+    // Authentication is optional for public procedures.
+    user = null;
+  }
+
+  return {
+    req: opts.req,
+    res: opts.res,
+    user,
+  };
+}
--- a/server/_core/cookies.ts
+++ b/server/_core/cookies.ts
@@ -0,0 +1,48 @@
+import type { CookieOptions, Request } from "express";
+
+const LOCAL_HOSTS = new Set(["localhost", "127.0.0.1", "::1"]);
+
+function isIpAddress(host: string) {
+  // Basic IPv4 check and IPv6 presence detection.
+  if (/^\d{1,3}(\.\d{1,3}){3}$/.test(host)) return true;
+  return host.includes(":");
+}
+
+function isSecureRequest(req: Request) {
+  if (req.protocol === "https") return true;
+
+  const forwardedProto = req.headers["x-forwarded-proto"];
+  if (!forwardedProto) return false;
+
+  const protoList = Array.isArray(forwardedProto)
+    ? forwardedProto
+    : forwardedProto.split(",");
+
+  return protoList.some(proto => proto.trim().toLowerCase() === "https");
+}
+
+export function getSessionCookieOptions(
+  req: Request
+): Pick<CookieOptions, "domain" | "httpOnly" | "path" | "sameSite" | "secure"> {
+  // const hostname = req.hostname;
+  // const shouldSetDomain =
+  //   hostname &&
+  //   !LOCAL_HOSTS.has(hostname) &&
+  //   !isIpAddress(hostname) &&
+  //   hostname !== "127.0.0.1" &&
+  //   hostname !== "::1";
+
+  // const domain =
+  //   shouldSetDomain && !hostname.startsWith(".")
+  //     ? `.${hostname}`
+  //     : shouldSetDomain
+  //       ? hostname
+  //       : undefined;
+
+  return {
+    httpOnly: true,
+    path: "/",
+    sameSite: "none",
+    secure: isSecureRequest(req),
+  };
+}
--- a/server/_core/dataApi.ts
+++ b/server/_core/dataApi.ts
@@ -0,0 +1,64 @@
+/**
+ * Quick example (matches curl usage):
+ *   await callDataApi("Youtube/search", {
+ *     query: { gl: "US", hl: "en", q: "manus" },
+ *   })
+ */
+import { ENV } from "./env";
+
+export type DataApiCallOptions = {
+  query?: Record<string, unknown>;
+  body?: Record<string, unknown>;
+  pathParams?: Record<string, unknown>;
+  formData?: Record<string, unknown>;
+};
+
+export async function callDataApi(
+  apiId: string,
+  options: DataApiCallOptions = {}
+): Promise<unknown> {
+  if (!ENV.forgeApiUrl) {
+    throw new Error("BUILT_IN_FORGE_API_URL is not configured");
+  }
+  if (!ENV.forgeApiKey) {
+    throw new Error("BUILT_IN_FORGE_API_KEY is not configured");
+  }
+
+  // Build the full URL by appending the service path to the base URL
+  const baseUrl = ENV.forgeApiUrl.endsWith("/") ? ENV.forgeApiUrl : `${ENV.forgeApiUrl}/`;
+  const fullUrl = new URL("webdevtoken.v1.WebDevService/CallApi", baseUrl).toString();
+
+  const response = await fetch(fullUrl, {
+    method: "POST",
+    headers: {
+      accept: "application/json",
+      "content-type": "application/json",
+      "connect-protocol-version": "1",
+      authorization: `Bearer ${ENV.forgeApiKey}`,
+    },
+    body: JSON.stringify({
+      apiId,
+      query: options.query,
+      body: options.body,
+      path_params: options.pathParams,
+      multipart_form_data: options.formData,
+    }),
+  });
+
+  if (!response.ok) {
+    const detail = await response.text().catch(() => "");
+    throw new Error(
+      `Data API request failed (${response.status} ${response.statusText})${detail ? `: ${detail}` : ""}`
+    );
+  }
+
+  const payload = await response.json().catch(() => ({}));
+  if (payload && typeof payload === "object" && "jsonData" in payload) {
+    try {
+      return JSON.parse((payload as Record<string, string>).jsonData ?? "{}");
+    } catch {
+      return (payload as Record<string, unknown>).jsonData;
+    }
+  }
+  return payload;
+}
--- a/server/_core/env.ts
+++ b/server/_core/env.ts
@@ -0,0 +1,12 @@
+export const ENV = {
+  appId: process.env.VITE_APP_ID ?? "",
+  cookieSecret: process.env.JWT_SECRET ?? "",
+  databaseUrl: process.env.DATABASE_URL ?? "",
+  oAuthServerUrl: process.env.OAUTH_SERVER_URL ?? "",
+  ownerOpenId: process.env.OWNER_OPEN_ID ?? "",
+  isProduction: process.env.NODE_ENV === "production",
+  forgeApiUrl: process.env.BUILT_IN_FORGE_API_URL ?? "",
+  forgeApiKey: process.env.BUILT_IN_FORGE_API_KEY ?? "",
+  ollamaBaseUrl: process.env.OLLAMA_BASE_URL ?? "https://ollama.com/v1",
+  ollamaApiKey: process.env.OLLAMA_API_KEY ?? "",
+};
--- a/server/_core/imageGeneration.ts
+++ b/server/_core/imageGeneration.ts
@@ -0,0 +1,92 @@
+/**
+ * Image generation helper using internal ImageService
+ *
+ * Example usage:
+ *   const { url: imageUrl } = await generateImage({
+ *     prompt: "A serene landscape with mountains"
+ *   });
+ *
+ * For editing:
+ *   const { url: imageUrl } = await generateImage({
+ *     prompt: "Add a rainbow to this landscape",
+ *     originalImages: [{
+ *       url: "https://example.com/original.jpg",
+ *       mimeType: "image/jpeg"
+ *     }]
+ *   });
+ */
+import { storagePut } from "server/storage";
+import { ENV } from "./env";
+
+export type GenerateImageOptions = {
+  prompt: string;
+  originalImages?: Array<{
+    url?: string;
+    b64Json?: string;
+    mimeType?: string;
+  }>;
+};
+
+export type GenerateImageResponse = {
+  url?: string;
+};
+
+export async function generateImage(
+  options: GenerateImageOptions
+): Promise<GenerateImageResponse> {
+  if (!ENV.forgeApiUrl) {
+    throw new Error("BUILT_IN_FORGE_API_URL is not configured");
+  }
+  if (!ENV.forgeApiKey) {
+    throw new Error("BUILT_IN_FORGE_API_KEY is not configured");
+  }
+
+  // Build the full URL by appending the service path to the base URL
+  const baseUrl = ENV.forgeApiUrl.endsWith("/")
+    ? ENV.forgeApiUrl
+    : `${ENV.forgeApiUrl}/`;
+  const fullUrl = new URL(
+    "images.v1.ImageService/GenerateImage",
+    baseUrl
+  ).toString();
+
+  const response = await fetch(fullUrl, {
+    method: "POST",
+    headers: {
+      accept: "application/json",
+      "content-type": "application/json",
+      "connect-protocol-version": "1",
+      authorization: `Bearer ${ENV.forgeApiKey}`,
+    },
+    body: JSON.stringify({
+      prompt: options.prompt,
+      original_images: options.originalImages || [],
+    }),
+  });
+
+  if (!response.ok) {
+    const detail = await response.text().catch(() => "");
+    throw new Error(
+      `Image generation request failed (${response.status} ${response.statusText})${detail ? `: ${detail}` : ""}`
+    );
+  }
+
+  const result = (await response.json()) as {
+    image: {
+      b64Json: string;
+      mimeType: string;
+    };
+  };
+  const base64Data = result.image.b64Json;
+  const buffer = Buffer.from(base64Data, "base64");
+
+  // Save to S3
+  const { url } = await storagePut(
+    `generated/${Date.now()}.png`,
+    buffer,
+    result.image.mimeType
+  );
+  return {
+    url,
+  };
+}
--- a/server/_core/index.ts
+++ b/server/_core/index.ts
@@ -0,0 +1,65 @@
+import "dotenv/config";
+import express from "express";
+import { createServer } from "http";
+import net from "net";
+import { createExpressMiddleware } from "@trpc/server/adapters/express";
+import { registerOAuthRoutes } from "./oauth";
+import { appRouter } from "../routers";
+import { createContext } from "./context";
+import { serveStatic, setupVite } from "./vite";
+
+function isPortAvailable(port: number): Promise<boolean> {
+  return new Promise(resolve => {
+    const server = net.createServer();
+    server.listen(port, () => {
+      server.close(() => resolve(true));
+    });
+    server.on("error", () => resolve(false));
+  });
+}
+
+async function findAvailablePort(startPort: number = 3000): Promise<number> {
+  for (let port = startPort; port < startPort + 20; port++) {
+    if (await isPortAvailable(port)) {
+      return port;
+    }
+  }
+  throw new Error(`No available port found starting from ${startPort}`);
+}
+
+async function startServer() {
+  const app = express();
+  const server = createServer(app);
+  // Configure body parser with larger size limit for file uploads
+  app.use(express.json({ limit: "50mb" }));
+  app.use(express.urlencoded({ limit: "50mb", extended: true }));
+  // OAuth callback under /api/oauth/callback
+  registerOAuthRoutes(app);
+  // tRPC API
+  app.use(
+    "/api/trpc",
+    createExpressMiddleware({
+      router: appRouter,
+      createContext,
+    })
+  );
+  // development mode uses Vite, production mode uses static files
+  if (process.env.NODE_ENV === "development") {
+    await setupVite(app, server);
+  } else {
+    serveStatic(app);
+  }
+
+  const preferredPort = parseInt(process.env.PORT || "3000");
+  const port = await findAvailablePort(preferredPort);
+
+  if (port !== preferredPort) {
+    console.log(`Port ${preferredPort} is busy, using port ${port} instead`);
+  }
+
+  server.listen(port, () => {
+    console.log(`Server running on http://localhost:${port}/`);
+  });
+}
+
+startServer().catch(console.error);
--- a/server/_core/llm.ts
+++ b/server/_core/llm.ts
@@ -0,0 +1,332 @@
+import { ENV } from "./env";
+
+export type Role = "system" | "user" | "assistant" | "tool" | "function";
+
+export type TextContent = {
+  type: "text";
+  text: string;
+};
+
+export type ImageContent = {
+  type: "image_url";
+  image_url: {
+    url: string;
+    detail?: "auto" | "low" | "high";
+  };
+};
+
+export type FileContent = {
+  type: "file_url";
+  file_url: {
+    url: string;
+    mime_type?: "audio/mpeg" | "audio/wav" | "application/pdf" | "audio/mp4" | "video/mp4" ;
+  };
+};
+
+export type MessageContent = string | TextContent | ImageContent | FileContent;
+
+export type Message = {
+  role: Role;
+  content: MessageContent | MessageContent[];
+  name?: string;
+  tool_call_id?: string;
+};
+
+export type Tool = {
+  type: "function";
+  function: {
+    name: string;
+    description?: string;
+    parameters?: Record<string, unknown>;
+  };
+};
+
+export type ToolChoicePrimitive = "none" | "auto" | "required";
+export type ToolChoiceByName = { name: string };
+export type ToolChoiceExplicit = {
+  type: "function";
+  function: {
+    name: string;
+  };
+};
+
+export type ToolChoice =
+  | ToolChoicePrimitive
+  | ToolChoiceByName
+  | ToolChoiceExplicit;
+
+export type InvokeParams = {
+  messages: Message[];
+  tools?: Tool[];
+  toolChoice?: ToolChoice;
+  tool_choice?: ToolChoice;
+  maxTokens?: number;
+  max_tokens?: number;
+  outputSchema?: OutputSchema;
+  output_schema?: OutputSchema;
+  responseFormat?: ResponseFormat;
+  response_format?: ResponseFormat;
+};
+
+export type ToolCall = {
+  id: string;
+  type: "function";
+  function: {
+    name: string;
+    arguments: string;
+  };
+};
+
+export type InvokeResult = {
+  id: string;
+  created: number;
+  model: string;
+  choices: Array<{
+    index: number;
+    message: {
+      role: Role;
+      content: string | Array<TextContent | ImageContent | FileContent>;
+      tool_calls?: ToolCall[];
+    };
+    finish_reason: string | null;
+  }>;
+  usage?: {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+  };
+};
+
+export type JsonSchema = {
+  name: string;
+  schema: Record<string, unknown>;
+  strict?: boolean;
+};
+
+export type OutputSchema = JsonSchema;
+
+export type ResponseFormat =
+  | { type: "text" }
+  | { type: "json_object" }
+  | { type: "json_schema"; json_schema: JsonSchema };
+
+const ensureArray = (
+  value: MessageContent | MessageContent[]
+): MessageContent[] => (Array.isArray(value) ? value : [value]);
+
+const normalizeContentPart = (
+  part: MessageContent
+): TextContent | ImageContent | FileContent => {
+  if (typeof part === "string") {
+    return { type: "text", text: part };
+  }
+
+  if (part.type === "text") {
+    return part;
+  }
+
+  if (part.type === "image_url") {
+    return part;
+  }
+
+  if (part.type === "file_url") {
+    return part;
+  }
+
+  throw new Error("Unsupported message content part");
+};
+
+const normalizeMessage = (message: Message) => {
+  const { role, name, tool_call_id } = message;
+
+  if (role === "tool" || role === "function") {
+    const content = ensureArray(message.content)
+      .map(part => (typeof part === "string" ? part : JSON.stringify(part)))
+      .join("\n");
+
+    return {
+      role,
+      name,
+      tool_call_id,
+      content,
+    };
+  }
+
+  const contentParts = ensureArray(message.content).map(normalizeContentPart);
+
+  // If there's only text content, collapse to a single string for compatibility
+  if (contentParts.length === 1 && contentParts[0].type === "text") {
+    return {
+      role,
+      name,
+      content: contentParts[0].text,
+    };
+  }
+
+  return {
+    role,
+    name,
+    content: contentParts,
+  };
+};
+
+const normalizeToolChoice = (
+  toolChoice: ToolChoice | undefined,
+  tools: Tool[] | undefined
+): "none" | "auto" | ToolChoiceExplicit | undefined => {
+  if (!toolChoice) return undefined;
+
+  if (toolChoice === "none" || toolChoice === "auto") {
+    return toolChoice;
+  }
+
+  if (toolChoice === "required") {
+    if (!tools || tools.length === 0) {
+      throw new Error(
+        "tool_choice 'required' was provided but no tools were configured"
+      );
+    }
+
+    if (tools.length > 1) {
+      throw new Error(
+        "tool_choice 'required' needs a single tool or specify the tool name explicitly"
+      );
+    }
+
+    return {
+      type: "function",
+      function: { name: tools[0].function.name },
+    };
+  }
+
+  if ("name" in toolChoice) {
+    return {
+      type: "function",
+      function: { name: toolChoice.name },
+    };
+  }
+
+  return toolChoice;
+};
+
+const resolveApiUrl = () =>
+  ENV.forgeApiUrl && ENV.forgeApiUrl.trim().length > 0
+    ? `${ENV.forgeApiUrl.replace(/\/$/, "")}/v1/chat/completions`
+    : "https://forge.manus.im/v1/chat/completions";
+
+const assertApiKey = () => {
+  if (!ENV.forgeApiKey) {
+    throw new Error("OPENAI_API_KEY is not configured");
+  }
+};
+
+const normalizeResponseFormat = ({
+  responseFormat,
+  response_format,
+  outputSchema,
+  output_schema,
+}: {
+  responseFormat?: ResponseFormat;
+  response_format?: ResponseFormat;
+  outputSchema?: OutputSchema;
+  output_schema?: OutputSchema;
+}):
+  | { type: "json_schema"; json_schema: JsonSchema }
+  | { type: "text" }
+  | { type: "json_object" }
+  | undefined => {
+  const explicitFormat = responseFormat || response_format;
+  if (explicitFormat) {
+    if (
+      explicitFormat.type === "json_schema" &&
+      !explicitFormat.json_schema?.schema
+    ) {
+      throw new Error(
+        "responseFormat json_schema requires a defined schema object"
+      );
+    }
+    return explicitFormat;
+  }
+
+  const schema = outputSchema || output_schema;
+  if (!schema) return undefined;
+
+  if (!schema.name || !schema.schema) {
+    throw new Error("outputSchema requires both name and schema");
+  }
+
+  return {
+    type: "json_schema",
+    json_schema: {
+      name: schema.name,
+      schema: schema.schema,
+      ...(typeof schema.strict === "boolean" ? { strict: schema.strict } : {}),
+    },
+  };
+};
+
+export async function invokeLLM(params: InvokeParams): Promise<InvokeResult> {
+  assertApiKey();
+
+  const {
+    messages,
+    tools,
+    toolChoice,
+    tool_choice,
+    outputSchema,
+    output_schema,
+    responseFormat,
+    response_format,
+  } = params;
+
+  const payload: Record<string, unknown> = {
+    model: "gemini-2.5-flash",
+    messages: messages.map(normalizeMessage),
+  };
+
+  if (tools && tools.length > 0) {
+    payload.tools = tools;
+  }
+
+  const normalizedToolChoice = normalizeToolChoice(
+    toolChoice || tool_choice,
+    tools
+  );
+  if (normalizedToolChoice) {
+    payload.tool_choice = normalizedToolChoice;
+  }
+
+  payload.max_tokens = 32768
+  payload.thinking = {
+    "budget_tokens": 128
+  }
+
+  const normalizedResponseFormat = normalizeResponseFormat({
+    responseFormat,
+    response_format,
+    outputSchema,
+    output_schema,
+  });
+
+  if (normalizedResponseFormat) {
+    payload.response_format = normalizedResponseFormat;
+  }
+
+  const response = await fetch(resolveApiUrl(), {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      authorization: `Bearer ${ENV.forgeApiKey}`,
+    },
+    body: JSON.stringify(payload),
+  });
+
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(
+      `LLM invoke failed: ${response.status} ${response.statusText} – ${errorText}`
+    );
+  }
+
+  return (await response.json()) as InvokeResult;
+}
--- a/server/_core/map.ts
+++ b/server/_core/map.ts
@@ -0,0 +1,319 @@
+/**
+ * Google Maps API Integration for Manus WebDev Templates
+ * 
+ * Main function: makeRequest<T>(endpoint, params) - Makes authenticated requests to Google Maps APIs
+ * All credentials are automatically injected. Array parameters use | as separator.
+ * 
+ * See API examples below the type definitions for usage patterns.
+ */
+
+import { ENV } from "./env";
+
+// ============================================================================
+// Configuration
+// ============================================================================
+
+type MapsConfig = {
+  baseUrl: string;
+  apiKey: string;
+};
+
+function getMapsConfig(): MapsConfig {
+  const baseUrl = ENV.forgeApiUrl;
+  const apiKey = ENV.forgeApiKey;
+
+  if (!baseUrl || !apiKey) {
+    throw new Error(
+      "Google Maps proxy credentials missing: set BUILT_IN_FORGE_API_URL and BUILT_IN_FORGE_API_KEY"
+    );
+  }
+
+  return {
+    baseUrl: baseUrl.replace(/\/+$/, ""),
+    apiKey,
+  };
+}
+
+// ============================================================================
+// Core Request Handler
+// ============================================================================
+
+interface RequestOptions {
+  method?: "GET" | "POST";
+  body?: Record<string, unknown>;
+}
+
+/**
+ * Make authenticated requests to Google Maps APIs
+ * 
+ * @param endpoint - The API endpoint (e.g., "/maps/api/geocode/json")
+ * @param params - Query parameters for the request
+ * @param options - Additional request options
+ * @returns The API response
+ */
+export async function makeRequest<T = unknown>(
+  endpoint: string,
+  params: Record<string, unknown> = {},
+  options: RequestOptions = {}
+): Promise<T> {
+  const { baseUrl, apiKey } = getMapsConfig();
+
+  // Construct full URL: baseUrl + /v1/maps/proxy + endpoint
+  const url = new URL(`${baseUrl}/v1/maps/proxy${endpoint}`);
+
+  // Add API key as query parameter (standard Google Maps API authentication)
+  url.searchParams.append("key", apiKey);
+
+  // Add other query parameters
+  Object.entries(params).forEach(([key, value]) => {
+    if (value !== undefined && value !== null) {
+      url.searchParams.append(key, String(value));
+    }
+  });
+
+  const response = await fetch(url.toString(), {
+    method: options.method || "GET",
+    headers: {
+      "Content-Type": "application/json",
+    },
+    body: options.body ? JSON.stringify(options.body) : undefined,
+  });
+
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(
+      `Google Maps API request failed (${response.status} ${response.statusText}): ${errorText}`
+    );
+  }
+
+  return (await response.json()) as T;
+}
+
+// ============================================================================
+// Type Definitions
+// ============================================================================
+
+export type TravelMode = "driving" | "walking" | "bicycling" | "transit";
+export type MapType = "roadmap" | "satellite" | "terrain" | "hybrid";
+export type SpeedUnit = "KPH" | "MPH";
+
+export type LatLng = {
+  lat: number;
+  lng: number;
+};
+
+export type DirectionsResult = {
+  routes: Array<{
+    legs: Array<{
+      distance: { text: string; value: number };
+      duration: { text: string; value: number };
+      start_address: string;
+      end_address: string;
+      start_location: LatLng;
+      end_location: LatLng;
+      steps: Array<{
+        distance: { text: string; value: number };
+        duration: { text: string; value: number };
+        html_instructions: string;
+        travel_mode: string;
+        start_location: LatLng;
+        end_location: LatLng;
+      }>;
+    }>;
+    overview_polyline: { points: string };
+    summary: string;
+    warnings: string[];
+    waypoint_order: number[];
+  }>;
+  status: string;
+};
+
+export type DistanceMatrixResult = {
+  rows: Array<{
+    elements: Array<{
+      distance: { text: string; value: number };
+      duration: { text: string; value: number };
+      status: string;
+    }>;
+  }>;
+  origin_addresses: string[];
+  destination_addresses: string[];
+  status: string;
+};
+
+export type GeocodingResult = {
+  results: Array<{
+    address_components: Array<{
+      long_name: string;
+      short_name: string;
+      types: string[];
+    }>;
+    formatted_address: string;
+    geometry: {
+      location: LatLng;
+      location_type: string;
+      viewport: {
+        northeast: LatLng;
+        southwest: LatLng;
+      };
+    };
+    place_id: string;
+    types: string[];
+  }>;
+  status: string;
+};
+
+export type PlacesSearchResult = {
+  results: Array<{
+    place_id: string;
+    name: string;
+    formatted_address: string;
+    geometry: {
+      location: LatLng;
+    };
+    rating?: number;
+    user_ratings_total?: number;
+    business_status?: string;
+    types: string[];
+  }>;
+  status: string;
+};
+
+export type PlaceDetailsResult = {
+  result: {
+    place_id: string;
+    name: string;
+    formatted_address: string;
+    formatted_phone_number?: string;
+    international_phone_number?: string;
+    website?: string;
+    rating?: number;
+    user_ratings_total?: number;
+    reviews?: Array<{
+      author_name: string;
+      rating: number;
+      text: string;
+      time: number;
+    }>;
+    opening_hours?: {
+      open_now: boolean;
+      weekday_text: string[];
+    };
+    geometry: {
+      location: LatLng;
+    };
+  };
+  status: string;
+};
+
+export type ElevationResult = {
+  results: Array<{
+    elevation: number;
+    location: LatLng;
+    resolution: number;
+  }>;
+  status: string;
+};
+
+export type TimeZoneResult = {
+  dstOffset: number;
+  rawOffset: number;
+  status: string;
+  timeZoneId: string;
+  timeZoneName: string;
+};
+
+export type RoadsResult = {
+  snappedPoints: Array<{
+    location: LatLng;
+    originalIndex?: number;
+    placeId: string;
+  }>;
+};
+
+// ============================================================================
+// Google Maps API Reference
+// ============================================================================
+
+/**
+ * GEOCODING - Convert between addresses and coordinates
+ * Endpoint: /maps/api/geocode/json
+ * Input: { address: string } OR { latlng: string }  // latlng: "37.42,-122.08"
+ * Output: GeocodingResult  // results[0].geometry.location, results[0].formatted_address
+ */
+
+/**
+ * DIRECTIONS - Get navigation routes between locations
+ * Endpoint: /maps/api/directions/json
+ * Input: { origin: string, destination: string, mode?: TravelMode, waypoints?: string, alternatives?: boolean }
+ * Output: DirectionsResult  // routes[0].legs[0].distance, duration, steps
+ */
+
+/**
+ * DISTANCE MATRIX - Calculate travel times/distances for multiple origin-destination pairs
+ * Endpoint: /maps/api/distancematrix/json
+ * Input: { origins: string, destinations: string, mode?: TravelMode, units?: "metric"|"imperial" }  // origins: "NYC|Boston"
+ * Output: DistanceMatrixResult  // rows[0].elements[1] = first origin to second destination
+ */
+
+/**
+ * PLACE SEARCH - Find businesses/POIs by text query
+ * Endpoint: /maps/api/place/textsearch/json
+ * Input: { query: string, location?: string, radius?: number, type?: string }  // location: "40.7,-74.0"
+ * Output: PlacesSearchResult  // results[].name, rating, geometry.location, place_id
+ */
+
+/**
+ * NEARBY SEARCH - Find places near a specific location
+ * Endpoint: /maps/api/place/nearbysearch/json
+ * Input: { location: string, radius: number, type?: string, keyword?: string }  // location: "40.7,-74.0"
+ * Output: PlacesSearchResult
+ */
+
+/**
+ * PLACE DETAILS - Get comprehensive information about a specific place
+ * Endpoint: /maps/api/place/details/json
+ * Input: { place_id: string, fields?: string }  // fields: "name,rating,opening_hours,website"
+ * Output: PlaceDetailsResult  // result.name, rating, opening_hours, etc.
+ */
+
+/**
+ * ELEVATION - Get altitude data for geographic points
+ * Endpoint: /maps/api/elevation/json
+ * Input: { locations?: string, path?: string, samples?: number }  // locations: "39.73,-104.98|36.45,-116.86"
+ * Output: ElevationResult  // results[].elevation (meters)
+ */
+
+/**
+ * TIME ZONE - Get timezone information for a location
+ * Endpoint: /maps/api/timezone/json
+ * Input: { location: string, timestamp: number }  // timestamp: Math.floor(Date.now()/1000)
+ * Output: TimeZoneResult  // timeZoneId, timeZoneName
+ */
+
+/**
+ * ROADS - Snap GPS traces to roads, find nearest roads, get speed limits
+ * - /v1/snapToRoads: Input: { path: string, interpolate?: boolean }  // path: "lat,lng|lat,lng"
+ * - /v1/nearestRoads: Input: { points: string }  // points: "lat,lng|lat,lng"
+ * - /v1/speedLimits: Input: { path: string, units?: SpeedUnit }
+ * Output: RoadsResult
+ */
+
+/**
+ * PLACE AUTOCOMPLETE - Real-time place suggestions as user types
+ * Endpoint: /maps/api/place/autocomplete/json
+ * Input: { input: string, location?: string, radius?: number }
+ * Output: { predictions: Array<{ description: string, place_id: string }> }
+ */
+
+/**
+ * STATIC MAPS - Generate map images as URLs (for emails, reports, <img> tags)
+ * Endpoint: /maps/api/staticmap
+ * Input: URL params - center: string, zoom: number, size: string, markers?: string, maptype?: MapType
+ * Output: Image URL (not JSON) - use directly in <img src={url} />
+ * Note: Construct URL manually with getMapsConfig() for auth
+ */
+
+
+
+
--- a/server/_core/notification.ts
+++ b/server/_core/notification.ts
@@ -0,0 +1,114 @@
+import { TRPCError } from "@trpc/server";
+import { ENV } from "./env";
+
+export type NotificationPayload = {
+  title: string;
+  content: string;
+};
+
+const TITLE_MAX_LENGTH = 1200;
+const CONTENT_MAX_LENGTH = 20000;
+
+const trimValue = (value: string): string => value.trim();
+const isNonEmptyString = (value: unknown): value is string =>
+  typeof value === "string" && value.trim().length > 0;
+
+const buildEndpointUrl = (baseUrl: string): string => {
+  const normalizedBase = baseUrl.endsWith("/")
+    ? baseUrl
+    : `${baseUrl}/`;
+  return new URL(
+    "webdevtoken.v1.WebDevService/SendNotification",
+    normalizedBase
+  ).toString();
+};
+
+const validatePayload = (input: NotificationPayload): NotificationPayload => {
+  if (!isNonEmptyString(input.title)) {
+    throw new TRPCError({
+      code: "BAD_REQUEST",
+      message: "Notification title is required.",
+    });
+  }
+  if (!isNonEmptyString(input.content)) {
+    throw new TRPCError({
+      code: "BAD_REQUEST",
+      message: "Notification content is required.",
+    });
+  }
+
+  const title = trimValue(input.title);
+  const content = trimValue(input.content);
+
+  if (title.length > TITLE_MAX_LENGTH) {
+    throw new TRPCError({
+      code: "BAD_REQUEST",
+      message: `Notification title must be at most ${TITLE_MAX_LENGTH} characters.`,
+    });
+  }
+
+  if (content.length > CONTENT_MAX_LENGTH) {
+    throw new TRPCError({
+      code: "BAD_REQUEST",
+      message: `Notification content must be at most ${CONTENT_MAX_LENGTH} characters.`,
+    });
+  }
+
+  return { title, content };
+};
+
+/**
+ * Dispatches a project-owner notification through the Manus Notification Service.
+ * Returns `true` if the request was accepted, `false` when the upstream service
+ * cannot be reached (callers can fall back to email/slack). Validation errors
+ * bubble up as TRPC errors so callers can fix the payload.
+ */
+export async function notifyOwner(
+  payload: NotificationPayload
+): Promise<boolean> {
+  const { title, content } = validatePayload(payload);
+
+  if (!ENV.forgeApiUrl) {
+    throw new TRPCError({
+      code: "INTERNAL_SERVER_ERROR",
+      message: "Notification service URL is not configured.",
+    });
+  }
+
+  if (!ENV.forgeApiKey) {
+    throw new TRPCError({
+      code: "INTERNAL_SERVER_ERROR",
+      message: "Notification service API key is not configured.",
+    });
+  }
+
+  const endpoint = buildEndpointUrl(ENV.forgeApiUrl);
+
+  try {
+    const response = await fetch(endpoint, {
+      method: "POST",
+      headers: {
+        accept: "application/json",
+        authorization: `Bearer ${ENV.forgeApiKey}`,
+        "content-type": "application/json",
+        "connect-protocol-version": "1",
+      },
+      body: JSON.stringify({ title, content }),
+    });
+
+    if (!response.ok) {
+      const detail = await response.text().catch(() => "");
+      console.warn(
+        `[Notification] Failed to notify owner (${response.status} ${response.statusText})${
+          detail ? `: ${detail}` : ""
+        }`
+      );
+      return false;
+    }
+
+    return true;
+  } catch (error) {
+    console.warn("[Notification] Error calling notification service:", error);
+    return false;
+  }
+}
--- a/server/_core/oauth.ts
+++ b/server/_core/oauth.ts
@@ -0,0 +1,53 @@
+import { COOKIE_NAME, ONE_YEAR_MS } from "@shared/const";
+import type { Express, Request, Response } from "express";
+import * as db from "../db";
+import { getSessionCookieOptions } from "./cookies";
+import { sdk } from "./sdk";
+
+function getQueryParam(req: Request, key: string): string | undefined {
+  const value = req.query[key];
+  return typeof value === "string" ? value : undefined;
+}
+
+export function registerOAuthRoutes(app: Express) {
+  app.get("/api/oauth/callback", async (req: Request, res: Response) => {
+    const code = getQueryParam(req, "code");
+    const state = getQueryParam(req, "state");
+
+    if (!code || !state) {
+      res.status(400).json({ error: "code and state are required" });
+      return;
+    }
+
+    try {
+      const tokenResponse = await sdk.exchangeCodeForToken(code, state);
+      const userInfo = await sdk.getUserInfo(tokenResponse.accessToken);
+
+      if (!userInfo.openId) {
+        res.status(400).json({ error: "openId missing from user info" });
+        return;
+      }
+
+      await db.upsertUser({
+        openId: userInfo.openId,
+        name: userInfo.name || null,
+        email: userInfo.email ?? null,
+        loginMethod: userInfo.loginMethod ?? userInfo.platform ?? null,
+        lastSignedIn: new Date(),
+      });
+
+      const sessionToken = await sdk.createSessionToken(userInfo.openId, {
+        name: userInfo.name || "",
+        expiresInMs: ONE_YEAR_MS,
+      });
+
+      const cookieOptions = getSessionCookieOptions(req);
+      res.cookie(COOKIE_NAME, sessionToken, { ...cookieOptions, maxAge: ONE_YEAR_MS });
+
+      res.redirect(302, "/");
+    } catch (error) {
+      console.error("[OAuth] Callback failed", error);
+      res.status(500).json({ error: "OAuth callback failed" });
+    }
+  });
+}
--- a/server/_core/sdk.ts
+++ b/server/_core/sdk.ts
@@ -0,0 +1,304 @@
+import { AXIOS_TIMEOUT_MS, COOKIE_NAME, ONE_YEAR_MS } from "@shared/const";
+import { ForbiddenError } from "@shared/_core/errors";
+import axios, { type AxiosInstance } from "axios";
+import { parse as parseCookieHeader } from "cookie";
+import type { Request } from "express";
+import { SignJWT, jwtVerify } from "jose";
+import type { User } from "../../drizzle/schema";
+import * as db from "../db";
+import { ENV } from "./env";
+import type {
+  ExchangeTokenRequest,
+  ExchangeTokenResponse,
+  GetUserInfoResponse,
+  GetUserInfoWithJwtRequest,
+  GetUserInfoWithJwtResponse,
+} from "./types/manusTypes";
+// Utility function
+const isNonEmptyString = (value: unknown): value is string =>
+  typeof value === "string" && value.length > 0;
+
+export type SessionPayload = {
+  openId: string;
+  appId: string;
+  name: string;
+};
+
+const EXCHANGE_TOKEN_PATH = `/webdev.v1.WebDevAuthPublicService/ExchangeToken`;
+const GET_USER_INFO_PATH = `/webdev.v1.WebDevAuthPublicService/GetUserInfo`;
+const GET_USER_INFO_WITH_JWT_PATH = `/webdev.v1.WebDevAuthPublicService/GetUserInfoWithJwt`;
+
+class OAuthService {
+  constructor(private client: ReturnType<typeof axios.create>) {
+    console.log("[OAuth] Initialized with baseURL:", ENV.oAuthServerUrl);
+    if (!ENV.oAuthServerUrl) {
+      console.error(
+        "[OAuth] ERROR: OAUTH_SERVER_URL is not configured! Set OAUTH_SERVER_URL environment variable."
+      );
+    }
+  }
+
+  private decodeState(state: string): string {
+    const redirectUri = atob(state);
+    return redirectUri;
+  }
+
+  async getTokenByCode(
+    code: string,
+    state: string
+  ): Promise<ExchangeTokenResponse> {
+    const payload: ExchangeTokenRequest = {
+      clientId: ENV.appId,
+      grantType: "authorization_code",
+      code,
+      redirectUri: this.decodeState(state),
+    };
+
+    const { data } = await this.client.post<ExchangeTokenResponse>(
+      EXCHANGE_TOKEN_PATH,
+      payload
+    );
+
+    return data;
+  }
+
+  async getUserInfoByToken(
+    token: ExchangeTokenResponse
+  ): Promise<GetUserInfoResponse> {
+    const { data } = await this.client.post<GetUserInfoResponse>(
+      GET_USER_INFO_PATH,
+      {
+        accessToken: token.accessToken,
+      }
+    );
+
+    return data;
+  }
+}
+
+const createOAuthHttpClient = (): AxiosInstance =>
+  axios.create({
+    baseURL: ENV.oAuthServerUrl,
+    timeout: AXIOS_TIMEOUT_MS,
+  });
+
+class SDKServer {
+  private readonly client: AxiosInstance;
+  private readonly oauthService: OAuthService;
+
+  constructor(client: AxiosInstance = createOAuthHttpClient()) {
+    this.client = client;
+    this.oauthService = new OAuthService(this.client);
+  }
+
+  private deriveLoginMethod(
+    platforms: unknown,
+    fallback: string | null | undefined
+  ): string | null {
+    if (fallback && fallback.length > 0) return fallback;
+    if (!Array.isArray(platforms) || platforms.length === 0) return null;
+    const set = new Set<string>(
+      platforms.filter((p): p is string => typeof p === "string")
+    );
+    if (set.has("REGISTERED_PLATFORM_EMAIL")) return "email";
+    if (set.has("REGISTERED_PLATFORM_GOOGLE")) return "google";
+    if (set.has("REGISTERED_PLATFORM_APPLE")) return "apple";
+    if (
+      set.has("REGISTERED_PLATFORM_MICROSOFT") ||
+      set.has("REGISTERED_PLATFORM_AZURE")
+    )
+      return "microsoft";
+    if (set.has("REGISTERED_PLATFORM_GITHUB")) return "github";
+    const first = Array.from(set)[0];
+    return first ? first.toLowerCase() : null;
+  }
+
+  /**
+   * Exchange OAuth authorization code for access token
+   * @example
+   * const tokenResponse = await sdk.exchangeCodeForToken(code, state);
+   */
+  async exchangeCodeForToken(
+    code: string,
+    state: string
+  ): Promise<ExchangeTokenResponse> {
+    return this.oauthService.getTokenByCode(code, state);
+  }
+
+  /**
+   * Get user information using access token
+   * @example
+   * const userInfo = await sdk.getUserInfo(tokenResponse.accessToken);
+   */
+  async getUserInfo(accessToken: string): Promise<GetUserInfoResponse> {
+    const data = await this.oauthService.getUserInfoByToken({
+      accessToken,
+    } as ExchangeTokenResponse);
+    const loginMethod = this.deriveLoginMethod(
+      (data as any)?.platforms,
+      (data as any)?.platform ?? data.platform ?? null
+    );
+    return {
+      ...(data as any),
+      platform: loginMethod,
+      loginMethod,
+    } as GetUserInfoResponse;
+  }
+
+  private parseCookies(cookieHeader: string | undefined) {
+    if (!cookieHeader) {
+      return new Map<string, string>();
+    }
+
+    const parsed = parseCookieHeader(cookieHeader);
+    return new Map(Object.entries(parsed));
+  }
+
+  private getSessionSecret() {
+    const secret = ENV.cookieSecret;
+    return new TextEncoder().encode(secret);
+  }
+
+  /**
+   * Create a session token for a Manus user openId
+   * @example
+   * const sessionToken = await sdk.createSessionToken(userInfo.openId);
+   */
+  async createSessionToken(
+    openId: string,
+    options: { expiresInMs?: number; name?: string } = {}
+  ): Promise<string> {
+    return this.signSession(
+      {
+        openId,
+        appId: ENV.appId,
+        name: options.name || "",
+      },
+      options
+    );
+  }
+
+  async signSession(
+    payload: SessionPayload,
+    options: { expiresInMs?: number } = {}
+  ): Promise<string> {
+    const issuedAt = Date.now();
+    const expiresInMs = options.expiresInMs ?? ONE_YEAR_MS;
+    const expirationSeconds = Math.floor((issuedAt + expiresInMs) / 1000);
+    const secretKey = this.getSessionSecret();
+
+    return new SignJWT({
+      openId: payload.openId,
+      appId: payload.appId,
+      name: payload.name,
+    })
+      .setProtectedHeader({ alg: "HS256", typ: "JWT" })
+      .setExpirationTime(expirationSeconds)
+      .sign(secretKey);
+  }
+
+  async verifySession(
+    cookieValue: string | undefined | null
+  ): Promise<{ openId: string; appId: string; name: string } | null> {
+    if (!cookieValue) {
+      console.warn("[Auth] Missing session cookie");
+      return null;
+    }
+
+    try {
+      const secretKey = this.getSessionSecret();
+      const { payload } = await jwtVerify(cookieValue, secretKey, {
+        algorithms: ["HS256"],
+      });
+      const { openId, appId, name } = payload as Record<string, unknown>;
+
+      if (
+        !isNonEmptyString(openId) ||
+        !isNonEmptyString(appId) ||
+        !isNonEmptyString(name)
+      ) {
+        console.warn("[Auth] Session payload missing required fields");
+        return null;
+      }
+
+      return {
+        openId,
+        appId,
+        name,
+      };
+    } catch (error) {
+      console.warn("[Auth] Session verification failed", String(error));
+      return null;
+    }
+  }
+
+  async getUserInfoWithJwt(
+    jwtToken: string
+  ): Promise<GetUserInfoWithJwtResponse> {
+    const payload: GetUserInfoWithJwtRequest = {
+      jwtToken,
+      projectId: ENV.appId,
+    };
+
+    const { data } = await this.client.post<GetUserInfoWithJwtResponse>(
+      GET_USER_INFO_WITH_JWT_PATH,
+      payload
+    );
+
+    const loginMethod = this.deriveLoginMethod(
+      (data as any)?.platforms,
+      (data as any)?.platform ?? data.platform ?? null
+    );
+    return {
+      ...(data as any),
+      platform: loginMethod,
+      loginMethod,
+    } as GetUserInfoWithJwtResponse;
+  }
+
+  async authenticateRequest(req: Request): Promise<User> {
+    // Regular authentication flow
+    const cookies = this.parseCookies(req.headers.cookie);
+    const sessionCookie = cookies.get(COOKIE_NAME);
+    const session = await this.verifySession(sessionCookie);
+
+    if (!session) {
+      throw ForbiddenError("Invalid session cookie");
+    }
+
+    const sessionUserId = session.openId;
+    const signedInAt = new Date();
+    let user = await db.getUserByOpenId(sessionUserId);
+
+    // If user not in DB, sync from OAuth server automatically
+    if (!user) {
+      try {
+        const userInfo = await this.getUserInfoWithJwt(sessionCookie ?? "");
+        await db.upsertUser({
+          openId: userInfo.openId,
+          name: userInfo.name || null,
+          email: userInfo.email ?? null,
+          loginMethod: userInfo.loginMethod ?? userInfo.platform ?? null,
+          lastSignedIn: signedInAt,
+        });
+        user = await db.getUserByOpenId(userInfo.openId);
+      } catch (error) {
+        console.error("[Auth] Failed to sync user from OAuth:", error);
+        throw ForbiddenError("Failed to sync user info");
+      }
+    }
+
+    if (!user) {
+      throw ForbiddenError("User not found");
+    }
+
+    await db.upsertUser({
+      openId: user.openId,
+      lastSignedIn: signedInAt,
+    });
+
+    return user;
+  }
+}
+
+export const sdk = new SDKServer();
--- a/server/_core/systemRouter.ts
+++ b/server/_core/systemRouter.ts
@@ -0,0 +1,29 @@
+import { z } from "zod";
+import { notifyOwner } from "./notification";
+import { adminProcedure, publicProcedure, router } from "./trpc";
+
+export const systemRouter = router({
+  health: publicProcedure
+    .input(
+      z.object({
+        timestamp: z.number().min(0, "timestamp cannot be negative"),
+      })
+    )
+    .query(() => ({
+      ok: true,
+    })),
+
+  notifyOwner: adminProcedure
+    .input(
+      z.object({
+        title: z.string().min(1, "title is required"),
+        content: z.string().min(1, "content is required"),
+      })
+    )
+    .mutation(async ({ input }) => {
+      const delivered = await notifyOwner(input);
+      return {
+        success: delivered,
+      } as const;
+    }),
+});
--- a/server/_core/trpc.ts
+++ b/server/_core/trpc.ts
@@ -0,0 +1,45 @@
+import { NOT_ADMIN_ERR_MSG, UNAUTHED_ERR_MSG } from '@shared/const';
+import { initTRPC, TRPCError } from "@trpc/server";
+import superjson from "superjson";
+import type { TrpcContext } from "./context";
+
+const t = initTRPC.context<TrpcContext>().create({
+  transformer: superjson,
+});
+
+export const router = t.router;
+export const publicProcedure = t.procedure;
+
+const requireUser = t.middleware(async opts => {
+  const { ctx, next } = opts;
+
+  if (!ctx.user) {
+    throw new TRPCError({ code: "UNAUTHORIZED", message: UNAUTHED_ERR_MSG });
+  }
+
+  return next({
+    ctx: {
+      ...ctx,
+      user: ctx.user,
+    },
+  });
+});
+
+export const protectedProcedure = t.procedure.use(requireUser);
+
+export const adminProcedure = t.procedure.use(
+  t.middleware(async opts => {
+    const { ctx, next } = opts;
+
+    if (!ctx.user || ctx.user.role !== 'admin') {
+      throw new TRPCError({ code: "FORBIDDEN", message: NOT_ADMIN_ERR_MSG });
+    }
+
+    return next({
+      ctx: {
+        ...ctx,
+        user: ctx.user,
+      },
+    });
+  }),
+);
--- a/server/_core/types/cookie.d.ts
+++ b/server/_core/types/cookie.d.ts
@@ -0,0 +1,6 @@
+declare module "cookie" {
+  export function parse(
+    str: string,
+    options?: Record<string, unknown>
+  ): Record<string, string>;
+}
--- a/server/_core/types/manusTypes.ts
+++ b/server/_core/types/manusTypes.ts
@@ -0,0 +1,69 @@
+// WebDev Auth TypeScript types
+// Auto-generated from protobuf definitions
+// Generated on: 2025-09-24T05:57:57.338Z
+
+export interface AuthorizeRequest {
+  redirectUri: string;
+  projectId: string;
+  state: string;
+  responseType: string;
+  scope: string;
+}
+
+export interface AuthorizeResponse {
+  redirectUrl: string;
+}
+
+export interface ExchangeTokenRequest {
+  grantType: string;
+  code: string;
+  refreshToken?: string;
+  clientId: string;
+  clientSecret?: string;
+  redirectUri: string;
+}
+
+export interface ExchangeTokenResponse {
+  accessToken: string;
+  tokenType: string;
+  expiresIn: number;
+  refreshToken?: string;
+  scope: string;
+  idToken: string;
+}
+
+export interface GetUserInfoRequest {
+  accessToken: string;
+}
+
+export interface GetUserInfoResponse {
+  openId: string;
+  projectId: string;
+  name: string;
+  email?: string | null;
+  platform?: string | null;
+  loginMethod?: string | null;
+}
+
+export interface CanAccessRequest {
+  openId: string;
+  projectId: string;
+}
+
+export interface CanAccessResponse {
+  canAccess: boolean;
+}
+
+export interface GetUserInfoWithJwtRequest {
+  jwtToken: string;
+  projectId: string;
+}
+
+export interface GetUserInfoWithJwtResponse {
+  openId: string;
+  projectId: string;
+  name: string;
+  email?: string | null;
+  platform?: string | null;
+  loginMethod?: string | null;
+}
--- a/server/_core/vite.ts
+++ b/server/_core/vite.ts
@@ -0,0 +1,67 @@
+import express, { type Express } from "express";
+import fs from "fs";
+import { type Server } from "http";
+import { nanoid } from "nanoid";
+import path from "path";
+import { createServer as createViteServer } from "vite";
+import viteConfig from "../../vite.config";
+
+export async function setupVite(app: Express, server: Server) {
+  const serverOptions = {
+    middlewareMode: true,
+    hmr: { server },
+    allowedHosts: true as const,
+  };
+
+  const vite = await createViteServer({
+    ...viteConfig,
+    configFile: false,
+    server: serverOptions,
+    appType: "custom",
+  });
+
+  app.use(vite.middlewares);
+  app.use("*", async (req, res, next) => {
+    const url = req.originalUrl;
+
+    try {
+      const clientTemplate = path.resolve(
+        import.meta.dirname,
+        "../..",
+        "client",
+        "index.html"
+      );
+
+      // always reload the index.html file from disk incase it changes
+      let template = await fs.promises.readFile(clientTemplate, "utf-8");
+      template = template.replace(
+        `src="/src/main.tsx"`,
+        `src="/src/main.tsx?v=${nanoid()}"`
+      );
+      const page = await vite.transformIndexHtml(url, template);
+      res.status(200).set({ "Content-Type": "text/html" }).end(page);
+    } catch (e) {
+      vite.ssrFixStacktrace(e as Error);
+      next(e);
+    }
+  });
+}
+
+export function serveStatic(app: Express) {
+  const distPath =
+    process.env.NODE_ENV === "development"
+      ? path.resolve(import.meta.dirname, "../..", "dist", "public")
+      : path.resolve(import.meta.dirname, "public");
+  if (!fs.existsSync(distPath)) {
+    console.error(
+      `Could not find the build directory: ${distPath}, make sure to build the client first`
+    );
+  }
+
+  app.use(express.static(distPath));
+
+  // fall through to index.html if the file doesn't exist
+  app.use("*", (_req, res) => {
+    res.sendFile(path.resolve(distPath, "index.html"));
+  });
+}
--- a/server/_core/voiceTranscription.ts
+++ b/server/_core/voiceTranscription.ts
@@ -0,0 +1,284 @@
+/**
+ * Voice transcription helper using internal Speech-to-Text service
+ *
+ * Frontend implementation guide:
+ * 1. Capture audio using MediaRecorder API
+ * 2. Upload audio to storage (e.g., S3) to get URL
+ * 3. Call transcription with the URL
+ * 
+ * Example usage:
+ * ```tsx
+ * // Frontend component
+ * const transcribeMutation = trpc.voice.transcribe.useMutation({
+ *   onSuccess: (data) => {
+ *     console.log(data.text); // Full transcription
+ *     console.log(data.language); // Detected language
+ *     console.log(data.segments); // Timestamped segments
+ *   }
+ * });
+ * 
+ * // After uploading audio to storage
+ * transcribeMutation.mutate({
+ *   audioUrl: uploadedAudioUrl,
+ *   language: 'en', // optional
+ *   prompt: 'Transcribe the meeting' // optional
+ * });
+ * ```
+ */
+import { ENV } from "./env";
+
+export type TranscribeOptions = {
+  audioUrl: string; // URL to the audio file (e.g., S3 URL)
+  language?: string; // Optional: specify language code (e.g., "en", "es", "zh")
+  prompt?: string; // Optional: custom prompt for the transcription
+};
+
+// Native Whisper API segment format
+export type WhisperSegment = {
+  id: number;
+  seek: number;
+  start: number;
+  end: number;
+  text: string;
+  tokens: number[];
+  temperature: number;
+  avg_logprob: number;
+  compression_ratio: number;
+  no_speech_prob: number;
+};
+
+// Native Whisper API response format
+export type WhisperResponse = {
+  task: "transcribe";
+  language: string;
+  duration: number;
+  text: string;
+  segments: WhisperSegment[];
+};
+
+export type TranscriptionResponse = WhisperResponse; // Return native Whisper API response directly
+
+export type TranscriptionError = {
+  error: string;
+  code: "FILE_TOO_LARGE" | "INVALID_FORMAT" | "TRANSCRIPTION_FAILED" | "UPLOAD_FAILED" | "SERVICE_ERROR";
+  details?: string;
+};
+
+/**
+ * Transcribe audio to text using the internal Speech-to-Text service
+ * 
+ * @param options - Audio data and metadata
+ * @returns Transcription result or error
+ */
+export async function transcribeAudio(
+  options: TranscribeOptions
+): Promise<TranscriptionResponse | TranscriptionError> {
+  try {
+    // Step 1: Validate environment configuration
+    if (!ENV.forgeApiUrl) {
+      return {
+        error: "Voice transcription service is not configured",
+        code: "SERVICE_ERROR",
+        details: "BUILT_IN_FORGE_API_URL is not set"
+      };
+    }
+    if (!ENV.forgeApiKey) {
+      return {
+        error: "Voice transcription service authentication is missing",
+        code: "SERVICE_ERROR",
+        details: "BUILT_IN_FORGE_API_KEY is not set"
+      };
+    }
+
+    // Step 2: Download audio from URL
+    let audioBuffer: Buffer;
+    let mimeType: string;
+    try {
+      const response = await fetch(options.audioUrl);
+      if (!response.ok) {
+        return {
+          error: "Failed to download audio file",
+          code: "INVALID_FORMAT",
+          details: `HTTP ${response.status}: ${response.statusText}`
+        };
+      }
+      
+      audioBuffer = Buffer.from(await response.arrayBuffer());
+      mimeType = response.headers.get('content-type') || 'audio/mpeg';
+      
+      // Check file size (16MB limit)
+      const sizeMB = audioBuffer.length / (1024 * 1024);
+      if (sizeMB > 16) {
+        return {
+          error: "Audio file exceeds maximum size limit",
+          code: "FILE_TOO_LARGE",
+          details: `File size is ${sizeMB.toFixed(2)}MB, maximum allowed is 16MB`
+        };
+      }
+    } catch (error) {
+      return {
+        error: "Failed to fetch audio file",
+        code: "SERVICE_ERROR",
+        details: error instanceof Error ? error.message : "Unknown error"
+      };
+    }
+
+    // Step 3: Create FormData for multipart upload to Whisper API
+    const formData = new FormData();
+    
+    // Create a Blob from the buffer and append to form
+    const filename = `audio.${getFileExtension(mimeType)}`;
+    const audioBlob = new Blob([new Uint8Array(audioBuffer)], { type: mimeType });
+    formData.append("file", audioBlob, filename);
+    
+    formData.append("model", "whisper-1");
+    formData.append("response_format", "verbose_json");
+    
+    // Add prompt - use custom prompt if provided, otherwise generate based on language
+    const prompt = options.prompt || (
+      options.language 
+        ? `Transcribe the user's voice to text, the user's working language is ${getLanguageName(options.language)}`
+        : "Transcribe the user's voice to text"
+    );
+    formData.append("prompt", prompt);
+
+    // Step 4: Call the transcription service
+    const baseUrl = ENV.forgeApiUrl.endsWith("/")
+      ? ENV.forgeApiUrl
+      : `${ENV.forgeApiUrl}/`;
+    
+    const fullUrl = new URL(
+      "v1/audio/transcriptions",
+      baseUrl
+    ).toString();
+
+    const response = await fetch(fullUrl, {
+      method: "POST",
+      headers: {
+        authorization: `Bearer ${ENV.forgeApiKey}`,
+        "Accept-Encoding": "identity",
+      },
+      body: formData,
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text().catch(() => "");
+      return {
+        error: "Transcription service request failed",
+        code: "TRANSCRIPTION_FAILED",
+        details: `${response.status} ${response.statusText}${errorText ? `: ${errorText}` : ""}`
+      };
+    }
+
+    // Step 5: Parse and return the transcription result
+    const whisperResponse = await response.json() as WhisperResponse;
+    
+    // Validate response structure
+    if (!whisperResponse.text || typeof whisperResponse.text !== 'string') {
+      return {
+        error: "Invalid transcription response",
+        code: "SERVICE_ERROR",
+        details: "Transcription service returned an invalid response format"
+      };
+    }
+
+    return whisperResponse; // Return native Whisper API response directly
+
+  } catch (error) {
+    // Handle unexpected errors
+    return {
+      error: "Voice transcription failed",
+      code: "SERVICE_ERROR",
+      details: error instanceof Error ? error.message : "An unexpected error occurred"
+    };
+  }
+}
+
+/**
+ * Helper function to get file extension from MIME type
+ */
+function getFileExtension(mimeType: string): string {
+  const mimeToExt: Record<string, string> = {
+    'audio/webm': 'webm',
+    'audio/mp3': 'mp3',
+    'audio/mpeg': 'mp3',
+    'audio/wav': 'wav',
+    'audio/wave': 'wav',
+    'audio/ogg': 'ogg',
+    'audio/m4a': 'm4a',
+    'audio/mp4': 'm4a',
+  };
+  
+  return mimeToExt[mimeType] || 'audio';
+}
+
+/**
+ * Helper function to get full language name from ISO code
+ */
+function getLanguageName(langCode: string): string {
+  const langMap: Record<string, string> = {
+    'en': 'English',
+    'es': 'Spanish',
+    'fr': 'French',
+    'de': 'German',
+    'it': 'Italian',
+    'pt': 'Portuguese',
+    'ru': 'Russian',
+    'ja': 'Japanese',
+    'ko': 'Korean',
+    'zh': 'Chinese',
+    'ar': 'Arabic',
+    'hi': 'Hindi',
+    'nl': 'Dutch',
+    'pl': 'Polish',
+    'tr': 'Turkish',
+    'sv': 'Swedish',
+    'da': 'Danish',
+    'no': 'Norwegian',
+    'fi': 'Finnish',
+  };
+  
+  return langMap[langCode] || langCode;
+}
+
+/**
+ * Example tRPC procedure implementation:
+ * 
+ * ```ts
+ * // In server/routers.ts
+ * import { transcribeAudio } from "./_core/voiceTranscription";
+ * 
+ * export const voiceRouter = router({
+ *   transcribe: protectedProcedure
+ *     .input(z.object({
+ *       audioUrl: z.string(),
+ *       language: z.string().optional(),
+ *       prompt: z.string().optional(),
+ *     }))
+ *     .mutation(async ({ input, ctx }) => {
+ *       const result = await transcribeAudio(input);
+ *       
+ *       // Check if it's an error
+ *       if ('error' in result) {
+ *         throw new TRPCError({
+ *           code: 'BAD_REQUEST',
+ *           message: result.error,
+ *           cause: result,
+ *         });
+ *       }
+ *       
+ *       // Optionally save transcription to database
+ *       await db.insert(transcriptions).values({
+ *         userId: ctx.user.id,
+ *         text: result.text,
+ *         duration: result.duration,
+ *         language: result.language,
+ *         audioUrl: input.audioUrl,
+ *         createdAt: new Date(),
+ *       });
+ *       
+ *       return result;
+ *     }),
+ * });
+ * ```
+ */
--- a/server/auth.logout.test.ts
+++ b/server/auth.logout.test.ts
@@ -0,0 +1,62 @@
+import { describe, expect, it } from "vitest";
+import { appRouter } from "./routers";
+import { COOKIE_NAME } from "../shared/const";
+import type { TrpcContext } from "./_core/context";
+
+type CookieCall = {
+  name: string;
+  options: Record<string, unknown>;
+};
+
+type AuthenticatedUser = NonNullable<TrpcContext["user"]>;
+
+function createAuthContext(): { ctx: TrpcContext; clearedCookies: CookieCall[] } {
+  const clearedCookies: CookieCall[] = [];
+
+  const user: AuthenticatedUser = {
+    id: 1,
+    openId: "sample-user",
+    email: "sample@example.com",
+    name: "Sample User",
+    loginMethod: "manus",
+    role: "user",
+    createdAt: new Date(),
+    updatedAt: new Date(),
+    lastSignedIn: new Date(),
+  };
+
+  const ctx: TrpcContext = {
+    user,
+    req: {
+      protocol: "https",
+      headers: {},
+    } as TrpcContext["req"],
+    res: {
+      clearCookie: (name: string, options: Record<string, unknown>) => {
+        clearedCookies.push({ name, options });
+      },
+    } as TrpcContext["res"],
+  };
+
+  return { ctx, clearedCookies };
+}
+
+describe("auth.logout", () => {
+  it("clears the session cookie and reports success", async () => {
+    const { ctx, clearedCookies } = createAuthContext();
+    const caller = appRouter.createCaller(ctx);
+
+    const result = await caller.auth.logout();
+
+    expect(result).toEqual({ success: true });
+    expect(clearedCookies).toHaveLength(1);
+    expect(clearedCookies[0]?.name).toBe(COOKIE_NAME);
+    expect(clearedCookies[0]?.options).toMatchObject({
+      maxAge: -1,
+      secure: true,
+      sameSite: "none",
+      httpOnly: true,
+      path: "/",
+    });
+  });
+});
--- a/server/db.ts
+++ b/server/db.ts
@@ -0,0 +1,92 @@
+import { eq } from "drizzle-orm";
+import { drizzle } from "drizzle-orm/mysql2";
+import { InsertUser, users } from "../drizzle/schema";
+import { ENV } from './_core/env';
+
+let _db: ReturnType<typeof drizzle> | null = null;
+
+// Lazily create the drizzle instance so local tooling can run without a DB.
+export async function getDb() {
+  if (!_db && process.env.DATABASE_URL) {
+    try {
+      _db = drizzle(process.env.DATABASE_URL);
+    } catch (error) {
+      console.warn("[Database] Failed to connect:", error);
+      _db = null;
+    }
+  }
+  return _db;
+}
+
+export async function upsertUser(user: InsertUser): Promise<void> {
+  if (!user.openId) {
+    throw new Error("User openId is required for upsert");
+  }
+
+  const db = await getDb();
+  if (!db) {
+    console.warn("[Database] Cannot upsert user: database not available");
+    return;
+  }
+
+  try {
+    const values: InsertUser = {
+      openId: user.openId,
+    };
+    const updateSet: Record<string, unknown> = {};
+
+    const textFields = ["name", "email", "loginMethod"] as const;
+    type TextField = (typeof textFields)[number];
+
+    const assignNullable = (field: TextField) => {
+      const value = user[field];
+      if (value === undefined) return;
+      const normalized = value ?? null;
+      values[field] = normalized;
+      updateSet[field] = normalized;
+    };
+
+    textFields.forEach(assignNullable);
+
+    if (user.lastSignedIn !== undefined) {
+      values.lastSignedIn = user.lastSignedIn;
+      updateSet.lastSignedIn = user.lastSignedIn;
+    }
+    if (user.role !== undefined) {
+      values.role = user.role;
+      updateSet.role = user.role;
+    } else if (user.openId === ENV.ownerOpenId) {
+      values.role = 'admin';
+      updateSet.role = 'admin';
+    }
+
+    if (!values.lastSignedIn) {
+      values.lastSignedIn = new Date();
+    }
+
+    if (Object.keys(updateSet).length === 0) {
+      updateSet.lastSignedIn = new Date();
+    }
+
+    await db.insert(users).values(values).onDuplicateKeyUpdate({
+      set: updateSet,
+    });
+  } catch (error) {
+    console.error("[Database] Failed to upsert user:", error);
+    throw error;
+  }
+}
+
+export async function getUserByOpenId(openId: string) {
+  const db = await getDb();
+  if (!db) {
+    console.warn("[Database] Cannot get user: database not available");
+    return undefined;
+  }
+
+  const result = await db.select().from(users).where(eq(users.openId, openId)).limit(1);
+
+  return result.length > 0 ? result[0] : undefined;
+}
+
+// TODO: add feature queries here as your schema grows.
--- a/server/ollama.test.ts
+++ b/server/ollama.test.ts
@@ -0,0 +1,82 @@
+import { describe, expect, it } from "vitest";
+import { appRouter } from "./routers";
+import type { TrpcContext } from "./_core/context";
+
+function createPublicContext(): TrpcContext {
+  return {
+    user: null,
+    req: {
+      protocol: "https",
+      headers: {},
+    } as TrpcContext["req"],
+    res: {
+      clearCookie: () => {},
+    } as TrpcContext["res"],
+  };
+}
+
+describe("ollama API integration", () => {
+  it("health check returns connected status and latency", async () => {
+    const ctx = createPublicContext();
+    const caller = appRouter.createCaller(ctx);
+
+    const result = await caller.ollama.health();
+
+    expect(result).toHaveProperty("connected");
+    expect(result).toHaveProperty("latencyMs");
+    expect(typeof result.connected).toBe("boolean");
+    expect(typeof result.latencyMs).toBe("number");
+    // API should be reachable
+    expect(result.connected).toBe(true);
+  });
+
+  it("models endpoint returns a list of models", async () => {
+    const ctx = createPublicContext();
+    const caller = appRouter.createCaller(ctx);
+
+    const result = await caller.ollama.models();
+
+    expect(result).toHaveProperty("success");
+    expect(result.success).toBe(true);
+    expect(result).toHaveProperty("models");
+    expect(Array.isArray(result.models)).toBe(true);
+    expect(result.models.length).toBeGreaterThan(0);
+
+    // Each model should have an id
+    expect(result.models[0]).toHaveProperty("id");
+    expect(typeof result.models[0].id).toBe("string");
+  });
+
+  it("chat endpoint sends a message and gets a response", async () => {
+    const ctx = createPublicContext();
+    const caller = appRouter.createCaller(ctx);
+
+    // First get available models
+    const modelsResult = await caller.ollama.models();
+    expect(modelsResult.success).toBe(true);
+    expect(modelsResult.models.length).toBeGreaterThan(0);
+
+    const modelId = modelsResult.models[0].id;
+
+    const result = await caller.ollama.chat({
+      model: modelId,
+      messages: [
+        { role: "user", content: "Reply with exactly the word: hello" },
+      ],
+      temperature: 0,
+      max_tokens: 20,
+    });
+
+    expect(result).toHaveProperty("success");
+    // The chat call itself should succeed (no network error)
+    // Response content may vary depending on model availability
+    if (result.success) {
+      expect(typeof result.response).toBe("string");
+      // Model responded (even if empty for some cloud models)
+      expect(result.model).toBeTruthy();
+    } else {
+      // If it failed, there should be an error message
+      expect(result.error).toBeTruthy();
+    }
+  }, 60_000);
+});
--- a/server/ollama.ts
+++ b/server/ollama.ts
@@ -0,0 +1,131 @@
+/**
+ * Ollama API Client — серверный прокси для безопасного доступа к Ollama Cloud API.
+ * Хранит API-ключ на сервере, обходит CORS, предоставляет типизированные функции.
+ */
+import { ENV } from "./_core/env";
+
+const TIMEOUT_MS = 30_000;
+
+interface OllamaModel {
+  id: string;
+  object: string;
+  created: number;
+  owned_by: string;
+}
+
+interface OllamaModelsResponse {
+  object: string;
+  data: OllamaModel[];
+}
+
+interface ChatMessage {
+  role: "system" | "user" | "assistant";
+  content: string;
+}
+
+interface ChatChoice {
+  index: number;
+  message: ChatMessage;
+  finish_reason: string;
+}
+
+interface ChatCompletionResponse {
+  id: string;
+  object: string;
+  created: number;
+  model: string;
+  choices: ChatChoice[];
+  usage?: {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+  };
+}
+
+function getHeaders(): Record<string, string> {
+  const headers: Record<string, string> = {
+    "Content-Type": "application/json",
+  };
+  if (ENV.ollamaApiKey) {
+    headers["Authorization"] = `Bearer ${ENV.ollamaApiKey}`;
+  }
+  return headers;
+}
+
+function getBaseUrl(): string {
+  return ENV.ollamaBaseUrl.replace(/\/$/, "");
+}
+
+/**
+ * Проверка доступности Ollama API
+ */
+export async function checkOllamaHealth(): Promise<{
+  connected: boolean;
+  latencyMs: number;
+  error?: string;
+}> {
+  const start = Date.now();
+  try {
+    const res = await fetch(`${getBaseUrl()}/models`, {
+      method: "GET",
+      headers: getHeaders(),
+      signal: AbortSignal.timeout(10_000),
+    });
+    const latencyMs = Date.now() - start;
+    if (res.ok) {
+      return { connected: true, latencyMs };
+    }
+    const text = await res.text();
+    return { connected: false, latencyMs, error: `HTTP ${res.status}: ${text}` };
+  } catch (err: any) {
+    return { connected: false, latencyMs: Date.now() - start, error: err.message };
+  }
+}
+
+/**
+ * Получение списка доступных моделей (OpenAI-совместимый формат)
+ */
+export async function listModels(): Promise<OllamaModelsResponse> {
+  const res = await fetch(`${getBaseUrl()}/models`, {
+    method: "GET",
+    headers: getHeaders(),
+    signal: AbortSignal.timeout(TIMEOUT_MS),
+  });
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`Ollama API error (${res.status}): ${text}`);
+  }
+  return res.json();
+}
+
+/**
+ * Отправка сообщения в чат (OpenAI-совместимый формат, без стриминга)
+ */
+export async function chatCompletion(
+  model: string,
+  messages: ChatMessage[],
+  options?: {
+    temperature?: number;
+    max_tokens?: number;
+  }
+): Promise<ChatCompletionResponse> {
+  const res = await fetch(`${getBaseUrl()}/chat/completions`, {
+    method: "POST",
+    headers: getHeaders(),
+    body: JSON.stringify({
+      model,
+      messages,
+      stream: false,
+      ...(options?.temperature !== undefined && { temperature: options.temperature }),
+      ...(options?.max_tokens !== undefined && { max_tokens: options.max_tokens }),
+    }),
+    signal: AbortSignal.timeout(120_000), // LLM может думать долго
+  });
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`Ollama Chat API error (${res.status}): ${text}`);
+  }
+  return res.json();
+}
+
+export type { OllamaModel, OllamaModelsResponse, ChatMessage, ChatCompletionResponse };
--- a/server/routers.ts
+++ b/server/routers.ts
@@ -0,0 +1,83 @@
+import { COOKIE_NAME } from "@shared/const";
+import { z } from "zod";
+import { getSessionCookieOptions } from "./_core/cookies";
+import { systemRouter } from "./_core/systemRouter";
+import { publicProcedure, router } from "./_core/trpc";
+import { checkOllamaHealth, listModels, chatCompletion } from "./ollama";
+
+export const appRouter = router({
+  system: systemRouter,
+  auth: router({
+    me: publicProcedure.query(opts => opts.ctx.user),
+    logout: publicProcedure.mutation(({ ctx }) => {
+      const cookieOptions = getSessionCookieOptions(ctx.req);
+      ctx.res.clearCookie(COOKIE_NAME, { ...cookieOptions, maxAge: -1 });
+      return { success: true } as const;
+    }),
+  }),
+
+  /**
+   * Ollama API — серверный прокси для безопасного доступа
+   */
+  ollama: router({
+    /** Проверка подключения к Ollama API */
+    health: publicProcedure.query(async () => {
+      return checkOllamaHealth();
+    }),
+
+    /** Получение списка доступных моделей */
+    models: publicProcedure.query(async () => {
+      try {
+        const result = await listModels();
+        return {
+          success: true as const,
+          models: result.data ?? [],
+        };
+      } catch (err: any) {
+        return {
+          success: false as const,
+          models: [],
+          error: err.message,
+        };
+      }
+    }),
+
+    /** Отправка сообщения в чат */
+    chat: publicProcedure
+      .input(
+        z.object({
+          model: z.string(),
+          messages: z.array(
+            z.object({
+              role: z.enum(["system", "user", "assistant"]),
+              content: z.string(),
+            })
+          ),
+          temperature: z.number().optional(),
+          max_tokens: z.number().optional(),
+        })
+      )
+      .mutation(async ({ input }) => {
+        try {
+          const result = await chatCompletion(input.model, input.messages, {
+            temperature: input.temperature,
+            max_tokens: input.max_tokens,
+          });
+          return {
+            success: true as const,
+            response: result.choices[0]?.message?.content ?? "",
+            model: result.model,
+            usage: result.usage,
+          };
+        } catch (err: any) {
+          return {
+            success: false as const,
+            response: "",
+            error: err.message,
+          };
+        }
+      }),
+  }),
+});
+
+export type AppRouter = typeof appRouter;
--- a/server/storage.ts
+++ b/server/storage.ts
@@ -0,0 +1,102 @@
+// Preconfigured storage helpers for Manus WebDev templates
+// Uses the Biz-provided storage proxy (Authorization: Bearer <token>)
+
+import { ENV } from './_core/env';
+
+type StorageConfig = { baseUrl: string; apiKey: string };
+
+function getStorageConfig(): StorageConfig {
+  const baseUrl = ENV.forgeApiUrl;
+  const apiKey = ENV.forgeApiKey;
+
+  if (!baseUrl || !apiKey) {
+    throw new Error(
+      "Storage proxy credentials missing: set BUILT_IN_FORGE_API_URL and BUILT_IN_FORGE_API_KEY"
+    );
+  }
+
+  return { baseUrl: baseUrl.replace(/\/+$/, ""), apiKey };
+}
+
+function buildUploadUrl(baseUrl: string, relKey: string): URL {
+  const url = new URL("v1/storage/upload", ensureTrailingSlash(baseUrl));
+  url.searchParams.set("path", normalizeKey(relKey));
+  return url;
+}
+
+async function buildDownloadUrl(
+  baseUrl: string,
+  relKey: string,
+  apiKey: string
+): Promise<string> {
+  const downloadApiUrl = new URL(
+    "v1/storage/downloadUrl",
+    ensureTrailingSlash(baseUrl)
+  );
+  downloadApiUrl.searchParams.set("path", normalizeKey(relKey));
+  const response = await fetch(downloadApiUrl, {
+    method: "GET",
+    headers: buildAuthHeaders(apiKey),
+  });
+  return (await response.json()).url;
+}
+
+function ensureTrailingSlash(value: string): string {
+  return value.endsWith("/") ? value : `${value}/`;
+}
+
+function normalizeKey(relKey: string): string {
+  return relKey.replace(/^\/+/, "");
+}
+
+function toFormData(
+  data: Buffer | Uint8Array | string,
+  contentType: string,
+  fileName: string
+): FormData {
+  const blob =
+    typeof data === "string"
+      ? new Blob([data], { type: contentType })
+      : new Blob([data as any], { type: contentType });
+  const form = new FormData();
+  form.append("file", blob, fileName || "file");
+  return form;
+}
+
+function buildAuthHeaders(apiKey: string): HeadersInit {
+  return { Authorization: `Bearer ${apiKey}` };
+}
+
+export async function storagePut(
+  relKey: string,
+  data: Buffer | Uint8Array | string,
+  contentType = "application/octet-stream"
+): Promise<{ key: string; url: string }> {
+  const { baseUrl, apiKey } = getStorageConfig();
+  const key = normalizeKey(relKey);
+  const uploadUrl = buildUploadUrl(baseUrl, key);
+  const formData = toFormData(data, contentType, key.split("/").pop() ?? key);
+  const response = await fetch(uploadUrl, {
+    method: "POST",
+    headers: buildAuthHeaders(apiKey),
+    body: formData,
+  });
+
+  if (!response.ok) {
+    const message = await response.text().catch(() => response.statusText);
+    throw new Error(
+      `Storage upload failed (${response.status} ${response.statusText}): ${message}`
+    );
+  }
+  const url = (await response.json()).url;
+  return { key, url };
+}
+
+export async function storageGet(relKey: string): Promise<{ key: string; url: string; }> {
+  const { baseUrl, apiKey } = getStorageConfig();
+  const key = normalizeKey(relKey);
+  return {
+    key,
+    url: await buildDownloadUrl(baseUrl, key, apiKey),
+  };
+}
--- a/shared/_core/errors.ts
+++ b/shared/_core/errors.ts
@@ -0,0 +1,19 @@
+/**
+ * Base HTTP error class with status code.
+ * Throw this from route handlers to send specific HTTP errors.
+ */
+export class HttpError extends Error {
+  constructor(
+    public statusCode: number,
+    message: string
+  ) {
+    super(message);
+    this.name = "HttpError";
+  }
+}
+
+// Convenience constructors
+export const BadRequestError = (msg: string) => new HttpError(400, msg);
+export const UnauthorizedError = (msg: string) => new HttpError(401, msg);
+export const ForbiddenError = (msg: string) => new HttpError(403, msg);
+export const NotFoundError = (msg: string) => new HttpError(404, msg);
--- a/shared/const.ts
+++ b/shared/const.ts
@@ -1,2 +1,5 @@
 export const COOKIE_NAME = "app_session_id";
 export const ONE_YEAR_MS = 1000 * 60 * 60 * 24 * 365;
+export const AXIOS_TIMEOUT_MS = 30_000;
+export const UNAUTHED_ERR_MSG = 'Please login (10001)';
+export const NOT_ADMIN_ERR_MSG = 'You do not have required permission (10002)';
--- a/shared/types.ts
+++ b/shared/types.ts
@@ -0,0 +1,7 @@
+/**
+ * Unified type exports
+ * Import shared types from this single entry point.
+ */
+
+export type * from "../drizzle/schema";
+export * from "./_core/errors";
--- a/todo.md
+++ b/todo.md
@@ -0,0 +1,20 @@
+# GoClaw Control Center TODO
+
+- [x] Basic Dashboard layout (Mission Control theme)
+- [x] Agents page with mock data
+- [x] Nodes page with mock data
+- [x] Chat page with mock conversation
+- [x] Settings page with provider cards
+- [x] Docker Stack integration
+- [x] Fix Home.tsx conflict after upgrade
+- [x] Fix DashboardLayout.tsx conflict after upgrade
+- [x] Create server-side Ollama API proxy routes (tRPC)
+- [x] Integrate real Ollama /v1/models endpoint in Settings
+- [x] Integrate real Ollama /v1/chat/completions in Chat page
+- [x] Add OLLAMA_API_KEY and OLLAMA_BASE_URL secrets
+- [x] Write vitest tests for Ollama API proxy
+- [x] Update Dashboard with real model data
+- [ ] Add streaming support for chat responses
+- [ ] Add agent CRUD (create/edit/delete agents via UI)
+- [ ] Connect real Docker Swarm API for node monitoring
+- [ ] Add authentication/login protection
--- a/vite.config.ts
+++ b/vite.config.ts
@@ -163,13 +163,12 @@ export default defineConfig({
  },
  envDir: path.resolve(import.meta.dirname),
  root: path.resolve(import.meta.dirname, "client"),
+  publicDir: path.resolve(import.meta.dirname, "client", "public"),
  build: {
    outDir: path.resolve(import.meta.dirname, "dist/public"),
    emptyOutDir: true,
  },
  server: {
-    port: 3000,
-    strictPort: false, // Will find next available port if 3000 is busy
    host: true,
    allowedHosts: [
      ".manuspre.computer",
--- a/vitest.config.ts
+++ b/vitest.config.ts
@@ -0,0 +1,19 @@
+import { defineConfig } from "vitest/config";
+import path from "path";
+
+const templateRoot = path.resolve(import.meta.dirname);
+
+export default defineConfig({
+  root: templateRoot,
+  resolve: {
+    alias: {
+      "@": path.resolve(templateRoot, "client", "src"),
+      "@shared": path.resolve(templateRoot, "shared"),
+      "@assets": path.resolve(templateRoot, "attached_assets"),
+    },
+  },
+  test: {
+    environment: "node",
+    include: ["server/**/*.test.ts", "server/**/*.spec.ts"],
+  },
+});