Skip to content

v1.42

Choose a tag to compare

@hermanekt hermanekt released this 05 Nov 23:29
· 5 commits to main since this release
46b0f6d

v1.42 - 2026-11-06

The Zabbix 8.0 release. 8.0.0 came out on 5 November 2026; v1.41 had been checked against its second release candidate. This release repeats that check against the final version, three ways, and moves 8.0 from "pre-release" to fully supported: the reference pages of 8.0 against the tool catalog, the version table and the get contracts (scripts/audit_api_reference.py, no difference left), the API classes of the released frontend against the tools (scripts/audit_api_frontend.py: 68 API objects, 233 methods, no difference; the same for 6.0 to 7.4), and a server installed from the official 8.0.0 packages (get contract audit, write round trip measured again, every object sent back through its tool). Then the sources themselves: every hunk of the PHP diff between the release candidate and the release, and what every get method of the 6.0 to 8.0 frontends takes according to its API class, against the contracts (scripts/audit_api_sources.py). The pages turned out to lag behind the source in a dozen places; those are under "Found in the source".

The final version is not the release candidate. Three things changed between them, and one thing around them.

Two more things are in this release. The get contracts are now stated in the JSON Schema of tools/list, not only in the descriptions (#106). And an independent review of the change set before the release found a way to lose template linkage that has been there since v1.40, and a promise the output parameter never kept; both are under Fixed. The source of the MCP server that Zabbix 8.0 ships was read as well, for what it does that this server did not; what came of it has a section of its own.

If you ran v1.40 or v1.41, read this first. Those two releases read a trigger with Zabbix's own expansion of the expression, which replaces every user macro by its current value, and a trigger that was read with trigger_get and sent back through trigger_update (the same for trigger prototypes) was stored that way: avg(/host/key,10m)>75 where it had been avg(/host/key,10m)>{$UTIL.MAX}. It still fires at 75 and no longer follows the macro. It is the first entry under Fixed; scripts/restore_trigger_macros.py finds the affected triggers in the Zabbix audit log and puts the macros back.

Two security fixes are in this release as well, found by the review of the release itself. Both are about who the client is behind a reverse proxy. If a reverse proxy runs in front of the server, read "Upgrading behind a reverse proxy" below before you upgrade: a proxy on the server's own host now has to be listed in [server].trusted_proxies.

Security

  • A proxy on the server's own host was believed without being listed (every release so far). uvicorn, the HTTP server underneath, has proxy handling of its own that believes X-Forwarded-For and X-Forwarded-Proto from every peer on loopback, and the server ran with it; [server].trusted_proxies did not come into it. Behind a local proxy or relay that passes the client's header through (nginx with a bare proxy_pass, a tunnel) a caller therefore named its own address. Measured behind such an nginx on v1.41: a caller outside both lists got through allowed_hosts and through a token's allowed_ips by sending X-Forwarded-For: 10.1.1.7, and the login limits counted each claimed address on its own. The server is now started without that handling and decides in one place who the client is, for the MCP endpoint and the admin portal alike (config.resolve_forwarded): for a peer listed in trusted_proxies the client and the scheme are what that proxy reports, and from anybody else the headers are not read at all, loopback included. allowed_hosts, a token's allowed_ips, the login limits, the audit log and the Secure flag of the portal cookie all go by the same answer.
  • The client address behind a reverse proxy on another host was the client's own claim (affects v1.21 to v1.41 where [server].trusted_proxies lists a proxy that connects from another address than loopback, such as a proxy container, a load balancer or a proxy that uses the host's LAN address, and that proxy appends to X-Forwarded-For, as nginx does with $proxy_add_x_forwarded_for). The server took the first entry of the header. A proxy that appends leaves what the client sent in front of its own entry, so a caller chose the address the server saw. Three checks go by that address. A token limited with allowed_ips was accepted from anywhere when the caller named an allowed address (the token itself was still needed), and the allowlist of an OAuth client likewise. The throttle on /oauth/login, five failed attempts per address in five minutes, counted every attempt on its own when the caller named a new address each time, which left the password of a portal user open to guessing at full speed; the portal's limit on POST requests could be passed the same way. Measured behind a real nginx with a token limited to 10.1.1.0/24: on v1.41 a caller outside the list was refused, and accepted after sending X-Forwarded-For: 10.1.1.7; a caller inside the list that sent a header of its own was refused. The address is now the one the nearest trusted proxy wrote: the right-most entry that is not itself a trusted proxy (config.forwarded_client), on the MCP endpoint and in the admin portal alike. Not affected by this one: a proxy that connects from loopback (the HTTP server underneath resolved it, see the entry above) and a proxy that sets the header instead of appending to it. On an older release, proxy_set_header X-Forwarded-For $remote_addr; in nginx closes both.
  • Upgrading behind a reverse proxy. If a proxy on the server's own host is in front of it and trusted_proxies does not list it yet, add trusted_proxies = ["127.0.0.1"] under [server] (and "::1" when the proxy connects over IPv6; "localhost" means both), as docs/OAUTH.md has asked for all along. Without it the server no longer knows who the clients behind that proxy are. Whatever allows by address refuses them: allowed_hosts, tokens with allowed_ips and OAuth clients with an allowlist (also where the list contains 127.0.0.1: a request from loopback that carries X-Forwarded-For is somebody's forwarded request, not a local client; a local relay that adds no such header is still taken for one, as it always was). The rate and login limits are shared by everybody behind the proxy, the audit log shows the proxy, redirects the server issues point to http://, and the portal's session cookie loses its Secure flag, because X-Forwarded-Proto is not read either. The server says so in its log, once per proxy ("X-Forwarded-* headers from 127.0.0.1 are ignored: it is not listed in [server].trusted_proxies ..."), and the security status at startup has a line "Reverse proxies". The proxy has to set or append X-Forwarded-For itself (the configurations in docs/OAUTH.md do); list proxies only, not the networks clients live in, since every listed address is believed. With more than one proxy in front (a load balancer or a CDN before nginx), list every one of them: the server takes the address reported by the last proxy it trusts, and a proxy that is not listed is, to the server, the client. allowed_hosts now goes by the client's address behind a listed proxy on another host as well, so the list can name the clients; a list that contains such a proxy's own address (by itself or inside a network) keeps letting every client behind it through, as it did.
  • A token limited with allowed_ips was accepted when the client address was unknown or was not an address (since tokens have the list, v1.16). The check was skipped in both cases, so X-Forwarded-For: x through such a proxy was enough. Such a token is refused now, as an OAuth client with an allowlist already was. allowed_hosts answered an address that is none with an unhandled error (HTTP 500); it answers 403 like any address outside the list.
  • A side effect that is a fix: a report download link built from X-Forwarded-Host and X-Forwarded-Proto now works behind a listed proxy on the server's own host. Before, the HTTP server had replaced the peer by the client before those headers were read, so only a proxy on another host could supply the address and everybody else needed public_url.

Changed in Zabbix 8.0.0 and followed here

  • The host interface API lost its write half. hostinterface.create, .update, .delete, .massadd and .massremove are gone from 8.0.0 (ZBXNEXT-10814; the release candidates still had them, a live 8.0.0 answers Incorrect method "hostinterface.update"). They join hostinterface.replacehostinterfaces and the four massupdate methods in the version table: on an 8.0 server the tools are refused before the call with what to do instead, tools/list marks them for the servers that lack them, and health_check lists them under unavailable_tools. Interfaces are edited through host_update, whose interfaces list replaces the current one (an entry with its interfaceid is updated, one without is created, one left out is removed); the tool description says so, and the list as host_get returns it goes back unchanged (verified live: change a port, add an SNMP interface, drop it again). hostinterface_get stays. The replacement text of hostinterface.replacehostinterfaces no longer points at methods that are gone too.
  • Deprecated is now a first-class notion, next to "since" and "removed". 8.0 deprecates event correlation in favour of complex event processing, and 7.4 had already deprecated the per-object discovery selects (selectItemDiscovery, selectHostDiscovery, selectTriggerDiscovery, selectGraphDiscovery, selectGroupDiscoveries, selectDiscoveries on hosts and templates) in favour of selectDiscoveryData / selectDiscoveryRules. Nothing deprecated is refused. METHOD_DEPRECATED in the version table dates the correlation.* methods: tools/list adds on '<server>' - correlation.get is deprecated since Zabbix 8.0 ... Prefer ceprule.get (complex event processing) for the servers that run such a release, health_check reports deprecated_tools, and the tool descriptions say it. The get contracts carry deprecated and replaced_by for the selects, so the description of item_get reads selectItemDiscovery (deprecated in 7.4, use selectDiscoveryData). The reference audit compares the marks with the pages, so the next deprecation is found the same way.
  • New in the 8.0.0 reference since the release candidate: maintenance.get triggerids, selectTriggers, selectEventNames; trigger.get maintenanceids; usergroup.get selectApmFilters. Added to the contracts and verified live. With them the tool descriptions cover what 8.0 can do that 7.4 could not: a maintenance scoped to triggers and event names instead of hosts, apm settings and timeout_telemetry_query on a proxy, proxies / proxy_groups / apm_filters on a user group, dashboards and global_regexes in a configuration export, the SAML certificates of a user directory (idp_certificate, required when the frontend runs with $SSO['CERT_STORAGE'] = 'database', refused otherwise).
  • CEP rules as released. The operations of a CEP rule changed after the release candidate: an operation has a scope (current event, other events, all events of the window) with an optional scope_filter, execute_when gained 5 (event closed), the operation type "set cause" is gone, and an operation's filters have their own condition types (tag, tag value, and the event flags problem opened / first / last / symptom / cloned / suppressed). The ceprule_* descriptions follow the 8.0.0 reference, the fixtures carry a scoped operation, and the filter rule (eval_formula dropped, formulaid only with a custom expression) covers scope_filter as well. Which operation type fits which moment, which scope goes with which moment, the order in which operations have to be listed (grouped by execute_when as 0, 1, 2, 5, 3, 4) and what each window type allows are checked by Zabbix with messages that do not always say so; ceprule_create now carries those tables (in the description of its params), taken from CCepRule and CCepRuleHelper.
  • Telemetry query items go back unchanged. The query of an item of type 24 carries a filter of the same kind as an LLD filter, and 8.0.0 treats it the same way: Invalid parameter "/1/query/filter": unexpected parameter "eval_formula", then "/1/query/filter/conditions/1/formulaid": value must be empty outside a custom expression. item_update / itemprototype_update (and the creates) apply the filter rule to it.
  • An LLD rule can be a telemetry query too. 8.0.0 added item type 24 to LLD rules and their prototypes (in the source after the release candidate; the reference page does not say so). Such a rule carries the same query with the same filter as the item, and a live discoveryrule.update refused what discoveryrule.get had returned (unexpected parameter "eval_formula"). The filter rule covers discoveryrule_* and discoveryruleprototype_* now, the write contract was measured again with two such rules among the fixtures (query.filter.eval_formula), and discoveryrule_create names the type.
  • APM as released. A trace is no longer described by its root span alone: apmtrace.get also returns traces whose root span is not stored (bounded by their earliest span), duration is the whole trace, and there is a new output property has_root_span. apmlog.get takes severity_numbers (0 to 24). There are four metric types (gauge, sum, histogram, exponential histogram); the description named a fifth. For a user who is not Super admin every apm*.get returns only the data whose resource attributes match an APM filter of the user's groups. The four apm*_get descriptions and the contract follow.
  • Symbolic names for the 8.0 values: item type TELEMETRY_QUERY (24, an item that reads the server's OpenTelemetry data), media type PUSH (5, notifications to the Zabbix mobile app). JSON (value type 6) was there.

Found in the source, not on the reference pages

scripts/audit_api_sources.py reads what every X.get takes out of the API classes of a frontend: the options of get() and the sort columns. Run against the sources of 6.0.48, 6.2.9, 6.4.21, 7.0.30, 7.2.15, 7.4.14 and 8.0.0 it found 26 places where the contracts, built from the reference pages, differed from the code. Each was then tried on live servers of those releases; what a class declares and nothing reads (hostinterface.get groupids, itemprototype.get groupids, usermacro.get itemids / triggerids) stays out. The rest:

  • Taken by Zabbix, missing from the tools (on every release unless dated): dashboard_get sorts by name as well; triggerprototype_get itemids; usermacro_get templateids; valuemap_get hostids; dcheck_get limitSelects; sla_get evaltype and service_tags (the SLAs whose service tags match); hostgroup_get selectHostPrototype (6.0 to 6.4; 7.0 has selectHostPrototypes); discoveryrule_get selectDiscoveryRule (7.4+); discoveryruleprototype_get selectDiscoveryData, the sort field discover, and discoveryids from 7.4, not 8.0; user_get current (8.0: only the calling user) and the sort field alias on 6.0 and 6.2; userdirectory_get sorting by host on 6.2. Before, each of these was refused by the tool as "not a parameter" although the server takes it.
  • Offered by the tools, not taken by Zabbix: usergroup_get limitSelects is on the reference page of every release, and no source reads it; a live server returns every user of the group whatever its value. regexp_get editable is answered with unexpected parameter on every release. Both are gone from the contracts.
  • groupCount: refused although Zabbix takes it. It is on no reference page, in the option table of two dozen get classes, and the frontend uses it itself: together with a count, item.get with hostids and groupCount answers one row per host with rowscount instead of one number. The source audit had set it aside as internal, and since v1.39 the tools refused it as "not a parameter of item.get; Zabbix would silently ignore it", which is not what Zabbix does. It is now a key of extra_params for the 22 get tools whose method honours it on every release it exists on (a list comes back: 21 of them measured on 6.0 to 8.0, discoveryruleprototype_get on 7.4 and 8.0), for hostgroup_get up to 6.0 and event_get up to 6.4 (from 6.2 and 7.0 on those methods validate their input and answer unexpected parameter), and the audit compares it like any other option. Without output: "count" it is refused before the call: Zabbix ignores it at best, and next to an ID filter 8.0 answers Database error occurred. and 6.0 an empty list. item_threshold_search, which reads item rows and cannot count, does not offer it.
  • Symbolic names that were missing: item type NESTED (23, 7.4+, an LLD rule prototype that reads its parent rule's data), post_type XML (3) for HTTP agent items, and BEARER (5) for a connector's authtype.
  • Typed tool parameters that Zabbix does not have. The audit was then pointed at the tools themselves: is every parameter a tool types by hand one the PHP method takes? Seven were not, on every release, and the validation let them through because a typed parameter was always accepted. Each was tried live. action_get eventsource and trigger_get with_unacknowledged_events were ignored by Zabbix, so the tool returned every action and every trigger while the caller believed it had filtered; usergroup_get with_users likewise. proxygroup_get proxygroupids, report_get dashboardids and proxy_get with_hosts (from 6.4) were answered with unexpected parameter, so the tool could not be used with them at all. Now eventsource and dashboardids are sent as keys of filter (the properties are filterable; a different value for the same key in the caller's own filter is refused instead of guessed), proxygroupids goes out as proxy_groupids and with_unacknowledged_events as withUnacknowledgedEvents (ParamDef.api_name; the tool's parameter names stay as they were), and with_hosts, with_users and task_get proxyids, which have no counterpart in Zabbix, are gone. A unit test keeps the rule: a typed get parameter is a parameter of the method, or says which filter key it becomes.
  • Methods with a signature of their own (not get, not the generic create / update / delete): the audit reads the fields their PHP validation takes and compares them with the tool. event_acknowledge gained suppress_until (6.2+; the tool could suppress, but not say until when) and cause_eventid (6.4+; Zabbix requires it for action 256, "make this a symptom", so that action was refused every time), and its description gave 128 for both directions of a rank change and did not know 256. script_execute gained manualinput (7.0+). script_getscriptsbyhosts and script_getscriptsbyevents gained scriptid and manualinput (7.0+), and work on 6.0 to 6.4 again: those releases take plain IDs, the tools sent the objects that 7.0 introduced. user_checkauthentication takes token (an API token instead of a session) and extend; sla_getsli takes periods. All of it verified through the tools on the releases that have it, the effects included (a problem suppressed until the given time, ranked as a symptom of the given cause and back).
  • After the corrections the source audit (57 to 76 methods per release: every get, and every method with a signature of its own) reports no difference on any of the seven releases, the reference audit of 8.0 lists the twelve additions as known omissions of the pages (and groupCount as on no page of any release), and the live audit of the get contracts (every property, sort field and select of every method: 1 154 to 1 442 calls per release) finds no problem on any of them.

Learned from the MCP server that Zabbix ships

Zabbix 8.0 comes with an MCP server of its own (zabbix_mcp_server; Go, AGPL-3.0, 22 tools over 18 API methods, the source is in the Debian source package of 8.0.0). Its source was read for what it does that this server did not. No code was taken; four behaviours were, each checked against this server first and measured on 6.0 to 8.0 where a Zabbix server is involved. A fifth finding came up on the way and is this project's own.

  • A write is never sent a second time. Their client repeats reads only. Ours repeated anything after a connection error; see "A write could be sent twice" under Fixed.
  • A log read with a limit returned its oldest rows. Zabbix answers a get without sortfield in the order of the database. history_get with itemids and limit: 3 returned three values a month old on a server whose newest value was a minute old; problem_get, event_get and auditlog_get returned the oldest rows or a slice from the middle, alert_get alerts 2, 1 and 3 of four (measured on 6.0 to 8.0; never the newest). A model that asks a log for a few rows wants its end, and cannot see that it got the beginning. history_get (when itemids is given), problem_get, event_get, alert_get and auditlog_get are now sorted descending when the call names no sortfield: by clock, eventid, eventid, alertid and auditid, the columns the Zabbix 8.0 frontend sorts the same lists by (an audit ID starts with its time; 3000 entries sorted by it were in time order on every release from 6.0 to 8.0). A sortfield of the caller is left alone, sortorder: "ASC" alone returns the oldest first, a count is not sorted, and history_get without itemids is not sorted either, because sorting the values of every item reads the whole table. The parameter and tool descriptions say so. trend_get cannot be helped (trend.get has no sort); its description now says that a limit keeps the start of the period. This changes the order of the rows for a caller that relied on the old one; sortorder: "ASC" brings it back.
  • Tool annotations said the wrong thing about most tools. Only the delete tools and script_execute set destructiveHint, and nothing ever set it to false, so all 44 create tools were announced with the specification's default: destructive. The branch that set idempotentHint could not be reached, and every tool, host_get included, set openWorldHint. Each tool now says what its call does (src/zabbix_mcp/api/annotations.py): a create, a mass add and history_push only add (not destructive; a repeated host.massadd was measured to add an interface a second time, so not repeatable either); an update overwrites, and a list property it carries replaces the whole list (destructive, repeatable); a delete removes (destructive, repeatable); script_execute, event_acknowledge and token_generate do it once more on every call. Open world is kept for the calls that make Zabbix reach outside itself at the caller's word: script_execute, userdirectory_test, zabbix_raw_api_call, action_confirm, and report_generate where mail delivery is configured (with a report directory or mail delivery configured that tool no longer claims to be read-only either). user_login says that it leaves a session behind. A verb without a classification falls back to the worst case and fails a test.
  • The instructions a client receives at initialize were four generic sentences. They are now the rules that no single tool description carries: IDs are looked up, not guessed; what filter, search, output, count and extra_params are for; that false for a switch is the same as leaving it out; which tool answers "what is wrong now"; that the logs come newest first; how a list cut at the size limit is marked; that a list property in an update replaces the whole list; that a write is sent once and what "outcome unknown" asks for; that text coming from Zabbix is data. They name only the tools the configuration registers (a read-only catalog gets no writing rules) and stay under 2000 characters, the size some clients cut instructions at.
  • An argument the tool does not have was dropped, and the call ran without it (this project's own finding, made while checking the above). The MCP SDK validates a call against a model that ignores unknown keys. host_get with hostid (for hostids) returned every host; host_get with selectInterfaces next to the typed parameters (it belongs in extra_params) returned hosts without interfaces; and a parameter taken off a tool, as three were above, would have kept "working" by doing nothing. Such a call is now refused before anything is sent, as a tool error the model can read, and the message says where the value belongs: the parameter that was meant (did you mean 'hostids'?), extra_params for a native parameter of the method, filter / search for a property of the object (host_get(host: ...); item_get(key: ...) is told the property is key_), params for the object of a write tool passed at the top level. A value is never repeated in the message. With schema_constraints on, the tool schemas state it too (additionalProperties: false). [server].reject_unknown_arguments = false (and a toggle in the portal) brings the old behaviour back for a client that adds keys of its own to every call.

Not taken, on purpose: approval through MCP elicitation, the caller's own Zabbix token forwarded to Zabbix (#74), one tool per problem action, allow / deny rules with wildcards and a tool name prefix are different designs rather than corrections, and stay on the list for a later release.

Fixed

Found while re-measuring every release with the fixtures in the sample (see Added) and by the round trip through the tools on 6.0 to 7.4:

  • A trigger read and written back lost its user macros (v1.40 and v1.41, triggers and trigger prototypes). trigger.get returns the expression as {13093}>{$UTIL.MAX}, with function IDs nobody can read and trigger.update refuses, so v1.40 asked Zabbix to expand it by default (expandExpression). That expansion writes the functions out and, in the same pass, puts the current value of every user macro in: in the expression, in the function parameters and in the item keys. Read with trigger_get and sent back, the trigger was stored as avg(/host/key,10m)>75: a threshold frozen at the value of the day, in a place where nothing shows it. More than half of the triggers and three quarters of the trigger prototypes of a stock Zabbix use a user macro. The round trip of v1.40 to v1.42 did not see it, because it compared what the tools returned before and after, and both were the expanded text; it surfaced when one run happened to compare the functions of a trigger prototype. The tools now return the form the frontend shows and the export writes: the function calls rebuilt from the trigger's own functions, everything else as stored, avg(/host/key,10m)>{$UTIL.MAX} (api/trigger_expressions.py, Zabbix 5.4 and later). Measured against Zabbix's own expansion for every trigger and trigger prototype of the 6.0.48 to 8.0.0 test servers, about 46 000 objects: identical wherever there is no user macro, and with the macro where Zabbix puts its value. expandExpression: true in extra_params still returns Zabbix's expansion, for reading the values; false the stored form. On 5.0 and 5.2, whose older expression syntax is not rebuilt, Zabbix's expansion remains the default and the loss with it.
  • Finding and repairing what those two releases did: scripts/restore_trigger_macros.py URL TOKEN reads the Zabbix audit log (6.0 and later; kept for 31 days by default from 7.0, 365 before) and lists every trigger and trigger prototype update in which the only change was a user macro turning into a plain value. With --restore it writes the earlier expression back, and only where three things hold: nothing but macros changed in that update, the trigger still has what that update left behind, and the values written are values those macros have today. An expression that was edited again afterwards, or a number that is not the macro's value, is listed (SKIPPED, REVIEW) and left for a person; --user narrows the search to the Zabbix user of the MCP server's API token. On our own test servers, which the round trips of the v1.40 and v1.42 work had run over, it found and restored 7 to 34 triggers per server.
  • An object on a host could not be sent back on Zabbix 6.2. Items, triggers, graphs and LLD rules that live on a host rather than on a template have no uuid; a get returns "uuid": "" and 6.2 refuses it (Invalid parameter "/1/uuid": cannot be empty). The measurement had classed the key as depending on the row and left it alone, correctly; the fixtures that would have shown the failure through the tools were never in the sample. An empty uuid is now dropped before every create and update, on every release: no caller can mean it.
  • A template read with template_get and sent back could lose every template it inherits from. template.get returns both directions of template linkage: parentTemplates (what the template inherits from) and templates (the templates that inherit from it). template.update calls the first one templates. Sent back as read, the list is therefore the other relation. A list of children is refused (key by key, unexpected parameter "proxyid", or as a circular linkage), but the empty list of a template that nothing inherits from is accepted and unlinks every parent without a word; the inherited items, triggers and LLD rules stay behind as the template's own (verified on 6.4.21 and 8.0.0). With selectTemplates alone this could always happen; with both selects Zabbix used to refuse the payload because of parentTemplates, until v1.40 began to drop that key as read-only. Now template_get always returns the two relations together, and a payload that still carries parentTemplates has its templates compared with the template's real children: equal means it is the echo and it is left out, so linkage does not change; anything else is refused with both meanings spelled out, because it cannot be told which relation was meant (a check that cannot be made, because the lookup failed or the template is not readable, is reported as that). Whenever the linkage keys of such an object are left out, the result carries a _note that linkage was not changed and how to change it: an echo with an empty templates and a wish to unlink every parent are the same payload, and a parentTemplates the caller edited is dropped as read-only, so "success" alone would have hidden that nothing was linked or unlinked; a copy made with template_create is told that it inherits from nothing. A templates sent without parentTemplates is the caller's own and is passed on untouched ([{"templateid": X}] links, [] unlinks). The fixtures gained a template that inherits from another; the round trip did not notice the loss, because an accepted update counted as success (see Added).
  • A template's graph read with graph_get and sent back emptied the graphs that hosts inherit from it. graph.get returns each graph item with the graphid of its graph. Zabbix takes that key back without a word, and when it then copies the template's graph to the hosts that inherit it, it writes the copies' items under that id: the inherited graph is left empty and its items hang on the template's graph. A second update repairs the template's graph and makes a new copy; the empty one stays behind. The same happens to graph prototypes. Reproduced with the raw API on 6.2.9, 6.4.21 and 8.0.0; without gitems[].graphid nothing of the sort happens (gitemid may stay). The key is now taken out of every graph item before graph_create, graph_update and the two prototype tools. Zabbix does not refuse the key, so the measurement of refusals could not find it; the round trip did, once it compared the inherited copies (see Added).
  • false switched a filter on. Zabbix has yes/no get parameters of two kinds. A boolean reads its value. A flag is on as soon as it is present: trigger.get with only_true: false returns the triggers in problem state, exactly as with true. A model that fills in every boolean of a schema, false for "no", therefore got the opposite of what it asked for, and nothing said so. Measured on all seven releases, with the parameter left out, true and false: forty parameters behave that way on at least one release (twenty-five from 6.2 on), among them the typed trigger_get only_true, monitored, active and with_unacknowledged_events, host_get and template_get with_items / with_triggers / with_graphs, and through extra_params templated_hosts, skipDependent, withAcknowledgedEvents, globalmacro and, on 6.0, every with_* of hostgroup_get. A false for a flag is no longer sent, typed or in extra_params; a boolean keeps its false (templated: false is "the ones that are not", not "any"). The description of extra_params lists the method's switches. This also makes a promise of v1.40 true: expandExpression: false for the raw form of a trigger expression never worked, because the server sent the false and Zabbix expanded anyway.
  • A write could be sent twice. After a connection error the client reconnected and sent the same call again, whatever it was. Those errors reach the client after the request has gone out (what fails before that is reported differently by the Zabbix library): a timeout while Zabbix is still working on a large import or a mass update, a connection closed by a proxy in between. For a read the second attempt is right. For a write it means two imports, two script.execute, two acknowledgements. A write is now sent once: the server reconnects, so the next call works, and the tool answers that the connection broke, that Zabbix may or may not have applied the call, and that the object should be read back first. A session that Zabbix refused is sent again as before, since the call was not carried out. Found by comparing with the MCP server that Zabbix 8.0 ships, which never repeats a write.
  • problem_get recent was described as "problems of the last 30 minutes". It is the switch that adds the problems resolved a moment ago to the unresolved ones. suppressed and item_get with_triggers did not say that false returns the opposite set, not everything. event_acknowledge says now that Zabbix carries out closing, suppressing and rank changes a few seconds after the call and skips, without an error, a part that changes nothing at that moment (seen live: "back to cause" sent right after "make it a symptom" is accepted and does nothing).
  • output: "count" never counted. The description of output has offered 'count' for the number of matches, and the server passed the word on. Zabbix has no such value: 37 get methods of 8.0.0 answer Invalid parameter "/output": value must be "extend", the others read it as a property name and return bare IDs, and usermacro.get fails inside PHP. count is now sent as countOutput, which every list-returning get method has (checked method by method on 6.0.48, 6.4.21, 7.0.30, 7.4.14 and 8.0.0 against the contracts: no difference), and it wins over a countOutput: false sent along. The six get tools that have nothing to count (settings_get, housekeeping_get, authentication_get, autoregistration_get, task_get, serverinfo_get) no longer offer it and say so when asked.
  • problem_get with monitored: a count was taken by Zabbix before the filter and so included the problems of disabled triggers and hosts; it is taken after the filter now. And an output list that left objectid out came back empty, because the filter finds a problem's trigger through it; the property is asked for, used and taken out again.
  • serverInfo.version in the initialize result was an empty string (what the MCP SDK sends for a server that does not state its version); it is the server's version now.
  • item_threshold_search failed with 'str' object has no attribute 'get' when extra_params carried countOutput or preservekeys; it refuses the two with the reason.
  • The description of ceprule_create was longer than a client keeps. It had grown to 2575 characters with the released CEP rules, and Claude Code cuts a tool description at 2048, so its end (the filter conditions) never reached a model. The conditions a filter takes, which operation type, scope and window go with which execute_when, and the conditions of an operation's own filters moved to the description of params; the description is 1618 characters, which leaves room for the note tools/list adds for a server below 8.0. A test keeps every tool under the limit as registered and with that note for a mixed pair of servers, and a note that would not fit goes in front of the description instead of being the part that is cut. One rule was missing from the text: an operation that runs when the event occurs (execute_when 0) takes neither "first" nor "last" as a condition of its own filters.
  • The sentence about what the server drops before a write named keys that stay. host_update said that the server "drops the read-only and sub-object keys host.update refuses (auto_compress, groups, interfaces, macros, tags)", although only keys inside the rows of groups, interfaces, macros and tags are dropped and the lists themselves are sent; usergroup_update listed rights, which is dropped only next to its successor hostgroup_rights; templategroup_update listed uuid, which only 6.2 refuses. The sentence now tells the four cases apart (host_update: "(inside groups, interfaces, macros, tags only the keys refused there; auto_compress on the releases that refuse it)"; mediatype_update: "(users; actions on the releases that refuse it; content_type next to message_format)"), and a test compares it with what the server drops on every release.
  • item_threshold_search sent a false switch on to Zabbix. The get tools stopped doing that in this release (see "false switched a filter on"); this tool passed extra_params through as they came, so webitems: false added the web items although its description says that false is the same as leaving the switch out. It leaves a false switch out now (false and 0, as the get tools do), and a boolean keeps its false.
  • [server].trusted_proxies with a network did not work on the admin portal. The MCP endpoint has matched the entries as addresses or networks since v1.36; the portal still compared strings. With ["10.0.0.0/24"] the endpoint saw the client behind the proxy and the portal saw the proxy, so everybody behind it shared one bucket of the portal's limit on POST requests (the same for an IPv6 address spelled differently). Both go by one matcher now, and by one reading of X-Forwarded-For (see Security).
  • A release candidate is not the release. 8.0.0rc2 still had the host interface write methods that 8.0.0 dropped, and the version table, which reads the number as 8.0, refused them there (through zabbix_raw_api_call as well). A pre-release (alpha, beta, rc) of the very release that removed something is no longer refused; Zabbix answers for itself.
  • The description of hostinterface_replacehostinterfaces still sent 8.0 users to the host interface tools that 8.0.0 removed; it names host_update with interfaces now. extra_params listed selectPages for dashboard_get, which the tool types itself.
  • module_* on Zabbix 6.0 and 6.2. v1.41 found that the module API answers there although the reference lists it from 6.4, and stopped refusing the tools; the contracts still dated everything 6.4. The get contract is dated 6.0 now (audited live on 6.0.48 and 6.2.9, no finding), and the write contract was measured there: id and relative_path are dropped on every release, where module_update on 6.0 and 6.2 failed with unexpected parameter "id".
  • overrides[].filter.eval_formula of an LLD rule was missing from the measured contract for 6.4 (the hand rule dropped it anyway); it is refused on every release and the contract says so.
  • scripts/roundtrip_fixtures.py --purge never found a leftover proxy on releases before 7.0, where a proxy is named by host, not name.

Added

  • A hint where 8.0 surprises an operator. A new 8.0 installation enables Access to API only for the Super admin role; User role and Admin role ship with it off (ZBXNEXT-10469), and an API token of such a user is answered with a bare No permissions to call "host.get". The server passes that message on, as before, and appends where to look (Users > User roles > Access to API); the hint is given only when Zabbix's error data starts with those words. The README says the same under Zabbix Compatibility.
  • The get contracts in the JSON Schema of tools/list (#106, @Amelkahil). Since v1.39 the descriptions say what each get method takes, and the server refuses the rest; a client that builds the call from the schema alone (a structured-output decoder of a local model, a JSON Schema validator in front of the call) still saw string | null and let the model write problem_get(sortfield: "clock"). The same contract is now schema: sortfield is an enum of the sortable fields (a list for several), sortorder is ASC / DESC, output is extend / count or a list whose items are the object's properties, filter and search are objects whose keys are limited to the properties the method filters or searches on (propertyNames), extra_params takes only the method's own parameters and selectXxx, an integer with a documented set of values is an enum (history_get history), the period of an extension tool has a pattern. item_threshold_search and problem_active_get carry the contract of the method they wrap. The names are the contract's (the ones the description lists, plus the few it no longer lists because they left in Zabbix 6.0 or earlier), and a test checks both directions for every tool: the schema offers nothing the validation refuses, and refuses nothing it takes. A method with no parameters beyond the typed ones takes no extra_params key at all. output, sortfield and sortorder take a list as well as a string, and the old comma-separated form keeps working: the listed schema is stricter than the handler, on purpose. What the schema does not carry: the release (one catalog serves servers of several releases; the call is still checked against the server it goes to), the properties a selectXxx may project (not measured yet), and "one of these two arguments is required", which stays in the description because several model APIs refuse anyOf at the top level of a tool schema. The catalog grows by about 10 % (tools/list of one read-write server: 787 KB against 716 KB); [server].schema_constraints = false (and a toggle in the portal) returns the plain types for a client that cannot digest propertyNames.
  • Identifiers are looked up, not guessed (the other half of #106). A planner that prepares several calls at once has to know which arguments it may write from the question and which it must resolve first. history_get and trend_get say that item IDs come from item_get and that history is the item's value_type; item_history_summary_get, capacity_forecast and anomaly_detect say that an item key must be one that exists, how to find it (item_get with a search on name or key_, which properties to ask for) and how they match it (exact, or as a substring where the first match wins); item_threshold_search says why the key of a metric depends on the templates in use; hostgroup_overview_get and host_status_get say that one of their two arguments is required and that the name is enough, with no lookup first.
  • The round trip reads every object again. scripts/mcp_roundtrip_live.py counted an update that Zabbix accepted as an object that went back unchanged, which is how the loss of template linkage stayed unseen. Every object that goes through is now read again with the same selects and compared, on its own and in order (the order of preprocessing steps is part of the object), leaving aside what a server changes on its own (lastclock, lastaccess, a trigger's regenerated functionid); a difference, or an object that cannot be read again, fails the run. For an object on a template the copies that hosts and templates inherit are compared too, and every fixture object is sent whatever its shape (a stock object of the same shape used to stand in for it, and only the fixtures have every relation). With the linkage check switched off, the same run reports the fixture template as changed in parentTemplates, items, triggers and discoveryRules; with the graph item rule switched off, it reports the template's graph, its graph prototype and their inherited copies. So the check sees what it is there for.
  • scripts/audit_get_flags_live.py: for every flag and boolean parameter of every get method it counts the rows of a running server with the parameter left out, true and false, and fails when a parameter whose false the server sends is switched on by it, or when one whose false it leaves out has a meaning of its own for false. 112 to 129 parameters per release, 93 to 103 of them told apart by the data of the test servers, none behaving differently from what the server assumes (groupCount included: its answer is a list of rows, which the audit reads as "on").
  • Four audit scripts in the repository, so the next release is checked by running them instead of by rebuilding them: scripts/audit_api_sources.py (what every get method takes and sorts by, read from the PHP classes of a frontend, against the get contracts; see "Found in the source"), scripts/audit_api_reference.py (reference pages of a release against tools, version table and get contracts, including which methods and selects the pages call deprecated; a page that did not arrive or arrived without its tables counts as a difference; the places where the reference is wrong and a live server was asked instead are listed in it: the sort field discovered that every 8.0 server refuses in favour of discover, the status sort field of template.get), scripts/audit_api_frontend.py (the methods a frontend really exposes, read from CApiServiceFactory and the ACCESS_RULES of its API classes; this is what showed the host interface removal and, in v1.41, the undocumented CEP rule API), and scripts/mcp_roundtrip_live.py (every object from its get tool back through its update tool, unchanged). scripts/audit_get_contracts_live.py now supplies the parameters hostdashboard.get, serverinfo.get and the apm* methods refuse to run without, and probes only query-type selects with extend.
  • The round-trip sample always contains the fixtures. The write audit took the first 500 plain items, triggers, graphs and LLD rules by id; on a server with thousands of template items those are all stock objects and the fixtures, created last, were never probed. Both the audit and the MCP round trip now add the newest 100 plain objects. Re-measured on all seven releases with that sample (the ten objects that inherit from templates, 3 000 to 25 000 API calls per release): the contract itself changed in one rule (the LLD override filter on 6.4, under Fixed), and the round trip through the tools showed the two failures the old sample had hidden (the empty uuid on 6.2, the templates of a template with children).
  • 8.0 fixtures for the round trip: a maintenance by trigger and event name, telemetry query items (plain filter and custom expression), a push media type, a proxy with APM settings, a user group with proxy and APM permissions, a regular expression with a description, a SAML user directory with its certificate (scripts/roundtrip_fixtures.py).

Changed

  • Zabbix 8.0 is "Fully supported" in the compatibility table, and the README has a section on the MCP server that Zabbix 8.0 ships itself: what each of the two covers, and that they share the name zabbix-mcp-server. A client connected to both needs the other server's ToolPrefix, since several tool names are the same.
  • The installer and the Zabbix 8.0 package of the same name. The package zabbix-mcp-server that ships with Zabbix 8.0 installs /etc/logrotate.d/zabbix-mcp-server, the path this project's installer used for its own logrotate config; on a host with both, one overwrote the other. The config is now /etc/logrotate.d/zabbix-mcp; install.sh update removes the old file when it is ours (it rotates /var/log/zabbix-mcp) and never the packaged one. The systemd unit name stays shared, and this server takes it over on purpose: /etc/systemd/system/zabbix-mcp-server.service here has precedence over /usr/lib/systemd/system/zabbix-mcp-server.service there. What that means was tried on Ubuntu 24.04 with real systemd and the real 8.0.0 package, and the installer now handles each case: a packaged server that was never configured fails to start (no FrontendURL) and is retried every ten seconds, and the first retry after this installer's unit took the name started this server, unconfigured; the installer stops that loop first. A packaged server that is running keeps running until the unit is restarted, and systemctl start does nothing while it runs; the installer says so and prints restart as the next step, and install.sh update says that it is replacing it. install.sh uninstall says that the name it stopped and disabled is the package's again. The README has the whole picture, including how to run both (the packaged server under a unit name of its own).
  • The server survives what that package's scripts do to the shared name. Taking the name over has a price: the package's install and removal scripts act on zabbix-mcp-server.service, which now is this server. Read from the 8.0.0 packages and played through with real systemd: removing the deb stops the name, and this server stayed down until the next reboot; purging the deb deletes the name's boot symlink, and installing the rpm applies the system preset, which disables the name, and in both cases nothing ran after the next reboot. Two units of this project's own now stand in the way. zabbix-mcp-initmax.service is the unit the server is enabled through (sudo systemctl enable --now zabbix-mcp-initmax, with zabbix-mcp as a systemd alias of it): it requires the server's unit, so it starts the server at boot, the server is part of it, so stopping or restarting it stops or restarts the server, and no other package touches its name. zabbix-mcp-initmax-recover.path watches the packaged unit file and starts the server again when that package is installed, upgraded or removed, provided the server is enabled at boot; a stop by hand is left alone, since no package touched the file. install.sh update switches an installation that is enabled under the old name over; install.sh uninstall removes the units and leaves the name to the package, which starts under it again. A name that already belongs to somebody else's unit (zabbix-mcp, or zabbix-mcp-initmax itself) is neither overwritten nor removed. systemctl start|stop|restart|status zabbix-mcp-server mean what they always did.
  • An answer goes out once, as text. Every tool returns text (report_generate adds a link to the PDF). The MCP SDK took the -> str of the handlers for structured output: each of the other 254 tools was announced with the output schema {"result": string} (40 KB of tools/list, 5 %), and every answer was sent twice, as text and as structuredContent: {"result": "<the same text>"}. A client that prefers structured content (Claude Code does) handed the model the JSON-escaped copy: 14 % more characters than the text over a measured session. The tools are registered as text-only now: no outputSchema, no structuredContent, the text itself unchanged. A client that read structuredContent.result reads content[0].text instead. Found when a real model was put in front of the server (see Tests).
  • config.example.toml documents [server].trusted_proxies and [zabbix.<name>].request_timeout, the two keys the loader takes that the example did not show.
  • The get contracts are rebuilt from the released 8.0.0: the observations of the release candidate are replaced by those of the final version (an LLD rule's storage_mode, returned by rc2, is not returned by 8.0.0). The write contracts are measured on 8.0.0 instead of rc2 (about 25 000 API calls with 73 fixture objects; 73 methods and 957 paths in all, after the selects the source audit added were measured on the releases that have them); hostinterface.* is no longer measured there, since the methods do not exist.
  • ceprule_*: the CEP rule API, taken from the frontend source for v1.41 because rc2 had no reference page, is documented in 8.0.0 and matches it; the tools no longer say "not documented".

Tests

  • 1067 tests (280 new). For what was learned from the other server: the classification of every write verb and the hints of every registered tool (tests/test_tool_annotations.py: no tool left to the defaults, the hint agreeing with what a read-only token is shown), the default sort (tests/test_newest_first.py: the five logs, a caller's sort and a lone sortorder left alone, counts, history_get without itemids, the sort field accepted by the contract of every release from 5.0 to 8.0), the refused arguments (tests/test_unknown_arguments.py: every message, no value echoed, every tool taking each of its own parameters, the call never reaching Zabbix, the switch, the schema), the instructions (tests/test_server_instructions.py: the size, only registered tools named, the read-only variant), and the same on the wire against a real server process in both protocol generations (tests/test_protocol_e2e.py, which also checks that no tool carries an output schema and no answer a structured copy). groupCount (tests/test_group_count.py: exactly the measured methods, the two that started to refuse it, a grouped count through the tool, false not sent, refused without a count that is true, the schema and the description, and item_threshold_search neither offering it nor passing a false switch on), the answers (tests/test_text_answers.py: no output schema on any tool, no structured copy, a tool that builds its own result keeping it), the descriptions (tests/test_tool_descriptions.py: no tool description longer than 2048 bytes as registered and with the version note of a mixed pair of servers, a note that would be cut going first, the sentence about dropped keys compared with what the server drops for every write method on every release) the repair script (tests/test_restore_trigger_macros.py: what an expansion looks like and what somebody's own edit looks like, the decision for a trigger that was edited afterwards, restored already or lost twice, the macro values, the audit log read whole across pages, and a run against a fake Zabbix that writes only what is certain), trigger expressions (tests/test_trigger_expressions.py: the rebuilt form with macros in the expression, in a parameter and in an item key, macro contexts, braces inside a string, pieces that do not add up keeping the stored form, the one extra call and its chunks, a count and an answer without expressions costing nothing, the caller's own expandExpression, 5.0 as before, and a trigger read and sent back still carrying its macro), the proxy list (tests/test_admin_peer_ip.py: addresses, networks and IPv6 spellings, the portal answering like the MCP endpoint) and the client address behind a proxy (tests/test_forwarded_client.py: a proxy that sets the header, one that appends to what the client sent, a chain of trusted proxies, ports, a header of nothing but proxies; through the real middleware a token limited to addresses refused for a caller that names an allowed one and accepted for a caller inside the list, fifty-nine claimed addresses counting as one client, and the token refused when the address is unknown or is not one; the outermost layer of the MCP endpoint for a proxy that is not listed (nothing believed; a local one leaves the client unknown, so that an upgrade does not open an allowlist that contains loopback), a listed one on the same host and on another, a load balancer before either, several header lines, the scheme, allowed_hosts going by the same address and answering 403 to one that is none, the warning said once; the portal as it is served (tests/test_admin_peer_ip.py: its outermost layer, a failed login counted for the client a listed proxy reports and for the peer otherwise); and end to end behind a real nginx, one that appends to the header and is listed and one with a bare proxy_pass that is not, with the released v1.41 next to this release). The rest: the deprecation table and its notes in tools/list for a mixed 7.4 / 8.0 pair of servers (one tool missing on one server and deprecated on the other included), the deprecated selects in the contracts and in the tool descriptions, the host interface methods refused on 8.0 with host.update as the way out, still passing on 7.4 and not refused on a release candidate, deprecated_tools in health_check, the 8.0 symbolic names, the API access hint, the filter rule on a CEP operation's scope filter and on a telemetry item's query, the empty uuid, the graph id inside graph items, a telemetry query on an LLD rule, template linkage (the echo of a child and of a parent template, a changed list refused, the caller's own list untouched, the note in the result, a failed and an empty lookup, a count, a copy), output: "count" (also against a contradicting countOutput and with monitored), and the schema constraints (tests/test_schema_constraints.py: schema against description for every get tool, the schema against the validation in both directions, every tool schema valid JSON Schema with no combinator at the top level, the call from #106 refused by the schema, both argument forms reaching Zabbix, the switch restoring the catalog as it was). What a typed parameter becomes on its way to Zabbix (tests/test_typed_params.py: the four translated names, the filter keys and their conflict, the removed parameters refused by the validation, and for every get tool that a typed parameter is one the method has; a false flag not sent, typed and in extra_params, a boolean keeping its false, the raw trigger expression; the methods with a signature of their own on both sides of the release that changed them). The client after a lost answer (tests/test_client_resend.py: a read asked again, a write sent once with a message that says so, the next call on a fresh connection, a refused session sent again, and the list of repeatable methods agreeing with the tool registry). The installer matrix has a 19th case: Debian 12 with the unit and the logrotate file of the Zabbix 8.0 zabbix-mcp-server package as they are in 8.0.0-1 (install, update and uninstall next to it; a pre-1.42 logrotate config moving on install and on update; the units of this project as designed; an alias name and the name zabbix-mcp-initmax held by somebody else's unit); an upgrade from v1.41 was run as well (configuration kept, logrotate file moved, a second update changes nothing).
  • The shared unit name was played through with real systemd and the real 8.0.0 packages, since the installer matrix runs without systemd: on Ubuntu 24.04 (deb) and AlmaLinux 9 (rpm), in containers with systemd as PID 1 where a container restart stands in for a reboot. The packaged server unconfigured and retried by systemd, and configured and running, each followed by this project's install, start, restart, update and uninstall; the packaged server under a unit name of its own next to this one; then, in both install orders and with a reboot after every step: the package installed, reinstalled, removed, installed again and purged, this server stopped, started and restarted under each of its names, disabled on purpose, enabled the old way and updated, and uninstalled with the package present (the packaged server starts under the name again). The edge cases of the watcher were run too: a stop by hand stays a stop, a server disabled on purpose stays down when the package is removed or installed, a stop by hand followed by the package's removal comes back. One trap on the way is worth recording: a Docker base image of Ubuntu forbids package scripts to start or stop services (/usr/sbin/policy-rc.d), so the first runs did not show the stop on removal at all; the image used for the final runs has that file removed, as a real host does. What the README says about the two on one host is what was seen there.
  • Live on 8.0.0, a server installed from the official packages: every distinct shape of every object and every fixture object from its get tool back through its update tool and read again (216 of 218 plain objects went through, the other two being Zabbix's own refusals: the stock Gmail media type without a username and the read-only Super admin role; 250 objects compared before and after together with the copies inherited from them, none different), the all-tools smoke (257 of 269; two fail on the environment, anomaly detection without a second host and graph rendering, ten are skipped for the same kind of reason: no APM database, no paired device), the schema constraints through the real handlers (list and string forms, count on ten methods and with monitored, what the schema refuses refused by the server too), and the 8.0 behaviour itself through the tools (interfaces changed, added and dropped through host_update, a telemetry query item created with TELEMETRY_QUERY and sent back, a push media type, a maintenance by trigger and event name with relative times, the removed methods refused with the way out, the deprecated ones working). scripts/test_all_tools.py knows the v1.41 and v1.42 tools now (apm*, hostdashboard_get, serverinfo_get, the ceprule_* chain), creates its test user with a role that has API access, which a new 8.0 no longer gives by default, and waits for the Zabbix server to learn about the host it has just created before it runs a script on it (script.execute answers Unknown host identifier for about ten seconds).
  • The additions of the section "Learned from the MCP server that Zabbix ships" through a real MCP HTTP server on 6.0.48, 6.2.9, 6.4.21, 7.0.30, 7.2.15, 7.4.14 and 8.0.0 (34 checks each, 36 on 8.0.0; none failed): the instructions and the version at initialize, the hints and the closed schemas of every tool in tools/list, history_get with limit: 3 returning the newest values of the item where the same call used to return the oldest (26 to 31 days old on the 6.0 to 7.4 test servers), problem_get / event_get / auditlog_get returning the rows Zabbix itself sorts first, sortorder: "ASC" returning the oldest, a count staying a count, and the refused calls refused with nothing created. alert_get was measured on 8.0.0 with alerts made for the purpose.
  • groupCount through a real MCP HTTP server on the same seven releases (10 to 12 checks each, none failed): every tool that offers it on the release answers rows with rowscount, the count per host of item_get and trigger_get and per group of host_get equals the plain count of each, a single row without an ID filter, false a plain count, the two methods that stopped taking it refused with the release that did, and the refusal without a count.
  • A real model in front of the server. Claude Haiku through Claude Code (headless, this server as its only MCP server) on 8.0.0, eight tasks an operator would give: the latest values of an item, the newest audit entries, two counts, the templates of a host asked for the way a skill words it (selectParentTemplates named next to the tool, not inside extra_params), the items per host of a group, a tag added to a host that has two, a host added to a new group without leaving its own, a maintenance for the next hour. All eight ended with the right answer or the right state in Zabbix, with no call refused and no error; the tag was added by reading the tags first and sending all three, as the instructions say, and the count per host was asked with groupCount in one run and with a selectItems count in the others. This is where the doubled answers were seen.
  • The same round trip on the older releases, with the fixtures in the sample and every object read again: 7.4.14 216 of 218 plain objects (250 compared), 7.2.15 172 of 174 (192), 7.0.30 187 of 188 (218), 6.4.21 162 of 165 (194), 6.2.9 164 of 167 (205), 6.0.48 173 of 175 (194); nothing came back different, the inherited copies included, and every shape that did not go through is Zabbix's own: the guest user's language, the read-only role, a media type without a username, an interface whose address is an LLD macro, and one stock graph that 6.4 refuses and 6.2 answers with a PHP fatal error (scripts/mcp_roundtrip_live.py exits 0 on each; the counts move by a few shapes from run to run, because a get of 150 templates with every select can exhaust the PHP memory limit of a test server and is then repeated with 30; one run on 8.0.0 reported the item list of the host "Zabbix server" as changed, in the minute in which low-level discovery, the audit log's user System, updated 29 of its discovered items, and the repeated run compared equal; one run on 6.2.9 reported the two elements of the fixture map in the other order, which map.get does not define, and the comparison now takes a map's elements and links as sets). The comparison reads each object on its own, because 6.2.9 has a defect of its own there: script.get over several rows with selectActions attaches actions and parameters to the wrong script. Python 3.10 checked in python:3.10-slim.
  • Two independent reviews of the change set before the release (a second reader given the diff, not the conclusions). The first is where the template linkage finding came from, and with it the release-candidate rule, the stale hostinterface_replacehostinterfaces text, the reference audit that passed on a page it could not read, the installer test that ignored the installer's exit status, and the wording of the installer's warning. The second read what was written after the first: the note in the result when linkage is left alone, count together with monitored and against countOutput: false, the places where the schema was narrower than the server (a list of sort orders, a list for a single sort field, limit for item_threshold_search, the names only a 5.x server takes), and a round-trip comparison that sorted lists and so could not have seen reordered preprocessing steps. A third reader went through the PHP diff between the release candidate and the release hunk by hunk; the telemetry query on LLD rules, the trace semantics, the CEP tables and the APM visibility rule come from there. A fourth reader went over what was added on the last day, in five passes and each time given the code rather than the conclusions: everything under Security comes from there (the first entry of X-Forwarded-For, then the layer below it, then what an upgrade does to an allowlist that contains loopback), as do item_threshold_search passing a false switch on, the description that had outgrown what a client keeps, the sentence about dropped keys, and the three conditions under which the repair script writes.