Repository navigation
RocketRide Server v3.6.0 (prerelease)
Pre-release
Pre-release
·
5 commits
to develop
since this release
Automated prerelease from develop — Server v3.6.0.
Added
- ai, client-python, client-typescript: native tool calling. A
Questionwith a non-emptymessageslist, and optionaltools, is sent to the model as real provider turns, andAnswer.fromResultreturns the model's message, its tool calls and a stop reason. The Anthropic, OpenAI and OpenAI-Compatible API nodes support it, and any other LLM node answers withtools_unsupportedbefore calling its model. Tool names keep their dots: the engine maps them to names each provider accepts and maps calls back. The prompt node keeps a turn's conversation and tools, and the guardrails node checks a turn's last user message and the arguments of its tool calls. AQuestionwithoutmessagesworks as before (#2838) - client-python:
rocketride --versionprints the installed package version - mcp: every HTTP MCP tool now declares explicit
readOnlyHint,destructiveHintandopenWorldHintannotations, the server sendsinstructions, the four core workflow tools ask Claude Code to load them upfront (anthropic/alwaysLoad), and the engine serves OpenAI's plugin domain-verification token at/.well-known/openai-apps-challengefromMCP_OPENAI_APPS_CHALLENGE_TOKEN(404 while unset) (#2997) - docs: a Cloud Databases page under Deploy & Operate says what an app owner gets from the
rocketride_sql,rocketride_vectorandrocketride_graphdatabases: one per organization shared by its members, plus team and personal ones, and none per app; up to 6 transactions at once per database and no storage, table or query-rate quotas; uninstalling an app leaves its tables, while a member leaving or a team or organization being deleted retains a database for 30 days before a final dump and deletion; backups configured for whole-cluster point-in-time recovery over 30 days; and no export.ROCKETRIDE_APPS.mdgives app agents the short version (rocketride-saas#788) - appdev, vscode: an app created as
local.<name>, before its organization had a developer id, can be moved into the organization's namespace from the App Builder. On the Store and Deploy tabs the read-only banner now offers to move it to<developerId>.<name>; once the user confirms, VS Code rewrites the app id inpackage.json(and the publisher and package name, if they are still the ones the app was created with), in the.rrappfile and insrc/AppDescriptor.ts, then reopens the App Builder on the new id. It refuses when another app in the workspace or on the server already has the new id, or when one of those files has unsaved edits, and replaces each file in one step. Nothing on the server is renamed: the user's saved settings for the app, in the App Builder and the preview, start fresh, and the old ones stay in the user's server file store under the old id. The web App Builder still asks for the rename by hand (#2471) - nodes: add tool_skills, a Skills tool node that gives agents custom skills in the
SKILL.mdformat, entered in the node or read from a folder in the RocketRide file store. Theload_skilldescription lists each skill's name and description, and the agent loads a skill's instructions withload_skilland its bundled files withread_skill_fileonly when it needs them - nodes: the MCP Client sets environment variables for a stdio MCP server (
env), so a server that reads its API key from the environment can be configured in the node, and withallowedToolsset exposes only the named tools: the others are left out of the agent's catalog and a call to one is refused without reaching the server - server: a seeded app version records the sha256 of the bundle it was copied from (
metadata.build.bundleSha256), andbundle_changed()tells an orchestrator whether the pod's build differs from the app's newest seed, so a deploy can re-seed only the apps whose build changed. An app whose public version is a direct deploy, not a seed, counts as unchanged, so a release never replaces it - tool_github: four reads for apps that work on repositories with credentials held in the node configuration:
repo_contributors,repo_languages,label_listanduser_get(the PAT user, or the App itself under App auth). They return{status, data, rate_limit, next_page}: rate-limit counters from the response headers, the next page number from theLinkheader, and a non-2xx answer as a result withstatus,messageanddocumentation_urlrather than an exception; tokens, private keys and bearer headers never appear in a result or an error message. Existing tools keep their return shapes (#2592) - tool_github:
repo_treelists a repository recursively at a branch, tag or SHA (defaultHEAD, the default branch), sorted by path, with GitHub'struncatedflag and acompleteflag of its own, in the result envelope of the repository reads. Withwalk: truea listing GitHub truncated is completed from subtree reads pinned to the SHA the ref resolved to, so a branch that moves during the walk cannot mix revisions: each subtree is read recursively and only one GitHub truncates again is split into its direct children, so a repository the size of Linux takes tens of requests.max_requests(default 1000) andmax_entries(default 200000) bound the walk; the entry cap is what stops a git bomb, where a few trees referenced from thousands of paths multiply entries while requests stay few. A partial result is alwayscomplete: falsewith amessagethat names the bound, or the subtree whose read failed and its status, and still holds the entries GitHub's truncated listing had named (#2464, #2592) - tool_github:
graphqlruns a GraphQL document (POST /graphql, optionalvariablesandoperationName) and returns GitHub'sdataanderrorsin the same envelope; GraphQL errors are results, not exceptions. WithreadOnlyon, a document containing a mutation operation is refused before anything is sent; with it off, mutations run only whengraphqlAllowMutations(off by default) is on, so a pipeline that adds nothing keeps the reach it has today; andgraphqlMaxResponseBytes(4 MiB) caps the response body. Atoolslist registers only the named tools, so an agent's schema holds just those (#648), and an unknown name stops the pipeline at start.graphqland the repository reads wait out primary and secondary rate limits, GraphQL's HTTP 200 rate limits included and a minute when GitHub names no wait, withinrateLimitBudgetSeconds(60, shared by every request of one call, arepo_treewalk included) andrateLimitMaxRetries(3 retries of each request), sending a freshly minted credential on each retry, then return the rate-limit error withretry_after; an answer GitHub partly ran is never retried (#2592) - tool_github: credentials stay on the server for apps that work across repositories. Under GitHub App auth
installationIdis optional: without it the node finds the installation per repository (GET /repos/{owner}/{repo}/installationwith the App JWT), caches it, and caches and refreshes a token per installation, so one pipeline reads repositories in several organizations; a repository the App is not installed on fails with a message naming it, a cached installation GitHub no longer knows is looked up once more, and a 401 to a cached installation token is retried once with a fresh one. An optionalcredentialMap(rows of repository and credential in the canvas form, a JSON object in a pipeline file, App credentials as their JSON text; a hand-written pipeline may also use App objects or one${ROCKETRIDE_*}placeholder holding the whole map) gives each call the most specific credential for its repository: exactowner/repo, thenowner/*, then the*default, each a token or an App credential, with the node's own credential as the default when the map has no*; the whole map is checked at pipeline start, and a repository with no match and no default fails with a message that names it and never the map. Every tool's result and error now has each token, private key and minted installation token the node holds replaced with[REDACTED], REST envelope errors before their 2,000-character cap;graphql,user_getandinstallation_repostake an optionalrepothat picks the credential, and a REST path with a.,..or empty segment is refused before it is sent, checked after decoding the path completely, so an encoded slash, a double encoding or a backslash cannot hide one (#2592) - tool_github:
installation_reposlists the repositories a GitHub App installation can reach, with theinstallation_idit used;user_get_repostakesaffiliation,visibilityandsortand keeps its paging and list result. Three writes return the result envelope and, in read-only mode, the refusal as a result:pr_request_reviewers,pr_remove_requested_reviewersandissue_add_labels, which appends whereissue_editreplaces the whole label set. A write is retried only after a rate-limit answer, which GitHub sends instead of processing it, never after a timeout or any other failure (#2592) - server:
RR_PARAM_TOKEN_SECRETgives a deployment its own key for thesecureParameterstokens the engine writes into pipelines. With it set, the engine encrypts new tokens with AES-256-GCM under a key derived from the value by HKDF-SHA256, with a random 96-bit nonce per token. Each token starts with a format header (RRPT, version 2) and an ID of that key, both authenticated with the ciphertext, so a token that was altered anywhere fails to load, and a token from another value fails with an error naming the variable. Tokens in the original format still load. Tasks never receive the variable: when it is set, the engine decodes a pipeline's tokens before it writes the task file. Without it, tokens are written and read as before - server: a task that crashes ends as
Stopped unexpectedlyinstead ofStopped, showsUnexpected termination: <what happened>in its console and records the run's outcome aserror, notcancelled. The engine's crash handlers on Linux, macOS and Windows and the JVM's abort and exit hooks end with>EXIT*Crash*..., a new error code, instead ofFatality; a fatal error given a single error keeps that error's code, and every fatal>EXITnames the place it was raised rather than the monitor.eaas.pyshows the engine's>DUMPasCrash dump: <file>instead ofUnknown control, and treats a task process that ends without a word as crashed when a crash signal or an OOM kill (SIGKILL) ended it, or on Windows a crash exception code, as a fast fail does (#2879)
Changed
- client: when the engine answers
No authorization providedto an empty credential, the Python and TypeScript clients keep that message and add ahintto theAuthenticationException: no API key was sent, setROCKETRIDE_APIKEYor passauthwhen creating the client, a local engine accepts any non-empty value unlessROCKETRIDE_APIKEYis set on the engine, and RocketRide Cloud needs a key fromrocketride login. Therocketridecommand line tools print an exception's own single-linehintfirst. Thedeploycommands and theapplifecycle commands now stop before they connect when no deployment API key is set; the message namesROCKETRIDE_DEPLOY_APIKEYand--apikey. The exception class and its message are unchanged - shell: a dev relay owns the OAuth
statewhen relaying, so an undecided visitor's cookieless signup context is not sent through it (#2978). - server: on Linux and macOS a task run no longer takes the crash dumps that other engine processes left unreported in the crash database, and no longer names them in its output; they stay in the database, where an operator can take them by hand (#2918)
- server: crash dumps are opt-in: the engine writes them only when started with
--dumps(Linux, macOS and Windows); like the--log.*switches it reads a value as a boolean, so--dumps=falsekeeps them off.eaas.pypasses its own--dumpson to its task processes, and a pipeline's task arguments cannot turn it on (#2878) - ai: EasyOCR recognizes the text boxes of an image in batches of up to 16 boxes that share a padded width, instead of one GPU call per box (
readtextwas called with EasyOCR's defaultbatch_size=1). Batching a whole page withreadtext(batch_size=16)would pad every box to the widest, 3.8x the recognition work on the test pages and a slightly different text; per width group each box gets the input it got alone, so only rare low-confidence characters can change (batched GPU kernels are not bit-identical to batch 1: 8 characters in 489k on an H100). A call's memory grows with boxes x padded width, so a call also stops at 256 model heights of padded width (about 0.25 GB withenglish_g2) unless one box is wider. On an 8 GB GPU, A4 pages at 200 dpi read 1.3-1.5x as fast in-process, and detection still sets their peak memory; an H100 model server read them 1.32x as fast one at a time and 2.25x with 32 in flight. On CPU EasyOCR still recognizes box by box. Words of a line that share a left edge are now ordered by their right edge, whatever order the engine returned them in; this applies on every device and to TrOCR too (#2897) - ocr: in-process OCR (no
--modelserver) no longer reads one image at a time per node behindreaderLock, and the table path no longer runs unguarded: every EasyOCR and docTR call waits in a per-device memory budget (ai.common.models.device_budget) that admits a call when its estimated cost (EasyOCR from the image size, docTR a constant) fits in the driver's free memory plus the process's unused torch cache, less what the calls inside may still claim and a 512 MB margin; the first call always runs, at most 4 at once, in arrival order, re-checked every 0.5 s so memory freed elsewhere is seen. While another engine process on the GPU, or a process NVML cannot name, counts as a neighbour, calls run one at a time, as with the lock, since each process would count the same free memory (two budgets on one 8 GB card read 17% slower than two locks and spilled 4.1 GB into shared memory); for 30 s after such a neighbour appears, a lone call also waits until its cost fits. Each process hands its unused torch cache back to the driver before each call while such a neighbour counts and once its device has been idle for 2 s (torch.cuda.empty_cache()takes no device, so the cache of every device of the process goes back), so neither an engine that ran several calls alone nor a finished task's idle process holds memory the other needs. Only processes named like the engine, or not named, count, so the desktop and browsers do not, and since #3058 only those NVML saw busy lately where it can tell (below). Where NVML lists host pids (another PID namespace, as in a container), one unnamed process is taken to be this one, so a lone neighbour there is not seen. Without NVML calls run one at a time, with one warning. On an 8 GB GPU (Windows) with 12 worker threads and EasyOCR batching (#2897) on both sides, A4 pages at 200 dpi read about 1.7x as fast as with the lock and 850x1100 pages about 1.6x, without spilling into shared memory; two engines started together read about 1.7x as fast as two locks, and a second engine started while the first was busy about 1.8x (1.7x slower than the lock without the cache release). Surya and TrOCR, whose cost is not measured, run alone on their device within their process; beside another engine process they start without waiting for their cost to fit, so one can run while the neighbour runs a call; on CPU one call runs at a time per process, across all OCR nodes and the table path, which ran unguarded before; the table engine is loaded once when the first pages arrive together. With--modelservernothing changes (#3015) - ocr: the device budget (#3015) sets up a worker thread's cuBLAS workspace in a memory pool of its own the first time the thread enters on a GPU. cuBLAS allocated it with the thread's first matrix product, out of whatever torch had cached, and a cached block goes back to the driver only when nothing in it is in use, so after its cache release the idle process of a finished task still held 0.5-2.4 GB of driver memory on an 8 GB card with 12 worker threads, varying from run to run; it now holds 0.48 GB each time (a workspace of 8 MiB + 128 KiB per thread, two to a 20 MiB segment; 32 MiB on sm_90); a thread that ran a matrix product before its first call in the budget keeps its workspace where it was. Reads take as long as before: 16 A4 pages alone 23.1 s against 23.2 s (mean of 10 runs each; single runs vary from 20 to 28 s), and bursts and single pages that start after an idle release 0.998x as long (21 paired runs, 90% interval 0.983-1.015x). The idle release runs in one thread per device budget instead of a timer per drain (#3150)
- ocr: the device budget (#3015) counts another engine process on the GPU only if NVML saw it busy there in the last 10 s (
nvmlDeviceGetProcessUtilization, any SM or memory sample above zero), so the idle process of a finished task, which holds a CUDA context for its idle TTL, no longer makes a task started beside it run one call at a time; a neighbour that is running still does, as before. Where NVML cannot report per-process utilisation, every listed engine process counts, with one warning; so it does, without a warning, until NVML has once sampled this process busy, so that a driver that samples no engine process cannot make a busy neighbour look idle; in another PID namespace NVML lists host pids, this process does not find itself in the samples, and the old rule holds. A neighbour that pauses for longer than 10 s counts again once it resumes, through the same path as a new neighbour (one call at a time, a lone call waits up to 30 s for its cost to fit, the cache is released before each call). A process reads NVML only when a call arrives, so one that was idle itself takes a neighbour it saw before the gap as known, and its next call enters without that wait, beside the calls the neighbour may have admitted while it did not count the idle process. On an 8 GB GPU (Windows), with the workspace change above, a 16-page A4 read at 12 threads beside the idle process of a finished task took 29.9 s against 38.3 s before (mean of 10 runs each, 20-48 s from run to run); beside a busy neighbour 43.3 s against 48.5 s (one develop run took 94 s; medians 42.6 and 43.4 s), and beside one that paused for 30 s mid-run and resumed 30.9 s against 34.3 s; the neighbour's own 48-page read was not slower in either case. A process that has just started may show start-up samples and count for about 10 s (#3058) - ai: a connection authenticated with a task key (
pk_ortk_) can send only the commands of its own run, over WebSocket and HTTP. Apk_can send data and subscribe to the run's events; atk_can also read the run's status and pipeline, terminate it and restart it. Every other command is refused withCommand not permitted for task-scoped credentials. For atk_that newly refusesrrext_store,rrext_dashboard, therrext_list_*commands and the DAP debug commands, which nothing in this repository sends with a task key; automation that sent them with atk_needs an account API key instead. Apk_that subscribes toSUMMARYorTASKevents is no longer sent the current status or the task list when it subscribes; it never received the live events of those types. Account API keys are not affected (#2961) - nodes: every node lives in the engine's one
nodes/folder, andnodesis a namespace package. Breaking: the engine no longer reads--node_pathor alocal_nodes/folder (EaaS still accepts--node_pathand warns that it is ignored); put a custom node innodes/<name>/.scaffold_nodewrites there, with thenodes.<name>module prefix (#2765) - ai: a run's cloud databases are authorized with the credential of the connection that started it, or of the one that restarted it:
TaskServer.start_taskandrestart_taskpassAccountInfo.authdown as a call argument toAccountBase.authorize_db_target(identity, target, *, credential=None), so an account implementation can limit what a restricted key may reach. The credential is not stored on the task, written to the task file, logged, or added to the identity, and the default account ignores it. An account implementation without the keyword is still called as before, with a warning. Reusing a running task (useExisting) now authorizes the requesting connection's credential for the databases the run holds, waiting for a run that is still starting to report them, and is refused if any is denied, so on that path a restricted key cannot attach to a wider run of the same owner
Fixed
- client-python, ai: the engine no longer stalls on the first refused request after many new imports. The error reply's
tracenow reads only its caller's frame;inspect.stack()mapped every loaded module on the event loop, which took over 30 s on a busy CI runner (#2838) - server: a webhook body sent as
application/jsonreached no component when the pipeline reads only the text lane, such aswebhook → question → agent: with nojsonreader it fell through to the raw lane and was answered200 OKunread. JSON, XML, NDJSON and YAML bodies (andapplication/*+json,application/*+xml) now go to the text lane when a component reads text and none reads their own lane or raw (tags, e.g. parse); JSON still goes to thejsonlane when a component reads that, andapplication/rocketride-question+jsonnever becomes text. A text-lane body of up to 8 MiB is now delivered as one text when the pipe closes, so a body that arrives in several chunks makes one question instead of several partial ones. A larger body is written as it arrives, as before, so memory stays bounded. A body that ends inside a character is still an error the client sees (#2880) - ai: validating a full pipeline that has no source (none given, none at the top level, none implied by a component with
mode: Source) now returns a warning saying so, because starting it would be refused; passing a source when starting also works. The reply stays valid and the CLIs' exit code does not change - shell: the checkout modal's button after a grant or hackathon code is redeemed said "Start building", RocketRide's own wording, inside every store app. A store app's checkout now names the app the user goes back to, for example "Continue to Judge Hack"; the pipeline builder keeps "Start building" (#3133)
- mcp: the
validate_pipeline,list_running_pipelinesanddeploy_removedescriptions now say what the tools do: the provider catalog check and the single-component probe, thestatustext, and that removal unschedules without terminating running tasks (#2997) - ai: a store or desktop app entry whose app declared no publisher still had an empty
publisher, so the app store showedDEVELOPER: Unknown. Such an entry now names the app id's namespace (acmeforacme.brandy), which deploy and publish guarantee is the publishing organization's registered developer id (rocketridefor the seeded platform apps and on OSS). A blank or non-string publisher counts as missing, and so doeslocal, the reserved placeholder the app scaffold writes when no developer id is known. A declared publisher in the version's manifest is now read before the publish snapshot's copy (#2977) - tool_mcp_client: the MCP client read only the first page of
tools/list, so a tool on a later page was never discovered and a refresh after a miss re-read page one. All three transports now follownextCursorthrough one shared helper that forwards every cursor unchanged, bounded to 100 pages, 5000 entries and 60 seconds, with repeated cursors and tool names repeated on a later page refused; a refused or failed traversal keeps the previous catalog and raises a warning (the helper's own errors name the page; transport errors keep their own message) (#2999) - nodes, test: a run that collected all of
nodes/testinstalled nothing on first use:tool_git/test_tools.pyleft a stubdependsand aMagicMockengLibinsys.modulesfor the rest of the session, so every laterdepends()/load_depends()call did nothing. On an engine without torch,test_embedding_image.pyfailed withNo module named 'torch', also when run with the command its docstring gives. The stubs are now insys.modulesonly whiletool_gitloads. Thesys.modulesguard pinsdependsandengLibthe way it pins numpy, so a test that leaves either replaced or removed fails; it now treats a module compiled into the interpreter, such asengLib, as real (#3097) - ai: SQL that an LLM generates for
db_postgres,db_mysql,db_clickhouseandrocketride_sqlwas only checked for its shape before it ran, so aSELECTcould still write (SELECT ... INTO,nextval,setval), lock rows (FOR UPDATE) or run without limit (pg_sleep), and a--inside a string (SELECT '--x' INTO OUTFILE ...) hid the rest of the statement from the check. The generated query and itsEXPLAINnow run on a connection the database keeps read-only, with a 60-second limit (aREAD ONLYtransaction andstatement_timeouton PostgreSQL, a read-only session andmax_execution_timeon MySQL and MariaDB,readonly=1andmax_execution_timeon ClickHouse, as far as the user's settings profile lets it change them), and the session gets back its own settings before the connection is reused. On PostgreSQL the transaction and its time limit cover one statement, and a later statement of a multi-statement input could end the transaction (COMMIT) or lift the limit (set_config()), so the shape check now rejects multi-statement input. The shape check masks literals and comments under PostgreSQL rules (a name may hold$and any non-ASCII character, andstandard_conforming_stringsmay be on or off) and under MySQL rules, and also rejectsINTO, row locks, MySQL's executed comments and ClickHouse'sSETTINGSclause; the READMEs say what a database role must still control (#2087) - tool_github: reject zero App and installation IDs and malformed
defaultRepovalues at validation and pipeline start. Refreshing a rejected installation token no longer waits for another installation's token mint. GraphQL mutations are never replayed after an HTTP 200 error response, including a null result with exhausted quota, because that response does not establish that the write was refused before execution. - canvas: preserve encrypted array settings, including
credentialMap, when saving unrelated node changes. Saved entries have an explicit replacement action; opening their form no longer turns an opaque stored value into an empty array. - canvas: send node validation through the SDK's
{ pipeline }options object so saving a node reaches component validation instead of validating an empty pipeline. - nodes, test: the pgvector search suite (
test_pgvector_search_live.py) failed on pgvector 0.8.7. A search with the wrong number of dimensions fails in one of two pgvector checks, both SQLSTATE 22000: on 0.8.0 the distance check (different vector dimensions 2 and 32), on 0.8.7 the check against the column type (expected 32 dimensions, not 2), and the test accepted only the first. It now accepts both. The setup instructions intest_rocketride_db_live.pyandtest_rocketride_vector_tools_live.pynamepgvector/pgvector:0.8.0-pg16, the image CI anddocker/docker-compose.ymlpin, instead of the floatingpg16tag (#3020) - nodes, test: a node test that left a stub
numpyinsys.modules(store_atlas, andstore_qdrantwhenqdrant_clientis not installed) or dropped the real one (test_elasticsearch_credentials.py, which restored all ofsys.moduleswithpatch.dict) broke later tests in the same process: Chroma's check against the installed client was skipped, the pgvector search suite failed in setup, andtest_store_object_batches.pygotcannot load module more than once per process. Those tests now stub only what they need, for as long as they need it, and put back what was there. Thesys.modulesguard imports numpy once per session; a test that leaves it replaced or removed fails in teardown, and the real module is put back (#3019, #3025) - store_milvus: with pymilvus 3 the node wrote nothing to Milvus: every write failed with
DataNotMatchException, because the node handed pymilvus aDocMetadataobject for the JSONmetafield, and the pipeline then stopped withCollection does not have control document, found 0. The node now stores the metadata as a plain dict without its empty fields, as the Chroma and Elasticsearch nodes do, so a row reads back as aDoc. Plain reads (search, get, paths, count, render) now use theSessionconsistency level and see this process's own writes at once; under the collection's defaultBoundedlevel a read can miss what was written in the last 5 s, so a pipeline thread did not find the control row of a collection created a moment before, and a mark or read right after a write missed the new chunks. ASessionread that comes right after this process's own write waits until Milvus can serve that write: up to about 0.3 s per write batch when batches arrive back to back, a few milliseconds when an embedding call sits between them. Reads that must also see other processes' writes useStrong, which waits about 0.4 s: the rowsmarkDeletedandmarkActivechange (withSession, a process that had not written to the collection could miss another process's new chunks and mark nothing), a control row aSessionread did not find, and every read of a collection configured asStrong. A chunk whose metadata leaves outisDeletedis stored as live, so default reads find it. TheisTable,tableIdsandpermissionsfilters now compare the stored bool and integers without quotes and match; keyword search looks for the question's text, not for the whole question object, and a%or_in that text matches only itself (text that ends with%can also match other characters in place of those, because Milvus cannot match an escaped%at the end of a pattern); a line break in a filter string (the question, a path, an object id) is written as an escape, so Milvus parses the filter instead of rejecting it; rendering a document no longer fails withKeyError: 'chunkId'(#3014) - web: the uvicorn request log replaces credential-bearing values with
[redacted]: the values of query parameters named like credentials, compared without case or separators soapi-key,API_KEYandapikeyare one name (code,state,auth,authorization,bearer,jwt,key,password,secret,session,sig,signature,token,tokens, theapi_keyandaccess_tokenfamilies, and names ending intoken,secret,passwordorsignature), the token segment of/task/fetch/{token}/{subpath}, and theuser:password@part of an absolute-form target. A filter on theuvicorn.accessanduvicorn.errorloggers rewrites the request target of uvicorn's request-line records, whatever its form, before any handler formats the line, and fails closed: any other record on those loggers has every URL-like word of its message and arguments redacted the same way. Method, the rest of the path, status and the WebSocket handshake lines stay, and request handling does not change. Servers built onWebServerget the filter. The deprecatedrocketride-mcp-sselauncher starts uvicorn itself and does not (#2998) - ocr: the in-process device budget (#3015) counted a table engine loaded lazily, on the first table page, as memory the text calls already inside had taken, so until the GPU next sat idle it saw that much more room than there was. docTR's 160 MB fit in the 512 MB margin; larger weights would not, and under steady load the GPU may not sit idle again during the task. The table engine now loads through
loading_model, which counts the loaded model's own tensors and adds them to the base of their GPU's budget when the load ends; what the text calls take or free meanwhile stays theirs. A budget with no call inside when a load starts takes its base then; no budget measures it again while a model loads, so until the load ends the part loaded so far counts as the calls' progress. For docTR it counts 157.5 of the 159.5 MB its load allocates (a tensor over 1 MiB can get up to 1 MiB more from the allocator) in a walk of 1-3 ms; calls do not wait for the load (#3064) - nodes: an object written to Pinecone, Milvus, Weaviate, PostgreSQL or RocketRide Vector in several batches kept only the last batch, with no error: those stores deleted every object of every batch before inserting it, and
embedding_transformerhands an object over every 64 chunks, so a 153-chunk document stored 25. They now delete an object's stored chunks only when the batch holds its chunk 0, as Chroma, Qdrant, Elasticsearch, Astra and Atlas already did; a later batch adds to the object. The documents lane warns when an object's chunk 0 arrives after its other chunks, because that batch deletes them (#1986) - ai: when a SQL node answered a question with a generated query that passed
EXPLAINbut failed when it ran, it wrote the textNoneto its text and answers lanes. It now reportsQuery execution failedthere, as an error ({"error": ...}on the answers lane), the same text theget_datatool returns; the database's own message is in the log. On ClickHouse such a failure escaped as a driver exception and is now caught the same way, an LLM reply with neither a query nor an answer is reported too, and every failure while handling a question now reaches those lanes or, when neither is wired, fails the question instead of only being logged. Only messages the node writes reach the caller, on the lanes or in the raised error; any other failure of the node, including anerrorthe LLM puts in its own reply, shows asFailed to answer the question, with the cause in the log. An error that a downstream node raises while the node writes to a lane still reaches the caller as that node reported it. Theget_sqlandget_datatools report such an LLM error with the same fixed text (#1925) - ai: text sent to a pipeline in pieces failed with
'utf-8' codec can't decode byte ...: unexpected end of datawhenever a piece ended inside a multi-byte character, because the text lane decoded every write on its own. A webhook body arrives in stream chunks cut at any byte and the SDKs upload files in chunks, so non-ASCII text failed at random. The text lane now carries an incomplete character over to the next write; a byte that can never be UTF-8 still fails the write, and a body that ends inside a character fails at close (#2458) - audio_transcribe: with
--modelserverthe node transcribed one stream at a time: every worker thread queued on a task-widethreading.Lockheld across the Whisper round trip (16.9 s of lock wait per 0.78 s call with 32 meetings in flight), so the model server never saw concurrent requests. The guard now comes frommake_device_lock(): a no-op with the model server, the same lock for in-process inference, whereWhisperLoader's per-model lock protects the model as well (#2905) - ai: a failed OCR inference, such as CUDA out of memory, came back as an empty page: the EasyOCR, docTR, Surya and TrOCR loaders set
erroron a failed image, but the wrappers never requested that field, so the OCR node passed the document with no text and the table path found no tables. The wrappers now requesterrorand raiseRuntimeErrorwhen it is set, so the document fails with the cause and the table path logs it; this works in-process and with any model server already deployed, which returns the field as it is. The Surya loader set one batch failure on every image of the batch, which in a model server holds other tasks' images; it now reads each image alone after a failed batch, so a failure stays with its own image (on a model server once it runs this version) (#2906) - ai: on a model server with several GPUs docTR ran on GPU 0 whatever GPU the server had allocated to it, because
DocTRLoader.loadplaced the predictor with.cuda(), which takes the current device. It now moves the predictor to the device it chose, as the TrOCR and EasyOCR loaders do. In-process the OCR node loads docTR oncuda:0, which did not change (#3063) - twelvelabs: the node buffered an entire video in a Python list before submitting it, so a large upload held the whole file in memory at once. Incoming chunks now stream straight to a
mkstemptemp file onBEGIN/WRITE, and the file is submitted and deleted onEND; a displaced stream (a secondBEGINwith no priorEND) and a document that reachesclosing()without ever getting anENDboth release their temp file too (#2564) - tool_github:
file_getreturned an emptycontentwithout a word for files over 1 MB, the Contents API's limit, so an agent verifying code read missing evidence as an empty file. It now reads such files through the Git blob API by the SHA the metadata named (GitHub serves blobs up to 100 MB), up to a newmax_bytesinput (default 1 MiB, the Contents API's own boundary, so a larger file is reported, not downloaded, until the call raises it; refused from the metadata before any download); when GitHub cannot serve the content, for a file over 100 MB or a blob read that fails, or when such a file is binary (a NUL byte in its first 8000 bytes),contentisnullandmessagesays why and what to do instead (#2464) - ai, nodes: task and vector-store errors give a short cause and recovery action; detailed SDK, pipeline-lane and agent-tool guidance moved to
docs/agents/skills/rocketride-debugging-pipelines/ERROR_TABLE.md, with the previous wording of each message. A run request whose pipeline is missing, empty or not an object is refused with one message on both the launch and execute paths, instead of an AttributeError, a TypeError or a no-source report for an empty{}(#2476, #2465) - anonymize: a GLiNER prediction that failed for one chunk or label batch, such as CUDA out of memory or a model-server error, was logged at debug level and skipped, so the node passed the document on as a success with that chunk's entities left unredacted, or with the original text when every chunk failed. A failed prediction now fails the document with the cause and the node emits no text for it; the rest of the batch and the task continue, in-process and with
--modelserver. A prediction that succeeds and finds no entities still passes the text through unchanged. When handling classifier input fails, the node no longer emits the text it was holding when the object closes (#3172) - ai: a document batch missing an embedding vector or model name failed with
object of type 'NoneType' has no len(), or created the collection and wrote its setup record with no model name before being refused; it is now refused before anything is created or written, on an existing collection too, and a semantic question without a vector is refused before the store driver is called (#2476) - agent_langchain, agent_deepagent: each tool's input schema reached the model three times per step (pasted into the description, as the generated argument schema, and as the original schema); it is now sent once, the original when available. LlamaIndex keeps the schema in the description, which is the only schema it has (#2995)
- ai: a pipe deploy (
rrext_deploy add, the default kind) can no longer be registered under an app id, or carry a build status of its own: the pipe door refuses aproject_idequal to or inside the caller's developer namespace (the mirror of the app door's<developerId>.*rule) unless the caller's org already holds only pipe rows for that id, and drops a caller-suppliedmetadata.build, which only the server's build lifecycle may set._home_org_of,entitled_version_dirsandopen_version_dirsread onlykind: 'app'registry rows, so a pipe row that shares an app's project id never counts as that app's rail - ai: deploying or publishing an app from an organization with no developer id told the user to run
rrext_app developer_register, a subcommandrrext_apprejects (registration lives onrrext_deploy_app). The error now names the ways that work: the Deploy tab in the App Builder,rocketride app developer register <id>(npm CLI) orclient.registerDeveloper(id)(Python:client.register_developer(id)), and says that only an org admin can register, once and permanently (#2471) - summarization: a pipeline with the node validated and then failed on the first document with
No module named 'langchain_text_splitters', unless another node had already installed that package. The node imports the splitter, but its requirements listed onlylangchain, and langchain 1.x no longer installs it. The node now requireslangchain-text-splitters>=1.1.3instead oflangchain, which it never imported (#3071) - llm_anthropic: the node no longer offers a
claude-haiku-latestprofile. Anthropic publishes no such model id and answered every request with404 not_found_error, so a pipeline on that profile never answered. A model sync had taken the name from OpenRouter, and the sync tool now excludes it. A saved pipeline that still names the profile fails withProfile claude-haiku-latest is not defined in llm_anthropicuntil it picks another profile, such asclaude-haiku-4-5(#3074) - mcp: on a self-hosted engine with neither
ROCKETRIDE_URInorMCP_RESOURCE_IDENTIFIERset, MCP tool calls were sent, with the caller's key, to RocketRide Cloud (wss://api.rocketride.ai) because that address is the built-in identifier default. They now connect back to this engine:ws://127.0.0.1:<port>for a0.0.0.0or unset bind,ws://[::1]:<port>for::,ws://<bind address>:<port>for a bind to one specific IP address, andws://127.0.0.1:<port>(with a warning) for a bind host that is a name. Upload links, the file-drop page and widget addresses use that address too, so the engine logs a warning and a remotely reachable engine should setMCP_RESOURCE_IDENTIFIER(orROCKETRIDE_URI). Setting either variable behaves as before. The refusal of a non-rr_credential on a public bind withoutMCP_EXPECTED_AUDIENCEnow names that setting and therr_prefix rule - mcp:
initializereports the engine version inserverInfo.versioninstead of0.0.0; when the engine cannot report one, the fallback0.0.0is logged at debug level - ai: on the Linux engine, an OCR task that loaded docTR (the default table engine, and the text engine of the
doctrprofile) died when matplotlib was installed, as theface_detectionanddetectnodes install it: docTR imported its optional drawing helpers, theirimport matplotlib.pyplotaborted the process withlibc++abi: terminating, and every later file of the task gotConnection closed. docTR now loads with those helpers marked absent, a case docTR already handles; OCR never draws, so the results do not change. The cause, a GCC-built extension served by the engine's own C++ runtime, remains for other extensions (#3067) - account: an environment name stored under the plain
ROCKETRIDE_prefix before the name rule (for exampleROCKETRIDE_MY KEY) could not be deleted, and any write that sent it back with its mask was refused, so no one could clear it through the API. The name rule now applies only to a name given a new value; any storedROCKETRIDE_*name can be kept or deleted. A write that names one variable in bothenvanddeleteis refused instead of deleting it. The request is parsed and checked in one place,ai.account.base.env_changes, that both servers use (#3251)