952 Commits

Author	SHA1	Message	Date
yang rui	a333ac3189	feat(search): add Webz news search provider and setup integration (#5880) ... * feat(search): add Webz news search provider and setup integration * fix(webz): honor caller result limits and clarify page counts * fix(frontend): render Webz search source links * fix(frontend): skip malformed search source entries	2026-10-10 18:49:59 +08:00
hataa	47d8ff13b2	feat(authz): account disable/enable across every authentication surface (#4063 gap 3) (#6566) ... * feat(authz): account disable/enable across every authentication surface (#4063 gap 3) Vertical slice 1 of the user-lifecycle work: an operator can suspend an account and every authentication surface rejects it, while the row — credentials, role, OAuth linkage — is retained so re-enabling restores exactly what was suspended. - users.disabled (NOT NULL, server default 0) via migration 0036_user_disabled; User/UserResponse carry and expose it. - Enforcement at all four surfaces: password login (no credential comparison happens), JWT session resolution (401 ACCOUNT_DISABLED — sessions die at the next request), PAT resolution (the generic 401, no oracle), OAuth provisioning (403 with a contact-admin message; the link is kept so re-enable restores access). - SQLiteUserRepository.set_disabled: single-column, serialized write (same idiom as update_system_role) with the last-ACTIVE-admin guard — disabled admins cannot authenticate, so they cannot restore management access; re-enabling is always allowed. Field-scoping completed both ways: the credential writer mirrors and never writes disabled, so a stale password-change snapshot cannot re-enable a suspended account. - PATCH /api/v1/admin/users/{id} becomes a partial account update (system_role and/or disabled), each field routed to its field-scoped writer; empty bodies 422. Tests 11->18: route (disable/re-enable, last-active-admin 409, empty 422, combined update), real-repo (field isolation both directions, disabled-admin-not-active, guard inside the serialized write, re-enable always), login rejection with the CORRECT password (only the disabled gate can reject) plus resolver-visible flag. Mutations verified red: guard removed (M19), login gate removed (M20 — after hardening the test with a real hash so the gate is load-bearing). * fix(authz): portable boolean default, alternate-authenticator suspension, active-admin role guard Review round 1 on #6566 — three P1s: - [PG default] sa.text("0") is a raw integer expression PostgreSQL rejects as a BOOLEAN default, breaking startup migration and fresh create_all bootstraps alike. Both the migration and the ORM model now use sa.false()/false() — dialect-rendered, portable. - [alternate authenticators] WebSockets bypass AuthMiddleware, so a disabled user's still-valid cookie could open a NEW browser/stream connection and drive the retained session; the standalone LangGraph authenticate callback accepted the same suspended JWT. Both now route through a shared post-lookup validator (validate_resolved_session_user in deps.py — token_version + disabled in one place) that the HTTP dependency also uses, so a lifecycle change lands everywhere at once. - [active-admin role guard] update_system_role counted every admin row, so 'disable B, then demote self' — or a combined {system_role, disabled} self-update — could strand the deployment with zero administrators able to authenticate or re-enable anyone. The demotion guard now counts ACTIVE admins only (disabled admins cannot authenticate), under the same serialization boundary. Tests 18->22: shared-validator verdicts, WS admission after suspension (real token, real repo), LangGraph-callback admission after suspension, disable-then-demote-self + combined self-update both rejected (fake-repo route level and real-repo update_system_role level). Mutations verified red: helper's disabled check removed (M21 — three admission tests fail), active-admin predicate reverted to all-admins (M22 — repo-level strand scenario fails). 366 tests green on the affected surface. * fix(migrations): chain 0036_user_disabled after upstream 0037 The maintainer main-merge brought 0037_project_document_summaries, which branched from 0035 independently of this PR's 0036 — alembic now sees two heads and every engine bootstrap fails. Chain 0036 after 0037 (single head; revision numbers are labels, the graph is what matters). * fix(migrations): renumber user_disabled to 0038 and follow the chain-test convention Upstream landed its own 0036 (run_idempotency_request) with 0037 chained after it while this PR was in review — my 0036_user_disabled collided on the number and my interim chain-fix (0036 revises 0037) left the graph in a state upstream's chain tests reject (heads == [0037] hardcoded). - 0036_user_disabled -> 0038_user_disabled, revises 0037_project_document_summaries: single head 0038. - Chain tests follow the repo convention (each migration PR appends the new head): 0032/0035 gain the DOC_SUMMARIES link and CURRENT_HEAD = 0038; 0037's single-head assertion moves to CURRENT_HEAD with its own-revision link check unchanged. * fix(migrations): pin the remaining chain tests to the 0038_user_disabled head The 0027/0028, 0029 and 0034 chain tests still pinned the single head to 0037_project_document_summaries (and 0034 asserted the head's parent was 0036_run_idempotency_request), so the renumbered lifecycle migration broke two unit-test shards. Follow the chain-test convention: every pinned head moves to 0038_user_disabled and 0034 walks the chain through 0037. * fix(authz): enforce account suspension on the internal-auth dispatch surface Round-3 review finding: the internal-auth principal is synthesized from trusted headers without a users-row lookup, so a suspended user with an active channel binding kept driving the agent, and scheduler-owned runs (their fabricated in-process requests skip AuthMiddleware entirely) kept launching. Two gates now enforce the lifecycle there: - AuthMiddleware rejects owner-bound internal calls whose users row is disabled (401 account_disabled) at the single gate every internal HTTP call passes through. Auth-disabled mode is exempt (no suspendable accounts, and its owner header carries the synthetic identity), and owner ids without a users row stay allowed — a nonexistent account cannot be suspended. - start_run re-asserts it at run admission after the owner is resolved for attribution: the scheduler records the rejection as the occurrence's launch error and no run record is created. Also addresses the remaining round-3 nits: drop the inline token_version check duplicated by validate_resolved_session_user, correct the local_provider comment (login never surfaces ACCOUNT_DISABLED), refresh the stale 0038 docstring header, and restore the deps module caches in the two suspension tests instead of leaking a closed engine. * fix(auth): carry the disabled field on the frontend synthetic users UserResponse now always includes disabled, so the auth-disabled contract e2e (gateway /auth/me deep-equals the frontend synthetic user) failed without the field on AUTH_DISABLED_USER. Add disabled to both synthetic users and declare it optional on the zod schema — absent still parses as not disabled for pre-gap-3 backends. * fix(authz): log when the internal-owner suspension check is skipped The middleware gate's users-lookup failure path silently degraded to allow; keep the fail-open behavior but leave a WARNING with the exception, so a store that cannot be read is observable in production logs instead of invisible. --------- Co-authored-by: Willem Jiang <willem.jiang@gmail.com>	2026-10-10 16:43:04 +08:00
stanGSA	f71999d99c	fix(frontend): export complete persisted conversation history (#6530) ... * fix(frontend): export complete persisted conversation history * fix(frontend): preserve canonical export order across runs --------- Co-authored-by: stanGSA <225717802+stanGSA@users.noreply.github.com>	2026-10-10 16:02:05 +08:00
Storm	061a7dfc14	feat(channels): select the model per conversation via /model (#6534) ... * feat(channels): select the model per conversation via /model IM channels could list models with /models but had no way to choose one: the model for a conversation came only from channel/session config or the server default, so a user who needed a stronger or cheaper model for one task had to reconfigure the whole channel or move to the web UI. - /model <name> pins a model to the current conversation, validated against the caller-visible /api/models list (list membership doubles as the authorization check), persisted in thread metadata so it survives a Gateway restart and applies from the next message in place — unlike /agent use, which must start a new conversation. - The pin is written to all three runtime carriers (run context, configurable, context) after the session layers merge, so it wins over channel/session configured models; like any explicitly requested model it also takes precedence over a Custom Agent's configured model. - /model (no args) reports the effective model and its source through one resolver that mirrors the run merge order (default -> channel -> user, context carrier over configurable, both session-config carriers scanned); /model default clears the pin; /models names the pinned model in a footer. - Pin lookups degrade instead of failing messages: the status query reports "Current model: unknown" on a lookup failure (matching the /models footer), and the reuse-thread preload leaves the in-process cache untouched so the next turn retries a transient threads.get. - Reserve "model" in the slash-skill reserved-name contract (backend, contract fixture, frontend), register the Telegram handler, and document the command in /help, README, and README_zh. * fix(channels): fence model pin cache and mirror runtime model resolution Review follow-up for /model: - Serialize cold pin loads with persist+cache publication under a per-manager lock, so a slow threads.get that captured pre-pin metadata can never overwrite a concurrently committed selection (commands are not run-serialized). - _resolve_configured_model_name now replicates the run path's shallow session merges and applies the real runtime precedence — config.context (preserved by build_run_config, unbeatable by the setdefault-filled body context) > top-level context > configurable — instead of scanning per-layer carriers; a later layer replacing a nested carrier wholesale no longer leaks a stale value into the status reply. - /api/models resolves the trusted bound owner for internal channel calls and filters the list with the owner's role, so /model selection gates on the same principal that run admission admits for that account. Tests: pin-write-vs-in-flight-load race, status compared against the real merged runtime config (parametrized across carriers), nested-carrier replacement, and owner-role filtering with the real RBAC provider; each verified red by reverting exactly its guard. * fix(channels): share model resolvers with the run path and harden the pin lifecycle The /model status reply re-implemented the session-layer merge and the Gateway carrier precedence, and it ignored the custom-agent model fallback — on a thread pinned to a custom agent whose config sets ``model:`` it reported "server default" while the run actually used the agent's model. Review also found the pin lock spanned a network call and a stale pin bricked its conversation behind the generic error fallback. - Extract ``_select_carried_model_name`` as the single carrier-precedence rule; the status reply reuses the run path's exact ``_merge_dicts`` layer shapes, so a future layering change has one place to touch. - Extract ``_resolve_message_assistant_id`` / ``_resolve_assistant_id`` and share the assistant precedence chain between the run path and the status reply. - Fall back to the resolved custom agent's configured ``model`` when no session layer carries one, mirroring the agent factory's ``_resolve_model_name(requested or agent_model_name)``; the reply now distinguishes "(from channel configuration)" and "(from agent configuration)". - Run the cold ``threads.get`` in ``_load_thread_model`` outside ``_model_pin_lock``; only cache publication takes the lock, with a post-GET re-check so an in-flight /model write still wins over the older snapshot. - Detect the run-admission allowlist rejection in ``_handle_message`` and recover: clear the stale pin (durable write plus cache under the lock) and reply with the reset and the /model recovery instead of the generic internal-error fallback. - Document /model and the ``channel_model_name`` pin semantics in backend/app/channels/AGENTS.md. * fix(channels): fence stale-pin recovery and cover streaming admission failures Review round 4 found the stale-pin recovery itself unsafe and incomplete: - Recovery cleared whatever pin was current when the delayed admission rejection arrived, so a rejection for an old pin could erase a replacement selection committed mid-flight (and tell the user the new model was unavailable). ``_stale_pin_recovery`` now takes the failed run's own selection (``expected_pin``, read from its run context) and clears only while that selection is still current under the lock; a replaced or already-reset selection gets a non-destructive reply instead. - Feishu/Telegram/DingTalk streaming turns never reached the recovery hook because ``_handle_streaming_chat`` swallows start_run's 400 into its terminal-error reply. The recovery now runs in the streaming terminal-error path too, delivered as the single final outbound with the same dedupe cleanup; blocking, streaming, and fire-and-forget run-creation paths all handle the rejection at the site that knows the submitted selection. * docs(channels): fit the /model entry within the agent-guidance size budget The base file sits one byte under the AGENTS.md hard limit, so documenting /model requires net-zero growth: keep the command-inventory addition and a compact pin-semantics sentence, and losslessly tighten the surrounding prose (the file was already at the limit). * fix(channels): apply the review suggestions on /model replies Three non-blocking findings from the latest review: - The /models pin footer decorated the failure string too, advertising a pin next to an error that lists nothing. The command now fetches the listing through ``_fetch_gateway_json`` and appends the footer only on a successful fetch. - The /model status reply labeled every session-layer model "from channel configuration", misreporting user- and default-layer models. The label is now "session configuration" for every session layer. - Stale-pin recovery replies read as if the turn went through, but the run was rejected before starting and the triggering message never reached the agent. All recovery variants now end with an explicit "Your message was not processed — please send it again." * fix(channels): recover stale model pins on the follow-up drain path The drain is the fourth run-creation path and the only one without stale-pin recovery: a /model pin that left the allowlist while follow-ups were buffered made every drained runs.create fail admission, requeueing the batch into the same 400 on every cycle with no user-facing recovery — contradicting the documented "stale pins self-clear" invariant. - Compute expected_pin from the drain's run context (mirroring _handle_chat_on_thread, initialized None since _resolve_run_params is itself inside the guarded try) and run _stale_pin_recovery on drain failure before requeueing; the pin self-clears and the requeued batch succeeds on the next cycle. - Pass the caller-authoritative thread_id into _stale_pin_recovery: every call site already holds it, so recovery never re-derives it from the message — a store-mapping rewrite between dispatch and recovery can never clear the wrong conversation's pin, and the lookup's failure mode (and its guard) disappears entirely. - Return StalePinRecovery(text, resolved) so requeueing callers can tell a cleared pin from a repeat failure: the drain logs INFO when the next cycle is free of this rejection and WARNING when recovery could not remove it (persist failed, or the selection came from session configuration, which still carries it) — no silent infinite requeue loop. Drain logs carry structured facts only: the reply text ends with a "please resend" note that would double-process buffered messages retried automatically (GitHub, the only buffering channel, sends log-only anyway). - Reword the config-carried recovery reply: with no pin held, the rejected selection came from session configuration — name that source and the fix instead of claiming a default takeover that would not happen. - Correct the _load_thread_model lock docstring (writes deliberately hold _model_pin_lock across threads.update) and read the agent config for /model status off the event loop via asyncio.to_thread, with a Blockbuster-gated blocking_io regression test. - Pin the under-lock re-check in _stale_pin_recovery with a concurrency test (a /model committed during the lock-wait window wins; recovery persists nothing), mutation-verified — the drain is the only caller running on a background task without the serialized-run lock, so it is the path most exposed to that window. * Revert "fix(channels): recover stale model pins on the follow-up drain path" This reverts commit 0b4652c689afb56791e5e670901c97a4bf44a156. The drain recovery work moves to a dedicated PR stacked on this branch, keeping #6534 scoped to the /model feature itself. * fix(channels): recover stale model pins on the follow-up drain path The drain is the fourth run-creation path and the only one without stale-pin recovery: a /model pin that left the allowlist while follow-ups were buffered made every drained runs.create fail admission, requeueing the batch into the same 400 on every cycle with no user-facing recovery — contradicting the documented "stale pins self-clear" invariant. - Compute expected_pin from the drain's run context (mirroring _handle_chat_on_thread, initialized None since _resolve_run_params is itself inside the guarded try) and run _stale_pin_recovery on drain failure before requeueing; the pin self-clears and the requeued batch succeeds on the next cycle. - Pass the caller-authoritative thread_id into _stale_pin_recovery: every call site already holds it, so recovery never re-derives it from the message — a store-mapping rewrite between dispatch and recovery can never clear the wrong conversation's pin, and the lookup's failure mode (and its guard) disappears entirely. - Return StalePinRecovery(text, resolved) so requeueing callers can tell a cleared pin from a repeat failure: the drain logs INFO when the next cycle is free of this rejection and WARNING when recovery could not remove it (persist failed, or the selection came from session configuration, which still carries it) — no silent infinite requeue loop. Drain logs carry structured facts only: the reply text ends with a "please resend" note that would double-process buffered messages retried automatically (GitHub, the only buffering channel, sends log-only anyway). - Reword the config-carried recovery reply: with no pin held, the rejected selection came from session configuration — name that source and the fix instead of claiming a default takeover that would not happen. - Correct the _load_thread_model lock docstring (writes deliberately hold _model_pin_lock across threads.update) and read the agent config for /model status off the event loop via asyncio.to_thread, with a Blockbuster-gated blocking_io regression test. - Pin the under-lock re-check in _stale_pin_recovery with a concurrency test (a /model committed during the lock-wait window wins; recovery persists nothing), mutation-verified — the drain is the only caller running on a background task without the serialized-run lock, so it is the path most exposed to that window. (cherry picked from commit 0b4652c689afb56791e5e670901c97a4bf44a156) * fix(channels): apply the third review round on /model command replies - Delete the dead kind == "models" branch in _fetch_gateway: /models has rendered the listing inline since the pin-footer fix, so the helper's copy was unreachable and had already diverged (unguarded m["name"], no pin footer). The internal-auth-header test now drives the surviving /memory kind. - Guard the inline /models listing comprehension like the _handle_model_command sibling (isinstance(m, Mapping) and isinstance(m.get("name"), str)), so a malformed payload entry can no longer turn the command into the generic internal-error reply; regression: test_models_command_skips_malformed_entries. - Drop the unused user parameter from _resolve_bound_owner_for_model_list: the resolved owner comes solely from the trusted header, and the parameter implied the caller's own principal shaped the filter. * fix(channels): apply the fourth review round on the /model lifecycle - Preserve fresh model pins across cache eviction: a cold threads.get racing a successful /model write could still publish its stale snapshot after clear-on-pressure evicted the fresh entry — the in-cache re-check cannot see an eviction. The model-pin cache now carries a write generation; a load whose generation moved during the GET refetches once instead of publishing over the committed selection. Regression: test_fresh_model_pin_survives_cache_eviction_during_cold_load (blocked GET, write, eviction, then the refetch wins), mutation-verified. - Resolve context-carried agents before reporting their model: /model status now mirrors the run path's effective-agent rule — explicit message/thread choice overwrites every carrier, then the merged carriers' agent_name (new _select_carried_agent_name, sharing the model-name precedence via _select_carried_value), then the session-layer assistant_id that only setdefaults into context. A session with context.agent_name=coder now reports coder-model instead of server default, and assistant_id=writer alongside context.agent_name=coder reports coder-model instead of writer-model. Regressions: context-carried, context-beats-assistant_id, and thread-pin-beats-context status tests. --------- Co-authored-by: Willem Jiang <willem.jiang@gmail.com>	2026-10-10 09:45:17 +08:00
Zeren Wang	553f85e788	feat(projects): best-effort LLM summaries for shelf documents (#6581) ... Opt-in per-document summary column rendered into the injected <documents> index, list_project_documents JSON, and the documents API. Pipeline (projects/summaries.py, behind the narrow enqueue_summary interface): - The two shelf write routes enqueue a job on created=True; dedup hits never regenerate. Off by default (projects.summaries_enabled). - Bounded worker pool (summary_concurrency + bounded summary_queue_size; a full queue drops the job) fed by FIFO; shutdown drains queued jobs, delivers one sentinel per worker via blocking put (queue smaller than the worker pool cannot strand idle workers), and bounds only genuinely in-flight jobs with the grace period. - Jobs carry (document_id, project_id, user_id) explicitly; the job's owner is bound into the user ContextVar around the model call so tracing/usage attribution never falls back to 'default'. - Text source reuses read_text_serving_path (convertible-first rule, content validation); conversion has no deadline (await_drained), the model call has a caller-side wait limit — the worker slot is retained until the provider call actually finishes and late results are discarded. - Output contract: strip leading <think> reasoning -> unwrap fence/ quotes -> collapse to one line -> empty is NULL -> UTF-8 byte cap on a character boundary; length-capped responses (provider-normalized detectors) are failures. - set_summary pins updated_at (literal self-assignment) so a landing summary never reorders the shelf; owner-predicated UPDATE is a no-op on rows purged mid-generation. - Metrics: eligible/success/failed/skipped/queue_dropped/ uncapped_accepted. Schema/config: - project_documents.summary (migration 0036, nullable, no backfill; forward-compat floor unchanged). - Six projects.summary_* keys, all registered in STARTUP_ONLY_FIELDS (captured once at lifespan startup); config_version 57 -> 58. - run_oneshot_llm gains an optional model_overrides passthrough (passed only when set, existing callers unchanged) and a detailed variant exposing the raw response message for termination-signal detection. Docs: API.md response field, ARCHITECTURE.md pipeline paragraph, migrations AGENTS.md chain head, root AGENTS.md records the scoped all-core exception with the lift-out path.	2026-10-10 07:11:02 +08:00
Totoro	0fe6e63a68	feat(goal): show why a chat goal stopped and when it was met, and redact the goal evaluator and continuation input (#6556) ... * feat(goal): record the met goal and keep goal state on the history head - Add a goal_outcome LastValue channel (GoalOutcomeState). Only the guarded clear of a satisfied ordinary goal writes it, in the same checkpoint as the clear; the reply anchor is the latest visible AI message with text, the reply the visible signature keys on. A goal stored without created_at still clears and gets a record. - write_thread_goal removes the record on every other goal write and lists it in channel_versions, new_versions and metadata writes when it changes. Threads that never had a record keep their checkpoint shape. The sync-only SqliteSaver and CachedHistorySaver, which take the #6448 sync fallback, store and drop it the same way. - goal_outcome is server-owned: POST /state and non-internal run input that carry it get 400. A POST /state goal write, or a goal in external run input, clears it. - A branch head written onto its replay base resets the channels the head lacks, so a goal or record that write_thread_goal removed does not come back. Branching from the met turn keeps the record without the met goal. - The POST /history head now carries an active goal and an achieved goal_outcome, also before any message exists, so the post-run history refetch keeps them. Older entries stay title/thread_data. - contracts/thread_goal_contract.json pins the chat stand-down and check-failure codes, the record shape and status, the head keys and the host-written reasons. * feat(frontend): show why a goal stopped and when it was met - The goal bar derives its state from the active goal, the goal_outcome record and the messages: set, in progress, continuing, stopped (limit, auto-continue off, no progress, token budget, missing evidence, failed run, unknown code), waiting for you, waiting, couldn't check the goal, paused and goal met. An 8/8 stand-down now reads "Stopped" with the next step instead of "Continuing 8/8", and a count-0 stand-down no longer looks like a fresh goal. - "Goal met" shows while its anchor reply is the latest visible message (a visible human message, or a visible AI message with text, moves the chat on), so a reload agrees with the live view. An active goal wins over the record, and this tab's /goal set or clear hides it. - useActiveGoal drops the optimistic goal when the record of that same goal arrives, which fixes the bar that stayed after a goal met on the first run (the clear frame has no goal key), also for a goal stored without created_at. Server goal values pass through isGoalState; a /goal status read uses the backend's own active check, so the bar, the toast and the edit lock agree with the server. - Row 2 gives the reason and what to do next; Details holds the full goal, the checker's own note (never host-written text, a check failure or a paused goal's older check), the assumption note and an unknown code, and starts collapsed in each new state. The bar is a labelled section with a live region that announces state changes only (another goal's same state counts) and re-reads its text after a language switch. - The edit pencil on the latest turn is shown disabled with "Editing is off while a goal is set" instead of hidden; the message toolbar shows on focus-within, so keyboard users can reach it. - A /goal set or clear rejected with 409 keeps the draft and says a run is still going; other failures keep the server's message and the draft. A /goal request replaced by a newer one leaves the composer alone, so a double submit no longer empties it before the second one fails. - Copy lives in inputBox.goalBar (en-US, zh-CN); a contract test reads contracts/thread_goal_contract.json, and the raw-identifier guard now catches stand-down codes and goal field names. * test(frontend): cover the goal bar on both chat pages - tests/e2e/goal-status.spec.ts runs every case on the chat page and the agent chat page, since each wires the goal bar and the edit lock itself: a goal stopped at 8/8, one waiting for details and one waiting on an open question card show their reason and next step, also after a reload; the locked edit pencil gets keyboard focus, shows its toolbar and tooltip, does not open the editor, and hides while a file uploads; Goal met after one automatic follow-up (In progress, Continuing 1/8, then "Auto-continued once") survives a reload and hides after the next visible message; a goal met on the first run of a new chat replaces the set bar and frees the pencil, and a new /goal replaces Goal met while its own run goes on; a /goal set or clear refused with 409 keeps the draft for the retry and shows its own busy toast. - The mock POST /history head carries only the contract's history_head_keys, with goal only while active and goal_outcome only when achieved; thread state and run values omit an unset goal instead of sending goal: null. PUT and DELETE /goal drop the met record, setGoalWritesBusy returns the Gateway's 409, and a repeat create of a requested thread id returns the thread as is, like the Gateway. - The raw-identifier guard also catches checker blockers and the met record's field names. - frontend/src/AGENTS.md: the GoalStatus sentence now names goal, goal_outcome and useActiveGoal, reworded in place. * test(frontend): keep the draft through a failed upload and a busy /goal #6412 fires onSent only once a send is dispatched, so a failed upload keeps the text, files and stored draft. A /goal the Gateway refuses with 409 never reaches sendMessage, and the composer rejects it so PromptInput keeps the text. Drive both through the real sendMessage in one composer: a failed upload keeps "summarize it" stored, a busy /goal keeps its text and stored draft with no run, and the retry saves the goal and starts one run with the objective, not the "/goal" text. After that run the composer is empty and no stored draft comes back. * fix(frontend): drop the stop condition's closing period before the pause clause A stored stop condition often ends with a period, so the schedule card read "…remain)., pauses itself" (and "…。，满足后自动暂停" in Chinese). Trim the condition's closing sentence punctuation before the clause that follows it. The event line, where the condition ends the sentence, is unchanged. * fix(frontend): point "evidence missing" at the agent, not a user reply "Evidence missing" asked the user to reply with what's left, which is the push a goal is meant to save. It now asks the agent to show the result or explain what's missing, and offers /goal clear only for a goal that no longer applies: clearing drops the met record, so work that is right would never show "Goal met". zh-CN follows. Copy only: no key, state or mapping changes, and the scheduled page's reason labels are untouched. tests/unit/components/workspace/goal-status-next-steps.test.ts checks the row in en-US and zh-CN, and that no stop row offers /goal clear without that condition. goal-status.dom.test.tsx and goal-stream.dom.test.tsx now expect the new copy. * fix(frontend): say "Couldn't check the goal" once in the goal bar After a goal check that could not run, the bar's second line borrowed the scheduled page's whole reason, so it repeated the chip: "Couldn't check the goal · Couldn't check the goal; the run itself may be fine. It's checked again after your next message." Chinese had the same repeat. The line now gives only why the check failed ("The run itself may be fine", "No final reply was saved" or "The chat changed during the check"), then when it is checked again. The screen-reader announcement follows. The chip and the scheduled page's reason labels are unchanged. tests/unit/components/workspace/goal-status-unchecked.test.ts checks every check-failure code in en-US and zh-CN: the label appears once, and the line still says why the check failed. * feat(goal): redact the evaluator input when pii_redaction is enabled The goal evaluator calls its model directly, outside PiiRedactionMiddleware, so it sent raw user lines, tool arguments, tool results and Human Input Card answers even with pii_redaction enabled. With pii_redaction enabled: - the messages in the evidence window are redacted whole before the evidence caps can cut an identifier in two, as TitleMiddleware does. This reuses redact_queued_messages, which already covers content, call arguments and card answers. Earlier messages are left alone: the evaluator never sees them, and the pass is synchronous work on the event loop (0.84 s for an 800-message, 4 MB thread, 0.06 s for its window); - the assembled input, the goal objective included, is redacted again. A redaction error fails the check with evaluator_failed; raw text is never sent instead. When redaction is off, the input is byte-identical. Thread state keeps the raw text. README.md, config.example.yaml and the middleware docstring list the evaluator with the other redacted inputs. tests/test_goal_pii.py puts an address where the evidence caps cut a tool argument, a tool result and a card answer, and checks the objective, the unchanged input when redaction is off, that only the evidence window reaches the redactor and gives the same evidence as redacting the whole thread, that a redaction error stands down with evaluator_failed before the model is called, and the worker path. * fix(goal): redact the hidden continuation when pii_redaction is enabled The hidden /goal continuation repeats the goal objective and the evaluator's reason and evidence summary. PiiRedactionMiddleware skips it, since it is a framework message and not a user message, so with pii_redaction enabled each continuation turn sent them raw to the agent's model, and the message stayed in the thread for later model calls. The durable-context block and the evaluator input already redact the objective. With pii_redaction enabled, make_goal_continuation_message now redacts the objective, the reason and the evidence summary with redact_text before the message is built. The thread keeps the redacted message, which the UI hides; the goal state keeps the raw objective. The worker builds the message before it counts the continuation. A redaction error fails the check the way an evaluator redaction error does: run_failed with stand_down_reason evaluator_failed, the goal stays active, nothing is sent and the continuation budget is not spent. Only the exception type is stored. With redaction off, the message is byte-identical. README.md, config.example.yaml and the middleware docstring list the continuation with the other redacted inputs. tests/test_goal_continuation_pii.py checks the redacted objective, reason and evidence summary against the tokens redact_text gives, the unchanged message with redaction off or no config, the worker path under the run config, and a redaction error. * docs(changelog): link the goal outcome entries to #6556 Fill the four ([#PR]) placeholders in CHANGELOG.md and CHANGELOG_zh.md with this PR's number and add the matching link references. * fix(frontend): keep an active goal stored without timestamps visible POST /threads/{id}/state and run input can store an active goal without created_at or updated_at. The backend still evaluates it and rejects an edit with 409 (is_active_goal checks only status "active"), but isGoalState required both timestamps, so history and live values dropped it: both chat pages hid the goal bar and unlocked the last-turn pencil, and only a /goal status read, which used a looser predicate, brought them back. isGoalState now accepts any record with a string objective and status "active", and normalizeGoalStatusRead uses it, so thread values, live updates and status reads share one rule. Malformed or inactive values are still dropped. Tests cover a sparse active goal from the history head and from a live update before the post-run refetch (bar shown, hasGoal true), and a malformed goal that stays hidden. * test(goal): check the outcome write metadata the same way on every saver PostgresSaver stores checkpoint metadata through get_serializable_checkpoint_metadata, which drops "writes", so the [postgres] case of test_goal_outcome_round_trips_through_the_sync_fallback failed with KeyError: 'writes' when CI ran it against a live database. The test now records the metadata write_thread_goal passes to put and asserts the clear's and the next goal's "writes" there, for every saver. The stored channel values are checked as before, and on sqlite and cached-sqlite the stored "writes" must still equal what was passed. * docs(agents): keep goal_outcome out of the agents guidance chain The middlewares AGENTS.md chain is already over the 98,304-byte AG002 hard limit on main, and the PR-mode check fails any chain a PR touches, so adding goal_outcome to the ThreadState field list in deerflow/agents/AGENTS.md failed the agent-guidance job. goal_outcome stays documented in runtime/AGENTS.md and backend/app/gateway/AGENTS.md, which are outside that chain. * refactor(goal): read the evaluator's evidence and redaction from one window format_visible_conversation recomputed the window start that the redaction pass takes from _evidence_window. Both now use _evidence_window, so a later change to the cap or to what counts as visible moves both. The window test now fills the window with tool-only replies and tool results. Before, it caught a cap change in one copy but not a change to what counts as visible. --------- Co-authored-by: Totoro-qaq <279883115+Totoro-qaq@users.noreply.github.com> Co-authored-by: Willem Jiang <willem.jiang@gmail.com>	2026-10-10 00:20:45 +08:00
Zhengxu (Joshua) Jin	0c5b25b4ab	docs: stop recommending deerflow-harness extras that do not exist (#6561) ... The Tavily, Exa and Firecrawl tool pages and the AIO sandbox sections tell readers to run `uv add 'deerflow-harness[tavily|exa|firecrawl|aio-sandbox]'`. deerflow-harness has no such extras: tavily-python, exa-py, firecrawl-py and agent-sandbox are core dependencies. uv warns about the unknown extra and still writes it into backend/pyproject.toml. Say that no extra dependency is required, matching the Brave and Serply tabs and the E2B sandbox section.	2026-10-09 18:09:53 +08:00
yu1128-L	5ecc1c2ac2	docs(events): document durable thread seq watermark (#6532) ... * docs(events): document durable thread seq watermark RUN_EVENT_STREAM.md described seq as monotonic but did not cover the durable per-thread high-water mark that keeps allocations monotonic after a run is deleted. Record that behavior in the Record Envelope section, including that thread deletion drops the mark only when no events remain. * test(scheduler): pin clock for scheduled-run timezone assertions --------- Co-authored-by: yu1128-L <296164533+yu1128-L@users.noreply.github.com> Co-authored-by: Willem Jiang <willem.jiang@gmail.com>	2026-10-09 08:10:41 +08:00
dependabot[bot]	47d81d892b	chore(deps): bump next from 16.3.6 to 16.3.8 in /frontend (#6523) ... Bumps [next](https://github.com/vercel/next.js) from 16.3.6 to 16.3.8. - [Release notes](https://github.com/vercel/next.js/releases) - [Commits](https://github.com/vercel/next.js/compare/v16.3.6...v16.3.8) --- updated-dependencies: - dependency-name: next dependency-version: 16.3.8 dependency-type: direct:production ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2026-10-08 23:22:15 +08:00
Nan Gao	4bab280250	fix(skills): share skill cache invalidation across Gateway replicas (#6495) ... * fix(skills): share skill cache invalidation across Gateway replicas SkillStorage.load_skills() rescans disk and re-reads extensions_config.json on every call, but the prompt layer in deerflow/agents/lead_agent/prompt.py caches the enabled-skills list, the per-(app_config, user_id) entries and the rendered <skill_system> section per process, and every skill mutation in routers/skills.py only refreshed the process that handled it. With several uvicorn workers or several Pods sharing one home volume, a skill installed, edited, deleted, rolled back or toggled through replica A kept being offered as the old skill set by replica B until B restarted, and POST /api/skills/reload had to be sent to every Pod separately. Reuse the MCP cache-reset mechanism. A new generic helper, deerflow.config.shared_reset_marker, owns a hidden JSON marker beside the resolved extensions config (.<config name>.<suffix>.json): publish() replaces it atomically with a random generation under extensions_config_write_lock + extensions_config_file_lock, chaining previous_generation and an optional user_id; SharedResetMarkerTracker polls it at most once per second (monotonic clock, never blocking behind a concurrent poller), adopts the current state silently on its first poll, and classifies a change as user-scoped only when exactly one publication carrying that user happened since the last poll. deerflow/mcp/cache.py now builds its .<config>.mcp-cache-reset.json marker through the same helper with no behavior change. prompt.py publishes .<config>.skills-cache-reset.json via publish_skills_cache_reset(user_id=...) and checks the marker on every cache lookup (global cache, per-config cache, prompt-section LRU, user scoped entries), calling _invalidate_enabled_skills_cache() or invalidate_user_skill_cache(). The publishing process remembers its own generation so it does not retire the caches it just rebuilt. Every mutation tail in routers/skills.py (install/upload, edit, delete, rollback, enable/disable, reload) refreshes locally and then publishes the marker off the event loop; /skills/reload answers scope=shared_config, or scope=process when no extensions config path resolves, and a marker publication failure is a 500 so a 200 never means only one process was refreshed. Docs: README, backend/docs/API.md, skills/config/mcp/gateway AGENTS.md, and frontend skills.mdx (en/zh; also fixes the reference to a non-existent skills/loader.py) describe the shared invalidation and drop the per-Pod guidance. CHANGELOG entry under Unreleased / Fixed. * docs(changelog): link the skills cache reset entry to #6495 * fix(skills): drain the reload tail and keep marker failures out of 404 Two review follow-ups on the shared skills cache reset (#6495). POST /skills/reload awaited the local refresh and the marker publication unshielded. CancelledError is a BaseException, so a caller that disconnected between the two slipped past the `except Exception -> 500` mapping, surfaced no error, and left every peer replica serving the old skill set -- the one outcome the operator hook for external mount writes exists to prevent. The refresh and the publication now run as one `await_drained(_drain_skill_mutation("reload", ...))` tail, the same discipline the install/edit/delete/rollback/toggle tails already use; the exception -> 500 mapping and the scope response are unchanged. Publication errors could surface as 404. resolve_shared_config_path() only swallows the resolution-time FileNotFoundError; a config directory that vanishes between resolution and the lock file / atomic replace still raised FileNotFoundError from the marker write, and the install, edit, delete and rollback handlers mapped that to HTTP 404 with the raw OS error text for a skill that had in fact been applied. publish_skills_cache_reset() now re-raises OSError (and a misconfigured project root's ValueError) as SkillCacheResetPublishError, a RuntimeError that no handler maps to 404/400, so every handler reports it through its generic 500 branch; the message names only the exception type, never a server path. The install handler gains an explicit clause that pins that contract beside its 404 mapping. Tests: cancelling reload after the refresh still publishes the marker; a FileNotFoundError from the marker write yields 500 (not 404) for install, edit, delete and rollback, 500 for the public toggle and the generic reload error; the wrapper type is not an OSError.	2026-10-08 19:43:04 +08:00
kuse	69f4093ce9	fix(voice-input): separate transcript segments for providers that trim final results (#6432) ... * fix(voice-input): separate transcript segments for providers that trim final results readSpeechRecognitionTranscript concatenated final and interim transcripts with no separator, relying on providers padding final results with trailing whitespace. WebKit's SpeechRecognition implementation trims them, so the last finalized word glued onto the interim hypothesis ("hello world" + "today is" -> "hello worldtoday is"), both in the live composer and in the submitted message. Join every adjacent segment pair with an explicit space unless either side of the boundary is a no-space script or its punctuation (Han, kana, CJK symbols, full-width forms) — those keep the plain concatenation Chinese and Japanese dictation always had. Korean is treated as a space-delimited script, matching its eojeol spacing. * fix(voice-input): consolidate transcript boundary regressions Port the remaining regression cases from #6449, retaining equivalent English and Hangul fixtures already present in #6432. Attach leading punctuation and percent signs without losing spacing after sentence punctuation, quoted phrases, or combining accents. Pin whitespace-only segments and document the join contract. Co-authored-by: Yufeng He <40085740+he-yufeng@users.noreply.github.com> --------- Co-authored-by: Willem Jiang <willem.jiang@gmail.com> Co-authored-by: Yufeng He <40085740+he-yufeng@users.noreply.github.com>	2026-10-08 09:34:47 +08:00
ZJPex	220d62d79a	feat(memory): add scoped fact lookup by ID (#6443) ... * feat(memory): add scoped fact lookup by ID * docs(memory): synchronize tool-mode lookup guidance * docs(memory): clarify named-agent read capability requirement	2026-10-08 09:25:12 +08:00
Hyeonsang Cho	f0476677de	fix(frontend): keep composer context when an attachment upload fails (#6412) ... * fix(frontend): keep composer context when an attachment upload fails sendMessage called onSent right after the in-flight guard, before any attachment was prepared or uploaded. The composer's onSent drops its one-time state there: quotes, conversation references, staged project files and the stored draft. PromptInput keeps the text and files when the upload rejects, so the user saw the same message and retried it, but the retry went out without that context. onSent now fires once the send is dispatched: after the attachments upload, right before the run is submitted. A failed preparation or upload rejects first, so every caller (the chat composer and the side chat) keeps its state for a retry. Because onSent can now arrive after the composer has moved to another conversation, InputBox checks which conversation it shows. If it changed, onSent leaves that conversation's live state alone and retires only the sending conversation's stored draft and staged files, through a new clearProjectAttachments helper that does not touch mounted state. The chat E2E that held an attachment upload asserted the draft was gone mid-upload, which encoded the old timing. It now asserts the draft stays stored while the upload is pending and is gone, without being rewritten, once the send is dispatched. * docs(changelog): reference #6412 * docs(frontend): note onSent's guarantee ends at dispatch * fix(frontend): retire only what a detached send carried A send whose upload finishes after its composer unmounted still took the live path, because only a conversation switch was detected, and could delete a draft a new composer saved under the same reusable key. A late send also cleared the thread's whole staged list, dropping a document attached during the upload. Track the composer's lifetime instead of its key, and in the detached path clear the stored draft only while it still holds the sent text and retire only the staged entries the send captured. --------- Co-authored-by: Willem Jiang <willem.jiang@gmail.com>	2026-10-07 17:55:15 +08:00
hataa	0032579017	feat(authz): admin role-assignment API for configured custom roles (#4063 gap 2) (#6382) ... * feat(authz): admin role-assignment API for configured custom roles (#4063 gap 2) The RBAC provider accepts arbitrary configured role names (guest, ...), but nothing could assign them to real users: User.system_role was pinned to Literal["admin", "user"] at the API layer while the DB column stayed a plain String(16) for exactly this future, and zhfeng's #3462 audit listed the missing assignment surface as gap 2 — custom roles were declarable in YAML but unreachable for authenticated web users. - User/UserResponse.system_role widens to a non-empty string; whether a role is *assignable* is the admin API's contract, not the model's. - RbacAuthorizationProvider exposes known_roles; the Gateway's new assignable_role_names() unions the built-ins with the provider's configured role names (custom providers: built-ins only). - New admin-only router /api/v1/admin/users: GET lists users with their role; PATCH assigns — role validated against assignable names (an unknown role would silently fall through to default_role on every decision), 404 for missing users, and the last remaining admin cannot be demoted (bootstrap lockout protection). Enforcement is unchanged: the assignment only changes which role the principal carries; the @require_permission route guards and runtime provider decisions remain the single enforcement points. - SQLite repository gains list_users (ordered oldest-first). Tests: router guard/422/404/409/no-op/happy-path, last-admin invariant (both directions), assignable names union, principal carries the configured role; the two old Literal-rejection contract tests updated to the new contract (custom role representable; empty string still rejected). * fix(auth): widen the frontend user schema for custom roles (review-lessons catch) The role-assignment API's review-lessons sweep found the one consumer class the implementation had not enumerated: the FRONTEND parses /me with a strict userSchema whose system_role was z.enum(["admin", "user"]) — a user assigned a provider-configured custom role (guest) would fail userSchema.parse in server.ts and break the auth flow before rendering anything. - types.ts: system_role widens to z.string().min(1), kept in lockstep with the backend model (min_length=1). All existing consumers compare === "admin", so any other value is simply non-admin — no behavior change for admin/user. - server.test.ts: contract tests — custom role parses verbatim; empty string still rejected. - config.example.yaml: the authorization comment now says custom roles become reachable via PATCH /api/v1/admin/users/{id} and that a declared-but-unassigned role grants nothing. * fix(auth): commit the admin_users router, drop the stale type-ignore, document the surface Review catch on #6382: the router module was never staged — app.py and the tests import it, so the pushed branch could not boot (ImportError in create_app). The local tree kept it as an untracked file, which is why every check passed before the push. - Actually commit app/gateway/routers/admin_users.py. - _row_to_user: drop the now-stale '# type: ignore[arg-type]' on system_role — the model field is a plain string now (keep the comma). - README: the authorization paragraph now mentions the admin role-assignment surface (GET/PATCH /api/v1/admin/users, admin-only, last-admin demotion protected, declared-but-unassigned grants nothing). - server.test.ts import-order lint fix from the frontend sweep. * fix(auth): field-scoped role writes close the demotion-undo race Review round 2 on #6382 — three findings, one design: - [P1] update_user copied system_role from the caller's account snapshot, so a password change that read the user as admin could restore a role concurrently revoked by the demotion route (stale-snapshot write-back). Account writes are now field-scoped against each other: update_user is the credential/profile writer (never touches the role, mirrors the row's current role back), update_system_role is the only role writer (single-column, never touches credentials or token_version). - The last-admin lockout check moved inside the role write's serialized transaction: count-then-write across two sessions let two concurrent demotions of the only two admins both pass. Same idiom as create_first_admin — BEGIN IMMEDIATE on SQLite, pg_advisory_xact_lock on a distinct key on Postgres, raise on unknown dialects. - UserNotFoundError from the racing-delete window maps to the route's 404 instead of a 500. Tests 11->12: real-repo regression covering the P1 interleaving (demotion lands -> stale credential snapshot writes -> role stays revoked, credentials applied), field isolation both directions, and the last-admin invariant raised from inside the write with the row intact. Mutation-verified: restoring the role write-back in update_user fails it. * style(auth): format the server auth tests * fix(tests): migrate the personal-MCP demote revocation to update_system_role The role-write field-scoping (66e2cec23) made update_user a credential/profile-only writer, so the demote branch of test_revocation_blocks_discovery... silently no-oped and CI failed on all four shards (assert 2 == 1 — the role never changed). - The demote now goes through update_system_role, the sole role writer. - The fixture gains a second admin: the revocation test demotes its sole synthetic admin, which the new last-admin lockout guard correctly blocks — a second admin keeps the scenario legal without weakening either invariant. --------- Co-authored-by: Willem Jiang <willem.jiang@gmail.com>	2026-10-07 14:59:16 +08:00
Willem Jiang	140857c89e	fix(frontend): upgrade source-map-js to 1.2.2 (#6418) ... Co-authored-by: Willem Jiang <willem.jiang@gmail.com>	2026-10-07 14:36:06 +08:00
Hyeonsang Cho	4217b30e3b	fix(frontend): keep the side-chat draft when a send fails (#6407) ... * fix(frontend): keep the side-chat draft when a send fails PromptInput clears the composer only when onSubmit resolves and keeps it on rejection. The side chat's handleSubmit caught every failure, showed the toast and resolved, so a failed side-chat creation or attachment upload lost the typed text and attachments. The first message to a new side chat was also cleared as soon as it was queued, before the queued effect sent it, so a failure there could not be retried either. handleSubmit now rethrows after its toast, and the queued first send carries the submit's resolve/reject so the composer settles with that send's outcome. The queued effect no longer toasts on its own, so a failed first send shows one error instead of two. * docs(changelog): reference #6407 --------- Co-authored-by: Willem Jiang <willem.jiang@gmail.com>	2026-10-07 14:09:57 +08:00
Totoro	35cdcab1c5	feat(scheduled-tasks): signals, honest notices and fair queueing for server-started runs (RFC #6340, 2/2) (#6393) ... * feat(scheduler): lifecycle rules, goal/limit parity and coded errors for scheduled tasks - Migration 0031: nullable scheduled_tasks.unmet_streak_after_seq (internal streak boundary) and stop_condition (the user's stop rule, own column). - Stop rule is normalized (stop_rule.py) and appended only at launch; the stored prompt never contains it. Wording adapts when scheduler.tool_enabled is off. - Willem 1: page-created tasks get goal evaluation, <standing_notes>, the previous-run reference and own-schedule stop; request_stop and the scheduled capability no longer require an origin conversation. - Repository: single reactivation choke point raising ScheduledTaskLimitsExhausted; streak boundary moves on goal/prompt/stop condition/note changes (not on resume); goal-check failures neither count nor reset the streak; pause of a finished task returns "finished"; trials on a paused task keep the host pause marker. - New repository reads: automatic_runs_used_for, active_run_status_for, list_manageable_from_thread, thread_relation/thread_run on thread tasks, task_ids_for_thread, run_number, and run_number/total_tokens/summary on run history rows. - REST: goal/max_runs/end_at/stop_condition on create and PATCH (null clears, naive end_at = task timezone), resume recomputes from now with an optional renewal body, once_time_passed, task_finished, limits_exhausted, scheduler_not_running on create, trigger returns outcome/existing/thread_id, task responses add automatic_runs_used and active_run_status. - Coded errors {code, message, params} for routes, shared validation and the chat capability (scheduled_task_errors.py), pinned by contracts/scheduled_task_errors_contract.json; goal notes contract v2 with check_failure_codes, scheduled_origin_key and host_run_errors (host_notes.py). - /api/features adds scheduled_tasks {available, running, tool_enabled, min_interval_seconds}; ScheduledTaskService.is_running. - Docs: six README scheduler sections, API.md scheduled tasks section (breaking error shape), CONFIGURATION.md, AGENTS notes, CHANGELOGs. - Tests: migration 0031, stop rule, error contract, run listing, lifecycle over HTTP, repository, service and capability cases; updated tests for the new error shape, finished-task pause and head revision. * feat(scheduler): conversation update/resume, run-conversation authority and readable launches - schedule_task: update and resume actions, stop_condition and clear_fields parameters, plain parameter types (value rules come back as coded results), rewritten docstrings for schedule_task and stop_scheduled_task. - Capability: update/resume share the REST validation and error codes; interactive turns in a task's run conversation may manage that task; scheduled runs keep only own-stop; grants require a running scheduler. - Results: compact JSON-safe task views with local times, display card/text, last run in list, timezone_source/browser_timezone, now_local; no ISO, user, lease or origin fields; stop_instructions removed. - Timezone: explicit > browser (context.client_timezone, validated in start_run and never forwarded to the run config) > not needed for intervals and offset run_at > timezone_required. - Trial gate accepts natural direct requests after acknowledgements and particles; trial results report thread_id and existing. - Scheduled launches: stable message id scheduled-<task_run_id>, server-owned deerflow_scheduled_origin metadata with the user-language parts, run thread title for fresh-thread tasks. - Worker records goal continuations in the verdict; lead prompt language rule covers stored task text and scheduled runs. - Docs: six READMEs, CONFIGURATION, API, runtime/tools AGENTS, CHANGELOGs. * feat(frontend): scheduled-task core types, formatting, errors and glossary - throwGatewayApiError now throws GatewayApiError (status, code, params, rawMessage); message stays the string detail or detail.message - scheduled-task types gain stop_condition, automatic_runs_used, active_run_status, origin/notes, run_number/total_tokens/summary, thread relation, trigger result, renewal and scheduled origin; isTaskBusy and hasActiveRun helpers - api: fetchScheduledTask, resume with optional renewal body, typed trigger result and update payload with null clears - hooks: polling at 3 s while a run is active (list, thread list, run history), useScheduledTask with live gating and final 404, useInView, localized error toasts; run history refreshes tasks when a run finishes - new pure modules: errors.ts (contract code to localized copy), format.ts (relative task times, viewer time, display zone), status.ts, actions.ts, run-error.ts; describeTaskSchedule in cron.ts; goal-outcome adds unchecked goal checks, describeTaskOutcome and parseStopRunId - features: scheduled_tasks block with defaults when missing - buildRunContext sends client_timezone - titleOfThread takes a localized untitled label; breadcrumb names scheduled tasks and agents; reference chips use the localized untitled label - schedule input: shared browserTimeZone, labelled selects, aria-pressed type toggles, interval minimum from the hint template - i18n: all PR1 scheduled-task keys in en-US and zh-CN, glossary fixes, recipe instructions moved into i18n - e2e mocks follow the new task, trigger, resume, thread-task and features shapes; expectNoRawIdentifiers helpers for e2e and DOM tests - tests for errors, format, cron, status, actions, goal outcome, run errors, hooks, run context, thread titles and features; scheduled e2e copy updated * feat(frontend): list-first scheduled tasks page with outcomes and editable goals - page.tsx is now a thin composition of components/workspace/scheduled-tasks: status tabs (All/Active/Paused/Finished) and search over the task list, ?task_id= deep link with router.replace on selection, ?thread_id= chip with Show all, empty state, scheduler-off notice and unavailable state - task list rows show the schedule in words and one status line (next run, running now, paused by agent, auto-paused, finished by its cap) - task detail: status badge, actions from availableActions with reasons, More actions menu (Duplicate, Copy task ID, Delete), outcome notice, Runs / Stops when / Each run's goal / Does / Notes from chat / History, origin chat link; success toasts for every action - run rows: run number or Trial run, summary, goal and assumption badges, continuations, tokens, Open chat link; raw errors and the evaluator reason only behind Details - create/edit/duplicate dialog with goal, stop condition, safety caps and advanced agent/context options; PATCH sends only changed fields, null clears a cap - renew dialog raises or removes caps and resumes in one request; a limits_exhausted Resume opens it - removed i18n keys the old page used; added feedback.resumedNoTime - recorded en-3 and zh-1 page fixtures; scheduled e2e specs rewritten for the new page; DOM tests for the detail and the form dialog - CHANGELOG entries and the frontend AGENTS.md scheduled-task note * feat(frontend): live schedule card, run conversation provenance and header entry - schedule_task results (create, update, pause, resume, trial, delete) become an assistant:scheduled-task message group rendered as a live card: schedule, next run, stop condition with the safety cap, goal, where results go, Run once now, Pause/Resume and Open task; the card polls the task only while it is on screen and shows deleted, scheduler-off and limits-exhausted states - one card per task per assistant turn; the card group is not a turn boundary for usage, branching, editing, outline or skill attribution - a human message with deerflow_scheduled_origin stays a human group with scheduledOrigin and renders as a "Scheduled run / Trial run" block with the task instructions, stop condition and notes collapsed; the launched text is never shown and the message is not editable - readable step labels for schedule_task actions and stop_scheduled_task - ThreadScheduledTasksButton replaces the header link: hidden without tasks, shows the count, links to the task (or the chat filter), and a run's chat links to its task - recorded en-3 / zh-1 chat and run-thread fixtures; chat-card and run-thread e2e specs; unit and DOM tests for parsing, grouping, turn boundaries, card, run block, header button, step labels and reconnect hydration - i18n: header.countLabelOne added, unused card.next removed; CHANGELOG and frontend AGENTS.md notes * fix(scheduler): address verification findings Move the scheduled-task lifecycle guidance from backend/AGENTS.md into the persistence guide and leave a one-line pointer, so the effective AGENTS.md chains for agents/middlewares, sandbox and subagents stay under the 98304-byte hard limit enforced by scripts/check_agent_guidance.py in lint-check. * fix(scheduler): address review findings * fix(gateway): no-transform on SSE responses All four text/event-stream responses (thread run create stream, join, existing-run GET/POST stream, stateless create stream) now take their headers from app/gateway/sse_headers.py and send Cache-Control: no-cache, no-transform, so compressing proxies such as Next's rewrite proxy stop buffering streams. Content-Location and X-Accel-Buffering are unchanged; scheduled and MCP-notification runs keep stream_mode=None. Tests pin the headers on every SSE route and fail on a literal no-cache header left in routers. Docs: API.md SSE headers note, CHANGELOGs. * feat(scheduler): per-owner run cap and fair queue selection New scheduler.max_concurrent_runs_per_user (default 2, 0 = off, effective min(cap, max_concurrent_runs)) caps launching/running scheduled runs per task owner. claim_queued_run checks it right after the global count under the same budget lock, so it is atomic across workers and Pods. list_queued_runs ranks same-thread FIFO heads per owner with ROW_NUMBER() OVER (PARTITION BY owner) and orders the batch by that rank, so the drain is owner-fair even with the cap off; owners at their cap drop out before the batch limit. Orphan rows (task deleted while queued) are never held back by the cap. Gateway lifespan passes the startup value; the service constructor default stays 0. Docs: config.example.yaml (config_version 54), CONFIGURATION.md, the six READMEs, backend AGENTS.md, CHANGELOGs (behavior change flagged). The live-task quota is untouched. * feat(scheduler): durable lifecycle events for the originating chat When a chat-created schedule is paused by the agent, auto-paused or finishes, finalization now reports task_stopped / task_paused / task_finished, only on a live -> paused/finished transition. The new finish_task_at_end_condition replaces the three inline "mark completed" blocks (admission rejected as ended, claim-time skip, complete_if_ended), so every site emits exactly once. The scheduler's finalization observer is always installed. It writes scheduled_task_events rows for the originating chat in the same transaction as the state change, deduplicated on (task_id, anchor, event), with a title snapshot, stop condition, run number, last run outcome and the chat's newest run as placement anchor. Lookups fall back on bad stored data; only database errors propagate. Manual trials drop only run_* events. The IM step keeps PR1's selection until B4. New GET /api/threads/{thread_id}/scheduled-task-events (owner check, caller's rows, oldest first); rows survive task deletion and go with the chat. Migration 0032_activity_and_task_events adds the events table plus the run-origin column/index and read-state tables used later, each object guarded on its own. Contract scheduled_goal_notes v3 pins the lifecycle vocabulary. Docs: API.md, migrations chain, backend AGENTS.md, six READMEs, CHANGELOGs. * feat(scheduler): honest, localized and self-contained IM notices Every scheduled-task IM notice is now enqueued by the finalization observer in the transaction that records the outcome, one message per occurrence (task_stopped > task_paused > task_finished > run_failed > run_unmet > run_completed; a once task sends only its run event). The merged auto-pause replaces the separate unmet + pause messages, agent stops and finishes now notify, and recovery-finalized runs notify exactly once. Idle finishes use a deterministic idle: key derived from the lifecycle anchor. The old non-transactional enqueue in handle_run_completion is removed. New app/channels/capabilities.py holds CHANNEL_CAPABILITIES with a proactive_notifications flag (adds the missing qq entry); only push-capable providers (WeCom) get rows, /api/channels/providers returns the flag, and the worker ends legacy rows for other providers as terminal failed. New app/scheduler/notification_text.py renders en-US/zh-CN text: title, what happened (plus the last run's outcome), the tasks page's one-line run summary (redacted) when the agent replied, and a closing line. No IDs, no links, no public_base_url. Locale is the owner's new `locale` preference, else the new channel_connections.notification_locale (default en-US). Docs: config.example.yaml (config_version 55), CONFIGURATION.md, API.md, channels AGENTS.md, six READMEs, CHANGELOGs (behavior change flagged). * feat(gateway): thread origin, activity feed and read markers for server-created threads Runs started by the server for a user (scheduler, IM channels, GitHub agents, extension handles, MCP notifications) now carry a server-owned metadata.deerflow_origin {kind, provider?, namespace?} (new harness module deerflow.runtime.run_origin, pinned by contracts/thread_origin_contract.json). It is stamped only from request.state.run_origin or by the internal channel caller; run admission drops client copies from both metadata and config.metadata, and thread create/patch strip it. RunRepository derives runs.origin_kind on put and on create_thread_operation_atomic (agent runs only), and gains latest_change(). New ThreadReadRepository keeps a per-user, never-decreasing read position (thread_read_markers) and a per-user read clock (thread_read_versions). POST /api/threads/{id}/read marks a thread read, thread search items carry unread, and thread delete removes the markers. GET /api/thread-activity pages the caller's run changes over the run-change clock, returns only threads changed by server-originated runs plus read_version, and 503s without SQL; /api/features reports thread_activity.available. Docs: API.md, gateway AGENTS.md (condensed to stay under its budget), CHANGELOGs. * fix(scheduler): adapt PR2 to PR1 follow-ups PR1 moved the scheduled-task lifecycle rules out of backend/AGENTS.md into the persistence guide and grew the sandbox AGENTS.md chain to within 267 bytes of its hard limit. The per-owner queue-fairness detail now lives in the persistence guide next to the lifecycle rules (backend/AGENTS.md keeps the cap and a link), so check_agent_guidance passes again. PR1's goal-outcome unit test pinned scheduled_goal_notes_contract version 2; PR2 bumps it to 3 (lifecycle vocabulary only, the v2 keys are unchanged). * fix(scheduled-tasks): polish from live acceptance - zh schedule wording: an interval of one unit reads 每分钟 / 每小时 / 每秒, and a saved interval of whole days reads 每天 / 每 2 天 (Every day / Every 2 days) instead of 每 1 分钟 or 每 24 小时; several units keep the number - zh spacing: 已于{time} 满足 and 在{time} 的运行中 now leave a space between the interpolated time and the Chinese after it; a copy test guards every scheduled-task zh string against a placeholder glued to Chinese - run summary: when the first line of the final reply only leads in to a list (ends with ":" or "："), the list items follow it as plain text (bullets, numbering, checkboxes, bold, code and links stripped), joined with "；" for CJK text and "; " otherwise, within the 160-character cap - a schedule_task result (create, update, pause, resume, trial, delete) that arrives in a chat invalidates that chat's task list, the tasks list and the named task, so the header button and cards update without waiting for the idle poll; results already in the loaded history do not refetch - e2e and unit fixtures are now the live acceptance recordings (DeepSeek Flash, demo data, fictional names): live-weekday.json (create, trial, edit, pause, resume in one zh chat) and live-minute.json (per-minute chat, run 1 and run 2, paused by the agent), fetched with GET from the demo Gateway and trimmed; the hand-shaped en-3 / zh-1 fixtures are removed and the chat-card, run-thread and tasks-page specs run in both locales over the recorded data * docs(changelog): reference #6378 for the scheduled-tasks entries * docs(agents): shorten the scheduled-task pointer to stay under the guidance limit * test(scheduled-tasks): pin the live takes to their recorded time zone The live fixtures were recorded in Asia/Shanghai, and an interval task reads in the viewer's zone, so the 16:48 assertions failed on UTC CI runners. Pin the browser zone in the two live-take e2e specs and the zh live-take unit test. * feat(frontend): thread origin, activity polling, read markers and task events core Frontend core for server-created threads and schedule lifecycle events (PR2 F1); the sidebar markers (F2) and the chat event line (F3) build on it. - core/threads/origin.ts: threadOriginOf reads metadata.deerflow_origin, then channel_source (github -> GitHub origin), then a legacy scheduled_task_id; key and kinds pinned to contracts/thread_origin_contract.json. labelOfThreadOrigin and the now exported labelOfChannelProvider(provider, t) use the new localized threads.origin.providers names (飞书, 企业微信, ...), with the English map (gaining GitHub) only as the fallback. - core/threads/activity.ts: useThreadActivity polls /api/thread-activity every 15 s (focus refetch, never in the background, off unless features.thread_activity.available). The first response only seeds the cursor; server-origin threads, a truncated page or a higher read_version invalidate the thread lists, a scheduled thread also ["scheduled-tasks"]; an invalid cursor re-seeds. useMarkThreadRead debounces POST /read by 1 s, skips a thread whose cached unread is false, patches the search and infinite caches optimistically and stores the returned read_version so a tab's own read does not refetch its lists. AgentThread gains unread. - core/scheduled-tasks/events.ts: ScheduledTaskEvent, the events query (["scheduled-tasks","thread-events",id], one fetch per saved chat, not gated on the task list so a deleted task's lines stay, refetched when a task of the chat changes status or finishes a run), describeTaskEvent (en/zh copy, title and condition as segments, last-run suffix, See that run / Open task) and placeTaskEvents (end of the after_run_id turn, else the tail, ordered by created_at); lifecycle names pinned to contract v3. - features: thread_activity (default unavailable); channels: proactive_notifications on providers. - Locale sync: the I18nProvider reports the UI language and a signed-in preference session saves it as the new `locale` preference when the account's differs (and on every switch), so IM notices follow the UI language; nothing is written with auth disabled. - i18n: threads.* (unread, origin labels, provider names), scheduledTasks.events.*, history.waitingForSlot (now shown for queued run rows), channels.scheduledUpdates.*. - e2e mocks: thread activity feed and controller, POST /read, the events route, providers with proactive_notifications, search unread, features thread_activity (off by default). Preference e2e mocks return the UI locale so they keep asserting only their own edits. - Docs: frontend AGENTS.md, CHANGELOGs. * fix(scheduled-tasks): keep untouched end times and drop a chat filter the new task is not in - The edit, duplicate and renew dialogs keep a stored end time's instant while its field still shows it. A minute-precision wall value cannot keep seconds or name the later 01:30 of a DST fall-back, so a title-only edit moved the cap an hour earlier, and raising the run limit re-sent the end time without its seconds. - Creating or duplicating a task from a chat's task view drops the chat filter when the new task does not belong to that chat, instead of showing "This task isn't one of this chat's tasks". * feat(frontend): origin markers and unread state in the thread lists Server-created threads (PR2 F2) now say who created them and whether they are new, in the sidebar and on the Chats page, and reach an open sidebar without a reload. - ThreadOriginIcon (thread-channel-source.tsx): clock for a scheduled run, the provider mark for IM threads, the GitHub mark (new in ChannelProviderIcon) for GitHub threads, a puzzle piece for extensions; the localized "Scheduled run" / "From Feishu" / "From GitHub" / "From an extension" label is its accessible name and tooltip. ThreadChannelIcon stays exported as a wrapper, and the provider chip tooltip is localized (no more "Feishu channel"). - Unread dot after the title (aria-hidden dot plus sr-only "Unread"); the row aria-label becomes "{title}, unread" / "{title}，未读". Never shown for the open thread. - WorkspaceSidebar mounts useThreadActivity once. - useMarkOpenThreadRead (components/workspace/chats): the default and custom-agent chat pages mark the thread read once its metadata has loaded, when its cached unread flips to true while open, when the tab becomes visible, and from onFinish (a send or a joined run ended). Each trigger goes through useMarkThreadRead, so it is debounced and a no-op while the cached unread is false. - Tests: thread-origin-icon and recent-chat-list DOM tests (en/zh, active row, no raw identifiers), use-mark-open-thread-read DOM tests, e2e thread-activity.spec.ts (new scheduled run appears unread within one fake-clock poll without a reload, opening it posts /read and clears the dot, a read on another device clears it, IM and GitHub markers, zh labels, the Chats page, no polling when unavailable); thread-history.spec.ts now finds the localized origin icon. - Docs: frontend AGENTS.md, CHANGELOGs. * feat(frontend): schedule event line in the originating chat and channel notice support The chat that created a schedule now says when the schedule paused or ended, and the channel cards say which apps receive scheduled task updates (PR2 F3). - ScheduledTaskEventLine (mockup m2, marker 4): a dashed, muted row with the describeTaskEvent text (title in <strong>, stop condition clamped to one line with the full text in its tooltip, last-run suffix), the time via formatTaskTime and a right-aligned "See that run" (run chat) or "Open task" link. PauseCircle for paused, CircleCheck for finished and once-done, CircleX for once-failed. role="note", aria-label "Scheduled task update" / "定时任务通知", data-task-id and data-event-id only. - MessageList takes scheduledTaskEvents and renders placeTaskEvents output through a new VirtualMessageList.renderAfterGroup, so each line sits at the end of its after_run_id turn inside the group's measured row (also when the list virtualizes); lines with nowhere to go render at the tail. - Both chat pages load useThreadScheduledTaskEvents (not gated on the task list, so the lines stay after a task is deleted). The custom-agent page passes its agent so "See that run" opens the run on that agent's route. - ChannelScheduledUpdates: "Scheduled task updates: sent here" / "... not available for this app yet" (定时任务通知：会发送到这里 / 此应用暂不支持) on the Settings provider cards and under each sidebar channel row; nothing when an older backend does not report proactive_notifications. - e2e mock controller: setScheduledTasks. - Tests: scheduled-task-event-line and channel-scheduled-updates DOM tests (every kind in en and zh, hrefs, clamp, no raw identifiers, Chinese title), MessageList placement DOM tests; e2e scheduled-task-chat-events.spec.ts (the line appears with the card's "Paused by agent" without a reload, See that run opens the run chat, anchored vs tail placement, two events in time order, the line survives task deletion and Open task shows the task is gone; en-3 and zh-1) and channels.spec.ts (WeCom sent here, Feishu not yet; en and zh). - Docs: frontend AGENTS.md, CHANGELOGs. * fix(scheduled-tasks): tie pause notices to the pause they describe - Paused by agent links and times only the run named in last_error. When that run is not loaded, the notice shows no link and the task's own time instead of an earlier run that also asked to stop. - The outcome notice reads the latest history page whichever page is shown, so browsing older runs no longer swaps the auto-pause reason and "Open latest run" to an earlier miss. It shares that page's request. * fix(scheduler): address PR2 review findings - Event lines: hold an event whose anchor run is on an unloaded history page instead of placing it at the bottom (hasMoreHistory); tail fallback only for fully loaded (branched/pruned) history or no anchor. - Idle-finish anchor follows its reason: end:<iso> only for an end_at finish, seq:<n> otherwise, so a later end-time finish is not deduplicated away by an earlier max_runs finish. - Observer takes FOR SHARE on the originating threads_meta row, so a racing thread delete cannot leave an orphan event line. - One taskPagePath (core), re-exported by the card. - Notification locales derived from NotificationLocale; /preferences uses it. - IM notices drop generic reasons (goal_not_met_yet, unknown) instead of repeating the sentence. - Localized provider names on Settings cards, sidebar rows and setup dialog. - zh event lines: no space after a Chinese title (Latin-aware gap). - Unread row label keeps the origin marker; chats page keeps the time as a description. - Sidebar shows the scheduled-updates line only for connected apps; Settings says "available after you connect" for unconnected push apps. - Event line keeps a real space before the time. * fix(scheduled-tasks): three lifecycle gaps found while re-checking review classes - The edit form compares a cron in the form its schedule input emits, so an untouched "0 09 * * 0,6" is not re-sent as "0 9 * * 6,0" and a title-only edit no longer re-arms or refuses a finished task. - Chat resume asks for a timezone, as update does, when a naive end_at would land in the UTC placeholder of a zone-free task. - Re-arming a task clears a host pause marker, as resume does, so a later manual pause no longer reads as "Paused by agent". * test(scheduler): consolidate PR2 backend test setup - Fold the repeated task, origin-chat and observer setup of the lifecycle-event repository tests into one lifecycle_task builder. - Build the per-owner-cap services through one _capped_service builder that keeps every cap explicit at the call site. - Table the five SSE route header checks into one parametrized test with the same routes, bodies and Content-Location expectations. - Reuse bind_wecom and hoist repeated local imports in the event tests. Every case and assertion is kept; collected cases are unchanged. * test(frontend): consolidate PR2 thread activity and origin test setup Extract shared builders and helpers in the frontend tests PR2 adds, with every case, input and assertion kept: - activity.test.ts: seededClient/apply helpers and one LIST_KEYS constant replace the per-test seed, spy and apply boilerplate. - mark-read.dom.test.tsx: newClient() and advance() replace the repeated QueryClient wrapper and fake-timer act blocks. - origin.test.ts: the English and Chinese label checks become tables; the no-English-name check now runs on every Chinese row. - thread-activity.spec.ts: a scheduledRun() builder replaces four inline copies of the scheduled run thread. - channels.spec.ts: the PR2 block uses setLocaleCookie and one card helper. Collected cases are unchanged (unit 211, e2e 60); no test was removed. * fix(scheduled-tasks): keep the notice's latest-runs query from refreshing older pages useLatestScheduledTaskRuns kept React Query's default refetch on mount, focus and reconnect, so going offline and back while an older history page was shown fetched the latest page again. Refreshing stays with the history, which refreshes the latest page only while it is shown. * fix(scheduler): two gaps found in live acceptance - A fresh scheduled run thread is named when it launches. The worker copied the title to the thread list only when the run ended, so the sidebar, which now shows the new run thread at once, listed it as untitled while it ran. - A task capped at one run finishes with "its one run is done" / "唯一一次运行已完成" in the chat event line and the IM notice, instead of "all 1 runs are done". * test(scheduled-tasks): let the viewer's time carry its own day label Between 16:00 and 24:00 UTC, UTC and Asia/Shanghai are on different days, so the run prompt shows "Tomorrow 01:00 · Today 09:00 your time" and the fixed "01:00 · 09:00 your time" assertion failed depending on the hour. * test(scheduler): expect the one-run finish copy in service notices * fix(gateway): create a scheduled run thread with its title Pre-setting the name after start_run raced the thread row, which the run worker creates asynchronously: live, one of two run threads still reached the sidebar untitled. Run admission now creates a new thread with the title its run input carries, which the worker would copy only at run end. * docs(changelog): reference #6393 for the scheduled-task signal entries * fix(scheduled-tasks): route event-line run links by the agent that ran them The originating chat's agent was used for "See that run", but a task's agent can change after the chat created it, so the link could open the run chat on another agent's route. Lifecycle events now record run_agent_name, the task's agent when the run finished (edits are refused while a run is active), and the line routes by it. * fix(scheduled-tasks): load up to the route's maximum of chat event lines The chat loads its lifecycle events once, and the route's default of 50 would silently drop the oldest lines of a chat with many schedules. Ask for the maximum, 200. * fix(threads): keep activity reads and the first cursor in step with the lists - Accepting the first activity cursor refreshes the thread lists once. The lists load on their own, possibly before a run the seed already counts, and later polls start after it, so such a thread never appeared. - A local read whose returned read clock jumps past that one read also covers reads on other devices; the lists are refreshed instead of the clock silently skipping those threads' stale unread dots. - An invalid cursor re-seeds through the same path, so it refreshes once. * docs(agents): bring the middlewares guidance chain back under the hard limit #6378 and #6363 each fit the budget, but together the middlewares AGENTS.md chain on main is 98,425 bytes, 121 over the 98,304 hard limit, so Lint Check fails on main. Move the scheduled-task recovery, launch-update and queue-timeout rules from backend/AGENTS.md into the persistence guide's lifecycle section, which backend/AGENTS.md already points to. The chain is now 98,067 bytes. * fix(helm): bump the chart's config_version to 55 config.example.yaml moved to 55 in this PR, so the Helm chart's validate-chart drift check failed. The chart's embedded config needs no field changes: the new scheduler and channel keys have defaults. --------- Co-authored-by: Totoro-qaq <279883115+Totoro-qaq@users.noreply.github.com> Co-authored-by: Willem Jiang <willem.jiang@gmail.com>	2026-10-07 10:22:15 +08:00
Hyeonsang Cho	2e42242888	fix(frontend): retry a failed same-tab reconnect after refresh (#6400) ... * fix(frontend): retry a failed same-tab reconnect after refresh After a refresh the SDK reconnects once from the tab's lg:stream pointer and keeps that pointer when the join fails. Active-run recovery defers to the SDK whenever the pointer matches the active run, and its error handler only scheduled retries for joins it started itself, so a failed reconnect (at connect time or mid-stream) left the tab without a live stream until another refresh. When an SDK reconnect fails, release the pointer and wake the recovery effect, which rejoins the run if the runs read still reports it active, with its existing bounded retries. Runs created by this hook's submit (onCreated) keep their current error handling. The new native-reconnect-recovery test drives the real SDK useStream, so it also pins the SDK behavior this relies on: one reconnect per mount and a pointer that survives a failed join. * docs(changelog): reference #6400 * test(frontend): pin that a released reconnect skips finished runs A run handed to recovery after a failed SDK reconnect was never streamed by this hook, so completedRunIdsRef cannot guard it; only the server-reported status in activeRunId does. Resolve the runs read with each terminal status after the failed reconnect and assert recovery never joins and the pointer stays cleared. --------- Co-authored-by: Willem Jiang <willem.jiang@gmail.com>	2026-10-07 09:53:22 +08:00
Nan Gao	4f64ca2ae0	fix(config): revalidate the extensions config singleton by file signature (#6386) ... * fix(config): revalidate the extensions config singleton by file signature `get_extensions_config()` parsed `extensions_config.json` once per process and only the process that handled a write ever reloaded it. With several uvicorn workers, or several Pods sharing one volume, every other process kept its startup copy: the MCP servers the agent could use and the local-bash absolute path allowlist derived from the filesystem MCP server differed between replicas until each one restarted. The singleton now records the resolved path and the file's (mtime, size, sha256) signature and reloads when either changes, like `get_app_config()` does for `config.yaml` and `mcp/cache.py` does for the tools cache. After a successful load, a revision that cannot be loaded (file gone, truncated, invalid) keeps the last-known-good configuration and is logged once with the exception type only; the first load still raises. `set_extensions_config()` pins the injected instance until a reload or reset. The cached AppConfig's `extensions` snapshot is built from the singleton instance and refreshes when that instance changes, so it inherits the same fail-soft policy instead of parsing the file again. * docs(changelog): link the extensions config freshness entry to #6386 * fix(config): follow an explicitly reloaded extensions config path `reload_extensions_config(config_path=X)` recorded X, but the freshness probe re-resolved the default path, so the next read either flipped the cache back to the default file or pinned a stale copy of X. The cache now remembers the explicit path and both the probe and later reloads follow it until a reset or an argument-less reload. Also shortens the pointer in backend/AGENTS.md so the nested guidance chains stay under the hard size limit enforced by the agent-guidance check. * docs: keep backend guidance within the inherited size budget * fix(config): reload the probed extensions config path --------- Co-authored-by: Willem Jiang <willem.jiang@gmail.com>	2026-10-07 09:39:26 +08:00
dependabot[bot]	7d600e20b7	chore(deps): bump next from 16.3.3 to 16.3.6 in /frontend (#6402) ... Bumps [next](https://github.com/vercel/next.js) from 16.3.3 to 16.3.6. - [Release notes](https://github.com/vercel/next.js/releases) - [Commits](https://github.com/vercel/next.js/compare/v16.3.3...v16.3.6) --- updated-dependencies: - dependency-name: next dependency-version: 16.3.6 dependency-type: direct:production ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2026-10-07 09:36:52 +08:00
Totoro	2dd2e5415c	feat(scheduled-tasks): finish the user-facing side of conversation schedules (RFC #6340, 1/2) (#6378) ... * feat(scheduler): lifecycle rules, goal/limit parity and coded errors for scheduled tasks - Migration 0031: nullable scheduled_tasks.unmet_streak_after_seq (internal streak boundary) and stop_condition (the user's stop rule, own column). - Stop rule is normalized (stop_rule.py) and appended only at launch; the stored prompt never contains it. Wording adapts when scheduler.tool_enabled is off. - Willem 1: page-created tasks get goal evaluation, <standing_notes>, the previous-run reference and own-schedule stop; request_stop and the scheduled capability no longer require an origin conversation. - Repository: single reactivation choke point raising ScheduledTaskLimitsExhausted; streak boundary moves on goal/prompt/stop condition/note changes (not on resume); goal-check failures neither count nor reset the streak; pause of a finished task returns "finished"; trials on a paused task keep the host pause marker. - New repository reads: automatic_runs_used_for, active_run_status_for, list_manageable_from_thread, thread_relation/thread_run on thread tasks, task_ids_for_thread, run_number, and run_number/total_tokens/summary on run history rows. - REST: goal/max_runs/end_at/stop_condition on create and PATCH (null clears, naive end_at = task timezone), resume recomputes from now with an optional renewal body, once_time_passed, task_finished, limits_exhausted, scheduler_not_running on create, trigger returns outcome/existing/thread_id, task responses add automatic_runs_used and active_run_status. - Coded errors {code, message, params} for routes, shared validation and the chat capability (scheduled_task_errors.py), pinned by contracts/scheduled_task_errors_contract.json; goal notes contract v2 with check_failure_codes, scheduled_origin_key and host_run_errors (host_notes.py). - /api/features adds scheduled_tasks {available, running, tool_enabled, min_interval_seconds}; ScheduledTaskService.is_running. - Docs: six README scheduler sections, API.md scheduled tasks section (breaking error shape), CONFIGURATION.md, AGENTS notes, CHANGELOGs. - Tests: migration 0031, stop rule, error contract, run listing, lifecycle over HTTP, repository, service and capability cases; updated tests for the new error shape, finished-task pause and head revision. * feat(scheduler): conversation update/resume, run-conversation authority and readable launches - schedule_task: update and resume actions, stop_condition and clear_fields parameters, plain parameter types (value rules come back as coded results), rewritten docstrings for schedule_task and stop_scheduled_task. - Capability: update/resume share the REST validation and error codes; interactive turns in a task's run conversation may manage that task; scheduled runs keep only own-stop; grants require a running scheduler. - Results: compact JSON-safe task views with local times, display card/text, last run in list, timezone_source/browser_timezone, now_local; no ISO, user, lease or origin fields; stop_instructions removed. - Timezone: explicit > browser (context.client_timezone, validated in start_run and never forwarded to the run config) > not needed for intervals and offset run_at > timezone_required. - Trial gate accepts natural direct requests after acknowledgements and particles; trial results report thread_id and existing. - Scheduled launches: stable message id scheduled-<task_run_id>, server-owned deerflow_scheduled_origin metadata with the user-language parts, run thread title for fresh-thread tasks. - Worker records goal continuations in the verdict; lead prompt language rule covers stored task text and scheduled runs. - Docs: six READMEs, CONFIGURATION, API, runtime/tools AGENTS, CHANGELOGs. * feat(frontend): scheduled-task core types, formatting, errors and glossary - throwGatewayApiError now throws GatewayApiError (status, code, params, rawMessage); message stays the string detail or detail.message - scheduled-task types gain stop_condition, automatic_runs_used, active_run_status, origin/notes, run_number/total_tokens/summary, thread relation, trigger result, renewal and scheduled origin; isTaskBusy and hasActiveRun helpers - api: fetchScheduledTask, resume with optional renewal body, typed trigger result and update payload with null clears - hooks: polling at 3 s while a run is active (list, thread list, run history), useScheduledTask with live gating and final 404, useInView, localized error toasts; run history refreshes tasks when a run finishes - new pure modules: errors.ts (contract code to localized copy), format.ts (relative task times, viewer time, display zone), status.ts, actions.ts, run-error.ts; describeTaskSchedule in cron.ts; goal-outcome adds unchecked goal checks, describeTaskOutcome and parseStopRunId - features: scheduled_tasks block with defaults when missing - buildRunContext sends client_timezone - titleOfThread takes a localized untitled label; breadcrumb names scheduled tasks and agents; reference chips use the localized untitled label - schedule input: shared browserTimeZone, labelled selects, aria-pressed type toggles, interval minimum from the hint template - i18n: all PR1 scheduled-task keys in en-US and zh-CN, glossary fixes, recipe instructions moved into i18n - e2e mocks follow the new task, trigger, resume, thread-task and features shapes; expectNoRawIdentifiers helpers for e2e and DOM tests - tests for errors, format, cron, status, actions, goal outcome, run errors, hooks, run context, thread titles and features; scheduled e2e copy updated * feat(frontend): list-first scheduled tasks page with outcomes and editable goals - page.tsx is now a thin composition of components/workspace/scheduled-tasks: status tabs (All/Active/Paused/Finished) and search over the task list, ?task_id= deep link with router.replace on selection, ?thread_id= chip with Show all, empty state, scheduler-off notice and unavailable state - task list rows show the schedule in words and one status line (next run, running now, paused by agent, auto-paused, finished by its cap) - task detail: status badge, actions from availableActions with reasons, More actions menu (Duplicate, Copy task ID, Delete), outcome notice, Runs / Stops when / Each run's goal / Does / Notes from chat / History, origin chat link; success toasts for every action - run rows: run number or Trial run, summary, goal and assumption badges, continuations, tokens, Open chat link; raw errors and the evaluator reason only behind Details - create/edit/duplicate dialog with goal, stop condition, safety caps and advanced agent/context options; PATCH sends only changed fields, null clears a cap - renew dialog raises or removes caps and resumes in one request; a limits_exhausted Resume opens it - removed i18n keys the old page used; added feedback.resumedNoTime - recorded en-3 and zh-1 page fixtures; scheduled e2e specs rewritten for the new page; DOM tests for the detail and the form dialog - CHANGELOG entries and the frontend AGENTS.md scheduled-task note * feat(frontend): live schedule card, run conversation provenance and header entry - schedule_task results (create, update, pause, resume, trial, delete) become an assistant:scheduled-task message group rendered as a live card: schedule, next run, stop condition with the safety cap, goal, where results go, Run once now, Pause/Resume and Open task; the card polls the task only while it is on screen and shows deleted, scheduler-off and limits-exhausted states - one card per task per assistant turn; the card group is not a turn boundary for usage, branching, editing, outline or skill attribution - a human message with deerflow_scheduled_origin stays a human group with scheduledOrigin and renders as a "Scheduled run / Trial run" block with the task instructions, stop condition and notes collapsed; the launched text is never shown and the message is not editable - readable step labels for schedule_task actions and stop_scheduled_task - ThreadScheduledTasksButton replaces the header link: hidden without tasks, shows the count, links to the task (or the chat filter), and a run's chat links to its task - recorded en-3 / zh-1 chat and run-thread fixtures; chat-card and run-thread e2e specs; unit and DOM tests for parsing, grouping, turn boundaries, card, run block, header button, step labels and reconnect hydration - i18n: header.countLabelOne added, unused card.next removed; CHANGELOG and frontend AGENTS.md notes * fix(scheduler): address verification findings Move the scheduled-task lifecycle guidance from backend/AGENTS.md into the persistence guide and leave a one-line pointer, so the effective AGENTS.md chains for agents/middlewares, sandbox and subagents stay under the 98304-byte hard limit enforced by scripts/check_agent_guidance.py in lint-check. * fix(scheduler): address review findings * fix(scheduled-tasks): polish from live acceptance - zh schedule wording: an interval of one unit reads 每分钟 / 每小时 / 每秒, and a saved interval of whole days reads 每天 / 每 2 天 (Every day / Every 2 days) instead of 每 1 分钟 or 每 24 小时; several units keep the number - zh spacing: 已于{time} 满足 and 在{time} 的运行中 now leave a space between the interpolated time and the Chinese after it; a copy test guards every scheduled-task zh string against a placeholder glued to Chinese - run summary: when the first line of the final reply only leads in to a list (ends with ":" or "："), the list items follow it as plain text (bullets, numbering, checkboxes, bold, code and links stripped), joined with "；" for CJK text and "; " otherwise, within the 160-character cap - a schedule_task result (create, update, pause, resume, trial, delete) that arrives in a chat invalidates that chat's task list, the tasks list and the named task, so the header button and cards update without waiting for the idle poll; results already in the loaded history do not refetch - e2e and unit fixtures are now the live acceptance recordings (DeepSeek Flash, demo data, fictional names): live-weekday.json (create, trial, edit, pause, resume in one zh chat) and live-minute.json (per-minute chat, run 1 and run 2, paused by the agent), fetched with GET from the demo Gateway and trimmed; the hand-shaped en-3 / zh-1 fixtures are removed and the chat-card, run-thread and tasks-page specs run in both locales over the recorded data * docs(changelog): reference #6378 for the scheduled-tasks entries * docs(agents): shorten the scheduled-task pointer to stay under the guidance limit * test(scheduled-tasks): pin the live takes to their recorded time zone The live fixtures were recorded in Asia/Shanghai, and an interval task reads in the viewer's zone, so the 16:48 assertions failed on UTC CI runners. Pin the browser zone in the two live-take e2e specs and the zh live-take unit test. * fix(scheduled-tasks): keep untouched end times and drop a chat filter the new task is not in - The edit, duplicate and renew dialogs keep a stored end time's instant while its field still shows it. A minute-precision wall value cannot keep seconds or name the later 01:30 of a DST fall-back, so a title-only edit moved the cap an hour earlier, and raising the run limit re-sent the end time without its seconds. - Creating or duplicating a task from a chat's task view drops the chat filter when the new task does not belong to that chat, instead of showing "This task isn't one of this chat's tasks". * fix(scheduled-tasks): tie pause notices to the pause they describe - Paused by agent links and times only the run named in last_error. When that run is not loaded, the notice shows no link and the task's own time instead of an earlier run that also asked to stop. - The outcome notice reads the latest history page whichever page is shown, so browsing older runs no longer swaps the auto-pause reason and "Open latest run" to an earlier miss. It shares that page's request. * fix(scheduled-tasks): three lifecycle gaps found while re-checking review classes - The edit form compares a cron in the form its schedule input emits, so an untouched "0 09 * * 0,6" is not re-sent as "0 9 * * 6,0" and a title-only edit no longer re-arms or refuses a finished task. - Chat resume asks for a timezone, as update does, when a naive end_at would land in the UTC placeholder of a zone-free task. - Re-arming a task clears a host pause marker, as resume does, so a later manual pause no longer reads as "Paused by agent". * fix(scheduled-tasks): keep the notice's latest-runs query from refreshing older pages useLatestScheduledTaskRuns kept React Query's default refetch on mount, focus and reconnect, so going offline and back while an older history page was shown fetched the latest page again. Refreshing stays with the history, which refreshes the latest page only while it is shown. * test(scheduled-tasks): let the viewer's time carry its own day label Between 16:00 and 24:00 UTC, UTC and Asia/Shanghai are on different days, so the run prompt shows "Tomorrow 01:00 · Today 09:00 your time" and the fixed "01:00 · 09:00 your time" assertion failed depending on the hour. --------- Co-authored-by: Totoro-qaq <279883115+Totoro-qaq@users.noreply.github.com> Co-authored-by: Willem Jiang <willem.jiang@gmail.com>	2026-10-07 07:47:32 +08:00
PeaceMaker-best	77df35baa8	fix(frontend): keep recovered run cancellation target (#6075) ... * fix(frontend): keep recovered run cancellation target Signed-off-by: PeaceMaker-best <221849497+PeaceMaker-best@users.noreply.github.com> * docs(frontend): explain recovered stream error metadata contract --------- Signed-off-by: PeaceMaker-best <221849497+PeaceMaker-best@users.noreply.github.com> Co-authored-by: PeaceMaker-best <221849497+PeaceMaker-best@users.noreply.github.com> Co-authored-by: Willem Jiang <willem.jiang@gmail.com>	2026-10-06 11:39:58 +08:00
Nan Gao	063383d995	fix(deploy): wire the multi-replica prerequisites into the Helm chart and compose (#6347) ... * fix(deploy): wire the multi-replica prerequisites into the Helm chart and compose The chart shipped gateway.replicas: 1 with a README citing the long-closed issue #3948, while its rendered config lacked run_ownership heartbeats and db run events: raising replicas made every starting Pod write its peers' lease-less runs off as orphans, and the Gateway's startup gate could not notice because its worker count only sees one Pod. Enable heartbeats and db run events in the default config, export DEER_FLOW_MULTI_INSTANCE from the replica count for the startup gate, generate and inject a shared AUTH_JWT_SECRET (per-Pod .jwt_secret files logged users out across replicas), declare a surge-then-drain rollout strategy, render a PodDisruptionBudget when replicas > 1, and bound uvicorn's graceful shutdown inside a 90s termination grace period. docker-compose gets the same uvicorn bound and a 60s stop_grace_period so the 30s memory flush is no longer SIGKILLed. Docs and comments now list what actually remains single-instance: IM channels, WeChat QR login and browser tools. * fix(deploy): honor existingAppSecret, declare multi-instance explicitly, cover the dev stack's shutdown Follow-up to the multi-replica prerequisites wiring, addressing review: - `deer-flow.appSecret` returns `existingAppSecret` when it is set. The gateway and frontend kept referencing the generated `<release>-app` Secret, which the chart stopped rendering, so every Pod sat in CreateContainerConfigError. The value is now declared in values.yaml. - `gateway.multiInstance` (boolean, default null) overrides the replica-derived DEER_FLOW_MULTI_INSTANCE, PodDisruptionBudget and AUTH_JWT_SECRET requirement for deployments scaled with kubectl or an HPA, which change the replica count without a Helm upgrade. - AUTH_JWT_SECRET is required, not optional, whenever the gateway is multi-instance: concurrently booting Pods otherwise race to write different `.jwt_secret` files on the home volume and sign sessions with different keys. - `gateway.uvicornGracefulShutdownSeconds: 0` is honored instead of being swallowed by `default 10`. - docker-compose-dev.yaml and dev-entrypoint.sh get the same uvicorn graceful-shutdown bound and `stop_grace_period: 60s`. - The chart README documents the one-time sign-out when upgrading a release that predates AUTH_JWT_SECRET and how to seed the previous key into the Secret first. - Tests read the shutdown budget from the Gateway through a shared helper instead of hard-coding 5/5/30, the raw-template string matches give way to `helm template` renders, and new renders cover multiInstance, existingAppSecret, a disabled PDB and a zero graceful-shutdown bound. * docs(changelog): link the multi-replica deploy entry to #6347 * fix(deploy): budget every bounded teardown hook and flag the multiInstance PDB window Review follow-ups on #6347: - The shutdown budget modeled only channel stop + run drain + memory flush (40s). The lifespan also runs the startup trash sweep, the notification delivery worker stop, browser-session close and the MCP session-pool close, each bounded at _SHUTDOWN_HOOK_TIMEOUT_SECONDS, plus a 1s retrieval-warm wait: about 61s worst case. _gateway_shutdown_budget.py now reads all of them from the Gateway, a drift guard pins the hook count against app.py, and both compose files move stop_grace_period from 60s to 90s (Helm's 90s already had room: 5 + 10 + 61). Comments and the chart README cite the full arithmetic. - gateway.multiInstance: true renders the PodDisruptionBudget immediately, which blocks drains of the single Pod until the scale-up happens; the README, values comment and both deployment guides say so and name podDisruptionBudget.enabled: false as the interim escape hatch.	2026-10-06 11:21:51 +08:00
PeaceMaker-best	3606c4a098	feat(agents): add portable custom agent packages (#6127) ... * feat(agents): add portable agent packages Signed-off-by: PeaceMaker-best <221849497+PeaceMaker-best@users.noreply.github.com> * fix(agents): show readable package import validation errors --------- Signed-off-by: PeaceMaker-best <221849497+PeaceMaker-best@users.noreply.github.com> Co-authored-by: PeaceMaker-best <221849497+PeaceMaker-best@users.noreply.github.com> Co-authored-by: Willem Jiang <willem.jiang@gmail.com>	2026-10-06 10:20:38 +08:00
Totoro	cdbcc0d9e9	feat(scheduled-tasks): show goal outcomes and end conditions in run history (#6326) ... * docs(scheduler): document tool_enabled, goal notices and goal-evaluation change Follow-up to #6229: - CONFIGURATION.md: add scheduler.tool_enabled to the example and notes. - CONFIGURATION.md, README (en/zh/pt): unmet goal runs send a goal-unmet notice instead of a completion notice, and three unmet runs add an auto-pause notice; the docs still said only success/failed notify. - CHANGELOG (en/zh): the #6229 entry now states the default-on goal evaluation change for scheduled/webhook/autonomous goal runs and that evaluator usage counts toward run usage. * feat(scheduled-tasks): show goal outcomes and end conditions in run history Follow-up to #6229. The API already returns these fields; the tasks page did not show them, so a met goal read as plain "Success", an unmet reason code rendered as a red execution error, and the goal-unmet IM notice pointed to a workspace showing neither objective nor verdict. - Task detail shows the per-run goal, max automatic runs and end time when a conversation-created task has them. - Goal runs show "Goal met" (or met relying on stated assumptions); unmet runs show a localized reason plus the host code in neutral styling. The run whose agent asked to stop the schedule is marked. - Runs without a goal, and failed runs, render as before. Read-only and frontend-only: no API change. * docs(changelog): add #6326 scheduled-task goal outcome entry * fix(scheduled-tasks): show readable unmet reasons instead of raw codes Unmet runs now show only the localized reason; the host code moves to the tooltip so it can still be matched with the IM notice. Codes without a label are still shown verbatim. * fix(scheduler): show readable goal reasons instead of internal codes Task detail now localizes the host-written last_error values from goal and stop finalization (agent stop, automatic pause, unmet reason codes) under a matching label, and Chinese copy is tightened. Goal-unmet and auto-pause IM notices state the reason in words instead of printing the raw code; unknown codes are still not forwarded. * docs(changelog): describe readable goal reasons in #6326 entry * test(scheduler): pin host goal strings with a cross-language contract Address review on #6326: - Add contracts/scheduled_goal_notes_contract.json listing the task last_error strings and unmet reason codes the tasks page and IM notices translate. A backend test checks finalization constants, blocker and stand-down codes against it; a frontend test checks every listed value has a label. - Move the two last_error strings in finalization.py into constants. - Frontend reason lookup strips the blocked: prefix like the IM map and now covers goal_not_met_yet, with en/zh labels. --------- Co-authored-by: Totoro-qaq <279883115+Totoro-qaq@users.noreply.github.com> Co-authored-by: Willem Jiang <willem.jiang@gmail.com>	2026-10-05 21:56:04 +08:00
Wenchao An	648870b590	feat(extensions): add full Custom Agent team collaboration plugin (#6243) ... * feat(extensions): add full Custom Agent team collaboration plugin * fix(extensions): register agent teams in the capability catalog * fix(agent-teams): recover incomplete teams and preserve request capacity * fix(agent-teams): preserve clarification waits and active handoff lineage * fix(agent-teams): align mention and input text limits	2026-10-04 16:36:48 +08:00
Xuehao Xu	2e4191e56f	fix(frontend): preserve complete artifact editing baselines (#6036) ... * fix(frontend): preserve complete artifact editing baselines * fix(frontend): keep artifact edit exit available during reloads * refactor(frontend): remove redundant artifact action fragments	2026-10-04 14:40:42 +08:00
quifox	06e9bfd269	fix: propagate current run failures from wait endpoints (#6217) ... * fix: propagate current run failures from wait endpoints * docs: clarify checkpoint wait errors and SDK behavior	2026-10-04 07:46:59 +08:00
Totoro	35023bb908	feat(scheduler): create conversation schedules and support agent self-stop (#6229) ... * feat(scheduler): create conversation schedules and support agent self-stop * fix(scheduler): validate goals and trial requests before dispatch --------- Co-authored-by: Totoro-qaq <279883115+Totoro-qaq@users.noreply.github.com>	2026-10-04 06:46:13 +08:00
Wenchao An	59b051b0fd	feat(frontend): support extension providers in composer mentions (#6189) ... * feat(frontend): support extension providers in composer mentions * fix(mentions): retain settled plugin suggestions during search * fix(extensions): validate identifiers and skip empty mention searches * test: stabilize history pagination after latest page refresh --------- Co-authored-by: Willem Jiang <willem.jiang@gmail.com>	2026-10-03 20:30:23 +08:00
Wenchao An	c7e24e4d14	fix(frontend): allow atomic keyboard deletion of inline references (#6184) ... * fix(frontend): allow atomic keyboard deletion of inline references * fix(frontend): preserve conversation metadata across native undo	2026-10-03 17:05:20 +08:00
Daoyuan Li	c84b32205d	fix(frontend): ignore literal base tags in HTML artifact previews (#6176) ... * fix(frontend): ignore literal base tags in HTML artifact previews * fix(frontend): address HTML preview base review feedback --------- Co-authored-by: Willem Jiang <willem.jiang@gmail.com>	2026-10-03 16:35:55 +08:00
Daoyuan Li	b0c1b2e7ce	fix(artifacts): handle CRLF splits in CSV/TSV previews (#6180) ... * fix(artifacts): handle truncated CRLF after quoted fields * Handle LF-first truncated CRLF artifact samples	2026-10-03 14:48:32 +08:00
Xuehao Xu	9b17bef630	feat(channel): add QQ WebSocket channel (#6081) ... * feat: add QQ WebSocket channel * fix: address QQ channel review feedback * docs: trim inherited agent guidance below CI limit * fix: align QQ gateway and passive reply limits with protocol * docs: keep merged channel guidance within CI budget	2026-10-03 14:32:44 +08:00
Hyeonsang Cho	7f7668d975	fix(community): refuse non-global addresses in the shared SSRF guard (#6202) ... * fix(community): refuse non-global addresses in the shared SSRF guard is_blocked_address ORed is_private, is_loopback, is_link_local, is_reserved, is_multicast and is_unspecified. None of them covers the 100.64.0.0/10 shared address space, which holds CGNAT and Tailscale hosts and Alibaba Cloud's 100.100.100.200 instance metadata endpoint, so web_fetch, web_capture, the agentic browser and personal MCP connections could reach it, including through the IPv4-mapped ::ffff:100.100.100.200 form a DNS answer can carry. Also refuse any address that is not is_global, the classification the repo's other SSRF filters already use. Keep the existing flags alongside it: some non-public forms still report is_global, such as the NAT64 spelling of a metadata address (64:ff9b::a9fe:a9fe) and 224.0.0.1, so an is_global-only check would newly allow them. * docs(changelog): reference #6202 in the shared address space entry * test(community): pin the IPv4-mapped metadata spelling at the web_fetch and personal MCP entry points --------- Co-authored-by: Willem Jiang <willem.jiang@gmail.com>	2026-10-03 10:29:56 +08:00
Wenchao An	9ff47cfae5	feat(extensions): show the bundled catalog by default (#6188) ... * feat(extensions): show the bundled catalog by default * test(extensions): pin bundled catalog namespaces	2026-10-02 23:01:34 +08:00
lihongyuan99	571a7e40e4	docs(harness): import the Gateway app from the module that defines it (#6169) ... Both the en and zh integration guides show `from deerflow.app.gateway.main import app`, but there is no deerflow.app package and no gateway/main.py in the tree: the FastAPI instance is created by create_app() and bound at module level in backend/app/gateway/app.py, which is also how backend/AGENTS.md documents it. The copy-pasteable snippet now names that module, so mounting the Gateway as a sub-application works from the documented import instead of failing at runtime.	2026-10-02 17:08:30 +08:00
Daoyuan Li	59743568ba	fix(frontend): ignore inherited artifact language keys (#6152)	2026-10-01 19:42:06 +08:00
Wenchao An	9f5897cef2	feat(frontend): reserve slash menu for built-in commands (#6154) ... * feat(frontend): reserve slash menu for built-in commands * chore(frontend): remove unused skill removal translations	2026-10-01 19:31:31 +08:00
lihongyuan99	241a7b3b9b	fix(frontend): key the Julia entry of extensionMap by its extension (#6130) ... extensionMap is keyed by extension and valued by language, but the Julia row was written backwards as `julia: "jl"`. checkCodeFile tests membership with `extension in extensionMap`, so ".jl" never matched and a Julia artifact was not a code file at all, while ".julia" resolved to a language named "jl". Add both `jl: "julia"` and `julia: "julia"`, the same pair form the map already uses for haskell/hs and elixir/ex, so no extension that classified before stops classifying.	2026-10-01 09:58:23 +08:00
creed	9c75236ea1	fix(frontend): strip closing hashes from web fetch titles (#6103) ... * fix(frontend): strip closing hashes from web fetch titles Signed-off-by: 97three <2212371308@qq.com> * fix(frontend): scan web fetch heading suffixes in linear time Signed-off-by: 97three <2212371308@qq.com> --------- Signed-off-by: 97three <2212371308@qq.com>	2026-10-01 08:51:40 +08:00
kuse	ee3159a01d	fix(threads): re-anchor re-persisted history rows to their earliest seq (#6128) ... * fix(threads): re-anchor re-persisted history rows to their earliest seq reconcileThreadHistoryRows collapsed a repeated (run_id, identity) to its latest-seq copy, deleting the earliest-seq row before buildVisibleHistoryMessages could apply its earliest-seq-wins anchoring. A message re-persisted under a newer seq therefore jumped to the tail of the thread, contradicting the documented contract in this function's docstring, in buildVisibleHistoryMessages, and in the backend get_message_seqs earliest-seq-wins rule. Re-anchor the surviving row to the earliest seq its identity held in the merged window after deduping, and make the retained-history stability check value-based so re-anchored rows do not force a state update on every pass. Fixes #6125 * fix(threads): address history reconciliation review --------- Co-authored-by: liwenjie200543 <175601277+liwenjie200543@users.noreply.github.com> Co-authored-by: Willem Jiang <willem.jiang@gmail.com>	2026-10-01 08:20:42 +08:00
Wenchao An	4c05e88c52	feat: add inline @ references with multiple skill activation (#6063) ... * feat(frontend): unify composer references with an @ picker * feat: edit references inline and activate multiple skills * docs: describe inline references and multiple skill selection * fix: prevent sent drafts from returning and repair CI checks * fix: reconcile inline references and address review feedback * fix: preserve references through discovery errors and polish	2026-09-30 23:09:05 +08:00
Daoyuan Li	5c67d61d65	fix(frontend): detect artifact types from file basenames (#6091)	2026-09-30 20:11:26 +08:00
Anton Dziatkovskii	a83aebe702	fix(docs): harness docs document an async client API that does not exist (#5843) ... * docs: replace nonexistent async client API in harness docs DeerFlowClient has no async methods: client.astream() and client.ainvoke() do not exist, so the "Create Your First Harness" tutorial and the harness integration guide fail with AttributeError on their first call. Overrides were also shown as a nested config={"configurable": {...}} dict, which stream()/chat() swallow via **kwargs and silently ignore. Switch the examples to the shipping API (sync stream()/chat(), flat kwarg overrides, agent_name as a constructor arg) in the EN and ZH copies of both pages. backend/docs/STREAMING.md is left alone: its astream mentions are design discussion and LangGraph internals, not user-facing examples. Assisted-by: Claude Code / claude-opus-5 Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> Signed-off-by: Anton Dziatkovskii <194927794+tonydzi@users.noreply.github.com> * docs: serialize StreamEvent before StreamingResponse, use real event names Review follow-up on the two points raised in #5843. P2 — the streaming examples handed a generator of `StreamEvent` dataclasses straight to Starlette. `StreamingResponse` calls `.encode()` on any chunk that is not `str`/`bytes`, so the first event raised `AttributeError: 'StreamEvent' object has no attribute 'encode'`. Both occurrences (the `run_agent` snippet and the inline FastAPI route, which shipped the dataclass `repr()` through an f-string) now serialize to SSE frames built from `event.type` / `event.data`. P3 — the tutorial showed mapping literals with `messages` and `thread_state`, neither of which exists. The real contract is `StreamEventType = Literal["values", "messages-tuple", "custom", "end"]` (backend/packages/harness/deerflow/client.py:128) and the stream yields dataclasses, so the section now shows `StreamEvent(...)` with the real names plus a consuming loop. The zh tutorial had no equivalent section at all; added for parity. Assisted-by: Claude Code / claude-opus-5 Machine: A-Mac16-2019-PaloAlto Account: tonydzi Operator: robot:pr-reply-daily Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> * docs: drop the nonexistent load_config() from every harness snippet Review follow-up on #5843 (@willem-bd): the rewritten tutorial still opened with `from deerflow.config import load_config`, which raises ImportError before `client.stream(...)` is ever reached — `deerflow/config/__init__.py` exports `get_app_config` and friends, and the string `load_config` does not appear anywhere under `backend/packages/harness/deerflow/` (the only near match is `load_configured_extension_middlewares`). The call was also unnecessary: `DeerFlowClient.__init__` already resolves configuration itself (client.py:220-222 — `reload_app_config(config_path)` when a path is given, otherwise `get_app_config()`, which auto-loads from the default path or DEER_FLOW_CONFIG_PATH). Fixed the class rather than the one snippet you flagged: the same dead import appeared 10 times across 4 pages (EN + ZH tutorial and integration guide). Every one is gone. The "configuration in embedded mode" section now shows the API that exists — `DeerFlowClient(config_path="...")` — instead of `load_config(config_path="...")`. Also from the review: - the `end` example showed only `total_tokens`; `stream()` always yields input/output/total (client.py:920), and the snippet right below prints the whole usage dict, so a reader saw keys the docs omitted. Both EN and ZH now show the full payload, and the `values` example visibly elides `artifacts` and `summary_text` instead of pretending they are absent. - the two SSE comments on the ZH integration page stayed English while the example above them was translated; translated. Verified statically, not executed: `grep` for the symbol across the harness package (zero hits) and a read of `DeerFlowClient.__init__`. I did not stand up a backend to run the tutorial end to end. Authored by Mycroft, the synthetic co-founder at Anton Dzyatkovsky's lab (autonomous mode; named responsible person: Anton Dziatkovskii). Assisted-by: Claude Code / Opus 5 (review response, implementation) Machine: MacBook-Anton Account: a Operator: mycroft (autonomous routine github-thread-watch) Signed-off-by: tonydzi <194927794+tonydzi@users.noreply.github.com> Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> * docs: fix native artifact SSE encoding and custom config advice --------- Signed-off-by: Anton Dziatkovskii <194927794+tonydzi@users.noreply.github.com> Signed-off-by: tonydzi <194927794+tonydzi@users.noreply.github.com> Co-authored-by: Anton Dziatkovskii <194927794+tonydzi@users.noreply.github.com> Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com> Co-authored-by: Willem Jiang <willem.jiang@gmail.com>	2026-09-30 19:36:54 +08:00
Wenchao An	1e462ae4a2	fix(frontend): consolidate run duration into reasoning headers (#6057) ... * fix(frontend): show run duration in reasoning headers * fix(frontend): cover all reasoning duration disclosures * fix(frontend): collapse restored reasoning and cache duration targets * chore: remove PR-only reasoning screenshot	2026-09-30 17:22:41 +08:00
PeaceMaker-best	b73a4e79bf	feat(memory): scope management API by agent (#5565) ... * feat(memory): scope management API by agent Signed-off-by: PeaceMaker-best <221849497+PeaceMaker-best@users.noreply.github.com> * fix(memory): preserve scoped management isolation Signed-off-by: PeaceMaker-best <221849497+PeaceMaker-best@users.noreply.github.com> --------- Signed-off-by: PeaceMaker-best <221849497+PeaceMaker-best@users.noreply.github.com> Co-authored-by: PeaceMaker-best <221849497+PeaceMaker-best@users.noreply.github.com>	2026-09-30 16:50:07 +08:00
xihongshichaojidan8	d0e4d3525c	fix(frontend): show media icons for APNG, AVIF and WebM (#6089)	2026-09-30 15:58:45 +08:00
NanHan Qing	c714629faf	fix(sandbox): expose DEERFLOW_USER_ID to every bash command (#6058) ... * fix(sandbox): expose DEERFLOW_USER_ID to bash commands A skill's SKILL.md can trigger scripts, but those scripts run as bash subprocesses inside the sandbox and cannot reach the Gateway auth context, so get_effective_user_id() is unavailable to them and user-scoped skills are impossible to write. The maintainer settled the direction on #3919: inject the id as DEERFLOW_USER_ID. Every bash command now begins with 'export DEERFLOW_USER_ID=<resolved>; ' (or 'unset' when the resolved id is unusable), mirroring the existing DEERFLOW_CHANNEL_USER_ID channel-identity prefix (#3914). The id rides the command string rather than execute_command(env=...), because a non-empty env switches AioSandbox to the bash.exec API reserved for request-scoped secrets. The earlier attempt (#4029) was closed for making every command carry the new export without updating the exact-command assertions in tests/test_channel_user_id_env.py. Those assertions are updated here, and the composition of the two prefixes is pinned by a dedicated test. * fix(sandbox): fix the DEERFLOW_USER_ID unit test and cover review findings Follow-up to the review on this PR. Unit test (CI `backend-unit-tests (2)`): the change moved the command contract but left the exact-command assertion in tests/test_skill_request_scoped_secrets.py::test_local_bash_forwards_env_and_timeout expecting the bare `echo hi`. The local validation run used a `-k` filter that did not select that file, so the breakage was invisible there. The assertion now pins the composed command, and `_is_windows` is patched explicitly so it no longer depends on the host OS. [P2] Windows local sandbox: `export` is invalid under the PowerShell/cmd.exe fallback, but skipping the prefix outright left the promise unmet on Windows. The id is published through `execute_command(env=...)` there instead: LocalSandbox layers `env` into the per-process environment and, unlike AioSandbox, has no persistent session that could carry a stale value. It is deliberately kept out of `injected_env` so the identifier does not enter the secret-redaction set. Docstring: `_user_identity_prefix` now carries the same "informational, not authenticated identity" caveat the channel variable has in backend/app/channels/AGENTS.md. The value is authorization-grade at the Gateway boundary, but any bash command can overwrite its own environment, so skills must not treat the shell variable as proof of identity. Docs: the en/zh sandbox.mdx identity sections and the channels/AGENTS.md identity paragraph now describe the second, outermost prefix, its ordering against the channel prefix, and the Windows behaviour.	2026-09-30 14:56:03 +08:00
yang rui	fcff55a075	fix(frontend): preserve first-turn order during chat creation (#6074)	2026-09-30 10:45:19 +08:00