refactor: convert messagesWithSystem to use object parameter

🤖 Generated with Codebuff
Co-Authored-By: Codebuff <noreply@codebuff.com>

Author: charleslien

backend/src/admin/relabelRuns.ts

@@ -169,10 +169,10 @@ export async function relabelForUserHandler(req: Request, res: Response) {
             const system = payload.system
 
             output = await promptAiSdk({
-              messages: messagesWithSystem(
-                messages as Message[],
-                system as System,
-              ),
+              messages: messagesWithSystem({
+                messages: messages as Message[],
+                system: system as System,
+              }),
               model: model,
               clientSessionId: 'relabel-trace-api',
               fingerprintId: 'relabel-trace-api',
@@ -395,7 +395,7 @@ export async function relabelWithClaudeWithFullFileContext(
   }
 
   const output = await promptAiSdk({
-    messages: messagesWithSystem(trace.payload.messages as Message[], system),
+    messages: messagesWithSystem({ messages: trace.payload.messages as Message[], system }),
     model: model as any, // Model type is string here for flexibility
     clientSessionId: 'relabel-trace-api',
     fingerprintId: 'relabel-trace-api',

backend/src/find-files/request-files-prompt.ts

@@ -327,7 +327,7 @@ async function getRelevantFiles(
     bufferTokens,
   )
   const start = performance.now()
-  let codebuffMessages = messagesWithSystem(messagesWithPrompt, system)
+  let codebuffMessages = messagesWithSystem({ messages: messagesWithPrompt, system })
 
   // Converts assistant messages to user messages for finetuned model
   codebuffMessages = codebuffMessages
@@ -410,7 +410,7 @@ async function getRelevantFilesForTraining(
   )
   const start = performance.now()
   let response = await promptAiSdk({
-    messages: messagesWithSystem(messagesWithPrompt, system),
+    messages: messagesWithSystem({ messages: messagesWithPrompt, system }),
     clientSessionId,
     fingerprintId,
     userInputId,

backend/src/run-agent-step.ts

@@ -277,7 +277,9 @@ export const runAgentStep = async (
   let fullResponse = ''
   const toolResults: ToolResultPart[] = []
 
-  const stream = getStream(messagesWithSystem(agentMessages, system))
+  const stream = getStream(
+    messagesWithSystem({ messages: agentMessages, system }),
+  )
 
   const {
     toolCalls,

backend/src/run-programmatic-step.ts

@@ -86,7 +86,7 @@ export async function runProgrammaticStep(
 
   // Run with either a generator or a sandbox.
   let generator = runIdToGenerator[agentState.runId]
-  let sandbox = sandboxManager.getSandbox(agentState.runId)
+  let sandbox = sandboxManager.getSandbox({ runId: agentState.runId })
 
   // Check if we need to initialize a generator
   if (!generator && !sandbox) {
@@ -113,18 +113,18 @@ export async function runProgrammaticStep(
 
     if (typeof template.handleSteps === 'string') {
       // Initialize QuickJS sandbox for string-based generator
-      sandbox = await sandboxManager.getOrCreateSandbox(
-        agentState.runId,
-        template.handleSteps,
-        {
+      sandbox = await sandboxManager.getOrCreateSandbox({
+        runId: agentState.runId,
+        generatorCode: template.handleSteps,
+        initialInput: {
           agentState,
           prompt,
           params,
           logger: streamingLogger,
         },
-        undefined, // config
-        streamingLogger, // pass the streaming logger instance for internal use
-      )
+        config: undefined, // config
+        logger: streamingLogger, // pass the streaming logger instance for internal use
+      })
     } else {
       // Initialize native generator
       generator = template.handleSteps({
@@ -362,7 +362,7 @@ export async function runProgrammaticStep(
     if (endTurn) {
       if (sandbox) {
         // Clean up QuickJS sandbox if execution is complete
-        sandboxManager.removeSandbox(agentState.runId)
+        sandboxManager.removeSandbox({ runId: agentState.runId })
       }
       delete runIdToGenerator[agentState.runId]
       runIdToStepAll.delete(agentState.runId)

backend/src/util/__tests__/messages.test.ts

@@ -30,7 +30,7 @@ describe('messagesWithSystem', () => {
     ] as Message[]
     const system = 'Be helpful'
 
-    const result = messagesWithSystem(messages, system)
+    const result = messagesWithSystem({ messages, system })
 
     expect(result).toEqual([
       { role: 'system', content: 'Be helpful' },

backend/src/util/messages.ts

@@ -19,10 +19,11 @@ import type {
   ToolMessage,
 } from '@codebuff/common/types/messages/codebuff-message'
 
-export function messagesWithSystem(
-  messages: Message[],
-  system: System,
-): Message[] {
+export function messagesWithSystem(params: {
+  messages: Message[]
+  system: System
+}): Message[] {
+  const { messages, system } = params
   return [
     {
       role: 'system',

backend/src/util/quickjs-sandbox.ts

@@ -261,18 +261,19 @@ export class SandboxManager {
   /**
    * Create or get a sandbox for the given agent ID
    */
-  async getOrCreateSandbox(
-    runId: string,
-    generatorCode: string,
-    initialInput: any,
-    config?: SandboxConfig,
+  async getOrCreateSandbox(params: {
+    runId: string
+    generatorCode: string
+    initialInput: any
+    config?: SandboxConfig
     logger?: {
       debug: (data: any, msg?: string) => void
       info: (data: any, msg?: string) => void
       warn: (data: any, msg?: string) => void
       error: (data: any, msg?: string) => void
-    },
-  ): Promise<QuickJSSandbox> {
+    }
+  }): Promise<QuickJSSandbox> {
+    const { runId, generatorCode, initialInput, config, logger } = params
     const existing = this.sandboxes.get(runId)
     if (existing && existing.isInitialized()) {
       return existing
@@ -297,14 +298,16 @@ export class SandboxManager {
   /**
    * Get an existing sandbox
    */
-  getSandbox(runId: string): QuickJSSandbox | undefined {
+  getSandbox(params: { runId: string }): QuickJSSandbox | undefined {
+    const { runId } = params
     return this.sandboxes.get(runId)
   }
 
   /**
    * Remove and dispose a sandbox
    */
-  removeSandbox(runId: string): void {
+  removeSandbox(params: { runId: string }): void {
+    const { runId } = params
     const sandbox = this.sandboxes.get(runId)
     if (sandbox) {
       sandbox.dispose()

backend/src/websockets/websocket-action.ts

@@ -47,9 +47,10 @@ export const sendAction = (ws: WebSocket, action: ServerAction) => {
  * @param authToken - The authentication token to validate
  * @returns The user ID if found, undefined otherwise
  */
-export const getUserIdFromAuthToken = async (
-  authToken?: string,
-): Promise<string | undefined> => {
+export const getUserIdFromAuthToken = async (params: {
+  authToken?: string
+}): Promise<string | undefined> => {
+  const { authToken } = params
   if (!authToken) return undefined
 
   const userId = await db