@vericto/sdk 0.0.0-stage → 0.2.0

package/dist/index.d.ts

@@ -0,0 +1,76 @@
+import { a as Verdict, F as Finding } from './guard-BVpq8ytG.js';
+export { C as CONFIG_PATH, D as DEFAULT_API_URL, b as Decision, E as EVALUATE_PATH, c as Evaluator, d as FailMode, R as RuntimeApiEvaluator, e as RuntimeApiOptions, V as Vericto, f as VerictoLogger, g as VerictoOptions, i as isMasked, s as sqlToExecute, v as verdictFromResponse } from './guard-BVpq8ytG.js';
+
+/**
+ * Dialects the Vericto engine evaluates (`sqlite` since vericto-engine 4.1.0). The
+ * wrappers still ask the server (`GET /api/v1/meta/config`) and refuse a dialect it
+ * does not list.
+ */
+declare const KNOWN_DIALECTS: readonly ["postgres", "mysql", "oracle", "mssql", "snowflake", "sqlite"];
+/**
+ * Map a driver name to the Vericto dialect id. Unknown names pass through
+ * lower-cased: the server decides, and answers with a clear error.
+ */
+declare function normalizeDialect(name: string): string;
+
+/** Base class of every error this package throws. */
+declare class VerictoError extends Error {
+    constructor(message: string);
+}
+/**
+ * The client is misconfigured: missing or rejected API key, bad database id, a key
+ * without the `proxy:evaluate` scope, or a malformed request. Thrown whatever the
+ * fail mode is: failing open on a revoked key would switch the firewall off silently.
+ */
+declare class VerictoConfigError extends VerictoError {
+    readonly status: number | undefined;
+    readonly code: string | undefined;
+    constructor(message: string, options?: {
+        status?: number;
+        code?: string;
+    });
+}
+/**
+ * The Vericto server does not evaluate this dialect (it is missing from
+ * `GET /api/v1/meta/config`, e.g. `sqlite` on a server older than vericto-engine
+ * 4.1.0). No SQL was executed.
+ */
+declare class VerictoUnsupportedDialectError extends VerictoConfigError {
+    readonly dialect: string;
+    readonly supported: readonly string[];
+    constructor(dialect: string, supported: readonly string[], apiUrl: string);
+}
+/**
+ * Vericto could not return a verdict after the configured retries. With
+ * `failMode: 'closed'` (the default) the statement is not executed and this is thrown.
+ */
+declare class VerictoUnavailableError extends VerictoError {
+    readonly status: number | undefined;
+    readonly code: string | undefined;
+    constructor(message: string, options?: {
+        status?: number;
+        code?: string;
+    });
+}
+/** The workspace used its monthly query quota (HTTP 429 `QUOTA_EXCEEDED`). Not retried. */
+declare class VerictoQuotaExceededError extends VerictoUnavailableError {
+    readonly resetsAt: string | undefined;
+    readonly upgradeUrl: string | undefined;
+    constructor(message: string, options?: {
+        resetsAt?: string;
+        upgradeUrl?: string;
+    });
+}
+/** Vericto blocked the statement. It was not executed. */
+declare class VerictoBlockedError extends VerictoError {
+    readonly verdict: Verdict;
+    readonly sql: string;
+    constructor(verdict: Verdict, sql: string);
+    get findings(): readonly Finding[];
+    get suggestedFix(): string | undefined;
+}
+
+/** The package version (kept in sync with package.json by a test). */
+declare const VERSION = "0.2.0";
+
+export { Finding, KNOWN_DIALECTS, VERSION, Verdict, VerictoBlockedError, VerictoConfigError, VerictoError, VerictoQuotaExceededError, VerictoUnavailableError, VerictoUnsupportedDialectError, normalizeDialect };

package/dist/index.js

@@ -0,0 +1,3 @@
+export { CONFIG_PATH, DEFAULT_API_URL, EVALUATE_PATH, KNOWN_DIALECTS, RuntimeApiEvaluator, VERSION, Vericto, VerictoBlockedError, VerictoConfigError, VerictoError, VerictoQuotaExceededError, VerictoUnavailableError, VerictoUnsupportedDialectError, isMasked, normalizeDialect, sqlToExecute, verdictFromResponse } from './chunk-I4I35HUY.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/langchain.cjs

@@ -0,0 +1,195 @@
+'use strict';
+
+var chunkHFL7W4WC_cjs = require('./chunk-HFL7W4WC.cjs');
+var sql$1 = require('@langchain/classic/agents/toolkits/sql');
+var sql_db = require('@langchain/classic/sql_db');
+var sql = require('@langchain/classic/tools/sql');
+var tools = require('@langchain/core/tools');
+
+var TYPEORM_DIALECTS = {
+  postgres: "postgres",
+  "aurora-postgres": "postgres",
+  mysql: "mysql",
+  mariadb: "mysql",
+  "aurora-mysql": "mysql",
+  mssql: "mssql",
+  oracle: "oracle",
+  sqlite: "sqlite",
+  "better-sqlite3": "sqlite",
+  sqljs: "sqlite"
+};
+function dialectFromDataSource(dataSource) {
+  const type = dataSource.options.type;
+  const dialect = TYPEORM_DIALECTS[type];
+  if (!dialect) {
+    throw new chunkHFL7W4WC_cjs.VerictoConfigError(
+      `vericto: no Vericto dialect for the TypeORM type '${type}'. Supported: ${Object.keys(TYPEORM_DIALECTS).join(", ")}; or pass { dialect }.`
+    );
+  }
+  return dialect;
+}
+function guardDataSource(dataSource, vericto, dialect) {
+  const name = chunkHFL7W4WC_cjs.normalizeDialect(dialect);
+  const query = async (sql, parameters, ...rest) => {
+    const final = await vericto.prepare(sql, name);
+    return dataSource.query.call(dataSource, final, parameters, ...rest);
+  };
+  return new Proxy(dataSource, {
+    get(target, prop) {
+      if (prop === "query") return query;
+      const value = Reflect.get(target, prop, target);
+      return typeof value === "function" ? value.bind(target) : value;
+    }
+  });
+}
+function blockedMessage(verdict) {
+  const lines = ["Vericto blocked this SQL query; it was NOT executed."];
+  const rule = verdict.ruleCode ?? "a Vericto rule";
+  lines.push(`Rule: ${rule}${verdict.severity ? ` (severity ${verdict.severity})` : ""}`);
+  if (verdict.message) lines.push(`Reason: ${verdict.message}`);
+  const denied = verdict.accessDenied.length ? JSON.stringify(verdict.accessDenied) : void 0;
+  if (denied) lines.push(`Access denied: ${denied}`);
+  if (verdict.suggestedFix) {
+    lines.push(`Suggested fix: ${verdict.suggestedFix}`);
+    lines.push("Use the suggested fix, or rewrite the query so that it complies with the rule, and try again.");
+  } else {
+    lines.push("Rewrite the query so that it complies with the rule, and try again. Do not retry the same query.");
+  }
+  return lines.join("\n");
+}
+function describeVerdict(verdict) {
+  if (verdict.decision === "BLOCKED") return blockedMessage(verdict).replace("; it was NOT executed.", ".");
+  const rule = verdict.ruleCode ? ` by ${verdict.ruleCode}${verdict.severity ? ` (severity ${verdict.severity})` : ""}` : "";
+  let text;
+  switch (verdict.decision) {
+    case "FLAGGED":
+      text = `Vericto: FLAGGED${rule}. The query is allowed to run, but it was reported.`;
+      break;
+    case "MONITORED":
+      text = `Vericto: MONITORED${rule}. The query is allowed to run.`;
+      break;
+    case "PARSE_ERROR":
+      text = `Vericto could not parse the query${verdict.parseError ? ` (${verdict.parseError})` : ""}; the workspace policy allows it to run.`;
+      break;
+    default:
+      text = "Vericto: ALLOWED. The query can run.";
+  }
+  if (chunkHFL7W4WC_cjs.isMasked(verdict)) {
+    text += `
+It reads sensitive columns, so it will run masked, as: ${chunkHFL7W4WC_cjs.sqlToExecute(verdict)}`;
+  }
+  return text;
+}
+function checkOnBlock(onBlock) {
+  const value = onBlock ?? "return";
+  if (value !== "return" && value !== "raise") {
+    throw new chunkHFL7W4WC_cjs.VerictoConfigError(`onBlock must be 'return' or 'raise', got ${JSON.stringify(value)}.`);
+  }
+  return value;
+}
+var VerictoSqlDatabase = class _VerictoSqlDatabase extends sql_db.SqlDatabase {
+  vericto;
+  dialect;
+  onBlock;
+  /** The unguarded data source: SQL run through it directly is not checked. */
+  rawDataSource;
+  constructor(fields) {
+    super(fields);
+    this.vericto = fields.vericto;
+    this.dialect = fields.dialect;
+    this.onBlock = checkOnBlock(fields.onBlock);
+    this.rawDataSource = fields.appDataSource;
+    this.appDataSource = guardDataSource(fields.appDataSource, this.vericto, this.dialect);
+  }
+  /**
+   * Same as `SqlDatabase.fromDataSourceParams`, plus the Vericto options. Fails fast
+   * when the server does not evaluate the dialect. LangChain's own schema
+   * introspection (the column catalogue read here) runs on the raw data source.
+   */
+  static async fromDataSourceParams(fields) {
+    const vericto = fields.vericto ?? new chunkHFL7W4WC_cjs.Vericto();
+    const dialect = await vericto.requireDialect(fields.dialect ?? dialectFromDataSource(fields.appDataSource));
+    checkOnBlock(fields.onBlock);
+    const base = await sql_db.SqlDatabase.fromDataSourceParams(fields);
+    const db = new _VerictoSqlDatabase({ ...fields, vericto, dialect });
+    db.allTables = base.allTables;
+    db.customDescription = base.customDescription;
+    return db;
+  }
+  /** Same as `SqlDatabase.fromOptionsParams`, plus the Vericto options. */
+  static async fromOptionsParams(fields) {
+    const { DataSource } = await sql_db.SqlDatabase.imports();
+    const { appDataSourceOptions, ...rest } = fields;
+    return _VerictoSqlDatabase.fromDataSourceParams({ ...rest, appDataSource: new DataSource(appDataSourceOptions) });
+  }
+  /**
+   * Run `command` after Vericto checks it. Blocked: returns {@link blockedMessage}
+   * (or throws `VerictoBlockedError` with `onBlock: 'raise'`). Masked: runs the
+   * rewrite. Vericto unavailable or misconfigured: throws.
+   */
+  async run(command, fetch = "all") {
+    try {
+      return await super.run(command, fetch);
+    } catch (err) {
+      if (err instanceof chunkHFL7W4WC_cjs.VerictoBlockedError && this.onBlock === "return") return blockedMessage(err.verdict);
+      throw err;
+    }
+  }
+};
+var VerictoQuerySqlTool = class extends sql.QuerySqlTool {
+  static lc_name() {
+    return "VerictoQuerySqlTool";
+  }
+  /** @ignore */
+  async _call(input) {
+    try {
+      return await this.db.run(input);
+    } catch (err) {
+      if (err instanceof chunkHFL7W4WC_cjs.VerictoError) throw err;
+      return String(err);
+    }
+  }
+};
+var VerictoSqlToolkit = class extends sql$1.SqlToolkit {
+  constructor(db, llm) {
+    super(db, llm);
+    this.tools = this.tools.map((tool) => tool instanceof sql.QuerySqlTool ? new VerictoQuerySqlTool(db) : tool);
+    this.dialect = db.dialect;
+  }
+};
+var VerictoCheckSqlTool = class extends tools.Tool {
+  static lc_name() {
+    return "VerictoCheckSqlTool";
+  }
+  name = "vericto-check-sql";
+  description = "Input is one SQL query. Checks it with the Vericto SQL firewall without running it and returns the verdict: ALLOWED, FLAGGED, MONITORED, or BLOCKED with the rule and a suggested fix. Use it before running a query; if it is blocked, fix the query and check again.";
+  vericto;
+  dialect;
+  onBlock;
+  constructor(options = {}) {
+    super();
+    const vericto = options.vericto ?? options.db?.vericto;
+    const dialect = options.dialect ?? options.db?.dialect;
+    if (!dialect) throw new chunkHFL7W4WC_cjs.VerictoConfigError("VerictoCheckSqlTool needs { dialect } or { db }.");
+    this.vericto = vericto ?? new chunkHFL7W4WC_cjs.Vericto();
+    this.dialect = chunkHFL7W4WC_cjs.normalizeDialect(dialect);
+    this.onBlock = checkOnBlock(options.onBlock ?? options.db?.onBlock);
+  }
+  /** @ignore */
+  async _call(input) {
+    const verdict = await this.vericto.check(input, this.dialect);
+    if (verdict.decision === "BLOCKED" && this.onBlock === "raise") throw new chunkHFL7W4WC_cjs.VerictoBlockedError(verdict, input);
+    return describeVerdict(verdict);
+  }
+};
+
+exports.VerictoCheckSqlTool = VerictoCheckSqlTool;
+exports.VerictoQuerySqlTool = VerictoQuerySqlTool;
+exports.VerictoSqlDatabase = VerictoSqlDatabase;
+exports.VerictoSqlToolkit = VerictoSqlToolkit;
+exports.blockedMessage = blockedMessage;
+exports.describeVerdict = describeVerdict;
+exports.dialectFromDataSource = dialectFromDataSource;
+exports.guardDataSource = guardDataSource;
+//# sourceMappingURL=langchain.cjs.map
+//# sourceMappingURL=langchain.cjs.map

package/dist/langchain.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/langchain.ts"],"names":["VerictoConfigError","normalizeDialect","isMasked","sqlToExecute","SqlDatabase","Vericto","VerictoBlockedError","QuerySqlTool","VerictoError","SqlToolkit","Tool"],"mappings":"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","file":"langchain.cjs","sourcesContent":["/**\n * Vericto for LangChain.js SQL agents and chains (`@langchain/classic`).\n *\n * ```ts\n * import { DataSource } from 'typeorm';\n * import { VerictoSqlDatabase, VerictoSqlToolkit } from '@vericto/sdk/langchain';\n * import { createSqlAgent } from '@langchain/classic/agents/toolkits/sql';\n *\n * const db = await VerictoSqlDatabase.fromDataSourceParams({\n *   appDataSource: new DataSource({ type: 'postgres', url: process.env.DATABASE_URL }),\n * });\n * const agent = createSqlAgent(llm, new VerictoSqlToolkit(db, llm));\n * ```\n *\n * Every statement LangChain sends through the database's TypeORM `DataSource` is\n * checked: the agent's queries (`run`, `QuerySqlTool`), the sample rows of\n * `getTableInfo`, and `SqlDatabaseChain`'s generated SQL. A blocked query is\n * answered with a message the model can act on (rule, reason, suggested fix)\n * instead of an exception, unless `onBlock: 'raise'`. Masked queries run as the\n * rewrite. Vericto being unavailable or misconfigured is never turned into a message\n * for the model: it propagates, so the fail mode stays in charge.\n *\n * Requires the optional peers `@langchain/classic`, `@langchain/core` and `typeorm`.\n */\nimport { SqlToolkit } from '@langchain/classic/agents/toolkits/sql';\nimport { SqlDatabase, type SqlDatabaseDataSourceParams } from '@langchain/classic/sql_db';\nimport { QuerySqlTool } from '@langchain/classic/tools/sql';\nimport type { BaseLanguageModelInterface } from '@langchain/core/language_models/base';\nimport { Tool } from '@langchain/core/tools';\nimport type { DataSource } from 'typeorm';\n\nimport { normalizeDialect } from './dialects.js';\nimport { VerictoBlockedError, VerictoConfigError, VerictoError } from './errors.js';\nimport { Vericto } from './guard.js';\nimport { isMasked, sqlToExecute, type Verdict } from './verdict.js';\n\n/** What a blocked query does: `return` a message for the model (default), or `raise`. */\nexport type OnBlock = 'return' | 'raise';\n\nexport interface VerictoLangChainOptions {\n  /** The guard. Default: one built from the `VERICTO_*` environment variables. */\n  vericto?: Vericto;\n  /** The Vericto dialect. Default: read from the TypeORM `DataSource` type. */\n  dialect?: string;\n  /** Default `return`. */\n  onBlock?: OnBlock;\n}\n\nexport type VerictoSqlDatabaseParams = SqlDatabaseDataSourceParams & VerictoLangChainOptions;\n\nconst TYPEORM_DIALECTS: Readonly<Record<string, string>> = {\n  postgres: 'postgres',\n  'aurora-postgres': 'postgres',\n  mysql: 'mysql',\n  mariadb: 'mysql',\n  'aurora-mysql': 'mysql',\n  mssql: 'mssql',\n  oracle: 'oracle',\n  sqlite: 'sqlite',\n  'better-sqlite3': 'sqlite',\n  sqljs: 'sqlite',\n};\n\n/**\n * The Vericto dialect of a TypeORM `DataSource` type. Types Vericto does not\n * evaluate (cockroachdb, sap, spanner, mongodb...) throw `VerictoConfigError`: pass\n * `dialect` explicitly if you know what you are doing.\n */\nexport function dialectFromDataSource(dataSource: Pick<DataSource, 'options'>): string {\n  const type: string = dataSource.options.type;\n  const dialect = TYPEORM_DIALECTS[type];\n  if (!dialect) {\n    throw new VerictoConfigError(\n      `vericto: no Vericto dialect for the TypeORM type '${type}'. ` +\n        `Supported: ${Object.keys(TYPEORM_DIALECTS).join(', ')}; or pass { dialect }.`,\n    );\n  }\n  return dialect;\n}\n\n/**\n * A `DataSource` whose `query()` is checked by Vericto first (and runs the masked\n * rewrite). Everything else is the original data source's.\n */\nexport function guardDataSource(dataSource: DataSource, vericto: Vericto, dialect: string): DataSource {\n  const name = normalizeDialect(dialect);\n  const query = async (sql: string, parameters?: unknown[], ...rest: unknown[]): Promise<unknown> => {\n    const final = await vericto.prepare(sql, name);\n    return (dataSource.query as (...args: unknown[]) => Promise<unknown>).call(dataSource, final, parameters, ...rest);\n  };\n  return new Proxy(dataSource, {\n    get(target, prop) {\n      if (prop === 'query') return query;\n      const value: unknown = Reflect.get(target, prop, target);\n      return typeof value === 'function' ? (value as (...a: unknown[]) => unknown).bind(target) : value;\n    },\n  });\n}\n\n/** The message a model gets for a blocked query: what was blocked, why, and the fix. */\nexport function blockedMessage(verdict: Verdict): string {\n  const lines = ['Vericto blocked this SQL query; it was NOT executed.'];\n  const rule = verdict.ruleCode ?? 'a Vericto rule';\n  lines.push(`Rule: ${rule}${verdict.severity ? ` (severity ${verdict.severity})` : ''}`);\n  if (verdict.message) lines.push(`Reason: ${verdict.message}`);\n  const denied = verdict.accessDenied.length ? JSON.stringify(verdict.accessDenied) : undefined;\n  if (denied) lines.push(`Access denied: ${denied}`);\n  if (verdict.suggestedFix) {\n    lines.push(`Suggested fix: ${verdict.suggestedFix}`);\n    lines.push('Use the suggested fix, or rewrite the query so that it complies with the rule, and try again.');\n  } else {\n    lines.push('Rewrite the query so that it complies with the rule, and try again. Do not retry the same query.');\n  }\n  return lines.join('\\n');\n}\n\n/** A readable verdict for the check tool. */\nexport function describeVerdict(verdict: Verdict): string {\n  if (verdict.decision === 'BLOCKED') return blockedMessage(verdict).replace('; it was NOT executed.', '.');\n  const rule = verdict.ruleCode ? ` by ${verdict.ruleCode}${verdict.severity ? ` (severity ${verdict.severity})` : ''}` : '';\n  let text: string;\n  switch (verdict.decision) {\n    case 'FLAGGED':\n      text = `Vericto: FLAGGED${rule}. The query is allowed to run, but it was reported.`;\n      break;\n    case 'MONITORED':\n      text = `Vericto: MONITORED${rule}. The query is allowed to run.`;\n      break;\n    case 'PARSE_ERROR':\n      text = `Vericto could not parse the query${verdict.parseError ? ` (${verdict.parseError})` : ''}; the workspace policy allows it to run.`;\n      break;\n    default:\n      text = 'Vericto: ALLOWED. The query can run.';\n  }\n  if (isMasked(verdict)) {\n    text += `\\nIt reads sensitive columns, so it will run masked, as: ${sqlToExecute(verdict)}`;\n  }\n  return text;\n}\n\nfunction checkOnBlock(onBlock: OnBlock | undefined): OnBlock {\n  // Checked at run time too: plain-JS callers get no type error.\n  const value: string = onBlock ?? 'return';\n  if (value !== 'return' && value !== 'raise') {\n    throw new VerictoConfigError(`onBlock must be 'return' or 'raise', got ${JSON.stringify(value)}.`);\n  }\n  return value;\n}\n\n/**\n * A LangChain `SqlDatabase` whose statements are checked by Vericto. Accepted\n * wherever a `SqlDatabase` is: `QuerySqlTool`, `SqlToolkit`/`createSqlAgent`,\n * `SqlDatabaseChain`.\n */\nexport class VerictoSqlDatabase extends SqlDatabase {\n  readonly vericto: Vericto;\n  readonly dialect: string;\n  readonly onBlock: OnBlock;\n  /** The unguarded data source: SQL run through it directly is not checked. */\n  readonly rawDataSource: DataSource;\n\n  protected constructor(fields: VerictoSqlDatabaseParams & { vericto: Vericto; dialect: string }) {\n    super(fields);\n    this.vericto = fields.vericto;\n    this.dialect = fields.dialect;\n    this.onBlock = checkOnBlock(fields.onBlock);\n    this.rawDataSource = fields.appDataSource;\n    this.appDataSource = guardDataSource(fields.appDataSource, this.vericto, this.dialect);\n  }\n\n  /**\n   * Same as `SqlDatabase.fromDataSourceParams`, plus the Vericto options. Fails fast\n   * when the server does not evaluate the dialect. LangChain's own schema\n   * introspection (the column catalogue read here) runs on the raw data source.\n   */\n  static override async fromDataSourceParams(fields: VerictoSqlDatabaseParams): Promise<VerictoSqlDatabase> {\n    const vericto = fields.vericto ?? new Vericto();\n    const dialect = await vericto.requireDialect(fields.dialect ?? dialectFromDataSource(fields.appDataSource));\n    checkOnBlock(fields.onBlock);\n    const base = await SqlDatabase.fromDataSourceParams(fields);\n    const db = new VerictoSqlDatabase({ ...fields, vericto, dialect });\n    db.allTables = base.allTables;\n    db.customDescription = base.customDescription;\n    return db;\n  }\n\n  /** Same as `SqlDatabase.fromOptionsParams`, plus the Vericto options. */\n  static override async fromOptionsParams(\n    fields: Parameters<typeof SqlDatabase.fromOptionsParams>[0] & VerictoLangChainOptions,\n  ): Promise<VerictoSqlDatabase> {\n    const { DataSource } = await SqlDatabase.imports();\n    const { appDataSourceOptions, ...rest } = fields;\n    return VerictoSqlDatabase.fromDataSourceParams({ ...rest, appDataSource: new DataSource(appDataSourceOptions) });\n  }\n\n  /**\n   * Run `command` after Vericto checks it. Blocked: returns {@link blockedMessage}\n   * (or throws `VerictoBlockedError` with `onBlock: 'raise'`). Masked: runs the\n   * rewrite. Vericto unavailable or misconfigured: throws.\n   */\n  override async run(command: string, fetch: 'all' | 'one' = 'all'): Promise<string> {\n    try {\n      return await super.run(command, fetch);\n    } catch (err) {\n      if (err instanceof VerictoBlockedError && this.onBlock === 'return') return blockedMessage(err.verdict);\n      throw err;\n    }\n  }\n}\n\n/**\n * `QuerySqlTool` that lets Vericto errors through. The stock tool turns every error\n * into text for the model, which would also hide \"Vericto unavailable\" (and, with\n * `onBlock: 'raise'`, the block) from your code.\n */\nexport class VerictoQuerySqlTool extends QuerySqlTool {\n  static override lc_name(): string {\n    return 'VerictoQuerySqlTool';\n  }\n\n  /** @ignore */\n  override async _call(input: string): Promise<string> {\n    try {\n      return await this.db.run(input);\n    } catch (err) {\n      if (err instanceof VerictoError) throw err;\n      return String(err);\n    }\n  }\n}\n\n/** `SqlToolkit` with {@link VerictoQuerySqlTool} and the Vericto dialect in the prompt. */\nexport class VerictoSqlToolkit extends SqlToolkit {\n  constructor(db: VerictoSqlDatabase, llm: BaseLanguageModelInterface) {\n    super(db, llm);\n    this.tools = this.tools.map((tool) => (tool instanceof QuerySqlTool ? new VerictoQuerySqlTool(db) : tool));\n    this.dialect = db.dialect;\n  }\n}\n\nexport interface VerictoCheckSqlToolOptions extends VerictoLangChainOptions {\n  /** Take the guard, dialect and onBlock from this database. */\n  db?: VerictoSqlDatabase;\n}\n\n/**\n * A tool that only checks a query (nothing is executed) and answers with Vericto's\n * verdict, so an agent can validate SQL before it proposes or runs it. Each check is\n * a Runtime API evaluation (it counts against the runtime quota and is audited).\n */\nexport class VerictoCheckSqlTool extends Tool {\n  static override lc_name(): string {\n    return 'VerictoCheckSqlTool';\n  }\n\n  name = 'vericto-check-sql';\n  description =\n    'Input is one SQL query. Checks it with the Vericto SQL firewall without running it and returns the ' +\n    'verdict: ALLOWED, FLAGGED, MONITORED, or BLOCKED with the rule and a suggested fix. ' +\n    'Use it before running a query; if it is blocked, fix the query and check again.';\n\n  readonly vericto: Vericto;\n  readonly dialect: string;\n  readonly onBlock: OnBlock;\n\n  constructor(options: VerictoCheckSqlToolOptions = {}) {\n    super();\n    const vericto = options.vericto ?? options.db?.vericto;\n    const dialect = options.dialect ?? options.db?.dialect;\n    if (!dialect) throw new VerictoConfigError('VerictoCheckSqlTool needs { dialect } or { db }.');\n    this.vericto = vericto ?? new Vericto();\n    this.dialect = normalizeDialect(dialect);\n    this.onBlock = checkOnBlock(options.onBlock ?? options.db?.onBlock);\n  }\n\n  /** @ignore */\n  async _call(input: string): Promise<string> {\n    const verdict = await this.vericto.check(input, this.dialect);\n    if (verdict.decision === 'BLOCKED' && this.onBlock === 'raise') throw new VerictoBlockedError(verdict, input);\n    return describeVerdict(verdict);\n  }\n}\n"]}

package/dist/langchain.d.cts

@@ -0,0 +1,126 @@
+import { SqlToolkit } from '@langchain/classic/agents/toolkits/sql';
+import { SqlDatabase, SqlDatabaseDataSourceParams } from '@langchain/classic/sql_db';
+import { QuerySqlTool } from '@langchain/classic/tools/sql';
+import { BaseLanguageModelInterface } from '@langchain/core/language_models/base';
+import { Tool } from '@langchain/core/tools';
+import { DataSource } from 'typeorm';
+import { Vericto, Verdict } from './index.cjs';
+
+/**
+ * Vericto for LangChain.js SQL agents and chains (`@langchain/classic`).
+ *
+ * ```ts
+ * import { DataSource } from 'typeorm';
+ * import { VerictoSqlDatabase, VerictoSqlToolkit } from '@vericto/sdk/langchain';
+ * import { createSqlAgent } from '@langchain/classic/agents/toolkits/sql';
+ *
+ * const db = await VerictoSqlDatabase.fromDataSourceParams({
+ *   appDataSource: new DataSource({ type: 'postgres', url: process.env.DATABASE_URL }),
+ * });
+ * const agent = createSqlAgent(llm, new VerictoSqlToolkit(db, llm));
+ * ```
+ *
+ * Every statement LangChain sends through the database's TypeORM `DataSource` is
+ * checked: the agent's queries (`run`, `QuerySqlTool`), the sample rows of
+ * `getTableInfo`, and `SqlDatabaseChain`'s generated SQL. A blocked query is
+ * answered with a message the model can act on (rule, reason, suggested fix)
+ * instead of an exception, unless `onBlock: 'raise'`. Masked queries run as the
+ * rewrite. Vericto being unavailable or misconfigured is never turned into a message
+ * for the model: it propagates, so the fail mode stays in charge.
+ *
+ * Requires the optional peers `@langchain/classic`, `@langchain/core` and `typeorm`.
+ */
+
+/** What a blocked query does: `return` a message for the model (default), or `raise`. */
+type OnBlock = 'return' | 'raise';
+interface VerictoLangChainOptions {
+    /** The guard. Default: one built from the `VERICTO_*` environment variables. */
+    vericto?: Vericto;
+    /** The Vericto dialect. Default: read from the TypeORM `DataSource` type. */
+    dialect?: string;
+    /** Default `return`. */
+    onBlock?: OnBlock;
+}
+type VerictoSqlDatabaseParams = SqlDatabaseDataSourceParams & VerictoLangChainOptions;
+/**
+ * The Vericto dialect of a TypeORM `DataSource` type. Types Vericto does not
+ * evaluate (cockroachdb, sap, spanner, mongodb...) throw `VerictoConfigError`: pass
+ * `dialect` explicitly if you know what you are doing.
+ */
+declare function dialectFromDataSource(dataSource: Pick<DataSource, 'options'>): string;
+/**
+ * A `DataSource` whose `query()` is checked by Vericto first (and runs the masked
+ * rewrite). Everything else is the original data source's.
+ */
+declare function guardDataSource(dataSource: DataSource, vericto: Vericto, dialect: string): DataSource;
+/** The message a model gets for a blocked query: what was blocked, why, and the fix. */
+declare function blockedMessage(verdict: Verdict): string;
+/** A readable verdict for the check tool. */
+declare function describeVerdict(verdict: Verdict): string;
+/**
+ * A LangChain `SqlDatabase` whose statements are checked by Vericto. Accepted
+ * wherever a `SqlDatabase` is: `QuerySqlTool`, `SqlToolkit`/`createSqlAgent`,
+ * `SqlDatabaseChain`.
+ */
+declare class VerictoSqlDatabase extends SqlDatabase {
+    readonly vericto: Vericto;
+    readonly dialect: string;
+    readonly onBlock: OnBlock;
+    /** The unguarded data source: SQL run through it directly is not checked. */
+    readonly rawDataSource: DataSource;
+    protected constructor(fields: VerictoSqlDatabaseParams & {
+        vericto: Vericto;
+        dialect: string;
+    });
+    /**
+     * Same as `SqlDatabase.fromDataSourceParams`, plus the Vericto options. Fails fast
+     * when the server does not evaluate the dialect. LangChain's own schema
+     * introspection (the column catalogue read here) runs on the raw data source.
+     */
+    static fromDataSourceParams(fields: VerictoSqlDatabaseParams): Promise<VerictoSqlDatabase>;
+    /** Same as `SqlDatabase.fromOptionsParams`, plus the Vericto options. */
+    static fromOptionsParams(fields: Parameters<typeof SqlDatabase.fromOptionsParams>[0] & VerictoLangChainOptions): Promise<VerictoSqlDatabase>;
+    /**
+     * Run `command` after Vericto checks it. Blocked: returns {@link blockedMessage}
+     * (or throws `VerictoBlockedError` with `onBlock: 'raise'`). Masked: runs the
+     * rewrite. Vericto unavailable or misconfigured: throws.
+     */
+    run(command: string, fetch?: 'all' | 'one'): Promise<string>;
+}
+/**
+ * `QuerySqlTool` that lets Vericto errors through. The stock tool turns every error
+ * into text for the model, which would also hide "Vericto unavailable" (and, with
+ * `onBlock: 'raise'`, the block) from your code.
+ */
+declare class VerictoQuerySqlTool extends QuerySqlTool {
+    static lc_name(): string;
+    /** @ignore */
+    _call(input: string): Promise<string>;
+}
+/** `SqlToolkit` with {@link VerictoQuerySqlTool} and the Vericto dialect in the prompt. */
+declare class VerictoSqlToolkit extends SqlToolkit {
+    constructor(db: VerictoSqlDatabase, llm: BaseLanguageModelInterface);
+}
+interface VerictoCheckSqlToolOptions extends VerictoLangChainOptions {
+    /** Take the guard, dialect and onBlock from this database. */
+    db?: VerictoSqlDatabase;
+}
+/**
+ * A tool that only checks a query (nothing is executed) and answers with Vericto's
+ * verdict, so an agent can validate SQL before it proposes or runs it. Each check is
+ * a Runtime API evaluation (it counts against the runtime quota and is audited).
+ */
+declare class VerictoCheckSqlTool extends Tool {
+    static lc_name(): string;
+    name: string;
+    description: string;
+    readonly vericto: Vericto;
+    readonly dialect: string;
+    readonly onBlock: OnBlock;
+    constructor(options?: VerictoCheckSqlToolOptions);
+    /** @ignore */
+    _call(input: string): Promise<string>;
+}
+
+export { VerictoCheckSqlTool, VerictoQuerySqlTool, VerictoSqlDatabase, VerictoSqlToolkit, blockedMessage, describeVerdict, dialectFromDataSource, guardDataSource };
+export type { OnBlock, VerictoCheckSqlToolOptions, VerictoLangChainOptions, VerictoSqlDatabaseParams };

package/dist/langchain.d.ts

@@ -0,0 +1,126 @@
+import { SqlToolkit } from '@langchain/classic/agents/toolkits/sql';
+import { SqlDatabase, SqlDatabaseDataSourceParams } from '@langchain/classic/sql_db';
+import { QuerySqlTool } from '@langchain/classic/tools/sql';
+import { BaseLanguageModelInterface } from '@langchain/core/language_models/base';
+import { Tool } from '@langchain/core/tools';
+import { DataSource } from 'typeorm';
+import { Vericto, Verdict } from './index.js';
+
+/**
+ * Vericto for LangChain.js SQL agents and chains (`@langchain/classic`).
+ *
+ * ```ts
+ * import { DataSource } from 'typeorm';
+ * import { VerictoSqlDatabase, VerictoSqlToolkit } from '@vericto/sdk/langchain';
+ * import { createSqlAgent } from '@langchain/classic/agents/toolkits/sql';
+ *
+ * const db = await VerictoSqlDatabase.fromDataSourceParams({
+ *   appDataSource: new DataSource({ type: 'postgres', url: process.env.DATABASE_URL }),
+ * });
+ * const agent = createSqlAgent(llm, new VerictoSqlToolkit(db, llm));
+ * ```
+ *
+ * Every statement LangChain sends through the database's TypeORM `DataSource` is
+ * checked: the agent's queries (`run`, `QuerySqlTool`), the sample rows of
+ * `getTableInfo`, and `SqlDatabaseChain`'s generated SQL. A blocked query is
+ * answered with a message the model can act on (rule, reason, suggested fix)
+ * instead of an exception, unless `onBlock: 'raise'`. Masked queries run as the
+ * rewrite. Vericto being unavailable or misconfigured is never turned into a message
+ * for the model: it propagates, so the fail mode stays in charge.
+ *
+ * Requires the optional peers `@langchain/classic`, `@langchain/core` and `typeorm`.
+ */
+
+/** What a blocked query does: `return` a message for the model (default), or `raise`. */
+type OnBlock = 'return' | 'raise';
+interface VerictoLangChainOptions {
+    /** The guard. Default: one built from the `VERICTO_*` environment variables. */
+    vericto?: Vericto;
+    /** The Vericto dialect. Default: read from the TypeORM `DataSource` type. */
+    dialect?: string;
+    /** Default `return`. */
+    onBlock?: OnBlock;
+}
+type VerictoSqlDatabaseParams = SqlDatabaseDataSourceParams & VerictoLangChainOptions;
+/**
+ * The Vericto dialect of a TypeORM `DataSource` type. Types Vericto does not
+ * evaluate (cockroachdb, sap, spanner, mongodb...) throw `VerictoConfigError`: pass
+ * `dialect` explicitly if you know what you are doing.
+ */
+declare function dialectFromDataSource(dataSource: Pick<DataSource, 'options'>): string;
+/**
+ * A `DataSource` whose `query()` is checked by Vericto first (and runs the masked
+ * rewrite). Everything else is the original data source's.
+ */
+declare function guardDataSource(dataSource: DataSource, vericto: Vericto, dialect: string): DataSource;
+/** The message a model gets for a blocked query: what was blocked, why, and the fix. */
+declare function blockedMessage(verdict: Verdict): string;
+/** A readable verdict for the check tool. */
+declare function describeVerdict(verdict: Verdict): string;
+/**
+ * A LangChain `SqlDatabase` whose statements are checked by Vericto. Accepted
+ * wherever a `SqlDatabase` is: `QuerySqlTool`, `SqlToolkit`/`createSqlAgent`,
+ * `SqlDatabaseChain`.
+ */
+declare class VerictoSqlDatabase extends SqlDatabase {
+    readonly vericto: Vericto;
+    readonly dialect: string;
+    readonly onBlock: OnBlock;
+    /** The unguarded data source: SQL run through it directly is not checked. */
+    readonly rawDataSource: DataSource;
+    protected constructor(fields: VerictoSqlDatabaseParams & {
+        vericto: Vericto;
+        dialect: string;
+    });
+    /**
+     * Same as `SqlDatabase.fromDataSourceParams`, plus the Vericto options. Fails fast
+     * when the server does not evaluate the dialect. LangChain's own schema
+     * introspection (the column catalogue read here) runs on the raw data source.
+     */
+    static fromDataSourceParams(fields: VerictoSqlDatabaseParams): Promise<VerictoSqlDatabase>;
+    /** Same as `SqlDatabase.fromOptionsParams`, plus the Vericto options. */
+    static fromOptionsParams(fields: Parameters<typeof SqlDatabase.fromOptionsParams>[0] & VerictoLangChainOptions): Promise<VerictoSqlDatabase>;
+    /**
+     * Run `command` after Vericto checks it. Blocked: returns {@link blockedMessage}
+     * (or throws `VerictoBlockedError` with `onBlock: 'raise'`). Masked: runs the
+     * rewrite. Vericto unavailable or misconfigured: throws.
+     */
+    run(command: string, fetch?: 'all' | 'one'): Promise<string>;
+}
+/**
+ * `QuerySqlTool` that lets Vericto errors through. The stock tool turns every error
+ * into text for the model, which would also hide "Vericto unavailable" (and, with
+ * `onBlock: 'raise'`, the block) from your code.
+ */
+declare class VerictoQuerySqlTool extends QuerySqlTool {
+    static lc_name(): string;
+    /** @ignore */
+    _call(input: string): Promise<string>;
+}
+/** `SqlToolkit` with {@link VerictoQuerySqlTool} and the Vericto dialect in the prompt. */
+declare class VerictoSqlToolkit extends SqlToolkit {
+    constructor(db: VerictoSqlDatabase, llm: BaseLanguageModelInterface);
+}
+interface VerictoCheckSqlToolOptions extends VerictoLangChainOptions {
+    /** Take the guard, dialect and onBlock from this database. */
+    db?: VerictoSqlDatabase;
+}
+/**
+ * A tool that only checks a query (nothing is executed) and answers with Vericto's
+ * verdict, so an agent can validate SQL before it proposes or runs it. Each check is
+ * a Runtime API evaluation (it counts against the runtime quota and is audited).
+ */
+declare class VerictoCheckSqlTool extends Tool {
+    static lc_name(): string;
+    name: string;
+    description: string;
+    readonly vericto: Vericto;
+    readonly dialect: string;
+    readonly onBlock: OnBlock;
+    constructor(options?: VerictoCheckSqlToolOptions);
+    /** @ignore */
+    _call(input: string): Promise<string>;
+}
+
+export { VerictoCheckSqlTool, VerictoQuerySqlTool, VerictoSqlDatabase, VerictoSqlToolkit, blockedMessage, describeVerdict, dialectFromDataSource, guardDataSource };
+export type { OnBlock, VerictoCheckSqlToolOptions, VerictoLangChainOptions, VerictoSqlDatabaseParams };