The all-in-one local AI studio for your desktop: chat, image and video generation and a coding agent in one free, open source app. Windows and Linux. No Docker, no terminal, no cloud required.
TypeScript agentai-chatai-studioall-in-onecoding-agentdesktop-appfluximage-generationlinuxllmlocal-ailocal-llmopen-sourceprivacyself-hostedstable-diffusionuncensoreduncensored-aivideo-generationwindows
/**
* Texts of the strand "agent". Every text a user can read in this strand's
* screens lives here, not in JSX, so the guard reads them in one place.
* English, short sentences, no dashes, "Tap" instead of the desktop verb,
* "this phone" instead of "your machine".
*/
import { priced } from '../policy/gates'
/** A getter here is a text in two wordings; the store switches of the build pick one (policy/gates.ts). */
export const AGENT_STRINGS = {
common: {
cancel: 'Cancel',
save: 'Save',
remove: 'Remove',
delete: 'Delete',
close: 'Close',
tryAgain: 'Try again',
turnOn: 'Turn on',
notNow: 'Not now',
done: 'Done',
loading: 'Loading',
saved: 'Saved',
copied: 'Copied',
copyFailed: 'Could not copy on this phone.',
newChatFirst: 'Send a first message in this chat, then this works.',
chooseModelFirst: 'Choose a model first.',
report: 'Report',
show: 'Show',
hide: 'Hide',
},
policy: {
consentDeclined: 'Nothing was sent.',
},
tools: {
/** Under an answer of an agent run that names search results or sources although no tool ran. */
noToolRan: 'No tool ran for this answer. Search results and sources it names came from the model itself.',
/** Under an answer that says something was written or saved, although every step was declined or failed (round 9, N7). */
nothingWasDone: 'No step ran for this answer. Nothing was written, saved or changed.',
noSearchRan: 'No search ran for this answer. It came from the model itself, not from the web.',
rememberSaved: 'Saved to Memory.',
rememberNothing: 'Nothing was saved to Memory. Say what to keep in the same message, or add it under Memory.',
names: {
web_search: 'Search the web',
web_fetch: 'Read a page',
web_research: 'Research the web',
file_read: 'Read a file',
file_write: 'Write a file',
file_edit: 'Change a file',
file_list: 'List files',
file_search: 'Search in files',
run_workflow: 'Run a workflow',
delegate_task: 'Start a sub agent',
check_tasks: 'Check background tasks',
message_agent: 'Message a sub agent',
todo_write: 'Update the plan',
get_current_time: 'Look up the time',
} as Record<string, string>,
state: {
waiting: 'waiting for you',
running: 'running',
done: 'done',
failed: 'failed',
denied: 'not allowed',
stopped: 'stopped',
},
inThisChat: (name: string) => `${name} in this chat`,
filesOfChat: 'Files in this chat',
failed: (tool: string) => `${tool} failed`,
failedWith: (tool: string, reason: string) => `${tool} failed: ${reason}`,
cut: (more: number) => `(${more} more characters not shown)`,
steps: (n: number) => (n === 1 ? '1 step' : `${n} steps`),
stepsRunning: (n: number) => (n === 1 ? '1 step, running' : `${n} steps, running`),
stepsFailed: (n: number, failed: number) => `${n} steps, ${failed} failed`,
input: 'Input',
result: 'Result',
noResult: 'No result yet.',
technicalName: 'Tool',
showMore: 'Show all',
showLess: 'Show less',
thinking: 'Thinking',
thoughtFor: (seconds: number) => `Thought for ${seconds} s`,
thought: 'Thought',
note: 'Note from the model',
compacted: 'Earlier messages were compacted',
compactedCount: (n: number) => (n === 1 ? '1 message summarized' : `${n} messages summarized`),
compactedAuto: 'Done automatically',
compactedUnreadable: 'This summary could not be read back.',
compactedExplain: 'The messages above stay in this chat. From here on the model reads the summary instead of them.',
interrupted: 'Interrupted',
},
permissions: {
blocked: 'Blocked',
ask: 'Ask',
auto: 'Auto',
groups: {
web: 'Web',
files: 'Files in chat',
workflows: 'Workflows',
subagents: 'Sub agents',
},
hints: {
web: 'Search the web and read pages.',
files: 'Read and write files inside the folder of a chat.',
workflows: 'Run a saved workflow as one step.',
subagents: 'Hand a part of the work to a second run.',
},
levelOf: (group: string) => `Permission for ${group}`,
memoryTitle: 'Memory',
memoryHint: 'Memory is not a tool the model calls. What LU learns is set on the Memory page.',
appWideOnly: 'Set for the whole app in Settings, Agent and permissions.',
explain: 'Blocked: the model never gets the tool. Ask: LU asks you before each step. Auto: the step runs without asking.',
},
notices: {
goal: 'Goal',
clearGoal: 'Clear goal',
goalCleared: 'Goal cleared',
loop: 'Repeating',
loopPass: (pass: number, cap: number) => (cap > 0 ? `pass ${pass} of ${cap}` : `pass ${pass}`),
loopNextIn: (seconds: number) => `next in ${seconds} s`,
loopRunning: 'running now',
stopLoop: 'Stop loop',
loopStopped: 'Loop stopped',
plan: 'Plan',
planProgress: (done: number, total: number) => `${done} of ${total} done`,
planNow: (step: string) => `Now: ${step}`,
planName: (done: number, total: number, open: boolean) => `Plan, ${done} of ${total} done. ${open ? 'Hide steps' : 'Show steps'}`,
planClear: 'Clear plan',
planDone: 'done',
planDoing: 'in progress',
planOpen: 'to do',
slotUnloading: 'Reading document. The chat model makes room first and reloads afterwards.',
slotReading: 'Reading document, the chat model reloads afterwards.',
slotReloading: 'Document read. The chat model is loading again.',
docReading: 'Reading a document. New answers start when it is done.',
docWaiting: 'A document waits until this answer is finished. Then it is read.',
docWaitingModel: 'A document waits until the chat model has loaded. Then it is read.',
},
status: {
agent: 'Agent',
agentName: 'Agent mode is on. Open chat options',
agentNoTools: 'Agent mode is on, but this model cannot use tools. Open chat options',
/** Toast: the model was changed to one of this phone that cannot call tools while Agent mode was on. */
agentTurnedOff: 'Agent mode is off now. This model cannot use tools.',
documents: (n: number) => (n === 1 ? '1 document' : `${n} documents`),
documentsOff: (n: number) => (n === 1 ? '1 document, search off' : `${n} documents, search off`),
documentsName: (n: number, on: boolean) => `${n === 1 ? '1 document' : `${n} documents`} in this chat, search ${on ? 'on' : 'off'}. Open documents`,
thinking: 'Thinking',
thinkingName: 'Thinking is on. Open chat options',
persona: (name: string) => `Persona: ${name}`,
personaOwn: 'Custom',
personaName: (name: string) => `Persona ${name}. Change persona`,
group: (n: number) => `Group: ${n} models`,
groupName: (n: number) => `Group chat with ${n} models. Open group chat`,
caveman: 'Caveman',
cavemanName: (level: string) => `Caveman mode ${level}. Change it`,
rowName: 'Chat status',
},
approval: {
title: 'Allow this step?',
allow: 'Allow',
deny: 'Deny',
always: 'Always allow in this chat',
alwaysDone: (group: string) => `${group} runs without asking in this chat`,
details: 'Details',
noTarget: 'The model wants to run this step.',
waiting: (n: number) => (n === 1 ? '1 more step is waiting' : `${n} more steps are waiting`),
gone: 'This step is no longer waiting.',
denied: 'Step denied',
fromSubAgent: 'Asked by a sub agent of this chat.',
},
options: {
title: 'Chat options',
done: 'Done',
/** Prompt v2: the model, the documents and the cost stand at the top of the sheet now, not around the field. */
model: 'Model',
modelNone: 'Choose a model',
modelPhone: 'On this phone',
modelCloud: 'LU Cloud, uses credits',
modelOther: 'From a provider',
documents: 'Documents',
documentsSub: 'Files this chat can search',
cost: 'Cost of this chat',
costSub: 'What a message on LU Cloud takes',
groupNow: 'This chat',
/** Above the switches that are settings of the app and hold in every chat (Thinking, Small model mode). */
groupAll: 'All chats',
groupMore: 'More',
groupFine: 'Fine tuning',
agent: 'Agent mode',
agentSub: 'Let the model use tools step by step',
agentNoTools: 'This model cannot use tools. Pick another model or turn on Small model mode.',
agentNoToolsDevice: 'This model cannot use tools. Pick a model with the Tools mark to use Agent mode.',
agentNoModel: 'Choose a model, then Agent mode can use it.',
// A phone with too little memory for every model that drives tools (small iPhone, K5).
// The model drives tools, this file of it is packed with 1 or 2 bits (check on Android with 4 GB, F3).
agentNoToolsPacking: 'This model is packed too small for Agent mode. Pick one packed with 3 bits or more that has the Tools mark.',
// One reason each, the one that applies (check 4 on Android, F6: the sentence named the packing also for a model in 4 bit that has no Tools mark).
agentNoToolsFit: 'This model cannot use tools, and no model with the Tools mark fits the memory of this phone: use a cloud model or a phone with more memory.',
agentNoToolsFitPacking: 'This model is packed too small for Agent mode, and no packing of it with 3 bits or more fits the memory of this phone: use a cloud model or a phone with more memory.',
agentOtherModel: 'Choose another model',
// Where the row leads, as it is: without a sign in the list of LU Cloud is not there yet.
agentOtherModelSub: 'Opens the models of LU Cloud',
agentOtherModelSubSignedOut: 'Opens LU Cloud. Its models need a sign in.',
thinking: 'Thinking',
thinkingSub: 'The model reasons before it answers. Slower, often better.',
thinkingAlways: 'Always on for this model',
effort: 'Reasoning effort',
effortLevels: { low: 'Low', medium: 'Medium', high: 'High', max: 'Max' } as Record<string, string>,
webSearch: 'Web search',
webSearchSub: 'Search and read pages when needed',
webSearchBlocked: 'Off for this chat. The model cannot search or read pages here.',
writeFiles: 'Write files',
writeFilesSub: 'Let the model save files into this chat',
writeFilesBlocked: 'Off for this chat. The model cannot read or write files here.',
smallModel: 'Small model mode',
smallModelSub: 'A lean set of tools and shorter prompts for small models on this phone',
persona: 'Persona',
personaOff: 'Off',
personaOwn: 'On',
group: 'Group chat',
groupSub: 'Several models answer in turn',
groupOn: (n: number) => `${n} models`,
caveman: 'Caveman mode',
cavemanLevels: { off: 'Off', lite: 'Lite', full: 'Full', ultra: 'Ultra' } as Record<string, string>,
memory: 'Memory',
memorySub: 'What LU remembers about you',
memoryCount: (n: number) => (n === 1 ? '1 memory' : `${n} memories`),
workflows: 'Workflows',
workflowsSub: 'Run a saved chain of steps in this chat',
sampling: 'Sampling',
samplingOwn: 'Changed for this chat',
samplingDefault: 'App defaults',
context: 'Context window',
contextSub: 'One size for all chats',
permissions: 'Permissions for this chat',
permissionsOwn: 'Changed for this chat',
permissionsDefault: 'App defaults',
goal: 'Set a goal',
goalSet: 'Goal is set',
loop: 'Repeat a task',
loopRunning: 'A loop is running',
needsSavedChat: 'Send a first message in this chat, then this works.',
intro: {
title: 'Agent mode',
lead: 'In Agent mode the model does not only answer. It works in steps and uses tools on the way.',
points: [
'It can search the web and read pages.',
'It can read and write files inside this chat. Nothing outside this chat is touched.',
'It can run your workflows and hand parts of the work to a sub agent.',
'Before a step that changes something, LU asks you. You decide each time, or allow it for the whole chat.',
],
// The same four for a model that runs on this phone: it gets no sub agents (lib/phone-sub-agents.ts).
pointsOnDevice: [
'It can search the web and read pages.',
'It can read and write files inside this chat. Nothing outside this chat is touched.',
'It can run your workflows.',
'Before a step that changes something, LU asks you. You decide each time, or allow it for the whole chat.',
],
battery: 'Agent runs take longer than a normal answer and use more battery. They pause when LU is in the background.',
noTools: 'The model you chose cannot use tools. Agent mode will stay without effect until you pick another model.',
turnOn: 'Turn on',
notNow: 'Not now',
},
personaPage: {
title: 'Persona',
useInChat: 'Use a persona in this chat',
useInChatSub: 'Off: this chat talks to the plain model.',
inChatOn: (name: string) => `On: this chat answers as ${name}.`,
inChatOnPlain: 'On: this chat answers with the persona it started with.',
listTitle: 'Persona',
listHint: 'Choosing a persona turns it on for this chat, from the next message on. New chats start with it too. Other chats keep theirs.',
builtIn: 'Built in',
own: 'Your own',
manage: 'Manage personas',
},
cavemanPage: {
title: 'Caveman mode',
label: 'Caveman mode',
text: 'The model answers in very few words. Lite trims filler, Full drops whole sentences, Ultra keeps only the bare facts. It applies to every chat.',
},
workflowsPage: {
title: 'Workflows',
empty: 'No workflows yet.',
emptyText: 'A workflow is a saved chain of steps. Build one under Manage workflows.',
manage: 'Manage workflows',
steps: (n: number) => (n === 1 ? '1 step' : `${n} steps`),
needsAgent: 'Workflows run in Agent mode.',
turnOnAgent: 'Turn on Agent mode',
busy: 'An answer is being written. Wait for it, then start the workflow.',
started: (name: string) => `${name} started`,
askTitle: (name: string) => `Start ${name}`,
askLabel: 'Input',
askConfirm: 'Start',
runName: (name: string) => `Run ${name} in this chat`,
},
samplingPage: {
title: 'Sampling',
text: 'These values apply to this chat only.',
textNew: 'These values apply to this chat once you send the first message.',
temperature: 'Temperature',
temperatureHint: 'Low is exact and repeatable, high is varied.',
topP: 'Top P',
maxLength: 'Max length',
maxLengthHint: 'The most tokens one answer may have.',
noLimit: 'No limit',
tokens: (n: number) => `${n} tokens`,
reset: 'Reset to defaults',
resetDone: 'Back to the app defaults',
},
contextPage: {
title: 'Context window',
fill: 'Context used',
fillOf: (used: string, max: string) => `${used} of ${max} tokens`,
fillEmpty: 'Nothing sent yet. The bar fills as the chat grows.',
fillUnknown: 'LU does not know the window of this model yet.',
nearFull: 'The window is almost full. Compact the chat, or the oldest messages fall out.',
trimmed: 'This chat is longer than the window, so the oldest messages are left out of what the model reads. They stay in the chat. Compact now keeps a summary of them for the model.',
tooLong: 'The last message alone is more text than the model can read at once. Send a shorter one, or start a new chat.',
windowTitleLocal: 'Window size for all chats on this phone',
windowTitleCloud: 'Window size for all chats with this model',
windowLabel: 'Window size',
auto: 'Auto',
localHint: 'The model on this phone has one window, so this size holds for every chat, not only this one. A larger window remembers more of the chat and needs more memory. Changing it loads the model again.',
get cloudHint() {
return priced('How much of a chat each answer sends to LU Cloud. It holds for every chat with this model. A larger window costs more credits.', 'How much of a chat each answer sends to LU Cloud. It holds for every chat with this model. A larger window uses a larger share of your credits.')
},
fixedHint: 'This model sets its own window. It cannot be changed here.',
applying: 'Loading the model with the new window',
applied: 'Window changed',
applyFailed: (reason: string) => `Could not change the window. ${reason}`,
compact: 'Compact now',
compactHint: 'Replaces older messages with a summary for the model. The messages stay readable in the chat.',
compactBusy: 'An answer is being written. Wait for it, then compact.',
compactTooShort: 'There is not enough in this chat to compact yet.',
compactStarted: 'Compacting this chat',
},
permissionsPage: {
title: 'Permissions for this chat',
text: 'These levels apply to this chat only.',
useDefaults: 'Use app defaults',
defaultsDone: 'This chat follows the app defaults again',
appSettings: 'Agent and permissions',
appSettingsSub: 'Defaults for every chat',
},
goalPage: {
title: 'Set a goal',
text: 'A goal stays in view for the whole chat. The model is reminded of it with every message.',
label: 'Goal',
placeholder: 'What should this chat achieve?',
set: 'Set goal',
update: 'Update goal',
clear: 'Clear goal',
done: 'Goal set',
cleared: 'Goal cleared',
empty: 'Write the goal first.',
tooLong: (max: number) => `A goal has at most ${max} characters.`,
},
loopPage: {
title: 'Repeat a task',
text: 'The model works on the task, then looks at it again after each pause, until it says the task is done or you stop it.',
label: 'Task',
placeholder: 'What should be done, and how will you know it is done?',
interval: 'Pause between passes',
intervals: { '30s': '30 s', '2m': '2 min', '10m': '10 min', '30m': '30 min' } as Record<string, string>,
hint: 'Runs only while LU is open.',
start: 'Start loop',
started: 'Loop started',
stop: 'Stop loop',
stopped: 'Loop stopped',
empty: 'Write the task first.',
needsAgent: 'A loop runs in Agent mode.',
turnOnAgent: 'Turn on Agent mode',
busy: 'An answer is being written. Wait for it, then start the loop.',
running: (pass: number) => `A loop is running in this chat, pass ${pass}.`,
},
},
documents: {
title: 'Documents',
search: 'Search documents in this chat',
searchSub: 'The model gets the passages that match your question.',
whereLocal: 'Documents are read and searched on this phone. Only the passages that match your question are sent to the model.',
whereCloud: 'Documents are read and searched on this phone. Only the passages that match your question leave the phone, to the model you chose.',
add: 'Add document',
addBusy: 'A document is being read. Wait for it, or cancel it.',
listTitle: 'In this chat',
empty: 'No documents in this chat yet.',
emptyText: 'Add a PDF, a Word file or a text file. LU reads it on this phone.',
newChat: 'This chat has no messages yet.',
newChatText: 'Open the chat, tap the plus button and choose Documents. The chat starts there.',
gone: 'This chat is gone.',
goneText: 'It was deleted or never existed on this phone.',
backToChats: 'Back to chats',
docSub: (kind: string, size: string, passages: number) => `${kind}, ${size}, ${passages === 1 ? '1 passage' : `${passages} passages`}`,
docName: (name: string) => `Document ${name}`,
passagesTitle: 'Last passages found',
passagesNone: 'No passage of this document was used yet. Ask something about it.',
score: (percent: number) => `Match ${percent}%`,
remove: 'Remove',
removeName: (name: string) => `Remove ${name}`,
removeTitle: (name: string) => `Remove ${name}?`,
removeText: 'The document leaves this chat. The file itself stays where it is.',
removed: 'Document removed',
removeAll: 'Remove all',
removeAllTitle: 'Remove all documents?',
removeAllText: (n: number) => (n === 1 ? 'The document leaves this chat. The file itself stays where it is.' : `All ${n} documents leave this chat. The files themselves stay where they are.`),
removedAll: 'All documents removed',
reading: 'Reading',
indexing: 'Indexing',
// Round 10, N14: measured in this reading, shown once there is enough to go by (lib/reading-limits.ts).
timeLeft: (seconds: number) => (seconds < 60 ? 'about a minute or less left' : `about ${Math.ceil(seconds / 60)} min left`),
workName: (name: string) => `Reading ${name}`,
cancel: 'Cancel',
cancelled: 'Stopped. The document was not added.',
failed: 'Could not read this file.',
failedState: 'Failed',
failedRestart: 'Choose the file again to try once more.',
// Round 35, D1: the file was gone when LU read it (iOS removes the copy it hands to the app).
fileGone: (name: string) => `LU could no longer open "${name}". Try adding the file again.`,
notReadable: (name: string, words: string) => `LU could not read "${name}": ${words}`,
// Round 38, L2: in the list, but its passages were lost with the storage of the web view.
notSaved: (name: string) => `"${name}" was not fully saved before LU closed, so it cannot be searched.`,
tryAgain: 'Try again',
tryAgainName: (name: string) => `Try reading ${name} again`,
failedToast: (name: string) => `${name} could not be read. Open Documents to try again.`,
duplicate: (name: string) => `${name} is already in this chat. It was not added again.`,
duplicateAs: (name: string, existing: string) => `${name} has the same content as ${existing}, which is already in this chat. It was not added again.`,
waitsForAnswer: 'Waits until the answer in the chat is finished.',
waitsForModel: 'Waits until the chat model has loaded.',
takesTurns: 'This phone holds one model at a time. While a document is read the chat model is unloaded, and it loads again afterwards.',
paused: 'Paused. LU was in the background while it read this file.',
pausedRestart: 'Paused. LU was closed while it read this file. Choose the file again to finish.',
continue: 'Continue',
continueName: (name: string) => `Continue reading ${name}`,
pickAgain: 'Choose file',
pickAgainName: (name: string) => `Choose ${name} again`,
wrongType: 'LU reads PDF, Word and text files.',
added: (name: string) => `${name} added`,
waiting: (n: number) => (n === 1 ? '1 file waits for the document model.' : `${n} files wait for the document model.`),
install: {
title: (size: string) => `Install the document model, ${size}`,
text: 'LU needs a small model to search documents. It runs on this phone and is downloaded once.',
button: 'Install',
progress: 'Downloading the document model',
failed: 'The download did not finish. Check the connection and try again.',
done: 'Document model installed',
},
checking: 'Checking the document model',
importChats: 'Import chats from ChatGPT, Claude or Gemini',
importChatsGroup: 'Other sources',
importChatsSub: 'Bring old chats in, then ask about them like a document.',
kinds: { pdf: 'PDF', docx: 'Word', txt: 'Text' } as Record<string, string>,
},
compare: {
title: 'Compare',
modelA: 'Model A',
modelB: 'Model B',
choose: 'Choose a model',
viewLabel: 'Answer shown',
a: 'A',
b: 'B',
placeholder: 'Ask both models',
inputLabel: 'Message to both models',
needTwo: 'Choose two models first.',
same: 'A and B are the same model. Choose two different ones.',
bothLocal: 'This phone holds one model at a time. LU answers with A, then loads B. That takes longer.',
empty: 'One prompt, two answers.',
emptyText: 'Choose two models and ask below. Each answer shows which model wrote it.',
you: 'You',
waiting: 'Waiting for the answer',
waitingTurn: 'Waits until A is done',
noAnswer: 'No answer came back. The model may be unreachable or the run was stopped.',
keep: 'Keep this answer',
keepBlocked: 'Wait until both answers are done.',
kept: 'Answer added to the chat',
keepNoChat: 'This chat has no messages yet, so the answer starts it.',
stats: (tokens: number, perSec: string) => `${tokens} tokens, ${perSec} per second`,
statsShort: (tokens: number) => `${tokens} ${tokens === 1 ? 'token' : 'tokens'}`,
stopped: 'Stopped',
clear: 'Start over',
clearTitle: 'Start the comparison over?',
clearText: 'Both answer lists are emptied. The chat itself is not changed.',
answerOf: (side: string, model: string) => `Answer ${side}, ${model}`,
paidHint: 'Cloud models use credits. This sends the prompt to each cloud model once.',
},
tasks: {
title: 'Background tasks',
hint: 'Tasks pause when LU is in the background.',
empty: 'No tasks running.',
emptyText: 'When the agent hands work to a sub agent, it shows up here.',
status: { queued: 'Waiting', running: 'Running', done: 'Done', failed: 'Failed', cancelled: 'Stopped' } as Record<string, string>,
taskName: (goal: string, status: string) => `${goal}. ${status}`,
seconds: (n: number) => (n < 60 ? `${n} s` : `${Math.floor(n / 60)} min ${n % 60} s`),
foreground: 'The agent waits for this task.',
background: 'Runs beside the chat.',
goal: 'Task',
context: 'What it was given',
activity: 'Working on',
counts: (steps: number, tools: number) => `${steps === 1 ? '1 step' : `${steps} steps`}, ${tools === 1 ? '1 tool run' : `${tools} tool runs`}`,
output: 'Answer',
error: 'Error',
noOutput: 'No answer yet.',
unread: (n: number) => (n === 1 ? '1 message not read yet' : `${n} messages not read yet`),
stop: 'Stop',
stopName: (goal: string) => `Stop task ${goal}`,
stopped: 'Stopping the task',
stopFailed: 'This task had already ended.',
stopAll: 'Stop all',
stopAllTitle: 'Stop all tasks?',
stopAllText: (n: number) => (n === 1 ? 'The running task ends now. What it found so far is lost.' : `${n} running tasks end now. What they found so far is lost.`),
stoppedAll: (n: number) => (n === 1 ? 'Stopping 1 task' : `Stopping ${n} tasks`),
message: 'Message agent',
messageLabel: 'Message to the sub agent',
messagePlaceholder: 'Tell it what to change or add',
send: 'Send',
sent: 'Message sent. The task reads it before its next step.',
sendFailed: 'This task has ended and reads no more messages.',
messageEmpty: 'Write the message first.',
tokens: 'Tokens used',
},
preview: {
title: 'Preview',
close: 'Close',
widthLabel: 'Frame width',
phone: 'Phone',
wide: 'Wide',
reload: 'Reload',
frame: 'Preview of the page the model wrote',
failed: 'This page could not be shown.',
failedText: 'The code block is gone or is not a web page. Go back to the chat and open the preview from the answer again.',
sandbox: 'The page runs closed off. It cannot read this chat or anything else in LU.',
wideHint: 'Wide shows the page as on a desktop. Scroll sideways inside the frame.',
noScriptsTitle: 'Scripts are off in this preview',
noScripts: 'You see the layout and the styles of the page. Its scripts do not run inside the app, so buttons and animations made with scripts stay still. Copy the code to try it in a browser.',
},
groupChat: {
title: 'Group chat',
enable: 'Group chat in this conversation',
enableSub: 'Several models answer each message in turn.',
participants: 'Participants',
add: 'Add model',
addFull: (max: number) => `A group has at most ${max} models.`,
addOne: 'Add a second model to start.',
already: 'This model is already in the group.',
persona: 'Persona',
personaOf: (model: string) => `Persona of ${model}`,
personaFollow: 'Follows the chat',
personaFollowSub: 'Uses the persona of this chat, if one is on.',
personaTitle: (model: string) => `Persona for ${model}`,
remove: 'Remove',
removeName: (model: string) => `Remove ${model} from the group`,
removeTitle: (model: string) => `Remove ${model}?`,
removeText: 'It stops answering in this chat. Its earlier answers stay.',
cost: (n: number) => `One message, ${n} answers. Cloud models use credits for each answer.`,
costLocal: (n: number) => `One message, ${n} answers. All of them run on this phone and cost nothing.`,
bothLocal: 'This phone holds one model at a time. LU answers with one, then loads the next. That takes longer.',
off: 'Group chat is off. This chat talks to one model.',
newChat: 'Send a first message in this chat, then a group can be set up.',
gone: 'This chat is gone.',
agentNote: 'A group round is plain talk. Agent mode and tools rest while the group is on.',
onDevice: 'On this phone',
cloud: 'LU Cloud',
turnedOff: 'Group chat turned off',
},
personas: {
title: 'Personas',
use: 'Use personas',
useSub: 'A persona gives the model a role and a tone.',
off: 'Personas are off. Every chat talks to the plain model.',
listTitle: 'Active persona',
builtIn: 'Built in',
own: 'Your own',
edit: 'Edit',
editName: (name: string) => `Edit ${name}`,
add: 'New persona',
reset: 'Reset built in personas',
resetTitle: 'Reset built in personas?',
resetText: 'The built in personas get their first text back. Your own personas are not touched.',
resetConfirm: 'Reset',
resetDone: 'Built in personas reset',
resetNothing: 'The built in personas are unchanged.',
hint: 'New chats start with the active persona while this is on. A chat can turn it off in its options, and a chat that is already running keeps what it started with.',
editor: {
titleNew: 'New persona',
titleEdit: 'Persona',
name: 'Name',
namePlaceholder: 'For example Editor',
instructions: 'Instructions',
instructionsPlaceholder: 'Tell the model who it is and how it answers.',
instructionsHint: 'The model reads this before every message of a chat.',
save: 'Save',
saved: 'Persona saved',
delete: 'Delete persona',
deleteTitle: (name: string) => `Delete ${name}?`,
deleteText: 'The persona is removed from this phone. Chats that used it go on without it.',
deleted: 'Persona deleted',
nameEmpty: 'Give the persona a name.',
nameTaken: 'Another persona already has this name.',
instructionsEmpty: 'Write the instructions first.',
builtInNote: 'This persona is built in. You can change its text, and Reset built in personas brings the first text back.',
gone: 'This persona is gone.',
goneText: 'It was deleted on this phone.',
back: 'Back to personas',
unchanged: 'Nothing changed yet.',
},
},
memory: {
title: 'Memory',
search: 'Search memories',
filterLabel: 'Category',
all: 'All',
types: { user: 'About you', feedback: 'How to answer', project: 'Projects', reference: 'References' } as Record<string, string>,
count: (n: number) => (n === 1 ? '1 memory' : `${n} memories`),
empty: 'No memories yet.',
emptyText: 'LU remembers what you tell it to keep, and what it learns from chats when that is on.',
noMatch: 'No memory matches.',
noMatchText: 'Try another word or another category.',
clearSearch: 'Show all',
add: 'Add memory',
outdated: 'Outdated',
sensitive: 'Sensitive',
rowName: (title: string) => `Memory ${title}`,
settingsTitle: 'Learning',
learn: 'Learn from chats',
learnSub: 'After an answer LU asks the model once more what is worth keeping. Uses a little battery.',
get learnSubCloud() {
return priced('After an answer LU asks the model once more what is worth keeping. With a model that does not run on this phone, that is billed like any other message.', 'After an answer LU asks the model once more what is worth keeping. With a model that does not run on this phone, that counts like any other message.')
},
// Which model learns, and what a small one misses (check 4 on Android, F1: no word about it, and nothing was learned).
learnWith: (model: string) =>
model
? `Learning is done by the chat model on this phone, now ${model}. A small model misses things. What you say about yourself in plain words, such as "I am a nurse" or "I work as a teacher", is kept either way.`
: 'Learning is done by the chat model on this phone. A small model misses things. What you say about yourself in plain words, such as "I am a nurse" or "I work as a teacher", is kept either way.',
outside: 'Also outside Agent mode',
outsideSub: 'Learn from plain chats as well.',
outsideOff: 'Turn on Learn from chats first.',
keep: 'Keep at most',
keepSub: 'How many memories one message may carry to the model.',
keepAuto: 'Auto',
keepAutoSub: 'LU picks the number from the size of the model.',
keepValue: (n: number) => (n === 1 ? '1 memory' : `${n} memories`),
review: 'Review old memories',
reviewSub: (n: number) => (n === 0 ? 'Nothing to review' : n === 1 ? '1 memory to look at' : `${n} memories to look at`),
reviewing: 'Showing memories to review',
reviewDone: 'Show all memories',
reviewEmpty: 'Nothing to review.',
reviewEmptyText: 'Every memory is current and was looked at.',
syncTitle: 'Sync',
signIn: 'Sign in to sync',
signInSub: 'With an account your memories can follow you to other devices.',
collection: 'Use account memories',
collectionSub: 'Off: the memories that belong to this phone only.',
collectionFailed: 'Could not open this collection. Nothing was replaced.',
allow: 'Store this collection in LU Cloud',
allowSub: 'Needed for sync. Asked again each time you open this page.',
allowSensitive: 'Include sensitive memories',
allowSensitiveSub: 'Off: memories marked sensitive stay on this phone.',
syncNow: 'Sync now',
syncNeedsAllow: 'Turn on cloud storage for this collection first.',
syncing: 'Syncing memories',
cancelSync: 'Cancel',
synced: (up: number, down: number) => `Synced. ${up} sent, ${down} received.`,
syncedOmitted: (n: number) => (n === 1 ? '1 sensitive memory stayed on this phone.' : `${n} sensitive memories stayed on this phone.`),
syncFailed: 'Could not sync. Your memories are safe on this phone.',
syncCancelled: 'Sync cancelled. Some changes may already be saved.',
syncChanged: 'Memories changed while syncing. Sync again.',
syncNeedsConsent: 'Nothing was sent. Syncing stores your memories in LU Cloud, and LU needs your consent for that.',
lastSynced: (when: string) => `Last synced ${when}`,
neverSynced: 'Not synced yet',
conflicts: (n: number) => (n === 1 ? '1 memory differs between this phone and the account' : `${n} memories differ between this phone and the account`),
resolve: 'Choose a version',
conflict: {
title: 'Which version?',
text: 'This memory was changed on this phone and in your account. Choose what stays.',
phone: 'On this phone',
account: 'In your account',
keepPhone: 'Keep this phone',
keepAccount: 'Keep account',
keepBoth: 'Keep both',
keepBothHint: 'Keeps the version of this phone and adds the account version as a second memory.',
noPreview: 'This memory was deleted on one side. Sync again after you saved or deleted it here.',
more: (n: number) => (n === 1 ? '1 more after this one' : `${n} more after this one`),
none: 'Nothing to choose any more.',
copySuffix: '(account)',
},
older: 'Bring over older memories',
olderSub: 'Look at the copy an older version of LU stored in your account.',
olderChecking: 'Checking the older copy',
olderNone: 'There is no older copy in your account.',
olderFound: (n: number) => (n === 1 ? 'The older copy holds 1 memory. It is in this collection now.' : `The older copy holds ${n} memories. They are in this collection now.`),
olderRemove: 'Remove the older copy',
olderRemoveTitle: 'Remove the older copy?',
olderRemoveText: 'The copy an older version of LU stored in your account is deleted. Older versions of LU can then no longer sync memories.',
olderRemoved: 'Older copy removed',
olderFailed: 'Could not read the older copy. Sync first, then try again.',
dataTitle: 'Your data',
export: 'Export',
exportTitle: 'Export memories',
exportMarkdown: 'Markdown',
exportMarkdownSub: 'Readable text, one memory after the other.',
exportJson: 'JSON',
exportJsonSub: 'Everything, to import into LU again.',
exported: 'Export ready',
exportFailed: (reason: string) => `Could not export. ${reason}`,
exportEmpty: 'There is nothing to export yet.',
import: 'Import',
importSub: 'A Markdown or JSON export of LU.',
importNone: 'No memories found in that file. Use a Markdown or JSON export of LU.',
importUnreadable: 'Could not read that file.',
importChanged: 'The collection changed while reading. Choose the file again.',
deleteAll: 'Delete all memories',
deleteAllEmpty: 'There are no memories to delete yet.',
deleteAllTitle: 'Delete all memories?',
deleteAllText: (n: number) => `${n === 1 ? 'The memory' : `All ${n} memories`} of this collection will be removed from this phone. This cannot be undone. Type DELETE to go on.`,
deleteAllConfirm: 'Delete all',
deletedAll: 'All memories deleted',
detail: {
titleNew: 'New memory',
titleEdit: 'Memory',
name: 'Title',
namePlaceholder: 'A few words',
text: 'Text',
textPlaceholder: 'What should LU remember?',
category: 'Category',
project: 'Project',
projectPlaceholder: 'Leave empty for every chat',
projectHint: 'A memory with a project is only used in chats of that project.',
sensitive: 'Sensitive',
sensitiveSub: 'Never sent to a model and never synced unless you allow it.',
save: 'Save',
saved: 'Memory saved',
delete: 'Delete',
deleteTitle: 'Delete this memory?',
deleteText: 'It is removed from this phone. With sync on it is removed from your account at the next sync.',
deleted: 'Memory deleted',
nameEmpty: 'Give the memory a title.',
textEmpty: 'Write what LU should remember.',
duplicate: 'This memory is already saved.',
gone: 'This memory is gone.',
goneText: 'It was deleted or belongs to another collection.',
back: 'Back to memories',
outdated: 'This memory is outdated. A newer one replaced it, so it is no longer used.',
reviewed: (when: string) => `Looked at ${when}`,
notReviewed: 'Not looked at yet',
confirm: 'Still correct',
confirmed: 'Marked as current',
source: { manual: 'Added by you', auto: 'Learned from a chat' } as Record<string, string>,
created: (when: string) => `Created ${when}`,
},
},
agentSettings: {
title: 'Agent and permissions',
groupsTitle: 'What the agent may do',
memoryRow: 'Memory',
memoryRowSub: 'What LU learns and keeps is set on the Memory page.',
subTitle: 'Sub agents',
subCalls: 'Sub agent tool calls',
subCallsSub: 'The most tool runs one sub agent may make.',
subSteps: 'Sub agent steps',
subStepsSub: 'The most turns one sub agent may take.',
subDefault: (n: number) => `0 uses the default of ${n}. A sub agent runs without you watching, so keep these low.`,
subValue: (n: number, fallback: number) => (n === 0 ? `Now the default, ${fallback}.` : ''),
intro: 'Show the Agent mode intro again',
introSub: 'The next time you turn on Agent mode, the intro comes first.',
introDone: 'The intro shows again next time',
introAlready: 'The intro already shows next time.',
reset: 'Reset permissions',
resetTitle: 'Reset permissions?',
resetText: 'Every group goes back to its first level, for the app and for every chat.',
resetConfirm: 'Reset',
resetDone: 'Permissions reset',
},
webSearch: {
title: 'Web search',
providerTitle: 'Search provider',
auto: 'Auto',
autoSub: 'Uses your key when one is saved, else the free search.',
duckduckgo: 'DuckDuckGo',
duckduckgoSub: 'Free. No key is sent, even when one is saved. DuckDuckGo sometimes refuses automated searches, then Wikipedia answers instead.',
brave: 'Brave',
braveSub: 'Uses your Brave API key.',
tavily: 'Tavily',
tavilySub: 'Uses your Tavily API key.',
needsKey: (name: string) => `Add a ${name} API key below first.`,
/** In a build without search keys of one's own (store switch webSearchKeys): what the page says in place of the choice. */
freeOnly: 'LU searches with the free search. DuckDuckGo answers first, and Wikipedia when it refuses. Nothing has to be set up.',
keysTitle: 'API keys',
braveKey: 'Brave API key',
tavilyKey: 'Tavily API key',
newKey: (name: string) => `New ${name} API key`,
keyPlaceholder: 'Paste the key',
keyHint: 'Keys are kept in the secure key storage of this phone. They are not part of your settings or of a backup, and a key is sent only to its own search provider.',
savedLine: (name: string) => `${name} API key saved on this phone.`,
save: 'Save key',
saveName: (name: string) => `Save the ${name} API key`,
pasteFirst: 'Paste a key first.',
replace: 'Replace',
replaceName: (name: string) => `Replace the ${name} API key`,
keep: 'Keep the saved key',
keepName: (name: string) => `Keep the saved ${name} API key`,
remove: 'Remove',
removeName: (name: string) => `Remove the ${name} API key`,
removeTitle: (name: string) => `Remove the ${name} API key?`,
removeText: 'Searches then go through the free search.',
removed: 'Key removed',
removeFailed: 'The key could not be removed. Unlock the phone and try again.',
saved: 'Key saved',
noKeychain: 'This device has no secure key storage, so the key was not saved.',
saveFailed: 'The key could not be saved. Unlock the phone and try again.',
test: 'Test search',
testing: 'Searching',
// A question the same everywhere. "weather today" was answered by where the phone stands, and the first
// hit of the test named the place (acceptance Android, re-run, N12).
testQuery: 'history of the printing press',
testOk: (n: number, provider: string) => `Search works. ${n === 1 ? '1 result' : `${n} results`} from ${provider}.`,
testFallback: (reason: string) => `Your provider did not answer, so the free search was used. ${reason}`,
testSkipped: (reasons: string) => `Not every free search answered. ${reasons}`,
testFailed: (reason: string) => `Search did not work. ${reason}`,
testEmpty: 'The search came back empty.',
// No network (second check on Android, F7): one sentence about the cause and one about what to do. Not the text
// of the system, and no advice to add a key. The model gets the same gist as the result of its tool (lib/search-offline.ts).
testOffline: 'This phone has no internet connection, so the search did not run. Connect to Wi-Fi or mobile data and try again.',
firstResult: 'First result',
providerNames: { auto: 'the free search', brave: 'Brave', tavily: 'Tavily', duckduckgo: 'DuckDuckGo', wikipedia: 'Wikipedia', searxng: 'SearXNG' } as Record<string, string>,
},
workflows: {
title: 'Workflows',
empty: 'No workflows yet.',
emptyText: 'A workflow is a saved chain of steps the agent runs one after the other.',
add: 'New workflow',
builtIn: 'Built in',
steps: (n: number) => (n === 1 ? '1 step' : `${n} steps`),
rowName: (name: string) => `Workflow ${name}`,
notHere: (n: number) => (n === 1 ? '1 workflow uses tools that do not exist on a phone and is not listed.' : `${n} workflows use tools that do not exist on a phone and are not listed.`),
editor: {
titleNew: 'New workflow',
titleEdit: 'Workflow',
name: 'Name',
namePlaceholder: 'For example Morning briefing',
description: 'Description',
descriptionPlaceholder: 'What it is for',
stepsTitle: 'Steps',
noSteps: 'No steps yet. Add the first one.',
addStep: 'Add step',
stepName: (n: number, label: string) => `Step ${n}, ${label}. Edit`,
moveUp: 'Move up',
moveDown: 'Move down',
moveUpName: (label: string) => `Move ${label} up`,
moveDownName: (label: string) => `Move ${label} down`,
removeStep: 'Remove step',
removeStepName: (label: string) => `Remove step ${label}`,
save: 'Save',
saved: 'Workflow saved',
delete: 'Delete workflow',
deleteTitle: (name: string) => `Delete ${name}?`,
deleteText: 'The workflow is removed from this phone.',
deleted: 'Workflow deleted',
run: 'Run in a new chat',
runSaveFirst: 'Save the workflow first.',
runNoModel: 'Choose a model first.',
runNoSteps: 'Add a step first.',
runAskTitle: (name: string) => `Start ${name}`,
runAskLabel: 'Input',
runAskConfirm: 'Start',
nameEmpty: 'Give the workflow a name.',
stepsEmpty: 'A workflow needs at least one step.',
stepBroken: (n: number, why: string) => `Step ${n}: ${why}`,
builtInNote: 'This workflow is built in. It can be run, not changed.',
gone: 'This workflow is gone.',
goneText: 'It was deleted on this phone.',
back: 'Back to workflows',
duplicate: 'Make a copy to change',
duplicated: 'Copy made',
},
kinds: {
prompt: 'Ask the model',
tool: 'Run a tool',
condition: 'Branch',
loop: 'Repeat',
user_input: 'Ask you',
memory_save: 'Save a memory',
} as Record<string, string>,
summary: {
prompt: (text: string) => text || 'No prompt yet',
tool: (name: string) => name || 'No tool chosen yet',
condition: (op: string, value: string) => (value ? `${op} "${value}"` : op),
loop: (n: number, steps: number) => `Up to ${n} times, ${steps === 1 ? '1 step' : `${steps} steps`}`,
user_input: (text: string) => text || 'No question yet',
memory_save: (title: string) => title || 'No title yet',
},
kindHints: {
prompt: 'Send a prompt to the model and keep its answer.',
tool: 'Run one tool with fixed input, for example a web search.',
condition: 'Go on at one step or another, depending on the last answer.',
loop: 'Repeat some steps until the last answer says to stop.',
user_input: 'Stop and ask you for a text, then go on with it.',
memory_save: 'Keep something from the run in Memory.',
} as Record<string, string>,
addSheet: {
title: 'Add step',
},
step: {
title: 'Step',
label: 'Step name',
labelPlaceholder: 'A few words',
prompt: 'Prompt',
promptPlaceholder: 'What should the model do in this step?',
promptTools: 'Let the model use tools in this step',
promptToolsSub: 'Off: the model only writes. On: it may search, read pages and use files, with your permissions.',
promptHint: 'Write {{last_output}} where the answer of the step before belongs, and {{user_input}} for what you typed.',
tool: 'Tool',
toolPick: 'Choose a tool',
toolInput: 'Input',
toolInputHint: 'One line per value. {{last_output}} and {{user_input}} are replaced during the run.',
toolNone: 'This tool needs no input.',
toolNames: { web_search: 'Search the web', web_fetch: 'Read a page', file_read: 'Read a file', file_write: 'Write a file' } as Record<string, string>,
toolArgs: { query: 'Search for', url: 'Address of the page', path: 'File name', content: 'Text of the file' } as Record<string, string>,
question: 'Question',
questionPlaceholder: 'What should LU ask you?',
source: 'Look at',
sourceLast: 'The last answer',
operator: 'Check',
operators: { contains: 'Contains', not_contains: 'Does not contain', equals: 'Equals', not_equals: 'Is not', truthy: 'Is not empty', falsy: 'Is empty' } as Record<string, string>,
value: 'Text to look for',
thenStep: 'If yes, go on at',
elseStep: 'If no, go on at',
nextStep: 'The next step',
stepOption: (n: number, label: string) => `Step ${n}: ${label}`,
loopMax: 'Repeat at most',
loopTimes: (n: number) => (n === 1 ? '1 time' : `${n} times`),
loopUntil: 'Stop when the last answer',
loopBody: 'Steps to repeat',
loopBodyNone: 'Add other steps first, then pick the ones to repeat.',
memoryTitle: 'Memory title',
memoryText: 'Memory text',
memoryType: 'Category',
memoryHint: '{{last_output}} puts the answer of the step before into the memory.',
done: 'Done',
gone: 'This step is gone.',
back: 'Back to the workflow',
errors: {
label: 'Give the step a name.',
prompt: 'Write the prompt.',
tool: 'Choose a tool.',
toolArg: (name: string) => `The tool needs a value for ${name}.`,
question: 'Write the question.',
value: 'Write the text to look for.',
loopBody: 'Pick at least one step to repeat.',
target: 'A branch points at a step that is gone.',
memory: 'Give the memory a title and a text.',
},
},
},
} as const