opsveritas-sdk 0.3.4 → 0.4.1

package/dist/index.d.mts

@@ -13,6 +13,12 @@ interface TraceOptions {
 }
 declare function trace<T>(agentName: string, fn: () => Promise<T>, options?: TraceOptions): Promise<T>;
 
+declare class OpsVeritasKilledError extends Error {
+    agentName: string;
+    reason?: string | undefined;
+    constructor(agentName: string, reason?: string | undefined);
+}
+
 interface WrapOptions {
     agentName: string;
     platform?: string;
@@ -39,6 +45,34 @@ interface LangChainOptions {
     userId?: string;
 }
 declare function langchain(agentName: string, opts?: LangChainOptions): Record<string, unknown>;
+interface LangChainModel {
+    invoke?: (...args: unknown[]) => unknown;
+    ainvoke?: (...args: unknown[]) => Promise<unknown>;
+    stream?: (...args: unknown[]) => unknown;
+    astream?: (...args: unknown[]) => unknown;
+    batch?: (...args: unknown[]) => unknown;
+    [key: string]: unknown;
+}
+/**
+ * Kill-switch enforcement for LangChain models — ADDITIVE, does not replace
+ * `langchain()` above. `langchain()` is telemetry-only (a callback handler;
+ * LangChain's callback manager swallows exceptions raised inside callbacks by
+ * default, so it can never actually block a call). This patches the model's
+ * own `invoke`/`ainvoke`/`stream`/`astream`/`batch` directly — the same
+ * technique wrap() uses on raw provider clients — so a kill-switch check
+ * genuinely runs before the real API call happens.
+ *
+ *   const model = new ChatOpenAI({ callbacks: [opsveritas.langchain('My Agent')] }); // telemetry
+ *   opsveritas.wrapLangChain(model, { agentName: 'My Agent' });                      // enforcement
+ *
+ * `stream`/`astream` are gated at call-start only (check-then-call, same as
+ * invoke/ainvoke) — NOT mid-stream cancellation. If the kill switch fires
+ * after a stream has already started, that in-flight stream still completes;
+ * only the *next* call is blocked. This is a deliberate, simpler scope than
+ * killing a stream already in progress, and matches the same bounded-delay
+ * philosophy as the kill switch's poll interval.
+ */
+declare function wrapLangChain<T extends LangChainModel>(model: T, opts: WrapOptions): T;
 
 interface ExecutionPayload {
     platform: string;
@@ -66,6 +100,7 @@ declare const OpsVeritas: {
     trace: typeof trace;
     wrap: typeof wrap;
     langchain: typeof langchain;
+    wrapLangChain: typeof wrapLangChain;
 };
 
-export { type ExecutionPayload, type LangChainOptions, OpsVeritas, type TraceOptions, type WrapOptions, OpsVeritas as default, init, langchain, run, trace, wrap };
+export { type ExecutionPayload, type LangChainOptions, OpsVeritas, OpsVeritasKilledError, type TraceOptions, type WrapOptions, OpsVeritas as default, init, langchain, run, trace, wrap, wrapLangChain };

package/dist/index.d.ts

@@ -13,6 +13,12 @@ interface TraceOptions {
 }
 declare function trace<T>(agentName: string, fn: () => Promise<T>, options?: TraceOptions): Promise<T>;
 
+declare class OpsVeritasKilledError extends Error {
+    agentName: string;
+    reason?: string | undefined;
+    constructor(agentName: string, reason?: string | undefined);
+}
+
 interface WrapOptions {
     agentName: string;
     platform?: string;
@@ -39,6 +45,34 @@ interface LangChainOptions {
     userId?: string;
 }
 declare function langchain(agentName: string, opts?: LangChainOptions): Record<string, unknown>;
+interface LangChainModel {
+    invoke?: (...args: unknown[]) => unknown;
+    ainvoke?: (...args: unknown[]) => Promise<unknown>;
+    stream?: (...args: unknown[]) => unknown;
+    astream?: (...args: unknown[]) => unknown;
+    batch?: (...args: unknown[]) => unknown;
+    [key: string]: unknown;
+}
+/**
+ * Kill-switch enforcement for LangChain models — ADDITIVE, does not replace
+ * `langchain()` above. `langchain()` is telemetry-only (a callback handler;
+ * LangChain's callback manager swallows exceptions raised inside callbacks by
+ * default, so it can never actually block a call). This patches the model's
+ * own `invoke`/`ainvoke`/`stream`/`astream`/`batch` directly — the same
+ * technique wrap() uses on raw provider clients — so a kill-switch check
+ * genuinely runs before the real API call happens.
+ *
+ *   const model = new ChatOpenAI({ callbacks: [opsveritas.langchain('My Agent')] }); // telemetry
+ *   opsveritas.wrapLangChain(model, { agentName: 'My Agent' });                      // enforcement
+ *
+ * `stream`/`astream` are gated at call-start only (check-then-call, same as
+ * invoke/ainvoke) — NOT mid-stream cancellation. If the kill switch fires
+ * after a stream has already started, that in-flight stream still completes;
+ * only the *next* call is blocked. This is a deliberate, simpler scope than
+ * killing a stream already in progress, and matches the same bounded-delay
+ * philosophy as the kill switch's poll interval.
+ */
+declare function wrapLangChain<T extends LangChainModel>(model: T, opts: WrapOptions): T;
 
 interface ExecutionPayload {
     platform: string;
@@ -66,6 +100,7 @@ declare const OpsVeritas: {
     trace: typeof trace;
     wrap: typeof wrap;
     langchain: typeof langchain;
+    wrapLangChain: typeof wrapLangChain;
 };
 
-export { type ExecutionPayload, type LangChainOptions, OpsVeritas, type TraceOptions, type WrapOptions, OpsVeritas as default, init, langchain, run, trace, wrap };
+export { type ExecutionPayload, type LangChainOptions, OpsVeritas, OpsVeritasKilledError, type TraceOptions, type WrapOptions, OpsVeritas as default, init, langchain, run, trace, wrap, wrapLangChain };

package/dist/index.js

@@ -21,12 +21,14 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   OpsVeritas: () => OpsVeritas,
+  OpsVeritasKilledError: () => OpsVeritasKilledError,
   default: () => index_default,
   init: () => init,
   langchain: () => langchain,
   run: () => run,
   trace: () => trace,
-  wrap: () => wrap
+  wrap: () => wrap,
+  wrapLangChain: () => wrapLangChain
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -355,6 +357,53 @@ async function trace(agentName, fn, options) {
   return result;
 }
 
+// src/killSwitch.ts
+var POLL_INTERVAL_MS = 18e4;
+var OpsVeritasKilledError = class extends Error {
+  constructor(agentName, reason) {
+    super(`[OpsVeritas] Agent "${agentName}" is paused (kill switch: ${reason ?? "budget exceeded"}). Call opsveritas restart from the dashboard to resume.`);
+    this.agentName = agentName;
+    this.reason = reason;
+    this.name = "OpsVeritasKilledError";
+  }
+};
+var cache = /* @__PURE__ */ new Map();
+var polling = /* @__PURE__ */ new Set();
+async function poll(agentName, framework) {
+  let cfg;
+  try {
+    cfg = getConfig();
+  } catch {
+    return void 0;
+  }
+  const params = new URLSearchParams({ agent_name: agentName });
+  if (framework) params.set("framework", framework);
+  try {
+    const res = await fetch(`${cfg.endpoint}/webhooks/agent-budget-status?${params}`, {
+      headers: { "x-opsveritas-key": cfg.apiKey }
+    });
+    if (!res.ok) return void 0;
+    const data = await res.json();
+    cache.set(agentName, { killed: !!data.killed, reason: data.reason });
+    return data.kill_switch_enabled;
+  } catch {
+    return void 0;
+  }
+}
+function startPolling(agentName, framework) {
+  if (polling.has(agentName)) return;
+  polling.add(agentName);
+  void poll(agentName, framework).then((enabled) => {
+    if (enabled === false) return;
+    const timer = setInterval(() => void poll(agentName, framework), POLL_INTERVAL_MS);
+    const t = timer;
+    if (typeof t.unref === "function") t.unref();
+  });
+}
+function isKilled(agentName) {
+  return cache.get(agentName) ?? { killed: false };
+}
+
 // src/wrap.ts
 var PATCHED = /* @__PURE__ */ Symbol("opsveritas.patched");
 var OUTPUT_SUMMARY_MAX = 3e3;
@@ -395,7 +444,10 @@ function patchOpenAI(client, opts) {
   const completions = client.chat?.completions;
   if (!completions || completions[PATCHED]) return;
   const orig = completions.create.bind(completions);
+  startPolling(opts.agentName, "sdk");
   completions.create = async function(...args) {
+    const killState = isKilled(opts.agentName);
+    if (killState.killed) throw new OpsVeritasKilledError(opts.agentName, killState.reason);
     const executedAt = (/* @__PURE__ */ new Date()).toISOString();
     const t0 = Date.now();
     let status = "success";
@@ -446,7 +498,10 @@ function patchAnthropic(client, opts) {
   const messages = client.messages;
   if (!messages || messages[PATCHED]) return;
   const orig = messages.create.bind(messages);
+  startPolling(opts.agentName, "sdk");
   messages.create = async function(...args) {
+    const killState = isKilled(opts.agentName);
+    if (killState.killed) throw new OpsVeritasKilledError(opts.agentName, killState.reason);
     const executedAt = (/* @__PURE__ */ new Date()).toISOString();
     const t0 = Date.now();
     let status = "success";
@@ -495,7 +550,10 @@ function patchGemini(client, opts) {
   if (client[PATCHED]) return;
   const modelName = typeof client.model === "string" ? client.model.replace(/^models\//, "") : void 0;
   const orig = client.generateContent.bind(client);
+  startPolling(opts.agentName, "sdk");
   client.generateContent = async function(...args) {
+    const killState = isKilled(opts.agentName);
+    if (killState.killed) throw new OpsVeritasKilledError(opts.agentName, killState.reason);
     const executedAt = (/* @__PURE__ */ new Date()).toISOString();
     const t0 = Date.now();
     let status = "success";
@@ -555,6 +613,7 @@ function wrap(client, opts) {
 }
 
 // src/langchain.ts
+var LC_PATCHED = /* @__PURE__ */ Symbol("opsveritas.langchain.patched");
 function extractUsage2(output) {
   let model;
   let inputTokens;
@@ -658,16 +717,64 @@ function langchain(agentName, opts = {}) {
     }
   };
 }
+function wrapLangChain(model, opts) {
+  const m = model;
+  if (m[LC_PATCHED]) return model;
+  startPolling(opts.agentName, "sdk");
+  const guard = () => {
+    const killState = isKilled(opts.agentName);
+    if (killState.killed) throw new OpsVeritasKilledError(opts.agentName, killState.reason);
+  };
+  if (typeof m.invoke === "function") {
+    const origInvoke = m.invoke.bind(model);
+    m.invoke = function(...args) {
+      guard();
+      return origInvoke(...args);
+    };
+  }
+  if (typeof m.ainvoke === "function") {
+    const origAinvoke = m.ainvoke.bind(model);
+    m.ainvoke = async function(...args) {
+      guard();
+      return origAinvoke(...args);
+    };
+  }
+  if (typeof m.stream === "function") {
+    const origStream = m.stream.bind(model);
+    m.stream = function(...args) {
+      guard();
+      return origStream(...args);
+    };
+  }
+  if (typeof m.astream === "function") {
+    const origAstream = m.astream.bind(model);
+    m.astream = function(...args) {
+      guard();
+      return origAstream(...args);
+    };
+  }
+  if (typeof m.batch === "function") {
+    const origBatch = m.batch.bind(model);
+    m.batch = async function(...args) {
+      guard();
+      return origBatch(...args);
+    };
+  }
+  m[LC_PATCHED] = true;
+  return model;
+}
 
 // src/index.ts
-var OpsVeritas = { init, run, trace, wrap, langchain };
+var OpsVeritas = { init, run, trace, wrap, langchain, wrapLangChain };
 var index_default = OpsVeritas;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   OpsVeritas,
+  OpsVeritasKilledError,
   init,
   langchain,
   run,
   trace,
-  wrap
+  wrap,
+  wrapLangChain
 });

package/dist/index.mjs

@@ -323,6 +323,53 @@ async function trace(agentName, fn, options) {
   return result;
 }
 
+// src/killSwitch.ts
+var POLL_INTERVAL_MS = 18e4;
+var OpsVeritasKilledError = class extends Error {
+  constructor(agentName, reason) {
+    super(`[OpsVeritas] Agent "${agentName}" is paused (kill switch: ${reason ?? "budget exceeded"}). Call opsveritas restart from the dashboard to resume.`);
+    this.agentName = agentName;
+    this.reason = reason;
+    this.name = "OpsVeritasKilledError";
+  }
+};
+var cache = /* @__PURE__ */ new Map();
+var polling = /* @__PURE__ */ new Set();
+async function poll(agentName, framework) {
+  let cfg;
+  try {
+    cfg = getConfig();
+  } catch {
+    return void 0;
+  }
+  const params = new URLSearchParams({ agent_name: agentName });
+  if (framework) params.set("framework", framework);
+  try {
+    const res = await fetch(`${cfg.endpoint}/webhooks/agent-budget-status?${params}`, {
+      headers: { "x-opsveritas-key": cfg.apiKey }
+    });
+    if (!res.ok) return void 0;
+    const data = await res.json();
+    cache.set(agentName, { killed: !!data.killed, reason: data.reason });
+    return data.kill_switch_enabled;
+  } catch {
+    return void 0;
+  }
+}
+function startPolling(agentName, framework) {
+  if (polling.has(agentName)) return;
+  polling.add(agentName);
+  void poll(agentName, framework).then((enabled) => {
+    if (enabled === false) return;
+    const timer = setInterval(() => void poll(agentName, framework), POLL_INTERVAL_MS);
+    const t = timer;
+    if (typeof t.unref === "function") t.unref();
+  });
+}
+function isKilled(agentName) {
+  return cache.get(agentName) ?? { killed: false };
+}
+
 // src/wrap.ts
 var PATCHED = /* @__PURE__ */ Symbol("opsveritas.patched");
 var OUTPUT_SUMMARY_MAX = 3e3;
@@ -363,7 +410,10 @@ function patchOpenAI(client, opts) {
   const completions = client.chat?.completions;
   if (!completions || completions[PATCHED]) return;
   const orig = completions.create.bind(completions);
+  startPolling(opts.agentName, "sdk");
   completions.create = async function(...args) {
+    const killState = isKilled(opts.agentName);
+    if (killState.killed) throw new OpsVeritasKilledError(opts.agentName, killState.reason);
     const executedAt = (/* @__PURE__ */ new Date()).toISOString();
     const t0 = Date.now();
     let status = "success";
@@ -414,7 +464,10 @@ function patchAnthropic(client, opts) {
   const messages = client.messages;
   if (!messages || messages[PATCHED]) return;
   const orig = messages.create.bind(messages);
+  startPolling(opts.agentName, "sdk");
   messages.create = async function(...args) {
+    const killState = isKilled(opts.agentName);
+    if (killState.killed) throw new OpsVeritasKilledError(opts.agentName, killState.reason);
     const executedAt = (/* @__PURE__ */ new Date()).toISOString();
     const t0 = Date.now();
     let status = "success";
@@ -463,7 +516,10 @@ function patchGemini(client, opts) {
   if (client[PATCHED]) return;
   const modelName = typeof client.model === "string" ? client.model.replace(/^models\//, "") : void 0;
   const orig = client.generateContent.bind(client);
+  startPolling(opts.agentName, "sdk");
   client.generateContent = async function(...args) {
+    const killState = isKilled(opts.agentName);
+    if (killState.killed) throw new OpsVeritasKilledError(opts.agentName, killState.reason);
     const executedAt = (/* @__PURE__ */ new Date()).toISOString();
     const t0 = Date.now();
     let status = "success";
@@ -523,6 +579,7 @@ function wrap(client, opts) {
 }
 
 // src/langchain.ts
+var LC_PATCHED = /* @__PURE__ */ Symbol("opsveritas.langchain.patched");
 function extractUsage2(output) {
   let model;
   let inputTokens;
@@ -626,16 +683,64 @@ function langchain(agentName, opts = {}) {
     }
   };
 }
+function wrapLangChain(model, opts) {
+  const m = model;
+  if (m[LC_PATCHED]) return model;
+  startPolling(opts.agentName, "sdk");
+  const guard = () => {
+    const killState = isKilled(opts.agentName);
+    if (killState.killed) throw new OpsVeritasKilledError(opts.agentName, killState.reason);
+  };
+  if (typeof m.invoke === "function") {
+    const origInvoke = m.invoke.bind(model);
+    m.invoke = function(...args) {
+      guard();
+      return origInvoke(...args);
+    };
+  }
+  if (typeof m.ainvoke === "function") {
+    const origAinvoke = m.ainvoke.bind(model);
+    m.ainvoke = async function(...args) {
+      guard();
+      return origAinvoke(...args);
+    };
+  }
+  if (typeof m.stream === "function") {
+    const origStream = m.stream.bind(model);
+    m.stream = function(...args) {
+      guard();
+      return origStream(...args);
+    };
+  }
+  if (typeof m.astream === "function") {
+    const origAstream = m.astream.bind(model);
+    m.astream = function(...args) {
+      guard();
+      return origAstream(...args);
+    };
+  }
+  if (typeof m.batch === "function") {
+    const origBatch = m.batch.bind(model);
+    m.batch = async function(...args) {
+      guard();
+      return origBatch(...args);
+    };
+  }
+  m[LC_PATCHED] = true;
+  return model;
+}
 
 // src/index.ts
-var OpsVeritas = { init, run, trace, wrap, langchain };
+var OpsVeritas = { init, run, trace, wrap, langchain, wrapLangChain };
 var index_default = OpsVeritas;
 export {
   OpsVeritas,
+  OpsVeritasKilledError,
   index_default as default,
   init,
   langchain,
   run,
   trace,
-  wrap
+  wrap,
+  wrapLangChain
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opsveritas-sdk",
-  "version": "0.3.4",
+  "version": "0.4.1",
   "description": "Monitor your AI agents in 3 lines of code — tokens, cost, latency, and silent failures",
   "main": "dist/index.js",
   "module": "dist/index.mjs",