chap-coordinator (Python)
Python reference implementation of the Collaborative Human-Agent Protocol (CHAP).
Covers Core plus every profile, 40 method handlers in total. Spec-aligned
field names, error codes, and response shapes against profiles/*.md.
Install
pip install chap-coordinator
For the security-signed/1.0 profile (Ed25519 signing) and the OIDC
binding hook:
pip install "chap-coordinator[crypto]"
For the MCP server transport (drive a Coordinator from any MCP client):
pip install "chap-coordinator[mcp]"
For the A2A server transport (expose a Coordinator as an A2A agent):
pip install "chap-coordinator[a2a]"
Companion modules
The base package is the protocol core, with what runs it for people and agents in more than one process, standard library only:
chap_coordinator.server, the desk server: the review desk,POST /chapand a read API, from the one process that owns the store; and the same routes as an ASGI app for FastAPI or Starlette.chap_coordinator.client, the HTTP client the other processes use.chap-coordinator, the command that runs the desk server and the two transports below (python -m chap_coordinatoris the same command).
Two transport adapters ship in the same wheel under optional extras:
chap_coordinator.transports.mcp_serverwraps a Coordinator as an MCP server. Every CHAP method becomes an MCP tool namedchap.<method>. Reference stdio server atreference/mcp-server-py/. Spec target: MCP 2026-07-28, serving 2025-11-25 clients as well.chap_coordinator.transports.a2a_serverwraps a Coordinator as an A2A agent. Every CHAP method becomes anAgentSkillon the Agent Card. Reference FastAPI server atreference/a2a-server-py/. Spec target: A2A 1.0 (with v0.3 compatibility).
Inward citation helpers (wrap_mcp_tool_call,
wrap_a2a_message_exchange, content_hash) live in
chap_coordinator.transports.wrap. They take a completed external
event and emit the matching CHAP audit entries with input/output
hashes.
Quick start
from chap_coordinator import Coordinator, CoordinatorOptions
coord = Coordinator(CoordinatorOptions(default_profiles=[
"core/1.0", "review/1.0", "whisper/1.0",
]))
coord.dispatch({"jsonrpc": "2.0", "id": "1",
"method": "workspace.create",
"params": {"workspace": "wsp_demo"}})
coord.dispatch({"jsonrpc": "2.0", "id": "2",
"method": "participant.join",
"params": {"workspace": "wsp_demo",
"from": "human:me@local",
"type": "human", "role": "reviewer"}})
coord.dispatch({"jsonrpc": "2.0", "id": "3",
"method": "participant.join",
"params": {"workspace": "wsp_demo",
"from": "agent:bot",
"type": "agent", "role": "drafter"}})
resp = coord.dispatch({"jsonrpc": "2.0", "id": "4",
"method": "task.create",
"params": {"workspace": "wsp_demo",
"from": "human:me@local",
"kind": "draft_response",
"input": {"ticket_id": "INC-1"},
"assignee": "agent:bot"}})
print(resp["result"]) # {"task_id": "tsk_...", "state": "created"}
The server, the client and the command
A coordinator runs in one process, which owns its store, and the people
and agents it serves reach it from others. chap_coordinator.server is
that process: the review desk where a person decides, POST /chap for CHAP
calls as JSON-RPC, and a read API under /api/. A chap.config.json
describes it:
{
"workspace": "wsp_support",
"profiles": ["core/1.0", "review/1.0"],
"store": "./data/chap.db",
"port": 8792,
"humans": [{ "uri": "human:ana@example.org", "display_name": "Ana", "role": "reviewer" }],
"agent": { "uri": "agent:drafter", "display_name": "The drafter" },
"require_signatures": "humans",
"chain": true
}
pip install "chap-coordinator[crypto]"
chap-coordinator serve --config chap.config.json
The desk is then at http://localhost:8792/. The server prints the desk's
address at localhost wherever it listens on this machine, since the desk
may sign with WebAuthn, which needs a domain name, and on the loopback
address it listens on IPv4 and IPv6 alike, so the name reaches it either
way.
A person's first join holds their name for good, with the key it carries, so where signatures are required the first join of a person the config names needs the enrolment code the server prints at start:
enrol 7KQ2M-X9D4T: the code human:ana@example.org joins with the first time, or open http://localhost:8792/#enrol=7KQ2M-X9D4T
Open that address, or give the desk the code when it asks. Without the
code, a process that started first, an agent among them, could join under
a person's name with a key of its own and approve its own work. A member's
later joins, and joins under any name but a configured person's, need no
code. CHAP_ENROLMENT_CODE sets the code, of 8 letters or digits at
least, and "enrolment": false in the config turns it off, for a
deployment that authenticates joins another way. A ChapDesk mounted in
an app of your own prints the code when it is made. Against a program
running as the person's own user, a coding agent with a shell among them,
the code is no boundary: run the agent as another user.
storeis read against the config file's directory, wherever the server starts, and a leading~is the home directory;":memory:"keeps everything in the process.require_signaturesistrue(every call is signed),"humans"(a person's calls are signed, by the desk in the browser, and a member that is not a person calls unsigned) orfalse. Under"humans"the server joins theagentwhen it starts, and each person joins from the desk with the key it makes for them. A workspace keeps the policy it was created with: the server says which when it starts, and/api/configgives it assignature_policy,"all","humans"ornull. Signing needs thecryptoextra.desk_signingsays how the desk signs, where signatures are required:"browser-key", the default, with a key the desk makes and keeps in the browser;"webauthn", with a passkey, which asks the person to verify each signature;"auto", with a passkey where the browser has one that verifies its user, and the browser key otherwise. A passkey needs the desk opened at a name, which on this machine islocalhost.chainlinks each entry on the log to the one before it by its hash.notifytells people that a review or a question waits for them:{"console": true}prints a line where the server runs, and{"webhook": {"url": "https://...", "secret": "..."}}POSTs a JSON notice to the URL, withX-Chap-Signature: sha256=<hex>, the HMAC-SHA256 of the body under the secret, for the receiver to check. Each notice is a summary and a link to the task in the desk, which grant nothing: whoever follows the link decides only as the desk lets them. A webhook that fails is logged, and no call waits on it. The secret is as private as the file that holds it.- PORT, CHAP_HOST, CHAP_DB_PATH, CHAP_REQUIRE_SIGNATURES, CHAP_DESK_SIGNING, CHAP_CHAIN and CHAP_ALLOWED_HOSTS override the file.
A notice, as the webhook receives it:
{
"event": "review.requested",
"workspace": "wsp_support",
"task_id": "tsk_01M6S3RGTEHGM0RX307P50NXT6",
"kind": "draft_reply",
"from": "agent:drafter",
"to": ["human:ana@example.org"],
"summary": "agent:drafter asks human:ana@example.org to review draft_reply tsk_01M6S3RGTEHGM0RX307P50NXT6",
"link": "http://localhost:8792/#task=tsk_01M6S3RGTEHGM0RX307P50NXT6",
"seq": 7,
"at": "2026-11-06T19:00:56.270Z"
}
A question is "event": "whisper.asked", with its whisper_id. seq is
the entry's place on the log.
The server answers only under its own host names, and a proxy's name goes
in allowed_hosts. It refuses a browser request from another origin,
takes JSON only on POST /chap, and its Content-Security-Policy lets no
other page frame the desk. The pages chap-analytics writes to analytics/
beside the config are served under /analytics/, in a sandbox that keeps
them out of the desk's origin. There is no login: a deployment reached from
other machines puts one in front. A program that joins a person from a
script, a test among them, passes the code as
Participant(desk, workspace, uri, signer=signer, enrolment=code).
Every other process reaches the server with chap_coordinator.client:
from chap_coordinator.client import HttpCoordinator, Participant
desk = HttpCoordinator("http://localhost:8792/chap")
agent = Participant(desk, "wsp_support", "agent:drafter")
task = agent.call("task.create", kind="draft_reply", assignee=agent.uri,
input={"ticket": "T-1"}, review_required=True)
agent.call("task.complete", task_id=task["task_id"], output={"body": "Hello"})
decided = agent.wait_for_decision(task["task_id"], timeout=3600)
print(decided["state"], decided["output"])
call raises ChapError, with the coordinator's code, when a call is
refused, and ChapEndpointError when no JSON-RPC answer comes at all. A
person joins when they first open the desk, and until one has, a
completion that asks for a review is refused with -32011, since nobody
could decide it; agent.reviewer_present() says whether one has, as the
templates' agents check before they submit. Under "humans" the agent
calls unsigned, as above. Where every call is signed, the agent signs with
a key of its own and joins once, which registers the key:
from chap_coordinator.client import Signer
agent = Participant(desk, "wsp_support", "agent:drafter",
Signer.load_or_create("agent:drafter", "keys"))
agent.join("agent", "drafter")
With a Signer, every call the participant makes is signed with its own
key, which load_or_create keeps in keys/, readable by its owner alone,
and names by its RFC 7638 thumbprint; without one, its calls go unsigned.
HttpCoordinator.dispatch(envelope) answers as Coordinator.dispatch
does, and a Participant stands in for a coordinator as well, signing what
it sends, so a framework bridge runs against the server unchanged.
chap-coordinator has three commands, each with --help:
serve: the desk server, from a chap.config.json (--config,--host,--port).mcp: an MCP server on stdio that acts as one agent,--as agent:assistantby default. With--url http://localhost:8792/chapit forwards every call to a running desk server, so the assistant's work waits for the person at that desk. Needs themcpextra.a2a: an A2A server that acts as one agent. Needs thea2aextra.
Running it for real
The store. CoordinatorOptions(store=SqliteStore(path)) keeps every
workspace in a SQLite file: the coordinator loads it when it starts and
writes each call that adds to a workspace's log before the call returns.
Without a store the state lives in memory and goes when the process exits.
The desk server opens the store chap.config.json names, from the config
file's directory.
When a write fails. store_errors says what a failed write does to
the call that made it, a full disk say:
"raise", the default: the call is answered with-32603anddata: {"reason": "store"}, and the workspace goes back to what the store holds. The call took no effect, so its caller makes it again; while the store cannot be read, calls on the workspace are refused the same way. The desk server's message says so: "The store did not record this call, so it took no effect; the server's log says why". The templates' agents report it and make the call again on their next pass."log": the call is answered as if it had been written, and the next write carries its change. This is the behaviour of 0.3.4 and earlier, where a caller could be told of a decision the store never kept.
on_store_error(err, {"id": ..., "version": ...}) hears of each failure;
unset, the failure is logged on the chap_coordinator logger, which is
the server's log.
Several processes, one store. Each coordinator holds its workspaces in
memory. Before a call on a workspace it asks the store whether another
process has written since, and reloads if so. A write another process got
to first is answered with -32603 and data: {"reason": "store"}, after
the workspace has been reloaded, and the caller may send the call again.
Two processes over one SQLite file, such as a server and a queue worker,
therefore cannot contradict each other's decisions. The desk server reads
the store again before each read of its API, so its pages show what other
processes wrote. A store of your own that implements
save alone has no such check, and still needs one process
(SPECIFICATION.md §10.3).
FastAPI. Mount the desk in your app after your own routes, and run one worker: the desk's pages read the coordinator's memory, which a call handled by another worker does not update until this worker's next call.
from contextlib import asynccontextmanager
from fastapi import FastAPI
from chap_coordinator.server import ChapDesk, load_config, make_coordinator
config = load_config("chap.config.json")
coord = make_coordinator(config)
desk = ChapDesk(config, coord)
@asynccontextmanager
async def lifespan(app):
yield
coord.options.store.close()
app = FastAPI(lifespan=lifespan)
@app.get("/healthz")
def healthz():
with desk.lock:
return {"tasks": len(coord.get_workspace(config["workspace"]).tasks)}
app.mount("/", desk)
uvicorn app:app --workers 1
The desk's pages name their files relative to the page, so the desk works
mounted at any path: app.mount("/review", desk) serves it at /review/,
with POST /review/chap and the read API beside it. An app that needs more
workers runs chap-coordinator serve beside them, and each worker calls it
through HttpCoordinator.
A job queue. Queue workers (Celery, RQ, arq) are processes of their own, so each reaches the server over HTTP. One job opens the review and ends; a later one reads the decision, so no worker waits on a person:
from chap_coordinator.client import HttpCoordinator, Participant
desk = HttpCoordinator("http://localhost:8792/chap")
agent = Participant(desk, "wsp_support", "agent:drafter")
def write_draft(ticket): # the agent's model call
return {"to": ticket["customer"], "body": "Thank you for writing to us."}
def send(reply): # what happens to an approved reply
print("sending", reply)
def draft_reply(ticket): # enqueued for each new ticket
task = agent.call("task.create", kind="draft_reply", assignee=agent.uri, input=ticket,
review_required=True, idempotency_key=f"ticket-{ticket['id']}")
if task["state"] in ("created", "in_progress"):
agent.call("task.complete", task_id=task["task_id"], output=write_draft(ticket))
return task["task_id"]
def send_when_decided(task_id): # run on a schedule; None while the review is open
view = agent.task(task_id)
if view["state"] == "review_requested":
return None
if view["state"] == "completed":
send(view["output"])
return view["state"]
Under "humans" the server joined the agent when it started. Where every
call is signed, every worker gives the participant the same key file, and
the agent joins once with it. The idempotency key lets a retried job find
the task it opened before, and a job that finds its draft already submitted
leaves it. A job run before any person has opened the desk fails at
task.complete with -32011, and the queue runs it again. A rejection that asks for a revision leaves the task
in_progress, and running draft_reply again submits a new draft.
Backups and chain heads. With WAL, the SQLite store's default, copy
the file while the server runs with SQLite's online backup:
sqlite3 data/chap.db ".backup backup.db", or
sqlite3.Connection.backup. The chain head stays in that file, where
whoever runs the server can rewrite it. To show later that an entry
existed, keep the head where they cannot change it: publish the
chain_head that audit.verify_chain returns, or hand the entries to a
transparency service with audit.submit_to_scitt and keep its receipts.
What is implemented
This package implements CHAP Core plus every profile:
| Profile | Methods (per profile spec) |
|---|---|
core/1.0 |
workspace.create, workspace.describe, workspace.set_profiles, participant.join, participant.leave, task.create, task.update, task.complete, audit.read; a task created with review_required completes only on a reviewer decision |
review/1.0 |
review.request, review.acknowledge, decide.approve, decide.reject, decide.override, abstain.declare, escalate.raise |
whisper/1.0 |
whisper.ask, whisper.answer; lapse hook via coord.check_whisper_lapses(workspace_id, now) |
deliberation/1.0 |
deliberate.open, deliberate.comment, deliberate.vote, deliberate.close |
handoff/1.0 |
handoff.propose, handoff.accept, handoff.decline; carries multiple tasks; recipient may be a URI or group: |
control/1.0 |
control.pause, control.resume, control.cancel, control.snapshot, control.rollback, control.supersede, control.set_mode_ceiling; pause/resume take scope: task/participant/workspace |
routing/1.0 |
task.route, review.depth, escalate.auto; each emits a route_decision artefact |
modes/1.0 |
Mode handling at task.create; trial mode forces review_required; control.set_mode_ceiling shared with control/1.0 |
security-signed/1.0 |
participant.rotate_key, participant.revoke_key; top-level sig field verified at dispatch where the workspace advertises the profile or options.require_signatures=True, under the workspace's signature_policy |
audit-scitt/1.0 |
audit.submit_to_scitt, audit.verify_receipt, audit.verify_chain; SCITT statements assembled and passed to a deployment-supplied submitter; local prev-hash chain linkage retained |
identity-oidc/1.0 |
participant.join binding via options.verify_oidc_token; cnf.jwk pinning, step-up auth via enforce_step_up=True |
identity-vc/1.0 |
participant.join binding via options.verify_vc; holder-key pinning |
40 method handlers in total.
The review gate. A task carrying review_required does not complete on
task.complete. The call opens a review, holding the submitted output as the
artefact under review, and only a decide.* reaches completed. task.update
cannot complete such a task either, and answers -32602 naming the route
through. Where no reviewer was named, the set is the human members other than
the completer and the assignee; a workspace with no eligible human refuses the
completion rather than opening a review nobody can decide. Under modes/1.0 a
trial-mode task has review_required set for it.
Architecture
The coordinator is transport-agnostic, persistence-agnostic, and UI-agnostic. It exposes a single entry point:
response = coord.dispatch(envelope)
Where envelope is a JSON-RPC 2.0 request and response is the
JSON-RPC 2.0 response. Bind whichever HTTP, WebSocket, or in-process
transport you like. State is held in memory, and kept in a store when
one is set: see Running it for real.
dispatch holds a lock, so calls from several threads are handled one at
a time. With a store option (SqliteStore, or a store of your own),
each call's changes are written before dispatch returns, and the
listeners hear of an entry once it is written. A call whose write fails is
answered with -32603 and data: {"reason": "store"}, and its workspace
goes back to what the store holds; store_errors="log" answers it as it
was, and the next write carries its change. Before each call on a
workspace the coordinator asks the store how many entries it holds, and
reloads a workspace another instance has written; a write another instance
got to first is answered with -32603 and data: {"reason": "store"}, and
may be sent again
(SPECIFICATION.md §10.3).
chap_coordinator.server binds HTTP with the desk included. A minimal
stdlib HTTP server is at
reference/python/server.py in the parent repo.
Determinism for tests
Set deterministic_ids=True and deterministic_clock=True on
CoordinatorOptions for replayable demos and golden-file tests:
coord = Coordinator(CoordinatorOptions(
deterministic_ids=True,
deterministic_clock=True,
))
Identity binding (identity-oidc/1.0, identity-vc/1.0)
These profiles bind a participant's claimed identity to a verifiable external authority. The coordinator does not implement OIDC or VC verification itself; you supply callbacks:
def verify_oidc(token: str) -> dict | None:
# Validate the token against your IdP; return claims dict or None
# Include "cnf": {"jwk": {...}} to bind a signing key
...
def verify_vc(presentation: dict) -> dict | None:
# Verify the VP; return subject claims dict or None
# Include "cnf_jwk": {...} to bind a holder key
...
coord = Coordinator(CoordinatorOptions(
verify_oidc_token=verify_oidc,
verify_vc=verify_vc,
enforce_step_up=True, # require fresh auth_time for privileged methods
))
If a participant.join envelope includes oidc_token or
vc_presentation parameters, the relevant hook is called and the bound
key is added to the participant's key history. A token with no
cnf.jwk binds the key in the join's jwks whose RFC 7638 thumbprint is
the token's nonce. Where a hook is configured and the workspace
advertises its profile, a human joins with the credential it checks or
is refused (-32403, -32410), and the log records the credential as
its SHA-256 digest, never the credential itself.
Signed envelopes (security-signed/1.0)
To require signatures on every envelope:
coord = Coordinator(CoordinatorOptions(require_signatures=True))
A workspace also requires signatures when it advertises
security-signed/1.0, and cannot stop advertising it once it does. Its
signature_policy, a workspace.create param that falls back to the
signature_policy option, is "all" by default; under "humans" an
unsigned call is taken from a member that is not human, so an agent on the
server's own transport works unsigned, and every person's decision is
still signed.
Each participant registers one or more JWKs at participant.join via
jwks: {keys: [...]}. Senders sign the JCS canonicalisation of the
envelope with the top-level sig field removed, then attach the
signature as a top-level sig: "ed25519:<kid>:<base64>" field. The
Coordinator looks up the verifying key by (from, kid, ts), so
historical envelopes verify across key rotation.
A key held by a browser's authenticator, a P-256 JWK with a webauthn
member naming its rp_id, signs with a WebAuthn assertion whose challenge
is the SHA-256 of those same bytes, tagged
webauthn:<kid>:<authenticatorData>.<clientDataJSON>.<signature>
(profiles/security-signed.md §3).
Both kinds are verified through the cryptography package, the crypto
extra; without it a signed call is refused with -32070 and a message
that names the extra.
A signed request takes effect once. The same signed call sent again, its
sig re-encoded or not, is refused with -32075 and
data.accepted_at_seq, and a copy of a recorded refusal is answered with
that refusal; neither is evaluated again.
Key lifecycle:
participant.rotate_keyis signed with the old key; the Coordinator marksvalid_untilon the old key andvalid_fromon the new one.participant.revoke_keyis an admin operation; subsequent envelopes signed with the revoked key are rejected.
Routing policies (routing/1.0)
A default policy ships out of the box. Override it with operator hooks:
def route(task, candidates):
# Return {"selected": "...", "rationale": {...}}
return {"selected": candidates[0], "rationale": {
"policy_id": "round-robin",
"summary": "first eligible",
}}
coord = Coordinator(CoordinatorOptions(routing_policy=route))
Every call to task.route, review.depth, and escalate.auto
emits a route_decision artefact recording the inputs, the policy
id, and the rationale. task.route also updates the task's
assignee to match the selected URI. The caller must be a workspace
member. The default policy takes the first candidate that is a member
and is not paused; a routing_policy selection that is not a member
is refused with -32510, and one that is paused with -32063.
Audit and SCITT submission (audit-scitt/1.0)
Audit entries are hash-linked when the profile is active.
audit.verify_chain replays the chain locally and confirms
prev_hash continuity. The verdict names the range it covered:
status is verified with ok: true only when every entry was
checked, and not_evaluated with ok: false when part of the log
lies outside the chain, which happens when the profile is added to a
workspace that already has entries. A broken chain is an error. Read
status, or read ok and fail closed.
audit.submit_to_scitt builds a SCITT-shaped signed statement for
each audit entry in the requested range and passes it to a
deployment-supplied submitter:
def submitter(statement):
# Submit to your SCITT transparency service; return the receipt
...
coord = Coordinator(CoordinatorOptions(scitt_submitter=submitter))
Without a submitter configured, audit.submit_to_scitt returns the
statements so the caller can submit out-of-band.
Testing
pip install -e ".[dev]"
pytest
The suite covers the core library, the desk server, the client and the command, the MCP and A2A transports, and the wrap helpers.
Spec fidelity
This implementation was reviewed against every profile spec under
profiles/ and aligned with the documented field names, error codes,
and response shapes. The full audit notes are in the parent repo's
CHANGELOG.md, with the 0.2.1 entry covering
the original Python implementation and 0.2.3 / 0.2.4 covering the
MCP and A2A transport additions.
Licence
Apache 2.0. This package ships the licence in its own LICENSE file.
Specification
Tracks the spec at github.com/BrightbeamAI/chap/SPECIFICATION.md.
Metadata
Release files for chap-coordinator 0.3.5
For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.
Source distribution (sdist)
| File | Size | Uploaded | Provenance | Actions |
|---|---|---|---|---|
| chap_coordinator-0.3.5.tar.gz | 412.0 kB | Without provenance | Details for chap_coordinator-0.3.5.tar.gz |
Built distribution (wheel)
| File | Interpreter | ABI | Platform | Actions Reset |
|---|---|---|---|---|
| chap_coordinator-0.3.5-py3-none-any.whl | Python 3 | none | any | Details for chap_coordinator-0.3.5-py3-none-any.whl |
Total release size: 679.3 kB
Release files / chap_coordinator-0.3.5.tar.gz
| Download URL | chap_coordinator-0.3.5.tar.gz |
|---|---|
| Size | 412.0 kB |
| Tags | Source |
|
SHA-256 checksum How to use checksums |
a439f8e27d7c77efcc083fff2041a7546e578c3e0a155d1e42791b4c108713b1
|
|
BLAKE2b-256 checksum How to use checksums |
85ce17864161d2b88d62ef7e84f8dc8f92bd792692db700d13aba20b1c801405
|
| Upload date | |
|
Uploaded using Trusted Publishing? What is trusted publishing? |
No |
| Uploaded via |
twine/7.0.0 CPython/3.11.15
|
Release files / chap_coordinator-0.3.5-py3-none-any.whl
| Download URL | chap_coordinator-0.3.5-py3-none-any.whl |
|---|---|
| Size | 267.3 kB |
| Tags | Python 3 |
|
SHA-256 checksum How to use checksums |
59ad6af062d1bfec6017b782ab25dc6124cc9586a0246fc440d3db09ffb9c6e6
|
|
BLAKE2b-256 checksum How to use checksums |
eab1549ba99c9743b9c2c844ab3c885656b0b2b615242412f3e525a6a3dfbf39
|
| Upload date | |
|
Uploaded using Trusted Publishing? What is trusted publishing? |
No |
| Uploaded via |
twine/7.0.0 CPython/3.11.15
|
Security for chap-coordinator 0.3.5
Provenance
Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.
No provenance found
None of the files in this release were uploaded with provenance metadata.
A note on package security
PyPI is a repository for distributing packages, not a service for auditing them. While third-party security researchers and our staff do their best to detect and remove malicious packages, PyPI cannot guarantee the quality, security or suitability of any given package.
To learn more about protecting yourself from malicious actors, visit our package security documentation.