refactor(server): drop stale prompt text, duplicated routes and dead options

- lib/system-prompts.ts: delete the extended prompt kept only to reach
  the 4096-token cache threshold of two old Claude models; describe the
  current canvas-first UI in the App Features section
- app/api/chat/route.ts: remove the server-side example cache (the
  browser answers examples itself), the ENABLE_HISTORY_XML_REPLACE
  option and its helper, the unread messageMetadata fields; the
  DEBUG_LLM_PAYLOAD blocks become one describeMessages summary
- app/api/log-feedback and log-save share scoreLatestTrace in
  lib/langfuse.ts
- app/api/admin/test-model and validate-model call a shared
  testModelConnection() instead of one route faking a request to the
  other and passing trust through the body
- lib/dynamo-quota-manager.ts reads the failing item from the
  conditional update instead of a second GetItem
- lib/ai-providers.ts: geminiThinkingOptions helper for the google and
  vertexai cases, drop the unused fourth resolveBaseURL parameter
- edge-functions: always stream, shrink messageSchema, drop model
  aliases nothing sends
- delete app/api/chat/xml_guide.md, parseOutputTokenLimit, unused type
  exports and export keywords on file-internal symbols
- env.example: drop variables nothing reads, document the quota,
  validation and analytics variables, mention the apiKeyEnv array form
  (also in docs/*/ai-providers.md)

edge-functions/api/edgeai/chat/completions.ts

@@ -29,6 +29,7 @@ const messageItemSchema = z
     })
     .passthrough()
 
+// The fields read here; every other field is passed on to AI.chatCompletions
 const messageSchema = z
     .object({
         messages: z.array(messageItemSchema),
@@ -36,21 +37,6 @@ const messageSchema = z
         stream: z.boolean().optional(),
         tools: z.any().optional(),
         tool_choice: z.any().optional(),
-        functions: z.any().optional(),
-        function_call: z.any().optional(),
-        temperature: z.number().optional(),
-        top_p: z.number().optional(),
-        max_tokens: z.number().optional(),
-        presence_penalty: z.number().optional(),
-        frequency_penalty: z.number().optional(),
-        stop: z.union([z.string(), z.array(z.string())]).optional(),
-        response_format: z.any().optional(),
-        seed: z.number().optional(),
-        user: z.string().optional(),
-        n: z.number().int().optional(),
-        logit_bias: z.record(z.string(), z.number()).optional(),
-        parallel_tool_calls: z.boolean().optional(),
-        stream_options: z.any().optional(),
     })
     .passthrough()
 
@@ -61,12 +47,6 @@ const ALLOWED_MODELS = [
     "@tx/deepseek-ai/deepseek-v3-0324",
 ]
 
-const MODEL_ALIASES: Record<string, string> = {
-    "deepseek-v3.2": "@tx/deepseek-ai/deepseek-v32",
-    "deepseek-r1-0528": "@tx/deepseek-ai/deepseek-r1-0528",
-    "deepseek-v3-0324": "@tx/deepseek-ai/deepseek-v3-0324",
-}
-
 /**
  * Create standardized JSON response
  */
@@ -145,8 +125,16 @@ export async function onRequest({ request, env }: any) {
             )
         }
 
-        const { messages, model, stream, tools, tool_choice, ...extraParams } =
-            parseResult.data
+        // stream is taken out so it is not passed on: AI.chatCompletions
+        // only streams, and every caller reads a stream
+        const {
+            messages,
+            model,
+            stream: _,
+            tools,
+            tool_choice,
+            ...extraParams
+        } = parseResult.data
 
         // Validate messages
         const userMessages = messages.filter(
@@ -165,14 +153,13 @@ export async function onRequest({ request, env }: any) {
         }
 
         // Resolve model
-        const requestedModel = model || ALLOWED_MODELS[0]
-        const selectedModel = MODEL_ALIASES[requestedModel] || requestedModel
+        const selectedModel = model || ALLOWED_MODELS[0]
 
         if (!ALLOWED_MODELS.includes(selectedModel)) {
             return createResponse(
                 {
                     error: {
-                        message: `Invalid model: ${requestedModel}.`,
+                        message: `Invalid model: ${selectedModel}.`,
                         type: "invalid_request_error",
                     },
                 },
@@ -181,39 +168,10 @@ export async function onRequest({ request, env }: any) {
         }
 
         console.log(
-            `[EdgeOne] Model: ${selectedModel}, Tools: ${tools?.length || 0}, Stream: ${stream ?? true}`,
+            `[EdgeOne] Model: ${selectedModel}, Tools: ${tools?.length || 0}`,
         )
 
         try {
-            const isStream = !!stream
-
-            // Non-streaming: return mock response for validation
-            // AI.chatCompletions doesn't support non-streaming mode
-            if (!isStream) {
-                const mockResponse = {
-                    id: `chatcmpl-${Date.now()}`,
-                    object: "chat.completion",
-                    created: Math.floor(Date.now() / 1000),
-                    model: selectedModel,
-                    choices: [
-                        {
-                            index: 0,
-                            message: {
-                                role: "assistant",
-                                content: "OK",
-                            },
-                            finish_reason: "stop",
-                        },
-                    ],
-                    usage: {
-                        prompt_tokens: 10,
-                        completion_tokens: 1,
-                        total_tokens: 11,
-                    },
-                }
-                return createResponse(mockResponse)
-            }
-
             // Build AI.chatCompletions options for streaming
             const aiOptions: any = {
                 ...extraParams,