@adminforth/agent 2.0.10 → 2.2.0

package/dist/index.js

@@ -7,26 +7,23 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { AdminForthPlugin } from "adminforth";
+import { AdminForthPlugin, logger } from "adminforth";
 import { MemorySaver } from "@langchain/langgraph";
-import { AdminForthCheckpointSaver } from "./agent/checkpointer.js";
-import { appendCustomSystemPrompt, buildAgentSystemPrompt, DEFAULT_AGENT_SYSTEM_PROMPT } from "./agent/systemPrompt.js";
-import { setupCoreEndpoints } from "./endpoints/core.js";
-import { setupSessionEndpoints } from "./endpoints/sessions.js";
-import { setupChatSurfaceEndpoints } from "./endpoints/chatSurfaces.js";
-import { AgentSessionStore } from "./sessionStore.js";
-import { ChatSurfaceService } from "./chatSurfaceService.js";
-import { AgentTurnService } from "./agentTurnService.js";
-import { AgentModelFactory } from "./agent/models/AgentModelFactory.js";
-import { AgentModeResolver } from "./agent/models/AgentModeResolver.js";
-import { AgentRuntime } from "./agent/runtime/AgentRuntime.js";
-import { SpeechTurnService } from "./agent/speech/SpeechTurnService.js";
-import { AgentToolProvider } from "./agent/tools/AgentToolProvider.js";
-import { TurnContextBuilder } from "./agent/turn/TurnContextBuilder.js";
-import { TurnLifecycleService } from "./agent/turn/TurnLifecycleService.js";
-import { TurnPersistenceService } from "./agent/turn/TurnPersistenceService.js";
-import { TurnPromptBuilder } from "./agent/turn/TurnPromptBuilder.js";
-import { TurnStreamConsumer } from "./agent/turn/TurnStreamConsumer.js";
+import { AdminForthCheckpointSaver } from "./persistence/checkpointStore.js";
+import { appendCustomSystemPrompt, buildAgentSystemPrompt, DEFAULT_AGENT_SYSTEM_PROMPT } from "./domain/systemPrompt.js";
+import { setupCoreEndpoints } from "./transport/http/coreEndpoints.js";
+import { setupSessionEndpoints } from "./transport/http/sessionEndpoints.js";
+import { setupChatSurfaceEndpoints } from "./transport/http/chatSurfaceEndpoints.js";
+import { AgentSessionStore } from "./persistence/sessionStore.js";
+import { ChatSurfaceService } from "./transport/surfaces/chatSurfaceService.js";
+import { RunTurnUseCase } from "./application/runTurnUseCase.js";
+import { createSequenceDebugCollector } from "./llm/middleware/sequenceDebug.js";
+import { LangGraphLlm } from "./llm/langGraphLlm.js";
+import { AgentModelFactory } from "./llm/modelFactory.js";
+import { AgentRuntime } from "./llm/agentRuntime.js";
+import { SpeechTurnService } from "./transport/surfaces/speechTurnService.js";
+import { AgentToolProvider } from "./tools/agentToolProvider.js";
+import { SteerBuffer } from "./domain/steerBuffer.js";
 export default class AdminForthAgentPlugin extends AdminForthPlugin {
     getCheckpointer() {
         if (this.checkpointer)
@@ -44,6 +41,18 @@ export default class AdminForthAgentPlugin extends AdminForthPlugin {
             (_a = this.options.checkpointResource) === null || _a === void 0 ? void 0 : _a.resourceId,
         ].filter((resourceId) => Boolean(resourceId));
     }
+    getAgentSystemPrompt() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.agentSystemPrompt) {
+                const systemPrompt = yield buildAgentSystemPrompt(this.adminforth, this.getInternalAgentResourceIds()).catch((err) => {
+                    logger.error(`Failed to build agent system prompt, falling back to default: ${err instanceof Error ? err.message : String(err)}`);
+                    return DEFAULT_AGENT_SYSTEM_PROMPT;
+                });
+                this.agentSystemPrompt = appendCustomSystemPrompt(systemPrompt, this.options.systemPrompt);
+            }
+            return this.agentSystemPrompt;
+        });
+    }
     constructor(options) {
         var _a;
         super(options, import.meta.url);
@@ -52,28 +61,28 @@ export default class AdminForthAgentPlugin extends AdminForthPlugin {
         this.checkpointer = null;
         this.options = options;
         this.sessionStore = new AgentSessionStore(() => this.adminforth, this.options);
+        this.steerBuffer = new SteerBuffer();
         const toolProvider = new AgentToolProvider(() => this.adminforth, this.getInternalAgentResourceIds.bind(this));
         const runtime = new AgentRuntime({
             name: `adminforth-agent-${this.pluginInstanceId}`,
             getAdminforth: () => this.adminforth,
             getCheckpointer: this.getCheckpointer.bind(this),
             toolProvider,
+            steerBuffer: this.steerBuffer,
         });
-        const persistence = new TurnPersistenceService(() => this.adminforth, this.options);
-        this.agentTurnService = new AgentTurnService(new TurnLifecycleService(this.sessionStore, persistence, this.options), new TurnContextBuilder(() => this.adminforth), new AgentModeResolver(this.options), new AgentModelFactory((_a = this.options.maxTokens) !== null && _a !== void 0 ? _a : 1000), new TurnPromptBuilder({
+        const llm = new LangGraphLlm(runtime, new AgentModelFactory((_a = this.options.maxTokens) !== null && _a !== void 0 ? _a : 1000));
+        this.runTurnUseCase = new RunTurnUseCase({
+            llm,
+            sessions: this.sessionStore,
+            steerBuffer: this.steerBuffer,
+            modes: this.options.modes,
             getAdminforth: () => this.adminforth,
-            getAgentSystemPrompt: () => __awaiter(this, void 0, void 0, function* () {
-                if (!this.agentSystemPrompt) {
-                    const systemPrompt = yield buildAgentSystemPrompt(this.adminforth, this.getInternalAgentResourceIds()).catch((err) => {
-                        return DEFAULT_AGENT_SYSTEM_PROMPT;
-                    });
-                    this.agentSystemPrompt = appendCustomSystemPrompt(systemPrompt, this.options.systemPrompt);
-                }
-                return this.agentSystemPrompt;
-            }),
-        }), runtime, new TurnStreamConsumer());
-        this.speechTurnService = new SpeechTurnService(this.agentTurnService.runAndPersistAgentResponse.bind(this.agentTurnService));
-        this.chatSurfaceService = new ChatSurfaceService(() => this.adminforth, this.options, this.sessionStore, this.agentTurnService.handleTurn.bind(this.agentTurnService), this.agentTurnService.runAndPersistAgentResponse.bind(this.agentTurnService));
+            getAgentSystemPrompt: this.getAgentSystemPrompt.bind(this),
+            hasPersistentCheckpointer: Boolean(this.options.checkpointResource),
+            createDebugSink: createSequenceDebugCollector,
+        });
+        this.speechTurnService = new SpeechTurnService(this.runTurnUseCase.runAndPersistAgentResponse.bind(this.runTurnUseCase));
+        this.chatSurfaceService = new ChatSurfaceService(() => this.adminforth, this.options, this.sessionStore, this.runTurnUseCase.handleTurn.bind(this.runTurnUseCase), this.runTurnUseCase.runAndPersistAgentResponse.bind(this.runTurnUseCase));
         this.agentSystemPromptPromise = Promise.resolve(appendCustomSystemPrompt(DEFAULT_AGENT_SYSTEM_PROMPT, this.options.systemPrompt));
         this.shouldHaveSingleInstancePerWholeApp = () => false;
     }
@@ -139,12 +148,17 @@ export default class AdminForthAgentPlugin extends AdminForthPlugin {
         const endpointContext = {
             adminforth: this.adminforth,
             options: this.options,
-            handleTurn: this.agentTurnService.handleTurn.bind(this.agentTurnService),
+            handleTurn: this.runTurnUseCase.handleTurn.bind(this.runTurnUseCase),
             handleSpeechTurn: this.speechTurnService.handle.bind(this.speechTurnService),
-            runAndPersistAgentResponse: this.agentTurnService.runAndPersistAgentResponse.bind(this.agentTurnService),
+            steer: ({ sessionId, message }) => {
+                const { id } = this.steerBuffer.add(sessionId, message);
+                return { id, queued: this.steerBuffer.size(sessionId) };
+            },
+            runAndPersistAgentResponse: this.runTurnUseCase.runAndPersistAgentResponse.bind(this.runTurnUseCase),
             getSessionTurns: this.sessionStore.getSessionTurns.bind(this.sessionStore),
             createNewTurn: this.sessionStore.createNewTurn.bind(this.sessionStore),
             createSystemTurn: this.sessionStore.createSystemTurn.bind(this.sessionStore),
+            appendSteerToCurrentTurn: this.sessionStore.appendSteerToCurrentTurn.bind(this.sessionStore),
             handleChatSurfaceMessage: this.chatSurfaceService.handleMessage.bind(this.chatSurfaceService),
         };
         setupCoreEndpoints(endpointContext, server);

package/dist/{agent/runtime/AgentContext.d.ts → llm/agentContext.d.ts}

@@ -1,9 +1,9 @@
 import type { AdminUser } from "adminforth";
 import { z } from "zod";
-import type { AgentEventEmitter } from "../../agentEvents.js";
-import type { SequenceDebugCollector } from "../middleware/sequenceDebug.js";
+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 "../turn/turnTypes.js";
+import type { AgentTurnContext } from "../domain/turnTypes.js";
 export declare const contextSchema: z.ZodObject<{
     adminUser: z.ZodCustom<AdminUser, AdminUser>;
     userTimeZone: z.ZodString;

package/dist/{agent/simpleAgent.d.ts → llm/agentModels.d.ts}

@@ -2,22 +2,26 @@ import type { BaseChatModel } from "@langchain/core/language_models/chat_models"
 import { type CompletionAdapter } from "adminforth";
 import { BaseCallbackHandler } from "@langchain/core/callbacks/base";
 import type { LLMResult } from "@langchain/core/outputs";
+import type { Messages, Command } from "@langchain/langgraph";
 import { createSequenceDebugMiddleware } from "./middleware/sequenceDebug.js";
+import type { AgentModelPurpose } from "../application/ports.js";
+import type { AgentTurnContext, AgentTurnObservability } from "../domain/turnTypes.js";
+export type { AgentModeCompletionAdapter, AgentModelPurpose } from "../application/ports.js";
 export type AgentChatModel = BaseChatModel<any, any>;
-export type AgentModelPurpose = "primary" | "summary";
-export type AgentModeCompletionAdapter = CompletionAdapter & {
-    getLangChainAgentSpec(params: {
-        maxTokens: number;
-        purpose: AgentModelPurpose;
-    }): Promise<{
-        model: unknown;
-        middleware?: unknown[];
-    }> | {
-        model: unknown;
-        middleware?: unknown[];
-    };
-};
 export type AgentMiddleware = ReturnType<typeof createSequenceDebugMiddleware>;
+export type AgentTurnModels = {
+    model: AgentChatModel;
+    summaryModel: AgentChatModel;
+    modelMiddleware?: AgentMiddleware[];
+};
+export type AgentRuntimeRunInput = {
+    models: AgentTurnModels;
+    input: {
+        messages: Messages;
+    } | Command;
+    context: AgentTurnContext;
+    observability: AgentTurnObservability;
+};
 type AgentChatModelSpec = {
     model: AgentChatModel;
     middleware: AgentMiddleware[];
@@ -27,8 +31,7 @@ declare class AgentLlmMetricsLogger extends BaseCallbackHandler {
     lc_prefer_streaming: boolean;
     private readonly pendingRuns;
     handleLLMStart(_llm: unknown, _prompts: string[], runId: string): Promise<void>;
-    handleLLMNewToken(_token: string, _chunk: unknown, runId: string): Promise<void>;
-    handleLLMEnd(output: LLMResult, runId: string): Promise<void>;
+    handleLLMEnd(_output: LLMResult, runId: string): Promise<void>;
     handleLLMError(_error: unknown, runId: string): Promise<void>;
 }
 export declare function createAgentLlmMetricsLogger(): AgentLlmMetricsLogger;
@@ -37,4 +40,3 @@ export declare function createAgentChatModel(params: {
     maxTokens: number;
     purpose: AgentModelPurpose;
 }): Promise<AgentChatModelSpec>;
-export {};

package/dist/llm/agentModels.js

@@ -0,0 +1,65 @@
+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 { BaseCallbackHandler } from "@langchain/core/callbacks/base";
+function isLangChainAgentCompletionAdapter(adapter) {
+    return typeof adapter
+        .getLangChainAgentSpec === "function";
+}
+function getAgentChatModelSpec(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const spec = yield params.adapter.getLangChainAgentSpec({
+            maxTokens: params.maxTokens,
+            purpose: params.purpose,
+        });
+        return {
+            model: spec.model,
+            middleware: ((_a = spec.middleware) !== null && _a !== void 0 ? _a : []),
+        };
+    });
+}
+class AgentLlmMetricsLogger extends BaseCallbackHandler {
+    constructor() {
+        super(...arguments);
+        this.name = "AgentLlmMetricsLogger";
+        this.lc_prefer_streaming = true;
+        this.pendingRuns = new Map();
+    }
+    handleLLMStart(_llm, _prompts, runId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.pendingRuns.set(runId, { startedAt: Date.now() });
+        });
+    }
+    handleLLMEnd(_output, runId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.pendingRuns.delete(runId);
+        });
+    }
+    handleLLMError(_error, runId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.pendingRuns.delete(runId);
+        });
+    }
+}
+export function createAgentLlmMetricsLogger() {
+    return new AgentLlmMetricsLogger();
+}
+export function createAgentChatModel(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!isLangChainAgentCompletionAdapter(params.adapter)) {
+            throw new Error("AdminForth Agent requires completionAdapter to implement getLangChainAgentSpec({ maxTokens, purpose }).");
+        }
+        return yield getAgentChatModelSpec({
+            adapter: params.adapter,
+            maxTokens: params.maxTokens,
+            purpose: params.purpose,
+        });
+    });
+}

package/dist/{agent/runtime/AgentRuntime.d.ts → llm/agentRuntime.d.ts}

@@ -1,15 +1,27 @@
 import type { IAdminForth } from "adminforth";
 import type { BaseCheckpointSaver } from "@langchain/langgraph";
-import type { AgentToolProvider } from "../tools/AgentToolProvider.js";
-import type { AgentRuntimeRunInput } from "../turn/turnTypes.js";
+import type { SteerBuffer } from "../domain/steerBuffer.js";
+import type { AgentToolProvider } from "../tools/agentToolProvider.js";
+import type { AgentRuntimeRunInput, AgentTurnModels } from "./agentModels.js";
 export type AgentRuntimeOptions = {
     name: string;
     getAdminforth: () => IAdminForth;
     getCheckpointer: () => BaseCheckpointSaver;
     toolProvider: AgentToolProvider;
+    /** Per-session buffer of mid-turn steering instructions drained by the steer middleware. */
+    steerBuffer: SteerBuffer;
 };
 export declare class AgentRuntime {
     private readonly options;
     constructor(options: AgentRuntimeOptions);
     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">>]>>;
+    /**
+     * Read the pending human-in-the-loop interrupts persisted for a thread from the
+     * checkpointer. Builds a minimal agent (model + checkpointer + HITL middleware) and
+     * queries its state — no model call is made. Returns raw LangGraph interrupt objects.
+     */
+    getPendingInterrupts(input: {
+        models: AgentTurnModels;
+        sessionId: string;
+    }): Promise<unknown[]>;
 }

package/dist/{agent/runtime/AgentRuntime.js → llm/agentRuntime.js}

@@ -8,10 +8,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 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";
+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";
 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; })
@@ -33,12 +34,17 @@ export class AgentRuntime {
             const tools = yield this.options.toolProvider.getTools(apiBasedTools);
             const adminforth = this.options.getAdminforth();
             const apiBasedToolsMiddleware = createApiBasedToolsMiddleware(apiBasedTools, adminforth);
-            const sequenceDebugMiddleware = createSequenceDebugMiddleware(input.observability.sequenceDebugSink);
+            // The domain exposes only the narrow DebugSink; the concrete collector (with the
+            // model-call hooks the debug middleware needs) is an llm-layer detail.
+            const sequenceDebugSink = input.observability.sequenceDebugSink;
+            const sequenceDebugMiddleware = createSequenceDebugMiddleware(sequenceDebugSink);
             const hitlMiddleware = humanInTheLoopMiddleware({
                 interruptOn: createHumanInTheLoopInterrupts(apiBasedTools),
                 descriptionPrefix: "Tool execution pending approval",
             });
+            const steerMiddleware = createSteerMiddleware(this.options.steerBuffer);
             const middleware = [
+                steerMiddleware,
                 apiBasedToolsMiddleware,
                 hitlMiddleware,
                 ...((_a = input.models.modelMiddleware) !== null && _a !== void 0 ? _a : []),
@@ -65,8 +71,37 @@ export class AgentRuntime {
                 configurable: {
                     thread_id: input.context.sessionId,
                 },
-                context: toLangchainAgentContext(Object.assign(Object.assign({}, input.context), { adminBaseUrl: adminforth.config.baseUrlSlashed, emit: input.observability.emit, sequenceDebugSink: input.observability.sequenceDebugSink })),
+                context: toLangchainAgentContext(Object.assign(Object.assign({}, input.context), { adminBaseUrl: adminforth.config.baseUrlSlashed, emit: input.observability.emit, sequenceDebugSink })),
             });
         });
     }
+    /**
+     * Read the pending human-in-the-loop interrupts persisted for a thread from the
+     * checkpointer. Builds a minimal agent (model + checkpointer + HITL middleware) and
+     * queries its state — no model call is made. Returns raw LangGraph interrupt objects.
+     */
+    getPendingInterrupts(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const apiBasedTools = this.options.toolProvider.getApiBasedTools();
+            const tools = yield this.options.toolProvider.getTools(apiBasedTools);
+            const agent = createAgent({
+                name: this.options.name,
+                model: input.models.model,
+                checkpointer: this.options.getCheckpointer(),
+                tools,
+                contextSchema,
+                middleware: [
+                    humanInTheLoopMiddleware({
+                        interruptOn: createHumanInTheLoopInterrupts(apiBasedTools),
+                        descriptionPrefix: "Tool execution pending approval",
+                    }),
+                ],
+            });
+            const state = yield agent.getState({
+                configurable: { thread_id: input.sessionId },
+            });
+            const tasks = Array.isArray(state === null || state === void 0 ? void 0 : state.tasks) ? state.tasks : [];
+            return tasks.flatMap((task) => (Array.isArray(task === null || task === void 0 ? void 0 : task.interrupts) ? task.interrupts : []));
+        });
+    }
 }

package/dist/llm/langGraphLlm.d.ts

@@ -0,0 +1,25 @@
+import type { AgentRuntime } from "./agentRuntime.js";
+import type { AgentModelFactory } from "./modelFactory.js";
+import { type PreviousUserMessage } from "../domain/languageDetect.js";
+import type { AgentModeCompletionAdapter, LlmPort, LlmStreamInput } from "../application/ports.js";
+import type { PendingInterrupt } from "../domain/turnTypes.js";
+/**
+ * LangChain/LangGraph implementation of {@link LlmPort}. This is the single
+ * place that knows about the agent graph, model construction, and the raw
+ * stream shape; the application layer talks only to the port.
+ */
+export declare class LangGraphLlm implements LlmPort {
+    private readonly runtime;
+    private readonly modelFactory;
+    constructor(runtime: AgentRuntime, modelFactory: AgentModelFactory);
+    streamTurn(input: LlmStreamInput): Promise<AsyncGenerator<import("../domain/turnTypes.js").AgentStreamChunk, any, any>>;
+    detectLanguage(input: {
+        completionAdapter: AgentModeCompletionAdapter;
+        prompt: string;
+        previousUserMessages: PreviousUserMessage[];
+    }): Promise<import("../domain/languageDetect.js").DetectedLanguage | null>;
+    getPendingInterrupts(input: {
+        completionAdapter: AgentModeCompletionAdapter;
+        sessionId: string;
+    }): Promise<PendingInterrupt[]>;
+}

package/dist/llm/langGraphLlm.js

@@ -0,0 +1,54 @@
+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 { Command } from "@langchain/langgraph";
+import { HumanMessage, SystemMessage } 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));
+}
+/**
+ * LangChain/LangGraph implementation of {@link LlmPort}. This is the single
+ * place that knows about the agent graph, model construction, and the raw
+ * stream shape; the application layer talks only to the port.
+ */
+export class LangGraphLlm {
+    constructor(runtime, modelFactory) {
+        this.runtime = runtime;
+        this.modelFactory = modelFactory;
+    }
+    streamTurn(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const models = yield this.modelFactory.create(input.completionAdapter);
+            const runtimeInput = "resume" in input.input
+                ? new Command({ resume: input.input.resume })
+                : { messages: toLangchainMessages(input.input.messages) };
+            const rawStream = yield this.runtime.stream({
+                models,
+                input: runtimeInput,
+                context: input.context,
+                observability: input.observability,
+            });
+            return adaptRawStream(rawStream);
+        });
+    }
+    detectLanguage(input) {
+        return detectUserLanguage(input.completionAdapter, input.prompt, input.previousUserMessages);
+    }
+    getPendingInterrupts(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const models = yield this.modelFactory.create(input.completionAdapter);
+            const raw = yield this.runtime.getPendingInterrupts({ models, sessionId: input.sessionId });
+            return normalizeInterrupts(raw);
+        });
+    }
+}

package/dist/{agent/middleware/apiBasedTools.d.ts → llm/middleware/apiToolsMiddleware.d.ts}

@@ -1,3 +1,3 @@
 import { type IAdminForth } from "adminforth";
-import { type ApiBasedTool } from "../../apiBasedTools.js";
+import { type ApiBasedTool } from "../../tools/apiBasedTools.js";
 export declare function createApiBasedToolsMiddleware(apiBasedTools: Record<string, ApiBasedTool>, adminforth: IAdminForth): import("langchain").AgentMiddleware<undefined, undefined, unknown, readonly (import("@langchain/core/tools").ClientTool | import("@langchain/core/tools").ServerTool)[]>;

package/dist/{agent/middleware/apiBasedTools.js → llm/middleware/apiToolsMiddleware.js}

@@ -11,11 +11,11 @@ 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";
+import { formatApiBasedToolCall, } from "../../tools/apiBasedTools.js";
+import { createToolCallTracker, } from "../../domain/toolCallEvents.js";
+import { ALWAYS_AVAILABLE_API_TOOL_NAMES } from "../../tools/index.js";
+import { createApiTool } from "../../tools/apiTool.js";
+import { isAbortError } from "../../shared/errors.js";
 function getEnabledApiToolNames(messages) {
     const enabledToolNames = new Set();
     for (const message of messages) {
@@ -58,15 +58,13 @@ export function createApiBasedToolsMiddleware(apiBasedTools, adminforth) {
                     .filter((toolName) => !alwaysAvailableApiToolNames.has(toolName))
                     .map((toolName) => dynamicTools[toolName]);
                 const availableTools = [...request.tools, ...tools];
-                logger.info(`AdminForth Agent callable tools: ${availableTools.map((tool) => tool.name).join(", ")}`);
                 return handler(Object.assign(Object.assign({}, request), { tools: availableTools }));
             });
         },
         wrapToolCall(request, handler) {
             return __awaiter(this, void 0, void 0, function* () {
-                var _a, _b, _c;
+                var _a, _b;
                 const startedAt = Date.now();
-                const toolInput = JSON.stringify((_a = request.toolCall.args) !== null && _a !== void 0 ? _a : {});
                 if (!request.toolCall.id) {
                     throw new Error(`Tool call "${request.toolCall.name}" has no id.`);
                 }
@@ -79,7 +77,7 @@ export function createApiBasedToolsMiddleware(apiBasedTools, adminforth) {
                         data: event,
                     }));
                 };
-                const toolArgs = ((_b = request.toolCall.args) !== null && _b !== void 0 ? _b : {});
+                const toolArgs = ((_a = request.toolCall.args) !== null && _a !== void 0 ? _a : {});
                 let toolInfo;
                 if (request.toolCall.name === "fetch_skill") {
                     toolInfo = `Load ${toolArgs.skillName.split("_").join(" ")} skill`;
@@ -105,7 +103,6 @@ export function createApiBasedToolsMiddleware(apiBasedTools, adminforth) {
                     startedAt,
                 });
                 toolCallTracker.start();
-                logger.info(`Invoking tool "${request.toolCall.name}" with input: ${toolInput}`);
                 try {
                     const result = getEnabledApiToolNames(request.state.messages).has(request.toolCall.name)
                         ? yield handler(Object.assign(Object.assign({}, request), { tool: dynamicTools[request.toolCall.name] }))
@@ -120,7 +117,7 @@ export function createApiBasedToolsMiddleware(apiBasedTools, adminforth) {
                         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)}`);
+                    logger.error(`Error calling tool "${request.toolCall.name}": ${error instanceof Error ? (_b = error.stack) !== null && _b !== void 0 ? _b : error.message : String(error)}`);
                     toolCallTracker.finishError(`Error: ${message}`);
                     return new ToolMessage({
                         name: request.toolCall.name,
@@ -129,9 +126,6 @@ export function createApiBasedToolsMiddleware(apiBasedTools, adminforth) {
                         content: `Error: ${message}`,
                     });
                 }
-                finally {
-                    logger.info(`Tool "${request.toolCall.name}" finished in ${Date.now() - startedAt}ms`);
-                }
             });
         },
     });

package/dist/{agent → llm}/middleware/sequenceDebug.d.ts

@@ -1,4 +1,4 @@
-import type { ToolCallEvent } from "../toolCallEvents.js";
+import type { ToolCallEvent } from "../../domain/toolCallEvents.js";
 export type SequenceDebugResultType = "tool_calls" | "final_text";
 type SequenceDebugToolCall = {
     toolCallId: string;

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

@@ -0,0 +1,21 @@
+import { z } from "zod";
+import type { AgentEventEmitter } from "../../domain/agentEvents.js";
+import type { SteerBuffer } from "../../domain/steerBuffer.js";
+/**
+ * `beforeModel` middleware that folds user "steering" instructions into a running
+ * turn. Before every model call in the agent loop it drains the per-session
+ * {@link SteerBuffer}; any buffered steers are appended to the conversation as
+ * user messages (so the model sees them on the very next call) and a
+ * `steer-applied` event is emitted on the turn's already-open SSE stream so the
+ * frontend knows the steer was actually consumed (not just received/queued).
+ *
+ * Placed first in the middleware array so the injected messages are present for
+ * every downstream `beforeModel` hook (e.g. summarization) and the model itself.
+ */
+export declare function createSteerMiddleware(steerBuffer: SteerBuffer): import("langchain").AgentMiddleware<undefined, z.ZodObject<{
+    sessionId: z.ZodString;
+    emit: z.ZodOptional<z.ZodCustom<AgentEventEmitter, AgentEventEmitter>>;
+}, z.core.$strip>, {
+    sessionId: string;
+    emit?: AgentEventEmitter | undefined;
+}, readonly (import("@langchain/core/tools").ClientTool | import("@langchain/core/tools").ServerTool)[]>;

package/dist/llm/middleware/steerMiddleware.js

@@ -0,0 +1,50 @@
+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 { HumanMessage } from "langchain";
+import { createMiddleware } from "langchain";
+import { z } from "zod";
+const steerContextSchema = z.object({
+    sessionId: z.string(),
+    emit: z.custom().optional(),
+});
+/**
+ * `beforeModel` middleware that folds user "steering" instructions into a running
+ * turn. Before every model call in the agent loop it drains the per-session
+ * {@link SteerBuffer}; any buffered steers are appended to the conversation as
+ * user messages (so the model sees them on the very next call) and a
+ * `steer-applied` event is emitted on the turn's already-open SSE stream so the
+ * frontend knows the steer was actually consumed (not just received/queued).
+ *
+ * Placed first in the middleware array so the injected messages are present for
+ * every downstream `beforeModel` hook (e.g. summarization) and the model itself.
+ */
+export function createSteerMiddleware(steerBuffer) {
+    return createMiddleware({
+        name: "SteerMiddleware",
+        contextSchema: steerContextSchema,
+        beforeModel(_state, runtime) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const { sessionId, emit } = runtime.context;
+                const steers = steerBuffer.drain(sessionId);
+                if (steers.length === 0) {
+                    return;
+                }
+                void (emit === null || emit === void 0 ? void 0 : emit({
+                    type: "steer-applied",
+                    count: steers.length,
+                    ids: steers.map((steer) => steer.id),
+                }));
+                return {
+                    messages: steers.map((steer) => new HumanMessage(`[User steering — new instruction sent mid-turn, take it into account from now on]\n${steer.text}`)),
+                };
+            });
+        },
+    });
+}

package/dist/{agent/models/AgentModelFactory.d.ts → llm/modelFactory.d.ts}

@@ -1,5 +1,5 @@
 import type { CompletionAdapter } from "adminforth";
-import type { AgentTurnModels } from "../turn/turnTypes.js";
+import { type AgentTurnModels } from "./agentModels.js";
 export declare class AgentModelFactory {
     private readonly maxTokens;
     constructor(maxTokens: number);

package/dist/{agent/models/AgentModelFactory.js → llm/modelFactory.js}

@@ -7,7 +7,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { createAgentChatModel } from "../simpleAgent.js";
+import { createAgentChatModel } from "./agentModels.js";
 export class AgentModelFactory {
     constructor(maxTokens) {
         this.maxTokens = maxTokens;

package/dist/llm/streamAdapter.d.ts

@@ -0,0 +1,18 @@
+import type { AgentStreamChunk, PendingInterrupt } from "../domain/turnTypes.js";
+/**
+ * Normalize raw LangGraph interrupt object(s) into provider-agnostic descriptors.
+ * Kept in the llm layer so the LangGraph interrupt shape never reaches the app.
+ */
+export declare function normalizeInterrupts(interrupt: unknown): PendingInterrupt[];
+type RawStreamEntry = ["messages", [any, any]] | ["updates", Record<string, any>];
+/**
+ * Convert one raw LangGraph stream entry into zero or more normalized chunks.
+ * Pure and synchronous so the parsing rules can be unit-tested in isolation.
+ */
+export declare function parseRawStreamChunk(entry: RawStreamEntry): AgentStreamChunk[];
+/**
+ * Adapt the raw LangGraph `["messages" | "updates", ...]` stream into a typed
+ * `AgentStreamChunk` stream for the application layer.
+ */
+export declare function adaptRawStream(raw: AsyncIterable<RawStreamEntry>): AsyncGenerator<AgentStreamChunk>;
+export {};