Repository navigation
release: v3.5.0 — stage → main - #2776
Merged
Merged
Conversation
… uv resolve (#2126) * feat(depends): cache the satisfied verdict so cold processes skip the uv resolve `_processed` only spans one process, so every cold engine process re-ran the uv dry-run for each requirements file and, on a warm machine, only learned that everything was already installed — 20-40s behind the engine-global lock. Persist that verdict under <engine cache>/satisfied/, one file per requirements file, keyed by everything the resolve consults: the requirements file, the compiled constraints/overrides/excludes, the interpreter and the installed dist-info set. A matching key skips the dry-run and the install; any change reruns them. Lock semantics are unchanged. Fixes #2089 * fix(depends): fingerprint files pulled in through -r/-c in the verdict key A change inside an included requirements file left the verdict key unchanged (CodeRabbit on #2126). The key now digests the full include closure, resolved relative to each including file; adds regression tests and docstrings on the new tests. * fix(depends): join backslash-continued lines before scanning requirement includes pip and uv treat a trailing backslash as a line continuation, so a continued -r/-c directive was invisible to _requirements_closure (CodeRabbit on #2126). Join continuations before matching; adds a regression test. * fix(depends): treat an unreadable or unwritable verdict cache as a miss, never a failure _save_verdict runs on the success path, so an OSError from the cache directory turned a successful resolve or install into a failed depends(); the read side had the same hole via _load_stored_hash. Both are now best-effort, like the progress sidecar (CodeRabbit on #2126). * fix(depends): never cache a verdict the key cannot compute honestly Review on #2126 found two ways the cache fails wrong. A non-UTF-8 included file raised UnicodeDecodeError out of _requirements_closure and hard-failed node startup — new, since an included file was previously read only by uv. And an include path with a space captured a name that does not exist, so the real file was never fingerprinted and an edit to it kept a satisfied verdict: a silent stale hit. The decode is now replace-on-error, quoted paths parse, and _verdict_key returns None whenever an input is invisible to it, which degrades to resolving every time. Adds _VERDICT_SCHEMA so a change to the resolve's own arguments retires old verdicts, and makes --rebuild-cache clear the verdicts so a bad state is recoverable without a redeploy. * fix(depends): refuse the key when site-packages cannot be listed _installed_fingerprint hashed an empty list on OSError, which is a stable digest — the key would stop noticing installs and every verdict would stay satisfied for ever. It now returns None and _verdict_key refuses, so the failure degrades to resolving. bootstrap() creates the directory before any key is computed, so this cannot fire on the real path. * fix(depends): verify the verdict cache was actually cleared, and gate on isfile --rebuild-cache reported a cleared cache even when the directory survived: removeDir returns false and only warns when it is in use (EPERM/EBUSY), so a surviving verdict left depends() skipping the re-resolve the flag exists to force (CodeRabbit on #2126). The task now confirms the directory is gone and fails loudly if it is not, checked on the directory rather than on removeDir's return value, which reports success for an absent directory too. Also takes the review's note that _verdict_key gated on os.path.exists, so an include naming a directory passed the gate and then digested to '' - a stable key over an unreadable input, the shape the refusal exists to prevent.
Injects msvalidate.01 into every docs.rocketride.org page's <head> via Docusaurus headTags, which Bing Webmaster Tools scans for site verification. Scoped to docs.rocketride.org: the packages/docs subpackage is built and deployed only by .github/workflows/docs.yml to GitHub Pages, and is not bundled into any self-hosted RocketRide install, so the tag does not ride into other people's deployments. Tag value comes from a Bing Webmaster account seeded 2026-08-27 for the SEO program. The same tag verifies rocketride.org (via Webflow head code) and news.rocketride.ai (via Ghost code injection); Bing issues one tag per account. Public value, safe to commit: the tag proves domain ownership to Bing but grants no capability by itself. Do not remove after verification succeeds per Bing's own guidance. Runbook: ~/Downloads/bing-webmaster-setup.md (Mithilesh, 2026-08-27).
* feat(nodes): add hackjudge_account business-account node Signup, signin, session validate/signout and profile ops inside the pipeline; resolves tenant_id and tier for the verify flow and short-circuits invalid sessions. scrypt password hashing with parameters recorded in the stored hash; session tokens stored only as SHA-256 hashes. Offline tests cover hashing round-trips and the op surface using the sys.modules stub pattern from the agent_crewai tests. Part of the Hack Judge suite (engine, account, store, tokens): four independently mergeable node PRs wired together by a verify-flow envelope. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * test(nodes): import the shared stub helper relatively The test-root guard rightly rejects nodes/test on sys.path (it shadows node packages of the same name); use the package-relative import the other suites use instead. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * refactor(nodes): hackjudge_account is a marketplace identity resolver Review feedback plus the app owner runbook settled this: identity is the platform's job (manifest authenticated: true hands the app the signed-in user), so the signup/signin/password/session machinery is deleted. What remains is what the pipeline needs regardless: resolve the platform org + user to the app tenant and tier (creating both on first sight, keyed by marketplace_org_id, user keys scoped per org), stamp them into the verify-flow envelope, and short-circuit requests without an identity. Tier stays owned by entitlement, not this node. session_ttl_hours config is gone; database_url is the only config left. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(nodes): review feedback on hackjudge_account Schema ships with the node: schema.sql (idempotent DDL for every table the hackjudge_* nodes touch) plus a README section on applying it. The generic DATABASE_URL fallback is gone; blank config falls back to HACKJUDGE_DATABASE_URL only and the node refuses to start without one, so it can never write tenants into an unrelated database. First-sight creation is insert-first with ON CONFLICT on the new unique indexes (tenants.marketplace_org_id, users.external_id) and a re-select, so concurrent first logins converge on one tenant/user instead of racing SELECT-then-INSERT. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> --------- Co-authored-by: Poushali Deb Purkayastha <poushali.purkayastha@rocketride.ai> Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
…in validate_pipeline (#2082) * feat(mcp): add resolve_config, showing what a node actually receives A .pipe rarely says what a node gets. The engine merges profile defaults and, when a profile is set, reads the user layer only from the sub-object named after that profile, so a key written beside it is discarded in silence. The author of #1989 lost a day to exactly that, and the schema cannot express it: a schema describes what a field is, not that this field in this profile will be dropped. resolve_config runs the config through the same Config.getNodeConfig a node calls at load, and returns the resolved result plus the keys the resolver discarded, with a hint naming the object they belong in. Resolution has to happen engine-side. getServiceSchemas copies 15 keys into the catalog and preconfig is not among them (services.cpp:2100-2148), so profile resolution cannot be reproduced from rrext_services or /services. The tool reaches the engine through the existing seam rather than importing Config directly. modules/mcp/engine.py states that tools depend only on the EngineClient protocol so a later revision can swap the WS SDK for in-process calls without touching tool code; a direct import would have made this the first tool to break that. So this adds rrext_resolve_config next to rrext_services and rrext_validate, the matching SDK method, and one line on each side of the seam. Both argument checks default only a genuinely absent config: `or {}` would coerce a falsy non-object such as [] and skip the type check entirely. A test caught that. doc.md gains the tool row and its count moves to 28. * feat(mcp): add scaffold_node, emitting a node that loads on the first try Authoring a node means discovering its contract by failure, and the documented contract is wrong in three places, so reading the docs first does not help: - preconfig is marked optional in README-node-schema.md, but Config.getNodeConfig raises without it and nearly every IGlobal calls that at load. Of 170 services*.json in the tree, the only ones without preconfig are global-field files with no protocol plus a handful whose IGlobal never calls it. - depends() is documented as running in __init__.py, and the same page then contradicts itself. The real nodes call it from IGlobal.beginGlobal, and any third-party import has to follow it. - The "Adding a New Node" example shows a plain class with a process() method, which nothing in the engine calls. The contract is IGlobalBase/IInstanceBase. Two more the docs omit: a services.json without protocol is not registered as a service at all, and register must be filter or endpoint or the node loads but can never be instantiated. The provider name is the protocol, which is the mistake the issue opens with. scaffold_node emits all of that correctly, including the parent local_nodes/__init__.py and the local_nodes.<name> import path. class_type and lane_out are checked against the live catalog rather than a list here, so the allowed sets follow the engine instead of drifting as nodes are added. It returns files rather than writing them. _common.load_pipeline already refuses server-side reads because an MCP caller could otherwise reach the server's disk; writing deserves the same stance. The tests assert the emitted skeleton against the engine's real requirements: every generated Python file parses, the manifest carries the four keys that stop a node loading, depends() is in IGlobal and not __init__.py, and the handler matches the requested lane. Dropping preconfig from the template fails them. doc.md gains the tool row and its count moves to 29. * fix(client-python): let a non-object config reach the engine's type check resolve_config defaulted with `config or {}`, which coerces a falsy non-object such as [] into {} and hides the mistake the engine would have reported. Only an absent config is defaulted now, matching the handler it calls. * fix(mcp): report a config key the profile overwrote, not just an absent one resolve_config decided a key was discarded by checking whether it was missing from the resolved config. Nearly every profile in the catalog declares apikey, so an apikey written beside "profile" comes back present, holding the profile's value rather than the author's, and the tool stayed silent on the exact case it exists to surface. A key now counts as discarded when what the node receives differs from what the author wrote. Found by calling the tool over the MCP transport against a real llm_openai profile; the unit test missed it because its stub returned a resolved config without the key at all. * refactor(mcp): give the catalog lookups one job each _catalog_values branched on whether its key argument was the string 'lanes', so one function carried two different traversals. Splitting them drops the branch and the stringly-typed parameter, and the lane names are now filtered for strings the way the class types already were. * fix(mcp): harden scaffold_node against catalog and argument shapes Three defects found in review: A catalog entry whose classType is a bare string was iterated character by character, so 'text' admitted 't', 'e' and 'x' as class types and rejected the real one. Introduced when the lookup was split in two; the container check that guarded it is back. Dispatch does not apply the tool's inputSchema, so a non-string name reached the regex and raised TypeError instead of returning an actionable answer. Name, both lanes and class_type are now checked for type first. lane_in was validated only against the local handler templates, never against the catalog, so a lane with a template but no engine support produced a manifest with an input lane nothing serves. Also corrects the introspection group heading in doc.md, which still counted 5 tools and did not list scaffold.py as a source. * fix(mcp): report every profile sibling key, not only one whose value changed Comparing the resolved value against the author's missed the sibling that happens to match the profile's own value. The resolver never read that line either, so staying quiet left the author believing it was in effect when the key inside the profile is what applied. With a profile set every sibling is discarded, so the value is not worth comparing and the check is simpler for it. * fix(mcp): keep a supplied falsy argument out of the scaffold defaults lane_in, lane_out and class_type defaulted with `or`, so a supplied 0, '' or [] became the fallback and never reached the type check that would have reported it. Defaulting now applies only to an absent or null argument, matching the handler this PR already corrected on the client side. * feat(mcp): flag a component whose provider the engine cannot serve validate_pipeline passed a pipeline naming a provider that does not exist, so a typed name validated clean and failed later at run time. The engine's provider lookup lives in validate_pipeline.cpp's single-component path, which the whole pipeline path never reaches. The tool now checks each component against the engine's service catalog after the engine's own validation, and reports the component id with the name it could not resolve. The names come from the engine, so no rule moves into the client, and engine findings are added to rather than replaced. Closes the third of the four tools #1989 asked for; it was previously treated as already shipped in #1880, which covers the structural half only. * fix(mcp): report only the config keys a profile actually discarded resolve_config reported every sibling of the selected profile, so it named parameters on all 34 components in the repo's own pipelines that select one, and told the author to move it inside the profile object. parameters is not node configuration: the engine validates and consumes it on its own path (pipeline_config.cpp Rule 5 and Rule 6), and moving it would break the component. name is the same shape, and an editor-saved config keeps a sub-object per profile, so an unselected profile read as a discarded key too. Structural keys and the service's own profile names are now excluded. Over the same pipelines the report goes from 34 components to 1, and that one is a real finding: search_exa carries apikey beside the profile. The existing test passed because its config was hand-written with only apikey beside the profile. The new one is shaped like a real .pipe. Also drops the return in the scaffolded handler's preventDefault call, which raises, matching how the real nodes write it. * fix(examples): repair the two component configs these tools surfaced Both are real defects the PR's own additions found in shipped examples. document-processor names provider "anonymize", but that node declares "protocol": "anonymize_text://" and the provider is the protocol minus the scheme, so no such service exists and the component could never instantiate. The new provider check in validate_pipeline flags it; the old validator resolved the definition and silently ignored the miss. exa-search-working carries apikey beside "profile", where getNodeConfig never reads it, so the pipe named "working" resolved its key to the profile's empty default. Moving it inside the profile object is correct under the current resolver and under the one #2039 and #1979 propose. resolve_config reports it. Over every pipeline in the repo, resolve_config now reports no discarded keys.
The link pointed at ../../../../tools/sync_models/README.md, a repo-relative path that resolves to /tools/sync_models/README.md in the built docs URL space. The docs subpackage does not include tools/, so Docusaurus's broken- link check throws and the Docs workflow fails on every push touching a node README (last two runs on develop failed with this signature). Point it at the file on GitHub instead. Docusaurus treats absolute URLs as external and skips them, users see the same content, and the docs deploy unblocks. Same fix would apply to any other node README that links repo-relative into tools/ or scripts/; leaving that sweep out of scope so this is a minimal unblock.
* feat(nodes): add authoritative_overlay node for financial auditing (#1430) - Created node to cross-check extracted financial answers against official regulator data. - Added local snapshot testing connectors for SEC, IFRS, Companies House, and EDINET. - Implemented logic to abstain and drop answers when a mismatch is detected. * feat(nodes): add fail-closed numeric validation to authoritative_overlay * fix(authoritative-overlay): fix test framework compatibility * resolve coderabbit issues * fix(authoritative_overlay): address maintainer PR feedback * refactor the node by migrating to live SEC API & address review feedback Cleaned up the working tree by removing all unrelated scratch files and mock snapshots. Replaced the static connector mock with a live integration to the SEC EDGAR API using a configurable CIK. Fixed normalization bug for parenthesized numbers, corrected config field naming conventions, and dropped empty boilerplate functions. * fix(authoritative_overlay): scope SEC matches to a filing period Stop treating any historical company-concept value as a verification, emit a matching answer once, and keep overlay unit tests isolated for engine CI.
…-readable code (#2127) * fix(ai,client-python,client-typescript): give task failures a machine-readable code A dead task token was indistinguishable from a live one: every task lookup failure raised a bare RuntimeError, and the only signal a client had was the English sentence, so applications matched on prose that a reword or a translation would silently break. The SDKs then appended a developer troubleshooting checklist to that message, which reached end users verbatim. Engine: a TaskError carrying a code (TASK_NOT_REGISTERED, TASK_AMBIGUOUS, TASK_COMPLETED, TASK_STOPPED) at the registry lookups and the readiness wait. It subclasses RuntimeError and the messages are unchanged, so existing handling and existing string matches keep working. Protocol: DAPBase.build_exception copies a string `code` off the exception onto the DAP error packet, next to `message`. Additive — a plain exception still produces a byte-identical packet. SDKs: `code` and `hint` on DAPException (optional readonly fields in TypeScript, properties in Python), and DataPipe.open() keeps the server's message as the message with the checklist moved to `hint`. Fixes #2097 * fix(ai,sdk): complete the typed-error contract and stop chat() discarding it Addresses CodeRabbit on #2127: authenticate() now raises TaskError like every other task lookup; the Python open() hint named a mimetype keyword that does not exist (the parameter is mime_type); the TS guide claimed every exception extends DAPException, which LoginAttemptCancelledError does not; and chat() rewrapped typed exceptions in a plain Error, so callers on the most common path could not read code or hint. * test(client-typescript): pin chat() rethrowing typed exceptions The chat() rethrow was the only change in this PR with no regression test behind it. Without it the first test fails with 'Received constructor: Error'; the second pins that non-DAP failures are still normalised to a plain Error. * test(client-typescript): fail inside the pipe path in the normalisation test The old test passed an undefined question, which trips chat()'s empty-question guard before a pipe exists — it exercised the catch without reaching the path it names. The stubbed request now rejects with a plain Error from inside open() (CodeRabbit on #2127). * docs(ai,server): correct authenticate()'s Raises and scope codes to command replies * fix(ai): fall back to a message when a stopped task has no exitMessage * fix(ai): correct every false Raises claim in task_server, and let remove_task reach its typed error Audited all eight remaining ValueError: docstring claims against each function's actual raise paths rather than fixing an arbitrary subset (CodeRabbit and review on #2127). Five stated ValueError for a failure that is now TaskError, and restart_task's claim was false only in its first clause; get_task_control, start_task and restart_task's remaining clauses are backed by live raises and are left alone. get_task, get_task_status and attach_task propagate both, verified by calling them. Separately, remove_task popped without a default, so an unknown token raised KeyError before the TaskError guard below it could run - the failure reached the caller unclassified, which is the thing this PR exists to fix. * test(ai): pin that remove_task classifies an unknown token The registry pop had no default, so the TaskError guard beneath it was unreachable for the one case it was written for. Reverting pop(token, None) to pop(token) fails this test with KeyError: 'tk_unknown'.
… via lts-cpu wrapper (#1175) * fix(models/ocr): use OS trust store for model downloads; route polars via lts-cpu wrapper - ssl: install truststore and inject it into the default SSL context so HTTPS model downloads use the full OS trust store, fixing "unable to get local issuer certificate" behind TLS-intercepting proxies (falls back to certifi). - polars: route OCR polars imports through ai.common.polars, which installs polars-lts-cpu and removes any transitively-pulled plain polars, fixing SIGILL / SEH 0xc000001d on x86_64 hosts without AVX2/FMA. Fixes #1162 * refactor(models/ocr): lazy SSL injection, lock polars cleanup, fix comments Address review feedback on the TLS trust-store / polars-lts-cpu fix: - SSL injection is now lazy and process-scoped to local mode. ai.common.ssl exposes an idempotent ensure() guarded by a module-level flag, called from BaseLoader._ensure_dependencies (the chokepoint every local load() hits) before the per-class requirements guard, instead of running eagerly at ai.common.models import. Remote-mode dispatch processes never import ML libraries or download weights, so they no longer pay for the injection. - The polars-lts-cpu cleanup (pip uninstall + force-reinstall) now runs under the same install.lock FileLock that depends() uses. pip() runs raw with no locking, so concurrent worker startups could otherwise interleave and corrupt site-packages mid-rewrite. - Replace the silent `except: pass` in both shims with debug logging so a skipped cleanup/injection is observable. - Document that the version('polars') check queries the distribution name (not the import name), which is why it detects the transitive plain wheel. - Correct the nodes/ocr/requirements.txt comment: listing polars-lts-cpu does not stop a transitive plain `polars` from installing; the runtime cleanup is what makes lts-cpu authoritative. - Note that the kokoro spaCy-wheel `pip install <url>` validates TLS with pip's own CA bundle and is not covered by the in-process ssl injection. * refactor(models): drop polars lts-cpu shim, import engLib directly B1: the polars AVX2 crash no longer reproduces against currently-resolved versions, so the wrapper is dropped rather than kept as a permanent shim. * img2table resolves to 2.0.0, whose metadata declares no polars dependency and whose wheel contains no reference to polars in any module, so nothing pulls plain polars in transitively any more. * polars 1.43.2 moved its compiled runtime into separate polars-runtime-32/64/compat distributions and selects the baseline build by default, so the plain wheel no longer requires AVX2. * polars-lts-cpu is frozen at 1.33.1, so keeping the pin would hold the OCR node ten minor versions behind. * the only polars call site, to_ocr_dataframe(), belongs to the img2table v1 plug-in contract, which v2 replaced with of(). It is not reachable on a fresh install. ai/common/polars and the ocr requirements pin are removed, and the OCR node returns to its develop state. B4: ai.common.ssl imports engLib.debug directly instead of proxying it behind a try/except no-op. engLib is built into the engine, so the fallback masked import errors rather than guarding a real absence. * fix(ai): make the SSL trust store fallback reachable and the guard race-free - Move depends(requirements) inside the guarded block. It ran before the try, so a failed install propagated out of ensure() and the documented certifi fallback was never reached. - Set the one-shot guard after the attempt finishes, under a lock. It was set up front, so a second thread could return while the first was still injecting and then download weights through an unpatched SSL context. A failed attempt is still recorded, so a broken environment is not re-run through the install lock on every later load(). - Declare certifi in requirements.txt. The fallback imports it, so it can no longer depend on a transitive copy being present. Note truststore's Python 3.10+ floor there as well.
…objects (#1990) * fix(store_pinecone): read list_indexes() entries that are IndexModel objects pinecone-client returns IndexModel description objects from list_indexes() from v7 onward, not the dicts earlier releases yielded. The connection probe calls .get() on each entry, which those objects do not have, so it raises 'IndexModel' object has no attribute 'get'. requirements.txt pins no version, so which shape arrives depends on when the dependency was resolved. The failure also only appears once the index exists: next() stops evaluating the predicate on an empty account, so a fresh install looks healthy and every run afterwards fails. Adds a small accessor that reads either shape, including nested description objects such as spec, rather than pinning a client version. Fixes #1984 * fix(store_pinecone): detect serverless by value, and cover both entry shapes Addresses review feedback on the serverless compatibility check. IndexSpec.to_dict() emits every variant it knows about, unset ones included, so a pod-based index describes itself as {'serverless': None, 'pod': {...}}. The key-membership test therefore reported every pod-based index as serverless and emitted the opposite compatibility warning to the one the user needs. Verified against pinecone 9.1.0. The membership test predates this branch, but it was unreachable while the probe still crashed on IndexModel.get(), so this fix is what exposes it. Extracts _is_serverless() so the check is unit-testable without the probe, and adds regression tests for both entry shapes: pod and serverless, as dicts and as description objects. The tests fail against the key-membership check and pass against the value check. * Update nodes/src/nodes/store_pinecone/IGlobal.py --------- Co-authored-by: Alexandru Sclearuc <asclearuc@gmail.com>
* feat(tika): support RAR5 archives via 7-Zip-JBinding Tika's junrar-backed RarParser throws on RAR v5 (the default WinRAR format since 2013). Add net.sf.sevenzipjbinding plus a RarSevenZipParser that auto-detects RAR4/RAR5 and routes entries through the configured EmbeddedDocumentExtractor; ConfigBuilder swaps the parser and TikaApi initializes the native binding once per JVM. Fixes #1163 * refactor(tika): bulk RAR extraction, per-entry encryption handling, ASF header Address review feedback on the 7-Zip-JBinding RAR parser: - Replace per-entry extractSlow() with a single IInArchive.extract(int[], false, callback) pass. extractSlow re-decompresses from the start of the archive on every call, which is O(n^2) on solid RAR archives; the bulk call decompresses once while preserving solid-block ordering. Each entry is spooled to a temp file and dispatched to the embedded extractor as it completes, so peak disk usage stays at one entry. - Stop aborting the whole archive on the first encrypted entry. Encrypted entries are now logged and skipped per-entry, consistent with how unreadable headers and failed extractions are handled; an EncryptedDocumentException is surfaced only when every entry is encrypted (the archive as a whole is unreadable). - Switch the file's license header from MIT/Aparavi to the Apache ASF header used by sibling parsers, since handleEntryMetadata is ported from Tika's Apache-2.0 PackageParser. - Document the frozen sevenzipjbinding 16.02-2.01 security posture in the pom alongside the dependency. * fix(tika): gate the RAR parser swap on 7-Zip init, harden init and cleanup - ConfigBuilder replaced Tika's RarParser unconditionally, so when the 7-Zip-JBinding native library failed to load the config removed the only working RAR parser and installed one that cannot run. Gate the swap on TikaApi.isSevenZipReady() and keep junrar (RAR4) when it is not. - TikaApi.init() checked and assigned `initialized` without synchronization, so two callers could both pass the guard and race into initSevenZipFromPlatformJAR(). Make init() synchronized and the flag volatile. - Narrow the init catch from Throwable to Exception | LinkageError. A missing or incompatible native library arrives as UnsatisfiedLinkError, which LinkageError still covers, while OutOfMemoryError and StackOverflowError now propagate instead of being logged and ignored. - Close and delete the entry still in flight when bulk extraction aborts. setOperationResult() handles the normal path, but 7-Zip-JBinding does not promise a matching call once a callback throws, and on Windows the open handle also stops TemporaryResources from deleting the file.
Co-authored-by: Mayuresh Pandey <mayuresh@nybsys.com>
) * fix(sync_models): reject output token values that equal the context window LiteLLM and OpenRouter report max output tokens as the context window for some models. That value reaches the provider as max_tokens and the call is rejected with a 400. Discard such a candidate and try the next source; the fallback default no longer overwrites a limit already in the catalogue. Fail the sync when a profile still has modelOutputTokens equal to modelTotalTokens, and cover every llm_* node with a catalogue test. * fix(sync_models): scope the output-token check to providers that cap completions Equality between modelOutputTokens and modelTotalTokens only proves a broken value where the provider enforces a completion limit below its window. OpenAI rejects an oversized max_tokens outright and litellm swaps the fields for Anthropic, so both opt in via output_limit_below_context. Mistral and xAI accept max_tokens up to the window and publish no separate limit, which is why every source reports the two values as equal there — applying the check globally would have replaced correct data with the 4096 default. The gate now fails only for native profiles on an opted-in provider, skips deprecated ones and any model confirmed in model_output_tokens.overrides, and reports the rest as a note. The four gpt-5-*-chat-latest profiles carried 16384 in both fields, hand-entered. 16384 is their real output limit; the context window was the wrong one — both models.dev and litellm report 128000 — so the window is corrected instead. They were also truncating prompts at 16k. * fix(llm): warn when a custom profile sets max_tokens above what the model accepts A custom profile carries whatever the author typed and the model sync never sees it, so nothing catches an oversized max_tokens before the request goes out. The provider answers with a 400 naming a limit the author never saw, and by then the value may not even be in the pipeline file any more. Resolve the configured model name against the node's own catalogue: most custom profiles name a model that is also a profile there, which gives a real completion limit to compare against. Anything above it is named with both numbers. Without a catalogue match, fall back to reporting output equal to the context window. Catalogue entries whose own output equals their window are skipped as a comparison basis - that value is the window, not a limit. * fix(sync_models): check hand-written token limits before the clamp, and keep the sync PR flowing Review feedback. The runtime check ran after validate_max_tokens, so a value the provider would reject could be clamped into a plausible one with nothing left to report. It now reads what the author wrote. It also keyed off profile == 'custom', which misses the profile-less direct-config form and llm_openai_api, whose default profile is 'custom' so an omitted key resolves there without the literal ever appearing. The trigger is now the presence of a hand-supplied token field at either config level, which is what actually distinguishes an author's value from the catalogue's. Added a notice for output above the configured window, since that clamp was silent too. Pin the four gpt-5-chat-latest windows in token_limit_overrides: the modelTotalTokens merge path overwrites unconditionally, and a source reporting no context window for these could let the wrong value back in and recreate output == total on a gated profile. The gate's exit 1 aborted the scheduled job before the keyless sync and the Create Pull Request step, so one stale profile would have halted model updates for all 12 providers every week with nobody paged. The sync steps now continue on error, the PR is created either way with the gate findings rendered into its body, and a final step fails the run so it stays visibly red. Overrides no longer count as confirmed limits under --no-config-overrides, where they are not applied to the catalogue either. * fix(llm): decide the rejection warning on the value that is actually sent The check read the configured value, but validate_max_tokens caps it before the request goes out: 128,000 configured under a 16,384 window is sent as 16,384, which the provider accepts. Saying it would be rejected was wrong in exactly the case where the cap saves the call. Compare the effective value - min(output, total, MAX_OUTPUT_TOKENS) - against the model's limit, and report the cap itself separately, since that is silent too and reads at run time as the model refusing to write more.
…one (#2166) * fix(config): name a config key that is almost, but not quite, a real one A key the engine does not recognise is copied into the merged config and never read again, so the node runs with a default the author believes they overrode. Nothing warns at publish time or at run time; the pipeline reads as correct. The distance between the typo and the symptom is what makes it expensive: 'outputTokens' instead of 'modelOutputTokens' does not fail, it sends a different max_tokens and surfaces much later as an intermittent provider 400. Warning on every unrecognised key was not an option: 15 nodes read keys their services.json never declares (score, similarity, renderChunkSize, table), and flagging those on every run would teach people to ignore the message. So the check reports only a near-certain miss - a known key that ends with the unknown one, which is the dropped-prefix mistake, or a difflib match at 0.9. Measured against the whole catalogue: zero valid keys flagged, and a test holds that line for the 120 services.json files. * fix(config): a casing-only key is a mistake too, and the catalogue sweep must not run on nothing merge() keys off the exact spelling, so MODELOUTPUTTOKENS overrides nothing and the node runs on the default - the same failure the warning exists for. It was being treated as acceptable; it now suggests the canonical key. The catalogue test swallowed load failures and would have passed while checking zero files, which is how an earlier wrong repo-root path went unnoticed. It now lets the error surface and asserts the sweep actually covered the catalogue. * fix(config): catalogue metadata is not a configuration key title, modelSource, deprecated, deprecatedBy, deprecatedSince and migration are what the catalogue records about a profile, not what a pipeline sets. Counting them as known keys meant a near-miss could be answered with one of them - a typo suggesting 'deprecated' as the key the author meant.
…ze crash (#1178) * fix(text-output): install smbprotocol at module level and fix anonymize crash - Move depends() to module level in endpoint.py so smbprotocol is always installed regardless of OPEN_MODE. - Fix STATUS_HEAP_CORRUPTION in anonymize by removing the ThreadPoolExecutor from glinerRecognizer.predict(); GLiNER/PyTorch is not thread-safe and concurrent calls on the same model corrupt the native heap. Fixes #1165 * Remove 'name' property from text output services * fix(text-output): define the SMB fields the parameters object references The build validated services.json and rejected it: Exit: InvalidName (ap:0x27) services.cpp:428 Field name smb.storePath was not found in .../text_output/services.json text_output.target.parameters listed smb.storePath, smb.server, smb.username and smb.password, but no field by those names exists in the node or in nodes/src/nodes/core. The engine resolves every referenced property against a definition, so the node failed to load and the build died on all three platforms. storePath is already a core field, so it is referenced bare, matching local_text_output. server, username and password have no core definition, so they are defined locally under the node namespace, matching the store_astra pattern where astra_db.api_endpoint reaches the node as api_endpoint. That lines the shape up with what endpoint.py already reads: parameters.get('server'), get('username'), get('password') and get('storePath'). The password field is marked secure with a password widget and the 127-character limit that validateConfig already enforces. * fix(text-output): fail validation on SMB config errors, keep reachability advisory The connect() probe this PR enabled reported every failure as a warning, so a rejected credential or a wrong share name passed validateConfig. Split the two cases instead: - EACCES, EPERM and ENOENT fail validation. Each is a configuration mistake the user has to fix. connect() already tolerates ENOENT on the store path (it is created on first write), so an ENOENT arriving here came from the share root and means the share name is wrong. - Everything else stays a warning. Validation also runs on the Platform host, which often has no route to the customer's share, and rejecting a correct configuration there was the reason the probe had been commented out. Also document both lifecycle no-ops in IGlobal, and correct the README, which still claimed the connection was not tested during configuration validation. * fix(text-output): classify SMB failures by NtStatus, scope credentials, keep GLiNER parallel The errno-based split shipped in the previous commit did not work. Verified against smbprotocol 1.17.0: - SMBAuthenticationError derives from SMBException, not OSError, so a rejected credential carried no errno and was downgraded to a warning. That is the one case the README called a blocking configuration mistake. - STATUS_ACCESS_DENIED is absent from SMBOSError's errno table, so it arrives with errno 0 and the EACCES branch never fired either. - errno EPERM comes from STATUS_SHARING_VIOLATION ("file in use by another process"), which is transient, so treating it as a config error was wrong. Classify on NtStatus instead, with an explicit SMBAuthenticationError branch. Rejected, wrong or expired credentials, access denied, privilege not held, a missing share (STATUS_BAD_NETWORK_NAME) and missing names or paths now fail validation. Timeouts, dropped transports, refused connections and sharing violations warn without rejecting. Also: - Register credentials with register_session() against the configured server instead of the process-wide ClientConfig singleton. Validation runs this now, so one endpoint could otherwise overwrite the credential another endpoint was already connected with. - Restore the GLiNER thread pool and hold a lock around predict_entities only. Removing the pool fixed the crash but serialized chunking, offset arithmetic and overlap filtering with it. Output is unchanged: results are sorted and deduplicated before returning, verified identical to the sequential version across multi-chunk, overlap-boundary and dense-entity inputs. - Correct the README, which described the old global credential registration. Tests: 25 for validateConfig covering both failure classes, the smbprotocol hierarchy facts the classification depends on, and probe scope; 11 for predict() covering absolute offsets, overlap dedup, single-chunk input, determinism across runs, forward-pass serialization and label batching.
… them (#2162) * fix(nodes): deprecate claude-opus-4-1, retired by Anthropic Anthropic retired claude-opus-4-1-20250805 on 2026-08-05 and the API now answers not_found_error. The profile is still offered, so anyone selecting it gets failing requests that never reach the usage page. The model sync cannot reach this on its own: the profile carries modelSource: openrouter, so _source_is_authoritative() lets only OpenRouter deprecate it, and OpenRouter still lists anthropic/claude-opus-4.1 with no expiration date. Marked by hand until that gap is closed. * fix(sync_models): a hand-marked deprecation is no longer undone by the sync _source_is_authoritative received two vocabularies and recognised neither fully: the deprecation path passes display labels ('Anthropic API'), the enrichment path passes internal keys ('openrouter'), and the function compared against 'provider API' and 'OpenRouter'. So the native API could never deprecate a profile, and OpenRouter could never lift one - the reverse of what the docstring describes. Normalise both vocabularies to one key. That fix alone would delete the deprecation added in this branch on the next run, since OpenRouter still lists claude-opus-4.1. So record deprecatedBy when the sync marks a profile, and only lift a mark the sync itself made. A profile deprecated by hand carries no deprecatedBy and stays: a provider that keeps listing a model it has retired is precisely why someone marks one by hand, so seeing it in the listing again is not evidence to the contrary. Without this the four hand-marked gemini profiles would be reinstated on the next sync with a Gemini key, since models.list() still returns retired models. * fix(sync_models): decide deprecation authority on canonical source keys Review feedback on the ownership model. The lift required deprecatedBy to name the same source that is running, but the OpenRouter expiration branch stamps a mark without checking authority and can therefore mark a 'provider' profile. Matching on the stamp left that profile deprecated with no source able to clear it - worse than the behaviour it replaced. Any source with authority over the profile may now lift a mark the sync applied; hand-applied marks carry no deprecatedBy and stay protected either way. Authority is decided on canonical keys ('provider'/'openrouter'/'litellm') threaded from primary_source, replacing the label heuristic that would have granted provider authority to any future '<Something> API' string. The display label stays prose for the migration message. A mark left standing while the source lists the model again is now reported instead of landing in unchanged, which surfaces the existing hand-marked profiles that need a one-time decision. * fix(sync_models): a standing deprecation mark is not a pure skip has_changes() drove an early return that rendered a provider as SKIPPED and moved on, so a provider whose only finding was a profile listed again while still deprecated had that finding dropped from both the console output and the PR body - the exact case the previous commit added the report line for. * feat(sync_models): re-verify catalogue models by calling them The smoke gate validates additions only: a model already in services.json is accepted without being called, so one that entered correctly and was retired six months later stays in the catalogue forever. The live test does not catch it either - it asks the listing endpoint, and providers keep returning models they have retired, with generateContent among the supported methods, refusing only when the model is actually called. --verify-existing calls every active profile and deprecates the ones the provider reports as gone, carrying over the replacement the provider names when it names one. Only a message identifying the model as unavailable qualifies; a rate limit or a permission error never deprecates anything. That evidence bypasses the authority rule, deliberately. Absence from a listing means little across sources - an OpenRouter alias missing from a provider's API is expected - but a direct refusal does not: a profile discovered through OpenRouter is just as unusable once the provider behind it has retired the model, and OpenRouter will keep listing it regardless. The gemini live test now makes one real call per profile instead of trusting the listing, which is the check it always claimed to be. * fix(nodes): deprecate the five gemini profiles the API refuses to run Verified with a real generateContent call per profile against a current key, which is what --verify-existing does: models/gemini-2.5-pro, 2.5-flash, 2.5-flash-lite, 2.5-pro-preview and 2.5-pro-preview-05-06 all answer 404, 'no longer available to new users'. All five are still listed by models.list() with generateContent among their supported methods, which is why nothing had noticed. Google names the replacement for three of them and those go into the migration notes; the two preview IDs are simply gone with nothing suggested. Also repointed two existing notes: gemini-2.0-flash and 2.0-flash-lite were directing people to 2.5-flash and 2.5-flash-lite, both of which are in this same batch. Every migration target now resolves to a profile that runs. * fix(sync_models): classify a failed call, and keep call-made marks out of the listing path Two problems the larger scope introduced. A call-verified retirement was stamped deprecatedBy: 'provider', which the lift path reads as ordinary listing evidence. The premise of the feature is that the provider still lists the model, so the next scheduled run - which never passes --verify-existing - would find it listed, find the provider authoritative, and resurrect it, deleting the replacement note. With the flag on every run it would churn every other run. Such a mark now records 'provider-call', deliberately outside SOURCE_KEYS so the listing path cannot touch it, and is lifted only by a call that passes. Retirement was decided by substring matching a flattened string, and the guard meant to keep transient errors out never ran, because base.py passed reason (a str) where an Exception was expected. Worse, the patterns matched access-gated 404s: OpenAI answers 'does not exist or you do not have access to it' for a retired model and for one the key cannot reach, and Anthropic returns not_found_error for org-restricted models, so a CI key without a tier would have deprecated every gated-but-live model in one run. Classification moves to the smoke layer and reads the typed exception. A bare 404 is now 'missing' - reported, never acted on - and only a provider stating the model is gone yields 'retired'. Verified against the live Gemini API: the three models Google declares retired classify as retired, the two ambiguous 404s as missing, a live model passes. * fix(sync_models): an OpenRouter expiry only deprecates what OpenRouter owns The expiration branch changed deprecation state with no authority check, so an entry OpenRouter marks expired could deprecate a 'provider' or 'manual' profile whose model the native API still serves - and a keyless run is enough to do it. This is the smallest of the two fixes offered in review; the other one (letting an authoritative source lift any sync-applied mark) is already in. Both belong: one stops the wrong profile being marked, the other stops a mark being stranded. Ownership now reads the same in every direction - absence, expiry and lifting - while a direct call still overrides it, since a model that will not run is gone whoever discovered it. * fix(sync_models): a majority of retirements is an API failure, not a catalogue dying Review feedback, and the loose end in the verification: a retirement message is per-model evidence, but a break one level up produces the same message for every model at once. Retire an API version and every call answers with the same 404 carrying the same wording - which is exactly what the retirement phrases match - and a single run would deprecate the whole provider. Above half the verified models, the run now deprecates nothing, moves those findings to the unverified list and warns. Providers do not retire most of a catalogue at once, so a majority verdict says more about the API than about the models; a real mass retirement is then applied deliberately rather than swept in. The threshold check is a named function so the boundary is pinned by tests rather than inferred from a run: five of twenty-six is believed, exactly half is not a majority, and a verified count of zero is never judged.
#1178 gave text_output a password field for SMB shares but did not regenerate the credentials catalog, so nodes:credentials-check fails on develop and takes every PR that rebases onto it down with it. Curated rather than left as the generated stub: the field is optional in services.json, so required is false, and the title says what it is instead of repeating the path.
* feat(tool_notion): add Notion tool node Exposes a Notion workspace (search, pages, databases) to agents as eight tools, targeting the 2025-09-03 database/data-source API split (Notion-Version 2026-03-11) rather than the older single-database shape. No live workspace has exercised this end-to-end, so the node is marked experimental. * fix(tool_notion): address CodeRabbit findings on parent type, title property, trash field, and write retries Verified each finding directly against developers.notion.com before applying: - parent.type must be "page_id"/"data_source_id", not the bare "page"/"data_source" the create-page body was sending. - A data source's title property isn't always called "Name" (e.g. "Task") -- look it up from the schema instead of guessing. - The update-page and get-page paths used a nonexistent "archived" field; the real fields are "in_trash" (request) and "in_trash"/ "is_archived" (response). - Writes (create/update/append) no longer retry: Notion has no idempotency key for these endpoints, so retrying a mutation whose response was lost to a connection error risked creating duplicate pages or content. - notion_append_content now batches into groups of <=100 blocks and rejects lines over 2000 characters, matching Notion's documented request limits. - Pin requests>=2.34.2 as a baseline floor. Declined: collapsing credentials.json's two apikey catalog entries into one. Verified via credentials.py that this does make both entries required for "configured" status, but the same generator output (a prefix-keyed path plus a node-name-keyed path, both required) already exists uncurated on every other tool_* node with a single apikey field (tool_apify, tool_exa_search, tool_deepl, tool_tavily) -- a pre-existing, repo-wide generator behavior, not a defect introduced by this node. * fix(tool_notion): drop the nonexistent is_archived fallback in notion_get_page Re-verified against Notion's page object reference and changelog: "archived" was deprecated in April 2024 and fully removed/renamed to "in_trash" in API version 2026-03-11 -- they are the same state under old/new names, not two independent fields. The "is_archived" name came from an earlier, less authoritative fetch and doesn't actually exist on the current page object; reading it was harmless (always None) but implied a real field that isn't there. * docs(tool_notion): add shared-surface entries for the Notion node Adds the three shared-surface pieces flagged in review: the node catalog row in docs/README-nodes.md, the CHANGELOG entry, and the generated params block in the node's README. --------- Co-authored-by: madhumithachandrasekaran31 <madhumitha2110549@ssn.edu.in>
Catch provider 400s that reject ReAct stop/stop_sequences (including Anthropic message-only bodies) and retry once before any chunks are emitted, without dropping token-usage metering from the Adapter.
… tool (#2130) * feat(tool_crustdata): add Crustdata company/people search as an agent tool Adds tool_crustdata, giving an agent B2B discovery: company_search and person_search against Crustdata's filter-based /company/search and /person-docs/search API. Same pattern as tool_exa_search (single API key, plain requests, no vendor SDK, structured {success, ...} JSON returns, no pipeline lanes). UNVERIFIED SURFACE (#2129): built from Crustdata's public docs, not against a live account. The filters shape (list of {filter_type, type, value}) and both endpoints are corroborated across multiple doc pages, but the exhaustive filter_type enum and exact response envelope aren't confirmed -- response parsing is deliberately defensive (_extract_records tries several plausible top-level keys) rather than assuming one exact shape. Marked experimental for the same reason. Also registers the node's mock apikey in the dynamic test framework's per-node credential table (nodes/test/framework/pipeline.py), matching every other apikey-gated tool node -- without it the framework's own pipeline-open test fails on the empty placeholder key that ships in the real default profile. * fix(tool_crustdata): correct the search contract per Crustdata's real API reference CodeRabbit's review on #2130 flagged that the endpoint/filter shape this node shipped with didn't match Crustdata's current API. Verified independently by fetching docs.crustdata.com's own versioned reference pages directly (not paraphrased) -- three prior research passes (mine, CodeRabbit's, and a third-party dev's notes) had disagreed with each other, so this reads the primary source rather than trusting any one of them: - person_search now hits /person/search, not /person-docs/search. - filters are now a list of {field, type, value} conditions the node wraps into Crustdata's {op, conditions} group form, not a bare array of {filter_type, type, value} sent as-is. - pagination is now cursor-based (cursor in, next_cursor/total_count out), not the page integer the node sent before -- Crustdata's API doesn't have a page parameter at all. - limit range widened to the documented 1-1000 (was 1-100, an invented number). - added an optional sorts passthrough, since Crustdata's docs warn a missing/changed sort order invalidates the pagination cursor. Also, from CodeRabbit's other two findings: - IGlobal.beginGlobal() no longer raises out of the engine lifecycle on a malformed defaultLimit (e.g. an empty string from a hand-edited .pipe file bypassing the UI's own type coercion) -- extracted _coerce_limit(), used by both beginGlobal and a new validateConfig warning, with tests for the malformed-input paths. - test_timeout_is_reported_as_a_structured_error_not_raised now mocks time.sleep like the other retry tests; it was previously the one test in the suite that actually slept out its ~14s of backoff. The module docstring, README, and services.json capability comment are updated from "unverified surface" to "verified against Crustdata's reference, not yet against a live account" -- the schema is no longer a guess, only the untested runtime behavior (plan-tier gating, the full per-entity field enum) remains open per #2129. * fix(tool_crustdata): drop all_of from the generic match parameter CodeRabbit's second review pass on #2130 flagged that 'match' offered 'all_of' as a third option alongside 'and'/'or'. Verified independently against the actual OpenAPI schema for the company search endpoint (docs.crustdata.com/api-reference/company-apis/search-companies-with- indexed-fields-only): its op enum is exactly ['and', 'or'] -- all_of isn't a company-search option at all. Person search does document all_of, but it isn't a generic combinator: it's constrained to a single nested-array field path (employment, education, ...), rejects scalar fields, can't hold negation operators, and can't nest another all_of/has_all inside it. None of that fits a flat "combine any conditions" match parameter shared by both tools, so it's dropped from the schema entirely rather than exposed and silently misbehaving on the conditions an agent actually sends. * fix(tool_crustdata): use shared post_with_retry, coerce per-call limit Addresses joshuadarron's review on #2130: the hand-rolled retry loop dropped ConnectionError retries (the same regression tool_tavily shipped and fixed); switching to the shared post_with_retry helper fixes that and matches the tool_tavily/tool_v0/tool_deepl convention. Also reuses _coerce_limit for the per-call "limit" argument so a stringy value like "50" from the model isn't silently discarded, and adds tool_crustdata to the docs/README-nodes.md catalog. * fix(tool_crustdata): patch tenacity.nap.time.sleep, not nap.sleep CodeRabbit caught it on #2130: tenacity's BaseRetrying binds its sleep default at import time (sleep: Callable = sleep), so patching the tenacity.nap.sleep attribute afterward doesn't touch the callable Retrying actually invokes. It still calls time.sleep under the hood, so that's the real patch target. Confirmed empirically — the previous target let real sleeps run (test file took ~44s), the fix drops it to ~0.3s with identical assertions passing. --------- Co-authored-by: madhumithachandrasekaran31 <madhumitha2110549@ssn.edu.in> Co-authored-by: Dylan Savage <130109357+dylan-savage@users.noreply.github.com>
#1608) * feat(gcp): implement native nodes for firestore, gcs, and vertex ai (#1515) * fix pr #1608 issues including GCP auth keys, Firestore startup, linting, and docs * Fix data url parsing by checking for data: prefix instead of comma * fix(gcp): address PR #1608 review feedback Apply OAuth scopes for service-account auth, ship Vertex as tool-only without process-global aiplatform.init, and harden GCS downloads plus Firestore startup probing. Co-authored-by: Cursor <cursoragent@cursor.com> * added an adc test with custom scopes * fix(gcp): address remaining PR #1608 review feedback Place node icons beside services.json, ship Vertex as tool_vertex_search, bound GCS temp files, and add unit tests plus catalog/CHANGELOG rows. * fix(gcp): stop GCS/Vertex tests from clobbering the real ai package Replacing ai with a non-package stub leaked into later node tests on CI and failed the OS matrix Test step. * fix(gcp): import tool_function from rocketlib like every other node ai.common.tool does not exist, so the engine failed to load the new Firestore/GCS/Vertex nodes during the OS-matrix Test step. Use rocketlib.tool_function with input_schema and the args-dict invoke contract, and restore sys.modules around the unit-test imports. * fix(gcp): stub google.auth so CI gcp_auth tests can run without the SDK CI pytest does not install google-auth, and ROCKETRIDE_MOCK google has oauth2 but no auth submodule. Validate config before the import so missing-key and unknown-type errors do not depend on the SDK. * fix(gcp): stop gcp_auth tests from unloading native google modules Windows workers crash if google.protobuf is popped from sys.modules. Load the google package before stubbing auth, and only mark google-auth import targets as missing. * fix(gcp): restore google-auth sys.modules slots after gcp_auth tests * resolving code rabbit comments * chore(nodes): add MIT license headers to new GCP node files The ten new files added for the Firestore, GCS, and Vertex Vector Search nodes shipped without the license header every other node source file carries (635 of 650 before this change; all five recently merged node suites are at 100%). Uses the same header variant as the sibling shared-auth modules in nodes/src/nodes/core (google_access.py, microsoft_access.py). Comments only: no code moved, ruff check/format clean, nodes:test unchanged at 3984 passed / 239 skipped. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01WvgPXbYqQoi7xyC5J4QVXb --------- Co-authored-by: Cursor <cursoragent@cursor.com> Co-authored-by: Dylan Savage <130109357+dylan-savage@users.noreply.github.com> Co-authored-by: Dylan Savage <dylanmsavage@hotmail.com> Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
…API (#1700) * fix(tool_google_workspace): make check_connection actually probe the API connection_ok was derived only from local checks (client constructed, token scopes claimed) for gmail/drive/docs/sheets, since check_connection called _check_connection_impl() without a probe. calendar was the only service with a live probe wired, so a disabled Google API on the caller's project was invisible everywhere else — connection_ok: true while every real call 403'd. - Wire a live probe for gmail (users().getProfile), drive (about().get), and docs/sheets (a made-up-id get(), swallowing the expected 404 since neither API has a list/about endpoint to probe cheaply). - _check_connection_impl no longer defaults to True when no probe runs; it reports 'unknown' instead, and fixes a bug where the scope-coverage check could silently coerce that sentinel back to a bool. - execute() now attaches the structured Google reason code (e.g. accessNotConfigured vs forbidden vs rateLimitExceeded) to raised errors, surfaced as errorReason. Closes #1694 * test,docs(tool_google_workspace): decouple test fixtures, fix scope-check wording Test fixtures for the accessNotConfigured probe-failure case set _HttpErr's raw HTTP reason to the same string as the structured JSON body's error reason ('accessNotConfigured' both places). errorReason is verified to come exclusively from the parsed JSON body (_error_reason_code never reads .reason), but with both fields equal, the test couldn't tell that apart from a future regression that accidentally read the generic .reason instead. Decoupled all four (docs/drive/gmail/sheets): .reason is now 'Forbidden', 'accessNotConfigured' stays only in the JSON payload. Verified by temporarily making _error_reason_code read exc.reason directly -- all four then fail with 'Forbidden' != 'accessNotConfigured' as expected, confirming they'd catch that exact regression; reverted and confirmed the real implementation passes all four again. README diagnostics bullets (docs/drive/gmail/sheets) said check_connection "verifies that granted OAuth scopes cover the configured access tier and probes the API" as one combined behavior. _check_connection_impl runs the live probe unconditionally regardless of auth type, but only runs token_scope_report inside `if auth_type == 'user':` -- service-account connections get probed but never get a scope check (there's no per-user grant to check). Reworded to state the two facts separately with their actual conditions. * fix(tool_google_workspace): parse the One Platform error shape, fix calendar docs drift _error_reason_code only read the legacy error.errors[] body (Gmail, Drive). Sheets and Docs are One Platform APIs and carry the reason in error.details[] as a google.rpc.ErrorInfo instead, with no errors[] array at all -- so a disabled Sheets/Docs API, the actual #1694 scenario, never got an errorReason. Now parses both shapes, falling back further to the coarser error.status when even ErrorInfo is absent. _is_rate_limit_403 normalizes the SCREAMING_SNAKE_CASE ErrorInfo reasons to match its existing set. Also: - calendar's tool description and README now use the same "live probe + scope coverage" wording already applied to the other four services. - raise the probe-error truncation cap (200 -> 500 chars) so the actionable guidance clause isn't cut mid-sentence. - a scope-check failure no longer overwrites a probe failure's error message; it now reports separately as scopeError (with the two tests that asserted the old key updated to match). --------- Co-authored-by: madhumithachandrasekaran31 <madhumitha2110549@ssn.edu.in>
…ft 404) (#2198) Marketing routes are served as prerendered static captures. Googlebot renders JS: it runs the capture's inline bootstrap, the shell boots, createRoot(#root) CLEARS #root, then the shell waits on its /task/service WebSocket before it has app content. A crawler opens no sockets, so ShellLayout would paint the ConnectionErrorBanner ("Can't reach the server") over the good content — a Soft 404 (reproduced across all 12 prerendered routes, Mithilesh's WS-stub repro). Fix (createRoot clears #root, so a plain `return null` would just blank it): - util/prerenderFallback.ts: capturePrerenderedContent() snapshots #root's HTML BEFORE createRoot clears it — only when <html data-prerendered="1"> (the capture marker; companion prerender.mjs change sets it). No-op otherwise. - bootstrap.tsx: capture before createRoot. - ShellLayout.tsx: at the TOP of render (before the LoadingScreen and error returns), until real app UI mounts, re-render the captured HTML back INTO #root (dangerouslySetInnerHTML; display:contents keeps #root's layout; the innerHTML scripts do not re-run). A monotonic hadAppUiRef latches once app UI mounts so a later app-switch/reconnect dip never re-shows the one-shot capture. Non-prerendered loads have no capture -> the guard is skipped -> the existing LoadingScreen / ConnectionErrorBanner (Retry / Sign in) behaviour is unchanged. Claude-Session: https://claude.ai/code/session_015nTVr6jfSFYm1GppxbjghP Co-authored-by: Dmitrii Karataev <dmitry.karataev@gmail.com> Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>
…son when profile is set (#2039) * fix(ai): getNodeConfig drops top-level keys when profile is set When connConfig has an explicit "profile" key, getNodeConfig only read connConfig[profile], ignoring every key the caller wrote at the top level (e.g. an "apikey" alongside "profile" instead of nested under the profile name). The other branch (no "profile" key) already overlays top-level keys on top of a nested profile-named block; the two branches disagreed about where a caller's configuration could live depending on whether "profile" happened to be set. Extract that overlay into a shared helper (overlay_top_level) and use it in both branches, so a key written at the top level is honoured whether or not "profile" is set, and both branches agree on precedence: profile defaults < nested profile block < real top-level values. The "profile" selector key itself is now explicitly excluded so it can't leak into the resolved config. Confirmed independently against a real pipeline: an llm_anthropic node configured with {"profile": "claude-sonnet-4-6", "apikey": "..."} (flat) silently received no API key, while nesting the same apikey under connConfig["claude-sonnet-4-6"] worked - reproducing exactly what's described in #1839 defect 1. Adds TestExplicitProfileBranchTopLevelFields covering the fix, and renames the test class that pinned the old (dropped) behavior to TestExplicitProfileBranchNestedShape since it no longer stands alone. Fixes #1839 * fix(ai): normalize getNodeConfig's return value with IJson.toDict Addresses #1839 defect 2: array/object config values arrive from the engine as IJson, not list/dict, so a node that type-checks its own declared field (isinstance(value, list)) silently falls through to its default. IJson.toDict already does the recursive conversion and is a no-op on values that are already native, so apply it once at the return boundary rather than pushing the conversion onto every node, per the issue's own suggested direction. Adds TestNativeConfigTypes (3 tests) and upgrades the test file's IJson stub from a shallow dict-only shim to one that actually wraps a value and recurses, matching the real rocketlib.types.IJson.toDict closely enough to exercise this. Also adds docstrings to the defect-1 tests to close out the docstring-coverage gap flagged in review. Full suite: 21/21 passed (up from 18; +3 new). * docs(ai): add docstrings to remaining test methods in test_config_shapes Closes out the docstring-coverage check, which scores the whole file: the pre-existing test methods (written before this PR) had none, relying on their names alone. Every function in the file is now documented; no behavior change. * docs(ai): add class-level docstrings to remaining test classes Covers the four test classes (TestFlatShape, TestNestedShape, TestMixedShapePrecedence, TestExplicitProfileBranchNestedShape) that had per-method docstrings but no class-level summary of which connConfig shape they exercise. File is now fully documented at both the class and function level (35/35). No behavior change. * fix(ai): read the nested profile block via IJson.toDict, not isinstance rocketlib's IJson subclasses the engLib IJson the engine actually constructs, and config.py imports the subclass. Every value the engine produces is a base-class instance, so isinstance(value, IJson) is False in production. overlay_top_level() type-tested the nested profile block on that check, so it took the else branch and used an empty dict -- discarding the whole block. The node test harness builds exactly that shape ({"profile": "default", "default": {"apikey": ...}}), which is why every node with mock credentials failed with "apikey is required", and why the lane guardrail failed with "Model name was provided but is empty". Develop carries the same broken check on its default-profile branch, but harmlessly: when it fails it falls back to using connConfig whole. This PR made the check the only path in, so failing it lost the config. Normalize with IJson.toDict() first -- it tests against the correct base class and is a no-op on already-native values -- then inspect the result. This also removes the dict(<list>) path that raised "dictionary update sequence element #0 has length 27". The unit tests missed all of this because the _FakeIJson stub was a single flat class that isinstance matched. Split it into _EngineIJson (the engLib stand-in the engine constructs) and _FakeIJson (the rocketlib subclass config.py imports) so the trap is reproducible, and add TestEngineSuppliedConfig. Two of those four fail against the old code. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01R6gbzJyEdgWhSHPgswzw5L --------- Co-authored-by: Dylan Savage <dylanmsavage@hotmail.com>
A task running parse beside a node that imports torch died at start with SIGSEGV at 0x20 in libstdc++: Tika's prebuilt lib7-Zip-JBinding.so carries a statically linked GCC libstdc++ whose GNU-unique locale facet ids bind process-wide to the first definer, so loaded into a libc++ engine it renumbered the system runtime's facet table and the next std::ostream to format a number reached a facet that was not there. plat::lin::init() now claims libstdc++.so.6 with RTLD_GLOBAL, beside the Crashpad registration and for the same reason. One runtime owns the ids and a bundled copy arriving later is inert. Fails open where the library is absent, since a host without it cannot load GCC-built code either. Linux only. Costs 0.86 MB resident, shared and file-backed, and 0.42 ms once per process. Fixes #2676 (cherry picked from commit 074c316) Co-authored-by: Claude Opus 5 <noreply@anthropic.com>
…2714 to stage) (#2715) * fix(agent_rocketride): log the wait for timed-out calls as a warning When a tool call times out, the run waits for it to return before it ends (#2521). It logged that wait with rocketlib.error(), which puts it in the task's errors. The canvas shows a node with any error as failed, so a run that handled the timeout and answered normally looked failed. The wait is now a warning. The wait itself is unchanged. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * test(agent_rocketride): release the timed-out call from a named function --------- Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
…tage) (#2733) * fix(ai): cut ClickHouse's remaining statement echoes and stop cutting other dialects' text `_format_db_error` ran one marker list over every driver's message. Two defects followed, both found by a QA run on live MySQL 8.4 and ClickHouse 25.8: - ClickHouse still echoed the statement, with the bind values clickhouse-driver interpolates client-side, in three places the markers missed: a named CTE or lambda scope (`in scope x AS (SELECT ...)`, `in scope x -> ...`), code 215's `In query SELECT ...`, and a mutation's `while processing: '<expr>'`. These are now cut, along with the same CTE form after `In query` and the old interpreter's `: While processing`. The lookaheads still need the shape ClickHouse's formatter prints, a keyword followed by a space included, so prose that shares the words survives. - One dialect's markers cut another's own text: a MySQL SIGNAL reading "Upload failed at position 3 of batch" came back as "Upload", and `throwIf(1, 'In scope SELECT secret')` came back as `DB::Exception:`. A branch that recognised its driver now cuts only with that driver's markers: none for pymysql, since MySQL appends nothing and SQLAlchemy's tail is never in `args`, and ClickHouse's for clickhouse-driver. Every marker still applies, as a backstop, on the branches that cannot tell which driver wrote the text. A throwIf failure (code 395) keeps the caller's message whole. The runtime context after it is kept too, unless a marker fires inside it, in which case it is dropped whole. Of the 106 distinct native messages QA captured, exactly the 24 cases above change, and no bound value survives that did not before. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit fc6afce) * fix(ai,nodes): stop describing ClickHouse sessions as transactions The `execute` tool description and the db_clickhouse README told callers to recover a session with `rollback` or `rollback to savepoint <name>`, and the begin/commit/rollback tools described a transaction. On ClickHouse, clickhouse-sqlalchemy's native connector makes commit and rollback no-ops, so every statement is executed when it is sent. Savepoints do not exist either: SAVEPOINT is a syntax error. An agent following the advice would believe its work was discarded when it was not. `_sessionsAreTransactions()` is false for the clickhouse dialect. The four session-related tool descriptions read it and say what a ClickHouse session actually does; every other dialect keeps its existing wording. The README's tool table and session paragraph now say the same. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit b177971) * test(ai): replace the constructed ClickHouse and MySQL error shapes with live captures The error-formatter tests built some messages by hand because no live server was available. Those shapes are now captured from ClickHouse 25.8.33.6 and MySQL 8.4.11 with clickhouse-driver 0.2.9 and pymysql, and each test names the statement it was captured for. - The multi-argument lambda scope, `In query` after a named CTE, and the old interpreter's `: While processing` arrive as the tests assumed. Only the database name in the 215 message and the column in the alias test change. - A lazy throwIf inside `if()` reports an `if(...)` runtime context, which ClickHouse truncates with `...` in the middle of a literal. The formatted result is the same. - A throwIf inside a scalar subquery gets no `In scope`, before or after its runtime context. A new test pins this. - MySQL returns the hand-built SIGNAL texts verbatim. The formatter itself does not change. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit 4f60846) * fix(ai,nodes): route error text by who wrote it and keep the backstop narrow Answers dylan-savage's review on #2713. - pymysql's `(errno, message)` branch keeps a strip again. The pair names the wire protocol, not the server: db_mysql pointed at ClickHouse's MySQL interface receives `(47, "Code: 47. DB::Exception: ... in scope SELECT ... '<bound value>'")`. Text naming `DB::Exception:` is now cut with ClickHouse's markers, throwIf protection included, and the duplicated `Code: N.` prefix is dropped. MySQL's own text keeps SQLAlchemy's markers only, so SIGNAL text stays whole. - The backstop used by the SQLSTATE, `args[0]`, `str(orig)` and `str(exc)` branches is back to the pre-#2713 marker set. The ClickHouse-only markers apply only to ClickHouse's text. `clickhouse_driver.dbapi`'s `OperationalError(ServerException)` is unwrapped into the ClickHouse branch, so that layer keeps every echo fix. - New ClickHouse echoes are cut: - the input a parser prints after ` here: `, which for `INSERT ... VALUES` is every later row with its bound values; - a function-call scope, `In scope nofunc('<value>')`. - The throwIf split anchors on `: while executing 'FUNCTION `, so a caller's own "while executing" stays in the message. The code check now runs before any partitioning, and `Stack trace:` is defined once. - `_sessionsAreTransactions()` is True in the shared base and overridden in db_clickhouse's IInstance. The wording uses the node's display name. The `session_id` schema text and the unknown-session error no longer say "transaction" on a node without transactions. The README's session_id, allow-execute and throwIf wording now match. Tests use messages captured live from ClickHouse 25.8.33.6, both native and over its MySQL interface. 16 of them fail on 4f60846 and pass here. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit 220950b) * fix(ai,nodes): use ClickHouse's markers only on text ClickHouse wrote Follow-up from an independent review of the previous commit. - A `.code` / `.message` pair is not ClickHouse's shape alone, so its text is cut with ClickHouse's markers only when it opens with `DB::Exception:`. Other text gets the backstop again, as it did on develop. The one-element-`args` unwrap applies only when the inner text is ClickHouse's. Before this, another driver's wrapped error could lose the backstop's DETAIL/LINE cut. - ClickHouse text is recognised with one anchored pattern, `\A(?:Code: N. )?(?=DB::Exception:)`, on both the native and the MySQL-wire paths. MySQL text that merely mentions the phrase stays whole. - The new node test loads `db_clickhouse.IInstance` through a bare package module, so collection no longer runs the node's `depends()`. - Docstring corrections: the `(int, str)` strip, SQLAlchemy's tail markers, and the commit/rollback method docstrings. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit 6c18adb) * fix(ai,nodes): cut ClickHouse's `before:` echo of the rest of the input ValuesBlockInputFormat expects `,` or `(` after a closed row. When it finds anything else, the error is code 27: `Cannot parse input: expected '(' before: '<rest of the VALUES input>'`. The rest of the input is quoted there, with every later bound value in it. Agents produce this easily by writing another dialect's upsert, such as `ON DUPLICATE KEY UPDATE s = $3` or `ON CONFLICT ... DO UPDATE`. `FORMAT CSV` adds per-row `parsed text` lines after the same phrase, and those repeat the earlier rows' values. ` before: '` is now a ClickHouse-only marker. It is cut natively and over the MySQL interface. Every message in the new tests was captured live from ClickHouse 25.8.33.6. The two extra `here:` cases also come from that capture. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit ade0f13) * fix(ai): recognise an older ClickHouse server's exception class Older servers name their parse errors' class `DB::ParsingException:`. Those are the errors that carry the `here:` and `before:` echoes. Detection now accepts any `DB::<name>Exception:`, so that text still gets ClickHouse's markers, natively and over the MySQL interface. Also corrects the module comment: it no longer says the backstop runs every group, and it no longer says the ClickHouse-only lookaheads belong to the backstop. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit 4aff10d) * fix(ai): recognise ClickHouse 23.x driver text and cut its remaining echoes Answers dylan-savage's review 5578809432 on #2713. - clickhouse-driver writes an older server's exception subclass twice, `DB::ParsingException. DB::ParsingException: ...`. The start-anchored check missed that, so on 23.x the `before:` echo and its bound values reached the caller. Detection now has one anchored pattern per arrival shape, each read off live 23.8.16.16 and 25.8.33.6 servers: - the driver's `.message`, with the repeated class name dropped; - `str()` of the driver and dbapi exceptions (`Code: N.` and a newline, optionally behind clickhouse-sqlalchemy's `Orig exception: `), and clickhouse-connect's one-line wrapper when both codes are equal. On these backstop branches the cut is the earlier of the unchanged backstop and ClickHouse's markers, so it can only remove more; - the MySQL interface's `Code: <errno>. `, which must now repeat the pair's own errno. A MySQL SIGNAL whose text starts with `DB::Exception:` stays whole. Text that only contains ClickHouse's class on a later line is not reclassified. - More echoes are cut, all captured live: ` at: ` after a quoted type (code 53), the expression after `Cannot deduce template of expression:` (62) and `(result column not found):` (36), a text input format's `Row N:` / `Column N` diagnostic (117, 72, CSV/TSV), and `in scope` in any expression shape. The throwIf runtime-context check keeps the old `in scope` shapes, so a caller's "not in scope for this trigger" passes. - When ClickHouse's markers leave only the exception class, the error says the message only repeated the statement instead of returning a bare header. - Shared markers are defined once (the backstop pattern is unchanged), `_strip_clickhouse_detail` has one return path, and the dbapi layer is classified once. The docstring now says MySQL 1064 quotes the rest of the statement, up to 80 characters. 47 new tests; 29 of them fail on 4aff10d. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit d2613ba) * docs(nodes): state the SQL error contract each node actually returns Answers items C, D and G of dylan-savage's review 5578809432 on #2713. - db_mysql README: documents what the pymysql branch does. Only SQLAlchemy's tail is removed, a SIGNAL's text comes back whole, and a 1064 `near '...'` quotes the rest of the statement from where the parser stopped, up to 80 characters, so a value bound after that point can appear. It also states when text from ClickHouse's MySQL interface is treated as ClickHouse's. - db_clickhouse README: the removed shapes are now a list that matches the markers, plus the 23.x class prefix, the `str()` and clickhouse-connect shapes, and the bare-message fallback. - The four SQL node READMEs no longer say the full text "stays in the server log". It is written to the engine log; only the error `execute` returns is trimmed. - `begin`, `commit` and `rollback` docstrings are provider-accurate. - A new test pins that db_mysql, db_postgres and rocketride_sql keep transactional sessions, so only db_clickhouse opts out. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit 8ecdad4) * docs(nodes): make two db_mysql error-contract sentences exact A SIGNAL's text is cut at SQLAlchemy's markers like any MySQL message, so "returned exactly as written, whatever words it contains" overstated it. A SIGNAL that copies ClickHouse's whole prefix can get the fixed "only repeated the statement" note appended, so "nothing is added" becomes "no part of the statement is added". Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit 93636ff) * fix(ai,nodes): move ClickHouse error formatting into the db_clickhouse node Answers dylan-savage's review 5588942190 on #2713, items 1-3. - db_clickhouse's IGlobal overrides `_format_db_error`. Every clickhouse-driver error, found in `.orig` or as the only argument of a dbapi error, is cut at the first place ClickHouse repeats the statement or its input. The driver's doubled class name is dropped. A `throwIf` (code 395) message comes back whole with its runtime context dropped. Anything else goes to the shared formatter. - The shared fallback no longer carries ClickHouse's markers, so MySQL's own text (a SIGNAL reading "Upload failed at position 3 of batch") is no longer cut by them. The pymysql branch is develop's again; db_mysql pointed at ClickHouse's MySQL interface is not supported. - No pattern has a leading `\s*` any more. The `Row N:` marker is bounded. A 4,000-space run that took 28 s to format now takes 0.26 ms (develop: 141 ms); 100,000 spaces take 6 ms. - Tests: the 1,929-line dialects file is replaced by one table of live ClickHouse 23.8.16.16 / 25.8.33.6 captures that asserts properties (no bound value, the sentence survives, no stack trace) on both driver routes, plus two-stage timing tests. The eight develop tests that ran ClickHouse text through the shared base move into that table. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit b856c10) * docs(ai,nodes): shorten the SQL error and session docs to what the code does Answers item 4 of dylan-savage's review 5588942190 on #2713. - db_clickhouse README: one paragraph that lists what the node removes, and states that a `throwIf` message comes back whole while a 395 without its runtime context gets the markers. - db_mysql README: only SQLAlchemy's tail is removed. A SIGNAL's text comes back whole. A 1064 `near '...'` quotes up to 80 characters of the rest of the statement, so a later bound value can appear (#2732). ClickHouse should use db_clickhouse. - Both rewritten paragraphs say the full text is written to the server log, not that it stays there. - `begin`, `commit` and `rollback` docstrings are one line each. The session hook and the provider-aware tool descriptions are unchanged. - Reverted as out of scope: the db_postgres and rocketride_sql README sentences, and the extra session pin test. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit 9508c8f) * test(nodes): say which ClickHouse error rows are constructed The table comment said the last two rows were constructed. The constructed rows are the four added after the list, with ids starting `constructed-`; the last two rows of the list are live captures. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit 4259340) --------- Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
…er is refused (#2688 to stage) (#2689) * fix(agent): report why a run stopped when it fails before its first status #2519 says the last status event of a run carries its stop reason on every exit. Two exits in AgentBase.run_agent sent none: - A driver that raises before its first status. agent_rocketride checks its verify_tool before anything else (#2520), so a check tool that is not connected ended the run with the error as the answer and no status event: the chat UI was left on its last state with no stop_reason. - The require_tool_call guard. The run's own last status could say "done" while the answer was refused. Both exits now send a last 'thinking' status with stop_reason 'error'. The send is best effort: the answer is already built, and a failed send must not replace it. Runs that answer normally send nothing extra. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(agent): log a status that could not be sent as a warning When the status channel is broken the UI never learns the run stopped, so the failure belongs in normal logs, not debug. * fix(agent): send the stop status through the invoker, so an early failure reports it too A run that failed before its context was built sent the status through a missing context, so nothing went out. Every run context's invoker is the run's iInstance, so the status now goes through it directly. * fix(agent): only a top-level run sends the error stop status A sub-agent runs on its parent's status stream. When it failed or its answer was refused, its error status became the last one on that stream, so a parent that then answered normally (LangChain, CrewAI, LlamaIndex, Deep Agent send no closing status of their own) looked failed. The status is now sent only when the run writes the answers lane, which top-level runs do and sub-agent runs do not. * docs(agent): document what emit_answers_lane decides and what the stop status promises emit_answers_lane now also decides whether a run ends with an error stop status, and _send_stop_status no longer claims the answer is already built. The status send drops its extra instance check (the answers write beside it has none) and the test imports the agent module at the top. --------- Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
…laceholder (#2690 to stage) (#2691) * fix(ai, nodes): name the missing variable when a key is an unfilled placeholder A task keeps a ${ROCKETRIDE_*} placeholder it has no value for as-is, so a key written as ${ROCKETRIDE_OPENAI_KEY} with no saved variable reached OpenAI as the literal text. The user saw OpenAI's 401, "Incorrect API key provided: ${ROCKET************KEY}", and nothing said what to add. A name outside the ROCKETRIDE_ namespace became <REDACTED> and failed the same way. With saas#765 the server's own key no longer fills these, so more pipelines reach this path. check_credential_resolved() (ai.common.config) raises an error that names the variable and where to add it. It runs on the effective key, where the key is used: - ChatBase.__init__, so every chat LLM node fails at start with the name instead of sending the placeholder. Nodes a run never starts are not checked, so a pipeline with a second, unused source is unaffected. - embedding_openai, when it builds its client. - llm_openai and llm_openai_api validateConfig, before the probe request: a warning instead of a request with the placeholder as the key. The messages hold no '*', since the engine splits error text on it. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(ai): say how to fix a key that comes from a profile default Only the pipeline's own text is resolved, so a profile default such as the Nebius profiles' apikey ${ROCKETRIDE_NEBIUS_KEY} is never filled from a saved variable. A pipeline that leaves apikey out sent that text as the key (stage: "Bearer ${ROCKETRIDE_NEBIUS_KEY}" even with the variable supplied), and the first version of this check then told the user to add a variable they had already added. check_credential_resolved() takes the node config as the pipeline wrote it. A placeholder that is not in it came from a profile default, and the message says to set the field to the placeholder in the node settings (so the task fills it) or to enter the key there. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(ai): read only the active key field to tell a profile default apart The check looked for the placeholder anywhere in the node config, so the same placeholder in another profile's block counted as written by the pipeline, and the message told the user to add a variable that would not fill the default in use. It now reads what the pipeline wrote where getNodeConfig reads it: the top-level value, else the active profile's block (the config's "profile", or the service default). (CodeRabbit review on #2690.) Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(ai): do not guess a profile default when the node config cannot be read _written_value returned '' when reading the config failed, and the check then said the key was a profile default even if the pipeline wrote it. It now returns None for a config it cannot read, and the check gives the general "no variable named X" message. (CodeRabbit review on #2690.) Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(ai, nodes): name the missing variable for every LLM and vector store key End-to-end runs found the placeholder still sent as the credential outside the OpenAI nodes. Each LLM node's save-time check sends a probe request with the configured key before the run starts, and only llm_openai and llm_openai_api checked first. Anthropic also tested the key's sk-ant prefix before ChatBase, so an unfilled key failed as "Invalid Anthropic API key format". Bedrock signs with accessKey and secretKey, which ChatBase does not check, and vector stores send their key to the server at save time and start. - Check before the probe in the other LLM nodes (Anthropic, Baidu Qianfan, Bedrock, DeepSeek, Gemini, GLM, GMI Cloud, Kimi, MiniMax, Mistral, Perplexity, Qwen, xAI, vision Gemini), and before Anthropic's format check. - Check both AWS keys in Bedrock's probe and constructor. - StoreGlobalBase checks each driver's credential_fields before the probe and before the store opens. Qdrant, Pinecone, Weaviate, Astra, Postgres and Atlas declare theirs. Milvus and Chroma check the key only when it is sent (not in local mode). Elasticsearch checks its key, and OpenSearch its password when basic auth is on. * fix(store_milvus): send the token to a cloud server only at save time too The save-time probe took the cloud path whenever a key was set, so in local mode a key left as an unfilled ${ROCKETRIDE_...} reached the server, which the credential check skips for local mode. It now follows mode, as the running store does. Also adds docstrings to the Anthropic unfilled-key tests. * refactor(ai, nodes): one helper for the save-time credential check - UnresolvedCredentialError(ValueError) for an unfilled placeholder, so a caller can catch that case alone; existing ValueError handlers still catch it. - warn_if_credential_unresolved() replaces the try / warning / return block pasted into the save-time checks. - _written_value no longer swallows every exception: it returns None only when the config or its active profile block is not a mapping. - Milvus's probe and the new config code use if blocks instead of conditional expressions. - Tests: Chroma checks its key only for a cloud or remote server; the save-time helper; configs that cannot be read. * test: add the MIT license header to the new credential tests * test(nodes): cover the Elasticsearch, OpenSearch and Bedrock credential checks; share the local-mode check Follow-ups from the #2690 review: - Tests: an unfilled Elasticsearch key stops the store and the save-time health check; an OpenSearch password is checked only with basic auth on, at start and at save time; an unfilled Bedrock accessKey or secretKey stops the save-time probe and the chat. Nothing is sent in any of them. - Chroma and Milvus read local vs cloud from one small helper module each (store_chroma/mode.py, store_milvus/mode.py), used both by the key check and by the driver that sends the key, so the two cannot drift apart. --------- Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
…o stage) (#2719) * fix(pipediff): harden numbers, nesting, and Markdown reports Reject non-JSON constants and unsupported numeric ranges in file/Git inputs, guard nesting failures before stdout, and preserve rendered add/remove signs. Add regression coverage and document numeric bounds. Refs #1606 (cherry picked from commit 41304f0) * fix(pipediff): keep Markdown values in their code spans and show type changes - An empty value rendered as a bare double backtick, which GFM paired with the next value's two-backtick fence and left that value as live Markdown (links, images, mentions). Empty strings now render as a visible `""` in every reporter, and `_md_code` can no longer emit an empty span. (#2698) - The human report escapes C1 controls and the Unicode bidi, isolate, mark and line-separator controls as well as C0, so a crafted value cannot reorder or spoof what the reviewer reads. (#2696, item 3) - Type-only changes stay visible: when one side is a string, strings are JSON-quoted (`512 -> "512"`). Markdown spells values as JSON (`true`, `null`, `{"k": ...}`) instead of Python's `True`/`None`/repr. Provider and version pairs use the same rules, and provider changes are compared with JSON equality in the reporter too. (#2696, item 5) Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit 1a53894) * fix(pipediff): diff canvas-group children as nodes; compare providers by JSON type - The editor saves a group's children inside the group component, under `config.pipeline.components`, each with its own `ui` block. The diff only treated top-level `ui` as layout, so a drag inside a group was gated as a config change of the group (exit 1), and grouped rewires and provider changes were reported as positional config paths. Group children are now flattened into the node set and matched by id: their `ui` is layout, their wiring is edges, and their provider/config are compared on the child. Ids must be unique across nesting levels; malformed children are rejected with their location; traversal is iterative and cycle-safe. (#2697) - Providers are compared with `_json_equal`, like `version` and config, so a `0` -> `false` or `1` -> `true` provider edit is reported. (#2696, item 4) Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit 8ceddd4) * fix(pipediff,cli): look up --git FILE by its own path; reject an empty ref; skip .env for diff - `--git` resolved FILE through `realpath`, not `<ref>:<FILE>` as documented: an untracked link to a tracked file was compared at its target ("No semantic changes"), and a mis-cased path on a case-insensitive volume was reported as all added. Only the directory is resolved now; a link committed as a link still compares its target, and a mis-cased name that is the same file on disk compares the tracked spelling. (#2696, item 6) - `--git ""` was read as "no --git": with two files the command silently ran file mode, with one it blamed the file count. An empty or blank ref is now a usage error (exit 2). (#2696, item 7) - `diff` is local-only and reads no configuration, so `main()` no longer loads the workspace `.env` for it; an invalid-UTF-8 `.env` crashed every command, including `rocketride diff a.pipe a.pipe`. Other commands are unchanged. (#2696, item 8) Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit ecf2120) * docs(pipediff): correct the release wording; document groups, --git lookup and value rendering - "ships in a release after 1.3.0" implied PyPI 1.4.0 has `diff`; it does not. The docs now say no PyPI release has it yet (1.4.0 and earlier lack it, the first will be 1.5.0 or later), and the `cli-version` examples use `>=1.5,<2` instead of `==1.4.0`. (#2700) - `--git` with a file absent at the ref also reports `layout changed` when the file has a `viewport`; the JSON example shows the real sorted key order (`summary` before `viewport`). (#2700) - Document canvas-group semantics, the `--git` FILE lookup (empty refs, symlinks, case), type-sensitive providers, terminal escaping of C1/bidi controls, and how values are rendered (`""`, JSON spelling, quoting on type changes); update the example's Markdown output to JSON spelling. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit 730fb62) * test(client-python): give CLI subprocess tests rocketride_common's import root The `_cli_subprocess` helper pinned the child's PYTHONPATH to the rocketride source root only. In CI rocketride_common is not installed -- conftest.py adds it to sys.path in-process -- so every subprocess test failed with `ModuleNotFoundError: No module named 'rocketride_common'` (13 tests on Build / Ubuntu 22.04). Add rocketride_common's root as well; verified with a venv that has the dependencies but not the package, as in CI. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit 7d89f7a) * fix(pipediff): address review — escaped-text collisions, cased symlinks, doc accuracy - Human report: U+202E and the literal text `` printed identically once the control was escaped, hiding the edit. `_fmt_pair` now compares the two sides after the renderer's escaping and JSON-quotes them on a collision. - `--git`: after recovering a differently cased name, the tracked entry can be a symlink; follow it to its target instead of parsing the link text. - Docs: a file absent at the ref reports a version change only when it has a `version`, and `layout changed` only when its `viewport` is non-empty; the inline workflow examples set `pipefail` so an exit-2 error is not masked by `tee`. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit 829501f) * test(client-python): put CLI subprocess import roots on sys.path in the child CI runs these tests on the engine interpreter (dist/server/engine), which initialises Python with PyConfig_InitIsolatedConfig and therefore ignores PYTHONPATH, so the previous fix could not reach the child and the 13 subprocess tests still failed with `No module named 'rocketride_common'` on Ubuntu and macOS. The child's `-c` code now prepends the roots to sys.path itself; PYTHONPATH stays for ordinary interpreters. Reproduced and verified locally by running the suite with an `python -I` stand-in for the engine. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit 12a1a1b) * fix(pipediff): compare Markdown value pairs after code-span normalisation `_md_code` folds line breaks to spaces, so a change from `a\nb` to `a b` rendered as `a b` -> `a b` in the config table, the provider bullet and the Version line. Those `_fmt_pair` calls now pass `_md_code` as the escaping, so a collision JSON-quotes both sides (`"a\nb"` -> `"a b"`), as the terminal renderer already does with `_term_safe`. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit 86b4c62) * fix(pipediff): resolve --git symlinks and case from the ref and the disk Review (dylan-savage) on #2695: - A committed link is now followed through the target text stored at the ref, decided by the ref's tree entry, not the working tree. A retargeted link (v1 -> v2) compared v2 with HEAD:v2 and passed the gate with "No semantic changes"; a link at the ref that is now a regular file was parsed as link text. Targets outside the repository and link loops are errors. - The directory is resolved with realpath as given, not abspath first: abspath folded `lnk/..` as text, so the blob looked up was not the file opened. - Every path component is spelled with its on-disk case before the repo-relative path is computed, so mis-cased directories (and a mis-cased repo root, which failed with a false "outside the repository") find the tracked file on case-insensitive filesystems; case-sensitive filesystems are unaffected. - Real-git tests pass `commit.gpgsign=false` and a timeout. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit 7efbed8) * fix(pipediff): linear-memory finite-number check; PipeDiffError for deep comparisons Review (dylan-savage) on #2695: - `_validate_finite_numbers` built every value's full path string up front, so peak memory grew with depth squared (about 200 MB for a 2 MB deep, wide, long-keyed pipe). Pending values now carry a parent link and the path is built only for the value that fails (about 4 MB peak). Decoded JSON skips the walk entirely: the decoder's parse_float/parse_constant already reject non-finite numbers, so only in-memory dicts are walked. - `diff_pipes` reports a deep or cyclic in-memory config that exhausts the recursion limit as PipeDiffError instead of a raw RecursionError, for library callers as well as the CLI. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit 563bc34) * fix(pipediff): escape bidi/control chars in Markdown; unambiguous values; narrow CLI errors Review (dylan-savage) on #2695: - `_md_code` now escapes C0/C1 controls and the Unicode bidi, isolate, mark and line-separator controls, as the terminal report does, so a crafted value or id cannot reorder the auto-posted PR comment. The pattern is written with escapes rather than raw invisible characters. - A string is JSON-quoted when bare text would misread it: empty, padded with whitespace, or itself readable as JSON ("true", "512", the literal `""`), so one-sided values stay type-distinct. Pairs are also compared after whitespace folding, so `gpt-4` -> ` gpt-4 ` and tab -> space stay visible. - The CLI treats ValueError as a usage error only while reading arguments and inputs; one from the comparison or a reporter keeps its traceback. A non-finite number in the JSON report is converted explicitly. - A nested-fixture test commit passes `commit.gpgsign=false`. - Docs: `--git` symlink/case behaviour, Markdown escaping, the quoting rule, and that `diff` does not load the workspace `.env`. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit 681a06b) * fix(pipediff): convert only the JSON serializer's ValueError in _render `_render` wrapped `render_json()` and `json.dumps()` in one ValueError handler, so a ValueError from the reporter itself still became a one-line exit-2 error. Build the document first and convert only the `allow_nan=False` failure; a reporter bug keeps its traceback (new test covers it). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit 005bdf6) * test(client-python): assert the `lnk/..` gitref case against the file the OS opens On Windows `..` is folded lexically before symlinks are followed, so `lnk/../x.pipe` opens the top-level x.pipe, while POSIX opens deep/x.pipe. The resolver already compared the file each OS actually opens; the test hard-coded the POSIX answer and failed on Build / Windows Server 2022. It now asserts the ref side equals the opened file's content, keeping the POSIX check off Windows. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit 4079b67) * refactor(pipediff): share JSON helpers privately and index each pipe in one walk Answers two review notes on #2695 and closes a residual: - `reporters` imported `engine._json_equal` and `gitref` imported `engine._parse_pipe_json`. Both now import from a package-private `pipediff/_pipejson.py`, which imports no sibling module. It holds the strict JSON parsing, pipe validation, group traversal and JSON equality. `PipeDiffError` is defined there with `__module__ = 'rocketride.pipediff'` and remains a single class object everywhere. engine gains an `__all__` limited to its four documented names. - `_index_pipe` builds the component index and the edge set in one walk per pipeline and comparison, replacing `_components_by_id` and `_extract_edges`. The index is transient: nothing is cached on, and nothing mutates, the caller's dicts. - A value stored on one side only (removed or added config, provider, version, ui, viewport) that refers to itself, or nests past the recursion limit, now raises PipeDiffError from `diff_pipes`. Before, the error was a ValueError or RecursionError raised later, while rendering. `deep_diff_config` raises PipeDiffError for deep or cyclic input as well. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit ebccdd9) * fix(pipediff): escape every invisible or look-alike character in reports A change hidden in a character a reader cannot see still printed as no change: - zero-width spaces, joiners and word joiners; - a BOM, soft hyphens and tag characters; - NBSP and other non-ASCII spaces; - variation selectors, Hangul fillers and the braille blank; - lone surrogates. The human and Markdown renderers now escape characters by Unicode category (controls, format characters, non-ASCII spaces, separators, surrogates and unassigned code points), plus an explicit set of invisible marks and letters. A one-sided value holding an escaped character is JSON-quoted, so a real U+202E and the six characters `\u202e` no longer print alike. Markdown escapes line breaks instead of folding them to spaces, so `a\nb` and `a b` stay apart in ids too. Raw bidi characters in the reporter tests are now written as escapes. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit babf8e7) * fix(pipediff): resolve --git paths through the ref tree, one component at a time Three silent false negatives remained in `diff --git`, plus one false positive: - A directory renamed only in case on disk reported "1 node added", because only the file name's case was recovered (review: directory case). - A directory symlink retargeted since the ref was read through today's link. - A `..` in committed link text was folded as text. - A file reached through a directory link at the ref was reported as added. `_resolve_in_ref` replaces `_tree_mode`, `_follow_ref_symlinks` and `_same_file_in_ref`: - It lists each directory at the ref (`ls-tree <ref>:<dir>`). - It recovers the tracked case of every typed component. - It substitutes committed link text and applies `..` to the resolved path. - It stops after 40 hops, with clear errors for loops and for links that leave the repository. The working-tree side keeps the path as typed. The git test fixtures move to a shared hermetic helper: - no global or system config; - hooks off; - inherited GIT_* scrubbed; - literal pathspecs; - signing off; - a fixed identity; - no stdin; - timeouts. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit 0a882ab) * fix(cli): never crash on a damaged .env, and never rewrite one A workspace `.env` with invalid UTF-8 crashed `list`, `start`, `validate` and the rest with a raw UnicodeDecodeError traceback. A NUL byte crashed them with a ValueError (review: `diff` was the only command protected). - **Reader.** `load_dot_env` now applies every usable line and prints one `Warning:` line naming the file and problem, never its contents. - Invalid bytes read as U+FFFD, as in the TypeScript loader. - Assignments containing NUL are skipped. - An unreadable or non-regular file is treated as absent. - A `.env` directory is still skipped silently. - A leading BOM is stripped, matching the TypeScript loader. - Precedence is unchanged. - **Writer.** `write_dot_env` refuses such a file (`DotEnvError`) and leaves it byte-identical. `rocketride login` checks first, so a damaged `.env` can no longer lead it to rewrite a deploy pair that points elsewhere. `diff` still does not load the workspace `.env`. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit e0ddd59) * fix(pipediff,cli): prove the nesting error path; print reports on any console - The depth-600/981 CLI tests passed whether or not the RecursionError handling ran (review summary). Injection tests now force the error at each stage (load, git ref, compare, and the three renderers), in normal and `--exit-zero` mode. Each asserts that the injected call ran, exit 2, empty stdout and one `Error:` line. A pinned-limit pair, depth 600 refused and depth 20 reported, closes the gap. The realistic deep inputs are kept under honest names. - A console that cannot encode the report no longer turns a change into `?? -> ??`: - `--json` falls back to ASCII escapes, which also covers lone surrogates; - the human and Markdown reports write unprintable characters as visible escapes. - The CLI tests use the hermetic git helper (review summary: signing and hooks could hang them), and pin that a NO_COLOR set only in the workspace `.env` does not reach `diff`. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit 9c11962) * fix(pipediff): spell a component's location only when validation fails Validation built a location string for every component, repeating the group id in each child's, and kept all of them to report duplicate ids. Memory grew with group-id length times child count: a 269 KB file with a 100,000-character group id and 5,000 children peaked at 502 MB in load_pipe. The walk now yields (component, parent, index), keeps one list iterator per nesting level, and a location is spelled only for the component that fails. The same file peaks at 2.2 MB; error messages are unchanged. Tests pin the walk order, the full duplicate-id message, the last-wins rule for a key repeated in one JSON object, and the import-boundary scan (now also covering `from . import x` and absolute imports, with a self-test). The docs state the duplicate-key rule and which errors are PipeDiffError. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit a47fc8f) * fix(pipediff): escape canonically equivalent and compatibility spellings in reports Canonically equivalent spellings printed identically in human and Markdown reports: `e` plus U+0301 against U+00E9, U+212B ANGSTROM SIGN against U+00C5, Hangul jamo against the syllable. A node renamed from one to the other read as the same node removed and added, and a changed value as `x -> x`. Non-ASCII runs that NFC would rewrite are now spelled as escapes in ids, endpoints, lanes, providers, versions, paths, values and titles; already-normalised text such as `cafe` with U+00E9 stays readable. Two sides that differ only in a compatibility look-alike (U+FF14, the full-width digit four; the `fi` ligature) still read alike after JSON quoting, so those pairs are spelled with ASCII escapes. A fuzz of distinct values went from 54,572 alike-reading pairs in human output to none; the pair tests check the Markdown through cmarkgfm. The docs describe the new escapes and state that cross-script look-alikes are not flagged. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit d27fccb) * fix(pipediff): quote text that reads like an escape the reports write Reports spell invisible and non-ASCII characters as `\xNN`/`\uNNNN` escapes, and the CLI writes characters an ASCII console cannot print the same way. A value, id or config path whose literal text was such an escape then printed exactly like the character it names: on an ASCII console a real CJK character and the six characters of its escape both read `\u65e5`, and two different node ids could print as the same `a\u202e`. Text that reads like one of those escapes, or that starts with a quote, is now JSON-quoted, which doubles its backslash. Values get the rule through _reads_ambiguously, and ids, edge endpoints, lanes and config paths through a small _ident helper, so ordinary text prints as before. An exhaustive check of every string up to three tokens long, plus 150k random ones, finds no two inputs that print alike in either reporter, on a UTF-8 or an ASCII console. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit f7512bc) * fix(cli): skip .env lines this process cannot store, keep line endings CI failed on three platforms with the damaged-.env handling: - Ubuntu: the engine's embedded interpreter starts with an ASCII filesystem encoding, so os.environ raised UnicodeEncodeError on any non-ASCII name or value, including the U+FFFD the loader substituted for invalid bytes and a valid value such as "cafe" with U+00E9. The file was left half applied. - Windows: the writer opened the file in text mode, so every LF became CRLF. - All three: the start cases ran through the engine binary, which consumes --pipeline, --args, --trace and --stream itself before Python sees argv, so argparse failed with exit 2 instead of reaching the .env handling. The loader now judges each line on its own and applies it exactly as written or not at all. An assignment line holding an invalid UTF-8 byte, a NUL, or text the environment cannot store is skipped; a credential with a replacement character in it is a different credential, so it is never applied. One warning per file names counts, line numbers and a byte offset, never content, and the file is never modified. login refuses to write when a ROCKETRIDE_* connection value cannot be stored, so it never rewrites a deploy line the reader skipped. The writer splits lines where the reader does (LF, CRLF, lone CR) rather than with str.splitlines(), which also splits at form feeds and U+2028; it keeps each untouched line's ending, gives appended lines the file's first ending and writes LF for a new file. The test helper now passes the CLI arguments to the child through sys.argv, so the start cases run as typed. Verified in ordinary Python, the embedded engine, and Linux CPython 3.12 with an ASCII filesystem encoding and with UTF-8. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit da2cf54) * fix(pipediff): read absolute and re-entering --git link targets at the ref A committed link with an absolute target inside the repository, or one that climbs out of the root and back in (../<repo>/v1.pipe, also as a directory link), failed with a false "outside the repository" error; the PR base read them. Such a target is now followed on disk outside the repository only until it is back at the root, and the rest is looked up in the ref's tree. A target that never comes back, or a loop, is still an error. Also fixed while checking the historical-link cases against real repositories: - Under an ASCII filesystem encoding, a non-ASCII directory name never matched git's listing, so the file read as absent and every node as added. Names are now compared as bytes, and listings and link text are read byte for byte, so a non-UTF-8 name elsewhere in the directory no longer fails the command. - A typed lnk/../x.pipe after lnk was retargeted, or a relative path typed inside a retargeted directory link, followed the working tree; it now follows the link as committed (POSIX; Windows folds .. as text first). - The case lookup takes the repository prefix from git instead of listing every ancestor directory, a ref starting with "-" is refused before git runs, and an OSError from running git is a PipeDiffError. git cat-file --batch-check --follow-symlinks was evaluated and not adopted: it reports out-of-tree targets without resolving them, drops the rest of the path after an absolute directory link, and needs -z for names with newlines. Test fixtures create links through one helper that writes the native separator, so they resolve on Windows, and skip only when Windows refuses the symlink privilege. The --git docs describe the link rules. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit 500b8fa) * fix(pipediff): quote identifiers that differ only in whitespace Node ids, edge endpoints and lanes, and config paths print bare, so an id with a trailing space read exactly like the id without it (`+ llm_1 (p)` against `+ llm_1 (p)`), and a tab like a space once a terminal or a Markdown code span folded it. A node renamed by whitespace alone looked like the same node removed and added. An identifier is now JSON-quoted when it has leading or trailing whitespace, a tab, or a run of two or more spaces, the way values already are; padding then shows inside the quotes and a tab prints as an escape. Ordinary single-spaced ids and paths print as before. Across 136,892 generated identifiers, displays that read alike once whitespace is folded went from 17,096 (terminal) and 10,664 (Markdown) to none; the pair tests also check cmark-gfm's rendering. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit 5b86260) * fix(cli): escape input text in diff and usage error lines diff's error lines repeated text from its inputs verbatim: a component id, a path, a name git echoes back, and argparse's "unrecognized arguments" list. The pipe-diff Action passes a pull request's changed file names as arguments and pastes this stream into a PR comment, so a crafted .pipe or file name could print control, bidi or line-separator characters there and forge or reorder the error block. _fail now writes each message through the human reporter's escaper, so those characters print as \xNN/\uNNNN escapes on one line and ordinary text prints as typed. The CLI parser's error() does the same, so every command's usage error is covered; the reporter's helper is imported lazily there so --help stays fast. Tests cover crafted ids, paths, links, refs and arguments in each error class, and the real CLI process end to end. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit 71edc83) * fix(cli): count each skipped .env line once, and explain an unstorable value A UTF-16 .env (each line holding a NUL and invalid bytes) reported every skipped line twice, once per reason. Each skipped assignment line is now counted once, under the NUL reason that carries the UTF-16 hint. When login refuses a file because a connection value cannot be stored in this process's environment, it said "Fix or remove it", although nothing is wrong with the file. It now says so and suggests a UTF-8 locale or an ASCII value, still naming only the line number and the encoding. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit a91b191) * docs(pipediff): state which --git link targets re-enter the repository A link target is read at the ref when it is absolute inside the checkout or climbs back in through the repository root; a path that reaches the repository only through another alias counts as outside, as the code does. cli.mdx also gains the rule for a relative FILE typed inside a directory link. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit 20faee3) * fix(pipediff): report a removed working directory from resolve_git_ref Called directly with a relative path from a working directory that has been removed, resolve_git_ref raised a raw FileNotFoundError from realpath before the lookup's own working-directory check could run. It is now a PipeDiffError that names the path; the test removes a real working directory and calls the public function (POSIX; Windows cannot remove a process's working directory). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit 38d7d81) * docs(pipediff): say how values compare, and that the 1.5 range is unreleased "Compared type-sensitively" read as if 512 and 512.0 were a change; values are compared as JSON values, where a boolean never equals a number and a string never equals either, but numerically equal literals compare equal. The Action README's example called >=1.5,<2 a published range; no 1.5 release exists yet, so the comment points to install-from. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit 465bb8c) * revert(cli): move the damaged-.env handling out of this pull request The workspace .env loader, its writer and login's refusal changed for every connected command, not for `diff`, which does not load the workspace .env at all. That is a separate change to shared code, so it moves to its own pull request; this one keeps only the `diff` exemption. env.py, auth.py and their tests return to the base of this branch. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit 57ed8eb) * refactor(cli): keep error-text escaping inside diff Escaping argparse's usage errors changed every command's parser for a concern that belongs to `diff` and the pipe-diff Action, and pulled the pipediff reporter's helper into the CLI entry point. The CLI parser is back to plain argparse; diff's own error messages (an id, a path, a ref) are still written as one line with control, bidi and invisible characters escaped, and the docs now say exactly that. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit 93ecaee) * test(pipediff): test behaviour, not structure or history The suite pinned the implementation in several places: a fake git that replayed the exact command sequence of the --git walk, counts of how often the group tree was walked, scans of import statements and of source text, and direct calls into private helpers. Those tests broke on harmless changes without guarding anything a caller sees. The fake-git walk tests are replaced by the same cases against real repositories (unknown and option-like refs, unreadable objects, invalid content, loops, dangling and re-entering links, and link text in Windows form committed directly, so any platform runs it); the structure and source-text checks are removed; helper tests now go through render_human, render_markdown, diff_pipes and resolve_git_ref. Each removal was checked against seeded faults in the code: every fault the removed tests caught is still caught on at least one CI platform. Comments that retold earlier behaviour or review history are gone. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit c8e3ef3) * docs(pipediff): keep comments to what the code does and why Docstrings and comments in the pipediff package no longer retell measured evidence, earlier behaviour, or how the tests and CI check them; they state what each function does and guarantees, and the reasons that are not obvious from the code. No code changes. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit 2884dbd) --------- Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
main is the v3.4.0 release (captured stage d3b6eea plus its version bump and .gitleaksignore). stage already carries newer versions of all of it, and .gitleaksignore and both release workflows are identical, so the tree is stage's as captured. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015nTVr6jfSFYm1GppxbjghP
Seven fixes went into server stage after #2671 cut [3.5.0] and the release notes come from that section, so they're added under Fixed: #2720, #2674, #2714, #2713, #2688, #2690, #2695. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015nTVr6jfSFYm1GppxbjghP
dk-rocketride
requested review from
Rod-Christensen,
jmaionchi,
kwit75 and
stepmikhaylov
as code owners
October 21, 2026 18:35
Contributor
|
Important Review skippedIgnore keyword(s) in the title. ⛔ Ignored keywords: 5
Please check the settings in the CodeRabbit UI or the ⚙️ Run configuration
You can disable this status message by setting the Use the checkbox below for a quick retry:
Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out. Comment |
Contributor
🤖 Internal: Discord sync markerAuto-managed by the Discord notification workflow. Stores the linked Discord message ID and forum thread ID. Do not edit or delete. |
dylan-savage
approved these changes
Oct 21, 2026
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Merging this publishes v3.5.0: VS Code and Open VSX 1.5.0, npm and PyPI 1.5.0 (
rocketride), and the server 3.5.0 GitHub release.rocketride-mcp1.5.0 is already on PyPI, so its job skips. The push tomainfiresrelease.yaml, which waits on thereleaseenvironment approval.Built on server
stageas shipped. Production runs this tree since 10-21 11:04 PT: the saas pin is732817a0, the head ofstage. The diff againststageis one file:CHANGELOG.md: seven fixes that reachedstageafter release: bump to server 3.5.0 / clients 1.5.0 and cut the changelog (#2670 to stage) #2671 cut[3.5.0], added under its Fixed list (fix(server): claim the GNU C++ runtime at engine startup #2720, fix(nodes): langchain-text-splitters 1.1.3 so General Text stops loading torch #2674, fix(agent_rocketride): log the wait for timed-out calls as a warning #2714, fix(ai,nodes): cut remaining ClickHouse echoes, keep other dialects' error text whole, fix ClickHouse session docs #2713, fix(agent): report the stop reason when a run fails early or its answer is refused #2688, fix(ai, nodes): name the missing variable when a key is an unfilled placeholder #2690, fix(pipediff): harden numbers, nesting, and Markdown reports #2695). The release body comes from that section, so without them the notes would miss them.The version bump and the
[3.5.0]cut are already instage(#2671).mainis merged in withstage's tree:mainis the v3.4.0 release (captured staged3b6eea8plus its version bump and.gitleaksignore)..gitleaksignoreand both release workflows are identical betweenstageandmain.Registries today: VS Code Marketplace 1.4.0, Open VSX 1.4.0, npm 1.4.0, PyPI 1.4.0,
rocketride-mcp1.5.0.🤖 Generated with Claude Code
https://claude.ai/code/session_015nTVr6jfSFYm1GppxbjghP