@cuylabs/agent-a365-tooling 3.1.0 → 4.0.0

package/README.md

@@ -2,10 +2,13 @@
 
 Microsoft Agent 365 tooling adapter for `@cuylabs/agent-core`.
 
-This package exposes one turn-scoped tool provider factory. On each chat turn,
-it uses Microsoft's Agent 365 tooling SDK to discover MCP servers for the active
+This package exposes a turn-scoped tool provider factory and an optional
+Agent 365 chat-history middleware. On each chat turn, the provider uses
+Microsoft's Agent 365 tooling SDK to discover MCP servers for the active
 Microsoft 365 turn, connects those servers through agent-core's MCP manager,
-and returns MCP tools for that turn only.
+and returns MCP tools for that turn only. The middleware can submit recent
+agent-core chat history to Microsoft's Agent 365 real-time threat protection
+registration endpoint.
 
 Use this when your agent is hosted behind Microsoft 365 / Agent 365 and should
 use the MCP tool servers configured for the current tenant, user, and agent
@@ -18,6 +21,8 @@ identity. Do not use it for static MCP servers known at startup; use
 - Microsoft SDK token exchange and per-server bearer headers.
 - Agent 365 platform headers for real Microsoft-hosted MCP servers.
 - Turn-scoped MCP tools that are cleaned up after the turn.
+- Opt-in Agent 365 chat-history submission for Microsoft's real-time threat
+  protection registration API.
 - A Microsoft-specific adapter without importing Microsoft SDK types into
   `agent-core`.
 
@@ -63,6 +68,69 @@ createA365ToolingTurnToolProvider({
 });
 ```
 
+## Chat History Submission
+
+Microsoft's RTP API is developer-invoked; this package does not automatically
+intercept every conversation. Register the middleware only when the host should
+submit chat history for Microsoft Agent 365 analysis.
+
+```ts
+import { createAgent } from "@cuylabs/agent-core";
+import {
+  createA365ChatHistoryMiddleware,
+  createA365ToolingTurnToolProvider,
+} from "@cuylabs/agent-a365-tooling";
+
+const agent = createAgent({
+  model,
+  turnToolProviders: [
+    createA365ToolingTurnToolProvider({
+      authorization,
+      authHandlerName: "agentic",
+    }),
+  ],
+  middleware: [
+    createA365ChatHistoryMiddleware({
+      toolOptions: {
+        orchestratorName: "dory",
+      },
+    }),
+  ],
+});
+```
+
+The middleware defaults to `timing: "after-turn"`, `limit: 20`, and
+`maxContentChars: 32000`. It reads history lazily from agent-core's lifecycle
+context, converts text content to Microsoft's
+`{ id, role, content, timestamp }` shape, keeps the most recent converted
+messages within the content budget, and calls `sendChatHistory` even when the
+converted history is `[]`. Empty arrays are intentional: Microsoft uses the
+current `TurnContext.activity` as the message being registered, with
+`chatHistory` as context.
+On `onChatEnd`, agent-core resolves this lazy history from the completed turn
+before any automatic context compaction rewrites the visible session history.
+
+Tool messages are included by default to match Microsoft's standard-message
+expectation. Set `includeTools: false` only when the host has a privacy or
+compliance reason to filter tool outputs; doing so can reduce RTP context.
+
+For non-M365 hosts, missing TurnContext is skipped by default:
+
+```ts
+createA365ChatHistoryMiddleware({
+  onMissingTurnContext: "skip", // "skip" | "warn"
+  getTurnContext: () => myTurnContext,
+});
+```
+
+If another `onChatEnd` hook must run after the submission attempt, place it
+later in the middleware array. The captured history leaf is fixed before
+automatic compaction and before `onChatEnd` hooks run. The Microsoft SDK returns
+transport success/failure only; threat verdicts are not returned inline through
+`sendChatHistory`.
+Submission failures are non-blocking by design; use `failureMode: "warn"` to
+log them or `failureMode: "ignore"` to silence them.
+
 ## Concept Docs
 
 The package docs are split by concern:
@@ -91,12 +159,25 @@ exchange for the active turn. In local dev-manifest mode, examples can pass a
 fake decoded token because the SDK reads `ToolingManifest.json` instead of
 calling the cloud gateway.
 
+## Open Microsoft Questions
+
+These do not block the v0 adapter, but they matter for production policy:
+
+- Does `/agents/real-time-threat-protection/chat-message` require an
+  `Authorization` header in production? Microsoft's current SDK call path passes
+  `undefined` as the auth token.
+- What is the server-side HTTP body size cap for `chatHistory`, and does
+  Microsoft recommend a client-side history limit?
+- Are retries with the same `activity.id` / `messageId` guaranteed idempotent?
+- Should post-turn `chatHistory` include the current user/assistant/tool
+  messages, or only messages before the current activity?
+
 ## What This Does Not Do
 
 This package is not a channel, not an LLM provider, and not a replacement for
 agent-core's MCP engine. It does not implement cross-turn MCP pooling,
-mid-turn token refresh, or Agent 365 real-time threat protection chat-history
-submission in v0.
+mid-turn token refresh, or inline threat blocking. `sendChatHistory` is a
+submit/register call; hosts should not treat it as a synchronous threat verdict.
 
 ## Examples
 

package/dist/index.d.ts

@@ -1,10 +1,13 @@
-import { AgentTurnToolContext, Logger, AgentTurnToolProviderResult, MCPServerStatus, AgentTurnToolProvider, MCPConfig } from '@cuylabs/agent-core';
+import { ChatLifecycleContext, AgentTurnToolContext, Logger, AgentTurnToolProviderResult, MCPServerStatus, MessageRole, Message, AgentMiddleware, AgentTurnToolProvider, MCPConfig } from '@cuylabs/agent-core';
 
 type MaybePromise<T> = T | Promise<T>;
 type TurnMcpTools = NonNullable<AgentTurnToolProviderResult["mcpTools"]>;
 type A365ToolingUtility = {
     GetToolRequestHeaders?: (authToken?: string, turnContext?: A365TurnContextLike, options?: A365ToolingToolOptions) => Record<string, string>;
 };
+type A365ChatHistoryService = {
+    sendChatHistory(turnContext: A365TurnContextLike, chatHistoryMessages: A365ChatHistoryMessage[], options?: A365ToolingToolOptions): Promise<A365OperationResultLike>;
+};
 type A365TurnContextLike = {
     activity?: unknown;
     [key: string]: unknown;
@@ -26,6 +29,10 @@ interface A365ToolingProviderContext {
     agentContext: AgentTurnToolContext;
     turnContext: A365TurnContextLike;
 }
+interface A365ChatHistoryContext {
+    chatContext: ChatLifecycleContext;
+    turnContext: A365TurnContextLike;
+}
 interface A365ToolingConnectorContext extends A365ToolingProviderContext {
     providerName: string;
     serverTimeoutMs: number;
@@ -39,12 +46,128 @@ interface A365ToolingMcpConnection {
 type A365ToolingMcpConnector = (servers: A365McpServerConfig[], context: A365ToolingConnectorContext) => Promise<A365ToolingMcpConnection>;
 type A365ToolingServerFilter = (servers: A365McpServerConfig[], context: A365ToolingProviderContext) => MaybePromise<A365McpServerConfig[]>;
 type A365ToolingValueResolver<T> = (context: A365ToolingProviderContext) => MaybePromise<T>;
+type A365ChatHistoryValueResolver<T> = (context: A365ChatHistoryContext) => MaybePromise<T>;
+interface A365ChatHistoryMessage {
+    id: string;
+    role: string;
+    content: string;
+    timestamp: string;
+}
+interface A365OperationResultLike {
+    succeeded: boolean;
+    errors?: readonly unknown[];
+    toString?: () => string;
+}
 interface A365ToolingModule {
     Utility?: A365ToolingUtility;
     McpToolServerConfigurationService: new (configurationProvider?: unknown) => {
         listToolServers(turnContext: A365TurnContextLike, authorization: A365AuthorizationLike, authHandlerName: string, authToken?: string, options?: A365ToolingToolOptions): Promise<A365McpServerConfig[]>;
+        sendChatHistory?(turnContext: A365TurnContextLike, chatHistoryMessages: A365ChatHistoryMessage[], options?: A365ToolingToolOptions): Promise<A365OperationResultLike>;
     };
 }
+type A365ChatHistoryFailureMode = "warn" | "ignore";
+type A365MissingTurnContextMode = "skip" | "warn";
+type A365ChatHistoryTiming = "after-turn";
+interface ConvertAgentMessagesToA365ChatHistoryOptions {
+    /**
+     * Restrict converted messages to these roles. Defaults to all roles.
+     */
+    roles?: readonly MessageRole[];
+    /**
+     * Include tool messages in the RTP context.
+     *
+     * Defaults to true to match Microsoft's PRD, which expects standard tool and
+     * function messages to be submitted unless the host explicitly filters them.
+     */
+    includeTools?: boolean;
+}
+interface SendA365ChatHistoryOptions {
+    turnContext: A365TurnContextLike;
+    chatHistoryMessages: A365ChatHistoryMessage[];
+    toolOptions?: A365ToolingToolOptions;
+    configurationProvider?: unknown;
+    getToolingModule?: () => Promise<A365ToolingModule>;
+    serviceFactory?: (module: A365ToolingModule, configurationProvider: unknown) => A365ChatHistoryService;
+}
+interface CreateA365ChatHistoryMiddlewareOptions {
+    /**
+     * Middleware name used in agent-core middleware logs.
+     *
+     * @default "a365-chat-history"
+     */
+    name?: string;
+    /**
+     * When to submit chat history. v0 supports post-turn submission only.
+     *
+     * @default "after-turn"
+     */
+    timing?: A365ChatHistoryTiming;
+    /**
+     * Maximum recent messages to submit as context.
+     *
+     * Empty context is still submitted to register the current Microsoft
+     * activity with RTP.
+     *
+     * @default 20
+     */
+    limit?: number;
+    /**
+     * Maximum combined characters from submitted chat history message content.
+     *
+     * The middleware keeps the most recent converted messages within this
+     * budget. If the oldest included message is too large, its content is
+     * truncated to fit. Empty context is still submitted when the budget is 0.
+     *
+     * @default 32000
+     */
+    maxContentChars?: number;
+    /**
+     * Restrict submitted history to these roles. Defaults to all roles.
+     */
+    roles?: readonly MessageRole[];
+    /**
+     * Include tool messages in the submitted history.
+     *
+     * @default true
+     */
+    includeTools?: boolean;
+    /**
+     * Optional A365 tooling request options, such as `orchestratorName`.
+     */
+    toolOptions?: A365ToolingToolOptions | A365ChatHistoryValueResolver<A365ToolingToolOptions | undefined>;
+    /**
+     * Gets the active Microsoft TurnContext.
+     *
+     * Defaults to reading `currentM365TurnContext()?.turnContext` from
+     * `@cuylabs/agent-channel-m365`. Non-M365 hosts are skipped by default.
+     */
+    getTurnContext?: () => MaybePromise<A365TurnContextLike | undefined>;
+    /**
+     * What to do when no Microsoft TurnContext is available.
+     *
+     * @default "skip"
+     */
+    onMissingTurnContext?: A365MissingTurnContextMode;
+    /**
+     * How to handle transport/module/conversion failures.
+     *
+     * @default "warn"
+     */
+    failureMode?: A365ChatHistoryFailureMode;
+    /**
+     * Optional Microsoft A365 tooling configuration provider.
+     */
+    configurationProvider?: unknown;
+    /**
+     * Test seam for loading `@microsoft/agents-a365-tooling`.
+     */
+    getToolingModule?: () => Promise<A365ToolingModule>;
+    /**
+     * Advanced service factory override for tests or custom Microsoft SDK wiring.
+     */
+    serviceFactory?: SendA365ChatHistoryOptions["serviceFactory"];
+    logger?: Logger;
+}
 interface CreateA365ToolingTurnToolProviderOptions {
     /**
      * Provider name used in duplicate-tool errors and logs.
@@ -126,7 +249,10 @@ declare class A365ToolingModuleLoadError extends Error {
     constructor(packageName: string, cause: unknown);
 }
 declare function createA365ToolingTurnToolProvider(options: CreateA365ToolingTurnToolProviderOptions): AgentTurnToolProvider;
+declare function convertAgentMessagesToA365ChatHistory(messages: readonly Message[], options?: ConvertAgentMessagesToA365ChatHistoryOptions): A365ChatHistoryMessage[];
+declare function sendA365ChatHistory(options: SendA365ChatHistoryOptions): Promise<A365OperationResultLike>;
+declare function createA365ChatHistoryMiddleware(options?: CreateA365ChatHistoryMiddlewareOptions): AgentMiddleware;
 declare function connectA365McpServers(servers: A365McpServerConfig[], context: A365ToolingConnectorContext): Promise<A365ToolingMcpConnection>;
 declare function toAgentCoreMcpConfig(servers: A365McpServerConfig[], options?: ToAgentCoreMcpConfigOptions): MCPConfig;
 
-export { type A365AuthorizationLike, type A365McpServerConfig, type A365ToolingConnectorContext, type A365ToolingMcpConnection, type A365ToolingMcpConnector, type A365ToolingModule, A365ToolingModuleLoadError, type A365ToolingProviderContext, type A365ToolingServerFilter, type A365ToolingToolOptions, A365ToolingTurnContextError, type A365ToolingValueResolver, type A365TurnContextLike, type CreateA365ToolingTurnToolProviderOptions, type ToAgentCoreMcpConfigOptions, connectA365McpServers, createA365ToolingTurnToolProvider, toAgentCoreMcpConfig };
+export { type A365AuthorizationLike, type A365ChatHistoryContext, type A365ChatHistoryFailureMode, type A365ChatHistoryMessage, type A365ChatHistoryTiming, type A365ChatHistoryValueResolver, type A365McpServerConfig, type A365MissingTurnContextMode, type A365OperationResultLike, type A365ToolingConnectorContext, type A365ToolingMcpConnection, type A365ToolingMcpConnector, type A365ToolingModule, A365ToolingModuleLoadError, type A365ToolingProviderContext, type A365ToolingServerFilter, type A365ToolingToolOptions, A365ToolingTurnContextError, type A365ToolingValueResolver, type A365TurnContextLike, type ConvertAgentMessagesToA365ChatHistoryOptions, type CreateA365ChatHistoryMiddlewareOptions, type CreateA365ToolingTurnToolProviderOptions, type SendA365ChatHistoryOptions, type ToAgentCoreMcpConfigOptions, connectA365McpServers, convertAgentMessagesToA365ChatHistory, createA365ChatHistoryMiddleware, createA365ToolingTurnToolProvider, sendA365ChatHistory, toAgentCoreMcpConfig };

package/dist/index.js

@@ -6,6 +6,15 @@ var A365_TOOLING_PACKAGE = "@microsoft/agents-a365-tooling";
 var M365_CHANNEL_PACKAGE = "@cuylabs/agent-channel-m365";
 var DEFAULT_PROVIDER_NAME = "a365-tooling";
 var DEFAULT_SERVER_TIMEOUT_MS = 5e3;
+var DEFAULT_CHAT_HISTORY_MIDDLEWARE_NAME = "a365-chat-history";
+var DEFAULT_CHAT_HISTORY_LIMIT = 20;
+var DEFAULT_CHAT_HISTORY_CONTENT_CHAR_LIMIT = 32e3;
+var ALL_MESSAGE_ROLES = [
+  "system",
+  "user",
+  "assistant",
+  "tool"
+];
 var A365ToolingTurnContextError = class extends Error {
   constructor(message = defaultMissingTurnContextMessage(), options) {
     super(message, options);
@@ -92,6 +101,137 @@ function createA365ToolingTurnToolProvider(options) {
     }
   };
 }
+function convertAgentMessagesToA365ChatHistory(messages, options = {}) {
+  const roles = options.roles ? new Set(options.roles) : void 0;
+  const includeTools = options.includeTools ?? true;
+  const converted = [];
+  for (const message of messages) {
+    if (!includeTools && message.role === "tool") {
+      continue;
+    }
+    if (roles && !roles.has(message.role)) {
+      continue;
+    }
+    const content = extractMessageContent(message);
+    if (content.trim().length === 0) {
+      continue;
+    }
+    converted.push({
+      id: message.id,
+      role: message.role,
+      content,
+      timestamp: message.createdAt.toISOString()
+    });
+  }
+  return converted;
+}
+async function sendA365ChatHistory(options) {
+  const module = await loadToolingModule(options.getToolingModule);
+  const service = options.serviceFactory ? options.serviceFactory(module, options.configurationProvider) : new module.McpToolServerConfigurationService(
+    options.configurationProvider
+  );
+  if (typeof service.sendChatHistory !== "function") {
+    throw new Error(
+      "The loaded @microsoft/agents-a365-tooling service does not expose sendChatHistory."
+    );
+  }
+  return service.sendChatHistory(
+    options.turnContext,
+    options.chatHistoryMessages,
+    options.toolOptions
+  );
+}
+function createA365ChatHistoryMiddleware(options = {}) {
+  const name = normalizeRequiredString(
+    options.name ?? DEFAULT_CHAT_HISTORY_MIDDLEWARE_NAME,
+    "name"
+  );
+  const timing = options.timing ?? "after-turn";
+  if (timing !== "after-turn") {
+    throw new Error(
+      'A365 chat history middleware only supports timing "after-turn"'
+    );
+  }
+  const limit = normalizeChatHistoryLimit(options.limit);
+  const maxContentChars = normalizeChatHistoryContentCharLimit(
+    options.maxContentChars
+  );
+  const failureMode = normalizeChatHistoryFailureMode(options.failureMode);
+  const onMissingTurnContext = normalizeMissingTurnContextMode(
+    options.onMissingTurnContext
+  );
+  return {
+    name,
+    async onChatEnd(sessionId, _result, ctx) {
+      const chatContext = ctx ?? { sessionId };
+      let turnContext;
+      try {
+        turnContext = await resolveOptionalTurnContext(options.getTurnContext);
+      } catch (error) {
+        handleChatHistoryFailure(
+          failureMode,
+          options.logger,
+          name,
+          error,
+          chatContext
+        );
+        return;
+      }
+      if (!turnContext) {
+        handleMissingChatHistoryTurnContext(
+          onMissingTurnContext,
+          options.logger,
+          name,
+          chatContext
+        );
+        return;
+      }
+      try {
+        const historyContext = {
+          chatContext,
+          turnContext
+        };
+        const toolOptions = await resolveChatHistoryOptionalValue(
+          options.toolOptions,
+          historyContext
+        );
+        const roles = resolveChatHistoryRoles(options);
+        const messages = chatContext.history?.getRecentMessages({ limit, roles }) ?? [];
+        const chatHistoryMessages = constrainA365ChatHistoryContent(
+          convertAgentMessagesToA365ChatHistory(messages, {
+            includeTools: options.includeTools ?? true
+          }),
+          maxContentChars
+        );
+        const operationResult = await sendA365ChatHistory({
+          turnContext,
+          chatHistoryMessages,
+          toolOptions,
+          configurationProvider: options.configurationProvider,
+          getToolingModule: options.getToolingModule,
+          serviceFactory: options.serviceFactory
+        });
+        if (!operationResult.succeeded) {
+          handleChatHistoryFailure(
+            failureMode,
+            options.logger,
+            name,
+            new Error(formatOperationResultError(operationResult)),
+            chatContext
+          );
+        }
+      } catch (error) {
+        handleChatHistoryFailure(
+          failureMode,
+          options.logger,
+          name,
+          error,
+          chatContext
+        );
+      }
+    }
+  };
+}
 async function connectA365McpServers(servers, context) {
   const manager = createMCPManager(
     toAgentCoreMcpConfig(servers, { timeoutMs: context.serverTimeoutMs })
@@ -175,6 +315,120 @@ function extractBearerToken(headers) {
   }
   return void 0;
 }
+function extractMessageContent(message) {
+  const rawMessage = message;
+  if (typeof rawMessage.text === "string" && rawMessage.text.trim()) {
+    return rawMessage.text;
+  }
+  const content = extractTextFromContent(rawMessage.content);
+  if (content.trim()) {
+    return content;
+  }
+  if (message.role === "assistant" && message.toolCalls?.length) {
+    return message.toolCalls.map(
+      (toolCall) => `tool_call: ${toolCall.toolName}(${stringifyToolArgs(toolCall.args)})`
+    ).join("\n");
+  }
+  return typeof rawMessage.text === "string" ? rawMessage.text : "";
+}
+function stringifyToolArgs(args) {
+  try {
+    return JSON.stringify(args) ?? "undefined";
+  } catch {
+    return String(args);
+  }
+}
+function extractTextFromContent(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  if (Array.isArray(content)) {
+    return content.map((part) => extractTextFromContentPart(part)).filter((part) => part.length > 0).join("\n");
+  }
+  if (content && typeof content === "object") {
+    const text = content.text;
+    if (typeof text === "string") {
+      return text;
+    }
+  }
+  return "";
+}
+function extractTextFromContentPart(part) {
+  if (typeof part === "string") {
+    return part;
+  }
+  if (!part || typeof part !== "object") {
+    return "";
+  }
+  const text = part.text;
+  if (typeof text === "string") {
+    return text;
+  }
+  const content = part.content;
+  return extractTextFromContent(content);
+}
+function resolveChatHistoryRoles(options) {
+  const roles = options.roles ?? ALL_MESSAGE_ROLES;
+  if (options.includeTools !== false) {
+    return roles;
+  }
+  return roles.filter((role) => role !== "tool");
+}
+function constrainA365ChatHistoryContent(messages, maxContentChars) {
+  if (messages.length === 0 || maxContentChars === 0) {
+    return [];
+  }
+  const constrained = [];
+  let remainingChars = maxContentChars;
+  for (let index = messages.length - 1; index >= 0; index--) {
+    const message = messages[index];
+    if (message.content.length <= remainingChars) {
+      constrained.push(message);
+      remainingChars -= message.content.length;
+      continue;
+    }
+    if (remainingChars > 0) {
+      const content = sliceWithoutDanglingSurrogate(
+        message.content,
+        remainingChars
+      );
+      constrained.push({
+        ...message,
+        content
+      });
+    }
+    break;
+  }
+  constrained.reverse();
+  return constrained;
+}
+function sliceWithoutDanglingSurrogate(value, length) {
+  let sliced = value.slice(0, length);
+  const lastCode = sliced.charCodeAt(sliced.length - 1);
+  if (lastCode >= 55296 && lastCode <= 56319) {
+    sliced = sliced.slice(0, -1);
+  }
+  return sliced;
+}
+async function resolveChatHistoryOptionalValue(value, context) {
+  if (value === void 0) {
+    return void 0;
+  }
+  return typeof value === "function" ? value(context) : value;
+}
+async function resolveOptionalTurnContext(getTurnContext) {
+  if (getTurnContext) {
+    return getTurnContext();
+  }
+  try {
+    return await getDefaultM365TurnContext();
+  } catch (error) {
+    if (error instanceof A365ToolingTurnContextError) {
+      return void 0;
+    }
+    throw error;
+  }
+}
 async function resolveTurnContext(getTurnContext) {
   const turnContext = getTurnContext ? await getTurnContext() : await getDefaultM365TurnContext();
   if (!turnContext) {
@@ -223,6 +477,34 @@ function normalizeTimeout(timeoutMs) {
   }
   return timeout;
 }
+function normalizeChatHistoryLimit(limit) {
+  const normalized = limit ?? DEFAULT_CHAT_HISTORY_LIMIT;
+  if (!Number.isFinite(normalized) || normalized < 0) {
+    throw new Error("limit must be a non-negative finite number");
+  }
+  return Math.floor(normalized);
+}
+function normalizeChatHistoryContentCharLimit(maxContentChars) {
+  const normalized = maxContentChars ?? DEFAULT_CHAT_HISTORY_CONTENT_CHAR_LIMIT;
+  if (!Number.isFinite(normalized) || normalized < 0) {
+    throw new Error("maxContentChars must be a non-negative finite number");
+  }
+  return Math.floor(normalized);
+}
+function normalizeChatHistoryFailureMode(mode) {
+  const normalized = mode ?? "warn";
+  if (normalized !== "warn" && normalized !== "ignore") {
+    throw new Error('failureMode must be "warn" or "ignore"');
+  }
+  return normalized;
+}
+function normalizeMissingTurnContextMode(mode) {
+  const normalized = mode ?? "skip";
+  if (normalized !== "skip" && normalized !== "warn") {
+    throw new Error('onMissingTurnContext must be "skip" or "warn"');
+  }
+  return normalized;
+}
 function normalizeRequiredString(value, name) {
   const trimmed = value?.trim();
   if (!trimmed) {
@@ -230,6 +512,46 @@ function normalizeRequiredString(value, name) {
   }
   return trimmed;
 }
+function handleMissingChatHistoryTurnContext(mode, logger, middlewareName, ctx) {
+  const message = "A365 chat history submission skipped: no ambient Microsoft TurnContext";
+  if (mode === "warn") {
+    logger?.warn(message, {
+      middleware: middlewareName,
+      sessionId: ctx.sessionId,
+      turnId: ctx.turnId
+    });
+    return;
+  }
+  logger?.debug(message, {
+    middleware: middlewareName,
+    sessionId: ctx.sessionId,
+    turnId: ctx.turnId
+  });
+}
+function handleChatHistoryFailure(mode, logger, middlewareName, error, ctx) {
+  if (mode === "warn") {
+    const errorInstance = error instanceof Error ? error : new Error(String(error));
+    logger?.warn("A365 chat history submission failed", {
+      middleware: middlewareName,
+      sessionId: ctx.sessionId,
+      turnId: ctx.turnId,
+      error: errorInstance,
+      message: errorInstance.message,
+      stack: errorInstance.stack
+    });
+  }
+}
+function formatOperationResultError(result) {
+  const errors = Array.from(result.errors ?? []);
+  if (errors.length > 0) {
+    return errors.map((error) => error instanceof Error ? error.message : String(error)).join("; ");
+  }
+  const formatted = result.toString?.();
+  if (formatted) {
+    return formatted;
+  }
+  return "Microsoft A365 sendChatHistory returned an unsuccessful result";
+}
 function logConnectionStatuses(logger, providerName, statuses) {
   if (!logger || !statuses) {
     return;
@@ -261,6 +583,9 @@ export {
   A365ToolingModuleLoadError,
   A365ToolingTurnContextError,
   connectA365McpServers,
+  convertAgentMessagesToA365ChatHistory,
+  createA365ChatHistoryMiddleware,
   createA365ToolingTurnToolProvider,
+  sendA365ChatHistory,
   toAgentCoreMcpConfig
 };

package/docs/lifecycle-and-limits.md

@@ -82,6 +82,17 @@ There is no package-level close timeout in v0. If production deployments show
 tail-latency spikes during turn cleanup, add a future `closeTimeoutMs` option to
 the connector path.
 
+## Chat History Submission
+
+`createA365ChatHistoryMiddleware()` is opt-in and runs after a completed
+agent-core turn. It reads recent messages through the lazy lifecycle history
+accessor, converts them to Microsoft's chat-history shape, and calls
+`sendChatHistory`.
+
+The middleware submits transport registration only. It does not turn the RTP
+call into a synchronous blocking verdict, and failures are non-blocking by
+default.
+
 ## Abort
 
 `AgentTurnToolContext.abort` is passed to providers, but agent-core's MCP
@@ -104,7 +115,7 @@ v0 does not include:
 
 - cross-turn MCP client pooling;
 - mid-turn token refresh;
-- real-time threat protection chat-history submission;
+- inline real-time threat protection blocking;
 - generic platform-neutral MCP discovery abstraction;
 - dedicated cleanup timeout;
 - custom telemetry events for per-server partial failure.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cuylabs/agent-a365-tooling",
-  "version": "3.1.0",
+  "version": "4.0.0",
   "description": "Microsoft Agent 365 tooling adapter for @cuylabs/agent-core turn-scoped MCP tools",
   "type": "module",
   "main": "./dist/index.js",
@@ -18,12 +18,12 @@
     "README.md"
   ],
   "dependencies": {
-    "@cuylabs/agent-core": "^3.1.0"
+    "@cuylabs/agent-core": "^4.0.0"
   },
   "peerDependencies": {
     "@microsoft/agents-a365-tooling": ">=0.2.0-preview.5 <1.0.0",
     "@microsoft/agents-hosting": ">=1.4.0",
-    "@cuylabs/agent-channel-m365": "^3.1.0"
+    "@cuylabs/agent-channel-m365": "^4.0.0"
   },
   "peerDependenciesMeta": {
     "@cuylabs/agent-channel-m365": {
@@ -43,7 +43,7 @@
     "typescript": "^5.7.0",
     "vitest": "^4.0.18",
     "zod": "^3.25.76 || ^4.1.8",
-    "@cuylabs/agent-channel-m365": "^3.1.0"
+    "@cuylabs/agent-channel-m365": "^4.0.0"
   },
   "keywords": [
     "agent",