@pinecall/protocol 0.6.0 → 0.6.2

package/dist/generated/codec.d.ts

@@ -46,7 +46,7 @@ export type Snake<T> = T extends readonly (infer Item)[] ? Snake<Item>[] : T ext
 } : T;
 /** The keys whose values belong to the app (its state, a tool's arguments, a map it named): never renamed below them. */
 export declare const OPAQUE_KEYS: Set<string>;
-export type OpaqueKey = "app_state" | "arguments" | "attributes" | "data" | "input" | "metadata" | "output" | "parameters" | "prompt" | "result" | "state";
+export type OpaqueKey = "app_state" | "arguments" | "attributes" | "data" | "facts" | "input" | "metadata" | "output" | "parameters" | "prompt" | "result" | "state";
 /** Rename every key from snake_case to camelCase, deep. Values are never touched. */
 export declare function toCamel<T>(value: T): Camel<T>;
 /** Rename every key from camelCase to snake_case, deep. Values are never touched. */

package/dist/generated/codec.js

@@ -37,7 +37,7 @@ export function isCommandType(type) {
     return Object.hasOwn(COMMAND_SCHEMAS, type);
 }
 /** The keys whose values belong to the app (its state, a tool's arguments, a map it named): never renamed below them. */
-export const OPAQUE_KEYS = new Set(["app_state", "arguments", "attributes", "data", "input", "metadata", "output", "parameters", "prompt", "result", "state"]);
+export const OPAQUE_KEYS = new Set(["app_state", "arguments", "attributes", "data", "facts", "input", "metadata", "output", "parameters", "prompt", "result", "state"]);
 /** Rename every key from snake_case to camelCase, deep. Values are never touched. */
 export function toCamel(value) {
     return renameKeys(value, camelCase);

package/dist/generated/defs.d.ts

@@ -30,8 +30,8 @@ export declare const EnvSchema: z.ZodEnum<{
 export type Env = z.infer<typeof EnvSchema>;
 /**
  * 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 from its personas, its
- * goldens and a suite of them, its knowledge folder pushed or its golden asked, its memory
+ * 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.
@@ -54,7 +54,6 @@ export declare const DevVerbSchema: z.ZodEnum<{
     "promote.write": "promote.write";
     "reproductions.read": "reproductions.read";
     "reproductions.roster": "reproductions.roster";
-    "simulate.roster": "simulate.roster";
     "simulate.start": "simulate.start";
 }>;
 export type DevVerb = z.infer<typeof DevVerbSchema>;

package/dist/generated/defs.js

@@ -18,13 +18,13 @@ export const DirectionSchema = z.enum(["inbound", "outbound"]);
 export const EnvSchema = z.enum(["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 from its personas, its
- * goldens and a suite of them, its knowledge folder pushed or its golden asked, its memory
+ * 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.
  */
-export const DevVerbSchema = z.enum(["chat.roster", "chat.start", "chat.say", "chat.end", "simulate.roster", "simulate.start", "goldens.roster", "goldens.run", "knowledge.roster", "knowledge.push", "knowledge.eval", "memory.roster", "memory.eval", "memory.extraction", "promote.roster", "promote.write", "drift.read", "reproductions.roster", "reproductions.read"]);
+export const DevVerbSchema = z.enum(["chat.roster", "chat.start", "chat.say", "chat.end", "simulate.start", "goldens.roster", "goldens.run", "knowledge.roster", "knowledge.push", "knowledge.eval", "memory.roster", "memory.eval", "memory.extraction", "promote.roster", "promote.write", "drift.read", "reproductions.roster", "reproductions.read"]);
 /**
  * Why the call is over. Who hung up, what failed before anybody could, drained: the platform took
  * the worker down (a deploy, a stop) with the call still on it, or app_detached: the app holding

package/dist/generated/events.d.ts

@@ -228,6 +228,7 @@ export declare const CallStartedSchema: z.ZodObject<{
     from: z.ZodString;
     to: z.ZodString;
     run: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodString>>>;
+    persona: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodString>>>;
     caller: z.ZodNullable<z.ZodObject<{
         id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         phone: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -465,7 +466,6 @@ export declare const DevRequestSchema: z.ZodObject<{
         "promote.write": "promote.write";
         "reproductions.read": "reproductions.read";
         "reproductions.roster": "reproductions.roster";
-        "simulate.roster": "simulate.roster";
         "simulate.start": "simulate.start";
     }>;
     data: z.ZodRecord<z.ZodString, z.ZodUnknown>;

package/dist/generated/events.js

@@ -126,6 +126,7 @@ export const CallStartedSchema = z.strictObject({
     from: z.string(),
     to: z.string(),
     run: z.string().nullable().nullish(),
+    persona: z.string().nullable().nullish(),
     caller: ContactSchema.nullable(),
     started_at: z.number(),
     env: EnvSchema.nullish(),

package/dist/generated/registry.d.ts

@@ -152,6 +152,7 @@ export declare const EVENT_SCHEMAS: {
         from: import("zod").ZodString;
         to: import("zod").ZodString;
         run: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodNullable<import("zod").ZodString>>>;
+        persona: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodNullable<import("zod").ZodString>>>;
         caller: import("zod").ZodNullable<import("zod").ZodObject<{
             id: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
             phone: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
@@ -352,7 +353,6 @@ export declare const EVENT_SCHEMAS: {
             "promote.write": "promote.write";
             "reproductions.read": "reproductions.read";
             "reproductions.roster": "reproductions.roster";
-            "simulate.roster": "simulate.roster";
             "simulate.start": "simulate.start";
         }>;
         data: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;

package/dist/generated/rest.d.ts

@@ -2175,6 +2175,56 @@ export declare const CallTuningSchema: z.ZodObject<{
     }, z.core.$strict>>;
 }, z.core.$strict>;
 export type CallTuning = z.infer<typeof CallTuningSchema>;
+/** One file of a base as the list draws it. */
+export declare const KnowledgeFileRowSchema: z.ZodObject<{
+    path: z.ZodString;
+    chars: z.ZodInt;
+    chunks: z.ZodInt;
+    pushed_at: z.ZodNumber;
+}, z.core.$strict>;
+export type KnowledgeFileRow = z.infer<typeof KnowledgeFileRowSchema>;
+/**
+ * GET /v1/knowledge/{base}: every file of the base, by path, with its size and what it became.
+ * Never the text: one file is read at a time.
+ */
+export declare const KnowledgeFilesSchema: z.ZodObject<{
+    base: z.ZodString;
+    kept: z.ZodBoolean;
+    files: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        chars: z.ZodInt;
+        chunks: z.ZodInt;
+        pushed_at: z.ZodNumber;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type KnowledgeFiles = z.infer<typeof KnowledgeFilesSchema>;
+/** GET /v1/knowledge/{base}/files/{path}: one file, text and all. */
+export declare const KnowledgeFileReadSchema: z.ZodObject<{
+    path: z.ZodString;
+    text: z.ZodString;
+    chunks: z.ZodInt;
+    pushed_at: z.ZodNumber;
+}, z.core.$strict>;
+export type KnowledgeFileRead = z.infer<typeof KnowledgeFileReadSchema>;
+/**
+ * PUT /v1/knowledge/{base}/files/{path}, the body: the file's whole text. New under that path, or
+ * replaced in place; the base is begun when there is none.
+ */
+export declare const KnowledgeFilePutSchema: z.ZodObject<{
+    text: z.ZodString;
+}, z.core.$strict>;
+export type KnowledgeFilePut = z.infer<typeof KnowledgeFilePutSchema>;
+/**
+ * PUT /v1/knowledge/{base}/files/{path}, the answer: which file, how many chunks it became, and
+ * how long that took.
+ */
+export declare const KnowledgeFilePushedSchema: z.ZodObject<{
+    base: z.ZodString;
+    path: z.ZodString;
+    chunks: z.ZodInt;
+    took_ms: z.ZodNumber;
+}, z.core.$strict>;
+export type KnowledgeFilePushed = z.infer<typeof KnowledgeFilePushedSchema>;
 /** One base and the agents whose settings attach it. */
 export declare const KnowledgeUseSchema: z.ZodObject<{
     base: z.ZodString;
@@ -2192,3 +2242,122 @@ export declare const KnowledgeUsesSchema: z.ZodObject<{
     }, z.core.$strict>>;
 }, z.core.$strict>;
 export type KnowledgeUses = z.infer<typeof KnowledgeUsesSchema>;
+/**
+ * One synthetic caller of an ORG, kept by the gateway: what they want, how they talk, and what
+ * they may state about themselves. A model plays them turn by turn — there is no script — for
+ * `pinecall simulate` and the console's Simulations. A caller is a person on the phone, so who
+ * they are does not depend on which of the org's agents answers: every agent of the org calls with
+ * the same list.
+ */
+export declare const PersonaSchema: z.ZodObject<{
+    name: z.ZodString;
+    about: z.ZodString;
+    goal: z.ZodString;
+    style: z.ZodString;
+    facts: z.ZodRecord<z.ZodString, z.ZodString>;
+    state: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    author: z.ZodString;
+    set_at: z.ZodNumber;
+}, z.core.$strict>;
+export type Persona = z.infer<typeof PersonaSchema>;
+/**
+ * GET /v1/personas: every caller the org wrote, by name. The same list for every agent of the org,
+ * and the same one in both worlds.
+ */
+export declare const PersonaListSchema: z.ZodObject<{
+    personas: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        about: z.ZodString;
+        goal: z.ZodString;
+        style: z.ZodString;
+        facts: z.ZodRecord<z.ZodString, z.ZodString>;
+        state: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        author: z.ZodString;
+        set_at: z.ZodNumber;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type PersonaList = z.infer<typeof PersonaListSchema>;
+/**
+ * PUT /v1/personas/{name}, the body: the caller, written whole. A name that exists is replaced;
+ * `was` renames the caller it names.
+ */
+export declare const PersonaPutSchema: z.ZodObject<{
+    about: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    goal: z.ZodString;
+    style: z.ZodString;
+    facts: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>>;
+    state: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    was: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strict>;
+export type PersonaPut = z.infer<typeof PersonaPutSchema>;
+/**
+ * One simulation this caller has run: the call it was, and what the call came to. Read off the
+ * call index, never off a log — the same row the sessions list is drawn from.
+ */
+export declare const PersonaRunSchema: z.ZodObject<{
+    call: z.ZodString;
+    agent: z.ZodString;
+    started_at: z.ZodNumber;
+    ended_at: z.ZodNullable<z.ZodNumber>;
+    turns: z.ZodInt;
+    end_reason: z.ZodNullable<z.ZodEnum<{
+        agent_hung_up: "agent_hung_up";
+        app_detached: "app_detached";
+        busy: "busy";
+        caller_hung_up: "caller_hung_up";
+        dial_failed: "dial_failed";
+        drained: "drained";
+        error: "error";
+        no_answer: "no_answer";
+        supervisor_ended: "supervisor_ended";
+        timeout: "timeout";
+        transferred: "transferred";
+    }>>;
+    outcome: z.ZodNullable<z.ZodString>;
+    cost_eur: z.ZodNullable<z.ZodNumber>;
+    score: z.ZodNullable<z.ZodObject<{
+        held: z.ZodInt;
+        judged: z.ZodInt;
+        passed: z.ZodBoolean;
+        reason: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type PersonaRun = z.infer<typeof PersonaRunSchema>;
+/**
+ * Every simulation this caller has run, newest first, a page at a time. GET
+ * /v1/personas/{name}/runs, in the key's own world and corner, paged exactly as the sessions list
+ * is.
+ */
+export declare const PersonaRunListSchema: z.ZodObject<{
+    runs: z.ZodArray<z.ZodObject<{
+        call: z.ZodString;
+        agent: z.ZodString;
+        started_at: z.ZodNumber;
+        ended_at: z.ZodNullable<z.ZodNumber>;
+        turns: z.ZodInt;
+        end_reason: z.ZodNullable<z.ZodEnum<{
+            agent_hung_up: "agent_hung_up";
+            app_detached: "app_detached";
+            busy: "busy";
+            caller_hung_up: "caller_hung_up";
+            dial_failed: "dial_failed";
+            drained: "drained";
+            error: "error";
+            no_answer: "no_answer";
+            supervisor_ended: "supervisor_ended";
+            timeout: "timeout";
+            transferred: "transferred";
+        }>>;
+        outcome: z.ZodNullable<z.ZodString>;
+        cost_eur: z.ZodNullable<z.ZodNumber>;
+        score: z.ZodNullable<z.ZodObject<{
+            held: z.ZodInt;
+            judged: z.ZodInt;
+            passed: z.ZodBoolean;
+            reason: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    total: z.ZodInt;
+    next: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type PersonaRunList = z.infer<typeof PersonaRunListSchema>;

package/dist/generated/rest.js

@@ -779,6 +779,46 @@ export const CallTuningSchema = z.strictObject({
     config: TuningRowSchema.nullable(),
     lexicon: LexiconRowSchema.nullable(),
 });
+/** One file of a base as the list draws it. */
+export const KnowledgeFileRowSchema = z.strictObject({
+    path: z.string(),
+    chars: z.int(),
+    chunks: z.int(),
+    pushed_at: z.number(),
+});
+/**
+ * GET /v1/knowledge/{base}: every file of the base, by path, with its size and what it became.
+ * Never the text: one file is read at a time.
+ */
+export const KnowledgeFilesSchema = z.strictObject({
+    base: z.string(),
+    kept: z.boolean(),
+    files: z.array(KnowledgeFileRowSchema),
+});
+/** GET /v1/knowledge/{base}/files/{path}: one file, text and all. */
+export const KnowledgeFileReadSchema = z.strictObject({
+    path: z.string(),
+    text: z.string(),
+    chunks: z.int(),
+    pushed_at: z.number(),
+});
+/**
+ * PUT /v1/knowledge/{base}/files/{path}, the body: the file's whole text. New under that path, or
+ * replaced in place; the base is begun when there is none.
+ */
+export const KnowledgeFilePutSchema = z.strictObject({
+    text: z.string(),
+});
+/**
+ * PUT /v1/knowledge/{base}/files/{path}, the answer: which file, how many chunks it became, and
+ * how long that took.
+ */
+export const KnowledgeFilePushedSchema = z.strictObject({
+    base: z.string(),
+    path: z.string(),
+    chunks: z.int(),
+    took_ms: z.number(),
+});
 /** One base and the agents whose settings attach it. */
 export const KnowledgeUseSchema = z.strictObject({
     base: z.string(),
@@ -791,3 +831,64 @@ export const KnowledgeUseSchema = z.strictObject({
 export const KnowledgeUsesSchema = z.strictObject({
     bases: z.array(KnowledgeUseSchema),
 });
+/**
+ * One synthetic caller of an ORG, kept by the gateway: what they want, how they talk, and what
+ * they may state about themselves. A model plays them turn by turn — there is no script — for
+ * `pinecall simulate` and the console's Simulations. A caller is a person on the phone, so who
+ * they are does not depend on which of the org's agents answers: every agent of the org calls with
+ * the same list.
+ */
+export const PersonaSchema = z.strictObject({
+    name: z.string(),
+    about: z.string(),
+    goal: z.string(),
+    style: z.string(),
+    facts: z.record(z.string(), z.string()),
+    state: z.record(z.string(), z.unknown()),
+    author: z.string(),
+    set_at: z.number(),
+});
+/**
+ * GET /v1/personas: every caller the org wrote, by name. The same list for every agent of the org,
+ * and the same one in both worlds.
+ */
+export const PersonaListSchema = z.strictObject({
+    personas: z.array(PersonaSchema),
+});
+/**
+ * PUT /v1/personas/{name}, the body: the caller, written whole. A name that exists is replaced;
+ * `was` renames the caller it names.
+ */
+export const PersonaPutSchema = z.strictObject({
+    about: z.string().nullish(),
+    goal: z.string(),
+    style: z.string(),
+    facts: z.record(z.string(), z.string()).nullish(),
+    state: z.record(z.string(), z.unknown()).nullish(),
+    was: z.string().nullish(),
+});
+/**
+ * One simulation this caller has run: the call it was, and what the call came to. Read off the
+ * call index, never off a log — the same row the sessions list is drawn from.
+ */
+export const PersonaRunSchema = z.strictObject({
+    call: z.string(),
+    agent: z.string(),
+    started_at: z.number(),
+    ended_at: z.number().nullable(),
+    turns: z.int(),
+    end_reason: EndReasonSchema.nullable(),
+    outcome: z.string().nullable(),
+    cost_eur: z.number().nullable(),
+    score: SessionScoreSchema.nullable(),
+});
+/**
+ * Every simulation this caller has run, newest first, a page at a time. GET
+ * /v1/personas/{name}/runs, in the key's own world and corner, paged exactly as the sessions list
+ * is.
+ */
+export const PersonaRunListSchema = z.strictObject({
+    runs: z.array(PersonaRunSchema),
+    total: z.int(),
+    next: z.string().nullable(),
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pinecall/protocol",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "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>",