@pinecall/protocol 0.6.0 → 0.6.1

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

@@ -465,7 +465,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/registry.d.ts

@@ -352,7 +352,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,46 @@ export declare const KnowledgeUsesSchema: z.ZodObject<{
     }, z.core.$strict>>;
 }, z.core.$strict>;
 export type KnowledgeUses = z.infer<typeof KnowledgeUsesSchema>;
+/**
+ * One synthetic caller of an agent, 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.
+ */
+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/agents/{slug}/personas: every caller written for this agent, by name. */
+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/agents/{slug}/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>;

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,34 @@ export const KnowledgeUseSchema = z.strictObject({
 export const KnowledgeUsesSchema = z.strictObject({
     bases: z.array(KnowledgeUseSchema),
 });
+/**
+ * One synthetic caller of an agent, 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.
+ */
+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/agents/{slug}/personas: every caller written for this agent, by name. */
+export const PersonaListSchema = z.strictObject({
+    personas: z.array(PersonaSchema),
+});
+/**
+ * PUT /v1/agents/{slug}/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(),
+});

package/package.json

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