@k2b/cloud 0.24.0 → 0.26.0

package/src/ai/chat/messages.ts

@@ -11,7 +11,6 @@ const messages = i18n.define({
       tableCapped: "Showing the first 100 returned rows. The full tool result remains available in details.",
       tableMore: "More rows are available. Ask for the next page or open the result in the application.",
       assistantTurns: "Assistant turns",
-      workSteps: "Work steps",
       surveyNoAnswer: "No answer",
       surveyNoAnswers: "No answers submitted.",
       toolCalls: "Tool calls",
@@ -21,10 +20,170 @@ const messages = i18n.define({
       createdPdf: "Created PDF",
       thinking: "Thinking",
       showReasoning: "Show reasoning",
+      reconnecting: "Reconnecting",
       byteRange: ({ start, end }: { start: string; end: string }) => `Bytes ${start}–${end}`,
+      worked: "Worked",
+      workedFor: ({ duration }: { duration: string }) => `Worked ${duration}`,
+      workedStopped: ({ duration }: { duration: string }) => (duration ? `Worked ${duration} · stopped` : "Stopped"),
+      workedInterrupted: ({ duration }: { duration: string }) => (duration ? `Worked ${duration} · interrupted` : "Interrupted"),
+      workedLabel: ({ duration, steps, ending }: { duration: string; steps: string; ending: "stopped" | "failed" | null }) =>
+        [duration ? `Worked ${duration}` : "Worked", ending === "stopped" ? "stopped" : ending === "failed" ? "interrupted" : "", steps]
+          .filter(Boolean)
+          .join(", "),
+      steps: ({ count }: { count: number }) => (count === 1 ? "1 step" : `${count} steps`),
+      waitingForApproval: "Waiting for your approval",
+      waitingForAnswer: "Waiting for your answer",
+      waitingSince: ({ duration }: { duration: string }) => `for ${duration}`,
+      durationSeconds: ({ seconds }: { seconds: number }) => `${seconds} s`,
+      durationMinutes: ({ minutes }: { minutes: number }) => `${minutes} min`,
+      durationHours: ({ hours, minutes }: { hours: number; minutes: number }) => (minutes ? `${hours} h ${minutes} min` : `${hours} h`),
+      durationSecondsLong: ({ seconds }: { seconds: number }) => (seconds === 1 ? "1 second" : `${seconds} seconds`),
+      durationMinutesLong: ({ minutes }: { minutes: number }) => (minutes === 1 ? "1 minute" : `${minutes} minutes`),
+      durationHoursLong: ({ hours, minutes }: { hours: number; minutes: number }) =>
+        [hours === 1 ? "1 hour" : `${hours} hours`, minutes ? (minutes === 1 ? "1 minute" : `${minutes} minutes`) : ""]
+          .filter(Boolean)
+          .join(" "),
+      stepThinking: "Thinking",
+      stepWriting: "Writing",
+      stepReading: ({ target }: { target: string }) => (target ? `Reading ${target}` : "Reading a file"),
+      stepListingFiles: "Looking through files",
+      stepViewingImage: "Looking at an image",
+      stepWritingFile: "Writing a file",
+      stepWritingCode: "Writing code",
+      stepRunningCode: "Running code",
+      stepCheckingApp: "Checking the app",
+      stepCode: "Working with code",
+      stepPlan: "Updating the working plan",
+      stepPdf: "Creating a PDF",
+      stepLoading: "Loading tools and guidance",
+      stepWeb: "Searching the web",
+      stepMemory: "Using memory",
+      stepCalculating: "Calculating",
+      stepUsingApp: ({ app }: { app: string }) => `Using ${app}`,
+      stepDeliveringFile: "Delivering a file",
+      stepPreparingView: "Preparing a view",
+      stepPreparingCard: "Preparing a card",
+      stepCompacting: "Summarizing the conversation",
+      stepTool: "Using a tool",
+      stepFailed: "failed",
+      stepRejected: "rejected",
+      stepWaiting: "waiting",
+      steered: "Conversation steered",
+      reasoning: "Reasoning",
+      groupPlan: "Updated working plan",
+      groupCode: "Worked with code",
+      groupCloud: "Used Cloud integration",
+      groupReadFiles: "Read files",
+      groupWriteFiles: "Wrote files",
+      groupPdf: "Created PDFs",
+      groupLoad: "Loaded tools and guidance",
+      groupWeb: "Searched the web",
+      groupMemory: "Used memory",
+      groupDelivered: "Delivered results",
+      groupTools: "Used tools",
+      groupFailed: ({ count }: { count: number }) => `${count} failed`,
+      groupRejected: ({ count }: { count: number }) => `${count} rejected`,
+      receiptDone: ({ title }: { title: string }) => `${title} done`,
+      receiptApproved: ({ title }: { title: string }) => `Approved: ${title}`,
+      approvalNeeded: ({ title }: { title: string }) => `Approval needed: ${title}`,
+      answerReady: "Answer ready",
+      receiptRejected: ({ title }: { title: string }) => `Rejected: ${title}`,
+      receiptFailed: ({ title }: { title: string }) => `Failed: ${title}`,
+      receiptNotRun: ({ title, stopped }: { title: string; stopped: boolean }) => `Not run: ${title}${stopped ? " · stopped" : ""}`,
+      workSteps: "Work steps",
       streamLoginRequired: "Your session has ended. Sign in again to continue this chat.",
       streamAccessDenied: "You no longer have access to this chat.",
       streamNotFound: "This chat is no longer available.",
+      assistant: "Assistant",
+      action: "Action",
+      approvalRequired: ({ title }: { title: string }) => `Approval required: ${title}`,
+      reject: "Reject",
+      approved: "Approved",
+      rejected: "Rejected",
+      alwaysApprove: "Always approve",
+      details: "Details",
+      hideDetails: "Hide details",
+      moreOptions: ({ title }: { title: string }) => `More options for ${title}`,
+      detailsFor: ({ title }: { title: string }) => `${title} details`,
+      linksFor: ({ title }: { title: string }) => `${title} links`,
+      contentOf: ({ label }: { label: string }) => `${label} content`,
+      approvalUnavailable: "Approval unavailable",
+      approvalFailed: "Could not submit. Try again.",
+      submitting: "Submitting",
+      submitted: "Submitted",
+      stoppingResponse: "Stopping response",
+      openIn: ({ app }: { app: string }) => `Open in ${app}`,
+      editIn: ({ app }: { app: string }) => `Edit in ${app}`,
+      statusIn: ({ app }: { app: string }) => `View status in ${app}`,
+      preview: "Preview",
+      download: "Download",
+      open: "Open",
+      edit: "Edit",
+      toolFailed: ({ title }: { title: string }) => `${title} failed`,
+      toolRejected: ({ title }: { title: string }) => `${title} was rejected`,
+      actionNotCompleted: "The action could not be completed.",
+      input: "Input",
+      response: "Response",
+      output: "Output",
+      toolInputOutput: "Tool input and output",
+      waiting: "Waiting",
+      failed: "Failed",
+      conversationSteered: "Conversation steered",
+      compacting: "Compacting context",
+      compacted: "Context compacted",
+      compactionSkipped: "Nothing to compact",
+      compactionFailed: "Compaction failed",
+      showCompaction: "Show compaction",
+      compactionSummary: "Older chat context was summarized into compact conversation memory.",
+      before: "Before",
+      after: "After",
+      textEditor: "Text editor",
+      preparingTextEditor: "Preparing text editor",
+      memory: "Memory",
+      usingMemory: "Using memory",
+      memoryNotUpdated: "Memory not updated",
+      remembered: "Remembered",
+      memoryUpdated: "Updated memory",
+      memoryForgotten: "Forgot memory",
+      memoriesSearched: "Searched memories",
+      memoriesListed: "Listed memories",
+      fileDownloadFailed: "File download failed",
+      fileNotImported: "The linked file could not be imported into this chat.",
+      tools: "Tools",
+      searchTools: ({ query }: { query: string }) => `Search tools: ${query}`,
+      found: ({ count, more }: { count: number; more?: boolean }) => `${count}${more ? "+" : ""} found`,
+      noTools: "No tools found.",
+      listApps: "List apps",
+      available: ({ count }: { count: number }) => `${count} available`,
+      noApps: "No capability apps available.",
+      loadTools: "Load tools",
+      loadedCount: ({ count }: { count: number }) => `${count} loaded`,
+      toolsLoaded: "Loaded",
+      toolsAlreadyLoaded: "Already loaded",
+      toolsMissing: "Missing",
+      toolsEvicted: "Evicted",
+      loadedSkill: ({ name }: { name: string }) => `Loaded skill ${name}`,
+      help: "Help",
+      searchHelp: ({ query }: { query: string }) => `Search help: ${query}`,
+      noHelp: "No Help articles found.",
+      readHelp: "Read help",
+      readHelpArticle: ({ title }: { title: string }) => `Read help: ${title}`,
+      articleNotFound: "Article not found",
+      searchProject: ({ query }: { query: string }) => `Search Project: ${query}`,
+      listProjectSources: "List Project sources",
+      noProjectSources: "No Project sources found.",
+      projectEntry: "Entry",
+      readProjectKnowledge: ({ title }: { title: string }) => `Read Project knowledge: ${title}`,
+      listFiles: ({ path }: { path: string }) => `List files: ${path}`,
+      noFiles: "No files found.",
+      file: "File",
+      wroteFile: "Wrote file",
+      readFile: ({ name }: { name: string }) => `Read file: ${name}`,
+      fileComplete: "complete",
+      fileMoreAvailable: "more available",
+      calculate: "Calculate",
+      inspectImage: ({ name }: { name: string }) => `Inspect image: ${name}`,
+      readResource: ({ ref }: { ref: string }) => `Read resource: ${ref}`,
     },
     de: {
       backgroundRun: "Hintergrundlauf",
@@ -35,7 +194,6 @@ const messages = i18n.define({
         "Die ersten 100 zurückgegebenen Zeilen werden angezeigt. Das vollständige Werkzeugergebnis bleibt in den Details verfügbar.",
       tableMore: "Weitere Zeilen sind verfügbar. Frage nach der nächsten Seite oder öffne das Ergebnis in der Anwendung.",
       assistantTurns: "Antwortdurchläufe",
-      workSteps: "Arbeitsschritte",
       surveyNoAnswer: "Keine Antwort",
       surveyNoAnswers: "Keine Antworten abgegeben.",
       toolCalls: "Werkzeugaufrufe",
@@ -45,10 +203,174 @@ const messages = i18n.define({
       createdPdf: "PDF erstellt",
       thinking: "Denkt nach",
       showReasoning: "Denkprozess anzeigen",
+      reconnecting: "Verbindung wird wiederhergestellt",
       byteRange: ({ start, end }) => `Bytes ${start}–${end}`,
+      worked: "Gearbeitet",
+      workedFor: ({ duration }) => `${duration} gearbeitet`,
+      workedStopped: ({ duration }) => (duration ? `${duration} gearbeitet · gestoppt` : "Gestoppt"),
+      workedInterrupted: ({ duration }) => (duration ? `${duration} gearbeitet · abgebrochen` : "Abgebrochen"),
+      workedLabel: ({ duration, steps, ending }) =>
+        [
+          duration ? `${duration} gearbeitet` : "Gearbeitet",
+          ending === "stopped" ? "gestoppt" : ending === "failed" ? "abgebrochen" : "",
+          steps,
+        ]
+          .filter(Boolean)
+          .join(", "),
+      steps: ({ count }) => (count === 1 ? "1 Schritt" : `${count} Schritte`),
+      waitingForApproval: "Wartet auf deine Freigabe",
+      waitingForAnswer: "Wartet auf deine Antwort",
+      waitingSince: ({ duration }) => `seit ${duration}`,
+      durationSeconds: ({ seconds }) => `${seconds} s`,
+      durationMinutes: ({ minutes }) => `${minutes} Min.`,
+      durationHours: ({ hours, minutes }) => (minutes ? `${hours} Std. ${minutes} Min.` : `${hours} Std.`),
+      durationSecondsLong: ({ seconds }) => (seconds === 1 ? "1 Sekunde" : `${seconds} Sekunden`),
+      durationMinutesLong: ({ minutes }) => (minutes === 1 ? "1 Minute" : `${minutes} Minuten`),
+      durationHoursLong: ({ hours, minutes }) =>
+        [hours === 1 ? "1 Stunde" : `${hours} Stunden`, minutes ? (minutes === 1 ? "1 Minute" : `${minutes} Minuten`) : ""]
+          .filter(Boolean)
+          .join(" "),
+      stepThinking: "Denkt nach",
+      stepWriting: "Schreibt",
+      stepReading: ({ target }) => (target ? `Liest ${target}` : "Liest eine Datei"),
+      stepListingFiles: "Sieht Dateien durch",
+      stepViewingImage: "Sieht sich ein Bild an",
+      stepWritingFile: "Schreibt eine Datei",
+      stepWritingCode: "Schreibt Code",
+      stepRunningCode: "Führt Code aus",
+      stepCheckingApp: "Prüft die App",
+      stepCode: "Arbeitet mit Code",
+      stepPlan: "Aktualisiert den Arbeitsplan",
+      stepPdf: "Erstellt ein PDF",
+      stepLoading: "Lädt Werkzeuge und Wissen",
+      stepWeb: "Recherchiert im Web",
+      stepMemory: "Nutzt das Gedächtnis",
+      stepCalculating: "Rechnet",
+      stepUsingApp: ({ app }) => `Nutzt ${app}`,
+      stepDeliveringFile: "Stellt eine Datei bereit",
+      stepPreparingView: "Bereitet eine Ansicht vor",
+      stepPreparingCard: "Bereitet eine Karte vor",
+      stepCompacting: "Fasst das Gespräch zusammen",
+      stepTool: "Nutzt ein Werkzeug",
+      stepFailed: "fehlgeschlagen",
+      stepRejected: "abgelehnt",
+      stepWaiting: "wartet",
+      steered: "Richtung geändert",
+      reasoning: "Überlegungen",
+      groupPlan: "Arbeitsplan aktualisiert",
+      groupCode: "Mit Code gearbeitet",
+      groupCloud: "Cloud-Integration verwendet",
+      groupReadFiles: "Dateien gelesen",
+      groupWriteFiles: "Dateien geschrieben",
+      groupPdf: "PDFs erstellt",
+      groupLoad: "Werkzeuge und Wissen geladen",
+      groupWeb: "Im Web recherchiert",
+      groupMemory: "Gedächtnis genutzt",
+      groupDelivered: "Ergebnisse bereitgestellt",
+      groupTools: "Werkzeuge verwendet",
+      groupFailed: ({ count }) => `${count} fehlgeschlagen`,
+      groupRejected: ({ count }) => `${count} abgelehnt`,
+      receiptDone: ({ title }) => `${title} erledigt`,
+      receiptApproved: ({ title }) => `Freigegeben: ${title}`,
+      approvalNeeded: ({ title }) => `Freigabe nötig: ${title}`,
+      answerReady: "Antwort fertig",
+      receiptRejected: ({ title }) => `Abgelehnt: ${title}`,
+      receiptFailed: ({ title }) => `Fehlgeschlagen: ${title}`,
+      receiptNotRun: ({ title, stopped }) => `Nicht ausgeführt: ${title}${stopped ? " · gestoppt" : ""}`,
+      workSteps: "Arbeitsschritte",
       streamLoginRequired: "Deine Sitzung ist abgelaufen. Melde dich erneut an, um diesen Chat fortzusetzen.",
       streamAccessDenied: "Du hast keinen Zugriff mehr auf diesen Chat.",
       streamNotFound: "Dieser Chat ist nicht mehr verfügbar.",
+      assistant: "Assistent",
+      action: "Aktion",
+      approvalRequired: ({ title }) => `Freigabe erforderlich: ${title}`,
+      reject: "Ablehnen",
+      approved: "Freigegeben",
+      rejected: "Abgelehnt",
+      alwaysApprove: "Immer freigeben",
+      details: "Details",
+      hideDetails: "Details ausblenden",
+      moreOptions: ({ title }) => `Weitere Optionen für ${title}`,
+      detailsFor: ({ title }) => `Details zu ${title}`,
+      linksFor: ({ title }) => `Links zu ${title}`,
+      contentOf: ({ label }) => `Inhalt von ${label}`,
+      approvalUnavailable: "Freigabe nicht verfügbar",
+      approvalFailed: "Senden fehlgeschlagen. Versuche es erneut.",
+      submitting: "Wird gesendet",
+      submitted: "Gesendet",
+      stoppingResponse: "Antwort wird angehalten",
+      openIn: ({ app }) => `In ${app} öffnen`,
+      editIn: ({ app }) => `In ${app} bearbeiten`,
+      statusIn: ({ app }) => `Status in ${app} ansehen`,
+      preview: "Vorschau",
+      download: "Herunterladen",
+      open: "Öffnen",
+      edit: "Bearbeiten",
+      toolFailed: ({ title }) => `${title} fehlgeschlagen`,
+      toolRejected: ({ title }) => `${title} abgelehnt`,
+      actionNotCompleted: "Die Aktion konnte nicht abgeschlossen werden.",
+      input: "Eingabe",
+      response: "Antwort",
+      output: "Ausgabe",
+      toolInputOutput: "Werkzeug-Eingabe und -Ausgabe",
+      waiting: "Wartet",
+      failed: "Fehlgeschlagen",
+      conversationSteered: "Gesprächsrichtung angepasst",
+      compacting: "Kontext wird verdichtet",
+      compacted: "Kontext verdichtet",
+      compactionSkipped: "Nichts zu verdichten",
+      compactionFailed: "Verdichtung fehlgeschlagen",
+      showCompaction: "Verdichtung anzeigen",
+      compactionSummary: "Älterer Chatverlauf wurde zu einer kompakten Zusammenfassung verdichtet.",
+      before: "Vorher",
+      after: "Nachher",
+      textEditor: "Texteditor",
+      preparingTextEditor: "Texteditor wird vorbereitet",
+      memory: "Personalisierung",
+      usingMemory: "Personalisierung wird verwendet",
+      memoryNotUpdated: "Personalisierung nicht aktualisiert",
+      remembered: "Gemerkt",
+      memoryUpdated: "Personalisierung aktualisiert",
+      memoryForgotten: "Aus der Personalisierung entfernt",
+      memoriesSearched: "Personalisierung durchsucht",
+      memoriesListed: "Personalisierung angezeigt",
+      fileDownloadFailed: "Datei konnte nicht geladen werden",
+      fileNotImported: "Die verlinkte Datei konnte nicht in diesen Chat übernommen werden.",
+      tools: "Werkzeuge",
+      searchTools: ({ query }) => `Werkzeuge suchen: ${query}`,
+      found: ({ count, more }) => `${count}${more ? "+" : ""} gefunden`,
+      noTools: "Keine Werkzeuge gefunden.",
+      listApps: "Apps auflisten",
+      available: ({ count }) => `${count} verfügbar`,
+      noApps: "Keine Apps mit Capabilities verfügbar.",
+      loadTools: "Werkzeuge laden",
+      loadedCount: ({ count }) => `${count} geladen`,
+      toolsLoaded: "Geladen",
+      toolsAlreadyLoaded: "Bereits geladen",
+      toolsMissing: "Nicht gefunden",
+      toolsEvicted: "Entladen",
+      loadedSkill: ({ name }) => `Skill ${name} geladen`,
+      help: "Hilfe",
+      searchHelp: ({ query }) => `Hilfe durchsuchen: ${query}`,
+      noHelp: "Keine Hilfeartikel gefunden.",
+      readHelp: "Hilfe lesen",
+      readHelpArticle: ({ title }) => `Hilfe lesen: ${title}`,
+      articleNotFound: "Artikel nicht gefunden",
+      searchProject: ({ query }) => `Projekt durchsuchen: ${query}`,
+      listProjectSources: "Projektquellen auflisten",
+      noProjectSources: "Keine Projektquellen gefunden.",
+      projectEntry: "Eintrag",
+      readProjectKnowledge: ({ title }) => `Projektwissen lesen: ${title}`,
+      listFiles: ({ path }) => `Dateien auflisten: ${path}`,
+      noFiles: "Keine Dateien gefunden.",
+      file: "Datei",
+      wroteFile: "Datei geschrieben",
+      readFile: ({ name }) => `Datei lesen: ${name}`,
+      fileComplete: "vollständig",
+      fileMoreAvailable: "weitere verfügbar",
+      calculate: "Berechnen",
+      inspectImage: ({ name }) => `Bild prüfen: ${name}`,
+      readResource: ({ ref }) => `Ressource lesen: ${ref}`,
     },
   },
 });