LyricPatch for agents

Change short lyrics in an existing song: upload authorized audio, select a phrase, write replacement words, preview the new version, and download the finished song.

This public connector is MIT licensed. The hosted LyricPatch service and its private backend are not part of that license. No song or credentials are included.

Connect

Start with the generic workflow: install the Python client below, then use lyricpatch-agent preview and lyricpatch-agent export. They handle upload, job polling, stable retry identifiers, a total credit ceiling, and private resume state for any supported song and known time range. No hardcoded demo lyrics. See host installation and the full workflow, or hear the real example.

No LyricPatch website signup is required. A wallet-capable agent can open a private session, purchase 40 credits for $1.99 USDC on Base, and receive its scoped API key automatically. The person still needs to authorize spending and permitted audio processing; connecting a tool does not create a wallet or grant permission.

1. Read GET https://api.lyricpatch.com/v1/agent/sessions/offer for the current price, legal version and required authorizations.
2. Generate and privately persist lp_session_ followed by 64 cryptographically random hex characters before any bootstrap request. Send it as X-LyricPatch-Session to POST /v1/agent/sessions and handle its x402 challenge.
3. Pay that same session only within the person's approved budget and attestations. Persist the signed proof before submission when the signer exposes it; the optional Coinbase adapter instead persists a one-attempt marker and permits only server-side recovery afterward. Recover with GET /v1/agent/sessions/current; never create a second session to retry payment.
4. Use the returned api_key as a bearer credential for private editing and MCP calls. Preserve the session secret for recovery; public transaction hashes do not grant access to projects.

Existing customers can still create account-owned keys and use ordinary Stripe checkout. Keep credentials in a private secret store, never in prompts, browser bundles, public repositories, analytics or tool logs.

For clients supporting Streamable HTTP with custom headers:

{
  "mcpServers": {
    "lyricpatch": {
      "url": "https://api.lyricpatch.com/mcp",
      "headers": {"Authorization": "Bearer YOUR_LYRICPATCH_AGENT_KEY"}
    }
  }
}

Public MCP initialization, tool discovery and service information work without credentials. Private tools use the automatically issued scoped bearer key. Host configuration formats vary. This release uses bearer keys, not OAuth; a host that only accepts OAuth connections cannot connect directly. The REST API works with any HTTPS client. An MCP client also needs a local-file upload capability: the server returns a private signed PUT URL, not a file picker.

Python client

These instructions describe Python client 1.3.0. Server and plugin metadata intentionally remain at version 1.2.0 because those interfaces are unchanged.

Install the release directly from the public connector repository:

python -m pip install 'git+https://github.com/yaboijbigs/lyricpatch-agent.git@v1.3.0'

Or from this public connector checkout:

python -m pip install .

import os
from lyricpatch_agent import LyricPatch

with LyricPatch(os.environ["LYRICPATCH_API_KEY"]) as api:
    balance = api.account()["credit_balance"]
    print(f"Available credits: {balance}")

No automatic spending is enabled by importing or connecting the client.

Generic, resumable command

Create two private UTF-8 files containing the original and replacement words. Use an existing secret-store LYRICPATCH_API_KEY, or add --session-state for an already-funded signup-free session. For an authorized four-second selection:

lyricpatch-agent preview --song /private/song.mp3 --original-file /private/original.txt --replacement-file /private/replacement.txt --start 30 --end 34 --max-credits 9 --state /private/edit.bin --output /private/preview.wav --rights-confirmed --authorize-generation

Omit --authorize-generation to upload, prepare, save the draft, and inspect its quote without spending generation credits. After listening and approving:

lyricpatch-agent export --state /private/edit.bin --output /private/finished.mp3 --approve-version --authorize-export

The same protected state binds the source file, words, timing, format, and total budget. Reusing it resumes the same work; it does not buy credits or automatically create another version. Choose --format wav on the preview command if the finished file should be WAV. An uncertain submitted quote cannot be replaced; --refresh-quote only refreshes an unsubmitted quote. Preserve the source file and state until the output is saved. One command workflow manages one change; the lower-level API continues to support up to 32 non-overlapping edits.

Signup-free client and recovery

SignupFreeSession(state, save_state) accepts state loaded from your host's private secret store and a durable synchronous save callback. The callback must complete persistence before returning. Do not run two processes against one session state. prepare() obtains a price without signing; recover() checks the same session; await pay(signer, authorizations, max_amount_cents=199) can spend only when explicitly authorized. client() returns the regular editing client after the payment is confirmed.

The local-signer helper persists a signing marker before consulting the wallet and the exact proof before submitting it. After an uncertain response it checks the same payment and can resend only that stored proof. It never signs a replacement after an uncertain signing attempt, automatically buys another pack, or renews an expired payment authorization. Keep the recovery state and check the payment if interrupted.

For a runnable signup-free Outlet example, install .[x402], keep a dedicated limited-balance wallet key in your local EVM_PRIVATE_KEY secret, and use examples/signup_free_outlet.py. The example protects its separate private session state with Windows DPAPI or mode 0600 on POSIX and uses an exclusive process lock. Use an owner-only directory outside source control. The session state is a secret; the existing Outlet workflow state contains only operation IDs.

python examples/signup_free_outlet.py /path/to/outlet_original.mp3 --session-state /private/path/payment-session.bin --state /private/path/outlet-run.json --output /private/path/preview.wav --rights-confirmed --adult --accept-terms --allow-media-processing --legal-version CURRENT_VERSION_FROM_OFFER --authorize-1-99-usdc

The authorization flags must reflect the person's actual permission. After the first payment, rerun with the same session state; no manually created API key is needed. To accept and export the preview, append --stage export --approve-version and choose a new MP3 output path. The example uses the known 44–48-second Outlet selection, not an invented word alignment or a whole-song transcription service.

Optional Coinbase Agentic Wallet adapter

The experimental connect --coinbase-wallet-runtime /private/lyricpatch-awal option uses a separately installed, pinned Coinbase runtime without exporting a wallet key or putting the session credential in process arguments. The wallet owner must already have configured, funded, signed in to, and started the wallet. The adapter never installs or starts it. Do not supply EVM_PRIVATE_KEY with a Coinbase initiation or reuse local-signing state for it.

This path requires Node.js 18+ on Linux/macOS or a configured WSL environment; native Windows is unsupported because upstream IPC ACLs have not been verified. It uses Coinbase's local plaintext IPC inside existing owner-only directories, not a memory-only transport. Every payment attempt is durably marked before invocation; afterward, even an auth failure or pre-submission crash is recovery-only, with owner resolution if the session stays unresolved.

See setup, authorization flags, recovery, and trust boundaries. Tests use mocked wallet/auth/telemetry and the real pinned command factory; no live Coinbase payment or end-to-end wallet compatibility is claimed.

Let the calling agent supply the words

If the calling agent already has word timestamps, use the local text-matching helper before creating an edit:

matches = api.phrase_matches(project_id, "singing in the booth", [
    {"text": "singing", "start_seconds": 44.0, "end_seconds": 44.5},
    {"text": "in", "start_seconds": 44.5, "end_seconds": 44.7},
    {"text": "the", "start_seconds": 44.7, "end_seconds": 44.9},
    {"text": "booth", "start_seconds": 44.9, "end_seconds": 45.4},
])

These example timestamps illustrate the schema, not a verified Outlet alignment. Supply timestamps from the agent's actual audio understanding or the person's selection. LyricPatch matches the provided text in memory, returns candidates, and checks the real source duration; it does not verify the supplied transcription, store that transcript, call OpenAI, or spend credits. Ambiguous/approximate matches require confirmation. Listen to the original selection before generating. If the agent cannot determine reliable timing, ask for timestamps instead of guessing.

Limits: 5,000 supplied words, 100,000 text characters, 40-word target, at most ten candidates. Edit selections still must last 0.1–6 seconds. Existing optional selected-clip transcription is unchanged; there is no whole-song provider scan.

A real edit, with a preview approval step