Repository navigation
v0.8.3
Added
-
agents: a module can add its screen to the admin UI's sidebar. A jar on
the classpath that serves a page of its own had no way into the navigation —
the menu was a fixed list, so the page was reachable by URL only. It now
registers anAdminMenuContributionbean and says which entries to show,
for an admin of the namespace and for a plain user of it separately, so a
contribution never offers a viewer a route the server would refuse. An entry
is a link or a group of links, like Install; groups with one id from several
modules become one. The entries follow the shipped sections, before the
Install group. -
agents: a module on the classpath ships its own agents, skills and workflows. The
seeds were read from the app's own jar only:initial-data/in a second jar
was never scanned, so a module that brings an agent had to install it by
hand. The loaders — and the Migrations screen — now look through every jar
on the classpath, so a module'sinitial-data/agent-definitions/*.json,
skills/*.mdandworkflows/*.jsonare seeded and migrated exactly like the
bundled ones. -
agents: a turn that waits for an approval can say so. A tool marked
needsApprovalused to leave the caller waiting for the final answer until
somebody answered the card elsewhere.AgentRuntime.send(…)returns as soon
as a call waits, with aTurnResultthat isINCOMPLETEand lists the open
questions;approve(…)anddeny(…)continue the same turn and return its
answer or the next question. Underneath,ChatTurnHandle.outcome()completes
at the question, andAgentChatService.sendChat,approveanddenyare the
non-blocking forms. Over REST the chat stream ends a waiting stretch with an
incompleteframe, andPOST /api/sessions/{id}/approvals/{callId}/continue
answers and streams the turn on. The runtime protocol backend ends such a
responseINCOMPLETE(WAITING_FOR_APPROVAL)with anApprovalRequestitem,
and anApprovalResponseas the next input continues the turn. -
agents: the Admin UI can carry your own name, mark and stylesheet.
mindconnect.branding.*sets the heading in the header, the logo beside it
and where it leads, the browser tab's title and icon, the look the shell
opens in, and any number of stylesheets that are linked after the shipped
ones so their rules win.assets-dirserves a directory next to the running
app at/branding/**, so an installation brands itself by dropping files in
rather than by building its own image; the login page follows the same
settings. Unset, everything looks exactly as before — except the browser tab,
which now says "Mindconnect Agent Runtime" instead of "Agent Admin".
switchtakes it one step further: named variants with aurl-patterneach,
so one deployment behind two host names wears two brands, decided per request
rather than per process.style-pickersays what the header's theme picker
may offer — every shipped theme, a named few, or none at all, and with none
the look is genuinely fixed. See
Branding the app. -
agents: the calendar is a port too, and CalDAV comes with it.
mc-calendar-corehasCalendarStore— the calendars, a period of
appointments, reading one, creating, changing and deleting — and the
CalendarProviderseam a kind of account plugs into.mc-calendar-caldav
brings CalDAV, which nearly every mail provider and every self-hosted
calendar speaks: a card with the CalDAV address, user and password, a Test
button that signs in and says which calendars it found, and as much
iCalendar as an appointment needs.mc-agent-tools-calendarbrings
calendar_calendars,calendar_events,calendar_read,calendar_create,
calendar_updateandcalendar_delete, which name an account
provider.key(caldav.web) or askall— one set of tools whatever kind
of calendar a user connected, and each change a tool of its own so a binding
can make it ask for approval. -
agents:
code_executeruns python in an image with the office libraries.
The default python image is nowghcr.io/mindconnect-ai/code-exec-python:
Python 3.12 with python-pptx, python-docx, openpyxl, matplotlib and pandas, and
themc_officepackage whosepptx_builder,docx_builderandxlsx_builder
build a deck, a Word document or a workbook from a small spec. The office
skills used to carry those generators as text the model had to copy into every
call — tens of kilobytes that crowded a local model's context before the first
slide was written. The tool tells the model what the image carries. It is
published for amd64 and arm64;mindconnect.code-exec.languages=python=python:3.12-slim
goes back to the plain image. -
agents: a connection made by signing in is named after the account. After
"Connect with Microsoft" the card said "Microsoft account", and with two of them
nobody could tell which was which — nor which mailbox a mail would leave from. The
connection is now tried out the moment it arrives, and when the source's test says
whose account it is, the connection takes that name: the address, as a rule. The
toast after signing in says what the test found. AConnectionTestcan carry the
accountit saw; sources that do not say leave the card's name in place. -
agents: a connection can be tried out from the Connections page. A
tool source that declares aConnectionSpecmay offer aConnectionTester
(connectionTester()onToolFactoryandMultiToolProvider); the page
then shows a Test button on each of that provider's rows, runs the test
right after a connection is added or edited — while the person who typed
the password is still looking — and writes the verdict into the Status
column, so a wrong password reads "error — the server refused the account"
instead of every tool call failing the same way. An OAuth token is renewed
before the test, as it would be before a tool call.ToolRegistry
gainedconnectionTesterOf(provider). -
agents: a jar on the classpath declares what it brings, and a namespace can switch it off.
A module that ships tools, agents or a screen was loaded by whatever
ServiceLoaderfound, with no record of what it brought and no way to keep
it out of one namespace. It now carries a manifest,
META-INF/mindconnect/extension.json— id, vendor, version, and under
contributesits tools (as name patterns), agents, menu entries, routes,
decorated ports and more. The host reads every manifest at start and the
new Extensions screen (Install → Extensions) lists them; an admin
switches an extension off for the namespace at hand, and its tools leave
the catalogs and its sidebar entries the menu there. From a brand's own
namespace the decision can be taken for the whole brand, locked against
the namespaces' own say or not;mindconnect.extensions.disabledlets the
operator switch an extension off everywhere. Decisions are stored per
namespace (system/extensions/on files,mc_extension_activationin
Postgres) and per brand (system/extension-brands/,
mc_extension_brand_activation). Menu entries a manifest declares with a
label and href are rendered by the host, into a shipped group or a new
one; the routes it declares are sections of the admin UI — shell, layout
and a 404 where the extension is off — so a jar's own screen needs no
filter of its own; and beside every declared tool pattern and provider
class the screen says whether the classpath actually has it. A worked
example ships with the admin UI app, switched off:mc-extension-demo, a
short adventure with the LLM as game master — a dice tool, an agent, a
decorator around the trace store, a store of its own for scenarios, saved
games and rolls, and two screens; switch it on under Install → Extensions. Problems — two manifests with one id, an unreadable one, two
extensions replacing the same bean — and jars that bring providers without
a manifest are logged and shown;mindconnect.extensions.strict=true
refuses to start on them instead. -
agents: the chat's Files dialog opens, edits and deletes files. A file
opens in place of the tree: text up to 1 MB in an editor with Save, images
scaled to fit, PDFs in the browser's viewer; Office documents and other
binaries are offered as a download. Files and folders can be deleted, a folder
with everything in it, after a confirmation; a directory of the chat itself
never can, and a link is removed without touching what it points to. Behind
it areGET …/files/view,POST …/files/saveandPOST …/files/deleteunder
/admin/api/sessions/{id}, for the session's owner only. Workspaces on a
virtual environment server work the same way;WorkspaceFilesgained
delete(Path). -
agents: a folder in the chat's Files dialog downloads as a zip. Every
folder, each of the chat's directories included, has a download button that
packs everything below it into one zip, instead of fetching file by file. The
zip holds only what the dialog would list, so a link out of the directory
stays out. A folder with more than 10,000 files or more than 1 GB is refused
(413). Behind it isGET /admin/api/sessions/{id}/files/zip?root=…&path=…,
for the session's owner only, like the rest of the dialog. -
agents: A folder's newest thousand messages are kept, and a list or a search answers from there.
mc-mail-indexholds a window per folder somebody looks at — headers only, in a file per user, account and folder — filled on the first look, compared with the provider's top page when older than two minutes, widened when a page below it is read, and written through by every delete, move and read flag. The folder views and a gathered list read from it;mail_listsearches it, all heads at once, and says how far that reached ("searched the newest 1,000 of 3,835, back to 12 March; 2,835 older not searched") —everything=truehas the provider search the whole folder as before. -
agents: mail is a port now, and IMAP comes with it.
mc-mail-core
hasMailStore— folders, paging, search by sender, subject and date,
reading, marking, moving, deleting, sending — and theMailProviderseam a
kind of mailbox plugs into;mc-mail-imapbrings IMAP, POP3 and SMTP, the
Mailbox card on a user's profile and its Test button;mc-agent-tools-mail
brings the tools:mail_folders,mail_list,mail_read,mail_mark_read,
mail_move,mail_delete,mail_send. A call names its mailbox as
provider.key(email.work) or asksall, so one set of tools serves every
mailbox a user has;MailAccountslists what the classpath can open, and a
distribution that adds a provider (Outlook, Gmail) changes no tool, no name
and no argument. Changing is a tool of its own, so an agent binding can make
mail_sendask for approval whilemail_listruns freely. -
agents: A list of mail is now a thing with a name.
mc-mail-viewsbringsMailListView— the interface a folder, all inboxes and what an agent gathered all implement — with aViewState(selection, search, page) that is saved with the view and comes back with it, a file store for the views that are kept, and four tools beside the mail tools:mail_list_add,mail_list_remove,mail_list_show(a chat gathers a list page by page and puts it on the screen without naming a single id) andmail_view_current(what the person is looking at, ticks included). A view says what it is about —account(),folderId(),from()andsession(), the chat that gathered it — so a screen never asks what class it is; a gathered list is read a page at a time and holds up to 5,000 rows. -
agents: What an agent gathers is on the screen at once.
mail_list_addputs the list on the screen with its first call and grows it with every one (an optionaltitlenames it);mail_list_showis only needed to rename it or show another list.mail_list_removewith ids that are not in the list says so instead of ignoring them. -
agents: a namespace now says who shapes it and who works in it. Its
people are two lists of e-mail addresses —adminsandusers— instead of
one flat membership. Admins create and change what the namespace holds,
invite, promote and set its variables; users work in it. The one right an
admin cannot be given is deleting the namespace: that stays with whoever
created it, who is also the one entry that cannot be taken out of the admins.
Because the lists are addresses and not accounts, somebody can be invited
before they have ever signed in — the membership is simply waiting at
their first sign-in, with nothing to send and nothing pending. A name without
an@getsmindconnect.email-domainappended, so a company whose accounts
are all<name>@company.exampleinvites by name. Records written before this
read as they did: their members become users, their creator stays an admin. -
agents: a brand can bring its own namespace.
mindconnect.branding.switch.<brand>.namespacenames the admins its hosts
work under (creator: <address>for a single one); the namespace's id is the
brand's own name unlessidsays otherwise, and its display name is the
brand's title. It is created the first time somebody arrives under one of
that brand's hosts — and never changed from configuration afterwards: who is
in a namespace is its admins' business, not that of a file edited later. -
agents: signing in is no longer the same as being let in.
mindconnect.namespace-adminsnames who shapes the default namespace, and
naming anybody closes it: an account this installation lists nowhere now sees
a page saying so, with the way to sign out, instead of an empty app — and the
API answers 403 rather than falling back into the default namespace. Nobody
is put into a namespace by arriving under a host; an admin invites them.
Whoever is listed somewhere also gets an empty namespace of their own, and
the first sign-in under a brand opens that brand's work. Left unset,
namespace-adminskeeps the default namespace open to every signed-in user,
so a single-user installation and the dev mode are exactly as they were. -
agents: a user can attach an account by signing in at the provider,
not only by typing a password. The second way to come by a
connection:Acquisition.OAuthon aConnectionSpecputs a Connect
button on the card, the browser goes to the provider's consent page and
comes back with a stored connection.OAuthFlowdoes the
authorization-code exchange with PKCE by default and sends a client
secret only where a provider actually has one — an app registration several
installations share cannot carry a secret, so it is a public client proving
possession of a one-time verifier instead. The one-timestateis generated
per attempt, kept on the browser's session and consumed by the callback, so
a callback that does not echo it is refused before the code is redeemed.
OAuthProvidergets a repository (file, Postgres, in-memory) with the
client secret encrypted at rest, and a token is renewed on its way to a
tool — the one place every call passes and exactly when it is worth
renewing. A refresh the provider refuses marks the connectionEXPIREDwith
the reason rather than failing every call the same way, so the profile says
what happened and the tool says to connect it again. Installations that
register no OAuth app are unaffected; the callback lives at
/admin/oauth/callbackand has to be registered with the app. -
agents: OpenAI goes through the Responses API. Configs with provider
OPENAI
now talk to/v1/responsesinstead of/v1/chat/completions— the only endpoint
where gpt-5.6 and later take tools and reasoning together. Reasoning survives tool
rounds (replayed as encrypted items, nothing stored at OpenAI), and its summary
shows up in the chat as the thought. NewadditionalParams.reasoning_summary
(autodefault,concise,detailed,none) — setnoneif OpenAI refuses
summaries to your organization. Other OpenAI-compatible providers and Azure are
unchanged. A config that has to stay on Chat Completions picks the new provider
OPENAI_CHAT_COMPLETIONS. -
agents:
presentation-builder, a sub-agent for PowerPoint decks, bundled
with thepptx-builderskill and callable fromdefault-chat. The chat hands it
a brief — the outline and facts, or the path of a deck to revise — and gets back
the path and the slide titles; the planning, the spec and any failed attempts stay
in the sub-agent's own context. It saves the spec beside the deck as
<name>.spec.json, which is how a later brief changes the deck. New installations
get both; an existing one imports the agent and the skill on start, while its
storeddefault-chatkeeps its roster until you add the agent there. -
agents: Import an entry, or a whole rubric, straight from the registry
list. Every row on a registry's catalog now carries the button that
installs it — Import, or Overwrite for something already here —
instead of only a link to the entry page, and every rubric carries Import
missing (n) for everything of that kind that is not here yet, imported in
one walk so what several of them require is fetched once. The import runs
there and then and the page that comes back is the same list, with its report
above it, the row's new Already here badge, and the search and kind filter
untouched. The entry page keeps everything it had: the warning, the details,
and a package's Contents tab for leaving members out. -
agents: the file tools, the document tools,
bash,process_list,process_killand
code_executecan work on a virtual environment server instead of the agent's machine.
Addmc-agent-tools-virtual-env(the admin UI and API apps ship it) and set
mindconnect.virtual-env.client.url(MC_VIRTUAL_ENV_URLin theserverprofile). Each chat
then gets a workspace of its own there, mounted at/workspacein its container; its uploads
are copied in, the session directory the prompt names is read as/workspace, andbashruns
in the container — so theserverprofile can offer it (MC_TOOLS_DISABLED=). A binding picks
its template with the override{"environment": "office"}. Tools and schemas are unchanged;
tool code reaches the disk through the newWorkspaceFilesport inmc-agent-tool-spi, and a
WorkspaceProviderbean decides where.vector_ingest_filestays on the agent's machine. -
agents: calls to a virtual environment server carry a token signed for the chat's user.
Withmindconnect.virtual-env.client.issuer(MC_VIRTUAL_ENV_ISSUER) every call carries a
short-lived RS256 token for the calling user and namespace, and the agent apps publish the
public key at/.well-known/mc-virtual-env/jwks.json. The key pair exists only in memory and is
new on every start; a server that trusts the issuer tells users apart without any shared secret. -
agents: the embedded runtime is now a core plus installed features, the way
a JacksonObjectMapperis a core plus modules.AgentRuntimeBuilder.of(persistence)
is the smallest runtime that chats — theCoreFeature: LLM, messages, agents, no tools;
install(new ToolsFeature()),install(new WorkflowsFeature().seed("workflows/x.json")), … add what the runtime should have,
andinstallFromClasspath()picks up every feature registered as a service. A feature declares what it depends on and installing it
without that dependency is an error, not an auto-install. Afterbuild()every
bean any feature registered is reachable —runtime.beans().get(LlmChat.class),
runtime.feature(LlmFeature.class)— and a feature of your own registers beans,
decorates others' (the way encryption wraps the config store) and contributes
task and tool advisors. The shipped features live in one Maven module each under
agents/builder/mc-agent-runtime-feature-*. Each domain module gained a
repository factory per backend (AgentRepositoryFactory,MessageRepositoryFactory,
LlmRepositoryFactory,FileStoreFactory,WorkflowRepositoryFactory, withFile…,
InMemory…andPg…implementations), so a custom assembly picks a factory instead
of switching per repository. If you embed the runtime: the optional features
are now what you put on the classpath — addmc-agent-runtime-feature-tools,
-skills,-workflows,-file-uploadto your pom instead of the capability
modules they bring along; a builder without them chats without tools. The
builder'sskill(),skillFromClasspath()andworkflowFromClasspath()moved to
SkillsFeatureandWorkflowsFeature. Theuse…()factories still build
the batteries-included runtime they always did, so nothing changes for a caller
who does not install anything. -
agents: a Files dialog in the chat — next to Working Memory, Traces and
Todos. It lists the session's directories (the working directory, the
additional ones and the session's own) and lets you open their folders, view a
file and download it, so what the agent produced withbashorcode_execute
reaches you again, the way the Workspace dialog did before the workspace tools
were removed. Only the session's owner sees anything, nothing outside those
directories is reachable (..and symbolic links included), and HTML or SVG is
shown as source rather than rendered. -
agents: a session has a type, and the chat lists only chats.
AgentSession.typeis a free word —chatfor a conversation a person
started in the chat, anything else for a session a feature opens for its own
purpose (the Office composer's drafting chat isoffice). The chat's history
and its live list ask forchatonly:AgentSessionRepository.findByUserand
findHeadersByUsertake a type, Postgres keeps it in asession_typecolumn,
andsession_startedon the user stream carriessessionType, which
chat-ui.jschecks before adding a row.AgentSessionService.openChat(agent, user, type)(andopenChatOfType(agentId, user, type)for a registry agent) opens one andsessionsOfType(user, type)finds them again, so a
feature can build its own view of its sessions or tidy them up. Sessions
written before the field — and rows with nosession_type— are chats. -
agents: An agent can keep its own know-how: skills have a group, and four tools write and read them. A
Skillcarries agroup(generalwhen none — in theSKILL.mdfront matter asgroup:, in the admin form and list), so an installation can tell an office assistant's rules from a coder's release checklist.skills_list,skills_get,skills_saveandskills_delete(groupskills, beside theskilltool that loads one) let a chat write a skill into the namespace's store — the person's rules for clearing out their inbox, dictated once — where the admin UI shows it and every agent onALLhas it from its next turn. Only managed skills are written; a skill off disk is edited where it lies. Bindskills_savewith approval where a save should be confirmed. -
agents:
mail_listtakes several senders.from: "InfoQ OR coop.ch"is one search per sender, merged — the same ruletextalready had, because a model writes it that way whatever the description says. -
agents:
mc-agent-starter-runtime— the Spring Boot applications now build
their agent runtime the way the embedded builder does: the core plus installed
features, configured from themindconnect.*properties, with the runtime's beans
exported to the context. The persistence starters supply aPersistence
(and the installation-wide users and API tokens), the namespace starter the
thread-bound scope;DefaultAgentRuntimeConfig,TodoToolsConfigand
MessageRepositoryConfigare gone, and so are the LLM gateway beans the admin
and API apps declared themselves. An application contributesRuntimeFeature
beans (installed, replacing a shipped feature of the same name) and
AgentRuntimeCustomizerbeans, and injectsAgentRuntimeto reach any bean or
feature.mc-agent-runtime-feature-namespaceis the feature behind it: a runtime
that works in the namespace of the call, for any host that binds a scope;
mc-agent-runtime-feature-transcriptionis speech to text as a feature of its
own, installed by the starter, left out by a runtime that never hears audio. Every
domain module's repository factory can build for a namespace, and the tool
environment falls back to the host's beans. -
agents: the server's scope is strict: a thread that touches a store without
a bound namespace fails instead of silently working inmindconnect.namespace.
Requests bind through the namespace filter, tasks through the runtime; start-up
routines (the runtime build, the tool warm-up, the seed loaders, the MCP and
registry seeds) bind the default namespace explicitly. A custom start-up routine
that reads a repository has to do the same (scope.runIn(Scope.of(ns), …)). -
agents: two more features.
SubAgentsFeature(mc-agent-runtime-feature-subagents)
is delegation: an agent's roster yieldsrun_agent/run_agentsonly with it
installed, andmaxDepthbounds the chain (mindconnect.agent.sub-agents.max-depth
in Spring, default 5).TaskQueueFeature(mc-agent-runtime-feature-taskqueue)
configures the queue the turns run on —retention,maintenanceInterval, and
jdbc()for aJdbcTaskStoreshared across nodes on Postgres; in Spring
mindconnect.task-queue.{retention,maintenance-interval,store,node-id,lease},
with the store in memory and finished tasks kept, as before. -
agents: a user attaches their own account to a tool, and may attach
several. What a tool can do is the installation's business; whose mailbox
it does it with is the user's. A tool source declares aConnectionSpec—
a provider key, a title and aSchemafor the form — and implements
ConnectedTool; the registry then hands each call the account of whoever it
runs for.Connection/ConnectionRepository(file, Postgres, in-memory)
/ConnectionServicekeep them per user and installation-wide beside the
API tokens, with the schema deciding what is a secret: aFormat.PASSWORD
field is encrypted at rest and never shown again, everything else stays
readable so a typo can be corrected. The profile has a Connections tab
rendered entirely from the schema — no tool ships a screen — and a missing
connection becomes a notification on the next sign-in. A user with several
accounts gets anaccountparameter whose values are exactly their own
connection keys; with one, nothing appears at all. An agent can pin it
(overrides: {"params": {"account": "arbeit"}}) and so carry the same tool
twice under two names. Nothing changes for a tool that declares no
connection. -
agents: tools can be added by the group, and a group is one entry.
The agent's Tools table has Add a group… beside Add Tool, and the
profile's My tools picker offers the same sets as checkboxes: a whole group
(the five email tools), a subgroup within it (one MCP server), everything
one connection brings (the thirteen Microsoft tools), or several single
tools at once. On an agent a set expands into its tools right there — each
its own row, so Remove takes one out again. In a user's account a set stays
one row: its account, its on/off switch and its approval hold for every
tool in it, and a tool the group gains later is in from the next chat on. -
agents: a tool can say which variables it needs from a user, and the
installation asks them for it. AToolFactoryorMultiToolProvider
returnsuserVariables()— a list ofToolVariables with a title, whether
the tool can work without it and whether its value is a secret — and
ToolRegistry.declaredVariables()aggregates them across everything on the
classpath. On a user's first request of a session the Admin UI writes the
ones that have a sensible default, lists all of them under Your variables
on the profile with a Set action that opens the form ready-named, and
raises a notification for every required one that neither the user, their
namespace nor the process has a value for. Nothing is ever created empty: a
blank user variable would answer the${VAR}lookup and cut off the
namespace and the server behind it. A tool that declares nothing behaves
exactly as before. -
agents: bring your own API key — a
${VAR}placeholder in an LLM config
no longer has to come from the server's environment. On the profile page every
user keeps Your variables (anOPENAI_API_KEYof their own, say), the creator
of a namespace keeps Variables for everyone working there, and a placeholder
takes the user's value first, then the namespace's, then the process
environment; values are encrypted at rest and never shown again. What a user
brought for themselves reaches a config'sapiKeyonly — itsmodel,
baseUrlandnameresolve without anybody's personal variables, so nobody
redirects a shared config's endpoint to a host of their own while the
installation's key still travels with it. A namespace's variables are its
creator's to set, like renaming and deleting it; the default namespace has
none of its own — nobody created it and everyone works there — so a${VAR}
there means your own value, else the server's environment. The lookup itself
is a port now (EnvVarResolverinmc-common, withsystem(),of(map),
chain(…),shared()andmemoized(); the staticEnvVarResolver.resolve(value)
becameresolver.resolve(value)): the gateways take one,
AgentRuntimeBuilder.envVarResolver(…)plugs a source of your own into an
embedded runtime, a runtime feature reads it with
ctx.require(EnvVarResolver.class), and a Spring host may define its own
EnvVarResolverbean. Model listing and the workflow engine'senvvariable
(a run from the admin, a workflow tool in a chat, a vector-store ingestion)
resolve through the same chain; the migration diff stays on the process
environment, so it reads the same for whoever opens it. -
agents: the Admin UI has a notification bell: what is waiting for you,
not what the server is doing.Notification,NotificationRepository(file
and Postgres) andNotificationServicekeep a list per user, installation-wide
beside their API tokens; the bell in the header carries the unread count and
opens the panel, where each notice can carry a link to the place that clears
it. A notice has a key — the condition it stands for — so a check that runs
on every sign-in collapses onto the entry that is already there instead of
piling up, raising nothing again for a condition the user dismissed, and a
condition that goes away takes its notice with it without anybody tidying up.
Anything can contribute one by implementingSetupCheckas a bean; the one
shipped reports the tool variables a user still has to fill in. A host that
assembles noNotificationRepositoryhas no bell and is unaffected. -
agents: what a user's screens remember has a place of its own.
Preferences,PreferenceRepository(file and Postgres,mc_user_preference)
andPreferenceServicekeep one small document per user and scope
(office.email,admin.agents) — the folder last open, the view last chosen,
a column last sorted by. A value is a string; changing one is a merge, and a
write that changes nothing writes nothing, so a screen can store where it is
on every navigation. Scopes, keys and sizes are bounded (64-character names,
100 keys, 4,096 characters a value). Preferences are not the user's variables:
they are not encrypted, not handed to tools and not listed under Variables —
which is what screens storing their state as variables had been doing. A host
that assembles noPreferenceRepositoryhas noPreferenceService, and a
screen that asks for one simply starts where it always did. -
agents: a user can put tools in their own account, and the same tool
twice. The chain of who may say what about a tool ran Source →
Installation → Namespace → Agent and stopped there;UserToolis the step
below it. One record does both things a person wants: a binding for a tool
the agent does not list adds it to their chats, one for a tool it does
changes it for them alone — its name, its description, which of their
connections it runs on, whether it asks first, or whether they want it at
all. Added under a name of their own it becomes a second entry, so
email_privatandemail_arbeitcan sit side by side, one mailbox each;
underneath they are ordinaryAliasToolandPinnedParamsTooloverrides,
the same thing an operator could write into an agent definition by hand —
only derived from their connections instead of typed into a definition
several people share. It reaches the agent they are chatting with and no
sub-agent: a sub-agent's roster was curated for a narrow job. Their
connections do follow them everywhere, because the call scope carries the
user all the way down. Two rules the layer keeps: a name is claimed once,
and an approval is tightened by any layer and relaxed by none — a user
cannot switch on what the installation switched off, nor ask for fewer
questions than their agent asks for.UserToolRepositoryhas file, Postgres
and in-memory adapters; the profile has a My tools tab. A host that
keeps no per-user tools is unaffected. -
workflow:
WorkflowExecutorService.withEnvironment(supplier)— where the
built-inenvvariable comes from; the process environment plus system
properties as before when not set.WorkflowRunServiceand
WorkflowAdminServicetake the same supplier.
Changed
- agents: the chat's "+" counts what the conversation holds, and keeps pictures
and documents apart. The "+" carries the number of attached files; its menu
shows badges on Upload files (the documents), Add images (the pictures), Tools
and Sub-agents. The Upload files dialog lists only documents, the Add images
dialog only pictures. The file count no longer disappears from the menu after a
turn. - agents:
code_executeworks in the chat's directories. Its container's
/workspaceused to be a scratch directory of its own under the data
directory, so a file the code wrote — a chart, a PowerPoint — was out of reach
ofbash, the file tools and the user, and an agent telling you where it saved
it named a path that did not exist. The chat's working directory (its own
directory unless one was chosen) and its additional directories are now
mounted writable under their own host paths, so a path means the same inside
the container and out; the working directory is also/workspaceand the
current directory. Only a session without a working directory keeps a scratch
directory. A chat that changes its directories gets a fresh container on the
next call, with its files but without packages installed in the old one.
The bundleddefault-chatno longer mounts your home directory read-only at
/mnt/hostforcode_execute: the container sees the chat's directories and
nothing else, and its prompt tells the model to save files for you there. The
bundled definition changes for new installations; an existingdefault-chat
keeps its stored tool binding until you edit it.
code_executealso describes itself correctly now: which image each language
runs in and that it carries only the standard library, where files go, that
installed packages go when the container is recreated, and its time and memory
limits. The bundleddefault-chatno longer overrides that description with a
fixed text of its own, which had kept all of it from the model. - agents: tool and thinking cards in the chat are compact again. A run of
cards sits close together in small, muted type instead of a turn's gap and
body-size text per card. Collapsible summaries elsewhere in the admin UI keep
their size. While a turn streamed, a finished card also showed a framed, rounded
box until the turn ended; it no longer does. A thought now carries a marker like a
tool — ⧖ while the model thinks, ✓ once it is done — so its words line up with the
tool names around it, and everything still running (tools, reviewers, sub-agents)
shows the monochrome ⧖ instead of the coloured ⏳ emoji. - agents: an image sent with a message shows in the chat right away. The
bubble a turn shows the moment it is sent now carries the attachment line and
the pictures of the stored message, instead of the text alone until the turn
ended. - agents: a module's sidebar entry can join a shipped group. A contributed
group with the id of one the menu already has —nav-group-data, say — used
to stand beside it as a second group of the same name. It now joins it: its
links follow the shipped ones, and the group opens while one of them is the
current page. - agents: a new message ends a turn that waits for an approval. The
turn used to stay parked forever while the new one ran; now its waiting
calls are closed as "Not approved: superseded by a new message" — no
further model round, so nothing from it lands in the new turn — before the
new message is written. - agents: A mail message now knows where it lies, and a move says where it went.
MailMessage.folderbecameMailMessage.location(account and folder) — no caller has to carry the account beside the message or recover it from amailbox:idstring.MailStore.listanswersFetched<MailMessage>(when and how each row was fetched, for a cache to say so later), andmove/deleteanswer oneOutcomeper id —Movedwith the new location and id (IMAPCOPYUID, Graph),Deletedwith the Undo handle,Gone,Failed— instead ofvoidor a throw for the batch. - agents: the profile page is split into tabs, and shows your namespaces'
variables. Account, Namespaces, Your variables, Namespace variables and API tokens
each have a tab instead of one long page. The new Namespace variables tab lists the
variables of every namespace you created, where you add and remove them — until now
they could only be set on the Namespaces & members screen behind the namespace
switcher. - agents: the admin sidebar is grouped into AI, Tools and Data. The
seven admin entries sat in one flat list. Agents, LLM Configs and Skills
now sit under AI; Tools, MCP Servers and Workflows under Tools;
Vector Stores under Data. A group is open while one of its pages is the
current one, so the selected entry is never folded away. Entries modules
contribute, Install and API keep their places below. - agents: the Admin UI installs its semantic-ui extensions from the asset registry (semantic-ui 0.4.0).
app.jsno longer imports a fixed list (jsonviewer, markdown, diagram); it
callsinstallAll(renderer, bus)from/sui/assets.js, so any jar on the
classpath that declares its scripts and stylesheets in
META-INF/sui/assets.json— a module's calendar or charts, a plugin's
widgets — is on the page from the first render, with no filter or loader
script of its own. The registry's stylesheets are written into the shell's
head ahead of the branding stylesheets, which still win. A host that ships
its ownindex.html/app.jsshould switch toinstallAlltoo. The 0.4.0
update also means an iframe withsandbox("")is now really sandboxed and
RICHTEXT values are sanitised wherever they are rendered. - agents:
ToolApprovalmoved fromai.mindconnect.agent.runtime.service.approval
toai.mindconnect.agent.runtime.domain, next to the newTurnResult. Code that
reads open approvals needs the new import; the JSON is unchanged. - agents: open approval questions are stored behind a port.
ToolApprovalStore
is now the interfaceToolApprovalRepository(ai.mindconnect.agent.runtime.port.out)
withInMemoryToolApprovalRepositoryinmc-agent-runtimeas the default; a runtime
feature that registers its ownToolApprovalRepositoryreplaces it. The runtime
accessorAgentRuntime.approvalStore()is nowtoolApprovals(). Storage is still
in memory only, so an open question does not survive a restart. - agents: the admin UI's pages sit in a centred column, and containers are outlined instead of filled.
Page content is centred next to the menu (at most 1280px wide), so a wide monitor no longer shows a bare
strip on the right. Lists, tables and tab panels draw a hairline border with only their header filled;
the chat and its composer sit on the page ground too. Tables keep their outline wherever they are nested,
and "Register MCP Server" in Tools is a primary button.
Removed
- agents: the
deploy/directory is gone from this repository. The
single-host Compose setup (Caddy, Postgres, Keycloak, the admin UI) was never
part of a build or a release here — it described one installation, named its
hosts and carried its Keycloak realm. It now lives with the rest of that
installation's infrastructure. If you were using it as a starting point, the
last version is in this repository's history
(git show <tag>:deploy/docker-compose.yml); nothing about the application
changed with it.
Fixed
- agents: an approved tool call stays in the chat. Answering an approval
card rebuilt the whole message list, which wiped the card of the tool that had
just started running; it only came back when the turn ended. Now only the
approval card is removed. - agents: the note on an attached file agrees with the system prompt. The
note ahead of your next question still said an upload was only indexed for
search and not on the filesystem, while the system prompt named its path on disk
and said to open it there — the model got two opposite instructions. The note now
names the same path and says to open the file by it with the file and document
tools; only a file without a copy on disk is still pointed atvector_search. - agents: an attached file's tools reach the agent. After
attachFile(or an
upload in the chat) the system note told the model to read the file with
vector_search, but an agent whose definition did not list that tool never got
it, so it could only answer that it had no way to look. A chat's attachments now
bring what reads them —vector_searchfor what was indexed,view_attachment
for an image or a PDF,file_readandfile_listfor a copy on disk — for as
long as the file is attached, whether or not the definition lists them. Nothing
else is granted this way, and what the installation disabled stays disabled. - agents: a stopped turn no longer leaves its tool spinning in the chat. After
Stop — or a turn that failed — the card of the tool or sub-agent that was running
kept showing "running…" until the page was reloaded, and after the reload it was
gone: the calls of a turn without an answer were not drawn once another message
followed. The card now turns failed the moment the turn ends, and the history shows
it, failed, above the next question. - agents: HTML in a conversation no longer breaks the chat. An answer, a
thought, a tool's output or a user message that contained HTML or JSX outside a
code block was rendered as real elements — an unclosed<div>swallowed the rest
of the conversation and the layout fell apart, and markup like<img onerror>
could run script. Such text now shows as text; code blocks and inline code render
as before, and tool output that itself contains a code fence stays inside its
block. The admin UI also tells the markdown renderer itself to show raw HTML as text
(only its own icon markup passes), so no reply can build elements in the page
even where the escaping and the renderer read the markdown differently. - agents: the chat's microphone button turns red while it records. The style
aimed at a class the framework never renders on an icon button, so the button kept
its idle colour and only the placeholder showed the recording, hidden as soon as
the field had text. The rule now matches the composer's mic by its action. - common: a document table in a schema of its own gets its indexes.
DocumentTablenamed an index after its table, schema included
(CREATE INDEX … ext_demo_dungeon.dice_roll_…_idx), which Postgres refuses
as a syntax error — so an extension that keeps its data in its own schema
failed the first time it wrote (the demo's dice answered 500). The index is
now named after the table alone; Postgres puts it in the table's schema. - agents: a route an extension's manifest opens to users is open to them.
contributes.ui.routes[].rolesnamingUSERwas shown on the Extensions
screen but not enforced: the namespace access guard only knew its fixed list
of open paths, so a plain user of the namespace was refused (403) a screen
whose sidebar entry the same manifest showed them. The guard now lets a
member of the namespace through on such a route while the extension is on
there; where routes nest, the most specific one decides. Somebody who is not
in the namespace is refused as before. - agents:
mindconnect.file-store.backendis honoured on Postgres again. A
Postgres installation that kept its uploads on a volume (filesystem) had them put
into the database instead. - agents: a finished response is reported as finished. A turn's events
reach their listener on a thread of their own, so the turn could end before its
final event had been handed over. A caller reading the result at that moment —
a synchronousPOSTto the responses API, an approval answer — now and then got
the response back stillin_progress. The turn's outcome now waits until its
final event has reached the listener. - agents: gpt-5.6 with tools works on
OPENAI_CHAT_COMPLETIONS. From gpt-5.6
on, OpenAI refuses function tools together with reasoning on Chat Completions,
and those models reason by default — every turn of an agent with tools ended in a
"Streaming error" (HTTP 400). A config that stays on Chat Completions now sends
reasoning_effort: noneto these models when tools are offered; a configured
effort still applies to turns without tools. For reasoning and tools together,
use providerOPENAI(the Responses API). - agents: a loaded skill is no longer evicted from the context. With
toolResultEvictionon, a skill's text was replaced by a stub after the user's
next message, and the model reloaded it withfetch_tool_resultstraight away —
paying for the skill twice. - agents: Test connection names the MCP server it could not reach. A url whose
host does not resolve showed onlyjava.nio.channels.UnresolvedAddressException—
no host, no sentence. The result now reads "MCP initialize failed for endpoint
https://…: …" with the cause's name after it. - agents: a deleted namespace stays deleted. Deleting it while a variable or
member change was being saved could bring the record back with its creator and
variables, and switching into it worked again; the deletion now waits for such a
write, and a write that waited for the deletion fails withNo namespace. The task
board no longer re-creates an emptydata/<namespace>/for the finished tasks of a
deleted namespace — they show without agent and owner. And a namespace created
again under a deleted id gets its.mc-partition.lockback, so a second process
on that partition is refused again. - agents: an OAuth client id set after the first start is used. A module's
shipped OAuth registration is stored on the first start, and an operator who set
their own client id (MC_MICROSOFT_CLIENT_ID, or the variable of another module)
only afterwards was ignored for good — every "Connect" still went to Microsoft
with the placeholder id. The operator's client id and secret now go onto the
stored registration on every start; their other edits to it stay. - agents: "Connect with Microsoft" reaches Microsoft. The button was an
API call the page fetched, and a consent page cannot be fetched into the page:
the browser reported the backend as unreachable. It is a real link now and opens
the sign-in in a new tab; the account is on the card there when the provider
sends the browser back. - agents: a cut-off OpenAI response is no longer taken for a finished one. A
Responses stream that ends without its completed event (a proxy closing the
connection) fails the call instead of storing half an answer as final; an answer cut
off atmax_output_tokensin the middle of a tool call reportsLENGTHinstead of
running the call with broken arguments; and GPT models after 5 are treated as
reasoning models. - agents: OpenAI reasoning models work for organizations without reasoning
summaries. The Responses gateway asks for a summary by default, and OpenAI refuses
one to an organization that is not verified — every call failed with HTTP 400 until
reasoning_summary=nonewas set. The call is now repeated without the summary, and
the gateway remembers that for the endpoint. A summary a config asks for explicitly
still fails loudly. - agents: parallel sub-agents no longer corrupt the chat's live cards. Agents
run withrun_agentsreport from several threads at once, and the chat kept its live
cards in structures only one thread may touch — a card could stay "running" for good,
or an update fail inside the stream. Events of a turn are now handled one at a time.
A client that joins a turn after a tool call also no longer sees the thought before
that call twice. - agents: the admin UI and the API server start on Postgres again. With
mindconnect.persistence=postgresthe application stopped at start-up with a
circular reference betweenagentRuntimeandtoolRepository: the runtime asked
the application for a tool repository, and the only one there was the runtime
starter's own export of it. The runtime now looks among the application's beans
only, never among the ones the starter hands out from the runtime itself. - agents: asking for the background processes lists them instead of killing
one. Listing was hidden inprocess_killcalled without a pid, so a model asked
for the session's processes ranps, or calledprocess_killwith a pid and ended
the server. A read-onlyprocess_listtool now lists them;process_killsays it
is for ending one and still lists without a pid. The bundledcoding-assistant
anddefault-chatbindprocess_listfor new installations; an existing agent
keeps its stored bindings until you edit it, and its seed shows as differing. The
serverprofile disablesprocess_listalong withbashandprocess_kill. - agents: a Chat Completions config no longer fails a turn when OpenAI refuses
reasoning_effort.
The gateway only leaves the field out, or sendsnone, for the models it knows OpenAI refuses it
on; gpt-5.4-mini together with function tools was not among them and answered HTTP 400. On such a
400 the gateway now logs a warning and sends the same request once more without the field.
Configs on the providerOPENAI(Responses API) were not affected. - agents: the REST chat stream no longer loses the end of an answer.
POST /api/sessions/{id}/chatclosed its Server-Sent Events stream the moment the
turn finished, while the last text deltas and thedoneframe were still on their
way — a fast final round could reach the client without its ending. The stream now
closes once itsdoneframe has been sent. - agents: the stores use the application's JSON settings again. Sessions,
messages and the other file stores were written with a defaultObjectMapper
instead of the application's — timestamps as numbers rather than ISO strings, and
unknown fields failing a read.AgentRuntimeBuilder.objectMapper(...)now reaches
every feature. - agents: a thought keeps streaming after you come back to the chat. Leaving a
chat while the model was thinking — to the agents page and back — lost the
thinking card: it was not saved yet, so the page could not rebuild it, and the
updates that followed had nowhere to go. A client that attaches mid-turn now gets
the running (or just finished) thought along with the streaming reply. - agents: the chat's Tools badge agrees with the Tools picker. The badge on
the "+" menu's Tools entry counted every tool the chat binds, while the
picker's header counts the tools that are on and have a row. A fresh
default-chatread19on the menu and12 onin the picker: the badge also
counted the tools set to Search and thegmail_*tools a host without Gmail
credentials cannot resolve. Both numbers now come from one count — tools on and
resolvable here — on the chat page and after every redraw of the composer. - agents: a turn after a cancelled one streams into its own cards. Stopping a
turn left its thinking card, tool cards and reply bubble on the page, and the next
turn reused their ids — its thought and its answer streamed into the cancelled
turn's card or bubble while its own stayed empty. Every live card now gets an id no
earlier turn used. - agents: a workflow no longer sees the calling user's own variables. A
workflow'senvheld the whole variable chain, including what the user running the
agent stored for themselves — so a workflow written by one user and called by
another's agent could read that user's API keys. It now gets the shared view, the
namespace's and the server's values, like a config's non-secret fields. - agents: a wrong encryption key no longer deletes users' and namespaces'
variables. A stored value that did not decrypt was left out when the record was
read and then saved back without it — on a user's next login, or when a namespace
was renamed — so starting once with a wrong or rotated
MINDCONNECT_ENCRYPTION_SECRET_KEYdeleted them for good. Unreadable values are
now kept as they are until their name is set again, and read again once the right
key is back.
What's Changed
- feat(agents): users and namespaces bring their own API keys by @beisdog in #101
- feat(agents): import skills from a registry, and read an index with entry types this version does not know by @beisdog in #104
- feat(agents): the embedded runtime is a core plus installed features by @beisdog in #99
- feat(agents): the Spring starters configure the runtime built from features by @beisdog in #100
- feat(agents): sub-agents and the task queue as features, a strict request scope by @beisdog in #102
- feat(agents): a turn that waits for an approval ends INCOMPLETE for its caller by @beisdog in #108
- fix(agents): an attached file's tools reach the agent by @beisdog in #103
- build(demo): drop mc-vector-store and mc-file-store from the simple demo by @beisdog in #106
- feat(agents): a Files dialog for the chat's directories, and code_execute works in them by @beisdog in #107
- refactor(agents): open approval questions are stored behind a port by @beisdog in #109
- fix(agents): code_execute describes itself as it really is by @beisdog in #110
- feat(agents): an office image for code_execute, presentation-builder, and skills that stay in context by @beisdog in #111
- feat(agents): OpenAI goes through the Responses API by @beisdog in #112
- Chat fixes: approvals, thinking after navigation, images, + menu counts; gpt-5.6 on Chat Completions by @beisdog in #113
- fix(agents): a turn's outcome waits until its Done has reached the listener by @beisdog in #114
- Chat: escape HTML in conversations, unified status markers, unique live ids after a cancel by @beisdog in #115
- Manual tests: name the port the server uses (9090), and how to drive the suite from a browser by @beisdog in #116
- fix(agents): the admin UI and the API server start on Postgres again by @beisdog in #119
- Admin UI: profile page in tabs, with the variables of your namespaces by @beisdog in #117
- Security: raw HTML in markdown can no longer run in the admin UI by @beisdog in #118
- Security: a wrong key no longer deletes variables; workflows don't see the caller's own secrets by @beisdog in #120
- Fix: host ObjectMapper reaches the runtime's stores; file-store backend honoured on Postgres by @beisdog in #121
- Fix: OpenAI Responses gateway — refused summaries, cut-off streams, truncated tool calls by @beisdog in #122
- Fix: parallel sub-agents no longer corrupt live chat cards; no duplicate thought for late joiners by @beisdog in #123
- Fix: REST chat stream no longer loses the end of an answer by @beisdog in #124
- Fix: a stopped turn no longer leaves its tool card spinning by @beisdog in #125
- Fix: the chat's microphone button turns red while it records by @beisdog in #126
- Fix: the attach note names an uploaded file's path, as the system prompt does by @beisdog in #127
- Fix: the chat's Tools badge agrees with the Tools picker's on count by @beisdog in #128
- Fix: list background processes with a read-only process_list tool by @beisdog in #129
- Fix: a deleted namespace stays deleted by @beisdog in #132
- chore: one changelog file per change, assembled at release by @beisdog in #130
- Fix: a failed MCP connection test names the endpoint by @beisdog in #133
- Manual tests: skill and namespace cases, suite brought up to date by @beisdog in #131
- feat(agents): the agent's tools can work in a remote workspace by @beisdog in #134
- feat(agents): a folder in the chat's Files dialog downloads as a zip by @beisdog in #136
- fix(agents): retry once without reasoning_effort when OpenAI refuses it by @beisdog in #135
- feat(admin-ui): brand the app from application.yaml by @beisdog in #137
- Fix a race in TaskMonitorTest's namespace board test by @beisdog in #138
- Admin UI: outlined containers in a centred page column by @beisdog in #139
- chore: move the deployment out of the product repo by @beisdog in #140
- feat(agents): the chat's Files dialog opens, edits and deletes files by @beisdog in #141
- feat(admin-ui): brand per host, and keep the feature vendor-neutral by @beisdog in #142
- feat(agents): roles in a namespace, a namespace per brand, and nobody in by default by @beisdog in #143
- feat(agents): import from the registry list, by the row or by the rubric by @beisdog in #144
- Tools can declare the variables they need from a user, and a bell that says so by @beisdog in #145
- Connections: a user attaches their own account to a tool, and may attach several by @beisdog in #146
- My tools: a user keeps tools in their own account, and the same one twice by @beisdog in #147
- OAuth: attach an account by signing in at the provider by @beisdog in #148
- Connections: try an account out from the page by @beisdog in #149
- Tools by the group — and a group is one entry in your account by @beisdog in #150
- An OAuth client id set after the first start is used by @beisdog in #153
- A connection made by signing in is named after the account by @beisdog in #154
- Admin UI: a module adds its sidebar entry and its seeds; connections can be tried out by @beisdog in #155
- A contributed sidebar entry can be a group by @beisdog in #156
- Admin menu contributions and module seeds, from #155 by @beisdog in #157
- Group the admin sidebar into AI, Tools and Data by @beisdog in #158
- A module's sidebar entry can join a shipped group by @beisdog in #159
- Admin UI: install semantic-ui extensions from the asset registry by @beisdog in #160
- Extension manifests, the Extensions screen and a worked example by @beisdog in #162
- Extensions: root build, routes open to users, indexes in an extension's schema by @beisdog in #163
- Office upstream: mail and calendar ports, mail views and index, skill groups, session types, user preferences by @beisdog in #164
Full Changelog: v0.8.2...v0.8.3