@pinecall/protocol 0.2.0 → 0.3.0

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;

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(),

package/dist/generated/rest.d.ts

@@ -991,6 +991,75 @@ export declare const OrgMailWantedSchema: z.ZodObject<{
     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.
@@ -1420,7 +1489,6 @@ export declare const DialGuardsSchema: z.ZodObject<{
     dial_anywhere: z.ZodBoolean;
     per_minute: z.ZodInt;
     per_day: z.ZodInt;
-    countries: z.ZodArray<z.ZodString>;
     max_duration_s: z.ZodInt;
 }, z.core.$strict>;
 export type DialGuards = z.infer<typeof DialGuardsSchema>;
@@ -1437,7 +1505,6 @@ export declare const CarrierOutboundSchema: z.ZodObject<{
         dial_anywhere: z.ZodBoolean;
         per_minute: z.ZodInt;
         per_day: z.ZodInt;
-        countries: z.ZodArray<z.ZodString>;
         max_duration_s: z.ZodInt;
     }, z.core.$strict>;
 }, z.core.$strict>;

package/dist/generated/rest.js

@@ -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.
@@ -534,7 +593,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(),
 });
 /**

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.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>",