Skip to content

feat: send email content from code with posthog.emails.send - #2

Closed
Silthus wants to merge 5 commits into
mainfrom
feat/emails-code-form
Closed

Silthus wants to merge 5 commits into
mainfrom
feat/emails-code-form

Conversation

@Silthus

@Silthus Silthus commented Oct 23, 2026 •

Copy link
Copy Markdown
Owner

💡 Motivation and Context

A Python backend that renders its own email, or keeps its email templates in its code, can't send through PostHog today. emails.send takes only a template made in PostHog, by its ID. This PR adds the code form to emails.send, beside the template form that PostHog#1093 shipped in 7.81.0. The SDK contract is PostHog/sdk-specs openspec/specs/emails/spec.md, plus the draft change add-emails-code-form for the code form.

# Rendered content: sent as is, never stored as a template
posthog.emails.send(
    to="jane@example.com",
    distinct_id="user_123",
    template_key="password-reset",
    subject="Reset your password",
    html=rendered_html,
    from_="Acme <security@example.com>",
)

# Local template: the code is the source of truth, PostHog fills in the variables
posthog.emails.send(
    to="jane@example.com",
    distinct_id="user_123",
    template_key="welcome",
    subject="Welcome, {{ variables.name }}",
    html=welcome_html,
    template_data={"name": "Jane"},
)

Part of map Silthus/posthog#461. Rebased onto main after PostHog#1093 merged, so this diff holds only the code form. It absorbs what the spec allows from the closed #3.

Impact

Pays into Grow Workflows through email sends from code: the spec's Code-sending orgs metric, not measured yet (send attribution has to count posthog-python/ as an SDK). In scope: Messaging, email. Expected move: small, up. Python callers get the same code form as posthog-node. Run cost: n/a.

Merge Danger

Caution

🔴 Merge risk: high · one-way door once released (merge-risk rubric)

  • A release makes the keyword names (template_key, from_, reply_to, capture_engagement, cc, bcc, headers, tags, attachments, max_retries), the migrated_from client option and the EmailTag and EmailAttachment shapes a public contract.
  • A local template sends a real email after an automatic upload. A wrong 409 branch could upload or send twice. Tests pin one upload at most per send and the same idempotency key on the second send.
  • The code form needs the server's code arm of send/email/ with the flat body, which is not on PostHog master yet. Release this after it.

Changes

Kind Files Lines (against main)
Production 4 +623 −85
Tests 1 +509 −1
Snapshot and changeset 2 +42 −6
  • Two forms, one send. TemplateEmailArgs and CodeEmailArgs type the keyword arguments with Unpack, one @overload each, on Emails and AsyncEmails. A send with both forms, neither form, or a field of the other form raises TypeError before any request.
  • Rendered content (no template_data): a flat body to POST /messaging/send/email/: template_key, subject, html, text, from, reply_to, capture_engagement, to, distinct_id. It never uploads.
  • Local template (with template_data): the client hashes subject, html and text with the server's content_hash v1 and sends template: {key, hash}, message_data and identifiers.distinct_id. On 409 template_outdated it uploads by key (PUT /messaging_templates/by_key/{key}/, if_not_superseded, if_code_managed) and sends once more with the same body and Idempotency-Key. A refused upload (409 template_edited_in_posthog) raises a validation_error and sends nothing. A local template without html raises ValueError before any request, because PostHog stores it and a stored template needs HTML.
  • None counts as left out for an optional code-form field (html, text, from_, reply_to, cc, bcc, headers, tags, attachments, capture_engagement, template_data), as it already did for distinct_id. A wrapper can pass its own optional values through.
  • Engagement capture belongs to the code form. capture_engagement is always sent there, True unless the call passes False. The template form refuses it with TypeError.
  • Copies, headers, tags and attachments on the code form only: cc and bcc as lists, headers, tags, and attachments with bytes-like content Base64-encoded once, before the retry loop.
  • From the closed feat: align email sends with the shared SDK contract #3: migrated_from on the client, sent as X-PostHog-Migrated-From on every email request and refused at construction unless it is visible ASCII; and max_retries on a code send, as the template form has it.
  • Kept as main has them: a Retry-After over 30 s raises at once, replayed and warnings stay on the result, and argument checks raise TypeError or ValueError.

💚 How did you test it?

Test seams: Emails.send and AsyncEmails.send on a real client with the HTTP transport faked, as PostHog#1093's tests do (FakeAdapter, httpx.MockTransport). The tests assert the requests the client makes and what it returns or raises. The type seam is .github/scripts/check_strict_types.sh under pyright strict.

  • What the new tests pin: each code-form body with a flat distinct_id and capture_engagement; the hash against the server's v1 test vectors; upload then resend with one key, sync and async; at most one upload per send, with a refused upload named validation_error; no upload for rendered content; copies, headers, tags and attachments on both sends of a local template and never on the upload; Base64 once across retries; each TypeError and ValueError refusal, including a local template without html; None for every optional code-form field sent as left out; capture_engagement refused on the template form; migrated_from on send and get, and refused when blank or not text; max_retries on a code send.
  • Mutation check: dropping the migrated_from header, the capture default, the template-form capture refusal or the code send's max_retries each fails a test.
  • Lane gate on e5fdedf: ruff format --check, ruff check, mypy | mypy-baseline filter, the strict types script, the public API snapshot, and the full pytest suite (5936 passed).
  • Shadow diff, main (dca2207) against 1fef822: 22 invented inputs through Emails.send with the transport faked, recording every request and result. The 12 template-form cases are identical. The 10 that differ are all code-form sends, which main refuses and this PR sends as described above. e5fdedf only drops two comments.
  • CI: GitHub Actions don't run on this fork, so the PR shows no checks (recorded as a ci gap); the lane gate above runs the same steps.

Proofs owed:

  • Live run: gap. Lane dj3 runs it in this round with this head against the restacked server code send. A new local template also needs a verified default sender in the project: the server's upload answers 400 sender_unavailable without one, even when the send passes from_.
  • Cross-version (new SDK, older server): gap. No deployed server has the code arm of send/email/. An older server answers 400, which raises validation_error.
  • Prod shape: gap until read-only production access is available.

📝 Checklist

  • All commits are signed (see Commit signing)
  • I reviewed the submitted code.
  • I added tests to verify the changes.
  • I updated the docs if needed.
  • No breaking change or entry added to the changelog.

If releasing new changes

  • Ran sampo add to generate a changeset file

🤖 Agent context

Autonomy: Human-driven (agent-assisted)

Decisions

Question Answer Who Where
Base for the code form Stack on PostHog#1093, retarget once it merges (done) 👤 Human map conductor
Add cc, bcc, headers, tags, attachments here yes, in this PR 👤 Human map conductor
Python name for from from_ 🤖 Agent this PR
Upload name the template_key 🤖 Agent this PR
Where distinct_id goes on a code send Flat at the top level, like PostHog/posthog#126287; the template form and the local template keep identifiers.distinct_id 🤖 Agent pending approval
Argument errors Native TypeError and ValueError, as 7.81.0 has them; the typed validation error of #3 is not ported 🤖 Agent pending approval
What to take from #3 migrated_from, max_retries on a code send, and the capture default on the code form only; not its Retry-After clamp or the removal of replayed, which the spec contradicts 🤖 Agent pending approval
None for an optional code-form field Counts as left out, as it does for distinct_id and in posthog-node; the alternative was to document that the code form never takes None 🤖 Agent pending approval
What a local template needs html, checked before any request, since PostHog can't store a template without it 🤖 Agent pending approval
The name of a refused template upload 409 template_edited_in_posthog is validation_error, as contract #120921 says 🤖 Agent pending approval

No open questions.

Follow-ups:

  • The diff is above the ~400 production lines a single review reads well. It stays one PR, because the code form, the local template and the code fields share one send and its checks; split it if a reviewer asks.
  • An explicit empty reply_to, cc or bcc list is sent as [], as posthog-node does. An older server branch refused reply_to: [] with validation_error on reply_to; the live run checks the restacked server.

Involvement: carries the earlier #2 review rounds and design pass. This rebuild: one full-scope GPT-6.1 Sol read at b80b8ab80 (2 findings: 1 fixed in 3f2428df8, 1 rejected because the flat distinct_id is the round's decision); a QA swarm at 3f2428df8 with a full two-family panel (GPT-6.1 Sol on six lenses, Claude Opus 5.5 fresh eyes: 3 fixed) and a narrow round on the fixes (comments dropped); shadow diff captured; live run owed to lane dj3.

🤖 Generated with Claude Code

A send with template_key carries subject and html, text or both, flat at
the top of the body with distinct_id. With template_data, the content is a
local template sent by key and content hash, uploaded when PostHog answers
template_outdated. A code send also takes from_, reply_to, cc, bcc,
headers, tags, attachments and max_retries, and captures engagement unless
it passes capture_engagement=False. A template_id send doesn't take
capture_engagement. migrated_from on the client or on Emails goes out as
X-PostHog-Migrated-From on every email request.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
@Silthus
Silthus changed the base branch from base/posthog-transactional-emails to main October 31, 2026 08:25
@Silthus
Silthus force-pushed the feat/emails-code-form branch from a6bc0ac to b80b8ab Compare October 31, 2026 08:25
Silthus and others added 4 commits October 31, 2026 08:37
A 409 template_edited_in_posthog from a local-template upload is a
permanent refusal, not a concurrent request, so it carries the name
validation_error like template_outdated.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
PostHog stores a local template on upload, and its upload route needs an
HTML body. A text-only local template got 409 template_outdated, then a
400 on the upload, on every send. The client now raises ValueError before
any request, as posthog-node refuses it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A wrapper that forwards its own optional values passed text=None or
template_data=None, and the code form raised TypeError, while
distinct_id=None and the template form's template_data=None already
counted as left out. The code form's optional fields now do too, and
their types say so.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The docstring names None as a left-out field, and the error names the html rule.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
@Silthus

Silthus commented Nov 2, 2026

Copy link
Copy Markdown
Owner Author

Moved to PostHog#1171.

@Silthus Silthus closed this Nov 2, 2026
Silthus added a commit to PostHog/posthog-python that referenced this pull request Nov 5, 2026
* feat: send email content from code with posthog.emails.send

Squash of Silthus#2 at e5fdedf, re-signed for required signatures.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* feat: cut emails.send to the template and rendered code forms

Parks the local-template form (template_data on a code send, the
content hash, the upload by key and its retry) and the cc, bcc,
headers, tags and attachments fields, to match posthog-node. A code
send now takes rendered html and/or text only.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* test(emails): cover the async code-form send and migrated_from

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(emails): leave reply_to out when the list is empty

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(emails): name the transactional_email scopes for sends and status reads

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* docs(emails): rewrite the release note for transactional email

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Silthus added a commit to PostHog/posthog-python that referenced this pull request Nov 13, 2026
* feat: send email content from code with posthog.emails.send

Squash of Silthus#2 at e5fdedf, re-signed for required signatures.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* feat: cut emails.send to the template and rendered code forms

Parks the local-template form (template_data on a code send, the
content hash, the upload by key and its retry) and the cc, bcc,
headers, tags and attachments fields, to match posthog-node. A code
send now takes rendered html and/or text only.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* test(emails): cover the async code-form send and migrated_from

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* feat: send cc, bcc and attachments with emails.send

A code send takes cc and bcc as one address or a list, and attachments
as files with bytes or Base64 content. The client encodes bytes once,
before any retry. A file it can't send raises EmailError with the code
invalid_attachment and a field such as attachments__0__content, and
the error never repeats the file's content. A template_id send refuses
all three fields before any request.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix: refuse every unknown attachment key, a None key included

next(..., None) used None as its no-match value, so a None key hid the
unknown keys after it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* test: cover a None attachment key before an unknown one

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* docs: describe an older server's refusal without its error code

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(emails): leave reply_to out when the list is empty

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(emails): refuse an attachment string that is not base64

A text file passed as a str was sent unchecked as if it were Base64.
The client now raises invalid_attachment before any request and hints
to pass the file's bytes instead.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* chore(emails): name the refused-send test after what it guards

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* chore(emails): drop a comment the name and test already state

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* chore(emails): give cc, bcc and attachments their own changeset

The base PR owns emails-code-form.md, so this PR no longer edits it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(emails): refuse an attachment with an empty filename

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* feat(emails): upload attachments by hash, then send their references

A code send hashes each file, asks PostHog which files it lacks, PUTs
those straight to PostHog's file storage with the returned headers and
without the secret key, then sends the email naming each file by its
SHA-256. The client checks 10 files and the 40 MB message estimate before
any request. A failed upload sends no email and surfaces the storage's
answer.

Part of PostHog/michaelr-context#81.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(emails): send the storage upload exactly as signed

An injected client's defaults leaked into the presigned PUT: httpx
params replaced the URL's signature query, a requests session appended
its params, and default headers rode along. The upload is now a
standalone request with only the returned URL and headers, sent through
the same transport and retries.

Part of PostHog/michaelr-context#81.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(emails): keep the environment's TLS settings and the signed URL private on uploads

The standalone storage PUT skipped requests' environment merge, so a
custom CA bundle or proxy applied to sends but not to uploads. It now
merges the environment's transport settings, without session headers or
auth. A storage network error is re-raised without its cause, so the
presigned URL never reaches a traceback.

Part of PostHog/michaelr-context#81.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(emails): upload shared bytes once and retry a storage's passing faults

- The client counts attachments before it reads any file.
- Bytes that two attachments share go in the upload request once.
- The upload parser returns only the uploads still to make, each with
  its attachment index.
- A storage 500, 502 or 504 is retried like 503.
- A refused upload no longer takes the names of PostHog's API statuses.
- An unreachable storage raises network_error naming the attachment.

PostHog/michaelr-context#81

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(emails): retry a storage's 429 and name what the comments said

The previous commit stopped retrying a storage 429, which the general
rate-limit branch had retried. Storage 429 is retried again and named
rate_limit_exceeded. Names replace the comments that commit added.

PostHog/michaelr-context#81

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(emails): name attachments when PostHog has no upload route

A PostHog version without the upload route answered 404, and the send
raised a bare not_found with no field. The docs promise that an older
PostHog's refusal names the field. It now raises not_found with field
attachments, a reason and a fix, and sends nothing. Tests now cover the
names a storage fault gets once its retries run out.

PostHog/michaelr-context#81

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(emails): size attachments before copying them

The client copied and hashed every file before it checked the message
size. Ten views of one large buffer could exhaust memory before
message_too_large. Each file is now sized from its buffer or its Base64
length, the estimate is checked, and only then are files read and
hashed.

PostHog/michaelr-context#81

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(emails): size Base64 content by its data, not its padding

Extra trailing padding decodes, so it must not shrink the estimate.

Ticket: PostHog/michaelr-context#81

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* test(emails): pin each body's count in the size estimate

The server counts html and text each like a file: UTF-8 bytes, Base64 with
line breaks. Pin both bodies, their UTF-8 length and per-body rounding.

Ticket: PostHog/michaelr-context#81

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(emails): report PostHog's own answer to an upload-route 404

A 404 can mean a PostHog without the upload route or sending from code
off for the project, so keep the server's reason on attachments instead
of naming one cause.

Ticket: PostHog/michaelr-context#81

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(emails): say which Base64 the SDK takes and where a refused upload goes wrong

A wrapped, unpadded or URL-safe string now learns it needs one padded line
from base64.b64encode. A storage refusal points at a fresh send or a proxy,
not at bytes the caller can't change.

Ticket: PostHog/michaelr-context#81

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(emails): count the subject in the message estimate like the server

The server now adds 75 bytes per 42 UTF-8 bytes of subject, so a long
subject beside a near-limit file must be refused before the upload.

Ticket: PostHog/michaelr-context#81

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* test(emails): check uploads against their signed checksum like real storage

The fake storage now refuses a PUT whose bytes don't match the signed
checksum and length, and each upload slot is signed for its own file.
A new test asserts every file PostHog lacks lands in storage under its
own hash.

Refs PostHog/michaelr-context#81

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(emails): size padded Base64 without a copy and never follow a storage redirect

Sizing a Base64 string no longer strips its padding into a new string,
so refusing an oversized file allocates nothing the size of the file.
The async upload passes follow_redirects=False, so an injected client
that follows redirects can't turn a storage 302 into a GET that looks
like a stored file. The subject's share of the size limit is now pinned
through send instead of through a private helper.

Refs PostHog/michaelr-context#81

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* test(emails): prove the async upload refuses a storage redirect over real sockets

The redirect test now runs against a local HTTP server that answers the
upload route, redirects the PUT and serves a login page, instead of a
scripted transport. It asserts upload_failed and that the login page and
the send route were never reached.

Refs PostHog/michaelr-context#81

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* test(emails): test attachments against fakes that behave like PostHog and S3

The attachment tests now run against one in-memory PostHog with its file
storage. The upload and send routes need the secret key and refuse
fields outside their schema. Storage refuses a presigned PUT the way S3
does: an added query parameter, an Authorization header, an expired URL
or bytes that don't match the signed checksum. A send delivers an email
with the stored bytes and replays a repeated idempotency key. Tests
assert the delivered email, the bucket and the EmailError, not request
shapes. The CA test runs a real TLS handshake against a local storage
server with a certificate made in the test.

Refs PostHog/michaelr-context#81

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(emails): count the text PostHog derives and upload only over https

Without text, PostHog derives the plain text from the HTML and counts it
in the message size, so an HTML-only email near the limit uploaded its
files and was then refused. The client now counts the HTML twice, since
the derived text is never longer.

A plain HTTP upload URL from misconfigured storage would carry the file
and its signed URL unencrypted. The client now stops before any upload
with api_error naming the attachment, unless the client's host is plain
HTTP too, as in local development.

The fake PostHog now checks each route's method and records the content
type storage keeps. Tests assert stored files, not storage keys, and the
tests that only exercised the fake are gone.

Refs PostHog/michaelr-context#81

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(emails): name the caller's attachment in upload refusals and read storage answers whole

An upload-route refusal named the wire field (files, files__1__size),
which the caller never passed. It now names attachments, or the first
attachment holding that file. A session with stream=True left a storage
answer unread until after the upload, so a cut-off answer lost its
attachment; the storage request now always reads the answer at once.

The cc and bcc tests now assert the recipients of the delivered email,
and the template-content tests are back to main's shape.

Refs PostHog/michaelr-context#81

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* test(emails): serve the test's TLS storage at TLS 1.2 or later

CodeQL flags the local HTTPS storage server's SSLContext for allowing
TLS 1.0 and 1.1. Pin the minimum version.

PostHog/michaelr-context#81

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* test(emails): assert outcomes, not request traces, in the real-socket upload tests

The redirect and cut-short storage tests compared the server's request
list, which held the storage object path. They now assert the caller's
error, that no email was sent, and that the redirect was never followed.

PostHog/michaelr-context#81

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* test(emails): run the field refusal and size tests against the PostHog fake

The cc refusal test now sends to a PostHog that doesn't take cc and
asserts the caller's error and that nothing was delivered, instead of
counting requests on a canned transport. The two oversized-email tests
assert that nothing was stored or delivered.

PostHog/michaelr-context#81

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* test(emails): prove an upload never follows storage to another server

A client that follows a 307 or 308 on the PUT sends the file again to
the new URL, even over plain HTTP, and reports success. Both upload paths
already refuse redirects. New sync and async tests have the storage
answer 307 to a plain-HTTP server and assert upload_failed on the
attachment without either URL, that the other server received nothing,
and that no email was sent. Without the fix, requests and an httpx client
with follow_redirects deliver the file there. The docs and changeset say
the client never follows a redirect.

PostHog/michaelr-context#81

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* test(emails): name the lost-reply retry test for what it proves

The test shows a send retried after a lost reply replays with its
idempotency key. It can't observe whether uploads are asked for again,
so the name no longer promises that.

PostHog/michaelr-context#81

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(emails): refuse extra Base64 padding before copying the string

The size check walked back over any number of trailing "=", so a short
Base64 string followed by tens of millions of "=" passed as a few bytes,
and b64decode then copied and scanned all of it, blocking the async
client's event loop. Standard Base64 has at most two "=", so a third
now raises invalid_attachment with the Base64 advice during that walk,
before any copy. The extra-padding size case is refused this way now.

PostHog/michaelr-context#81

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* feat(emails): name a failed attachment upload attachment_upload_failed

Go, JS, Ruby and PHP raise attachment_upload_failed for a refused or
redirected upload, and the docs list one code for every SDK. The code
was upload_failed only in this unreleased change, so it takes the shared
name in the error, the tests, the docstrings and the changeset.

PostHog/michaelr-context#81

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* test(emails): follow a storage 307 to another server over real sockets

The two cross-server redirect tests now run against a local PostHog whose
storage answers the upload with a 307 to a second local server. They assert
the second server receives nothing and no email is sent, instead of
injecting the redirect through mocked transports.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant