* feat(agent): persist human-in-the-loop prompts with a shared broker
Tool approvals and MCP OAuth prompts are now rows in agent_prompts,
awaited through hitl.Broker (lease, DB polling, Redis wake-up, per-kind
answer validation). Resolve is bound to session and kind. This is P1 of
the suspend/resume design; runs still block as before.
* feat(agent): suspend runs whose prompt outlives a short in-memory wait
Behind agent.prompt_suspend_enabled (off by default). A run raised from the
HTTP stream saves its state when a tool approval is raised; after the hot
wait the prompt moves to suspended and the assistant message is saved as
awaiting_input instead of blocking. A reaper takes over prompts whose
waiting replica stopped renewing its lease. Resume comes in a later change.
* feat(agent): resume suspended runs once their prompt is answered
The replica that records the answer resumes the run in process under the
prompt's lease. Superseded, expired and abandoned runs are closed with a
result for every tool call, and approved tools are never replayed.
* feat(agent): let users answer suspended tool approvals and follow the resumed run
* feat(agent): ask_user tool and generic prompt answer endpoint
- ask_user built-in tool: options, short forms or free text; validated
answers, decline, suspend/resume like tool approval; non-interactive
callers (IM, API keys) are told to ask in the reply instead
- POST /agent/prompts/{prompt_id} (and embed variant) answers ask_user
and tool_approval prompts, returns resumed; SDK ResolveAgentPrompt
- agent_prompt_required/resolved events; AskUserCard sharing the
countdown with ToolApprovalCard; answered questions rebuilt as cards
from history
- awaiting-input messages keep their steps expanded so the pending card
stays visible; prompt cards keyed by their own id
- i18n for all locales; design doc updated
* fix(agent): keep prompt answers that race a suspending or vanished owner
- Resolve suspends a pending prompt whose owner's lease lapsed, as the
reaper would, so the answer resumes the run instead of waking nobody.
- Resuming waits for the suspending run to persist its message and clear
its live-run marker; a marker left by a vanished owner is cleared.
- A resumed run that suspends again on a new prompt no longer has its
message closed from the old state.
- tool_approval answers are decoded strictly and require "approved";
fix the SDK doc that showed {"decision": "approve"}.
- API-key runs block instead of suspending, since they cannot answer.
- A run state that cannot be saved falls back to an in-memory wait, and
NUL escapes are stripped from snapshots for jsonb.
* style(chat): align the ask_user card with the other interaction cards
Question and answer use the timeline's step text styles instead of
primary-colored and monospace text; options and form controls use the
compact step size, the number input spans the row, and the free-text
character counter is hidden.
* feat(chat): dock pending agent prompts above the composer
Tool approvals, ask_user questions and MCP OAuth prompts were answered
inline in the agent timeline, where a long answer or scrolling back
pushes them out of view. Open prompts of a streaming or suspended run
now gather in a dock above the composer (main chat and embed), one at a
time with a pager, lettered options and Enter to submit. The timeline
keeps a one-line record with a link back to the dock and the outcome
once answered. Views without a dock still answer inline.
* fix(agent): fence prompt ownership and preserve resumed turn context
* fix(agent): keep runs through consume errors and file prompts under the caller
Consume reported a store error as a lost claim, so an answer consumed
during a database hiccup detached its run: the message was never
persisted, the live-run marker stayed, and the reaper skipped the row
because the waiter had already dropped the snapshot. Consume now retries,
then decides from the row, and gives a run up only when the prompt is
known to have moved on.
Tool approvals and OAuth prompts of a shared agent were filed under the
agent's workspace, so the user's answer failed the tenant check and the
prompt timed out. Like ask_user, they now use the caller's workspace;
policy and token lookups stay in the agent's.
Enter on a picked option submits it instead of toggling it off, and
resume errors no longer report a nil cause.
* fix(agent): validate prompt choices and require durable approval claims
Reject malformed serialized option lists so the model can retry with valid arguments. Distinguish prompt consumption failures from lost ownership without authorizing side effects, and preserve native Enter selection for unselected choices.
* fix(agent): resolve prompt workflow lint errors
|
||
|---|---|---|
| .. | ||
| README.md | ||
| citations.go | ||
| graph_truncation_test.go | ||
| handle_table.go | ||
| handles.go | ||
| image_sources.go | ||
| image_sources_test.go | ||
| leaks.go | ||
| leaks_test.go | ||
| mcp.go | ||
| mcp_sources.go | ||
| mcp_sources_test.go | ||
| mcp_test.go | ||
| model_output.go | ||
| omitted_results_test.go | ||
| registry.go | ||
| registry_test.go | ||
| resources.go | ||
| resources_test.go | ||
| sources.go | ||
| sources_test.go | ||
| stream.go | ||
| tool_policy.go | ||
| tool_policy_test.go | ||
README.md
Model context boundary
modelcontext.Registry is the only application-facing boundary for values
that are shortened before an LLM call and restored afterwards. The whole
codec lives in this one package:
| File | Role |
|---|---|
registry.go |
Registry facade — the only type request lifecycles use |
handle_table.go |
handleTable[M], the generic bidirectional primitive behind every handle space |
sources.go |
source handles (cN/dN/bN/wN) and the tool-argument codec |
citations.go |
protocol prompts, <ref/> → <kb/>/<web/> expansion, citation stream expander |
model_output.go |
compact source-centric renderings of tool results |
resources.go |
durable-resource handles (res://NNNN) |
stream.go |
streamHold suffix-hold primitive and every streaming decoder |
tool_policy.go |
the single policy layer: per-tool key contracts + sourceKeySpaces dispatch |
mcp.go |
MCP bridge routing handles (msN/mtN), definition projection and envelope codec |
mcp_sources.go |
bounded citation sidecar for HTTP(S) links in successful MCP results |
handles.go |
exported HandleTable for invocation-local spaces (iN, ref-N, c000) |
leaks.go |
LeakedIdentifiers report of raw UUIDs that survive EncodeMessages, logged at every model-call site |
Identity rules
- Durable application identities: UUIDs, Wiki slugs, URLs, and
resource://...references. - Request-local model handles:
cN,dN,bN,wN,msN,mtN, andres://NNNN. - Tool-private request handles:
iNfor Wiki issues. - Ingest-call handles:
cNNNandref-N, allocated withHandleTable. - Temporary handles are decoded before tool execution, persistence, or UI delivery. They are never accepted as durable authorization or routing data.
Request lifecycle
- Create one
Registryfor the complete request or Agent execution. - Register structured source identities as they enter the context.
For Agent tools, use
EncodeToolsto project MCP routing enums and source summaries. - Call
EncodeMessagesimmediately before the model call. - Decode tool calls through
DecodeToolCallsbefore parsing or execution. - Decode complete responses with
DecodeResponse, or streaming text with oneStreamDecoderper response channel.
Unknown handle-shaped values in declared tool fields are rejected before tool execution. The same per-tool policy is applied when historical assistant tool calls and tool results are replayed, so handles neither disappear nor drift to new numbers across Agent rounds.
The registry owns codec ordering. Resource references are encoded before
source IDs so a Wiki slug such as summary/<knowledge-id> cannot be corrupted
into summary/d1.
Source addressability is separate from citation eligibility. Use
RegisterContextChunk for bound-KB directory entries. Replayed citations,
legacy tool history, and tool arguments also register navigation handles only.
ModelToolResultForTool and explicitly supplied retrieval results authorize
citations for the current execution; rereading a historical source promotes the
same handle without renumbering it. Both complete and streaming decoders drop
references that have not been backed by current evidence.
Observability
Every model-call site runs LeakedIdentifiers on the encoded messages and
logs a warning naming the role or tool whose text still carries a raw UUID.
A registered leak means the codec missed a rewrite site; an unregistered
leak means a producer emitted an identifier that never entered the registry.
Text-level compaction (CompactKnownText) stays in place as defense in depth
until those producers are fixed and the report stays quiet.
Langfuse generation observations contain the exact encoded payload sent to and
returned by the model. Agent tool spans contain both model_arguments (the
model-emitted handles) and resolved_arguments (the durable values actually
executed), plus argument_resolution and any unresolved handles. Sensitive
tools report only argument keys and resolution counts.
Langfuse is an observer of this boundary; it must not implement another handle mapping.
Built-in tool policies
Canonical ID-bearing arguments for knowledge, graph, data, web, and Wiki tools
are decoded centrally through a tool-name plus JSON-field allowlist. The
sourceKeySpaces table is the single source of truth for which keys are
ID-bearing and which handle space they register into; per-tool sourceIDKeys
contracts gate which of those keys each tool may use.
database_query.sql has an explicit policy because source handles can be
embedded inside quoted SQL values when the model filters the real
knowledges/chunks tables; unquoted SQL aliases and arbitrary prose are
never rewritten. data_analysis.sql carries no handles: the selected document
is always exposed as the fixed table dataset, so only knowledge_id is
decoded. Wiki issue IDs use the same lifecycle
via an iN handle space.
Dynamic MCP tools are intentionally opaque in both arguments and results.
Their schemas and identity semantics are controlled by the MCP server, so the
application must not guess that an arbitrary id, knowledge_id, or url
field is durable or rewrite it. Durable resource handles inside MCP arguments
still use the normal res://NNNN codec. A future MCP ID mapping must be an
explicit server/tool annotation and should plug into this registry rather than
create a parallel mapper.
Successful MCP execution results additionally receive an
external_source_candidates sidecar with up to 50 distinct observed HTTP(S)
links mapped to wN. The external payload is not rewritten, discovery schemas
are not scanned, and article IDs are never used to guess URLs. A candidate link
does not establish that its page was read: the model must select the link whose
associated result supports the claim. When no handle is supplied, the citation
protocol permits an exact supplied source URL as a Markdown link, never a
borrowed knowledge-base citation.
The application-owned MCP bridge is an explicit exception for routing fields:
discover_mcp_tools.server_id uses msN, and call_mcp_tool.tool_ref uses
mtN. Tool definition enums, service summaries, discovery results and replayed
calls share the same request registry. Only directory envelope fields are
registered; input_schema, call_mcp_tool.arguments, and external execution
results remain opaque. Arguments are restored before authorization, validation,
execution, persistence and UI events. Unknown routing handles fail closed.
For model-emitted call_mcp_tool calls, one extra JSON-string encoding of the
arguments envelope is accepted only when it contains a complete JSON object
(including {}). Normalization runs before resource-handle decoding; original
model arguments are retained for tracing. Nested business strings are unchanged,
and malformed JSON, arrays, null, and further encoding layers remain invalid.
The canonical object still passes the existing routing, schema and approval checks.
Wiki routing
WikiRouteResolver is intentionally separate. It stores server-side
slug-to-knowledge-base provenance gathered during Wiki search/read operations,
and can only return knowledge bases already present in the Agent's authorized
Wiki scope. It is routing state, not a model handle table. Reads scan every
legal Wiki KB so cached provenance cannot hide a duplicate slug; mutations
require one unique owner. New pages use link provenance, a single Wiki scope,
or a single source-document owner and reject ambiguous routing instead of
asking the model for a durable KB ID.
Document/tag-constrained Wiki and graph requests are filtered by the same
server-owned SearchTargets provenance. Uncited/global Wiki pages and graph
results outside that subset fail closed; only an explicit whole-KB target
authorizes whole-KB content.