@memori.ai/memori-react 8.29.0 → 8.30.0

package/src/helpers/llmUsage.ts

@@ -0,0 +1,328 @@
+export interface LlmUsageOnLine {
+  provider?: string;
+  model?: string;
+  totalInputTokens?: number;
+  inputCacheReadTokens?: number;
+  inputCacheWriteTokens?: number;
+  outputTokens?: number;
+  durationMs?: number;
+  energyImpact?: {
+    energy?: number | { source?: string; parsedValue?: number };
+    energyUnit?: string;
+    gwp?: number | { source?: string; parsedValue?: number };
+    gwpUnit?: string;
+    wcf?: number | { source?: string; parsedValue?: number };
+    wcfUnit?: string;
+  };
+}
+
+export type UsageBadgeType = 'llm' | 'energy' | 'co2' | 'water';
+type NumericMetric = number | { source?: string; parsedValue?: number };
+type ImpactMetricType = 'energy' | 'co2' | 'water';
+type TranslateFn = (key: string, options?: { [key: string]: unknown }) => string;
+
+export interface LlmUsageLabels {
+  llm: string;
+  model: string;
+  provider: string;
+  tokens: string;
+  input: string;
+  output: string;
+  cacheRead: string;
+  cacheWrite: string;
+  duration: string;
+  energy: string;
+  co2: string;
+  water: string;
+  usageBadgesHint: string;
+}
+
+export const BADGE_EMOJI: Record<UsageBadgeType, string> = {
+  llm: '🤖',
+  energy: '⚡',
+  co2: '🌍',
+  water: '💧',
+};
+
+export const escapeHtml = (value: string): string =>
+  value
+    .replaceAll('&', '&amp;')
+    .replaceAll('<', '&lt;')
+    .replaceAll('>', '&gt;')
+    .replaceAll('"', '&quot;')
+    .replaceAll("'", '&#39;');
+
+export const getMetricValue = (metric?: NumericMetric): number | undefined => {
+  if (typeof metric === 'number' && Number.isFinite(metric)) return metric;
+  if (!metric || typeof metric !== 'object') return undefined;
+  if (
+    typeof metric.parsedValue === 'number' &&
+    Number.isFinite(metric.parsedValue)
+  ) {
+    return metric.parsedValue;
+  }
+  if (typeof metric.source === 'string') {
+    const parsed = Number(metric.source);
+    if (Number.isFinite(parsed)) return parsed;
+  }
+  return undefined;
+};
+
+const formatMetricValue = (value: number, locale = 'it-IT'): string => {
+  if (!Number.isFinite(value)) return '—';
+  if (value === 0) return '0';
+
+  const absValue = Math.abs(value);
+  return new Intl.NumberFormat(locale, {
+    minimumFractionDigits: 0,
+    maximumFractionDigits: absValue >= 1 ? 3 : 4,
+  }).format(value);
+};
+
+export const formatIntegerValue = (value: number, locale = 'it-IT'): string => {
+  if (!Number.isFinite(value)) return '0';
+  return new Intl.NumberFormat(locale, { maximumFractionDigits: 0 }).format(
+    value,
+  );
+};
+
+export const formatDuration = (durationMs?: number, locale = 'it-IT'): string => {
+  if (typeof durationMs !== 'number' || !Number.isFinite(durationMs)) {
+    return '—';
+  }
+  if (durationMs < 1000) return `${formatIntegerValue(durationMs, locale)} ms`;
+  return `${formatMetricValue(durationMs / 1000, locale)} s`;
+};
+
+const floorToSingleDecimal = (value: number): number =>
+  Math.floor(value * 10) / 10;
+
+const formatComparisonNumber = (value: number, locale = 'it-IT'): string =>
+  new Intl.NumberFormat(locale, {
+    minimumFractionDigits: 1,
+    maximumFractionDigits: 1,
+  }).format(floorToSingleDecimal(value));
+
+const formatReadableDuration = (seconds: number, locale = 'it-IT'): string => {
+  if (!Number.isFinite(seconds) || seconds <= 0) return '0 s';
+  if (seconds < 60) return `${formatComparisonNumber(seconds, locale)} s`;
+
+  const minutes = seconds / 60;
+  if (minutes < 60) return `${formatComparisonNumber(minutes, locale)} min`;
+
+  return `${formatComparisonNumber(minutes / 60, locale)} h`;
+};
+
+const formatReadableDistance = (meters: number, locale = 'it-IT'): string => {
+  if (!Number.isFinite(meters) || meters <= 0) return '0 m';
+  if (meters < 1000) return `${formatComparisonNumber(meters, locale)} m`;
+  return `${formatComparisonNumber(meters / 1000, locale)} km`;
+};
+
+const getApiUnitToBaseFactor = (
+  unitFromApi: string | undefined,
+  metricType: ImpactMetricType,
+): number => {
+  const u = (unitFromApi ?? '').trim().toLowerCase();
+  if (metricType === 'energy') {
+    if (u === 'kwh') return 1;
+    if (u === 'wh') return 0.001;
+    if (u === 'mwh') return 0.000001;
+    return 1;
+  }
+  if (metricType === 'co2') {
+    if (u === 'kg' || u === 'kgco2eq') return 1;
+    if (u === 'g') return 0.001;
+    if (u === 'mg') return 0.000001;
+    return 1;
+  }
+  if (u === 'l') return 1;
+  if (u === 'ml') return 0.001;
+  if (u === 'μl' || u === 'ul') return 0.000001;
+  return 1;
+};
+
+export const formatImpactInReadableUnit = (
+  value: number,
+  metricType: ImpactMetricType,
+  locale = 'it-IT',
+): string => {
+  const absValue = Math.abs(value);
+
+  if (metricType === 'energy') {
+    if (absValue >= 1) return `${formatMetricValue(value, locale)} kWh`;
+    const wattHours = value * 1000;
+    if (Math.abs(wattHours) >= 1) return `${formatMetricValue(wattHours, locale)} Wh`;
+    return `${formatMetricValue(wattHours * 1000, locale)} mWh`;
+  }
+
+  if (metricType === 'co2') {
+    if (absValue >= 1) return `${formatMetricValue(value, locale)} kg`;
+    const grams = value * 1000;
+    if (Math.abs(grams) >= 1) return `${formatMetricValue(grams, locale)} g`;
+    return `${formatMetricValue(grams * 1000, locale)} mg`;
+  }
+
+  if (absValue >= 1) return `${formatMetricValue(value, locale)} L`;
+  const milliliters = value * 1000;
+  if (Math.abs(milliliters) >= 1) return `${formatMetricValue(milliliters, locale)} mL`;
+  return `${formatMetricValue(milliliters * 1000, locale)} μL`;
+};
+
+export const formatImpactWithApiUnit = (
+  value: number,
+  unitFromApi: string | undefined,
+  fallbackUnit: string,
+  metricType: ImpactMetricType,
+  locale = 'it-IT',
+): string => {
+  const factor = getApiUnitToBaseFactor(
+    unitFromApi ?? fallbackUnit,
+    metricType,
+  );
+  const baseValue = value * factor;
+  return formatImpactInReadableUnit(baseValue, metricType, locale);
+};
+
+export const getImpactComparison = (
+  value: number,
+  metricType: ImpactMetricType,
+  locale = 'it-IT',
+  t: TranslateFn,
+): string => {
+  if (!Number.isFinite(value) || value <= 0) {
+    return t('chatLogs.impactComparisonUnavailable');
+  }
+
+  if (metricType === 'energy') {
+    const ledSeconds = (value * 1000 * 3600) / 10;
+    return t('chatLogs.impactComparisonEnergy', {
+      duration: formatReadableDuration(ledSeconds, locale),
+    });
+  }
+
+  if (metricType === 'co2') {
+    const averageCarMeters = (value / 0.12) * 1000;
+    return t('chatLogs.impactComparisonCo2', {
+      distance: formatReadableDistance(averageCarMeters, locale),
+    });
+  }
+
+  const drops = (value * 1000) / 0.05;
+  return t('chatLogs.impactComparisonWater', {
+    count: formatComparisonNumber(drops, locale),
+  });
+};
+
+const buildUsageBadgeHtml = ({
+  badgeType,
+  badgeClassName,
+  label,
+  value,
+  lineIndex,
+  emoji,
+}: {
+  badgeType: UsageBadgeType;
+  badgeClassName: string;
+  label: string;
+  value?: string;
+  lineIndex: number;
+  emoji: string;
+}): string => {
+  const escapedLabel = escapeHtml(label);
+  const valueHtml = value
+    ? `<span class="memori-chat--usage-badge-value">${value}</span>`
+    : '';
+  const content =
+    valueHtml ||
+    `<span class="memori-chat--usage-badge-label">${escapedLabel}</span>`;
+
+  return `<button type="button" class="memori-chat--usage-badge ${badgeClassName}" data-llm-badge-type="${badgeType}" data-line-index="${lineIndex}" aria-label="${escapedLabel}">${emoji} ${content}</button>`;
+};
+
+export const buildLlmUsageHtml = (
+  usage: LlmUsageOnLine,
+  labels: LlmUsageLabels,
+  lineIndex: number,
+  locale = 'it-IT',
+): string => {
+  const badges = [
+    buildUsageBadgeHtml({
+      badgeType: 'llm',
+      badgeClassName: 'memori-chat--usage-badge-llm',
+      label: labels.llm,
+      lineIndex,
+      emoji: BADGE_EMOJI.llm,
+    }),
+  ];
+
+  const energy = getMetricValue(usage.energyImpact?.energy);
+  const gwp = getMetricValue(usage.energyImpact?.gwp);
+  const wcf = getMetricValue(usage.energyImpact?.wcf);
+
+  if (typeof energy === 'number') {
+    const energyFormatted = formatImpactWithApiUnit(
+      energy,
+      usage.energyImpact?.energyUnit,
+      'kWh',
+      'energy',
+      locale,
+    );
+    badges.push(
+      buildUsageBadgeHtml({
+        badgeType: 'energy',
+        badgeClassName: 'memori-chat--usage-badge-energy',
+        label: `${labels.energy} ${energyFormatted}`,
+        value: escapeHtml(energyFormatted),
+        lineIndex,
+        emoji: BADGE_EMOJI.energy,
+      }),
+    );
+  }
+
+  if (typeof gwp === 'number') {
+    const co2Formatted = formatImpactWithApiUnit(
+      gwp,
+      usage.energyImpact?.gwpUnit,
+      'kgCO2eq',
+      'co2',
+      locale,
+    );
+    badges.push(
+      buildUsageBadgeHtml({
+        badgeType: 'co2',
+        badgeClassName: 'memori-chat--usage-badge-co2',
+        label: `${labels.co2} ${co2Formatted}`,
+        value: escapeHtml(co2Formatted),
+        lineIndex,
+        emoji: BADGE_EMOJI.co2,
+      }),
+    );
+  }
+
+  if (typeof wcf === 'number') {
+    const waterFormatted = formatImpactWithApiUnit(
+      wcf,
+      usage.energyImpact?.wcfUnit,
+      'L',
+      'water',
+      locale,
+    );
+    badges.push(
+      buildUsageBadgeHtml({
+        badgeType: 'water',
+        badgeClassName: 'memori-chat--usage-badge-water',
+        label: `${labels.water} ${waterFormatted}`,
+        value: escapeHtml(waterFormatted),
+        lineIndex,
+        emoji: BADGE_EMOJI.water,
+      }),
+    );
+  }
+
+  return `<div class="memori-chat--llm-usage" data-llm-usage><hr class="memori-chat--llm-usage-hr" /><p class="memori-chat--llm-usage-hint">${escapeHtml(
+    labels.usageBadgesHint,
+  )}</p><div class="memori-chat--llm-usage-badges">${badges.join(
+    '',
+  )}</div></div>`;
+};

package/src/helpers/message.ts

@@ -177,3 +177,6 @@ export const renderMsg = (
     return { text };
   }
 };
+
+export const sanitizeMsg = (msg: string) =>
+  DOMPurify.sanitize(msg, { ADD_ATTR: ['target'] });

package/src/index.stories.tsx

@@ -86,8 +86,8 @@ WithChatHistory.args = {
   showChatHistory: true,
 };
 
-export const WithUploadWithMaxTotalMessagePayload = Template.bind({});
-WithUploadWithMaxTotalMessagePayload.args = {
+export const WithUploadNoTotalPayloadLimit = Template.bind({});
+WithUploadNoTotalPayloadLimit.args = {
   ownerUserName: 'nzambello',
   memoriName: 'Nicola',
   tenantID: 'www.aisuru.com',
@@ -98,7 +98,6 @@ WithUploadWithMaxTotalMessagePayload.args = {
   spokenLang: 'IT',
   enableAudio: true,
   showUpload: true,
-  maxTotalMessagePayload: 300000,
 };
 
 export const WithMaxTextareaCharacters = Template.bind({});

package/src/index.tsx

@@ -44,6 +44,7 @@ export interface Props {
   showInputs?: boolean;
   showDates?: boolean;
   showContextPerLine?: boolean;
+  showMessageConsumption?: boolean;
   showSettings?: boolean;
   __WEBCOMPONENT__?: boolean;
   showClear?: boolean;
@@ -77,7 +78,7 @@ export interface Props {
   useMathFormatting?: boolean;
   autoStart?: boolean;
   applyVarsToRoot?: boolean;
-  /** Override total document payload and per-document content limit (character count). Default from constants (200000). */
+  /** Max per-document content length (character count). Kept name for backward compatibility. Default: 300000. */
   maxTotalMessagePayload?: number;
   /** Max characters allowed in the chat textarea. When set, shows a counter (e.g. "0 / 500") and enforces that pasted content + existing text does not exceed this limit. */
   maxTextareaCharacters?: number;
@@ -131,6 +132,7 @@ const Memori: React.FC<Props> = ({
   showInputs = true,
   showDates = false,
   showContextPerLine = false,
+  showMessageConsumption = false,
   showUpload,
   showLogin,
   showReasoning,
@@ -372,6 +374,7 @@ const Memori: React.FC<Props> = ({
         showUpload,
         showReasoning,
         showContextPerLine,
+        showMessageConsumption,
         initialContextVars:
           context ?? getParsedContext(layoutIntegrationConfig.contextVars),
         initialQuestion:
@@ -540,6 +543,7 @@ Memori.propTypes = {
   showInputs: PropTypes.bool,
   showDates: PropTypes.bool,
   showContextPerLine: PropTypes.bool,
+  showMessageConsumption: PropTypes.bool,
   showSettings: PropTypes.bool,
   showClear: PropTypes.bool,
   showOnlyLastMessages: PropTypes.bool,

package/src/locales/de.json

@@ -172,6 +172,7 @@
     "pressAndHoldToSpeak": "Zum Sprechen gedrückt halten",
     "microphoneMode": "Mikrofonmodus",
     "hideEmissionsLabel": "Vom Zwilling ausgegebenen Text ausblenden",
+    "showMessageConsumptionLabel": "Verbrauch pro Nachricht anzeigen",
     "secondsLabel": "Sekunden einstellen",
     "controlsPosition": "Steuert die Position",
     "tryMeHeaderLabel": "VERSUCHEN",
@@ -369,6 +370,27 @@
     "successfullyLoggedIn": "{{username}} hat sich erfolgreich angemeldet"
   },
   "chatLogs": {
+    "llm": "LLM",
+    "model": "Modell",
+    "provider": "Anbieter",
+    "tokens": "Tokens",
+    "input": "Eingabe",
+    "output": "Ausgabe",
+    "cacheRead": "Cache lesen",
+    "cacheWrite": "Cache schreiben",
+    "duration": "Dauer",
+    "energy": "Energie",
+    "co2": "CO2",
+    "water": "Wasser",
+    "usageBadgesHint": "Klicke auf einen dieser Buttons, um mehr Informationen zu sehen",
+    "impactComparisonUnavailable": "Indikativer Vergleich nicht verfuegbar.",
+    "impactComparisonEnergy": "Indikativer Vergleich: in etwa wie eine 10-W-LED-Lampe fuer {{duration}} eingeschaltet lassen.",
+    "impactComparisonCo2": "Indikativer Vergleich: etwa {{distance}} mit einem durchschnittlichen Benzinauto gefahren.",
+    "impactComparisonWater": "Indikativer Vergleich: etwa {{count}} Wassertropfen.",
+    "energyImpactDescription": "Dieser Wert schaetzt die elektrische Energie, die zur Erzeugung der Modellantwort benoetigt wird. Er hilft, Prompts, Modelle und Strategien zu vergleichen, auch wenn eine einzelne Nachricht nur sehr geringe Auswirkungen hat.",
+    "co2ImpactDescription": "CO2-Aequivalent steht fuer die geschaetzten Klimaauswirkungen der Nachricht. Die Umrechnung des Verbrauchs in Emissionen hilft, die Umweltauswirkungen einer KI-Antwort mit vergleichbaren Kennzahlen zu verstehen.",
+    "waterImpactDescription": "Dieser Indikator zeigt den geschaetzten Wasserfussabdruck der Nachrichtenverarbeitung. Er umfasst Wasser, das indirekt in Energie und Infrastruktur eingesetzt wird, die die Berechnung ermoeglichen.",
+    "approximateValuesTooltip": "Diese Werte sind ungefaehr.",
     "anyMessage": "Jede Nachricht",
     "atLeast": "Mindestens {{count}} Nachrichten",
     "atLeast2": "Mindestens 2 Nachrichten",

package/src/locales/en.json

@@ -174,6 +174,7 @@
     "pressAndHoldToSpeak": "Press and hold to speak",
     "microphoneMode": "Microphone mode",
     "hideEmissionsLabel": "Hide text emitted by the agent",
+    "showMessageConsumptionLabel": "Show message consumption",
     "secondsLabel": "Set seconds",
     "controlsPosition": "Controls position",
     "avatarControls": "Avatar controls",
@@ -440,6 +441,27 @@
     "successfullyLoggedIn": "{{username}} has successfully logged in"
   },
   "chatLogs": {
+    "llm": "LLM",
+    "model": "Model",
+    "provider": "Provider",
+    "tokens": "Tokens",
+    "input": "Input",
+    "output": "Output",
+    "cacheRead": "Cache read",
+    "cacheWrite": "Cache write",
+    "duration": "Duration",
+    "energy": "Energy",
+    "co2": "CO2",
+    "water": "Water",
+    "usageBadgesHint": "Click one of these buttons to show more information",
+    "impactComparisonUnavailable": "Indicative comparison unavailable.",
+    "impactComparisonEnergy": "Indicative comparison: roughly like keeping a 10 W LED bulb on for {{duration}}.",
+    "impactComparisonCo2": "Indicative comparison: about {{distance}} traveled by an average gasoline car.",
+    "impactComparisonWater": "Indicative comparison: about {{count}} drops of water.",
+    "energyImpactDescription": "This value estimates the electrical energy needed to generate the model response. It helps compare prompts, models, and strategies even when a single message has a very small impact.",
+    "co2ImpactDescription": "CO2 equivalent represents the estimated climate impact of the message. Converting consumption into emissions helps understand AI impact with comparable metrics.",
+    "waterImpactDescription": "This indicator shows the estimated water footprint associated with processing the message. It includes water indirectly used by the energy and infrastructure supporting computation.",
+    "approximateValuesTooltip": "These values are approximate.",
     "anyMessage": "Any message",
     "atLeast": "At least {{count}} messages",
     "atLeast2": "At least 2 messages",

package/src/locales/es.json

@@ -172,6 +172,7 @@
     "pressAndHoldToSpeak": "Mantenga presionado para hablar",
     "microphoneMode": "Modo micrófono",
     "hideEmissionsLabel": "Ocultar texto emitido por el Agent",
+    "showMessageConsumptionLabel": "Mostrar consumo por mensaje",
     "secondsLabel": "Establecer segundos",
     "controlsPosition": "Posición de los controles",
     "tryMeHeaderLabel": "INTENTAR",
@@ -396,6 +397,27 @@
     "successfullyLoggedIn": "{{username}} ha iniciado sesión correctamente"
   },
   "chatLogs": {
+    "llm": "LLM",
+    "model": "Modelo",
+    "provider": "Proveedor",
+    "tokens": "Tokens",
+    "input": "Entrada",
+    "output": "Salida",
+    "cacheRead": "Lectura de caché",
+    "cacheWrite": "Escritura de caché",
+    "duration": "Duración",
+    "energy": "Energía",
+    "co2": "CO2",
+    "water": "Agua",
+    "usageBadgesHint": "Haz clic en uno de estos botones para ver más información",
+    "impactComparisonUnavailable": "Comparacion indicativa no disponible.",
+    "impactComparisonEnergy": "Comparacion indicativa: aproximadamente como mantener encendida una bombilla LED de 10 W durante {{duration}}.",
+    "impactComparisonCo2": "Comparacion indicativa: aproximadamente {{distance}} recorridos en un coche de gasolina promedio.",
+    "impactComparisonWater": "Comparacion indicativa: aproximadamente {{count}} gotas de agua.",
+    "energyImpactDescription": "Este valor estima la energia electrica necesaria para generar la respuesta del modelo. Sirve para comparar prompts, modelos y estrategias incluso cuando un solo mensaje tiene un impacto muy pequeno.",
+    "co2ImpactDescription": "El CO2 equivalente representa el impacto climatico estimado del mensaje. Traducir el consumo a emisiones ayuda a entender cuanto pesa una respuesta de IA en el medioambiente con metricas comparables.",
+    "waterImpactDescription": "Este indicador muestra la huella hidrica estimada asociada al procesamiento del mensaje. Incluye el agua utilizada indirectamente en la energia y en la infraestructura que soporta el calculo.",
+    "approximateValuesTooltip": "Estos valores son aproximados.",
     "anyMessage": "Cualquier mensaje",
     "atLeast": "Al menos {{count}} mensajes",
     "atLeast2": "Al menos 2 mensajes",

package/src/locales/fr.json

@@ -180,6 +180,7 @@
     "pressAndHoldToSpeak": "Appuyez et maintenez pour parler",
     "microphoneMode": "Mode micro",
     "hideEmissionsLabel": "Masquer le texte émis par le Agent",
+    "showMessageConsumptionLabel": "Afficher la consommation par message",
     "secondsLabel": "Régler les secondes",
     "controlsPosition": "Position des commandes",
     "tryMeHeaderLabel": "ESSAYER",
@@ -404,6 +405,27 @@
     "successfullyLoggedIn": "{{username}} s'est connecté avec succès"
   },
   "chatLogs": {
+    "llm": "LLM",
+    "model": "Modèle",
+    "provider": "Fournisseur",
+    "tokens": "Tokens",
+    "input": "Entrée",
+    "output": "Sortie",
+    "cacheRead": "Lecture cache",
+    "cacheWrite": "Écriture cache",
+    "duration": "Durée",
+    "energy": "Énergie",
+    "co2": "CO2",
+    "water": "Eau",
+    "usageBadgesHint": "Cliquez sur un de ces boutons pour afficher plus d'informations",
+    "impactComparisonUnavailable": "Comparaison indicative non disponible.",
+    "impactComparisonEnergy": "Comparaison indicative : environ comme laisser allumee une ampoule LED de 10 W pendant {{duration}}.",
+    "impactComparisonCo2": "Comparaison indicative : environ {{distance}} parcourus en voiture essence moyenne.",
+    "impactComparisonWater": "Comparaison indicative : environ {{count}} gouttes d'eau.",
+    "energyImpactDescription": "Cette valeur estime l'energie electrique necessaire pour generer la reponse du modele. Elle permet de comparer prompts, modeles et strategies meme quand l'impact d'un seul message est tres faible.",
+    "co2ImpactDescription": "Le CO2 equivalent represente l'impact climatique estime du message. Traduire la consommation en emissions aide a comprendre le poids environnemental d'une reponse IA avec des mesures comparables.",
+    "waterImpactDescription": "Cet indicateur montre l'empreinte hydrique estimee associee au traitement du message. Il inclut l'eau utilisee indirectement par l'energie et l'infrastructure qui soutiennent le calcul.",
+    "approximateValuesTooltip": "Ces valeurs sont approximatives.",
     "anyMessage": "Tout message",
     "atLeast": "Au moins {{count}} messages",
     "atLeast2": "Au moins 2 messages",

package/src/locales/it.json

@@ -177,6 +177,7 @@
     "pressAndHoldToSpeak": "Premi e tieni premuto per parlare",
     "microphoneMode": "Modalità microfono",
     "hideEmissionsLabel": "Nascondi testo emesso dall'agente",
+    "showMessageConsumptionLabel": "Mostra consumo per messaggio",
     "secondsLabel": "Secondi",
     "controlsPosition": "Posizione dei controlli",
     "avatarControls": "Controlli Avatar",
@@ -437,6 +438,27 @@
     "successfullyLoggedIn": "{{username}} ha effettuato l'accesso con successo"
   },
   "chatLogs": {
+    "llm": "LLM",
+    "model": "Modello",
+    "provider": "Provider",
+    "tokens": "Token",
+    "input": "Input",
+    "output": "Output",
+    "cacheRead": "Cache read",
+    "cacheWrite": "Cache write",
+    "duration": "Durata",
+    "energy": "Energia",
+    "co2": "CO2",
+    "water": "Acqua",
+    "usageBadgesHint": "Clicca uno di questi pulsanti per mostrare maggiori informazioni",
+    "impactComparisonUnavailable": "Confronto indicativo non disponibile.",
+    "impactComparisonEnergy": "Confronto indicativo: circa quanto tenere accesa una lampadina LED da 10 W per {{duration}}.",
+    "impactComparisonCo2": "Confronto indicativo: circa {{distance}} percorsi in auto a benzina media.",
+    "impactComparisonWater": "Confronto indicativo: circa {{count}} gocce d'acqua.",
+    "energyImpactDescription": "Questo valore stima l'energia elettrica necessaria per generare la risposta del modello. Serve a confrontare prompt, modelli e strategie diverse anche quando il singolo messaggio ha un impatto molto piccolo.",
+    "co2ImpactDescription": "La CO2 equivalente rappresenta l'impatto climatico stimato del messaggio. Tradurre il consumo in emissioni aiuta a capire quanto una risposta AI pesa sull'ambiente in termini comparabili.",
+    "waterImpactDescription": "Questo indicatore mostra l'impronta idrica stimata associata all'elaborazione del messaggio. Include l'acqua impiegata indirettamente nell'energia e nell'infrastruttura che supportano il calcolo.",
+    "approximateValuesTooltip": "Questi valori sono approssimativi.",
     "atLeast": "Almeno {{count}} messaggi",
     "anyMessage": "Qualunque messaggio",
     "atLeast2": "Almeno 2 messaggi",

package/src/version.ts

@@ -1,2 +1,2 @@
 // This file is auto-generated. Do not edit manually.
-export const version = '8.29.0';
+export const version = '8.30.0';