assign_payment_device
ChatGPTAssign a payment device (terminal) to an account. Two-call confirm contract, enforced server-side. This is a mutating tool, so it dry-runs first: the FIRST call changes nothing and returns a plan — the action, the environment it would run against, and the device + account it touches — for the operator to confirm. The plan also returns a confirmation_code. The write happens only on a second call carrying BOTH confirm=True and that code, so confirm=True on a first call cannot write: it just returns the plan. Ask the operator, then echo the code back. The plan names the environment the terminal was actually found in, which is where the write will land — pass that environment back on the confirming call to pin it explicitly. After assignment, transactions taken on the device bill to account_id. The backend checks assignment eligibility and permissions when the confirmed write runs. device_id must be device_…; account_id must be acc_…. The terminal's current state is checked before the write. If the desired state already exists, return success with changed=false and issue no write. An uncertain write response causes one state read in the same environment. A matching state is an observation; otherwise the outcome is unknown. Never repeat an uncertain write automatically.
download_report
ChatGPTRead one page of rows from a single Rootline financial report CSV. Use an id from list_reports, and only when the merchant asks about ONE specific report by ID. For released-funds totals over a time window, use get_account_activity. Returns the report's full column set and a page of rows. Every column is in the structured output (the interactive card lets the operator toggle which columns show); use offset to walk further. total_rows is the exact row count of the whole file. Settlement_report columns include: account_id, account_name, payment_id, payment_method, journal, gross_amount, gross_currency, net_amount, net_currency, platform_fees, interchange_fees, scheme_fees, processing_fees, journal_event_time, payment_created_at. The journal column's value set varies by report; the values present are in journals_present. summary covers the WHOLE file, not the page: rows, gross and net per journal and currency, so "what did this report release" (funds_released) or "why is this the total" is answered from it, never by adding up one page. net_balanced says per currency whether all rows net to zero, i.e. what came in is what the payout rows took out. Pass journal and/or payment_id to page through only those rows (matching_rows counts them). A settlement report is one payout run of one account. Its ledger, also over the WHOLE file, says whose it is, which payment dates it covers, how the balance moved per currency and which payout emptied it (pyt_…; a July 2026 btransfer_…; or, in 2025 files, only a statement descriptor). split_children lists, per payment on the page, the split pmt_… ids it was routed to. Read reports one at a time. Limits: a file larger than 30 MB, or one that is not a valid CSV, is refused with a clear message and the report's dashboard_url, so the full file is always reachable from the dashboard. Every response carries that link.
find_accounts
ChatGPTResolve which account(s) the operator means, scoped to this login. Accounts are the money-holding layer — the acc_… objects that carry balances, payment activity/volume, and assigned terminals. This is the resolver for ANY "account(s)" ask ("the accounts for harborbooks.example", "my accounts", "find Acme's account"). It is NOT the legal-entity / onboarding resolver: a "which merchant / is X verified / onboarding status" ask goes to find_companies instead, never here. Pass name with whatever the operator called the account ("Rabobank test", "Acme Bakery") to get the best server-side matches. This is the fast path and the only one that scales: it runs ONE ranked search and the API caps it at 10 results (no pagination), so a login with hundreds of accounts still resolves a name in a single request — never a full walk. A domain-shaped term (e.g. "harborbooks.example") uses bounded name searches with relaxed punctuation and the leading label. This is name matching; the backend does not support an exact namespace filter. Leave name unset to answer "what can I see", and FIRST whenever the operator refers to their account without naming it ("check my account", "how is my account doing"): one account → continue with it; several → name them and ask which one. That returns the in-scope account total plus a first page, not the entire list. Companies are not accounts: never find accounts through find_companies or by a company's name. When truncated is true, more accounts matched than were returned: ask the operator to be more specific rather than guessing from a partial list. The accounts returned are exactly those this login is permitted to see — nothing more. Identity is taken from the operator's sign-in. Returns the matched account_name + acc_… id for YOU to act on: chain them straight into the next lookup (balance, activity, company, devices). Never ask the operator to supply, paste, confirm, or look up an acc_… — resolving names to ids is this tool's whole job, and sending them to the dashboard for an id defeats the point of the connector. Lead the operator with the account NAME, not the raw id string, but you always hold the id to chain with. operator: {username, name, email}: context only. Recite it only when asked who they are: name and scope, no email unless asked for account_count: accounts matching name (or total in scope when unset) accounts: [{account_id, account_name}] — the matches to choose from truncated: true when more matched than were returned (ask to narrow)
find_companies
ChatGPTFind companies (legal entities / merchants) and their onboarding status, scoped to this login. Companies are the legal-entity layer — the co_… objects that carry verification/onboarding status, KYC next-action, and registered country + address. They do NOT carry balances or payment activity. This is the tool for "what's the onboarding status of <merchant>?" and "which of my merchants are suspended / need action?". It is NOT the resolver for an "account(s)" ask. Anything about balances, payment activity/volume, terminals, or "the accounts for <name>" goes to find_accounts (or get_account_overview), never here — even when the operator names a brand or namespace that also happens to be a merchant. Pass name with whatever the operator called the merchant to match by name. Pass verification_status — one of created, open, verified, not_accepted, suspended — to list merchants in that onboarding state. Combine both to check one merchant's state. Leave both unset to answer "what companies can I see" — the in-scope total plus a first page. Pass vat_number to find a company by its VAT number ("whose VAT number is NL…?"): an exact match, tried as given and without spaces, dots or dashes; when it is set, name is not used. Each match carries the company NAME, its co_… id, the onboarding verification_status, and the pending next_action when there is one — so the status question is answered in-line, and you can chain the co_… into get_company for full detail. Never ask the operator to supply a co_…; resolving names to ids is this tool's job. Lead with the company NAME. Status here is fresh within seconds. For the authoritative real-time status of ONE company, chain its co_… into get_company. When truncated is true, more companies matched than were returned: ask the operator to narrow rather than guessing from a partial list. total_count: companies matching the query (or total in scope when unset) rows: [{company_name, id_raw (co_…), status, next_action, vat_number}] operator: {username, name, email}: context only. Recite it only when asked who they are: name and scope, no email unless asked for truncated: true when more matched than were returned (ask to narrow)
get_account
ChatGPTFetch a single Rootline account by its acc_… ID — its configuration AND its current balance in one answer. Call after find_accounts returns an acc_… id — never guess an id or ask the operator for one. Returns the account's display name, description, namespace, the company id of its main contracting entity (company_id_raw; its name and legal detail come from get_company), and the live available/pending balance per currency. It does NOT return processing options, enabled payment methods or permitted processing currencies: say those are not available here rather than inferring them from past payments or the balance. Accounts are flat: any parent_id references the owning organisation, not another account, so there is no account hierarchy to surface. Use this to answer 'what is account acc_…?' / 'show me account X' — it gives the full picture (config + balance) so the operator rarely needs a follow-up.
get_account_activity
ChatGPTTotal the RELEASED FUNDS of one account over a payment-time window, from its settlement reports. Use it for 'how much settled', 'fees paid', and 'method mix' over a period. Resolve the acc_… via find_accounts first. It reads settlement reports only. It therefore does NOT include payments that have not settled yet, declined or abandoned attempts, refunds, or disputes, and it cannot give a success rate or a live count. For individual rows use list_payments; for the live position use get_account_balance. The window is when the PAYMENTS happened, not when settlement ran. It reads the account's settlement reports whose payment dates overlap the window (however late they were generated), keeps the released payments (journal == 'funds_released') whose payment_created_at falls inside [since, until), and totals them per currency. A fee charged in its own row (journal == 'fee_paid', for example a processing fee) on one of those payments joins the fees and the net. Refunds, chargebacks and balance transfers are not in the totals; follow_ups counts what was left out. since/until accept an ISO date (YYYY-MM-DD, whole day) or an ISO datetime (YYYY-MM-DDTHH:MM:SS, UTC if no offset) — same syntax as list_payments. A plain end date is inclusive through the end of that day; a datetime upper bound is exclusive. These bounds are UTC while displayed times are local wall-clock — don't reuse a displayed time as a bound. Limits: at most 200 settlement reports covering the window are read, and at most 100 MB of report data, within 45 seconds. A window that needs more than that returns a clear limit error and no totals: ask for a shorter window, or use the dashboard's reports page for that history. A row with invalid money data also returns an error and no totals — never a partial figure. FEES, and which side of a platform you are on. fee_lines breaks the window's fees down by kind (platform_fees, interchange_fees, scheme_fees, markup, commission, processing_fees, other_fees) and lists only the kinds that carry money. Every figure is signed from THIS account's point of view (negative is money leaving it), so gross + split amounts + platform revenue + fees = net. net_lines lists exactly those terms and reconciles says whether they add up. On a marketplace SELLER's account platform_fees is what the platform charged it, and platform revenue is zero; on the PLATFORM's own account split amounts are what it routed on to its sellers and platform revenue is what it earned from them. Returns: account_id, account_name, window_label server_time_utc: the server clock when this ran — check a relative window ("today", "this week") against it before trusting a zero settled_through: the latest date settlement has actually covered for this account, or null when no report matched; a window running past it is partial and says so in follow_ups transactions: released payments counted currency_totals: one row per currency: count, gross, net, platform revenue, split amounts, fees by kind, net_lines and reconciles. Amounts are never summed across currencies. net_lines, reconciles: the single-currency gross-to-net breakdown and whether it adds up; empty / null for a mixed window primary_*: the single-currency headline figures; null when the window carries more than one currency (read currency_totals instead) by_method: {method, count, percent, gross_display}, most-used first recent_payments: up to five released payments, newest first — a sample, not the largest ones reports_consulted_count: settlement reports read follow_ups: caveats that qualify the numbers
get_account_balance
ChatGPTFetch real-time balance summaries for an account. Call after find_accounts returns an acc_… id — never guess an id or ask the operator for one. Returns current available + pending balances per currency. Pending is captured money not yet released to available, net of the fees and platform revenue already booked on it. Real-time, unlike settlement reports. Settlement is delayed (cadence varies by account — some weekly, some daily), so a fresh capture won't appear in get_account_activity until the next settlement run, but it shows in pending here within seconds. One exception: an account whose funds are released pass-through (after the money is verified received) books captures on a ledger this balance does not include, so a zero pending there does not prove nothing is on its way. Use this for 'how much is in account X right now?'. An empty result means no balance came back, which is not a zero balance.
get_account_overview
ChatGPTUSE THIS for a compound 'overview / status / how is X doing / summary / overview of the <name> accounts' ask about ONE account — it answers in a single call what would otherwise take find_accounts + get_account + get_account_balance + list_payments. This is the ACCOUNT (money-holding) overview — balance + activity + terminals; it is NOT the company / onboarding lookup (that's find_companies / get_company). account accepts whatever the operator has: a display name, a namespace ("harborbooks.example"), or an acc_… id — it resolves the name the same way find_accounts does. Exactly one match → the overview. Several matches → a short list and nothing else, so you can ask the operator which one (never guess). No match → a not-found line that names the accounts this login can see. When the operator names no account ("check my account"), call find_accounts without a name first; never derive an account name from a company name. Returns one composite covering the account's identity (name, namespace, linked company), live available/pending balance per currency, the last 14 days of payments (count, succeeded/failed/abandoned, succeeded gross per currency, and the latest five), and the terminals assigned to it. Each section loads independently: if one is momentarily unavailable the overview still returns with the rest, noting the gap. DO NOT use this for a single narrow fact — a balance alone → get_account_balance; one payment → get_payment; a windowed aggregation with method mix → get_account_activity. This is the broad first look, not a replacement for the focused tools.
get_company
ChatGPTFetch a single Rootline company by its co_… ID. Chain from find_companies (or an id another record carries) — don't guess ids. Returns the company's legal/trade name, verification status + pending next action, and the nested address (with country). (Registration and VAT numbers are not on this record.) Companies are the legal-entity layer above accounts: an account belongs to a company. This record is the LEGAL entity, not the money-holding account — balances, payment activity, and terminals live on the account tools (get_account / get_account_overview), never here. Use this to answer 'who legally owns account X', 'show me company co_…', or 'what's this merchant's onboarding status'. accounts lists the company's accounts this login can see (up to ten, with account_count): the way from a company to its money-holding accounts, to chain into the account tools. One company can hold several accounts, and an account's name need not match its company's.
get_payment
ChatGPTLook up a single Rootline payment by its pmt_… ID. Returns live data, so it works for today's payments too — before they settle. Returns one curated record: - identity: id_raw, amount_display + currency_symbol, checkout_status, reference, merchant_name, account_id_raw, payment_method_display, dashboard_url, details[]. - outcome: failure ({response_code, response_message, ...} — the decline reason when an auth fails) or success (headline + stats); gateway_summary is the one-line gateway verdict either way. - timeline[] — created/authorized/captured/refund events in order. - splits[] (destination account, amount, fees), refunds[], authentication (3DS / SCA outcome when present). - refundability: can_refund, can_partial_refund, refundable_display. Use this to answer 'what happened to payment <id>'. For declines, cite failure.response_code + failure.response_message; if those are blank fall back to gateway_summary. Card instrument details (brand, last-4, funding, issuing country, 3DS result) are returned when available. The bank identification number (BIN) is excluded. Customer identity (name, email, phone, address) is omitted by default; set include_contact_details=True ONLY when the operator explicitly asks about the customer (for example 'who paid this?' or 'what is their email?'), and it REQUIRES contact_details_reason: why they need it, in their words. The disclosure is recorded against the operator who asked, so the reason must be theirs. If they have not said why, ask them rather than supplying one. RISK — risk carries the screening decision, whether it ran before or after authorization, the score against the block threshold, and the features that moved it. What surfaces depends on the decision: - BLOCKED (or blocked by rule): the full explanation, without being asked. A blocked payment has no issuer response to cite, because screening stopped it before the bank ever saw it, so failure is empty and this is the only account of what happened. - CHALLENGED: the decision only. The payment went through after a 3-D Secure step-up, so there is no unexplained outcome to justify. - ALLOWED / TRUSTED: nothing. Set include_risk=True for the full explanation on ANY decision — use it when the operator asks about risk, screening or 3-D Secure directly. risk absent does NOT mean the payment was clean, and it is the COMMON case: risk screening is a separate product, so most merchants have no assessments at all. It is also what you see when the login may not read risk data. Those causes are indistinguishable from here, so when risk is absent, do not mention risk at all — not "no risk found", and not "not available to this login" either, which points at a product the merchant may never have bought. Risk is READ-ONLY. There is no way to unblock, allow, whitelist or change a rule from here — never imply otherwise; that is a dashboard action.
get_payment_device
ChatGPTFetch a single payment device (terminal) by its device_… ID — or by the serial number printed on the physical unit. Operators read the serial off the terminal, not the internal id, so pass whichever they gave you: a device_… id is looked up directly, and anything else is treated as a serial and resolved to the terminal automatically. Never ask the operator to convert a serial into a device_… id themselves. Returns the terminal's serial number, display name, model, and the accounts assigned to it (each with its TID). The status is ASSIGNMENT status — assigned to an account vs unassigned, derived from whether any account is attached — NOT connectivity: the backend reports no online/offline or last-seen signal for a terminal. To gauge whether a terminal is actually transacting, look at its recent payments via list_payments(payment_device_id=…). Use to answer 'which terminal is device_…?', 'is terminal <serial> assigned, and to which account?', 'what account does it bill to?', or to enrich a payment.payment_device_id reference.
get_payout
ChatGPTLook up one payout by its pyt_… id. Returns status, amount, account_id, reference, description, created_at and the payout method. confirmed means the bank has confirmed executing the transfer, not by itself proof the money is in the merchant's account; rejected and returned are the failure ends. The recipient bank account appears only as the last four digits of its IBAN, never the full number or the account-holder name. period_label is the period of the settlement batches this payout closed (a carried balance in them can come from earlier) and account_name the account (both from the payout search). What the payout was made of is not on this record: report_lookup holds the list_reports arguments for its account and period, and the report whose payout row names this pyt_… explains it (download_report), including a payout fee and the rounding up to the cent.
get_report
ChatGPTFetch metadata for a single Rootline report by its report_… ID — use an id from list_reports. Returns the row dict (see list_reports for columns). The period is start_time/end_time: for a current-format report the days its payments were created, for an earlier-format one the payout day (period_meaning says which). generated_at is when the report was made (UTC), usually a day or more after the period; never read it as the period. An id that matches no report is an error, the same as an unknown pmt_… on get_payment, never a silently empty result that could be read as "a report with no data".
get_risk_signals
ChatGPTHow many payments risk screening allowed, challenged, blocked or trusted over a window, and a sample of the most recently assessed payments. Use this for ANY question about risk across more than one payment: 'how many payments were blocked today', 'is our block rate going up', 'show me what got challenged this week'. For a single payment you already have an id for, use get_payment instead: the assessment rides on the payment there. Returns: - summary: counts for the whole window: assessed, allowed, challenged, blocked, trusted, and total payments. These are COMPLETE. - buckets: the same counts per time bucket, so a trend is visible. - rows: a SAMPLE, the most recently assessed payments whatever the decision, each with its decision. Not a list of what was blocked or challenged, and never the full set: this endpoint has no pagination. Say "a sample" when reporting them, and use summary for any number you quote. time_range is limited to 24h / 7d / 30d / 90d. A request for a longer period (a year, say) cannot be served. Say so plainly rather than substituting a shorter window and answering as though it were the one asked for. Risk screening is a separate product, so an account that does not have it returns zeros. That is not an error and not "no risk found": it means screening is not running, or that no payment in the window was one it screens. Read-only: there is no way to block, unblock or change a rule from here.
list_account_balances
ChatGPTReal-time balances for SEVERAL accounts in one call. Use this the moment more than one account is in play: "how much is across my accounts", "which account holds the most", "balances for the three seller accounts". For a single account use get_account_balance instead — it hydrates the name and reads as one figure rather than a table. Returns one row per account and currency, richest first within each currency (currencies are never ranked against each other), plus available summed per currency. Two things it will not do: an account the backend returned no balance for is listed in missing rather than shown as zero, and when anything is missing or not_visible the totals are marked partial so they are never presented as the whole picture. Ids this login cannot see are listed in not_visible and never read. Same freshness and meaning as get_account_balance, including its pass-through exception for pending.
list_eligible_accounts
ChatGPTList one bounded page of eligible assignment accounts for a device. Already assigned accounts can appear. A full page may omit other eligible accounts. The assignment backend checks eligibility and permissions when a confirmed write runs. Returns accounts with id and name, returned_count, and may_have_more. No continuation cursor is available.
list_payment_devices
ChatGPTList payment devices (terminals), cursor-paginated. Optionally filter by account_id to scope to devices assigned to one account. page_size is 1-100 (values above 100 are rejected). Returns rows, next_cursor, has_next, and total_count, assigned_count, and unassigned_count for this page. To walk further pages, pass the returned next_cursor back exactly as returned as after — never construct, modify, or reuse a cursor across different filters. There is no connectivity/last-seen field on a terminal — its status is ASSIGNMENT status (assigned to an account vs unassigned), not online/ offline. To gauge whether a terminal is transacting, look at recent payments via list_payments(payment_device_id=…). Use to answer 'what terminals does account X have?' or to find a device whose device_… ID isn't already known.
list_payments
ChatGPTList individual payments, newest first, with server-side filters. SPLIT PAYMENTS: upstream, every split is its own payment, so a split checkout produces a root row PLUS one row per split — same amount, same timestamp, ids differing only near the end. By default those split sub-payment rows are hidden (one row per customer transaction) and the result says how many were hidden. Pass include_splits=True for the full ledger; split rows are then marked and excluded from the summed total. Counts and sums over the default view are per customer transaction — never double-counted. SPLIT ROWS ONLY: scope account_ids to an account that RECEIVES splits — a marketplace seller, or a funds-holding entity such as a Dutch stichting derdengelden — and a page can hold only split rows, because each root sits on the paying account, outside this scope. Those rows are kept and the result says split_rows_only: report them as split amounts routed in from checkouts taken elsewhere, totalled apart in split_total_lines. One page's shape does not prove what kind of account this is; say what the page shows. The paying account is not on the rows. Pagination is page-based, not cursor-based (unlike list_reports): pass page=0 for the first page, page=1 for the second, etc. Page size is fixed at 50 rows, and paging stops at page 19 (1000 rows): a question that needs more rows than that is answered by narrowing the filters or by get_account_activity, not by walking on. All filters are AND-combined. List filters (account_ids, checkout_statuses, payment_methods) are OR within themselves. Enum filter values are CASE-SENSITIVE and lowercase, and they differ from the display forms shown in results: - checkout_statuses: use the lowercase status as returned in checkout_status — e.g. "succeeded", "failed", "open". Uppercase ("SUCCESS") is rejected. - payment_methods: use the lowercase method code — e.g. "ideal", "visa", "mastercard". The display-case the rows show ("Ideal") is NOT a valid filter value — it silently matches zero rows. There is no currency filter (the upstream filter is broken today) — narrow by date/status/method and read the currency off the rows. start_date/end_date accept an ISO date (YYYY-MM-DD, whole day) or an ISO datetime (YYYY-MM-DDTHH:MM:SS, UTC if no offset) for sub-day windows such as the last hour. CLOCK TRAP: these bounds are UTC, but every time this server displays is local wall-clock in the deployment's display zone (CET/CEST by default) — two hours apart from UTC in summer. Reusing a displayed time as a bound returns an empty window with no error to notice. Build sub-day filters from a row's created_at_utc, or convert explicitly and say you did. min_amount/max_amount are in WHOLE currency units (euros), NOT minor units/cents: passing eurocents over-filters by 100×. Both bounds are STRICT: min_amount=100 returns payments ABOVE €100.00, so an exact €100.00 is excluded (max_amount=1 likewise excludes an exact €1.00). At whole-euro granularity "€100 or more" has no exact form: use 99 and say the result starts at €99.01. query is a free-text search across reference + customer fields. Use this for individual rows or a specific payment — 'show me payments for account X last week', 'top recent payments', 'declined payments for method Y', or 'payments in the last hour' (pass start/end one hour apart). For a single known pmt_… ID, use get_payment instead — it returns the full detail tree (authorizations, captures, refunds, …). For a how-much / summary total over a window, use get_account_activity, which walks and aggregates internally. "Biggest / largest payment": there is NO server-side sort by amount, so this takes reasoning over rows, never a search loop. Pull the window ONCE and compare the amounts in the returned rows. Only when that window overflows a page (has_next) narrow it, with a tighter date range first or a min_amount floor, and stop after one or two narrowings rather than ratcheting upward call after call. Do not claim a maximum you didn't actually see in rows you recei…
list_payouts
ChatGPTList payouts, the bank transfers that paid settled funds out, newest first, one cursor-paginated page. Answers "when was I last paid out", "has last week's payout landed", "which payouts failed". Filter by account_id, status, and a since/until window on the payout's creation. "When is my next payout" is get_account: its next payout run comes from the account's schedule. Asked for a settlement report, the document or its rows, use list_reports / download_report instead: "settlement" is the reports vocabulary, "payout" is this tool's. A question about the document is not a question about the transfer. Returns {rows: [...], next_cursor, has_next, total_in_scope}. Each row carries id_raw (pyt_…), account_id, account_name, reference, description, amount with its currency, status, created_at, payout_method, period_start, period_end, period_label and recipient_bank_country: enough to answer follow-ups about any listed payout without a second call. total_in_scope is the exact count matching the filter across all pages, or null when the count is unavailable (say the total is unknown, never guess it); pass next_cursor back as after only when the operator asks for the next page, never a constructed cursor. Bank account numbers and account-holder names are not returned. The transactions are not on this record, so never imply a breakdown from it. They are in the account's settlement report whose payout row names the pyt_…, which download_report explains, including a payout fee and the rounding up to the cent. If that report holds only a balance carried in, the payments are in the earlier report it came from.
list_reports
ChatGPTList financial reports, one cursor-paginated page sorted newest first. Filter by report_type (e.g. settlement_report), account_id, and since/until dates on the report's period ("which report covers 5 August", "reports from July"). page_size is 1-100 (values above 100 are rejected). Each row says what its period means (period_meaning) and when it was generated. Returns {rows: [...], next_cursor, has_next, total_in_scope}. Each row has: id_raw (report_xxx), kind_label, account_name, window_label, status, filename, version, and dashboard_url. has_next is true when a further page exists; total_in_scope is the total number of reports matching the filter (across all pages). To walk further pages, pass the returned next_cursor back exactly as returned as the after parameter — never construct, modify, or reuse a cursor across different filters.
manage_payment_device
ChatGPTAssign or unassign a payment device (terminal) to/from an account. Two-call confirm contract, enforced server-side. This is a mutating tool, so it dry-runs first: the FIRST call changes nothing and returns a plan — the action, the environment it would run against, and the device + account it touches — for the operator to confirm. The plan also returns a confirmation_code. The write happens only on a second call carrying BOTH confirm=True and that code, so confirm=True on a first call cannot write: it just returns the plan. Ask the operator, then echo the code back. The plan names the environment the terminal was actually found in, which is where the write will land — pass that environment back on the confirming call to pin it explicitly. action="assign": after assignment, transactions taken on the device bill to account_id. The backend checks assignment eligibility and permissions when the confirmed write runs. action="unassign": the device no longer bills to that account (it may still be assigned to others — see get_payment_device(...)). device_id must be device_…; account_id must be acc_…. The terminal's current state is checked before the write. If the desired state already exists, return success with changed=false and issue no write. An uncertain write response causes one state read in the same environment. A matching state is an observation; otherwise the outcome is unknown. Never repeat an uncertain write automatically.
search_rootline_documentation
ChatGPTAnswer a conceptual / how-to / integration question from Rootline's PUBLIC documentation, grounded in real doc content with canonical links. USE THIS TOOL for knowledge questions — how a feature works, what a term or field means, how to integrate, setup/onboarding concepts, error-code meanings. These are questions about Rootline itself, not about any specific account, payment, company, device, or report. DO NOT use it to look up records or tenant data (a merchant's payments, an account balance, a device's status, a report's rows) — those go to the data tools (get_account, list_payments, get_payment_device, …). If a question mixes both ("how do payouts work, and when is MerchantX's next one?"), answer the concept from here and the specific fact from the data tool. Grounds every answer in retrieved doc excerpts and returns the canonical documentation links — never invents fields, endpoints, or behaviour. Cite only the links this tool returned, verbatim; do not relabel them or append a plausible-looking URL or #anchor of your own. If the docs don't cover it, say so plainly rather than guessing.
unassign_payment_device
ChatGPTUnassign a payment device (terminal) from an account. Two-call confirm contract, enforced server-side. This is a mutating tool, so it dry-runs first: the FIRST call changes nothing and returns a plan — the action, the environment it would run against, and the device + account it touches — for the operator to confirm. The plan also returns a confirmation_code. The write happens only on a second call carrying BOTH confirm=True and that code, so confirm=True on a first call cannot write: it just returns the plan. Ask the operator, then echo the code back. The plan names the environment the terminal was actually found in, which is where the write will land — pass that environment back on the confirming call to pin it explicitly. After unassignment, the device no longer bills to that account (it may still be assigned to others — see get_payment_device(...)). device_id must be device_…; account_id must be acc_…. The terminal's current state is checked before the write. If the desired state already exists, return success with changed=false and issue no write. An uncertain write response causes one state read in the same environment. A matching state is an observation; otherwise the outcome is unknown. Never repeat an uncertain write automatically.