@byollm/protocol 0.1.0-alpha.84 → 0.1.0-alpha.86

package/README.md

@@ -1,5 +1,5 @@
 > [!WARNING]
-> **Alpha (`0.1.0-alpha.84`) — under active development. Don't use this yet.**
+> **Alpha (`0.1.0-alpha.86`) — under active development. Don't use this yet.**
 >
 > Install it deliberately: `npm install @byollm/protocol@alpha`.
 >

package/dist/index.d.ts

@@ -845,6 +845,38 @@ declare function updateOfferFor(input: {
 }): {
     readonly updateTo?: string;
 };
+/**
+ * Source with its comments removed, for the checks below.
+ *
+ * Comments go first because a rule about a field has to be explainable in
+ * prose beside the code it governs — and the first version of the relay's
+ * fence test flagged its own explanation, which was written to say there
+ * must be no such write anywhere.
+ */
+declare function withoutComments(source: string): string;
+/**
+ * Does this source mention a wire field at all?
+ *
+ * **A word, not a spelling.** The relay's fence test shipped scanning for
+ * `/\bupdateTo\s*:/`, which is one syntax of one way to set a property —
+ * `"updateTo": offer`, `res.updateTo = offer`, `res["updateTo"] = offer` and
+ * shorthand in a spread all walk straight past it. The check's claim was
+ * "there is nowhere else to call from"; what it enforced was a spelling.
+ * That is our own recurring law, and this is its sixth instance — the first
+ * inside a test written to be structural rather than remembered.
+ *
+ * So the question this asks is deliberately blunter than the rule it serves.
+ * A mention is not a write, and the false positives are the point: anything
+ * that names the field in code has to be looked at by a person, because the
+ * cost of the miss is every daemon that predates the field rejecting every
+ * heartbeat.
+ *
+ * Lives here, beside {@link updateOfferFor}, so the hub and the relay run one
+ * copy rather than two that drift — the field's hazard is fleet-wide and it
+ * crosses a repository boundary, which is exactly where a duplicated rule
+ * stops being the same rule.
+ */
+declare function mentionsWireField(source: string, field: string): boolean;
 
 /** The full description — five sections, plus why it matters. */
 declare const ABOUT = "# About BYOLLM\n\n**What BYOLLM is**\n\nBYOLLM lets you use your own AI on websites. You install one small program on\nyour computer. Then, websites that support BYOLLM can use the AI you already\nhave \u2014 a free model running on your machine, or an AI service you already pay\nfor \u2014 instead of the website paying for AI and passing the cost to you.\n\n**Why it matters**\n\nFor you:\n\n- Your favorite model, everywhere you go.\n- New models the moment you get them \u2013 not when a site gets around to adding\n  them.\n- Encrypted end-to-end. Your prompts go to your own device; byollm.cloud can't\n  read them.\n- Sites never learn which model you use, and your subscriptions are never\n  shared.\n- Pay less. Sites that don't pay for AI can charge you less \u2013 or nothing.\n\nFor sites and developers:\n\n- Zero AI bills. Your users bring their own compute.\n- No floating money \u2013 you don't pay LLM bills up front and hope to collect\n  later, and you never ask people to prepay just to try you.\n- Free trials that cost you nothing to offer.\n- Ship the AI features you kept private for fear of the API bill.\n- One small integration. Your users choose the models.\n\n**Your device**\n\nThe `byollm` program runs on your computer. It knows which AI services you have\nset up: free open-source models on your machine, metered services you pay per\nuse, or your own subscriptions like Claude Pro/Max. When a website you have\nenabled sends work, your device runs it with the service you chose. Your\nprompts are encrypted end-to-end to your own device. byollm.cloud passes them\nalong and cannot read them.\n\n**Sites**\n\nA website that wants to use BYOLLM says what it needs \u2014 \"writing help,\" \"chat,\"\nand so on. When you connect the site, you pick which of your services answers\neach one. The site never learns which model you use. You can turn a site off at\nany time, and it stops getting your work.\n\n**Teams (optional)**\n\nA team lets you share what runs on your devices with people you name \u2014 the free\nopen-source models on your machine, or a metered service with a spending limit\nyou set. Your subscription accounts (like Claude Pro/Max) are never shared with\nanyone. That is a rule, not a setting.\n\n**byollm.cloud (or your own relay)**\n\nMany sites, many devices, many people. byollm.cloud keeps track of who has\nallowed what and sends each job to the right device. It never sees your\nprompts. If you would rather run this part yourself, the relay is open source \u2014\nyou can run your own instead of using byollm.cloud.";
@@ -1796,6 +1828,39 @@ declare const MAX_ENVELOPE_BYTES: number;
  * this function is that one number answers both questions.
  */
 declare function envelopeBytes(envelope: unknown): number;
+/**
+ * A size somebody can act on, rounded **up** and only ever up.
+ *
+ * The rounding rule, in one place, because it has now been got wrong twice —
+ * B072. `toFixed` rounds to nearest, so a message one byte over the line
+ * printed "this message is 10.5 MB and the limit is 10.5 MB": a refusal that
+ * reads as a contradiction, given to somebody who now has no idea what to
+ * change.
+ *
+ * The relay found that, fixed it, and wrote the reasoning down beside the
+ * fix. The SDK's refusal then rediscovered the identical bug, because it
+ * copied the SENTENCE rather than the function — which is the same shape as
+ * `MAX_BODY_BYTES` diverging from `MAX_ENVELOPE_BYTES`, and the same answer:
+ * neither side holds the rule.
+ *
+ * Up is also the honest direction. Understating how far over a message is
+ * sends somebody to trim a hundred bytes off something that needs to lose a
+ * megabyte; overstating by a tenth costs them nothing.
+ */
+declare function describeBytes(bytes: number): string;
+/**
+ * What a message that is too big is told, minus anything about pricing.
+ *
+ * Shared because both planes refuse the same thing for the same reason. What
+ * is NOT shared is the relay's "every plan has the same ceiling" — a hosted
+ * sentence, and meaningless to somebody self-hosting the direct lane, where
+ * there are no plans. One rule, two audiences: the rule travels, the words
+ * about our billing do not.
+ */
+declare function tooLargeMessage(input: {
+    readonly bytes: number;
+    readonly limit: number;
+}): string;
 /** Where the bucket boundaries sit, in characters of payload text. */
 declare const SIZE_CLASS_LIMITS: Readonly<{
     small: 4000;
@@ -2810,4 +2875,4 @@ declare const MUST_IDS: readonly ("PAIR_ONE_USER" | "PAIR_INTERACTIVE" | "PAIR_C
 /** Every MUST verified a particular way. */
 declare function mustsVerifiedBy(kind: MustVerification): MustId[];
 
-export { ABOUT, ABOUT_SHORT, ABOUT_SHORT_LEDE, ABOUT_SHORT_TAIL, AUDIENCES, Audience, BACKENDS, BACKEND_CLASSES, BACKEND_IDS, BackendClass, BackendCost, type BackendDescriptor, type BackendId, BackendIdSchema, CLOCK_ATTRIBUTION_MS, CLOCK_SKEW_WARN_MS, Capability, CapabilityMatrix, ChatMessage, ChatPayload, ClaimRequest, ClaimResponse, ClaimedJob, ClaimedStub, DeliveredResult, ENCRYPTION_KEY_CONTEXT, ENDPOINTS, ENVELOPE_MAX_AGE_MS, ERROR_STATUS, type Endpoint, type EnvelopeContext, EnvelopeDirection, type EnvelopeFailure, FetchRequest, FetchResponse, type FloorRefusal, GRANT_CONTEXT, GRANT_MAX_AGE_MS, GRANT_SIGNED_FIELDS, GeneratePayload, type GrantClaims, GrantRef, type GrantRefusal, HeartbeatRequest, HeartbeatResponse, JOB_KINDS, JobKind, JobOutcome, JobPayload, JobRefused, JobResultCanceled, JobResultError, JobResultOk, JobState, JobStub, KindedPayload, Lease, MAX_CLOCK_SKEW_MS, MAX_ENVELOPE_BYTES, MAX_PURPOSES, MAX_SUCCESSION_CHAIN, MIN_PROTOCOL_VERSION, MUSTS, MUST_IDS, Manifest, type MatchDaemon, type MatchJob, MatchRefusal, type MatchResult, type Must, type MustEnforcer, type MustId, type MustVerification, type MustVerifiedBy, OFFER_SCOPES, OfferScope, type OpenResult, PAYLOAD_LIMITS, PROTOCOL_PREFIX, PROTOCOL_VERSION, PairPollRequest, PairPollResponse, PairRequest, PairStartRequest, PairStartResponse, type PayloadFor, PublicIdentity, Purpose, REFUSAL_MESSAGES, RESERVED_PURPOSE, RETIREMENT_WINDOW_MS, RefusalReason, ReleaseRequest, ReleaseResponse, RequestSignature, ResultDisposition, ResultProvenance, ResultRequest, ResultResponse, RunMetadata, SIZE_CLASSES, SIZE_CLASS_LIMITS, SUCCESSION_CONTEXT, SUPPORTED_PROTOCOL_VERSIONS, SealedEnvelope, SealedOutcome, type SignatureFailure, SignedGrant, SizeClass, type SpendConsent, StoredKeys, Succession, type SuccessionFailure, type SuccessionWalk, TERMINAL_STATES, UPDATE_OFFER_SINCE, UPGRADE_COMMAND, type VersionRefusal, WireError, WireErrorCode, WithheldKind, backendDescriptor, backendName, canTransition, canonicalRequest, checkDaemonFloor, checkProtocolVersion, classifyCost, compareVersions, cryptoReady, declaredVersion, effectiveOfferScope, envelopeBytes, fingerprint, generateKeys, grantStatement, isBackendId, isCloudTaggedModel, isJobKind, isLocalHost, isTerminal, keyId, kindsOf, matchAudience, mayOfferUpdate, mustsVerifiedBy, open, payloadTextLength, provenanceFor, publicIdentityOf, resolveCost, seal, signGrant, signRequest, signSiteRequest, signSuccession, signWith, singlePurposeManifest, sizeClassCeiling, sizeClassOf, successionStatement, updateOfferFor, verifyGrant, verifyLink, verifyPublicIdentity, verifyRequest, verifySiteRequest, verifyWith, walkSuccession };
+export { ABOUT, ABOUT_SHORT, ABOUT_SHORT_LEDE, ABOUT_SHORT_TAIL, AUDIENCES, Audience, BACKENDS, BACKEND_CLASSES, BACKEND_IDS, BackendClass, BackendCost, type BackendDescriptor, type BackendId, BackendIdSchema, CLOCK_ATTRIBUTION_MS, CLOCK_SKEW_WARN_MS, Capability, CapabilityMatrix, ChatMessage, ChatPayload, ClaimRequest, ClaimResponse, ClaimedJob, ClaimedStub, DeliveredResult, ENCRYPTION_KEY_CONTEXT, ENDPOINTS, ENVELOPE_MAX_AGE_MS, ERROR_STATUS, type Endpoint, type EnvelopeContext, EnvelopeDirection, type EnvelopeFailure, FetchRequest, FetchResponse, type FloorRefusal, GRANT_CONTEXT, GRANT_MAX_AGE_MS, GRANT_SIGNED_FIELDS, GeneratePayload, type GrantClaims, GrantRef, type GrantRefusal, HeartbeatRequest, HeartbeatResponse, JOB_KINDS, JobKind, JobOutcome, JobPayload, JobRefused, JobResultCanceled, JobResultError, JobResultOk, JobState, JobStub, KindedPayload, Lease, MAX_CLOCK_SKEW_MS, MAX_ENVELOPE_BYTES, MAX_PURPOSES, MAX_SUCCESSION_CHAIN, MIN_PROTOCOL_VERSION, MUSTS, MUST_IDS, Manifest, type MatchDaemon, type MatchJob, MatchRefusal, type MatchResult, type Must, type MustEnforcer, type MustId, type MustVerification, type MustVerifiedBy, OFFER_SCOPES, OfferScope, type OpenResult, PAYLOAD_LIMITS, PROTOCOL_PREFIX, PROTOCOL_VERSION, PairPollRequest, PairPollResponse, PairRequest, PairStartRequest, PairStartResponse, type PayloadFor, PublicIdentity, Purpose, REFUSAL_MESSAGES, RESERVED_PURPOSE, RETIREMENT_WINDOW_MS, RefusalReason, ReleaseRequest, ReleaseResponse, RequestSignature, ResultDisposition, ResultProvenance, ResultRequest, ResultResponse, RunMetadata, SIZE_CLASSES, SIZE_CLASS_LIMITS, SUCCESSION_CONTEXT, SUPPORTED_PROTOCOL_VERSIONS, SealedEnvelope, SealedOutcome, type SignatureFailure, SignedGrant, SizeClass, type SpendConsent, StoredKeys, Succession, type SuccessionFailure, type SuccessionWalk, TERMINAL_STATES, UPDATE_OFFER_SINCE, UPGRADE_COMMAND, type VersionRefusal, WireError, WireErrorCode, WithheldKind, backendDescriptor, backendName, canTransition, canonicalRequest, checkDaemonFloor, checkProtocolVersion, classifyCost, compareVersions, cryptoReady, declaredVersion, describeBytes, effectiveOfferScope, envelopeBytes, fingerprint, generateKeys, grantStatement, isBackendId, isCloudTaggedModel, isJobKind, isLocalHost, isTerminal, keyId, kindsOf, matchAudience, mayOfferUpdate, mentionsWireField, mustsVerifiedBy, open, payloadTextLength, provenanceFor, publicIdentityOf, resolveCost, seal, signGrant, signRequest, signSiteRequest, signSuccession, signWith, singlePurposeManifest, sizeClassCeiling, sizeClassOf, successionStatement, tooLargeMessage, updateOfferFor, verifyGrant, verifyLink, verifyPublicIdentity, verifyRequest, verifySiteRequest, verifyWith, walkSuccession, withoutComments };

package/dist/index.js

@@ -905,6 +905,12 @@ function envelopeBytes(envelope) {
   const serialised = JSON.stringify(envelope);
   return serialised === void 0 ? 0 : serialised.length;
 }
+function describeBytes(bytes) {
+  return `${(Math.ceil(bytes / (1024 * 1024) * 10) / 10).toFixed(1)} MB`;
+}
+function tooLargeMessage(input) {
+  return `this message is ${describeBytes(input.bytes)} and the limit is ${describeBytes(input.limit)} \u2014 it is a limit on one message rather than on how many you send. Split the work into smaller jobs and send them separately.`;
+}
 var SIZE_CLASS_LIMITS = Object.freeze({
   small: 4e3,
   medium: 64e3,
@@ -1896,6 +1902,12 @@ function updateOfferFor(input) {
 function exactOffer(value) {
   return /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/.test(value) ? value : void 0;
 }
+function withoutComments(source) {
+  return source.replace(/\/\*[\s\S]*?\*\//g, " ").replace(/^[ \t]*\/\/.*$/gm, " ");
+}
+function mentionsWireField(source, field) {
+  return new RegExp(`\\b${field}\\b`).test(withoutComments(source));
+}
 
 // src/about.ts
 var ABOUT = `# About BYOLLM
@@ -2621,6 +2633,7 @@ export {
   compareVersions,
   cryptoReady,
   declaredVersion,
+  describeBytes,
   effectiveOfferScope,
   envelopeBytes,
   fingerprint,
@@ -2635,6 +2648,7 @@ export {
   kindsOf,
   matchAudience,
   mayOfferUpdate,
+  mentionsWireField,
   mustsVerifiedBy,
   open,
   payloadTextLength,
@@ -2651,6 +2665,7 @@ export {
   sizeClassCeiling,
   sizeClassOf,
   successionStatement,
+  tooLargeMessage,
   updateOfferFor,
   verifyGrant,
   verifyLink,
@@ -2658,6 +2673,7 @@ export {
   verifyRequest,
   verifySiteRequest,
   verifyWith,
-  walkSuccession
+  walkSuccession,
+  withoutComments
 };
 //# sourceMappingURL=index.js.map