Feat/i18n workflow (#4819)

web/i18n/de-DE/workflow.ts

@@ -1,58 +1,58 @@
 const translation = {
   common: {
-    editing: 'Bearbeiten',
+    editing: 'Bearbeitung',
     autoSaved: 'Automatisch gespeichert',
-    unpublished: 'Nicht veröffentlicht',
+    unpublished: 'Unveröffentlicht',
     published: 'Veröffentlicht',
     publish: 'Veröffentlichen',
     update: 'Aktualisieren',
-    run: 'Starten',
-    running: 'Läuft',
-    inRunMode: 'Im Start-Modus',
-    inPreview: 'In Vorschau',
-    inPreviewMode: 'Im Vorschau-Modus',
+    run: 'Ausführen',
+    running: 'Wird ausgeführt',
+    inRunMode: 'Im Ausführungsmodus',
+    inPreview: 'In der Vorschau',
+    inPreviewMode: 'Im Vorschaumodus',
     preview: 'Vorschau',
-    viewRunHistory: 'Verlauf ansehen',
-    runHistory: 'Verlauf',
-    goBackToEdit: 'Zurück zum Bearbeiten',
+    viewRunHistory: 'Ausführungsverlauf anzeigen',
+    runHistory: 'Ausführungsverlauf',
+    goBackToEdit: 'Zurück zum Editor',
     conversationLog: 'Konversationsprotokoll',
     features: 'Funktionen',
     debugAndPreview: 'Debuggen und Vorschau',
     restart: 'Neustarten',
     currentDraft: 'Aktueller Entwurf',
-    currentDraftUnpublished: 'Aktueller Entwurf nicht veröffentlicht',
+    currentDraftUnpublished: 'Aktueller Entwurf unveröffentlicht',
     latestPublished: 'Zuletzt veröffentlicht',
     publishedAt: 'Veröffentlicht am',
     restore: 'Wiederherstellen',
-    runApp: 'App starten',
-    batchRunApp: 'Batch-App starten',
+    runApp: 'App ausführen',
+    batchRunApp: 'App im Batch-Modus ausführen',
     accessAPIReference: 'API-Referenz aufrufen',
-    embedIntoSite: 'In Website einbetten',
+    embedIntoSite: 'In die Webseite einbetten',
     addTitle: 'Titel hinzufügen...',
     addDescription: 'Beschreibung hinzufügen...',
     noVar: 'Keine Variable',
     searchVar: 'Variable suchen',
     variableNamePlaceholder: 'Variablenname',
-    setVarValuePlaceholder: 'Variable festlegen',
+    setVarValuePlaceholder: 'Variable setzen',
     needConnecttip: 'Dieser Schritt ist mit nichts verbunden',
-    maxTreeDepth: 'Maximale Grenze von {{depth}} Knoten pro Zweig',
+    maxTreeDepth: 'Maximales Limit von {{depth}} Knoten pro Ast',
     needEndNode: 'Der Endblock muss hinzugefügt werden',
     needAnswerNode: 'Der Antwortblock muss hinzugefügt werden',
-    workflowProcess: 'Workflow-Prozess',
-    notRunning: 'Läuft noch nicht',
-    previewPlaceholder: 'Geben Sie unten Inhalte ein, um das Debugging des Chatbots zu starten',
+    workflowProcess: 'Arbeitsablauf',
+    notRunning: 'Noch nicht ausgeführt',
+    previewPlaceholder: 'Geben Sie den Inhalt in das Feld unten ein, um das Debuggen des Chatbots zu starten',
     effectVarConfirm: {
       title: 'Variable entfernen',
       content: 'Die Variable wird in anderen Knoten verwendet. Möchten Sie sie trotzdem entfernen?',
     },
-    insertVarTip: 'Drücken Sie die \'/\' Taste, um schnell einzufügen',
+    insertVarTip: 'Drücken Sie die Taste \'/\' zum schnellen Einfügen',
     processData: 'Daten verarbeiten',
     input: 'Eingabe',
     output: 'Ausgabe',
     jinjaEditorPlaceholder: 'Tippen Sie \'/\' oder \'{\' um eine Variable einzufügen',
-    viewOnly: 'Nur Ansicht',
+    viewOnly: 'Nur anzeigen',
     showRunHistory: 'Ausführungsverlauf anzeigen',
-    enableJinja: 'Jinja-Template-Unterstützung aktivieren',
+    enableJinja: 'Jinja-Vorlagenunterstützung aktivieren',
     learnMore: 'Mehr erfahren',
     copy: 'Kopieren',
     duplicate: 'Duplizieren',
@@ -60,35 +60,48 @@ const translation = {
     pasteHere: 'Hier einfügen',
     pointerMode: 'Zeigermodus',
     handMode: 'Handmodus',
+    model: 'Modell',
+    workflowAsTool: 'Workflow als Tool',
+    configureRequired: 'Konfiguration erforderlich',
+    configure: 'Konfigurieren',
+    manageInTools: 'In den Tools verwalten',
+    workflowAsToolTip: 'Nach dem Workflow-Update ist eine Neukonfiguration des Tools erforderlich.',
+    viewDetailInTracingPanel: 'Details anzeigen',
   },
   errorMsg: {
-    fieldRequired: '{{field}} wird benötigt',
-    authRequired: 'Autorisierung erforderlich',
-    invalidJson: '{{field}} ist ungültiges JSON',
+    fieldRequired: '{{field}} ist erforderlich',
+    authRequired: 'Autorisierung ist erforderlich',
+    invalidJson: '{{field}} ist ein ungültiges JSON',
     fields: {
       variable: 'Variablenname',
       variableValue: 'Variablenwert',
       code: 'Code',
       model: 'Modell',
-      rerankModel: 'Rerank-Modell',
+      rerankModel: 'Neusortierungsmodell',
     },
     invalidVariable: 'Ungültige Variable',
   },
   singleRun: {
-    testRun: 'Testlauf',
+    testRun: 'Testlauf ',
     startRun: 'Lauf starten',
-    running: 'Läuft',
+    running: 'Wird ausgeführt',
+    testRunIteration: 'Testlaufiteration',
+    back: 'Zurück',
+    iteration: 'Iteration',
   },
   tabs: {
-    'searchBlock': 'Suchblock',
+    'searchBlock': 'Block suchen',
     'blocks': 'Blöcke',
-    'builtInTool': 'Integriertes Werkzeug',
-    'customTool': 'Benutzerdefiniertes Werkzeug',
-    'question-understand': 'Fragenverständnis',
+    'tools': 'Werkzeuge',
+    'allTool': 'Alle',
+    'builtInTool': 'Eingebaut',
+    'customTool': 'Benutzerdefiniert',
+    'workflowTool': 'Arbeitsablauf',
+    'question-understand': 'Fragen verstehen',
     'logic': 'Logik',
     'transform': 'Transformieren',
     'utilities': 'Dienstprogramme',
-    'noResult': 'Keine Übereinstimmung gefunden',
+    'noResult': 'Kein Ergebnis gefunden',
   },
   blocks: {
     'start': 'Start',
@@ -97,45 +110,52 @@ const translation = {
     'llm': 'LLM',
     'knowledge-retrieval': 'Wissensabruf',
     'question-classifier': 'Fragenklassifizierer',
-    'if-else': 'IF/ELSE',
+    'if-else': 'WENN/SONST',
     'code': 'Code',
     'template-transform': 'Vorlage',
     'http-request': 'HTTP-Anfrage',
-    'variable-assigner': 'Variablenzuweiser',
+    'variable-assigner': 'Variablen-Zuweiser',
+    'variable-aggregator': 'Variablen-Aggregator',
+    'iteration-start': 'Iterationsstart',
+    'iteration': 'Iteration',
+    'parameter-extractor': 'Parameter-Extraktor',
   },
   blocksAbout: {
-    'start': 'Definieren der Startparameter zum Starten eines Workflows',
-    'end': 'Definieren des Endes und des Ergebnistyps eines Workflows',
-    'answer': 'Definieren des Antwortinhalts eines Chat-Gesprächs',
-    'llm': 'Aufrufen von großen Sprachmodellen, um Fragen zu beantworten oder natürliche Sprache zu verarbeiten',
-    'knowledge-retrieval': 'Ermöglicht das Abfragen von Textinhalten in Bezug auf Benutzerfragen aus dem Wissen',
-    'question-classifier': 'Definieren der Klassifizierungsbedingungen von Benutzerfragen, LLM kann basierend auf der Klassifizierungsbeschreibung festlegen, wie das Gespräch fortschreitet',
+    'start': 'Definieren Sie die Anfangsparameter zum Starten eines Workflows',
+    'end': 'Definieren Sie das Ende und den Ergebnistyp eines Workflows',
+    'answer': 'Definieren Sie den Antwortinhalt einer Chat-Konversation',
+    'llm': 'Große Sprachmodelle aufrufen, um Fragen zu beantworten oder natürliche Sprache zu verarbeiten',
+    'knowledge-retrieval': 'Ermöglicht das Abfragen von Textinhalten, die sich auf Benutzerfragen aus der Wissensdatenbank beziehen',
+    'question-classifier': 'Definieren Sie die Klassifizierungsbedingungen von Benutzerfragen, LLM kann basierend auf der Klassifikationsbeschreibung festlegen, wie die Konversation fortschreitet',
     'if-else': 'Ermöglicht das Aufteilen des Workflows in zwei Zweige basierend auf if/else-Bedingungen',
-    'code': 'Ausführen eines Stücks Python- oder NodeJS-Code, um benutzerdefinierte Logik zu implementieren',
-    'template-transform': 'Daten mithilfe der Jinja-Vorlagensyntax in einen String konvertieren',
-    'http-request': 'Ermöglicht das Senden von Serveranfragen über das HTTP-Protokoll',
-    'variable-assigner': 'Variablen in verschiedenen Zweigen derselben Variable zuweisen, um eine einheitliche Konfiguration von Nachknoten zu erreichen',
+    'code': 'Ein Stück Python- oder NodeJS-Code ausführen, um benutzerdefinierte Logik zu implementieren',
+    'template-transform': 'Daten in Zeichenfolgen mit Jinja-Vorlagensyntax umwandeln',
+    'http-request': 'Ermöglichen, dass Serveranforderungen über das HTTP-Protokoll gesendet werden',
+    'variable-assigner': 'Variablen aus mehreren Zweigen in eine einzige Variable zusammenführen, um eine einheitliche Konfiguration der nachgelagerten Knoten zu ermöglichen.',
+    'variable-aggregator': 'Variablen aus mehreren Zweigen in eine einzige Variable zusammenführen, um eine einheitliche Konfiguration der nachgelagerten Knoten zu ermöglichen.',
+    'iteration': 'Mehrere Schritte an einem Listenobjekt ausführen, bis alle Ergebnisse ausgegeben wurden.',
+    'parameter-extractor': 'Verwenden Sie LLM, um strukturierte Parameter aus natürlicher Sprache für Werkzeugaufrufe oder HTTP-Anfragen zu extrahieren.',
   },
   operator: {
     zoomIn: 'Vergrößern',
     zoomOut: 'Verkleinern',
-    zoomTo50: 'Auf 50% zoomen',
-    zoomTo100: 'Auf 100% zoomen',
-    zoomToFit: 'An Fenstergröße anpassen',
+    zoomTo50: 'Auf 50% vergrößern',
+    zoomTo100: 'Auf 100% vergrößern',
+    zoomToFit: 'An Bildschirm anpassen',
   },
   panel: {
     userInputField: 'Benutzereingabefeld',
     changeBlock: 'Block ändern',
-    helpLink: 'Hilfe-Link',
+    helpLink: 'Hilfelink',
     about: 'Über',
-    createdBy: 'Erstellt von',
+    createdBy: 'Erstellt von ',
     nextStep: 'Nächster Schritt',
     addNextStep: 'Fügen Sie den nächsten Block in diesem Workflow hinzu',
-    selectNextStep: 'Nächsten Block wählen',
+    selectNextStep: 'Nächsten Block auswählen',
     runThisStep: 'Diesen Schritt ausführen',
     checklist: 'Checkliste',
-    checklistTip: 'Stellen Sie sicher, dass alle Probleme gelöst sind, bevor Sie veröffentlichen',
-    checklistResolved: 'Alle Probleme gelöst',
+    checklistTip: 'Stellen Sie sicher, dass alle Probleme vor der Veröffentlichung gelöst sind',
+    checklistResolved: 'Alle Probleme wurden gelöst',
     organizeBlocks: 'Blöcke organisieren',
     change: 'Ändern',
   },
@@ -145,11 +165,11 @@ const translation = {
       insertVarTip: 'Variable einfügen',
       memory: {
         memory: 'Speicher',
-        memoryTip: 'Chat-Speichereinstellungen',
+        memoryTip: 'Einstellungen des Chat-Speichers',
         windowSize: 'Fenstergröße',
-        conversationRoleName: 'Gesprächsrollenname',
-        user: 'Benutzerprefix',
-        assistant: 'Assistentenprefix',
+        conversationRoleName: 'Rollenname in der Konversation',
+        user: 'Benutzer-Präfix',
+        assistant: 'Assistenten-Präfix',
       },
       memories: {
         title: 'Erinnerungen',
@@ -164,7 +184,7 @@ const translation = {
       outputVars: {
         query: 'Benutzereingabe',
         memories: {
-          des: 'Gesprächsverlauf',
+          des: 'Konversationsverlauf',
           type: 'Nachrichtentyp',
           content: 'Nachrichteninhalt',
         },
@@ -193,11 +213,11 @@ const translation = {
       variables: 'Variablen',
       context: 'Kontext',
       contextTooltip: 'Sie können Wissen als Kontext importieren',
-      notSetContextInPromptTip: 'Um die Kontextfunktion zu aktivieren, füllen Sie bitte die Kontextvariable in PROMPT aus.',
-      prompt: 'Aufforderung',
+      notSetContextInPromptTip: 'Um die Kontextfunktion zu aktivieren, füllen Sie die Kontextvariable im PROMPT aus.',
+      prompt: 'Prompt',
       roleDescription: {
-        system: 'Geben Sie hochrangige Anweisungen für das Gespräch',
-        user: 'Stellen Sie Anweisungen, Anfragen oder jegliche textbasierte Eingabe für das Modell bereit',
+        system: 'Geben Sie hochrangige Anweisungen für die Konversation',
+        user: 'Geben Sie dem Modell Anweisungen, Abfragen oder beliebigen texteingabebasierten Input',
         assistant: 'Die Antworten des Modells basierend auf den Benutzernachrichten',
       },
       addMessage: 'Nachricht hinzufügen',
@@ -209,13 +229,13 @@ const translation = {
         low: 'Niedrig',
       },
       outputVars: {
-        output: 'Inhalt generieren',
-        usage: 'Modellnutzungsinformation',
+        output: 'Generierter Inhalt',
+        usage: 'Nutzungsinformationen des Modells',
       },
       singleRun: {
         variable: 'Variable',
       },
-      sysQueryInUser: 'sys.query in der Benutzeranfrage ist erforderlich',
+      sysQueryInUser: 'sys.query in Benutzernachricht erforderlich',
     },
     knowledgeRetrieval: {
       queryVariable: 'Abfragevariable',
@@ -232,19 +252,19 @@ const translation = {
     http: {
       inputVars: 'Eingabevariablen',
       api: 'API',
-      apiPlaceholder: 'Geben Sie die URL ein, tippen Sie ‘/’, um eine Variable einzufügen',
+      apiPlaceholder: 'Geben Sie die URL ein, tippen Sie ‘/’, um Variable einzufügen',
       notStartWithHttp: 'API sollte mit http:// oder https:// beginnen',
       key: 'Schlüssel',
       value: 'Wert',
-      bulkEdit: 'Massenbearbeitung',
-      keyValueEdit: 'Schlüssel-Wert-Bearbeitung',
-      headers: 'Kopfzeilen',
+      bulkEdit: 'Massenerfassung',
+      keyValueEdit: 'Schlüssel-Wert-Erfassung',
+      headers: 'Header',
       params: 'Parameter',
-      body: 'Körper',
+      body: 'Body',
       outputVars: {
         body: 'Antwortinhalt',
         statusCode: 'Antwortstatuscode',
-        headers: 'Antwortkopfzeilenliste JSON',
+        headers: 'Antwort-Header-Liste im JSON-Format',
         files: 'Dateiliste',
       },
       authorization: {
@@ -252,29 +272,29 @@ const translation = {
         'authorizationType': 'Autorisierungstyp',
         'no-auth': 'Keine',
         'api-key': 'API-Schlüssel',
-        'auth-type': 'Authentifizierungstyp',
-        'basic': 'Basic',
+        'auth-type': 'Autorisierungstyp',
+        'basic': 'Basis',
         'bearer': 'Bearer',
         'custom': 'Benutzerdefiniert',
         'api-key-title': 'API-Schlüssel',
-        'header': 'Kopfzeile',
+        'header': 'Header',
       },
-      insertVarPlaceholder: 'Tippen Sie ‘/’, um eine Variable einzufügen',
+      insertVarPlaceholder: 'tippen Sie ‘/’, um Variable einzufügen',
       timeout: {
         title: 'Zeitüberschreitung',
-        connectLabel: 'Verbindungszeitüberschreitung',
-        connectPlaceholder: 'Geben Sie die Verbindungszeitüberschreitung in Sekunden ein',
-        readLabel: 'Lesezeitüberschreitung',
-        readPlaceholder: 'Geben Sie die Lesezeitüberschreitung in Sekunden ein',
-        writeLabel: 'Schreibzeitüberschreitung',
-        writePlaceholder: 'Geben Sie die Schreibzeitüberschreitung in Sekunden ein',
+        connectLabel: 'Verbindungs-Zeitüberschreitung',
+        connectPlaceholder: 'Geben Sie die Verbindungs-Zeitüberschreitung in Sekunden ein',
+        readLabel: 'Lese-Zeitüberschreitung',
+        readPlaceholder: 'Geben Sie die Lese-Zeitüberschreitung in Sekunden ein',
+        writeLabel: 'Schreib-Zeitüberschreitung',
+        writePlaceholder: 'Geben Sie die Schreib-Zeitüberschreitung in Sekunden ein',
       },
     },
     code: {
       inputVars: 'Eingabevariablen',
       outputVars: 'Ausgabevariablen',
       advancedDependencies: 'Erweiterte Abhängigkeiten',
-      advancedDependenciesTip: 'Fügen Sie einige vorab geladene Abhängigkeiten hinzu, die mehr Zeit benötigen oder hier nicht standardmäßig integriert sind',
+      advancedDependenciesTip: 'Fügen Sie hier einige vorinstallierte Abhängigkeiten hinzu, die mehr Zeit in Anspruch nehmen oder nicht standardmäßig eingebaut sind',
       searchDependencies: 'Abhängigkeiten suchen',
     },
     templateTransform: {
@@ -288,11 +308,11 @@ const translation = {
     ifElse: {
       if: 'Wenn',
       else: 'Sonst',
-      elseDescription: 'Wird verwendet, um die Logik zu definieren, die ausgeführt werden soll, wenn die Wenn-Bedingung nicht erfüllt ist.',
+      elseDescription: 'Wird verwendet, um die Logik zu definieren, die ausgeführt werden soll, wenn die if-Bedingung nicht erfüllt ist.',
       and: 'und',
       or: 'oder',
       operator: 'Operator',
-      notSetVariable: 'Bitte zuerst Variable festlegen',
+      notSetVariable: 'Bitte setzen Sie zuerst die Variable',
       comparisonOperator: {
         'contains': 'enthält',
         'not contains': 'enthält nicht',
@@ -312,28 +332,31 @@ const translation = {
     variableAssigner: {
       title: 'Variablen zuweisen',
       outputType: 'Ausgabetyp',
-      outputVarType: 'Ausgabevariablentyp',
       varNotSet: 'Variable nicht gesetzt',
       noVarTip: 'Fügen Sie die zuzuweisenden Variablen hinzu',
       type: {
-        string: 'Zeichenkette',
-        number: 'Zahl',
+        string: 'String',
+        number: 'Nummer',
         object: 'Objekt',
         array: 'Array',
       },
+      aggregationGroup: 'Aggregationsgruppe',
+      aggregationGroupTip: 'Durch Aktivieren dieser Funktion kann der Variablen-Aggregator mehrere Variablensätze aggregieren.',
+      addGroup: 'Gruppe hinzufügen',
       outputVars: {
-        output: 'Zugewiesener Variablenwert',
+        varDescribe: 'Ausgabe {{groupName}}',
       },
+      setAssignVariable: 'Zuweisungsvariable festlegen',
     },
     tool: {
-      toAuthorize: 'Zur Autorisierung',
+      toAuthorize: 'Autorisieren',
       inputVars: 'Eingabevariablen',
       outputVars: {
-        text: 'vom Werkzeug generierter Inhalt',
+        text: 'durch das Tool generierter Inhalt',
         files: {
-          title: 'vom Werkzeug generierte Dateien',
-          type: 'Unterstützter Typ. Aktuell nur Bild unterstützt',
-          transfer_method: 'Übertragungsmethode. Wert ist remote_url oder local_file',
+          title: 'durch das Tool generierte Dateien',
+          type: 'Unterstützungstyp. Derzeit nur Bild unterstützt',
+          transfer_method: 'Übertragungsmethode. Der Wert ist remote_url oder local_file',
           url: 'Bild-URL',
           upload_file_id: 'Hochgeladene Datei-ID',
         },
@@ -343,20 +366,54 @@ const translation = {
       model: 'Modell',
       inputVars: 'Eingabevariablen',
       outputVars: {
-        className: 'Klassenname',
+        className: 'Klassennamen',
       },
       class: 'Klasse',
-      classNamePlaceholder: 'Schreiben Sie Ihren Klassennamen',
+      classNamePlaceholder: 'Geben Sie Ihren Klassennamen ein',
       advancedSetting: 'Erweiterte Einstellung',
       topicName: 'Themenname',
-      topicPlaceholder: 'Schreiben Sie Ihren Themenname',
+      topicPlaceholder: 'Geben Sie Ihren Themennamen ein',
       addClass: 'Klasse hinzufügen',
       instruction: 'Anweisung',
-      instructionPlaceholder: 'Schreiben Sie Ihre Anweisung',
+      instructionTip: 'Geben Sie zusätzliche Anweisungen ein, um dem Fragenklassifizierer zu helfen, besser zu verstehen, wie Fragen kategorisiert werden sollen.',
+      instructionPlaceholder: 'Geben Sie Ihre Anweisung ein',
+    },
+    parameterExtractor: {
+      inputVar: 'Eingabevariable',
+      extractParameters: 'Parameter extrahieren',
+      importFromTool: 'Aus Tools importieren',
+      addExtractParameter: 'Extraktionsparameter hinzufügen',
+      addExtractParameterContent: {
+        name: 'Name',
+        namePlaceholder: 'Name des Extraktionsparameters',
+        type: 'Typ',
+        typePlaceholder: 'Typ des Extraktionsparameters',
+        description: 'Beschreibung',
+        descriptionPlaceholder: 'Beschreibung des Extraktionsparameters',
+        required: 'Erforderlich',
+        requiredContent: 'Erforderlich wird nur als Referenz für die Modellschlussfolgerung verwendet und nicht für die zwingende Validierung der Parameter-Ausgabe.',
+      },
+      extractParametersNotSet: 'Extraktionsparameter nicht eingerichtet',
+      instruction: 'Anweisung',
+      instructionTip: 'Geben Sie zusätzliche Anweisungen ein, um dem Parameter-Extraktor zu helfen, zu verstehen, wie Parameter extrahiert werden.',
+      advancedSetting: 'Erweiterte Einstellung',
+      reasoningMode: 'Schlussfolgerungsmodus',
+      reasoningModeTip: 'Sie können den entsprechenden Schlussfolgerungsmodus basierend auf der Fähigkeit des Modells wählen, auf Anweisungen zur Funktionsaufruf- oder Eingabeaufforderungen zu reagieren.',
+      isSuccess: 'Ist Erfolg. Bei Erfolg beträgt der Wert 1, bei Misserfolg beträgt der Wert 0.',
+      errorReason: 'Fehlergrund',
+    },
+    iteration: {
+      deleteTitle: 'Iterationsknoten löschen?',
+      deleteDesc: 'Das Löschen des Iterationsknotens löscht alle untergeordneten Knoten',
+      input: 'Eingabe',
+      output: 'Ausgabevariablen',
+      iteration_one: '{{count}} Iteration',
+      iteration_other: '{{count}} Iterationen',
+      currentIteration: 'Aktuelle Iteration',
     },
   },
   tracing: {
-    stopBy: 'Angehalten von {{user}}',
+    stopBy: 'Gestoppt von {{user}}',
   },
 }
 

web/i18n/fr-FR/workflow.ts

@@ -1,20 +1,20 @@
 const translation = {
   common: {
     editing: 'Édition',
-    autoSaved: 'Enregistré automatiquement',
+    autoSaved: 'Sauvegardé automatiquement',
     unpublished: 'Non publié',
     published: 'Publié',
     publish: 'Publier',
     update: 'Mettre à jour',
     run: 'Exécuter',
-    running: 'En cours',
+    running: 'En cours d\'exécution',
     inRunMode: 'En mode exécution',
-    inPreview: 'En prévisualisation',
-    inPreviewMode: 'En mode prévisualisation',
+    inPreview: 'En aperçu',
+    inPreviewMode: 'En mode aperçu',
     preview: 'Aperçu',
-    viewRunHistory: 'Voir l\'historique d\'exécution',
-    runHistory: 'Historique d\'exécution',
-    goBackToEdit: 'Retourner à l\'éditeur',
+    viewRunHistory: 'Voir l\'historique des exécutions',
+    runHistory: 'Historique des exécutions',
+    goBackToEdit: 'Retour à l\'éditeur',
     conversationLog: 'Journal de conversation',
     features: 'Fonctionnalités',
     debugAndPreview: 'Déboguer et prévisualiser',
@@ -22,76 +22,89 @@ const translation = {
     currentDraft: 'Brouillon actuel',
     currentDraftUnpublished: 'Brouillon actuel non publié',
     latestPublished: 'Dernière publication',
-    publishedAt: 'Publié',
+    publishedAt: 'Publié le',
     restore: 'Restaurer',
     runApp: 'Exécuter l\'application',
     batchRunApp: 'Exécuter l\'application en lot',
-    accessAPIReference: 'Accéder à la référence de l\'API',
-    embedIntoSite: 'Intégrer dans le site',
+    accessAPIReference: 'Accéder à la référence API',
+    embedIntoSite: 'Intégrer au site',
     addTitle: 'Ajouter un titre...',
     addDescription: 'Ajouter une description...',
-    noVar: 'Aucune variable',
+    noVar: 'Pas de variable',
     searchVar: 'Rechercher une variable',
     variableNamePlaceholder: 'Nom de la variable',
-    setVarValuePlaceholder: 'Définir la variable',
+    setVarValuePlaceholder: 'Définir la valeur de la variable',
     needConnecttip: 'Cette étape n\'est connectée à rien',
     maxTreeDepth: 'Limite maximale de {{depth}} nœuds par branche',
     needEndNode: 'Le bloc de fin doit être ajouté',
     needAnswerNode: 'Le bloc de réponse doit être ajouté',
-    workflowProcess: 'Processus de workflow',
+    workflowProcess: 'Processus de flux de travail',
     notRunning: 'Pas encore en cours d\'exécution',
-    previewPlaceholder: 'Saisissez du contenu dans la zone ci-dessous pour commencer le débogage du Chatbot',
+    previewPlaceholder: 'Entrez le contenu dans la boîte ci-dessous pour commencer à déboguer le Chatbot',
     effectVarConfirm: {
       title: 'Supprimer la variable',
-      content: 'La variable est utilisée dans d\'autres nœuds. Voulez-vous toujours la supprimer ?',
+      content: 'La variable est utilisée dans d\'autres nœuds. Voulez-vous toujours la supprimer?',
     },
     insertVarTip: 'Appuyez sur la touche \'/\' pour insérer rapidement',
     processData: 'Traiter les données',
     input: 'Entrée',
     output: 'Sortie',
     jinjaEditorPlaceholder: 'Tapez \'/\' ou \'{\' pour insérer une variable',
-    viewOnly: 'Vue Seulement',
-    showRunHistory: 'Afficher l\'Historique des Exécutions',
-    enableJinja: 'Activer le support des modèles Jinja',
-    learnMore: 'En Savoir Plus',
+    viewOnly: 'Affichage seulement',
+    showRunHistory: 'Afficher l\'historique des exécutions',
+    enableJinja: 'Activer le support des templates Jinja',
+    learnMore: 'En savoir plus',
     copy: 'Copier',
     duplicate: 'Dupliquer',
-    addBlock: 'Ajouter un Bloc',
-    pasteHere: 'Coller Ici',
-    pointerMode: 'Mode Pointeur',
-    handMode: 'Mode Main',
+    addBlock: 'Ajouter un bloc',
+    pasteHere: 'Coller ici',
+    pointerMode: 'Mode pointeur',
+    handMode: 'Mode main',
+    model: 'Modèle',
+    workflowAsTool: 'Flux de travail en tant qu\'outil',
+    configureRequired: 'Configuration requise',
+    configure: 'Configurer',
+    manageInTools: 'Gérer dans les outils',
+    workflowAsToolTip: 'Reconfiguration de l\'outil requise après la mise à jour du flux de travail.',
+    viewDetailInTracingPanel: 'Voir les détails',
   },
   errorMsg: {
     fieldRequired: '{{field}} est requis',
-    authRequired: 'L\'autorisation est requise',
+    authRequired: 'Autorisation requise',
     invalidJson: '{{field}} est un JSON invalide',
     fields: {
       variable: 'Nom de la variable',
       variableValue: 'Valeur de la variable',
       code: 'Code',
       model: 'Modèle',
-      rerankModel: 'Modèle de retrait',
+      rerankModel: 'Modèle de rerank',
     },
     invalidVariable: 'Variable invalide',
   },
   singleRun: {
-    testRun: 'Exécution de test ',
+    testRun: 'Exécution de test',
     startRun: 'Démarrer l\'exécution',
-    running: 'En cours',
+    running: 'En cours d\'exécution',
+    testRunIteration: 'Itération de l\'exécution de test',
+    back: 'Retour',
+    iteration: 'Itération',
   },
   tabs: {
     'searchBlock': 'Rechercher un bloc',
     'blocks': 'Blocs',
-    'builtInTool': 'Outil intégré',
-    'customTool': 'Outil personnalisé',
+    'tools': 'Outils',
+    'allTool': 'Tous',
+    'builtInTool': 'Intégré',
+    'customTool': 'Personnalisé',
+    'workflowTool': 'Flux de travail',
     'question-understand': 'Compréhension des questions',
     'logic': 'Logique',
     'transform': 'Transformer',
     'utilities': 'Utilitaires',
-    'noResult': 'Aucune correspondance trouvée',
+    'noResult': 'Aucun résultat trouvé',
   },
   blocks: {
-    'start': 'Démarrer',
+    'start': 'Début',
     'end': 'Fin',
     'answer': 'Réponse',
     'llm': 'LLM',
@@ -101,43 +114,50 @@ const translation = {
     'code': 'Code',
     'template-transform': 'Modèle',
     'http-request': 'Requête HTTP',
-    'variable-assigner': 'Assignateur de variables',
+    'variable-assigner': 'Assigneur de variables',
+    'variable-aggregator': 'Agrégateur de variables',
+    'iteration-start': 'Début d\'itération',
+    'iteration': 'Itération',
+    'parameter-extractor': 'Extracteur de paramètres',
   },
   blocksAbout: {
     'start': 'Définir les paramètres initiaux pour lancer un flux de travail',
     'end': 'Définir la fin et le type de résultat d\'un flux de travail',
-    'answer': 'Définir le contenu de réponse d\'une conversation',
-    'llm': 'Appeler de grands modèles de langage pour répondre aux questions ou traiter le langage naturel',
-    'knowledge-retrieval': 'Vous permet de interroger le contenu textuel lié aux questions des utilisateurs à partir des connaissances',
+    'answer': 'Définir le contenu de la réponse d\'une conversation',
+    'llm': 'Inviter de grands modèles de langage pour répondre aux questions ou traiter le langage naturel',
+    'knowledge-retrieval': 'Permet de consulter le contenu textuel lié aux questions des utilisateurs à partir de la base de connaissances',
     'question-classifier': 'Définir les conditions de classification des questions des utilisateurs, LLM peut définir comment la conversation progresse en fonction de la description de la classification',
-    'if-else': 'Vous permet de diviser le flux de travail en deux branches en fonction de conditions SI/SINON',
+    'if-else': 'Permet de diviser le flux de travail en deux branches basées sur des conditions if/else',
     'code': 'Exécuter un morceau de code Python ou NodeJS pour implémenter une logique personnalisée',
-    'template-transform': 'Convertir des données en chaîne à l\'aide de la syntaxe du modèle Jinja',
-    'http-request': 'Permet d\'envoyer des requêtes serveur via le protocole HTTP',
-    'variable-assigner': 'Attribuer des variables dans différentes branches à la même variable pour obtenir une configuration unifiée des post-nœuds',
+    'template-transform': 'Convertir les données en chaîne en utilisant la syntaxe du template Jinja',
+    'http-request': 'Permettre l\'envoi de requêtes serveur via le protocole HTTP',
+    'variable-assigner': 'Agrégation de variables de plusieurs branches en une seule variable pour la configuration unifiée des nœuds en aval.',
+    'variable-aggregator': 'Agrégation de variables de plusieurs branches en une seule variable pour la configuration unifiée des nœuds en aval.',
+    'iteration': 'Effectuer plusieurs étapes sur un objet de liste jusqu\'à ce que tous les résultats soient produits.',
+    'parameter-extractor': 'Utiliser LLM pour extraire des paramètres structurés du langage naturel pour les invocations d\'outils ou les requêtes HTTP.',
   },
   operator: {
     zoomIn: 'Zoomer',
     zoomOut: 'Dézoomer',
-    zoomTo50: 'Zoom à 50%',
-    zoomTo100: 'Zoom à 100%',
-    zoomToFit: 'Ajuster à la fenêtre',
+    zoomTo50: 'Zoomer à 50%',
+    zoomTo100: 'Zoomer à 100%',
+    zoomToFit: 'Zoomer pour ajuster',
   },
   panel: {
-    userInputField: 'Champ de saisie utilisateur',
+    userInputField: 'Champ de saisie de l\'utilisateur',
     changeBlock: 'Changer de bloc',
     helpLink: 'Lien d\'aide',
     about: 'À propos',
-    createdBy: 'Créé par ',
+    createdBy: 'Créé par',
     nextStep: 'Étape suivante',
     addNextStep: 'Ajouter le prochain bloc dans ce flux de travail',
-    selectNextStep: 'Sélectionner le bloc suivant',
+    selectNextStep: 'Sélectionner le prochain bloc',
     runThisStep: 'Exécuter cette étape',
     checklist: 'Liste de contrôle',
     checklistTip: 'Assurez-vous que tous les problèmes sont résolus avant de publier',
-    checklistResolved: 'Tous les problèmes sont résolus',
+    checklistResolved: 'Tous les problèmes ont été résolus',
     organizeBlocks: 'Organiser les blocs',
-    change: 'Changer',
+    change: 'Modifier',
   },
   nodes: {
     common: {
@@ -145,7 +165,7 @@ const translation = {
       insertVarTip: 'Insérer une variable',
       memory: {
         memory: 'Mémoire',
-        memoryTip: 'Paramètres de mémoire de chat',
+        memoryTip: 'Paramètres de mémoire de conversation',
         windowSize: 'Taille de la fenêtre',
         conversationRoleName: 'Nom du rôle de conversation',
         user: 'Préfixe utilisateur',
@@ -153,16 +173,16 @@ const translation = {
       },
       memories: {
         title: 'Mémoires',
-        tip: 'Mémoire de chat',
+        tip: 'Mémoire de conversation',
         builtIn: 'Intégré',
       },
     },
     start: {
       required: 'requis',
-      inputField: 'Champ d\'entrée',
+      inputField: 'Champ de saisie',
       builtInVar: 'Variables intégrées',
       outputVars: {
-        query: 'Entrée utilisateur',
+        query: 'Saisie utilisateur',
         memories: {
           des: 'Historique de conversation',
           type: 'type de message',
@@ -170,7 +190,7 @@ const translation = {
         },
         files: 'Liste de fichiers',
       },
-      noVarTip: 'Définissez les entrées pouvant être utilisées dans le flux de travail',
+      noVarTip: 'Définir les entrées qui peuvent être utilisées dans le flux de travail',
     },
     end: {
       outputs: 'Sorties',
@@ -192,36 +212,36 @@ const translation = {
       model: 'modèle',
       variables: 'variables',
       context: 'contexte',
-      contextTooltip: 'Vous pouvez importer des connaissances comme contexte',
-      notSetContextInPromptTip: 'Pour activer la fonction de contexte, veuillez remplir la variable de contexte dans PROMPT.',
+      contextTooltip: 'Vous pouvez importer des connaissances en tant que contexte',
+      notSetContextInPromptTip: 'Pour activer la fonctionnalité de contexte, remplissez la variable de contexte dans le PROMPT.',
       prompt: 'invite',
       roleDescription: {
-        system: 'Donnez des instructions générales pour la conversation',
-        user: 'Fournir des instructions, des requêtes ou toute entrée basée sur du texte au modèle',
-        assistant: 'Les réponses du modèle basées sur les messages de l\'utilisateur',
+        system: 'Donner des instructions de haut niveau pour la conversation',
+        user: 'Fournir des instructions, des questions ou toute entrée textuelle au modèle',
+        assistant: 'Les réponses du modèle basées sur les messages des utilisateurs',
       },
       addMessage: 'Ajouter un message',
       vision: 'vision',
       files: 'Fichiers',
       resolution: {
         name: 'Résolution',
-        high: 'Élevée',
-        low: 'Faible',
+        high: 'Haute',
+        low: 'Basse',
       },
       outputVars: {
-        output: 'Générer du contenu',
+        output: 'Contenu généré',
         usage: 'Informations sur l\'utilisation du modèle',
       },
       singleRun: {
         variable: 'Variable',
       },
-      sysQueryInUser: 'sys.query dans l\'entrée utilisateur',
+      sysQueryInUser: 'sys.query dans le message utilisateur est requis',
     },
     knowledgeRetrieval: {
       queryVariable: 'Variable de requête',
       knowledge: 'Connaissances',
       outputVars: {
-        output: 'Données segmentées de récupération',
+        output: 'Données segmentées récupérées',
         content: 'Contenu segmenté',
         title: 'Titre segmenté',
         icon: 'Icône segmentée',
@@ -230,9 +250,9 @@ const translation = {
       },
     },
     http: {
-      inputVars: 'Variables d\'entrée',
+      inputVars: 'Variables de saisie',
       api: 'API',
-      apiPlaceholder: 'Saisissez l\'URL, tapez ‘/’ pour insérer une variable',
+      apiPlaceholder: 'Entrez l\'URL, tapez ‘/’ pour insérer une variable',
       notStartWithHttp: 'L\'API doit commencer par http:// ou https://',
       key: 'Clé',
       value: 'Valeur',
@@ -243,9 +263,9 @@ const translation = {
       body: 'Corps',
       outputVars: {
         body: 'Contenu de la réponse',
-        statusCode: 'Code d\'état de la réponse',
-        headers: 'Liste d\'en-têtes de réponse JSON',
-        files: 'Liste de fichiers',
+        statusCode: 'Code de statut de la réponse',
+        headers: 'Liste des en-têtes de réponse JSON',
+        files: 'Liste des fichiers',
       },
       authorization: {
         'authorization': 'Autorisation',
@@ -254,7 +274,7 @@ const translation = {
         'api-key': 'Clé API',
         'auth-type': 'Type d\'authentification',
         'basic': 'De base',
-        'bearer': 'Porteur',
+        'bearer': 'Bearer',
         'custom': 'Personnalisé',
         'api-key-title': 'Clé API',
         'header': 'En-tête',
@@ -271,16 +291,16 @@ const translation = {
       },
     },
     code: {
-      inputVars: 'Variables d\'entrée',
+      inputVars: 'Variables de saisie',
       outputVars: 'Variables de sortie',
-      advancedDependencies: 'Dépendances Avancées',
-      advancedDependenciesTip: 'Ajoutez ici des dépendances préchargées qui prennent plus de temps à consommer ou qui ne sont pas intégrées par défaut',
-      searchDependencies: 'Rechercher des Dépendances',
+      advancedDependencies: 'Dépendances avancées',
+      advancedDependenciesTip: 'Ajoutez quelques dépendances préchargées qui prennent plus de temps à consommer ou ne sont pas par défaut ici',
+      searchDependencies: 'Rechercher des dépendances',
     },
     templateTransform: {
-      inputVars: 'Variables d\'entrée',
+      inputVars: 'Variables de saisie',
       code: 'Code',
-      codeSupportTip: 'Ne prend en charge que Jinja2',
+      codeSupportTip: 'Prend en charge uniquement Jinja2',
       outputVars: {
         output: 'Contenu transformé',
       },
@@ -288,7 +308,7 @@ const translation = {
     ifElse: {
       if: 'Si',
       else: 'Sinon',
-      elseDescription: 'Utilisé pour définir la logique qui doit être exécutée lorsque la condition SI n\'est pas remplie.',
+      elseDescription: 'Utilisé pour définir la logique à exécuter lorsque la condition if n\'est pas remplie.',
       and: 'et',
       or: 'ou',
       operator: 'Opérateur',
@@ -305,14 +325,13 @@ const translation = {
         'null': 'est nul',
         'not null': 'n\'est pas nul',
       },
-      enterValue: 'Entrer une valeur',
+      enterValue: 'Entrez la valeur',
       addCondition: 'Ajouter une condition',
       conditionNotSetup: 'Condition NON configurée',
     },
     variableAssigner: {
       title: 'Attribuer des variables',
       outputType: 'Type de sortie',
-      outputVarType: 'Type de variable de sortie',
       varNotSet: 'Variable non définie',
       noVarTip: 'Ajoutez les variables à attribuer',
       type: {
@@ -321,18 +340,22 @@ const translation = {
         object: 'Objet',
         array: 'Tableau',
       },
+      aggregationGroup: 'Groupe d\'agrégation',
+      aggregationGroupTip: 'L\'activation de cette fonctionnalité permet à l\'agrégateur de variables d\'agréger plusieurs ensembles de variables.',
+      addGroup: 'Ajouter un groupe',
       outputVars: {
-        output: 'Valeur de la variable attribuée',
+        varDescribe: 'Sortie {{groupName}}',
       },
+      setAssignVariable: 'Définir la variable à attribuer',
     },
     tool: {
-      toAuthorize: 'Pour autoriser',
-      inputVars: 'Variables d\'entrée',
+      toAuthorize: 'Autoriser',
+      inputVars: 'Variables de saisie',
       outputVars: {
         text: 'contenu généré par l\'outil',
         files: {
           title: 'fichiers générés par l\'outil',
-          type: 'Type de support. Actuellement, seul le support de l\'image est pris en charge',
+          type: 'Type de support. Actuellement ne prend en charge que l\'image',
           transfer_method: 'Méthode de transfert. La valeur est remote_url ou local_file',
           url: 'URL de l\'image',
           upload_file_id: 'ID du fichier téléchargé',
@@ -341,19 +364,53 @@ const translation = {
     },
     questionClassifiers: {
       model: 'modèle',
-      inputVars: 'Variables d\'entrée',
+      inputVars: 'Variables de saisie',
       outputVars: {
         className: 'Nom de la classe',
       },
       class: 'Classe',
-      classNamePlaceholder: 'Écrivez votre nom de classe',
+      classNamePlaceholder: 'Écrivez le nom de votre classe',
       advancedSetting: 'Paramètre avancé',
       topicName: 'Nom du sujet',
-      topicPlaceholder: 'Écrivez votre nom de sujet',
+      topicPlaceholder: 'Écrivez le nom de votre sujet',
       addClass: 'Ajouter une classe',
       instruction: 'Instruction',
+      instructionTip: 'Entrez des instructions supplémentaires pour aider le classificateur de questions à mieux comprendre comment catégoriser les questions.',
       instructionPlaceholder: 'Écrivez votre instruction',
     },
+    parameterExtractor: {
+      inputVar: 'Variable de saisie',
+      extractParameters: 'Extraire des paramètres',
+      importFromTool: 'Importer des outils',
+      addExtractParameter: 'Ajouter un paramètre d\'extraction',
+      addExtractParameterContent: {
+        name: 'Nom',
+        namePlaceholder: 'Nom du paramètre d\'extraction',
+        type: 'Type',
+        typePlaceholder: 'Type de paramètre d\'extraction',
+        description: 'Description',
+        descriptionPlaceholder: 'Description du paramètre d\'extraction',
+        required: 'Requis',
+        requiredContent: 'Requis est utilisé uniquement comme référence pour l\'inférence du modèle, et non pour la validation obligatoire de la sortiedu paramètre.',
+      },
+      extractParametersNotSet: 'Paramètres d\'extraction non configurés',
+      instruction: 'Instruction',
+      instructionTip: 'Entrez des instructions supplémentaires pour aider l\'extracteur de paramètres à comprendre comment extraire les paramètres.',
+      advancedSetting: 'Paramètre avancé',
+      reasoningMode: 'Mode de raisonnement',
+      reasoningModeTip: 'Vous pouvez choisir le mode de raisonnement approprié en fonction de la capacité du modèle à répondre aux instructions pour les appels de fonction ou les invites.',
+      isSuccess: 'Est réussi. En cas de succès, la valeur est 1, en cas d\'échec, la valeur est 0.',
+      errorReason: 'Raison de l\'erreur',
+    },
+    iteration: {
+      deleteTitle: 'Supprimer le nœud d\'itération?',
+      deleteDesc: 'La suppression du nœud d\'itération supprimera tous les nœuds enfants',
+      input: 'Entrée',
+      output: 'Variables de sortie',
+      iteration_one: '{{count}} Itération',
+      iteration_other: '{{count}} Itérations',
+      currentIteration: 'Itération actuelle',
+    },
   },
   tracing: {
     stopBy: 'Arrêté par {{user}}',

web/i18n/ko-KR/workflow.ts

@@ -2,9 +2,9 @@ const translation = {
   common: {
     editing: '편집 중',
     autoSaved: '자동 저장됨',
-    unpublished: '미게시',
-    published: '게시됨',
-    publish: '게시',
+    unpublished: '미발행',
+    published: '발행됨',
+    publish: '발행',
     update: '업데이트',
     run: '실행',
     running: '실행 중',
@@ -14,88 +14,88 @@ const translation = {
     preview: '미리보기',
     viewRunHistory: '실행 기록 보기',
     runHistory: '실행 기록',
-    goBackToEdit: '편집으로 돌아가기',
+    goBackToEdit: '편집기로 돌아가기',
     conversationLog: '대화 로그',
     features: '기능',
     debugAndPreview: '디버그 및 미리보기',
     restart: '재시작',
     currentDraft: '현재 초안',
-    currentDraftUnpublished: '현재 초안 (게시되지 않음)',
-    latestPublished: '최신 게시됨',
-    publishedAt: '게시 시간',
+    currentDraftUnpublished: '현재 초안 미발행',
+    latestPublished: '최신 발행본',
+    publishedAt: '발행일',
     restore: '복원',
     runApp: '앱 실행',
-    batchRunApp: '일괄 실행 앱',
-    accessAPIReference: 'API 참조에 액세스',
-    embedIntoSite: '사이트에 포함',
+    batchRunApp: '앱 일괄 실행',
+    accessAPIReference: 'API 참조 접근',
+    embedIntoSite: '사이트에 삽입',
     addTitle: '제목 추가...',
     addDescription: '설명 추가...',
     noVar: '변수 없음',
     searchVar: '변수 검색',
-    variableNamePlaceholder: '변수명',
+    variableNamePlaceholder: '변수 이름',
     setVarValuePlaceholder: '변수 값 설정',
-    needConnecttip: '이 단계에는 연결된 항목이 없습니다',
-    maxTreeDepth: '각 브랜치 당 최대 {{depth}} 노드 제한',
+    needConnecttip: '이 단계는 아무것도 연결되어 있지 않습니다',
+    maxTreeDepth: '분기당 최대 {{depth}} 노드 제한',
     needEndNode: '종료 블록을 추가해야 합니다',
-    needAnswerNode: '응답 블록을 추가해야 합니다',
-    workflowProcess: '워크플로우 처리',
+    needAnswerNode: '답변 블록을 추가해야 합니다',
+    workflowProcess: '워크플로우 과정',
     notRunning: '아직 실행되지 않음',
-    previewPlaceholder: '챗봇 디버깅을 시작하려면 아래 상자에 내용을 입력하세요',
+    previewPlaceholder: '디버깅을 시작하려면 아래 상자에 내용을 입력하세요',
     effectVarConfirm: {
-      title: '변수 삭제',
-      content: '다른 노드에서 변수를 사용하고 있습니다. 그래도 삭제하시겠습니까?',
+      title: '변수 제거',
+      content: '변수가 다른 노드에서 사용되고 있습니다. 그래도 제거하시겠습니까?',
     },
-    insertVarTip: '빠른 삽입을 위해 \'/\' 키를 누르세요',
+    insertVarTip: '빠르게 삽입하려면 \'/\' 키를 누르세요',
     processData: '데이터 처리',
     input: '입력',
     output: '출력',
+    jinjaEditorPlaceholder: '변수를 삽입하려면 \'/\' 또는 \'{\'를 입력하세요',
+    viewOnly: '보기 전용',
+    showRunHistory: '실행 기록 보기',
     enableJinja: 'Jinja 템플릿 지원 활성화',
     learnMore: '더 알아보기',
-    jinjaEditorPlaceholder: '\'/\' 또는 \'{\'를 입력하여 변수를 삽입하세요.',
-    viewOnly: '보기 모드',
-    showRunHistory: '실행 기록 보기',
     copy: '복사',
     duplicate: '복제',
     addBlock: '블록 추가',
     pasteHere: '여기에 붙여넣기',
-    pointerMode: '선택 모드',
-    handMode: '시점 모드',
+    pointerMode: '포인터 모드',
+    handMode: '핸드 모드',
     model: '모델',
-    workflowAsTool: '워크플로우를 도구로 사용',
-    configureRequired: '설정 필요함',
-    configure: '설정',
+    workflowAsTool: '도구로서의 워크플로우',
+    configureRequired: '구성 필요',
+    configure: '구성',
     manageInTools: '도구에서 관리',
-    workflowAsToolTip: '워크플로우 업데이트 후, 도구 재설정이 필요합니다.',
-    viewDetailInTracingPanel: '자세히 보기',
+    workflowAsToolTip: '워크플로우 업데이트 후 도구 재구성이 필요합니다.',
+    viewDetailInTracingPanel: '세부 정보 보기',
   },
   errorMsg: {
-    fieldRequired: '{{field}}은(는) 필수입니다',
+    fieldRequired: '{{field}}가 필요합니다',
     authRequired: '인증이 필요합니다',
-    invalidJson: '{{field}}이(가) 유효하지 않습니다',
+    invalidJson: '{{field}}는 잘못된 JSON입니다',
     fields: {
-      variable: '변수명',
+      variable: '변수 이름',
       variableValue: '변수 값',
       code: '코드',
       model: '모델',
-      rerankModel: '재순위 모델',
+      rerankModel: '재정렬 모델',
     },
-    invalidVariable: '유효하지 않은 변수',
+    invalidVariable: '잘못된 변수',
   },
   singleRun: {
     testRun: '테스트 실행',
     startRun: '실행 시작',
     running: '실행 중',
-    testRunIteration: '테스트 반복 실행',
-    back: '뒤로가기',
-    iteration: '반복하기',
+    testRunIteration: '테스트 실행 반복',
+    back: '뒤로',
+    iteration: '반복',
   },
   tabs: {
     'searchBlock': '블록 검색',
     'blocks': '블록',
     'tools': '도구',
-    'allTool': '모두',
-    'builtInTool': '내장 도구',
-    'customTool': '커스텀 도구',
+    'allTool': '전체',
+    'builtInTool': '내장',
+    'customTool': '사용자 정의',
     'workflowTool': '워크플로우',
     'question-understand': '질문 이해',
     'logic': '논리',
@@ -114,43 +114,43 @@ const translation = {
     'code': '코드',
     'template-transform': '템플릿',
     'http-request': 'HTTP 요청',
-    'variable-assigner': '변수 할당기',
-    'variable-aggregator': '변수 집합기',
+    'variable-assigner': '변수 할당자',
+    'variable-aggregator': '변수 집계자',
     'iteration-start': '반복 시작',
     'iteration': '반복',
-    'parameter-extractor': '파라미터 추출기',
+    'parameter-extractor': '매개변수 추출기',
   },
   blocksAbout: {
-    'start': '워크플로우 시작을 위한 매개변수를 정의합니다',
-    'end': '워크플로우 종료 및 결과 유형을 정의합니다',
-    'answer': '채팅 대화의 응답 내용을 정의합니다',
-    'llm': '대규모 언어 모델을 호출하여 질문에 답변하거나 자연어를 처리합니다',
-    'knowledge-retrieval': '사용자의 질문과 관련된 텍스트 콘텐츠를 지식에서 쿼리할 수 있도록 합니다',
-    'question-classifier': '사용자의 질문 분류 조건을 정의하고, LLM은 분류 기술에 따라 대화가 어떻게 진행될지 정의할 수 있습니다',
-    'if-else': 'IF/ELSE 조건에 따라 워크플로우를 두 가지 분기로 나눌 수 있습니다',
-    'code': '사용자 정의 로직을 구현하기 위해 Python 또는 NodeJS 코드를 실행합니다',
+    'start': '워크플로우를 시작하기 위한 초기 매개변수를 정의합니다',
+    'end': '워크플로우의 종료 및 결과 유형을 정의합니다',
+    'answer': '대화의 답변 내용을 정의합니다',
+    'llm': '질문에 답하거나 자연어를 처리하기 위해 대형 언어 모델을 호출합니다',
+    'knowledge-retrieval': '사용자 질문과 관련된 텍스트 콘텐츠를 지식 베이스에서 쿼리할 수 있습니다',
+    'question-classifier': '사용자 질문의 분류 조건을 정의합니다. LLM은 분류 설명을 기반으로 대화의 진행 방식을 정의할 수 있습니다',
+    'if-else': 'if/else 조건을 기반으로 워크플로우를 두 가지 분기로 나눌 수 있습니다',
+    'code': '사용자 정의 논리를 구현하기 위해 Python 또는 NodeJS 코드를 실행합니다',
     'template-transform': 'Jinja 템플릿 구문을 사용하여 데이터를 문자열로 변환합니다',
     'http-request': 'HTTP 프로토콜을 통해 서버 요청을 보낼 수 있습니다',
-    'variable-assigner': '다른 분기에서 동일한 변수에 변수를 할당하여 후속 노드의 통일된 구성을 달성할 수 있습니다',
-    'variable-aggregator': '다른 분기에서 동일한 변수에 변수를 할당하여 후속 노드의 통일된 구성을 달성할 수 있습니다',
-    'iteration': '모든 결과가 출력될 때까지 리스트 객체에서 단계 반복을 수행합니다.',
-    'parameter-extractor': '도구 혹은 HTTP 요청에 사용할 구조화된 파라미터를 LLM을 이용하여 자연어에서 추출합니다.',
+    'variable-assigner': '다중 분기 변수들을 하나의 변수로 집계하여 다운스트림 노드의 통합 구성을 가능하게 합니다.',
+    'variable-aggregator': '다중 분기 변수들을 하나의 변수로 집계하여 다운스트림 노드의 통합 구성을 가능하게 합니다.',
+    'iteration': '목록 객체에서 여러 단계를 수행하여 모든 결과가 출력될 때까지 반복합니다.',
+    'parameter-extractor': '도구 호출 또는 HTTP 요청을 위해 자연어에서 구조화된 매개변수를 추출하기 위해 LLM을 사용합니다.',
   },
   operator: {
     zoomIn: '확대',
     zoomOut: '축소',
     zoomTo50: '50%로 확대',
     zoomTo100: '100%로 확대',
-    zoomToFit: '적합하게 확대',
+    zoomToFit: '화면에 맞게 확대',
   },
   panel: {
     userInputField: '사용자 입력 필드',
     changeBlock: '블록 변경',
     helpLink: '도움말 링크',
     about: '정보',
-    createdBy: '작성자',
+    createdBy: '작성자 ',
     nextStep: '다음 단계',
-    addNextStep: '이 워크플로우에 다음 블록 추가',
+    addNextStep: '이 워크플로우의 다음 블록 추가',
     selectNextStep: '다음 블록 선택',
     runThisStep: '이 단계 실행',
     checklist: '체크리스트',
@@ -165,15 +165,15 @@ const translation = {
       insertVarTip: '변수 삽입',
       memory: {
         memory: '메모리',
-        memoryTip: '채팅 메모리 설정',
-        windowSize: '윈도우 크기',
+        memoryTip: '대화 메모리 설정',
+        windowSize: '창 크기',
         conversationRoleName: '대화 역할 이름',
         user: '사용자 접두사',
         assistant: '어시스턴트 접두사',
       },
       memories: {
         title: '메모리',
-        tip: '채팅 메모리',
+        tip: '대화 메모리',
         builtIn: '내장',
       },
     },
@@ -190,7 +190,7 @@ const translation = {
         },
         files: '파일 목록',
       },
-      noVarTip: '워크플로우에서 사용할 수 있는 입력을 설정합니다',
+      noVarTip: '워크플로우에서 사용할 입력을 설정하세요',
     },
     end: {
       outputs: '출력',
@@ -200,8 +200,8 @@ const translation = {
       },
       type: {
         'none': '없음',
-        'plain-text': '평문',
-        'structured': '구조화',
+        'plain-text': '일반 텍스트',
+        'structured': '구조화된',
       },
     },
     answer: {
@@ -216,9 +216,9 @@ const translation = {
       notSetContextInPromptTip: '컨텍스트 기능을 활성화하려면 PROMPT에 컨텍스트 변수를 입력하세요.',
       prompt: '프롬프트',
       roleDescription: {
-        system: '대화의 고수준 명령을 제공합니다',
-        user: '모델에 대한 지시, 쿼리 또는 텍스트 기반 입력을 제공합니다',
-        assistant: '사용자 메시지를 기반으로 모델의 응답을 생성합니다',
+        system: '대화를 위한 고급 지침 제공',
+        user: '모델에 지침, 질문 또는 텍스트 기반 입력 제공',
+        assistant: '사용자 메시지에 기반한 모델의 응답',
       },
       addMessage: '메시지 추가',
       vision: '비전',
@@ -229,47 +229,47 @@ const translation = {
         low: '낮음',
       },
       outputVars: {
-        output: '컨텐츠 생성',
+        output: '생성된 내용',
         usage: '모델 사용 정보',
       },
       singleRun: {
         variable: '변수',
       },
-      sysQueryInUser: '사용자 메시지에 sys.query가 요구됩니다.',
+      sysQueryInUser: '사용자 메시지에 sys.query가 필요합니다',
     },
     knowledgeRetrieval: {
       queryVariable: '쿼리 변수',
       knowledge: '지식',
       outputVars: {
-        output: '검색된 세그먼트화된 데이터',
-        content: '세그먼트화된 콘텐츠',
-        title: '세그먼트화된 제목',
-        icon: '세그먼트화된 아이콘',
-        url: '세그먼트화된 URL',
+        output: '복구된 세그먼트 데이터',
+        content: '세그먼트 내용',
+        title: '세그먼트 제목',
+        icon: '세그먼트 아이콘',
+        url: '세그먼트 URL',
         metadata: '기타 메타데이터',
       },
     },
     http: {
       inputVars: '입력 변수',
       api: 'API',
-      apiPlaceholder: 'URL 입력, \'/\'을 입력하여 변수 삽입',
+      apiPlaceholder: 'URL을 입력하세요, 변수를 삽입하려면 ‘/’를 입력하세요',
       notStartWithHttp: 'API는 http:// 또는 https://로 시작해야 합니다',
       key: '키',
       value: '값',
-      bulkEdit: '일괄 수정',
-      keyValueEdit: '키-값 수정',
+      bulkEdit: '일괄 편집',
+      keyValueEdit: '키-값 편집',
       headers: '헤더',
-      params: '파라미터',
-      body: '바디',
+      params: '매개변수',
+      body: '본문',
       outputVars: {
-        body: '응답 콘텐츠',
+        body: '응답 내용',
         statusCode: '응답 상태 코드',
         headers: '응답 헤더 목록 JSON',
         files: '파일 목록',
       },
       authorization: {
-        'authorization': '인증',
-        'authorizationType': '인증 유형',
+        'authorization': '권한 부여',
+        'authorizationType': '권한 부여 유형',
         'no-auth': '없음',
         'api-key': 'API 키',
         'auth-type': '인증 유형',
@@ -279,60 +279,60 @@ const translation = {
         'api-key-title': 'API 키',
         'header': '헤더',
       },
-      insertVarPlaceholder: '변수 삽입을 위해 \'/\'를 입력하세요',
+      insertVarPlaceholder: '변수를 삽입하려면 \'/\'를 입력하세요',
       timeout: {
-        title: '타임아웃',
-        connectLabel: '연결 타임아웃',
-        connectPlaceholder: '연결 타임아웃을 초 단위로 입력하세요',
-        readLabel: '읽기 타임아웃',
-        readPlaceholder: '읽기 타임아웃을 초 단위로 입력하세요',
-        writeLabel: '쓰기 타임아웃',
-        writePlaceholder: '쓰기 타임아웃을 초 단위로 입력하세요',
+        title: '시간 초과',
+        connectLabel: '연결 시간 초과',
+        connectPlaceholder: '초 단위로 연결 시간 초과 입력',
+        readLabel: '읽기 시간 초과',
+        readPlaceholder: '초 단위로 읽기 시간 초과 입력',
+        writeLabel: '쓰기 시간 초과',
+        writePlaceholder: '초 단위로 쓰기 시간 초과 입력',
       },
     },
     code: {
       inputVars: '입력 변수',
       outputVars: '출력 변수',
       advancedDependencies: '고급 종속성',
-      advancedDependenciesTip: '소비하는 데 시간이 더 걸리거나 기본 내장되지 않은 일부 사전 로드된 종속성을 추가하십시오',
+      advancedDependenciesTip: '더 많은 시간이 소요되거나 기본으로 내장되지 않은 일부 미리 로드된 종속성을 여기에 추가하세요',
       searchDependencies: '종속성 검색',
     },
     templateTransform: {
       inputVars: '입력 변수',
       code: '코드',
-      codeSupportTip: 'Jinja2만 지원됩니다',
+      codeSupportTip: 'Jinja2만 지원합니다',
       outputVars: {
-        output: '변환된 콘텐츠',
+        output: '변환된 내용',
       },
     },
     ifElse: {
-      if: '만약',
-      else: '그렇지 않으면',
-      elseDescription: 'IF 조건이 충족되지 않을 경우 실행할 로직을 정의합니다.',
+      if: 'If',
+      else: 'Else',
+      elseDescription: 'If 조건이 충족되지 않을 때 실행할 논리를 정의하는 데 사용됩니다.',
       and: '그리고',
       or: '또는',
       operator: '연산자',
       notSetVariable: '먼저 변수를 설정하세요',
       comparisonOperator: {
         'contains': '포함',
-        'not contains': '미포함',
-        'start with': '시작하는',
-        'end with': '끝나는',
-        'is': '일치',
-        'is not': '불일치',
-        'empty': '빈 값',
-        'not empty': '빈 값이 아님',
-        'null': 'null',
+        'not contains': '포함하지 않음',
+        'start with': '시작',
+        'end with': '끝',
+        'is': '이다',
+        'is not': '아니다',
+        'empty': '비어 있음',
+        'not empty': '비어 있지 않음',
+        'null': 'null임',
         'not null': 'null이 아님',
       },
-      enterValue: '값을 입력하세요',
+      enterValue: '값 입력',
       addCondition: '조건 추가',
-      conditionNotSetup: '조건이 설정되지 않았습니다',
+      conditionNotSetup: '조건이 설정되지 않음',
     },
     variableAssigner: {
       title: '변수 할당',
       outputType: '출력 유형',
-      varNotSet: '변수가 설정되지 않았습니다',
+      varNotSet: '변수가 설정되지 않음',
       noVarTip: '할당할 변수를 추가하세요',
       type: {
         string: '문자열',
@@ -340,25 +340,25 @@ const translation = {
         object: '객체',
         array: '배열',
       },
-      aggregationGroup: '집합 그룹',
-      aggregationGroupTip: '이 기능을 사용하면 변수 집합기가 변수의 다중 세트를 집합하도록 합니다.',
+      aggregationGroup: '집계 그룹',
+      aggregationGroupTip: '이 기능을 활성화하면 변수 집계자가 여러 변수 집합을 집계할 수 있습니다.',
       addGroup: '그룹 추가',
       outputVars: {
-        output: '할당된 변수의 값',
+        varDescribe: '{{groupName}} 출력',
       },
       setAssignVariable: '할당 변수 설정',
     },
     tool: {
-      toAuthorize: '승인하려면',
+      toAuthorize: '승인하기',
       inputVars: '입력 변수',
       outputVars: {
-        text: '툴이 생성한 콘텐츠',
+        text: '도구가 생성한 내용',
         files: {
-          title: '툴이 생성한 파일',
-          type: '지원 유형: 현재 이미지만 지원됩니다',
-          transfer_method: '전송 방법: remote_url 또는 local_file 값',
+          title: '도구가 생성한 파일',
+          type: '지원 유형. 현재는 이미지만 지원합니다',
+          transfer_method: '전송 방법. 값은 remote_url 또는 local_file',
           url: '이미지 URL',
-          upload_file_id: '업로드 파일 ID',
+          upload_file_id: '업로드된 파일 ID',
         },
       },
     },
@@ -369,41 +369,42 @@ const translation = {
         className: '클래스 이름',
       },
       class: '클래스',
-      classNamePlaceholder: '클래스 이름을 입력하세요',
+      classNamePlaceholder: '클래스 이름을 작성하세요',
       advancedSetting: '고급 설정',
-      topicName: '주제명',
-      topicPlaceholder: '주제명을 입력하세요',
+      topicName: '주제 이름',
+      topicPlaceholder: '주제 이름을 작성하세요',
       addClass: '클래스 추가',
       instruction: '지시',
-      instructionPlaceholder: '지시를 입력하세요',
+      instructionTip: '질문 분류기가 질문을 더 잘 분류할 수 있도록 추가 지시를 입력하세요.',
+      instructionPlaceholder: '지시를 작성하세요',
     },
     parameterExtractor: {
       inputVar: '입력 변수',
-      extractParameters: '추출 파라미터',
+      extractParameters: '매개변수 추출',
       importFromTool: '도구에서 가져오기',
-      addExtractParameter: '추출 파라미터 추가',
+      addExtractParameter: '추출 매개변수 추가',
       addExtractParameterContent: {
         name: '이름',
-        namePlaceholder: '추출 파라미터 이름',
-        type: '타입',
-        typePlaceholder: '추출 파라미터 타입',
+        namePlaceholder: '추출 매개변수 이름',
+        type: '유형',
+        typePlaceholder: '추출 매개변수 유형',
         description: '설명',
-        descriptionPlaceholder: '추출 파라미터 설명',
-        required: '필요 항목',
-        requiredContent: '필요항목은 파라미터 출력의 확인을 위한 것이 아닌, 모델 추론의 참고용으로 사용됩니다.',
+        descriptionPlaceholder: '추출 매개변수 설명',
+        required: '필수',
+        requiredContent: '필수는 모델 추론을 위한 참고 용도로만 사용되며, 매개변수 출력의 필수 유효성 검사는 아닙니다.',
       },
-      extractParametersNotSet: '추출 파라미터가 설정되지 않았습니다.',
-      instruction: '지시어',
-      instructionTip: '어떻게 파라미터를 추출할 것인지에 도움을 주기 위해, 추가적인 지시어를 입력하세요.',
+      extractParametersNotSet: '추출 매개변수가 설정되지 않음',
+      instruction: '지시',
+      instructionTip: '매개변수 추출기가 매개변수를 추출하는 방법을 이해하는 데 도움이 되는 추가 지시를 입력하세요.',
       advancedSetting: '고급 설정',
-      reasoningMode: '추리 모드',
-      reasoningModeTip: '모델의 함수 호출이나 프롬프트를 위한 지시어에 응답하는 능력에 따라 추리모드를 선택할 수 있습니다.',
-      isSuccess: '성공할 경우 값은 1, 실패할 경우 값은 0',
-      errorReason: '추리 오류',
+      reasoningMode: '추론 모드',
+      reasoningModeTip: '모델의 함수 호출 또는 프롬프트에 대한 지시 응답 능력을 기반으로 적절한 추론 모드를 선택할 수 있습니다.',
+      isSuccess: '성공 여부. 성공 시 값은 1이고, 실패 시 값은 0입니다.',
+      errorReason: '오류 원인',
     },
     iteration: {
       deleteTitle: '반복 노드를 삭제하시겠습니까?',
-      deleteDesc: '반복 노드를 제거할 경우, 하위 노드도 모두 제거됩니다.',
+      deleteDesc: '반복 노드를 삭제하면 모든 하위 노드가 삭제됩니다',
       input: '입력',
       output: '출력 변수',
       iteration_one: '{{count}} 반복',

web/i18n/pl-PL/workflow.ts

@@ -1,33 +1,33 @@
 const translation = {
   common: {
     editing: 'Edytowanie',
-    autoSaved: 'Autozapisano',
-    unpublished: 'Nieopublikowany',
-    published: 'Opublikowany',
+    autoSaved: 'Automatycznie zapisane',
+    unpublished: 'Nieopublikowane',
+    published: 'Opublikowane',
     publish: 'Opublikuj',
     update: 'Aktualizuj',
     run: 'Uruchom',
     running: 'Uruchamianie',
-    inRunMode: 'W trybie Uruchom',
-    inPreview: 'Podgląd',
-    inPreviewMode: 'W trybie Podgląd',
+    inRunMode: 'W trybie uruchamiania',
+    inPreview: 'W podglądzie',
+    inPreviewMode: 'W trybie podglądu',
     preview: 'Podgląd',
     viewRunHistory: 'Zobacz historię uruchomień',
-    runHistory: 'Historia Uruchomień',
+    runHistory: 'Historia uruchomień',
     goBackToEdit: 'Wróć do edytora',
-    conversationLog: 'Dziennik Konwersacji',
+    conversationLog: 'Dziennik rozmów',
     features: 'Funkcje',
-    debugAndPreview: 'Debugowanie i Podgląd',
-    restart: 'Uruchom Ponownie',
-    currentDraft: 'Aktualny Szkic',
-    currentDraftUnpublished: 'Aktualny Szkic Nieopublikowany',
-    latestPublished: 'Ostatnio Opublikowany',
-    publishedAt: 'Opublikowany',
+    debugAndPreview: 'Debugowanie i podgląd',
+    restart: 'Uruchom ponownie',
+    currentDraft: 'Bieżący szkic',
+    currentDraftUnpublished: 'Bieżący szkic nieopublikowany',
+    latestPublished: 'Najnowsze opublikowane',
+    publishedAt: 'Opublikowane',
     restore: 'Przywróć',
-    runApp: 'Uruchom Aplikację',
-    batchRunApp: 'Uruchom Aplikację Partiami',
-    accessAPIReference: 'Dostęp do Referencji API',
-    embedIntoSite: 'Osadź na Stronie',
+    runApp: 'Uruchom aplikację',
+    batchRunApp: 'Uruchom aplikację wsadowo',
+    accessAPIReference: 'Uzyskaj dostęp do dokumentacji API',
+    embedIntoSite: 'Osadź na stronie',
     addTitle: 'Dodaj tytuł...',
     addDescription: 'Dodaj opis...',
     noVar: 'Brak zmiennej',
@@ -36,133 +36,153 @@ const translation = {
     setVarValuePlaceholder: 'Ustaw zmienną',
     needConnecttip: 'Ten krok nie jest połączony z niczym',
     maxTreeDepth: 'Maksymalny limit {{depth}} węzłów na gałąź',
-    needEndNode: 'Należy dodać Blok Końcowy',
-    needAnswerNode: 'Należy dodać Blok Odpowiedzi',
-    workflowProcess: 'Proces Przepływu',
-    notRunning: 'Nie uruchamiany jeszcze',
+    needEndNode: 'Należy dodać blok końcowy',
+    needAnswerNode: 'Należy dodać blok odpowiedzi',
+    workflowProcess: 'Proces przepływu pracy',
+    notRunning: 'Jeszcze nie uruchomiono',
     previewPlaceholder: 'Wprowadź treść w poniższym polu, aby rozpocząć debugowanie Chatbota',
     effectVarConfirm: {
-      title: 'Usuń Zmienną',
-      content: 'Zmienna jest używana w innych węzłach. Czy nadal chcesz ją usunąć?',
+      title: 'Usuń zmienną',
+      content: 'Zmienna jest używana w innych węzłach. Czy na pewno chcesz ją usunąć?',
     },
-    insertVarTip: 'Naciśnij klawisz \'/\' aby szybko wstawić',
-    processData: 'Przetwarzaj Dane',
+    insertVarTip: 'Naciśnij klawisz \'/\', aby szybko wstawić',
+    processData: 'Przetwórz dane',
     input: 'Wejście',
     output: 'Wyjście',
-    jinjaEditorPlaceholder: 'Wprowadź \'/\' lub \'{\' aby wstawić zmienną',
-    viewOnly: 'Tylko Podgląd',
-    showRunHistory: 'Pokaż Historię Uruchomień',
-    enableJinja: 'Włącz wsparcie dla szablonów Jinja',
-    learnMore: 'Czytaj więcej',
+    jinjaEditorPlaceholder: 'Naciśnij \'/\' lub \'{\', aby wstawić zmienną',
+    viewOnly: 'Tylko do podglądu',
+    showRunHistory: 'Pokaż historię uruchomień',
+    enableJinja: 'Włącz obsługę szablonów Jinja',
+    learnMore: 'Dowiedz się więcej',
     copy: 'Kopiuj',
     duplicate: 'Duplikuj',
-    addBlock: 'Dodaj Blok',
-    pasteHere: 'Wklej Tutaj',
-    pointerMode: 'Tryb Wskaźnika',
-    handMode: 'Tryb Ręczny',
+    addBlock: 'Dodaj blok',
+    pasteHere: 'Wklej tutaj',
+    pointerMode: 'Tryb wskaźnika',
+    handMode: 'Tryb ręczny',
+    model: 'Model',
+    workflowAsTool: 'Przepływ pracy jako narzędzie',
+    configureRequired: 'Wymagana konfiguracja',
+    configure: 'Skonfiguruj',
+    manageInTools: 'Zarządzaj w narzędziach',
+    workflowAsToolTip: 'Wymagana rekonfiguracja narzędzia po aktualizacji przepływu pracy.',
+    viewDetailInTracingPanel: 'Zobacz szczegóły',
   },
   errorMsg: {
     fieldRequired: '{{field}} jest wymagane',
-    authRequired: 'Autoryzacja jest wymagana',
-    invalidJson: '{{field}} jest nieprawidłowy JSON',
+    authRequired: 'Wymagana autoryzacja',
+    invalidJson: '{{field}} jest nieprawidłowym JSON-em',
     fields: {
-      variable: 'Nazwa Zmiennej',
-      variableValue: 'Wartość Zmiennej',
+      variable: 'Nazwa zmiennej',
+      variableValue: 'Wartość zmiennej',
       code: 'Kod',
       model: 'Model',
-      rerankModel: 'Model Ponownej Klasyfikacji',
+      rerankModel: 'Model rerank',
     },
     invalidVariable: 'Nieprawidłowa zmienna',
   },
   singleRun: {
-    testRun: 'Testuj Uruchomienie ',
-    startRun: 'Uruchomienie',
+    testRun: 'Testowe uruchomienie ',
+    startRun: 'Rozpocznij uruchomienie',
     running: 'Uruchamianie',
+    testRunIteration: 'Iteracja testowego uruchomienia',
+    back: 'Wstecz',
+    iteration: 'Iteracja',
   },
   tabs: {
-    'searchBlock': 'Szukaj Bloku',
+    'searchBlock': 'Szukaj bloku',
     'blocks': 'Bloki',
-    'builtInTool': 'Wbudowany Narzędzie',
-    'customTool': 'Niestandardowe Narzędzie',
-    'question-understand': 'Zrozumienie Pytania',
+    'tools': 'Narzędzia',
+    'allTool': 'Wszystkie',
+    'builtInTool': 'Wbudowane',
+    'customTool': 'Niestandardowe',
+    'workflowTool': 'Przepływ pracy',
+    'question-understand': 'Zrozumienie pytania',
     'logic': 'Logika',
     'transform': 'Transformacja',
-    'utilities': 'Użyteczność',
-    'noResult': 'Brak pasujących wyników',
+    'utilities': 'Narzędzia pomocnicze',
+    'noResult': 'Nie znaleziono dopasowań',
   },
   blocks: {
     'start': 'Start',
     'end': 'Koniec',
     'answer': 'Odpowiedź',
     'llm': 'LLM',
-    'knowledge-retrieval': 'Odzyskiwanie Wiedzy',
-    'question-classifier': 'Klasyfikator Pytań',
-    'if-else': 'IF/ELSE',
+    'knowledge-retrieval': 'Wyszukiwanie wiedzy',
+    'question-classifier': 'Klasyfikator pytań',
+    'if-else': 'JEŚLI/W PRZECIWNYM WYPADKU',
     'code': 'Kod',
     'template-transform': 'Szablon',
     'http-request': 'Żądanie HTTP',
-    'variable-assigner': 'Przypisywacz Zmiennych',
+    'variable-assigner': 'Agregator zmiennych',
+    'variable-aggregator': 'Agregator zmiennych',
+    'iteration-start': 'Początek iteracji',
+    'iteration': 'Iteracja',
+    'parameter-extractor': 'Ekstraktor parametrów',
   },
   blocksAbout: {
-    'start': 'Definiuje początkowe parametry uruchamiania przepływu',
-    'end': 'Definiuje koniec i typ wyniku przepływu',
-    'answer': 'Definiuje treść odpowiedzi w rozmowie czatowej',
-    'llm': 'Wywołuje duże modele językowe do odpowiedzi na pytania lub przetwarzania języka naturalnego',
-    'knowledge-retrieval': 'Pozwala na wyszukiwanie treści tekstowych związanych z pytaniami użytkowników z Wiedzy',
-    'question-classifier': 'Definiuje warunki klasyfikacji pytań użytkowników, LLM może określić, jak postępuje rozmowa na podstawie opisu klasyfikacji',
-    'if-else': 'Pozwala na podział przepływu na dwie gałęzie na podstawie warunków if/else',
-    'code': 'Wykonuje fragment kodu Pythona lub NodeJS w celu zastosowania niestandardowej logiki',
-    'template-transform': 'Konwertuje dane na ciąg za pomocą składni szablonu Jinja',
-    'http-request': 'Pozwala na wysyłanie żądań serwera za pośrednictwem protokołu HTTP',
-    'variable-assigner': 'Przypisuje zmienne w różnych gałęziach do tej samej zmiennej w celu uzyskania zharmonizowanej konfiguracji post-węzłów',
+    'start': 'Zdefiniuj początkowe parametry uruchamiania przepływu pracy',
+    'end': 'Zdefiniuj zakończenie i typ wyniku przepływu pracy',
+    'answer': 'Zdefiniuj treść odpowiedzi w rozmowie',
+    'llm': 'Wywołaj duże modele językowe do odpowiadania na pytania lub przetwarzania języka naturalnego',
+    'knowledge-retrieval': 'Pozwala na wyszukiwanie treści tekstowych związanych z pytaniami użytkowników z bazy wiedzy',
+    'question-classifier': 'Zdefiniuj warunki klasyfikacji pytań użytkowników, LLM może definiować, jak rozmowa postępuje na podstawie opisu klasyfikacji',
+    'if-else': 'Pozwala na podział przepływu pracy na dwie gałęzie na podstawie warunków if/else',
+    'code': 'Wykonaj fragment kodu Python lub NodeJS, aby wdrożyć niestandardową logikę',
+    'template-transform': 'Konwertuj dane na ciąg znaków przy użyciu składni szablonu Jinja',
+    'http-request': 'Pozwala na wysyłanie żądań serwera za pomocą protokołu HTTP',
+    'variable-assigner': 'Zbierz zmienne z wielu gałęzi do jednej zmiennej dla jednolitej konfiguracji węzłów końcowych.',
+    'variable-aggregator': 'Zbierz zmienne z wielu gałęzi do jednej zmiennej dla jednolitej konfiguracji węzłów końcowych.',
+    'iteration': 'Wykonuj wielokrotne kroki na liście obiektów, aż wszystkie wyniki zostaną wypisane.',
+    'parameter-extractor': 'Użyj LLM do wyodrębnienia strukturalnych parametrów z języka naturalnego do wywołań narzędzi lub żądań HTTP.',
   },
   operator: {
     zoomIn: 'Powiększ',
     zoomOut: 'Pomniejsz',
     zoomTo50: 'Powiększ do 50%',
     zoomTo100: 'Powiększ do 100%',
-    zoomToFit: 'Dopasuj do rozmiaru',
+    zoomToFit: 'Dopasuj do ekranu',
   },
   panel: {
-    userInputField: 'Pole Wejściowe Użytkownika',
-    changeBlock: 'Zmień Blok',
-    helpLink: 'Link Pomocniczy',
-    about: 'O Autorze',
-    createdBy: 'Utworzone przez',
-    nextStep: 'Następny Krok',
-    addNextStep: 'Dodaj następny blok w tym przepływie',
-    selectNextStep: 'Wybierz Następny Blok',
+    userInputField: 'Pole wprowadzania użytkownika',
+    changeBlock: 'Zmień blok',
+    helpLink: 'Link do pomocy',
+    about: 'O',
+    createdBy: 'Stworzone przez ',
+    nextStep: 'Następny krok',
+    addNextStep: 'Dodaj następny blok w tym przepływie pracy',
+    selectNextStep: 'Wybierz następny blok',
     runThisStep: 'Uruchom ten krok',
     checklist: 'Lista kontrolna',
-    checklistTip: 'Upewnij się, że wszystkie problemy są rozwiązane przed opublikowaniem',
+    checklistTip: 'Upewnij się, że wszystkie problemy zostały rozwiązane przed opublikowaniem',
     checklistResolved: 'Wszystkie problemy zostały rozwiązane',
     organizeBlocks: 'Organizuj bloki',
     change: 'Zmień',
   },
   nodes: {
     common: {
-      outputVars: 'Zmienne Wyjściowe',
-      insertVarTip: 'Wstaw Zmienną',
+      outputVars: 'Zmienne wyjściowe',
+      insertVarTip: 'Wstaw zmienną',
       memory: {
         memory: 'Pamięć',
-        memoryTip: 'Ustawienia pamięci czatu',
-        windowSize: 'Rozmiar Okna',
-        conversationRoleName: 'Nazwa Roli Konwersacji',
+        memoryTip: 'Ustawienia pamięci rozmowy',
+        windowSize: 'Rozmiar okna',
+        conversationRoleName: 'Nazwa roli w rozmowie',
         user: 'Prefiks użytkownika',
         assistant: 'Prefiks asystenta',
       },
       memories: {
-        title: 'Wspomnienia',
-        tip: 'Pamięć czatu',
+        title: 'Pamięci',
+        tip: 'Pamięć rozmowy',
         builtIn: 'Wbudowane',
       },
     },
     start: {
       required: 'wymagane',
-      inputField: 'Pole Wejściowe',
-      builtInVar: 'Zmienne Wbudowane',
+      inputField: 'Pole wejściowe',
+      builtInVar: 'Wbudowane zmienne',
       outputVars: {
-        query: 'Wejście użytkownika',
+        query: 'Wprowadzenie użytkownika',
         memories: {
           des: 'Historia rozmowy',
           type: 'typ wiadomości',
@@ -170,37 +190,37 @@ const translation = {
         },
         files: 'Lista plików',
       },
-      noVarTip: 'Ustaw wejścia, które można użyć w Przepływie',
+      noVarTip: 'Ustaw wejścia, które mogą być używane w przepływie pracy',
     },
     end: {
-      outputs: 'Wyjścia',
+      outputs: 'Wyniki',
       output: {
-        type: 'typ wyjścia',
-        variable: 'zmienna wyjścia',
+        type: 'typ wyniku',
+        variable: 'zmienna wyjściowa',
       },
       type: {
         'none': 'Brak',
-        'plain-text': 'Tekst Prosty',
-        'structured': 'Strukturyzowany',
+        'plain-text': 'Zwykły tekst',
+        'structured': 'Strukturalny',
       },
     },
     answer: {
       answer: 'Odpowiedź',
-      outputVars: 'Zmienne Wyjściowe',
+      outputVars: 'Zmienne wyjściowe',
     },
     llm: {
       model: 'model',
       variables: 'zmienne',
       context: 'kontekst',
-      contextTooltip: 'Możesz zaimportować Wiedzę jako kontekst',
-      notSetContextInPromptTip: 'Aby włączyć funkcję kontekstu, proszę wypełnić zmienną kontekstu w PROMPT.',
+      contextTooltip: 'Możesz zaimportować wiedzę jako kontekst',
+      notSetContextInPromptTip: 'Aby włączyć funkcję kontekstu, wypełnij zmienną kontekstu w PROMPT.',
       prompt: 'prompt',
       roleDescription: {
-        system: 'Daj instrukcje na wysokim poziomie dla rozmowy',
-        user: 'Dostarcz instrukcje, zapytania lub jakiekolwiek wejście oparte na tekście do modelu',
-        assistant: 'Odpowiedzi modelu na wiadomości użytkownika',
+        system: 'Podaj wysokopoziomowe instrukcje dla rozmowy',
+        user: 'Podaj instrukcje, zapytania lub dowolne tekstowe wejście dla modelu',
+        assistant: 'Odpowiedzi modelu oparte na wiadomościach użytkownika',
       },
-      addMessage: 'Dodaj Wiadomość',
+      addMessage: 'Dodaj wiadomość',
       vision: 'wizja',
       files: 'Pliki',
       resolution: {
@@ -209,7 +229,7 @@ const translation = {
         low: 'Niska',
       },
       outputVars: {
-        output: 'Generuj zawartość',
+        output: 'Generowana treść',
         usage: 'Informacje o użyciu modelu',
       },
       singleRun: {
@@ -218,78 +238,77 @@ const translation = {
       sysQueryInUser: 'sys.query w wiadomości użytkownika jest wymagane',
     },
     knowledgeRetrieval: {
-      queryVariable: 'Zmienna Zapytania',
+      queryVariable: 'Zmienna zapytania',
       knowledge: 'Wiedza',
       outputVars: {
-        output: 'Odzyskane dane podzielone',
-        content: 'Zawartość podzielona',
-        title: 'Tytuł podzielony',
-        icon: 'Ikona podzielona',
-        url: 'URL podzielony',
+        output: 'Odzyskane dane segmentowane',
+        content: 'Treść segmentowana',
+        title: 'Tytuł segmentowany',
+        icon: 'Ikona segmentowana',
+        url: 'URL segmentowany',
         metadata: 'Inne metadane',
       },
     },
     http: {
-      inputVars: 'Zmienne Wejściowe',
+      inputVars: 'Zmienne wejściowe',
       api: 'API',
-      apiPlaceholder: 'Wprowadź URL, wpisz \'/\' aby wstawić zmienną',
-      notStartWithHttp: 'API powinno rozpoczynać się od http:// lub https://',
+      apiPlaceholder: 'Wpisz URL, wpisz ‘/’, aby wstawić zmienną',
+      notStartWithHttp: 'API powinno zaczynać się od http:// lub https://',
       key: 'Klucz',
       value: 'Wartość',
-      bulkEdit: 'Edycja Masowa',
-      keyValueEdit: 'Edycja Klucz-Wartość',
+      bulkEdit: 'Edycja zbiorcza',
+      keyValueEdit: 'Edycja klucz-wartość',
       headers: 'Nagłówki',
       params: 'Parametry',
       body: 'Treść',
       outputVars: {
-        body: 'Zawartość Odpowiedzi',
-        statusCode: 'Kod Stanu Odpowiedzi',
-        headers: 'Lista Nagłówków Odpowiedzi w formacie JSON',
+        body: 'Treść odpowiedzi',
+        statusCode: 'Kod statusu odpowiedzi',
+        headers: 'Lista nagłówków odpowiedzi w formacie JSON',
         files: 'Lista plików',
       },
       authorization: {
         'authorization': 'Autoryzacja',
-        'authorizationType': 'Typ Autoryzacji',
+        'authorizationType': 'Typ autoryzacji',
         'no-auth': 'Brak',
         'api-key': 'Klucz API',
-        'auth-type': 'Typ Autoryzacji',
+        'auth-type': 'Typ autoryzacji',
         'basic': 'Podstawowa',
         'bearer': 'Bearer',
         'custom': 'Niestandardowa',
         'api-key-title': 'Klucz API',
         'header': 'Nagłówek',
       },
-      insertVarPlaceholder: 'wpisz \'/\' aby wstawić zmienną',
+      insertVarPlaceholder: 'wpisz \'/\', aby wstawić zmienną',
       timeout: {
         title: 'Limit czasu',
         connectLabel: 'Limit czasu połączenia',
-        connectPlaceholder: 'Wprowadź limit czasu połączenia w sekundach',
+        connectPlaceholder: 'Wpisz limit czasu połączenia w sekundach',
         readLabel: 'Limit czasu odczytu',
-        readPlaceholder: 'Wprowadź limit czasu odczytu w sekundach',
+        readPlaceholder: 'Wpisz limit czasu odczytu w sekundach',
         writeLabel: 'Limit czasu zapisu',
-        writePlaceholder: 'Wprowadź limit czasu zapisu w sekundach',
+        writePlaceholder: 'Wpisz limit czasu zapisu w sekundach',
       },
     },
     code: {
-      inputVars: 'Zmienne Wejściowe',
-      outputVars: 'Zmienne Wyjściowe',
-      advancedDependencies: 'Zaawansowane Zależności',
-      advancedDependenciesTip: 'Dodaj tutaj niektóre wstępnie załadowane zależności, które wymagają więcej czasu na załadowanie lub nie są domyślnie wbudowane',
-      searchDependencies: 'Wyszukaj Zależności',
-
+      inputVars: 'Zmienne wejściowe',
+      outputVars: 'Zmienne wyjściowe',
+      advancedDependencies: 'Zaawansowane zależności',
+      advancedDependenciesTip: 'Dodaj niektóre preładowane zależności, które zajmują więcej czasu lub nie są domyślnie wbudowane',
+      searchDependencies: 'Wyszukaj zależności',
     },
     templateTransform: {
-      inputVars: 'Zmienne Wejściowe',
+      inputVars: 'Zmienne wejściowe',
       code: 'Kod',
       codeSupportTip: 'Obsługuje tylko Jinja2',
       outputVars: {
-        output: 'Przekształcona zawartość',
+        output: 'Przekształcona treść',
       },
     },
     ifElse: {
       if: 'Jeśli',
       else: 'W przeciwnym razie',
-      elseDescription: 'Służy do zdefiniowania logiki, która powinna być wykonana, gdy warunek if nie jest spełniony.',
+      elseDescription: 'Używane do określenia logiki, która powinna być wykonana, gdy warunek if nie jest spełniony.',
       and: 'i',
       or: 'lub',
       operator: 'Operator',
@@ -303,61 +322,98 @@ const translation = {
         'is not': 'nie jest',
         'empty': 'jest pusty',
         'not empty': 'nie jest pusty',
-        'null': 'jest pusty',
-        'not null': 'nie jest pusty',
+        'null': 'jest null',
+        'not null': 'nie jest null',
       },
-      enterValue: 'Wprowadź wartość',
-      addCondition: 'Dodaj Warunek',
-      conditionNotSetup: 'Warunek NIE jest ustawiony',
+      enterValue: 'Wpisz wartość',
+      addCondition: 'Dodaj warunek',
+      conditionNotSetup: 'Warunek NIE został ustawiony',
     },
     variableAssigner: {
       title: 'Przypisz zmienne',
-      outputType: 'Typ Wyjścia',
-      outputVarType: 'Typ Zmiennej Wyjściowej',
-      varNotSet: 'Zmienna nieustawiona',
+      outputType: 'Typ wyjścia',
+      varNotSet: 'Zmienna nie została ustawiona',
       noVarTip: 'Dodaj zmienne do przypisania',
       type: {
-        string: 'Tekst',
+        string: 'Ciąg znaków',
         number: 'Liczba',
         object: 'Obiekt',
         array: 'Tablica',
       },
+      aggregationGroup: 'Grupa agregacji',
+      aggregationGroupTip: 'Włączenie tej funkcji pozwala na agregowanie wielu zestawów zmiennych przez agregator zmiennych.',
+      addGroup: 'Dodaj grupę',
       outputVars: {
-        output: 'Wartość zmiennej przypisanej',
+        varDescribe: 'Wyjście {{groupName}}',
       },
+      setAssignVariable: 'Ustaw przypisanie zmiennej',
     },
     tool: {
-      toAuthorize: 'Aby autoryzować',
-      inputVars: 'Zmienne Wejściowe',
+      toAuthorize: 'Do autoryzacji',
+      inputVars: 'Zmienne wejściowe',
       outputVars: {
-        text: 'wygenerowana zawartość narzędzia',
+        text: 'treść generowana przez narzędzie',
         files: {
-          title: 'wygenerowane pliki narzędzia',
-          type: 'Typ wsparcia. Obecnie obsługuje tylko obraz',
+          title: 'pliki generowane przez narzędzie',
+          type: 'Typ wsparcia. Obecnie tylko obsługuje obraz',
           transfer_method: 'Metoda transferu. Wartość to remote_url lub local_file',
           url: 'URL obrazu',
-          upload_file_id: 'Identyfikator przesyłanego pliku',
+          upload_file_id: 'ID przesłanego pliku',
         },
       },
     },
     questionClassifiers: {
       model: 'model',
-      inputVars: 'Zmienne Wejściowe',
+      inputVars: 'Zmienne wejściowe',
       outputVars: {
-        className: 'Nazwa Klasy',
+        className: 'Nazwa klasy',
       },
       class: 'Klasa',
-      classNamePlaceholder: 'Wpisz nazwę swojej klasy',
-      advancedSetting: 'Ustawienia Zaawansowane',
-      topicName: 'Nazwa Tematu',
-      topicPlaceholder: 'Wpisz nazwę swojego tematu',
-      addClass: 'Dodaj Klasę',
+      classNamePlaceholder: 'Napisz nazwę swojej klasy',
+      advancedSetting: 'Zaawansowane ustawienia',
+      topicName: 'Nazwa tematu',
+      topicPlaceholder: 'Napisz nazwę swojego tematu',
+      addClass: 'Dodaj klasę',
       instruction: 'Instrukcja',
-      instructionPlaceholder: 'Wpisz swoją instrukcję',
+      instructionTip: 'Wprowadź dodatkowe instrukcje, aby pomóc klasyfikatorowi pytań lepiej zrozumieć, jak kategoryzować pytania.',
+      instructionPlaceholder: 'Napisz swoją instrukcję',
+    },
+    parameterExtractor: {
+      inputVar: 'Zmienna wejściowa',
+      extractParameters: 'Wyodrębnij parametry',
+      importFromTool: 'Importuj z narzędzi',
+      addExtractParameter: 'Dodaj parametr wyodrębniania',
+      addExtractParameterContent: {
+        name: 'Nazwa',
+        namePlaceholder: 'Nazwa parametru wyodrębniania',
+        type: 'Typ',
+        typePlaceholder: 'Typ parametru wyodrębniania',
+        description: 'Opis',
+        descriptionPlaceholder: 'Opis parametru wyodrębniania',
+        required: 'Wymagane',
+        requiredContent: 'Wymagane jest tylko jako odniesienie do wnioskowania modelu, a nie do obowiązkowej walidacji wyjścia parametru.',
+      },
+      extractParametersNotSet: 'Parametry wyodrębniania nie zostały ustawione',
+      instruction: 'Instrukcja',
+      instructionTip: 'Wprowadź dodatkowe instrukcje, aby pomóc ekstraktorowi parametrów zrozumieć, jak wyodrębniać parametry.',
+      advancedSetting: 'Zaawansowane ustawienia',
+      reasoningMode: 'Tryb wnioskowania',
+      reasoningModeTip: 'Możesz wybrać odpowiedni tryb wnioskowania w zależności od zdolności modelu do reagowania na instrukcje dotyczące wywoływania funkcji lub zapytań.',
+      isSuccess: 'Czy się udało. W przypadku sukcesu wartość wynosi 1, w przypadku niepowodzenia wartość wynosi 0.',
+      errorReason: 'Powód błędu',
+    },
+    iteration: {
+      deleteTitle: 'Usunąć węzeł iteracji?',
+      deleteDesc: 'Usunięcie węzła iteracji usunie wszystkie węzły potomne',
+      input: 'Wejście',
+      output: 'Zmienne wyjściowe',
+      iteration_one: '{{count}} Iteracja',
+      iteration_other: '{{count}} Iteracje',
+      currentIteration: 'Bieżąca iteracja',
     },
   },
   tracing: {
-    stopBy: 'Zatrzymano przez {{user}}',
+    stopBy: 'Zatrzymane przez {{user}}',
   },
 }
 

web/i18n/pt-BR/workflow.ts

@@ -1,7 +1,7 @@
 const translation = {
   common: {
     editing: 'Editando',
-    autoSaved: 'Auto-salvo',
+    autoSaved: 'Salvo automaticamente',
     unpublished: 'Não publicado',
     published: 'Publicado',
     publish: 'Publicar',
@@ -9,15 +9,15 @@ const translation = {
     run: 'Executar',
     running: 'Executando',
     inRunMode: 'No modo de execução',
-    inPreview: 'Na prévia',
-    inPreviewMode: 'No modo de prévia',
-    preview: 'Prévia',
+    inPreview: 'Em visualização',
+    inPreviewMode: 'No modo de visualização',
+    preview: 'Visualizar',
     viewRunHistory: 'Ver histórico de execução',
     runHistory: 'Histórico de execução',
-    goBackToEdit: 'Voltar para a edição',
+    goBackToEdit: 'Voltar para o editor',
     conversationLog: 'Registro de conversa',
     features: 'Recursos',
-    debugAndPreview: 'Depurar e pré-visualizar',
+    debugAndPreview: 'Depurar e visualizar',
     restart: 'Reiniciar',
     currentDraft: 'Rascunho atual',
     currentDraftUnpublished: 'Rascunho atual não publicado',
@@ -27,50 +27,57 @@ const translation = {
     runApp: 'Executar aplicativo',
     batchRunApp: 'Executar aplicativo em lote',
     accessAPIReference: 'Acessar referência da API',
-    embedIntoSite: 'Incorporar no site',
+    embedIntoSite: 'Incorporar ao site',
     addTitle: 'Adicionar título...',
     addDescription: 'Adicionar descrição...',
     noVar: 'Sem variável',
     searchVar: 'Buscar variável',
     variableNamePlaceholder: 'Nome da variável',
-    setVarValuePlaceholder: 'Definir variável',
-    needConnecttip: 'Esta etapa não está conectada a nada',
-    maxTreeDepth: 'Limite máximo de {{depth}} nós por ramificação',
+    setVarValuePlaceholder: 'Definir valor da variável',
+    needConnecttip: 'Este passo não está conectado a nada',
+    maxTreeDepth: 'Limite máximo de {{depth}} nós por ramo',
     needEndNode: 'O bloco de fim deve ser adicionado',
     needAnswerNode: 'O bloco de resposta deve ser adicionado',
     workflowProcess: 'Processo de fluxo de trabalho',
-    notRunning: 'Ainda não em execução',
-    previewPlaceholder: 'Digite o conteúdo na caixa abaixo para iniciar a depuração do Chatbot',
+    notRunning: 'Ainda não está em execução',
+    previewPlaceholder: 'Digite o conteúdo na caixa abaixo para começar a depurar o Chatbot',
     effectVarConfirm: {
       title: 'Remover variável',
-      content: 'A variável está sendo usada em outros nós. Deseja removê-la mesmo assim?',
+      content: 'A variável é usada em outros nós. Você ainda deseja removê-la?',
     },
     insertVarTip: 'Pressione a tecla \'/\' para inserir rapidamente',
     processData: 'Processar dados',
     input: 'Entrada',
     output: 'Saída',
     jinjaEditorPlaceholder: 'Digite \'/\' ou \'{\' para inserir variável',
-    viewOnly: 'Apenas Visualização',
-    showRunHistory: 'Mostrar Histórico de Execuções',
-    enableJinja: 'Ativar suporte a templates Jinja',
-    learnMore: 'Saiba Mais',
+    viewOnly: 'Apenas visualização',
+    showRunHistory: 'Mostrar histórico de execução',
+    enableJinja: 'Ativar suporte ao template Jinja',
+    learnMore: 'Saiba mais',
     copy: 'Copiar',
     duplicate: 'Duplicar',
-    addBlock: 'Adicionar Bloco',
-    pasteHere: 'Colar Aqui',
-    pointerMode: 'Modo Ponteiro',
-    handMode: 'Modo Manual',
+    addBlock: 'Adicionar bloco',
+    pasteHere: 'Colar aqui',
+    pointerMode: 'Modo ponteiro',
+    handMode: 'Modo mão',
+    model: 'Modelo',
+    workflowAsTool: 'Fluxo de trabalho como ferramenta',
+    configureRequired: 'Configuração necessária',
+    configure: 'Configurar',
+    manageInTools: 'Gerenciar nas ferramentas',
+    workflowAsToolTip: 'É necessária a reconfiguração da ferramenta após a atualização do fluxo de trabalho.',
+    viewDetailInTracingPanel: 'Ver detalhes',
   },
   errorMsg: {
     fieldRequired: '{{field}} é obrigatório',
     authRequired: 'Autorização é necessária',
-    invalidJson: '{{field}} é JSON inválido',
+    invalidJson: '{{field}} é um JSON inválido',
     fields: {
-      variable: 'Nome da Variável',
-      variableValue: 'Valor da Variável',
+      variable: 'Nome da variável',
+      variableValue: 'Valor da variável',
       code: 'Código',
       model: 'Modelo',
-      rerankModel: 'Modelo de Re-ordenação',
+      rerankModel: 'Modelo de reordenação',
     },
     invalidVariable: 'Variável inválida',
   },
@@ -78,50 +85,63 @@ const translation = {
     testRun: 'Execução de teste ',
     startRun: 'Iniciar execução',
     running: 'Executando',
+    testRunIteration: 'Iteração de execução de teste',
+    back: 'Voltar',
+    iteration: 'Iteração',
   },
   tabs: {
     'searchBlock': 'Buscar bloco',
     'blocks': 'Blocos',
-    'builtInTool': 'Ferramenta incorporada',
-    'customTool': 'Ferramenta personalizada',
-    'question-understand': 'Entendimento da pergunta',
+    'tools': 'Ferramentas',
+    'allTool': 'Todos',
+    'builtInTool': 'Integrado',
+    'customTool': 'Personalizado',
+    'workflowTool': 'Fluxo de trabalho',
+    'question-understand': 'Compreensão de perguntas',
     'logic': 'Lógica',
     'transform': 'Transformar',
     'utilities': 'Utilitários',
     'noResult': 'Nenhum resultado encontrado',
   },
   blocks: {
-    'start': 'Início',
+    'start': 'Iniciar',
     'end': 'Fim',
     'answer': 'Resposta',
     'llm': 'LLM',
     'knowledge-retrieval': 'Recuperação de conhecimento',
     'question-classifier': 'Classificador de perguntas',
-    'if-else': 'Se/Senão',
+    'if-else': 'SE/SENÃO',
     'code': 'Código',
     'template-transform': 'Modelo',
     'http-request': 'Requisição HTTP',
     'variable-assigner': 'Atribuidor de variáveis',
+    'variable-aggregator': 'Agregador de variáveis',
+    'iteration-start': 'Início de iteração',
+    'iteration': 'Iteração',
+    'parameter-extractor': 'Extrator de parâmetros',
   },
   blocksAbout: {
-    'start': 'Defina os parâmetros iniciais para iniciar um fluxo de trabalho',
-    'end': 'Defina o final e o tipo de resultado de um fluxo de trabalho',
-    'answer': 'Defina o conteúdo da resposta de uma conversa no chat',
+    'start': 'Definir os parâmetros iniciais para iniciar um fluxo de trabalho',
+    'end': 'Definir o fim e o tipo de resultado de um fluxo de trabalho',
+    'answer': 'Definir o conteúdo da resposta de uma conversa',
     'llm': 'Invocar grandes modelos de linguagem para responder perguntas ou processar linguagem natural',
-    'knowledge-retrieval': 'Permite consultar conteúdo de texto relacionado a perguntas de usuário do conhecimento',
-    'question-classifier': 'Define as condições de classificação de perguntas do usuário, LLM pode definir como a conversa progride com base na descrição da classificação',
-    'if-else': 'Permite dividir o fluxo de trabalho em dois ramos com base em condições if/else',
-    'code': 'Execute um trecho de código Python ou NodeJS para implementar lógica personalizada',
-    'template-transform': 'Converta dados em string usando a sintaxe do modelo Jinja',
-    'http-request': 'Permite enviar solicitações de servidor sobre o protocolo HTTP',
-    'variable-assigner': 'Atribua variáveis em diferentes ramos à mesma variável para alcançar uma configuração unificada de pós-nós',
+    'knowledge-retrieval': 'Permite consultar conteúdo de texto relacionado a perguntas do usuário a partir da base de conhecimento',
+    'question-classifier': 'Definir as condições de classificação das perguntas dos usuários, LLM pode definir como a conversa progride com base na descrição da classificação',
+    'if-else': 'Permite dividir o fluxo de trabalho em dois ramos com base nas condições if/else',
+    'code': 'Executar um pedaço de código Python ou NodeJS para implementar lógica personalizada',
+    'template-transform': 'Converter dados em string usando a sintaxe de template Jinja',
+    'http-request': 'Permitir que solicitações de servidor sejam enviadas pelo protocolo HTTP',
+    'variable-assigner': 'Agregue variáveis de vários ramos em uma única variável para configuração unificada dos nós finais.',
+    'variable-aggregator': 'Agregue variáveis de vários ramos em uma única variável para configuração unificada dos nós finais.',
+    'iteration': 'Execute múltiplos passos em um objeto lista até que todos os resultados sejam produzidos.',
+    'parameter-extractor': 'Use LLM para extrair parâmetros estruturados da linguagem natural para invocações de ferramentas ou requisições HTTP.',
   },
   operator: {
-    zoomIn: 'Aumentar zoom',
-    zoomOut: 'Diminuir zoom',
-    zoomTo50: 'Zoom para 50%',
-    zoomTo100: 'Zoom para 100%',
-    zoomToFit: 'Zoom para ajustar',
+    zoomIn: 'Aproximar',
+    zoomOut: 'Afastar',
+    zoomTo50: 'Aproximar para 50%',
+    zoomTo100: 'Aproximar para 100%',
+    zoomToFit: 'Aproximar para ajustar',
   },
   panel: {
     userInputField: 'Campo de entrada do usuário',
@@ -134,18 +154,18 @@ const translation = {
     selectNextStep: 'Selecionar próximo bloco',
     runThisStep: 'Executar este passo',
     checklist: 'Lista de verificação',
-    checklistTip: 'Certifique-se de resolver todos os problemas antes de publicar',
-    checklistResolved: 'Todos os problemas estão resolvidos',
+    checklistTip: 'Certifique-se de que todos os problemas foram resolvidos antes de publicar',
+    checklistResolved: 'Todos os problemas foram resolvidos',
     organizeBlocks: 'Organizar blocos',
     change: 'Mudar',
   },
   nodes: {
     common: {
       outputVars: 'Variáveis de saída',
-      insertVarTip: 'Pressione a tecla \'/\' para inserir',
+      insertVarTip: 'Inserir variável',
       memory: {
         memory: 'Memória',
-        memoryTip: 'Configurações de memória do chat',
+        memoryTip: 'Configurações de memória de conversa',
         windowSize: 'Tamanho da janela',
         conversationRoleName: 'Nome do papel na conversa',
         user: 'Prefixo do usuário',
@@ -153,30 +173,30 @@ const translation = {
       },
       memories: {
         title: 'Memórias',
-        tip: 'Memória do chat',
-        builtIn: 'Incorporada',
+        tip: 'Memória de conversa',
+        builtIn: 'Integrado',
       },
     },
     start: {
-      required: 'obrigatório',
+      required: 'requerido',
       inputField: 'Campo de entrada',
-      builtInVar: 'Variáveis incorporadas',
+      builtInVar: 'Variáveis integradas',
       outputVars: {
         query: 'Entrada do usuário',
         memories: {
           des: 'Histórico da conversa',
-          type: 'Tipo de mensagem',
-          content: 'Conteúdo da mensagem',
+          type: 'tipo de mensagem',
+          content: 'conteúdo da mensagem',
         },
         files: 'Lista de arquivos',
       },
-      noVarTip: 'Defina as entradas que podem ser usadas no fluxo de trabalho',
+      noVarTip: 'Defina as entradas que podem ser usadas no Fluxo de Trabalho',
     },
     end: {
       outputs: 'Saídas',
       output: {
-        type: 'Tipo de saída',
-        variable: 'Variável de saída',
+        type: 'tipo de saída',
+        variable: 'variável de saída',
       },
       type: {
         'none': 'Nenhum',
@@ -192,13 +212,13 @@ const translation = {
       model: 'modelo',
       variables: 'variáveis',
       context: 'contexto',
-      contextTooltip: 'Você pode importar conhecimento como contexto',
-      notSetContextInPromptTip: 'Para habilitar o recurso de contexto, preencha a variável de contexto em PROMPT.',
+      contextTooltip: 'Você pode importar Conhecimento como contexto',
+      notSetContextInPromptTip: 'Para ativar o recurso de contexto, preencha a variável de contexto no PROMPT.',
       prompt: 'prompt',
       roleDescription: {
         system: 'Dar instruções de alto nível para a conversa',
         user: 'Fornecer instruções, consultas ou qualquer entrada baseada em texto para o modelo',
-        assistant: 'Respostas do modelo com base nas mensagens do usuário',
+        assistant: 'As respostas do modelo baseadas nas mensagens do usuário',
       },
       addMessage: 'Adicionar mensagem',
       vision: 'visão',
@@ -209,73 +229,73 @@ const translation = {
         low: 'Baixa',
       },
       outputVars: {
-        output: 'Gerar conteúdo',
+        output: 'Conteúdo gerado',
         usage: 'Informações de uso do modelo',
       },
       singleRun: {
         variable: 'Variável',
       },
-      sysQueryInUser: 'sys.query em user é inválido',
+      sysQueryInUser: 'sys.query na mensagem do usuário é necessário',
     },
     knowledgeRetrieval: {
       queryVariable: 'Variável de consulta',
       knowledge: 'Conhecimento',
       outputVars: {
-        output: 'Dados segmentados de recuperação',
+        output: 'Dados segmentados recuperados',
         content: 'Conteúdo segmentado',
         title: 'Título segmentado',
         icon: 'Ícone segmentado',
-        url: 'URL segmentada',
+        url: 'URL segmentado',
         metadata: 'Outros metadados',
       },
     },
     http: {
       inputVars: 'Variáveis de entrada',
       api: 'API',
-      apiPlaceholder: 'Insira o URL, digite \'/\' para inserir a variável',
-      notStartWithHttp: 'A API deve começar com http:// ou https://',
+      apiPlaceholder: 'Digite a URL, digite ‘/’ para inserir variável',
+      notStartWithHttp: 'API deve começar com http:// ou https://',
       key: 'Chave',
       value: 'Valor',
-      bulkEdit: 'Editar em massa',
-      keyValueEdit: 'Edição de chave-valor',
+      bulkEdit: 'Edição em massa',
+      keyValueEdit: 'Edição chave-valor',
       headers: 'Cabeçalhos',
       params: 'Parâmetros',
       body: 'Corpo',
       outputVars: {
         body: 'Conteúdo da resposta',
         statusCode: 'Código de status da resposta',
-        headers: 'Lista de cabeçalhos de resposta JSON',
+        headers: 'Lista de cabeçalhos da resposta em JSON',
         files: 'Lista de arquivos',
       },
       authorization: {
         'authorization': 'Autorização',
         'authorizationType': 'Tipo de autorização',
-        'no-auth': 'Nenhum',
-        'api-key': 'Chave da API',
-        'auth-type': 'Tipo de autenticação',
+        'no-auth': 'Nenhuma',
+        'api-key': 'Chave API',
+        'auth-type': 'Tipo de autorização',
         'basic': 'Básica',
         'bearer': 'Bearer',
         'custom': 'Personalizada',
-        'api-key-title': 'Chave da API',
+        'api-key-title': 'Chave API',
         'header': 'Cabeçalho',
       },
       insertVarPlaceholder: 'digite \'/\' para inserir variável',
       timeout: {
-        title: 'Tempo esgotado',
-        connectLabel: 'Tempo de conexão',
-        connectPlaceholder: 'Insira o tempo de conexão em segundos',
-        readLabel: 'Tempo de leitura',
-        readPlaceholder: 'Insira o tempo de leitura em segundos',
-        writeLabel: 'Tempo de escrita',
-        writePlaceholder: 'Insira o tempo de escrita em segundos',
+        title: 'Timeout',
+        connectLabel: 'Timeout de conexão',
+        connectPlaceholder: 'Digite o timeout de conexão em segundos',
+        readLabel: 'Timeout de leitura',
+        readPlaceholder: 'Digite o timeout de leitura em segundos',
+        writeLabel: 'Timeout de escrita',
+        writePlaceholder: 'Digite o timeout de escrita em segundos',
       },
     },
     code: {
       inputVars: 'Variáveis de entrada',
       outputVars: 'Variáveis de saída',
-      advancedDependencies: 'Dependências Avançadas',
-      advancedDependenciesTip: 'Adicione algumas dependências pré-carregadas que demoram mais para serem consumidas ou que não são padrão aqui',
-      searchDependencies: 'Pesquisar Dependências',
+      advancedDependencies: 'Dependências avançadas',
+      advancedDependenciesTip: 'Adicione algumas dependências pré-carregadas que levam mais tempo para consumir ou não são padrão aqui',
+      searchDependencies: 'Buscar dependências',
     },
     templateTransform: {
       inputVars: 'Variáveis de entrada',
@@ -300,9 +320,9 @@ const translation = {
         'end with': 'termina com',
         'is': 'é',
         'is not': 'não é',
-        'empty': 'vazio',
+        'empty': 'está vazio',
         'not empty': 'não está vazio',
-        'null': 'nulo',
+        'null': 'é nulo',
         'not null': 'não é nulo',
       },
       enterValue: 'Digite o valor',
@@ -312,7 +332,6 @@ const translation = {
     variableAssigner: {
       title: 'Atribuir variáveis',
       outputType: 'Tipo de saída',
-      outputVarType: 'Tipo de variável de saída',
       varNotSet: 'Variável não definida',
       noVarTip: 'Adicione as variáveis a serem atribuídas',
       type: {
@@ -321,21 +340,25 @@ const translation = {
         object: 'Objeto',
         array: 'Array',
       },
+      aggregationGroup: 'Grupo de agregação',
+      aggregationGroupTip: 'Habilitar este recurso permite que o agregador de variáveis agregue múltiplos conjuntos de variáveis.',
+      addGroup: 'Adicionar grupo',
       outputVars: {
-        output: 'Valor da variável atribuída',
+        varDescribe: 'Saída de {{groupName}}',
       },
+      setAssignVariable: 'Definir variável atribuída',
     },
     tool: {
-      toAuthorize: 'Para autorizar',
+      toAuthorize: 'Autorizar',
       inputVars: 'Variáveis de entrada',
       outputVars: {
         text: 'conteúdo gerado pela ferramenta',
         files: {
           title: 'arquivos gerados pela ferramenta',
-          type: 'Tipo de suporte. Agora apenas suporte a imagem',
+          type: 'Tipo de suporte. Agora suporta apenas imagem',
           transfer_method: 'Método de transferência. O valor é remote_url ou local_file',
           url: 'URL da imagem',
-          upload_file_id: 'ID de upload do arquivo',
+          upload_file_id: 'ID do arquivo enviado',
         },
       },
     },
@@ -346,14 +369,48 @@ const translation = {
         className: 'Nome da classe',
       },
       class: 'Classe',
-      classNamePlaceholder: 'Escreva o nome da classe',
+      classNamePlaceholder: 'Escreva o nome da sua classe',
       advancedSetting: 'Configuração avançada',
       topicName: 'Nome do tópico',
-      topicPlaceholder: 'Escreva o nome do tópico',
+      topicPlaceholder: 'Escreva o nome do seu tópico',
       addClass: 'Adicionar classe',
       instruction: 'Instrução',
+      instructionTip: 'Insira instruções adicionais para ajudar o classificador de perguntas a entender melhor como categorizar perguntas.',
       instructionPlaceholder: 'Escreva sua instrução',
     },
+    parameterExtractor: {
+      inputVar: 'Variável de entrada',
+      extractParameters: 'Extrair parâmetros',
+      importFromTool: 'Importar das ferramentas',
+      addExtractParameter: 'Adicionar parâmetro de extração',
+      addExtractParameterContent: {
+        name: 'Nome',
+        namePlaceholder: 'Nome do parâmetro de extração',
+        type: 'Tipo',
+        typePlaceholder: 'Tipo de parâmetro de extração',
+        description: 'Descrição',
+        descriptionPlaceholder: 'Descrição do parâmetro de extração',
+        required: 'Obrigatório',
+        requiredContent: 'Obrigatório é usado apenas como referência para inferência do modelo, e não para validação obrigatória da saída do parâmetro.',
+      },
+      extractParametersNotSet: 'Parâmetros de extração não configurados',
+      instruction: 'Instrução',
+      instructionTip: 'Insira instruções adicionais para ajudar o extrator de parâmetros a entender como extrair parâmetros.',
+      advancedSetting: 'Configuração avançada',
+      reasoningMode: 'Modo de raciocínio',
+      reasoningModeTip: 'Você pode escolher o modo de raciocínio apropriado com base na capacidade do modelo de responder a instruções para chamadas de função ou prompts.',
+      isSuccess: 'É sucesso. Em caso de sucesso, o valor é 1, em caso de falha, o valor é 0.',
+      errorReason: 'Motivo do erro',
+    },
+    iteration: {
+      deleteTitle: 'Excluir nó de iteração?',
+      deleteDesc: 'Excluir o nó de iteração excluirá todos os nós filhos',
+      input: 'Entrada',
+      output: 'Variáveis de saída',
+      iteration_one: '{{count}} Iteração',
+      iteration_other: '{{count}} Iterações',
+      currentIteration: 'Iteração atual',
+    },
   },
   tracing: {
     stopBy: 'Parado por {{user}}',

web/i18n/ro-RO/workflow.ts

@@ -7,166 +7,186 @@ const translation = {
     publish: 'Publică',
     update: 'Actualizează',
     run: 'Rulează',
-    running: 'În desfășurare',
+    running: 'Rulând',
     inRunMode: 'În modul de rulare',
     inPreview: 'În previzualizare',
     inPreviewMode: 'În modul de previzualizare',
-    preview: 'Previzualizare',
-    viewRunHistory: 'Vezi istoricul de rulare',
-    runHistory: 'Istoric de rulare',
+    preview: 'Previzualizează',
+    viewRunHistory: 'Vezi istoricul rulărilor',
+    runHistory: 'Istoric rulări',
     goBackToEdit: 'Înapoi la editor',
-    conversationLog: 'Jurnal de conversație',
-    features: 'Caracteristici',
+    conversationLog: 'Jurnal conversație',
+    features: 'Funcționalități',
     debugAndPreview: 'Depanare și previzualizare',
     restart: 'Repornește',
-    currentDraft: 'Schița curentă',
-    currentDraftUnpublished: 'Schița curentă nepublicată',
-    latestPublished: 'Cel mai recent publicat',
+    currentDraft: 'Schimbare curentă',
+    currentDraftUnpublished: 'Schimbare curentă nepublicată',
+    latestPublished: 'Ultima publicare',
     publishedAt: 'Publicat la',
     restore: 'Restaurează',
     runApp: 'Rulează aplicația',
     batchRunApp: 'Rulează aplicația în lot',
     accessAPIReference: 'Accesează referința API',
-    embedIntoSite: 'Încorporează în site',
+    embedIntoSite: 'Incorporează în site',
     addTitle: 'Adaugă titlu...',
     addDescription: 'Adaugă descriere...',
-    noVar: 'Nicio variabilă',
+    noVar: 'Fără variabilă',
     searchVar: 'Caută variabilă',
-    variableNamePlaceholder: 'Numele variabilei',
-    setVarValuePlaceholder: 'Setează variabila',
-    needConnecttip: 'Această etapă nu este conectată la nimic',
+    variableNamePlaceholder: 'Nume variabilă',
+    setVarValuePlaceholder: 'Setează valoarea variabilei',
+    needConnecttip: 'Acest pas nu este conectat la nimic',
     maxTreeDepth: 'Limită maximă de {{depth}} noduri pe ramură',
-    needEndNode: 'Blocul de Sfârșit trebuie adăugat',
-    needAnswerNode: 'Blocul de Răspuns trebuie adăugat',
+    needEndNode: 'Trebuie adăugat blocul de sfârșit',
+    needAnswerNode: 'Trebuie adăugat blocul de răspuns',
     workflowProcess: 'Proces de flux de lucru',
     notRunning: 'Încă nu rulează',
-    previewPlaceholder: 'Introduceți conținutul în caseta de mai jos pentru a începe depanarea Chatbot-ului',
+    previewPlaceholder: 'Introduceți conținutul în caseta de mai jos pentru a începe depanarea Chatbotului',
     effectVarConfirm: {
       title: 'Elimină variabila',
-      content: 'Variabila este utilizată în alte noduri. Doriți totuși să o eliminați?',
+      content: 'Variabila este utilizată în alte noduri. Doriți să o eliminați oricum?',
     },
     insertVarTip: 'Apăsați tasta \'/\' pentru a insera rapid',
-    processData: 'Procesează datele',
+    processData: 'Procesează date',
     input: 'Intrare',
     output: 'Ieșire',
     jinjaEditorPlaceholder: 'Tastați \'/\' sau \'{\' pentru a insera variabila',
-    viewOnly: 'Doar vizualizare',
-    showRunHistory: 'Afișează istoricul de rulare',
+    viewOnly: 'Vizualizare doar',
+    showRunHistory: 'Afișează istoricul rulărilor',
     enableJinja: 'Activează suportul pentru șabloane Jinja',
     learnMore: 'Află mai multe',
     copy: 'Copiază',
     duplicate: 'Duplică',
-    addBlock: 'Adaugă Bloc',
-    pasteHere: 'Lipește Aici',
-    pointerMode: 'Mod Indicator',
-    handMode: 'Mod Manual',
+    addBlock: 'Adaugă bloc',
+    pasteHere: 'Lipește aici',
+    pointerMode: 'Modul pointer',
+    handMode: 'Modul mână',
+    model: 'Model',
+    workflowAsTool: 'Flux de lucru ca instrument',
+    configureRequired: 'Configurare necesară',
+    configure: 'Configurează',
+    manageInTools: 'Gestionează în instrumente',
+    workflowAsToolTip: 'Reconfigurarea instrumentului este necesară după actualizarea fluxului de lucru.',
+    viewDetailInTracingPanel: 'Vezi detalii',
   },
   errorMsg: {
     fieldRequired: '{{field}} este obligatoriu',
-    authRequired: 'Este necesară autorizarea',
-    invalidJson: '{{field}} nu este un JSON valid',
+    authRequired: 'Autorizarea este necesară',
+    invalidJson: '{{field}} este un JSON invalid',
     fields: {
-      variable: 'Numele variabilei',
-      variableValue: 'Valoarea variabilei',
+      variable: 'Nume variabilă',
+      variableValue: 'Valoare variabilă',
       code: 'Cod',
       model: 'Model',
-      rerankModel: 'Model de reevaluare',
+      rerankModel: 'Model de rerankare',
     },
     invalidVariable: 'Variabilă invalidă',
   },
   singleRun: {
-    testRun: 'Rulare de test',
+    testRun: 'Rulare de test ',
     startRun: 'Începe rularea',
-    running: 'În desfășurare',
+    running: 'Rulând',
+    testRunIteration: 'Iterație rulare de test',
+    back: 'Înapoi',
+    iteration: 'Iterație',
   },
   tabs: {
-    'searchBlock': 'Căutare bloc',
+    'searchBlock': 'Caută bloc',
     'blocks': 'Blocuri',
-    'builtInTool': 'Instrument încorporat',
-    'customTool': 'Instrument personalizat',
-    'question-understand': 'Înțelegerea întrebării',
+    'tools': 'Instrumente',
+    'allTool': 'Toate',
+    'builtInTool': 'Integrat',
+    'customTool': 'Personalizat',
+    'workflowTool': 'Flux de lucru',
+    'question-understand': 'Înțelegerea întrebărilor',
     'logic': 'Logică',
     'transform': 'Transformare',
     'utilities': 'Utilități',
-    'noResult': 'Nicio potrivire găsită',
+    'noResult': 'Niciun rezultat găsit',
   },
   blocks: {
-    'start': 'Început',
+    'start': 'Începe',
     'end': 'Sfârșit',
     'answer': 'Răspuns',
     'llm': 'LLM',
-    'knowledge-retrieval': 'Recuperare cunoștințe',
+    'knowledge-retrieval': 'Recuperare de cunoștințe',
     'question-classifier': 'Clasificator de întrebări',
-    'if-else': 'DACĂ/ALTĂFEL',
+    'if-else': 'Dacă/Altminteri',
     'code': 'Cod',
     'template-transform': 'Șablon',
     'http-request': 'Cerere HTTP',
-    'variable-assigner': 'Atribuire variabilă',
+    'variable-assigner': 'Asignator de variabile',
+    'variable-aggregator': 'Agregator de variabile',
+    'iteration-start': 'Început de iterație',
+    'iteration': 'Iterație',
+    'parameter-extractor': 'Extractor de parametri',
   },
   blocksAbout: {
     'start': 'Definiți parametrii inițiali pentru lansarea unui flux de lucru',
-    'end': 'Definiți sfârșitul și tipul de rezultat al unui flux de lucru',
-    'answer': 'Definiți conținutul de răspuns al unei conversații prin chat',
-    'llm': 'Invocarea modelelor de limbaj extinse pentru a răspunde la întrebări sau a procesa limbajul natural',
-    'knowledge-retrieval': 'Vă permite să interogați conținutul text legat de întrebările utilizatorului din Cunoștințe',
-    'question-classifier': 'Definiți condițiile de clasificare ale întrebărilor utilizatorului, LLM poate defini modul în care conversația progresează pe baza descrierii clasificării',
-    'if-else': 'Vă permite să împărțiți fluxul de lucru în două ramuri pe baza condițiilor dacă/altăfel',
-    'code': 'Executați un fragment de cod Python sau NodeJS pentru a implementa o logică personalizată',
-    'template-transform': 'Conversia datelor în șiruri folosind sintaxa șablonului Jinja',
-    'http-request': 'Permite trimiterea de cereri de la server prin protocolul HTTP',
-    'variable-assigner': 'Atribuie variabile în diferite ramuri aceleiași variabile pentru a obține o configurare unificată a post-nodurilor',
+    'end': 'Definiți sfârșitul și tipul rezultatului unui flux de lucru',
+    'answer': 'Definiți conținutul răspunsului unei conversații',
+    'llm': 'Invocarea modelelor de limbaj mari pentru a răspunde la întrebări sau pentru a procesa limbajul natural',
+    'knowledge-retrieval': 'Permite interogarea conținutului textului legat de întrebările utilizatorului din baza de cunoștințe',
+    'question-classifier': 'Definiți condițiile de clasificare a întrebărilor utilizatorului, LLM poate defini cum progresează conversația pe baza descrierii clasificării',
+    'if-else': 'Permite împărțirea fluxului de lucru în două ramuri pe baza condițiilor if/else',
+    'code': 'Executați un fragment de cod Python sau NodeJS pentru a implementa logică personalizată',
+    'template-transform': 'Convertiți datele în șiruri de caractere folosind sintaxa șablonului Jinja',
+    'http-request': 'Permite trimiterea cererilor de server prin protocolul HTTP',
+    'variable-assigner': 'Agregarea variabilelor din mai multe ramuri într-o singură variabilă pentru configurarea unificată a nodurilor ulterioare.',
+    'variable-aggregator': 'Agregarea variabilelor din mai multe ramuri într-o singură variabilă pentru configurarea unificată a nodurilor ulterioare.',
+    'iteration': 'Efectuați mai mulți pași pe un obiect listă până când toate rezultatele sunt produse.',
+    'parameter-extractor': 'Utilizați LLM pentru a extrage parametrii structurați din limbajul natural pentru invocările de instrumente sau cererile HTTP.',
   },
   operator: {
     zoomIn: 'Mărește',
     zoomOut: 'Micșorează',
-    zoomTo50: 'Zoom la 50%',
-    zoomTo100: 'Zoom la 100%',
-    zoomToFit: 'Zoom la potrivire',
+    zoomTo50: 'Mărește la 50%',
+    zoomTo100: 'Mărește la 100%',
+    zoomToFit: 'Mărește pentru a se potrivi',
   },
   panel: {
-    userInputField: 'Câmp de intrare utilizator',
+    userInputField: 'Câmp de introducere utilizator',
     changeBlock: 'Schimbă blocul',
     helpLink: 'Link de ajutor',
     about: 'Despre',
     createdBy: 'Creat de ',
     nextStep: 'Pasul următor',
     addNextStep: 'Adăugați următorul bloc în acest flux de lucru',
-    selectNextStep: 'Selectați blocul următor',
+    selectNextStep: 'Selectați următorul bloc',
     runThisStep: 'Rulează acest pas',
-    checklist: 'Listă de verificare',
+    checklist: 'Lista de verificare',
     checklistTip: 'Asigurați-vă că toate problemele sunt rezolvate înainte de publicare',
-    checklistResolved: 'Toate problemele sunt rezolvate',
-    organizeBlocks: 'Organizați blocurile',
+    checklistResolved: 'Toate problemele au fost rezolvate',
+    organizeBlocks: 'Organizează blocurile',
     change: 'Schimbă',
   },
   nodes: {
     common: {
       outputVars: 'Variabile de ieșire',
-      insertVarTip: 'Inserați variabila',
+      insertVarTip: 'Inserează variabilă',
       memory: {
         memory: 'Memorie',
-        memoryTip: 'Configurări de memorie pentru chat',
+        memoryTip: 'Setări de memorie pentru conversație',
         windowSize: 'Dimensiunea ferestrei',
-        conversationRoleName: 'Numele rolului de conversație',
+        conversationRoleName: 'Numele rolului în conversație',
         user: 'Prefix utilizator',
         assistant: 'Prefix asistent',
       },
       memories: {
         title: 'Amintiri',
-        tip: 'Memorie de chat',
-        builtIn: 'Încorporat',
+        tip: 'Memoria conversației',
+        builtIn: 'Integrat',
       },
     },
     start: {
-      required: 'obligatoriu',
+      required: 'necesar',
       inputField: 'Câmp de intrare',
-      builtInVar: 'Variabile încorporate',
+      builtInVar: 'Variabile integrate',
       outputVars: {
         query: 'Intrare utilizator',
         memories: {
-          des: 'Istoricul conversației',
-          type: 'tipul mesajului',
-          content: 'conținutul mesajului',
+          des: 'Istoric conversație',
+          type: 'tip mesaj',
+          content: 'conținut mesaj',
         },
         files: 'Listă de fișiere',
       },
@@ -175,11 +195,11 @@ const translation = {
     end: {
       outputs: 'Ieșiri',
       output: {
-        type: 'tipul ieșirii',
-        variable: 'variabila de ieșire',
+        type: 'tip ieșire',
+        variable: 'variabilă de ieșire',
       },
       type: {
-        'none': 'Niciunul',
+        'none': 'Nimic',
         'plain-text': 'Text simplu',
         'structured': 'Structurat',
       },
@@ -192,36 +212,36 @@ const translation = {
       model: 'model',
       variables: 'variabile',
       context: 'context',
-      contextTooltip: 'Puteți importa Cunoștințe ca context',
-      notSetContextInPromptTip: 'Pentru a activa funcția de context, vă rugăm să completați variabila de context în PROMPT.',
+      contextTooltip: 'Puteți importa cunoștințe ca și context',
+      notSetContextInPromptTip: 'Pentru a activa funcția de context, completați variabila de context în PROMPT.',
       prompt: 'prompt',
       roleDescription: {
         system: 'Dați instrucțiuni de nivel înalt pentru conversație',
-        user: 'Furnizați instrucțiuni, interogări sau orice intrare bazată pe text pentru model',
+        user: 'Furnizați instrucțiuni, întrebări sau orice intrare bazată pe text pentru model',
         assistant: 'Răspunsurile modelului bazate pe mesajele utilizatorului',
       },
-      addMessage: 'Adăugați mesaj',
+      addMessage: 'Adaugă mesaj',
       vision: 'viziune',
       files: 'Fișiere',
       resolution: {
         name: 'Rezoluție',
         high: 'Înaltă',
-        low: 'Scăzută',
+        low: 'Joasă',
       },
       outputVars: {
-        output: 'Generați conținut',
-        usage: 'Informații despre utilizarea modelului',
+        output: 'Conținut generat',
+        usage: 'Informații de utilizare a modelului',
       },
       singleRun: {
         variable: 'Variabilă',
       },
-      sysQueryInUser: 'sys.query în mesajul utilizatorului este obligatoriu',
+      sysQueryInUser: 'sys.query în mesajul utilizatorului este necesar',
     },
     knowledgeRetrieval: {
       queryVariable: 'Variabilă de interogare',
       knowledge: 'Cunoștințe',
       outputVars: {
-        output: 'Date segmentate de recuperare',
+        output: 'Date segmentate recuperate',
         content: 'Conținut segmentat',
         title: 'Titlu segmentat',
         icon: 'Pictogramă segmentată',
@@ -232,63 +252,63 @@ const translation = {
     http: {
       inputVars: 'Variabile de intrare',
       api: 'API',
-      apiPlaceholder: 'Introduceți URL-ul, tastați \'/\' pentru a insera variabila',
+      apiPlaceholder: 'Introduceți URL-ul, tastați ‘/’ pentru a insera variabilă',
       notStartWithHttp: 'API-ul trebuie să înceapă cu http:// sau https://',
       key: 'Cheie',
       value: 'Valoare',
-      bulkEdit: 'Editare în bloc',
+      bulkEdit: 'Editare în masă',
       keyValueEdit: 'Editare cheie-valoare',
       headers: 'Antete',
       params: 'Parametri',
       body: 'Corp',
       outputVars: {
         body: 'Conținutul răspunsului',
-        statusCode: 'Codul de stare al răspunsului',
-        headers: 'Listă anteturi răspuns JSON',
-        files: 'Listă de fișiere',
+        statusCode: 'Cod de stare al răspunsului',
+        headers: 'Lista antetelor de răspuns în format JSON',
+        files: 'Lista fișierelor',
       },
       authorization: {
         'authorization': 'Autorizare',
-        'authorizationType': 'Tipul autorizării',
-        'no-auth': 'Niciunul',
+        'authorizationType': 'Tip de autorizare',
+        'no-auth': 'Niciuna',
         'api-key': 'Cheie API',
-        'auth-type': 'Tipul autentificării',
+        'auth-type': 'Tip de autentificare',
         'basic': 'De bază',
         'bearer': 'Bearer',
         'custom': 'Personalizat',
         'api-key-title': 'Cheie API',
         'header': 'Antet',
       },
-      insertVarPlaceholder: 'tastați \'/\' pentru a insera variabila',
+      insertVarPlaceholder: 'tastați \'/\' pentru a insera variabilă',
       timeout: {
-        title: 'Timeout',
-        connectLabel: 'Timeout de conectare',
-        connectPlaceholder: 'Introduceți timeout-ul de conectare în secunde',
-        readLabel: 'Timeout de citire',
-        readPlaceholder: 'Introduceți timeout-ul de citire în secunde',
-        writeLabel: 'Timeout de scriere',
-        writePlaceholder: 'Introduceți timeout-ul de scriere în secunde',
+        title: 'Timp limită',
+        connectLabel: 'Timp limită pentru conexiune',
+        connectPlaceholder: 'Introduceți timpul limită pentru conexiune în secunde',
+        readLabel: 'Timp limită pentru citire',
+        readPlaceholder: 'Introduceți timpul limită pentru citire în secunde',
+        writeLabel: 'Timp limită pentru scriere',
+        writePlaceholder: 'Introduceți timpul limită pentru scriere în secunde',
       },
     },
     code: {
       inputVars: 'Variabile de intrare',
       outputVars: 'Variabile de ieșire',
-      advancedDependencies: 'Dependențe Avansate',
-      advancedDependenciesTip: 'Adăugați aici unele dependențe preîncărcate care necesită mai mult timp pentru a fi utilizate sau care nu sunt în mod implicit integrate',
-      searchDependencies: 'Căutați Dependențe',
+      advancedDependencies: 'Dependențe avansate',
+      advancedDependenciesTip: 'Adăugați câteva dependențe preîncărcate care necesită mai mult timp pentru a consuma sau nu sunt integrate implicit aici',
+      searchDependencies: 'Căutați dependențe',
     },
     templateTransform: {
       inputVars: 'Variabile de intrare',
       code: 'Cod',
-      codeSupportTip: 'Acceptă doar Jinja2',
+      codeSupportTip: 'Suportă doar Jinja2',
       outputVars: {
-        output: 'Conținutul transformat',
+        output: 'Conținut transformat',
       },
     },
     ifElse: {
       if: 'Dacă',
-      else: 'Altfel',
-      elseDescription: 'Utilizat pentru a defini logica care trebuie executată atunci când condiția dacă nu este îndeplinită.',
+      else: 'Altminteri',
+      elseDescription: 'Utilizat pentru a defini logica care ar trebui executată atunci când condiția if nu este îndeplinită.',
       and: 'și',
       or: 'sau',
       operator: 'Operator',
@@ -302,40 +322,43 @@ const translation = {
         'is not': 'nu este',
         'empty': 'este gol',
         'not empty': 'nu este gol',
-        'null': 'este nul',
-        'not null': 'nu este nul',
+        'null': 'este null',
+        'not null': 'nu este null',
       },
       enterValue: 'Introduceți valoarea',
       addCondition: 'Adăugați condiție',
-      conditionNotSetup: 'Condiția NU este configurată',
+      conditionNotSetup: 'Condiția NU este setată',
     },
     variableAssigner: {
-      title: 'Atribuire variabile',
-      outputType: 'Tipul ieșirii',
-      outputVarType: 'Tipul variabilei de ieșire',
+      title: 'Atribuie variabile',
+      outputType: 'Tip de ieșire',
       varNotSet: 'Variabila nu este setată',
-      noVarTip: 'Adăugați variabilele care trebuie atribuite',
+      noVarTip: 'Adăugați variabilele de atribuit',
       type: {
-        string: 'Șir de caractere',
+        string: 'Șir',
         number: 'Număr',
         object: 'Obiect',
-        array: 'Tablou',
+        array: 'Array',
       },
+      aggregationGroup: 'Grup de agregare',
+      aggregationGroupTip: 'Activarea acestei funcții permite agregatorului de variabile să agrege mai multe seturi de variabile.',
+      addGroup: 'Adăugați grup',
       outputVars: {
-        output: 'Valoarea variabilei atribuite',
+        varDescribe: 'Ieșire {{groupName}}',
       },
+      setAssignVariable: 'Setați variabila de atribuire',
     },
     tool: {
-      toAuthorize: 'Pentru a autoriza',
+      toAuthorize: 'Autorizați',
       inputVars: 'Variabile de intrare',
       outputVars: {
-        text: 'Conținut generat de instrument',
+        text: 'conținut generat de instrument',
         files: {
-          title: 'Fișiere generate de instrument',
-          type: 'Tipul suportat. Acum suportă doar imaginea',
-          transfer_method: 'Metoda de transfer. Valoarea este remote_url sau local_file',
-          url: 'URL-ul imaginii',
-          upload_file_id: 'ID-ul fișierului încărcat',
+          title: 'fișiere generate de instrument',
+          type: 'Tip de suport. Acum acceptă doar imagine',
+          transfer_method: 'Metodă de transfer. Valoarea este remote_url sau local_file',
+          url: 'URL imagine',
+          upload_file_id: 'ID fișier încărcat',
         },
       },
     },
@@ -343,17 +366,51 @@ const translation = {
       model: 'model',
       inputVars: 'Variabile de intrare',
       outputVars: {
-        className: 'Numele clasei',
+        className: 'Nume clasă',
       },
       class: 'Clasă',
       classNamePlaceholder: 'Scrieți numele clasei',
-      advancedSetting: 'Configurare avansată',
-      topicName: 'Numele subiectului',
+      advancedSetting: 'Setare avansată',
+      topicName: 'Nume subiect',
       topicPlaceholder: 'Scrieți numele subiectului',
       addClass: 'Adăugați clasă',
       instruction: 'Instrucțiune',
+      instructionTip: 'Introduceți instrucțiuni suplimentare pentru a ajuta clasificatorul de întrebări să înțeleagă mai bine cum să categorizeze întrebările.',
       instructionPlaceholder: 'Scrieți instrucțiunea',
     },
+    parameterExtractor: {
+      inputVar: 'Variabilă de intrare',
+      extractParameters: 'Extrageți parametrii',
+      importFromTool: 'Importă din instrumente',
+      addExtractParameter: 'Adăugați parametru de extragere',
+      addExtractParameterContent: {
+        name: 'Nume',
+        namePlaceholder: 'Nume parametru de extragere',
+        type: 'Tip',
+        typePlaceholder: 'Tip parametru de extragere',
+        description: 'Descriere',
+        descriptionPlaceholder: 'Descriere parametru de extragere',
+        required: 'Necesar',
+        requiredContent: 'Necesar este utilizat doar ca referință pentru inferența modelului și nu pentru validarea obligatorie a ieșirii parametrului.',
+      },
+      extractParametersNotSet: 'Parametrii de extragere nu sunt setați',
+      instruction: 'Instrucțiune',
+      instructionTip: 'Introduceți instrucțiuni suplimentare pentru a ajuta extractorul de parametri să înțeleagă cum să extragă parametrii.',
+      advancedSetting: 'Setare avansată',
+      reasoningMode: 'Mod de raționament',
+      reasoningModeTip: 'Puteți alege modul de raționament potrivit în funcție de capacitatea modelului de a răspunde la instrucțiuni pentru apelarea funcțiilor sau prompturi.',
+      isSuccess: 'Este succes. În caz de succes valoarea este 1, în caz de eșec valoarea este 0.',
+      errorReason: 'Motivul erorii',
+    },
+    iteration: {
+      deleteTitle: 'Ștergeți nodul de iterație?',
+      deleteDesc: 'Ștergerea nodului de iterație va șterge toate nodurile copil',
+      input: 'Intrare',
+      output: 'Variabile de ieșire',
+      iteration_one: '{{count}} Iterație',
+      iteration_other: '{{count}} Iterații',
+      currentIteration: 'Iterație curentă',
+    },
   },
   tracing: {
     stopBy: 'Oprit de {{user}}',

web/i18n/uk-UA/workflow.ts

@@ -7,49 +7,49 @@ const translation = {
     publish: 'Опублікувати',
     update: 'Оновити',
     run: 'Запустити',
-    running: 'Виконується',
-    inRunMode: 'У режимі виконання',
-    inPreview: 'У попередньому перегляді',
+    running: 'Запущено',
+    inRunMode: 'У режимі запуску',
+    inPreview: 'У режимі попереднього перегляду',
     inPreviewMode: 'У режимі попереднього перегляду',
     preview: 'Попередній перегляд',
     viewRunHistory: 'Переглянути історію запусків',
     runHistory: 'Історія запусків',
-    goBackToEdit: 'Повернутися до редагування',
+    goBackToEdit: 'Повернутися до редактора',
     conversationLog: 'Журнал розмов',
     features: 'Функції',
-    debugAndPreview: 'Налагодження і попередній перегляд',
+    debugAndPreview: 'Налагодження та попередній перегляд',
     restart: 'Перезапустити',
     currentDraft: 'Поточний чернетка',
-    currentDraftUnpublished: 'Поточний чернетка не опубліковано',
-    latestPublished: 'Остання опублікована',
-    publishedAt: 'Опубліковано',
+    currentDraftUnpublished: 'Поточний чернетка неопублікований',
+    latestPublished: 'Останнє опубліковане',
+    publishedAt: 'Опубліковано о',
     restore: 'Відновити',
     runApp: 'Запустити додаток',
     batchRunApp: 'Пакетний запуск додатку',
-    accessAPIReference: 'Доступ до посилання на API',
-    embedIntoSite: 'Вбудувати в сайт',
-    addTitle: 'Додати назву...',
+    accessAPIReference: 'Доступ до довідника API',
+    embedIntoSite: 'Вбудувати на сайт',
+    addTitle: 'Додати заголовок...',
     addDescription: 'Додати опис...',
-    noVar: 'Немає змінної',
+    noVar: 'Без змінної',
     searchVar: 'Пошук змінної',
     variableNamePlaceholder: 'Назва змінної',
-    setVarValuePlaceholder: 'Встановити змінну',
-    needConnecttip: 'Цей крок не підключено до чогось',
+    setVarValuePlaceholder: 'Встановити значення змінної',
+    needConnecttip: 'Цей крок ні до чого не підключений',
     maxTreeDepth: 'Максимальний ліміт {{depth}} вузлів на гілку',
-    needEndNode: 'Необхідно додати блок "Кінець"',
-    needAnswerNode: 'Необхідно додати блок "Відповідь"',
-    workflowProcess: 'Процес робочого процесу',
+    needEndNode: 'Потрібно додати кінцевий блок',
+    needAnswerNode: 'Потрібно додати блок відповіді',
+    workflowProcess: 'Процес робочого потоку',
     notRunning: 'Ще не запущено',
-    previewPlaceholder: 'Введіть вміст у полі нижче, щоб розпочати налагодження чат-бота',
+    previewPlaceholder: 'Введіть вміст у поле нижче, щоб розпочати налагодження чат-бота',
     effectVarConfirm: {
       title: 'Видалити змінну',
-      content: 'Цю змінну використовується в інших вузлах. Ви все ще хочете її видалити?',
+      content: 'Змінна використовується в інших вузлах. Ви все ще хочете її видалити?',
     },
-    insertVarTip: 'Натисніть клавішу "/" для швидкого вставлення',
-    processData: 'Обробка даних',
+    insertVarTip: 'Натисніть клавішу \'/\' для швидкого вставлення',
+    processData: 'Обробити дані',
     input: 'Вхід',
     output: 'Вихід',
-    jinjaEditorPlaceholder: 'Введіть \'/\' або \'{\' щоб вставити змінну',
+    jinjaEditorPlaceholder: 'Введіть \'/\' або \'{\' для вставлення змінної',
     viewOnly: 'Тільки перегляд',
     showRunHistory: 'Показати історію запусків',
     enableJinja: 'Увімкнути підтримку шаблонів Jinja',
@@ -57,112 +57,132 @@ const translation = {
     copy: 'Копіювати',
     duplicate: 'Дублювати',
     addBlock: 'Додати блок',
-    pasteHere: 'Вставити тут',
+    pasteHere: 'Вставити сюди',
     pointerMode: 'Режим вказівника',
-    handMode: 'Режим руки',
+    handMode: 'Ручний режим',
+    model: 'Модель',
+    workflowAsTool: 'Робочий потік як інструмент',
+    configureRequired: 'Потрібна конфігурація',
+    configure: 'Налаштувати',
+    manageInTools: 'Керування в інструментах',
+    workflowAsToolTip: 'Після оновлення робочого потоку необхідна переконфігурація інструменту.',
+    viewDetailInTracingPanel: 'Переглянути деталі',
   },
   errorMsg: {
     fieldRequired: '{{field}} є обов\'язковим',
     authRequired: 'Потрібна авторизація',
-    invalidJson: '{{field}} недійсний JSON',
+    invalidJson: '{{field}} є недійсним JSON',
     fields: {
       variable: 'Назва змінної',
       variableValue: 'Значення змінної',
       code: 'Код',
       model: 'Модель',
-      rerankModel: 'Модель пересортування',
+      rerankModel: 'Модель повторного ранжування',
     },
     invalidVariable: 'Недійсна змінна',
   },
   singleRun: {
-    testRun: 'Тестовий запуск ',
+    testRun: 'Тестовий запуск',
     startRun: 'Почати запуск',
-    running: 'Виконується',
+    running: 'Запущено',
+    testRunIteration: 'Ітерація тестового запуску',
+    back: 'Назад',
+    iteration: 'Ітерація',
   },
   tabs: {
     'searchBlock': 'Пошук блоку',
     'blocks': 'Блоки',
-    'builtInTool': 'Вбудований інструмент',
-    'customTool': 'Спеціальний інструмент',
+    'tools': 'Інструменти',
+    'allTool': 'Усі',
+    'builtInTool': 'Вбудовані',
+    'customTool': 'Користувацькі',
+    'workflowTool': 'Робочий потік',
     'question-understand': 'Розуміння питань',
     'logic': 'Логіка',
     'transform': 'Трансформація',
     'utilities': 'Утиліти',
-    'noResult': 'Співпадінь не знайдено',
+    'noResult': 'Нічого не знайдено',
   },
   blocks: {
     'start': 'Початок',
     'end': 'Кінець',
     'answer': 'Відповідь',
     'llm': 'LLM',
-    'knowledge-retrieval': 'Пошук знань',
+    'knowledge-retrieval': 'Отримання знань',
     'question-classifier': 'Класифікатор питань',
-    'if-else': 'Якщо / Інакше',
+    'if-else': 'ЯКЩО/ІНАКШЕ',
     'code': 'Код',
     'template-transform': 'Шаблон',
     'http-request': 'HTTP-запит',
-    'variable-assigner': 'Призначення змінних',
+    'variable-assigner': 'Присвоювач змінних',
+    'variable-aggregator': 'Агрегатор змінних',
+    'iteration-start': 'Початок ітерації',
+    'iteration': 'Ітерація',
+    'parameter-extractor': 'Екстрактор параметрів',
   },
   blocksAbout: {
-    'start': 'Визначте початкові параметри для запуску робочого процесу',
-    'end': 'Визначте кінець і тип результату робочого процесу',
-    'answer': 'Визначте вміст відповіді чат-розмови',
-    'llm': 'Виклик великих мовних моделей для відповіді на питання або обробки природної мови',
-    'knowledge-retrieval': 'Дозволяє вам запитувати текстовий вміст, що стосується питань користувача, знань',
-    'question-classifier': 'Визначте умови класифікації користувачів, LLM може визначити, як прогресує розмова на основі опису класифікації',
-    'if-else': 'Дозволяє вам розгалужувати робочий процес на дві гілки на основі умов if / else',
-    'code': 'Виконати фрагмент коду Python або NodeJS для реалізації власної логіки',
-    'template-transform': 'Перетворити дані в рядок, використовуючи синтаксис шаблону Jinja',
+    'start': 'Визначте початкові параметри для запуску робочого потоку',
+    'end': 'Визначте кінець і тип результату робочого потоку',
+    'answer': 'Визначте зміст відповіді у чаті',
+    'llm': 'Виклик великих мовних моделей для відповіді на запитання або обробки природної мови',
+    'knowledge-retrieval': 'Дозволяє виконувати запити текстового вмісту, пов\'язаного із запитаннями користувача, з бази знань',
+    'question-classifier': 'Визначте умови класифікації запитань користувачів, LLM може визначати, як розвивається розмова на основі опису класифікації',
+    'if-else': 'Дозволяє розділити робочий потік на дві гілки на основі умов if/else',
+    'code': 'Виконайте фрагмент коду Python або NodeJS для реалізації користувацької логіки',
+    'template-transform': 'Перетворіть дані на рядок за допомогою синтаксису шаблону Jinja',
     'http-request': 'Дозволяє відправляти серверні запити через протокол HTTP',
-    'variable-assigner': 'Призначте змінні в різних гілках тієї самої змінної, щоб забезпечити єдину конфігурацію після-вузлів',
+    'variable-assigner': 'Агрегує змінні з кількох гілок у одну змінну для уніфікованої конфігурації кінцевих вузлів.',
+    'variable-aggregator': 'Агрегує змінні з кількох гілок у одну змінну для уніфікованої конфігурації кінцевих вузлів.',
+    'iteration': 'Виконувати кілька кроків на об\'єкті списку, поки не буде виведено всі результати.',
+    'parameter-extractor': 'Використовуйте LLM для вилучення структурованих параметрів з природної мови для викликів інструментів або HTTP-запитів.',
   },
   operator: {
     zoomIn: 'Збільшити',
     zoomOut: 'Зменшити',
-    zoomTo50: 'Масштабувати до 50%',
-    zoomTo100: 'Масштабувати до 100%',
-    zoomToFit: 'Підігнати по ширині',
+    zoomTo50: 'Збільшити до 50%',
+    zoomTo100: 'Збільшити до 100%',
+    zoomToFit: 'Збільшити для підгонки',
   },
   panel: {
     userInputField: 'Поле введення користувача',
     changeBlock: 'Змінити блок',
-    helpLink: 'Посилання на довідку',
+    helpLink: 'Посилання на допомогу',
     about: 'Про',
     createdBy: 'Створено ',
     nextStep: 'Наступний крок',
-    addNextStep: 'Додати наступний блок у цей робочий процес',
-    selectNextStep: 'Виберіть наступний блок',
+    addNextStep: 'Додати наступний блок у цей робочий потік',
+    selectNextStep: 'Вибрати наступний блок',
     runThisStep: 'Запустити цей крок',
-    checklist: 'Перелік',
-    checklistTip: 'Переконайтеся, що всі питання вирішено перед публікацією',
-    checklistResolved: 'Всі питання вирішено',
+    checklist: 'Контрольний список',
+    checklistTip: 'Переконайтеся, що всі проблеми вирішені перед публікацією',
+    checklistResolved: 'Всі проблеми вирішені',
     organizeBlocks: 'Організувати блоки',
     change: 'Змінити',
   },
   nodes: {
     common: {
-      outputVars: 'Вихідні змінні',
+      outputVars: 'Змінні виходу',
       insertVarTip: 'Вставити змінну',
       memory: {
         memory: 'Пам\'ять',
-        memoryTip: 'Налаштування чат-пам\'яті',
+        memoryTip: 'Налаштування пам\'яті чату',
         windowSize: 'Розмір вікна',
-        conversationRoleName: 'Назва ролі розмови',
+        conversationRoleName: 'Назва ролі у розмові',
         user: 'Префікс користувача',
         assistant: 'Префікс помічника',
       },
       memories: {
-        title: 'Пам\'яті',
-        tip: 'Чат-пам\'ять',
-        builtIn: 'Вбудований',
+        title: 'Спогади',
+        tip: 'Пам\'ять чату',
+        builtIn: 'Вбудовано',
       },
     },
     start: {
-      required: 'обов\'язково',
+      required: 'обов\'язковий',
       inputField: 'Поле введення',
       builtInVar: 'Вбудовані змінні',
       outputVars: {
-        query: 'Вхід користувача',
+        query: 'Введення користувача',
         memories: {
           des: 'Історія розмов',
           type: 'тип повідомлення',
@@ -170,38 +190,38 @@ const translation = {
         },
         files: 'Список файлів',
       },
-      noVarTip: 'Встановіть вхідні дані, які можна використовувати в робочому процесі',
+      noVarTip: 'Встановіть вхідні дані, які можуть бути використані у робочому потоці',
     },
     end: {
-      outputs: 'Вихідні дані',
+      outputs: 'Виходи',
       output: {
         type: 'тип виходу',
-        variable: 'вихідна змінна',
+        variable: 'змінна виходу',
       },
       type: {
-        'none': 'Нічого',
-        'plain-text': 'Звичайний текст',
+        'none': 'Немає',
+        'plain-text': 'Простий текст',
         'structured': 'Структурований',
       },
     },
     answer: {
       answer: 'Відповідь',
-      outputVars: 'Вихідні змінні',
+      outputVars: 'Змінні виходу',
     },
     llm: {
       model: 'модель',
       variables: 'змінні',
       context: 'контекст',
       contextTooltip: 'Ви можете імпортувати знання як контекст',
-      notSetContextInPromptTip: 'Щоб увімкнути функцію контексту, будь ласка, заповніть змінну контексту в PROMPT.',
-      prompt: 'підказка',
+      notSetContextInPromptTip: 'Щоб увімкнути функцію контексту, заповніть змінну контексту в PROMPT.',
+      prompt: 'prompt',
       roleDescription: {
-        system: 'Надати високорівневі інструкції для розмови',
-        user: 'Надати інструкції, запити або будь-який текстовий ввід для моделі',
+        system: 'Дайте високорівневі інструкції для розмови',
+        user: 'Надайте інструкції, запити або будь-який текстовий вхід для моделі',
         assistant: 'Відповіді моделі на основі повідомлень користувача',
       },
       addMessage: 'Додати повідомлення',
-      vision: 'візія',
+      vision: 'бачення',
       files: 'Файли',
       resolution: {
         name: 'Роздільна здатність',
@@ -209,90 +229,90 @@ const translation = {
         low: 'Низька',
       },
       outputVars: {
-        output: 'Створення вмісту',
+        output: 'Генерований вміст',
         usage: 'Інформація про використання моделі',
       },
       singleRun: {
         variable: 'Змінна',
       },
-      sysQueryInUser: 'sys.query потрібно в повідомленні користувача.',
+      sysQueryInUser: 'sys.query у повідомленні користувача є обов\'язковим',
     },
     knowledgeRetrieval: {
-      queryVariable: 'Запит змінної',
+      queryVariable: 'Змінна запиту',
       knowledge: 'Знання',
       outputVars: {
-        output: 'Вилучені сегментовані дані',
+        output: 'Відновлені сегментовані дані',
         content: 'Сегментований вміст',
         title: 'Сегментований заголовок',
-        icon: 'Сегментована іконка',
-        url: 'Сегментований URL',
-        metadata: 'Інша метадані',
+        icon: 'Сегментована піктограма',
+        url: 'Сегментована URL',
+        metadata: 'Інші метадані',
       },
     },
     http: {
       inputVars: 'Вхідні змінні',
       api: 'API',
-      apiPlaceholder: 'Введіть URL, наберіть «/» для вставки змінної',
-      notStartWithHttp: 'API повинно починатися з http:// або https://',
+      apiPlaceholder: 'Введіть URL, введіть ‘/’, щоб вставити змінну',
+      notStartWithHttp: 'API має починатися з http:// або https://',
       key: 'Ключ',
       value: 'Значення',
       bulkEdit: 'Масове редагування',
-      keyValueEdit: 'Редагування Ключ-Значення',
+      keyValueEdit: 'Редагування ключ-значення',
       headers: 'Заголовки',
       params: 'Параметри',
       body: 'Тіло',
       outputVars: {
-        body: 'Вміст відповіді',
-        statusCode: 'Код статусу відповіді',
-        headers: 'Список заголовків відповіді JSON',
+        body: 'Зміст відповіді',
+        statusCode: 'Код стану відповіді',
+        headers: 'Список заголовків відповіді у форматі JSON',
         files: 'Список файлів',
       },
       authorization: {
         'authorization': 'Авторизація',
         'authorizationType': 'Тип авторизації',
         'no-auth': 'Немає',
-        'api-key': 'API-Key',
-        'auth-type': 'Тип авторизації',
-        'basic': 'Базова',
+        'api-key': 'API-ключ',
+        'auth-type': 'Тип аутентифікації',
+        'basic': 'Базовий',
         'bearer': 'Bearer',
-        'custom': 'Користувацька',
-        'api-key-title': 'Ключ API',
+        'custom': 'Користувацький',
+        'api-key-title': 'API-ключ',
         'header': 'Заголовок',
       },
-      insertVarPlaceholder: 'наберіть \'/\' для вставки змінної',
+      insertVarPlaceholder: 'введіть \'/\', щоб вставити змінну',
       timeout: {
-        title: 'Час вичерпано',
-        connectLabel: 'Тайм-аут з’єднання',
-        connectPlaceholder: 'Введіть час тайм-ауту з’єднання у секундах',
+        title: 'Тайм-аут',
+        connectLabel: 'Тайм-аут підключення',
+        connectPlaceholder: 'Введіть тайм-аут підключення в секундах',
         readLabel: 'Тайм-аут читання',
-        readPlaceholder: 'Введіть час тайм-ауту читання у секундах',
+        readPlaceholder: 'Введіть тайм-аут читання в секундах',
         writeLabel: 'Тайм-аут запису',
-        writePlaceholder: 'Введіть час тайм-ауту запису у секундах',
+        writePlaceholder: 'Введіть тайм-аут запису в секундах',
       },
     },
     code: {
       inputVars: 'Вхідні змінні',
-      outputVars: 'Вихідні змінні',
+      outputVars: 'Змінні виходу',
       advancedDependencies: 'Розширені залежності',
-      advancedDependenciesTip: 'Додайте деякі попередньо завантажені залежності, які потребують більше часу для використання або не є вбудованими за замовчуванням',
+      advancedDependenciesTip: 'Додайте тут деякі попередньо завантажені залежності, які потребують більше часу для споживання або не є за замовчуванням вбудованими',
       searchDependencies: 'Шукати залежності',
     },
     templateTransform: {
       inputVars: 'Вхідні змінні',
       code: 'Код',
-      codeSupportTip: 'Підтримується лише Jinja2',
+      codeSupportTip: 'Підтримує лише Jinja2',
       outputVars: {
-        output: 'Перетворений вміст',
+        output: 'Трансформований вміст',
       },
     },
     ifElse: {
       if: 'Якщо',
       else: 'Інакше',
-      elseDescription: 'Використовується для визначення логіки, яка має виконуватися, коли умова if не виконується.',
+      elseDescription: 'Використовується для визначення логіки, яка має бути виконана, коли умова if не виконана.',
       and: 'і',
       or: 'або',
       operator: 'Оператор',
-      notSetVariable: 'Спочатку встановіть змінну',
+      notSetVariable: 'Будь ласка, спочатку встановіть змінну',
       comparisonOperator: {
         'contains': 'містить',
         'not contains': 'не містить',
@@ -302,40 +322,43 @@ const translation = {
         'is not': 'не є',
         'empty': 'порожній',
         'not empty': 'не порожній',
-        'null': 'нуль',
-        'not null': 'не нуль',
+        'null': 'є null',
+        'not null': 'не є null',
       },
       enterValue: 'Введіть значення',
       addCondition: 'Додати умову',
       conditionNotSetup: 'Умова НЕ налаштована',
     },
     variableAssigner: {
-      title: 'Призначення змінних',
+      title: 'Присвоєння змінних',
       outputType: 'Тип виходу',
-      outputVarType: 'Тип вихідної змінної',
       varNotSet: 'Змінна не встановлена',
-      noVarTip: 'Додайте змінні для призначення',
+      noVarTip: 'Додайте змінні для присвоєння',
       type: {
         string: 'Рядок',
         number: 'Число',
-        object: 'Об’єкт',
+        object: 'Об\'єкт',
         array: 'Масив',
       },
+      aggregationGroup: 'Група агрегації',
+      aggregationGroupTip: 'Увімкнення цієї функції дозволяє агрегатору змінних агрегувати кілька наборів змінних.',
+      addGroup: 'Додати групу',
       outputVars: {
-        output: 'Значення призначеної змінної',
+        varDescribe: 'Вихід {{groupName}}',
       },
+      setAssignVariable: 'Встановити змінну присвоєння',
     },
     tool: {
-      toAuthorize: 'Авторизуватися',
+      toAuthorize: 'Авторизувати',
       inputVars: 'Вхідні змінні',
       outputVars: {
-        text: 'вміст, згенерований інструментом',
+        text: 'генерований вміст інструменту',
         files: {
-          title: 'файли, згенеровані інструментом',
-          type: 'Тип підтримки. Тепер підтримується лише зображення',
-          transfer_method: 'Метод передачі. Значення - віддалений URL або локальний файл',
+          title: 'файли, генеровані інструментом',
+          type: 'Тип підтримки. Наразі підтримуються лише зображення',
+          transfer_method: 'Метод передачі. Значення - remote_url або local_file',
           url: 'URL зображення',
-          upload_file_id: 'Ідентифікатор завантаженого файлу',
+          upload_file_id: 'ID завантаженого файлу',
         },
       },
     },
@@ -347,13 +370,47 @@ const translation = {
       },
       class: 'Клас',
       classNamePlaceholder: 'Напишіть назву вашого класу',
-      advancedSetting: 'Розширена настройка',
+      advancedSetting: 'Розширене налаштування',
       topicName: 'Назва теми',
       topicPlaceholder: 'Напишіть назву вашої теми',
       addClass: 'Додати клас',
       instruction: 'Інструкція',
+      instructionTip: 'Введіть додаткові інструкції, щоб допомогти класифікатору запитань краще зрозуміти, як категоризувати запитання.',
       instructionPlaceholder: 'Напишіть вашу інструкцію',
     },
+    parameterExtractor: {
+      inputVar: 'Вхідна змінна',
+      extractParameters: 'Витягти параметри',
+      importFromTool: 'Імпорт з інструментів',
+      addExtractParameter: 'Додати параметр витягування',
+      addExtractParameterContent: {
+        name: 'Ім\'я',
+        namePlaceholder: 'Ім\'я параметра витягування',
+        type: 'Тип',
+        typePlaceholder: 'Тип параметра витягування',
+        description: 'Опис',
+        descriptionPlaceholder: 'Опис параметра витягування',
+        required: 'Обов\'язковий',
+        requiredContent: 'Обов\'язковий використовується лише як посилання для інференції моделі і не для обов\'язкової валідації вихідного параметра.',
+      },
+      extractParametersNotSet: 'Параметри витягування не налаштовані',
+      instruction: 'Інструкція',
+      instructionTip: 'Введіть додаткові інструкції, щоб допомогти екстрактору параметрів зрозуміти, як витягувати параметри.',
+      advancedSetting: 'Розширене налаштування',
+      reasoningMode: 'Режим інференції',
+      reasoningModeTip: 'Ви можете вибрати відповідний режим інференції залежно від здатності моделі реагувати на інструкції щодо викликів функцій або запитів.',
+      isSuccess: 'Є успіх. У разі успіху значення 1, у разі невдачі значення 0.',
+      errorReason: 'Причина помилки',
+    },
+    iteration: {
+      deleteTitle: 'Видалити вузол ітерації?',
+      deleteDesc: 'Видалення вузла ітерації видалить усі дочірні вузли',
+      input: 'Вхід',
+      output: 'Змінні виходу',
+      iteration_one: '{{count}} Ітерація',
+      iteration_other: '{{count}} Ітерацій',
+      currentIteration: 'Поточна ітерація',
+    },
   },
   tracing: {
     stopBy: 'Зупинено користувачем {{user}}',

web/i18n/vi-VN/workflow.ts

@@ -8,25 +8,25 @@ const translation = {
     update: 'Cập nhật',
     run: 'Chạy',
     running: 'Đang chạy',
-    inRunMode: 'Ở Chế độ chạy',
-    inPreview: 'Ở Chế độ xem trước',
-    inPreviewMode: 'Ở Chế độ xem trước',
+    inRunMode: 'Chế độ chạy',
+    inPreview: 'Trong chế độ xem trước',
+    inPreviewMode: 'Chế độ xem trước',
     preview: 'Xem trước',
     viewRunHistory: 'Xem lịch sử chạy',
     runHistory: 'Lịch sử chạy',
-    goBackToEdit: 'Quay lại trình soạn thảo',
+    goBackToEdit: 'Quay lại trình chỉnh sửa',
     conversationLog: 'Nhật ký cuộc trò chuyện',
     features: 'Tính năng',
-    debugAndPreview: 'Debug và Xem trước',
+    debugAndPreview: 'Gỡ lỗi và xem trước',
     restart: 'Khởi động lại',
     currentDraft: 'Bản nháp hiện tại',
     currentDraftUnpublished: 'Bản nháp hiện tại chưa xuất bản',
-    latestPublished: 'Bản xuất bản mới nhất',
-    publishedAt: 'Đã xuất bản lúc',
+    latestPublished: 'Xuất bản mới nhất',
+    publishedAt: 'Đã xuất bản tại',
     restore: 'Khôi phục',
     runApp: 'Chạy ứng dụng',
     batchRunApp: 'Chạy ứng dụng hàng loạt',
-    accessAPIReference: 'Truy cập Tài liệu API',
+    accessAPIReference: 'Truy cập tài liệu API',
     embedIntoSite: 'Nhúng vào trang web',
     addTitle: 'Thêm tiêu đề...',
     addDescription: 'Thêm mô tả...',
@@ -34,135 +34,155 @@ const translation = {
     searchVar: 'Tìm kiếm biến',
     variableNamePlaceholder: 'Tên biến',
     setVarValuePlaceholder: 'Đặt giá trị biến',
-    needConnecttip: 'Bước này chưa kết nối với bất kỳ điều gì',
-    maxTreeDepth: 'Giới hạn tối đa của {{depth}} nút mỗi nhánh',
-    needEndNode: 'Khối Kết thúc phải được thêm vào',
-    needAnswerNode: 'Khối Trả lời phải được thêm vào',
+    needConnecttip: 'Bước này không được kết nối với bất kỳ điều gì',
+    maxTreeDepth: 'Giới hạn tối đa {{depth}} nút trên mỗi nhánh',
+    needEndNode: 'Phải thêm khối Kết thúc',
+    needAnswerNode: 'Phải thêm khối Trả lời',
     workflowProcess: 'Quy trình làm việc',
     notRunning: 'Chưa chạy',
-    previewPlaceholder: 'Nhập nội dung vào ô dưới đây để bắt đầu gỡ lỗi Chatbot',
+    previewPlaceholder: 'Nhập nội dung vào hộp bên dưới để bắt đầu gỡ lỗi Chatbot',
     effectVarConfirm: {
       title: 'Xóa biến',
-      content: 'Biến được sử dụng trong các nút khác. Bạn vẫn muốn xóa nó?',
+      content: 'Biến được sử dụng trong các nút khác. Bạn có chắc chắn muốn xóa nó không?',
     },
     insertVarTip: 'Nhấn phím \'/\' để chèn nhanh',
     processData: 'Xử lý dữ liệu',
-    input: 'Nhập',
+    input: 'Đầu vào',
     output: 'Đầu ra',
-    jinjaEditorPlaceholder: 'Nhập \'/\' hoặc \'{\' để chèn biến',
-    viewOnly: 'Chỉ Xem',
-    showRunHistory: 'Hiển Thị Lịch Sử Chạy',
-    enableJinja: 'Kích Hoạt Hỗ Trợ Mẫu Jinja',
-    learnMore: 'Tìm Hiểu Thêm',
-    copy: 'Sao Chép',
-    duplicate: 'Nhân Bản',
-    addBlock: 'Thêm Khối',
-    pasteHere: 'Dán Vào Đây',
-    pointerMode: 'Chế Độ Con Trỏ',
-    handMode: 'Chế Độ Tay',
+    jinjaEditorPlaceholder: 'Gõ \'/\' hoặc \'{\' để chèn biến',
+    viewOnly: 'Chỉ xem',
+    showRunHistory: 'Hiển thị lịch sử chạy',
+    enableJinja: 'Bật hỗ trợ mẫu Jinja',
+    learnMore: 'Tìm hiểu thêm',
+    copy: 'Sao chép',
+    duplicate: 'Nhân bản',
+    addBlock: 'Thêm khối',
+    pasteHere: 'Dán vào đây',
+    pointerMode: 'Chế độ con trỏ',
+    handMode: 'Chế độ tay',
+    model: 'Mô hình',
+    workflowAsTool: 'Quy trình làm việc như công cụ',
+    configureRequired: 'Yêu cầu cấu hình',
+    configure: 'Cấu hình',
+    manageInTools: 'Quản lý trong công cụ',
+    workflowAsToolTip: 'Cần cấu hình lại công cụ sau khi cập nhật quy trình làm việc.',
+    viewDetailInTracingPanel: 'Xem chi tiết',
   },
   errorMsg: {
     fieldRequired: '{{field}} là bắt buộc',
     authRequired: 'Yêu cầu xác thực',
-    invalidJson: '{{field}} không hợp lệ',
+    invalidJson: '{{field}} là JSON không hợp lệ',
     fields: {
-      variable: 'Tên Biến',
-      variableValue: 'Giá trị Biến',
+      variable: 'Tên biến',
+      variableValue: 'Giá trị biến',
       code: 'Mã',
       model: 'Mô hình',
-      rerankModel: 'Mô hình Rerank',
+      rerankModel: 'Mô hình xếp hạng lại',
     },
     invalidVariable: 'Biến không hợp lệ',
   },
   singleRun: {
-    testRun: 'Chạy thử ',
+    testRun: 'Chạy thử nghiệm ',
     startRun: 'Bắt đầu chạy',
     running: 'Đang chạy',
+    testRunIteration: 'Lặp chạy thử nghiệm',
+    back: 'Quay lại',
+    iteration: 'Lặp',
   },
   tabs: {
     'searchBlock': 'Tìm kiếm khối',
     'blocks': 'Khối',
-    'builtInTool': 'Công cụ tích hợp',
-    'customTool': 'Công cụ tùy chỉnh',
+    'tools': 'Công cụ',
+    'allTool': 'Tất cả',
+    'builtInTool': 'Tích hợp sẵn',
+    'customTool': 'Tùy chỉnh',
+    'workflowTool': 'Quy trình làm việc',
     'question-understand': 'Hiểu câu hỏi',
     'logic': 'Logic',
     'transform': 'Chuyển đổi',
     'utilities': 'Tiện ích',
-    'noResult': 'Không tìm thấy kết quả',
+    'noResult': 'Không tìm thấy kết quả phù hợp',
   },
   blocks: {
     'start': 'Bắt đầu',
     'end': 'Kết thúc',
     'answer': 'Trả lời',
     'llm': 'LLM',
-    'knowledge-retrieval': 'Truy xuất Kiến thức',
-    'question-classifier': 'Bộ phân loại Câu hỏi',
+    'knowledge-retrieval': 'Truy xuất kiến thức',
+    'question-classifier': 'Phân loại câu hỏi',
     'if-else': 'NẾU/NGƯỢC LẠI',
     'code': 'Mã',
     'template-transform': 'Mẫu',
     'http-request': 'Yêu cầu HTTP',
-    'variable-assigner': 'Bộ gán biến',
+    'variable-assigner': 'Trình gán biến',
+    'variable-aggregator': 'Trình tổng hợp biến',
+    'iteration-start': 'Bắt đầu lặp',
+    'iteration': 'Lặp',
+    'parameter-extractor': 'Trình trích xuất tham số',
   },
   blocksAbout: {
-    'start': 'Xác định các tham số ban đầu cho việc khởi chạy một quy trình',
-    'end': 'Xác định kết thúc và loại kết quả của một quy trình',
-    'answer': 'Xác định nội dung trả lời của một cuộc trò chuyện chat',
+    'start': 'Định nghĩa các tham số ban đầu để khởi chạy quy trình làm việc',
+    'end': 'Định nghĩa kết thúc và loại kết quả của quy trình làm việc',
+    'answer': 'Định nghĩa nội dung trả lời của cuộc trò chuyện',
     'llm': 'Gọi các mô hình ngôn ngữ lớn để trả lời câu hỏi hoặc xử lý ngôn ngữ tự nhiên',
-    'knowledge-retrieval': 'Cho phép bạn truy vấn nội dung văn bản liên quan đến các câu hỏi của người dùng từ Kiến thức',
-    'question-classifier': 'Xác định các điều kiện phân loại của các câu hỏi của người dùng, LLM có thể xác định cách cuộc trò chuyện tiến triển dựa trên mô tả phân loại',
-    'if-else': 'Cho phép bạn chia quy trình thành hai nhánh dựa trên các điều kiện if/else',
+    'knowledge-retrieval': 'Cho phép truy vấn nội dung văn bản liên quan đến câu hỏi của người dùng từ cơ sở kiến thức',
+    'question-classifier': 'Định nghĩa các điều kiện phân loại câu hỏi của người dùng, LLM có thể định nghĩa cách cuộc trò chuyện tiến triển dựa trên mô tả phân loại',
+    'if-else': 'Cho phép phân chia quy trình làm việc thành hai nhánh dựa trên điều kiện if/else',
     'code': 'Thực thi một đoạn mã Python hoặc NodeJS để thực hiện logic tùy chỉnh',
-    'template-transform': 'Chuyển đổi dữ liệu thành chuỗi sử dụng cú pháp mẫu Jinja',
+    'template-transform': 'Chuyển đổi dữ liệu thành chuỗi bằng cú pháp mẫu Jinja',
     'http-request': 'Cho phép gửi các yêu cầu máy chủ qua giao thức HTTP',
-    'variable-assigner': 'Gán biến trong các nhánh khác nhau vào cùng một biến để đạt được cấu hình thống nhất của các nút sau',
+    'variable-assigner': 'Tổng hợp các biến từ nhiều nhánh thành một biến duy nhất để cấu hình đồng nhất các nút cuối.',
+    'variable-aggregator': 'Tổng hợp các biến từ nhiều nhánh thành một biến duy nhất để cấu hình đồng nhất các nút cuối.',
+    'iteration': 'Thực hiện nhiều bước trên một đối tượng danh sách cho đến khi tất cả các kết quả được xuất ra.',
+    'parameter-extractor': 'Sử dụng LLM để trích xuất các tham số có cấu trúc từ ngôn ngữ tự nhiên để gọi công cụ hoặc yêu cầu HTTP.',
   },
   operator: {
     zoomIn: 'Phóng to',
     zoomOut: 'Thu nhỏ',
-    zoomTo50: 'Thu phóng đến 50%',
-    zoomTo100: 'Thu phóng đến 100%',
-    zoomToFit: 'Thu phóng vừa với cửa sổ',
+    zoomTo50: 'Phóng to 50%',
+    zoomTo100: 'Phóng to 100%',
+    zoomToFit: 'Phóng to vừa màn hình',
   },
   panel: {
-    userInputField: 'Trường nhập của người dùng',
-    changeBlock: 'Thay đổi Khối',
-    helpLink: 'Liên kết Trợ giúp',
+    userInputField: 'Trường đầu vào của người dùng',
+    changeBlock: 'Thay đổi khối',
+    helpLink: 'Liên kết trợ giúp',
     about: 'Về',
-    createdBy: 'Được tạo bởi ',
+    createdBy: 'Tạo bởi ',
     nextStep: 'Bước tiếp theo',
     addNextStep: 'Thêm khối tiếp theo trong quy trình làm việc này',
-    selectNextStep: 'Chọn Khối Tiếp theo',
+    selectNextStep: 'Chọn khối tiếp theo',
     runThisStep: 'Chạy bước này',
     checklist: 'Danh sách kiểm tra',
-    checklistTip: 'Đảm bảo tất cả các vấn đề được giải quyết trước khi xuất bản',
+    checklistTip: 'Đảm bảo rằng tất cả các vấn đề đã được giải quyết trước khi xuất bản',
     checklistResolved: 'Tất cả các vấn đề đã được giải quyết',
-    organizeBlocks: 'Sắp xếp các khối',
+    organizeBlocks: 'Tổ chức các khối',
     change: 'Thay đổi',
   },
   nodes: {
     common: {
       outputVars: 'Biến đầu ra',
-      insertVarTip: 'Chèn Biến',
+      insertVarTip: 'Chèn biến',
       memory: {
         memory: 'Bộ nhớ',
-        memoryTip: 'Cài đặt bộ nhớ trò chuyện',
+        memoryTip: 'Cài đặt bộ nhớ cuộc trò chuyện',
         windowSize: 'Kích thước cửa sổ',
         conversationRoleName: 'Tên vai trò cuộc trò chuyện',
         user: 'Tiền tố người dùng',
         assistant: 'Tiền tố trợ lý',
       },
       memories: {
-        title: 'Các ký ức',
-        tip: 'Bộ nhớ trò chuyện',
+        title: 'Bộ nhớ',
+        tip: 'Bộ nhớ cuộc trò chuyện',
         builtIn: 'Tích hợp sẵn',
       },
     },
     start: {
       required: 'bắt buộc',
-      inputField: 'Trường nhập',
+      inputField: 'Trường đầu vào',
       builtInVar: 'Biến tích hợp sẵn',
       outputVars: {
-        query: 'Đầu vào người dùng',
+        query: 'Đầu vào của người dùng',
         memories: {
           des: 'Lịch sử cuộc trò chuyện',
           type: 'loại tin nhắn',
@@ -170,7 +190,7 @@ const translation = {
         },
         files: 'Danh sách tệp',
       },
-      noVarTip: 'Thiết lập các đầu vào có thể được sử dụng trong Quy trình làm việc',
+      noVarTip: 'Đặt các đầu vào có thể sử dụng trong Quy trình làm việc',
     },
     end: {
       outputs: 'Đầu ra',
@@ -179,7 +199,7 @@ const translation = {
         variable: 'biến đầu ra',
       },
       type: {
-        'none': 'Không',
+        'none': 'Không có',
         'plain-text': 'Văn bản thuần',
         'structured': 'Cấu trúc',
       },
@@ -191,16 +211,16 @@ const translation = {
     llm: {
       model: 'mô hình',
       variables: 'biến',
-      context: 'bối cảnh',
-      contextTooltip: 'Bạn có thể nhập Kiến thức dưới dạng bối cảnh',
-      notSetContextInPromptTip: 'Để bật tính năng bối cảnh, vui lòng điền vào biến ngữ cảnh trong PROMPT.',
-      prompt: 'nhắc nhở',
+      context: 'ngữ cảnh',
+      contextTooltip: 'Bạn có thể nhập Kiến thức làm ngữ cảnh',
+      notSetContextInPromptTip: 'Để kích hoạt tính năng ngữ cảnh, vui lòng điền biến ngữ cảnh vào PROMPT.',
+      prompt: 'prompt',
       roleDescription: {
-        system: 'Đưa ra chỉ thị cấp cao cho cuộc trò chuyện',
-        user: 'Cung cấp chỉ thị, truy vấn hoặc bất kỳ đầu vào dựa trên văn bản nào cho mô hình',
-        assistant: 'Các phản hồi của mô hình dựa trên các tin nhắn của người dùng',
+        system: 'Cung cấp hướng dẫn cấp cao cho cuộc trò chuyện',
+        user: 'Cung cấp hướng dẫn, câu hỏi hoặc bất kỳ đầu vào văn bản nào cho mô hình',
+        assistant: 'Các phản hồi của mô hình dựa trên tin nhắn của người dùng',
       },
-      addMessage: 'Thêm Tin nhắn',
+      addMessage: 'Thêm tin nhắn',
       vision: 'tầm nhìn',
       files: 'Tệp',
       resolution: {
@@ -209,112 +229,110 @@ const translation = {
         low: 'Thấp',
       },
       outputVars: {
-        output: 'Tạo nội dung',
-        usage: 'Thông tin Sử dụng Mô hình',
+        output: 'Nội dung được tạo',
+        usage: 'Thông tin sử dụng mô hình',
       },
       singleRun: {
         variable: 'Biến',
       },
-      sysQueryInUser: 'sys.query được yêu cầu trong tin nhắn người dùng.',
+      sysQueryInUser: 'sys.query trong tin nhắn của người dùng là bắt buộc',
     },
     knowledgeRetrieval: {
-      queryVariable: 'Biến Truy vấn',
+      queryVariable: 'Biến truy vấn',
       knowledge: 'Kiến thức',
       outputVars: {
-        output: 'Dữ liệu phân đoạn truy xuất',
+        output: 'Dữ liệu phân đoạn được truy xuất',
         content: 'Nội dung phân đoạn',
         title: 'Tiêu đề phân đoạn',
         icon: 'Biểu tượng phân đoạn',
         url: 'URL phân đoạn',
-        metadata: 'Các siêu dữ liệu khác',
+        metadata: 'Siêu dữ liệu khác',
       },
     },
     http: {
       inputVars: 'Biến đầu vào',
       api: 'API',
-      apiPlaceholder: 'Nhập URL, nhập ‘/’ chèn biến',
+      apiPlaceholder: 'Nhập URL, gõ ‘/’ để chèn biến',
       notStartWithHttp: 'API phải bắt đầu bằng http:// hoặc https://',
       key: 'Khóa',
       value: 'Giá trị',
       bulkEdit: 'Chỉnh sửa hàng loạt',
-      keyValueEdit: 'Chỉnh sửa Khóa-Giá trị',
+      keyValueEdit: 'Chỉnh sửa khóa-giá trị',
       headers: 'Tiêu đề',
       params: 'Tham số',
       body: 'Nội dung',
       outputVars: {
-        body: 'Nội dung Phản hồi',
-        statusCode: 'Mã trạng thái Phản hồi',
-        headers: 'Danh sách Tiêu đề Phản hồi JSON',
-        files: 'Danh sách Tệp',
+        body: 'Nội dung phản hồi',
+        statusCode: 'Mã trạng thái phản hồi',
+        headers: 'Danh sách tiêu đề phản hồi JSON',
+        files: 'Danh sách tệp',
       },
       authorization: {
-        'authorization': 'Xác thực',
-        'authorizationType': 'Loại Xác thực',
-        'no-auth': 'Không',
+        'authorization': 'Ủy quyền',
+        'authorizationType': 'Loại ủy quyền',
+        'no-auth': 'Không có',
         'api-key': 'Khóa API',
-        'auth-type': 'Loại Xác thực',
+        'auth-type': 'Loại xác thực',
         'basic': 'Cơ bản',
         'bearer': 'Bearer',
         'custom': 'Tùy chỉnh',
         'api-key-title': 'Khóa API',
         'header': 'Tiêu đề',
       },
-      insertVarPlaceholder: 'nhập \'/\' để chèn biến',
+      insertVarPlaceholder: 'gõ \'/\' để chèn biến',
       timeout: {
-        title: 'Hết thời gian',
-        connectLabel: 'Hết thời gian kết nối',
-        connectPlaceholder: 'Nhập thời gian kết nối bằng giây',
-        readLabel: 'Hết thời gian đọc',
-        readPlaceholder: 'Nhập thời gian đọc bằng giây',
-        writeLabel: 'Hết thời gian ghi',
-        writePlaceholder: 'Nhập thời gian ghi bằng giây',
+        title: 'Thời gian chờ',
+        connectLabel: 'Thời gian chờ kết nối',
+        connectPlaceholder: 'Nhập thời gian chờ kết nối tính bằng giây',
+        readLabel: 'Thời gian chờ đọc',
+        readPlaceholder: 'Nhập thời gian chờ đọc tính bằng giây',
+        writeLabel: 'Thời gian chờ ghi',
+        writePlaceholder: 'Nhập thời gian chờ ghi tính bằng giây',
       },
     },
     code: {
       inputVars: 'Biến đầu vào',
       outputVars: 'Biến đầu ra',
-      advancedDependencies: 'Phụ thuộc Nâng cao',
-      advancedDependenciesTip: 'Thêm một số phụ thuộc đã được tải sẵn cần nhiều thời gian hơn để sử dụng hoặc không được tích hợp sẵn tại đây',
-      searchDependencies: 'Tìm Kiếm Phụ Thuộc',
-
+      advancedDependencies: 'Phụ thuộc nâng cao',
+      advancedDependenciesTip: 'Thêm một số phụ thuộc được tải trước mà tốn nhiều thời gian hoặc không phải là mặc định tại đây',
+      searchDependencies: 'Tìm kiếm phụ thuộc',
     },
     templateTransform: {
       inputVars: 'Biến đầu vào',
       code: 'Mã',
       codeSupportTip: 'Chỉ hỗ trợ Jinja2',
       outputVars: {
-        output: 'Nội dung đã chuyển đổi',
+        output: 'Nội dung chuyển đổi',
       },
     },
     ifElse: {
       if: 'Nếu',
       else: 'Ngược lại',
-      elseDescription: 'Được sử dụng để xác định logic sẽ được thực hiện khi điều kiện if không được đáp ứng.',
+      elseDescription: 'Sử dụng để xác định logic sẽ thực hiện khi điều kiện if không được thỏa mãn.',
       and: 'và',
       or: 'hoặc',
       operator: 'Toán tử',
-      notSetVariable: 'Vui lòng thiết lập biến trước',
+      notSetVariable: 'Vui lòng đặt biến trước',
       comparisonOperator: {
         'contains': 'chứa',
         'not contains': 'không chứa',
         'start with': 'bắt đầu bằng',
         'end with': 'kết thúc bằng',
         'is': 'là',
-        'is not': 'không phải là',
+        'is not': 'không là',
         'empty': 'trống',
         'not empty': 'không trống',
-        'null': 'null',
-        'not null': 'không null',
+        'null': 'là null',
+        'not null': 'không là null',
       },
       enterValue: 'Nhập giá trị',
-      addCondition: 'Thêm Điều kiện',
-      conditionNotSetup: 'Điều kiện CHƯA được thiết lập',
+      addCondition: 'Thêm điều kiện',
+      conditionNotSetup: 'Điều kiện chưa được thiết lập',
     },
     variableAssigner: {
       title: 'Gán biến',
       outputType: 'Loại đầu ra',
-      outputVarType: 'Loại Biến đầu ra',
-      varNotSet: 'Biến không được thiết lập',
+      varNotSet: 'Biến chưa được đặt',
       noVarTip: 'Thêm các biến cần gán',
       type: {
         string: 'Chuỗi',
@@ -322,21 +340,25 @@ const translation = {
         object: 'Đối tượng',
         array: 'Mảng',
       },
+      aggregationGroup: 'Nhóm tổng hợp',
+      aggregationGroupTip: 'Bật tính năng này cho phép trình tổng hợp biến tổng hợp nhiều bộ biến.',
+      addGroup: 'Thêm nhóm',
       outputVars: {
-        output: 'Giá trị biến được gán',
+        varDescribe: 'Đầu ra {{groupName}}',
       },
+      setAssignVariable: 'Đặt biến gán',
     },
     tool: {
-      toAuthorize: 'Để ủy quyền',
+      toAuthorize: 'Ủy quyền',
       inputVars: 'Biến đầu vào',
       outputVars: {
-        text: 'nội dung được tạo ra bởi công cụ',
+        text: 'nội dung do công cụ tạo ra',
         files: {
-          title: 'tệp được tạo ra bởi công cụ',
-          type: 'Loại hỗ trợ. Hiện chỉ hỗ trợ hình ảnh',
-          transfer_method: 'Phương pháp chuyển. Giá trị là remote_url hoặc local_file',
-          url: 'URL Hình ảnh',
-          upload_file_id: 'ID tệp tải lên',
+          title: 'tệp do công cụ tạo ra',
+          type: 'Loại hỗ trợ. Hiện tại chỉ hỗ trợ hình ảnh',
+          transfer_method: 'Phương pháp truyền. Giá trị là remote_url hoặc local_file',
+          url: 'URL hình ảnh',
+          upload_file_id: 'ID tệp đã tải lên',
         },
       },
     },
@@ -344,20 +366,54 @@ const translation = {
       model: 'mô hình',
       inputVars: 'Biến đầu vào',
       outputVars: {
-        className: 'Tên phân loại',
+        className: 'Tên lớp',
       },
       class: 'Lớp',
       classNamePlaceholder: 'Viết tên lớp của bạn',
-      advancedSetting: 'Cài đặt Nâng cao',
-      topicName: 'Tên Chủ đề',
+      advancedSetting: 'Cài đặt nâng cao',
+      topicName: 'Tên chủ đề',
       topicPlaceholder: 'Viết tên chủ đề của bạn',
-      addClass: 'Thêm Lớp',
+      addClass: 'Thêm lớp',
       instruction: 'Hướng dẫn',
+      instructionTip: 'Nhập hướng dẫn bổ sung để giúp trình phân loại câu hỏi hiểu rõ hơn về cách phân loại câu hỏi.',
       instructionPlaceholder: 'Viết hướng dẫn của bạn',
     },
+    parameterExtractor: {
+      inputVar: 'Biến đầu vào',
+      extractParameters: 'Trích xuất tham số',
+      importFromTool: 'Nhập từ công cụ',
+      addExtractParameter: 'Thêm tham số trích xuất',
+      addExtractParameterContent: {
+        name: 'Tên',
+        namePlaceholder: 'Tên tham số trích xuất',
+        type: 'Loại',
+        typePlaceholder: 'Loại tham số trích xuất',
+        description: 'Mô tả',
+        descriptionPlaceholder: 'Mô tả tham số trích xuất',
+        required: 'Bắt buộc',
+        requiredContent: 'Bắt buộc chỉ được sử dụng làm tài liệu tham khảo cho suy luận mô hình và không phải để xác thực bắt buộc của đầu ra tham số.',
+      },
+      extractParametersNotSet: 'Tham số trích xuất chưa được thiết lập',
+      instruction: 'Hướng dẫn',
+      instructionTip: 'Nhập hướng dẫn bổ sung để giúp trình trích xuất tham số hiểu rõ hơn về cách trích xuất tham số.',
+      advancedSetting: 'Cài đặt nâng cao',
+      reasoningMode: 'Chế độ suy luận',
+      reasoningModeTip: 'Bạn có thể chọn chế độ suy luận phù hợp dựa trên khả năng của mô hình để phản hồi các hướng dẫn về việc gọi hàm hoặc prompt.',
+      isSuccess: 'Thành công. Khi thành công giá trị là 1, khi thất bại giá trị là 0.',
+      errorReason: 'Lý do lỗi',
+    },
+    iteration: {
+      deleteTitle: 'Xóa nút lặp?',
+      deleteDesc: 'Xóa nút lặp sẽ xóa tất cả các nút con',
+      input: 'Đầu vào',
+      output: 'Biến đầu ra',
+      iteration_one: '{{count}} Lặp',
+      iteration_other: '{{count}} Lặp',
+      currentIteration: 'Lặp hiện tại',
+    },
   },
   tracing: {
-    stopBy: 'Dừng lại bởi {{user}}',
+    stopBy: 'Dừng bởi {{user}}',
   },
 }
 

web/i18n/zh-Hant/workflow.ts

@@ -1,89 +1,102 @@
 const translation = {
   common: {
     editing: '編輯中',
-    autoSaved: '自動儲存',
-    unpublished: '未釋出',
-    published: '已釋出',
-    publish: '釋出',
+    autoSaved: '自動保存',
+    unpublished: '未發佈',
+    published: '已發佈',
+    publish: '發佈',
     update: '更新',
-    run: '執行',
-    running: '執行中',
-    inRunMode: '在執行模式中',
+    run: '運行',
+    running: '運行中',
+    inRunMode: '在運行模式中',
     inPreview: '預覽中',
     inPreviewMode: '預覽中',
     preview: '預覽',
-    viewRunHistory: '檢視執行歷史',
-    runHistory: '執行歷史',
+    viewRunHistory: '查看運行歷史',
+    runHistory: '運行歷史',
     goBackToEdit: '返回編輯模式',
     conversationLog: '對話記錄',
     features: '功能',
-    debugAndPreview: '除錯和預覽',
+    debugAndPreview: '調試和預覽',
     restart: '重新開始',
     currentDraft: '當前草稿',
-    currentDraftUnpublished: '當前草稿未釋出',
-    latestPublished: '最新發布',
-    publishedAt: '釋出於',
+    currentDraftUnpublished: '當前草稿未發佈',
+    latestPublished: '最新發佈',
+    publishedAt: '發佈於',
     restore: '恢復',
-    runApp: '執行',
-    batchRunApp: '批次執行',
+    runApp: '運行',
+    batchRunApp: '批量運行',
     accessAPIReference: '訪問 API',
     embedIntoSite: '嵌入網站',
-    addTitle: '新增標題...',
-    addDescription: '新增描述...',
-    noVar: '沒有變數',
-    variableNamePlaceholder: '變數名',
-    searchVar: '搜尋變數',
-    setVarValuePlaceholder: '設定變數值',
-    needConnecttip: '此節點尚未連線到其他節點',
+    addTitle: '添加標題...',
+    addDescription: '添加描述...',
+    noVar: '沒有變量',
+    variableNamePlaceholder: '變量名',
+    searchVar: '搜索變量',
+    setVarValuePlaceholder: '設置變量值',
+    needConnecttip: '此節點尚未連接到其他節點',
     maxTreeDepth: '每個分支最大限制 {{depth}} 個節點',
-    needEndNode: '必須新增結束節點',
-    needAnswerNode: '必須新增直接回復節點',
+    needEndNode: '必須添加結束節點',
+    needAnswerNode: '必須添加直接回覆節點',
     workflowProcess: '工作流',
-    notRunning: '尚未執行',
-    previewPlaceholder: '在下面的框中輸入內容開始除錯聊天機器人',
+    notRunning: '尚未運行',
+    previewPlaceholder: '在下面的框中輸入內容開始調試聊天機器人',
     effectVarConfirm: {
-      title: '移除變數',
-      content: '該變數在其他節點中使用。您是否仍要刪除它？',
+      title: '移除變量',
+      content: '該變量在其他節點中使用。您是否仍要刪除它？',
     },
     insertVarTip: '按 \'/\' 鍵快速插入',
-    processData: '資料處理',
+    processData: '數據處理',
     input: '輸入',
     output: '輸出',
-    jinjaEditorPlaceholder: '输入 “/” 或 “{” 插入变量',
-    viewOnly: '只读',
-    showRunHistory: '显示运行历史',
-    enableJinja: '开启支持 Jinja 模板',
+    jinjaEditorPlaceholder: '輸入 “/” 或 “{” 插入變量',
+    viewOnly: '只讀',
+    showRunHistory: '顯示運行歷史',
+    enableJinja: '開啟支持 Jinja 模板',
     learnMore: '了解更多',
-    copy: '拷贝',
-    duplicate: '复制',
-    addBlock: '添加节点',
-    pasteHere: '粘贴到这里',
-    pointerMode: '指针模式',
+    copy: '拷貝',
+    duplicate: '複製',
+    addBlock: '添加節點',
+    pasteHere: '粘貼到這裡',
+    pointerMode: '指針模式',
     handMode: '手模式',
+    model: '模型',
+    workflowAsTool: '發佈為工具',
+    configureRequired: '需要進行配置',
+    configure: '配置',
+    manageInTools: '訪問工具頁',
+    workflowAsToolTip: '工作流更新後需要重新配置工具參數',
+    viewDetailInTracingPanel: '查看詳細信息',
   },
   errorMsg: {
     fieldRequired: '{{field}} 不能為空',
     authRequired: '請先授權',
     invalidJson: '{{field}} 是非法的 JSON',
     fields: {
-      variable: '變數名',
-      variableValue: '變數值',
-      code: '程式碼',
+      variable: '變量名',
+      variableValue: '變量值',
+      code: '代碼',
       model: '模型',
       rerankModel: 'Rerank 模型',
     },
-    invalidVariable: '無效的變數',
+    invalidVariable: '無效的變量',
   },
   singleRun: {
-    testRun: '測試執行 ',
-    startRun: '開始執行',
-    running: '執行中',
+    testRun: '測試運行',
+    startRun: '開始運行',
+    running: '運行中',
+    testRunIteration: '測試運行迭代',
+    back: '返回',
+    iteration: '迭代',
   },
   tabs: {
-    'searchBlock': '搜尋節點',
+    'searchBlock': '搜索節點',
     'blocks': '節點',
-    'builtInTool': '內建工具',
-    'customTool': '自定義工具',
+    'tools': '工具',
+    'allTool': '全部',
+    'builtInTool': '內置',
+    'customTool': '自定義',
+    'workflowTool': '工作流',
     'question-understand': '問題理解',
     'logic': '邏輯',
     'transform': '轉換',
@@ -93,150 +106,157 @@ const translation = {
   blocks: {
     'start': '開始',
     'end': '結束',
-    'answer': '直接回復',
+    'answer': '直接回覆',
     'llm': 'LLM',
     'knowledge-retrieval': '知識檢索',
     'question-classifier': '問題分類器',
     'if-else': '條件分支',
-    'code': '程式碼執行',
+    'code': '代碼執行',
     'template-transform': '模板轉換',
     'http-request': 'HTTP 請求',
-    'variable-assigner': '變數賦值',
+    'variable-assigner': '變量聚合器',
+    'variable-aggregator': '變量聚合器',
+    'iteration-start': '迭代開始',
+    'iteration': '迭代',
+    'parameter-extractor': '參數提取器',
   },
   blocksAbout: {
-    'start': '定義一個 workflow 流程啟動的初始引數',
-    'end': '定義一個 workflow 流程的結束和結果型別',
+    'start': '定義一個 workflow 流程啟動的初始參數',
+    'end': '定義一個 workflow 流程的結束和結果類型',
     'answer': '定義一個聊天對話的回覆內容',
-    'llm': '呼叫大語言模型回答問題或者對自然語言進行處理',
-    'knowledge-retrieval': '允許你從知識庫中查詢與使用者問題相關的文字內容',
-    'question-classifier': '定義使用者問題的分類條件，LLM 能夠根據分類描述定義對話的進展方式',
+    'llm': '調用大語言模型回答問題或者對自然語言進行處理',
+    'knowledge-retrieval': '允許你從知識庫中查詢與用戶問題相關的文本內容',
+    'question-classifier': '定義用戶問題的分類條件，LLM 能夠根據分類描述定義對話的進展方式',
     'if-else': '允許你根據 if/else 條件將 workflow 拆分成兩個分支',
-    'code': '執行一段 Python 或 NodeJS 程式碼實現自定義邏輯',
-    'template-transform': '使用 Jinja 模板語法將資料轉換為字串',
-    'http-request': '允許透過 HTTP 協議傳送伺服器請求',
-    'variable-assigner': '將不同分支中的變數指派給同一個變數，以實現後置節點統一配置',
+    'code': '執行一段 Python 或 NodeJS 代碼實現自定義邏輯',
+    'template-transform': '使用 Jinja 模板語法將數據轉換為字符串',
+    'http-request': '允許通過 HTTP 協議發送服務器請求',
+    'variable-assigner': '將多路分支的變量聚合為一個變量，以實現下游節點統一配置。',
+    'variable-aggregator': '將多路分支的變量聚合為一個變量，以實現下游節點統一配置。',
+    'iteration': '對列表對象執行多次步驟直至輸出所有結果。',
+    'parameter-extractor': '利用 LLM 從自然語言內推理提取出結構化參數，用於後置的工具調用或 HTTP 請求。',
   },
   operator: {
     zoomIn: '放大',
     zoomOut: '縮小',
     zoomTo50: '縮放到 50%',
     zoomTo100: '放大到 100%',
-    zoomToFit: '自適應檢視',
+    zoomToFit: '自適應視圖',
   },
   panel: {
-    userInputField: '使用者輸入欄位',
+    userInputField: '用戶輸入字段',
     changeBlock: '更改節點',
-    helpLink: '幫助連結',
+    helpLink: '幫助鏈接',
     about: '關於',
     createdBy: '作者',
     nextStep: '下一步',
-    addNextStep: '新增此工作流程中的下一個節點',
+    addNextStep: '添加此工作流程中的下一個節點',
     selectNextStep: '選擇下一個節點',
-    runThisStep: '執行此步驟',
+    runThisStep: '運行此步驟',
     checklist: '檢查清單',
-    checklistTip: '釋出前確保所有問題均已解決',
+    checklistTip: '發佈前確保所有問題均已解決',
     checklistResolved: '所有問題均已解決',
     organizeBlocks: '整理節點',
     change: '更改',
   },
   nodes: {
     common: {
-      outputVars: '輸出變數',
-      insertVarTip: '插入變數',
+      outputVars: '輸出變量',
+      insertVarTip: '插入變量',
       memory: {
         memory: '記憶',
-        memoryTip: '聊天記憶設定',
-        windowSize: '記憶視窗',
+        memoryTip: '聊天記憶設置',
+        windowSize: '記憶窗口',
         conversationRoleName: '對話角色名',
-        user: '使用者字首',
-        assistant: '助手字首',
+        user: '用戶前綴',
+        assistant: '助手前綴',
       },
       memories: {
         title: '記憶',
         tip: '聊天記憶',
-        builtIn: '內建',
+        builtIn: '內置',
       },
     },
     start: {
       required: '必填',
-      inputField: '輸入欄位',
-      builtInVar: '內建變數',
+      inputField: '輸入字段',
+      builtInVar: '內置變量',
       outputVars: {
-        query: '使用者輸入',
+        query: '用戶輸入',
         memories: {
           des: '會話歷史',
-          type: '訊息型別',
-          content: '訊息內容',
+          type: '消息類型',
+          content: '消息內容',
         },
-        files: '檔案列表',
+        files: '文件列表',
       },
-      noVarTip: '設定的輸入可在工作流程中使用',
+      noVarTip: '設置的輸入可在工作流程中使用',
     },
     end: {
       outputs: '輸出',
       output: {
-        type: '輸出型別',
-        variable: '輸出變數',
+        type: '輸出類型',
+        variable: '輸出變量',
       },
       type: {
         'none': '無',
-        'plain-text': '純文字',
+        'plain-text': '純文本',
         'structured': '結構化',
       },
     },
     answer: {
       answer: '回覆',
-      outputVars: '輸出變數',
+      outputVars: '輸出變量',
     },
     llm: {
       model: '模型',
-      variables: '變數',
+      variables: '變量',
       context: '上下文',
-      contextTooltip: '您可以匯入知識庫作為上下文',
-      notSetContextInPromptTip: '要啟用上下文功能，請在提示中填寫上下文變數。',
+      contextTooltip: '您可以導入知識庫作為上下文',
+      notSetContextInPromptTip: '要啟用上下文功能，請在提示中填寫上下文變量。',
       prompt: '提示詞',
-      addMessage: '新增訊息',
+      addMessage: '添加消息',
       roleDescription: {
         system: '為對話提供高層指導',
-        user: '向模型提供指令、查詢或任何基於文字的輸入',
-        assistant: '基於使用者訊息的模型回覆',
+        user: '向模型提供指令、查詢或任何基於文本的輸入',
+        assistant: '基於用戶消息的模型回覆',
       },
       vision: '視覺',
-      files: '檔案',
+      files: '文件',
       resolution: {
-        name: '解析度',
+        name: '分辨率',
         high: '高',
         low: '低',
       },
       outputVars: {
         output: '生成內容',
-        usage: '模型用量資訊',
+        usage: '模型用量信息',
       },
       singleRun: {
-        variable: '變數',
+        variable: '變量',
       },
       sysQueryInUser: 'user message 中必須包含 sys.query',
     },
     knowledgeRetrieval: {
-      queryVariable: '查詢變數',
+      queryVariable: '查詢變量',
       knowledge: '知識庫',
       outputVars: {
         output: '召回的分段',
         content: '分段內容',
         title: '分段標題',
-        icon: '分段圖示',
-        url: '分段連結',
-        metadata: '其他元資料',
+        icon: '分段圖標',
+        url: '分段鏈接',
+        metadata: '其他元數據',
       },
     },
     http: {
-      inputVars: '輸入變數',
+      inputVars: '輸入變量',
       api: 'API',
-      apiPlaceholder: '輸入 URL，輸入變數時請鍵入‘/’',
+      apiPlaceholder: '輸入 URL，輸入變量時請鍵入‘/’',
       notStartWithHttp: 'API 應該以 http:// 或 https:// 開頭',
       key: '鍵',
       value: '值',
-      bulkEdit: '批次編輯',
+      bulkEdit: '批量編輯',
       keyValueEdit: '鍵值編輯',
       headers: 'Headers',
       params: 'Params',
@@ -245,42 +265,42 @@ const translation = {
         body: '響應內容',
         statusCode: '響應狀態碼',
         headers: '響應頭列表 JSON',
-        files: '檔案列表',
+        files: '文件列表',
       },
       authorization: {
         'authorization': '鑑權',
-        'authorizationType': '鑑權型別',
+        'authorizationType': '鑑權類型',
         'no-auth': '無',
         'api-key': 'API-Key',
-        'auth-type': 'API 鑑權型別',
+        'auth-type': 'API 鑑權類型',
         'basic': '基礎',
         'bearer': 'Bearer',
         'custom': '自定義',
         'api-key-title': 'API Key',
         'header': 'Header',
       },
-      insertVarPlaceholder: '鍵入 \'/\' 鍵快速插入變數',
+      insertVarPlaceholder: '鍵入 \'/\' 鍵快速插入變量',
       timeout: {
-        title: '超时设置',
-        connectLabel: '连接超时',
-        connectPlaceholder: '输入连接超时（以秒为单位）',
-        readLabel: '读取超时',
-        readPlaceholder: '输入读取超时（以秒为单位）',
-        writeLabel: '写入超时',
-        writePlaceholder: '输入写入超时（以秒为单位）',
+        title: '超時設置',
+        connectLabel: '連接超時',
+        connectPlaceholder: '輸入連接超時（以秒為單位）',
+        readLabel: '讀取超時',
+        readPlaceholder: '輸入讀取超時（以秒為單位）',
+        writeLabel: '寫入超時',
+        writePlaceholder: '輸入寫入超時（以秒為單位）',
       },
     },
     code: {
-      inputVars: '輸入變數',
-      outputVars: '輸出變數',
-      advancedDependencies: '高级依赖',
-      advancedDependenciesTip: '在这里添加一些预加载需要消耗较多时间或非默认内置的依赖包',
-      searchDependencies: '搜索依赖',
+      inputVars: '輸入變量',
+      outputVars: '輸出變量',
+      advancedDependencies: '高級依賴',
+      advancedDependenciesTip: '在這裡添加一些預加載需要消耗較多時間或非默認內置的依賴包',
+      searchDependencies: '搜索依賴',
     },
     templateTransform: {
-      inputVars: '輸入變數',
-      code: '程式碼',
-      codeSupportTip: '只支援 Jinja2',
+      inputVars: '輸入變量',
+      code: '代碼',
+      codeSupportTip: '只支持 Jinja2',
       outputVars: {
         output: '轉換後內容',
       },
@@ -291,8 +311,8 @@ const translation = {
       elseDescription: '用於定義當 if 條件不滿足時應執行的邏輯。',
       and: 'and',
       or: 'or',
-      operator: '運算子',
-      notSetVariable: '請先設定變數',
+      operator: '操作符',
+      notSetVariable: '請先設置變量',
       comparisonOperator: {
         'contains': '包含',
         'not contains': '不包含',
@@ -306,54 +326,91 @@ const translation = {
         'not null': '不為空',
       },
       enterValue: '輸入值',
-      addCondition: '新增條件',
-      conditionNotSetup: '條件未設定',
+      addCondition: '添加條件',
+      conditionNotSetup: '條件未設置',
     },
     variableAssigner: {
-      title: '變數賦值',
-      outputType: '輸出型別',
-      outputVarType: '輸出變數型別',
-      varNotSet: '未設定變數',
-      noVarTip: '新增需要賦值的變數',
+      title: '變量賦值',
+      outputType: '輸出類型',
+      varNotSet: '未設置變量',
+      noVarTip: '添加需要賦值的變量',
       type: {
         string: 'String',
         number: 'Number',
         object: 'Object',
         array: 'Array',
       },
+      aggregationGroup: '聚合分組',
+      aggregationGroupTip: '開啟該功能後，變量聚合器內可以同時聚合多組變量',
+      addGroup: '添加分組',
       outputVars: {
-        output: '指派的變數值',
+        varDescribe: '{{groupName}}的輸出變量',
       },
+      setAssignVariable: '設置賦值變量',
     },
     tool: {
       toAuthorize: '授權',
-      inputVars: '輸入變數',
+      inputVars: '輸入變量',
       outputVars: {
         text: '工具生成的內容',
         files: {
-          title: '工具生成的檔案',
-          type: '支援型別。現在只支援圖片',
+          title: '工具生成的文件',
+          type: '支持類型。現在只支持圖片',
           transfer_method: '傳輸方式。值為 remote_url 或 local_file',
-          url: '圖片連結',
-          upload_file_id: '上傳檔案ID',
+          url: '圖片鏈接',
+          upload_file_id: '上傳文件ID',
         },
       },
     },
     questionClassifiers: {
       model: '模型',
-      inputVars: '輸入變數',
+      inputVars: '輸入變量',
       outputVars: {
         className: '分類名稱',
       },
       class: '分類',
       classNamePlaceholder: '輸入你的分類名稱',
-      advancedSetting: '高階設定',
+      advancedSetting: '高級設置',
       topicName: '主題內容',
       topicPlaceholder: '在這裡輸入你的主題內容',
-      addClass: '新增分類',
+      addClass: '添加分類',
       instruction: '指令',
+      instructionTip: '你可以輸入額外的附加指令，幫助問題分類器更好的理解如何分類',
       instructionPlaceholder: '在這裡輸入你的指令',
     },
+    parameterExtractor: {
+      inputVar: '輸入變量',
+      extractParameters: '提取參數',
+      importFromTool: '從工具導入',
+      addExtractParameter: '添加提取參數',
+      addExtractParameterContent: {
+        name: '名稱',
+        namePlaceholder: '提取參數名稱',
+        type: '類型',
+        typePlaceholder: '提取參數類型',
+        description: '描述',
+        descriptionPlaceholder: '提取參數描述',
+        required: '必填',
+        requiredContent: '必填僅作為模型推理的參考，不用於參數輸出的強制驗證。',
+      },
+      extractParametersNotSet: '提取參數未設置',
+      instruction: '指令',
+      instructionTip: '你可以輸入額外的附加指令，幫助參數提取器理解如何提取參數',
+      advancedSetting: '高級設置',
+      reasoningMode: '推理模式',
+      reasoningModeTip: '你可以根據模型對於 Function calling 或 Prompt 的指令響應能力選擇合適的推理模式',
+      isSuccess: '是否成功。成功時值為 1，失敗時值為 0。',
+      errorReason: '錯誤原因',
+    },
+    iteration: {
+      deleteTitle: '刪除迭代節點？',
+      deleteDesc: '刪除迭代節點將刪除所有子節點',
+      input: '輸入',
+      output: '輸出變量',
+      iteration_one: '{{count}}個迭代',
+      iteration_other: '{{count}}個迭代',
+      currentIteration: '當前迭代',
+    },
   },
   tracing: {
     stopBy: '由{{user}}終止',