laidline-pipecat 1.0.0__tar.gz

laidline_pipecat-1.0.0/.gitignore

@@ -0,0 +1,2 @@
+__pycache__/
+*.pyc

laidline_pipecat-1.0.0/LICENSE

@@ -0,0 +1,341 @@
+Laidline Source-Available Licence
+
+Copyright (c) 2026 Harrison Bootes, licensed exclusively to Laidline LLC.
+
+Acceptance
+
+By using the Software, You agree to all of the terms and conditions below.
+
+You are not required to accept these terms in order to receive a copy of the
+Software, and Detection and Verification applies to everyone, whether or not
+they accept these terms. However, nothing other than these terms grants You
+permission to use, copy, distribute, make available, or prepare derivative works
+of the Software beyond what the law allows without the Licensor's permission,
+and You indicate Your acceptance of these terms by doing any of those things.
+
+Copyright Licence
+
+The Licensor grants You a non-exclusive, worldwide, non-sublicensable,
+non-transferable licence to use, copy, distribute, make available, and prepare
+derivative works of the Software, in each case subject to the limitations and
+conditions below. Within the Allowance the licence is royalty-free. The Software
+is licensed, not sold.
+
+Detection and Verification
+
+Anyone may use the Software to detect, decode and verify marks, signatures,
+certificates and evidence produced with the Software, and to run the
+verification script it places in evidence exports, free of charge, for
+themselves or for others. This right applies in every licence state, whether or
+not the user has registered, is within the Allowance or holds a Laidline
+Licence, and it does not end when any licence under these terms ends. Nothing in
+these terms, including the limitations below, may be read as restricting it.
+
+This right does not extend to embedding a watermark in content or attaching a
+signed manifest to content; those acts are Marking and remain subject to the
+Marking Allowance and the Limitations. A service that offers detection and
+verification together with Marking is within this right only as to the detection
+and verification.
+
+Marking Allowance
+
+You may use the Software to Mark content without charge up to the Allowance. The
+Allowance is the number of Credits per calendar month (UTC) that the Licensor
+publishes for that month. It is one Allowance per month for You together with
+every member of Your Company that uses the Software, not one Allowance for each
+evidence log, installation or entity: the Credits of all Marking by those users,
+in every evidence log, count towards that one Allowance. The Software counts
+Credits per evidence log; that is a technical limit, not a grant of a separate
+Allowance for each log. Credits are computed, from the facts the Software
+records in Your evidence log, by the weight table in force for that month, which
+the Licensor signs and identifies by version. The weight table in force for a
+month is the newest signed weight table the Licensor has published whose
+effective_from date is at or before the start of that month, whether or not Your
+installation holds it; the Software applies the newest table Your installation
+holds, so its figures can differ from the Credits under these terms until Your
+installation receives the published table. The Licensor may change the Allowance
+or the weights only (a) to add a medium or Marking method that the previous
+table lacks, (b) to reflect a change in its measured cost of serving a medium,
+stated in the notice, or (c) to correct an error that the notice identifies by
+row, with the measurement that shows it. It makes a change by publishing a new
+signed weight table in a release and on its website, with a notice stating the
+reason. A table that raises any weight or lowers the Allowance applies only from
+a month that begins at least 30 days after its publication, and the Licensor
+also emails the notice to registered users when it publishes the table. A table
+that raises no weight and does not lower the Allowance applies from the first
+day of the month after its publication, without that wait. A change never
+applies to a month already begun or past. If You do not accept a change, You may
+stop Marking at no cost.
+
+Marking above the Allowance in a calendar month is licensed only on one
+condition, which limits the scope of that permission and is not a promise: that
+before 23:59:59 UTC on the last day of the following calendar month the Licensor
+has issued to You or Your Company a Laidline Licence other than a Legal-Process
+Licence whose coverage includes that month. The condition applies separately to
+each calendar month. If it is met, that Marking is licensed from the start. If
+it is not met, Marking in that month is unlicensed from the first Credit above
+the Allowance, and the Licensor has the remedies available for unlicensed Use;
+that Marking can become licensed later only by the late issue of a Laidline
+Licence under Termination (a). The condition does not by itself end Your other
+licences; a notice under Termination governs when they end. Where a Laidline
+Licence already applies to the month, Marking above its grant is settled as its
+Customer Agreement provides.
+
+Above the Allowance the Software behaves as follows, by design and not as a
+failure. Every mark is still watermarked, signed, logged, checkpointed and
+timestamped exactly as before, and mark and proxy responses do not change.
+Unless a paid Laidline Licence is current or in its grace period, new marks
+carry the shared pool key and a trial issuer number instead of a private key and
+a registered issuer number. Without a Laidline Licence that unlocks the month,
+an evidence export still produces the complete signed bundle, but the compliance
+paperwork (the filled-in compliance texts, the licence clause and the packaged
+robustness and phantom figures) is withheld and the bundle's summary opens with
+an unlicensed-use notice. In every case the raw evidence log, checkpoints and
+certificates stay on Your systems, readable and copyable with any tool; the
+Software does not delete, encrypt or lock them.
+
+Limitations
+
+You may not provide the Software to third parties as a hosted or managed
+service, where the service provides users with access to any substantial set of
+the features or functionality of the Software.
+
+You may not use the Software, or any derivative work of it, for a Competing Use.
+
+Using the Software to Mark, sign and record the outputs of Your own products and
+services, including outputs You deliver to Your customers, is neither a hosted
+or managed service nor a Competing Use.
+
+Marking, signing or recording the outputs of third parties' own generators as a
+service to those third parties is a Competing Use unless a Laidline Licence that
+includes the tenant-reports feature applies. You may let a contractor use the
+Software on Your behalf, for Your own outputs; You remain responsible for its
+compliance.
+
+You may not move, change, disable, or circumvent the Licence Key Functionality
+in the Software, and You may not remove or obscure any functionality in the
+Software that is protected by the licence key. The Licence Key Functionality
+includes the Meter, the meter block in evidence entries, the Licence-State
+Surfaces and the Payload-Key Switch. You may not re-enable by other means any
+functionality that the licence key protects. Any such change ends Your Licences
+under Termination. This paragraph does not restrict detection and verification,
+writing Your own compliance documents, reading, copying, verifying or exporting
+Your own records, or correcting an error that stops the Software working as
+documented, to the extent the law gives You that right and only as far as
+necessary to correct it.
+
+You may have rights under the law that these terms cannot limit, including the
+rights to make a back-up copy of the Software, to observe, study and test its
+functioning, and to decompile it for interoperability to the extent the law
+allows. These terms do not limit them.
+
+You may not alter, remove, or obscure any licensing, copyright, or other notices
+of the Licensor in the Software. Any use of the Licensor's Trademarks is subject
+to applicable law.
+
+Benchmarks
+
+If You are a Competitor, You may not disclose to any third party any benchmark,
+comparison or performance data about the Software without the Licensor's prior
+written permission.
+
+If You are not a Competitor, You may benchmark the Software, and You may publish
+or otherwise disclose the results only if (a) the disclosure names the Software
+version, the configuration, the decoder mode, the data and the published run of
+the benchmark harness used, so that the result can be replicated, and (b) You
+grant the Licensor, to the extent You are entitled to grant it, the right to
+benchmark Your products and services and to publish the results on the same
+terms, irrespective of any restriction on benchmarks in the terms of Your
+products and services. Disclosing results grants that right.
+
+Nothing in this section restricts acts the law allows despite a contrary term,
+or disclosure to a court or public authority. The first paragraph does not cover
+testing by public authorities, research institutions or independent experts not
+paid by a Competitor.
+
+Patents
+
+The Licensor grants You a licence, under any patent claims the Licensor can
+license, or becomes able to license, to make, have made, use, sell, offer for
+sale, import and have imported the Software, in each case subject to the
+limitations and conditions in this licence. This licence does not cover any
+patent claims that You cause to be infringed by modifications or additions to
+the Software. If You or Your Company make any written claim that the Software
+infringes or contributes to infringement of any patent, Your patent licence for
+the Software granted under these terms ends immediately. If Your Company makes
+such a claim, Your patent licence ends immediately for work on behalf of Your
+Company.
+
+Notices
+
+You must ensure that anyone who gets a copy of any part of the Software from You
+also gets a copy of these terms.
+
+If You modify the Software, You must include in any modified copies of the
+Software prominent notices stating that You have modified the Software.
+
+Third-party components distributed with the Software keep their own licences,
+listed in docs/licences.md; these terms do not apply to them.
+
+Your Records
+
+As between You and the Licensor, the evidence logs, checkpoints and
+certificates, the signing and payload keys You generate, and the media You
+create or process with the Software are Yours. The Software does not send them
+to the Licensor, and these terms give the Licensor no right to them.
+Registration and the usage report, if You use them, send only what the
+Software's documentation lists, which includes no media, evidence entries or
+private keys.
+
+Nothing in these terms restricts You from reading, copying, verifying or
+exporting Your own raw evidence log, checkpoints and certificates, with the
+Software or any other tool, during or after Your Licences. The compliance
+paperwork that the Software withholds above the Allowance is text and figures
+written by the Licensor, into which the Software merges facts from Your own
+evidence log; those facts stay in Your log, readable and copyable, and
+withholding the paperwork withholds none of Your data.
+
+Your records are available to You in every licence state for any legal or
+regulatory proceeding. If You receive a lawful order for them, the Licensor's
+published legal-process policy describes how to obtain, free and on presentation
+of the order, a Legal-Process Licence unlocking the compliance paperwork for the
+months demanded.
+
+Issuer Numbers
+
+Trial issuer numbers, which the Software draws at random, are not registered
+with the Licensor, carry no claim about who made a mark, and may be held by more
+than one user at the same time. Registered issuer numbers are allocated only
+under a Customer Agreement.
+
+Compliance Texts
+
+The compliance texts that the Software places in evidence exports are templates
+written by the Licensor. They are not legal advice and do not establish that You
+comply with any law. You remain the provider responsible for Your own
+compliance, including any duty to mark content, disclose it or keep records.
+
+No Other Rights
+
+These terms do not imply any licences other than those expressly granted in
+these terms.
+
+Termination
+
+Use of the Software in violation of these terms is not licensed. Your Licences
+end only after You receive a written notice of the violation from the Licensor,
+as follows.
+
+(a) A notice about Marking above the Allowance names each calendar month
+concerned and the Credits above the Allowance in it. Your Licences end at
+23:59:59 UTC on the 30th day after You receive the notice, unless by then the
+Licensor has issued to You or Your Company a Laidline Licence other than a
+Legal-Process Licence whose coverage includes every month the notice names. In
+that case nothing ends, and the Marking in those months is licensed from the
+start.
+
+(b) For any other violation, Your Licences end at 23:59:59 UTC on the 30th day
+after You receive the notice, unless by then You have ceased the violation and,
+where the notice asks, confirmed in writing that You have done so.
+
+You receive a notice when it reaches the email address of Your registration, if
+You have registered, or otherwise any address through which You offer the
+Software or Marked content to the public. A notice sent by email is treated as
+received on the next business day after it is sent, unless it bounces.
+
+Termination never affects the right under Detection and Verification or Your
+rights under Your Records.
+
+No Liability
+
+AS FAR AS THE LAW ALLOWS, THE SOFTWARE COMES "AS IS" AND "WITH ALL FAULTS",
+WITHOUT ANY WARRANTY OR CONDITION, EXPRESS OR IMPLIED. THE LICENSOR DISCLAIMS
+ALL IMPLIED WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, ANY
+IMPLIED WARRANTY OF FITNESS FOR A PARTICULAR PURPOSE AND ANY IMPLIED WARRANTY OF
+TITLE OR NON-INFRINGEMENT. THE LICENSOR WILL NOT BE LIABLE TO YOU FOR ANY
+DAMAGES ARISING OUT OF THESE TERMS OR THE USE OR NATURE OF THE SOFTWARE, UNDER
+ANY KIND OF LEGAL CLAIM.
+
+NOTHING IN THESE TERMS EXCLUDES OR LIMITS LIABILITY FOR FRAUD, FRAUDULENT
+MISREPRESENTATION OR FRAUDULENT CONCEALMENT, FOR INTENTIONAL ACTS, WILFUL
+MISCONDUCT OR GROSS NEGLIGENCE, FOR INJURY TO LIFE, BODY OR HEALTH TO THE EXTENT
+THE LAW DOES NOT ALLOW ITS EXCLUSION, OR FOR ANY OTHER LIABILITY THAT THE LAW
+DOES NOT ALLOW TO BE EXCLUDED OR LIMITED. NOTHING IN THESE TERMS LIMITS ANY
+RIGHT THAT CANNOT BE LIMITED UNDER APPLICABLE LAW, INCLUDING ANY RIGHT UNDER THE
+FLORIDA DECEPTIVE AND UNFAIR TRADE PRACTICES ACT.
+
+Governing Law
+
+These terms, and any dispute or claim arising out of or in connection with them
+or the Software (including non-contractual disputes or claims), are governed by
+the laws of the State of Florida, United States of America, without regard to
+its conflict-of-laws rules, and the United Nations Convention on Contracts for
+the International Sale of Goods (1980) does not apply. The state and federal
+courts located in Florida, and within Florida the courts of the county of
+Laidline's principal office, have exclusive jurisdiction over any such dispute
+or claim, as far as the law allows the parties to agree on it. If You are a
+consumer, nothing in this clause limits Your right to bring proceedings in the
+courts of the place where You are domiciled or habitually resident, or in the
+courts located in Florida, and the Licensor may bring proceedings against You
+only in the former. This clause also does not deprive You of the protection of
+any provision of the law of Your habitual residence (or, for a business,
+establishment) that cannot be excluded by agreement.
+
+Definitions
+
+The Licensor (also called Laidline) is Laidline LLC, a Florida limited liability
+company, which holds an exclusive licence of the copyright in the Software from
+its author, with the right to grant licences, and the Software is the software
+the Licensor makes available under these terms, including any portion of it.
+
+You refers to the individual or entity agreeing to these terms.
+
+Your Company is any legal entity, sole proprietorship, or other kind of
+organization that You work for, plus all organizations that have Control over,
+are under the Control of, or are under common Control with that organization.
+Control means ownership of substantially all the assets of an entity, or the
+power to direct its management and policies by vote, contract, or otherwise.
+Control can be direct or indirect.
+
+Your Licences are all the licences granted to You for the Software under these
+terms.
+
+Use means anything You do with the Software requiring one of Your Licences.
+
+Trademark means trademarks, service marks, and similar rights.
+
+To Mark content is to use the Software to embed a watermark in it or to attach a
+signed manifest to it.
+
+A Laidline Licence is a licence file that the Licensor signs and issues for the
+Software under a Customer Agreement or under the Licensor's published
+legal-process policy. A Legal-Process Licence is a Laidline Licence issued under
+that policy: it unlocks export and the compliance paperwork for the months a
+lawful order demands, and it licenses no Marking. A Customer Agreement is a
+separate agreement between You and the Licensor under which the Licensor issues
+Laidline Licences and registered issuer numbers.
+
+The Licence Key Functionality is the functionality in the Software that reads,
+verifies or applies Laidline Licences, issuer certificates and signed weight
+tables, or that counts Credits. The Meter is the functionality that records and
+counts Credits. The Licence-State Surfaces are the licence state and usage
+figures the Software reports in its status commands, logs, metrics, response
+headers and evidence exports, including the unlicensed-use notice and the
+export's licence block. The Payload-Key Switch is the Software's choice of
+payload key and issuer number for each new mark, and the evidence event it
+records when that choice changes.
+
+A Competing Use is making available to others, commercially or free of charge, a
+product or service that (a) substitutes for the Software; (b) substitutes for
+any other product or service the Licensor offers using the Software that exists
+when the Licensor makes the Software available; or (c) offers the same or
+substantially similar marking, watermarking, signing or detection of
+AI-generated content as the Software. Products and services compete even when
+they work through different interfaces or on different platforms, or are free of
+charge; one marketed as a practical substitute for the Software competes.
+Detecting and verifying marks made with the Software, as Detection and
+Verification permits, is never a Competing Use.
+
+A Competitor is anyone who offers, or has publicly announced that it will offer,
+a Competing Use or a hosted or managed service built from the Software. If You
+are a Competitor, so is Your Company.

laidline_pipecat-1.0.0/PKG-INFO

@@ -0,0 +1,82 @@
+Metadata-Version: 2.5
+Name: laidline-pipecat
+Version: 1.0.0
+Summary: Pipecat `FrameProcessor` placed after TTS; marks TTS audio frames with streaming AudioSeal; one evidence entry per utterance.
+Project-URL: Homepage, https://laidline.com
+Project-URL: Documentation, https://laidline.com/docs/quickstart
+Project-URL: Changelog, https://laidline.com/docs/changelog
+Author: Laidline LLC
+License-Expression: LicenseRef-Laidline-Source-Available
+License-File: LICENSE
+Keywords: ai-act,c2pa,pipecat,provenance,voice,watermark
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Multimedia
+Classifier: Topic :: Security :: Cryptography
+Requires-Python: >=3.12
+Requires-Dist: laidline[audio]<2,>=1.0
+Requires-Dist: pipecat-ai<2,>=1.12
+Description-Content-Type: text/markdown
+
+# laidline-pipecat
+
+A Pipecat `FrameProcessor` that sits right after the TTS service. It marks every TTS audio frame with streaming AudioSeal and writes one Laidline evidence entry per utterance.
+
+```bash
+pip install laidline-pipecat   # pulls laidline[audio] and pipecat-ai>=1.12,<2
+```
+
+```python
+from laidline import MarkContext, Marker
+from laidline_pipecat import LaidlineTTSProcessor
+
+marker = Marker.from_config("laidline.yaml")  # in-process: keys, models and evidence stay on your host
+pipeline = Pipeline(
+    [
+        transport.input(),
+        stt,
+        context_aggregator.user(),
+        llm,
+        tts,
+        LaidlineTTSProcessor(marker, ctx=MarkContext(route="pipecat:support-bot", tenant="acme")),
+        transport.output(),
+        context_aggregator.assistant(),
+    ]
+)
+```
+
+## What it does
+
+- Each downstream `TTSAudioRawFrame` is replaced by a copy carrying the marked PCM. The copy keeps the same length, rate, channels, `pts`, `transport_destination`, `context_id` and metadata. Every other frame passes through unchanged.
+- `TTSStartedFrame` opens an utterance. `TTSStoppedFrame`, `InterruptionFrame`, `EndFrame`, `CancelFrame` and processor cleanup close it. Closing writes one `marked` evidence entry with `modality: audio`, `watermark.streaming: true`, the payload and issuer id, the duration, your `ctx`, and the TTS `context_id` under `extra.context_id`. An utterance that changes sample rate part-way gets one entry per format.
+- It needs an in-process `Marker` with `watermark.audio.enabled: true`. A `MarkClient` raises `TypeError`, because the streaming path has no HTTP form. A Marker with audio watermarking disabled raises `ValueError`.
+- A marking failure raises out of `process_frame`. Pipecat reports it as an error and does not push the unmarked frame.
+- The embedder is AudioSeal's streaming card (`watermark.audio.stream_kind: block`, the only kind).
+
+## What it does not do
+
+- Audio below 16 kHz (an 8 kHz phone bot) is not marked: it passes through unchanged and the entry says `watermark: null`, `watermark_skipped:rate_below_16k`. The streaming mark does not survive below 16 kHz.
+- A stream carries no C2PA manifest (`c2pa: null`, warning `manifest_skipped:streaming`). The watermark and the evidence entry are the provenance for live audio.
+- For a recording you store, sign the file itself with `marker.mark_audio(..., fmt="wav" | "flac" | "mp3" | "m4a")`. This embeds a manifest and adds the batch mark. Laidline's `/v1/audio/speech` proxy in streaming mode stores a signed twin of a response only when `watermark.audio.store_signed_twin` is enabled and only for a stream that completed.
+
+## Survival
+
+Measured 2026-09-27 on LibriSpeech test-clean, 500 speech clips. The detection threshold is 0.39, which gave a 0.75 % false-positive rate. Figures are the share of clips on which the streaming-mode mark (the one this plugin embeds) is still detected:
+
+| Transform | Streaming mode |
+|---|---|
+| Opus 24 kbps | 100 % |
+| Opus 48 kbps | 100 % |
+| MP3 64 kbps | 100 % |
+| AAC 64 kbps | 100 % |
+| G.711 mu-law | 0 % |
+| 8 kHz resampling | 0 % |
+| EnCodec 6 kbps | 100 % detected, 0 % exact issuer |
+| Mimi | 0 % |
+
+The streaming mark survives an offline Opus transcode at 24 and 48 kbps (100 percent on 500 LibriSpeech clips); no WebRTC session, packet loss or jitter was tested. **It does not survive a simulated phone leg** (G.711 codec simulation). The streaming mark was not run over a real call. For phone deployments, provenance comes from the evidence entry and from C2PA on stored recordings, not from the watermark. For comparison, the batch (non-streaming) mark that `mark_audio` embeds survives simulated G.711 and 8 kHz at 100 %, and a real call with the batch mark: 99 % (100 Twilio number-to-number calls recorded at the callee, G.711 8 kHz, carrier routing unconfirmed and possibly on-net, measured 2026-09-27).
+
+Mean embed SNR is 17.4 dB (5th percentile 8.7 dB), which is audible on some voices. Listen to your own voices before you ship.
+
+The full numbers and method are in [the benchmarks page](https://laidline.com/docs/benchmarks) ("Audio robustness"), and what was tested, and how, in [https://laidline.com/docs/integrations/pipecat](https://laidline.com/docs/integrations/pipecat). Streaming sessions, detection and the operating threshold are in [https://laidline.com/docs/integrations/audio](https://laidline.com/docs/integrations/audio).

laidline_pipecat-1.0.0/README.md

@@ -0,0 +1,61 @@
+# laidline-pipecat
+
+A Pipecat `FrameProcessor` that sits right after the TTS service. It marks every TTS audio frame with streaming AudioSeal and writes one Laidline evidence entry per utterance.
+
+```bash
+pip install laidline-pipecat   # pulls laidline[audio] and pipecat-ai>=1.12,<2
+```
+
+```python
+from laidline import MarkContext, Marker
+from laidline_pipecat import LaidlineTTSProcessor
+
+marker = Marker.from_config("laidline.yaml")  # in-process: keys, models and evidence stay on your host
+pipeline = Pipeline(
+    [
+        transport.input(),
+        stt,
+        context_aggregator.user(),
+        llm,
+        tts,
+        LaidlineTTSProcessor(marker, ctx=MarkContext(route="pipecat:support-bot", tenant="acme")),
+        transport.output(),
+        context_aggregator.assistant(),
+    ]
+)
+```
+
+## What it does
+
+- Each downstream `TTSAudioRawFrame` is replaced by a copy carrying the marked PCM. The copy keeps the same length, rate, channels, `pts`, `transport_destination`, `context_id` and metadata. Every other frame passes through unchanged.
+- `TTSStartedFrame` opens an utterance. `TTSStoppedFrame`, `InterruptionFrame`, `EndFrame`, `CancelFrame` and processor cleanup close it. Closing writes one `marked` evidence entry with `modality: audio`, `watermark.streaming: true`, the payload and issuer id, the duration, your `ctx`, and the TTS `context_id` under `extra.context_id`. An utterance that changes sample rate part-way gets one entry per format.
+- It needs an in-process `Marker` with `watermark.audio.enabled: true`. A `MarkClient` raises `TypeError`, because the streaming path has no HTTP form. A Marker with audio watermarking disabled raises `ValueError`.
+- A marking failure raises out of `process_frame`. Pipecat reports it as an error and does not push the unmarked frame.
+- The embedder is AudioSeal's streaming card (`watermark.audio.stream_kind: block`, the only kind).
+
+## What it does not do
+
+- Audio below 16 kHz (an 8 kHz phone bot) is not marked: it passes through unchanged and the entry says `watermark: null`, `watermark_skipped:rate_below_16k`. The streaming mark does not survive below 16 kHz.
+- A stream carries no C2PA manifest (`c2pa: null`, warning `manifest_skipped:streaming`). The watermark and the evidence entry are the provenance for live audio.
+- For a recording you store, sign the file itself with `marker.mark_audio(..., fmt="wav" | "flac" | "mp3" | "m4a")`. This embeds a manifest and adds the batch mark. Laidline's `/v1/audio/speech` proxy in streaming mode stores a signed twin of a response only when `watermark.audio.store_signed_twin` is enabled and only for a stream that completed.
+
+## Survival
+
+Measured 2026-09-27 on LibriSpeech test-clean, 500 speech clips. The detection threshold is 0.39, which gave a 0.75 % false-positive rate. Figures are the share of clips on which the streaming-mode mark (the one this plugin embeds) is still detected:
+
+| Transform | Streaming mode |
+|---|---|
+| Opus 24 kbps | 100 % |
+| Opus 48 kbps | 100 % |
+| MP3 64 kbps | 100 % |
+| AAC 64 kbps | 100 % |
+| G.711 mu-law | 0 % |
+| 8 kHz resampling | 0 % |
+| EnCodec 6 kbps | 100 % detected, 0 % exact issuer |
+| Mimi | 0 % |
+
+The streaming mark survives an offline Opus transcode at 24 and 48 kbps (100 percent on 500 LibriSpeech clips); no WebRTC session, packet loss or jitter was tested. **It does not survive a simulated phone leg** (G.711 codec simulation). The streaming mark was not run over a real call. For phone deployments, provenance comes from the evidence entry and from C2PA on stored recordings, not from the watermark. For comparison, the batch (non-streaming) mark that `mark_audio` embeds survives simulated G.711 and 8 kHz at 100 %, and a real call with the batch mark: 99 % (100 Twilio number-to-number calls recorded at the callee, G.711 8 kHz, carrier routing unconfirmed and possibly on-net, measured 2026-09-27).
+
+Mean embed SNR is 17.4 dB (5th percentile 8.7 dB), which is audible on some voices. Listen to your own voices before you ship.
+
+The full numbers and method are in [the benchmarks page](https://laidline.com/docs/benchmarks) ("Audio robustness"), and what was tested, and how, in [https://laidline.com/docs/integrations/pipecat](https://laidline.com/docs/integrations/pipecat). Streaming sessions, detection and the operating threshold are in [https://laidline.com/docs/integrations/audio](https://laidline.com/docs/integrations/audio).

laidline_pipecat-1.0.0/laidline_pipecat/__init__.py

@@ -0,0 +1,8 @@
+"""Pipecat ``FrameProcessor`` placed after TTS: marks every TTS audio frame with streaming AudioSeal and writes one
+evidence entry per utterance. See ``LaidlineTTSProcessor``."""
+
+from laidline_pipecat.processor import LaidlineTTSProcessor
+
+__version__ = "1.0.0"
+
+__all__ = ["LaidlineTTSProcessor", "__version__"]

laidline_pipecat-1.0.0/laidline_pipecat/processor.py

@@ -0,0 +1,150 @@
+"""``LaidlineTTSProcessor``: a Pipecat ``FrameProcessor`` placed right after the TTS service. Every downstream
+``TTSAudioRawFrame`` is replaced by a copy of the same frame carrying AudioSeal-marked PCM (``pts``,
+``transport_destination``, ``context_id`` and metadata kept). ``TTSStartedFrame`` opens an utterance;
+``TTSStoppedFrame``, ``InterruptionFrame``, ``EndFrame``, ``CancelFrame`` and ``cleanup`` close it and write its one
+evidence entry (``modality: audio``, ``watermark.streaming: true``, ``c2pa: null``: a stream carries no manifest).
+Every frame is pushed on; nothing but the audio bytes changes.
+
+Needs an in-process ``Marker`` with ``watermark.audio.enabled`` (the streaming path has no HTTP form). A marking
+failure raises out of ``process_frame``: Pipecat reports it as an error and the unmarked frame is not pushed."""
+
+from __future__ import annotations
+
+import asyncio
+import copy
+import dataclasses
+import logging
+import threading
+from typing import Any
+
+from laidline import MarkContext, Marker
+from laidline.core.api import AudioStreamSession, MarkClient
+from pipecat.frames.frames import (
+    CancelFrame,
+    EndFrame,
+    Frame,
+    InterruptionFrame,
+    TTSAudioRawFrame,
+    TTSStartedFrame,
+    TTSStoppedFrame,
+)
+from pipecat.processors.frame_processor import FrameDirection, FrameProcessor
+
+log = logging.getLogger(__name__)
+
+_CLOSING = (TTSStoppedFrame, InterruptionFrame, EndFrame, CancelFrame)
+
+
+class LaidlineTTSProcessor(FrameProcessor):
+    """Watermark TTS audio in a Pipecat pipeline: ``[..., tts, LaidlineTTSProcessor(marker), transport.output()]``.
+
+    ``ctx`` is copied into every utterance's evidence entry (default route ``pipecat:tts``); the utterance's TTS
+    ``context_id`` is added under ``extra.context_id``. Other keyword arguments go to ``FrameProcessor``."""
+
+    def __init__(self, marker: Marker, *, ctx: MarkContext | None = None, **kwargs: Any) -> None:
+        if isinstance(marker, MarkClient) or not isinstance(marker, Marker):
+            raise TypeError("LaidlineTTSProcessor needs an in-process Marker (a MarkClient cannot mark a stream)")
+        if marker.audio_wm is None:
+            raise ValueError("watermark.audio.enabled is false in this Marker's configuration")
+        super().__init__(**kwargs)
+        self._marker = marker
+        self._ctx = ctx or MarkContext(route="pipecat:tts")
+        self._session: AudioStreamSession | None = None
+        self._context_id: str | None = None
+        # System frames (interruption, cancel) run on Pipecat's input task while an audio frame may be mid-``process``
+        # in a worker thread on the process task; the lock keeps ``close`` from racing that call.
+        self._lock = threading.Lock()
+        self._closing: set[asyncio.Future[str | None]] = set()
+
+    async def process_frame(self, frame: Frame, direction: FrameDirection) -> None:
+        await super().process_frame(frame, direction)
+        if isinstance(frame, TTSStartedFrame):
+            await self._finish(relay=True)
+            self._context_id = frame.context_id
+        elif isinstance(frame, TTSAudioRawFrame) and direction == FrameDirection.DOWNSTREAM:
+            frame = await self._mark(frame)
+        elif isinstance(frame, _CLOSING):
+            # an utterance that ends relays what a keyed stream held back; an interruption or a cancel discards it
+            await self._finish(relay=isinstance(frame, (TTSStoppedFrame, EndFrame)))
+            self._context_id = None
+        await self.push_frame(frame, direction)
+
+    async def cleanup(self) -> None:
+        """Close the open utterance, then wait for every close still running, including those whose caller a
+        barge-in cancelled, so no evidence write is left behind when the pipeline stops."""
+        await super().cleanup()  # type: ignore[no-untyped-call]  # unannotated in pipecat 1.12
+        await self._finish()
+        if self._closing:
+            await asyncio.gather(*self._closing, return_exceptions=True)  # failures are logged by _closed
+
+    async def _mark(self, frame: TTSAudioRawFrame) -> TTSAudioRawFrame:
+        marked = None
+        while marked is None:  # None: an interruption closed the session under this frame; mark it in a new one
+            marked = await asyncio.to_thread(self._process, await self._session_for(frame), frame.audio)
+        out = copy.copy(frame)  # same id, pts, destination, context_id: only the samples change
+        out.metadata = dict(frame.metadata)
+        out.audio = marked
+        out.num_frames = len(marked) // (2 * frame.num_channels)
+        return out
+
+    async def _session_for(self, frame: TTSAudioRawFrame) -> AudioStreamSession:
+        s = self._session
+        if s is not None and s.rate == frame.sample_rate and s.channels == frame.num_channels:
+            return s
+        await self._finish(relay=True)  # none open, or the format changed mid-utterance: one entry per format
+        context_id = frame.context_id or self._context_id
+        extra = {**self._ctx.extra, **({"context_id": context_id} if context_id else {})}
+        ctx = dataclasses.replace(self._ctx, extra=extra)
+        # off the loop: the first session loads the streaming generator (a download on a cold cache)
+        s = await asyncio.to_thread(
+            self._marker.audio_stream, ctx, sample_rate=frame.sample_rate, channels=frame.num_channels
+        )
+        self._session = s
+        return s
+
+    def _process(self, s: AudioStreamSession, pcm16: bytes) -> bytes | None:
+        with self._lock:
+            return None if s.closed else s.process(pcm16)
+
+    def _close(self, s: AudioStreamSession) -> str | None:
+        with self._lock:
+            # an utterance that ended was flushed first; an interrupted one pushed no tail, so none is counted
+            return s.close(discard_tail=True).entry_hash
+
+    def _flush(self, s: AudioStreamSession) -> bytes:
+        with self._lock:
+            return b"" if s.closed else s.flush()
+
+    async def _finish(self, relay: bool = False) -> None:
+        s, self._session = self._session, None
+        if s is None:
+            return
+        try:
+            if relay and s.keyed:  # only a keyed stream holds frames back
+                # a keyed stream holds its lookahead and last hop back; push them, marked, as one
+                # more audio frame before the frame that ends the utterance
+                tail = await asyncio.to_thread(self._flush, s)
+                if tail:
+                    out = TTSAudioRawFrame(
+                        audio=tail, sample_rate=s.rate, num_channels=s.channels, context_id=self._context_id
+                    )
+                    await self.push_frame(out, FrameDirection.DOWNSTREAM)
+        finally:  # the session is already detached: a failed or cancelled relay must not leave it unclosed
+            # shielded: a barge-in cancels the task awaiting this, and a close still queued in the executor would be
+            # dropped with it, leaving marked audio with no entry. ``_closing`` holds the task until it is done.
+            task = asyncio.ensure_future(asyncio.to_thread(self._close, s))
+            self._closing.add(task)
+            task.add_done_callback(lambda t: self._closed(t, s.asset_id))
+            entry_hash = await asyncio.shield(task)
+            log.info("laidline: utterance %s marked (%d frames), evidence %s", s.asset_id, s.frames, entry_hash)
+
+    def _closed(self, task: asyncio.Future[str | None], asset_id: str) -> None:
+        """Done callback of a shielded close: forget it and log a failure, which nobody may be awaiting any more (a
+        barge-in cancelled the caller)."""
+        self._closing.discard(task)
+        if task.cancelled():
+            log.error("laidline: close of utterance %s was cancelled; its evidence was not written", asset_id)
+        elif (e := task.exception()) is not None:
+            log.error(
+                "laidline: utterance %s: evidence was not written: %s: %s", asset_id, type(e).__name__, str(e)[:200]
+            )

laidline_pipecat-1.0.0/pyproject.toml

@@ -0,0 +1,34 @@
+[project]
+name = "laidline-pipecat"
+version = "1.0.0"
+description = "Pipecat `FrameProcessor` placed after TTS; marks TTS audio frames with streaming AudioSeal; one evidence entry per utterance."
+readme = "README.md"
+requires-python = ">=3.12"
+authors = [{name = "Laidline LLC"}]
+license = "LicenseRef-Laidline-Source-Available"
+license-files = ["LICENSE"]
+keywords = ["ai-act", "c2pa", "pipecat", "provenance", "voice", "watermark"]
+classifiers = [
+  "Development Status :: 5 - Production/Stable",
+  "Programming Language :: Python :: 3.12",
+  "Topic :: Multimedia",
+  "Topic :: Security :: Cryptography",
+  "Operating System :: OS Independent",
+]
+dependencies = ["laidline[audio]>=1.0,<2", "pipecat-ai>=1.12,<2"]
+
+[project.urls]
+Homepage = "https://laidline.com"
+Documentation = "https://laidline.com/docs/quickstart"
+Changelog = "https://laidline.com/docs/changelog"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.sdist]
+# the tests and the repository's ignore file stay in the repository
+exclude = ["/tests", "/.gitignore", "**/__pycache__"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["laidline_pipecat"]