mcp-event-intelligence 0.1.0

package/dist/src/intelligenceProtocol/schemas.d.ts

@@ -0,0 +1,325 @@
+import { z } from 'zod';
+export declare const RuntimeTargetSchema: z.ZodObject<{
+    runtime: z.ZodString;
+    kind: z.ZodEnum<{
+        goal: "goal";
+        session: "session";
+        conversation: "conversation";
+        task: "task";
+        spawn_template: "spawn_template";
+    }>;
+    id: z.ZodString;
+}, z.core.$strip>;
+export declare const EventSourceSchema: z.ZodObject<{
+    serverId: z.ZodString;
+    transport: z.ZodEnum<{
+        stdio: "stdio";
+        streamable_http: "streamable_http";
+        webhook: "webhook";
+        poll: "poll";
+        internal: "internal";
+    }>;
+    provider: z.ZodOptional<z.ZodString>;
+    cursor: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export declare const EventLineageSchema: z.ZodObject<{
+    protocol: z.ZodLiteral<"mcp-event-intelligence">;
+    protocolVersion: z.ZodLiteral<"0.1.0">;
+    schemaVersion: z.ZodLiteral<"ei.v0.1">;
+    traceId: z.ZodString;
+    environmentId: z.ZodString;
+    subscriptionId: z.ZodString;
+    sourceEventId: z.ZodString;
+    observedAt: z.ZodString;
+    source: z.ZodObject<{
+        serverId: z.ZodString;
+        transport: z.ZodEnum<{
+            stdio: "stdio";
+            streamable_http: "streamable_http";
+            webhook: "webhook";
+            poll: "poll";
+            internal: "internal";
+        }>;
+        provider: z.ZodOptional<z.ZodString>;
+        cursor: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>;
+    target: z.ZodObject<{
+        runtime: z.ZodString;
+        kind: z.ZodEnum<{
+            goal: "goal";
+            session: "session";
+            conversation: "conversation";
+            task: "task";
+            spawn_template: "spawn_template";
+        }>;
+        id: z.ZodString;
+    }, z.core.$strip>;
+    event: z.ZodObject<{
+        name: z.ZodString;
+        occurredAt: z.ZodString;
+        payloadHash: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const SemanticDecisionRecordSchema: z.ZodObject<{
+    decisionId: z.ZodString;
+    traceId: z.ZodString;
+    subscriptionId: z.ZodString;
+    sourceEventId: z.ZodString;
+    createdAt: z.ZodString;
+    evaluator: z.ZodString;
+    outcome: z.ZodEnum<{
+        reject: "reject";
+        match: "match";
+        uncertain: "uncertain";
+    }>;
+    probability: z.ZodNumber;
+    matched: z.ZodBoolean;
+    shouldEscalate: z.ZodBoolean;
+    policy: z.ZodObject<{
+        matchThreshold: z.ZodNumber;
+        rejectThreshold: z.ZodNumber;
+        uncertain: z.ZodEnum<{
+            escalate: "escalate";
+            reject: "reject";
+            match: "match";
+        }>;
+    }, z.core.$strip>;
+    inputFields: z.ZodArray<z.ZodString>;
+    providerEvidence: z.ZodOptional<z.ZodObject<{
+        requestedModel: z.ZodOptional<z.ZodString>;
+        resolvedModel: z.ZodOptional<z.ZodString>;
+        requestId: z.ZodOptional<z.ZodString>;
+        httpStatus: z.ZodOptional<z.ZodNumber>;
+        inputTokens: z.ZodOptional<z.ZodNumber>;
+        outputTokens: z.ZodOptional<z.ZodNumber>;
+        providerReportedCost: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const WakeRecordSchema: z.ZodObject<{
+    wakeId: z.ZodString;
+    traceId: z.ZodString;
+    decisionId: z.ZodNullable<z.ZodString>;
+    subscriptionId: z.ZodString;
+    sourceEventId: z.ZodString;
+    createdAt: z.ZodString;
+    target: z.ZodObject<{
+        runtime: z.ZodString;
+        kind: z.ZodEnum<{
+            goal: "goal";
+            session: "session";
+            conversation: "conversation";
+            task: "task";
+            spawn_template: "spawn_template";
+        }>;
+        id: z.ZodString;
+    }, z.core.$strip>;
+    status: z.ZodEnum<{
+        queued: "queued";
+        delivered: "delivered";
+        handled: "handled";
+        duplicate: "duplicate";
+        dead_letter: "dead_letter";
+    }>;
+    runtimeReceiptId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const McpEventOccurrenceSchema: z.ZodObject<{
+    eventId: z.ZodString;
+    name: z.ZodString;
+    timestamp: z.ZodString;
+    data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    cursor: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export declare const SemanticConditionWireSchema: z.ZodObject<{
+    type: z.ZodLiteral<"semantic_boolean">;
+    instruction: z.ZodString;
+    input: z.ZodArray<z.ZodString>;
+    matchThreshold: z.ZodNumber;
+    rejectThreshold: z.ZodNumber;
+    uncertain: z.ZodEnum<{
+        escalate: "escalate";
+        reject: "reject";
+        match: "match";
+    }>;
+}, z.core.$strip>;
+export declare const EventIngestRequestSchema: z.ZodObject<{
+    event: z.ZodObject<{
+        eventId: z.ZodString;
+        name: z.ZodString;
+        timestamp: z.ZodString;
+        data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        cursor: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>;
+    context: z.ZodObject<{
+        traceId: z.ZodOptional<z.ZodString>;
+        environmentId: z.ZodString;
+        subscriptionId: z.ZodString;
+        serverId: z.ZodString;
+        transport: z.ZodEnum<{
+            stdio: "stdio";
+            streamable_http: "streamable_http";
+            webhook: "webhook";
+            poll: "poll";
+            internal: "internal";
+        }>;
+        provider: z.ZodOptional<z.ZodString>;
+        target: z.ZodObject<{
+            runtime: z.ZodString;
+            kind: z.ZodEnum<{
+                goal: "goal";
+                session: "session";
+                conversation: "conversation";
+                task: "task";
+                spawn_template: "spawn_template";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    semanticCondition: z.ZodOptional<z.ZodObject<{
+        type: z.ZodLiteral<"semantic_boolean">;
+        instruction: z.ZodString;
+        input: z.ZodArray<z.ZodString>;
+        matchThreshold: z.ZodNumber;
+        rejectThreshold: z.ZodNumber;
+        uncertain: z.ZodEnum<{
+            escalate: "escalate";
+            reject: "reject";
+            match: "match";
+        }>;
+    }, z.core.$strip>>;
+    wakeOnEscalation: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const LifecycleStateSchema: z.ZodEnum<{
+    matched: "matched";
+    handled: "handled";
+    duplicate: "duplicate";
+    dead_letter: "dead_letter";
+    received: "received";
+    evaluating: "evaluating";
+    rejected: "rejected";
+    escalated: "escalated";
+    wake_queued: "wake_queued";
+    wake_delivered: "wake_delivered";
+    failed: "failed";
+}>;
+export declare const AuditKindSchema: z.ZodEnum<{
+    error: "error";
+    "event.received": "event.received";
+    "event.duplicate": "event.duplicate";
+    "decision.evaluated": "decision.evaluated";
+    "lifecycle.transition": "lifecycle.transition";
+    "wake.queued": "wake.queued";
+    "wake.delivered": "wake.delivered";
+    "wake.handled": "wake.handled";
+    "wake.dead_letter": "wake.dead_letter";
+    "trigger.partial": "trigger.partial";
+    "trigger.correlation": "trigger.correlation";
+    "trigger.matched": "trigger.matched";
+    "trigger.fired": "trigger.fired";
+    "trigger.emitted": "trigger.emitted";
+    "trigger.expired": "trigger.expired";
+    "trigger.created": "trigger.created";
+    "trigger.paused": "trigger.paused";
+    "trigger.resumed": "trigger.resumed";
+    "trigger.updated": "trigger.updated";
+    "trigger.deleted": "trigger.deleted";
+    "trigger.completed": "trigger.completed";
+    "trigger.lifecycle_expired": "trigger.lifecycle_expired";
+    "event_source.registered": "event_source.registered";
+    "derived_event.created": "derived_event.created";
+    "derived_event.replayed": "derived_event.replayed";
+    "derived_contract.created": "derived_contract.created";
+    "derived_contract.producer_registered": "derived_contract.producer_registered";
+    "derived_contract.conflict": "derived_contract.conflict";
+}>;
+export declare const AuditRecordSchema: z.ZodObject<{
+    auditId: z.ZodString;
+    sequence: z.ZodNumber;
+    traceId: z.ZodString;
+    timestamp: z.ZodString;
+    kind: z.ZodEnum<{
+        error: "error";
+        "event.received": "event.received";
+        "event.duplicate": "event.duplicate";
+        "decision.evaluated": "decision.evaluated";
+        "lifecycle.transition": "lifecycle.transition";
+        "wake.queued": "wake.queued";
+        "wake.delivered": "wake.delivered";
+        "wake.handled": "wake.handled";
+        "wake.dead_letter": "wake.dead_letter";
+        "trigger.partial": "trigger.partial";
+        "trigger.correlation": "trigger.correlation";
+        "trigger.matched": "trigger.matched";
+        "trigger.fired": "trigger.fired";
+        "trigger.emitted": "trigger.emitted";
+        "trigger.expired": "trigger.expired";
+        "trigger.created": "trigger.created";
+        "trigger.paused": "trigger.paused";
+        "trigger.resumed": "trigger.resumed";
+        "trigger.updated": "trigger.updated";
+        "trigger.deleted": "trigger.deleted";
+        "trigger.completed": "trigger.completed";
+        "trigger.lifecycle_expired": "trigger.lifecycle_expired";
+        "event_source.registered": "event_source.registered";
+        "derived_event.created": "derived_event.created";
+        "derived_event.replayed": "derived_event.replayed";
+        "derived_contract.created": "derived_contract.created";
+        "derived_contract.producer_registered": "derived_contract.producer_registered";
+        "derived_contract.conflict": "derived_contract.conflict";
+    }>;
+    entityType: z.ZodEnum<{
+        runtime: "runtime";
+        event: "event";
+        decision: "decision";
+        wake: "wake";
+        subscription: "subscription";
+        trigger_match: "trigger_match";
+        trigger: "trigger";
+        event_source: "event_source";
+        derived_event: "derived_event";
+        derived_contract: "derived_contract";
+    }>;
+    entityId: z.ZodString;
+    fromState: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        matched: "matched";
+        handled: "handled";
+        duplicate: "duplicate";
+        dead_letter: "dead_letter";
+        received: "received";
+        evaluating: "evaluating";
+        rejected: "rejected";
+        escalated: "escalated";
+        wake_queued: "wake_queued";
+        wake_delivered: "wake_delivered";
+        failed: "failed";
+    }>>>;
+    toState: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        matched: "matched";
+        handled: "handled";
+        duplicate: "duplicate";
+        dead_letter: "dead_letter";
+        received: "received";
+        evaluating: "evaluating";
+        rejected: "rejected";
+        escalated: "escalated";
+        wake_queued: "wake_queued";
+        wake_delivered: "wake_delivered";
+        failed: "failed";
+    }>>>;
+    details: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    previousHash: z.ZodNullable<z.ZodString>;
+    hash: z.ZodString;
+}, z.core.$strip>;
+export type RuntimeTarget = z.infer<typeof RuntimeTargetSchema>;
+export type McpEventOccurrence = z.infer<typeof McpEventOccurrenceSchema>;
+export type SemanticConditionWire = z.infer<typeof SemanticConditionWireSchema>;
+export type EventIngestRequest = z.infer<typeof EventIngestRequestSchema>;
+export type EventLineage = z.infer<typeof EventLineageSchema>;
+export type SemanticDecisionRecord = z.infer<typeof SemanticDecisionRecordSchema>;
+export type WakeRecord = z.infer<typeof WakeRecordSchema>;
+export type LifecycleState = z.infer<typeof LifecycleStateSchema>;
+export type AuditRecord = z.infer<typeof AuditRecordSchema>;
+export declare function parseEventIngestRequest(value: unknown): EventIngestRequest;
+export declare function parseEventLineage(value: unknown): EventLineage;
+export declare function parseSemanticDecisionRecord(value: unknown): SemanticDecisionRecord;
+export declare function parseWakeRecord(value: unknown): WakeRecord;
+export declare function parseAuditRecord(value: unknown): AuditRecord;

package/dist/src/intelligenceProtocol/schemas.js

@@ -0,0 +1,182 @@
+import { z } from 'zod';
+import { EVENT_INTELLIGENCE_PROTOCOL, EVENT_INTELLIGENCE_PROTOCOL_VERSION, EVENT_INTELLIGENCE_SCHEMA_VERSION, } from './version.js';
+const Id = z.string().min(1).max(200);
+const Timestamp = z.string().datetime({ offset: true });
+export const RuntimeTargetSchema = z.object({
+    runtime: z.string().min(1),
+    kind: z.enum(['goal', 'session', 'conversation', 'task', 'spawn_template']),
+    id: Id,
+});
+export const EventSourceSchema = z.object({
+    serverId: Id,
+    transport: z.enum(['stdio', 'streamable_http', 'webhook', 'poll', 'internal']),
+    provider: z.string().min(1).optional(),
+    cursor: z.string().nullable().optional(),
+});
+export const EventLineageSchema = z.object({
+    protocol: z.literal(EVENT_INTELLIGENCE_PROTOCOL),
+    protocolVersion: z.literal(EVENT_INTELLIGENCE_PROTOCOL_VERSION),
+    schemaVersion: z.literal(EVENT_INTELLIGENCE_SCHEMA_VERSION),
+    traceId: Id,
+    environmentId: Id,
+    subscriptionId: Id,
+    sourceEventId: Id,
+    observedAt: Timestamp,
+    source: EventSourceSchema,
+    target: RuntimeTargetSchema,
+    event: z.object({
+        name: z.string().min(1),
+        occurredAt: Timestamp,
+        payloadHash: z.string().regex(/^[a-f0-9]{64}$/),
+    }),
+});
+export const SemanticDecisionRecordSchema = z.object({
+    decisionId: Id,
+    traceId: Id,
+    subscriptionId: Id,
+    sourceEventId: Id,
+    createdAt: Timestamp,
+    evaluator: z.string().min(1),
+    outcome: z.enum(['match', 'reject', 'uncertain']),
+    probability: z.number().min(0).max(1),
+    matched: z.boolean(),
+    shouldEscalate: z.boolean(),
+    policy: z.object({
+        matchThreshold: z.number().min(0).max(1),
+        rejectThreshold: z.number().min(0).max(1),
+        uncertain: z.enum(['escalate', 'reject', 'match']),
+    }),
+    inputFields: z.array(z.string().min(1)),
+    providerEvidence: z.object({
+        requestedModel: z.string().min(1).optional(),
+        resolvedModel: z.string().min(1).optional(),
+        requestId: z.string().min(1).optional(),
+        httpStatus: z.number().int().min(100).max(599).optional(),
+        inputTokens: z.number().int().nonnegative().optional(),
+        outputTokens: z.number().int().nonnegative().optional(),
+        providerReportedCost: z.number().nonnegative().optional(),
+    }).optional(),
+});
+export const WakeRecordSchema = z.object({
+    wakeId: Id,
+    traceId: Id,
+    decisionId: Id.nullable(),
+    subscriptionId: Id,
+    sourceEventId: Id,
+    createdAt: Timestamp,
+    target: RuntimeTargetSchema,
+    status: z.enum(['queued', 'delivered', 'handled', 'duplicate', 'dead_letter']),
+    runtimeReceiptId: Id.optional(),
+});
+export const McpEventOccurrenceSchema = z.object({
+    eventId: Id,
+    name: z.string().min(1),
+    timestamp: Timestamp,
+    data: z.record(z.string(), z.unknown()),
+    cursor: z.string().nullable().optional(),
+});
+export const SemanticConditionWireSchema = z.object({
+    type: z.literal('semantic_boolean'),
+    instruction: z.string().min(1),
+    input: z.array(z.string().min(1)).min(1),
+    matchThreshold: z.number().min(0).max(1),
+    rejectThreshold: z.number().min(0).max(1),
+    uncertain: z.enum(['escalate', 'reject', 'match']),
+});
+export const EventIngestRequestSchema = z.object({
+    event: McpEventOccurrenceSchema,
+    context: z.object({
+        traceId: Id.optional(),
+        environmentId: Id,
+        subscriptionId: Id,
+        serverId: Id,
+        transport: z.enum(['stdio', 'streamable_http', 'webhook', 'poll', 'internal']),
+        provider: z.string().min(1).optional(),
+        target: RuntimeTargetSchema,
+    }),
+    semanticCondition: SemanticConditionWireSchema.optional(),
+    wakeOnEscalation: z.boolean().default(false),
+});
+export const LifecycleStateSchema = z.enum([
+    'received',
+    'duplicate',
+    'evaluating',
+    'matched',
+    'rejected',
+    'escalated',
+    'wake_queued',
+    'wake_delivered',
+    'handled',
+    'failed',
+    'dead_letter',
+]);
+export const AuditKindSchema = z.enum([
+    'event.received',
+    'event.duplicate',
+    'decision.evaluated',
+    'lifecycle.transition',
+    'wake.queued',
+    'wake.delivered',
+    'wake.handled',
+    'wake.dead_letter',
+    'trigger.partial',
+    'trigger.correlation',
+    'trigger.matched',
+    'trigger.fired',
+    'trigger.emitted',
+    'trigger.expired',
+    'trigger.created',
+    'trigger.paused',
+    'trigger.resumed',
+    'trigger.updated',
+    'trigger.deleted',
+    'trigger.completed',
+    'trigger.lifecycle_expired',
+    'event_source.registered',
+    'derived_event.created',
+    'derived_event.replayed',
+    'derived_contract.created',
+    'derived_contract.producer_registered',
+    'derived_contract.conflict',
+    'error',
+]);
+export const AuditRecordSchema = z.object({
+    auditId: Id,
+    sequence: z.number().int().nonnegative(),
+    traceId: Id,
+    timestamp: Timestamp,
+    kind: AuditKindSchema,
+    entityType: z.enum([
+        'event',
+        'decision',
+        'wake',
+        'subscription',
+        'runtime',
+        'trigger_match',
+        'trigger',
+        'event_source',
+        'derived_event',
+        'derived_contract',
+    ]),
+    entityId: Id,
+    fromState: LifecycleStateSchema.nullable().optional(),
+    toState: LifecycleStateSchema.nullable().optional(),
+    details: z.record(z.string(), z.unknown()).default({}),
+    previousHash: z.string().regex(/^[a-f0-9]{64}$/).nullable(),
+    hash: z.string().regex(/^[a-f0-9]{64}$/),
+});
+export function parseEventIngestRequest(value) {
+    return EventIngestRequestSchema.parse(value);
+}
+export function parseEventLineage(value) {
+    return EventLineageSchema.parse(value);
+}
+export function parseSemanticDecisionRecord(value) {
+    return SemanticDecisionRecordSchema.parse(value);
+}
+export function parseWakeRecord(value) {
+    return WakeRecordSchema.parse(value);
+}
+export function parseAuditRecord(value) {
+    return AuditRecordSchema.parse(value);
+}