fix: add createSystemTurn method to handle system messages in session management

Author: NoOne7135

endpoints/context.ts

@@ -33,6 +33,7 @@ export type AgentEndpointsContext = {
   runAndPersistAgentResponse(input: RunAndPersistAgentResponseInput): Promise<RunAndPersistAgentResponseResult>;
   getSessionTurns(sessionId: string): Promise<SessionTurn[]>;
   createNewTurn(sessionId: string, prompt: string, response?: string): Promise<string>;
+  createSystemTurn(sessionId: string, systemMessage: string): Promise<string>;
   getChatSurfaceConnectActionAdapters(): ChatSurfaceAdapterWithConnectAction[];
   createChatSurfaceLinkToken(surface: string, adminUser: AdminUser): string;
   handleChatSurfaceMessage(
@@ -50,6 +51,7 @@ export type CoreEndpointsContext = Pick<
 export type SessionEndpointsContext = Pick<
   AgentEndpointsContext,
   "adminforth" | "options" | "parseBody" | "getSessionTurns" | "createNewTurn"
+  | "createSystemTurn"
 >;
 
 export type ChatSurfaceEndpointsContext = Pick<

endpoints/sessions.ts

@@ -2,6 +2,7 @@ import type { IHttpServer } from "adminforth";
 import { Filters, Sorts } from "adminforth";
 import { randomUUID } from "crypto";
 import { z } from "zod";
+import { AGENT_SYSTEM_TURN_PROMPT } from "../sessionStore.js";
 import type { SessionEndpointsContext } from "./context.js";
 
 const addSystemMessageBodySchema = z.object({
@@ -71,7 +72,14 @@ export function setupSessionEndpoints(ctx: SessionEndpointsContext, server: IHtt
           title: session[ctx.options.sessionResource.titleField],
           timestamp: session[ctx.options.sessionResource.createdAtField],
           messages: turns.flatMap(turn => {
-            const messages: Array<{ text: string; role: 'user' | 'assistant' }> = [];
+            const messages: Array<{ text: string; role: 'user' | 'assistant' | 'system' }> = [];
+            if (turn.prompt === AGENT_SYSTEM_TURN_PROMPT) {
+              messages.push({
+                text: turn.response,
+                role: 'system',
+              });
+              return messages;
+            }
             if (turn.prompt) {
               messages.push({
                 text: turn.prompt,
@@ -166,6 +174,7 @@ export function setupSessionEndpoints(ctx: SessionEndpointsContext, server: IHtt
           error: 'Unauthorized'
         };
       }
+      await ctx.createSystemTurn(data.sessionId, data.systemMessage);
       return {
         ok: true
       }

index.ts

@@ -162,6 +162,7 @@ export default class AdminForthAgentPlugin extends AdminForthPlugin {
       runAndPersistAgentResponse: this.agentTurnService.runAndPersistAgentResponse.bind(this.agentTurnService),
       getSessionTurns: this.sessionStore.getSessionTurns.bind(this.sessionStore),
       createNewTurn: this.sessionStore.createNewTurn.bind(this.sessionStore),
+      createSystemTurn: this.sessionStore.createSystemTurn.bind(this.sessionStore),
       getChatSurfaceConnectActionAdapters: this.chatSurfaceService.getConnectActionAdapters.bind(this.chatSurfaceService),
       createChatSurfaceLinkToken: this.chatSurfaceService.createLinkToken.bind(this.chatSurfaceService),
       handleChatSurfaceMessage: this.chatSurfaceService.handleMessage.bind(this.chatSurfaceService),

sessionStore.ts

@@ -5,6 +5,8 @@ import type { ChatSurfaceIncomingMessage } from "adminforth";
 import type { PreviousUserMessage } from "./agent/languageDetect.js";
 import type { PluginOptions } from "./types.js";
 
+export const AGENT_SYSTEM_TURN_PROMPT = "__adminforth_system_message__";
+
 export class AgentSessionStore {
   constructor(
     private getAdminforth: () => IAdminForth,
@@ -23,6 +25,18 @@ export class AgentSessionStore {
     return newTurn.createdRecord[this.options.turnResource.idField];
   }
 
+  async createSystemTurn(sessionId: string, systemMessage: string) {
+    const turnId = randomUUID();
+    const turnRecord = {
+      [this.options.turnResource.idField]: turnId,
+      [this.options.turnResource.sessionIdField]: sessionId,
+      [this.options.turnResource.promptField]: AGENT_SYSTEM_TURN_PROMPT,
+      [this.options.turnResource.responseField]: systemMessage,
+    };
+    const newTurn = await this.getAdminforth().resource(this.options.turnResource.resourceId).create(turnRecord);
+    return newTurn.createdRecord[this.options.turnResource.idField];
+  }
+
   async getSessionTurns(sessionId: string) {
     const turns = await this.getAdminforth().resource(this.options.turnResource.resourceId).list(
       [Filters.EQ(this.options.turnResource.sessionIdField, sessionId)],
@@ -45,6 +59,7 @@ export class AgentSessionStore {
     );
     return turns
       .reverse()
+      .filter((turn) => turn[this.options.turnResource.promptField] !== AGENT_SYSTEM_TURN_PROMPT)
       .map((turn): PreviousUserMessage => ({
         text: turn[this.options.turnResource.promptField],
       }));