@adea-ai/runtime-sdk 3.0.0 → 3.1.0

package/dist/adapter.d.ts

@@ -511,6 +511,7 @@ export declare const RuntimeStartRequestSchema: z.ZodObject<{
         maximumMicrounits: z.ZodNumber;
         maximumTokens: z.ZodNumber;
     }, z.core.$strict>>>;
+    traceId: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@adea-ai/contracts").OpaqueIdentifier<"trace ID">, string>>>;
 }, z.core.$strict>;
 export declare const RuntimeInputRequestSchema: z.ZodObject<{
     interactionId: z.ZodPipe<z.ZodString, z.ZodTransform<import("@adea-ai/contracts").OpaqueIdentifier<"interaction ID">, string>>;
@@ -622,8 +623,9 @@ export declare const RuntimeAdapterContract: Readonly<{
     }>;
     lifecycle: readonly string[];
     idempotentOperations: readonly string[];
-    terminalStates: readonly string[];
+    terminalStates: readonly ["completed", "failed", "cancelled", "timed_out"];
 }>;
+export declare function isTerminalRuntimeState(state: string): boolean;
 export interface RuntimeProgressOptions {
     readonly afterSequence?: number;
     readonly signal?: AbortSignal;
@@ -648,4 +650,5 @@ export declare class RuntimeAdapterError extends Error {
     constructor(errorInput: RuntimeError);
     toJSON(): RuntimeError;
 }
+export declare function failRuntime(code: string, classification: RuntimeError['classification'], retryable?: boolean, details?: Record<string, string>): never;
 export declare function inspectRuntimeCapabilities(capabilities: RuntimeAdapterInspection['capabilities'], requirements: readonly CapabilityRequirement[]): CapabilityEvaluation;

package/dist/adapter.js

@@ -1,12 +1,10 @@
-import { ArtifactReferenceSchema, IdentifierSchemas } from '@adea-ai/contracts';
+import { ArtifactReferenceSchema, IdentifierSchemas, Sha256DigestSchema, TimestampSchema, } from '@adea-ai/contracts';
 import { z } from 'zod';
 import { CapabilityRequirementSetSchema, RuntimeCapabilitySchema, evaluateCapabilities, } from './capabilities.js';
 import { AgentPluginsCapabilityReportSchema } from './agent-plugins.js';
-const TimestampSchema = z.iso.datetime();
 const SemanticVersionSchema = z.string().regex(/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/);
 const IdempotencyKeySchema = z.string().min(1).max(256);
 const HandleIdSchema = z.string().min(1).max(256);
-const DigestSchema = z.string().regex(/^sha256:[a-f0-9]{64}$/);
 export const RuntimeAdapterMetadataSchema = z
     .object({
     contractVersion: z.object({ major: z.literal(1), minor: z.number().int().nonnegative() }),
@@ -234,7 +232,7 @@ export const RuntimeExecutionPlanSnapshotSchema = z
     .object({
     schemaVersion: z.number().int().positive(),
     executionPlanId: IdentifierSchemas.executionPlanId,
-    contentDigest: DigestSchema,
+    contentDigest: Sha256DigestSchema,
     runtimeRequirements: CapabilityRequirementSetSchema,
 })
     .catchall(z.unknown());
@@ -245,7 +243,7 @@ export const RuntimeAttemptBudgetAuthoritySchema = z
     executionId: IdentifierSchemas.executionId,
     attemptId: IdentifierSchemas.attemptId,
     executionPlanId: IdentifierSchemas.executionPlanId,
-    executionPlanDigest: DigestSchema,
+    executionPlanDigest: Sha256DigestSchema,
     reservationKey: z.string().min(1).max(256),
     currency: z.literal('USD'),
     maximumMicrounits: z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
@@ -274,6 +272,7 @@ export const RuntimeStartRequestSchema = z
     idempotencyKey: IdempotencyKeySchema,
     executionPlan: RuntimeExecutionPlanSnapshotSchema,
     attemptBudget: RuntimeAttemptBudgetAuthoritySchema.optional(),
+    traceId: IdentifierSchemas.traceId.optional(),
 })
     .strict()
     .superRefine((request, context) => {
@@ -387,6 +386,9 @@ export const RuntimeAdapterContract = Object.freeze({
     ]),
     terminalStates: Object.freeze(['completed', 'failed', 'cancelled', 'timed_out']),
 });
+export function isTerminalRuntimeState(state) {
+    return RuntimeAdapterContract.terminalStates.includes(state);
+}
 export class RuntimeAdapterError extends Error {
     code;
     classification;
@@ -412,6 +414,15 @@ export class RuntimeAdapterError extends Error {
         });
     }
 }
+export function failRuntime(code, classification, retryable = false, details) {
+    throw new RuntimeAdapterError({
+        code,
+        classification,
+        message: code,
+        retryable,
+        ...(details ? { details } : {}),
+    });
+}
 export function inspectRuntimeCapabilities(capabilities, requirements) {
     return evaluateCapabilities(capabilities, CapabilityRequirementSetSchema.parse(requirements));
 }

package/dist/channel-ownership.js

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { TimestampSchema } from '@adea-ai/contracts';
 export const RuntimeChannelOwnershipSchema = z
     .object({
     nodeId: z.string().regex(/^rnr_[0-9A-HJKMNP-TV-Z]{26}$/),
@@ -9,8 +10,8 @@ export const RuntimeChannelOwnershipSchema = z
     protocolVersion: z
         .object({ major: z.number().int().nonnegative(), minor: z.number().int().nonnegative() })
         .strict(),
-    connectedAt: z.iso.datetime(),
-    lastHeartbeatAt: z.iso.datetime(),
+    connectedAt: TimestampSchema,
+    lastHeartbeatAt: TimestampSchema,
 })
     .strict()
     .refine((record) => Date.parse(record.lastHeartbeatAt) >= Date.parse(record.connectedAt), {

package/dist/eligibility.js

@@ -1,11 +1,10 @@
-import { createHash } from 'node:crypto';
-import { compareCodePointOrder } from '@adea-ai/contracts';
+import { compareCodePointOrder, Sha256DigestSchema } from '@adea-ai/contracts';
 import { IdentifierSchemas } from '@adea-ai/contracts';
 import { z } from 'zod';
 import { CapabilityRequirementSetSchema, RuntimeCapabilityNameSchema, evaluateCapabilities, } from './capabilities.js';
 import { RuntimeNodeHealthStatusSchema } from './health.js';
 import { RuntimeConnectionLocationSchema, RuntimeConnectionSchema, RuntimeTimestampSchema, } from './models.js';
-const DigestSchema = z.string().regex(/^sha256:[a-f0-9]{64}$/);
+import { sha256Digest } from '@adea-ai/contracts/digest';
 const RuntimeFamilySchema = z
     .string()
     .min(1)
@@ -24,7 +23,7 @@ export const RuntimeEligibilityInputSchema = z
     executionPlan: z
         .object({
         executionPlanId: IdentifierSchemas.executionPlanId,
-        contentDigest: DigestSchema,
+        contentDigest: Sha256DigestSchema,
         runtimeRequirements: CapabilityRequirementSetSchema,
     })
         .strict(),
@@ -41,7 +40,7 @@ export const RuntimeEligibilityInputSchema = z
             .object({
             policyId: z.string().min(1).max(128),
             version: z.number().int().positive(),
-            digest: DigestSchema,
+            digest: Sha256DigestSchema,
         })
             .strict(),
         allowedFamilies: z.array(RuntimeFamilySchema).min(1).max(64),
@@ -141,11 +140,11 @@ export const RuntimeEligibilityDecisionSchema = z
             .object({
             policyId: z.string().min(1).max(128),
             version: z.number().int().positive(),
-            digest: DigestSchema,
+            digest: Sha256DigestSchema,
         })
             .strict(),
         evaluatedAt: RuntimeTimestampSchema,
-        inputDigest: DigestSchema,
+        inputDigest: Sha256DigestSchema,
     })
         .strict(),
 })
@@ -293,5 +292,5 @@ function digestEligibilityInput(input) {
             deniedRuntimeConnectionIds: [...input.policy.deniedRuntimeConnectionIds].toSorted(),
         },
     };
-    return `sha256:${createHash('sha256').update(JSON.stringify(normalized)).digest('hex')}`;
+    return sha256Digest(JSON.stringify(normalized));
 }

package/dist/health.js

@@ -1,10 +1,10 @@
-import { createHash } from 'node:crypto';
 import { compareCodePointOrder } from '@adea-ai/contracts';
 import { IdentifierSchemas } from '@adea-ai/contracts';
 import { z } from 'zod';
 import { RuntimeCapabilitySchema } from './capabilities.js';
 import { RuntimeAvailabilityStateSchema, RuntimeCapabilityVerificationSchema, RuntimeDiagnosticCodeSchema, RuntimeSemanticVersionSchema, RuntimeTimestampSchema, } from './models.js';
 import { RuntimeConnectionRegistry, RuntimeConnectionRegistryError, } from './registry.js';
+import { sha256Digest } from '@adea-ai/contracts/digest';
 const uniqueCapabilities = (capabilities) => new Set(capabilities.map((capability) => capability.name)).size === capabilities.length;
 const RuntimeDisplayLimitationSchema = z
     .string()
@@ -460,7 +460,7 @@ function sameCapabilities(left, right) {
     return JSON.stringify(left) === JSON.stringify(right);
 }
 function digest(value) {
-    return `sha256:${createHash('sha256').update(JSON.stringify(value)).digest('hex')}`;
+    return sha256Digest(JSON.stringify(value));
 }
 function addMilliseconds(timestamp, milliseconds) {
     return new Date(Date.parse(timestamp) + milliseconds).toISOString();

package/dist/index.d.ts

@@ -2,6 +2,7 @@ export * from './adapter.js';
 export * from './pi-durable-lead.js';
 export * from './pi-durable-questions.js';
 export * from './pi-durable-approvals.js';
+export * from './pi-durable-ids.js';
 export * from './agent-plugins.js';
 export * from './channel-ownership.js';
 export * from './capabilities.js';

package/dist/index.js

@@ -2,6 +2,7 @@ export * from './adapter.js';
 export * from './pi-durable-lead.js';
 export * from './pi-durable-questions.js';
 export * from './pi-durable-approvals.js';
+export * from './pi-durable-ids.js';
 export * from './agent-plugins.js';
 export * from './channel-ownership.js';
 export * from './capabilities.js';

package/dist/mock.js

@@ -1,6 +1,6 @@
-import { createHash } from 'node:crypto';
-import { RuntimeAdapterInspectionSchema, RuntimeApprovalRequestSchema, RuntimeCancelRequestSchema, RuntimeExecutionHandleSchema, RuntimeExecutionResultSchema, RuntimeExecutionStatusSchema, RuntimeInputRequestSchema, RuntimeSessionOperationSchema, RuntimeSessionResultSchema, RuntimeStartRequestSchema, RuntimeAdapterError, inspectRuntimeCapabilities, } from './adapter.js';
+import { RuntimeAdapterInspectionSchema, RuntimeApprovalRequestSchema, RuntimeCancelRequestSchema, RuntimeExecutionHandleSchema, RuntimeExecutionResultSchema, RuntimeExecutionStatusSchema, RuntimeInputRequestSchema, RuntimeSessionOperationSchema, RuntimeSessionResultSchema, RuntimeStartRequestSchema, inspectRuntimeCapabilities, isTerminalRuntimeState, failRuntime, } from './adapter.js';
 import { RuntimeCapabilitySchema } from './capabilities.js';
+import { sha256Hex } from '@adea-ai/contracts/digest';
 export class MockRuntimeAdapter {
     #now;
     #capabilities;
@@ -45,8 +45,8 @@ export class MockRuntimeAdapter {
         const replay = this.#starts.get(request.idempotencyKey);
         if (replay) {
             if (replay.fingerprint !== fingerprint)
-                fail('IDEMPOTENCY_CONFLICT', 'conflict', false);
-            return clone(replay.handle);
+                failRuntime('IDEMPOTENCY_CONFLICT', 'conflict', false);
+            return structuredClone(replay.handle);
         }
         const startedAt = this.#now();
         const handle = RuntimeExecutionHandleSchema.parse({
@@ -55,7 +55,7 @@ export class MockRuntimeAdapter {
             startedAt,
         });
         if (this.#executions.has(handle.handleId))
-            fail('ATTEMPT_ALREADY_STARTED', 'conflict', false);
+            failRuntime('ATTEMPT_ALREADY_STARTED', 'conflict', false);
         const execution = {
             handle,
             status: RuntimeExecutionStatusSchema.parse({
@@ -67,7 +67,7 @@ export class MockRuntimeAdapter {
             nextSequence: 1,
         };
         this.#executions.set(handle.handleId, execution);
-        this.#starts.set(request.idempotencyKey, { fingerprint, handle: clone(handle) });
+        this.#starts.set(request.idempotencyKey, { fingerprint, handle: structuredClone(handle) });
         this.#emit(execution, 'status', { state: 'starting' });
         execution.status = RuntimeExecutionStatusSchema.parse({
             handle,
@@ -75,7 +75,7 @@ export class MockRuntimeAdapter {
             observedAt: this.#now(),
         });
         this.#emit(execution, 'status', { state: 'running' });
-        return clone(handle);
+        return structuredClone(handle);
     }
     async *progress(handleInput, options = {}) {
         const execution = this.#execution(handleInput);
@@ -83,7 +83,7 @@ export class MockRuntimeAdapter {
             if (options.signal?.aborted)
                 return;
             if (event.sequence > (options.afterSequence ?? 0))
-                yield clone(event);
+                yield structuredClone(event);
         }
     }
     async submitInput(handle, requestInput) {
@@ -113,12 +113,12 @@ export class MockRuntimeAdapter {
         const replay = this.#actions.get(actionKey);
         if (replay) {
             if (replay.fingerprint !== requestFingerprint)
-                fail('IDEMPOTENCY_CONFLICT', 'conflict', false);
-            return clone(replay.status);
+                failRuntime('IDEMPOTENCY_CONFLICT', 'conflict', false);
+            return structuredClone(replay.status);
         }
         const execution = this.#execution(handle);
-        if (terminal(execution.status.state))
-            fail('EXECUTION_TERMINAL', 'conflict', false);
+        if (isTerminalRuntimeState(execution.status.state))
+            failRuntime('EXECUTION_TERMINAL', 'conflict', false);
         execution.status = RuntimeExecutionStatusSchema.parse({
             handle: execution.handle,
             state: 'cancelled',
@@ -127,15 +127,15 @@ export class MockRuntimeAdapter {
         this.#emit(execution, 'status', { state: 'cancelled' });
         this.#actions.set(actionKey, {
             fingerprint: requestFingerprint,
-            status: clone(execution.status),
+            status: structuredClone(execution.status),
         });
-        return clone(execution.status);
+        return structuredClone(execution.status);
     }
     async status(handle) {
-        return clone(this.#execution(handle).status);
+        return structuredClone(this.#execution(handle).status);
     }
     async reconcile(handle) {
-        return clone(this.#execution(handle).status);
+        return structuredClone(this.#execution(handle).status);
     }
     async session(operationInput) {
         const operation = RuntimeSessionOperationSchema.parse(operationInput);
@@ -143,7 +143,7 @@ export class MockRuntimeAdapter {
         if (operation.operation === 'create') {
             const replay = this.#sessionCreates.get(operation.idempotencyKey);
             if (replay)
-                return clone(replay);
+                return structuredClone(replay);
             const session = {
                 sessionId: 'ses_01JABCDEF0123456789ABCDEFG',
                 state: 'active',
@@ -152,7 +152,7 @@ export class MockRuntimeAdapter {
             this.#sessions.set(session.sessionId, session);
             const result = RuntimeSessionResultSchema.parse({ operation: 'create', session });
             this.#sessionCreates.set(operation.idempotencyKey, result);
-            return clone(result);
+            return structuredClone(result);
         }
         if (operation.operation === 'list') {
             return RuntimeSessionResultSchema.parse({
@@ -162,7 +162,7 @@ export class MockRuntimeAdapter {
         }
         const session = this.#sessions.get(operation.sessionId);
         if (!session)
-            fail('SESSION_NOT_FOUND', 'validation', false);
+            failRuntime('SESSION_NOT_FOUND', 'validation', false);
         if (operation.operation === 'history') {
             return RuntimeSessionResultSchema.parse({
                 operation: 'history',
@@ -175,7 +175,7 @@ export class MockRuntimeAdapter {
         if (operation.operation === 'close')
             session.state = 'closed';
         else if (session.state === 'closed')
-            fail('SESSION_CLOSED', 'conflict', false);
+            failRuntime('SESSION_CLOSED', 'conflict', false);
         return RuntimeSessionResultSchema.parse({ operation: operation.operation, session });
     }
     async cleanup(handleInput) {
@@ -184,8 +184,8 @@ export class MockRuntimeAdapter {
     }
     complete(handleInput, resultInput) {
         const execution = this.#execution(handleInput);
-        if (terminal(execution.status.state))
-            return clone(execution.status);
+        if (isTerminalRuntimeState(execution.status.state))
+            return structuredClone(execution.status);
         const result = RuntimeExecutionResultSchema.parse({ outcome: 'completed', ...resultInput });
         execution.status = RuntimeExecutionStatusSchema.parse({
             handle: execution.handle,
@@ -194,7 +194,7 @@ export class MockRuntimeAdapter {
             result,
         });
         this.#emit(execution, 'status', { state: 'completed' });
-        return clone(execution.status);
+        return structuredClone(execution.status);
     }
     #interaction(handleInput, operation, idempotencyKey, request, data) {
         const handle = RuntimeExecutionHandleSchema.parse(handleInput);
@@ -203,31 +203,31 @@ export class MockRuntimeAdapter {
         const replay = this.#actions.get(actionKey);
         if (replay) {
             if (replay.fingerprint !== requestFingerprint)
-                fail('IDEMPOTENCY_CONFLICT', 'conflict', false);
-            return clone(replay.status);
+                failRuntime('IDEMPOTENCY_CONFLICT', 'conflict', false);
+            return structuredClone(replay.status);
         }
         const execution = this.#execution(handle);
-        if (terminal(execution.status.state))
-            fail('EXECUTION_TERMINAL', 'conflict', false);
+        if (isTerminalRuntimeState(execution.status.state))
+            failRuntime('EXECUTION_TERMINAL', 'conflict', false);
         this.#emit(execution, 'interaction', data);
         this.#actions.set(actionKey, {
             fingerprint: requestFingerprint,
-            status: clone(execution.status),
+            status: structuredClone(execution.status),
         });
-        return clone(execution.status);
+        return structuredClone(execution.status);
     }
     #execution(handleInput) {
         const handle = RuntimeExecutionHandleSchema.parse(handleInput);
         const execution = this.#executions.get(handle.handleId);
         if (!execution || stable(execution.handle) !== stable(handle)) {
-            fail('EXECUTION_HANDLE_NOT_FOUND', 'validation', false);
+            failRuntime('EXECUTION_HANDLE_NOT_FOUND', 'validation', false);
         }
         return execution;
     }
     #requireCapability(name) {
         const capability = this.#capabilities.find((candidate) => candidate.name === name);
         if (!capability || capability.support === 'unsupported') {
-            fail('CAPABILITY_UNSUPPORTED', 'unsupported', false, { capability: name });
+            failRuntime('CAPABILITY_UNSUPPORTED', 'unsupported', false, { capability: name });
         }
     }
     #emit(execution, type, data) {
@@ -240,21 +240,6 @@ export class MockRuntimeAdapter {
         });
     }
 }
-function terminal(state) {
-    return ['completed', 'failed', 'cancelled', 'timed_out'].includes(state);
-}
-function fail(code, classification, retryable, details) {
-    throw new RuntimeAdapterError({
-        code,
-        classification,
-        message: code,
-        retryable,
-        ...(details ? { details } : {}),
-    });
-}
 function stable(value) {
-    return createHash('sha256').update(JSON.stringify(value)).digest('hex');
-}
-function clone(value) {
-    return structuredClone(value);
+    return sha256Hex(JSON.stringify(value));
 }

package/dist/models.js

@@ -1,8 +1,8 @@
 import { z } from 'zod';
-import { compareCodePointOrder } from '@adea-ai/contracts';
+import { compareCodePointOrder, Sha256DigestSchema, TimestampSchema, } from '@adea-ai/contracts';
 import { ContractVersionSchema, IdentifierSchemas } from '@adea-ai/contracts';
 import { RuntimeCapabilitySchema, evaluateCapabilities, } from './capabilities.js';
-export const RuntimeTimestampSchema = z.iso.datetime();
+export const RuntimeTimestampSchema = TimestampSchema;
 export const RuntimeSemanticVersionSchema = z
     .string()
     .regex(/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/);
@@ -82,7 +82,7 @@ export const RuntimeCompatibilityStateSchema = z.enum([
     'unavailable',
     'capability_missing',
 ]);
-export const RuntimeConnectionIdentityDigestSchema = z.string().regex(/^sha256:[a-f0-9]{64}$/);
+export const RuntimeConnectionIdentityDigestSchema = Sha256DigestSchema;
 export const RuntimeOpaqueNativeRefSchema = z
     .string()
     .length(31)

package/dist/pi-durable-approvals.js

@@ -1,6 +1,7 @@
 import { z } from 'zod';
-import { canonicalJsonStringify, IdentifierSchemas } from '@adea-ai/contracts';
-export const PiDurableApprovalEffectDigestSchema = z.string().regex(/^sha256:[a-f0-9]{64}$/);
+import { canonicalJsonStringify, IdentifierSchemas, Sha256DigestSchema, TimestampSchema, } from '@adea-ai/contracts';
+import { PiDurableDispatchIdSchema } from './pi-durable-ids.js';
+export const PiDurableApprovalEffectDigestSchema = Sha256DigestSchema;
 export const PiDurableApprovalDecisionIdSchema = z.string().regex(/^pi-decision:[a-f0-9]{32}$/);
 const Reference = z
     .string()
@@ -8,7 +9,7 @@ const Reference = z
     .max(256)
     .regex(/^[A-Za-z0-9._:-]+$/);
 export const PiDurableApprovalAnswerSchema = z.strictObject({
-    dispatchId: z.string().regex(/^dispatch_[a-f0-9]{32}$/),
+    dispatchId: PiDurableDispatchIdSchema,
     approvalId: IdentifierSchemas.interactionId,
     effectDigest: PiDurableApprovalEffectDigestSchema,
     decision: z.enum(['approve', 'deny']),
@@ -30,8 +31,8 @@ export const PiDurableApprovalDecisionSchema = z.strictObject({
     decision: PiDurableApprovalAnswerSchema.shape.decision,
     decisionId: PiDurableApprovalDecisionIdSchema,
     ...PiDurableApprovalAttestationSchema.shape,
-    decidedAt: z.iso.datetime(),
-    deadlineAt: z.iso.datetime(),
+    decidedAt: TimestampSchema,
+    deadlineAt: TimestampSchema,
 });
 export function samePiDurableApprovalDecision(left, right) {
     const { decidedAt: _left, ...a } = left;

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

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+export declare const PiDurableDispatchIdSchema: z.ZodString;
+export declare function piLeadSessionId(dispatchId: string): string;
+export declare const PiLeadSessionIdSchema: z.ZodString;

package/dist/pi-durable-ids.js

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+export const PiDurableDispatchIdSchema = z.string().regex(/^dispatch_[a-f0-9]{32}$/);
+export function piLeadSessionId(dispatchId) {
+    return `pi-lead:${dispatchId}`;
+}
+export const PiLeadSessionIdSchema = z.string().regex(/^pi-lead:dispatch_[a-f0-9]{32}$/);

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

@@ -1,10 +1,10 @@
 import { z } from 'zod';
 import { PiDurableQuestionAnswersSchema, PiDurableQuestionRequestIdSchema } from './pi-durable-questions.js';
 import { PiDurableApprovalAnswerSchema, PiDurableApprovalAttestationSchema } from './pi-durable-approvals.js';
-import { IdentifierSchemas, ModelSelectionRefSchema } from '@adea-ai/contracts';
+import { IdentifierSchemas, ModelSelectionRefSchema, Sha256DigestSchema } from '@adea-ai/contracts';
 import { RuntimeExecutionProgressSchema, RuntimeExecutionStatusSchema, RuntimeExecutionStateSchema, RuntimeObservedGenerationSchema } from './adapter.js';
+import { PiDurableDispatchIdSchema } from './pi-durable-ids.js';
 declare const IntentId: z.ZodUUID;
-declare const DispatchId: z.ZodString;
 export declare const PiDurableLeadPreparationRefSchema: z.ZodString;
 declare const Caller: z.ZodObject<{
     servicePrincipalId: z.ZodString;
@@ -142,7 +142,7 @@ export declare const PiDurableLeadProgressRequestSchema: z.ZodObject<{
     correlation: typeof Correlation;
     operation: z.ZodLiteral<"pi-durable.lead.progress">;
     parameters: z.ZodObject<{
-        dispatchId: typeof DispatchId;
+        dispatchId: typeof PiDurableDispatchIdSchema;
         afterSequence: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>;
 }, z.core.$strict>;
@@ -163,7 +163,7 @@ export declare const PiDurableLeadEventsRequestSchema: z.ZodObject<{
     correlation: typeof Correlation;
     operation: z.ZodLiteral<"pi-durable.lead.events">;
     parameters: z.ZodObject<{
-        dispatchId: typeof DispatchId;
+        dispatchId: typeof PiDurableDispatchIdSchema;
         messageId: z.ZodString;
         afterSeq: z.ZodNumber;
         waitMs: z.ZodNumber;
@@ -191,7 +191,7 @@ export declare const PiDurableLeadTurnEventSchema: z.ZodObject<{
 }, z.core.$strict>;
 export declare const PiDurableLeadEventsDataSchema: z.ZodObject<{
     contractVersion: z.ZodLiteral<1>;
-    dispatchId: typeof DispatchId;
+    dispatchId: typeof PiDurableDispatchIdSchema;
     events: z.ZodArray<typeof PiDurableLeadTurnEventSchema>;
     nextSeq: z.ZodNumber;
     complete: z.ZodBoolean;
@@ -215,7 +215,7 @@ export declare const PiDurableLeadChildrenRequestSchema: z.ZodObject<{
     correlation: typeof Correlation;
     operation: z.ZodLiteral<"pi-durable.lead.children">;
     parameters: z.ZodObject<{
-        dispatchId: typeof DispatchId;
+        dispatchId: typeof PiDurableDispatchIdSchema;
         after: z.ZodOptional<typeof PiDurableLeadChildrenCursorSchema>;
         limit: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>;
@@ -253,6 +253,7 @@ export declare const PiDurableSessionEventsRequestSchema: z.ZodObject<{
     operation: z.ZodLiteral<"pi-durable.lead.session-events">;
     parameters: z.ZodObject<{
         runtimeSessionId: typeof PiDurableSessionIdSchema;
+        messageId: z.ZodOptional<z.ZodString>;
         afterSeq: z.ZodNumber;
         waitMs: z.ZodNumber;
         limit: z.ZodOptional<z.ZodNumber>;
@@ -271,7 +272,7 @@ export declare const PiDurableLeadChildTargetRequestSchema: z.ZodObject<{
     correlation: typeof Correlation;
     operation: z.ZodLiteral<"pi-durable.lead.child-target">;
     parameters: z.ZodObject<{
-        dispatchId: typeof DispatchId;
+        dispatchId: typeof PiDurableDispatchIdSchema;
         delegationId: typeof IdentifierSchemas.delegationId;
     }, z.core.$strict>;
 }, z.core.$strict>;
@@ -310,7 +311,7 @@ export declare const PiDurableLeadQuestionAnswerRequestSchema: z.ZodObject<{
     correlation: typeof Correlation;
     operation: z.ZodLiteral<"pi-durable.lead.question-answer">;
     payload: z.ZodObject<{
-        dispatchId: typeof DispatchId;
+        dispatchId: typeof PiDurableDispatchIdSchema;
         requestId: typeof PiDurableQuestionRequestIdSchema;
         answers: typeof PiDurableQuestionAnswersSchema;
     }, z.core.$strict>;
@@ -332,6 +333,30 @@ export declare const PiDurableLeadApprovalAnswerRequestSchema: z.ZodObject<{
     operation: z.ZodLiteral<"pi-durable.lead.approval-answer">;
     payload: z.ZodObject<typeof PiDurableApprovalAnswerSchema.shape & typeof PiDurableApprovalAttestationSchema.shape, z.core.$strict>;
 }, z.core.$strict>;
+export declare const PiDurableChildMessageRequestIdSchema: z.ZodString;
+export declare const PI_DURABLE_CHILD_MESSAGE_MAX_CHARS = 8192;
+export declare const PiDurableLeadChildMessageRequestSchema: z.ZodObject<{
+    contractVersion: z.ZodObject<{
+        major: z.ZodNumber;
+        minor: z.ZodNumber;
+    }, z.core.$strict>;
+    requestId: z.ZodPipe<z.ZodString, z.ZodTransform<import("@adea-ai/contracts").OpaqueIdentifier<"request ID">, string>>;
+    workspaceId: z.ZodPipe<z.ZodString, z.ZodTransform<import("@adea-ai/contracts").OpaqueIdentifier<"workspace ID">, string>>;
+    projectId: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@adea-ai/contracts").OpaqueIdentifier<"project ID">, string>>>;
+    commandId: z.ZodPipe<z.ZodString, z.ZodTransform<import("@adea-ai/contracts").OpaqueIdentifier<"command ID">, string>>;
+    idempotencyKey: z.ZodString;
+    payloadHash: z.ZodString;
+    issuedAt: z.ZodISODateTime;
+    caller: typeof Caller;
+    correlation: typeof Correlation;
+    operation: z.ZodLiteral<"pi-durable.lead.child-message">;
+    payload: z.ZodObject<{
+        dispatchId: typeof PiDurableDispatchIdSchema;
+        delegationId: typeof IdentifierSchemas.delegationId;
+        requestId: typeof PiDurableChildMessageRequestIdSchema;
+        text: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
 export declare const PiDurableLeadChildCancelRequestSchema: z.ZodObject<{
     contractVersion: z.ZodObject<{
         major: z.ZodNumber;
@@ -348,13 +373,13 @@ export declare const PiDurableLeadChildCancelRequestSchema: z.ZodObject<{
     correlation: typeof Correlation;
     operation: z.ZodLiteral<"pi-durable.lead.child-cancel">;
     payload: z.ZodObject<{
-        dispatchId: typeof DispatchId;
+        dispatchId: typeof PiDurableDispatchIdSchema;
         delegationId: typeof IdentifierSchemas.delegationId;
     }, z.core.$strict>;
 }, z.core.$strict>;
 export declare const PiDurableLeadReceiptResponseSchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<"pi-lead-dispatch/v1">;
-    dispatchId: typeof DispatchId;
+    dispatchId: typeof PiDurableDispatchIdSchema;
     intentId: typeof IntentId;
     executionId: typeof IdentifierSchemas.executionId;
     attemptId: typeof IdentifierSchemas.attemptId;
@@ -362,10 +387,9 @@ export declare const PiDurableLeadReceiptResponseSchema: z.ZodObject<{
     requestedTarget: z.ZodOptional<typeof PiDurableLeadRequestedTargetSchema>;
     observedTarget: z.ZodOptional<typeof PiDurableLeadObservedTargetSchema>;
 }, z.core.$strict>;
-declare const PlanDigest: z.ZodString;
 export declare const PiDurableLeadChildAllowanceSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     schemaVersion: z.ZodLiteral<"pi-lead-child-allowance/v1">;
-    executionPlanDigest: typeof PlanDigest;
+    executionPlanDigest: typeof Sha256DigestSchema;
     profile: z.ZodReadonly<z.ZodObject<{
         profileId: typeof IdentifierSchemas.profileId;
         profileVersionId: typeof IdentifierSchemas.profileVersionId;
@@ -378,7 +402,7 @@ export declare const PiDurableLeadChildAllowanceSchema: z.ZodDiscriminatedUnion<
     maximumTokens: z.ZodNumber;
 }, z.core.$strict>, z.ZodObject<{
     schemaVersion: z.ZodLiteral<"pi-lead-child-allowance/v1">;
-    executionPlanDigest: typeof PlanDigest;
+    executionPlanDigest: typeof Sha256DigestSchema;
     profile: z.ZodReadonly<z.ZodObject<{
         profileId: typeof IdentifierSchemas.profileId;
         profileVersionId: typeof IdentifierSchemas.profileVersionId;
@@ -464,7 +488,7 @@ export declare const PiDurableLeadLookupResponseSchema: z.ZodObject<{
         workspaceId: typeof IdentifierSchemas.workspaceId;
         intentId: typeof IntentId;
         receipt: z.ZodNullable<z.ZodObject<{
-            dispatchId: typeof DispatchId;
+            dispatchId: typeof PiDurableDispatchIdSchema;
             executionId: typeof IdentifierSchemas.executionId;
             attemptId: typeof IdentifierSchemas.attemptId;
             state: z.ZodEnum<{
@@ -491,7 +515,7 @@ export declare const PiDurableLeadDispatchResponseSchema: z.ZodObject<{
     }, z.core.$strict>;
     data: z.ZodObject<{
         schemaVersion: z.ZodLiteral<"pi-lead-dispatch/v1">;
-        dispatchId: typeof DispatchId;
+        dispatchId: typeof PiDurableDispatchIdSchema;
         intentId: typeof IntentId;
         executionId: typeof IdentifierSchemas.executionId;
         attemptId: typeof IdentifierSchemas.attemptId;
@@ -515,7 +539,7 @@ export declare const PiDurableLeadStatusResponseSchema: z.ZodObject<{
     }, z.core.$strict>;
     data: z.ZodObject<{
         schemaVersion: z.ZodLiteral<"pi-lead-dispatch/v1">;
-        dispatchId: typeof DispatchId;
+        dispatchId: typeof PiDurableDispatchIdSchema;
         intentId: typeof IntentId;
         executionId: typeof IdentifierSchemas.executionId;
         attemptId: typeof IdentifierSchemas.attemptId;
@@ -539,7 +563,7 @@ export declare const PiDurableLeadProgressResponseSchema: z.ZodObject<{
     }, z.core.$strict>;
     data: z.ZodObject<{
         schemaVersion: z.ZodLiteral<"pi-lead-dispatch/v1">;
-        dispatchId: typeof DispatchId;
+        dispatchId: typeof PiDurableDispatchIdSchema;
         intentId: typeof IntentId;
         executionId: typeof IdentifierSchemas.executionId;
         attemptId: typeof IdentifierSchemas.attemptId;
@@ -563,7 +587,7 @@ export declare const PiDurableLeadCancelResponseSchema: z.ZodObject<{
     }, z.core.$strict>;
     data: z.ZodObject<{
         schemaVersion: z.ZodLiteral<"pi-lead-dispatch/v1">;
-        dispatchId: typeof DispatchId;
+        dispatchId: typeof PiDurableDispatchIdSchema;
         intentId: typeof IntentId;
         executionId: typeof IdentifierSchemas.executionId;
         attemptId: typeof IdentifierSchemas.attemptId;
@@ -587,7 +611,7 @@ export declare const PiDurableLeadQuestionAnswerResponseSchema: z.ZodObject<{
     }, z.core.$strict>;
     data: z.ZodObject<{
         schemaVersion: z.ZodLiteral<"pi-lead-dispatch/v1">;
-        dispatchId: typeof DispatchId;
+        dispatchId: typeof PiDurableDispatchIdSchema;
         intentId: typeof IntentId;
         executionId: typeof IdentifierSchemas.executionId;
         attemptId: typeof IdentifierSchemas.attemptId;
@@ -619,7 +643,7 @@ export declare const PiDurableLeadApprovalAnswerResponseSchema: z.ZodObject<{
     }, z.core.$strict>;
     data: z.ZodObject<{
         schemaVersion: z.ZodLiteral<"pi-lead-dispatch/v1">;
-        dispatchId: typeof DispatchId;
+        dispatchId: typeof PiDurableDispatchIdSchema;
         intentId: typeof IntentId;
         executionId: typeof IdentifierSchemas.executionId;
         attemptId: typeof IdentifierSchemas.attemptId;
@@ -661,7 +685,7 @@ export declare const PiDurableSessionSchema: z.ZodObject<{
         child: "child";
         lead: "lead";
     }>;
-    dispatchId: typeof DispatchId;
+    dispatchId: typeof PiDurableDispatchIdSchema;
     intentId: typeof IntentId;
     delegationId: z.ZodOptional<typeof IdentifierSchemas.delegationId>;
     executionId: typeof IdentifierSchemas.executionId;
@@ -762,7 +786,7 @@ export declare const PiDurableLeadChildrenResponseSchema: z.ZodObject<{
     }, z.core.$strict>;
     data: z.ZodObject<{
         schemaVersion: z.ZodLiteral<"pi-lead-dispatch/v1">;
-        dispatchId: typeof DispatchId;
+        dispatchId: typeof PiDurableDispatchIdSchema;
         intentId: typeof IntentId;
         executionId: typeof IdentifierSchemas.executionId;
         attemptId: typeof IdentifierSchemas.attemptId;
@@ -788,7 +812,7 @@ export declare const PiDurableLeadChildCancelResponseSchema: z.ZodObject<{
     }, z.core.$strict>;
     data: z.ZodObject<{
         schemaVersion: z.ZodLiteral<"pi-lead-dispatch/v1">;
-        dispatchId: typeof DispatchId;
+        dispatchId: typeof PiDurableDispatchIdSchema;
         intentId: typeof IntentId;
         executionId: typeof IdentifierSchemas.executionId;
         attemptId: typeof IdentifierSchemas.attemptId;
@@ -799,6 +823,34 @@ export declare const PiDurableLeadChildCancelResponseSchema: z.ZodObject<{
         attributed: z.ZodBoolean;
     }, z.core.$strict>;
 }, z.core.$strict>;
+export declare const PiDurableLeadChildMessageResponseSchema: z.ZodObject<{
+    contractVersion: z.ZodObject<{
+        major: z.ZodNumber;
+        minor: z.ZodNumber;
+    }, z.core.$strict>;
+    requestId: z.ZodPipe<z.ZodString, z.ZodTransform<import("@adea-ai/contracts").OpaqueIdentifier<"request ID">, string>>;
+    correlation: z.ZodObject<{
+        traceId: z.ZodPipe<z.ZodString, z.ZodTransform<import("@adea-ai/contracts").OpaqueIdentifier<"trace ID">, string>>;
+        causationCommandId: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@adea-ai/contracts").OpaqueIdentifier<"command ID">, string>>>;
+        parentEventId: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@adea-ai/contracts").OpaqueIdentifier<"event ID">, string>>>;
+    }, z.core.$strict>;
+    data: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"pi-lead-dispatch/v1">;
+        dispatchId: typeof PiDurableDispatchIdSchema;
+        intentId: typeof IntentId;
+        executionId: typeof IdentifierSchemas.executionId;
+        attemptId: typeof IdentifierSchemas.attemptId;
+        runtimeSessionId: z.ZodPipe<z.ZodString, z.ZodTransform<import("@adea-ai/contracts").OpaqueIdentifier<"external-session ID">, string>>;
+        requestedTarget: z.ZodOptional<typeof PiDurableLeadRequestedTargetSchema>;
+        observedTarget: z.ZodOptional<typeof PiDurableLeadObservedTargetSchema>;
+        child: typeof PiDurableLeadChildSchema;
+        requestId: typeof PiDurableChildMessageRequestIdSchema;
+        outcome: z.ZodEnum<{
+            already_delivered: "already_delivered";
+            delivered: "delivered";
+        }>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
 export declare const PiDurableLeadChildTargetSchema: z.ZodObject<{
     source: z.ZodLiteral<"control_plane_reported">;
     runtimeConnectionId: typeof IdentifierSchemas.runtimeConnectionId;
@@ -832,7 +884,7 @@ export declare const PiDurableLeadChildTargetResponseSchema: z.ZodObject<{
     }, z.core.$strict>;
     data: z.ZodObject<{
         schemaVersion: z.ZodLiteral<"pi-lead-dispatch/v1">;
-        dispatchId: typeof DispatchId;
+        dispatchId: typeof PiDurableDispatchIdSchema;
         intentId: typeof IntentId;
         executionId: typeof IdentifierSchemas.executionId;
         attemptId: typeof IdentifierSchemas.attemptId;
@@ -985,6 +1037,13 @@ export declare const PiDurableLeadHttpContract: Readonly<{
         requestSchema: typeof PiDurableLeadChildCancelRequestSchema;
         responseSchema: typeof PiDurableLeadChildCancelResponseSchema;
     }>;
+    childMessage: Readonly<{
+        route: "child-message";
+        operation: "pi-durable.lead.child-message";
+        scope: "execution:write";
+        requestSchema: typeof PiDurableLeadChildMessageRequestSchema;
+        responseSchema: typeof PiDurableLeadChildMessageResponseSchema;
+    }>;
 }>;
 export type PiDurableLeadPrepareRequest = z.output<typeof PiDurableLeadPrepareRequestSchema>;
 export type PiDurableLeadPrepareResponse = z.output<typeof PiDurableLeadPrepareResponseSchema>;
@@ -1017,6 +1076,8 @@ export type PiDurableLeadApprovalAnswerRequest = z.output<typeof PiDurableLeadAp
 export type PiDurableLeadApprovalAnswerResponse = z.output<typeof PiDurableLeadApprovalAnswerResponseSchema>;
 export type PiDurableLeadChildCancelRequest = z.output<typeof PiDurableLeadChildCancelRequestSchema>;
 export type PiDurableLeadChildCancelResponse = z.output<typeof PiDurableLeadChildCancelResponseSchema>;
+export type PiDurableLeadChildMessageRequest = z.output<typeof PiDurableLeadChildMessageRequestSchema>;
+export type PiDurableLeadChildMessageResponse = z.output<typeof PiDurableLeadChildMessageResponseSchema>;
 export type PiDurableLeadChildTargetRequest = z.output<typeof PiDurableLeadChildTargetRequestSchema>;
 export type PiDurableLeadChildTargetResponse = z.output<typeof PiDurableLeadChildTargetResponseSchema>;
 export type PiDurableLeadChildTarget = z.output<typeof PiDurableLeadChildTargetSchema>;

package/dist/pi-durable-lead.js

@@ -1,10 +1,10 @@
 import { z } from 'zod';
 import { PiDurableQuestionAnswersSchema, PiDurableQuestionRequestIdSchema, } from './pi-durable-questions.js';
 import { PiDurableApprovalAnswerSchema, PiDurableApprovalAttestationSchema, PiDurableApprovalDecisionIdSchema, } from './pi-durable-approvals.js';
-import { IdentifierSchemas, ModelSelectionFundingViewSchema, ModelSelectionRefSchema, ReadRequestEnvelopeSchema, StateChangingCommandEnvelopeSchema, SuccessResponseEnvelopeSchema, } from '@adea-ai/contracts';
+import { IdentifierSchemas, ModelSelectionFundingViewSchema, ModelSelectionRefSchema, ReadRequestEnvelopeSchema, StateChangingCommandEnvelopeSchema, SuccessResponseEnvelopeSchema, Sha256DigestSchema, TimestampSchema, } from '@adea-ai/contracts';
 import { RuntimeExecutionHandleSchema, RuntimeExecutionProgressSchema, RuntimeExecutionStatusSchema, RuntimeExecutionStateSchema, RuntimeObservedGenerationSchema, } from './adapter.js';
+import { PiDurableDispatchIdSchema, piLeadSessionId } from './pi-durable-ids.js';
 const IntentId = z.uuid();
-const DispatchId = z.string().regex(/^dispatch_[a-f0-9]{32}$/);
 export const PiDurableLeadPreparationRefSchema = z.string().regex(/^prep_[a-f0-9]{32}$/);
 const Caller = StateChangingCommandEnvelopeSchema.shape.caller.unwrap().strict();
 const Correlation = StateChangingCommandEnvelopeSchema.shape.correlation.strict();
@@ -61,7 +61,7 @@ export const PiDurableLeadDispatchRequestSchema = PiDurableLeadCommandEnvelopeSc
 });
 export const PiDurableLeadStatusRequestSchema = PiDurableLeadReadEnvelopeSchema.extend({
     operation: z.literal('pi-durable.lead.status'),
-    parameters: z.object({ dispatchId: DispatchId }).strict(),
+    parameters: z.object({ dispatchId: PiDurableDispatchIdSchema }).strict(),
 });
 export const PiDurableLeadLookupRequestSchema = PiDurableLeadReadEnvelopeSchema.extend({
     operation: z.literal('pi-durable.lead.lookup'),
@@ -71,7 +71,7 @@ export const PiDurableLeadProgressRequestSchema = PiDurableLeadReadEnvelopeSchem
     operation: z.literal('pi-durable.lead.progress'),
     parameters: z
         .object({
-        dispatchId: DispatchId,
+        dispatchId: PiDurableDispatchIdSchema,
         afterSequence: z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER).optional(),
     })
         .strict(),
@@ -87,7 +87,7 @@ export const PiDurableLeadEventsRequestSchema = PiDurableLeadReadEnvelopeSchema.
     operation: z.literal('pi-durable.lead.events'),
     parameters: z
         .object({
-        dispatchId: DispatchId,
+        dispatchId: PiDurableDispatchIdSchema,
         messageId: z
             .string()
             .min(1)
@@ -107,8 +107,8 @@ export const PiDurableLeadTurnEventSchema = z
     harnessRunId: z.string().min(1).max(256),
     generation: z.literal(1),
     seq: z.string().regex(/^[1-9]\d*$/),
-    occurredAt: z.iso.datetime(),
-    receivedAt: z.iso.datetime(),
+    occurredAt: TimestampSchema,
+    receivedAt: TimestampSchema,
     source: z.literal('native'),
     sourceEventId: z.string().min(1).max(256),
     confidence: z.literal('authoritative'),
@@ -120,7 +120,7 @@ export const PiDurableLeadTurnEventSchema = z
 export const PiDurableLeadEventsDataSchema = z
     .object({
     contractVersion: z.literal(PI_DURABLE_LEAD_EVENTS_CONTRACT_VERSION),
-    dispatchId: DispatchId,
+    dispatchId: PiDurableDispatchIdSchema,
     events: z
         .array(PiDurableLeadTurnEventSchema)
         .max(PI_DURABLE_LEAD_EVENTS_MAX_PAGE),
@@ -132,7 +132,7 @@ export const PiDurableLeadEventsDataSchema = z
     const first = value.nextSeq - value.events.length + 1;
     value.events.forEach((event, index) => {
         if (event.seq !== String(first + index) ||
-            event.runtimeSessionId !== `pi-lead:${value.dispatchId}`)
+            event.runtimeSessionId !== piLeadSessionId(value.dispatchId))
             context.addIssue({
                 code: 'custom',
                 path: ['events', index],
@@ -143,7 +143,7 @@ export const PiDurableLeadEventsDataSchema = z
         context.addIssue({ code: 'custom', path: ['nextSeq'], message: 'nextSeq precedes the page' });
 });
 export const PiDurableLeadChildrenCursorSchema = z
-    .object({ acceptedAt: z.iso.datetime(), delegationId: IdentifierSchemas.delegationId })
+    .object({ acceptedAt: TimestampSchema, delegationId: IdentifierSchemas.delegationId })
     .strict()
     .readonly();
 export const PI_DURABLE_LEAD_CHILDREN_MAX_PAGE = 256;
@@ -151,7 +151,7 @@ export const PiDurableLeadChildrenRequestSchema = PiDurableLeadReadEnvelopeSchem
     operation: z.literal('pi-durable.lead.children'),
     parameters: z
         .object({
-        dispatchId: DispatchId,
+        dispatchId: PiDurableDispatchIdSchema,
         after: PiDurableLeadChildrenCursorSchema.optional(),
         limit: z.number().int().min(1).max(PI_DURABLE_LEAD_CHILDREN_MAX_PAGE).optional(),
     })
@@ -173,6 +173,12 @@ export const PiDurableSessionEventsRequestSchema = PiDurableLeadReadEnvelopeSche
     parameters: z
         .object({
         runtimeSessionId: PiDurableSessionIdSchema,
+        messageId: z
+            .string()
+            .min(1)
+            .max(128)
+            .regex(/^[A-Za-z0-9._:-]+$/)
+            .optional(),
         afterSeq: LeadEventSeq,
         waitMs: z.number().int().min(0).max(PI_DURABLE_LEAD_EVENTS_MAX_WAIT_MS),
         limit: z.number().int().min(1).max(PI_DURABLE_LEAD_EVENTS_MAX_PAGE).optional(),
@@ -183,20 +189,20 @@ export const PiDurableLeadChildTargetRequestSchema = PiDurableLeadReadEnvelopeSc
     operation: z.literal('pi-durable.lead.child-target'),
     parameters: z
         .object({
-        dispatchId: DispatchId,
+        dispatchId: PiDurableDispatchIdSchema,
         delegationId: IdentifierSchemas.delegationId,
     })
         .strict(),
 });
 export const PiDurableLeadCancelRequestSchema = PiDurableLeadCommandEnvelopeSchema.extend({
     operation: z.literal('pi-durable.lead.cancel'),
-    payload: z.object({ dispatchId: DispatchId }).strict(),
+    payload: z.object({ dispatchId: PiDurableDispatchIdSchema }).strict(),
 });
 export const PiDurableLeadQuestionAnswerRequestSchema = PiDurableLeadCommandEnvelopeSchema.extend({
     operation: z.literal('pi-durable.lead.question-answer'),
     payload: z
         .object({
-        dispatchId: DispatchId,
+        dispatchId: PiDurableDispatchIdSchema,
         requestId: PiDurableQuestionRequestIdSchema,
         answers: PiDurableQuestionAnswersSchema,
     })
@@ -206,11 +212,26 @@ export const PiDurableLeadApprovalAnswerRequestSchema = PiDurableLeadCommandEnve
     operation: z.literal('pi-durable.lead.approval-answer'),
     payload: PiDurableApprovalAnswerSchema.extend(PiDurableApprovalAttestationSchema.shape),
 });
+export const PiDurableChildMessageRequestIdSchema = z
+    .string()
+    .regex(/^pi-child-message:[a-f0-9]{32}$/);
+export const PI_DURABLE_CHILD_MESSAGE_MAX_CHARS = 8192;
+export const PiDurableLeadChildMessageRequestSchema = PiDurableLeadCommandEnvelopeSchema.extend({
+    operation: z.literal('pi-durable.lead.child-message'),
+    payload: z
+        .object({
+        dispatchId: PiDurableDispatchIdSchema,
+        delegationId: IdentifierSchemas.delegationId,
+        requestId: PiDurableChildMessageRequestIdSchema,
+        text: z.string().trim().min(1).max(PI_DURABLE_CHILD_MESSAGE_MAX_CHARS),
+    })
+        .strict(),
+});
 export const PiDurableLeadChildCancelRequestSchema = PiDurableLeadCommandEnvelopeSchema.extend({
     operation: z.literal('pi-durable.lead.child-cancel'),
     payload: z
         .object({
-        dispatchId: DispatchId,
+        dispatchId: PiDurableDispatchIdSchema,
         delegationId: IdentifierSchemas.delegationId,
     })
         .strict(),
@@ -218,7 +239,7 @@ export const PiDurableLeadChildCancelRequestSchema = PiDurableLeadCommandEnvelop
 export const PiDurableLeadReceiptResponseSchema = z
     .object({
     schemaVersion: z.literal('pi-lead-dispatch/v1'),
-    dispatchId: DispatchId,
+    dispatchId: PiDurableDispatchIdSchema,
     intentId: IntentId,
     executionId: IdentifierSchemas.executionId,
     attemptId: IdentifierSchemas.attemptId,
@@ -231,10 +252,9 @@ export const PiDurableLeadReceiptResponseSchema = z
     fenceForeignGeneration(receipt, context);
 });
 const response = SuccessResponseEnvelopeSchema.extend({ correlation: Correlation }).strict();
-const PlanDigest = z.string().regex(/^sha256:[a-f0-9]{64}$/);
 const ChildAllowanceBinding = {
     schemaVersion: z.literal('pi-lead-child-allowance/v1'),
-    executionPlanDigest: PlanDigest,
+    executionPlanDigest: Sha256DigestSchema,
     profile: z
         .strictObject({
         profileId: IdentifierSchemas.profileId,
@@ -265,7 +285,7 @@ export const PiDurableLeadPreparationSchema = z
     selectionRevision: z.number().int().positive().max(Number.MAX_SAFE_INTEGER),
     funding: ModelSelectionFundingViewSchema.options[0],
     childAllowance: PiDurableLeadChildAllowanceSchema.optional(),
-    expiresAt: z.iso.datetime(),
+    expiresAt: TimestampSchema,
     replayed: z.boolean(),
 })
     .strict()
@@ -296,7 +316,7 @@ export const PiDurableLeadLookupResponseSchema = response.extend({
         intentId: IntentId,
         receipt: z
             .object({
-            dispatchId: DispatchId,
+            dispatchId: PiDurableDispatchIdSchema,
             executionId: IdentifierSchemas.executionId,
             attemptId: IdentifierSchemas.attemptId,
             state: z.enum(['dispatching', 'dispatched', 'reconciliation_required']),
@@ -362,18 +382,18 @@ export const PiDurableSessionSchema = z
     .object({
     runtimeSessionId: PiDurableSessionIdSchema,
     role: z.enum(['lead', 'child']),
-    dispatchId: DispatchId,
+    dispatchId: PiDurableDispatchIdSchema,
     intentId: IntentId,
     delegationId: IdentifierSchemas.delegationId.optional(),
     executionId: IdentifierSchemas.executionId,
     attemptId: IdentifierSchemas.attemptId,
     state: RuntimeExecutionStateSchema,
-    startedAt: z.iso.datetime(),
-    updatedAt: z.iso.datetime(),
+    startedAt: TimestampSchema,
+    updatedAt: TimestampSchema,
 })
     .strict()
     .superRefine((value, context) => {
-    const lead = value.runtimeSessionId === `pi-lead:${value.dispatchId}`;
+    const lead = value.runtimeSessionId === piLeadSessionId(value.dispatchId);
     if ((value.role === 'lead') !== lead ||
         (value.role === 'lead') !== (value.delegationId === undefined))
         context.addIssue({
@@ -471,8 +491,8 @@ export const PiDurableLeadChildSchema = z
     ]),
     awaitingInput: z.boolean(),
     stopRequested: z.boolean(),
-    acceptedAt: z.iso.datetime(),
-    updatedAt: z.iso.datetime(),
+    acceptedAt: TimestampSchema,
+    updatedAt: TimestampSchema,
     revision: z.number().int().positive().max(Number.MAX_SAFE_INTEGER),
     outcome: PiDurableLeadChildOutcomeSchema.optional(),
 })
@@ -506,13 +526,20 @@ export const PiDurableLeadChildCancelResponseSchema = response.extend({
         attributed: z.boolean(),
     }),
 });
+export const PiDurableLeadChildMessageResponseSchema = response.extend({
+    data: PiDurableLeadReceiptResponseSchema.extend({
+        child: PiDurableLeadChildSchema,
+        requestId: PiDurableChildMessageRequestIdSchema,
+        outcome: z.enum(['delivered', 'already_delivered']),
+    }),
+});
 export const PiDurableLeadChildTargetSchema = z.strictObject({
     source: z.literal('control_plane_reported'),
     runtimeConnectionId: IdentifierSchemas.runtimeConnectionId,
     nativeSessionId: IdentifierSchemas.externalSessionId,
     nativeTaskId: IdentifierSchemas.taskId,
     nativeState: RuntimeExecutionStateSchema,
-    observedAt: z.iso.datetime(),
+    observedAt: TimestampSchema,
     observedGeneration: RuntimeObservedGenerationSchema.optional(),
 });
 export const PiDurableLeadRemoteSessionReferenceSchema = z
@@ -699,4 +726,11 @@ export const PiDurableLeadHttpContract = Object.freeze({
         requestSchema: PiDurableLeadChildCancelRequestSchema,
         responseSchema: PiDurableLeadChildCancelResponseSchema,
     }),
+    childMessage: Object.freeze({
+        route: 'child-message',
+        operation: 'pi-durable.lead.child-message',
+        scope: 'execution:write',
+        requestSchema: PiDurableLeadChildMessageRequestSchema,
+        responseSchema: PiDurableLeadChildMessageResponseSchema,
+    }),
 });

package/dist/pi-durable-questions.js

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { TimestampSchema } from '@adea-ai/contracts';
 export const PI_QUESTION_TIMEOUT_DEFAULT_SECONDS = 60 * 60;
 export const PI_QUESTION_TIMEOUT_MIN_SECONDS = 60;
 export const PI_QUESTION_TIMEOUT_MAX_SECONDS = 24 * 60 * 60;
@@ -63,15 +64,15 @@ export const PiDurableQuestionRequestSchema = z.strictObject({
     requestId: PiDurableQuestionRequestIdSchema,
     callId: z.string().min(1).max(256),
     questions: PiDurableQuestionsSchema,
-    expiresAt: z.iso.datetime(),
+    expiresAt: TimestampSchema,
 });
 export const PiDurableQuestionOutcomeSchema = z.discriminatedUnion('decision', [
     z.strictObject({
         decision: z.literal('answered'),
         answers: PiDurableQuestionAnswersSchema,
-        decidedAt: z.iso.datetime(),
+        decidedAt: TimestampSchema,
     }),
-    z.strictObject({ decision: z.literal('expired'), decidedAt: z.iso.datetime() }),
+    z.strictObject({ decision: z.literal('expired'), decidedAt: TimestampSchema }),
 ]);
 export function questionAnswersProblem(questions, input) {
     const parsed = PiDurableQuestionAnswersSchema.safeParse(input);

package/dist/registry.js

@@ -101,11 +101,11 @@ export class RuntimeConnectionRegistry {
     async get(runtimeConnectionId) {
         const parsedId = IdentifierSchemas.runtimeConnectionId.parse(runtimeConnectionId);
         const connection = await this.repository.get(parsedId);
-        return connection ? clone(connection) : undefined;
+        return connection ? structuredClone(connection) : undefined;
     }
     async listByRuntimeNode(runtimeNodeRefId) {
         const parsedId = IdentifierSchemas.runtimeNodeRefId.parse(runtimeNodeRefId);
-        return (await this.repository.listByRuntimeNode(parsedId)).map(clone);
+        return (await this.repository.listByRuntimeNode(parsedId)).map((value) => structuredClone(value));
     }
     async update(input) {
         const update = RuntimeConnectionUpdateSchema.parse(input);
@@ -215,7 +215,7 @@ export class InMemoryRuntimeConnectionRepository {
             this.#identities.has(connection.identityDigest)) {
             return false;
         }
-        this.#connections.set(connection.runtimeConnectionId, clone(connection));
+        this.#connections.set(connection.runtimeConnectionId, structuredClone(connection));
         this.#identities.set(connection.identityDigest, connection.runtimeConnectionId);
         return true;
     }
@@ -233,14 +233,14 @@ export class InMemoryRuntimeConnectionRepository {
             return false;
         if (!runtimeConnectionsShareStableIdentity(current, connection))
             return false;
-        this.#connections.set(connection.runtimeConnectionId, clone(connection));
+        this.#connections.set(connection.runtimeConnectionId, structuredClone(connection));
         return true;
     }
     async listByRuntimeNode(runtimeNodeRefId) {
         return [...this.#connections.values()]
             .filter((connection) => connection.runtimeNodeRefId === runtimeNodeRefId)
             .toSorted((left, right) => compareCodePointOrder(left.runtimeConnectionId, right.runtimeConnectionId))
-            .map(clone);
+            .map((value) => structuredClone(value));
     }
     async scanByRuntimeNode(input) {
         const { runtimeNodeRefId, afterConnectionId, limit } = RuntimeConnectionScanSchema.parse(input);
@@ -303,9 +303,6 @@ function latest(...timestamps) {
 function fail(code) {
     throw new RuntimeConnectionRegistryError(code);
 }
-function clone(value) {
-    return structuredClone(value);
-}
 function cloneOptional(value) {
-    return value === undefined ? undefined : clone(value);
+    return value === undefined ? undefined : structuredClone(value);
 }

package/dist/routing.js

@@ -1,10 +1,9 @@
-import { createHash } from 'node:crypto';
-import { compareCodePointOrder } from '@adea-ai/contracts';
+import { compareCodePointOrder, Sha256DigestSchema } from '@adea-ai/contracts';
 import { IdentifierSchemas } from '@adea-ai/contracts';
 import { z } from 'zod';
 import { RuntimeEligibilityDecisionSchema, RuntimeEligibilityReasonCodeSchema, } from './eligibility.js';
 import { RuntimeTimestampSchema } from './models.js';
-const DigestSchema = z.string().regex(/^sha256:[a-f0-9]{64}$/);
+import { sha256Digest } from '@adea-ai/contracts/digest';
 const RuntimeFamilySchema = z
     .string()
     .min(1)
@@ -15,7 +14,7 @@ export const RuntimeRoutingPolicySchema = z
     .object({
     policyId: z.string().min(1).max(128),
     version: z.number().int().positive(),
-    digest: DigestSchema,
+    digest: Sha256DigestSchema,
     weights: z
         .object({
         explicitConnection: WeightSchema,
@@ -124,12 +123,12 @@ export const RuntimeRoutingDecisionSchema = z
             .object({
             policyId: z.string().min(1).max(128),
             version: z.number().int().positive(),
-            digest: DigestSchema,
+            digest: Sha256DigestSchema,
         })
             .strict(),
         evaluatedAt: RuntimeTimestampSchema,
-        inputDigest: DigestSchema,
-        decisionDigest: DigestSchema,
+        inputDigest: Sha256DigestSchema,
+        decisionDigest: Sha256DigestSchema,
     })
         .strict(),
 })
@@ -310,5 +309,5 @@ function compareCoded(left, right) {
     return compareCodePointOrder(`${left.code}:${left.capability ?? ''}`, `${right.code}:${right.capability ?? ''}`);
 }
 function digest(value) {
-    return `sha256:${createHash('sha256').update(JSON.stringify(value)).digest('hex')}`;
+    return sha256Digest(JSON.stringify(value));
 }

package/dist/sessions.js

@@ -124,7 +124,7 @@ export class InMemoryExternalSessionRepository {
                 candidate.opaqueNativeSessionId === session.opaqueNativeSessionId)) {
             return false;
         }
-        this.#sessions.set(session.externalSessionId, clone(session));
+        this.#sessions.set(session.externalSessionId, structuredClone(session));
         return true;
     }
     async get(externalSessionId) {
@@ -141,12 +141,12 @@ export class InMemoryExternalSessionRepository {
             (scope.runtimeConnectionId === undefined ||
                 session.runtimeConnectionId === scope.runtimeConnectionId))
             .toSorted((left, right) => compareCodePointOrder(left.externalSessionId, right.externalSessionId))
-            .map(clone);
+            .map((value) => structuredClone(value));
     }
     async compareAndSet(expectedVersion, session) {
         if (this.#sessions.get(session.externalSessionId)?.version !== expectedVersion)
             return false;
-        this.#sessions.set(session.externalSessionId, clone(session));
+        this.#sessions.set(session.externalSessionId, structuredClone(session));
         return true;
     }
 }
@@ -400,9 +400,6 @@ function sameRegistration(session, input) {
 function fail(code, currentVersion) {
     throw new ExternalSessionRegistryError(code, currentVersion);
 }
-function clone(value) {
-    return structuredClone(value);
-}
 function cloneOptional(value) {
-    return value === undefined ? undefined : clone(value);
+    return value === undefined ? undefined : structuredClone(value);
 }

package/package.json

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