pika-shared 1.3.0 → 1.4.0

package/dist/util/server-utils.mjs

@@ -1,5 +1,11 @@
 import { gunzipSync, gzipSync } from 'zlib';
 
+// src/util/server-utils.ts
+
+// src/types/chatbot/chatbot-types.ts
+var DEFAULT_MAX_MEMORY_RECORDS_PER_PROMPT = 25;
+var DEFAULT_MAX_K_MATCHES_PER_STRATEGY = 5;
+
 // src/util/server-utils.ts
 function gunzipBase64EncodedString(base64EncodedString) {
   const gzippedHexEncodedString = Buffer.from(base64EncodedString, "base64").toString("hex");
@@ -11,7 +17,301 @@ function gzipAndBase64EncodeString(string) {
   const gzippedBase64EncodedString = Buffer.from(gzippedHexEncodedString, "hex").toString("base64");
   return gzippedBase64EncodedString;
 }
+function getOverridableFeatures(siteFeatures, chatApp, user) {
+  const result = {
+    entity: {
+      enabled: false
+    },
+    verifyResponse: {
+      enabled: false
+    },
+    traces: {
+      enabled: false,
+      detailedTraces: false
+    },
+    fileUpload: {
+      mimeTypesAllowed: []
+    },
+    suggestions: {
+      suggestions: [],
+      randomize: false,
+      randomizeAfter: 0,
+      maxToShow: 5
+    },
+    promptInputFieldLabel: {
+      label: void 0
+    },
+    uiCustomization: {
+      showUserRegionInLeftNav: false,
+      showChatHistoryInStandaloneMode: false
+    },
+    chatDisclaimerNotice: void 0,
+    logout: {
+      enabled: false,
+      menuItemTitle: "Logout",
+      dialogTitle: "Logout",
+      dialogDescription: "Are you sure you want to logout?"
+    },
+    siteAdmin: {
+      websiteEnabled: false
+    },
+    tags: {
+      tagsEnabled: []
+    },
+    agentInstructionAssistance: {
+      enabled: false,
+      includeOutputFormattingRequirements: false,
+      includeInstructionsForTags: false,
+      completeExampleInstructionEnabled: false,
+      completeExampleInstructionLine: void 0,
+      jsonOnlyImperativeInstructionEnabled: false,
+      jsonOnlyImperativeInstructionLine: void 0
+    },
+    instructionAugmentation: {
+      enabled: false,
+      type: void 0
+    },
+    userMemory: {
+      enabled: false,
+      maxMemoryRecordsPerPrompt: DEFAULT_MAX_MEMORY_RECORDS_PER_PROMPT,
+      maxKMatchesPerStrategy: DEFAULT_MAX_K_MATCHES_PER_STRATEGY
+    }
+  };
+  const effectiveVerifyResponseFeature = chatApp.override?.features?.verifyResponse || chatApp.features?.verifyResponse;
+  result.verifyResponse = handleAccessRuleFeature(
+    "verifyResponse",
+    effectiveVerifyResponseFeature,
+    siteFeatures?.verifyResponse,
+    result.verifyResponse,
+    user,
+    (feature, enabled) => ({
+      enabled,
+      autoRepromptThreshold: feature.autoRepromptThreshold
+    })
+  );
+  const effectiveTracesFeature = chatApp.override?.features?.traces || chatApp.features?.traces;
+  result.traces = handleAccessRuleFeature("traces", effectiveTracesFeature, siteFeatures?.traces, result.traces, user, (feature, enabled) => {
+    let detailedTraces = false;
+    if (enabled && feature.detailedTraces) {
+      const siteDetailedTracesRule = siteFeatures?.traces?.detailedTraces || { enabled: false };
+      if (siteDetailedTracesRule.enabled) {
+        detailedTraces = checkUserAccessToFeature(user, feature.detailedTraces);
+      }
+    } else if (enabled) {
+      const siteDetailedTracesRule = siteFeatures?.traces?.detailedTraces || { enabled: false };
+      detailedTraces = checkUserAccessToFeature(user, siteDetailedTracesRule);
+    }
+    return {
+      enabled,
+      detailedTraces
+    };
+  });
+  const effectiveLogoutFeature = chatApp.override?.features?.logout || chatApp.features?.logout;
+  result.logout = handleAccessRuleFeature("logout", effectiveLogoutFeature, siteFeatures?.logout, result.logout, user, (feature, enabled) => ({
+    enabled,
+    menuItemTitle: feature.menuItemTitle ?? "Logout",
+    dialogTitle: feature.dialogTitle ?? "Logout",
+    dialogDescription: feature.dialogDescription ?? "Are you sure you want to logout?"
+  }));
+  const effectiveFileUploadFeature = chatApp.override?.features?.fileUpload || chatApp.features?.fileUpload;
+  result.fileUpload = handleSimpleFeature("fileUpload", effectiveFileUploadFeature, siteFeatures?.fileUpload, result.fileUpload, (feature) => ({
+    mimeTypesAllowed: feature.mimeTypesAllowed || []
+  }));
+  const effectiveSuggestionsFeature = chatApp.override?.features?.suggestions || chatApp.features?.suggestions;
+  result.suggestions = handleSimpleFeature("suggestions", effectiveSuggestionsFeature, siteFeatures?.suggestions, result.suggestions, (feature) => ({
+    suggestions: feature.suggestions || [],
+    randomize: feature.randomize ?? false,
+    randomizeAfter: feature.randomizeAfter ?? 0,
+    maxToShow: feature.maxToShow ?? 5
+  }));
+  const effectivePromptInputFieldLabelFeature = chatApp.override?.features?.promptInputFieldLabel || chatApp.features?.promptInputFieldLabel;
+  result.promptInputFieldLabel = handleEnabledOnlyFeature(
+    "promptInputFieldLabel",
+    effectivePromptInputFieldLabelFeature,
+    siteFeatures?.promptInputFieldLabel,
+    { },
+    // Default return shape
+    (feature, enabled) => ({
+      label: enabled ? feature.promptInputFieldLabel ?? "Ready to chat" : void 0
+    })
+  );
+  const effectiveUiCustomizationFeature = chatApp.override?.features?.uiCustomization || chatApp.features?.uiCustomization;
+  result.uiCustomization = handleSimpleFeature("uiCustomization", effectiveUiCustomizationFeature, siteFeatures?.uiCustomization, result.uiCustomization, (feature) => ({
+    showUserRegionInLeftNav: feature.showUserRegionInLeftNav ?? false,
+    showChatHistoryInStandaloneMode: feature.showChatHistoryInStandaloneMode ?? false
+  }));
+  const effectiveChatDisclaimerNoticeFeature = chatApp.override?.features?.chatDisclaimerNotice || chatApp.features?.chatDisclaimerNotice;
+  const disclaimerResult = handleEnabledOnlyFeature(
+    "chatDisclaimerNotice",
+    effectiveChatDisclaimerNoticeFeature,
+    siteFeatures?.chatDisclaimerNotice,
+    { },
+    (feature, enabled) => ({
+      notice: enabled ? feature.notice : void 0
+    })
+  );
+  result.chatDisclaimerNotice = disclaimerResult.notice;
+  const effectiveTagsFeature = chatApp.override?.features?.tags || chatApp.features?.tags;
+  result.tags = handleSimpleFeature("tags", effectiveTagsFeature, siteFeatures?.tags, result.tags, (feature) => ({
+    tagsEnabled: feature.tagsEnabled ?? []
+  }));
+  const effectiveAgentInstructionAssistanceFeature = chatApp.override?.features?.agentInstructionAssistance || chatApp.features?.agentInstructionAssistance;
+  result.agentInstructionAssistance = handleSimpleFeature(
+    "agentInstructionAssistance",
+    effectiveAgentInstructionAssistanceFeature,
+    siteFeatures?.agentInstructionAssistance,
+    result.agentInstructionAssistance,
+    (feature) => ({
+      enabled: feature.enabled ?? false,
+      includeOutputFormattingRequirements: feature.includeOutputFormattingRequirements?.enabled ?? false,
+      includeInstructionsForTags: feature.includeInstructionsForTags?.enabled ?? false,
+      completeExampleInstructionEnabled: feature.completeExampleInstructionLine?.enabled ?? false,
+      completeExampleInstructionLine: feature.completeExampleInstructionLine?.mdLine ?? void 0,
+      jsonOnlyImperativeInstructionEnabled: feature.jsonOnlyImperativeInstructionLine?.enabled ?? false,
+      jsonOnlyImperativeInstructionLine: feature.jsonOnlyImperativeInstructionLine?.line ?? void 0
+    })
+  );
+  const effectiveInstructionAugmentationFeature = chatApp.override?.features?.instructionAugmentation || chatApp.features?.instructionAugmentation;
+  result.instructionAugmentation = handleSimpleFeature(
+    "instructionAugmentation",
+    effectiveInstructionAugmentationFeature,
+    siteFeatures?.instructionAugmentation,
+    result.instructionAugmentation,
+    (feature) => ({
+      enabled: feature.enabled ?? false,
+      type: feature.type ?? "llm-semantic-directive-search"
+    })
+  );
+  const effectiveUserMemoryFeature = chatApp.override?.features?.userMemory || chatApp.features?.userMemory;
+  result.userMemory = handleSimpleFeature("userMemory", effectiveUserMemoryFeature, siteFeatures?.userMemory, result.userMemory, (feature) => ({
+    enabled: feature.enabled ?? false,
+    maxMemoryRecordsPerPrompt: feature.maxMemoryRecordsPerPrompt ?? DEFAULT_MAX_MEMORY_RECORDS_PER_PROMPT,
+    maxKMatchesPerStrategy: feature.maxKMatchesPerStrategy ?? DEFAULT_MAX_K_MATCHES_PER_STRATEGY
+  }));
+  const effectiveEntityFeature = chatApp.override?.features?.entity || chatApp.features?.entity;
+  if (siteFeatures?.entity?.enabled) {
+    if (effectiveEntityFeature?.enabled === false) {
+      result.entity.enabled = false;
+    } else {
+      result.entity.enabled = true;
+      if (!siteFeatures?.entity?.attributeName) {
+        throw new Error("Entity feature is enabled at the site level but the site features entity object does not have an attributeName set");
+      }
+      result.entity.attributeName = siteFeatures.entity.attributeName;
+    }
+  } else {
+    result.entity.enabled = false;
+  }
+  return result;
+}
+function handleSimpleFeature(featureName, appFeature, siteFeature, defaults, propertyExtractor) {
+  if (isSimpleFeatureOverrideValid(appFeature, featureName) && appFeature) {
+    return propertyExtractor(appFeature);
+  } else {
+    const siteRule = siteFeature || defaults;
+    return propertyExtractor(siteRule);
+  }
+}
+function handleEnabledOnlyFeature(featureName, appFeature, siteFeature, defaults, propertyExtractor) {
+  const overrideStatus = isFeatureOverrideValid(appFeature, featureName);
+  if (overrideStatus === "enabled" && appFeature) {
+    const siteRule = siteFeature || { enabled: false };
+    if (siteRule.enabled) {
+      return propertyExtractor(appFeature, true);
+    }
+    return propertyExtractor({}, false);
+  } else if (overrideStatus === "disabled") {
+    return propertyExtractor({}, false);
+  } else {
+    const siteRule = siteFeature || { enabled: true };
+    return propertyExtractor(siteRule, siteRule.enabled);
+  }
+}
+function isFeatureOverrideValid(appFeature, featureName) {
+  if (!appFeature) return "none";
+  if (Object.keys(appFeature).length === 0) {
+    console.error(`Invalid empty feature override for ${featureName}. Falling back to site level.`);
+    return "invalid";
+  }
+  if (!("enabled" in appFeature)) {
+    console.error(`Invalid feature override for ${featureName}: missing 'enabled' property. Falling back to site level.`);
+    return "invalid";
+  }
+  return appFeature.enabled ? "enabled" : "disabled";
+}
+function isSimpleFeatureOverrideValid(appFeature, featureName) {
+  if (!appFeature) return false;
+  if (Object.keys(appFeature).length === 0) {
+    console.error(`Invalid empty feature override for ${featureName}. Falling back to site level.`);
+    return false;
+  }
+  return true;
+}
+function handleAccessRuleFeature(featureName, appFeature, siteFeature, defaults, user, propertyExtractor) {
+  const overrideStatus = isFeatureOverrideValid(appFeature, featureName);
+  if (overrideStatus === "enabled" && appFeature) {
+    const siteRule = siteFeature || { enabled: false };
+    if (siteRule.enabled) {
+      const enabled = checkUserAccessToFeature(user, appFeature);
+      return propertyExtractor(appFeature, enabled);
+    }
+    return propertyExtractor(defaults, false);
+  } else if (overrideStatus === "disabled") {
+    return propertyExtractor(defaults, false);
+  } else {
+    const siteRule = siteFeature || { enabled: false };
+    const enabled = checkUserAccessToFeature(user, siteRule);
+    return propertyExtractor(siteRule, enabled);
+  }
+}
+function checkUserAccessToFeature(user, feature) {
+  let { enabled, userTypes, userRoles, applyRulesAs = "and" } = feature;
+  if (userTypes && userTypes.length > 0 && userRoles && userRoles.length === 0) {
+    userRoles = void 0;
+  }
+  if (userRoles && userRoles.length > 0 && (!userTypes || userTypes.length === 0)) {
+    userTypes = void 0;
+  }
+  if (!enabled) {
+    return false;
+  }
+  if (!userTypes && !userRoles) {
+    return false;
+  }
+  const userTypeMatches = userTypes ? userTypes.includes(user.userType ?? "external-user") : true;
+  const userRoleMatches = userRoles ? (user.roles ?? []).some((role) => userRoles.includes(role)) : true;
+  if (applyRulesAs === "and") {
+    return userTypeMatches && userRoleMatches;
+  } else {
+    return userTypeMatches || userRoleMatches;
+  }
+}
+function getEntityIdForUser(user, overrideDataForThisChatApp, entityAttributeName) {
+  let customUserData = overrideDataForThisChatApp || user.customData;
+  if (!entityAttributeName || !customUserData) {
+    return void 0;
+  }
+  let currentObject = customUserData;
+  const attributeParts = entityAttributeName.split(".");
+  let currentValue;
+  for (let i = 0; i < attributeParts.length; i++) {
+    const part = attributeParts[i];
+    if (!(part in currentObject)) {
+      return void 0;
+    }
+    if (i === attributeParts.length - 1) {
+      currentValue = currentObject[part];
+    } else {
+      if (typeof currentObject[part] === "object" && currentObject[part] !== null) {
+        currentObject = currentObject[part];
+      } else {
+        return void 0;
+      }
+    }
+  }
+  return currentValue;
+}
 
-export { gunzipBase64EncodedString, gzipAndBase64EncodeString };
+export { checkUserAccessToFeature, getEntityIdForUser, getOverridableFeatures, gunzipBase64EncodedString, gzipAndBase64EncodeString };
 //# sourceMappingURL=server-utils.mjs.map
 //# sourceMappingURL=server-utils.mjs.map