@adminforth/agent 2.5.10 → 2.7.0

package/dist/application/ports.d.ts

@@ -25,6 +25,7 @@ export type AgentModeCompletionAdapter = CompletionAdapter & {
  */
 export type LlmStreamInput = {
     completionAdapter: AgentModeCompletionAdapter;
+    systemPrompt: string;
     input: {
         messages: AgentMessage[];
     } | {

package/dist/application/runTurnUseCase.d.ts

@@ -60,6 +60,7 @@ export type RunTurnUseCaseDeps = {
 export declare class RunTurnUseCase {
     private readonly deps;
     private readonly pendingInterrupts;
+    private readonly lastDetectedLanguage;
     constructor(deps: RunTurnUseCaseDeps);
     private resolveMode;
     private buildContext;
@@ -78,6 +79,7 @@ export declare class RunTurnUseCase {
      */
     private prepareEditTurn;
     private prepareTurn;
+    private resolveUserLanguage;
     private buildMessages;
     private handleInterrupt;
     private runAgentTurn;

package/dist/application/runTurnUseCase.js

@@ -17,7 +17,6 @@ var __asyncValues = (this && this.__asyncValues) || function (o) {
 import { logger, Filters } from "adminforth";
 import { randomUUID } from "crypto";
 import { VegaLiteStreamBuffer } from "../domain/vegaLiteStreamBuffer.js";
-import { buildAgentTurnSystemPrompt } from "../domain/systemPrompt.js";
 import { getErrorMessage, isAbortError } from "../shared/errors.js";
 function getApprovalDecision(input) {
     return "approvalDecision" in input
@@ -77,6 +76,7 @@ export class RunTurnUseCase {
     constructor(deps) {
         this.deps = deps;
         this.pendingInterrupts = new Map();
+        this.lastDetectedLanguage = new Map();
     }
     resolveMode(modeName) {
         var _a;
@@ -175,6 +175,7 @@ export class RunTurnUseCase {
             // Editing supersedes any in-flight turn state for this session.
             this.deps.steerBuffer.clear(input.sessionId);
             this.pendingInterrupts.delete(input.sessionId);
+            this.lastDetectedLanguage.delete(input.sessionId);
             // Apply the edit + truncate (deletes later turns first, then rewrites the edited turn).
             yield this.deps.sessions.editTurnAndTruncateAfter({
                 sessionId: input.sessionId,
@@ -239,9 +240,13 @@ export class RunTurnUseCase {
             };
         });
     }
-    buildMessages(prepared) {
+    resolveUserLanguage(prepared) {
         return __awaiter(this, void 0, void 0, function* () {
-            const userLanguage = yield this.deps.llm
+            var _a;
+            if (prepared.resume) {
+                return (_a = this.lastDetectedLanguage.get(prepared.sessionId)) !== null && _a !== void 0 ? _a : null;
+            }
+            const detected = yield this.deps.llm
                 .detectLanguage({
                 completionAdapter: prepared.mode.completionAdapter,
                 prompt: prepared.prompt,
@@ -255,20 +260,13 @@ export class RunTurnUseCase {
                 logger.warn(`Failed to detect user language: ${getErrorMessage(error)}`);
                 return null;
             });
-            const adminforth = this.deps.getAdminforth();
-            const systemPrompt = buildAgentTurnSystemPrompt({
-                agentSystemPrompt: yield this.deps.getAgentSystemPrompt(),
-                adminUser: prepared.context.adminUser,
-                usernameField: adminforth.config.auth.usernameField,
-                userLanguage,
-                chatSurface: prepared.context.chatSurface,
-            });
-            return [
-                { role: "system", content: systemPrompt },
-                { role: "user", content: prepared.prompt },
-            ];
+            this.lastDetectedLanguage.set(prepared.sessionId, detected);
+            return detected;
         });
     }
+    buildMessages(prepared) {
+        return [{ role: "user", content: prepared.prompt }];
+    }
     handleInterrupt(prepared, interrupt, descriptors) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, _b, _c;
@@ -290,6 +288,7 @@ export class RunTurnUseCase {
     runAgentTurn(prepared) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, e_1, _b, _c;
+            const userLanguage = yield this.resolveUserLanguage(prepared);
             const streamInput = prepared.resume
                 ? {
                     resume: buildResumeValue({
@@ -298,11 +297,12 @@ export class RunTurnUseCase {
                         prompt: prepared.prompt,
                     }),
                 }
-                : { messages: yield this.buildMessages(prepared) };
+                : { messages: this.buildMessages(prepared) };
             const stream = yield this.deps.llm.streamTurn({
                 completionAdapter: prepared.mode.completionAdapter,
+                systemPrompt: yield this.deps.getAgentSystemPrompt(),
                 input: streamInput,
-                context: prepared.context,
+                context: Object.assign(Object.assign({}, prepared.context), { userLanguage }),
                 observability: prepared.observability,
                 branchFromCheckpointId: prepared.branchFromCheckpointId,
             });
@@ -353,6 +353,9 @@ export class RunTurnUseCase {
                 // done and leftover (unconsumed) steers must not leak into the next turn.
                 if (!interrupted) {
                     this.deps.steerBuffer.clear(prepared.sessionId);
+                    // The detected language is only needed to bridge an interrupt -> resume; once
+                    // the turn is done the next one re-detects.
+                    this.lastDetectedLanguage.delete(prepared.sessionId);
                 }
                 if (!this.deps.hasPersistentCheckpointer && !interrupted) {
                     this.pendingInterrupts.delete(prepared.sessionId);

package/dist/custom/composables/agentStore/useAgentChat.ts

@@ -134,6 +134,11 @@ export function createAgentChatManager({
   }
 
   function handleManualApprovalStreamPart(dataPart: any) {
+    if (dataPart?.type === 'error') {
+      const error = dataPart.errorText ?? dataPart.error;
+      throw new Error(typeof error === 'string' && error ? error : 'Agent approval failed');
+    }
+
     if (dataPart?.type === 'text-delta' && typeof dataPart.delta === 'string') {
       appendTextDelta(dataPart.delta);
       return;
@@ -344,6 +349,7 @@ export function createAgentChatManager({
       body: JSON.stringify({
         sessionId,
         decision,
+        mode: activeModeName.value,
       }),
     });
 

package/dist/custom/composables/useAgentStore.ts

@@ -161,6 +161,7 @@ export const useAgentStore = defineStore('agent', () => {
 
     if (approvalPart?.data) {
       approvalPart.data.status = 'processing';
+      approvalPart.data.error = undefined;
     }
 
     try {
@@ -172,6 +173,7 @@ export const useAgentStore = defineStore('agent', () => {
     } catch (error) {
       if (approvalPart?.data) {
         approvalPart.data.status = 'pending';
+        approvalPart.data.error = error instanceof Error ? error.message : String(error);
       }
       console.error('Error submitting tool approval', error);
     }

package/dist/custom/conversation_area/ToolApprovalRenderer.vue

@@ -70,6 +70,12 @@
             {{ data.status === 'processing' ? $t('Processing') : data.status === 'approved' ? $t('Approved') : $t('Rejected') }}
           </span>
         </div>
+        <p
+          v-if="data.error"
+          class="mt-3 text-sm leading-5 text-red-600 dark:text-red-400"
+        >
+          {{ data.error }}
+        </p>
       </div>
     </div>
   </div>

package/dist/domain/systemPrompt.d.ts

@@ -2,11 +2,10 @@ import type { AdminUser, IAdminForth } from "adminforth";
 import type { DetectedLanguage } from "./languageDetect.js";
 export declare const DEFAULT_AGENT_SYSTEM_PROMPT: string;
 export declare function appendCustomSystemPrompt(systemPrompt: string, customSystemPrompt?: string): string;
-export declare function buildAgentTurnSystemPrompt(input: {
-    agentSystemPrompt: string;
+export declare function buildDynamicSystemPrompt(input: {
     adminUser: AdminUser;
     usernameField: string;
-    userLanguage: DetectedLanguage | null;
+    userLanguage?: DetectedLanguage | null;
     chatSurface?: string;
 }): string;
 export declare function buildAgentSystemPrompt(adminforth: IAdminForth, hiddenResourceIds?: Iterable<string>): Promise<string>;

package/dist/domain/systemPrompt.js

@@ -51,14 +51,14 @@ function formatAdminUserPrompt(adminUser, usernameField) {
         "Use this admin user email when the user asks to send information to themselves, the current admin, or the logged-in user.",
     ].join("\n");
 }
-export function buildAgentTurnSystemPrompt(input) {
+export function buildDynamicSystemPrompt(input) {
+    var _a;
     return [
-        input.agentSystemPrompt,
         formatAdminUserPrompt(input.adminUser, input.usernameField),
         input.chatSurface
             ? `Current chat surface: ${input.chatSurface}. The user is not in the AdminForth web UI, so tools cannot move their browser. When navigate_user returns a link, send that link to the user.`
             : "",
-        formatLanguagePrompt(input.userLanguage),
+        formatLanguagePrompt((_a = input.userLanguage) !== null && _a !== void 0 ? _a : null),
     ].filter(Boolean).join("\n\n");
 }
 function formatResources(resources) {

package/dist/domain/turnTypes.d.ts

@@ -1,4 +1,5 @@
 import type { AdminUser, AudioAdapter } from "adminforth";
+import type { DetectedLanguage } from "./languageDetect.js";
 import type { CurrentPageContext } from "../tools/getUserLocation.js";
 import type { AgentEventEmitter } from "./agentEvents.js";
 /**
@@ -53,6 +54,7 @@ export type AgentTurnContext = {
     currentPage?: CurrentPageContext;
     chatSurface?: string;
     adminPublicOrigin?: string;
+    userLanguage?: DetectedLanguage | null;
 };
 export type AgentTurnObservability = {
     emit?: AgentEventEmitter;
@@ -76,12 +78,8 @@ export type HandleSpeechTurnInput = SpeechAgentTurnInput;
 export type HandleEditTurnInput = TextAgentTurnInput & {
     turnId: string;
 };
-/**
- * Provider-agnostic message passed from the application layer to the LLM port.
- * The infrastructure adapter maps it onto concrete LangChain messages.
- */
 export type AgentMessage = {
-    role: "system" | "user";
+    role: "user";
     content: string;
 };
 /**

package/dist/llm/agentContext.d.ts

@@ -4,6 +4,7 @@ import type { AgentEventEmitter } from "../domain/agentEvents.js";
 import type { SequenceDebugCollector } from "./middleware/sequenceDebug.js";
 import type { CurrentPageContext } from "../tools/getUserLocation.js";
 import type { AgentTurnContext } from "../domain/turnTypes.js";
+import type { DetectedLanguage } from "../domain/languageDetect.js";
 export declare const contextSchema: z.ZodObject<{
     adminUser: z.ZodCustom<AdminUser, AdminUser>;
     userTimeZone: z.ZodString;
@@ -14,9 +15,11 @@ export declare const contextSchema: z.ZodObject<{
     chatSurface: z.ZodOptional<z.ZodString>;
     adminBaseUrl: z.ZodOptional<z.ZodString>;
     adminPublicOrigin: z.ZodOptional<z.ZodString>;
+    userLanguage: z.ZodOptional<z.ZodCustom<DetectedLanguage | null, DetectedLanguage | null>>;
     emit: z.ZodOptional<z.ZodCustom<AgentEventEmitter, AgentEventEmitter>>;
     sequenceDebugSink: z.ZodCustom<SequenceDebugCollector, SequenceDebugCollector>;
 }, z.core.$strip>;
+export type AgentContext = z.infer<typeof contextSchema>;
 export declare function toLangchainAgentContext(context: AgentTurnContext & {
     adminBaseUrl: string;
     emit?: AgentEventEmitter;

package/dist/llm/agentContext.js

@@ -9,6 +9,7 @@ export const contextSchema = z.object({
     chatSurface: z.string().optional(),
     adminBaseUrl: z.string().optional(),
     adminPublicOrigin: z.string().optional(),
+    userLanguage: z.custom().optional(),
     emit: z.custom().optional(),
     sequenceDebugSink: z.custom(),
 });

package/dist/llm/agentModels.d.ts

@@ -16,6 +16,7 @@ export type AgentTurnModels = {
 };
 export type AgentRuntimeRunInput = {
     models: AgentTurnModels;
+    systemPrompt: string;
     input: {
         messages: Messages;
     } | Command;

package/dist/llm/agentRuntime.js

@@ -7,12 +7,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { createAgent, summarizationMiddleware, humanInTheLoopMiddleware } from "langchain";
+import { createAgent, summarizationMiddleware, humanInTheLoopMiddleware, dynamicSystemPromptMiddleware, } from "langchain";
 import { createApiBasedToolsMiddleware } from "./middleware/apiToolsMiddleware.js";
 import { createSequenceDebugMiddleware } from "./middleware/sequenceDebug.js";
 import { createSteerMiddleware } from "./middleware/steerMiddleware.js";
 import { createAgentLlmMetricsLogger } from "./agentModels.js";
 import { contextSchema, toLangchainAgentContext } from "./agentContext.js";
+import { createLegacySystemMessagesMiddleware } from "./middleware/legacySystemMessages.js";
+import { buildDynamicSystemPrompt } from "../domain/systemPrompt.js";
 function createHumanInTheLoopInterrupts(apiBasedTools) {
     return Object.fromEntries(Object.entries(apiBasedTools)
         .filter(([, apiBasedTool]) => { var _a; return ((_a = apiBasedTool.agent) === null || _a === void 0 ? void 0 : _a.isDangerous) === true; })
@@ -43,10 +45,20 @@ export class AgentRuntime {
                 descriptionPrefix: "Tool execution pending approval",
             });
             const steerMiddleware = createSteerMiddleware(this.options.steerBuffer);
+            const legacySystemMessagesMiddleware = createLegacySystemMessagesMiddleware();
+            const usernameField = adminforth.config.auth.usernameField;
+            const dynamicPromptMiddleware = dynamicSystemPromptMiddleware((_state, runtime) => buildDynamicSystemPrompt({
+                adminUser: runtime.context.adminUser,
+                usernameField,
+                userLanguage: runtime.context.userLanguage,
+                chatSurface: runtime.context.chatSurface,
+            }));
             const middleware = [
                 steerMiddleware,
                 apiBasedToolsMiddleware,
                 hitlMiddleware,
+                legacySystemMessagesMiddleware,
+                dynamicPromptMiddleware,
                 ...((_a = input.models.modelMiddleware) !== null && _a !== void 0 ? _a : []),
                 sequenceDebugMiddleware,
                 summarizationMiddleware({
@@ -58,6 +70,11 @@ export class AgentRuntime {
             const agent = createAgent({
                 name: this.options.name,
                 model: input.models.model,
+                // Passed as a plain string on purpose: LangChain normalizes it to a single text
+                // block, and DynamicSystemPromptMiddleware appends the per-turn half as a second
+                // one. That block split is all the agent owes the provider — whether the boundary
+                // becomes a cache breakpoint is the adapter's call.
+                systemPrompt: input.systemPrompt,
                 checkpointer: this.options.getCheckpointer(),
                 tools,
                 contextSchema,

package/dist/llm/langGraphLlm.js

@@ -8,13 +8,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { Command } from "@langchain/langgraph";
-import { HumanMessage, SystemMessage } from "langchain";
+import { HumanMessage } from "langchain";
 import { detectUserLanguage } from "../domain/languageDetect.js";
 import { adaptRawStream, normalizeInterrupts } from "./streamAdapter.js";
 function toLangchainMessages(messages) {
-    return messages.map((message) => message.role === "system"
-        ? new SystemMessage(message.content)
-        : new HumanMessage(message.content));
+    return messages.map((message) => new HumanMessage(message.content));
 }
 /**
  * LangChain/LangGraph implementation of {@link LlmPort}. This is the single
@@ -34,6 +32,7 @@ export class LangGraphLlm {
                 : { messages: toLangchainMessages(input.input.messages) };
             const rawStream = yield this.runtime.stream({
                 models,
+                systemPrompt: input.systemPrompt,
                 input: runtimeInput,
                 context: input.context,
                 observability: input.observability,

package/dist/llm/middleware/legacySystemMessages.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Migration shield for threads checkpointed before the system prompt moved out of the
+ * message history.
+ *
+ * Turns used to be started with `[SystemMessage, HumanMessage]`, so every such turn left
+ * a system message inside the thread's persisted state. Those messages are still in old
+ * checkpoints and would now arrive mid-history — both an invalid shape for providers that
+ * take the system prompt out-of-band, and a stale duplicate of a prompt the agent already
+ * supplies. So they are dropped, not re-hoisted: the authoritative prompt is
+ * `createAgent({ systemPrompt })` plus DynamicSystemPromptMiddleware.
+ *
+ * Nothing writes system messages into state any more, so for new threads this is a no-op.
+ * It stays as a cheap guard (and can be deleted once no pre-refactor checkpoints remain).
+ */
+export declare function createLegacySystemMessagesMiddleware(): import("langchain").AgentMiddleware<undefined, undefined, unknown, readonly (import("@langchain/core/tools").ClientTool | import("@langchain/core/tools").ServerTool)[]>;

package/dist/llm/middleware/legacySystemMessages.js

@@ -0,0 +1,45 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { createMiddleware } from "langchain";
+function isSystemMessage(message) {
+    var _a, _b;
+    return (((_a = message._getType) === null || _a === void 0 ? void 0 : _a.call(message)) === "system" ||
+        ((_b = message.getType) === null || _b === void 0 ? void 0 : _b.call(message)) === "system" ||
+        message.type === "system");
+}
+/**
+ * Migration shield for threads checkpointed before the system prompt moved out of the
+ * message history.
+ *
+ * Turns used to be started with `[SystemMessage, HumanMessage]`, so every such turn left
+ * a system message inside the thread's persisted state. Those messages are still in old
+ * checkpoints and would now arrive mid-history — both an invalid shape for providers that
+ * take the system prompt out-of-band, and a stale duplicate of a prompt the agent already
+ * supplies. So they are dropped, not re-hoisted: the authoritative prompt is
+ * `createAgent({ systemPrompt })` plus DynamicSystemPromptMiddleware.
+ *
+ * Nothing writes system messages into state any more, so for new threads this is a no-op.
+ * It stays as a cheap guard (and can be deleted once no pre-refactor checkpoints remain).
+ */
+export function createLegacySystemMessagesMiddleware() {
+    return createMiddleware({
+        name: "LegacySystemMessagesMiddleware",
+        wrapModelCall(request, handler) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const typed = request;
+                const messages = typed.messages.filter((message) => !isSystemMessage(message));
+                if (messages.length === typed.messages.length) {
+                    return handler(request);
+                }
+                return handler(Object.assign(Object.assign({}, request), { messages }));
+            });
+        },
+    });
+}

package/dist/persistence/checkpointStore.d.ts

@@ -7,6 +7,11 @@ export declare class AdminForthCheckpointSaver extends BaseCheckpointSaver {
     constructor(adminforth: any, pluginOptions: PluginOptions);
     private get resourceConfig();
     private resource;
+    /**
+     * Checkpoints contain LangChain message instances. Plain JSON.stringify loses
+     * their constructors, so a resumed HITL middleware cannot recognize AIMessage
+     * tool calls. Use LangGraph's serializer, which preserves those constructors.
+     */
     private serialize;
     private deserialize;
     private now;

package/dist/persistence/checkpointStore.js

@@ -39,18 +39,28 @@ export class AdminForthCheckpointSaver extends BaseCheckpointSaver {
     resource() {
         return this.adminforth.resource(this.resourceConfig.resourceId);
     }
+    /**
+     * Checkpoints contain LangChain message instances. Plain JSON.stringify loses
+     * their constructors, so a resumed HITL middleware cannot recognize AIMessage
+     * tool calls. Use LangGraph's serializer, which preserves those constructors.
+     */
     serialize(value) {
-        if (value === undefined || value === null)
-            return null;
-        return JSON.stringify(value);
+        return __awaiter(this, void 0, void 0, function* () {
+            if (value === undefined || value === null)
+                return null;
+            const [encoding, payload] = yield this.serde.dumpsTyped(value);
+            if (encoding !== "json") {
+                throw new Error(`Unsupported checkpoint payload encoding "${encoding}".`);
+            }
+            return new TextDecoder().decode(payload);
+        });
     }
     deserialize(value) {
-        if (value === undefined || value === null)
-            return null;
-        if (typeof value === "string") {
-            return JSON.parse(value);
-        }
-        return value;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (value === undefined || value === null)
+                return null;
+            return this.serde.loadsTyped("json", typeof value === "string" ? value : JSON.stringify(value));
+        });
     }
     now() {
         return new Date().toISOString();
@@ -112,8 +122,8 @@ export class AdminForthCheckpointSaver extends BaseCheckpointSaver {
                 [r.taskIdField]: null,
                 [r.sequenceField]: 0,
                 [r.createdAtField]: createdAt,
-                [r.checkpointPayloadField]: this.serialize(checkpoint),
-                [r.metadataPayloadField]: this.serialize(metadata),
+                [r.checkpointPayloadField]: yield this.serialize(checkpoint),
+                [r.metadataPayloadField]: yield this.serialize(metadata),
                 [r.writesPayloadField]: null,
                 [r.schemaVersionField]: 1,
             });
@@ -144,7 +154,7 @@ export class AdminForthCheckpointSaver extends BaseCheckpointSaver {
                         [r.createdAtField]: createdAt,
                         [r.checkpointPayloadField]: null,
                         [r.metadataPayloadField]: null,
-                        [r.writesPayloadField]: this.serialize([channel, value]),
+                        [r.writesPayloadField]: yield this.serialize([channel, value]),
                         [r.schemaVersionField]: 1,
                     });
                 }
@@ -171,23 +181,23 @@ export class AdminForthCheckpointSaver extends BaseCheckpointSaver {
             }
             const resolvedCheckpointId = String(checkpointRow[r.checkpointIdField]);
             const writesRows = yield this.resource().list(Filters.AND(Filters.EQ(r.threadIdField, threadId), Filters.EQ(r.checkpointNamespaceField, storedCheckpointNs), Filters.EQ(r.checkpointIdField, resolvedCheckpointId), Filters.EQ(r.rowKindField, "writes")), undefined, undefined, [{ field: r.sequenceField, direction: "asc" }]);
-            const pendingWrites = writesRows.flatMap((row) => {
+            const pendingWrites = (yield Promise.all(writesRows.map((row) => __awaiter(this, void 0, void 0, function* () {
                 var _a;
                 const taskId = String((_a = row[r.taskIdField]) !== null && _a !== void 0 ? _a : "");
-                const write = this.deserialize(row[r.writesPayloadField]);
+                const write = yield this.deserialize(row[r.writesPayloadField]);
                 if (!write) {
                     return [];
                 }
                 const [channel, value] = write;
                 return [[taskId, channel, value]];
-            });
+            })))).flat();
             const parentCheckpointId = checkpointRow[r.parentCheckpointIdField]
                 ? String(checkpointRow[r.parentCheckpointIdField])
                 : null;
             const tuple = {
                 config: this.buildConfig(threadId, checkpointNs, resolvedCheckpointId),
-                checkpoint: this.deserialize(checkpointRow[r.checkpointPayloadField]),
-                metadata: ((_a = this.deserialize(checkpointRow[r.metadataPayloadField])) !== null && _a !== void 0 ? _a : {}),
+                checkpoint: yield this.deserialize(checkpointRow[r.checkpointPayloadField]),
+                metadata: ((_a = yield this.deserialize(checkpointRow[r.metadataPayloadField])) !== null && _a !== void 0 ? _a : {}),
                 parentConfig: parentCheckpointId
                     ? this.buildConfig(threadId, checkpointNs, parentCheckpointId)
                     : undefined,

package/dist/transport/http/coreEndpoints.js

@@ -25,6 +25,7 @@ const agentResponseBodySchema = z.object({
 const agentApprovalBodySchema = z.object({
     sessionId: z.string(),
     decision: z.enum(["approve", "reject"]),
+    mode: z.string().nullish(),
 }).strict();
 const agentSteerBodySchema = z.object({
     sessionId: z.string(),
@@ -151,6 +152,7 @@ export function setupCoreEndpoints(ctx, server) {
             yield ctx.handleTurn({
                 prompt: "",
                 sessionId: data.sessionId,
+                modeName: data.mode,
                 approvalDecision: data.decision,
                 abortSignal,
                 adminUser: adminUser,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adminforth/agent",
-  "version": "2.5.10",
+  "version": "2.7.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",
@@ -44,11 +44,11 @@
     "typescript": "^5.7.3"
   },
   "dependencies": {
-    "@langchain/core": "^1.1.40",
-    "@langchain/langgraph": "^1.2.8",
-    "@langchain/langgraph-checkpoint": "^1.0.1",
+    "@langchain/core": "1.2.5",
+    "@langchain/langgraph": "1.2.8",
+    "@langchain/langgraph-checkpoint": "1.0.1",
     "dayjs": "^1.11.20",
-    "langchain": "^1.3.3",
+    "langchain": "1.3.3",
     "multer": "^2.1.1",
     "vue-i18n": "^11.4.0",
     "yaml": "^2.8.3",