@adea-ai/runtime-sdk 1.18.0 → 1.20.0

package/dist/pi-durable-lead.d.ts

@@ -60,6 +60,12 @@ export declare const PI_DURABLE_OBSERVED_GENERATION_CONTRACT_VERSION: {
     readonly minor: 1;
 };
 export declare function supportsPiDurableObservedGeneration(consumerVersion: unknown): boolean;
+export declare const PI_DURABLE_REMOTE_SESSION_REFERENCE_CONTRACT_VERSION: {
+    readonly major: 3;
+    readonly minor: 2;
+};
+export declare function supportsPiDurableRemoteSessionReference(consumerVersion: unknown): boolean;
+export declare function supportsPiDurableRemoteOwnerObservation(consumerVersion: unknown): boolean;
 export declare const PiDurableLeadPrepareRequestSchema: z.ZodObject<{
     contractVersion: z.ZodObject<{
         major: z.ZodNumber;
@@ -509,6 +515,17 @@ export declare const PiDurableLeadChildTargetSchema: z.ZodObject<{
     observedAt: z.ZodISODateTime;
     observedGeneration: z.ZodOptional<typeof RuntimeObservedGenerationSchema>;
 }, z.core.$strict>;
+export declare const PiDurableLeadRemoteSessionReferenceSchema: z.ZodReadonly<z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"pi-child-remote-session-reference/v1">;
+    source: z.ZodLiteral<"control_plane_reported">;
+    basis: z.ZodLiteral<"retained_native_attribution">;
+    runtimeConnectionId: typeof IdentifierSchemas.runtimeConnectionId;
+    nativeSessionId: typeof IdentifierSchemas.externalSessionId;
+    permission: z.ZodLiteral<"none">;
+    history: z.ZodLiteral<"adapter_journal_only">;
+    attachment: z.ZodLiteral<"unavailable">;
+}, z.core.$strict>>;
+export type PiDurableLeadRemoteSessionReference = z.output<typeof PiDurableLeadRemoteSessionReferenceSchema>;
 export declare const PiDurableLeadChildTargetResponseSchema: z.ZodObject<{
     contractVersion: z.ZodObject<{
         major: z.ZodNumber;
@@ -544,6 +561,33 @@ export declare const PiDurableLeadChildTargetResponseSchema: z.ZodObject<{
             NOT_STARTED: "NOT_STARTED";
             UNAVAILABLE: "UNAVAILABLE";
         }>>;
+        remoteSessionReference: z.ZodOptional<z.ZodNullable<z.ZodReadonly<z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"pi-child-remote-session-reference/v1">;
+            source: z.ZodLiteral<"control_plane_reported">;
+            basis: z.ZodLiteral<"retained_native_attribution">;
+            runtimeConnectionId: typeof IdentifierSchemas.runtimeConnectionId;
+            nativeSessionId: typeof IdentifierSchemas.externalSessionId;
+            permission: z.ZodLiteral<"none">;
+            history: z.ZodLiteral<"adapter_journal_only">;
+            attachment: z.ZodLiteral<"unavailable">;
+        }, z.core.$strict>>>>;
+        remoteSessionReferenceUnavailableReason: z.ZodOptional<z.ZodEnum<{
+            NOT_CONFIGURED: "NOT_CONFIGURED";
+            NOT_STARTED: "NOT_STARTED";
+            UNAVAILABLE: "UNAVAILABLE";
+        }>>;
+        remoteOwnerObservation: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"pi-child-owner-observation/v1">;
+            runtimeConnectionId: z.ZodPipe<z.ZodString, z.ZodTransform<import("@adea-ai/contracts").OpaqueIdentifier<"runtime-connection ID">, string>>;
+            nativeSessionId: z.ZodPipe<z.ZodString, z.ZodTransform<import("@adea-ai/contracts").OpaqueIdentifier<"external-session ID">, string>>;
+            ownerInstanceId: z.ZodUUID;
+            permission: z.ZodLiteral<"none">;
+        }, z.core.$strict>>>;
+        remoteOwnerObservationUnavailableReason: z.ZodOptional<z.ZodEnum<{
+            NOT_CONFIGURED: "NOT_CONFIGURED";
+            NOT_STARTED: "NOT_STARTED";
+            UNAVAILABLE: "UNAVAILABLE";
+        }>>;
     }, z.core.$strict>;
 }, z.core.$strict>;
 export declare const PiDurableLeadHttpContract: Readonly<{

package/dist/pi-durable-lead.js

@@ -39,6 +39,22 @@ export function supportsPiDurableObservedGeneration(consumerVersion) {
     return (negotiated.major === PI_DURABLE_OBSERVED_GENERATION_CONTRACT_VERSION.major &&
         negotiated.minor >= PI_DURABLE_OBSERVED_GENERATION_CONTRACT_VERSION.minor);
 }
+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);
+}
+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;
+}
 function fenceForeignGeneration(receipt, context) {
     const foreign = (generation) => generation !== undefined && generation.attemptId !== receipt.attemptId;
     if (foreign(receipt.observedTarget?.generation))
@@ -306,12 +322,76 @@ export const PiDurableLeadChildTargetSchema = z.strictObject({
     observedAt: z.iso.datetime(),
     observedGeneration: RuntimeObservedGenerationSchema.optional(),
 });
+export const PiDurableLeadRemoteSessionReferenceSchema = z
+    .strictObject({
+    schemaVersion: z.literal('pi-child-remote-session-reference/v1'),
+    source: z.literal('control_plane_reported'),
+    basis: z.literal('retained_native_attribution'),
+    runtimeConnectionId: IdentifierSchemas.runtimeConnectionId,
+    nativeSessionId: IdentifierSchemas.externalSessionId,
+    permission: z.literal('none'),
+    history: z.literal('adapter_journal_only'),
+    attachment: z.literal('unavailable'),
+})
+    .readonly();
 export const PiDurableLeadChildTargetResponseSchema = response.extend({
     data: PiDurableLeadReceiptResponseSchema.extend({
         child: PiDurableLeadChildSchema,
         target: PiDurableLeadChildTargetSchema.nullable(),
         unavailableReason: z.enum(['NOT_STARTED', 'NOT_CONFIGURED', 'UNAVAILABLE']).optional(),
+        remoteSessionReference: PiDurableLeadRemoteSessionReferenceSchema.nullable().optional(),
+        remoteSessionReferenceUnavailableReason: z
+            .enum(['NOT_STARTED', 'NOT_CONFIGURED', 'UNAVAILABLE'])
+            .optional(),
+        remoteOwnerObservation: z
+            .strictObject({
+            schemaVersion: z.literal('pi-child-owner-observation/v1'),
+            runtimeConnectionId: IdentifierSchemas.runtimeConnectionId,
+            nativeSessionId: IdentifierSchemas.externalSessionId,
+            ownerInstanceId: z.uuid(),
+            permission: z.literal('none'),
+        })
+            .nullable()
+            .optional(),
+        remoteOwnerObservationUnavailableReason: z
+            .enum(['NOT_STARTED', 'NOT_CONFIGURED', 'UNAVAILABLE'])
+            .optional(),
     }).superRefine((value, context) => {
+        if ((value.remoteOwnerObservation === null) !==
+            (value.remoteOwnerObservationUnavailableReason !== undefined))
+            context.addIssue({
+                code: 'custom',
+                message: 'Unavailable owner observation requires a bounded reason',
+            });
+        if (value.remoteOwnerObservation &&
+            (!value.child.childAttemptId ||
+                (value.target !== null &&
+                    (value.target.runtimeConnectionId !== value.remoteOwnerObservation.runtimeConnectionId ||
+                        value.target.nativeSessionId !== value.remoteOwnerObservation.nativeSessionId)) ||
+                (value.remoteSessionReference &&
+                    (value.remoteSessionReference.runtimeConnectionId !==
+                        value.remoteOwnerObservation.runtimeConnectionId ||
+                        value.remoteSessionReference.nativeSessionId !==
+                            value.remoteOwnerObservation.nativeSessionId))))
+            context.addIssue({
+                code: 'custom',
+                message: 'Owner observation must bind the selected child reference',
+            });
+        const reference = value.remoteSessionReference;
+        if ((reference === null) !== (value.remoteSessionReferenceUnavailableReason !== undefined))
+            context.addIssue({
+                code: 'custom',
+                message: 'Unavailable remote reference requires a bounded reason',
+            });
+        if (reference &&
+            (value.child.childAttemptId === undefined ||
+                (value.target !== null &&
+                    (reference.runtimeConnectionId !== value.target.runtimeConnectionId ||
+                        reference.nativeSessionId !== value.target.nativeSessionId))))
+            context.addIssue({
+                code: 'custom',
+                message: 'Remote reference must bind the selected child target',
+            });
         if ((value.target === null) !== (value.unavailableReason !== undefined))
             context.addIssue({ code: 'custom', message: 'Unavailable target requires a bounded reason' });
         if (value.target &&

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adea-ai/runtime-sdk",
-  "version": "1.18.0",
+  "version": "1.20.0",
   "description": "SDK for building Control Plane runtimes: adapters, capabilities, conformance, discovery, eligibility, health, sessions, transport, and routing.",
   "keywords": [
     "adapter",
@@ -43,7 +43,7 @@
     "test": "bun test src"
   },
   "dependencies": {
-    "@adea-ai/contracts": "^1.23.1",
+    "@adea-ai/contracts": "^1.25.0",
     "zod": "4.6.6"
   },
   "engines": {