mcp-event-intelligence 0.1.0

package/dist/src/semantic/conditionEngine.js

@@ -0,0 +1,65 @@
+function getByPath(source, path) {
+    const parts = path.split('.');
+    let current = source;
+    for (const part of parts) {
+        if (current === null ||
+            typeof current !== 'object' ||
+            Array.isArray(current)) {
+            return undefined;
+        }
+        current = current[part];
+    }
+    return current;
+}
+export function projectSemanticInput(source, paths) {
+    const projected = {};
+    for (const path of paths) {
+        projected[path] = getByPath(source, path);
+    }
+    return projected;
+}
+export class SemanticConditionEngine {
+    evaluator;
+    constructor(evaluator) {
+        this.evaluator = evaluator;
+    }
+    async evaluate(source, condition) {
+        const result = await this.evaluator.evaluate({
+            instruction: condition.instruction,
+            input: projectSemanticInput(source, condition.input),
+        });
+        if (!Number.isFinite(result.probability) ||
+            result.probability < 0 ||
+            result.probability > 1) {
+            throw new Error('Semantic evaluator probability must be between 0 and 1');
+        }
+        const shared = {
+            probability: result.probability,
+            evaluator: result.evaluator,
+            condition,
+            ...(result.metadata ? { metadata: result.metadata } : {}),
+        };
+        if (result.probability >= condition.matchThreshold) {
+            return {
+                outcome: 'match',
+                matched: true,
+                shouldEscalate: false,
+                ...shared,
+            };
+        }
+        if (result.probability <= condition.rejectThreshold) {
+            return {
+                outcome: 'reject',
+                matched: false,
+                shouldEscalate: false,
+                ...shared,
+            };
+        }
+        return {
+            outcome: 'uncertain',
+            matched: condition.uncertain === 'match',
+            shouldEscalate: condition.uncertain === 'escalate',
+            ...shared,
+        };
+    }
+}

package/dist/src/semantic/types.d.ts

@@ -0,0 +1,31 @@
+export type UncertainPolicy = 'escalate' | 'reject' | 'match';
+export interface SemanticBooleanCondition {
+    type: 'semantic_boolean';
+    instruction: string;
+    input: string[];
+    matchThreshold: number;
+    rejectThreshold: number;
+    uncertain: UncertainPolicy;
+}
+export interface SemanticEvaluationRequest {
+    instruction: string;
+    input: Record<string, unknown>;
+}
+export interface SemanticEvaluation {
+    evaluator: string;
+    probability: number;
+    metadata?: Record<string, unknown>;
+}
+export interface SemanticEvaluator {
+    evaluate(request: SemanticEvaluationRequest): Promise<SemanticEvaluation>;
+}
+export type SemanticOutcome = 'match' | 'reject' | 'uncertain';
+export interface SemanticDecision {
+    outcome: SemanticOutcome;
+    matched: boolean;
+    shouldEscalate: boolean;
+    probability: number;
+    evaluator: string;
+    condition: SemanticBooleanCondition;
+    metadata?: Record<string, unknown>;
+}

package/dist/src/semantic/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/semantic/typesafeJevEvaluator.d.ts

@@ -0,0 +1,23 @@
+import type { SemanticEvaluation, SemanticEvaluationRequest, SemanticEvaluator } from './types.js';
+type FetchLike = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+export interface TypeSafeJevEvaluatorOptions {
+    apiKey: string;
+    model?: string;
+    baseUrl?: string;
+    fetchFn?: FetchLike;
+    maxRetries?: number;
+    retryBaseMs?: number;
+}
+export declare class TypeSafeJevEvaluator implements SemanticEvaluator {
+    private readonly options;
+    private readonly model;
+    private readonly baseUrl;
+    private readonly fetchFn;
+    private readonly maxRetries;
+    private readonly retryBaseMs;
+    constructor(options: TypeSafeJevEvaluatorOptions);
+    static fromEnvironment(env: Record<string, string | undefined>): TypeSafeJevEvaluator;
+    evaluate(request: SemanticEvaluationRequest): Promise<SemanticEvaluation>;
+    private requestWithRetry;
+}
+export {};

package/dist/src/semantic/typesafeJevEvaluator.js

@@ -0,0 +1,95 @@
+export class TypeSafeJevEvaluator {
+    options;
+    model;
+    baseUrl;
+    fetchFn;
+    maxRetries;
+    retryBaseMs;
+    constructor(options) {
+        this.options = options;
+        if (!options.apiKey) {
+            throw new Error('TypeSafe API key is required');
+        }
+        this.model = options.model ?? 'jev-latest';
+        this.baseUrl = options.baseUrl ?? 'https://api.typesafe.ai/v1/systemone';
+        this.fetchFn = options.fetchFn ?? fetch;
+        this.maxRetries = options.maxRetries ?? 2;
+        this.retryBaseMs = options.retryBaseMs ?? 100;
+    }
+    static fromEnvironment(env) {
+        const apiKey = env.TYPESAFE_API_KEY;
+        if (!apiKey) {
+            throw new Error('TYPESAFE_API_KEY is required');
+        }
+        return new TypeSafeJevEvaluator({
+            apiKey,
+            model: env.TYPESAFE_MODEL ?? 'jev-latest',
+        });
+    }
+    async evaluate(request) {
+        const payload = {
+            state: request.input,
+            model: this.model,
+            questions: {
+                match: {
+                    type: 'noul',
+                    instructions: request.instruction,
+                },
+            },
+        };
+        const response = await this.requestWithRetry(payload);
+        const answer = response.body.answers?.match;
+        if (!answer ||
+            answer.type !== 'noul' ||
+            !Number.isFinite(answer.noul) ||
+            answer.noul < 0 ||
+            answer.noul > 1) {
+            throw new Error('Invalid Jev noul response');
+        }
+        return {
+            evaluator: `typesafe/${response.body.model}`,
+            probability: answer.noul,
+            metadata: {
+                requestedModel: this.model,
+                resolvedModel: response.body.model,
+                inputTokens: response.body.usage?.input_tokens,
+                outputTokens: response.body.usage?.output_tokens,
+                cost: response.body.usage?.cost,
+                httpStatus: response.httpStatus,
+                requestId: response.requestId,
+            },
+        };
+    }
+    async requestWithRetry(payload) {
+        let attempt = 0;
+        while (true) {
+            const response = await this.fetchFn(this.baseUrl, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${this.options.apiKey}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(payload),
+            });
+            if (response.ok) {
+                const body = (await response.json());
+                const requestId = response.headers.get('x-request-id') ??
+                    response.headers.get('request-id') ??
+                    response.headers.get('x-amzn-requestid') ??
+                    undefined;
+                return {
+                    body,
+                    httpStatus: response.status,
+                    requestId,
+                };
+            }
+            const retryable = response.status === 429 || response.status === 529;
+            if (!retryable || attempt >= this.maxRetries) {
+                throw new Error(`TypeSafe Jev request failed with HTTP ${response.status}`);
+            }
+            const waitMs = this.retryBaseMs * 2 ** attempt;
+            await new Promise((resolve) => setTimeout(resolve, waitMs));
+            attempt += 1;
+        }
+    }
+}

package/package.json

@@ -0,0 +1,85 @@
+{
+  "name": "mcp-event-intelligence",
+  "version": "0.1.0",
+  "description": "Durable temporal event intelligence for agent hosts: host-owned MCP event discovery, composite triggers, derived events, and targeted wakeups.",
+  "license": "Apache-2.0",
+  "type": "module",
+  "main": "./dist/src/intelligenceProtocol/index.js",
+  "types": "./dist/src/intelligenceProtocol/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/src/intelligenceProtocol/index.d.ts",
+      "import": "./dist/src/intelligenceProtocol/index.js"
+    },
+    "./host": {
+      "types": "./scripts/host-integration.d.mts",
+      "import": "./scripts/host-integration.mjs"
+    }
+  },
+  "bin": {
+    "mcp-event-intelligence": "./bin/mcp-event-intelligence.mjs"
+  },
+  "files": [
+    "bin/",
+    "dist/",
+    "scripts/service.mjs",
+    "scripts/lib/",
+    "README.md",
+    "LICENSE",
+    "SECURITY.md",
+    "CHANGELOG.md",
+    "server.json",
+    "scripts/mcp-stdio.mjs",
+    "scripts/mcp-stdio-server.mjs",
+    "scripts/host-integration.mjs",
+    "scripts/host-integration.d.mts",
+    "scripts/run-tests.mjs"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "npm run build && node scripts/run-tests.mjs",
+    "check": "npm run test",
+    "pack:check": "npm pack --dry-run",
+    "prepack": "npm run build",
+    "start": "node scripts/service.mjs",
+    "protocol:check": "npm run check",
+    "mcp": "npm run build && node scripts/mcp-stdio.mjs",
+    "mcp:inspect": "npm run build && npx @modelcontextprotocol/inspector node scripts/mcp-stdio.mjs",
+    "registry:validate": "mcp-publisher validate server.json",
+    "pack:mcp-smoke": "node scripts/package-mcp-smoke.mjs"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "ai-agents",
+    "event-driven",
+    "temporal",
+    "durable-execution",
+    "triggers",
+    "derived-events",
+    "agent-runtime"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sarooo17/event-intelligence.git"
+  },
+  "bugs": {
+    "url": "https://github.com/sarooo17/event-intelligence/issues"
+  },
+  "homepage": "https://github.com/sarooo17/event-intelligence#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "zod": "4.6.5",
+    "@modelcontextprotocol/server": "2.0.0"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "devDependencies": {
+    "typescript": "6.0.3",
+    "@modelcontextprotocol/client": "2.0.0"
+  },
+  "mcpName": "io.github.sarooo17/event-intelligence"
+}

package/scripts/host-integration.d.mts

@@ -0,0 +1,86 @@
+export interface HostMcpClientLike {
+  request(
+    request: { method: string; params?: unknown },
+    resultSchema?: unknown,
+  ): Promise<unknown>;
+  getServerCapabilities?(): unknown;
+}
+
+export interface HostMcpConnectionOptions {
+  connectionId?: string;
+  id?: string;
+  name?: string;
+  serverId?: string;
+  client?: HostMcpClientLike;
+  request?: (method: string, params?: unknown) => Promise<unknown>;
+  enabled?: boolean;
+  pollIntervalMs?: number;
+  maxEvents?: number;
+}
+
+export interface HostMcpRegistry {
+  listConnections?(): Iterable<HostMcpConnectionOptions> | Promise<Iterable<HostMcpConnectionOptions>>;
+  list?(): Iterable<HostMcpConnectionOptions> | Promise<Iterable<HostMcpConnectionOptions>>;
+  connections?(): Iterable<HostMcpConnectionOptions> | Promise<Iterable<HostMcpConnectionOptions>>;
+  subscribe?(listener: () => void): void | (() => void);
+  [Symbol.iterator]?(): Iterator<HostMcpConnectionOptions>;
+}
+
+export interface HostWakeReceipt {
+  runtimeReceiptId: string;
+  duplicate?: boolean;
+  status?: string;
+}
+
+export type HostWakeHandler = (
+  packet: Record<string, unknown>,
+) => Promise<HostWakeReceipt | string> | HostWakeReceipt | string;
+
+export interface EventIntelligenceHostOptions {
+  dataDir?: string;
+  env?: Record<string, string | undefined>;
+  mcpRegistry?: HostMcpRegistry;
+  /** Low-level/manual fallback; prefer mcpRegistry for automatic discovery. */
+  mcpClients?: HostMcpConnectionOptions[];
+  /** Generic harness dispatcher. target.id identifies the task/session/agent to resume. */
+  wake?: HostWakeHandler;
+  /** Optional runtime-specific dispatchers. */
+  wakeHandlers?: Map<string, HostWakeHandler> | Record<string, HostWakeHandler>;
+  semanticEvaluator?: unknown;
+}
+
+export interface EventIntelligenceHost {
+  readonly runtime: any;
+  readonly store: any;
+  readonly triggerControl: any;
+  readonly triggerInspector: any;
+  readonly eventSources: any[];
+  refreshMcpRegistry(): Promise<any[]>;
+  attachMcpClient(connection: HostMcpConnectionOptions): Promise<{
+    connectionId: string;
+    events: any[];
+  }>;
+  detachMcpClient(connectionId: string): Promise<boolean>;
+  mcpStatus(): any[];
+  close(): Promise<void>;
+}
+
+export function createMcpRegistryAdapter(options: {
+  listConnections(): Iterable<HostMcpConnectionOptions> | Promise<Iterable<HostMcpConnectionOptions>>;
+  subscribe?: (listener: () => void) => void | (() => void);
+}): HostMcpRegistry;
+
+export function createHostMcpEventsConnection(
+  options: HostMcpConnectionOptions,
+): {
+  connectionId: string;
+  serverId: string;
+  request(method: string, params?: unknown): Promise<unknown>;
+  enabled: boolean;
+  pollIntervalMs: number;
+  maxEvents: number;
+};
+
+export function createEventIntelligenceHost(
+  options?: EventIntelligenceHostOptions,
+): Promise<EventIntelligenceHost>;

package/scripts/host-integration.mjs

@@ -0,0 +1,216 @@
+import {
+  createLocalEventIntelligenceRuntime,
+} from './lib/local-event-intelligence-runtime.mjs';
+import {
+  createHostMcpEventsConnection,
+} from './lib/mcp-events-client.mjs';
+
+function normalizeMcpConnection(input) {
+  const connectionId = String(
+    input?.connectionId ?? input?.id ?? input?.name ?? '',
+  ).trim();
+  if (!connectionId) {
+    throw new Error('Host MCP registry entry requires connectionId/id/name');
+  }
+
+  return createHostMcpEventsConnection({
+    ...input,
+    connectionId,
+    serverId: input?.serverId ?? connectionId,
+    client: input?.client ?? (
+      input && typeof input.request === 'function' ? input : undefined
+    ),
+  });
+}
+
+async function listRegistryConnections(registry) {
+  if (!registry) return [];
+
+  if (typeof registry.listConnections === 'function') {
+    return Array.from(await registry.listConnections());
+  }
+  if (typeof registry.list === 'function') {
+    return Array.from(await registry.list());
+  }
+  if (typeof registry.connections === 'function') {
+    return Array.from(await registry.connections());
+  }
+  if (Array.isArray(registry)) return registry;
+  if (typeof registry[Symbol.iterator] === 'function') {
+    return Array.from(registry);
+  }
+
+  throw new Error(
+    'mcpRegistry must expose listConnections(), list(), connections(), or be iterable',
+  );
+}
+
+export function createMcpRegistryAdapter({
+  listConnections,
+  subscribe,
+} = {}) {
+  if (typeof listConnections !== 'function') {
+    throw new Error('MCP registry adapter requires listConnections()');
+  }
+  if (subscribe !== undefined && typeof subscribe !== 'function') {
+    throw new Error('MCP registry adapter subscribe must be a function');
+  }
+  return {
+    listConnections,
+    ...(subscribe ? { subscribe } : {}),
+  };
+}
+
+/**
+ * Embed Event Intelligence once at the harness/host level.
+ *
+ * The host keeps ownership of MCP transports, auth, tools and credentials.
+ * Event Intelligence discovers Events-capable clients from the host registry,
+ * ignores tools-only MCPs, and stores only event/cursor state.
+ */
+export async function createEventIntelligenceHost({
+  dataDir,
+  env = {},
+  mcpRegistry,
+  mcpClients = [],
+  wake,
+  wakeHandlers = {},
+  semanticEvaluator,
+} = {}) {
+  const explicitConnections = mcpClients.map(normalizeMcpConnection);
+  const runtime = await createLocalEventIntelligenceRuntime({
+    env: {
+      ...process.env,
+      ...env,
+      ...(dataDir ? { DATA_DIR: dataDir } : {}),
+    },
+    mcpEventConnections: explicitConnections,
+    wake,
+    wakeHandlers,
+    semanticEvaluator,
+  });
+
+  const registryManaged = new Set();
+  let unsubscribe = null;
+
+  const refreshMcpRegistry = async () => {
+    const entries = await listRegistryConnections(mcpRegistry);
+    const desired = new Map();
+
+    for (const entry of entries) {
+      const normalized = normalizeMcpConnection(entry);
+      desired.set(normalized.connectionId, normalized);
+    }
+
+    const outcomes = [];
+
+    for (const connectionId of [...registryManaged]) {
+      if (!desired.has(connectionId)) {
+        await runtime.mcpEventsClient.detachConnection(connectionId);
+        registryManaged.delete(connectionId);
+        outcomes.push({ connectionId, status: 'detached' });
+      }
+    }
+
+    for (const [connectionId, connection] of desired) {
+      const existing = runtime.mcpEventsClient.connections.get(connectionId);
+      if (existing) {
+        if (
+          existing.identity === connection.identity &&
+          existing.serverId === connection.serverId
+        ) {
+          registryManaged.add(connectionId);
+          outcomes.push({ connectionId, status: 'already_attached' });
+          continue;
+        }
+
+        await runtime.mcpEventsClient.detachConnection(connectionId);
+        registryManaged.delete(connectionId);
+      }
+
+      try {
+        const result = await runtime.mcpEventsClient.attachConnection(connection);
+        registryManaged.add(connectionId);
+        outcomes.push({
+          connectionId,
+          status: existing ? 'reattached' : 'attached',
+          events: result.events.map((event) => event.name),
+        });
+      } catch (error) {
+        await runtime.mcpEventsClient.detachConnection(connectionId);
+        if (
+          error &&
+          typeof error === 'object' &&
+          error.code === 'MCP_EVENTS_CAPABILITY_UNAVAILABLE'
+        ) {
+          outcomes.push({
+            connectionId,
+            status: 'ignored_no_events',
+          });
+          continue;
+        }
+        outcomes.push({
+          connectionId,
+          status: 'error',
+          error: error instanceof Error ? error.message : String(error),
+        });
+      }
+    }
+
+    return outcomes;
+  };
+
+  if (mcpRegistry) {
+    await refreshMcpRegistry();
+
+    if (typeof mcpRegistry.subscribe === 'function') {
+      const maybeUnsubscribe = mcpRegistry.subscribe(() => {
+        refreshMcpRegistry().catch((error) => {
+          console.error(JSON.stringify({
+            message: 'event_intelligence_mcp_registry_refresh_failed',
+            error: error instanceof Error ? error.message : String(error),
+          }));
+        });
+      });
+      if (typeof maybeUnsubscribe === 'function') {
+        unsubscribe = maybeUnsubscribe;
+      }
+    }
+  }
+
+  return {
+    runtime,
+    get store() {
+      return runtime.store;
+    },
+    get triggerControl() {
+      return runtime.triggerControl;
+    },
+    get triggerInspector() {
+      return runtime.triggerInspector;
+    },
+    get eventSources() {
+      return runtime.triggerControl.listEventSources();
+    },
+    refreshMcpRegistry,
+    async attachMcpClient(connection) {
+      const normalized = normalizeMcpConnection(connection);
+      return runtime.mcpEventsClient.attachConnection(normalized);
+    },
+    async detachMcpClient(connectionId) {
+      registryManaged.delete(connectionId);
+      return runtime.mcpEventsClient.detachConnection(connectionId);
+    },
+    mcpStatus() {
+      return runtime.mcpEventsClient.status();
+    },
+    async close() {
+      unsubscribe?.();
+      await runtime.close();
+    },
+  };
+}
+
+export {
+  createHostMcpEventsConnection,
+};