@adminforth/agent 2.2.5 → 2.3.1

package/dist/persistence/sessionStore.js

@@ -63,13 +63,65 @@ export class AgentSessionStore {
     }
     getSessionTurns(sessionId) {
         return __awaiter(this, void 0, void 0, function* () {
-            const turns = yield this.getAdminforth().resource(this.options.turnResource.resourceId).list([Filters.EQ(this.options.turnResource.sessionIdField, sessionId)], undefined, undefined, [Sorts.ASC(this.options.turnResource.createdAtField)]);
+            const turns = yield this.getAdminforth().resource(this.options.turnResource.resourceId).list([Filters.EQ(this.options.turnResource.sessionIdField, sessionId)], undefined, undefined, [Sorts.ASC(this.options.turnResource.createdAtField), Sorts.ASC(this.options.turnResource.idField)]);
             return turns.map(turn => ({
+                id: turn[this.options.turnResource.idField],
                 prompt: turn[this.options.turnResource.promptField],
                 response: turn[this.options.turnResource.responseField],
             }));
         });
     }
+    /**
+     * Ordered non-system (real conversation) turns with their stored checkpoint id.
+     * Used by message editing to locate the target turn and its previous turn's
+     * fork point. Stable order (`createdAt ASC, id ASC`) so positions never drift.
+     */
+    getAgentTurns(sessionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const checkpointIdField = this.options.turnResource.checkpointIdField;
+            const turns = yield this.getAdminforth().resource(this.options.turnResource.resourceId).list([Filters.EQ(this.options.turnResource.sessionIdField, sessionId)], undefined, undefined, [Sorts.ASC(this.options.turnResource.createdAtField), Sorts.ASC(this.options.turnResource.idField)]);
+            return turns
+                .filter((turn) => turn[this.options.turnResource.promptField] !== AGENT_SYSTEM_TURN_PROMPT)
+                .map((turn) => ({
+                id: turn[this.options.turnResource.idField],
+                prompt: turn[this.options.turnResource.promptField],
+                response: turn[this.options.turnResource.responseField],
+                checkpointId: checkpointIdField
+                    ? (turn[checkpointIdField] ? String(turn[checkpointIdField]) : null)
+                    : null,
+            }));
+        });
+    }
+    /**
+     * Apply a message edit and branch: replace the edited turn's prompt and truncate
+     * everything after it. Deletes later turns FIRST, then updates the edited turn, so
+     * an interruption can only leave a consistent "truncated, edit-not-yet-applied"
+     * state (recoverable by retry) — never "edited but stale later turns remain".
+     * (AdminForth's resource API has no transactions, hence the deliberate ordering.)
+     */
+    editTurnAndTruncateAfter(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const r = this.options.turnResource;
+            const resource = this.getAdminforth().resource(r.resourceId);
+            const turns = yield resource.list([Filters.EQ(r.sessionIdField, input.sessionId)], undefined, undefined, [Sorts.ASC(r.createdAtField), Sorts.ASC(r.idField)]);
+            const targetIndex = turns.findIndex((turn) => turn[r.idField] === input.turnId);
+            if (targetIndex === -1) {
+                throw new Error(`Turn "${input.turnId}" not found in session "${input.sessionId}".`);
+            }
+            const laterTurns = turns.slice(targetIndex + 1);
+            for (const turn of laterTurns) {
+                yield resource.delete(turn[r.idField]);
+            }
+            const updates = {
+                [r.promptField]: input.newPrompt,
+                [r.responseField]: "not_finished",
+            };
+            if (r.checkpointIdField) {
+                updates[r.checkpointIdField] = null;
+            }
+            yield resource.update(input.turnId, updates);
+        });
+    }
     getPreviousUserMessages(sessionId) {
         return __awaiter(this, void 0, void 0, function* () {
             const turns = yield this.getAdminforth().resource(this.options.turnResource.resourceId).list([Filters.EQ(this.options.turnResource.sessionIdField, sessionId)], 2, undefined, [Sorts.DESC(this.options.turnResource.createdAtField)]);
@@ -121,6 +173,9 @@ export class AgentSessionStore {
             if (this.options.turnResource.debugField) {
                 turnUpdates[this.options.turnResource.debugField] = input.debugHistory;
             }
+            if (this.options.turnResource.checkpointIdField && input.checkpointId !== undefined) {
+                turnUpdates[this.options.turnResource.checkpointIdField] = input.checkpointId;
+            }
             yield this.getAdminforth()
                 .resource(this.options.turnResource.resourceId)
                 .update(input.turnId, turnUpdates);

package/dist/transport/http/context.d.ts

@@ -1,7 +1,8 @@
 import type { ChatSurfaceAdapter, ChatSurfaceEventSink, ChatSurfaceIncomingMessage, IAdminForth } from "adminforth";
-import type { HandleSpeechTurnInput, HandleTurnInput, RunAndPersistAgentResponseInput, RunAndPersistAgentResponseResult } from "../../domain/turnTypes.js";
+import type { HandleEditTurnInput, HandleSpeechTurnInput, HandleTurnInput, RunAndPersistAgentResponseInput, RunAndPersistAgentResponseResult } from "../../domain/turnTypes.js";
 import type { PluginOptions } from "../../types.js";
 export type SessionTurn = {
+    id: string;
     prompt: string;
     response: string;
 };
@@ -9,6 +10,7 @@ export type AgentEndpointsContext = {
     adminforth: IAdminForth;
     options: PluginOptions;
     handleTurn(input: HandleTurnInput): Promise<RunAndPersistAgentResponseResult>;
+    handleEditTurn(input: HandleEditTurnInput): Promise<RunAndPersistAgentResponseResult>;
     handleSpeechTurn(input: HandleSpeechTurnInput): Promise<RunAndPersistAgentResponseResult | null>;
     steer(input: {
         sessionId: string;
@@ -24,6 +26,6 @@ export type AgentEndpointsContext = {
     appendSteerToCurrentTurn(sessionId: string, steerText: string): Promise<void>;
     handleChatSurfaceMessage(adapter: ChatSurfaceAdapter, incoming: ChatSurfaceIncomingMessage, sink: ChatSurfaceEventSink): Promise<void>;
 };
-export type CoreEndpointsContext = Pick<AgentEndpointsContext, "options" | "handleTurn" | "handleSpeechTurn" | "steer">;
+export type CoreEndpointsContext = Pick<AgentEndpointsContext, "options" | "handleTurn" | "handleEditTurn" | "handleSpeechTurn" | "steer">;
 export type SessionEndpointsContext = Pick<AgentEndpointsContext, "adminforth" | "options" | "getSessionTurns" | "createNewTurn" | "createSystemTurn" | "appendSteerToCurrentTurn">;
 export type ChatSurfaceEndpointsContext = Pick<AgentEndpointsContext, "adminforth" | "options" | "handleChatSurfaceMessage">;

package/dist/transport/http/coreEndpoints.js

@@ -30,6 +30,14 @@ const agentSteerBodySchema = z.object({
     sessionId: z.string(),
     message: z.string().min(1),
 }).strict();
+const agentEditBodySchema = z.object({
+    sessionId: z.string(),
+    turnId: z.string(),
+    message: z.string().min(1),
+    mode: z.string().nullish(),
+    timeZone: z.string().optional(),
+    currentPage: currentPageContextSchema.optional(),
+}).strict();
 // Sent as multipart/form-data (via multer), so every field arrives as a plain string on the wire.
 // `currentPage` is JSON.stringify'd by the client into a form field and must be parsed back into
 // an object. Zod -> JSON-Schema conversion cannot represent `.transform()` at all (it throws), so
@@ -103,6 +111,33 @@ export function setupCoreEndpoints(ctx, server) {
             return null;
         })
     });
+    server.endpoint({
+        method: 'POST',
+        path: `/agent/edit`,
+        request_schema: agentEditBodySchema,
+        handler: (_a) => __awaiter(this, [_a], void 0, function* ({ body, adminUser, _raw_express_res, abortSignal }) {
+            var _b;
+            const data = body;
+            const emit = createSseEventEmitter(_raw_express_res, {
+                vercelAiUiMessageStream: true,
+                closeActiveBlockOnToolStart: true,
+            });
+            yield ctx.handleEditTurn({
+                prompt: data.message,
+                turnId: data.turnId,
+                sessionId: data.sessionId,
+                modeName: data.mode,
+                userTimeZone: (_b = data.timeZone) !== null && _b !== void 0 ? _b : 'UTC',
+                currentPage: data.currentPage,
+                abortSignal,
+                adminUser: adminUser,
+                emit,
+                failureLogMessage: "Agent message edit streaming failed",
+                abortLogMessage: "Agent message edit streaming aborted by the client",
+            });
+            return null;
+        })
+    });
     server.endpoint({
         method: 'POST',
         path: `/agent/approval`,

package/dist/transport/http/sessionEndpoints.js

@@ -81,6 +81,7 @@ export function setupSessionEndpoints(ctx, server) {
                             messages.push({
                                 text: turn.response,
                                 role: 'system',
+                                turnId: turn.id,
                             });
                             return messages;
                         }
@@ -88,12 +89,14 @@ export function setupSessionEndpoints(ctx, server) {
                             messages.push({
                                 text: turn.prompt,
                                 role: 'user',
+                                turnId: turn.id,
                             });
                         }
                         if (turn.response && turn.response !== "not_finished") {
                             messages.push({
                                 text: turn.response,
                                 role: 'assistant',
+                                turnId: turn.id,
                             });
                         }
                         return messages;

package/dist/transport/sse/sseWriter.js

@@ -124,6 +124,15 @@ function createAgentEventStream(res, options = {}) {
                 },
             });
         },
+        turnPersisted(sessionId, turnId) {
+            stream.send({
+                type: isAiUiMessageStream ? "data-turn-persisted" : "turn-persisted",
+                data: {
+                    sessionId,
+                    turnId,
+                },
+            });
+        },
         response(text, sessionId, turnId) {
             stream.send({
                 type: isAiUiMessageStream ? "data-response" : "response",
@@ -240,6 +249,9 @@ export function createSseEventEmitter(res, options = {}) {
             case "transcript":
                 stream.transcript(event.text, event.language);
                 break;
+            case "turn-persisted":
+                stream.turnPersisted(event.sessionId, event.turnId);
+                break;
             case "response":
                 stream.response(event.text, event.sessionId, event.turnId);
                 break;

package/dist/types.d.ts

@@ -21,6 +21,7 @@ interface ITurnResource {
     promptField: string;
     responseField: string;
     debugField?: string;
+    checkpointIdField?: string;
 }
 interface ICheckpointResource {
     resourceId: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adminforth/agent",
-  "version": "2.2.5",
+  "version": "2.3.1",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",