@driftwatch/sdk 0.2.1 → 0.4.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Victory Lucky
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -138,12 +138,28 @@ const config = DriftWatchConfigSchema.parse({
   labelled span + the `agent.tool.calls` / `agent.tool.duration` metrics.
 - `DriftWatchConfigSchema` / `loadDriftWatchConfigFromEnv` — Zod-validated
   typed config for telemetry, agent, and drift-detection settings.
-
-Full docs, architecture, and the reference Fastify server that uses this
-SDK live in the [workspace repo](https://github.com/codewithveek/drift-watch) —
-see [`docs/`](https://github.com/codewithveek/drift-watch/tree/main/docs)
-for guides and the [root README](https://github.com/codewithveek/drift-watch#readme)
-for the full picture.
+- `ApprovalService` / `AutopilotScheduler` / `executeControlAction` — the full
+  perceive→reason→act orchestration engine: runs drift detection on a
+  schedule, evaluates policies, dispatches notifications, and manages
+  human-in-the-loop approvals for control actions (pause/rollback/throttle/
+  switch_model). Built entirely on the `StateStore`/`Notifier` interfaces
+  below — no concrete I/O, so it costs nothing to import.
+- `MemoryStateStore` — the zero-dependency `StateStore` implementation
+  (single-process). For multi-process, `RedisStateStore` lives at the isolated
+  subpath `@driftwatch/sdk/redis`, with `ioredis` as an optional peer
+  dependency — importing the package root never pulls it in.
+- `evaluatePolicies` — the pure function mapping a `DriftReport` + policy
+  config to a list of action intents.
+
+Concrete Slack/Telegram/webhook notifiers and inbound-webhook signature
+verification are a separate companion package,
+[`@driftwatch/autopilot`](https://www.npmjs.com/package/@driftwatch/autopilot) —
+install it only if you use those channels.
+
+Full docs, architecture, and the reference Fastify server that uses this SDK
+are at **[drift-watch-docs.vercel.app](https://drift-watch-docs.vercel.app)**;
+the [root README](https://github.com/codewithveek/drift-watch#readme) has the
+full picture.
 
 ## License
 

package/dist/agent/runner.js

@@ -43,7 +43,7 @@ export async function runAgentTask(options) {
                 tools,
                 stopWhen: stopConditions,
                 prompt,
-                experimental_telemetry: {
+                telemetry: {
                     isEnabled: true,
                     functionId: 'agent-run',
                 },

package/dist/autopilot/actions.d.ts

@@ -0,0 +1,24 @@
+import type { ActionType, AgentRuntimeState, DriftSeverity, StateStore } from './types.js';
+export interface ControlActionContext {
+    /** Free-text reason recorded to the audit log. */
+    reason: string;
+    /** Who triggered it (e.g. a Slack user id, "console", "scheduler"). */
+    actor?: string;
+    /** Which surface triggered it: 'console' | 'slack' | 'telegram' | 'system'. */
+    channel?: string;
+    severity?: DriftSeverity;
+    /** Target model id for switch_model. */
+    targetModel?: string;
+}
+export interface ControlActionResult {
+    action: ActionType;
+    applied: boolean;
+    state: AgentRuntimeState;
+}
+/**
+ * Apply a single control action to the shared agent state and append an audit
+ * record. Returns the resulting state. Notify actions are rejected here — they
+ * do not belong on the control path.
+ */
+export declare function executeControlAction(store: StateStore, action: ActionType, context: ControlActionContext): Promise<ControlActionResult>;
+//# sourceMappingURL=actions.d.ts.map

package/dist/autopilot/actions.js

@@ -0,0 +1,125 @@
+/**
+ * Control-action executor — the "act" half of Loop 2.
+ *
+ * These functions mutate the *shared* runtime state (via the StateStore) so
+ * that every process and the console converge on the same posture. Control
+ * actions are only ever executed here: the scheduler enqueues them behind an
+ * approval, and the approval service calls back into this module once a human
+ * (from the console, Slack, or Telegram) has said yes.
+ *
+ * Notify actions are NOT handled here — they are safe side effects dispatched
+ * directly through the notifiers by the scheduler/approval service.
+ */
+import { trace, metrics } from '@opentelemetry/api';
+import { randomUUID } from 'node:crypto';
+const tracer = trace.getTracer('driftwatch');
+/**
+ * Lazily created (see instrument.ts for why module-load creation binds to a
+ * no-op meter): counts Autopilot model switches so the drift detector can tell
+ * an *intentional* switch from unexplained drift, and so a switch is visible on
+ * a dashboard. Paired with the `agent.model.switch` span below, which puts the
+ * same event on the trace timeline for correlation and for SigNoz MCP.
+ */
+let cachedSwitchCounter;
+function getModelSwitchCounter() {
+    if (!cachedSwitchCounter) {
+        cachedSwitchCounter = metrics
+            .getMeter('driftwatch')
+            .createCounter('agent.model.switches', {
+            description: 'Count of Autopilot-initiated model switches, by from/to model',
+        });
+    }
+    return cachedSwitchCounter;
+}
+/**
+ * Emit the observability marker for an applied model switch: a short span (for
+ * trace-timeline correlation — you can see the switch right before the behavior
+ * change, and SigNoz MCP can explain it) plus a counter increment (the
+ * low-cardinality signal the drift detector queries to avoid flagging the
+ * intended change as drift). `from` is the model before the switch, `to` after.
+ */
+function recordModelSwitchMarker(from, to, reason) {
+    const attributes = {
+        'agent.model.from': from ?? 'default',
+        'agent.model.to': to,
+        'agent.control.reason': reason,
+    };
+    tracer.startSpan('agent.model.switch', { attributes }).end();
+    getModelSwitchCounter().add(1, { from_model: from ?? 'default', to_model: to });
+}
+/**
+ * Apply a single control action to the shared agent state and append an audit
+ * record. Returns the resulting state. Notify actions are rejected here — they
+ * do not belong on the control path.
+ */
+export async function executeControlAction(store, action, context) {
+    const current = await store.getAgentState();
+    const next = applyAction(current, action, context);
+    const applied = next !== current;
+    if (applied) {
+        await store.setAgentState(next);
+        if (action === 'switch_model') {
+            recordModelSwitchMarker(current.activeModel, next.activeModel ?? '', context.reason);
+        }
+    }
+    await store.recordAction(toLogEntry(action, applied, context));
+    return { action, applied, state: next };
+}
+/**
+ * Pure state transition for a control action. Returns the SAME object when the
+ * action is a no-op (e.g. resuming an already-running agent) so callers can
+ * detect whether anything changed.
+ */
+function applyAction(current, action, context) {
+    const now = Date.now();
+    const base = { ...current, updatedAt: now, reason: context.reason };
+    switch (action) {
+        case 'pause_agent':
+            if (current.status === 'paused')
+                return current;
+            return { ...base, status: 'paused' };
+        case 'resume_agent':
+            if (current.status === 'running')
+                return current;
+            return { ...base, status: 'running' };
+        case 'throttle':
+            if (current.status === 'throttled')
+                return current;
+            return { ...base, status: 'throttled' };
+        case 'rollback': {
+            // Roll back to the last-known-good version pointer (floor at 1).
+            const target = Math.max(1, current.activeVersion - 1);
+            if (target === current.activeVersion)
+                return current;
+            return { ...base, activeVersion: target };
+        }
+        case 'switch_model': {
+            const target = context.targetModel;
+            if (!target || target === current.activeModel)
+                return current;
+            return { ...base, activeModel: target };
+        }
+        // Notify actions are not control actions and must not reach this path.
+        case 'notify_slack':
+        case 'notify_telegram':
+        case 'notify_webhook':
+            throw new Error(`executeControlAction called with notify action: ${action}`);
+        default: {
+            const exhaustive = action;
+            throw new Error(`Unhandled control action: ${String(exhaustive)}`);
+        }
+    }
+}
+function toLogEntry(action, applied, context) {
+    return {
+        id: randomUUID(),
+        at: Date.now(),
+        action,
+        category: 'control',
+        outcome: applied ? 'executed' : 'skipped_cooldown',
+        reason: applied ? context.reason : `${context.reason} (no-op)`,
+        actor: context.actor,
+        channel: context.channel,
+    };
+}
+//# sourceMappingURL=actions.js.map

package/dist/autopilot/approval-service.d.ts

@@ -0,0 +1,45 @@
+import type { ActionIntent, Approval, StateStore } from './types.js';
+import { type DispatchLogger, type NotifierRegistry } from './notify-dispatch.js';
+export type ApprovalDecision = 'approved' | 'rejected';
+export interface ApprovalServiceOptions {
+    store: StateStore;
+    notifiers: NotifierRegistry;
+    approvalTimeoutMs: number;
+    timeoutDecision: ApprovalDecision;
+    logger?: DispatchLogger;
+    /**
+     * Model id an approved `switch_model` action switches the agent to. The
+     * target is deployment config ("when you downshift, go here"), not per-drift
+     * data, so it lives on the service rather than being threaded through every
+     * intent/approval. Empty = `switch_model` is a no-op (nothing to switch to).
+     */
+    switchModelTo?: string;
+}
+export declare class ApprovalService {
+    private readonly store;
+    private readonly notifiers;
+    private readonly approvalTimeoutMs;
+    private readonly timeoutDecision;
+    private readonly logger?;
+    private readonly switchModelTo?;
+    /** Live timeout handles, so we can cancel on resolve and on shutdown. */
+    private readonly timers;
+    constructor(options: ApprovalServiceOptions);
+    /**
+     * Create a pending approval for a control action intent, broadcast it to
+     * every notifier (with Approve/Reject affordances), and arm the timeout.
+     */
+    requestApproval(intent: ActionIntent): Promise<Approval>;
+    /**
+     * Resolve an approval from any channel. Idempotent: only the first caller to
+     * win the store's atomic CAS executes the action; later calls return
+     * undefined. Returns the resolved approval, or undefined if it was missing
+     * or already resolved.
+     */
+    resolve(id: string, decision: ApprovalDecision, actor: string, channel: string): Promise<Approval | undefined>;
+    /** Cancel all pending timers (called on ordered shutdown). */
+    stop(): void;
+    private armTimeout;
+    private clearTimeout;
+}
+//# sourceMappingURL=approval-service.d.ts.map

package/dist/autopilot/approval-service.js

@@ -0,0 +1,108 @@
+/**
+ * Approval service — creates and resolves human-in-the-loop approvals for
+ * control actions, and executes the action once approved.
+ *
+ * Resolution is channel-agnostic: the console, a Slack button, and a Telegram
+ * button all call `resolve(...)`, which delegates to the StateStore's ATOMIC
+ * resolveApproval (a Redis Lua CAS, or a guarded map write in memory). That
+ * atomicity is what makes approvals safe across processes and idempotent under
+ * double-clicks — whoever wins the CAS executes the action exactly once.
+ *
+ * On creation we arm a timeout so a forgotten approval falls back to a safe
+ * default (reject, by default) rather than hanging a paused agent forever.
+ */
+import { randomUUID } from 'node:crypto';
+import { executeControlAction } from './actions.js';
+import { notifyAll } from './notify-dispatch.js';
+export class ApprovalService {
+    store;
+    notifiers;
+    approvalTimeoutMs;
+    timeoutDecision;
+    logger;
+    switchModelTo;
+    /** Live timeout handles, so we can cancel on resolve and on shutdown. */
+    timers = new Map();
+    constructor(options) {
+        this.store = options.store;
+        this.notifiers = options.notifiers;
+        this.approvalTimeoutMs = options.approvalTimeoutMs;
+        this.timeoutDecision = options.timeoutDecision;
+        this.logger = options.logger;
+        this.switchModelTo = options.switchModelTo;
+    }
+    /**
+     * Create a pending approval for a control action intent, broadcast it to
+     * every notifier (with Approve/Reject affordances), and arm the timeout.
+     */
+    async requestApproval(intent) {
+        const now = Date.now();
+        const approval = {
+            id: randomUUID(),
+            action: intent.type,
+            severity: intent.severity,
+            reasons: intent.reason ? [intent.reason] : [],
+            recommendedAction: `Autopilot proposes: ${intent.type}`,
+            status: 'pending',
+            createdAt: now,
+            expiresAt: now + this.approvalTimeoutMs,
+        };
+        await this.store.createApproval(approval);
+        await notifyAll(this.notifiers, {
+            title: `Approval needed: ${intent.type}`,
+            severity: intent.severity,
+            reasons: approval.reasons,
+            recommendedAction: approval.recommendedAction,
+            approvalId: approval.id,
+            action: intent.type,
+        }, this.logger);
+        this.armTimeout(approval.id);
+        return approval;
+    }
+    /**
+     * Resolve an approval from any channel. Idempotent: only the first caller to
+     * win the store's atomic CAS executes the action; later calls return
+     * undefined. Returns the resolved approval, or undefined if it was missing
+     * or already resolved.
+     */
+    async resolve(id, decision, actor, channel) {
+        const resolved = await this.store.resolveApproval(id, decision, actor, channel);
+        if (!resolved)
+            return undefined;
+        this.clearTimeout(id);
+        if (decision === 'approved') {
+            await executeControlAction(this.store, resolved.action, {
+                reason: `approved via ${channel} by ${actor}`,
+                actor,
+                channel,
+                severity: resolved.severity,
+                targetModel: this.switchModelTo,
+            });
+        }
+        return resolved;
+    }
+    /** Cancel all pending timers (called on ordered shutdown). */
+    stop() {
+        for (const timer of this.timers.values())
+            clearTimeout(timer);
+        this.timers.clear();
+    }
+    armTimeout(id) {
+        const timer = setTimeout(() => {
+            this.timers.delete(id);
+            // Resolve with the configured safe default; 'timeout' marks the channel.
+            void this.resolve(id, this.timeoutDecision, 'autopilot', 'timeout').catch((error) => this.logger?.error({ error, id }, 'approval timeout resolve failed'));
+        }, this.approvalTimeoutMs);
+        // Don't keep the event loop alive solely for a pending approval.
+        timer.unref?.();
+        this.timers.set(id, timer);
+    }
+    clearTimeout(id) {
+        const timer = this.timers.get(id);
+        if (timer) {
+            clearTimeout(timer);
+            this.timers.delete(id);
+        }
+    }
+}
+//# sourceMappingURL=approval-service.js.map

package/dist/autopilot/memory-store.d.ts

@@ -0,0 +1,29 @@
+/**
+ * In-memory StateStore — the zero-dependency default. Perfect for single-
+ * process use (a standalone script, a single container); NOT suitable across
+ * multiple processes, since each keeps its own state. For multi-process
+ * deployments, use `RedisStateStore` from `@driftwatch/sdk/redis` instead.
+ */
+import type { ActionLogEntry, AgentRuntimeState, Approval, ApprovalStatus, DriftHistoryEntry, StateStore } from './types.js';
+export declare class MemoryStateStore implements StateStore {
+    private agentState;
+    private readonly approvals;
+    private readonly driftHistory;
+    private readonly actionLog;
+    private readonly cooldowns;
+    private readonly leaderLocks;
+    getAgentState(): Promise<AgentRuntimeState>;
+    setAgentState(state: AgentRuntimeState): Promise<void>;
+    createApproval(approval: Approval): Promise<void>;
+    getApproval(id: string): Promise<Approval | undefined>;
+    listPendingApprovals(): Promise<Approval[]>;
+    resolveApproval(id: string, status: Exclude<ApprovalStatus, 'pending'>, resolvedBy: string, channel: string): Promise<Approval | undefined>;
+    recordDriftVerdict(entry: DriftHistoryEntry): Promise<void>;
+    listDriftHistory(limit: number): Promise<DriftHistoryEntry[]>;
+    recordAction(entry: ActionLogEntry): Promise<void>;
+    listActionLog(limit: number): Promise<ActionLogEntry[]>;
+    checkAndSetCooldown(key: string, ttlMs: number): Promise<boolean>;
+    acquireLeaderLock(key: string, ttlMs: number): Promise<boolean>;
+    close(): Promise<void>;
+}
+//# sourceMappingURL=memory-store.d.ts.map

package/dist/autopilot/memory-store.js

@@ -0,0 +1,84 @@
+const HISTORY_CAP = 500;
+export class MemoryStateStore {
+    agentState = {
+        status: 'running',
+        activeVersion: 1,
+        updatedAt: Date.now(),
+    };
+    approvals = new Map();
+    driftHistory = [];
+    actionLog = [];
+    cooldowns = new Map();
+    leaderLocks = new Map();
+    async getAgentState() {
+        return { ...this.agentState };
+    }
+    async setAgentState(state) {
+        this.agentState = { ...state };
+    }
+    async createApproval(approval) {
+        this.approvals.set(approval.id, { ...approval });
+    }
+    async getApproval(id) {
+        const approval = this.approvals.get(id);
+        return approval ? { ...approval } : undefined;
+    }
+    async listPendingApprovals() {
+        return Array.from(this.approvals.values())
+            .filter((approval) => approval.status === 'pending')
+            .sort((a, b) => a.createdAt - b.createdAt)
+            .map((approval) => ({ ...approval }));
+    }
+    async resolveApproval(id, status, resolvedBy, channel) {
+        const approval = this.approvals.get(id);
+        if (!approval || approval.status !== 'pending')
+            return undefined;
+        const resolved = {
+            ...approval,
+            status,
+            resolvedBy,
+            channel,
+            resolvedAt: Date.now(),
+        };
+        this.approvals.set(id, resolved);
+        return { ...resolved };
+    }
+    async recordDriftVerdict(entry) {
+        this.driftHistory.unshift({ ...entry });
+        if (this.driftHistory.length > HISTORY_CAP) {
+            this.driftHistory.length = HISTORY_CAP;
+        }
+    }
+    async listDriftHistory(limit) {
+        return this.driftHistory.slice(0, limit).map((entry) => ({ ...entry }));
+    }
+    async recordAction(entry) {
+        this.actionLog.unshift({ ...entry });
+        if (this.actionLog.length > HISTORY_CAP) {
+            this.actionLog.length = HISTORY_CAP;
+        }
+    }
+    async listActionLog(limit) {
+        return this.actionLog.slice(0, limit).map((entry) => ({ ...entry }));
+    }
+    async checkAndSetCooldown(key, ttlMs) {
+        const now = Date.now();
+        const existingExpiry = this.cooldowns.get(key);
+        if (existingExpiry !== undefined && existingExpiry > now)
+            return false;
+        this.cooldowns.set(key, now + ttlMs);
+        return true;
+    }
+    async acquireLeaderLock(key, ttlMs) {
+        const now = Date.now();
+        const existingExpiry = this.leaderLocks.get(key);
+        if (existingExpiry !== undefined && existingExpiry > now)
+            return false;
+        this.leaderLocks.set(key, now + ttlMs);
+        return true;
+    }
+    async close() {
+        // nothing to release for the in-memory store
+    }
+}
+//# sourceMappingURL=memory-store.js.map

package/dist/autopilot/notify-dispatch.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Notifier registry + fire-and-forget dispatch. Pure orchestration over the
+ * `Notifier` interface — no concrete channel (Slack/Telegram/webhook) lives
+ * here. Concrete notifiers are in the companion `@driftwatch/autopilot`
+ * package (or bring your own — anything implementing `Notifier`).
+ *
+ * Dispatch never throws into the caller: a channel failure is logged and
+ * swallowed so one broken webhook can't stall the drift loop.
+ */
+import type { ActionType, NotificationMessage, Notifier } from './types.js';
+export interface NotifierRegistry {
+    slack?: Notifier;
+    telegram?: Notifier;
+    webhook?: Notifier;
+    /** All configured notifiers, in a stable order. */
+    list: Notifier[];
+}
+/** Map a notify_* action to its concrete channel notifier, if configured. */
+export declare function notifierForAction(registry: NotifierRegistry, action: ActionType): Notifier | undefined;
+export interface DispatchLogger {
+    error: (obj: unknown, msg?: string) => void;
+}
+/** Fire-and-forget send to a single notifier; failures are logged, not thrown. */
+export declare function safeNotify(notifier: Notifier, message: NotificationMessage, logger?: DispatchLogger): Promise<void>;
+/** Broadcast a message to every configured notifier concurrently. */
+export declare function notifyAll(registry: NotifierRegistry, message: NotificationMessage, logger?: DispatchLogger): Promise<void>;
+//# sourceMappingURL=notify-dispatch.d.ts.map

package/dist/autopilot/notify-dispatch.js

@@ -0,0 +1,27 @@
+/** Map a notify_* action to its concrete channel notifier, if configured. */
+export function notifierForAction(registry, action) {
+    switch (action) {
+        case 'notify_slack':
+            return registry.slack;
+        case 'notify_telegram':
+            return registry.telegram;
+        case 'notify_webhook':
+            return registry.webhook;
+        default:
+            return undefined;
+    }
+}
+/** Fire-and-forget send to a single notifier; failures are logged, not thrown. */
+export async function safeNotify(notifier, message, logger) {
+    try {
+        await notifier.notify(message);
+    }
+    catch (error) {
+        logger?.error({ error, channel: notifier.channel }, 'notification failed');
+    }
+}
+/** Broadcast a message to every configured notifier concurrently. */
+export async function notifyAll(registry, message, logger) {
+    await Promise.all(registry.list.map((notifier) => safeNotify(notifier, message, logger)));
+}
+//# sourceMappingURL=notify-dispatch.js.map

package/dist/autopilot/redis-store.d.ts

@@ -0,0 +1,19 @@
+import type { ActionLogEntry, AgentRuntimeState, Approval, ApprovalStatus, DriftHistoryEntry, StateStore } from './types.js';
+export declare class RedisStateStore implements StateStore {
+    private readonly redis;
+    constructor(redisUrl: string);
+    getAgentState(): Promise<AgentRuntimeState>;
+    setAgentState(state: AgentRuntimeState): Promise<void>;
+    createApproval(approval: Approval): Promise<void>;
+    getApproval(id: string): Promise<Approval | undefined>;
+    listPendingApprovals(): Promise<Approval[]>;
+    resolveApproval(id: string, status: Exclude<ApprovalStatus, 'pending'>, resolvedBy: string, channel: string): Promise<Approval | undefined>;
+    recordDriftVerdict(entry: DriftHistoryEntry): Promise<void>;
+    listDriftHistory(limit: number): Promise<DriftHistoryEntry[]>;
+    recordAction(entry: ActionLogEntry): Promise<void>;
+    listActionLog(limit: number): Promise<ActionLogEntry[]>;
+    checkAndSetCooldown(key: string, ttlMs: number): Promise<boolean>;
+    acquireLeaderLock(key: string, ttlMs: number): Promise<boolean>;
+    close(): Promise<void>;
+}
+//# sourceMappingURL=redis-store.d.ts.map

package/dist/autopilot/redis-store.js

@@ -0,0 +1,126 @@
+/**
+ * Redis-backed StateStore for multi-process operation. When several server
+ * processes run behind a load balancer, they share one view of agent state,
+ * pending approvals, drift history, and the action log — and a leader lock
+ * ensures only one process runs each scheduled drift cycle.
+ *
+ * Not exported from the package root — import from `@driftwatch/sdk/redis`.
+ * `ioredis` is an OPTIONAL peer dependency: installing the core SDK never
+ * pulls it in, so this is the one place in the SDK a consumer opts into a
+ * concrete I/O dependency, and only if they import this subpath.
+ */
+import { Redis } from 'ioredis';
+const HISTORY_CAP = 500;
+const KEY = {
+    agentState: 'dw:agent:state',
+    pendingApprovals: 'dw:approvals:pending',
+    approval: (id) => `dw:approval:${id}`,
+    driftHistory: 'dw:drift:history',
+    actionLog: 'dw:action:log',
+    cooldown: (key) => `dw:cooldown:${key}`,
+    leader: (key) => `dw:leader:${key}`,
+};
+const DEFAULT_AGENT_STATE = {
+    status: 'running',
+    activeVersion: 1,
+    updatedAt: 0,
+};
+/**
+ * Atomically resolve a still-pending approval. Returns the updated JSON, or an
+ * empty string when the approval is missing or already resolved. Running this
+ * as a single Lua script guarantees two channels (console + Slack + Telegram)
+ * can't both "win" the same approval.
+ */
+const RESOLVE_APPROVAL_LUA = `
+local raw = redis.call('GET', KEYS[1])
+if not raw then return '' end
+local approval = cjson.decode(raw)
+if approval.status ~= 'pending' then return '' end
+approval.status = ARGV[1]
+approval.resolvedBy = ARGV[2]
+approval.channel = ARGV[3]
+approval.resolvedAt = tonumber(ARGV[4])
+local updated = cjson.encode(approval)
+redis.call('SET', KEYS[1], updated)
+redis.call('SREM', KEYS[2], ARGV[5])
+return updated
+`;
+export class RedisStateStore {
+    redis;
+    constructor(redisUrl) {
+        this.redis = new Redis(redisUrl, { lazyConnect: false, maxRetriesPerRequest: 3 });
+    }
+    async getAgentState() {
+        const raw = await this.redis.get(KEY.agentState);
+        if (!raw)
+            return { ...DEFAULT_AGENT_STATE, updatedAt: Date.now() };
+        return JSON.parse(raw);
+    }
+    async setAgentState(state) {
+        await this.redis.set(KEY.agentState, JSON.stringify(state));
+    }
+    async createApproval(approval) {
+        await this.redis
+            .multi()
+            .set(KEY.approval(approval.id), JSON.stringify(approval))
+            .sadd(KEY.pendingApprovals, approval.id)
+            .exec();
+    }
+    async getApproval(id) {
+        const raw = await this.redis.get(KEY.approval(id));
+        return raw ? JSON.parse(raw) : undefined;
+    }
+    async listPendingApprovals() {
+        const ids = await this.redis.smembers(KEY.pendingApprovals);
+        if (ids.length === 0)
+            return [];
+        const raws = await this.redis.mget(ids.map((id) => KEY.approval(id)));
+        const approvals = [];
+        for (const raw of raws) {
+            if (!raw)
+                continue;
+            const approval = JSON.parse(raw);
+            if (approval.status === 'pending')
+                approvals.push(approval);
+        }
+        return approvals.sort((a, b) => a.createdAt - b.createdAt);
+    }
+    async resolveApproval(id, status, resolvedBy, channel) {
+        const result = (await this.redis.eval(RESOLVE_APPROVAL_LUA, 2, KEY.approval(id), KEY.pendingApprovals, status, resolvedBy, channel, String(Date.now()), id));
+        return result ? JSON.parse(result) : undefined;
+    }
+    async recordDriftVerdict(entry) {
+        await this.redis
+            .multi()
+            .lpush(KEY.driftHistory, JSON.stringify(entry))
+            .ltrim(KEY.driftHistory, 0, HISTORY_CAP - 1)
+            .exec();
+    }
+    async listDriftHistory(limit) {
+        const raws = await this.redis.lrange(KEY.driftHistory, 0, limit - 1);
+        return raws.map((raw) => JSON.parse(raw));
+    }
+    async recordAction(entry) {
+        await this.redis
+            .multi()
+            .lpush(KEY.actionLog, JSON.stringify(entry))
+            .ltrim(KEY.actionLog, 0, HISTORY_CAP - 1)
+            .exec();
+    }
+    async listActionLog(limit) {
+        const raws = await this.redis.lrange(KEY.actionLog, 0, limit - 1);
+        return raws.map((raw) => JSON.parse(raw));
+    }
+    async checkAndSetCooldown(key, ttlMs) {
+        const result = await this.redis.set(KEY.cooldown(key), '1', 'PX', ttlMs, 'NX');
+        return result === 'OK';
+    }
+    async acquireLeaderLock(key, ttlMs) {
+        const result = await this.redis.set(KEY.leader(key), '1', 'PX', ttlMs, 'NX');
+        return result === 'OK';
+    }
+    async close() {
+        await this.redis.quit();
+    }
+}
+//# sourceMappingURL=redis-store.js.map

package/dist/autopilot/scheduler.d.ts

@@ -0,0 +1,48 @@
+import { type DriftReport } from '../drift/detector.js';
+import type { ModelClient } from '../model-client.js';
+import type { DriftDetectionConfig } from '../config/schema.js';
+import { type PolicyConfig } from './policy.js';
+import type { ActionIntent, StateStore } from './types.js';
+import type { ApprovalService } from './approval-service.js';
+import { type NotifierRegistry } from './notify-dispatch.js';
+export interface SchedulerLogger {
+    info: (obj: unknown, msg?: string) => void;
+    error: (obj: unknown, msg?: string) => void;
+}
+export interface AutopilotSchedulerOptions {
+    store: StateStore;
+    notifiers: NotifierRegistry;
+    approvalService: ApprovalService;
+    modelClient: ModelClient;
+    policyConfig: PolicyConfig;
+    driftDetectionConfig: DriftDetectionConfig;
+    isDryRun: boolean;
+    scanIntervalMs: number;
+    cooldownMs: number;
+    logger: SchedulerLogger;
+}
+export declare class AutopilotScheduler {
+    private readonly options;
+    private timer?;
+    private running;
+    constructor(options: AutopilotSchedulerOptions);
+    /** Begin the periodic loop. The first cycle runs after one interval. */
+    start(): void;
+    stop(): void;
+    /** One guarded tick: only the elected leader runs a cycle. */
+    private tick;
+    /**
+     * Run a single drift cycle end to end. Exposed so the control-plane's
+     * POST /drift/scan can trigger a manual run. Returns the report + intents
+     * for the caller to surface.
+     */
+    runCycle(trigger: string): Promise<{
+        report: DriftReport;
+        intents: ActionIntent[];
+    }>;
+    private dispatchIntent;
+    private dispatchNotify;
+    private dispatchControl;
+    private recordOutcome;
+}
+//# sourceMappingURL=scheduler.d.ts.map

package/dist/autopilot/scheduler.js

@@ -0,0 +1,144 @@
+/**
+ * Autopilot scheduler — the autonomous perceive→reason→act loop (Loop 2).
+ *
+ * Every SCAN_INTERVAL_MS the leader process (elected via the StateStore's
+ * leader lock so only ONE process acts per cycle in a multi-process
+ * deployment):
+ *   1. perceive — detectBehavioralDrift over the SigNoz windows (or fixtures),
+ *   2. reason   — evaluatePolicies maps the report to ActionIntents,
+ *   3. act      — notify_* intents fire immediately; control intents open an
+ *                 approval. A per-action cooldown dedups storms.
+ *
+ * In `shadow` mode nothing is executed: intended actions are logged only, which
+ * is the safe default and the CI/demo path.
+ */
+import { randomUUID } from 'node:crypto';
+import { detectBehavioralDrift } from '../drift/detector.js';
+import { evaluatePolicies } from './policy.js';
+import { notifierForAction, safeNotify, } from './notify-dispatch.js';
+const LEADER_LOCK_KEY = 'scheduler:leader';
+export class AutopilotScheduler {
+    options;
+    timer;
+    running = false;
+    constructor(options) {
+        this.options = options;
+    }
+    /** Begin the periodic loop. The first cycle runs after one interval. */
+    start() {
+        if (this.timer)
+            return;
+        this.timer = setInterval(() => {
+            void this.tick();
+        }, this.options.scanIntervalMs);
+        this.timer.unref?.();
+        this.options.logger.info({ intervalMs: this.options.scanIntervalMs, mode: this.options.policyConfig.mode }, 'autopilot scheduler started');
+    }
+    stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = undefined;
+        }
+    }
+    /** One guarded tick: only the elected leader runs a cycle. */
+    async tick() {
+        if (this.running)
+            return; // never overlap cycles within a process
+        const isLeader = await this.options.store.acquireLeaderLock(LEADER_LOCK_KEY, this.options.scanIntervalMs);
+        if (!isLeader)
+            return;
+        this.running = true;
+        try {
+            await this.runCycle('scheduler');
+        }
+        catch (error) {
+            this.options.logger.error({ error }, 'autopilot cycle failed');
+        }
+        finally {
+            this.running = false;
+        }
+    }
+    /**
+     * Run a single drift cycle end to end. Exposed so the control-plane's
+     * POST /drift/scan can trigger a manual run. Returns the report + intents
+     * for the caller to surface.
+     */
+    async runCycle(trigger) {
+        const { store, modelClient, driftDetectionConfig, isDryRun, policyConfig } = this.options;
+        const report = await detectBehavioralDrift({
+            modelClient,
+            isDryRun,
+            driftDetectionConfig,
+        });
+        await store.recordDriftVerdict({
+            id: randomUUID(),
+            at: Date.now(),
+            drift: report.verdict.drift,
+            severity: report.verdict.severity,
+            reasons: report.verdict.reasons,
+            recommendedAction: report.verdict.recommended_action,
+            baselineTokenSpend: report.baselineWindowStats.tokenSpend,
+            currentTokenSpend: report.currentWindowStats.tokenSpend,
+        });
+        const intents = evaluatePolicies(report, policyConfig);
+        for (const intent of intents) {
+            await this.dispatchIntent(intent, trigger);
+        }
+        return { report, intents };
+    }
+    async dispatchIntent(intent, trigger) {
+        const { store, policyConfig, cooldownMs, logger } = this.options;
+        const isShadow = policyConfig.mode === 'shadow';
+        // Cooldown dedup — one entry per action type per window.
+        const mayProceed = await store.checkAndSetCooldown(`action:${intent.type}`, cooldownMs);
+        if (!mayProceed) {
+            await this.recordOutcome(intent, 'skipped_cooldown', trigger);
+            return;
+        }
+        if (isShadow) {
+            logger.info({ intent, trigger }, 'autopilot shadow: intended action (not executed)');
+            await this.recordOutcome(intent, 'shadowed', trigger);
+            return;
+        }
+        if (intent.category === 'notify') {
+            await this.dispatchNotify(intent, trigger);
+        }
+        else {
+            await this.dispatchControl(intent, trigger);
+        }
+    }
+    async dispatchNotify(intent, trigger) {
+        const { notifiers, logger } = this.options;
+        const notifier = notifierForAction(notifiers, intent.type);
+        if (!notifier) {
+            logger.info({ intent }, 'notify action skipped: channel not configured');
+            await this.recordOutcome(intent, 'failed', trigger);
+            return;
+        }
+        await safeNotify(notifier, {
+            title: 'Behavioral drift detected',
+            severity: intent.severity,
+            reasons: intent.reason ? [intent.reason] : [],
+            recommendedAction: intent.reason || 'Review the drift report.',
+            action: intent.type,
+        }, logger);
+        await this.recordOutcome(intent, 'executed', trigger);
+    }
+    async dispatchControl(intent, trigger) {
+        await this.options.approvalService.requestApproval(intent);
+        await this.recordOutcome(intent, 'pending_approval', trigger);
+    }
+    async recordOutcome(intent, outcome, trigger) {
+        await this.options.store.recordAction({
+            id: randomUUID(),
+            at: Date.now(),
+            action: intent.type,
+            category: intent.category,
+            outcome,
+            reason: intent.reason,
+            actor: 'autopilot',
+            channel: trigger,
+        });
+    }
+}
+//# sourceMappingURL=scheduler.js.map

package/dist/autopilot/types.d.ts

@@ -1,11 +1,19 @@
 /**
  * Shared types for the Autopilot layer — Loop 2 of DriftWatch.
  *
- * These live in the SDK because they are pure data/interfaces with no I/O and
- * no provider or env coupling. The *implementations* (Redis state store, Slack
- * / Telegram / webhook notifiers, the scheduler) live in @driftwatch/server,
- * which is where side effects belong. This keeps the SDK publishable with zero
- * provider SDKs and zero process.env reads, exactly like the rest of it.
+ * The orchestration built on these types — `MemoryStateStore`,
+ * `ApprovalService`, `AutopilotScheduler`, `executeControlAction`, and the
+ * notify-dispatch helpers — lives alongside them in this package, since none
+ * of it does concrete I/O: it only calls the `StateStore`/`Notifier`
+ * interfaces defined here. Two things that DO require concrete I/O are kept
+ * out of the package root:
+ *   - `RedisStateStore` needs `ioredis` — it's an isolated subpath export at
+ *     `@driftwatch/sdk/redis` with ioredis as an optional peer dependency, so
+ *     importing the core SDK never pulls it in.
+ *   - Concrete Slack/Telegram/webhook `Notifier`s and inbound-webhook
+ *     signature verification live in the companion `@driftwatch/autopilot`
+ *     package, since they track those providers' APIs independently of this
+ *     package's release cadence.
  */
 import type { DriftVerdict } from '../drift/detector.js';
 /** Every remediation action Autopilot knows how to intend. */

package/dist/drift/detector.js

@@ -37,11 +37,18 @@ export async function detectBehavioralDrift(options) {
     const [baselineWindowStats, currentWindowStats] = isDryRun
         ? loadFixtureWindows()
         : await queryLiveWindows(driftDetectionConfig);
+    // If Autopilot switched the agent's model this window, the resulting behavior
+    // change is intentional — tell the judge so it doesn't flag the cure as the
+    // disease. Fixtures have no such context. See queryModelSwitchNote.
+    const modelSwitchNote = isDryRun
+        ? undefined
+        : await queryModelSwitchNote(driftDetectionConfig);
     const modelClientDescriptor = describeModelClient(modelClient);
     const { verdict, judgeTokenUsage, judgeAttempts } = await judgeDriftVerdict({
         baselineWindowStats,
         currentWindowStats,
         modelClient,
+        modelSwitchNote,
     });
     return {
         baselineWindowStats,
@@ -161,6 +168,48 @@ function buildTokenSpendQuery() {
         expression: 'C',
     });
 }
+function buildModelSwitchQuery() {
+    return buildMetricBuilderQuery({
+        metricKey: 'agent.model.switches',
+        instrumentType: 'Sum',
+        timeAggregation: 'sum',
+        spaceAggregation: 'sum',
+        expression: 'A',
+    });
+}
+/**
+ * Count Autopilot model switches in the current window (the `agent.model.switches`
+ * counter emitted by executeControlAction) and, if any, return a note the judge
+ * uses to avoid classifying the *intended* behavior change as drift.
+ *
+ * Fail-safe by design: any query error resolves to "no switch" (undefined), so a
+ * hiccup here never breaks drift detection — the worst case is a switch isn't
+ * discounted, i.e. exactly today's behavior.
+ */
+async function queryModelSwitchNote(driftDetectionConfig) {
+    const endTimeMs = Date.now();
+    const startTimeMs = endTimeMs - ONE_HOUR_MS;
+    try {
+        const signozResponseBody = await querySignozRange({
+            driftDetectionConfig,
+            startTimeMs,
+            endTimeMs,
+            builderQueries: { A: buildModelSwitchQuery() },
+        });
+        const switchCount = extractTokenSpend(findBuilderResult(signozResponseBody.data?.result ?? [], 'A'));
+        if (switchCount <= 0)
+            return undefined;
+        const times = switchCount >= 2 ? `${Math.round(switchCount)} times` : 'once';
+        return (`Autopilot switched the monitored agent's model ${times} during the CURRENT window ` +
+            `(an intentional remediation, not organic behavior). Changes attributable to a model ` +
+            `switch — especially token-spend and per-tool latency shifts — are EXPECTED and must ` +
+            `NOT be classified as drift on their own. Flag drift only for changes beyond what a ` +
+            `model switch explains (e.g. a real error-rate spike or a tool-mix collapse).`);
+    }
+    catch {
+        return undefined;
+    }
+}
 async function querySignozRange(options) {
     const { driftDetectionConfig, startTimeMs, endTimeMs, builderQueries } = options;
     // SigNoz v4 requires every builder query to carry a `queryName` that matches
@@ -302,11 +351,15 @@ function buildFixtureWindowStats(windowLabel, driftMultiplier) {
  */
 const MAX_JUDGE_ATTEMPTS = 3;
 async function judgeDriftVerdict(options) {
-    const { baselineWindowStats, currentWindowStats, modelClient } = options;
+    const { baselineWindowStats, currentWindowStats, modelClient, modelSwitchNote } = options;
     const messages = [
         {
             role: 'user',
-            content: buildDriftJudgePrompt({ baselineWindowStats, currentWindowStats }),
+            content: buildDriftJudgePrompt({
+                baselineWindowStats,
+                currentWindowStats,
+                modelSwitchNote,
+            }),
         },
     ];
     const usageTotals = {
@@ -433,11 +486,12 @@ The JSON object must have exactly these keys:
 Example of a correctly formatted reply (structure only — do not reuse these values):
 {"drift":true,"severity":"high","reasons":["p95 latency 180ms -> 450ms","error rate 2% -> 9%","search_docs share 40% -> 75%"],"recommended_action":"Page the on-call engineer to investigate the search_docs regression."}`;
 function buildDriftJudgePrompt(options) {
-    const { baselineWindowStats, currentWindowStats } = options;
+    const { baselineWindowStats, currentWindowStats, modelSwitchNote } = options;
+    const switchContext = modelSwitchNote ? `\n\nCONTEXT: ${modelSwitchNote}` : '';
     return `Compare the CURRENT window against the BASELINE and decide whether the agent's behavior has drifted enough to warrant a human alert. Consider shifts in tool-call mix, rising error rate, latency regressions, and token-spend spikes.
 
 BASELINE: ${JSON.stringify(baselineWindowStats)}
-CURRENT:  ${JSON.stringify(currentWindowStats)}
+CURRENT:  ${JSON.stringify(currentWindowStats)}${switchContext}
 
 Reply with ONLY the JSON object described in your instructions.`;
 }

package/dist/index.d.ts

@@ -9,4 +9,9 @@ export { withSkillExecutionSpan, type WithSkillExecutionSpanOptions, } from './t
 export { summarizeTokenUsage, recordUsageOnSpan, type TokenUsageSummary, } from './telemetry/usage-tracking.js';
 export { ACTION_TYPES, CONTROL_ACTIONS, categorizeAction, type ActionType, type ActionCategory, type ActionIntent, type DriftSeverity, type Approval, type ApprovalStatus, type AgentRuntimeState, type AgentStatus, type DriftHistoryEntry, type ActionLogEntry, type ActionOutcome, type NotificationMessage, type StateStore, type Notifier, } from './autopilot/types.js';
 export { evaluatePolicies, computeWindowDeltas, PolicyConfigSchema, PolicyRuleSchema, PolicyConditionSchema, type PolicyConfig, type PolicyRule, type PolicyCondition, type WindowDeltas, } from './autopilot/policy.js';
+export { MemoryStateStore } from './autopilot/memory-store.js';
+export { notifierForAction, safeNotify, notifyAll, type NotifierRegistry, type DispatchLogger, } from './autopilot/notify-dispatch.js';
+export { executeControlAction, type ControlActionContext, type ControlActionResult, } from './autopilot/actions.js';
+export { ApprovalService, type ApprovalDecision, type ApprovalServiceOptions, } from './autopilot/approval-service.js';
+export { AutopilotScheduler, type SchedulerLogger, type AutopilotSchedulerOptions, } from './autopilot/scheduler.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -15,4 +15,9 @@ export { summarizeTokenUsage, recordUsageOnSpan, } from './telemetry/usage-track
 // --- autopilot (Loop 2: drift-triggered remediation, pure decision layer) ---
 export { ACTION_TYPES, CONTROL_ACTIONS, categorizeAction, } from './autopilot/types.js';
 export { evaluatePolicies, computeWindowDeltas, PolicyConfigSchema, PolicyRuleSchema, PolicyConditionSchema, } from './autopilot/policy.js';
+export { MemoryStateStore } from './autopilot/memory-store.js';
+export { notifierForAction, safeNotify, notifyAll, } from './autopilot/notify-dispatch.js';
+export { executeControlAction, } from './autopilot/actions.js';
+export { ApprovalService, } from './autopilot/approval-service.js';
+export { AutopilotScheduler, } from './autopilot/scheduler.js';
 //# sourceMappingURL=index.js.map

package/dist/redis.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Subpath entry: `import { RedisStateStore } from '@driftwatch/sdk/redis'`.
+ * Isolated from the package root so core SDK consumers never pull in
+ * `ioredis` — only importers of this subpath need it installed (it's an
+ * optional peer dependency; see package.json).
+ */
+export { RedisStateStore } from './autopilot/redis-store.js';
+//# sourceMappingURL=redis.d.ts.map

package/dist/redis.js

@@ -0,0 +1,8 @@
+/**
+ * Subpath entry: `import { RedisStateStore } from '@driftwatch/sdk/redis'`.
+ * Isolated from the package root so core SDK consumers never pull in
+ * `ioredis` — only importers of this subpath need it installed (it's an
+ * optional peer dependency; see package.json).
+ */
+export { RedisStateStore } from './autopilot/redis-store.js';
+//# sourceMappingURL=redis.js.map

package/dist/telemetry/otel.d.ts

@@ -23,7 +23,7 @@
  * Logs: the bundled pino auto-instrumentation (enabled by default below) both
  * injects trace_id/span_id into every Fastify log line for trace<->log
  * correlation and emits those lines as OTel log records — which the
- * LogRecordProcessor registered here ships to SigNoz.
+ * LogRecordProcessor registered here sends to SigNoz.
  */
 import { NodeSDK } from '@opentelemetry/sdk-node';
 import type { TelemetryConfig } from '../config/schema.js';

package/dist/telemetry/otel.js

@@ -23,7 +23,7 @@
  * Logs: the bundled pino auto-instrumentation (enabled by default below) both
  * injects trace_id/span_id into every Fastify log line for trace<->log
  * correlation and emits those lines as OTel log records — which the
- * LogRecordProcessor registered here ships to SigNoz.
+ * LogRecordProcessor registered here sends to SigNoz.
  */
 import { NodeSDK } from '@opentelemetry/sdk-node';
 import { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node';

package/package.json

@@ -1,71 +1,84 @@
-{
-  "name": "@driftwatch/sdk",
-  "version": "0.2.1",
-  "description": "Self-observing AI agent SDK: OpenTelemetry instrumentation for AI SDK agents plus an LLM-over-traces behavioral drift detector. Bring your own model client — no provider SDKs bundled.",
-  "type": "module",
-  "license": "MIT",
-  "author": "Victory Lucky",
-  "homepage": "https://github.com/codewithveek/drift-watch#readme",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/codewithveek/drift-watch.git",
-    "directory": "packages/sdk"
-  },
-  "bugs": {
-    "url": "https://github.com/codewithveek/drift-watch/issues"
-  },
-  "keywords": [
-    "ai-agent",
-    "opentelemetry",
-    "observability",
-    "telemetry",
-    "drift-detection",
-    "ai-sdk",
-    "llm",
-    "vercel-ai-sdk",
-    "otel"
-  ],
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
-    }
-  },
-  "files": [
-    "dist",
-    "!dist/**/*.map"
-  ],
-  "publishConfig": {
-    "access": "public"
-  },
-  "engines": {
-    "node": ">=22"
-  },
-  "scripts": {
-    "build": "tsc",
-    "typecheck": "tsc --noEmit",
-    "test": "vitest run",
-    "prepublishOnly": "pnpm build && pnpm test"
-  },
-  "dependencies": {
-    "@opentelemetry/api": "^1.9.0",
-    "@opentelemetry/auto-instrumentations-node": "^0.78.0",
-    "@opentelemetry/exporter-logs-otlp-proto": "^0.220.0",
-    "@opentelemetry/exporter-metrics-otlp-proto": "^0.220.0",
-    "@opentelemetry/exporter-trace-otlp-proto": "^0.220.0",
-    "@opentelemetry/resources": "^2.9.0",
-    "@opentelemetry/sdk-logs": "^0.220.0",
-    "@opentelemetry/sdk-metrics": "^2.9.0",
-    "@opentelemetry/sdk-node": "^0.220.0",
-    "@opentelemetry/semantic-conventions": "^1.43.0",
-    "ai": "^7.0.31",
-    "zod": "^3.25.76"
-  },
-  "devDependencies": {
-    "@types/node": "^22.0.0",
-    "typescript": "^5.6.0",
-    "vitest": "^4.1.10"
-  }
-}
+{
+  "name": "@driftwatch/sdk",
+  "version": "0.4.0",
+  "description": "Self-observing AI agent SDK: OpenTelemetry instrumentation for AI SDK agents plus an LLM-over-traces behavioral drift detector. Bring your own model client — no provider SDKs bundled.",
+  "type": "module",
+  "license": "MIT",
+  "author": "Victory Lucky",
+  "homepage": "https://github.com/codewithveek/drift-watch#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/codewithveek/drift-watch.git",
+    "directory": "packages/sdk"
+  },
+  "bugs": {
+    "url": "https://github.com/codewithveek/drift-watch/issues"
+  },
+  "keywords": [
+    "ai-agent",
+    "opentelemetry",
+    "observability",
+    "telemetry",
+    "drift-detection",
+    "ai-sdk",
+    "llm",
+    "vercel-ai-sdk",
+    "otel"
+  ],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./redis": {
+      "types": "./dist/redis.d.ts",
+      "import": "./dist/redis.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!dist/**/*.map"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "dependencies": {
+    "@opentelemetry/api": "^1.9.0",
+    "@opentelemetry/auto-instrumentations-node": "^0.78.0",
+    "@opentelemetry/exporter-logs-otlp-proto": "^0.220.0",
+    "@opentelemetry/exporter-metrics-otlp-proto": "^0.220.0",
+    "@opentelemetry/exporter-trace-otlp-proto": "^0.220.0",
+    "@opentelemetry/resources": "^2.9.0",
+    "@opentelemetry/sdk-logs": "^0.220.0",
+    "@opentelemetry/sdk-metrics": "^2.9.0",
+    "@opentelemetry/sdk-node": "^0.220.0",
+    "@opentelemetry/semantic-conventions": "^1.43.0",
+    "ai": "^7.0.31",
+    "zod": "^3.25.76"
+  },
+  "peerDependencies": {
+    "ioredis": "^5.4.1"
+  },
+  "peerDependenciesMeta": {
+    "ioredis": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "ioredis": "^5.4.1",
+    "typescript": "^5.6.0",
+    "vitest": "^4.1.10"
+  },
+  "scripts": {
+    "build": "tsc",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  }
+}