feat: multi-user identity context support

Author: NamesMT

apps/backend-convex/convex/http/ai.ts

@@ -12,6 +12,7 @@ import { Hono } from 'hono'
 import { cors } from 'hono/cors'
 import { throttle } from 'kontroll'
 import { z } from 'zod'
+import { buildAiSdkMessage } from '../../utils/message'
 import { api, components, internal } from '../_generated/api'
 
 const orModels = process.env.AI_MODELS_LIST?.split(',') ?? ['qwen/qwen3-32b:free']
@@ -59,6 +60,9 @@ aiApp
       model: z.string(),
       apiKey: z.string(),
       content: z.optional(z.string()),
+      context: z.optional(z.object({
+        from: z.optional(z.string()),
+      })),
       resumeStreamId: z.optional(z.string()),
       finishOnly: z.optional(z.boolean()),
       lockerKey: z.optional(z.string()),
@@ -73,6 +77,7 @@ aiApp
         model,
         apiKey,
         content,
+        context = {},
         resumeStreamId,
         finishOnly,
         lockerKey,
@@ -140,17 +145,18 @@ aiApp
         streamId = `${Date.now()}_${randomStr(10)}`
 
         // Add user message to thread
-        await c.env.runMutation(api.messages.add, {
+        await c.env.runMutation(internal.messages.add, {
           threadId,
           role: 'user',
           content,
+          context: { ...context, uid: userIdentity?.subject ?? 'UNKNOWN' },
           provider,
           model,
           lockerKey,
         })
 
-        // Create initial streaming message
-        streamingMessageId = await c.env.runMutation(api.messages.add, {
+        // Add assistant message to thread (initial streaming)
+        streamingMessageId = await c.env.runMutation(internal.messages.add, {
           threadId,
           role: 'assistant',
           content: '',
@@ -171,10 +177,7 @@ aiApp
       // Prepare messages for AI API (exclude the streaming messages)
       const messagesContext = messages
         .filter(msg => !msg.isStreaming)
-        .map(msg => ({
-          role: msg.role,
-          content: msg.content,
-        }))
+        .map(buildAiSdkMessage)
 
       // Create streaming response
       const encoder = new TextEncoder()
@@ -219,7 +222,7 @@ aiApp
                 throttle(
                   500,
                   async () => {
-                    await c.env.runMutation(api.messages.updateStreamingMessage, {
+                    await c.env.runMutation(internal.messages.updateStreamingMessage, {
                       messageId: streamingMessageId,
                       content: aiResponse,
                       isStreaming: true,

apps/backend-convex/convex/messages.ts

@@ -1,7 +1,7 @@
 import { objectPick } from '@namesmt/utils'
 import { ConvexError, v } from 'convex/values'
 import { messagesInThreadCounter } from './_counters'
-import { internalMutation, internalQuery, mutation, query } from './_generated/server'
+import { internalMutation, internalQuery, query } from './_generated/server'
 import { assertThreadAccess } from './threads'
 
 export const listByThread = query({
@@ -61,11 +61,15 @@ export const get = query({
   },
 })
 
-export const add = mutation({
+export const add = internalMutation({
   args: {
     threadId: v.id('threads'),
     role: v.union(v.literal('user'), v.literal('assistant')),
     content: v.string(),
+    context: v.optional(v.object({
+      from: v.optional(v.string()),
+      uid: v.optional(v.string()),
+    })),
     isStreaming: v.optional(v.boolean()),
     streamId: v.optional(v.string()),
     provider: v.string(),
@@ -82,13 +86,13 @@ export const add = mutation({
     await messagesInThreadCounter.inc(ctx, args.threadId)
 
     return await ctx.db.insert('messages', {
-      ...objectPick(args, ['threadId', 'role', 'content', 'isStreaming', 'streamId', 'provider', 'model']),
+      ...objectPick(args, ['threadId', 'role', 'content', 'context', 'isStreaming', 'streamId', 'provider', 'model']),
       timestamp: Date.now(),
     })
   },
 })
 
-export const updateStreamingMessage = mutation({
+export const updateStreamingMessage = internalMutation({
   args: {
     messageId: v.id('messages'),
     content: v.string(),
@@ -147,6 +151,7 @@ export const finishStreaming = internalMutation({
       return
 
     await ctx.db.patch(message._id, {
+      streamId: undefined,
       isStreaming: false,
     })
   },

apps/backend-convex/convex/schema.ts

@@ -29,6 +29,10 @@ const aiChatTables = {
     role: v.union(v.literal('user'), v.literal('assistant')),
     timestamp: v.number(),
     content: v.string(),
+    context: v.optional(v.object({
+      from: v.optional(v.string()),
+      uid: v.optional(v.string()),
+    })),
     streamId: v.optional(v.string()),
     isStreaming: v.optional(v.boolean()),
     provider: v.string(),

apps/backend-convex/tsconfig.json

@@ -6,6 +6,6 @@
       "vitest"
     ]
   },
-  "include": ["./convex/**/*"],
+  "include": ["./convex/**/*", "./utils/**/*"],
   "exclude": ["./convex/_generated"]
 }

apps/backend-convex/utils/message.ts

@@ -0,0 +1,42 @@
+import type { Doc } from '../convex/_generated/dataModel'
+
+export interface BuiltMessage {
+  role: 'user' | 'assistant'
+  content: string
+}
+export function buildAiSdkMessage(message: Doc<'messages'>): BuiltMessage {
+  switch (message.role) {
+    case 'user':
+      return {
+        role: 'user',
+        content: buildUserMessageContent(message),
+      }
+    case 'assistant':
+      return {
+        role: 'assistant',
+        content: message.content,
+      }
+    default:
+      throw new Error(`Unknown message role: ${message.role}`)
+  }
+}
+
+export function buildUserMessageContent({ content, context }: Pick<Doc<'messages'>, 'content' | 'context'>) {
+  let builtContent = ''
+
+  if (context && Object.keys(context)) {
+    builtContent += `@--System context start@\n`
+
+    if (context.from)
+      builtContent += `From: "${context.from}"\n`
+
+    if (context.uid)
+      builtContent += `UID: "${context.uid}"\n`
+
+    builtContent += `@System context end--@\n\n`
+  }
+
+  builtContent += content
+
+  return builtContent
+}

apps/frontend/app/components/chat/ChatInterface.vue

@@ -16,7 +16,6 @@ import LiquidGlassDiv from '../LiquidGlassDiv.vue'
 
 const isDev = import.meta.dev
 const { $auth } = useNuxtApp()
-const { convexApiUrl } = useRuntimeConfig().public
 const convex = useConvexClient()
 const chatContext = useChatContext()
 const { toast } = useToast()
@@ -155,6 +154,7 @@ async function handleSubmit({ input, confirmMultiStream = false }: HandleSubmitA
     id: `user-${Date.now()}`,
     role: 'user',
     content: userInput,
+    context: { from: getUserName() },
   } as any as CustomMessage)
   messages.value.push({
     id: `assistant-${Date.now()}`,
@@ -252,23 +252,13 @@ async function streamToMessage({ message, content, resumeStreamId }: StreamToMes
     ++streamingMessages.value
 
     const currentThreadId = threadIdRef.value
-    const abortController = new AbortController()
-    const response = await fetch(`${convexApiUrl}/api/ai/chat/stream`, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'Authorization': `Bearer ${$auth.token}`,
-      },
-      body: JSON.stringify({
-        threadId: currentThreadId,
-        provider: 'openrouter',
-        model: 'deepseek/deepseek-chat:free',
-        apiKey: 'dummy',
-        content,
-        resumeStreamId,
-        lockerKey: getLockerKey(currentThreadId),
-      }),
-      signal: abortController.signal,
+    const { response, abortController } = await postChatStream({
+      threadId: currentThreadId as Id<'threads'>,
+      provider: 'openrouter',
+      model: 'deepseek/deepseek-chat:free',
+      apiKey: 'dummy',
+      content,
+      resumeStreamId,
     })
 
     if (!response.ok) {
@@ -477,6 +467,15 @@ function alertIsStreaming(input: string) {
               </Card>
             </component>
 
+            <div
+              v-if="m.role === 'user'"
+              class="absolute right-2 top-100% flex gap-1 opacity-0 transition-opacity group-hover/message:opacity-100"
+            >
+              <div v-if="m.context?.from" class="text-xs">
+                {{ m.context.from }}
+              </div>
+            </div>
+
             <div
               v-if="m.role !== 'user'"
               class="absolute bottom-2 left-2 flex gap-1 opacity-0 transition-opacity group-hover/message:opacity-100"

apps/frontend/app/utils/chat.ts

@@ -118,6 +118,47 @@ export async function threadSetLockerKey(convex: ConvexClient | ConvexHttpClient
   })
 }
 
+export function getUserName() {
+  const { $auth } = useNuxtApp()
+
+  return localStorage.getItem('chat/user-nickname') || $auth?.user?.name || 'Anonymous'
+}
+
+export interface PostChatStreamArgs {
+  threadId: Id<'threads'>
+  provider: string
+  model: string
+  apiKey: string
+  content?: string
+  resumeStreamId?: string
+  finishOnly?: boolean
+  abortController?: AbortController
+}
+export async function postChatStream(args: PostChatStreamArgs) {
+  const {
+    abortController = new AbortController(),
+  } = args
+
+  const { convexApiUrl } = useRuntimeConfig().public
+  const { $auth } = useNuxtApp()
+
+  const response = await fetch(`${convexApiUrl}/api/ai/chat/stream`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${$auth.token}`,
+    },
+    body: JSON.stringify({
+      ...args,
+      context: { from: getUserName() },
+      lockerKey: getLockerKey(args.threadId),
+    }),
+    signal: abortController.signal,
+  })
+
+  return { response, abortController }
+}
+
 export interface CustomMessage extends Doc<'messages'> {
   id: string
 }