@pinecall/protocol 0.2.0 → 0.4.0

package/dist/generated/rest.js

@@ -1,6 +1,6 @@
 // Generated from schema/rest.json: the envelopes the read doors answer in. Never edited by hand.
 import { z } from "zod";
-import { ChannelSchema, ContactSchema, CostSchema, DirectionSchema, EndReasonSchema, EnvSchema, KnowledgeFileSchema, PlatformToolSchema, } from "./defs.js";
+import { ChannelSchema, ContactSchema, CostSchema, DirectionSchema, DocsConfigSchema, EndReasonSchema, EnvSchema, GreetingConfigSchema, HangupConfigSchema, KnowledgeFileSchema, MemoryConfigSchema, PlatformToolSchema, PronunciationSchema, TurnConfigSchema, } from "./defs.js";
 import { EntrySchema } from "./envelope.js";
 import { CallStatusSchema, StateSchema } from "./state.js";
 /** GET /v1/calls/{call}/state: the whole log folded, and the seq a stream resumes from. */
@@ -241,6 +241,65 @@ export const OrgMailWantedSchema = z.strictObject({
     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.
@@ -340,13 +399,15 @@ export const KnowledgeScoreSchema = z.strictObject({
     misses: z.array(GoldenMissSchema),
 });
 /**
- * PUT /v1/knowledge/{base}, the answer: which base, how many chunks it became, and how long that
- * took.
+ * PUT /v1/knowledge/{base}, the answer: which base, how many chunks it became, how long that took,
+ * and what its whole files weigh on every call.
  */
 export const KnowledgePushedSchema = z.strictObject({
     base: z.string(),
     chunks: z.int(),
     took_ms: z.number(),
+    whole_tokens: z.int().nullish(),
+    notice: z.string().nullable().nullish(),
 });
 /** One knowledge base as the list draws it: its name, its size, and when it was last pushed. */
 export const KnowledgeBaseSchema = z.strictObject({
@@ -492,8 +553,9 @@ export const ExtractionRunSchema = z.strictObject({
 });
 /**
  * POST /v1/calls/{call}/lookup, the body: which platform tool to run for this turn, and what to
- * run it with. Worker-only; the gateway runs it against its own stores and writes memory.ops or
- * docs.sources on the call's log itself.
+ * run it with. Asked by the worker for the call it serves, and by the app for a call of its own
+ * org — `this.knowledge.search` in a tool; the gateway runs it against its own stores and writes
+ * memory.ops or docs.sources on the call's log itself.
  */
 export const LookupRequestSchema = z.strictObject({
     tool: PlatformToolSchema,
@@ -509,6 +571,19 @@ export const LookupResultSchema = z.strictObject({
     output: z.record(z.string(), z.unknown()),
     took_ms: z.number(),
 });
+/** One chunk search found: the file it came from, the heading it sits under, and its text. */
+export const FoundChunkSchema = z.strictObject({
+    path: z.string(),
+    heading: z.string().nullable(),
+    text: z.string(),
+});
+/**
+ * What search answers in a lookup's output: the best chunks of every base the agent reads, the
+ * best first. The app's `this.knowledge.search` hands the chunks to the tool that asked.
+ */
+export const SearchFoundSchema = z.strictObject({
+    chunks: z.array(FoundChunkSchema),
+});
 /**
  * POST /v1/calls/{call}/remember, the answer: what the call taught about the contact, counted.
  * Worker-only; the body is empty, the gateway reads the turns off its own log and writes
@@ -534,7 +609,6 @@ export const DialGuardsSchema = z.strictObject({
     dial_anywhere: z.boolean(),
     per_minute: z.int(),
     per_day: z.int(),
-    countries: z.array(z.string()),
     max_duration_s: z.int(),
 });
 /**
@@ -556,3 +630,137 @@ export const OutboundProvisionedSchema = z.strictObject({
     trunk: z.string().nullish(),
     address: z.string().nullish(),
 });
+/**
+ * An agent's tuning: what the org set over what the app declared, per world and per corner. Every
+ * field is optional; one left out is not set, and what the app declared — or the runtime's own
+ * default — stands for it.
+ */
+export const TuningBodySchema = z.strictObject({
+    voice: z.string().nullish(),
+    tts: z.string().nullish(),
+    tts_model: z.string().nullish(),
+    stt: z.string().nullish(),
+    llm: z.string().nullish(),
+    greeting: GreetingConfigSchema.nullish(),
+    hangup: HangupConfigSchema.nullish(),
+    turn: TurnConfigSchema.nullish(),
+    memory: MemoryConfigSchema.nullish(),
+    knowledge: z.array(DocsConfigSchema).nullish(),
+});
+/**
+ * One kept version of an agent's tuning: whose corner, which version, who set it and when, and
+ * what it says.
+ */
+export const TuningRowSchema = z.strictObject({
+    holder: z.string(),
+    version: z.int(),
+    author: z.string(),
+    note: z.string().nullable(),
+    set_at: z.number(),
+    config: TuningBodySchema,
+});
+/**
+ * GET /v1/agents/{slug}/settings: the agent's tuning as this key sees it — its own corner's, the
+ * team's and production's, each corner's own newest row, or null when that corner set nothing.
+ */
+export const TuningAnswerSchema = z.strictObject({
+    world: EnvSchema,
+    yours: TuningRowSchema.nullable(),
+    team: TuningRowSchema.nullable(),
+    production: TuningRowSchema.nullable(),
+});
+/**
+ * PUT /v1/agents/{slug}/settings, the body: the whole set, the version it was read at, why, and
+ * whose corner.
+ */
+export const TuningPutSchema = z.strictObject({
+    config: TuningBodySchema,
+    if_version: z.int().nullable().nullish(),
+    note: z.string().nullable().nullish(),
+    team: z.boolean().nullish(),
+});
+/** GET /v1/agents/{slug}/settings/history: one corner's versions, newest first. */
+export const TuningHistorySchema = z.strictObject({
+    world: EnvSchema,
+    holder: z.string(),
+    rows: z.array(TuningRowSchema),
+});
+/**
+ * GET /v1/agents/{slug}/settings/diff: what this key's corner reads against another corner's
+ * newest, and which fields differ.
+ */
+export const TuningDiffSchema = z.strictObject({
+    ours: TuningRowSchema.nullable(),
+    theirs: TuningRowSchema.nullable(),
+    changed: z.array(z.string()),
+});
+/**
+ * POST /v1/agents/{slug}/settings/rollback, the body: which version to bring back. It comes back
+ * as a NEW version; nothing is deleted.
+ */
+export const RollbackSchema = z.strictObject({
+    version: z.int(),
+    team: z.boolean().nullish(),
+});
+/**
+ * The org's lexicon: how the voice says the words it would get wrong, and the words the ears must
+ * know. Shared by every agent of the org, laid over each one's own says and hears.
+ */
+export const LexiconBodySchema = z.strictObject({
+    said: z.array(PronunciationSchema),
+    heard: z.array(z.string()),
+});
+/** One kept version of the org's lexicon. */
+export const LexiconRowSchema = z.strictObject({
+    holder: z.string(),
+    version: z.int(),
+    author: z.string(),
+    note: z.string().nullable(),
+    set_at: z.number(),
+    lexicon: LexiconBodySchema,
+});
+/**
+ * GET /v1/lexicon: the org's words as this key sees them — its own corner's, the team's and
+ * production's, each corner's own newest, or null.
+ */
+export const LexiconAnswerSchema = z.strictObject({
+    world: EnvSchema,
+    yours: LexiconRowSchema.nullable(),
+    team: LexiconRowSchema.nullable(),
+    production: LexiconRowSchema.nullable(),
+});
+/** PUT /v1/lexicon, the body: the whole lexicon, the version it was read at, why, and whose corner. */
+export const LexiconPutSchema = z.strictObject({
+    lexicon: LexiconBodySchema,
+    if_version: z.int().nullable().nullish(),
+    note: z.string().nullable().nullish(),
+    team: z.boolean().nullish(),
+});
+/** GET /v1/lexicon/history: one corner's versions, newest first. */
+export const LexiconHistorySchema = z.strictObject({
+    world: EnvSchema,
+    holder: z.string(),
+    rows: z.array(LexiconRowSchema),
+});
+/**
+ * GET /v1/calls/{call}/settings: the exact tuning and lexicon a call was built on, by the versions
+ * its head row recorded.
+ */
+export const CallTuningSchema = z.strictObject({
+    config_version: z.int().nullable(),
+    lexicon_version: z.int().nullable(),
+    config: TuningRowSchema.nullable(),
+    lexicon: LexiconRowSchema.nullable(),
+});
+/** One base and the agents whose settings attach it. */
+export const KnowledgeUseSchema = z.strictObject({
+    base: z.string(),
+    agents: z.array(z.string()),
+});
+/**
+ * GET /v1/knowledge/attached: which agents read each base, off every agent's newest settings in
+ * this world.
+ */
+export const KnowledgeUsesSchema = z.strictObject({
+    bases: z.array(KnowledgeUseSchema),
+});

package/dist/generated/room.d.ts

@@ -23,9 +23,9 @@ export declare const ParticipantJoinedSchema: z.ZodObject<{
     kind: z.ZodEnum<{
         agent: "agent";
         caller: "caller";
-        supervisor: "supervisor";
         listener: "listener";
         sip: "sip";
+        supervisor: "supervisor";
     }>;
     name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     attributes: z.ZodRecord<z.ZodString, z.ZodUnknown>;
@@ -51,15 +51,15 @@ export declare const TrackPublishedSchema: z.ZodObject<{
     identity: z.ZodString;
     kind: z.ZodEnum<{
         audio: "audio";
-        video: "video";
         screen: "screen";
+        video: "video";
     }>;
     source: z.ZodEnum<{
-        unknown: "unknown";
-        microphone: "microphone";
         camera: "camera";
+        microphone: "microphone";
         screen_share: "screen_share";
         screen_share_audio: "screen_share_audio";
+        unknown: "unknown";
     }>;
 }, z.core.$strict>;
 export type TrackPublished = z.infer<typeof TrackPublishedSchema>;
@@ -71,15 +71,15 @@ export declare const TrackUnpublishedSchema: z.ZodObject<{
     identity: z.ZodString;
     kind: z.ZodEnum<{
         audio: "audio";
-        video: "video";
         screen: "screen";
+        video: "video";
     }>;
     source: z.ZodEnum<{
-        unknown: "unknown";
-        microphone: "microphone";
         camera: "camera";
+        microphone: "microphone";
         screen_share: "screen_share";
         screen_share_audio: "screen_share_audio";
+        unknown: "unknown";
     }>;
 }, z.core.$strict>;
 export type TrackUnpublished = z.infer<typeof TrackUnpublishedSchema>;

package/dist/generated/state.d.ts

@@ -4,11 +4,11 @@ import { z } from "zod";
  * looks like.
  */
 export declare const CallStatusSchema: z.ZodEnum<{
-    idle: "idle";
-    ringing: "ringing";
-    dialing: "dialing";
     active: "active";
+    dialing: "dialing";
     ended: "ended";
+    idle: "idle";
+    ringing: "ringing";
 }>;
 export type CallStatus = z.infer<typeof CallStatusSchema>;
 /** One finished turn of the caller, with what the session measured about it. */
@@ -277,9 +277,9 @@ export declare const ToolRunSchema: z.ZodObject<{
     arguments: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     speech_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     status: z.ZodEnum<{
-        running: "running";
         done: "done";
         failed: "failed";
+        running: "running";
     }>;
     output: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
     error: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -312,9 +312,9 @@ export declare const ConfirmSchema: z.ZodObject<{
     audience: z.ZodString;
     phrase: z.ZodString;
     status: z.ZodEnum<{
-        pending: "pending";
-        granted: "granted";
         declined: "declined";
+        granted: "granted";
+        pending: "pending";
     }>;
     said: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     reason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -372,9 +372,9 @@ export declare const ParticipantSchema: z.ZodObject<{
     kind: z.ZodEnum<{
         agent: "agent";
         caller: "caller";
-        supervisor: "supervisor";
         listener: "listener";
         sip: "sip";
+        supervisor: "supervisor";
     }>;
     name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     joined_at: z.ZodNumber;
@@ -391,9 +391,9 @@ export declare const RoomSchema: z.ZodObject<{
         kind: z.ZodEnum<{
             agent: "agent";
             caller: "caller";
-            supervisor: "supervisor";
             listener: "listener";
             sip: "sip";
+            supervisor: "supervisor";
         }>;
         name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         joined_at: z.ZodNumber;
@@ -430,11 +430,11 @@ export declare const StateSchema: z.ZodObject<{
     agent: z.ZodString;
     call: z.ZodNullable<z.ZodString>;
     status: z.ZodEnum<{
-        idle: "idle";
-        ringing: "ringing";
-        dialing: "dialing";
         active: "active";
+        dialing: "dialing";
         ended: "ended";
+        idle: "idle";
+        ringing: "ringing";
     }>;
     channel: z.ZodNullable<z.ZodEnum<{
         phone: "phone";
@@ -462,9 +462,9 @@ export declare const StateSchema: z.ZodObject<{
             kind: z.ZodEnum<{
                 agent: "agent";
                 caller: "caller";
-                supervisor: "supervisor";
                 listener: "listener";
                 sip: "sip";
+                supervisor: "supervisor";
             }>;
             name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
             joined_at: z.ZodNumber;
@@ -476,29 +476,29 @@ export declare const StateSchema: z.ZodObject<{
     started_at: z.ZodNullable<z.ZodNumber>;
     ended_at: z.ZodNullable<z.ZodNumber>;
     end_reason: z.ZodNullable<z.ZodEnum<{
-        caller_hung_up: "caller_hung_up";
         agent_hung_up: "agent_hung_up";
-        supervisor_ended: "supervisor_ended";
-        transferred: "transferred";
-        no_answer: "no_answer";
+        app_detached: "app_detached";
         busy: "busy";
+        caller_hung_up: "caller_hung_up";
         dial_failed: "dial_failed";
-        timeout: "timeout";
         drained: "drained";
-        app_detached: "app_detached";
         error: "error";
+        no_answer: "no_answer";
+        supervisor_ended: "supervisor_ended";
+        timeout: "timeout";
+        transferred: "transferred";
     }>>;
     outcome: z.ZodNullable<z.ZodString>;
     user_state: z.ZodNullable<z.ZodEnum<{
+        away: "away";
         listening: "listening";
         speaking: "speaking";
-        away: "away";
     }>>;
     agent_state: z.ZodNullable<z.ZodEnum<{
+        idle: "idle";
+        initializing: "initializing";
         listening: "listening";
         speaking: "speaking";
-        initializing: "initializing";
-        idle: "idle";
         thinking: "thinking";
     }>>;
     live: z.ZodObject<{
@@ -714,9 +714,9 @@ export declare const StateSchema: z.ZodObject<{
         arguments: z.ZodRecord<z.ZodString, z.ZodUnknown>;
         speech_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         status: z.ZodEnum<{
-            running: "running";
             done: "done";
             failed: "failed";
+            running: "running";
         }>;
         output: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
         error: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -746,18 +746,18 @@ export declare const StateSchema: z.ZodObject<{
         audience: z.ZodString;
         phrase: z.ZodString;
         status: z.ZodEnum<{
-            pending: "pending";
-            granted: "granted";
             declined: "declined";
+            granted: "granted";
+            pending: "pending";
         }>;
         said: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         reason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     }, z.core.$strict>>;
     memory: z.ZodArray<z.ZodObject<{
         op: z.ZodEnum<{
+            forget: "forget";
             recall: "recall";
             remember: "remember";
-            forget: "forget";
         }>;
         contact: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         query: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -857,12 +857,12 @@ export declare const StateSchema: z.ZodObject<{
             provider: z.ZodString;
             model: z.ZodString;
             unit: z.ZodEnum<{
-                input_tokens: "input_tokens";
-                cached_input_tokens: "cached_input_tokens";
+                audio_seconds: "audio_seconds";
                 cache_creation_tokens: "cache_creation_tokens";
-                output_tokens: "output_tokens";
+                cached_input_tokens: "cached_input_tokens";
                 characters: "characters";
-                audio_seconds: "audio_seconds";
+                input_tokens: "input_tokens";
+                output_tokens: "output_tokens";
                 requests: "requests";
                 session_seconds: "session_seconds";
             }>;

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.2.0",
+  "version": "0.4.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>",