@byok-sdk/protocol 0.20.0 → 0.22.0

package/dist/input-preparation.d.ts

@@ -36,7 +36,7 @@ import { z } from 'zod';
  * below. See `INPUT_PREPARATION_VERSION` in the client for what each version
  * changed.
  */
-export declare const INPUT_PREPARATION_WIRE_VERSION: 5;
+export declare const INPUT_PREPARATION_WIRE_VERSION: 7;
 /**
  * Capability required before a task-free remote input preparation — or a
  * prepared Execution — is admitted: `agent-input-preparation-v<N>`, where
@@ -59,7 +59,7 @@ export declare const INPUT_PREPARATION_WIRE_VERSION: 5;
  * devices as a pair is the operator precondition for the cut (`docs/spec.md`,
  * bounded admission); nothing here parses an older receipt.
  */
-export declare const AGENT_INPUT_PREPARATION_CAPABILITY: "agent-input-preparation-v5";
+export declare const AGENT_INPUT_PREPARATION_CAPABILITY: "agent-input-preparation-v7";
 /** The preparation surface uses the package-wide lowercase `sha256:<hex>` transport form. */
 export declare const InputPreparationContentHashSchema: z.ZodString;
 /**
@@ -296,77 +296,9 @@ export declare const InputPreparationSelectionSchema: z.ZodObject<{
     }, z.core.$strict>;
 }, z.core.$strict>;
 export type InputPreparationSelection = z.infer<typeof InputPreparationSelectionSchema>;
-export declare const InputPreparationContextFileSchema: z.ZodObject<{
-    path: z.ZodString;
-    content: z.ZodString;
-}, z.core.$strict>;
-/**
- * The three documentation locations the native prompt renderer names.
- *
- * The wire field names are this SDK's own and do not track upstream Pi's
- * (`readme`/`docs`/`examples`): the contract a Host integrates against is this
- * one, and renaming a frozen wire field because a runtime renamed a parameter
- * would be a breaking change to every Host for no gain. The device adapter maps
- * these onto whatever the pinned runtime calls them.
- */
-export declare const InputPreparationDocsPathsSchema: z.ZodObject<{
-    readmePath: z.ZodString;
-    docsPath: z.ZodString;
-    examplesPath: z.ZodString;
-}, z.core.$strict>;
-/**
- * One skill the system prompt renders, stated as the closed set of fields the
- * renderer actually reads.
- *
- * Not a preformatted string: the native renderer owns the skill block's
- * markup, and a Host-rendered one would be a second renderer that could drift
- * from what a live session emits. Loader bookkeeping the prompt never reads
- * (`baseDir`, source info) is deliberately absent — the Host cannot know it and
- * the device must never invent it.
- */
-export declare const InputPreparationSkillSchema: z.ZodObject<{
-    name: z.ZodString;
-    description: z.ZodString;
-    filePath: z.ZodString;
-    disableModelInvocation: z.ZodBoolean;
-}, z.core.$strict>;
-export type InputPreparationSkill = z.infer<typeof InputPreparationSkillSchema>;
-/**
- * Explicit, already-authorized inputs for the native system prompt renderer.
- *
- * `toolSnippets` is PROMPT TEXT the Host authored — it is not the
- * model-visible tool schemas, which the device observes locally and the Host
- * never states (see this module's rule 1). `toolGuidelines` is the same kind of
- * value one level down: the guideline bullets a tool contributes, keyed by tool
- * name and bounded exactly like `toolSnippets` and `promptGuidelines`.
- *
- * `selectedTools` is deliberately absent for the same reason one level up: the
- * native contract requires that list to equal the model-visible manifest
- * exactly, so a Host stating it would be stating the manifest. The device
- * fills it from its own assembled tool surface.
- */
+/** Complete Host-authored prompt. No Pi renderer or device-local input is consulted. */
 export declare const InputPreparationPromptSnapshotSchema: z.ZodObject<{
-    customPrompt: z.ZodOptional<z.ZodString>;
-    appendSystemPrompt: z.ZodOptional<z.ZodString>;
-    cwd: z.ZodString;
-    toolSnippets: z.ZodRecord<z.ZodString, z.ZodString>;
-    toolGuidelines: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>;
-    promptGuidelines: z.ZodArray<z.ZodString>;
-    contextFiles: z.ZodArray<z.ZodObject<{
-        path: z.ZodString;
-        content: z.ZodString;
-    }, z.core.$strict>>;
-    skills: z.ZodArray<z.ZodObject<{
-        name: z.ZodString;
-        description: z.ZodString;
-        filePath: z.ZodString;
-        disableModelInvocation: z.ZodBoolean;
-    }, z.core.$strict>>;
-    docsPaths: z.ZodObject<{
-        readmePath: z.ZodString;
-        docsPath: z.ZodString;
-        examplesPath: z.ZodString;
-    }, z.core.$strict>;
+    systemPrompt: z.ZodString;
 }, z.core.$strict>;
 /**
  * One model-visible user message. Text-only: multimodal content and any extra
@@ -423,27 +355,7 @@ export type InputPreparationMessage = z.infer<typeof InputPreparationMessageSche
  */
 export declare const InputPreparationContextDocumentSchema: z.ZodObject<{
     prompt: z.ZodObject<{
-        customPrompt: z.ZodOptional<z.ZodString>;
-        appendSystemPrompt: z.ZodOptional<z.ZodString>;
-        cwd: z.ZodString;
-        toolSnippets: z.ZodRecord<z.ZodString, z.ZodString>;
-        toolGuidelines: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>;
-        promptGuidelines: z.ZodArray<z.ZodString>;
-        contextFiles: z.ZodArray<z.ZodObject<{
-            path: z.ZodString;
-            content: z.ZodString;
-        }, z.core.$strict>>;
-        skills: z.ZodArray<z.ZodObject<{
-            name: z.ZodString;
-            description: z.ZodString;
-            filePath: z.ZodString;
-            disableModelInvocation: z.ZodBoolean;
-        }, z.core.$strict>>;
-        docsPaths: z.ZodObject<{
-            readmePath: z.ZodString;
-            docsPath: z.ZodString;
-            examplesPath: z.ZodString;
-        }, z.core.$strict>;
+        systemPrompt: z.ZodString;
     }, z.core.$strict>;
     messages: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         role: z.ZodLiteral<"user">;
@@ -513,9 +425,10 @@ export type InputPreparationReadinessReason = z.infer<typeof InputPreparationRea
 export declare const InputPreparationRuntimeIdentitySchema: z.ZodObject<{
     packageName: z.ZodString;
     packageVersion: z.ZodString;
-    upstreamBase: z.ZodString;
+    tarballIntegrity: z.ZodString;
+    provenanceDigest: z.ZodString;
+    closureDigest: z.ZodString;
     upstreamCommit: z.ZodString;
-    forkBuild: z.ZodNumber;
     envelopeFormat: z.ZodString;
     requestFormat: z.ZodString;
     compilerVersion: z.ZodNumber;
@@ -751,9 +664,10 @@ export declare const InputPreparationBindingSchema: z.ZodObject<{
     runtime: z.ZodObject<{
         packageName: z.ZodString;
         packageVersion: z.ZodString;
-        upstreamBase: z.ZodString;
+        tarballIntegrity: z.ZodString;
+        provenanceDigest: z.ZodString;
+        closureDigest: z.ZodString;
         upstreamCommit: z.ZodString;
-        forkBuild: z.ZodNumber;
         envelopeFormat: z.ZodString;
         requestFormat: z.ZodString;
         compilerVersion: z.ZodNumber;
@@ -810,9 +724,10 @@ export declare const InputPreparationReceiptSummarySchema: z.ZodObject<{
         runtime: z.ZodObject<{
             packageName: z.ZodString;
             packageVersion: z.ZodString;
-            upstreamBase: z.ZodString;
+            tarballIntegrity: z.ZodString;
+            provenanceDigest: z.ZodString;
+            closureDigest: z.ZodString;
             upstreamCommit: z.ZodString;
-            forkBuild: z.ZodNumber;
             envelopeFormat: z.ZodString;
             requestFormat: z.ZodString;
             compilerVersion: z.ZodNumber;

package/dist/messages.d.ts

@@ -272,10 +272,11 @@ export declare const RequiredToolsetsSchema: z.ZodArray<z.ZodString>;
 /**
  * Additive v1 offer variant for tasks whose semantics require local MCP
  * tools. This is a distinct message type rather than an optional field on
- * `task.offer`: an older v1 daemon skips an unknown message type, whereas it
- * would legally strip an unknown optional control field and run the task
- * without its required tools. The whole payload is strict because every
- * field here affects execution authority.
+ * `task.offer`, so an older daemon can never strip an unknown optional control
+ * field and run the task without its required tools. An unknown type is not
+ * silently skipped either: on long-poll it freezes the cursor, so the enqueue
+ * capability gate is the real compatibility boundary. The whole payload is
+ * strict because every field here affects execution authority.
  */
 export declare const TaskOfferWithToolsetsPayloadSchema: z.ZodObject<{
     instruction: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
@@ -656,11 +657,10 @@ export type TaskOfferForAgentWithEgressFreshPayload = z.infer<typeof TaskOfferFo
  *
  * A DISTINCT message type, not a `preparation` field added to
  * `task.offer_for_agent`, for the same N/N-1 reason the toolset and egress
- * variants are distinct: an older daemon skips a message type it does not know
- * (`UnknownMessageTypeError`, and the long-poll transport skips that entry
- * whole), whereas it would legally STRIP an unknown optional field and run the
- * task as an ordinary instruction offer — compiling a request of its own
- * against tokens that were already counted for a different one.
+ * variants are distinct. On long-poll, both an unknown message type and an
+ * unknown key on a strict payload freeze the cursor. The enqueue capability
+ * gate is the compatibility boundary: v6 requires a drain and paired upgrade,
+ * with no dual token or dual read.
  *
  * It carries no `instruction`: the user request is already inside the frozen
  * envelope the referenced record retained, and an offer that carried both would
@@ -737,6 +737,46 @@ export declare const TaskOfferPreparedPayloadSchema: z.ZodObject<{
         requestDigest: z.ZodString;
         artifactDigest: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>;
+    egressPolicy: z.ZodObject<{
+        policyRevision: z.ZodString;
+        activity: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            mode: z.ZodLiteral<"metadata-status">;
+            delivery: z.ZodLiteral<"latest-value">;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"contentful-trajectory">;
+            delivery: z.ZodLiteral<"latest-value">;
+            maxCoalesceMs: z.ZodNumber;
+            maxEventBytes: z.ZodNumber;
+        }, z.core.$strict>], "mode">;
+        reliable: z.ZodObject<{
+            maxPendingEventsPerAgent: z.ZodNumber;
+            maxPendingBytesPerAgent: z.ZodNumber;
+            maxPendingBytesPerTenant: z.ZodNumber;
+        }, z.core.$strict>;
+        transfers: z.ZodObject<{
+            workspace: z.ZodUnion<readonly [z.ZodLiteral<"disabled">, z.ZodObject<{
+                maxBytes: z.ZodNumber;
+                allowedMimeTypes: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>]>;
+            transcript: z.ZodUnion<readonly [z.ZodLiteral<"disabled">, z.ZodObject<{
+                maxBytes: z.ZodNumber;
+                allowedMimeTypes: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>]>;
+            artifact: z.ZodUnion<readonly [z.ZodLiteral<"disabled">, z.ZodObject<{
+                maxBytes: z.ZodNumber;
+                allowedMimeTypes: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>]>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    messageEgress: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodLiteral<"required">;
+        contract: z.ZodString;
+        contentType: z.ZodEnum<{
+            "text/markdown": "text/markdown";
+            "text/plain": "text/plain";
+        }>;
+        maxBytes: z.ZodNumber;
+    }, z.core.$strict>>;
 }, z.core.$strict>;
 export type TaskOfferPreparedPayload = z.infer<typeof TaskOfferPreparedPayloadSchema>;
 /** Daemon -> cloud: one durable reliable-lane item after local sanitization. */
@@ -972,11 +1012,12 @@ export type AgentHomeProjectionPayload = z.infer<typeof AgentHomeProjectionPaylo
  * Server -> daemon: one task-free, exact-device remote input preparation.
  *
  * Distinct message type rather than an optional field on an existing one, for
- * the same N/N-1 reason `task.offer_with_toolsets` is: a daemon that predates
- * this contract SKIPS an unknown type outright (`parseMessage` ->
- * `UnknownMessageTypeError`), whereas it would legally STRIP an unknown
- * optional field and then answer as though a preparation it never performed
- * had somehow been handled.
+ * the same N/N-1 reason `task.offer_with_toolsets` is: an optional field could be
+ * legally STRIPPED by a daemon that predates this contract, which would then
+ * answer as though a preparation it never performed had somehow been handled.
+ * An unknown type (`parseMessage` -> `UnknownMessageTypeError`) is not skipped
+ * cleanly either: on long-poll it freezes the cursor, so the enqueue capability
+ * gate is the compatibility boundary.
  *
  * What is deliberately NOT here (§17 B): `tools`, `toolExecutors`, runtime or
  * compiler identity, `tenantId` and `deviceId`. The first three are local
@@ -2206,6 +2247,46 @@ declare const TASK_OFFER_PAYLOAD_SCHEMAS: {
             requestDigest: z.ZodString;
             artifactDigest: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>;
+        egressPolicy: z.ZodObject<{
+            policyRevision: z.ZodString;
+            activity: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                mode: z.ZodLiteral<"metadata-status">;
+                delivery: z.ZodLiteral<"latest-value">;
+            }, z.core.$strict>, z.ZodObject<{
+                mode: z.ZodLiteral<"contentful-trajectory">;
+                delivery: z.ZodLiteral<"latest-value">;
+                maxCoalesceMs: z.ZodNumber;
+                maxEventBytes: z.ZodNumber;
+            }, z.core.$strict>], "mode">;
+            reliable: z.ZodObject<{
+                maxPendingEventsPerAgent: z.ZodNumber;
+                maxPendingBytesPerAgent: z.ZodNumber;
+                maxPendingBytesPerTenant: z.ZodNumber;
+            }, z.core.$strict>;
+            transfers: z.ZodObject<{
+                workspace: z.ZodUnion<readonly [z.ZodLiteral<"disabled">, z.ZodObject<{
+                    maxBytes: z.ZodNumber;
+                    allowedMimeTypes: z.ZodArray<z.ZodString>;
+                }, z.core.$strict>]>;
+                transcript: z.ZodUnion<readonly [z.ZodLiteral<"disabled">, z.ZodObject<{
+                    maxBytes: z.ZodNumber;
+                    allowedMimeTypes: z.ZodArray<z.ZodString>;
+                }, z.core.$strict>]>;
+                artifact: z.ZodUnion<readonly [z.ZodLiteral<"disabled">, z.ZodObject<{
+                    maxBytes: z.ZodNumber;
+                    allowedMimeTypes: z.ZodArray<z.ZodString>;
+                }, z.core.$strict>]>;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        messageEgress: z.ZodOptional<z.ZodObject<{
+            mode: z.ZodLiteral<"required">;
+            contract: z.ZodString;
+            contentType: z.ZodEnum<{
+                "text/markdown": "text/markdown";
+                "text/plain": "text/plain";
+            }>;
+            maxBytes: z.ZodNumber;
+        }, z.core.$strict>>;
     }, z.core.$strict>;
 };
 export type TaskOfferType = keyof typeof TASK_OFFER_PAYLOAD_SCHEMAS;
@@ -2693,6 +2774,46 @@ export declare const MESSAGE_PAYLOAD_SCHEMAS: {
             requestDigest: z.ZodString;
             artifactDigest: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>;
+        egressPolicy: z.ZodObject<{
+            policyRevision: z.ZodString;
+            activity: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                mode: z.ZodLiteral<"metadata-status">;
+                delivery: z.ZodLiteral<"latest-value">;
+            }, z.core.$strict>, z.ZodObject<{
+                mode: z.ZodLiteral<"contentful-trajectory">;
+                delivery: z.ZodLiteral<"latest-value">;
+                maxCoalesceMs: z.ZodNumber;
+                maxEventBytes: z.ZodNumber;
+            }, z.core.$strict>], "mode">;
+            reliable: z.ZodObject<{
+                maxPendingEventsPerAgent: z.ZodNumber;
+                maxPendingBytesPerAgent: z.ZodNumber;
+                maxPendingBytesPerTenant: z.ZodNumber;
+            }, z.core.$strict>;
+            transfers: z.ZodObject<{
+                workspace: z.ZodUnion<readonly [z.ZodLiteral<"disabled">, z.ZodObject<{
+                    maxBytes: z.ZodNumber;
+                    allowedMimeTypes: z.ZodArray<z.ZodString>;
+                }, z.core.$strict>]>;
+                transcript: z.ZodUnion<readonly [z.ZodLiteral<"disabled">, z.ZodObject<{
+                    maxBytes: z.ZodNumber;
+                    allowedMimeTypes: z.ZodArray<z.ZodString>;
+                }, z.core.$strict>]>;
+                artifact: z.ZodUnion<readonly [z.ZodLiteral<"disabled">, z.ZodObject<{
+                    maxBytes: z.ZodNumber;
+                    allowedMimeTypes: z.ZodArray<z.ZodString>;
+                }, z.core.$strict>]>;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        messageEgress: z.ZodOptional<z.ZodObject<{
+            mode: z.ZodLiteral<"required">;
+            contract: z.ZodString;
+            contentType: z.ZodEnum<{
+                "text/markdown": "text/markdown";
+                "text/plain": "text/plain";
+            }>;
+            maxBytes: z.ZodNumber;
+        }, z.core.$strict>>;
     }, z.core.$strict>;
     readonly 'conn.hello': z.ZodObject<{
         protocolVersions: z.ZodArray<z.ZodNumber>;

package/dist/version.d.ts

@@ -107,5 +107,5 @@ export declare const STRICT_AGENT_ONLY_CAPABILITY: 'strict-agent-only';
  * cannot accidentally execute the instruction without the required tools.
  */
 export declare const CUSTOM_HARNESS_CAPABILITY: 'custom-harness';
-export declare const CAPABILITY_FLAGS: readonly ['steer', 'blob-upload', 'interactive-approval', 'approval_resolved', 'approval-targeting', 'result-document', 'dispatch-selection', "provider-profile-binding", 'toolset-selection', 'agent-home-contract', "strict-agent-only", "agent-egress-policy", "agent-egress-reliable-ack", "agent-message-egress", "agent-egress-fresh-session", "agent-content-workspace-read", "agent-content-transcript-read", "agent-content-artifact-read", "agent-home-projection", "agent-input-preparation-v5", "terminal-projection-selection", "host-mcp-task-context", "custom-harness", "mailbox-read-ahead"];
+export declare const CAPABILITY_FLAGS: readonly ['steer', 'blob-upload', 'interactive-approval', 'approval_resolved', 'approval-targeting', 'result-document', 'dispatch-selection', "provider-profile-binding", 'toolset-selection', 'agent-home-contract', "strict-agent-only", "agent-egress-policy", "agent-egress-reliable-ack", "agent-message-egress", "agent-egress-fresh-session", "agent-content-workspace-read", "agent-content-transcript-read", "agent-content-artifact-read", "agent-home-projection", "agent-input-preparation-v7", "terminal-projection-selection", "host-mcp-task-context", "custom-harness", "mailbox-read-ahead"];
 export type CapabilityFlag = (typeof CAPABILITY_FLAGS)[number];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@byok-sdk/protocol",
-  "version": "0.20.0",
+  "version": "0.22.0",
   "description": "BYOK SDK wire protocol: envelope schema, message types, and codec helpers",
   "type": "module",
   "license": "MIT",