pinecall-protocol 0.6.2__tar.gz → 0.6.14__tar.gz

{pinecall_protocol-0.6.2 → pinecall_protocol-0.6.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pinecall-protocol
-Version: 0.6.2
+Version: 0.6.14
 Summary: The Pinecall wire: pydantic models generated from the protocol schema
 Author-email: Bernardo Castro <me@bernardocastro.dev>
 License-Expression: Apache-2.0

pinecall_protocol-0.6.14/pinecall_protocol/_version.py

@@ -0,0 +1,4 @@
+"""Package version; hatch reads it at build time."""
+
+# 0.0.0 means "unreleased". Set by the maintainer; never bumped from code.
+__version__ = "0.6.14"

{pinecall_protocol-0.6.2 → pinecall_protocol-0.6.14}/pinecall_protocol/commands.py

@@ -17,6 +17,10 @@ class AgentConfigure(WireModel):
     config: AgentConfig
 
 
+class AgentDrain(WireModel):
+    """This socket is leaving, and its calls go on without it."""
+
+
 # The gateway answers agent.registered, or error.
 class AgentRegister(WireModel):
     """The app's first message: this socket speaks for this agent and answers these doors."""
@@ -46,6 +50,30 @@ class AgentSay(WireModel):
     allow_interruptions: bool | None = None
 
 
+# Ask for a person without sending the caller anywhere: the call waits on hold until a supervisor
+# takes the line, or until wait_s passes with nobody taking it. attention.answered says which.
+class CallAttention(WireModel):
+    """Ask for a person without sending the caller anywhere."""
+
+    reason: str
+    wait_s: float
+
+
+# Lands as callback.requested with via agent; placing the call is the app's.
+class CallCallback(WireModel):
+    """Write down that the caller wants to be called back."""
+
+    number: str
+    when: str | None = None
+    note: str | None = None
+
+
+class CallClaim(WireModel):
+    """The code the caller said, to bind this call to the page that shows it."""
+
+    code: str = Field(pattern="^[0-9]{4}$")
+
+
 # The new call's log opens with call.dialing; call.started follows when the far end answers.
 class CallDial(WireModel):
     """Place an outbound call as this agent."""
@@ -95,12 +123,12 @@ class CallMute(WireModel):
     """Mute the agent: it keeps listening and thinking, produces no audio."""
 
 
-# call.transferred says whether it worked.
+# call.transferred says whether it worked, and which mode it was.
 class CallTransfer(WireModel):
-    """Send the caller to another number."""
+    """Send the caller to another number, or bring that number into the call."""
 
     to: str
-    mode: TransferMode
+    mode: TransferMode | None = None
 
 
 class CallUnhold(WireModel):

{pinecall_protocol-0.6.2 → pinecall_protocol-0.6.14}/pinecall_protocol/defs.py

@@ -27,13 +27,15 @@ type Env = Literal["production", "sandbox"]
 # What a console may ask of the process standing in the agent's directory, relayed by the gateway: a
 # written call to the class mounted there (chat), a simulated caller put on the class it holds, its
 # goldens and a suite of them, its knowledge folder pushed or its golden asked, its memory goldens,
-# a call promoted to a candidate file, the drift of the last two windows, and the reproductions a
-# broken run left on that disk. Everything else a console needs is a door of the gateway.
+# the panel it draws beside a conversation (view), a call promoted to a candidate file, the drift of
+# the last two windows, and the reproductions a broken run left on that disk. Everything else a
+# console needs is a door of the gateway.
 type DevVerb = Literal[
     "chat.roster",
     "chat.start",
     "chat.say",
     "chat.end",
+    "view.render",
     "simulate.start",
     "goldens.roster",
     "goldens.run",
@@ -80,8 +82,9 @@ type EndedBy = Literal["caller", "agent", "supervisor", "platform"]
 type ScoreVerdict = Literal["held", "broken", "deferred", "skipped"]
 
 
-# Cold: the caller is sent on and the agent leaves. Warm: the agent stays on the line until the
-# other side answers, then leaves.
+# Cold: the caller is sent on with a REFER on their SIP leg and the call ends here. Warm: the number
+# is dialled into the call's own room, the agent stays on the line until the other side answers and
+# then falls silent; the call ends when either of them hangs up.
 type TransferMode = Literal["cold", "warm"]
 
 
@@ -234,6 +237,7 @@ class DocSource(WireModel):
     """One chunk of the knowledge base that retrieval put in front of the model for this turn."""
 
     id: str
+    base: str | None = None
     path: str
     heading: str | None = None
     score: float
@@ -309,6 +313,8 @@ class TurnConfig(WireModel):
 
     min_interruption_words: int | None = None
     endpointing_ms: int | None = None
+    eot_threshold: float | None = None
+    eager_eot_threshold: float | None = None
 
 
 # How the voice says one word it would otherwise get wrong: a proper name, a brand, a street.
@@ -327,6 +333,16 @@ class StateFieldSpec(WireModel):
     visibility: Visibility
 
 
+# The panel the agent draws beside a conversation: it is declared here so a console knows the agent
+# has one before it asks for it, and draws its own about the contact when it has not. What the panel
+# CONTAINS never comes this way — it is asked for a conversation at a time, through the view.render
+# dev verb.
+class ViewSpec(WireModel):
+    """The panel the agent draws beside a conversation."""
+
+    name: str
+
+
 # An event nobody declared is refused before it touches the log.
 class EventSpec(WireModel):
     """One outside event the agent accepts, and from whom."""
@@ -404,7 +420,9 @@ class AgentConfig(WireModel):
     docs: DocsConfig | None = None
     memory: MemoryConfig | None = None
     hangup: HangupConfig | None = None
+    record: bool = True
     tools: list[ToolSpec] | None = None
     uses_knowledge: bool = False
     state_fields: list[StateFieldSpec] | None = None
+    view: ViewSpec | None = None
     events: list[EventSpec] | None = None

{pinecall_protocol-0.6.2 → pinecall_protocol-0.6.14}/pinecall_protocol/events.py

@@ -17,6 +17,7 @@ from pinecall_protocol.defs import (
     EndReason,
     Env,
     MemoryOp,
+    Projection,
     Route,
     ScoreVerdict,
     Supervisor,
@@ -42,6 +43,15 @@ class AgentDetached(WireModel):
     left: bool
 
 
+class AgentDraining(WireModel):
+    """One socket let go of its calls without cutting them."""
+
+    app: str
+    env: Env
+    handed: int
+    parked: int
+
+
 # The gateway accepted an agent.register: this socket now speaks for the agent and answers its
 # routes. Many sockets may hold one agent at once — a new call takes the newest of them, unless the
 # caller names one by its `app` id.
@@ -74,6 +84,59 @@ class AgentTranscript(WireModel):
     end: float | None = None
 
 
+# An ask for a person settled: a supervisor took the line, or the wait ran out and the agent has the
+# caller back.
+class AttentionAnswered(WireModel):
+    """An ask for a person settled."""
+
+    ok: bool
+    by: Supervisor | None
+    error: str | None = None
+
+
+# The agent asked for a person: the caller is on hold and waits for a supervisor to take the line.
+# What a supervisor's console and phone are notified by.
+class AttentionRequested(WireModel):
+    """The agent asked for a person."""
+
+    reason: str
+    wait_s: float
+
+
+# Everything the agent says and hears comes after this.
+class CallStarted(WireModel):
+    """Media is up: the caller and the agent can hear each other, or the text session is open."""
+
+    channel: Channel
+    direction: Direction
+    from_: str = Field(alias="from")
+    to: str
+    run: str | None = None
+    persona: str | None = None
+    accepts_when: str | None = None
+    declines_when: str | None = None
+    caller: Contact | None
+    started_at: float
+    env: Env | None = None
+
+
+class CallAttached(WireModel):
+    """A call changed hands without ending."""
+
+    app: str
+    started: CallStarted
+    state: dict[str, Any]
+    seq: int
+    claimed: str | None = None
+
+
+class CallClaimed(WireModel):
+    """The call was bound to a page's code."""
+
+    code: str
+    via: Literal["keypad", "agent"]
+
+
 # The first entry of an outbound call's log.
 class CallDialing(WireModel):
     """The platform is placing an outbound call and the far end has not answered yet."""
@@ -150,21 +213,6 @@ class CallScore(WireModel):
     judge_cost_eur: float | None = None
 
 
-# Everything the agent says and hears comes after this.
-class CallStarted(WireModel):
-    """Media is up: the caller and the agent can hear each other, or the text session is open."""
-
-    channel: Channel
-    direction: Direction
-    from_: str = Field(alias="from")
-    to: str
-    run: str | None = None
-    persona: str | None = None
-    caller: Contact | None
-    started_at: float
-    env: Env | None = None
-
-
 # Written after call.ended, once memory and pricing are done; call.score follows it and seals the
 # log.
 class CallSummary(WireModel):
@@ -183,24 +231,42 @@ class CallTransferred(WireModel):
     """A transfer asked for by the agent or a supervisor finished, one way or the other."""
 
     to: str
-    mode: TransferMode
+    mode: TransferMode | None = None
     ok: bool
     error: str | None = None
 
 
-# Somebody asked to be called back because no seat was free: a phone caller the overflow agent
-# answered, or a web visitor who left a number at the widget. Written into the agent's own log; the
-# tenant's app reads it and places the call.
+# Somebody asked to be called back: a phone caller the overflow agent answered, a web visitor who
+# left a number at the widget, or a caller who asked the agent for one (call.callback). Written into
+# the agent's own log; the tenant's app reads it and places the call.
 class CallbackRequested(WireModel):
-    """Somebody asked to be called back because no seat was free."""
+    """Somebody asked to be called back."""
 
     channel: Channel
     number: str
-    via: Literal["overflow", "widget"]
+    via: Literal["overflow", "widget", "agent"]
     call: str | None
+    when: str | None = None
+    note: str | None = None
     contact: Contact | None
 
 
+class CodeClaimed(WireModel):
+    """One code, taken or expired."""
+
+    code: str
+    call: str | None
+
+
+class CodeIssued(WireModel):
+    """One code, waiting for the call that keys it."""
+
+    code: str
+    env: Env
+    expires_at: float
+    log: Projection
+
+
 # The tool does not run; the model is told.
 class ConfirmDeclined(WireModel):
     """The caller did not say yes, or the request lapsed."""
@@ -236,9 +302,10 @@ class ConfirmRequest(WireModel):
     ttl_s: int
 
 
+# The gateway refused a call, a written turn or a register because one of the org's quotas ran out.
 # Written into the agent's own log, which is the org's, before the door says no.
 class CreditsExhausted(WireModel):
-    """The gateway refused a call or a register because one of the org's quotas ran out."""
+    """CreditsExhausted, as protocol/schema declares it."""
 
     org: str
     quota: Literal[
@@ -250,6 +317,7 @@ class CreditsExhausted(WireModel):
         "knowledge_chunks",
         "numbers",
         "seats",
+        "llm_tokens",
     ]
     used: float
     limit: int
@@ -281,6 +349,13 @@ class DocsSources(WireModel):
     speech_id: str | None = None
 
 
+class DtmfReceived(WireModel):
+    """One tone the caller keyed."""
+
+    digit: Literal["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "*", "#"]
+    code: int
+
+
 # Inside a call it says what failed; outside a call it says which command the gateway refused.
 class ErrorEvent(WireModel):
     """Something went wrong."""
@@ -329,6 +404,27 @@ class MemoryOps(WireModel):
     speech_id: str | None = None
 
 
+class MessageTaken(WireModel):
+    """One waiting message, off the queue."""
+
+    message_id: str
+    call: str | None
+
+
+class MessageWaiting(WireModel):
+    """One message, kept until somebody can answer it."""
+
+    channel: Channel
+    env: Env
+    number: str
+    phone_number_id: str
+    from_: str = Field(alias="from")
+    name: str | None
+    message_id: str
+    text: str
+    received_at: float
+
+
 # Ephemeral: it proves the socket is alive and says nothing else.
 class Pong(WireModel):
     """The answer to ping."""
@@ -409,7 +505,7 @@ class SupervisorTransferred(WireModel):
 
     by: Supervisor
     to: str
-    mode: TransferMode
+    mode: TransferMode | None = None
 
 
 class SupervisorWhispered(WireModel):

{pinecall_protocol-0.6.2 → pinecall_protocol-0.6.14}/pinecall_protocol/fixtures/__init__.py

@@ -1,4 +1,4 @@
-"""The golden call log and the state it reduces to: every consumer proves the same thing."""
+"""Paths to the golden call log and the state it reduces to, shared by every language's tests."""
 
 from importlib.resources import files
 from pathlib import Path

{pinecall_protocol-0.6.2 → pinecall_protocol-0.6.14}/pinecall_protocol/fixtures/call-log-golden.state.json

@@ -30,6 +30,7 @@
   "held": false,
   "muted": false,
   "transfer": null,
+  "attention": null,
   "usage": [{"input_audio_tokens": 0, "input_cache_creation_tokens": 562, "input_cached_audio_tokens": 0, "input_cached_image_tokens": 0, "input_cached_text_tokens": 0, "input_cached_tokens": 13145, "input_image_tokens": 0, "input_text_tokens": 0, "input_tokens": 14963, "model": "claude-haiku-4-5", "output_audio_tokens": 0, "output_reasoning_tokens": 0, "output_text_tokens": 0, "output_tokens": 281, "provider": "anthropic", "session_duration": 0.0, "type": "llm_usage"}, {"audio_duration": 25.6, "characters_count": 397, "input_tokens": 0, "model": "eleven_flash_v2_5", "output_tokens": 0, "provider": "elevenlabs", "type": "tts_usage"}, {"audio_duration": 12.1, "input_tokens": 0, "model": "stt-rt-v5", "output_tokens": 0, "provider": "soniox", "type": "stt_usage"}, {"model": "adaptive", "provider": "livekit", "total_requests": 12, "type": "interruption_usage"}, {"model": "turn-detector-v1", "provider": "livekit", "total_requests": 5, "type": "eot_usage"}],
   "cost": {"eur": 0.022937, "rate": {"as_of": "2026-08-12", "currency": "EUR", "usd_to_eur": 0.92}, "rows": [{"eur": 0.001156, "model": "claude-haiku-4-5", "provider": "anthropic", "quantity": 1256.0, "unit": "input_tokens", "unit_price_usd": 1e-06}, {"eur": 0.001209, "model": "claude-haiku-4-5", "provider": "anthropic", "quantity": 13145.0, "unit": "cached_input_tokens", "unit_price_usd": 1e-07}, {"eur": 0.000646, "model": "claude-haiku-4-5", "provider": "anthropic", "quantity": 562.0, "unit": "cache_creation_tokens", "unit_price_usd": 1.25e-06}, {"eur": 0.001293, "model": "claude-haiku-4-5", "provider": "anthropic", "quantity": 281.0, "unit": "output_tokens", "unit_price_usd": 5e-06}, {"eur": 0.018262, "model": "eleven_flash_v2_5", "provider": "elevenlabs", "quantity": 397.0, "unit": "characters", "unit_price_usd": 5e-05}, {"eur": 0.000371, "model": "stt-rt-v5", "provider": "soniox", "quantity": 12.1, "unit": "audio_seconds", "unit_price_usd": 3.33e-05}], "unpriced": [{"model": "adaptive", "provider": "livekit"}, {"model": "turn-detector-v1", "provider": "livekit"}]},
   "routes": [],

{pinecall_protocol-0.6.2 → pinecall_protocol-0.6.14}/pinecall_protocol/registry.py

@@ -5,9 +5,13 @@ from typing import Literal
 from pinecall_protocol._base import WireModel
 from pinecall_protocol.commands import (
     AgentConfigure,
+    AgentDrain,
     AgentRegister,
     AgentReply,
     AgentSay,
+    CallAttention,
+    CallCallback,
+    CallClaim,
     CallDial,
     CallDtmf,
     CallEvent,
@@ -34,11 +38,16 @@ from pinecall_protocol.defs import ToolResult
 from pinecall_protocol.events import (
     AgentConfigured,
     AgentDetached,
+    AgentDraining,
     AgentRegistered,
     AgentStateChanged,
     AgentTranscript,
     AgentTurnEnded,
+    AttentionAnswered,
+    AttentionRequested,
+    CallAttached,
     CallbackRequested,
+    CallClaimed,
     CallDialing,
     CallEnded,
     CallLine,
@@ -47,6 +56,8 @@ from pinecall_protocol.events import (
     CallStarted,
     CallSummary,
     CallTransferred,
+    CodeClaimed,
+    CodeIssued,
     ConfirmDeclined,
     ConfirmGranted,
     ConfirmRequest,
@@ -54,11 +65,14 @@ from pinecall_protocol.events import (
     Custom,
     DevRequest,
     DocsSources,
+    DtmfReceived,
     ErrorEvent,
     FleetFull,
     LogCaughtUp,
     LogGap,
     MemoryOps,
+    MessageTaken,
+    MessageWaiting,
     Pong,
     PromptChanged,
     StateChanged,
@@ -100,9 +114,14 @@ from pinecall_protocol.room import (
 EVENTS: dict[str, type[WireModel]] = {
     "agent.configured": AgentConfigured,
     "agent.detached": AgentDetached,
+    "agent.draining": AgentDraining,
     "agent.registered": AgentRegistered,
     "agent.state": AgentStateChanged,
     "agent.transcript": AgentTranscript,
+    "attention.answered": AttentionAnswered,
+    "attention.requested": AttentionRequested,
+    "call.attached": CallAttached,
+    "call.claimed": CallClaimed,
     "call.dialing": CallDialing,
     "call.ended": CallEnded,
     "call.line": CallLine,
@@ -112,6 +131,8 @@ EVENTS: dict[str, type[WireModel]] = {
     "call.summary": CallSummary,
     "call.transferred": CallTransferred,
     "callback.requested": CallbackRequested,
+    "code.claimed": CodeClaimed,
+    "code.issued": CodeIssued,
     "confirm.declined": ConfirmDeclined,
     "confirm.granted": ConfirmGranted,
     "confirm.request": ConfirmRequest,
@@ -119,12 +140,15 @@ EVENTS: dict[str, type[WireModel]] = {
     "custom": Custom,
     "dev.request": DevRequest,
     "docs.sources": DocsSources,
+    "dtmf.received": DtmfReceived,
     "error": ErrorEvent,
     "event.received": EventReceived,
     "fleet.full": FleetFull,
     "log.caught_up": LogCaughtUp,
     "log.gap": LogGap,
     "memory.ops": MemoryOps,
+    "message.taken": MessageTaken,
+    "message.waiting": MessageWaiting,
     "metrics.avatar": AvatarMetrics,
     "metrics.eot": EOTInferenceMetrics,
     "metrics.eou": EOUMetrics,
@@ -162,9 +186,14 @@ EVENTS: dict[str, type[WireModel]] = {
 type EventType = Literal[
     "agent.configured",
     "agent.detached",
+    "agent.draining",
     "agent.registered",
     "agent.state",
     "agent.transcript",
+    "attention.answered",
+    "attention.requested",
+    "call.attached",
+    "call.claimed",
     "call.dialing",
     "call.ended",
     "call.line",
@@ -174,6 +203,8 @@ type EventType = Literal[
     "call.summary",
     "call.transferred",
     "callback.requested",
+    "code.claimed",
+    "code.issued",
     "confirm.declined",
     "confirm.granted",
     "confirm.request",
@@ -181,12 +212,15 @@ type EventType = Literal[
     "custom",
     "dev.request",
     "docs.sources",
+    "dtmf.received",
     "error",
     "event.received",
     "fleet.full",
     "log.caught_up",
     "log.gap",
     "memory.ops",
+    "message.taken",
+    "message.waiting",
     "metrics.avatar",
     "metrics.eot",
     "metrics.eou",
@@ -246,9 +280,13 @@ TERMINAL_EVENT: str = "call.score"
 # Every command by its wire type; codec looks the model up here.
 COMMANDS: dict[str, type[WireModel]] = {
     "agent.configure": AgentConfigure,
+    "agent.drain": AgentDrain,
     "agent.register": AgentRegister,
     "agent.reply": AgentReply,
     "agent.say": AgentSay,
+    "call.attention": CallAttention,
+    "call.callback": CallCallback,
+    "call.claim": CallClaim,
     "call.dial": CallDial,
     "call.dtmf": CallDtmf,
     "call.event": CallEvent,
@@ -275,9 +313,13 @@ COMMANDS: dict[str, type[WireModel]] = {
 
 type CommandType = Literal[
     "agent.configure",
+    "agent.drain",
     "agent.register",
     "agent.reply",
     "agent.say",
+    "call.attention",
+    "call.callback",
+    "call.claim",
     "call.dial",
     "call.dtmf",
     "call.event",
@@ -306,9 +348,13 @@ type CommandType = Literal[
 # Which events a command lands in the log as, so a caller knows what to wait for.
 PRODUCES: dict[str, tuple[str, ...]] = {
     "agent.configure": ("agent.configured",),
+    "agent.drain": ("agent.draining",),
     "agent.register": ("agent.registered",),
     "agent.reply": ("turn.agent",),
     "agent.say": ("turn.agent",),
+    "call.attention": ("attention.requested", "call.line", "attention.answered"),
+    "call.callback": ("callback.requested",),
+    "call.claim": ("call.claimed",),
     "call.dial": ("call.dialing",),
     "call.dtmf": (),
     "call.event": ("event.received",),

{pinecall_protocol-0.6.2 → pinecall_protocol-0.6.14}/pinecall_protocol/rest.py

@@ -22,7 +22,7 @@ from pinecall_protocol.defs import (
     TurnConfig,
 )
 from pinecall_protocol.envelope import Entry
-from pinecall_protocol.state import CallStatus, State
+from pinecall_protocol.state import AttentionState, CallStatus, State
 
 
 class CallState(WireModel):
@@ -78,6 +78,15 @@ class SessionLine(WireModel):
     cost: Cost | None
     score: SessionScore | None = None
     flags: list[SessionFlag] | None = None
+    attention: AttentionState | None = None
+
+
+# The operator's stream, every org of the box at once.
+class BoxEvent(WireModel):
+    """One frame of GET /v1/ops/events: an entry of some org's floor, and whose floor it is."""
+
+    org: str
+    entry: Entry
 
 
 # GET /v1/agents/{slug}/sessions and GET /v1/sessions: the calls that match, newest first, a page at
@@ -138,6 +147,29 @@ class Insights(WireModel):
     budget: InsightsBudget
 
 
+class Limit(WireModel):
+    """One quota: the limit the org was given, and how much of it is used."""
+
+    limit: int | None
+    used: float
+
+
+# GET /v1/limits: what the key's org may use and has used on this instance, where it bought more,
+# and which of the box's vendor keys it runs on. Any key of the org.
+class Limits(WireModel):
+    """GET /v1/limits."""
+
+    minutes: Limit
+    messages: Limit
+    llm_tokens: Limit
+    concurrent_calls: Limit
+    agents: Limit
+    seats: Limit
+    numbers: Limit
+    lends: list[str] | None
+    billing_url: str | None
+
+
 # GET and PUT /v1/org/judging: whether the org's calls are judged at hang-up, and what judging one
 # may spend on a model.
 class Judging(WireModel):
@@ -235,6 +267,11 @@ class AgentMemory(WireModel):
     next: str | None
 
 
+# auto: the visitor's own light or dark, as the browser says. light and dark: that one, whatever the
+# browser says.
+type WidgetTheme = Literal["auto", "light", "dark"]
+
+
 # GET and PUT /v1/agents/{slug}/widget: how the widget presents this agent, kept per org, world and
 # agent. PUT takes the whole set.
 class WidgetSettings(WireModel):
@@ -245,6 +282,7 @@ class WidgetSettings(WireModel):
     greeting: str | None
     accent: str | None
     autostart: bool
+    theme: WidgetTheme | None = None
 
 
 # GET and PUT /v1/org/sso: the OpenID Connect provider this org's people sign in at, and never the
@@ -738,6 +776,41 @@ class Dialled(WireModel):
     to: str
     from_: str = Field(alias="from")
     env: Env
+    log_token: str
+
+
+# POST /v1/codes, the answer: the four digits a page shows beside the agent's number, when they stop
+# being a code, and the token the page asks about them with.
+class Code(WireModel):
+    """POST /v1/codes, the answer."""
+
+    code: str
+    number: str
+    expires_at: float
+    code_token: str
+
+
+# GET /v1/codes/{code}: whether a call has claimed the code yet, and once one has, the call and the
+# token that reads it.
+class CodeStanding(WireModel):
+    """GET /v1/codes/{code}."""
+
+    code: str
+    status: Literal["waiting", "claimed", "expired"]
+    expires_at: float
+    call: str | None
+    log_token: str | None
+
+
+# POST /v1/tokens, the answer: where the browser joins, as whom, the call it becomes, and a token
+# that reads that call's log.
+class Minted(WireModel):
+    """POST /v1/tokens, the answer."""
+
+    server_url: str
+    participant_token: str
+    call: str
+    log_token: str
 
 
 class DialGuards(WireModel):
@@ -783,6 +856,8 @@ class TuningBody(WireModel):
     hangup: HangupConfig | None = None
     turn: TurnConfig | None = None
     memory: MemoryConfig | None = None
+    record: bool | None = None
+    max_duration_s: int | None = None
     knowledge: str | None = None
     bases: list[DocsConfig] | None = None
 
@@ -982,6 +1057,11 @@ class Persona(WireModel):
     style: str
     facts: dict[str, str]
     state: dict[str, Any]
+    llm: str | None
+    tts: str | None
+    voice: str | None
+    accepts_when: str
+    declines_when: str
     author: str
     set_at: float
 
@@ -1002,6 +1082,11 @@ class PersonaPut(WireModel):
     style: str
     facts: dict[str, str] | None = None
     state: dict[str, Any] | None = None
+    llm: str | None = None
+    tts: str | None = None
+    voice: str | None = None
+    accepts_when: str | None = None
+    declines_when: str | None = None
     was: str | None = None
 
 
@@ -1028,3 +1113,40 @@ class PersonaRunList(WireModel):
     runs: list[PersonaRun]
     total: int
     next: str | None
+
+
+# One voice a picker offers, as GET /v1/voices lists it: the id the `voice` setting takes, and what
+# a person chooses by. `country` and `accent` are the vendor's own words (`ES` is Spain, `MX`
+# Mexico), empty when the vendor said none.
+class ListedVoice(WireModel):
+    """One voice a picker offers, as GET /v1/voices lists it."""
+
+    id: str
+    name: str
+    language: str
+    description: str
+    gender: str
+    country: str
+    accent: str
+
+
+# GET /v1/voices?tts=&language=: a voice vendor's own voices in one language, in the vendor's order.
+class VoicesListed(WireModel):
+    """GET /v1/voices?tts=&language=."""
+
+    tts: str
+    language: str | None
+    voices: list[ListedVoice]
+
+
+# POST /v1/voices/sample, the body: which vendor, which voice, which model and which words to hear.
+# The answer is the WAV itself (`audio/wav`), with `Server-Timing: first-audio;dur=…, total;dur=…`
+# in milliseconds.
+class VoiceSample(WireModel):
+    """POST /v1/voices/sample, the body."""
+
+    tts: str
+    voice: str
+    model: str | None = None
+    language: str | None = None
+    text: str | None = None

{pinecall_protocol-0.6.2 → pinecall_protocol-0.6.14}/pinecall_protocol/state.py

@@ -134,11 +134,22 @@ class TransferState(WireModel):
     """The transfer in flight or the one that happened."""
 
     to: str
-    mode: TransferMode
+    mode: TransferMode | None = None
     status: Literal["requested", "done", "failed"]
     by: Literal["agent", "supervisor"]
 
 
+# The agent's last ask for a person, from attention.requested until attention.answered settles it.
+class AttentionState(WireModel):
+    """AttentionState, as protocol/schema declares it."""
+
+    reason: str
+    wait_s: float
+    status: Literal["open", "answered", "lapsed"]
+    asked_at: float
+    by: Supervisor | None
+
+
 class LiveTranscript(WireModel):
     """The words on screen right now: interim transcripts that a finished turn clears."""
 
@@ -233,6 +244,7 @@ class State(WireModel):
     held: bool
     muted: bool
     transfer: TransferState | None
+    attention: AttentionState | None = None
     usage: list[ModelUsage]
     cost: Cost | None
     routes: list[Route]

{pinecall_protocol-0.6.2 → pinecall_protocol-0.6.14}/pinecall_protocol/verbs.py

@@ -45,12 +45,13 @@ class TransferVerb(WireModel):
 
     verb: Literal["transfer"] = "transfer"
     to: str
-    mode: TransferMode
+    mode: TransferMode | None = None
 
 
-# Logged as supervisor.ended, then call.ended with reason supervisor_ended.
+# Hang up on the caller's behalf, at once: a sentence playing and a reply still being written are
+# cut, not finished. Logged as supervisor.ended, then call.ended with reason supervisor_ended.
 class EndVerb(WireModel):
-    """Hang up on the caller's behalf."""
+    """Hang up on the caller's behalf, at once."""
 
     verb: Literal["end"] = "end"
     reason: str | None = None

pinecall_protocol-0.6.2/pinecall_protocol/_version.py

@@ -1,4 +0,0 @@
-"""The one place the version lives; hatch reads it from here at build time."""
-
-# 0.0.0 means "unreleased". The number is the maintainer's call and is never bumped from code.
-__version__ = "0.6.2"