Langbase

PERMANENTLY DELETE a whole memory AND EVERY DOCUMENT IN IT, with their embeddings. Langbase publishes no recycle bin and no restore, and there is no memory-update tool to fall back on -- a memory deleted to change its chunking or embedding model has to be rebuilt document by document, from files Agentic Fabriq does not hold. Any pipe grounded in this memory loses that grounding. The reply is `{"success": true}`. Langbase reports a failure as `{"success": false, "error": {"code", "status", "message", "docs"}}`, and a 400 on a write carries the ZodError that names the exact field (`invalid_type: name: Required`) -- the most useful thing in the reply, so it is passed through. Agentic Fabriq removes this connection's API key from every Langbase message before it is raised or logged, because Langbase's 401 repeats the key it was sent.

PERMANENTLY DELETE one document from a memory, with its embeddings. Langbase publishes no recycle bin and no restore for this, and the document's bytes are gone from the memory -- re-adding it means uploading the file again. The reply is `{"success": true}`. Confirm the deletion with List a memory's documents rather than trusting the flag. Langbase reports a failure as `{"success": false, "error": {"code", "status", "message", "docs"}}`, and a 400 on a write carries the ZodError that names the exact field (`invalid_type: name: Required`) -- the most useful thing in the reply, so it is passed through. Agentic Fabriq removes this connection's API key from every Langbase message before it is raised or logged, because Langbase's 401 repeats the key it was sent. THIS ROUTE'S REJECTION NAMES A USER KEY. Measured credential-free on 2026-09-22: a bad credential here answers `Invalid user API key` rather than echoing the value sent, which most shipped routes do -- so an ORGANIZATION key may not reach this tool. Unconfirmed, because a bogus key cannot tell us which kind a caller must hold: the message names the kind the handler looked the key up as. If this tool fails with a 401 while the pipe and memory reads work on the same connection, try a user-level key.

PERMANENTLY DELETE a thread and its whole message history. Langbase publishes no recycle bin and no restore. The reply is `{"success": true}`; confirm with Get a thread rather than trusting the flag. Langbase reports a failure as `{"success": false, "error": {"code", "status", "message", "docs"}}`, and a 400 on a write carries the ZodError that names the exact field (`invalid_type: name: Required`) -- the most useful thing in the reply, so it is passed through. Agentic Fabriq removes this connection's API key from every Langbase message before it is raised or logged, because Langbase's 401 repeats the key it was sent.

PERMANENTLY DELETE one message from a thread. Langbase publishes no recycle bin and no restore, and the thread's remaining messages are left as a history with a hole in it. The reply is `{"success": true}`. Langbase reports a failure as `{"success": false, "error": {"code", "status", "message", "docs"}}`, and a 400 on a write carries the ZodError that names the exact field (`invalid_type: name: Required`) -- the most useful thing in the reply, so it is passed through. Agentic Fabriq removes this connection's API key from every Langbase message before it is raised or logged, because Langbase's 401 repeats the key it was sent.

Read the Langbase API's own banner -- `{"success": true, "message": "Langbase API", "link": "https://langbase.com/docs"}`, byte-identical to the health check (measured 2026-09-22). Useful only to confirm the API is reachable from Agentic Fabriq. PUBLIC, and therefore NOT a credential check: the sealed OpenAPI document declares no security on this operation and it was measured on 2026-09-22 answering 200 with no `Authorization` header at all. A 200 here says nothing about whether this connection's key works -- use List pipes for that.

Langbase's liveness endpoint. It answers the same banner payload as the service root (measured 2026-09-22) and reports only that the API is up -- it does not report the account's state, its quota or its keys. PUBLIC, and therefore NOT a credential check: the sealed OpenAPI document declares no security on this operation and it was measured on 2026-09-22 answering 200 with no `Authorization` header at all. A 200 here says nothing about whether this connection's key works -- use List pipes for that.

Langbase's own list of every route it serves, as `{"routes": [{"method", "path"}]}` with path parameters in Hono's `:name` form. Measured 2026-09-22: 57 entries, including the `ALL /*` catch-all, `/openapi.json` and `/ui`. This is how to tell whether Langbase has added or withdrawn an endpoint since this integration was built -- and it is why three routes the endpoint ledger could not settle are known to exist: `POST /v1/threads`, `POST /v1/traces` and the deployed-agent run all appear in it. PUBLIC, and therefore NOT a credential check: the sealed OpenAPI document declares no security on this operation and it was measured on 2026-09-22 answering 200 with no `Authorization` header at all. A 200 here says nothing about whether this connection's key works -- use List pipes for that.

List the memories -- Langbase's managed RAG stores -- on this account, each with `name`, `description`, `owner_login` and `url`. This is where a memory `name` comes from: every memory tool, and the `memory` argument on the two run tools, takes the name rather than an id. Langbase reports a failure as `{"success": false, "error": {"code", "status", "message", "docs"}}`, and a 400 on a write carries the ZodError that names the exact field (`invalid_type: name: Required`) -- the most useful thing in the reply, so it is passed through. Agentic Fabriq removes this connection's API key from every Langbase message before it is raised or logged, because Langbase's 401 repeats the key it was sent.

List one memory's documents, each with `name`, `status` and `status_message` (this is where an indexing failure is visible), its `metadata.size` and `metadata.type`, whether it is `enabled`, and the chunking it was indexed with. Poll this after an upload: a document is not retrievable until it has finished indexing. Langbase reports a failure as `{"success": false, "error": {"code", "status", "message", "docs"}}`, and a 400 on a write carries the ZodError that names the exact field (`invalid_type: name: Required`) -- the most useful thing in the reply, so it is passed through. Agentic Fabriq removes this connection's API key from every Langbase message before it is raised or logged, because Langbase's 401 repeats the key it was sent.

Re-run the embedding of one document whose indexing failed. NOTE THE VERB: Langbase serves this retry as a GET, on the sealed document's own authority and confirmed in its live route table -- so this is a GET THAT MUTATES, classified `write` here because that is its effect, and it spends embedding tokens each time it is called. Check `status` and `status_message` with List a memory's documents first; retrying a document that failed for a structural reason spends tokens and fails again. Langbase reports a failure as `{"success": false, "error": {"code", "status", "message", "docs"}}`, and a 400 on a write carries the ZodError that names the exact field (`invalid_type: name: Required`) -- the most useful thing in the reply, so it is passed through. Agentic Fabriq removes this connection's API key from every Langbase message before it is raised or logged, because Langbase's 401 repeats the key it was sent. THIS ROUTE'S REJECTION NAMES A USER KEY. Measured credential-free on 2026-09-22: a bad credential here answers `Invalid user API key` rather than echoing the value sent, which most shipped routes do -- so an ORGANIZATION key may not reach this tool. Unconfirmed, because a bogus key cannot tell us which kind a caller must hold: the message names the kind the handler looked the key up as. If this tool fails with a 401 while the pipe and memory reads work on the same connection, try a user-level key.

Every LLM Langbase can route to, grouped by provider, each with `id` (the `provider:model_id` string every `model` argument in this integration takes), `provider`, `type` (`text` or `image`), and its per-million-token `promptCost`/`completionCost` -- or, for image models, `basePrice`, `supportedSizes` and `supportedQualities`. THIS IS THE CATALOGUE, NOT THE ACCOUNT'S ENTITLEMENTS: whether a model actually runs depends on the customer's own LLM provider key for that provider. PUBLIC, and therefore NOT a credential check: the sealed OpenAPI document declares no security on this operation and it was measured on 2026-09-22 answering 200 with no `Authorization` header at all. A 200 here says nothing about whether this connection's key works -- use List pipes for that.

List the pipes -- Langbase's deployable LLM agents -- on the account this connection's key belongs to, each with its `name`, `description`, `status`, `model` and every stored generation parameter. This is where a pipe `name` comes from, which Run a pipe needs. IT IS ALSO THIS INTEGRATION'S CREDENTIAL CHECK, and the only shipped read whose rejection has been measured: on 2026-09-22 a bogus bearer answered 401 `Invalid <key> API key. Regenerate to try again.` and NO `Authorization` header at all answered 400 `Invalid 'Authorization' header or token` -- the control proving the endpoint does not ignore credentials. The 200 side has never been seen, because no Langbase credential existed when this shipped. Langbase reports a failure as `{"success": false, "error": {"code", "status", "message", "docs"}}`, and a 400 on a write carries the ZodError that names the exact field (`invalid_type: name: Required`) -- the most useful thing in the reply, so it is passed through. Agentic Fabriq removes this connection's API key from every Langbase message before it is raised or logged, because Langbase's 401 repeats the key it was sent.

Read one pipe's full stored configuration: model, prompt messages, every generation parameter, its tools and its memories. Unlike the two pipe writes, this reply does NOT carry the pipe's API key, so nothing is redacted from it. Langbase reports a failure as `{"success": false, "error": {"code", "status", "message", "docs"}}`, and a 400 on a write carries the ZodError that names the exact field (`invalid_type: name: Required`) -- the most useful thing in the reply, so it is passed through. Agentic Fabriq removes this connection's API key from every Langbase message before it is raised or logged, because Langbase's 401 repeats the key it was sent.

Read one thread's own record: `id`, `object`, `created_at` and its `metadata`. The MESSAGES are a separate call (List a thread's messages). Langbase reports a failure as `{"success": false, "error": {"code", "status", "message", "docs"}}`, and a 400 on a write carries the ZodError that names the exact field (`invalid_type: name: Required`) -- the most useful thing in the reply, so it is passed through. Agentic Fabriq removes this connection's API key from every Langbase message before it is raised or logged, because Langbase's 401 repeats the key it was sent.

Read every message in a thread, oldest first, as a bare ARRAY -- each with `id`, `role`, `content`, `created_at`, any `tool_calls` and its `metadata`. Langbase documents no paging on this call, so a long thread comes back whole. Langbase reports a failure as `{"success": false, "error": {"code", "status", "message", "docs"}}`, and a 400 on a write carries the ZodError that names the exact field (`invalid_type: name: Required`) -- the most useful thing in the reply, so it is passed through. Agentic Fabriq removes this connection's API key from every Langbase message before it is raised or logged, because Langbase's 401 repeats the key it was sent.

List execution traces for one primitive -- Langbase's own log of what a pipe or agent did. Both `primitiveId` and `primitiveName` are required, so this reads ONE primitive's traces and cannot list the account's. THE TRACES PLANE IS UNDOCUMENTED: it is in the sealed OpenAPI document and in the API's live route table, but Langbase's API reference has no traces page (`/docs/api-reference/traces` answers 404, measured 2026-09-22), so what a `primitiveId` is and where one comes from is not stated anywhere this build could read. Langbase reports a failure as `{"success": false, "error": {"code", "status", "message", "docs"}}`, and a 400 on a write carries the ZodError that names the exact field (`invalid_type: name: Required`) -- the most useful thing in the reply, so it is passed through. Agentic Fabriq removes this connection's API key from every Langbase message before it is raised or logged, because Langbase's 401 repeats the key it was sent.

Read one trace by id. The sealed document declares the reply as an ARRAY of trace objects rather than a single one, which is transcribed here as it stands rather than corrected. Same undocumented plane as List traces. Langbase reports a failure as `{"success": false, "error": {"code", "status", "message", "docs"}}`, and a 400 on a write carries the ZodError that names the exact field (`invalid_type: name: Required`) -- the most useful thing in the reply, so it is passed through. Agentic Fabriq removes this connection's API key from every Langbase message before it is raised or logged, because Langbase's 401 repeats the key it was sent.

Invoke an agent deployed on Langbase at its own address, `POST /{ownerLogin}/{agent}` -- Langbase's serverless compute plane. The input and the reply are whatever that agent defines; the sealed document declares a nullable 200 and no request body. THIS SPENDS WHATEVER THE AGENT SPENDS. NOTE THE AGENTIC FABRIQ PATH: this tool is addressed as `/langbase/agents/{ownerLogin}/{agent}/run` rather than mirroring the provider path, and that is deliberate -- the provider's route is two bare segments at the root, so mirroring it would shadow every two-segment Langbase route this integration mounts (`/v1/pipes`, `/v1/memory`, `/v1/threads`, `/v1/traces`, `/v1/embed`, `/v1/images`, `/v1/chunker`) and let a caller reach one of them by passing `ownerLogin=v1`. The connector still calls the provider's real path. Langbase reports a failure as `{"success": false, "error": {"code", "status", "message", "docs"}}`, and a 400 on a write carries the ZodError that names the exact field (`invalid_type: name: Required`) -- the most useful thing in the reply, so it is passed through. Agentic Fabriq removes this connection's API key from every Langbase message before it is raised or logged, because Langbase's 401 repeats the key it was sent.

Run a model directly, with everything specified at call time and nothing stored: the runtime counterpart to a pipe. Answers `{"completion": "...", "raw": {...usage...}}`. Use this when the model, prompt and tools are decided per call; use Run a pipe when the account has a stored agent to invoke. THIS SPENDS MODEL TOKENS. RUNNING A MODEL NEEDS A SECOND CREDENTIAL THAT IS NOT THIS CONNECTION'S: an upstream LLM provider key (OpenAI, Anthropic, Google, Together, OpenRouter, ...) belonging to the CUSTOMER. Langbase takes it from the keyset on their pipe, user or organization account, or from the `lbLlmKey` argument here, which Agentic Fabriq moves into the `LB-LLM-Key` request header and never stores. It is never filled in from this connection -- Agentic Fabriq holds no LLM provider key for the customer -- so a failure naming a missing or invalid LLM key is not a problem with this Langbase connection. Langbase's SDK reference types the LLM key as required for this primitive while its API reference does not mark the header required; that disagreement is unresolved here because no Langbase credential existed to settle it, so pass `lbLlmKey` if a run fails asking for a key. STREAMING IS NEVER EXPOSED: Agentic Fabriq pins `stream: false` on this call after merging the caller's body, so a caller cannot re-enable it. A streamed reply is a Server-Sent-Events body that cannot be returned as a tool result, and this connector follows no redirects. Langbase reports a failure as `{"success": false, "error": {"code", "status", "message", "docs"}}`, and a 400 on a write carries the ZodError that names the exact field (`invalid_type: name: Required`) -- the most useful thing in the reply, so it is passed through. Agentic Fabriq removes this connection's API key from every Langbase message before it is raised or logged, because Langbase's 401 repeats the key it was sent. THIS ROUTE'S REJECTION NAMES A USER KEY. Measured credential-free on 2026-09-22: a bad credential here answers `Invalid user API key` rather than echoing the value sent, which most shipped routes do -- so an ORGANIZATION key may not reach this tool. Unconfirmed, because a bogus key cannot tell us which kind a caller must hold: the message names the kind the handler looked the key up as. If this tool fails with a 401 while the pipe and memory reads work on the same connection, try a user-level key.

Split text into overlapping chunks with Langbase's own chunker, and get `{"success": true, "chunks": ["..."]}`. A stateless utility: it stores nothing and touches no memory, which is why it is classified as a read. Pair it with Embed text chunks to build vectors outside a Langbase memory. Langbase reports a failure as `{"success": false, "error": {"code", "status", "message", "docs"}}`, and a 400 on a write carries the ZodError that names the exact field (`invalid_type: name: Required`) -- the most useful thing in the reply, so it is passed through. Agentic Fabriq removes this connection's API key from every Langbase message before it is raised or logged, because Langbase's 401 repeats the key it was sent.

Turn texts into embedding vectors: the reply is a bare ARRAY of vectors (arrays of numbers), in the order the chunks were sent. THIS SPENDS EMBEDDING TOKENS on the customer's LLM provider account, and the model chosen must be one their keyset can reach. It stores nothing: to build a searchable store, use a memory instead. Langbase reports a failure as `{"success": false, "error": {"code", "status", "message", "docs"}}`, and a 400 on a write carries the ZodError that names the exact field (`invalid_type: name: Required`) -- the most useful thing in the reply, so it is passed through. Agentic Fabriq removes this connection's API key from every Langbase message before it is raised or logged, because Langbase's 401 repeats the key it was sent.

Generate an image and get back the provider's completion object, whose `choices[].message.images[].image_url.url` holds the result's URL. THE IMAGE BYTES DO NOT PASS THROUGH AGENTIC FABRIQ: the reply is a URL at the model provider, and such URLs are usually short-lived, so fetch it promptly with your own client. THIS SPENDS IMAGE-GENERATION CREDIT. `lbLlmKey` IS REQUIRED HERE -- Langbase's images reference marks the `LB-LLM-Key` header required and says in its own words that the LLM keys for the image provider must be supplied. RUNNING A MODEL NEEDS A SECOND CREDENTIAL THAT IS NOT THIS CONNECTION'S: an upstream LLM provider key (OpenAI, Anthropic, Google, Together, OpenRouter, ...) belonging to the CUSTOMER. Langbase takes it from the keyset on their pipe, user or organization account, or from the `lbLlmKey` argument here, which Agentic Fabriq moves into the `LB-LLM-Key` request header and never stores. It is never filled in from this connection -- Agentic Fabriq holds no LLM provider key for the customer -- so a failure naming a missing or invalid LLM key is not a problem with this Langbase connection. Langbase reports a failure as `{"success": false, "error": {"code", "status", "message", "docs"}}`, and a 400 on a write carries the ZodError that names the exact field (`invalid_type: name: Required`) -- the most useful thing in the reply, so it is passed through. Agentic Fabriq removes this connection's API key from every Langbase message before it is raised or logged, because Langbase's 401 repeats the key it was sent. THIS ROUTE'S REJECTION NAMES A USER KEY. Measured credential-free on 2026-09-22: a bad credential here answers `Invalid user API key` rather than echoing the value sent, which most shipped routes do -- so an ORGANIZATION key may not reach this tool. Unconfirmed, because a bogus key cannot tell us which kind a caller must hold: the message names the kind the handler looked the key up as. If this tool fails with a 401 while the pipe and memory reads work on the same connection, try a user-level key.

Create a memory: a RAG store that documents are uploaded into and retrieved from. Only `name` is required (measured 2026-09-22). THERE IS NO UPDATE TOOL FOR A MEMORY in the v1 API -- the chunking and the embedding model are fixed when it is created, so choose them deliberately; changing either means deleting the memory and starting again. Langbase reports a failure as `{"success": false, "error": {"code", "status", "message", "docs"}}`, and a 400 on a write carries the ZodError that names the exact field (`invalid_type: name: Required`) -- the most useful thing in the reply, so it is passed through. Agentic Fabriq removes this connection's API key from every Langbase message before it is raised or logged, because Langbase's 401 repeats the key it was sent.

Step one of adding a document to a memory: Langbase answers `{"signedUrl": "..."}`, a pre-signed URL to PUT the file's bytes to. THE BYTES DO NOT PASS THROUGH AGENTIC FABRIQ and cannot: no tool here carries file content, so the signed URL must be handed to whatever holds the file. That URL is the PRODUCT of this call and is returned whole -- it is a time-limited write capability for one object, not this connection's credential, and withholding it would leave the tool with nothing to return. Nothing is indexed until the bytes are uploaded; poll List a memory's documents for the document's `status`. Langbase reports a failure as `{"success": false, "error": {"code", "status", "message", "docs"}}`, and a 400 on a write carries the ZodError that names the exact field (`invalid_type: name: Required`) -- the most useful thing in the reply, so it is passed through. Agentic Fabriq removes this connection's API key from every Langbase message before it is raised or logged, because Langbase's 401 repeats the key it was sent.

Search one or more memories and get back the matching chunks with their similarity scores and metadata: `{"chunks": [{"text", "similarity", "meta"}]}`. This is a READ that spends embedding tokens on the query. It is a POST because the query rides in the body, not because it changes anything. Langbase reports a failure as `{"success": false, "error": {"code", "status", "message", "docs"}}`, and a 400 on a write carries the ZodError that names the exact field (`invalid_type: name: Required`) -- the most useful thing in the reply, so it is passed through. Agentic Fabriq removes this connection's API key from every Langbase message before it is raised or logged, because Langbase's 401 repeats the key it was sent.

Create a pipe: a named, stored LLM agent with its model, prompt messages, generation parameters, tools and grounding memories. Only `name` is required (measured 2026-09-22); everything else falls back to Langbase's defaults (`model: openai:gpt-4.1-mini`, `status: public`, `type: generate`, `temperature: 0.7`, `max_tokens: 2048`). NOTE `status`: Langbase's own default is `public`, which makes the pipe runnable by anyone holding its URL. THE REPLY CARRIES THE NEW PIPE'S OWN API KEY AND AGENTIC FABRIQ REDACTS IT: `api_key` comes back as a marker rather than a live credential, because a tool result is copied into the model's context and into the audit trail, and nothing here needs a pipe key. Read it in Langbase Studio if it is wanted. Langbase reports a failure as `{"success": false, "error": {"code", "status", "message", "docs"}}`, and a 400 on a write carries the ZodError that names the exact field (`invalid_type: name: Required`) -- the most useful thing in the reply, so it is passed through. Agentic Fabriq removes this connection's API key from every Langbase message before it is raised or logged, because Langbase's 401 repeats the key it was sent.

Update a pipe's configuration. Note the verb and the address: Langbase updates with POST on `/v1/pipes/{pipeName}`, not PUT or PATCH, and the path takes the pipe NAME rather than an id. No field is required. Send only what is changing -- and read `regenerateApiKey` before setting it, because it invalidates the pipe's existing key. THE REPLY CARRIES THE PIPE'S API KEY AND AGENTIC FABRIQ REDACTS IT, for the reason Create a pipe gives. Langbase reports a failure as `{"success": false, "error": {"code", "status", "message", "docs"}}`, and a 400 on a write carries the ZodError that names the exact field (`invalid_type: name: Required`) -- the most useful thing in the reply, so it is passed through. Agentic Fabriq removes this connection's API key from every Langbase message before it is raised or logged, because Langbase's 401 repeats the key it was sent.

Run one of the account's pipes and get its completion: `{"completion": "...", "raw": {...usage...}}`. THIS SPENDS MODEL TOKENS on the customer's LLM provider account. RUNNING A MODEL NEEDS A SECOND CREDENTIAL THAT IS NOT THIS CONNECTION'S: an upstream LLM provider key (OpenAI, Anthropic, Google, Together, OpenRouter, ...) belonging to the CUSTOMER. Langbase takes it from the keyset on their pipe, user or organization account, or from the `lbLlmKey` argument here, which Agentic Fabriq moves into the `LB-LLM-Key` request header and never stores. It is never filled in from this connection -- Agentic Fabriq holds no LLM provider key for the customer -- so a failure naming a missing or invalid LLM key is not a problem with this Langbase connection. STREAMING IS NEVER EXPOSED: Agentic Fabriq pins `stream: false` on this call after merging the caller's body, so a caller cannot re-enable it. A streamed reply is a Server-Sent-Events body that cannot be returned as a tool result, and this connector follows no redirects. Langbase reports a failure as `{"success": false, "error": {"code", "status", "message", "docs"}}`, and a 400 on a write carries the ZodError that names the exact field (`invalid_type: name: Required`) -- the most useful thing in the reply, so it is passed through. Agentic Fabriq removes this connection's API key from every Langbase message before it is raised or logged, because Langbase's 401 repeats the key it was sent.

Create a conversation thread, optionally with metadata and opening messages. The reply carries the thread's `id`, which Run a pipe takes as `threadId` to continue a conversation. The sealed OpenAPI document declares no request body for this route -- the fields here come from Langbase's own Threads reference -- and the endpoint's existence is not in doubt: it appears in the API's live route table, which is what settles the one operation the endpoint ledger recorded as inconclusive. Langbase reports a failure as `{"success": false, "error": {"code", "status", "message", "docs"}}`, and a 400 on a write carries the ZodError that names the exact field (`invalid_type: name: Required`) -- the most useful thing in the reply, so it is passed through. Agentic Fabriq removes this connection's API key from every Langbase message before it is raised or logged, because Langbase's 401 repeats the key it was sent.

Update a thread's metadata -- the only writable part of a thread. Note the verb: Langbase updates with POST on the thread's own URL, not PUT or PATCH. Langbase reports a failure as `{"success": false, "error": {"code", "status", "message", "docs"}}`, and a 400 on a write carries the ZodError that names the exact field (`invalid_type: name: Required`) -- the most useful thing in the reply, so it is passed through. Agentic Fabriq removes this connection's API key from every Langbase message before it is raised or logged, because Langbase's 401 repeats the key it was sent.

Append messages to an existing thread. THE BODY IS A BARE ARRAY of message objects: Langbase's Threads reference documents `{"messages": [...]}` and the server rejects exactly that -- see the measurement on the body argument. Answers the appended messages with their new ids. Langbase reports a failure as `{"success": false, "error": {"code", "status", "message", "docs"}}`, and a 400 on a write carries the ZodError that names the exact field (`invalid_type: name: Required`) -- the most useful thing in the reply, so it is passed through. Agentic Fabriq removes this connection's API key from every Langbase message before it is raised or logged, because Langbase's 401 repeats the key it was sent.

Rewrite one message in a thread -- its text, its metadata, or both. This EDITS CONVERSATION HISTORY: a stored assistant message can be changed to say something the model never said, and anything reading the thread afterwards sees the edit as the original. Note the verb: POST on the message's own URL. Langbase reports a failure as `{"success": false, "error": {"code", "status", "message", "docs"}}`, and a 400 on a write carries the ZodError that names the exact field (`invalid_type: name: Required`) -- the most useful thing in the reply, so it is passed through. Agentic Fabriq removes this connection's API key from every Langbase message before it is raised or logged, because Langbase's 401 repeats the key it was sent.

Fetch web pages through Langbase and get `[{"url", "content"}]`. The crawl runs at Spider.cloud or Firecrawl, so `lbCrawlKey` IS REQUIRED and is THE CUSTOMER'S OWN KEY at whichever of those `service` names -- never this Langbase connection's credential and never filled in from it. Measured 2026-09-22: with `{}` this route answers 400 `invalid_type: LB-CRAWL-KEY: Required`, before it looks at the Langbase credential. Agentic Fabriq moves the value into the `LB-CRAWL-KEY` header, never into the URL, and does not keep it. NOTE WHAT THIS DOES: it makes Langbase's crawler fetch URLs you name, from Langbase's network, so treat it as an outbound request on the customer's behalf. Langbase reports a failure as `{"success": false, "error": {"code", "status", "message", "docs"}}`, and a 400 on a write carries the ZodError that names the exact field (`invalid_type: name: Required`) -- the most useful thing in the reply, so it is passed through. Agentic Fabriq removes this connection's API key from every Langbase message before it is raised or logged, because Langbase's 401 repeats the key it was sent.

Search the web through Langbase and get `[{"url", "content"}]` -- the extracted page text, not just links. The search itself runs at Exa, so `lbWebSearchKey` IS REQUIRED and is THE CUSTOMER'S OWN EXA API KEY (exa.ai dashboard), never this Langbase connection's credential and never filled in from it: Agentic Fabriq holds no Exa key. Measured 2026-09-22: with `{}` this route answers 400 `invalid_type: lb-web-search-key: Required`, before it looks at the Langbase credential. Agentic Fabriq moves the value into the `LB-WEB-SEARCH-KEY` header, never into the URL, and does not keep it. Langbase reports a failure as `{"success": false, "error": {"code", "status", "message", "docs"}}`, and a 400 on a write carries the ZodError that names the exact field (`invalid_type: name: Required`) -- the most useful thing in the reply, so it is passed through. Agentic Fabriq removes this connection's API key from every Langbase message before it is raised or logged, because Langbase's 401 repeats the key it was sent.

Record an execution trace. UNDOCUMENTED, in two ways worth knowing before calling it: Langbase's API reference has no traces page (404, measured 2026-09-22), and the sealed OpenAPI document declares no request body for this operation -- so this tool forwards a free-form JSON object and cannot validate it for you. The route itself certainly exists: it is in the API's live route table, which is what settles one of the three operations the endpoint ledger recorded as inconclusive. Langbase reports a failure as `{"success": false, "error": {"code", "status", "message", "docs"}}`, and a 400 on a write carries the ZodError that names the exact field (`invalid_type: name: Required`) -- the most useful thing in the reply, so it is passed through. Agentic Fabriq removes this connection's API key from every Langbase message before it is raised or logged, because Langbase's 401 repeats the key it was sent.