Skip to content

RocketRide Server v3.6.0 (prerelease)

Pre-release
Pre-release

Choose a tag to compare

@github-actions github-actions released this 17 Nov 22:42
· 5 commits to develop since this release
6784b6e

Automated prerelease from develop — Server v3.6.0.

Added

  • ai, client-python, client-typescript: native tool calling. A Question with a non-empty messages list, and optional tools, is sent to the model as real provider turns, and Answer.fromResult returns 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 with tools_unsupported before 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. A Question without messages works as before (#2838)
  • client-python: rocketride --version prints the installed package version
  • mcp: every HTTP MCP tool now declares explicit readOnlyHint, destructiveHint and openWorldHint annotations, the server sends instructions, 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-challenge from MCP_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_vector and rocketride_graph databases: 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.md gives 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 in package.json (and the publisher and package name, if they are still the ones the app was created with), in the .rrapp file and in src/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.md format, entered in the node or read from a folder in the RocketRide file store. The load_skill description lists each skill's name and description, and the agent loads a skill's instructions with load_skill and its bundled files with read_skill_file only 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 with allowedTools set 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), and bundle_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_list and user_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 the Link header, and a non-2xx answer as a result with status, message and documentation_url rather 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_tree lists a repository recursively at a branch, tag or SHA (default HEAD, the default branch), sorted by path, with GitHub's truncated flag and a complete flag of its own, in the result envelope of the repository reads. With walk: true a 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) and max_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 always complete: false with a message that 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: graphql runs a GraphQL document (POST /graphql, optional variables and operationName) and returns GitHub's data and errors in the same envelope; GraphQL errors are results, not exceptions. With readOnly on, a document containing a mutation operation is refused before anything is sent; with it off, mutations run only when graphqlAllowMutations (off by default) is on, so a pipeline that adds nothing keeps the reach it has today; and graphqlMaxResponseBytes (4 MiB) caps the response body. A tools list registers only the named tools, so an agent's schema holds just those (#648), and an unknown name stops the pipeline at start. graphql and 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, within rateLimitBudgetSeconds (60, shared by every request of one call, a repo_tree walk included) and rateLimitMaxRetries (3 retries of each request), sending a freshly minted credential on each retry, then return the rate-limit error with retry_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 installationId is optional: without it the node finds the installation per repository (GET /repos/{owner}/{repo}/installation with 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 optional credentialMap (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: exact owner/repo, then owner/*, 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_get and installation_repos take an optional repo that 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_repos lists the repositories a GitHub App installation can reach, with the installation_id it used; user_get_repos takes affiliation, visibility and sort and 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_reviewers and issue_add_labels, which appends where issue_edit replaces 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_SECRET gives a deployment its own key for the secureParameters tokens 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 unexpectedly instead of Stopped, shows Unexpected termination: <what happened> in its console and records the run's outcome as error, not cancelled. 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 of Fatality; a fatal error given a single error keeps that error's code, and every fatal >EXIT names the place it was raised rather than the monitor. eaas.py shows the engine's >DUMP as Crash dump: <file> instead of Unknown 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 provided to an empty credential, the Python and TypeScript clients keep that message and add a hint to the AuthenticationException: no API key was sent, set ROCKETRIDE_APIKEY or pass auth when creating the client, a local engine accepts any non-empty value unless ROCKETRIDE_APIKEY is set on the engine, and RocketRide Cloud needs a key from rocketride login. The rocketride command line tools print an exception's own single-line hint first. The deploy commands and the app lifecycle commands now stop before they connect when no deployment API key is set; the message names ROCKETRIDE_DEPLOY_APIKEY and --apikey. The exception class and its message are unchanged
  • shell: a dev relay owns the OAuth state when 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=false keeps them off. eaas.py passes its own --dumps on 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 (readtext was called with EasyOCR's default batch_size=1). Batching a whole page with readtext(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 with english_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 behind readerLock, 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 --modelserver nothing 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_ or tk_) can send only the commands of its own run, over WebSocket and HTTP. A pk_ can send data and subscribe to the run's events; a tk_ can also read the run's status and pipeline, terminate it and restart it. Every other command is refused with Command not permitted for task-scoped credentials. For a tk_ that newly refuses rrext_store, rrext_dashboard, the rrext_list_* commands and the DAP debug commands, which nothing in this repository sends with a task key; automation that sent them with a tk_ needs an account API key instead. A pk_ that subscribes to SUMMARY or TASK events 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, and nodes is a namespace package. Breaking: the engine no longer reads --node_path or a local_nodes/ folder (EaaS still accepts --node_path and warns that it is ignored); put a custom node in nodes/<name>/. scaffold_node writes there, with the nodes.<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_task and restart_task pass AccountInfo.auth down as a call argument to AccountBase.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 trace now 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/json reached no component when the pipeline reads only the text lane, such as webhook → question → agent: with no json reader it fell through to the raw lane and was answered 200 OK unread. JSON, XML, NDJSON and YAML bodies (and application/*+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 the json lane when a component reads that, and application/rocketride-question+json never 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_pipelines and deploy_remove descriptions now say what the tools do: the provider catalog check and the single-component probe, the status text, 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 showed DEVELOPER: Unknown. Such an entry now names the app id's namespace (acme for acme.brandy), which deploy and publish guarantee is the publishing organization's registered developer id (rocketride for the seeded platform apps and on OSS). A blank or non-string publisher counts as missing, and so does local, 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 follow nextCursor through 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/test installed nothing on first use: tool_git/test_tools.py left a stub depends and a MagicMock engLib in sys.modules for the rest of the session, so every later depends() / load_depends() call did nothing. On an engine without torch, test_embedding_image.py failed with No module named 'torch', also when run with the command its docstring gives. The stubs are now in sys.modules only while tool_git loads. The sys.modules guard pins depends and engLib the way it pins numpy, so a test that leaves either replaced or removed fails; it now treats a module compiled into the interpreter, such as engLib, as real (#3097)
  • ai: SQL that an LLM generates for db_postgres, db_mysql, db_clickhouse and rocketride_sql was only checked for its shape before it ran, so a SELECT could 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 its EXPLAIN now run on a connection the database keeps read-only, with a 60-second limit (a READ ONLY transaction and statement_timeout on PostgreSQL, a read-only session and max_execution_time on MySQL and MariaDB, readonly=1 and max_execution_time on 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, and standard_conforming_strings may be on or off) and under MySQL rules, and also rejects INTO, row locks, MySQL's executed comments and ClickHouse's SETTINGS clause; the READMEs say what a database role must still control (#2087)
  • tool_github: reject zero App and installation IDs and malformed defaultRepo values 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 in test_rocketride_db_live.py and test_rocketride_vector_tools_live.py name pgvector/pgvector:0.8.0-pg16, the image CI and docker/docker-compose.yml pin, instead of the floating pg16 tag (#3020)
  • nodes, test: a node test that left a stub numpy in sys.modules (store_atlas, and store_qdrant when qdrant_client is not installed) or dropped the real one (test_elasticsearch_credentials.py, which restored all of sys.modules with patch.dict) broke later tests in the same process: Chroma's check against the installed client was skipped, the pgvector search suite failed in setup, and test_store_object_batches.py got cannot 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. The sys.modules guard 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 a DocMetadata object for the JSON meta field, and the pipeline then stopped with Collection 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 a Doc. Plain reads (search, get, paths, count, render) now use the Session consistency level and see this process's own writes at once; under the collection's default Bounded level 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. A Session read 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 use Strong, which waits about 0.4 s: the rows markDeleted and markActive change (with Session, a process that had not written to the collection could miss another process's new chunks and mark nothing), a control row a Session read did not find, and every read of a collection configured as Strong. A chunk whose metadata leaves out isDeleted is stored as live, so default reads find it. The isTable, tableIds and permissions filters 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 with KeyError: '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 so api-key, API_KEY and apikey are one name (code, state, auth, authorization, bearer, jwt, key, password, secret, session, sig, signature, token, tokens, the api_key and access_token families, and names ending in token, secret, password or signature), the token segment of /task/fetch/{token}/{subpath}, and the user:password@ part of an absolute-form target. A filter on the uvicorn.access and uvicorn.error loggers 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 on WebServer get the filter. The deprecated rocketride-mcp-sse launcher 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_transformer hands 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 EXPLAIN but failed when it ran, it wrote the text None to its text and answers lanes. It now reports Query execution failed there, as an error ({"error": ...} on the answers lane), the same text the get_data tool 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 an error the LLM puts in its own reply, shows as Failed 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. The get_sql and get_data tools 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 data whenever 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 --modelserver the node transcribed one stream at a time: every worker thread queued on a task-wide threading.Lock held 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 from make_device_lock(): a no-op with the model server, the same lock for in-process inference, where WhisperLoader'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 error on 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 request error and raise RuntimeError when 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.load placed 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 on cuda: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 mkstemp temp file on BEGIN/WRITE, and the file is submitted and deleted on END; a displaced stream (a second BEGIN with no prior END) and a document that reaches closing() without ever getting an END both release their temp file too (#2564)
  • tool_github: file_get returned an empty content without 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 new max_bytes input (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), content is null and message says 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 a project_id equal 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-supplied metadata.build, which only the server's build lifecycle may set. _home_org_of, entitled_version_dirs and open_version_dirs read only kind: '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 subcommand rrext_app rejects (registration lives on rrext_deploy_app). The error now names the ways that work: the Deploy tab in the App Builder, rocketride app developer register <id> (npm CLI) or client.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 only langchain, and langchain 1.x no longer installs it. The node now requires langchain-text-splitters>=1.1.3 instead of langchain, which it never imported (#3071)
  • llm_anthropic: the node no longer offers a claude-haiku-latest profile. Anthropic publishes no such model id and answered every request with 404 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 with Profile claude-haiku-latest is not defined in llm_anthropic until it picks another profile, such as claude-haiku-4-5 (#3074)
  • mcp: on a self-hosted engine with neither ROCKETRIDE_URI nor MCP_RESOURCE_IDENTIFIER set, 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 a 0.0.0.0 or unset bind, ws://[::1]:<port> for ::, ws://<bind address>:<port> for a bind to one specific IP address, and ws://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 set MCP_RESOURCE_IDENTIFIER (or ROCKETRIDE_URI). Setting either variable behaves as before. The refusal of a non-rr_ credential on a public bind without MCP_EXPECTED_AUDIENCE now names that setting and the rr_ prefix rule
  • mcp: initialize reports the engine version in serverInfo.version instead of 0.0.0; when the engine cannot report one, the fallback 0.0.0 is 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 doctr profile) died when matplotlib was installed, as the face_detection and detect nodes install it: docTR imported its optional drawing helpers, their import matplotlib.pyplot aborted the process with libc++abi: terminating, and every later file of the task got Connection 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 example ROCKETRIDE_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 stored ROCKETRIDE_* name can be kept or deleted. A write that names one variable in both env and delete is refused instead of deleting it. The request is parsed and checked in one place, ai.account.base.env_changes, that both servers use (#3251)