@adminforth/agent 1.51.1 → 1.52.1

package/dist/agent/middleware/apiBasedTools.js

@@ -8,12 +8,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { ToolMessage } from "@langchain/core/messages";
+import { isGraphInterrupt } from "@langchain/langgraph";
 import { createMiddleware } from "langchain";
 import { logger } from "adminforth";
 import { formatApiBasedToolCall, } from "../../apiBasedTools.js";
 import { createToolCallTracker, } from "../toolCallEvents.js";
 import { ALWAYS_AVAILABLE_API_TOOL_NAMES } from "../tools/index.js";
 import { createApiTool } from "../tools/apiTool.js";
+import { isAbortError } from "../../errors.js";
 function getEnabledApiToolNames(messages) {
     const enabledToolNames = new Set();
     for (const message of messages) {
@@ -62,10 +64,14 @@ export function createApiBasedToolsMiddleware(apiBasedTools, adminforth) {
         },
         wrapToolCall(request, handler) {
             return __awaiter(this, void 0, void 0, function* () {
-                var _a, _b, _c, _d;
+                var _a, _b, _c;
                 const startedAt = Date.now();
                 const toolInput = JSON.stringify((_a = request.toolCall.args) !== null && _a !== void 0 ? _a : {});
-                const { adminUser, emit, sequenceDebugSink, userTimeZone } = request.runtime.context;
+                if (!request.toolCall.id) {
+                    throw new Error(`Tool call "${request.toolCall.name}" has no id.`);
+                }
+                const toolCallId = request.toolCall.id;
+                const { adminUser, abortSignal, emit, sequenceDebugSink, userTimeZone } = request.runtime.context;
                 const emitToolCall = (event) => {
                     sequenceDebugSink.handleToolCallEvent(event);
                     void (emit === null || emit === void 0 ? void 0 : emit({
@@ -92,7 +98,7 @@ export function createApiBasedToolsMiddleware(apiBasedTools, adminforth) {
                 }
                 const toolCallTracker = createToolCallTracker({
                     emit: emitToolCall,
-                    toolCallId: request.toolCall.id,
+                    toolCallId,
                     toolName: request.toolCall.name,
                     toolInfo,
                     input: toolArgs,
@@ -101,32 +107,27 @@ export function createApiBasedToolsMiddleware(apiBasedTools, adminforth) {
                 toolCallTracker.start();
                 logger.info(`Invoking tool "${request.toolCall.name}" with input: ${toolInput}`);
                 try {
-                    let result;
-                    if (request.tool) {
-                        result = yield handler(request);
-                    }
-                    else {
-                        const enabledApiToolNames = getEnabledApiToolNames(request.state.messages);
-                        if (enabledApiToolNames.has(request.toolCall.name)) {
-                            result = yield handler(Object.assign(Object.assign({}, request), { tool: dynamicTools[request.toolCall.name] }));
-                        }
-                        else {
-                            result = new ToolMessage({
-                                content: `Tool "${request.toolCall.name}" is not loaded. Call fetch_tool_schema first.`,
-                                tool_call_id: (_c = request.toolCall.id) !== null && _c !== void 0 ? _c : "",
-                                name: request.toolCall.name,
-                                status: "error",
-                            });
-                        }
-                    }
+                    const result = getEnabledApiToolNames(request.state.messages).has(request.toolCall.name)
+                        ? yield handler(Object.assign(Object.assign({}, request), { tool: dynamicTools[request.toolCall.name] }))
+                        : yield handler(request);
                     toolCallTracker.finishSuccess(result);
                     return result;
                 }
                 catch (error) {
-                    const errorDetails = error instanceof Error ? (_d = error.stack) !== null && _d !== void 0 ? _d : error.message : String(error);
-                    logger.error(`Tool "${request.toolCall.name}" failed after ${Date.now() - startedAt}ms with input: ${toolInput}\n${errorDetails}`);
-                    toolCallTracker.finishError(error);
-                    throw error;
+                    if (isGraphInterrupt(error)
+                        || (abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.aborted)
+                        || isAbortError(error)) {
+                        throw error;
+                    }
+                    const message = error instanceof Error ? error.message : String(error);
+                    logger.error(`Error calling tool "${request.toolCall.name}": ${error instanceof Error ? (_c = error.stack) !== null && _c !== void 0 ? _c : error.message : String(error)}`);
+                    toolCallTracker.finishError(`Error: ${message}`);
+                    return new ToolMessage({
+                        name: request.toolCall.name,
+                        tool_call_id: toolCallId,
+                        status: "error",
+                        content: `Error: ${message}`,
+                    });
                 }
                 finally {
                     logger.info(`Tool "${request.toolCall.name}" finished in ${Date.now() - startedAt}ms`);

package/dist/agent/runtime/AgentRuntime.d.ts

@@ -11,5 +11,5 @@ export type AgentRuntimeOptions = {
 export declare class AgentRuntime {
     private readonly options;
     constructor(options: AgentRuntimeOptions);
-    stream(input: AgentRuntimeRunInput): Promise<import("@langchain/core/utils/stream").IterableReadableStream<[import("langchain").BaseMessage<import("@langchain/core/messages").MessageStructure<import("@langchain/core/messages").MessageToolSet>, import("@langchain/core/messages").MessageType>, Record<string, any>]>>;
+    stream(input: AgentRuntimeRunInput): Promise<import("@langchain/core/utils/stream").IterableReadableStream<["messages", [import("langchain").BaseMessage<import("@langchain/core/messages").MessageStructure<import("@langchain/core/messages").MessageToolSet>, import("@langchain/core/messages").MessageType>, Record<string, any>]] | ["updates", Record<string, Omit<import("langchain").BuiltInState<import("@langchain/core/messages").MessageStructure<import("langchain").ToolsToMessageToolSet<readonly (import("@langchain/core/tools").ClientTool | import("@langchain/core/tools").ServerTool)[]>>>, "jumpTo">>]>>;
 }

package/dist/agent/runtime/AgentRuntime.js

@@ -7,11 +7,21 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { createAgent, summarizationMiddleware } from "langchain";
+import { createAgent, summarizationMiddleware, humanInTheLoopMiddleware } from "langchain";
 import { createApiBasedToolsMiddleware } from "../middleware/apiBasedTools.js";
 import { createSequenceDebugMiddleware } from "../middleware/sequenceDebug.js";
 import { createAgentLlmMetricsLogger } from "../simpleAgent.js";
 import { contextSchema, toLangchainAgentContext } from "./AgentContext.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; })
+        .map(([toolName]) => [
+        toolName,
+        {
+            allowedDecisions: ["approve", "reject"],
+        },
+    ]));
+}
 export class AgentRuntime {
     constructor(options) {
         this.options = options;
@@ -24,8 +34,13 @@ export class AgentRuntime {
             const adminforth = this.options.getAdminforth();
             const apiBasedToolsMiddleware = createApiBasedToolsMiddleware(apiBasedTools, adminforth);
             const sequenceDebugMiddleware = createSequenceDebugMiddleware(input.observability.sequenceDebugSink);
+            const hitlMiddleware = humanInTheLoopMiddleware({
+                interruptOn: createHumanInTheLoopInterrupts(apiBasedTools),
+                descriptionPrefix: "Tool execution pending approval",
+            });
             const middleware = [
                 apiBasedToolsMiddleware,
+                hitlMiddleware,
                 ...((_a = input.models.modelMiddleware) !== null && _a !== void 0 ? _a : []),
                 sequenceDebugMiddleware,
                 summarizationMiddleware({
@@ -42,8 +57,8 @@ export class AgentRuntime {
                 contextSchema,
                 middleware,
             });
-            return agent.stream({ messages: input.messages }, {
-                streamMode: "messages",
+            return agent.stream(input.input, {
+                streamMode: ["messages", "updates"],
                 recursionLimit: 100,
                 callbacks: [createAgentLlmMetricsLogger()],
                 signal: input.context.abortSignal,

package/dist/agent/systemPrompt.js

@@ -24,11 +24,8 @@ export const DEFAULT_AGENT_SYSTEM_PROMPT = [
     "Do not add extra explanations or suggestions unless the user asks.",
     "Adapt to the user's tone and style of speaking, mirroring their vibe and wording.",
     "if the user speaks casually, you should respond casually too",
-    "Never mutate data without user confirmation for a clearly described mutation plan.",
-    "One confirmation may cover one mutation or one explicitly described batch/sequence of related mutations.",
-    "If the confirmed plan has multiple steps, you may execute the whole confirmed plan without asking again between those steps.",
-    "If the plan changes, expands, or you want to do anything beyond the confirmed plan, ask for confirmation again.",
-    "Do not reuse an old confirmation for a new mutation plan.",
+    "Before calling a dangerous tool, briefly describe the exact action, target, and important changes in chat.",
+    "Do not ask the user for textual confirmation; dangerous tools are approved by the runtime approval UI.",
 ].join(" ");
 export function appendCustomSystemPrompt(systemPrompt, customSystemPrompt) {
     const normalizedCustomSystemPrompt = customSystemPrompt === null || customSystemPrompt === void 0 ? void 0 : customSystemPrompt.trim();
@@ -98,7 +95,7 @@ export function buildAgentSystemPrompt(adminforth_1) {
             "If the user wants to fetch records, load fetch_data first. If the user wants analytics or charts, load analyze_data first.",
             "Only call fetch_tool_schema for tool names that are explicitly mentioned in a fetched skill and are not already available as base tools.",
             "If a fetched skill lists a non-base tool you need, call fetch_tool_schema for it immediately instead of telling the user the tool is unavailable.",
-            "For example: for record creation load mutate_data, read its tool list, call fetch_tool_schema for create_record, and then use create_record after confirmation.",
+            "For example: for record creation load mutate_data, read its tool list, call fetch_tool_schema for create_record, describe the planned record, and then use create_record.",
             "When fetch_tool_schema succeeds, that tool becomes available on the next step.",
             "All admin links must be root-relative and start with '/'.",
             "Build record links as '/resource/{resourceId}/show/{primary key}'. Never use bare 'resource/{resourceId}/show/{primary key}' without the leading slash.",

package/dist/agent/turn/TurnLifecycleService.d.ts

@@ -1,14 +1,21 @@
 import type { AgentSessionStore } from "../../sessionStore.js";
+import type { PluginOptions } from "../../types.js";
 import type { BaseAgentTurnInput } from "./turnTypes.js";
 import { TurnPersistenceService } from "./TurnPersistenceService.js";
 export declare class TurnLifecycleService {
     private readonly sessionStore;
     private readonly persistence;
-    constructor(sessionStore: AgentSessionStore, persistence: TurnPersistenceService);
+    private readonly options;
+    constructor(sessionStore: AgentSessionStore, persistence: TurnPersistenceService, options: PluginOptions);
     start(input: BaseAgentTurnInput): Promise<{
         turnId: any;
         previousUserMessages: import("../languageDetect.js").PreviousUserMessage[];
     }>;
+    resume(input: BaseAgentTurnInput): Promise<{
+        turnId: any;
+        previousUserMessages: import("../languageDetect.js").PreviousUserMessage[];
+        initialResponse: string;
+    }>;
     finish(input: {
         turnId: string;
         responseText: string;

package/dist/agent/turn/TurnLifecycleService.js

@@ -8,9 +8,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 export class TurnLifecycleService {
-    constructor(sessionStore, persistence) {
+    constructor(sessionStore, persistence, options) {
         this.sessionStore = sessionStore;
         this.persistence = persistence;
+        this.options = options;
     }
     start(input) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -23,6 +24,21 @@ export class TurnLifecycleService {
             };
         });
     }
+    resume(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const latestTurn = yield this.sessionStore.getLatestTurn(input.sessionId);
+            if (!latestTurn) {
+                throw new Error(`No agent turn found for session "${input.sessionId}".`);
+            }
+            return {
+                turnId: latestTurn[this.options.turnResource.idField],
+                previousUserMessages: yield this.sessionStore.getPreviousUserMessages(input.sessionId),
+                initialResponse: latestTurn[this.options.turnResource.responseField] === "not_finished"
+                    ? ""
+                    : String(latestTurn[this.options.turnResource.responseField]),
+            };
+        });
+    }
     finish(input) {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.persistence.saveTurnResponse(input);

package/dist/agent/turn/TurnStreamConsumer.d.ts

@@ -1,9 +1,10 @@
 import type { AgentEventEmitter } from "../../agentEvents.js";
 export declare class TurnStreamConsumer {
     consume(input: {
-        stream: AsyncIterable<[any, any]>;
+        stream: AsyncIterable<["messages", [any, any]] | ["updates", Record<string, any>]>;
         abortSignal?: AbortSignal;
         emit?: AgentEventEmitter;
+        onInterrupt?: (interrupt: unknown) => void | Promise<void>;
     }): Promise<{
         text: string;
     }>;

package/dist/agent/turn/TurnStreamConsumer.js

@@ -19,18 +19,24 @@ export class TurnStreamConsumer {
     consume(input) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, e_1, _b, _c;
-            var _d, _e;
+            var _d, _e, _f;
             let fullResponse = "";
             const textBuffer = new VegaLiteStreamBuffer();
             try {
-                for (var _f = true, _g = __asyncValues(input.stream), _h; _h = yield _g.next(), _a = _h.done, !_a; _f = true) {
-                    _c = _h.value;
-                    _f = false;
-                    const rawChunk = _c;
+                for (var _g = true, _h = __asyncValues(input.stream), _j; _j = yield _h.next(), _a = _j.done, !_a; _g = true) {
+                    _c = _j.value;
+                    _g = false;
+                    const [mode, chunk] = _c;
                     if ((_d = input.abortSignal) === null || _d === void 0 ? void 0 : _d.aborted) {
                         throw new DOMException("This operation was aborted", "AbortError");
                     }
-                    const [token, metadata] = rawChunk;
+                    if (mode === "updates") {
+                        if ("__interrupt__" in chunk) {
+                            yield ((_e = input.onInterrupt) === null || _e === void 0 ? void 0 : _e.call(input, chunk.__interrupt__));
+                        }
+                        continue;
+                    }
+                    const [token, metadata] = chunk;
                     const nodeName = typeof (metadata === null || metadata === void 0 ? void 0 : metadata.langgraph_node) === "string"
                         ? metadata.langgraph_node
                         : "";
@@ -51,7 +57,7 @@ export class TurnStreamConsumer {
                         .map((block) => { var _a; return String((_a = block.text) !== null && _a !== void 0 ? _a : ""); })
                         .join("");
                     if (reasoningDelta) {
-                        yield ((_e = input.emit) === null || _e === void 0 ? void 0 : _e.call(input, {
+                        yield ((_f = input.emit) === null || _f === void 0 ? void 0 : _f.call(input, {
                             type: "reasoning-delta",
                             delta: reasoningDelta,
                         }));
@@ -65,7 +71,7 @@ export class TurnStreamConsumer {
             catch (e_1_1) { e_1 = { error: e_1_1 }; }
             finally {
                 try {
-                    if (!_f && !_a && (_b = _g.return)) yield _b.call(_g);
+                    if (!_g && !_a && (_b = _h.return)) yield _b.call(_h);
                 }
                 finally { if (e_1) throw e_1.error; }
             }

package/dist/agent/turn/turnTypes.d.ts

@@ -1,5 +1,6 @@
 import type { AdminUser, AudioAdapter } from "adminforth";
 import type { Messages } from "@langchain/langgraph";
+import type { Command } from "@langchain/langgraph";
 import type { AgentChatModel, AgentMiddleware } from "../simpleAgent.js";
 import type { SequenceDebugCollector } from "../middleware/sequenceDebug.js";
 import type { PreviousUserMessage } from "../languageDetect.js";
@@ -18,6 +19,7 @@ export type BaseAgentTurnInput = {
 };
 export type TextAgentTurnInput = BaseAgentTurnInput & {
     emit: AgentEventEmitter;
+    approvalDecision?: "approve" | "reject";
     failureLogMessage?: string;
     abortLogMessage?: string;
 };
@@ -54,6 +56,14 @@ export type PreparedAgentTurn = {
     modeName?: string | null;
     context: AgentTurnContext;
     observability: AgentTurnObservability;
+    resume?: {
+        decision: "approve" | "reject";
+        interrupts?: {
+            id: string;
+            count: number;
+        }[];
+    };
+    initialResponse?: string;
 };
 export type AgentTurnModels = {
     model: AgentChatModel;
@@ -62,12 +72,15 @@ export type AgentTurnModels = {
 };
 export type AgentRuntimeRunInput = {
     models: AgentTurnModels;
-    messages: Messages;
+    input: {
+        messages: Messages;
+    } | Command;
     context: AgentTurnContext;
     observability: AgentTurnObservability;
 };
 export type RunAndPersistAgentResponseInput = BaseAgentTurnInput & {
     emit?: AgentEventEmitter;
+    approvalDecision?: "approve" | "reject";
     failureLogMessage: string;
     abortLogMessage: string;
 };

package/dist/agentEvents.d.ts

@@ -15,6 +15,10 @@ export type AgentEvent = {
     type: "rendering";
     phase: "start" | "end";
     label: string;
+} | {
+    type: "interrupt";
+    sessionId: string;
+    interrupt: unknown;
 } | {
     type: "open-page";
     targetPath: string;

package/dist/agentTurnService.d.ts

@@ -15,6 +15,7 @@ export declare class AgentTurnService {
     private readonly promptBuilder;
     private readonly runtime;
     private readonly streamConsumer;
+    private readonly pendingInterrupts;
     constructor(lifecycle: TurnLifecycleService, contextBuilder: TurnContextBuilder, modeResolver: AgentModeResolver, modelFactory: AgentModelFactory, promptBuilder: TurnPromptBuilder, runtime: AgentRuntime, streamConsumer: TurnStreamConsumer);
     private prepareTurn;
     private runAgentTurn;

package/dist/agentTurnService.js

@@ -9,8 +9,72 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { logger } from "adminforth";
 import { randomUUID } from "crypto";
+import { Command } from "@langchain/langgraph";
 import { createSequenceDebugCollector } from "./agent/middleware/sequenceDebug.js";
 import { getErrorMessage, isAbortError } from "./errors.js";
+function getApprovalDecision(input) {
+    return "approvalDecision" in input
+        && (input.approvalDecision === "approve" || input.approvalDecision === "reject")
+        ? input.approvalDecision
+        : undefined;
+}
+function getInterruptItems(interrupt) {
+    return Array.isArray(interrupt) ? interrupt : [interrupt];
+}
+function getHitlInterrupts(interrupt) {
+    return getInterruptItems(interrupt).flatMap((item) => {
+        const value = item && typeof item === "object" && "value" in item
+            ? item.value
+            : item;
+        const actionRequests = value && typeof value === "object"
+            ? value.actionRequests
+            : undefined;
+        const interruptId = item && typeof item === "object"
+            ? item.id
+            : undefined;
+        return typeof interruptId === "string" && Array.isArray(actionRequests)
+            ? [{ id: interruptId, count: actionRequests.length }]
+            : [];
+    });
+}
+function buildHitlDecision(decision, prompt) {
+    if (decision === "approve") {
+        return { type: "approve" };
+    }
+    return {
+        type: "reject",
+        message: prompt
+            ? `User rejected the pending tool execution and sent a new instruction instead: ${prompt}`
+            : "User rejected executing this tool",
+    };
+}
+function buildHitlResumeValue(input) {
+    return {
+        decisions: Array.from({ length: input.count }, () => (buildHitlDecision(input.decision, input.prompt))),
+    };
+}
+function buildLangGraphResume(input) {
+    var _a;
+    const interrupts = (_a = input.interrupts) !== null && _a !== void 0 ? _a : [];
+    if (interrupts.length === 0) {
+        throw new Error("No pending approval interrupt found for resume.");
+    }
+    if (interrupts.length === 1) {
+        return buildHitlResumeValue({
+            decision: input.decision,
+            count: interrupts[0].count,
+            prompt: input.prompt,
+        });
+    }
+    return Object.fromEntries(interrupts.map((interrupt) => [
+        interrupt.id,
+        buildHitlResumeValue({
+            decision: input.decision,
+            count: interrupt.count,
+            prompt: input.prompt,
+        }),
+    ]));
+}
 export class AgentTurnService {
     constructor(lifecycle, contextBuilder, modeResolver, modelFactory, promptBuilder, runtime, streamConsumer) {
         this.lifecycle = lifecycle;
@@ -20,26 +84,44 @@ export class AgentTurnService {
         this.promptBuilder = promptBuilder;
         this.runtime = runtime;
         this.streamConsumer = streamConsumer;
+        this.pendingInterrupts = new Map();
     }
     prepareTurn(input) {
         return __awaiter(this, void 0, void 0, function* () {
             const sequenceDebugCollector = createSequenceDebugCollector();
-            const { turnId, previousUserMessages } = yield this.lifecycle.start(input);
+            const approvalDecision = getApprovalDecision(input);
+            const shouldResume = Boolean(approvalDecision);
+            const pendingInterrupts = this.pendingInterrupts.get(input.sessionId);
+            if (shouldResume && (!pendingInterrupts || pendingInterrupts.length === 0)) {
+                throw new Error(`No pending approval interrupt found for session "${input.sessionId}".`);
+            }
+            const lifecycleTurn = shouldResume
+                ? yield this.lifecycle.resume(input)
+                : yield this.lifecycle.start(input);
             const context = yield this.contextBuilder.build({
                 base: input,
-                turnId,
+                turnId: lifecycleTurn.turnId,
             });
             return {
                 prompt: input.prompt,
                 sessionId: input.sessionId,
-                turnId,
-                previousUserMessages,
+                turnId: lifecycleTurn.turnId,
+                previousUserMessages: lifecycleTurn.previousUserMessages,
                 modeName: input.modeName,
                 context,
                 observability: {
                     emit: undefined,
                     sequenceDebugSink: sequenceDebugCollector,
                 },
+                resume: shouldResume
+                    ? {
+                        decision: approvalDecision,
+                        interrupts: pendingInterrupts,
+                    }
+                    : undefined,
+                initialResponse: shouldResume && "initialResponse" in lifecycleTurn
+                    ? lifecycleTurn.initialResponse
+                    : undefined,
             };
         });
     }
@@ -59,31 +141,66 @@ export class AgentTurnService {
             ]);
             const stream = yield this.runtime.stream({
                 models,
-                messages,
+                input: input.resume
+                    ? new Command({
+                        resume: buildLangGraphResume({
+                            decision: input.resume.decision,
+                            interrupts: input.resume.interrupts,
+                            prompt: input.prompt,
+                        }),
+                    })
+                    : { messages },
                 context: input.context,
                 observability: input.observability,
             });
-            return this.streamConsumer.consume({
-                stream: stream,
-                abortSignal: input.context.abortSignal,
-                emit: input.observability.emit,
-            });
+            let interrupted = false;
+            try {
+                return yield this.streamConsumer.consume({
+                    stream: stream,
+                    abortSignal: input.context.abortSignal,
+                    emit: input.observability.emit,
+                    onInterrupt: (interrupt) => __awaiter(this, void 0, void 0, function* () {
+                        var _a, _b, _c;
+                        interrupted = true;
+                        const interrupts = getHitlInterrupts(interrupt);
+                        const pendingInterrupts = (_a = this.pendingInterrupts.get(input.sessionId)) !== null && _a !== void 0 ? _a : [];
+                        const mergedInterrupts = new Map(pendingInterrupts.map((pendingInterrupt) => [
+                            pendingInterrupt.id,
+                            pendingInterrupt.count,
+                        ]));
+                        for (const pendingInterrupt of interrupts) {
+                            mergedInterrupts.set(pendingInterrupt.id, pendingInterrupt.count);
+                        }
+                        this.pendingInterrupts.set(input.sessionId, [...mergedInterrupts.entries()].map(([id, count]) => ({ id, count })));
+                        yield ((_c = (_b = input.observability).emit) === null || _c === void 0 ? void 0 : _c.call(_b, {
+                            type: "interrupt",
+                            sessionId: input.sessionId,
+                            interrupt,
+                        }));
+                    }),
+                });
+            }
+            finally {
+                if (!interrupted) {
+                    this.pendingInterrupts.delete(input.sessionId);
+                }
+            }
         });
     }
     runAndPersistAgentResponse(input) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
+            var _a, _b;
             const preparedTurn = yield this.prepareTurn(input);
             preparedTurn.observability.emit = input.emit;
-            let fullResponse = "";
+            let fullResponse = (_a = preparedTurn.initialResponse) !== null && _a !== void 0 ? _a : "";
             let aborted = false;
             let failed = false;
             try {
                 const agentResponse = yield this.runAgentTurn(preparedTurn);
-                fullResponse = agentResponse.text;
+                fullResponse += agentResponse.text;
             }
             catch (error) {
-                if (((_a = input.abortSignal) === null || _a === void 0 ? void 0 : _a.aborted) || isAbortError(error)) {
+                if (((_b = input.abortSignal) === null || _b === void 0 ? void 0 : _b.aborted) || isAbortError(error)) {
                     aborted = true;
                     logger.info(input.abortLogMessage);
                 }
@@ -122,6 +239,7 @@ export class AgentTurnService {
                 currentPage: input.currentPage,
                 chatSurface: input.chatSurface,
                 adminPublicOrigin: input.adminPublicOrigin,
+                approvalDecision: input.approvalDecision,
                 abortSignal: input.abortSignal,
                 adminUser: input.adminUser,
                 emit: input.emit,

package/dist/apiBasedTools.d.ts

@@ -1,4 +1,7 @@
 import { type AdminUser, type IAdminForth } from 'adminforth';
+type AgentToolMeta = {
+    isDangerous?: boolean;
+};
 export type ApiBasedToolCallParams = {
     adminUser?: AdminUser;
     adminuser?: AdminUser;
@@ -10,6 +13,7 @@ export type ApiBasedToolCallParams = {
 export type ApiBasedTool = {
     description?: string;
     input_schema?: unknown;
+    agent?: AgentToolMeta;
     call: (params?: ApiBasedToolCallParams) => Promise<string>;
 };
 export declare function formatApiBasedToolCall(params: {
@@ -20,3 +24,4 @@ export declare function formatApiBasedToolCall(params: {
     userTimeZone?: string;
 }): Promise<string | undefined>;
 export declare function prepareApiBasedTools(adminforth: IAdminForth, hiddenResourceIds?: Iterable<string>): Record<string, ApiBasedTool>;
+export {};

package/dist/apiBasedTools.js

@@ -410,6 +410,7 @@ export function prepareApiBasedTools(adminforth, hiddenResourceIds = []) {
         apiBasedTools[toolName] = {
             description: schema.description,
             input_schema: schema.request_schema,
+            agent: schema.agent,
             call: (...args_1) => __awaiter(this, [...args_1], void 0, function* ({ adminUser, adminuser, abortSignal, inputs, userTimeZone, acceptLanguage } = {}) {
                 if (isHiddenResourceCall(hiddenResourceIdSet, inputs)) {
                     return YAML.stringify({

package/dist/custom/ChatFooter.vue

@@ -20,7 +20,8 @@
           'min-h-12 px-4 pt-4 rounded-xl w-full resize-none overflow-hidden text-lightInputText dark:text-darkInputText rounded-md bg-transparent text-sm bg-gray-50 dark:bg-gray-700 dark:border-gray-600 focus:outline-none',
           { '!text-base': coreStore.isIos }
         ]"
-        :placeholder="agentStore.userMessagePlaceholder"
+        :placeholder="agentStore.hasPendingToolApproval ? 'Approve or reject the pending action to continue' : agentStore.userMessagePlaceholder"
+        :disabled="agentStore.isMessageInputBlocked"
         @keydown.enter.exact.prevent="sendMessage"
       />
       <div
@@ -70,7 +71,7 @@
           v-if="!agentStore.isResponseInProgress"
           class="absolute right-4 bottom-2 !p-0 h-9 w-9 transition-opacity duration-200"                    
           @click="sendMessage" 
-          :disabled="!agentStore.trimmedUserMessage || agentStore.isResponseInProgress"
+          :disabled="!agentStore.trimmedUserMessage || agentStore.isMessageInputBlocked"
         >
           <IconArrowUpOutline 
             class="w-8 h-8 p-1

package/dist/custom/chat.ts

@@ -17,7 +17,7 @@ import type {
   ChatStatus,
   UIMessage,
 } from 'ai';
-import {   AbstractChat, } from 'ai'
+import { AbstractChat } from 'ai'
 import { Ref, ref } from 'vue';
 
 class VueChatState<