diff --git a/.env.example b/.env.example
index 702dc04e..5f55b84e 100644
--- a/.env.example
+++ b/.env.example
@@ -10,6 +10,9 @@ OWNER_ID=opendots-owner
 # APP_ORIGIN=http://localhost:5173,http://127.0.0.1:5173
 # Required for an external HOST binding (24+ characters); enables local login too.
 # OWNER_TOKEN=
+# Public address of this server, for MCP sign-in callbacks behind a proxy or
+# on a hosted domain (PUBLIC_URL/oauth/mcp/callback). Defaults to the browser's.
+# PUBLIC_URL=https://dots.example.com
 
 # `copilotkit project select` or `local connect` writes CPK_INTELLIGENCE_API_KEY.
 # The server accepts either name and prefers a non-empty CPK_INTELLIGENCE_API_KEY.
diff --git a/docs/CONNECTIONS.md b/docs/CONNECTIONS.md
index 83c46e34..cf02ba45 100644
--- a/docs/CONNECTIONS.md
+++ b/docs/CONNECTIONS.md
@@ -10,6 +10,18 @@ Connections give a Dot tools from remote [MCP](https://modelcontextprotocol.io)
 
 Use **Refresh** after the server adds or changes tools. Your choices for existing tools are kept.
 
+## Signing in (OAuth)
+
+Many services ask you to sign in with your account instead of pasting a token. Add the server without a token. If it requires sign-in, the connection shows **needs sign-in**.
+
+1. Select **Sign in**. A new tab opens the service's sign-in and consent page.
+2. Approve access. The tab returns to OpenDots and says you're signed in.
+3. The settings update on their own and list the service's tools.
+
+OpenDots follows the MCP authorization spec through the official SDK: discovery, dynamic client registration, PKCE and refresh tokens. Access tokens refresh automatically. If the service stops accepting them, the connection asks you to sign in again, and its tools are hidden from the Dot until you do. **Sign out** forgets the tokens and stops the Dot's active turn.
+
+Set `PUBLIC_URL` when OpenDots runs behind a proxy or on a hosted domain. The service sends you back to `PUBLIC_URL/oauth/mcp/callback`; without `PUBLIC_URL`, OpenDots uses the address your browser is on. A sign-in link works once and expires after 10 minutes.
+
 ## Approvals
 
 Every tool starts enabled. A tool the server marks as read-only (`readOnlyHint`) runs on its own. Every other tool starts with **Ask first** on.
@@ -24,7 +36,6 @@ Changing a Dot's connections or tool settings stops that Dot's active turn.
 
 ## Security notes
 
-- Tokens are stored in the server's SQLite database and are never sent to the browser. Protect `DATABASE_PATH` the way you protect `.env`.
+- Tokens, OAuth tokens and OAuth client registrations are stored in the server's SQLite database and are never sent to the browser. Protect `DATABASE_PATH` the way you protect `.env`.
 - Tool results are passed to the model as untrusted data.
 - Endpoints must use `http` or `https` and cannot contain credentials in the URL. Local addresses are allowed, so you can run MCP servers on the same machine. Only add servers you trust.
-- OAuth-only servers are not supported yet. Use a server that accepts a bearer token, or put a token-authenticated proxy in front of it.
diff --git a/package-lock.json b/package-lock.json
index 05d28509..43f83753 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -41,6 +41,7 @@
       },
       "devDependencies": {
         "@eslint/js": "^10.0.1",
+        "@types/express": "^5.0.6",
         "@types/node": "^26.6.3",
         "@types/react": "^19.3.0",
         "@types/react-dom": "^19.3.0",
@@ -50,6 +51,7 @@
         "cross-env": "^10.1.0",
         "eslint": "^10.11.0",
         "eslint-plugin-react-hooks": "^7.1.1",
+        "express": "^5.2.1",
         "postcss": "^8.5.28",
         "prettier": "^3.9.9",
         "react-test-renderer": "^19.3.0",
diff --git a/package.json b/package.json
index 308d87c7..29cc02a0 100644
--- a/package.json
+++ b/package.json
@@ -56,6 +56,7 @@
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
+    "@types/express": "^5.0.6",
     "@types/node": "^26.6.3",
     "@types/react": "^19.3.0",
     "@types/react-dom": "^19.3.0",
@@ -65,6 +66,7 @@
     "cross-env": "^10.1.0",
     "eslint": "^10.11.0",
     "eslint-plugin-react-hooks": "^7.1.1",
+    "express": "^5.2.1",
     "postcss": "^8.5.28",
     "prettier": "^3.9.9",
     "react-test-renderer": "^19.3.0",
diff --git a/src/client/ConnectionsSection.tsx b/src/client/ConnectionsSection.tsx
index 9b4c9234..f72bf3cd 100644
--- a/src/client/ConnectionsSection.tsx
+++ b/src/client/ConnectionsSection.tsx
@@ -1,5 +1,5 @@
 import { useEffect, useState, type KeyboardEvent } from 'react';
-import { PlugZap, RefreshCw, Trash2 } from 'lucide-react';
+import { LogIn, PlugZap, RefreshCw, Trash2 } from 'lucide-react';
 import type { Connection } from '../shared/connection-types';
 import { api } from './api';
 // Lives inside the Dot form, so it saves immediately through its own
@@ -14,6 +14,29 @@ export function ConnectionsSection({ dotId }: { dotId: string }) {
   const [token, setToken] = useState('');
   const [busy, setBusy] = useState('');
   const [error, setError] = useState('');
+  const [waiting, setWaiting] = useState<string>();
+  const [signInUrl, setSignInUrl] = useState<string>();
+  // While the owner signs in in another tab, watch for the callback to land.
+  useEffect(() => {
+    if (!waiting) return;
+    const started = Date.now();
+    const timer = setInterval(() => {
+      if (Date.now() - started > 5 * 60_000) {
+        setWaiting(undefined);
+        return;
+      }
+      void api<Connection[]>(`/dots/${encodeURIComponent(dotId)}/connections`)
+        .then((list) => {
+          setConnections(list);
+          if (list.find((item) => item.id === waiting)?.signedIn) {
+            setWaiting(undefined);
+            setSignInUrl(undefined);
+          }
+        })
+        .catch(() => {});
+    }, 2000);
+    return () => clearInterval(timer);
+  }, [waiting, dotId]);
   useEffect(() => {
     let active = true;
     void api<Connection[]>(`/dots/${encodeURIComponent(dotId)}/connections`)
@@ -46,6 +69,28 @@ export function ConnectionsSection({ dotId }: { dotId: string }) {
     setConnections((list) =>
       list?.map((item) => (item.id === next.id ? next : item)),
     );
+  const signIn = async (connection: Connection) => {
+    // Open the tab during the click so popup blockers allow it.
+    const tab = window.open('about:blank', '_blank');
+    const result = await run(connection.id, () =>
+      api<{ authorizationUrl?: string; connection?: Connection }>(
+        `/connections/${connection.id}/sign-in`,
+        'POST',
+        {},
+      ),
+    );
+    if (!result || result.connection) {
+      tab?.close();
+      if (result?.connection) replace(result.connection);
+      return;
+    }
+    const url = result.authorizationUrl!;
+    if (tab) {
+      tab.opener = null;
+      tab.location.href = url;
+    } else setSignInUrl(url);
+    setWaiting(connection.id);
+  };
   const add = async () => {
     const created = await run('add', () =>
       api<Connection>(
@@ -69,8 +114,8 @@ export function ConnectionsSection({ dotId }: { dotId: string }) {
       <legend>Connections</legend>
       <p className="muted">
         Give this Dot tools from MCP servers. Read-only tools run on their own;
-        anything else asks you in chat before it runs. Tokens stay on the
-        server.
+        anything else asks you in chat before it runs. If a server needs an
+        account, leave the token empty and sign in. Tokens stay on the server.
       </p>
       {connections?.map((connection) => (
         <div className="connection" key={connection.id}>
@@ -81,8 +126,41 @@ export function ConnectionsSection({ dotId }: { dotId: string }) {
               <small>
                 {new URL(connection.url).host}
                 {connection.hasToken ? ' · token saved' : ''}
+                {connection.authMode === 'oauth'
+                  ? connection.signedIn
+                    ? ' · signed in'
+                    : waiting === connection.id
+                      ? ' · waiting for sign-in…'
+                      : ' · needs sign-in'
+                  : ''}
               </small>
             </span>
+            {connection.authMode === 'oauth' && (
+              <button
+                type="button"
+                className="connection-signin"
+                disabled={!!busy}
+                onClick={async () => {
+                  if (!connection.signedIn) return void signIn(connection);
+                  const next = await run(connection.id, () =>
+                    api<Connection>(
+                      `/connections/${connection.id}/sign-out`,
+                      'POST',
+                      {},
+                    ),
+                  );
+                  if (next) replace(next);
+                }}
+              >
+                {connection.signedIn ? (
+                  'Sign out'
+                ) : (
+                  <>
+                    <LogIn size={13} /> Sign in
+                  </>
+                )}
+              </button>
+            )}
             <button
               type="button"
               className="icon-button"
@@ -126,8 +204,20 @@ export function ConnectionsSection({ dotId }: { dotId: string }) {
               {connection.error}
             </p>
           )}
+          {waiting === connection.id && signInUrl && (
+            <p className="muted">
+              Your browser blocked the sign-in tab.{' '}
+              <a href={signInUrl} target="_blank" rel="noreferrer noopener">
+                Open sign-in
+              </a>
+            </p>
+          )}
           {!connection.tools.length && (
-            <p className="muted">This server offers no tools.</p>
+            <p className="muted">
+              {connection.authMode === 'oauth' && !connection.signedIn
+                ? 'Sign in to see and use this service’s tools.'
+                : 'This server offers no tools.'}
+            </p>
           )}
           <ul className="connection-tools">
             {connection.tools.map((tool) => {
diff --git a/src/client/style.css b/src/client/style.css
index 75be32de..4cbc9d62 100644
--- a/src/client/style.css
+++ b/src/client/style.css
@@ -4069,6 +4069,23 @@ h3 {
   font-size: 11px;
 }
 
+.connection-signin {
+  display: inline-flex;
+  align-items: center;
+  gap: 5px;
+  padding: 5px 10px;
+  border: 1px solid var(--line);
+  border-radius: 8px;
+  background: #fff;
+  font-size: 11px;
+  white-space: nowrap;
+  cursor: pointer;
+}
+.connection-signin:disabled {
+  opacity: 0.5;
+  cursor: default;
+}
+
 /* Polish: one ink accent everywhere, readable secondary text (WCAG AA), and
    disabled controls that look disabled. Later compact-chrome layers moved
    the app to ink; these older lavender surfaces now follow it. */
diff --git a/src/server/app.ts b/src/server/app.ts
index f56fbc44..dbf0cc32 100644
--- a/src/server/app.ts
+++ b/src/server/app.ts
@@ -1,5 +1,6 @@
 import { computerRoutes } from './computer-routes.js';
-import { connectionRoutes } from './connection-routes.js';
+import { connectionRoutes, oauthCallbackRoute } from './connection-routes.js';
+import { OAUTH_CALLBACK_PATH } from './connection-oauth.js';
 import { Hono } from 'hono';
 import { bodyLimit } from 'hono/body-limit';
 import { timingSafeEqual } from 'node:crypto';
@@ -94,8 +95,14 @@ export function createApp({
   if (platform)
     app.route(
       '/api',
-      connectionRoutes(platform.workspace, platform.connections),
+      connectionRoutes(
+        platform.workspace,
+        platform.connections,
+        platform.config.publicUrl,
+      ),
     );
+  if (platform)
+    app.route(OAUTH_CALLBACK_PATH, oauthCallbackRoute(platform.connections));
   const voice = platform ? new VoiceService(platform) : undefined;
   if (platform && voice) app.route('/api', workspaceRoutes(platform, voice));
   app.get('/api/state', (c) =>
diff --git a/src/server/connection-oauth.ts b/src/server/connection-oauth.ts
new file mode 100644
index 00000000..074c81b2
--- /dev/null
+++ b/src/server/connection-oauth.ts
@@ -0,0 +1,78 @@
+import { randomBytes } from 'node:crypto';
+import type { OAuthClientProvider } from '@modelcontextprotocol/sdk/client/auth.js';
+import type {
+  OAuthClientInformationMixed,
+  OAuthClientMetadata,
+  OAuthTokens,
+} from '@modelcontextprotocol/sdk/shared/auth.js';
+import type { ConnectionStore } from './connection-store.js';
+export const OAUTH_CALLBACK_PATH = '/oauth/mcp/callback';
+const STATE_TTL_MS = 10 * 60_000;
+// Persists the MCP SDK's OAuth client state (registration, PKCE verifier,
+// tokens, discovery) for one connection. The SDK runs discovery, dynamic
+// client registration, PKCE, code exchange, and refresh; OpenDots stores the
+// results and hands the authorization URL to the owner's browser.
+export class StoredOAuthProvider implements OAuthClientProvider {
+  authorizationUrl?: URL;
+  constructor(
+    private store: ConnectionStore,
+    private id: string,
+    // Only an owner-started sign-in may create a pending state; background
+    // refreshes during tool calls must not replace it.
+    private interactive = false,
+  ) {}
+  get redirectUrl() {
+    return this.store.oauth(this.id).redirectUrl ?? undefined;
+  }
+  get clientMetadata(): OAuthClientMetadata {
+    return {
+      client_name: 'OpenDots',
+      redirect_uris: this.redirectUrl ? [this.redirectUrl] : [],
+      grant_types: ['authorization_code', 'refresh_token'],
+      response_types: ['code'],
+      token_endpoint_auth_method: 'none',
+    };
+  }
+  state() {
+    const state = randomBytes(24).toString('base64url');
+    if (this.interactive)
+      this.store.setState(this.id, state, Date.now() + STATE_TTL_MS);
+    return state;
+  }
+  clientInformation() {
+    return this.store.oauth(this.id).client as
+      OAuthClientInformationMixed | undefined;
+  }
+  saveClientInformation(client: OAuthClientInformationMixed) {
+    this.store.saveOAuth(this.id, { client });
+  }
+  tokens() {
+    return this.store.oauth(this.id).tokens as OAuthTokens | undefined;
+  }
+  saveTokens(tokens: OAuthTokens) {
+    this.store.saveOAuth(this.id, { tokens });
+  }
+  redirectToAuthorization(url: URL) {
+    this.authorizationUrl = url;
+  }
+  saveCodeVerifier(verifier: string) {
+    this.store.saveOAuth(this.id, { verifier });
+  }
+  codeVerifier() {
+    const verifier = this.store.oauth(this.id).verifier;
+    if (!verifier) throw new Error('No sign-in is in progress.');
+    return verifier;
+  }
+  invalidateCredentials(
+    scope: 'all' | 'client' | 'tokens' | 'verifier' | 'discovery',
+  ) {
+    this.store.saveOAuth(this.id, {
+      ...(scope === 'all' || scope === 'client' ? { client: undefined } : {}),
+      ...(scope === 'all' || scope === 'tokens' ? { tokens: undefined } : {}),
+      ...(scope === 'all' || scope === 'verifier' ? { verifier: null } : {}),
+      ...(scope === 'all' || scope === 'discovery'
+        ? { discovery: undefined }
+        : {}),
+    });
+  }
+}
diff --git a/src/server/connection-routes.ts b/src/server/connection-routes.ts
index fd0d550d..a3911bd5 100644
--- a/src/server/connection-routes.ts
+++ b/src/server/connection-routes.ts
@@ -10,6 +10,7 @@ import { connectionInput, type ConnectionService } from './connections.js';
 export function connectionRoutes(
   workspace: WorkspaceStore,
   connections: ConnectionService,
+  publicUrl?: string,
 ) {
   const app = new Hono();
   app.onError((error, c) =>
@@ -47,6 +48,18 @@ export function connectionRoutes(
   app.post('/connections/:id/refresh', async (c) =>
     c.json(await connections.refresh(owned(c.req.param('id')).id)),
   );
+  // The callback must return to the address the owner's browser is using.
+  app.post('/connections/:id/sign-in', async (c) =>
+    c.json(
+      await connections.signIn(
+        owned(c.req.param('id')).id,
+        publicUrl ?? new URL(c.req.url).origin,
+      ),
+    ),
+  );
+  app.post('/connections/:id/sign-out', (c) =>
+    c.json(connections.signOut(owned(c.req.param('id')).id)),
+  );
   app.patch('/connections/:id/tools/:name', async (c) => {
     const patch = z
       .object({
@@ -149,3 +162,55 @@ export function connectionRoutes(
   });
   return app;
 }
+const escape = (value: string) =>
+  value.replace(
+    /[&<>"']/g,
+    (char) =>
+      ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' })[
+        char
+      ]!,
+  );
+const page = (title: string, body: string) =>
+  `<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1"><title>${escape(title)}</title><style>body{font-family:-apple-system,system-ui,sans-serif;max-width:420px;margin:15vh auto;padding:0 16px;color:#242424;background:#fff}h1{font-size:20px}p{color:#6b6b6b;line-height:1.6}a{color:#242424}@media (prefers-color-scheme:dark){body{color:#eee;background:#1b1b1b}p{color:#a6a6a6}a{color:#eee}}</style></head><body><h1>${escape(title)}</h1><p>${escape(body)}</p><p><a href="/">Back to OpenDots</a></p></body></html>`;
+// Where the service sends the owner's browser after sign-in. It sits outside
+// /api because a redirect cannot carry the owner token; the single-use,
+// expiring state ties it to a sign-in the owner started.
+export function oauthCallbackRoute(connections: ConnectionService) {
+  const app = new Hono();
+  app.get('/', async (c) => {
+    c.header('Cache-Control', 'no-store');
+    const { code, state, error } = c.req.query();
+    if (error || !code || !state)
+      return c.html(
+        page(
+          'Sign-in was not completed',
+          error === 'access_denied'
+            ? 'Access was denied. You can try again from the Dot settings.'
+            : 'The service did not return a sign-in code. Try again from the Dot settings.',
+        ),
+        400,
+      );
+    try {
+      const connection = await connections.completeSignIn(state, code);
+      return c.html(
+        connection.error
+          ? page(`Signed in to ${connection.name}`, connection.error)
+          : page(
+              `Signed in to ${connection.name}`,
+              'You can close this tab and return to OpenDots. Your Dot can use its tools now.',
+            ),
+      );
+    } catch (cause) {
+      return c.html(
+        page(
+          'Sign-in failed',
+          cause instanceof Error
+            ? cause.message
+            : 'Try again from the Dot settings.',
+        ),
+        400,
+      );
+    }
+  });
+  return app;
+}
diff --git a/src/server/connection-store.ts b/src/server/connection-store.ts
index bc53c1b7..580f3332 100644
--- a/src/server/connection-store.ts
+++ b/src/server/connection-store.ts
@@ -5,15 +5,34 @@ import type {
   ConnectionActionResult,
   ConnectionTool,
 } from '../shared/connection-types.js';
-type Row = Omit<Connection, 'hasToken' | 'tools'> & {
+type Row = Omit<Connection, 'hasToken' | 'signedIn' | 'tools'> & {
   token: string | null;
   tools: string;
 };
+// OAuth client state for one connection, kept server-side only.
+export interface OAuthState {
+  redirectUrl: string | null;
+  client: unknown;
+  tokens: unknown;
+  verifier: string | null;
+  discovery: unknown;
+}
+const oauthJson = ['client', 'tokens', 'discovery'] as const;
 export class ConnectionStore {
   constructor(private db: DatabaseSync) {
     db.exec(`CREATE TABLE IF NOT EXISTS mcp_connections(id TEXT PRIMARY KEY, dotId TEXT NOT NULL, name TEXT NOT NULL, url TEXT NOT NULL, token TEXT, tools TEXT NOT NULL, error TEXT, createdAt INTEGER NOT NULL, updatedAt INTEGER NOT NULL);
+      CREATE TABLE IF NOT EXISTS mcp_oauth(connectionId TEXT PRIMARY KEY, redirectUrl TEXT, client TEXT, tokens TEXT, verifier TEXT, discovery TEXT, state TEXT, stateExpires INTEGER);
       CREATE TABLE IF NOT EXISTS mcp_approvals(id TEXT PRIMARY KEY, threadId TEXT NOT NULL, dotId TEXT NOT NULL, connectionId TEXT NOT NULL, tool TEXT NOT NULL, arguments TEXT NOT NULL, createdAt INTEGER NOT NULL);
       CREATE TABLE IF NOT EXISTS mcp_actions(threadId TEXT NOT NULL, toolCallId TEXT NOT NULL, connectionId TEXT NOT NULL, tool TEXT NOT NULL, status TEXT NOT NULL, result TEXT, createdAt INTEGER NOT NULL, PRIMARY KEY(threadId, toolCallId));`);
+    if (
+      !db
+        .prepare('PRAGMA table_info(mcp_connections)')
+        .all()
+        .some((column) => column.name === 'authMode')
+    )
+      db.exec(
+        "ALTER TABLE mcp_connections ADD COLUMN authMode TEXT NOT NULL DEFAULT 'token'",
+      );
     // A receipt belongs to the approval that produced it.
     if (
       !db
@@ -31,7 +50,12 @@ export class ConnectionStore {
       .all(...(dotId ? [dotId] : [])) as unknown as Row[];
   }
   private view({ token, tools, ...row }: Row): Connection {
-    return { ...row, hasToken: !!token, tools: JSON.parse(tools) };
+    return {
+      ...row,
+      hasToken: !!token,
+      signedIn: row.authMode === 'oauth' && !!this.oauth(row.id).tokens,
+      tools: JSON.parse(tools),
+    };
   }
   list(dotId: string): Connection[] {
     return this.rows(dotId).map((row) => this.view(row));
@@ -50,12 +74,13 @@ export class ConnectionStore {
     dotId: string,
     value: { name: string; url: string; token?: string },
     tools: ConnectionTool[],
+    authMode: Connection['authMode'] = 'token',
   ): Connection {
     const id = randomUUID();
     const now = Date.now();
     this.db
       .prepare(
-        'INSERT INTO mcp_connections VALUES (?, ?, ?, ?, ?, ?, NULL, ?, ?)',
+        'INSERT INTO mcp_connections (id, dotId, name, url, token, tools, error, createdAt, updatedAt, authMode) VALUES (?, ?, ?, ?, ?, ?, NULL, ?, ?, ?)',
       )
       .run(
         id,
@@ -66,6 +91,7 @@ export class ConnectionStore {
         JSON.stringify(tools),
         now,
         now,
+        authMode,
       );
     return this.get(id)!;
   }
@@ -84,11 +110,77 @@ export class ConnectionStore {
     return this.get(id)!;
   }
   remove(id: string) {
+    this.db.prepare('DELETE FROM mcp_oauth WHERE connectionId=?').run(id);
     return (
       this.db.prepare('DELETE FROM mcp_connections WHERE id=?').run(id)
         .changes > 0
     );
   }
+  oauth(id: string): OAuthState {
+    const row = this.db
+      .prepare('SELECT * FROM mcp_oauth WHERE connectionId=?')
+      .get(id);
+    const parse = (value: unknown) =>
+      typeof value === 'string' ? JSON.parse(value) : undefined;
+    return {
+      redirectUrl:
+        typeof row?.redirectUrl === 'string' ? row.redirectUrl : null,
+      client: parse(row?.client),
+      tokens: parse(row?.tokens),
+      verifier: typeof row?.verifier === 'string' ? row.verifier : null,
+      discovery: parse(row?.discovery),
+    };
+  }
+  saveOAuth(id: string, patch: Partial<OAuthState>) {
+    const next = { ...this.oauth(id), ...patch };
+    const json = Object.fromEntries(
+      oauthJson.map((key) => [
+        key,
+        next[key] === undefined ? null : JSON.stringify(next[key]),
+      ]),
+    );
+    this.db
+      .prepare(
+        `INSERT INTO mcp_oauth (connectionId, redirectUrl, client, tokens, verifier, discovery) VALUES (?, ?, ?, ?, ?, ?)
+         ON CONFLICT(connectionId) DO UPDATE SET redirectUrl=excluded.redirectUrl, client=excluded.client, tokens=excluded.tokens, verifier=excluded.verifier, discovery=excluded.discovery`,
+      )
+      .run(
+        id,
+        next.redirectUrl,
+        json.client,
+        json.tokens,
+        next.verifier,
+        json.discovery,
+      );
+    // Signing in or out changes what the Dot can do: stop active turns.
+    if ('tokens' in patch)
+      this.db
+        .prepare('UPDATE mcp_connections SET updatedAt=? WHERE id=?')
+        .run(this.tick(id), id);
+  }
+  // One pending sign-in per connection; the state is single-use.
+  setState(id: string, state: string, expires: number) {
+    this.saveOAuth(id, {});
+    this.db
+      .prepare(
+        'UPDATE mcp_oauth SET state=?, stateExpires=? WHERE connectionId=?',
+      )
+      .run(state, expires, id);
+  }
+  takeState(state: string) {
+    const row = this.db
+      .prepare('SELECT connectionId, stateExpires FROM mcp_oauth WHERE state=?')
+      .get(state);
+    if (!row) return undefined;
+    this.db
+      .prepare(
+        'UPDATE mcp_oauth SET state=NULL, stateExpires=NULL WHERE connectionId=?',
+      )
+      .run(row.connectionId);
+    return Number(row.stateExpires) > Date.now()
+      ? String(row.connectionId)
+      : undefined;
+  }
   // Running turns compare this to stop as soon as the owner changes access.
   fingerprint(dotId: string) {
     return this.rows(dotId)
diff --git a/src/server/connections.ts b/src/server/connections.ts
index 182b0368..7ac81633 100644
--- a/src/server/connections.ts
+++ b/src/server/connections.ts
@@ -1,6 +1,14 @@
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
 import type { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
+import {
+  auth,
+  type OAuthClientProvider,
+} from '@modelcontextprotocol/sdk/client/auth.js';
+import {
+  OAUTH_CALLBACK_PATH,
+  StoredOAuthProvider,
+} from './connection-oauth.js';
 import { z } from 'zod';
 import type {
   Connection,
@@ -34,10 +42,17 @@ export type ConnectionInput = z.infer<typeof connectionInput>;
 export type McpTransportFactory = (target: {
   url: string;
   token?: string;
+  authProvider?: OAuthClientProvider;
   signal: AbortSignal;
 }) => Transport;
-export const httpTransport: McpTransportFactory = ({ url, token, signal }) =>
+export const httpTransport: McpTransportFactory = ({
+  url,
+  token,
+  authProvider,
+  signal,
+}) =>
   new StreamableHTTPClientTransport(new URL(url), {
+    authProvider,
     requestInit: token
       ? { headers: { Authorization: `Bearer ${token}` } }
       : undefined,
@@ -81,17 +96,25 @@ export interface ExposedTool {
 // bind to a stored connection, tool, and arguments.
 export function exposedTools(connections: Connection[]): ExposedTool[] {
   const used = new Set<string>();
-  return connections
-    .flatMap((connection) =>
-      connection.tools.map((tool) => {
-        const base = `${slug(connection.name, 20)}__${slug(tool.name, 40)}`;
-        let name = base;
-        for (let n = 2; used.has(name); n++) name = `${base.slice(0, 60)}_${n}`;
-        used.add(name);
-        return { name, connection, tool };
-      }),
-    )
-    .filter(({ tool }) => tool.enabled);
+  return (
+    connections
+      .flatMap((connection) =>
+        connection.tools.map((tool) => {
+          const base = `${slug(connection.name, 20)}__${slug(tool.name, 40)}`;
+          let name = base;
+          for (let n = 2; used.has(name); n++)
+            name = `${base.slice(0, 60)}_${n}`;
+          used.add(name);
+          return { name, connection, tool };
+        }),
+      )
+      // A signed-out connection offers nothing until the owner signs in again.
+      .filter(
+        ({ connection, tool }) =>
+          tool.enabled &&
+          (connection.authMode !== 'oauth' || connection.signedIn),
+      )
+  );
 }
 export function normalizeResult(result: unknown): ConnectionActionResult {
   const envelope = z
@@ -127,20 +150,26 @@ export function normalizeResult(result: unknown): ConnectionActionResult {
         : text,
   };
 }
-const failure = (error: unknown) => {
-  if (!(error instanceof Error))
-    return 'Could not reach the connected service.';
-  if (error.name === 'AbortError' || error.name === 'TimeoutError')
-    return 'The connected service did not respond in time.';
+// OAuth-protected servers surface UnauthorizedError or HTTP 401/403.
+const unauthorized = (error: unknown) => {
+  if (!(error instanceof Error)) return false;
   const status = (error as { code?: unknown }).code;
-  // OAuth-only servers surface UnauthorizedError when no token is supplied.
-  if (
+  return (
     status === 401 ||
     status === 403 ||
     error.name === 'UnauthorizedError' ||
     error.constructor.name === 'UnauthorizedError'
-  )
-    return 'The connected service rejected the credentials. Check the bearer token.';
+  );
+};
+const failure = (error: unknown, authMode: 'token' | 'oauth' = 'token') => {
+  if (!(error instanceof Error))
+    return 'Could not reach the connected service.';
+  if (error.name === 'AbortError' || error.name === 'TimeoutError')
+    return 'The connected service did not respond in time.';
+  if (unauthorized(error))
+    return authMode === 'oauth'
+      ? 'Sign in to this service again.'
+      : 'The connected service rejected the credentials. Check the bearer token.';
   return `Could not reach the connected service${error.message ? `: ${error.message.slice(0, 200)}` : '.'}`;
 };
 export class ConnectionService {
@@ -149,8 +178,18 @@ export class ConnectionService {
     private transport: McpTransportFactory = httpTransport,
     private timeoutMs = 60_000,
   ) {}
+  private target(id: string) {
+    const connection = this.store.get(id);
+    if (!connection) throw new Error('Connection not found.');
+    return {
+      ...this.store.credentials(id),
+      ...(connection.authMode === 'oauth'
+        ? { authProvider: new StoredOAuthProvider(this.store, id) }
+        : {}),
+    };
+  }
   private async session<T>(
-    target: { url: string; token?: string },
+    target: { url: string; token?: string; authProvider?: OAuthClientProvider },
     signal: AbortSignal | undefined,
     use: (client: Client, signal: AbortSignal) => Promise<T>,
   ) {
@@ -169,7 +208,7 @@ export class ConnectionService {
     }
   }
   private async discover(
-    target: { url: string; token?: string },
+    target: { url: string; token?: string; authProvider?: OAuthClientProvider },
     previous: ConnectionTool[] = [],
   ) {
     return this.session(target, undefined, async (client, signal) => {
@@ -209,15 +248,68 @@ export class ConnectionService {
     try {
       tools = await this.discover({ url: value.url, token: value.token });
     } catch (error) {
+      // No token and the server wants one: save it for the owner to sign in.
+      if (!value.token && unauthorized(error))
+        return this.store.create(dotId, value, [], 'oauth');
       throw new Error(failure(error), { cause: error });
     }
     return this.store.create(dotId, value, tools);
   }
+  // Starts an owner sign-in. Returns the provider's authorization URL for
+  // the owner's browser, or the refreshed connection if already authorized.
+  async signIn(id: string, appOrigin: string) {
+    const connection = this.store.get(id);
+    if (connection?.authMode !== 'oauth')
+      throw new Error('This connection does not use sign-in.');
+    this.store.saveOAuth(id, {
+      redirectUrl: `${appOrigin.replace(/\/+$/, '')}${OAUTH_CALLBACK_PATH}`,
+    });
+    const provider = new StoredOAuthProvider(this.store, id, true);
+    let result: Awaited<ReturnType<typeof auth>>;
+    try {
+      result = await auth(provider, { serverUrl: connection.url });
+    } catch (error) {
+      throw new Error(
+        `Could not start sign-in: ${error instanceof Error ? error.message.slice(0, 200) : 'the service did not respond.'}`,
+        { cause: error },
+      );
+    }
+    if (result === 'AUTHORIZED') return { connection: await this.refresh(id) };
+    const url = provider.authorizationUrl;
+    // The URL comes from the remote server's metadata; only open web pages.
+    if (!url || !['https:', 'http:'].includes(url.protocol))
+      throw new Error('The service returned an invalid sign-in address.');
+    return { authorizationUrl: url.toString() };
+  }
+  async completeSignIn(state: string, code: string) {
+    const id = this.store.takeState(state);
+    if (!id) throw new Error('This sign-in link expired. Start sign-in again.');
+    const connection = this.store.get(id)!;
+    try {
+      await auth(new StoredOAuthProvider(this.store, id), {
+        serverUrl: connection.url,
+        authorizationCode: code,
+      });
+    } catch (error) {
+      throw new Error(
+        `The service did not accept the sign-in: ${error instanceof Error ? error.message.slice(0, 200) : 'unknown error.'}`,
+        { cause: error },
+      );
+    }
+    return this.refresh(id);
+  }
+  signOut(id: string) {
+    const connection = this.store.get(id);
+    if (connection?.authMode !== 'oauth')
+      throw new Error('This connection does not use sign-in.');
+    this.store.saveOAuth(id, { tokens: undefined, verifier: null });
+    return this.store.get(id)!;
+  }
   async refresh(id: string) {
     const connection = this.store.get(id);
     if (!connection) throw new Error('Connection not found.');
     try {
-      const discovered = await this.discover(this.store.credentials(id));
+      const discovered = await this.discover(this.target(id));
       // Owner changes made while discovery ran win: merge against the
       // settings as they are now, not as they were when it started.
       const current = this.store.get(id);
@@ -236,7 +328,7 @@ export class ConnectionService {
         }),
       );
     } catch (error) {
-      return this.store.setError(id, failure(error));
+      return this.store.setError(id, failure(error, connection.authMode));
     }
   }
   setTool(
@@ -285,7 +377,7 @@ export class ConnectionService {
   ): Promise<ConnectionActionResult> {
     try {
       return await this.session(
-        this.store.credentials(exposed.connection.id),
+        this.target(exposed.connection.id),
         signal,
         async (client, bounded) =>
           normalizeResult(
@@ -297,7 +389,10 @@ export class ConnectionService {
           ),
       );
     } catch (error) {
-      return { isError: true, text: failure(error) };
+      return {
+        isError: true,
+        text: failure(error, exposed.connection.authMode),
+      };
     }
   }
 }
diff --git a/src/server/index.ts b/src/server/index.ts
index 0955d3f6..d7185435 100644
--- a/src/server/index.ts
+++ b/src/server/index.ts
@@ -13,6 +13,7 @@ import {
   intelligenceApiKeyFromEnv,
   intelligenceWsUrlFromEnv,
   type PlatformConfig,
+  publicUrlFromEnv,
 } from './platform-config.js';
 const host = process.env.HOST ?? '127.0.0.1';
 const port = Number(process.env.PORT ?? 4310);
@@ -57,6 +58,7 @@ const config: PlatformConfig = {
   slackDotId: process.env.SLACK_DOT_ID || undefined,
   runtimeUrl: `http://${host === '::1' ? '[::1]' : '127.0.0.1'}:${port}/api/copilotkit`,
   ownerToken,
+  publicUrl: publicUrlFromEnv(process.env.PUBLIC_URL),
 };
 const platform = new Platform(store, workspace, config);
 const researchConfig = {
diff --git a/src/server/platform-config.ts b/src/server/platform-config.ts
index 95ad9232..591fefbe 100644
--- a/src/server/platform-config.ts
+++ b/src/server/platform-config.ts
@@ -34,6 +34,22 @@ function firstNonEmptyEnvValue(
   return undefined;
 }
 
+// PUBLIC_URL must be an http(s) origin-like address without credentials;
+// a trailing slash is dropped so paths can be appended.
+export function publicUrlFromEnv(value: string | undefined) {
+  const trimmed = value?.trim();
+  if (!trimmed) return undefined;
+  const url = new URL(trimmed);
+  if (
+    !['http:', 'https:'].includes(url.protocol) ||
+    url.username ||
+    url.password
+  )
+    throw new Error(
+      'PUBLIC_URL must be an http(s) address without embedded credentials.',
+    );
+  return trimmed.replace(/\/+$/, '');
+}
 export interface PlatformConfig extends WebConfig {
   intelligenceKey?: string;
   intelligenceApiUrl?: string;
@@ -56,6 +72,8 @@ export interface PlatformConfig extends WebConfig {
   slackDotId?: string;
   runtimeUrl: string;
   ownerToken?: string;
+  // The address browsers and services use to reach this server.
+  publicUrl?: string;
 }
 export function setupStatus(
   config: PlatformConfig,
diff --git a/src/shared/connection-types.ts b/src/shared/connection-types.ts
index 2a01ecc5..1bb4b8ec 100644
--- a/src/shared/connection-types.ts
+++ b/src/shared/connection-types.ts
@@ -15,6 +15,9 @@ export interface Connection {
   name: string;
   url: string;
   hasToken: boolean;
+  // token: optional bearer token; oauth: the owner signs in to the service.
+  authMode: 'token' | 'oauth';
+  signedIn: boolean;
   tools: ConnectionTool[];
   error: string | null;
   createdAt: number;
diff --git a/tests/connection-oauth.test.ts b/tests/connection-oauth.test.ts
new file mode 100644
index 00000000..b252b0d2
--- /dev/null
+++ b/tests/connection-oauth.test.ts
@@ -0,0 +1,187 @@
+import { afterEach, expect, it } from 'vitest';
+import { Hono } from 'hono';
+import { WorkspaceStore } from '../src/server/workspace.js';
+import { ConnectionService } from '../src/server/connections.js';
+import {
+  connectionRoutes,
+  oauthCallbackRoute,
+} from '../src/server/connection-routes.js';
+import { OAUTH_CALLBACK_PATH } from '../src/server/connection-oauth.js';
+import type { Connection } from '../src/shared/connection-types.js';
+import { oauthMcpServer } from './fixtures/oauth-mcp-server.js';
+const cleanup: (() => unknown)[] = [];
+afterEach(async () => {
+  for (const done of cleanup.splice(0)) await done();
+});
+const origin = 'http://127.0.0.1:5173';
+async function fixture() {
+  const server = await oauthMcpServer();
+  const workspace = new WorkspaceStore(':memory:', 'owner');
+  cleanup.push(server.close, () => workspace.close());
+  const connections = new ConnectionService(workspace.connections);
+  const app = new Hono();
+  app.route('/api', connectionRoutes(workspace, connections));
+  app.route(OAUTH_CALLBACK_PATH, oauthCallbackRoute(connections));
+  const api = async <T>(path: string, method = 'GET', body?: unknown) => {
+    const response = await app.request(`${origin}/api${path}`, {
+      method,
+      headers: { 'Content-Type': 'application/json' },
+      ...(body === undefined ? {} : { body: JSON.stringify(body) }),
+    });
+    return { status: response.status, data: (await response.json()) as T };
+  };
+  const dotId = workspace.dots()[0].id;
+  // Follows the provider's consent redirect the way the owner's browser would.
+  const consent = async (authorizationUrl: string) => {
+    const response = await fetch(authorizationUrl, { redirect: 'manual' });
+    expect(response.status).toBe(302);
+    const callback = new URL(response.headers.get('location')!);
+    expect(callback.origin + callback.pathname).toBe(
+      `${origin}${OAUTH_CALLBACK_PATH}`,
+    );
+    return callback.pathname + callback.search;
+  };
+  return { server, workspace, connections, app, api, dotId, consent };
+}
+it('signs in to an OAuth-protected MCP server and uses its tools', async () => {
+  const f = await fixture();
+  const added = await f.api<Connection>(
+    `/dots/${f.dotId}/connections`,
+    'POST',
+    { name: 'Calendar', url: f.server.url },
+  );
+  expect(added.status).toBe(201);
+  expect(added.data).toMatchObject({
+    authMode: 'oauth',
+    signedIn: false,
+    tools: [],
+  });
+  expect(f.connections.tools(f.dotId)).toEqual([]);
+  const start = await f.api<{ authorizationUrl: string }>(
+    `/connections/${added.data.id}/sign-in`,
+    'POST',
+    {},
+  );
+  const authorization = new URL(start.data.authorizationUrl);
+  expect(authorization.searchParams.get('code_challenge_method')).toBe('S256');
+  expect(authorization.searchParams.get('redirect_uri')).toBe(
+    `${origin}${OAUTH_CALLBACK_PATH}`,
+  );
+  const callback = await f.consent(start.data.authorizationUrl);
+  const done = await f.app.request(callback);
+  expect(done.status).toBe(200);
+  expect(await done.text()).toContain('Signed in to Calendar');
+  const [connection] = (
+    await f.api<Connection[]>(`/dots/${f.dotId}/connections`)
+  ).data;
+  expect(connection).toMatchObject({ signedIn: true, error: null });
+  expect(connection.tools.map((tool) => tool.name)).toEqual(['list_events']);
+  // Tokens and client registration stay server-side.
+  const tokens = f.workspace.connections.oauth(connection.id).tokens as {
+    access_token: string;
+    refresh_token: string;
+  };
+  expect(JSON.stringify(connection)).not.toContain(tokens.access_token);
+  expect(JSON.stringify(connection)).not.toContain(tokens.refresh_token);
+  const [exposed] = f.connections.tools(f.dotId);
+  expect(exposed.name).toBe('calendar__list_events');
+  expect(await f.connections.call(exposed, { day: 'Monday' })).toEqual({
+    isError: false,
+    text: 'Standup on Monday',
+  });
+  // An expired access token is refreshed without the owner.
+  f.server.provider.expireAccessTokens();
+  expect(await f.connections.call(exposed, { day: 'Tuesday' })).toEqual({
+    isError: false,
+    text: 'Standup on Tuesday',
+  });
+  expect(f.server.provider.refreshes).toBe(1);
+  expect(f.server.calls).toEqual(['Monday', 'Tuesday']);
+});
+it('rejects replayed, forged, and denied callbacks', async () => {
+  const f = await fixture();
+  const added = await f.api<Connection>(
+    `/dots/${f.dotId}/connections`,
+    'POST',
+    { name: 'Calendar', url: f.server.url },
+  );
+  const start = await f.api<{ authorizationUrl: string }>(
+    `/connections/${added.data.id}/sign-in`,
+    'POST',
+    {},
+  );
+  const callback = await f.consent(start.data.authorizationUrl);
+  expect((await f.app.request(callback)).status).toBe(200);
+  const replay = await f.app.request(callback);
+  expect(replay.status).toBe(400);
+  expect(await replay.text()).toContain('expired');
+  const forged = await f.app.request(
+    `${OAUTH_CALLBACK_PATH}?code=x&state=not-a-state`,
+  );
+  expect(forged.status).toBe(400);
+  const denied = await f.app.request(
+    `${OAUTH_CALLBACK_PATH}?error=access_denied&state=x`,
+  );
+  expect(denied.status).toBe(400);
+  expect(await denied.text()).toContain('Access was denied');
+  const injected = await f.app.request(
+    `${OAUTH_CALLBACK_PATH}?code=x&state=${encodeURIComponent('<script>')}`,
+  );
+  expect(await injected.text()).not.toContain('<script>');
+});
+it('signs out, hides the tools, and asks to sign in again', async () => {
+  const f = await fixture();
+  const added = await f.api<Connection>(
+    `/dots/${f.dotId}/connections`,
+    'POST',
+    { name: 'Calendar', url: f.server.url },
+  );
+  const start = await f.api<{ authorizationUrl: string }>(
+    `/connections/${added.data.id}/sign-in`,
+    'POST',
+    {},
+  );
+  await f.app.request(await f.consent(start.data.authorizationUrl));
+  const [exposed] = f.connections.tools(f.dotId);
+  const before = f.workspace.connections.fingerprint(f.dotId);
+  const out = await f.api<Connection>(
+    `/connections/${added.data.id}/sign-out`,
+    'POST',
+    {},
+  );
+  expect(out.data.signedIn).toBe(false);
+  // Signing out stops the Dot's active turn, like other access changes.
+  expect(f.workspace.connections.fingerprint(f.dotId)).not.toBe(before);
+  expect(f.connections.tools(f.dotId)).toEqual([]);
+  expect(await f.connections.call(exposed, { day: 'Monday' })).toEqual({
+    isError: true,
+    text: 'Sign in to this service again.',
+  });
+  // Sign-in is refused for token connections.
+  const tokenConnection = f.workspace.connections.create(
+    f.dotId,
+    { name: 'Plain', url: 'https://plain.example/mcp' },
+    [],
+  );
+  const refused = await f.api<{ error: string }>(
+    `/connections/${tokenConnection.id}/sign-in`,
+    'POST',
+    {},
+  );
+  expect(refused.data.error).toContain('does not use sign-in');
+});
+it('validates PUBLIC_URL for sign-in callbacks', async () => {
+  const { publicUrlFromEnv } = await import('../src/server/platform-config.js');
+  expect(publicUrlFromEnv(undefined)).toBeUndefined();
+  expect(publicUrlFromEnv('  ')).toBeUndefined();
+  expect(publicUrlFromEnv('https://dots.example.com/')).toBe(
+    'https://dots.example.com',
+  );
+  expect(() => publicUrlFromEnv('ftp://dots.example.com')).toThrow(
+    'PUBLIC_URL',
+  );
+  expect(() => publicUrlFromEnv('https://user:pw@dots.example.com')).toThrow(
+    'PUBLIC_URL',
+  );
+  expect(() => publicUrlFromEnv('not a url')).toThrow();
+});
diff --git a/tests/fixtures/oauth-mcp-server.ts b/tests/fixtures/oauth-mcp-server.ts
new file mode 100644
index 00000000..e600d75a
--- /dev/null
+++ b/tests/fixtures/oauth-mcp-server.ts
@@ -0,0 +1,120 @@
+import { randomUUID } from 'node:crypto';
+import type { AddressInfo } from 'node:net';
+import express from 'express';
+import { z } from 'zod';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import {
+  getOAuthProtectedResourceMetadataUrl,
+  mcpAuthRouter,
+} from '@modelcontextprotocol/sdk/server/auth/router.js';
+import { requireBearerAuth } from '@modelcontextprotocol/sdk/server/auth/middleware/bearerAuth.js';
+import { DemoInMemoryAuthProvider } from '@modelcontextprotocol/sdk/examples/server/demoInMemoryOAuthProvider.js';
+import type { OAuthClientInformationFull } from '@modelcontextprotocol/sdk/shared/auth.js';
+import { InvalidTokenError } from '@modelcontextprotocol/sdk/server/auth/errors.js';
+// A real OAuth-protected MCP server: discovery, dynamic client registration,
+// PKCE, an auto-approving consent step, refresh tokens, and bearer checks.
+class RefreshingProvider extends DemoInMemoryAuthProvider {
+  refreshes = 0;
+  private refreshTokens = new Map<string, string>();
+  private issue(clientId: string) {
+    const token = randomUUID();
+    (this as unknown as { tokens: Map<string, unknown> }).tokens.set(token, {
+      token,
+      clientId,
+      scopes: [],
+      expiresAt: Date.now() + 3_600_000,
+      type: 'access',
+    });
+    const refresh = randomUUID();
+    this.refreshTokens.set(refresh, clientId);
+    return {
+      access_token: token,
+      token_type: 'bearer',
+      expires_in: 3600,
+      refresh_token: refresh,
+    };
+  }
+  async exchangeAuthorizationCode(
+    client: OAuthClientInformationFull,
+    code: string,
+  ) {
+    await super.exchangeAuthorizationCode(client, code);
+    return this.issue(client.client_id);
+  }
+  async exchangeRefreshToken(
+    client: OAuthClientInformationFull,
+    refreshToken: string,
+  ) {
+    if (this.refreshTokens.get(refreshToken) !== client.client_id)
+      throw new Error('Invalid refresh token');
+    this.refreshTokens.delete(refreshToken);
+    this.refreshes++;
+    return this.issue(client.client_id);
+  }
+  // Expired tokens are a 401 invalid_token (the demo throws a plain Error,
+  // which the middleware reports as a 500).
+  async verifyAccessToken(token: string) {
+    try {
+      return await super.verifyAccessToken(token);
+    } catch {
+      throw new InvalidTokenError('Invalid or expired token');
+    }
+  }
+  expireAccessTokens() {
+    (this as unknown as { tokens: Map<string, unknown> }).tokens.clear();
+  }
+}
+export async function oauthMcpServer(port = 0) {
+  const app = express();
+  const http = await new Promise<import('node:http').Server>((resolve) => {
+    const server = app.listen(port, 'localhost', () => resolve(server));
+  });
+  const base = new URL(
+    `http://localhost:${(http.address() as AddressInfo).port}`,
+  );
+  const mcpUrl = new URL('/mcp', base);
+  const provider = new RefreshingProvider();
+  const calls: string[] = [];
+  app.use(
+    mcpAuthRouter({ provider, issuerUrl: base, resourceServerUrl: mcpUrl }),
+  );
+  app.post(
+    '/mcp',
+    express.json(),
+    requireBearerAuth({
+      verifier: provider,
+      resourceMetadataUrl: getOAuthProtectedResourceMetadataUrl(mcpUrl),
+    }),
+    async (req, res) => {
+      const server = new McpServer({ name: 'calendar', version: '1.0.0' });
+      server.registerTool(
+        'list_events',
+        {
+          description: 'List upcoming events.',
+          inputSchema: { day: z.string() },
+          annotations: { readOnlyHint: true },
+        },
+        async ({ day }) => {
+          calls.push(day);
+          return { content: [{ type: 'text', text: `Standup on ${day}` }] };
+        },
+      );
+      const transport = new StreamableHTTPServerTransport({
+        sessionIdGenerator: undefined,
+      });
+      res.on('close', () => {
+        void transport.close();
+        void server.close();
+      });
+      await server.connect(transport);
+      await transport.handleRequest(req, res, req.body);
+    },
+  );
+  return {
+    url: mcpUrl.toString(),
+    provider,
+    calls,
+    close: () => new Promise<void>((resolve) => http.close(() => resolve())),
+  };
+}
diff --git a/vite.config.ts b/vite.config.ts
index 41a739d9..0c15d575 100644
--- a/vite.config.ts
+++ b/vite.config.ts
@@ -8,6 +8,9 @@ export default defineConfig({
   server: {
     strictPort: true,
     host: '127.0.0.1',
-    proxy: { '/api': 'http://127.0.0.1:4310' },
+    proxy: {
+      '/api': 'http://127.0.0.1:4310',
+      '/oauth': 'http://127.0.0.1:4310',
+    },
   },
 });