@kaana.ai/contracts 6.1.1 → 8.0.0

package/dist/internal/attribution.d.ts

@@ -4,15 +4,7 @@
  * Moved from `@oxy.so/contracts` 4.12.0 (`src/inference/attribution.ts`) by Kaana ADR 0002.
  */
 import { z } from 'zod';
-/**
- * The inference capability scopes the data plane needs to know about.
- *
- * A credential may carry many other Oxy scopes; only these cross the boundary,
- * because the data plane's authorization questions are exactly "may this caller
- * invoke", "may it read the catalogue", "may it read usage", "may it read or
- * write routing", "may it read or write provider connections". Everything else
- * is the control plane's business and is not the data plane's to hold.
- */
+/** External caller limits recorded by Oxy. First-party instructions carry no scopes. */
 export declare const INFERENCE_SCOPES: readonly ["inference:invoke", "inference:models:read", "inference:usage:read", "inference:routing:read", "inference:routing:write", "inference:providers:read", "inference:providers:write"];
 export declare const inferenceScopeSchema: z.ZodEnum<{
     "inference:invoke": "inference:invoke";
@@ -35,17 +27,9 @@ export declare const inferenceScopeSchema: z.ZodEnum<{
 export declare const billingPrincipalSchema: z.ZodObject<{
     accountId: z.core.$ZodBranded<z.ZodString, "OxyAccountId", "out">;
 }, z.core.$strict>;
-/**
- * Who authenticated, as resolved by the Oxy edge before a request is forwarded.
- *
- * Mirrors what a verified Oxy service token carries (`appId`, `credentialId`,
- * `ownerAccountId`, `environment`, effective scopes) so that the two
- * authentication paths — a machine API key and a first-party service token —
- * produce one shape downstream. The data plane authorizes against this
- * envelope; it does not re-derive access from its own database, because it has
- * no account graph to re-derive it from.
- */
-export declare const authenticatedPrincipalSchema: z.ZodObject<{
+/** Oxy has authorized this instruction; the discriminator never grants customer access in Kaana. */
+export declare const authenticatedPrincipalSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    authority: z.ZodLiteral<"first_party">;
     billing: z.ZodObject<{
         accountId: z.core.$ZodBranded<z.ZodString, "OxyAccountId", "out">;
     }, z.core.$strict>;
@@ -56,6 +40,8 @@ export declare const authenticatedPrincipalSchema: z.ZodObject<{
         staging: "staging";
         production: "production";
     }>;
+}, z.core.$strict>, z.ZodObject<{
+    authority: z.ZodOptional<z.ZodLiteral<"external">>;
     inferenceScopes: z.ZodArray<z.ZodEnum<{
         "inference:invoke": "inference:invoke";
         "inference:models:read": "inference:models:read";
@@ -65,7 +51,17 @@ export declare const authenticatedPrincipalSchema: z.ZodObject<{
         "inference:providers:read": "inference:providers:read";
         "inference:providers:write": "inference:providers:write";
     }>>;
-}, z.core.$strip>;
+    billing: z.ZodObject<{
+        accountId: z.core.$ZodBranded<z.ZodString, "OxyAccountId", "out">;
+    }, z.core.$strict>;
+    applicationId: z.ZodString;
+    credentialId: z.ZodString;
+    environment: z.ZodEnum<{
+        development: "development";
+        staging: "staging";
+        production: "production";
+    }>;
+}, z.core.$strict>], "authority">;
 /**
  * The attribution block carried by every request, receipt and ledger record.
  *
@@ -85,7 +81,8 @@ export declare const authenticatedPrincipalSchema: z.ZodObject<{
  * because only the data plane knows how many outputs a request produced.
  */
 export declare const inferenceAttributionSchema: z.ZodObject<{
-    principal: z.ZodObject<{
+    principal: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        authority: z.ZodLiteral<"first_party">;
         billing: z.ZodObject<{
             accountId: z.core.$ZodBranded<z.ZodString, "OxyAccountId", "out">;
         }, z.core.$strict>;
@@ -96,6 +93,8 @@ export declare const inferenceAttributionSchema: z.ZodObject<{
             staging: "staging";
             production: "production";
         }>;
+    }, z.core.$strict>, z.ZodObject<{
+        authority: z.ZodOptional<z.ZodLiteral<"external">>;
         inferenceScopes: z.ZodArray<z.ZodEnum<{
             "inference:invoke": "inference:invoke";
             "inference:models:read": "inference:models:read";
@@ -105,7 +104,17 @@ export declare const inferenceAttributionSchema: z.ZodObject<{
             "inference:providers:read": "inference:providers:read";
             "inference:providers:write": "inference:providers:write";
         }>>;
-    }, z.core.$strip>;
+        billing: z.ZodObject<{
+            accountId: z.core.$ZodBranded<z.ZodString, "OxyAccountId", "out">;
+        }, z.core.$strict>;
+        applicationId: z.ZodString;
+        credentialId: z.ZodString;
+        environment: z.ZodEnum<{
+            development: "development";
+            staging: "staging";
+            production: "production";
+        }>;
+    }, z.core.$strict>], "authority">;
     userId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "DelegatedUserId", "out">>;
     requestId: z.ZodString;
     generationId: z.ZodOptional<z.ZodString>;

package/dist/internal/attribution.js

@@ -6,15 +6,7 @@
 import { z } from 'zod';
 import { delegatedUserIdSchema, generationIdSchema, inferenceEnvironmentSchema, oxyApplicationIdSchema, oxyCredentialIdSchema, requestIdSchema, } from '../public/identifiers.js';
 import { oxyAccountIdSchema } from './identifiers.js';
-/**
- * The inference capability scopes the data plane needs to know about.
- *
- * A credential may carry many other Oxy scopes; only these cross the boundary,
- * because the data plane's authorization questions are exactly "may this caller
- * invoke", "may it read the catalogue", "may it read usage", "may it read or
- * write routing", "may it read or write provider connections". Everything else
- * is the control plane's business and is not the data plane's to hold.
- */
+/** External caller limits recorded by Oxy. First-party instructions carry no scopes. */
 export const INFERENCE_SCOPES = [
     'inference:invoke',
     'inference:models:read',
@@ -49,13 +41,23 @@ export const billingPrincipalSchema = z
  * envelope; it does not re-derive access from its own database, because it has
  * no account graph to re-derive it from.
  */
-export const authenticatedPrincipalSchema = z.object({
+const principalIdentity = {
     billing: billingPrincipalSchema,
     applicationId: oxyApplicationIdSchema,
     credentialId: oxyCredentialIdSchema,
     environment: inferenceEnvironmentSchema,
-    inferenceScopes: z.array(inferenceScopeSchema),
-});
+};
+/** Oxy has authorized this instruction; the discriminator never grants customer access in Kaana. */
+export const authenticatedPrincipalSchema = z.discriminatedUnion('authority', [
+    z.object({ ...principalIdentity, authority: z.literal('first_party') }).strict(),
+    z
+        .object({
+        ...principalIdentity,
+        authority: z.literal('external').optional(),
+        inferenceScopes: z.array(inferenceScopeSchema),
+    })
+        .strict(),
+]);
 /**
  * The attribution block carried by every request, receipt and ledger record.
  *

package/dist/internal/catalogue.d.ts

@@ -226,35 +226,6 @@ export declare const inferenceProviderSchema: z.ZodObject<{
 export declare const modelDeploymentSchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<2>;
     deploymentId: z.ZodString;
-    scopedExecution: z.ZodOptional<z.ZodObject<{
-        permitId: z.ZodString;
-        idempotencyKey: z.ZodString;
-        fixtureSha256: z.ZodString;
-        expiresAt: z.ZodString;
-        principal: z.ZodObject<{
-            accountId: z.ZodString;
-            applicationId: z.ZodString;
-            credentialId: z.ZodString;
-            environment: z.ZodEnum<{
-                development: "development";
-                staging: "staging";
-                production: "production";
-            }>;
-        }, z.core.$strict>;
-        policy: z.ZodObject<{
-            routingPolicyId: z.ZodString;
-            policyVersion: z.ZodNumber;
-        }, z.core.$strict>;
-        deploymentId: z.ZodString;
-        provider: z.ZodString;
-        keyId: z.ZodString;
-        modelReference: z.ZodString;
-        upstreamModelId: z.ZodString;
-        priceVersionId: z.ZodString;
-        providerRateCardVersionId: z.ZodString;
-        providerSourceVersion: z.ZodString;
-        maxCostUsd: z.core.$ZodBranded<z.ZodString, "ExactDecimal", "out">;
-    }, z.core.$strict>>;
     provider: z.ZodString;
     modelReference: z.ZodString;
     regions: z.ZodArray<z.ZodString>;
@@ -291,10 +262,9 @@ export declare const modelDeploymentSchema: z.ZodObject<{
 }, z.core.$strip>;
 /**
  * The commercial facts Kaana publishes about ONE deployment on the descriptors
- * it serves to Oxy (`POST /internal/v1/deployments/query` and
- * `/internal/v1/models/query`), from the reviewed file
- * `configs/deployment-commercial.json`. A deployment that is not sold carries
- * no `commercial` at all, which is why the member is optional on the
+ * it serves to Oxy (`POST /internal/v1/deployments/query`), from the reviewed
+ * file `configs/deployment-commercial.json`. A deployment that is not sold
+ * carries no `commercial` at all, which is why the member is optional on the
  * descriptor. New in contract set 4.4.0.
  *
  * `customer_byok` is the commercial basis of a `byok_only` route and of no

package/dist/internal/catalogue.js

@@ -9,7 +9,6 @@ import { cataloguePublisherSummarySchema, inferenceDataPolicySchema, modelCapabi
 import { inferenceDateSchema, inferenceHttpsUrlSchema, inferenceRegionSchema, inferenceTimestampSchema, modelIdSchema, modelReferenceSchema, modelRevisionLabelSchema, modelSlugSchema, publisherSlugSchema, RESERVED_ALIA_PUBLISHER, sha256DigestSchema, } from '../public/identifiers.js';
 import { priceSnapshotSchema } from '../public/money.js';
 import { deploymentIdSchema, inferenceProviderSlugSchema, routingProfileIdSchema, routingProfileSlugSchema, } from './identifiers.js';
-import { scopedExecutionAudienceSchema } from './scopedExecution.js';
 /**
  * Who a route may be served to. Availability to an official Oxy product never
  * implies permission to resell the same provider/model publicly, which is why
@@ -155,8 +154,6 @@ export const modelDeploymentSchema = z
     /** See `version.ts`: exchanged with the data plane on its own. */
     schemaVersion: z.literal(2),
     deploymentId: deploymentIdSchema,
-    /** Restrictive audience; never an eligibility approval. */
-    scopedExecution: scopedExecutionAudienceSchema.optional(),
     provider: inferenceProviderSlugSchema,
     /** Always revision-pinned: a deployment serves specific weights. */
     modelReference: modelReferenceSchema,
@@ -213,10 +210,9 @@ export const modelDeploymentSchema = z
 });
 /**
  * The commercial facts Kaana publishes about ONE deployment on the descriptors
- * it serves to Oxy (`POST /internal/v1/deployments/query` and
- * `/internal/v1/models/query`), from the reviewed file
- * `configs/deployment-commercial.json`. A deployment that is not sold carries
- * no `commercial` at all, which is why the member is optional on the
+ * it serves to Oxy (`POST /internal/v1/deployments/query`), from the reviewed
+ * file `configs/deployment-commercial.json`. A deployment that is not sold
+ * carries no `commercial` at all, which is why the member is optional on the
  * descriptor. New in contract set 4.4.0.
  *
  * `customer_byok` is the commercial basis of a `byok_only` route and of no

package/dist/internal/decisions.d.ts

@@ -10,7 +10,8 @@ export declare const decisionResultSchema: z.ZodObject<{
         requestId: z.ZodString;
         generationId: z.ZodOptional<z.ZodString>;
         attribution: z.ZodObject<{
-            principal: z.ZodObject<{
+            principal: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                authority: z.ZodLiteral<"first_party">;
                 billing: z.ZodObject<{
                     accountId: z.core.$ZodBranded<z.ZodString, "OxyAccountId", "out">;
                 }, z.core.$strict>;
@@ -21,6 +22,8 @@ export declare const decisionResultSchema: z.ZodObject<{
                     staging: "staging";
                     production: "production";
                 }>;
+            }, z.core.$strict>, z.ZodObject<{
+                authority: z.ZodOptional<z.ZodLiteral<"external">>;
                 inferenceScopes: z.ZodArray<z.ZodEnum<{
                     "inference:invoke": "inference:invoke";
                     "inference:models:read": "inference:models:read";
@@ -30,7 +33,17 @@ export declare const decisionResultSchema: z.ZodObject<{
                     "inference:providers:read": "inference:providers:read";
                     "inference:providers:write": "inference:providers:write";
                 }>>;
-            }, z.core.$strip>;
+                billing: z.ZodObject<{
+                    accountId: z.core.$ZodBranded<z.ZodString, "OxyAccountId", "out">;
+                }, z.core.$strict>;
+                applicationId: z.ZodString;
+                credentialId: z.ZodString;
+                environment: z.ZodEnum<{
+                    development: "development";
+                    staging: "staging";
+                    production: "production";
+                }>;
+            }, z.core.$strict>], "authority">;
             userId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "DelegatedUserId", "out">>;
             requestId: z.ZodString;
             generationId: z.ZodOptional<z.ZodString>;
@@ -170,7 +183,8 @@ export declare const decisionFailureSchema: z.ZodObject<{
         requestId: z.ZodString;
         generationId: z.ZodOptional<z.ZodString>;
         attribution: z.ZodObject<{
-            principal: z.ZodObject<{
+            principal: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                authority: z.ZodLiteral<"first_party">;
                 billing: z.ZodObject<{
                     accountId: z.core.$ZodBranded<z.ZodString, "OxyAccountId", "out">;
                 }, z.core.$strict>;
@@ -181,6 +195,8 @@ export declare const decisionFailureSchema: z.ZodObject<{
                     staging: "staging";
                     production: "production";
                 }>;
+            }, z.core.$strict>, z.ZodObject<{
+                authority: z.ZodOptional<z.ZodLiteral<"external">>;
                 inferenceScopes: z.ZodArray<z.ZodEnum<{
                     "inference:invoke": "inference:invoke";
                     "inference:models:read": "inference:models:read";
@@ -190,7 +206,17 @@ export declare const decisionFailureSchema: z.ZodObject<{
                     "inference:providers:read": "inference:providers:read";
                     "inference:providers:write": "inference:providers:write";
                 }>>;
-            }, z.core.$strip>;
+                billing: z.ZodObject<{
+                    accountId: z.core.$ZodBranded<z.ZodString, "OxyAccountId", "out">;
+                }, z.core.$strict>;
+                applicationId: z.ZodString;
+                credentialId: z.ZodString;
+                environment: z.ZodEnum<{
+                    development: "development";
+                    staging: "staging";
+                    production: "production";
+                }>;
+            }, z.core.$strict>], "authority">;
             userId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "DelegatedUserId", "out">>;
             requestId: z.ZodString;
             generationId: z.ZodOptional<z.ZodString>;

package/dist/internal/grant.d.ts

@@ -12,8 +12,10 @@
  * executes inside the grant; without a valid grant no provider is called.
  *
  * The grant carries the funding model as it is today, field for field: it
- * invents no policy. New in contract set 4.0.0; it replaces what the v1–v4
- * envelopes signed (`authorizedRoutes`, the scoped and Private Auto bindings).
+ * invents no policy. New in contract set 4.0.0; it replaces what the v1–v2
+ * envelopes signed (`authorizedRoutes`). Contract set 7.0.0 removes the exact
+ * route and the canonical input hash of the one-off source approvals: every
+ * operation, decisions included, is an ordinary grant of ordered steps.
  */
 import { z } from 'zod';
 /** The signature domain of a grant. Same Ed25519 keys as the envelope (`KAANA_EDGE_PUBLIC_KEYS`). */
@@ -134,7 +136,6 @@ export declare const inferenceAuthorizationRequestSchema: z.ZodObject<{
     idempotencyKey: z.ZodOptional<z.ZodString>;
     onBehalfOfUserId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "DelegatedUserId", "out">>;
     bodySha256: z.ZodString;
-    canonicalInputSha256: z.ZodOptional<z.ZodString>;
     client: z.ZodObject<{
         endpoint: z.ZodString;
         clientRequestId: z.ZodOptional<z.ZodString>;
@@ -214,7 +215,6 @@ export declare const authorizationRequestSchema: z.ZodDiscriminatedUnion<[z.ZodO
     idempotencyKey: z.ZodOptional<z.ZodString>;
     onBehalfOfUserId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "DelegatedUserId", "out">>;
     bodySha256: z.ZodString;
-    canonicalInputSha256: z.ZodOptional<z.ZodString>;
     client: z.ZodObject<{
         endpoint: z.ZodString;
         clientRequestId: z.ZodOptional<z.ZodString>;
@@ -241,12 +241,8 @@ export declare const grantLaneSchema: z.ZodEnum<{
     service_token: "service_token";
     product_session: "product_session";
 }>;
-/**
- * Who pays and who called. `billingAccountId` is the owner of the
- * authenticated application, UNRESOLVED: the ledger resolves the billable
- * ancestor. The end user never pays.
- */
-export declare const grantPrincipalSchema: z.ZodObject<{
+export declare const grantPrincipalSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    authority: z.ZodLiteral<"first_party">;
     billingAccountId: z.core.$ZodBranded<z.ZodString, "OxyAccountId", "out">;
     applicationId: z.ZodString;
     credentialId: z.ZodString;
@@ -255,6 +251,13 @@ export declare const grantPrincipalSchema: z.ZodObject<{
         staging: "staging";
         production: "production";
     }>;
+    lane: z.ZodEnum<{
+        machine_credential: "machine_credential";
+        service_token: "service_token";
+        product_session: "product_session";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    authority: z.ZodOptional<z.ZodLiteral<"external">>;
     scopes: z.ZodArray<z.ZodEnum<{
         "inference:invoke": "inference:invoke";
         "inference:models:read": "inference:models:read";
@@ -264,12 +267,20 @@ export declare const grantPrincipalSchema: z.ZodObject<{
         "inference:providers:read": "inference:providers:read";
         "inference:providers:write": "inference:providers:write";
     }>>;
+    billingAccountId: z.core.$ZodBranded<z.ZodString, "OxyAccountId", "out">;
+    applicationId: z.ZodString;
+    credentialId: z.ZodString;
+    environment: z.ZodEnum<{
+        development: "development";
+        staging: "staging";
+        production: "production";
+    }>;
     lane: z.ZodEnum<{
         machine_credential: "machine_credential";
         service_token: "service_token";
         product_session: "product_session";
     }>;
-}, z.core.$strict>;
+}, z.core.$strict>], "authority">;
 /** A model line Oxy admits for a step, with the price it settles at. */
 export declare const admittedModelLineSchema: z.ZodObject<{
     modelLine: z.ZodString;
@@ -353,24 +364,6 @@ export declare const grantStepSchema: z.ZodObject<{
         sameModelFailover: z.ZodDefault<z.ZodBoolean>;
     }, z.core.$strict>;
 }, z.core.$strict>;
-/**
- * The exact route of an operation with a source approval (scoped execution,
- * Private Auto, the Mention classifier): the deployment, provider, key and
- * price the approval fixed, and the input it was approved for.
- */
-export declare const grantExactRouteSchema: z.ZodObject<{
-    approval: z.ZodEnum<{
-        scoped_execution: "scoped_execution";
-        private_auto: "private_auto";
-        mention_classifier: "mention_classifier";
-    }>;
-    deploymentId: z.ZodString;
-    provider: z.ZodString;
-    keyId: z.ZodString;
-    modelReference: z.ZodString;
-    priceVersionId: z.ZodString;
-    inputSha256: z.ZodString;
-}, z.core.$strict>;
 /**
  * The signed grant: the body of a successful authorization for an inference
  * operation. Kaana verifies it and executes inside it; Oxy settles against it.
@@ -392,7 +385,8 @@ export declare const grantSchema: z.ZodObject<{
     issuedAt: z.ZodString;
     executeBy: z.ZodString;
     bodySha256: z.ZodString;
-    principal: z.ZodObject<{
+    principal: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        authority: z.ZodLiteral<"first_party">;
         billingAccountId: z.core.$ZodBranded<z.ZodString, "OxyAccountId", "out">;
         applicationId: z.ZodString;
         credentialId: z.ZodString;
@@ -401,6 +395,13 @@ export declare const grantSchema: z.ZodObject<{
             staging: "staging";
             production: "production";
         }>;
+        lane: z.ZodEnum<{
+            machine_credential: "machine_credential";
+            service_token: "service_token";
+            product_session: "product_session";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        authority: z.ZodOptional<z.ZodLiteral<"external">>;
         scopes: z.ZodArray<z.ZodEnum<{
             "inference:invoke": "inference:invoke";
             "inference:models:read": "inference:models:read";
@@ -410,12 +411,20 @@ export declare const grantSchema: z.ZodObject<{
             "inference:providers:read": "inference:providers:read";
             "inference:providers:write": "inference:providers:write";
         }>>;
+        billingAccountId: z.core.$ZodBranded<z.ZodString, "OxyAccountId", "out">;
+        applicationId: z.ZodString;
+        credentialId: z.ZodString;
+        environment: z.ZodEnum<{
+            development: "development";
+            staging: "staging";
+            production: "production";
+        }>;
         lane: z.ZodEnum<{
             machine_credential: "machine_credential";
             service_token: "service_token";
             product_session: "product_session";
         }>;
-    }, z.core.$strict>;
+    }, z.core.$strict>], "authority">;
     userId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "DelegatedUserId", "out">>;
     economics: z.ZodObject<{
         treatment: z.ZodEnum<{
@@ -479,19 +488,6 @@ export declare const grantSchema: z.ZodObject<{
             sameModelFailover: z.ZodDefault<z.ZodBoolean>;
         }, z.core.$strict>;
     }, z.core.$strict>>;
-    exactRoute: z.ZodOptional<z.ZodObject<{
-        approval: z.ZodEnum<{
-            scoped_execution: "scoped_execution";
-            private_auto: "private_auto";
-            mention_classifier: "mention_classifier";
-        }>;
-        deploymentId: z.ZodString;
-        provider: z.ZodString;
-        keyId: z.ZodString;
-        modelReference: z.ZodString;
-        priceVersionId: z.ZodString;
-        inputSha256: z.ZodString;
-    }, z.core.$strict>>;
     customerProviderCredential: z.ZodOptional<z.ZodObject<{
         credentialHandle: z.ZodString;
         credentialRevision: z.ZodNumber;
@@ -693,7 +689,6 @@ export type GrantPrincipal = z.infer<typeof grantPrincipalSchema>;
 export type AdmittedModelLine = z.infer<typeof admittedModelLineSchema>;
 export type GrantStepLimits = z.infer<typeof grantStepLimitsSchema>;
 export type GrantStep = z.infer<typeof grantStepSchema>;
-export type GrantExactRoute = z.infer<typeof grantExactRouteSchema>;
 export type Grant = z.infer<typeof grantSchema>;
 export type CatalogueAccess = z.infer<typeof catalogueAccessSchema>;
 export type ReceiptAccess = z.infer<typeof receiptAccessSchema>;

package/dist/internal/grant.js

@@ -12,19 +12,21 @@
  * executes inside the grant; without a valid grant no provider is called.
  *
  * The grant carries the funding model as it is today, field for field: it
- * invents no policy. New in contract set 4.0.0; it replaces what the v1–v4
- * envelopes signed (`authorizedRoutes`, the scoped and Private Auto bindings).
+ * invents no policy. New in contract set 4.0.0; it replaces what the v1–v2
+ * envelopes signed (`authorizedRoutes`). Contract set 7.0.0 removes the exact
+ * route and the canonical input hash of the one-off source approvals: every
+ * operation, decisions included, is an ordinary grant of ordered steps.
  */
 import { z } from 'zod';
 import { powerLevelSchema, realtimeSessionKindSchema } from '../public/catalogue.js';
 import { generationRecordSchema } from '../public/generations.js';
-import { delegatedUserIdSchema, generationIdSchema, idempotencyKeySchema, inferenceEnvironmentSchema, inferenceRegionSchema, inferenceTimestampSchema, modelIdSchema, modelReferenceSchema, modelRevisionLabelSchema, oxyApplicationIdSchema, oxyCredentialIdSchema, requestIdSchema, } from '../public/identifiers.js';
+import { delegatedUserIdSchema, generationIdSchema, idempotencyKeySchema, inferenceEnvironmentSchema, inferenceRegionSchema, inferenceTimestampSchema, modelIdSchema, modelRevisionLabelSchema, oxyApplicationIdSchema, oxyCredentialIdSchema, requestIdSchema, } from '../public/identifiers.js';
 import { requestLabelsSchema } from '../public/messages.js';
 import { moneySchema } from '../public/money.js';
 import { routingPolicyReferenceSchema } from '../public/policy.js';
 import { inferenceScopeSchema } from './attribution.js';
 import { inferenceEconomicTreatmentSchema } from './economics.js';
-import { deploymentIdSchema, inferenceFundingTierSchema, inferenceProviderSlugSchema, oxyAccountIdSchema, } from './identifiers.js';
+import { inferenceFundingTierSchema, inferenceProviderSlugSchema, oxyAccountIdSchema, } from './identifiers.js';
 import { authorizedRouteSchema } from './routing.js';
 /* -------------------------------------------------------------------------- */
 /*  Signing                                                                    */
@@ -132,12 +134,6 @@ export const inferenceAuthorizationRequestSchema = z
     onBehalfOfUserId: delegatedUserIdSchema.optional(),
     /** SHA-256 of the normalized request body; the grant is bound to it. */
     bodySha256: sha256HexSchema,
-    /**
-     * For an operation under a source approval (scoped execution, Private Auto,
-     * the Jev classifier): `canonicalInputSha256(input)`, which Oxy compares
-     * with the hash the approval fixed.
-     */
-    canonicalInputSha256: sha256HexSchema.optional(),
     client: z
         .object({
         /** The public path, e.g. `/v1/responses`. */
@@ -201,16 +197,32 @@ export const grantLaneSchema = z.enum(['machine_credential', 'service_token', 'p
  * authenticated application, UNRESOLVED: the ledger resolves the billable
  * ancestor. The end user never pays.
  */
-export const grantPrincipalSchema = z
-    .object({
+const grantPrincipalIdentity = {
     billingAccountId: oxyAccountIdSchema,
     applicationId: oxyApplicationIdSchema,
     credentialId: oxyCredentialIdSchema,
     environment: inferenceEnvironmentSchema,
-    scopes: z.array(inferenceScopeSchema),
     lane: grantLaneSchema,
-})
-    .strict();
+};
+export const grantPrincipalSchema = z
+    .discriminatedUnion('authority', [
+    z.object({ ...grantPrincipalIdentity, authority: z.literal('first_party') }).strict(),
+    z
+        .object({
+        ...grantPrincipalIdentity,
+        authority: z.literal('external').optional(),
+        scopes: z.array(inferenceScopeSchema),
+    })
+        .strict(),
+])
+    .superRefine((principal, ctx) => {
+    if (principal.authority === 'first_party' && principal.lane === 'machine_credential')
+        ctx.addIssue({
+            code: 'custom',
+            path: ['lane'],
+            message: 'A customer API key never has first-party authority',
+        });
+});
 /** A model line Oxy admits for a step, with the price it settles at. */
 export const admittedModelLineSchema = z
     .object({
@@ -299,34 +311,6 @@ export const grantStepSchema = z
         });
     }
 });
-/**
- * The exact route of an operation with a source approval (scoped execution,
- * Private Auto, the Mention classifier): the deployment, provider, key and
- * price the approval fixed, and the input it was approved for.
- */
-export const grantExactRouteSchema = z
-    .object({
-    approval: z.enum(['scoped_execution', 'private_auto', 'mention_classifier']),
-    deploymentId: deploymentIdSchema,
-    provider: inferenceProviderSlugSchema,
-    /** The provider key the approval fixed (opaque Kaana key identity). */
-    keyId: z.string().min(1).max(256),
-    /** Always revision-pinned. */
-    modelReference: modelReferenceSchema,
-    priceVersionId: z.string().min(1).max(128),
-    /** `canonicalInputSha256` of the approved input. */
-    inputSha256: sha256HexSchema,
-})
-    .strict()
-    .superRefine((route, ctx) => {
-    if (!route.modelReference.includes('@')) {
-        ctx.addIssue({
-            code: 'custom',
-            path: ['modelReference'],
-            message: 'an exact route pins an immutable revision',
-        });
-    }
-});
 /** The BYOK binding, exactly as an authorized route carries it today. */
 const customerProviderCredentialBinding = authorizedRouteSchema.options[0].shape.customerProviderCredential;
 /**
@@ -360,7 +344,7 @@ export const grantSchema = z
         reservationId: z.string().min(1).max(128),
         /** The most the hold covers. Shown, never spent by Kaana. */
         ceiling: moneySchema,
-        /** `promotional-only` for a scoped permit. */
+        /** `promotional-only`: the hold draws on promotional credit alone. */
         fundingRestriction: z.literal('promotional-only').optional(),
     })
         .strict()
@@ -371,7 +355,6 @@ export const grantSchema = z
         .strict()
         .optional(),
     steps: z.array(grantStepSchema).min(1).max(8),
-    exactRoute: grantExactRouteSchema.optional(),
     /** BYOK: the customer's own provider key. Excludes `maxFundingTier`. */
     customerProviderCredential: customerProviderCredentialBinding,
     idempotencyKey: idempotencyKeySchema.optional(),
@@ -403,22 +386,6 @@ export const grantSchema = z
             issue(['steps', index, 'limits', 'maxFundingTier'], 'a funding ceiling bounds platform keys; a customer credential is billed to the customer');
         }
     }
-    if (grant.exactRoute !== undefined) {
-        const [step] = grant.steps;
-        const route = grant.exactRoute;
-        const [line, revision] = route.modelReference.split('@');
-        if (grant.steps.length !== 1 ||
-            step.target.kind !== 'model' ||
-            step.target.modelLine !== line ||
-            step.target.revision !== revision ||
-            byok) {
-            issue(['exactRoute'], 'an exact route is one platform route for the one pinned model the grant serves');
-        }
-        if (step !== undefined &&
-            !step.limits.admittedModelLines.some((admitted) => admitted.modelLine === line && admitted.priceVersionId === route.priceVersionId)) {
-            issue(['exactRoute', 'priceVersionId'], 'the exact route settles at its admitted price');
-        }
-    }
 });
 /**
  * The answer to a catalogue authorization: what the credential may see.