@pinecall/protocol 0.1.0 → 0.3.0

package/dist/fixtures/call-log-golden.json

@@ -122,6 +122,6 @@
 {"seq": 122, "ts": 1786537552.4, "call": "CA_8f4a2c", "agent": "clinica-norte", "type": "call.ended", "ephemeral": false, "data": {"reason": "caller_hung_up", "ended_by": "caller", "ended_at": 1786537552.4, "duration_s": 51.988}},
 {"seq": 123, "ts": 1786537552.81, "call": "CA_8f4a2c", "agent": "clinica-norte", "type": "memory.ops", "ephemeral": false, "data": {"ops": [{"op": "remember", "contact": "ct_7d1e", "facts": [{"id": "mem_03", "text": "Cita de revisión con la Dra. Vidal el 2026-08-13 a las 09:30 (BK-5521)", "source": "CA_8f4a2c"}], "took_ms": 410}]}},
 {"seq": 124, "ts": 1786537553.46, "call": "CA_8f4a2c", "agent": "clinica-norte", "type": "call.summary", "ephemeral": false, "data": {"reason": "caller_hung_up", "outcome": "booked BK-5521: revisión Dra. Vidal, jueves 13 a las 09:30", "duration_s": 51.988, "turns": 11, "usage": [{"type": "llm_usage", "provider": "anthropic", "model": "claude-haiku-4-5", "input_tokens": 14963, "input_cached_tokens": 13145, "input_cache_creation_tokens": 562, "input_audio_tokens": 0, "input_cached_audio_tokens": 0, "input_text_tokens": 0, "input_cached_text_tokens": 0, "input_image_tokens": 0, "input_cached_image_tokens": 0, "output_tokens": 281, "output_audio_tokens": 0, "output_text_tokens": 0, "output_reasoning_tokens": 0, "session_duration": 0.0}, {"type": "tts_usage", "provider": "elevenlabs", "model": "eleven_flash_v2_5", "input_tokens": 0, "output_tokens": 0, "characters_count": 397, "audio_duration": 25.6}, {"type": "stt_usage", "provider": "soniox", "model": "stt-rt-v5", "input_tokens": 0, "output_tokens": 0, "audio_duration": 12.1}, {"type": "interruption_usage", "provider": "livekit", "model": "adaptive", "total_requests": 12}, {"type": "eot_usage", "provider": "livekit", "model": "turn-detector-v1", "total_requests": 5}], "cost": {"eur": 0.022937, "rate": {"currency": "EUR", "usd_to_eur": 0.92, "as_of": "2026-08-12"}, "rows": [{"provider": "anthropic", "model": "claude-haiku-4-5", "unit": "input_tokens", "quantity": 1256, "unit_price_usd": 1e-06, "eur": 0.001156}, {"provider": "anthropic", "model": "claude-haiku-4-5", "unit": "cached_input_tokens", "quantity": 13145, "unit_price_usd": 1e-07, "eur": 0.001209}, {"provider": "anthropic", "model": "claude-haiku-4-5", "unit": "cache_creation_tokens", "quantity": 562, "unit_price_usd": 1.25e-06, "eur": 0.000646}, {"provider": "anthropic", "model": "claude-haiku-4-5", "unit": "output_tokens", "quantity": 281, "unit_price_usd": 5e-06, "eur": 0.001293}, {"provider": "elevenlabs", "model": "eleven_flash_v2_5", "unit": "characters", "quantity": 397, "unit_price_usd": 5e-05, "eur": 0.018262}, {"provider": "soniox", "model": "stt-rt-v5", "unit": "audio_seconds", "quantity": 12.1, "unit_price_usd": 3.33e-05, "eur": 0.000371}], "unpriced": [{"provider": "livekit", "model": "adaptive"}, {"provider": "livekit", "model": "turn-detector-v1"}]}, "recording": "recordings/2026/08/12/CA_8f4a2c.ogg"}},
-{"seq": 125, "ts": 1786537553.102, "call": "CA_8f4a2c", "agent": "clinica-norte", "type": "call.score", "ephemeral": false, "data": {"passed": false, "judges": [{"name": "consent", "verdict": "broken", "criteria": "Every irreversible tool call in this conversation ran after a confirm.granted for the same tool call and the same audience.", "reason": "book_slot ran at seq 79, before its confirm.granted at seq 93", "evidence": {"seqs": [79, 93], "said": "Sí, confirmo."}}], "panel": ["consent", "grounded"], "judge_calls": 0}},
+{"seq": 125, "ts": 1786537553.102, "call": "CA_8f4a2c", "agent": "clinica-norte", "type": "call.score", "ephemeral": false, "data": {"passed": false, "judges": [{"name": "consent", "verdict": "broken", "criteria": "Every irreversible tool call in this conversation ran after a confirm.granted for the same tool call and the same audience.", "reason": "book_slot ran at seq 79, before its confirm.granted at seq 93", "evidence": {"seqs": [79, 93], "said": "Sí, confirmo."}}], "panel": ["consent", "grounded", "promises"], "judge_calls": 0}},
 {"seq": 125, "ts": 1786537553.461, "call": "CA_8f4a2c", "agent": "clinica-norte", "type": "log.caught_up", "ephemeral": true, "data": {"seq": 125}}
 ]

package/dist/generated/events.d.ts

@@ -52,8 +52,10 @@ export declare const AgentStateChangedSchema: z.ZodObject<{
 }, z.core.$strict>;
 export type AgentStateChanged = z.infer<typeof AgentStateChangedSchema>;
 /**
- * Words from the agent as they are played, synced to the audio. Interim while final is false; the
- * whole reply becomes turn.agent. Interim entries are ephemeral.
+ * One delta of the reply the agent is giving, never the reply so far: in a voice call one word, as
+ * the voice plays it, with the seconds it was aligned to; in a written call one model token. The
+ * reply so far is every delta of the same speech_id since the last turn.agent, joined; turn.agent
+ * carries the whole reply and closes it. Interim entries are ephemeral.
  */
 export declare const AgentTranscriptSchema: z.ZodObject<{
     speech_id: z.ZodString;
@@ -84,6 +86,7 @@ export declare const CallDialingSchema: z.ZodObject<{
         external_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     }, z.core.$strict>>;
     external_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    asked_by: z.ZodOptional<z.ZodNullable<z.ZodString>>;
 }, z.core.$strict>;
 export type CallDialing = z.infer<typeof CallDialingSchema>;
 /** The call is over. Nothing about the conversation follows; call.summary still does. */

package/dist/generated/events.js

@@ -32,8 +32,10 @@ export const AgentStateChangedSchema = z.strictObject({
     state: AgentStateSchema,
 });
 /**
- * Words from the agent as they are played, synced to the audio. Interim while final is false; the
- * whole reply becomes turn.agent. Interim entries are ephemeral.
+ * One delta of the reply the agent is giving, never the reply so far: in a voice call one word, as
+ * the voice plays it, with the seconds it was aligned to; in a written call one model token. The
+ * reply so far is every delta of the same speech_id since the last turn.agent, joined; turn.agent
+ * carries the whole reply and closes it. Interim entries are ephemeral.
  */
 export const AgentTranscriptSchema = z.strictObject({
     speech_id: z.string(),
@@ -53,6 +55,7 @@ export const CallDialingSchema = z.strictObject({
     run: z.string().nullable().nullish(),
     caller: ContactSchema.nullable(),
     external_id: z.string().nullish(),
+    asked_by: z.string().nullish(),
 });
 /** The call is over. Nothing about the conversation follows; call.summary still does. */
 export const CallEndedSchema = z.strictObject({

package/dist/generated/registry.d.ts

@@ -61,6 +61,7 @@ export declare const EVENT_SCHEMAS: {
             external_id: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
         }, import("zod/v4/core").$strict>>;
         external_id: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+        asked_by: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
     }, import("zod/v4/core").$strict>;
     readonly "call.ended": import("zod").ZodObject<{
         reason: import("zod").ZodEnum<{

package/dist/generated/rest.d.ts

@@ -494,6 +494,28 @@ export declare const LogPageSchema: z.ZodObject<{
     next: z.ZodNullable<z.ZodInt>;
 }, z.core.$strict>;
 export type LogPage = z.infer<typeof LogPageSchema>;
+/**
+ * One call's call.score as a list draws it: how many judges held of how many answered, and why the
+ * first one that broke did.
+ */
+export declare const SessionScoreSchema: z.ZodObject<{
+    held: z.ZodInt;
+    judged: z.ZodInt;
+    passed: z.ZodBoolean;
+    reason: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type SessionScore = z.infer<typeof SessionScoreSchema>;
+/**
+ * escalated: a person took part — a transfer, a supervisor taking the line, saying something, or
+ * ending the call. low_score: a judge answered broken. promise: the promises judge found the agent
+ * committing the business to something no tool call records.
+ */
+export declare const SessionFlagSchema: z.ZodEnum<{
+    promise: "promise";
+    escalated: "escalated";
+    low_score: "low_score";
+}>;
+export type SessionFlag = z.infer<typeof SessionFlagSchema>;
 /** One call as a list draws it: which call, how far the log got, and the state's own fields. */
 export declare const SessionLineSchema: z.ZodObject<{
     call: z.ZodString;
@@ -570,9 +592,23 @@ export declare const SessionLineSchema: z.ZodObject<{
             model: z.ZodString;
         }, z.core.$strict>>;
     }, z.core.$strict>>;
+    score: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodObject<{
+        held: z.ZodInt;
+        judged: z.ZodInt;
+        passed: z.ZodBoolean;
+        reason: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>>>;
+    flags: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodEnum<{
+        promise: "promise";
+        escalated: "escalated";
+        low_score: "low_score";
+    }>>>>;
 }, z.core.$strict>;
 export type SessionLine = z.infer<typeof SessionLineSchema>;
-/** GET /v1/agents/{slug}/sessions: which calls that agent handled, newest first. */
+/**
+ * GET /v1/agents/{slug}/sessions and GET /v1/sessions: the calls that match, newest first, a page
+ * at a time.
+ */
 export declare const SessionListSchema: z.ZodObject<{
     calls: z.ZodArray<z.ZodObject<{
         call: z.ZodString;
@@ -649,9 +685,413 @@ export declare const SessionListSchema: z.ZodObject<{
                 model: z.ZodString;
             }, z.core.$strict>>;
         }, z.core.$strict>>;
+        score: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodObject<{
+            held: z.ZodInt;
+            judged: z.ZodInt;
+            passed: z.ZodBoolean;
+            reason: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>>>>;
+        flags: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodEnum<{
+            promise: "promise";
+            escalated: "escalated";
+            low_score: "low_score";
+        }>>>>;
     }, z.core.$strict>>;
+    total: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodInt>>>;
+    next: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodString>>>;
 }, z.core.$strict>;
 export type SessionList = z.infer<typeof SessionListSchema>;
+/** How many calls started on the day, and on the day before it. */
+export declare const InsightsConversationsSchema: z.ZodObject<{
+    today: z.ZodInt;
+    yesterday: z.ZodInt;
+}, z.core.$strict>;
+export type InsightsConversations = z.infer<typeof InsightsConversationsSchema>;
+/** The day's calls by the door they came in by. */
+export declare const InsightsChannelsSchema: z.ZodObject<{
+    phone: z.ZodInt;
+    web: z.ZodInt;
+    whatsapp: z.ZodInt;
+}, z.core.$strict>;
+export type InsightsChannels = z.infer<typeof InsightsChannelsSchema>;
+/** One agent's day. */
+export declare const InsightsAgentSchema: z.ZodObject<{
+    slug: z.ZodString;
+    today: z.ZodInt;
+    score: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strict>;
+export type InsightsAgent = z.infer<typeof InsightsAgentSchema>;
+/** What the org may spend in a month and what it has spent so far, both worlds together. */
+export declare const InsightsBudgetSchema: z.ZodObject<{
+    limit_eur: z.ZodNullable<z.ZodNumber>;
+    spent_eur_month: z.ZodNumber;
+}, z.core.$strict>;
+export type InsightsBudget = z.infer<typeof InsightsBudgetSchema>;
+/**
+ * GET /v1/insights: one day of the key's world and corner at a glance, counted off the call index
+ * and never off a log.
+ */
+export declare const InsightsSchema: z.ZodObject<{
+    day: z.ZodString;
+    timezone: z.ZodString;
+    conversations: z.ZodObject<{
+        today: z.ZodInt;
+        yesterday: z.ZodInt;
+    }, z.core.$strict>;
+    resolved_rate: z.ZodNullable<z.ZodNumber>;
+    median_e2e_s: z.ZodNullable<z.ZodNumber>;
+    spend_eur: z.ZodNumber;
+    channels: z.ZodObject<{
+        phone: z.ZodInt;
+        web: z.ZodInt;
+        whatsapp: z.ZodInt;
+    }, z.core.$strict>;
+    sessions_total: z.ZodInt;
+    live: z.ZodInt;
+    agents: z.ZodArray<z.ZodObject<{
+        slug: z.ZodString;
+        today: z.ZodInt;
+        score: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strict>>;
+    budget: z.ZodObject<{
+        limit_eur: z.ZodNullable<z.ZodNumber>;
+        spent_eur_month: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type Insights = z.infer<typeof InsightsSchema>;
+/**
+ * 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.
+ */
+export declare const JudgingSchema: z.ZodObject<{
+    on: z.ZodBoolean;
+    ceiling_eur: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strict>;
+export type Judging = z.infer<typeof JudgingSchema>;
+/** PUT /v1/org/judging, the body. */
+export declare const JudgingWantedSchema: z.ZodObject<{
+    on: z.ZodBoolean;
+}, z.core.$strict>;
+export type JudgingWanted = z.infer<typeof JudgingWantedSchema>;
+/**
+ * in: the contact wrote it. out: the agent, or a person as the agent, did. call: a spoken call,
+ * drawn as one pill.
+ */
+export declare const ThreadKindSchema: z.ZodEnum<{
+    call: "call";
+    out: "out";
+    in: "in";
+}>;
+export type ThreadKind = z.infer<typeof ThreadKindSchema>;
+/** The newest thing on a contact's thread. */
+export declare const ThreadLastSchema: z.ZodObject<{
+    text: z.ZodNullable<z.ZodString>;
+    at: z.ZodNumber;
+    kind: z.ZodEnum<{
+        call: "call";
+        out: "out";
+        in: "in";
+    }>;
+}, z.core.$strict>;
+export type ThreadLast = z.infer<typeof ThreadLastSchema>;
+/** One contact of an agent's inbox: every call of theirs, folded into one line. */
+export declare const ThreadLineSchema: z.ZodObject<{
+    contact: z.ZodString;
+    name: z.ZodNullable<z.ZodString>;
+    channel_last: z.ZodEnum<{
+        phone: "phone";
+        web: "web";
+        whatsapp: "whatsapp";
+    }>;
+    last: z.ZodObject<{
+        text: z.ZodNullable<z.ZodString>;
+        at: z.ZodNumber;
+        kind: z.ZodEnum<{
+            call: "call";
+            out: "out";
+            in: "in";
+        }>;
+    }, z.core.$strict>;
+    unread: z.ZodInt;
+    calls: z.ZodInt;
+}, z.core.$strict>;
+export type ThreadLine = z.infer<typeof ThreadLineSchema>;
+/** GET /v1/agents/{slug}/threads: the agent's contacts, the newest thread first. */
+export declare const ThreadListSchema: z.ZodObject<{
+    threads: z.ZodArray<z.ZodObject<{
+        contact: z.ZodString;
+        name: z.ZodNullable<z.ZodString>;
+        channel_last: z.ZodEnum<{
+            phone: "phone";
+            web: "web";
+            whatsapp: "whatsapp";
+        }>;
+        last: z.ZodObject<{
+            text: z.ZodNullable<z.ZodString>;
+            at: z.ZodNumber;
+            kind: z.ZodEnum<{
+                call: "call";
+                out: "out";
+                in: "in";
+            }>;
+        }, z.core.$strict>;
+        unread: z.ZodInt;
+        calls: z.ZodInt;
+    }, z.core.$strict>>;
+    next: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type ThreadList = z.infer<typeof ThreadListSchema>;
+/** One message of a thread, or one spoken call drawn as a pill. */
+export declare const ThreadMessageSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        call: "call";
+        out: "out";
+        in: "in";
+    }>;
+    text: z.ZodNullable<z.ZodString>;
+    at: z.ZodNumber;
+    call: z.ZodString;
+    channel: z.ZodEnum<{
+        phone: "phone";
+        web: "web";
+        whatsapp: "whatsapp";
+    }>;
+    duration_s: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodNumber>>>;
+    answered: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+}, z.core.$strict>;
+export type ThreadMessage = z.infer<typeof ThreadMessageSchema>;
+/** GET /v1/agents/{slug}/threads/{contact}: every call of one contact, merged, oldest first. */
+export declare const ThreadSchema: z.ZodObject<{
+    contact: z.ZodString;
+    name: z.ZodNullable<z.ZodString>;
+    messages: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            call: "call";
+            out: "out";
+            in: "in";
+        }>;
+        text: z.ZodNullable<z.ZodString>;
+        at: z.ZodNumber;
+        call: z.ZodString;
+        channel: z.ZodEnum<{
+            phone: "phone";
+            web: "web";
+            whatsapp: "whatsapp";
+        }>;
+        duration_s: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodNumber>>>;
+        answered: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type Thread = z.infer<typeof ThreadSchema>;
+/** POST /v1/agents/{slug}/threads/{contact}/messages, the body. */
+export declare const ThreadSaySchema: z.ZodObject<{
+    text: z.ZodString;
+}, z.core.$strict>;
+export type ThreadSay = z.infer<typeof ThreadSaySchema>;
+/**
+ * POST /v1/agents/{slug}/threads/{contact}/messages, the answer: the call it was said on. The
+ * turn.agent it lands as is on that call's log.
+ */
+export declare const ThreadSaidSchema: z.ZodObject<{
+    contact: z.ZodString;
+    call: z.ZodString;
+}, z.core.$strict>;
+export type ThreadSaid = z.infer<typeof ThreadSaidSchema>;
+/** One current fact memory holds, across the contacts an agent's calls taught. */
+export declare const AgentFactSchema: z.ZodObject<{
+    id: z.ZodString;
+    contact: z.ZodString;
+    text: z.ZodString;
+    category: z.ZodNullable<z.ZodString>;
+    written_at: z.ZodNumber;
+}, z.core.$strict>;
+export type AgentFact = z.infer<typeof AgentFactSchema>;
+/** GET /v1/agents/{slug}/memory: the current facts the agent's calls taught, newest first. */
+export declare const AgentMemorySchema: z.ZodObject<{
+    facts: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        contact: z.ZodString;
+        text: z.ZodString;
+        category: z.ZodNullable<z.ZodString>;
+        written_at: z.ZodNumber;
+    }, z.core.$strict>>;
+    next: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type AgentMemory = z.infer<typeof AgentMemorySchema>;
+/**
+ * GET and PUT /v1/agents/{slug}/widget: how the widget presents this agent, kept per org, world
+ * and agent. PUT takes the whole set.
+ */
+export declare const WidgetSettingsSchema: z.ZodObject<{
+    title: z.ZodNullable<z.ZodString>;
+    tagline: z.ZodNullable<z.ZodString>;
+    greeting: z.ZodNullable<z.ZodString>;
+    accent: z.ZodNullable<z.ZodString>;
+    autostart: z.ZodBoolean;
+}, z.core.$strict>;
+export type WidgetSettings = z.infer<typeof WidgetSettingsSchema>;
+/**
+ * GET and PUT /v1/org/sso: the OpenID Connect provider this org's people sign in at, and never the
+ * client secret it was wired with.
+ */
+export declare const OrgSsoSchema: z.ZodObject<{
+    configured: z.ZodBoolean;
+    issuer: z.ZodNullable<z.ZodString>;
+    client_id: z.ZodNullable<z.ZodString>;
+    domains: z.ZodArray<z.ZodString>;
+    role: z.ZodNullable<z.ZodString>;
+    required: z.ZodBoolean;
+    redirect_uri: z.ZodString;
+}, z.core.$strict>;
+export type OrgSso = z.infer<typeof OrgSsoSchema>;
+/**
+ * PUT /v1/org/sso, the body. The configuration is replaced whole, the client secret included: it
+ * is write-only, so a change of anything else carries it again.
+ */
+export declare const OrgSsoWantedSchema: z.ZodObject<{
+    issuer: z.ZodString;
+    client_id: z.ZodString;
+    client_secret: z.ZodString;
+    domains: z.ZodArray<z.ZodString>;
+    role: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodString>>>;
+    required: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+}, z.core.$strict>;
+export type OrgSsoWanted = z.infer<typeof OrgSsoWantedSchema>;
+/**
+ * GET and PUT /v1/org/mail: the SMTP account this org's letters go out through, how the last one
+ * went, and never the password it was wired with. An org that wired none sends through the box's
+ * own mail, or through nothing.
+ */
+export declare const OrgMailSchema: z.ZodObject<{
+    configured: z.ZodBoolean;
+    host: z.ZodNullable<z.ZodString>;
+    port: z.ZodNullable<z.ZodInt>;
+    security: z.ZodNullable<z.ZodString>;
+    username: z.ZodNullable<z.ZodString>;
+    from: z.ZodNullable<z.ZodString>;
+    verified_at: z.ZodNullable<z.ZodString>;
+    last_error: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type OrgMail = z.infer<typeof OrgMailSchema>;
+/**
+ * PUT /v1/org/mail, the body. The account is replaced whole, the password included: it is write-
+ * only, so a change of anything else carries it again — and the standing is reset with it, since
+ * what a server said about the old password is not news about a new one.
+ */
+export declare const OrgMailWantedSchema: z.ZodObject<{
+    host: z.ZodString;
+    port: z.ZodInt;
+    security: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        starttls: "starttls";
+        tls: "tls";
+        none: "none";
+    }>>>;
+    username: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    password: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    from: z.ZodString;
+}, z.core.$strict>;
+export type OrgMailWanted = z.infer<typeof OrgMailWantedSchema>;
+/**
+ * GET and PUT /v1/ops/mail: the SMTP account the BOX posts its letters through — what the operator
+ * stored, or the environment's two variables — how the last one went, and never the password. An
+ * org's own account (OrgMail) still wins over both.
+ */
+export declare const BoxMailSchema: z.ZodObject<{
+    configured: z.ZodBoolean;
+    source: z.ZodNullable<z.ZodString>;
+    host: z.ZodNullable<z.ZodString>;
+    port: z.ZodNullable<z.ZodInt>;
+    security: z.ZodNullable<z.ZodString>;
+    username: z.ZodNullable<z.ZodString>;
+    from: z.ZodNullable<z.ZodString>;
+    verified_at: z.ZodNullable<z.ZodString>;
+    last_error: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type BoxMail = z.infer<typeof BoxMailSchema>;
+/**
+ * GET and PUT /v1/ops/brand, and `brand` on GET /.well-known/pinecall: what this box's letters and
+ * its sign-in page are called and painted with. Pinecall, its accent and no logo until the
+ * operator says.
+ */
+export declare const BoxBrandSchema: z.ZodObject<{
+    name: z.ZodString;
+    logo_url: z.ZodNullable<z.ZodString>;
+    accent: z.ZodString;
+}, z.core.$strict>;
+export type BoxBrand = z.infer<typeof BoxBrandSchema>;
+/**
+ * PUT /v1/ops/brand, the body. A field left out keeps what it had; an empty string goes back to
+ * the default — which for the logo is none at all, the only way to clear one.
+ */
+export declare const BoxBrandWantedSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodString>>>;
+    logo_url: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodString>>>;
+    accent: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodString>>>;
+}, z.core.$strict>;
+export type BoxBrandWanted = z.infer<typeof BoxBrandWantedSchema>;
+/**
+ * One box-wide identity provider as the operator reads it: whether it is usable, the client this
+ * gateway is at it, and the URI to register there. Never the secret.
+ */
+export declare const BoxProviderSchema: z.ZodObject<{
+    configured: z.ZodBoolean;
+    client_id: z.ZodNullable<z.ZodString>;
+    redirect_uri: z.ZodString;
+}, z.core.$strict>;
+export type BoxProvider = z.infer<typeof BoxProviderSchema>;
+/**
+ * GET /v1/ops/signin: every provider this box can offer every org's people, wired or not, one key
+ * each. Only `google` today; a second is a key here and a row on the box.
+ */
+export declare const BoxSignInSchema: z.ZodObject<{
+    google: z.ZodObject<{
+        configured: z.ZodBoolean;
+        client_id: z.ZodNullable<z.ZodString>;
+        redirect_uri: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type BoxSignIn = z.infer<typeof BoxSignInSchema>;
+/**
+ * PUT /v1/ops/signin/google, the body: the OAuth client the operator made at Google for this
+ * gateway. Replaced whole, the secret write-only; the issuer is Google's own and is not a field.
+ */
+export declare const BoxProviderWantedSchema: z.ZodObject<{
+    client_id: z.ZodString;
+    client_secret: z.ZodString;
+}, z.core.$strict>;
+export type BoxProviderWanted = z.infer<typeof BoxProviderWantedSchema>;
+/**
+ * POST /v1/org/mail/test: one letter, waited for — the only door of this runtime that waits for a
+ * mail server, because it is the one a person is watching.
+ */
+export declare const MailSentSchema: z.ZodObject<{
+    sent: z.ZodBoolean;
+    error: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type MailSent = z.infer<typeof MailSentSchema>;
+/**
+ * One org a sign-in page may send somebody to, named — and nothing about whether anybody answers
+ * to the address that asked.
+ */
+export declare const SsoOrgSchema: z.ZodObject<{
+    org: z.ZodString;
+    slug: z.ZodString;
+    name: z.ZodString;
+}, z.core.$strict>;
+export type SsoOrg = z.infer<typeof SsoOrgSchema>;
+/**
+ * POST /v1/login/sso/discover: the orgs whose domains match an address's and that wired a
+ * provider. Empty is the answer for a domain nobody wired, and for a box that keeps no provider at
+ * all.
+ */
+export declare const SsoDiscoverySchema: z.ZodObject<{
+    orgs: z.ZodArray<z.ZodObject<{
+        org: z.ZodString;
+        slug: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type SsoDiscovery = z.infer<typeof SsoDiscoverySchema>;
 /** One corner of a world holding an agent: the member whose it is, named so a person can read it. */
 export declare const LineHolderSchema: z.ZodObject<{
     holder: z.ZodNullable<z.ZodString>;
@@ -1029,3 +1469,52 @@ export declare const RememberedSchema: z.ZodObject<{
     took_ms: z.ZodNumber;
 }, z.core.$strict>;
 export type Remembered = z.infer<typeof RememberedSchema>;
+/**
+ * POST /v1/agents/{slug}/dial, the answer: the call a dial became, accepted before the far end has
+ * heard anything ring.
+ */
+export declare const DialledSchema: z.ZodObject<{
+    call: z.ZodString;
+    agent: z.ZodString;
+    to: z.ZodString;
+    from: z.ZodString;
+    env: z.ZodEnum<{
+        production: "production";
+        sandbox: "sandbox";
+    }>;
+}, z.core.$strict>;
+export type Dialled = z.infer<typeof DialledSchema>;
+/** GET /v1/carrier/outbound, the guards: what this org may dial and how often. */
+export declare const DialGuardsSchema: z.ZodObject<{
+    dial_anywhere: z.ZodBoolean;
+    per_minute: z.ZodInt;
+    per_day: z.ZodInt;
+    max_duration_s: z.ZodInt;
+}, z.core.$strict>;
+export type DialGuards = z.infer<typeof DialGuardsSchema>;
+/**
+ * GET /v1/carrier/outbound, the answer: whether this org can place a call yet, and what is
+ * missing.
+ */
+export declare const CarrierOutboundSchema: z.ZodObject<{
+    ready: z.ZodBoolean;
+    kind: z.ZodNullable<z.ZodString>;
+    from_numbers: z.ZodArray<z.ZodString>;
+    steps_missing: z.ZodArray<z.ZodString>;
+    guards: z.ZodObject<{
+        dial_anywhere: z.ZodBoolean;
+        per_minute: z.ZodInt;
+        per_day: z.ZodInt;
+        max_duration_s: z.ZodInt;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type CarrierOutbound = z.infer<typeof CarrierOutboundSchema>;
+/** POST /v1/carrier/outbound, the answer: the plan, and whether it was carried out. */
+export declare const OutboundProvisionedSchema: z.ZodObject<{
+    steps: z.ZodArray<z.ZodString>;
+    dry_run: z.ZodBoolean;
+    ready: z.ZodBoolean;
+    trunk: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    address: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strict>;
+export type OutboundProvisioned = z.infer<typeof OutboundProvisionedSchema>;

package/dist/generated/rest.js

@@ -15,6 +15,22 @@ export const LogPageSchema = z.strictObject({
     live: z.boolean(),
     next: z.int().nullable(),
 });
+/**
+ * One call's call.score as a list draws it: how many judges held of how many answered, and why the
+ * first one that broke did.
+ */
+export const SessionScoreSchema = z.strictObject({
+    held: z.int(),
+    judged: z.int(),
+    passed: z.boolean(),
+    reason: z.string().nullable(),
+});
+/**
+ * escalated: a person took part — a transfer, a supervisor taking the line, saying something, or
+ * ending the call. low_score: a judge answered broken. promise: the promises judge found the agent
+ * committing the business to something no tool call records.
+ */
+export const SessionFlagSchema = z.enum(["escalated", "low_score", "promise"]);
 /** One call as a list draws it: which call, how far the log got, and the state's own fields. */
 export const SessionLineSchema = z.strictObject({
     call: z.string(),
@@ -32,10 +48,282 @@ export const SessionLineSchema = z.strictObject({
     end_reason: EndReasonSchema.nullable(),
     outcome: z.string().nullable(),
     cost: CostSchema.nullable(),
+    score: SessionScoreSchema.nullable().nullish(),
+    flags: z.array(SessionFlagSchema).nullish(),
 });
-/** GET /v1/agents/{slug}/sessions: which calls that agent handled, newest first. */
+/**
+ * GET /v1/agents/{slug}/sessions and GET /v1/sessions: the calls that match, newest first, a page
+ * at a time.
+ */
 export const SessionListSchema = z.strictObject({
     calls: z.array(SessionLineSchema),
+    total: z.int().nullable().nullish(),
+    next: z.string().nullable().nullish(),
+});
+/** How many calls started on the day, and on the day before it. */
+export const InsightsConversationsSchema = z.strictObject({
+    today: z.int(),
+    yesterday: z.int(),
+});
+/** The day's calls by the door they came in by. */
+export const InsightsChannelsSchema = z.strictObject({
+    phone: z.int(),
+    web: z.int(),
+    whatsapp: z.int(),
+});
+/** One agent's day. */
+export const InsightsAgentSchema = z.strictObject({
+    slug: z.string(),
+    today: z.int(),
+    score: z.number().nullable(),
+});
+/** What the org may spend in a month and what it has spent so far, both worlds together. */
+export const InsightsBudgetSchema = z.strictObject({
+    limit_eur: z.number().nullable(),
+    spent_eur_month: z.number(),
+});
+/**
+ * GET /v1/insights: one day of the key's world and corner at a glance, counted off the call index
+ * and never off a log.
+ */
+export const InsightsSchema = z.strictObject({
+    day: z.string(),
+    timezone: z.string(),
+    conversations: InsightsConversationsSchema,
+    resolved_rate: z.number().nullable(),
+    median_e2e_s: z.number().nullable(),
+    spend_eur: z.number(),
+    channels: InsightsChannelsSchema,
+    sessions_total: z.int(),
+    live: z.int(),
+    agents: z.array(InsightsAgentSchema),
+    budget: InsightsBudgetSchema,
+});
+/**
+ * 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.
+ */
+export const JudgingSchema = z.strictObject({
+    on: z.boolean(),
+    ceiling_eur: z.number().nullable(),
+});
+/** PUT /v1/org/judging, the body. */
+export const JudgingWantedSchema = z.strictObject({
+    on: z.boolean(),
+});
+/**
+ * in: the contact wrote it. out: the agent, or a person as the agent, did. call: a spoken call,
+ * drawn as one pill.
+ */
+export const ThreadKindSchema = z.enum(["in", "out", "call"]);
+/** The newest thing on a contact's thread. */
+export const ThreadLastSchema = z.strictObject({
+    text: z.string().nullable(),
+    at: z.number(),
+    kind: ThreadKindSchema,
+});
+/** One contact of an agent's inbox: every call of theirs, folded into one line. */
+export const ThreadLineSchema = z.strictObject({
+    contact: z.string(),
+    name: z.string().nullable(),
+    channel_last: ChannelSchema,
+    last: ThreadLastSchema,
+    unread: z.int(),
+    calls: z.int(),
+});
+/** GET /v1/agents/{slug}/threads: the agent's contacts, the newest thread first. */
+export const ThreadListSchema = z.strictObject({
+    threads: z.array(ThreadLineSchema),
+    next: z.string().nullable(),
+});
+/** One message of a thread, or one spoken call drawn as a pill. */
+export const ThreadMessageSchema = z.strictObject({
+    kind: ThreadKindSchema,
+    text: z.string().nullable(),
+    at: z.number(),
+    call: z.string(),
+    channel: ChannelSchema,
+    duration_s: z.number().nullable().nullish(),
+    answered: z.boolean().nullish(),
+});
+/** GET /v1/agents/{slug}/threads/{contact}: every call of one contact, merged, oldest first. */
+export const ThreadSchema = z.strictObject({
+    contact: z.string(),
+    name: z.string().nullable(),
+    messages: z.array(ThreadMessageSchema),
+});
+/** POST /v1/agents/{slug}/threads/{contact}/messages, the body. */
+export const ThreadSaySchema = z.strictObject({
+    text: z.string(),
+});
+/**
+ * POST /v1/agents/{slug}/threads/{contact}/messages, the answer: the call it was said on. The
+ * turn.agent it lands as is on that call's log.
+ */
+export const ThreadSaidSchema = z.strictObject({
+    contact: z.string(),
+    call: z.string(),
+});
+/** One current fact memory holds, across the contacts an agent's calls taught. */
+export const AgentFactSchema = z.strictObject({
+    id: z.string(),
+    contact: z.string(),
+    text: z.string(),
+    category: z.string().nullable(),
+    written_at: z.number(),
+});
+/** GET /v1/agents/{slug}/memory: the current facts the agent's calls taught, newest first. */
+export const AgentMemorySchema = z.strictObject({
+    facts: z.array(AgentFactSchema),
+    next: z.string().nullable(),
+});
+/**
+ * GET and PUT /v1/agents/{slug}/widget: how the widget presents this agent, kept per org, world
+ * and agent. PUT takes the whole set.
+ */
+export const WidgetSettingsSchema = z.strictObject({
+    title: z.string().nullable(),
+    tagline: z.string().nullable(),
+    greeting: z.string().nullable(),
+    accent: z.string().nullable(),
+    autostart: z.boolean(),
+});
+/**
+ * GET and PUT /v1/org/sso: the OpenID Connect provider this org's people sign in at, and never the
+ * client secret it was wired with.
+ */
+export const OrgSsoSchema = z.strictObject({
+    configured: z.boolean(),
+    issuer: z.string().nullable(),
+    client_id: z.string().nullable(),
+    domains: z.array(z.string()),
+    role: z.string().nullable(),
+    required: z.boolean(),
+    redirect_uri: z.string(),
+});
+/**
+ * PUT /v1/org/sso, the body. The configuration is replaced whole, the client secret included: it
+ * is write-only, so a change of anything else carries it again.
+ */
+export const OrgSsoWantedSchema = z.strictObject({
+    issuer: z.string(),
+    client_id: z.string(),
+    client_secret: z.string(),
+    domains: z.array(z.string()),
+    role: z.string().nullable().nullish(),
+    required: z.boolean().nullish(),
+});
+/**
+ * GET and PUT /v1/org/mail: the SMTP account this org's letters go out through, how the last one
+ * went, and never the password it was wired with. An org that wired none sends through the box's
+ * own mail, or through nothing.
+ */
+export const OrgMailSchema = z.strictObject({
+    configured: z.boolean(),
+    host: z.string().nullable(),
+    port: z.int().nullable(),
+    security: z.string().nullable(),
+    username: z.string().nullable(),
+    from: z.string().nullable(),
+    verified_at: z.string().nullable(),
+    last_error: z.string().nullable(),
+});
+/**
+ * PUT /v1/org/mail, the body. The account is replaced whole, the password included: it is write-
+ * only, so a change of anything else carries it again — and the standing is reset with it, since
+ * what a server said about the old password is not news about a new one.
+ */
+export const OrgMailWantedSchema = z.strictObject({
+    host: z.string(),
+    port: z.int(),
+    security: z.enum(["starttls", "tls", "none"]).nullish(),
+    username: z.string().nullish(),
+    password: z.string().nullish(),
+    from: z.string(),
+});
+/**
+ * GET and PUT /v1/ops/mail: the SMTP account the BOX posts its letters through — what the operator
+ * stored, or the environment's two variables — how the last one went, and never the password. An
+ * org's own account (OrgMail) still wins over both.
+ */
+export const BoxMailSchema = z.strictObject({
+    configured: z.boolean(),
+    source: z.string().nullable(),
+    host: z.string().nullable(),
+    port: z.int().nullable(),
+    security: z.string().nullable(),
+    username: z.string().nullable(),
+    from: z.string().nullable(),
+    verified_at: z.string().nullable(),
+    last_error: z.string().nullable(),
+});
+/**
+ * GET and PUT /v1/ops/brand, and `brand` on GET /.well-known/pinecall: what this box's letters and
+ * its sign-in page are called and painted with. Pinecall, its accent and no logo until the
+ * operator says.
+ */
+export const BoxBrandSchema = z.strictObject({
+    name: z.string(),
+    logo_url: z.string().nullable(),
+    accent: z.string(),
+});
+/**
+ * PUT /v1/ops/brand, the body. A field left out keeps what it had; an empty string goes back to
+ * the default — which for the logo is none at all, the only way to clear one.
+ */
+export const BoxBrandWantedSchema = z.strictObject({
+    name: z.string().nullable().nullish(),
+    logo_url: z.string().nullable().nullish(),
+    accent: z.string().nullable().nullish(),
+});
+/**
+ * One box-wide identity provider as the operator reads it: whether it is usable, the client this
+ * gateway is at it, and the URI to register there. Never the secret.
+ */
+export const BoxProviderSchema = z.strictObject({
+    configured: z.boolean(),
+    client_id: z.string().nullable(),
+    redirect_uri: z.string(),
+});
+/**
+ * GET /v1/ops/signin: every provider this box can offer every org's people, wired or not, one key
+ * each. Only `google` today; a second is a key here and a row on the box.
+ */
+export const BoxSignInSchema = z.strictObject({
+    google: BoxProviderSchema,
+});
+/**
+ * PUT /v1/ops/signin/google, the body: the OAuth client the operator made at Google for this
+ * gateway. Replaced whole, the secret write-only; the issuer is Google's own and is not a field.
+ */
+export const BoxProviderWantedSchema = z.strictObject({
+    client_id: z.string(),
+    client_secret: z.string(),
+});
+/**
+ * POST /v1/org/mail/test: one letter, waited for — the only door of this runtime that waits for a
+ * mail server, because it is the one a person is watching.
+ */
+export const MailSentSchema = z.strictObject({
+    sent: z.boolean(),
+    error: z.string().nullable(),
+});
+/**
+ * One org a sign-in page may send somebody to, named — and nothing about whether anybody answers
+ * to the address that asked.
+ */
+export const SsoOrgSchema = z.strictObject({
+    org: z.string(),
+    slug: z.string(),
+    name: z.string(),
+});
+/**
+ * POST /v1/login/sso/discover: the orgs whose domains match an address's and that wired a
+ * provider. Empty is the answer for a domain nobody wired, and for a box that keeps no provider at
+ * all.
+ */
+export const SsoDiscoverySchema = z.strictObject({
+    orgs: z.array(SsoOrgSchema),
 });
 /** One corner of a world holding an agent: the member whose it is, named so a person can read it. */
 export const LineHolderSchema = z.strictObject({
@@ -289,3 +577,40 @@ export const RememberedSchema = z.strictObject({
     ops: z.int(),
     took_ms: z.number(),
 });
+/**
+ * POST /v1/agents/{slug}/dial, the answer: the call a dial became, accepted before the far end has
+ * heard anything ring.
+ */
+export const DialledSchema = z.strictObject({
+    call: z.string(),
+    agent: z.string(),
+    to: z.string(),
+    from: z.string(),
+    env: EnvSchema,
+});
+/** GET /v1/carrier/outbound, the guards: what this org may dial and how often. */
+export const DialGuardsSchema = z.strictObject({
+    dial_anywhere: z.boolean(),
+    per_minute: z.int(),
+    per_day: z.int(),
+    max_duration_s: z.int(),
+});
+/**
+ * GET /v1/carrier/outbound, the answer: whether this org can place a call yet, and what is
+ * missing.
+ */
+export const CarrierOutboundSchema = z.strictObject({
+    ready: z.boolean(),
+    kind: z.string().nullable(),
+    from_numbers: z.array(z.string()),
+    steps_missing: z.array(z.string()),
+    guards: DialGuardsSchema,
+});
+/** POST /v1/carrier/outbound, the answer: the plan, and whether it was carried out. */
+export const OutboundProvisionedSchema = z.strictObject({
+    steps: z.array(z.string()),
+    dry_run: z.boolean(),
+    ready: z.boolean(),
+    trunk: z.string().nullish(),
+    address: z.string().nullish(),
+});

package/dist/reduce.js

@@ -151,7 +151,8 @@ function applyEvent(state, entry, event) {
             state.live.user = event.data.final ? null : event.data.text;
             return;
         case "agent.transcript":
-            state.live.agent = event.data.final ? null : event.data.text;
+            // A delta, not the reply so far: one word of a spoken reply, one token of a written one.
+            state.live.agent = event.data.final ? null : saidSoFar(state.live.agent, event.data);
             return;
         case "turn.user":
             state.turns.push({ role: "user", ...event.data });
@@ -350,3 +351,14 @@ function lastIndex(items, matches) {
     }
     return -1;
 }
+/**
+ * The reply in flight with one more delta. A word the voice aligned arrives bare and is set a
+ * space apart; a token of a written reply carries its own spacing, and a space glued between
+ * "clean" and "ing" would be a word nobody said.
+ */
+function saidSoFar(soFar, delta) {
+    if (soFar === null || soFar === "")
+        return delta.text;
+    const apart = /\s$/.test(soFar) || /^\s/.test(delta.text);
+    return delta.start != null && !apart ? `${soFar} ${delta.text}` : `${soFar}${delta.text}`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pinecall/protocol",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "The Pinecall wire: zod schemas and types generated from the protocol schema, and the log reducer",
   "license": "Apache-2.0",
   "author": "Pinecall <hello@pinecall.io>",