@open-mercato/ai-assistant 0.6.7-develop.6775.1.c2313bb8a3 → 0.6.7-develop.6785.1.1dd7cfac55

package/dist/modules/ai_assistant/lib/agent-runtime.js

@@ -11,6 +11,18 @@ import {
   Experimental_Agent as ToolLoopAgent
 } from "ai";
 import { createModelFactory, resolveAllowRuntimeOverride } from "./model-factory.js";
+import { computeEndUserIdentifier } from "@open-mercato/shared/lib/ai/safety-identifier";
+import { llmProviderRegistry } from "@open-mercato/shared/lib/ai/llm-provider-registry";
+import {
+  AiModerationBlockedError,
+  AiModerationUnavailableError
+} from "./moderation.js";
+import {
+  isModerationActive,
+  resolveModerationPolicy,
+  shouldFailClosed
+} from "./moderation-policy.js";
+import { recordModerationFlag } from "./moderation-flag-recorder.js";
 import {
   resolveAiAgentTools,
   AgentPolicyError,
@@ -397,7 +409,7 @@ function assertLoopObjectModeCompatible(loopConfig) {
     );
   }
 }
-function resolveAgentModel(agent, modelOverride, providerOverride, container, baseUrlOverride, tenantOverride, requestOverride, tenantAllowlist) {
+function resolveAgentModel(agent, modelOverride, providerOverride, container, baseUrlOverride, tenantOverride, requestOverride, tenantAllowlist, endUserIdentifier) {
   const effectiveContainer = container ?? createContainer();
   const resolution = createModelFactory(effectiveContainer).resolveModel({
     moduleId: agent.moduleId,
@@ -410,14 +422,88 @@ function resolveAgentModel(agent, modelOverride, providerOverride, container, ba
     allowRuntimeOverride: resolveAllowRuntimeOverride(agent),
     tenantOverride: tenantOverride ?? void 0,
     requestOverride: requestOverride ?? void 0,
-    tenantAllowlist: tenantAllowlist ?? null
+    tenantAllowlist: tenantAllowlist ?? null,
+    endUserIdentifier
   });
   return {
     model: resolution.model,
     modelId: resolution.modelId,
-    providerId: resolution.providerId
+    providerId: resolution.providerId,
+    providerOptions: resolution.providerOptions,
+    supportsInputModeration: resolution.supportsInputModeration === true,
+    baseURL: resolution.baseURL
   };
 }
+function extractLatestUserText(messages) {
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const raw = messages[index];
+    if (raw.role !== "user") continue;
+    if (Array.isArray(raw.parts)) {
+      return raw.parts.filter((part) => part?.type === "text" && typeof part.text === "string").map((part) => part.text).join("\n");
+    }
+    return typeof raw.content === "string" ? raw.content : "";
+  }
+  return "";
+}
+async function runInputModerationGate(params) {
+  const policy = resolveModerationPolicy({
+    untrustedInput: params.untrustedInput,
+    perAgentOverride: params.perAgentOverride,
+    tenantWideOverride: params.tenantWideOverride,
+    env: params.env
+  });
+  if (!isModerationActive(policy)) return;
+  if (!params.supportsInputModeration) return;
+  const text = params.userText.trim();
+  if (!text) return;
+  const failClosed = shouldFailClosed(policy);
+  const failOpenOrThrow = (reason, error) => {
+    if (failClosed) {
+      if (error instanceof AiModerationUnavailableError) throw error;
+      throw new AiModerationUnavailableError(reason, error);
+    }
+    logger.warn("Input moderation unavailable; failing open for opt-in surface", { reason });
+  };
+  if (!params.service) {
+    return failOpenOrThrow("moderation service is not available in the container");
+  }
+  const apiKey = params.resolveApiKey();
+  if (!apiKey) {
+    return failOpenOrThrow("no API key available for the moderation provider");
+  }
+  let result;
+  try {
+    result = await params.service.checkInput({
+      text,
+      apiKey,
+      baseURL: params.baseURL,
+      model: params.moderationModel
+    });
+  } catch (error) {
+    if (error instanceof AiModerationUnavailableError) {
+      return failOpenOrThrow(error.message, error);
+    }
+    throw error;
+  }
+  if (result.flagged) {
+    if (params.onFlagged) {
+      try {
+        await params.onFlagged(result.categories);
+      } catch (error) {
+        logger.error("Moderation flag side effect failed (rejection still applies)", { err: error });
+      }
+    }
+    throw new AiModerationBlockedError(result.categories);
+  }
+}
+function resolveEndUserIdentifier(authContext) {
+  try {
+    return computeEndUserIdentifier(authContext.tenantId, authContext.userId);
+  } catch (error) {
+    logger.warn("Failed to derive end-user safety identifier", { err: error });
+    return void 0;
+  }
+}
 async function resolveTenantAllowlistSnapshot(container, tenantId, organizationId) {
   if (!tenantId || !container) return null;
   let em = null;
@@ -550,6 +636,31 @@ async function resolveRuntimeModelOverride(agentId, container, tenantId, organiz
     return null;
   }
 }
+async function resolveModerationOverrideValues(container, tenantId, organizationId, agentId) {
+  const empty = { perAgentOverride: null, tenantWideOverride: null };
+  if (!tenantId || !container) return empty;
+  let em = null;
+  try {
+    em = container.resolve("em");
+  } catch {
+    em = null;
+  }
+  if (!em) return empty;
+  try {
+    const repo = new AiAgentRuntimeOverrideRepository(em);
+    const [agentRow, tenantRow] = await Promise.all([
+      repo.getExact({ tenantId, organizationId: organizationId ?? null, agentId }),
+      repo.getDefault({ tenantId, organizationId: organizationId ?? null, agentId: null })
+    ]);
+    return {
+      perAgentOverride: agentRow?.inputModeration ?? null,
+      tenantWideOverride: tenantRow?.inputModeration ?? null
+    };
+  } catch (error) {
+    logger.warn("Moderation override lookup failed; falling back to env default", { agentId, err: error });
+    return empty;
+  }
+}
 function ensureUiMessageShape(messages) {
   return messages.map((message, index) => {
     const raw = message;
@@ -750,10 +861,47 @@ async function runAiAgentText(input) {
     input.baseUrlOverride,
     tenantRuntimeOverride,
     input.requestOverride,
-    tenantAllowlistSnapshot
+    tenantAllowlistSnapshot,
+    resolveEndUserIdentifier(input.authContext)
   );
   const { model } = resolvedModel;
+  const modelProviderOptions = resolvedModel.providerOptions;
   const normalizedMessages = ensureUiMessageShape(input.messages);
+  let moderationService = null;
+  try {
+    moderationService = input.container?.resolve("moderationService") ?? null;
+  } catch {
+    moderationService = null;
+  }
+  const moderationOverrides = resolvedModel.supportsInputModeration && agent.untrustedInput !== true ? await resolveModerationOverrideValues(
+    input.container,
+    input.authContext.tenantId,
+    input.authContext.organizationId,
+    agent.id
+  ) : { perAgentOverride: null, tenantWideOverride: null };
+  await runInputModerationGate({
+    untrustedInput: agent.untrustedInput,
+    supportsInputModeration: resolvedModel.supportsInputModeration,
+    perAgentOverride: moderationOverrides.perAgentOverride,
+    tenantWideOverride: moderationOverrides.tenantWideOverride,
+    userText: extractLatestUserText(normalizedMessages),
+    service: moderationService,
+    resolveApiKey: () => llmProviderRegistry.get(resolvedModel.providerId)?.resolveApiKey() ?? null,
+    baseURL: resolvedModel.baseURL,
+    moderationModel: process.env.OM_AI_MODERATION_MODEL,
+    onFlagged: (categories) => recordModerationFlag(
+      {
+        tenantId: input.authContext.tenantId,
+        organizationId: input.authContext.organizationId,
+        agentId: agent.id,
+        userId: input.authContext.userId,
+        providerId: resolvedModel.providerId,
+        modelId: resolvedModel.modelId,
+        categories
+      },
+      input.container
+    )
+  });
   const hydratedMessages = attachAttachmentsToMessages(normalizedMessages, resolvedAttachments);
   const modelMessages = await convertToModelMessages(hydratedMessages);
   const effectiveLoop = resolveEffectiveLoopConfig(agent, input.loop, WRAPPER_DEFAULT_LOOP_CHAT);
@@ -814,7 +962,8 @@ async function runAiAgentText(input) {
       onStepFinish: wiredOnStepFinish,
       ...effectiveLoop.repairToolCall !== void 0 ? { experimental_repairToolCall: effectiveLoop.repairToolCall } : {},
       ...sdkActiveTools !== void 0 ? { activeTools: sdkActiveTools } : {},
-      ...sdkToolChoice !== void 0 ? { toolChoice: sdkToolChoice } : {}
+      ...sdkToolChoice !== void 0 ? { toolChoice: sdkToolChoice } : {},
+      ...modelProviderOptions !== void 0 ? { providerOptions: modelProviderOptions } : {}
     };
     builtToolLoopAgent = new ToolLoopAgent(agentSettings);
   }
@@ -835,6 +984,7 @@ async function runAiAgentText(input) {
     toolChoice: sdkToolChoice,
     abortSignal: abortController.signal,
     finalizeLoopTrace: () => loopTraceCollector.finalize(budgetEnforcer.abortReason),
+    ...modelProviderOptions !== void 0 ? { providerOptions: modelProviderOptions } : {},
     ...builtToolLoopAgent !== void 0 ? { toolLoopAgent: builtToolLoopAgent } : {}
   };
   const taskPlanId = `turn_${turnId}`;
@@ -894,6 +1044,7 @@ async function runAiAgentText(input) {
     experimental_repairToolCall: effectiveLoop.repairToolCall,
     ...sdkActiveTools !== void 0 ? { activeTools: sdkActiveTools } : {},
     ...sdkToolChoice !== void 0 ? { toolChoice: sdkToolChoice } : {},
+    ...modelProviderOptions !== void 0 ? { providerOptions: modelProviderOptions } : {},
     abortSignal: abortController.signal
   });
   if (wallClockTimer !== void 0) {
@@ -1101,11 +1252,13 @@ export {
   buildLoopTraceCollector,
   buildWrapperPrepareStep,
   composeSystemPrompt,
+  extractLatestUserText,
   mergeStepOverrides,
   resolveEffectiveLoopConfig,
   resolveLoopBudgetPreset,
   runAiAgentObject,
   runAiAgentText,
+  runInputModerationGate,
   translateStopConditions
 };
 //# sourceMappingURL=agent-runtime.js.map