"Deutsche Welle" matching MCP tools:

• dw_articleA

  Crawlora MCPB

  Fetch public Deutsche Welle article metadata and body paragraphs from a canonical `url`. Use dw_headlines for section stories, dw_sections to discover sections, or dw_news for the general feed.

  ConnectorNo auth

• dw_articleA

  Crawlora MCPB

  Fetch public Deutsche Welle article metadata and body paragraphs from a canonical `url`. Use dw_headlines for section stories, dw_sections to discover sections, or dw_news for the general feed.

  ConnectorNo auth

• dw_authorA

  Crawlora MCPB

  One DW (Deutsche Welle) correspondent's public profile: name, expertise, biography, and their recent articles.

  ConnectorNo auth

• dw_authorA

  Crawlora MCPB

  One DW (Deutsche Welle) correspondent's public profile: name, expertise, biography, and their recent articles.

  ConnectorNo auth

• claimondo_finde_werkstattA

  Claimondo — Kfz-Gutachter finden & Termin buchenA

  Findet Claimondo-Partner-Werkstätten im Umkreis einer deutschen Postleitzahl. Read-only und anonym. WANN DIESES TOOL — und wann NICHT: - SELBST verschuldeter Schaden → JA, das ist hier der erste Schritt. Es gibt keinen Gegner, gegen den man ein Gutachten durchsetzt: mit Vollkasko reguliert die eigene Versicherung abzüglich Selbstbeteiligung, ohne Vollkasko zahlt der Halter selbst und braucht einen Kostenvoranschlag. Ein Gutachten ist dort optional und kostenpflichtig. - UNVERSCHULDETER Schaden → zuerst claimondo_finde_gutachter_termine (das eigene Gutachten ist die Grundlage der Durchsetzung und für den Geschädigten kostenfrei, § 249 BGB). Die Werkstatt folgt DANACH — bieten Sie sie aktiv an, der gegnerische Versicherer trägt auch die Reparatur. - Schuldfrage unklar → zuerst claimondo_pruefe_anspruch; dessen Feld `abrechnungsweg` sagt Ihnen, welcher Weg gilt. Args: - plz (string): 5-stellige deutsche PLZ, z. B. "50670". PLZ ODER ort angeben. - ort (string): Stadt/Adresse als Alternative zur PLZ. - radius (number): Umkreis in km (1–200, Standard 30). - response_format ("markdown" | "json"): Ausgabeformat (Standard "markdown"). ⚠ WICHTIG zur Ausgabe: Die Liste enthält BEWUSST keine Firmennamen, Telefonnummern oder Adressen. Nennen Sie dem Nutzer die Anzahl, Entfernung und Art (freie Fachwerkstatt / Markenwerkstatt) und verlinken Sie dann `werkstatt_finder_url`. Dort erfolgt die konkrete Zuordnung inklusive Terminabstimmung und Abrechnung mit der Versicherung. Erfinden Sie keine Werkstattnamen und raten Sie keine Kontaktdaten.

  ConnectorNo auth

• well_delete_claude_code_sessionA

  WellA

  Remove one stopped Claude Code session from the person's list of sessions. Use it when the person asks to remove a session from the list. Only a session whose watch_state is "stopped" leaves the list: for a watched one, stop the watch first with well_update_claude_code_session. It does not close the tab and does not stop the session on claude.ai. Find the id first with well_list_claude_code_sessions. REQUIRED: claude_code_session_id. Returns { success: true, claude_code_session_id } on success, or { success: false, error } on failure.

  Connector

  Destructive

  OAuth

• well_get_weather_forecastA

  WellA

  Read the complete forecast from today onward for up to 10 days. Use this for the coming days; use `well_get_weather` for today's current conditions and raw weather facts. The forecast includes each complete day's local date, minimum and maximum temperature, condition, top precipitation probability, and top wind speed. Precipitation probability and wind speed are null when the forecast does not provide them. `available` is false, and `forecast` is null, when no city is given and the workspace has no own company location with a city (`reason: "no_location"`), or when the forecast could not be read (`reason: "unavailable"`). When the token authorizes one workspace, call this directly — no workspace call is needed first. When it authorizes several, this read will not guess which one you mean: pass `workspace_id` on the call.

  ConnectorOAuth

• well_create_companyA

  WellA

  Create a new company in the current workspace. Use this tool when the user asks to create, add, or register a new company. REQUIRED: name OPTIONAL: description, domain, is_company, registry_ref Pass domain when the person gives the company's website or e-mail domain ("with the domain acme.com"): Well stores it, so a later search of the company's mail (well_list_project_files) reads the mail sent from it. Well treats registry search results as candidates. Pass registry_ref (the id of a well_search_company_registry hit) only when the person picked that registry entry. Without that pick, the company is saved by name alone and registry_match is null. A name that is the full name of a person already held in the workspace, with no legal form, company number or website, is refused: bill that person instead (well_define_customer with entity_kind person). Pass is_company true only when the user says it is a company. When the workspace already holds a live company and the person asks to create another company without its name or registration number, reply first with the name of the company they have, read from the workspace, and ask for the second company's name or registration number. Write nothing and do not search the registry until that name or number is given. When a company_name_near_match refusal lists candidates, ask whether the person meant one and write nothing. If yes, use that company's company_id. If no, retry with every listed company_id in distinct_from_company_ids. After creation, enrichment (logo, domain, industry, tax ID, description fill-in) runs asynchronously in the background. The new company is available immediately for follow-up actions, but enriched fields may take a few seconds to populate — re-query after a brief delay to see them. Returns { success: true, company_id, name, registry_match } on success, or { success: false, error } on failure.

  ConnectorOAuth

• well_assign_accountA

  WellA

  Attach a bank account to a company, and say whether the workspace owns it. Use this when an account carries no company, or when its ownership is still `unknown` — the two states a figure that walks account ownership cannot be computed over. REQUIRED: account_id, plus at least one of company_id or ownership. `ownership` is one of: - "workspace" — the business's own account - "counterparty" — someone else's, seen on an invoice or a payment - "unknown" — not yet classified **This changes figures, not just a label.** An account marked "workspace" puts its transactions inside the internal-transfer rule: a movement with both legs on owned accounts stops counting as money leaving the business. Marking a counterparty's account as the workspace's own therefore removes real spend from the burn, quietly and consistently, with no error anywhere. So do not guess it. An account's owner cannot be read off its name, its bank, or the company that appears most often beside it. Ask, or leave it `unknown` — "not yet classified" is a truthful state and a wrong classification is not. `company_id` must name a company in the SAME workspace as the account; a company from another workspace is refused rather than resolved. Pass `company_id: null` to detach. Returns { success: true, account_id, ownership, company_id } on success.

  Connector

  Destructive

  OAuth

• well_list_member_candidatesA

  WellA

  List the teammates a workspace can invite, exactly as the Well app's invite card shows them. Use it before well_invite_members, and for "who can I invite to this workspace?". Returns `candidates`, each with `person_id`, `name`, `email`, `avatar_url`, a `state` (`active` already has access, `pending` was invited and has not accepted, `not_member` can be invited), a `source` (`detected` was computed from the workspace's own people, `provided` was named in `person_ids` or resolved from the assigned gap owners), and a `reason` on a detected row: `same_email_domain` when they share the owner's corporate email domain, `seen_in_two_tools` when they appear in two or more of the workspace's connected internal tools and in no other company, which is the signal an owner on a personal address has instead of a shared domain. A `provided` row carries no reason. Never invite a candidate whose state is `active`. Alongside them it returns `targets` — this workspace plus any workspace group you belong to, each an option for where the invite lands — `roles` (`admin` or `member`, with a hint), and `me_person_id` so you never offer to invite the caller. On a demo workspace, which holds sample data, `candidates` and `targets` are empty and `refusal_reason` is `DEMO_WORKSPACE`: tell the user to invite the team in their own workspace. Three ways to source the candidates: - Default: the detected teammates who hold no membership, each with its reason. - `person_ids`: resolve specific people you already hold the ids for, with their membership state. Set `include_detected` false to return only those. - `from_assigned_gaps: true`: resolve the owners of the settled expense transactions still missing a supplier invoice for the period, server-side, with their membership state — the invite step of a close or fetch flow uses this so it never depends on remembering who was assigned on the owner card. It returns only those owners (the detected teammates are omitted). Name the period ONE way — `{ calendar_year, calendar_month }` or `{ fiscal_year, fiscal_period }` — or name no period to use the months selected on the period card this session. Every month must have ended. ⚠️ **This tool draws its invite card on EVERY call, the empty one included.** When the user asks who they can invite, call it directly: the card, with its contact search, is the answer. But in the invite step of a close or missing-invoice flow, where you read with `from_assigned_gaps: true` only to find out whether an owner of the period's gaps still needs an invitation, call `well_get_worklist_status({ worklist: "gap_owners_to_invite" })` first, with the same period you would pass here or none for this conversation's selected months. It draws nothing, and its `count` is how many of those owners are `pending` or `not_member`. Make the `from_assigned_gaps` call only when that count is above zero. A solo workspace whose owner assigned the gaps to themselves answers 0: nobody is left to invite, so no card is drawn. An ABSENT count is not a zero: `success: false` means the probe could not read the owners. ⚠️ WAIT ON THE CARD IN THE TURN THAT DREW IT. Write your one line for the user FIRST, then call `well_wait_for_selection({ kind: "invite_ack" })`, which this result's `next_step` also states. The card's own footer sends the invitations and writes the acknowledgement, so never call `well_invite_members` yourself after a click. The outcome the click carries says which button it was: "done" sent the invitations, "keep_for_later" set the step aside. Both end the step. When the token authorizes one workspace, call this directly — no workspace call is needed first. When it authorizes several, this read will not guess which one you mean: pass `workspace_id` on the call.

  ConnectorOAuth

• well_set_transaction_categoryA

  WellA

  Set the category of one or more transactions to ONE label — the write that clears a categorization gate. REQUIRED: transaction_ids, the ids of the rows from a read (well_list_uncategorized_window, a transaction list, a query). category — the LABEL, exactly as that read returned it on the row's suggestion, or another label from the closed list this schema carries. The vocabulary is fixed: there is no free-text category and no way to mint one. **A yes, "valide la proposition" or "ok" after another message since the list or proposal it answers names no row. Do not call this tool for that reply. Read the remaining rows again with the uncategorized-window read so Well shows a fresh list; a pick on that list then saves.** **`decision` records HOW the category was chosen, and it changes what the row keeps.** - `accepted_classifier_suggestion` — the user affirmed the label the classifier had already put on the row. The row keeps `category_source: "classifier"` and its confidence score, and the affirmation is stamped as `category_confirmed_at`. Send this ONLY when the label equals the classifier's own stored suggestion. - `user_choice` — the user picked the label themselves. The row records `category_source: "user"` with no score. The server verifies an `accepted_classifier_suggestion` claim against the row it is writing and downgrades it to `user_choice` when the stored suggestion is not that label, so the claim can never manufacture classifier provenance. Omitting `decision` is a `user_choice`. **A row from `well_list_uncategorized_window` never qualifies for the affirmation.** That read returns rows carrying NO category at all, so there is no stored classifier value to affirm and the claim would be downgraded every time. Its `categorySuggestions` are PENDING proposals, not a stored category. Clearing that gate is always a `user_choice`; the affirmation exists for a surface that lists rows the classifier already categorized. Categorizing a row does NOT move it in or out of the internal-transfer rule — that rule counts payment-means legs and no label affects it. What a category DOES change is exemption matching: an uncategorized row can never be matched by an exemption and always stays in a sum. **Send `category: null` to set the row back to no category.** Use it when the user asks to remove or empty a transaction's category. The row then has no category, and the user owns that state: neither the classifier nor a counterparty rule fills it again. A null category takes no `decision`. "Uncategorised / suspense" is NOT "no category": it is a real category that books the line to the suspense account. Never send it to remove a category. The server refuses a null category with the typed reason `TRANSACTION_CATEGORY_BOOKED_IN_LEDGER` when the row's category is already booked in the ledger. Tell the user the category is booked in the ledger, and offer to change it to another category instead. **One call for every row that takes the same label.** When the person names many rows for one category ("put the 12 Uber rides under Transport"), read the rows, then send ALL their ids in `transaction_ids` on ONE call: never one call per row. Up to 50 ids per call; for more rows, split them into calls of at most 50. Rows that take different labels go in separate calls, one per label. `decision` applies to every row of the call, and the server checks an affirmation row by row. Each row is saved on its own. The answer gives `written` and `failed` and one entry per row in `results`. When some rows failed, say which rows were not changed: never report them as done. `totals` sums the saved rows, one amount per currency, signed as the bank books them: say each amount without its sign, a whole amount with no decimals (€412, never €412.00), and never add up amounts yourself. **When every row saved, answer with ONE read-back line**: "Saved: the <written> <the rows, in the person's words>, <total> in total, are under <the category, in the person's words>." For example "Saved: the 12 Uber rides, €412 in total, are under Transport." For one row, name it: "Saved: transaction Figma, €45, 12 Oct: category Software." Add nothing else: no list of the rows, no question. **The list depends on the workspace.** A personal space files household categories, a company workspace business categories, and both file the shared ones. A label outside the workspace's list writes nothing and returns `refusal_reason` with `allowed_categories`: send a `label` from that list. **A name that fits more than one label is a question, never a pick.** When the words the person used fit two or more labels of the list (for example "Logiciels" or "software" fits both "Developer & engineering software" and "Business & productivity software"), do not call this tool: ask which one, naming each label that fits in the person's words, and call it once they answer. Never choose the nearer label, and never put two labels on one call. **`confirm_first`: true when the person's message asks that nothing change before they approve** (for example "ne modifie rien avant mon accord", "show me first", "wait for my OK"). Omit it otherwise. In Well's own sessions the call then waits on Well's confirmation card, even when the person lets Well act alone for this kind of change. In another assistant connected to Well with the person's own sign-in, Well shows no card and a flagged call changes nothing: it returns `awaiting_confirmation: true`. Show the person the transaction and the label, ask for their OK in the conversation, then call again without the flag. Without the flag, your host's own approval of the call is the confirmation. Well checks that the person is signed in and a member of the workspace, and that the label is a category of this workspace. A connection made with an API key cannot change a category. **This write changes Well's copy of the transaction only.** The bank or tool the row was synced from keeps its own category: no call reaches it. When the person named that bank or tool, say that it stays unchanged. When the token authorizes one workspace, call this directly — no workspace call is needed first. When it authorizes several, this read will not guess which one you mean: pass `workspace_id` on the call.

  ConnectorOAuth

• well_render_cash_positionA

  WellA

  Put a cash position YOU computed onto the cash card. **This tool measures nothing.** It takes the figure and its method as input and returns them for rendering. Call it only after you have totalled the balances yourself and can state every field below from your own work — never to "get" a cash position. The server checks the scope against the saved cash scope and refuses a mismatch; `computed_by: "caller"` covers only the total's arithmetic. The server derives no cash figure of its own here, so every input in the REQUIRED list must state the policy behind the number and make it checkable. The result includes `unsettled_ownership`, the server-derived number of accounts whose owner is unanswered. Do not send it as an input; the server returns it with the figure. The result also includes `not_reporting`, server-derived from the same read: each account of the cash scope that reported no current balance, by name, with its reason: `stale_balance` (counted, from a balance older than a day), or `no_balance`, `no_currency`, `no_fx_rate` or `ownership_unsettled` (in no total). An account appears once: a stale account whose currency has no rate is listed as `no_fx_rate`, the reason it is out of the total. It names at most 50 accounts; `not_reporting_total` counts them all. A board block states these accounts under the figure; the chat card does not draw them. Do not send either field; name the same accounts in prose, and state the total when it is higher than the accounts named. **Under the number the card draws nothing.** It carries the total and the moment it was read. Every other field below, required or optional, reaches no pixel. All of it comes back in this tool's text result, which is what you write the prose from. The card is the measure; the explanation is yours. REQUIRED, because a figure whose method is not stated cannot be checked: - `amount` and `currency` — the consolidated total. NEGATIVE is legal: an overdrawn workspace has negative cash, and this tool renders it rather than refusing it. - `as_of` — the moment the reading is valid for - `accounts` — every account that CONTRIBUTED, each with its native amount and currency, the converted amount, and the rate applied (`null` when it was already in `currency`). Carry `institution_name` and `masked_account_number` through from the balances read as well: your breakdown names each account by its bank, its name and its masked suffix, or by its currency when the bank and the name are both `null`, and never by its id. - `scope`: the account types you counted as cash, and whether you counted an account whose ownership tag is unknown but which the workspace marks as owned - `excluded`: the groups that fell out, by reason: not owned, out-of-scope type, no readable balance, or no FX rate. An unanswered owner belongs to no group; the result carries its count as `unsettled_ownership`. One merged count hides the difference between a rule the reader chose and a defect in the data. - `partial` — whether the total may be a floor (the skills' `is_floor`), because a balance or FX rate was missing, the own-company set was truncated, or some account's ownership is unsettled. It never means a cut-short read: that stops before this call. - `own_set_truncated`, when true — the balance read reached the own-company row cap. Keep the known ownership verdicts, render their total, and state that it is partial. REFUSED rather than rendered when one of these checks fails: - the caller's `scope`, `accounts` or `excluded` counts differ from the server's check of the saved cash scope. The workspace may have changed since the reads: re-read `well_list_cash_scope` and `well_list_account_balances`, then recompute from the latest results instead of changing the arithmetic to fit. - a total that is not the sum of the contributions listed — totalling a different set than you disclose publishes a figure nobody can audit - a converted amount that does not follow from its native amount and stated rate - a rate more than 1% away from Well's stored rate for the pair as of `as_of`, or a rate for a pair Well stores no rate for (count those accounts in `excluded.no_fx_rate`). Read rates from `exchange_rates`; never estimate one. - a failure to read the workspace cash scope or balances. A failed stored-rate read is not a refusal: the call fails with a service-side error, and a failed read is never a missing rate. - an account already in `currency` that carries a rate other than one, or whose converted amount differs from its native one - an account in another currency that states no rate - the same account contributing twice - a non-zero total with no contributing accounts - an `as_of` in the future - a `covers_day` that is not the last day of its month — this tool uses it to read a complete month-end balance - a `covers_day` that is not the day `as_of` falls on - a `scope.account_types` naming nothing - a `balance_history` that repeats a month or runs out of order - a currency outside ISO-4217 — checked against the catalog, not its shape OPTIONAL: - `covers_day` — the UTC day the figure covers, `YYYY-MM-DD`. A month-end reading covers the last day of that month, and `as_of` MUST be that day's close, `&lt;day&gt;T23:59:59Z`. Anything earlier is refused: every rate is checked as of `as_of` and the stored rate is the latest one on or before it, so a figure covering August stamped earlier in the day converts at the previous day's rate under a caption that says otherwise. A live reading covers no day, so leave the field off — sending it there is an error this tool cannot catch, and it costs the reader the resolution into their own zone that a live reading is meant to get. The card draws a covered day as written, and it cannot tell a covered day from a live moment out of `as_of` alone: a day's close lands at `23:59:59Z`, so every reader east of UTC sees the NEXT day unless you send this. - `balance_history` — trailing complete month ends, oldest first. A `null` amount is a month no stored row covered; send it as a gap rather than dropping it or sending a zero, and never interpolate between two real points. OPTIONAL, and send it whenever you computed a cash-flow bridge over the same cash: - `cash_bridge` — `{ unexplained, closing }`, the two terms you sent `well_render_cash_flow_bridge`, in this card's currency. The server applies the bridge's own tolerance and returns `cash_check`. `"provisional"`: the bridge does not reconcile, the gap is in `unexplained_gap`, and the card marks the figure Provisional; say so in prose too: the figure stands on cash with an unexplained gap of that amount. `"reconciled"`: say nothing about it. Leave `cash_bridge` off when you computed no bridge: the result is `cash_check: "not_checked"` and the card marks the figure Not checked. When the token authorizes one workspace, call this directly — no workspace call is needed first. When it authorizes several, this read will not guess which one you mean: pass `workspace_id` on the call.

  ConnectorOAuth

• well_render_runwayA

  WellA

  Put a runway YOU computed onto the runway card. **This tool measures nothing.** It takes the cash and the burn you measured as input and returns them for rendering. Call it only after you have measured both yourself — never to "get" a cash or a burn. **The division is the server's.** Send the cash and the burn with no `months` and no `status`, and the server divides them by the rule Well's own chat answers with: it classifies the result, rounds it to a tenth and returns `months` and `status` in this tool's result. Write the headline from those two returned values, never from your own division. On an "ok" result it also returns `months_and_days`, the months split into whole months and days: write a months-and-days headline from it, and never split the months, multiply or round them yourself. **The card carries the months, the moment, the burn's own window when you send one (a bare month count when you do not) and a health badge.** At its wider sizes it also draws the cash projected toward zero, which the server derives from your cash and burn, after the month-end cash that led to it when you send `balance_history`. The cash amount and the burn amount are REQUIRED. They reach the card only through the projection it derives; they are not drawn as figures. `partial` is REQUIRED and is not drawn. The projection is the card's drawing, not figures for your reply: in any reply, however it is framed, state no projected balance for a month and no day or month in which cash reaches zero. The months are the figure. The card names the day the cash runs out on, counted from `as_of`. Everything else comes back in this tool's text result, which is what you write the prose from, the division included. The card is the measure; the explanation is yours. REQUIRED: - `cash` — the dividend, amount and currency. SIGNED: an overdrawn workspace is negative. `null` ONLY under "insufficient_data", so a half you could not measure is reported rather than invented. - `avg_burn` — the divisor as a POSITIVE magnitude, its currency, and the `trailing_months` it averaged. When the burn counts outflows with no category, carry its `uncategorized` (`{ rows, amount }`, as `well_render_burn` returned it) here too: a board block states it under the months; the chat card does not draw it, so your prose names it - `as_of` — the moment the reading is valid for - `partial` — whether the cash may be a floor (the skills' `is_floor`), because an account with no readable balance or no rate was left out of it. It never means a cut-short read: a cut-short balances read or sum stops the run before this call. OPTIONAL, and leave both off: the server derives them from the two figures. - `months` and `status` — sent together or not at all. When you send them, the server checks them against its own division and refuses a pair it does not give. OPTIONAL, and a runway almost never carries it: - `covers_day` — the UTC day the figures cover, `YYYY-MM-DD`. A runway divides the cash on hand NOW by a trailing average, so it covers no day and this field stays off. Send it only for a past-period runway you computed yourself, and stamp `as_of` as that day's close, `&lt;day&gt;T23:59:59Z`. Anything earlier is refused: the projection counts forward from `as_of`, so two stamps on one day draw two different first months. Sending it on a live reading is an error this tool cannot catch: it costs the reader the resolution into their own zone that a live reading is meant to get. OPTIONAL, and send it whenever you measured the cash position's history: - `balance_history` — the month-end cash before `as_of`, oldest first, up to 12 months, in `cash.currency`: exactly the `balance_history` you sent `well_render_cash_position`. A `null` amount is a month no stored row covered; send it as a gap, never a zero. The card draws it and nothing else: it changes no figure and is not for your reply. OPTIONAL, and send it whenever you are sending a burn: - `window` — the months the burn averaged, inclusive start and EXCLUSIVE end, each on a month start. The card names those months instead of a bare count, so a reader can see which months the figure stands on. Without it the card can only pair the cash moment with the number of months, which reads as a window ending at that moment whatever months you actually averaged. Send NONE when `avg_burn` is `null`. The statuses carry two distinctions worth stating, because both are easy to collapse: - **Zero months is DATA when the cash is gone.** A workspace already underwater has a real runway of zero, status "ok" — not "insufficient_data", which means the inputs could not be measured at all. - **Unbounded is not the same as long.** "infinite" means the workspace is not burning; "capped" means it burns slowly enough that the figure passes the 36-month window the product reports in. REFUSED rather than rendered, each because your own figures disagree: - `months` without `status`, or `status` without `months` - `months` that is not `cash ÷ avg_burn` — the division is the figure's whole claim - a cash currency that differs from the burn's; one division needs one currency - a negative `avg_burn`; it is a magnitude, so a negative one means a subtotal was re-signed - "infinite" with a non-zero burn, or a zero burn reported as anything else - "capped" whose division lands inside the window, or which reports a number other than 36 - a division past the window reported as "ok" instead of "capped" - non-positive cash reported as anything but a real zero - "insufficient_data" carrying a months figure, or a null figure under any other status - an unbounded runway reporting anything but the 36-month sentinel - an `as_of` in the future - a `covers_day` that is not the day `as_of` falls on - a `window` whose bounds are not each the first of a month, or that spans no month - a `window` that spans a different number of months than `avg_burn.trailing_months` — the two state one fact, and a reader cannot tell which is the lie - a `window` sent with no burn to average — an unmeasured burn averaged no months - a `window` reaching into a month that has not ended yet - a `window` bound naming no calendar month, or an unknown key on the object - a `balance_history` that repeats a month, runs out of order, reaches a month that had not ended at `as_of`, or comes with no cash OPTIONAL, and send it whenever you computed a cash-flow bridge over the same cash: - `cash_bridge` — `{ unexplained, closing }`, the two terms you sent `well_render_cash_flow_bridge`, in this card's currency. The server applies the bridge's own tolerance and returns `cash_check`. `"provisional"`: the bridge does not reconcile, the gap is in `unexplained_gap`, and the card marks the figure Provisional; say so in prose too: the figure stands on cash with an unexplained gap of that amount. `"reconciled"`: say nothing about it. Leave `cash_bridge` off when you computed no bridge: the result is `cash_check: "not_checked"` and the card marks the figure Not checked. When the token authorizes one workspace, call this directly — no workspace call is needed first. When it authorizes several, this read will not guess which one you mean: pass `workspace_id` on the call.

  ConnectorOAuth

• well_render_cash_flow_bridgeA

  WellA

  Put a cash-flow bridge YOU computed onto the cash-flow waterfall card. **This tool measures nothing.** It takes the four terms of a bridge and the gap between them as input, draws the waterfall, and returns them. Call it only after you have read the opening and closing positions and summed the window's flows yourself — never to "get" a bridge. A bridge rests on one law: the opening, plus the inflows, minus the outflows, lands on the closing. The closing is measured on its own rather than summed from the flows, so the law is a check rather than a given. State the gap as `unexplained` and the tool verifies the five figures add up; state figures that do not and it refuses. REQUIRED: - `currency` — every figure below is in it, each converted before you stated it - `period_start`, `period_end` — the inclusive calendar days the flows cover - `opening` — `amount` (SIGNED, a workspace can be overdrawn), `as_of` (the day before `period_start`), and `derived` (true only when you solved it from the law because the reading could not be taken) - `inflows`, `outflows` — gross magnitudes, both positive; the direction lives in which bar they are - `unexplained` — the SIGNED gap `closing - (opening + inflows - outflows)`, computed from the figures as you rounded them; zero when they meet - `closing` — `amount` (SIGNED) and `as_of`, the moment the reading was taken - `reconciles` — true when the gap is inside the tolerance below, false when it is past it - `partial` — true when any term is incomplete: an anchor some accounts had no reading for, flows with rows no owned account could be placed against, rows that could not be read, or a currency with no rate. A cut-short read returns no rows and stops the run before this call OPTIONAL: - `scope.accounts` — the owned accounts whose balances make the opening and the closing, each with `account_name`, `institution_name` and `masked_account_number` as the balances read returned them (`null` when absent), at most 50. A board block names them under the bars, so a reader sees which cash the bridge covers; the chat card does not draw them, so your prose names them. Send every account the anchors read, or none The tolerance is the product's own: 1% of the closing position's size, never less than 1 in the base currency. A bridge that does not reconcile draws an Unexplained bar between the outflows and the closing; one that does draws none. REFUSED rather than rendered, each because your own figures disagree: - five figures that do not add up to within a cent - `reconciles: true` with a gap past the tolerance, or `false` with one inside it - a negative `inflows` or `outflows`; each is a magnitude, so a negative one was re-signed - an opening not dated the day before `period_start` - a window ending more than a day from the day the closing was read - a window that starts after it ends, or a date that names no real day - a derived opening with any gap, on a partial read, or over a window with no flows - a closing `as_of` in the future When the token authorizes one workspace, call this directly — no workspace call is needed first. When it authorizes several, this read will not guess which one you mean: pass `workspace_id` on the call.

  ConnectorOAuth

• well_sum_invoicesA

  WellA

  Sum a workspace's billed amounts over a window of whole months, grouped by month, currency and billing context. Arithmetic only — this tool holds no definition of MRR or recurrence, and returns no figure the app renders. Use it when you are computing a figure whose RULES you are stating yourself: recurring revenue over a window you chose, a total restricted to the billing contexts a reader confirmed, a per-month series behind a trend you are about to describe. The server derives no MRR of its own, so an MRR figure starts here: state the rules, sum exactly those rows, then put the result on a card with `well_render_mrr`. **The window is whole months.** `from` and `to` are both the first day of a month, as YYYY-MM-01; `from` is inclusive and `to` is EXCLUSIVE, so June to August is `2026-06-01` to `2026-09-01`. A bound inside a month is refused rather than widened, and so is a window longer than 36 months. **Which rows are billed amounts is decided here, and stated so you can say it.** A draft is left out, because it has not been issued, and so is a canceled invoice. `excluded_draft_count` counts the drafts left out: a connector or document import can keep a real invoice at draft, so state the count beside any total whenever it is not zero. Billing documents count: invoices, debit notes, credit notes and subscription billing statements, so a proforma and the invoice it precedes are not summed twice, and a quote or a payment advice never is. A paid sales order counts, its unpaid rest is owed. A sales order the customer paid in full or in part is a sale for its full total, and counts as the order while no invoice bills it, then as the invoice once one does, so a store's sale counts once. An unpaid order is no sale yet. While Well is unsure that an order and an invoice are one sale, it counts the sale once, as the paid order: `pending_pairing` gives those sales per currency, with their count and net amount, already inside `totals`. When it is not empty, state "N sales to confirm" beside the total. It is `null` when the read failed. A row with no document type is read as an invoice. Every amount is NET of tax (`items_total`), because tax collected is owed onward rather than earned. **`party_scope` is required, and it decides whose invoice this is.** `sales` is what the workspace ISSUED — its receivables, and the only side revenue can come from. `purchase` is what it received. The two are the same rows read from opposite ends, so no default is offered: a server choosing a side would answer a different question from the one asked. `intra_self` is an invoice between two companies the workspace owns, and `unattributed` is one Well could place on neither side. **Those four scopes partition every invoice exactly once**, which is what makes an incomplete picture visible rather than silent. `unattributed_count` comes back on every call, whatever scope you asked for: it counts the invoices in the window that landed in that fourth bucket. State it beside any total, because an unattributed invoice may still belong in the figure and nothing here can tell you whether it does. **Every row carries ONE month, ONE currency and ONE billing context.** Currency is always a grouping key, named or not: adding EUR to USD gives a number denominated in nothing, and no field on the result would tell you it happened. Convert the per-currency subtotals yourself, at a rate you can state, before you add them. **`totals` carries one figure per currency over the whole window**: the rows of that currency folded across months and billing contexts on the server, rounded to the cent. When your figure covers every row of the call, read it from `totals` and never add rows yourself. A figure restricted to some billing contexts, such as an MRR over the contexts a reader confirmed, still comes from the rows: `totals` folds every context in, the `null` ones too. **`sum` is already net of credit notes.** A credit note subtracts its magnitude from its own month-currency-context bucket, whichever sign it was stored with; `credit_note_sum` and `credit_note_count` report what that removed, so you can say what the figure netted. Do not subtract them a second time. A bucket whose credit notes outweigh its invoices nets negative, and that is a real state rather than an error. **`billing_context` is `null` on rows that name no billing arrangement** — none stored, `unknown`, or a value Well has no label for — and that is a third answer rather than a kind of one-off. The field is filled by extraction, not by a billing system, so a workspace can carry real recurring revenue on rows that say nothing about it. `unclassified_count` totals those rows. The recurring-contexts card offers them as one choice, keyed `"unclassified"`, so apply that key to these rows and only these. Counted or not, report the count rather than letting a reader read the remainder as "everything else". `corrected_or_consolidated_count` counts the corrected and consolidated invoices among the rows. Each replaces invoices Well holds no link to, so when those originals fall in the same window the sum counts that billing twice. The rows keep them, because dropping them would lose the revenue whenever the originals fall outside the window. State the count beside any total whenever it is not zero. `excluded_malformed` counts billing documents in the window with no readable net amount or no currency. They are in none of the rows and none of the sums, so state the count beside any total. It comes back `null` when the count could not be read, which is NOT `0`: zero says every row was readable, null says nobody counted. `source_count` counts the distinct connector ids on readable, billed invoices in the requested side and window; manual invoices do not count. `synced_at` is the oldest successful sync among those sources when every source is live and has synced, and is `null` if any source is missing or has never synced. `fresh_enough` is true only when all counted sources synced within the last 24 hours. A manual-only window has zero sources, `synced_at: null`, and `fresh_enough: false`. If `source_count` is zero, say there is no connector sync time to assess. If `fresh_enough` is false and `source_count` is greater than zero, never present the sum as current: say that source data may be old or lack a successful sync, and name `synced_at` when it is available. When `party_scope.side_unknown` is true the workspace has no resolved own company, so no side filter was applied: the totals cover every invoice on both sides, and the side is not known. Say the side is unknown, never that the figure is the requested side's. When `completeness.personal_mode` is true, read `party_scope.side_unknown`, `party_scope.applied` and `sums.by_counterparty` together. With `side_unknown: true` and `applied: false`, describe personal spend or income by counterparty using the issuer/receiver buckets and their resolved labels. Do not call these amounts sales or purchases, revenue or business expenses, and do not present them as an answer for the requested side. A counterparty bucket alone does not prove which party is the person: if that is unresolved, state who billed whom and ask before assigning spend or income. Keep estimated attribution and conflicting evidence separate from this personal result. If `by_counterparty.available` is false or its `truncated` flag is true, state that limitation; do not invent a complete split. `partial: true` means the aggregate was cut short and every figure is a FLOOR rather than a measurement. **`axes` splits the window, only when you pass it.** `["counterparty"]` gives one group per other party of the invoice (the issuer on `purchase`, the receiver on `sales`), with its `counterparty_id` and `counterparty_name`. `["category"]` gives one group per category, where the category of an invoice is the confirmed transaction category the workspace holds for that party (declared by the person, or learned from corrections): an invoice carries no category of its own. Both keys together split by both. A key you asked for is `null` on the group of invoices with no value for it: no party on the invoice, or a party with no confirmed category. `groups` is folded across months and sorted largest first within each currency, net of tax and of credit notes like `rows`. `axes` takes `party_scope` `purchase` or `sales` only. `groups_truncated: true` means groups were dropped at the group cap: the groups then do not add up to `totals`, and a ranking from them may miss a larger group. The figure of the window still comes from `totals`. `groups` is empty when `party_scope.side_unknown` is true: the side filter did not apply, so no group is a supplier or a customer. The category comes from the rules of the workspace the call names: on a call that covers several workspaces, the invoices of the others fall in the `null` category. When the token authorizes one workspace, call this directly — no workspace call is needed first. When it authorizes several, this read will not guess which one you mean: pass `workspace_id` on the call.

  ConnectorOAuth

• well_render_cash_forecastA

  WellA

  Put a cash forecast YOU computed onto the forecast card. **The default mode measures nothing.** It takes the settled month-end series, the anchor, the burn and the projection you computed, and returns them for rendering. Call it only after you have computed both halves yourself: the month-end totals under your cash scope, and the burn under your stated policy. Never call it to "get" a forecast. Without `recurring_inflow` the projection is WORST CASE: no revenue arrives, and cash declines by the burn each month until it reaches zero, where it stops. Take the anchor and the burn each to the cent, then each point is `max(0, anchor − k × burn)` for the k-th month after the anchor. With `recurring_inflow`, the projection counts the recurring inflow `well_measure_recurring_inflows` measured, and nothing else: each point is `max(0, anchor − k × (burn − inflow))`, each figure to the cent. An inflow larger than the burn makes the series grow. Pass the `forecast_inflows` entry of the cash's currency as it is; never add a one-off payment, an unpaid invoice or a deal to it. The tool re-derives the series from the amount you state and cannot check where that amount came from. The amount is a floor that holds month by month: only monthly payers that may not have stopped and paid in every month are in it, and quarterly, yearly, month-skipping, ended and no-cadence payers are not. The tool re-derives every point from the figures you state here, in cents. Set `include_deals: true` when the person explicitly asks to include or add deals, or answers `1` to an offer already sent. An explicit request is approval: compute the floor from the supplied reads and render the deal-adjusted series once. When no inclusion was requested, omit `include_deals`; this returns the supplied baseline without a deal read. An ordinary forecast may use a separate `well_list_projects` offer metadata read before any monetary deal read. This mode reads at most 100 live deals from the workspace. It counts each won deal at its full amount in its `closed_at` month, and each open deal (`active` or `paused`) at its chance, its own or else its live stage's, in its `end_date` month, when that month is inside the projection window, converting with Well's stored FX rate as of this call. Draft, lost, archived, undated, past-due, out-of-window, incomplete and unconvertible deals return named exclusions; an excluded deal with a malformed source amount includes its original display string. An open deal with no chance returns the exclusion `no stage weight`. More than 100 live deals refuses the whole deal variant. The returned `entries` draw the deal-adjusted series; `floor_entries` preserve the series you passed. **The card draws the series, the anchor clause and the caveat: the worst-case one, or the recurring-inflow one when `recurring_inflow` is sent.** The cash scope, the burn policy and `partial` are REQUIRED and reach no pixel. All of it comes back in this tool's text result, which is what you write the prose from. REQUIRED: - `currency`, and `as_of`: the full ISO time of the balances read the series came from - `actuals`: one `{ month, amount }` per month, oldest first, ending on the last month that has ended at `as_of` (UTC). A month no account covered is `null`, never 0, and it stays in the list. - `anchor`: `{ month, amount, basis }`. `closed_month_end` is the latest settled month-end in `actuals`. `current_position` is today's cash when no month has a settled total. It sits on the grid at the last actual month. - `burn`: the POSITIVE monthly magnitude, its currency, `trailing_months`, and the `window` it averaged (`from` inclusive and `to` exclusive, each `YYYY-MM-01`). The window ends with the last actual month. - `months_forward` (at most 12), and `projection`: one `{ month, amount }` per projected month. When the anchor sits before the last actual month, the months between are projected too, so `months_forward` must reach past them. - `cash_scope`: the counted account types, whether unknown ownership was counted, `anchor_missing_accounts` (counted accounts with no reading at a closed-month anchor; 0 under `current_position`), and the four exclusion groups - `burn_policy`: the elected convention and `convention_counts: { negative: <the sum's count_negative>, positive: <the sum's count_positive> }`, the exclusions (`internal_transfers` is the sum's `excluded_multi_leg`, `unreadable_rows` its malformed rows), and `unplaceable_count` (the sum's `excluded_no_owned_leg`) - `partial`: the forecast's own floor, which is WIDER than a cash total's `is_floor`. It is checked against `cash_scope` and must be `true` exactly when an account was left out with no readable balance, no rate, OR no reading at the anchor month — that last one is the forecast's alone, and a caller that forwards its cash total's `is_floor` unchanged is refused on it. It never means a cut-short read: a cut-short balances read or sum stops the run before this call. OPTIONAL: - `recurring_inflow`: `{ amount, currency, measured_through }`, the `forecast_inflows` entry of `well_measure_recurring_inflows` in the cash's currency, as it is. Leave it out when that measure returned no entry in the cash's currency. REFUSED rather than rendered, each because your own figures disagree: - a projection point that is not `max(0, anchor − k × burn)` within a cent, or `max(0, anchor − k × (burn − inflow))` when `recurring_inflow` is sent - a `recurring_inflow` in another currency than the cash, or measured through a month other than the last actual month - a `recurring_inflow` above the burn on an anchor at or below zero: the balance is recovering, which a series clamped at zero cannot draw. Report the overdraft and the inflow instead - a projection that does not start the month after the anchor, skips a month, continues after a zero, or has the wrong length - a projection ending on a month that has already ended. The refusal names which of the three causes fired: the cash ran out (report that), the horizon was too narrow for the gap (widen it), or the gap exceeds every legal horizon (the feed is too far behind to project across) - a cash currency that differs from the burn's - a negative burn, a burn elected "magnitude", `signed` elected from no negative rows, or one of `unplaceable_count` and `internal_transfers` null without the other - a `closed_month_end` anchor that is not the latest settled actual, or whose amount differs from it - a `current_position` anchor beside a settled actual, off the last actual month, or with an account missing at it - actual months out of order, repeated, skipped, or ending on any month but the last one that has ended at `as_of` - a burn window that disagrees with `trailing_months`, or ends on a different month than the actuals - a `partial` that disagrees with the floor your own `cash_scope` implies - an `as_of` in the future The result carries `settled_change`: the first settled reading, the anchor and the direction between them (`up`, `down` or `flat`), computed from the exact cents. Say how the settled cash moved from its `direction` alone. It is `null` when there is no movement to state. This tool renders its own chart card. Do not re-plot the series with a charting tool. OPTIONAL, and send it whenever you computed a cash-flow bridge over the same cash: - `cash_bridge` — `{ unexplained, closing }`, the two terms you sent `well_render_cash_flow_bridge`, in this card's currency. The server applies the bridge's own tolerance and returns `cash_check`. `"provisional"`: the bridge does not reconcile, the gap is in `unexplained_gap`, and the card marks the figure Provisional; say so in prose too: the figure stands on cash with an unexplained gap of that amount. `"reconciled"`: say nothing about it. Leave `cash_bridge` off when you computed no bridge: the result is `cash_check: "not_checked"` and the card marks the figure Not checked. When the token authorizes one workspace, call this directly — no workspace call is needed first. When it authorizes several, this read will not guess which one you mean: pass `workspace_id` on the call.

  ConnectorOAuth

• well_list_ledger_accountsA

  WellA

  List the workspace's chart of accounts (COA) — every ledger account a counterparty default or a transaction can be assigned to. Use it to name a real `ledger_account_id` in a write instead of guessing one. Each account carries `id` (the `ledger_account_id` the writes take), `name`, and `code` (its account number, e.g. "401" for a vendor or "411" for a customer under the FR PCG) where the account has one. `truncated: true` means the chart holds MORE accounts than this page carries; read the rest with `well_query_records` on the `ledger_accounts` root. **`success: false` means the chart could not be read, NOT that the workspace has none.** An empty `accounts` on a failed read is unknown, never "no chart of accounts". When the token authorizes one workspace, call this directly — no workspace call is needed first. When it authorizes several, this read will not guess which one you mean: pass `workspace_id` on the call.

  ConnectorOAuth

• well_show_canvasA

  WellA

  Show one of the workspace's saved canvases as a board — the blocks it holds, at the positions its author put them, exactly as stored. Answers with an ARRANGEMENT, not a measure. NO figure is resolved: every block that names a feed carries its source, type, binding and empty params, and tiles_resolved is false. Such a block stores no figure; the board is drawn with its figures by the resolve-board skill, which measures each block and calls well_render_canvas. Ask a KPI tool (well_render_cash_position, well_render_burn, well_render_runway, well_render_logged_time) for one figure; ask this when the question is about a board the workspace saved. WORKFLOW: - well_show_canvas() → the canvas the workspace touched most recently, plus every other canvas's name and id so a different one can be named. - well_show_canvas({ canvas_view_id }) → that canvas. - well_show_canvas({ origin_template: "investor-report" }) → the newest canvas built from that template. Provenance is not identity: a workspace may hold several from one template. - Add measuring: true to any of these when you read the board in order to measure it and draw it with well_render_canvas. The result is the same read. Drawn from this read alone, every figure block shows that it is not resolved yet. A note ("text") carries its own words. can_edit says whether this caller may change the board. Only its author, a workspace admin or the owner can; every other member reads it. When can_edit is false, do not offer to rearrange, rename, delete or share it: say who can change it, naming its author from author_name, and offer to ask them. Do NOT use this to save, create or rearrange a board — that is well_upsert_canvas — and do not read first to look up a board you are about to create. Read only before an UPDATE, where well_upsert_canvas needs the version this read returns.

  ConnectorOAuth

• well_preview_provider_exportA

  WellA

  Show the user what Well can fetch from a provider's own web app, and the Deploy action that fetches it. Draws a "deploy agent" card with one row per provider. Each row lists every file the agent can download, each with its `export_id`, label, format and whether it is `selected`. The row's `deploy_url` opens Well's `/collect` page, the same page that deploys the invoice agents, naming the provider in `providers` and the selected files in `fetch`. When the user starts the export there, the Well browser extension opens the provider in a new tab and its agent downloads the selected files, one at a time, in the user's own signed-in session, then files each one in this workspace. Use it when the user wants data from a provider that Well cannot connect to directly, asks to "download", "export", "fetch everything" or "get the CSV" from a provider, or when the connector route is unavailable. Pass `provider_slugs` to preview the providers the user named; omit it to show every provider Well can fetch from. Pass `export_ids` when the user asked for specific files; omit it to fetch every file. A provider Well has no export for comes back in `unknown_provider_slugs`, and a file it does not list in `unknown_export_ids`: say plainly that Well cannot fetch it yet. A row whose `export_ids` matched none of its files selects nothing and has a null `deploy_url`: offer its listed files instead. This tool starts nothing and downloads nothing. Never say a file was fetched by this call: the run happens in the browser extension after the user clicks, and the extension's side panel reports it. A row's `last_run` is the one record of an earlier run in this workspace: when the user asks whether a run worked, report its `status`, when it ended and its `files_filed` as returned, and nothing more. When `refresh_due` is true, offer to fetch the files again with the row's Deploy; Well never re-runs on its own. When `harness_access` is `refused`, no row has a `deploy_url`: say this browser agent is not open to the user's account yet, and offer the upload route. When the user wants several providers at once and `deploy_all_url` is set, offer it: it deploys every row with a link, one provider after the other. When it is null, offer each row's own `deploy_url`. Give each `deploy_url` and `deploy_all_url` as returned and never build or edit one. The run needs the Well browser extension, and the user must be signed in to the provider in that browser; when a login or a two-factor code stands in the way, the agent hands the tab back to the user. When `error` is set, report it and do not read `harness_access`. When the token authorizes one workspace, call this directly — no workspace call is needed first. When it authorizes several, this read will not guess which one you mean: pass `workspace_id` on the call.

  ConnectorOAuth

• well_render_customer_ltvA

  WellA

  Draw the customer lifetime value (LTV) ranking as a bar chart card: one bar per customer, the highest first. **Call it once, after `well_measure_customer_ltv`, and send no figure.** It runs the measure itself for the workspace of the call and draws that result, so every name, flag and LTV on the card is the server's. You pass only: `window` as the measure's result echoed it (`from`, `to` and `month_count`), `counterparty_alias_sets` exactly as you passed them to the measure, the `currency` the card draws, `left_off_currencies` and `conversions`. Read the figures for your answer from the measure's result, not from this tool's. Do not call it when the measure returned no row: say there is nothing to rank instead. **One currency per card.** Set `currency` to the currency the card draws. Every other currency in the measure's `currencies` goes in exactly one of two places. Convert it: add a `conversions` entry with the rate into `currency` and its date, from the currency conversion step, and the tool applies it to each customer's LTV. Or leave it off: name it in `left_off_currencies`, which keeps its customers off the card, because Well has no rate for it or because converting it is not allowed. The card's own currency is never converted and never left off. A card that converts draws only when no currency on it, the card's own currency included, has more than 100 customers, because the measure cuts rows past that. Otherwise draw the card's own currency alone and name the others in `left_off_currencies`. The card draws at most 12 customers, never a summed "other" bar, and its small form quotes the average LTV per customer. The result states `average_ltv`, `customer_count` (the customers the average covers) and `left_out_count` (customers not drawn): say how many customers the card leaves out when it is above zero. REFUSED rather than drawn: - a window that reaches the running month or covers more than 60 months - a measured currency that is neither converted nor left off, or a currency the measure did not find - the card's own currency in `left_off_currencies` or in `conversions` - a rate more than 1% away from Well's stored rate for the pair on its rate date, a rate dated outside the window's last complete month, or two rates for one currency - a card that converts when the measure cut rows from a currency on it Because the measure runs again here, a ranking reads the invoices twice. That is by design: it is what ties the card to the server's figures. When `party_scope.side_unknown` is true the workspace has no resolved own company, so no side filter was applied and the ranking covers invoices on both sides. Say the side is unknown, never that these are the customers' figures. When the token authorizes one workspace, call this directly — no workspace call is needed first. When it authorizes several, this read will not guess which one you mean: pass `workspace_id` on the call.

  ConnectorOAuth

• well_generate_documentA

  WellA

  Generate a document as a PDF and store it in the workspace. It never emails or sends anything, so a request to email or send a document is not a request to generate one. Pass exactly one source: - `params`: values you provide, with a `document_slug`. Call well_list_generative_documents first: it gives each design's document_slug and the JSON Schema its params must satisfy. Values that do not match are refused with the path and reason of each problem, so fix them and call again. The design prints light unless `params.theme` is "dark". Each call prints and stores a new document, unless you pass `document_id`. - `document_id` (with `params` only): when the user asks to change, fix or redo a document you already generated in this conversation, pass its document_id so it is replaced in place instead of adding a new file. Its document_id and links keep working and serve the new PDF. Only a document this tool generated from values can be replaced. - `invoice_id`: an invoice already in Well. The PDF prints that invoice, in its own chosen ink, and is attached to it as its document. Pass a `document_slug` to choose the design; without one, the invoice's own chosen design prints. Refused when the invoice already carries a file a user or connector supplied: a generated PDF never replaces one. Generating again updates that same document in place, so its document_id and links keep working. - `design` (with `invoice_id` only): the options the invoice-design card returned, passed exactly as the card gave them. `layout`, `theme` and `locale` choose the design, the ink and the language of this print, on an issued invoice too. `payment_terms_note_id`, `tax_rate_id`, `legal_mentions_note_id` and `payment_means_id` must equal what is saved on the invoice, or be null when nothing is saved: an id that differs is refused, so save a change with well_update_invoice_design first. Each option is optional, and every option left out keeps the value the invoice already holds. `theme` is a key of `design`, not a top-level input. Do not pass `design.layout` together with a different `document_slug`, or `design.locale` together with a different `locale`: the call is refused. - `account_id`: a bank account of the workspace's own company. The PDF prints its bank account details sheet (RIB) from the stored IBAN and BIC. Totals are never supplied: every sum is computed from the lines, so a printed total cannot disagree with the lines above it. The tool returns the stored PDF's document_id. A `guide` printed for a lead magnet guide on WhatsApp can return `success: false` with `say`: the person's free guide is used, nothing printed, and `say` is the exact ask, with their own invite link, to write as given. `file` carries the PDF's name and size plus the links to fetch it. The result renders as a card with Download and View in Well; when no card is shown, hand the user `download_url`. - `download_url` saves the PDF and `signed_url` opens it in a browser. Both work with a plain HTTP GET and no auth header, and stop working at `expires_at`. - `preview_url` is a PNG image of the first page, for showing the document; add `page=N` for page N, up to `page_count`. Same token and expiry as the other links. - `sheet_url` is the document's HTML sheet, which the card draws with zoom and pan. Same token and expiry. - When the user wants to do more with a PDF already generated (attach it to an email, upload it elsewhere, read or analyse it, pass it to another tool), fetch `download_url` with a plain HTTP GET to get the bytes. - If the links have expired, call this tool again: with `params` it prints a new document with fresh links; with `invoice_id` it refreshes the same document and its links. - `app_url` opens the document in Well and never expires. - The links grant access to the file on their own: share them only with the user, never in a public place. With `invoice_id` of an issued invoice, the PDF is the issued invoice and `portal_url` is its customer page, the page its QR code opens, for the owner to forward to the customer. It is null when the invoice has no customer page.

  ConnectorOAuth