@adea-ai/runtime-sdk 1.24.0 → 2.0.0

package/dist/compatibility.d.ts

@@ -13,7 +13,6 @@ export declare const RuntimeCertificationSchema: z.ZodObject<{
     runtimeFamily: z.ZodString;
     connectionType: z.ZodEnum<{
         external_local: "external_local";
-        managed_cloud: "managed_cloud";
         managed_local: "managed_local";
     }>;
     classification: z.ZodEnum<{
@@ -67,7 +66,6 @@ export declare const RuntimeCertificationSchema: z.ZodObject<{
             x64: "x64";
         }>;
         location: z.ZodEnum<{
-            agent_hq_cloud: "agent_hq_cloud";
             local_device: "local_device";
         }>;
         environment: z.ZodString;
@@ -100,7 +98,6 @@ export declare const RuntimeCompatibilityMatrixSchema: z.ZodObject<{
         runtimeFamily: z.ZodString;
         connectionType: z.ZodEnum<{
             external_local: "external_local";
-            managed_cloud: "managed_cloud";
             managed_local: "managed_local";
         }>;
         classification: z.ZodEnum<{
@@ -154,7 +151,6 @@ export declare const RuntimeCompatibilityMatrixSchema: z.ZodObject<{
                 x64: "x64";
             }>;
             location: z.ZodEnum<{
-                agent_hq_cloud: "agent_hq_cloud";
                 local_device: "local_device";
             }>;
             environment: z.ZodString;

package/dist/discovery.d.ts

@@ -6,7 +6,7 @@ export interface RuntimeConnectionDiscoveryProjectionInput {
     readonly connection: RuntimeConnection;
     readonly family: string;
     readonly node?: unknown;
-    readonly nodeHealth: 'online' | 'offline' | 'unknown' | 'revoked' | 'not_applicable';
+    readonly nodeHealth: 'online' | 'offline' | 'unknown' | 'revoked';
     readonly evaluatedAt: string;
     readonly localProjectGrant: {
         readonly required: boolean;

package/dist/discovery.js

@@ -7,15 +7,12 @@ import { ExternalSessionAssessmentSchema, ExternalSessionSchema, } from './sessi
 export function projectRuntimeConnectionDiscovery(inputValue) {
     const connection = RuntimeConnectionSchema.parse(inputValue.connection);
     const evaluatedAt = RuntimeTimestampSchema.parse(inputValue.evaluatedAt);
-    const nodeHealth = inputValue.nodeHealth === 'not_applicable'
-        ? 'not_applicable'
-        : RuntimeNodeHealthStatusSchema.parse(inputValue.nodeHealth);
+    const nodeHealth = RuntimeNodeHealthStatusSchema.parse(inputValue.nodeHealth);
     const node = inputValue.node === undefined ? undefined : RuntimeNodeRefSchema.parse(inputValue.node);
-    const local = connection.connectionType !== 'managed_cloud';
-    if (local !== (node !== undefined) || local !== (nodeHealth !== 'not_applicable')) {
+    if (node === undefined) {
         throw new Error('RUNTIME_DISCOVERY_NODE_SCOPE_MISMATCH');
     }
-    if (node && node.runtimeNodeRefId !== connection.runtimeNodeRefId) {
+    if (node.runtimeNodeRefId !== connection.runtimeNodeRefId) {
         throw new Error('RUNTIME_DISCOVERY_NODE_ID_MISMATCH');
     }
     const requiredCapabilities = (inputValue.requiredCapabilities ?? []).map((capability) => RuntimeCapabilityNameSchema.parse(capability));

package/dist/eligibility.d.ts

@@ -1,10 +1,10 @@
 import { z } from 'zod';
-export declare const RuntimeEligibilityNodeStatusSchema: z.ZodUnion<readonly [z.ZodEnum<{
+export declare const RuntimeEligibilityNodeStatusSchema: z.ZodEnum<{
     offline: "offline";
     online: "online";
     revoked: "revoked";
     unknown: "unknown";
-}>, z.ZodLiteral<"not_applicable">]>;
+}>;
 export declare const RuntimeEligibilityInputSchema: z.ZodObject<{
     eligibilityVersion: z.ZodLiteral<1>;
     evaluatedAt: z.ZodISODateTime;
@@ -47,24 +47,22 @@ export declare const RuntimeEligibilityInputSchema: z.ZodObject<{
     }, z.core.$strict>;
     candidate: z.ZodObject<{
         family: z.ZodString;
-        nodeStatus: z.ZodUnion<readonly [z.ZodEnum<{
+        nodeStatus: z.ZodEnum<{
             offline: "offline";
             online: "online";
             revoked: "revoked";
             unknown: "unknown";
-        }>, z.ZodLiteral<"not_applicable">]>;
+        }>;
         connection: z.ZodObject<{
             runtimeConnectionId: z.ZodPipe<z.ZodString, z.ZodTransform<import("@adea-ai/contracts").OpaqueIdentifier<"runtime-connection ID">, string>>;
             identityDigest: z.ZodString;
             connectionType: z.ZodEnum<{
                 external_local: "external_local";
-                managed_cloud: "managed_cloud";
                 managed_local: "managed_local";
             }>;
             runtimeNodeRefId: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@adea-ai/contracts").OpaqueIdentifier<"runtime-node reference ID">, string>>>;
             runtimeDefinitionId: z.ZodPipe<z.ZodString, z.ZodTransform<import("@adea-ai/contracts").OpaqueIdentifier<"runtime-definition ID">, string>>;
             location: z.ZodEnum<{
-                agent_hq_cloud: "agent_hq_cloud";
                 local_device: "local_device";
             }>;
             opaqueNativeRef: z.ZodOptional<z.ZodString>;
@@ -164,7 +162,6 @@ export declare const RuntimeEligibilityInputSchema: z.ZodObject<{
         }, z.core.$strict>;
         allowedFamilies: z.ZodArray<z.ZodString>;
         allowedLocations: z.ZodArray<z.ZodEnum<{
-            agent_hq_cloud: "agent_hq_cloud";
             local_device: "local_device";
         }>>;
         deniedRuntimeConnectionIds: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@adea-ai/contracts").OpaqueIdentifier<"runtime-connection ID">, string>>>;

package/dist/eligibility.js

@@ -16,10 +16,7 @@ const PolicyReasonCodeSchema = z
     .min(1)
     .max(128)
     .regex(/^[A-Z][A-Z0-9_]*$/);
-export const RuntimeEligibilityNodeStatusSchema = z.union([
-    RuntimeNodeHealthStatusSchema,
-    z.literal('not_applicable'),
-]);
+export const RuntimeEligibilityNodeStatusSchema = RuntimeNodeHealthStatusSchema;
 export const RuntimeEligibilityInputSchema = z
     .object({
     eligibilityVersion: z.literal(1),
@@ -85,17 +82,7 @@ export const RuntimeEligibilityInputSchema = z
         .strict()
         .optional(),
 })
-    .strict()
-    .superRefine((input, context) => {
-    const managedCloud = input.candidate.connection.connectionType === 'managed_cloud';
-    if (managedCloud !== (input.candidate.nodeStatus === 'not_applicable')) {
-        context.addIssue({
-            code: 'custom',
-            path: ['candidate', 'nodeStatus'],
-            message: 'Managed-cloud candidates must not invent RuntimeNode health',
-        });
-    }
-});
+    .strict();
 export const RuntimeEligibilityReasonCodeSchema = z.enum([
     'CAPABILITY_SNAPSHOT_MISSING',
     'CAPABILITY_SNAPSHOT_STALE',

package/dist/fixtures.d.ts

@@ -5,7 +5,7 @@ export declare const RuntimeFixtures: Readonly<{
         adapterVersion: string;
         driverVersion: string;
         harnessVersion: string;
-        location: "agent_hq_cloud" | "local_device" | "remote_host";
+        location: "local_device";
         health: "degraded" | "healthy" | "unavailable";
         lifecycle: "active" | "deprecated" | "revoked";
         capabilities: {
@@ -34,7 +34,7 @@ export declare const RuntimeFixtures: Readonly<{
         adapterVersion: string;
         driverVersion: string;
         harnessVersion: string;
-        location: "agent_hq_cloud" | "local_device" | "remote_host";
+        location: "local_device";
         health: "degraded" | "healthy" | "unavailable";
         lifecycle: "active" | "deprecated" | "revoked";
         capabilities: {
@@ -63,7 +63,7 @@ export declare const RuntimeFixtures: Readonly<{
         adapterVersion: string;
         driverVersion: string;
         harnessVersion: string;
-        location: "agent_hq_cloud" | "local_device" | "remote_host";
+        location: "local_device";
         health: "degraded" | "healthy" | "unavailable";
         lifecycle: "active" | "deprecated" | "revoked";
         capabilities: {

package/dist/models.d.ts

@@ -3,9 +3,7 @@ import { type CapabilityRequirement } from './capabilities.js';
 export declare const RuntimeTimestampSchema: z.ZodISODateTime;
 export declare const RuntimeSemanticVersionSchema: z.ZodString;
 export declare const RuntimeLocationSchema: z.ZodEnum<{
-    agent_hq_cloud: "agent_hq_cloud";
     local_device: "local_device";
-    remote_host: "remote_host";
 }>;
 export declare const RuntimeHealthSchema: z.ZodEnum<{
     degraded: "degraded";
@@ -42,9 +40,7 @@ export declare const RuntimeDefinitionSchema: z.ZodObject<{
     driverVersion: z.ZodString;
     harnessVersion: z.ZodString;
     location: z.ZodEnum<{
-        agent_hq_cloud: "agent_hq_cloud";
         local_device: "local_device";
-        remote_host: "remote_host";
     }>;
     health: z.ZodEnum<{
         degraded: "degraded";
@@ -112,9 +108,7 @@ export declare const RuntimeNodeRefSchema: z.ZodObject<{
     authority: z.ZodLiteral<"agent_hq">;
     displayName: z.ZodString;
     location: z.ZodEnum<{
-        agent_hq_cloud: "agent_hq_cloud";
         local_device: "local_device";
-        remote_host: "remote_host";
     }>;
     status: z.ZodEnum<{
         offline: "offline";
@@ -124,12 +118,10 @@ export declare const RuntimeNodeRefSchema: z.ZodObject<{
     observedAt: z.ZodISODateTime;
 }, z.core.$strip>;
 export declare const RuntimeConnectionLocationSchema: z.ZodEnum<{
-    agent_hq_cloud: "agent_hq_cloud";
     local_device: "local_device";
 }>;
 export declare const RuntimeConnectionTypeSchema: z.ZodEnum<{
     external_local: "external_local";
-    managed_cloud: "managed_cloud";
     managed_local: "managed_local";
 }>;
 export declare const RuntimeConnectionStatusSchema: z.ZodEnum<{
@@ -172,13 +164,11 @@ export declare const RuntimeConnectionSchema: z.ZodObject<{
     identityDigest: z.ZodString;
     connectionType: z.ZodEnum<{
         external_local: "external_local";
-        managed_cloud: "managed_cloud";
         managed_local: "managed_local";
     }>;
     runtimeNodeRefId: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@adea-ai/contracts").OpaqueIdentifier<"runtime-node reference ID">, string>>>;
     runtimeDefinitionId: z.ZodPipe<z.ZodString, z.ZodTransform<import("@adea-ai/contracts").OpaqueIdentifier<"runtime-definition ID">, string>>;
     location: z.ZodEnum<{
-        agent_hq_cloud: "agent_hq_cloud";
         local_device: "local_device";
     }>;
     opaqueNativeRef: z.ZodOptional<z.ZodString>;

package/dist/models.js

@@ -12,7 +12,7 @@ const RuntimeFamilySchema = z
     .max(64)
     .regex(/^[a-z][a-z0-9-]*$/);
 const uniqueCapabilities = (capabilities) => new Set(capabilities.map((capability) => capability.name)).size === capabilities.length;
-export const RuntimeLocationSchema = z.enum(['local_device', 'remote_host', 'agent_hq_cloud']);
+export const RuntimeLocationSchema = z.enum(['local_device']);
 export const RuntimeHealthSchema = z.enum(['healthy', 'degraded', 'unavailable']);
 export const RuntimeLifecycleSchema = z.enum(['active', 'deprecated', 'revoked']);
 export const RuntimeCompatibilityMetadataSchema = z.object({
@@ -46,12 +46,8 @@ export const RuntimeNodeRefSchema = z.object({
     status: z.enum(['online', 'offline', 'revoked']),
     observedAt: RuntimeTimestampSchema,
 });
-export const RuntimeConnectionLocationSchema = z.enum(['local_device', 'agent_hq_cloud']);
-export const RuntimeConnectionTypeSchema = z.enum([
-    'managed_cloud',
-    'managed_local',
-    'external_local',
-]);
+export const RuntimeConnectionLocationSchema = z.enum(['local_device']);
+export const RuntimeConnectionTypeSchema = z.enum(['managed_local', 'external_local']);
 export const RuntimeConnectionStatusSchema = z.enum([
     'connected',
     'degraded',
@@ -127,13 +123,8 @@ export const RuntimeConnectionSchema = z
 })
     .strict()
     .superRefine((connection, context) => {
-    const local = connection.connectionType !== 'managed_cloud';
-    if (local !== (connection.runtimeNodeRefId !== undefined)) {
-        context.addIssue({ code: 'custom', message: 'Only local connections require a RuntimeNode' });
-    }
-    const expectedLocation = local ? 'local_device' : 'agent_hq_cloud';
-    if (connection.location !== expectedLocation) {
-        context.addIssue({ code: 'custom', message: 'Connection type and location must agree' });
+    if (connection.runtimeNodeRefId === undefined) {
+        context.addIssue({ code: 'custom', message: 'A connection requires a RuntimeNode' });
     }
     const unavailable = ['unavailable', 'disconnected', 'expired', 'revoked'].includes(connection.status);
     if (unavailable !== (connection.health === 'unavailable')) {

package/dist/pi-durable-lead.js

@@ -30,32 +30,34 @@ export const PiDurableLeadObservedTargetSchema = z
     generation: RuntimeObservedGenerationSchema.optional(),
 })
     .readonly();
+function contractIncludes(negotiated, introduced) {
+    return (negotiated.major > introduced.major ||
+        (negotiated.major === introduced.major && negotiated.minor >= introduced.minor));
+}
 export const PI_DURABLE_OBSERVED_GENERATION_CONTRACT_VERSION = { major: 3, minor: 1 };
 export function supportsPiDurableObservedGeneration(consumerVersion) {
     const consumer = ContractVersionSchema.safeParse(consumerVersion);
     if (!consumer.success)
         return false;
-    const negotiated = negotiateContractVersion([PublicContractManifest.current], [consumer.data]);
-    if (negotiated === undefined)
-        return false;
-    return (negotiated.major === PI_DURABLE_OBSERVED_GENERATION_CONTRACT_VERSION.major &&
-        negotiated.minor >= PI_DURABLE_OBSERVED_GENERATION_CONTRACT_VERSION.minor);
+    const negotiated = negotiateContractVersion(PublicContractManifest.supported, [consumer.data]);
+    return (negotiated !== undefined &&
+        contractIncludes(negotiated, PI_DURABLE_OBSERVED_GENERATION_CONTRACT_VERSION));
 }
 export const PI_DURABLE_REMOTE_SESSION_REFERENCE_CONTRACT_VERSION = { major: 3, minor: 2 };
 export function supportsPiDurableRemoteSessionReference(consumerVersion) {
     const consumer = ContractVersionSchema.safeParse(consumerVersion);
     if (!consumer.success)
         return false;
-    const negotiated = negotiateContractVersion([PublicContractManifest.current], [consumer.data]);
-    return (negotiated?.major === PI_DURABLE_REMOTE_SESSION_REFERENCE_CONTRACT_VERSION.major &&
-        negotiated.minor >= PI_DURABLE_REMOTE_SESSION_REFERENCE_CONTRACT_VERSION.minor);
+    const negotiated = negotiateContractVersion(PublicContractManifest.supported, [consumer.data]);
+    return (negotiated !== undefined &&
+        contractIncludes(negotiated, PI_DURABLE_REMOTE_SESSION_REFERENCE_CONTRACT_VERSION));
 }
 export function supportsPiDurableRemoteOwnerObservation(consumerVersion) {
     const consumer = ContractVersionSchema.safeParse(consumerVersion);
     if (!consumer.success)
         return false;
-    const negotiated = negotiateContractVersion([PublicContractManifest.current], [consumer.data]);
-    return negotiated?.major === 3 && negotiated.minor >= 3;
+    const negotiated = negotiateContractVersion(PublicContractManifest.supported, [consumer.data]);
+    return negotiated !== undefined && contractIncludes(negotiated, { major: 3, minor: 3 });
 }
 function fenceForeignGeneration(receipt, context) {
     const foreign = (generation) => generation !== undefined && generation.attemptId !== receipt.attemptId;

package/dist/registry.d.ts

@@ -5,13 +5,11 @@ export declare const RuntimeConnectionRegistrationSchema: z.ZodObject<{
     identityDigest: z.ZodString;
     connectionType: z.ZodEnum<{
         external_local: "external_local";
-        managed_cloud: "managed_cloud";
         managed_local: "managed_local";
     }>;
     runtimeNodeRefId: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@adea-ai/contracts").OpaqueIdentifier<"runtime-node reference ID">, string>>>;
     runtimeDefinitionId: z.ZodPipe<z.ZodString, z.ZodTransform<import("@adea-ai/contracts").OpaqueIdentifier<"runtime-definition ID">, string>>;
     location: z.ZodEnum<{
-        agent_hq_cloud: "agent_hq_cloud";
         local_device: "local_device";
     }>;
     opaqueNativeRef: z.ZodOptional<z.ZodString>;

package/dist/sessions.js

@@ -292,10 +292,7 @@ const ExternalSessionAssessmentContextSchema = z
     nodeStatus: RuntimeEligibilityNodeStatusSchema,
     evaluatedAt: RuntimeTimestampSchema,
 })
-    .strict()
-    .refine((context) => context.connection === undefined ||
-    (context.connection.connectionType === 'managed_cloud') ===
-        (context.nodeStatus === 'not_applicable'), 'Managed-cloud sessions must not invent RuntimeNode health');
+    .strict();
 export function assessExternalSession(sessionValue, contextValue) {
     const session = ExternalSessionSchema.parse(sessionValue);
     const context = ExternalSessionAssessmentContextSchema.parse(contextValue);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adea-ai/runtime-sdk",
-  "version": "1.24.0",
+  "version": "2.0.0",
   "description": "SDK for building Control Plane runtimes: adapters, capabilities, conformance, discovery, eligibility, health, sessions, transport, and routing.",
   "keywords": [
     "adapter",
@@ -31,7 +31,8 @@
     }
   },
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "provenance": true
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",
@@ -42,7 +43,7 @@
     "test": "bun test src"
   },
   "dependencies": {
-    "@adea-ai/contracts": "^3.1.0",
+    "@adea-ai/contracts": "^4.0.0",
     "zod": "4.6.6"
   },
   "engines": {