Add model selection and inputHeaderSlot for BiChat fast mode

* Add per-turn model selection and inputHeaderSlot for BiChat fast mode

- Add model field to SendMessageOptions and wire through MessageTransport
- Add model/setModel to ChatMachine state, selectors, and session snapshot
- Add inputHeaderSlot prop to ChatSession for custom content above input
- Add models array to Extensions.llm type for backend-provided model list
- Show model badge on assistant messages in debug mode

* Move ModelSelector component into SDK bichat package

Reusable segmented toggle for per-turn model selection with
Cmd+Shift+M keyboard shortcut. Uses Phosphor icons (Lightning, Brain).

* Fix lint: add semicolons, curly braces, and useMemo for models

* Harden BiChat session recovery

Author: diyor28

internal/controller/controller.go

@@ -83,9 +83,10 @@ func (c *Controller) RegisterRoutes(router *mux.Router) {
 	if c.devAssets != nil || config.Assets.FS != nil {
 		c.registerAssetRoutes(router, fullAssetsPath)
 	}
+	excludedPrefixes := appRouteExcludedPrefixes(c.applet.BasePath(), config)
 	pathRouter := router.PathPrefix(c.applet.BasePath()).Subrouter()
 	c.applyMiddleware(pathRouter, config.Middleware)
-	c.registerAppRoutes(pathRouter, config.RoutePatterns)
+	c.registerAppRoutes(pathRouter, config.RoutePatterns, excludedPrefixes)
 
 	for _, host := range config.Hosts {
 		host = strings.TrimSpace(host)
@@ -97,7 +98,7 @@ func (c *Controller) RegisterRoutes(router *mux.Router) {
 			c.registerAssetRoutes(hostRouter, config.Assets.BasePath)
 		}
 		c.applyMiddleware(hostRouter, config.Middleware)
-		c.registerAppRoutes(hostRouter, config.RoutePatterns)
+		c.registerAppRoutes(hostRouter, config.RoutePatterns, excludedPrefixes)
 	}
 }
 
@@ -107,7 +108,7 @@ func (c *Controller) applyMiddleware(router *mux.Router, middleware []mux.Middle
 	}
 }
 
-func (c *Controller) registerAppRoutes(router *mux.Router, routePatterns []string) {
+func (c *Controller) registerAppRoutes(router *mux.Router, routePatterns []string, excludedPrefixes []string) {
 	for _, p := range routePatterns {
 		p = strings.TrimSpace(p)
 		if p == "" {
@@ -120,5 +121,94 @@ func (c *Controller) registerAppRoutes(router *mux.Router, routePatterns []strin
 	}
 	router.HandleFunc("", c.RenderApp).Methods(http.MethodGet, http.MethodHead)
 	router.HandleFunc("/", c.RenderApp).Methods(http.MethodGet, http.MethodHead)
-	router.PathPrefix("/").HandlerFunc(c.RenderApp).Methods(http.MethodGet, http.MethodHead)
+	router.MatcherFunc(func(r *http.Request, _ *mux.RouteMatch) bool {
+		return shouldRenderAppRoute(r.URL.Path, excludedPrefixes)
+	}).HandlerFunc(c.RenderApp).Methods(http.MethodGet, http.MethodHead)
+}
+
+func appRouteExcludedPrefixes(basePath string, config api.Config) []string {
+	candidates := []string{
+		config.Assets.BasePath,
+		config.Endpoints.GraphQL,
+		config.Endpoints.Stream,
+		config.Endpoints.REST,
+	}
+	if config.RPC != nil {
+		candidates = append(candidates, config.RPC.Path)
+	}
+
+	seen := make(map[string]struct{}, len(candidates)*2)
+	excluded := make([]string, 0, len(candidates)*2)
+	for _, candidate := range candidates {
+		for _, prefix := range normalizeExcludedRoutePrefixes(basePath, candidate) {
+			if prefix == "" {
+				continue
+			}
+			if _, exists := seen[prefix]; exists {
+				continue
+			}
+			seen[prefix] = struct{}{}
+			excluded = append(excluded, prefix)
+		}
+	}
+
+	return excluded
+}
+
+func normalizeExcludedRoutePrefixes(basePath, raw string) []string {
+	raw = strings.TrimSpace(raw)
+	if raw == "" {
+		return nil
+	}
+	if !strings.HasPrefix(raw, "/") {
+		raw = "/" + raw
+	}
+
+	basePath = strings.TrimSpace(basePath)
+	if basePath == "" {
+		basePath = "/"
+	}
+	if !strings.HasPrefix(basePath, "/") {
+		basePath = "/" + basePath
+	}
+	basePath = path.Clean(basePath)
+	absolute := path.Clean(raw)
+
+	prefixes := make([]string, 0, 2)
+	prefixes = append(prefixes, absolute)
+
+	if absolute == basePath {
+		prefixes = append(prefixes, "/")
+		return prefixes
+	}
+
+	if strings.HasPrefix(absolute, basePath+"/") {
+		relative := strings.TrimPrefix(absolute, basePath)
+		if relative == "" {
+			relative = "/"
+		}
+		prefixes = append(prefixes, path.Clean(relative))
+	}
+
+	return prefixes
+}
+
+func shouldRenderAppRoute(requestPath string, excludedPrefixes []string) bool {
+	cleanPath := path.Clean("/" + strings.TrimPrefix(strings.TrimSpace(requestPath), "/"))
+	for _, prefix := range excludedPrefixes {
+		if pathHasPrefix(cleanPath, prefix) {
+			return false
+		}
+	}
+	return true
+}
+
+func pathHasPrefix(requestPath, prefix string) bool {
+	if prefix == "" {
+		return false
+	}
+	if prefix == "/" {
+		return requestPath == "/"
+	}
+	return requestPath == prefix || strings.HasPrefix(requestPath, prefix+"/")
 }

internal/controller/controller_test.go

@@ -13,6 +13,7 @@ import (
 
 	"testing/fstest"
 
+	"github.com/google/uuid"
 	"github.com/gorilla/mux"
 	"github.com/iota-uz/applets/internal/api"
 	"github.com/stretchr/testify/assert"
@@ -132,6 +133,82 @@ func TestAppletController_DoesNotMountPerAppletRPCRoute(t *testing.T) {
 	assert.Equal(t, http.StatusMethodNotAllowed, w.Code)
 }
 
+func TestAppletController_ShellCatchAll_SkipsConfiguredAPIEndpoints(t *testing.T) {
+	t.Parallel()
+
+	a := &testApplet{
+		name:     "t",
+		basePath: "/t",
+		config: api.Config{
+			WindowGlobal: "__T__",
+			Shell:        api.ShellConfig{Mode: api.ShellModeStandalone},
+			Endpoints: api.EndpointConfig{
+				Stream: "/t/stream",
+				REST:   "/t/rest",
+			},
+			Assets: api.AssetConfig{
+				FS:           fstest.MapFS{"manifest.json": {Data: []byte(`{"index.html":{"file":"a.js","isEntry":true}}`)}, "a.js": {Data: []byte("console.log('ok')")}},
+				BasePath:     "/assets",
+				ManifestPath: "manifest.json",
+				Entrypoint:   "index.html",
+			},
+			RPC: &api.RPCConfig{Path: "/t/rpc"},
+		},
+	}
+
+	c, err := New(a, nil, api.DefaultSessionConfig, nil, nil, &testHostServices{})
+	require.NoError(t, err)
+
+	r := mux.NewRouter()
+	c.RegisterRoutes(r)
+
+	r.HandleFunc("/t/stream/status", func(w http.ResponseWriter, _ *http.Request) {
+		w.Header().Set("Content-Type", "application/json")
+		_, _ = w.Write([]byte(`{"active":true}`))
+	}).Methods(http.MethodGet)
+	r.HandleFunc("/t/rpc", func(w http.ResponseWriter, _ *http.Request) {
+		_, _ = w.Write([]byte("rpc"))
+	}).Methods(http.MethodGet)
+	r.HandleFunc("/t/rest/health", func(w http.ResponseWriter, _ *http.Request) {
+		_, _ = w.Write([]byte("rest"))
+	}).Methods(http.MethodGet)
+
+	for _, tc := range []struct {
+		name         string
+		target       string
+		wantBody     string
+		wantContains string
+	}{
+		{name: "stream", target: "/t/stream/status", wantBody: `{"active":true}`},
+		{name: "rpc", target: "/t/rpc", wantBody: "rpc"},
+		{name: "rest", target: "/t/rest/health", wantBody: "rest"},
+		{name: "session route still renders app", target: "/t/session/123", wantContains: "__T__"},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			w := httptest.NewRecorder()
+			req := httptest.NewRequest(http.MethodGet, tc.target, nil)
+			req = req.WithContext(context.WithValue(
+				context.WithValue(req.Context(), testUserKey, &mockUser{
+					id:        1,
+					email:     "t@example.com",
+					firstName: "Test",
+					lastName:  "User",
+				}),
+				testTenantIDKey,
+				uuid.New(),
+			))
+			r.ServeHTTP(w, req)
+
+			require.Equal(t, http.StatusOK, w.Code, w.Body.String())
+			if tc.wantBody != "" {
+				assert.Equal(t, tc.wantBody, w.Body.String())
+				return
+			}
+			assert.Contains(t, w.Body.String(), tc.wantContains)
+		})
+	}
+}
+
 func TestAppletController_RPC(t *testing.T) {
 	t.Parallel()
 

ui/src/bichat/components/AssistantMessage.tsx

@@ -681,6 +681,12 @@ export function AssistantMessage({
                   <span className={classes.timestamp}>{timestamp}</span>
                 )}
 
+                {showDebug && turn.debug?.attempts?.[0]?.model && (
+                  <span className="inline-flex items-center gap-0.5 rounded px-1 py-0.5 text-[10px] font-medium leading-none text-gray-500 dark:text-gray-400 bg-gray-100 dark:bg-gray-800">
+                    {turn.debug.attempts[0].model}
+                  </span>
+                )}
+
                 <button
                   onClick={handleCopyClick}
                   className={`cursor-pointer ${classes.actionButton} ${

ui/src/bichat/components/ChatSession.tsx

@@ -29,6 +29,7 @@ import { SessionArtifactsPanel } from './SessionArtifactsPanel';
 import { SessionMembersModal } from './SessionMembersModal';
 import Alert from './Alert';
 import { StreamError } from './StreamError';
+import { isOpenQuestionStatus } from '../machine/hitlLifecycle';
 
 interface ChatSessionProps {
   dataSource: ChatDataSource
@@ -56,6 +57,8 @@ interface ChatSessionProps {
   logoSlot?: ReactNode
   /** Custom action buttons for the header */
   actionsSlot?: ReactNode
+  /** Custom content rendered above the message input (e.g., model selector) */
+  inputHeaderSlot?: ReactNode
   /** Callback when user navigates back */
   onBack?: () => void
   /** Custom verbs for the typing indicator (e.g. ['Thinking', 'Analyzing', ...]) */
@@ -85,6 +88,7 @@ function ChatSessionCore({
   welcomeSlot,
   logoSlot,
   actionsSlot,
+  inputHeaderSlot,
   onBack,
   thinkingVerbs,
   onSessionRestored,
@@ -119,6 +123,7 @@ function ChatSessionCore({
     isCompacting,
     retryLastMessage,
     clearStreamError,
+    pendingQuestion,
   } = useChatMessaging();
   const {
     inputError,
@@ -135,6 +140,7 @@ function ChatSessionCore({
   const isArchived = session?.status === 'archived';
   const accessReadOnly = session?.access ? !session.access.canWrite : false;
   const effectiveReadOnly = Boolean(readOnly ?? isReadOnly) || isArchived || accessReadOnly;
+  const composerDisabled = isOpenQuestionStatus(pendingQuestion?.status);
   const [restoring, setRestoring] = useState(false);
   const handleRestore = useCallback(async () => {
     if (!session?.id) {return;}
@@ -405,7 +411,7 @@ function ChatSessionCore({
               <div className="flex flex-1 items-center justify-center px-4 py-8">
                 <div className="w-full max-w-5xl">
                   {welcomeSlot || (
-                    <WelcomeContent onPromptSelect={handlePromptSelect} disabled={loading} />
+                    <WelcomeContent onPromptSelect={handlePromptSelect} disabled={loading || composerDisabled} />
                   )}
                   {streamError && (
                     <div className="px-6 pt-4">
@@ -417,6 +423,7 @@ function ChatSessionCore({
                       />
                     </div>
                   )}
+                  {!effectiveReadOnly && inputHeaderSlot}
                   {!effectiveReadOnly && (
                     <MessageInput
                       message={message}
@@ -437,6 +444,7 @@ function ChatSessionCore({
                       onCancelStreaming={cancel}
                       containerClassName="pt-6 px-6"
                       formClassName="mx-auto"
+                      disabled={composerDisabled}
                       reasoningEffortOptions={reasoningEffortOptions}
                       reasoningEffort={reasoningEffort}
                       onReasoningEffortChange={setReasoningEffort}
@@ -483,6 +491,7 @@ function ChatSessionCore({
                   />
                 </div>
               )}
+              {!effectiveReadOnly && inputHeaderSlot}
               {!effectiveReadOnly && (
                 <MessageInput
                   message={message}
@@ -501,6 +510,7 @@ function ChatSessionCore({
                   onRemoveQueueItem={removeQueueItem}
                   onUpdateQueueItem={updateQueueItem}
                   onCancelStreaming={cancel}
+                  disabled={composerDisabled}
                   reasoningEffortOptions={reasoningEffortOptions}
                   reasoningEffort={reasoningEffort}
                   onReasoningEffortChange={setReasoningEffort}

ui/src/bichat/components/ModelSelector.tsx

@@ -0,0 +1,85 @@
+import { useEffect, useCallback, useMemo } from 'react';
+import { Lightning, Brain } from '@phosphor-icons/react';
+import { useChatSession } from '../context/ChatContext';
+import { useIotaContext } from '../context/IotaContext';
+
+interface ModelEntry {
+  id: string
+  label: string
+  default?: boolean
+}
+
+export function ModelSelector() {
+  const { model, setModel } = useChatSession();
+  const context = useIotaContext();
+
+  const models: ModelEntry[] = useMemo(
+    () => context.extensions?.llm?.models ?? [],
+    [context.extensions?.llm?.models],
+  );
+
+  const defaultModel = models.find((m) => m.default) ?? models[0];
+  const currentModel = model ?? defaultModel?.id;
+
+  // Set default model on mount
+  useEffect(() => {
+    if (!model && defaultModel) {
+      setModel(defaultModel.id);
+    }
+  }, [model, defaultModel, setModel]);
+
+  // Keyboard shortcut: Cmd+Shift+M to rotate
+  const rotateModel = useCallback(() => {
+    const currentIndex = models.findIndex((m) => m.id === currentModel);
+    const nextIndex = (currentIndex + 1) % models.length;
+    setModel(models[nextIndex].id);
+  }, [currentModel, models, setModel]);
+
+  useEffect(() => {
+    const handler = (e: KeyboardEvent) => {
+      if ((e.metaKey || e.ctrlKey) && e.shiftKey && e.key === 'm') {
+        e.preventDefault();
+        rotateModel();
+      }
+    };
+    document.addEventListener('keydown', handler);
+    return () => document.removeEventListener('keydown', handler);
+  }, [rotateModel]);
+
+  // Don't render if less than 2 models
+  if (models.length < 2) {return null;}
+
+  return (
+    <div className="flex items-center justify-between px-4 pt-3 pb-1">
+      <div className="inline-flex rounded-lg bg-gray-100 p-0.5 dark:bg-gray-800">
+        {models.map((m) => {
+          const isActive = m.id === currentModel;
+          const isFast = m.label === 'Fast';
+          return (
+            <button
+              key={m.id}
+              type="button"
+              onClick={() => setModel(m.id)}
+              className={`
+                flex items-center gap-1 rounded-md px-2.5 py-1 text-xs font-medium transition-all duration-150
+                ${
+                  isActive
+                    ? isFast
+                      ? 'bg-white text-amber-600 shadow-sm dark:bg-gray-700 dark:text-amber-400'
+                      : 'bg-white text-blue-600 shadow-sm dark:bg-gray-700 dark:text-blue-400'
+                    : 'text-gray-500 hover:text-gray-700 dark:text-gray-400 dark:hover:text-gray-300'
+                }
+              `}
+            >
+              {isFast ? <Lightning size={13} weight="fill" /> : <Brain size={13} weight="fill" />}
+              <span>{m.label}</span>
+            </button>
+          );
+        })}
+      </div>
+      <span className="hidden select-none text-[10px] text-gray-400 sm:block dark:text-gray-500">
+        {navigator.platform.includes('Mac') ? '\u2318' : 'Ctrl'}{'\u21E7'}M
+      </span>
+    </div>
+  );
+}