@nhtio/adk 1.20260607.2 → 1.20260609.1

package/dispatch_runner.cjs

@@ -1,4 +1,4 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 require("./chunk-Ble4zEEl.js");
-const require_dispatch_runner = require("./dispatch_runner-BHBNupqp.js");
+const require_dispatch_runner = require("./dispatch_runner-nHDKkxye.js");
 exports.DispatchRunner = require_dispatch_runner.DispatchRunner;

package/dispatch_runner.d.ts

@@ -14,4 +14,4 @@ export type { RawDispatchRunnerInput } from "./lib/dispatch_runner";
 /**
  * @primaryExport
  */
-export type { DispatchPipelineMiddlewareFn, DispatchExecutorFn, DispatchExecutorHelpers, DispatchExecutorLogChannel, DispatchExecutorLogEntry, DispatchExecutorLogLevel, LogEvent, DispatchStartEvent, DispatchEndEvent, IterationStartEvent, IterationEndEvent, DispatchRunnerFunctionalHooks, DispatchRunnerObservabilityHooks, DispatchRunnerFunctionalHookRegistrations, DispatchRunnerObservabilityHookRegistrations, } from "./lib/types/dispatch_runner";
+export type { DispatchPipelineMiddlewareFn, DispatchExecutorFn, DispatchExecutorHelpers, DispatchExecutorLogChannel, DispatchExecutorLogEntry, DispatchExecutorLogLevel, LogEvent, GenerationStats, GenerationStatsEvent, DispatchStartEvent, DispatchEndEvent, IterationStartEvent, IterationEndEvent, DispatchRunnerFunctionalHooks, DispatchRunnerObservabilityHooks, DispatchRunnerFunctionalHookRegistrations, DispatchRunnerObservabilityHookRegistrations, } from "./lib/types/dispatch_runner";

package/dispatch_runner.mjs

@@ -1,2 +1,2 @@
-import { t as DispatchRunner } from "./dispatch_runner-DPcS7Y_M.mjs";
+import { t as DispatchRunner } from "./dispatch_runner--ZhdDWRZ.mjs";
 export { DispatchRunner };

package/eslint/rules/artifact_tool_forbids_artifact_constructor.cjs

@@ -27,6 +27,7 @@ var literalKey = (prop) => {
 	if (prop.key.type === "Literal" && typeof prop.key.value === "string") return prop.key.value;
 };
 var isUndefinedValue = (node) => node.type === "Identifier" && node.name === "undefined";
+/** ESLint rule: flags `new ArtifactTool({ … })` that sets the forbidden `artifactConstructor` option. */
 var artifactToolForbidsArtifactConstructorRule = require_common.createRule({
 	name: "artifact-tool-forbids-artifact-constructor",
 	meta: {

package/eslint/rules/artifact_tool_forbids_artifact_constructor.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"artifact_tool_forbids_artifact_constructor.cjs","names":[],"sources":["../../../src/eslint/rules/artifact_tool_forbids_artifact_constructor.ts"],"sourcesContent":["/**\n * @module @nhtio/adk/eslint/rules/artifact_tool_forbids_artifact_constructor\n *\n * Flags `new ArtifactTool({ … })` whose options literal sets an `artifactConstructor`.\n *\n * Why: an `ArtifactTool` is the tool that answers queries AGAINST a spooled artifact — it must not\n * itself return a `SpooledArtifact`, or the result would be re-wrapped into another artifact whose\n * query tools are themselves `ArtifactTool`s, and so on without end. The base `RawTool` accepts an\n * `artifactConstructor` (the subclass used to wrap a tool's bytes), but `ArtifactTool` explicitly\n * FORBIDS it (`artifactConstructor: validator.any().forbidden()` in its schema). Supplying one is a\n * recursion footgun the constructor rejects at runtime; this rule surfaces it at the construction\n * site so it fails lint.\n *\n * Opt-out:\n *   // eslint-disable-next-line adk/artifact-tool-forbids-artifact-constructor -- <reason>\n */\n\nimport { createRule } from './common'\n\nimport type { TSESTree } from '@typescript-eslint/utils'\n\nconst literalKey = (prop: TSESTree.Property): string | undefined => {\n  if (prop.computed) return undefined\n  if (prop.key.type === 'Identifier') return prop.key.name\n  if (prop.key.type === 'Literal' && typeof prop.key.value === 'string') return prop.key.value\n  return undefined\n}\n\nconst isUndefinedValue = (node: TSESTree.Node): boolean =>\n  node.type === 'Identifier' && node.name === 'undefined'\n\nconst artifactToolForbidsArtifactConstructorRule = createRule({\n  name: 'artifact-tool-forbids-artifact-constructor',\n  meta: {\n    type: 'problem',\n    docs: {\n      description:\n        'An `ArtifactTool` must not declare `artifactConstructor` — it answers queries against an artifact and cannot itself return one (infinite re-wrapping). The ArtifactTool schema forbids the field at runtime; this surfaces it at the construction site.',\n    },\n    schema: [],\n    messages: {\n      forbidArtifactConstructor:\n        '`new ArtifactTool` must not set `artifactConstructor` — an artifact-query tool cannot itself return a SpooledArtifact (it would re-wrap forever). The ArtifactTool schema forbids this field. Remove it. Opt out with an eslint-disable-next-line adk/artifact-tool-forbids-artifact-constructor comment + reason.',\n    },\n  },\n  defaultOptions: [],\n  create(context) {\n    return {\n      NewExpression(node: TSESTree.NewExpression) {\n        if (node.callee.type !== 'Identifier' || node.callee.name !== 'ArtifactTool') return\n        const arg = node.arguments[0]\n        if (!arg || arg.type !== 'ObjectExpression') return\n\n        for (const p of arg.properties) {\n          if (p.type === 'SpreadElement') continue\n          if (literalKey(p) === 'artifactConstructor' && !isUndefinedValue(p.value)) {\n            context.report({ node: p, messageId: 'forbidArtifactConstructor' })\n          }\n        }\n      },\n    }\n  },\n})\n\nexport default artifactToolForbidsArtifactConstructorRule\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAqBA,IAAM,cAAc,SAAgD;CAClE,IAAI,KAAK,UAAU,OAAO,KAAA;CAC1B,IAAI,KAAK,IAAI,SAAS,cAAc,OAAO,KAAK,IAAI;CACpD,IAAI,KAAK,IAAI,SAAS,aAAa,OAAO,KAAK,IAAI,UAAU,UAAU,OAAO,KAAK,IAAI;AAEzF;AAEA,IAAM,oBAAoB,SACxB,KAAK,SAAS,gBAAgB,KAAK,SAAS;AAE9C,IAAM,6CAA6C,eAAA,WAAW;CAC5D,MAAM;CACN,MAAM;EACJ,MAAM;EACN,MAAM,EACJ,aACE,0PACJ;EACA,QAAQ,CAAC;EACT,UAAU,EACR,2BACE,qTACJ;CACF;CACA,gBAAgB,CAAC;CACjB,OAAO,SAAS;EACd,OAAO,EACL,cAAc,MAA8B;GAC1C,IAAI,KAAK,OAAO,SAAS,gBAAgB,KAAK,OAAO,SAAS,gBAAgB;GAC9E,MAAM,MAAM,KAAK,UAAU;GAC3B,IAAI,CAAC,OAAO,IAAI,SAAS,oBAAoB;GAE7C,KAAK,MAAM,KAAK,IAAI,YAAY;IAC9B,IAAI,EAAE,SAAS,iBAAiB;IAChC,IAAI,WAAW,CAAC,MAAM,yBAAyB,CAAC,iBAAiB,EAAE,KAAK,GACtE,QAAQ,OAAO;KAAE,MAAM;KAAG,WAAW;IAA4B,CAAC;GAEtE;EACF,EACF;CACF;AACF,CAAC"}
+{"version":3,"file":"artifact_tool_forbids_artifact_constructor.cjs","names":[],"sources":["../../../src/eslint/rules/artifact_tool_forbids_artifact_constructor.ts"],"sourcesContent":["/**\n * @module @nhtio/adk/eslint/rules/artifact_tool_forbids_artifact_constructor\n *\n * Flags `new ArtifactTool({ … })` whose options literal sets an `artifactConstructor`.\n *\n * Why: an `ArtifactTool` is the tool that answers queries AGAINST a spooled artifact — it must not\n * itself return a `SpooledArtifact`, or the result would be re-wrapped into another artifact whose\n * query tools are themselves `ArtifactTool`s, and so on without end. The base `RawTool` accepts an\n * `artifactConstructor` (the subclass used to wrap a tool's bytes), but `ArtifactTool` explicitly\n * FORBIDS it (`artifactConstructor: validator.any().forbidden()` in its schema). Supplying one is a\n * recursion footgun the constructor rejects at runtime; this rule surfaces it at the construction\n * site so it fails lint.\n *\n * Opt-out:\n *   // eslint-disable-next-line adk/artifact-tool-forbids-artifact-constructor -- <reason>\n */\n\nimport { createRule } from './common'\n\nimport type { TSESTree } from '@typescript-eslint/utils'\n\nconst literalKey = (prop: TSESTree.Property): string | undefined => {\n  if (prop.computed) return undefined\n  if (prop.key.type === 'Identifier') return prop.key.name\n  if (prop.key.type === 'Literal' && typeof prop.key.value === 'string') return prop.key.value\n  return undefined\n}\n\nconst isUndefinedValue = (node: TSESTree.Node): boolean =>\n  node.type === 'Identifier' && node.name === 'undefined'\n\n/** ESLint rule: flags `new ArtifactTool({ … })` that sets the forbidden `artifactConstructor` option. */\nconst artifactToolForbidsArtifactConstructorRule = createRule({\n  name: 'artifact-tool-forbids-artifact-constructor',\n  meta: {\n    type: 'problem',\n    docs: {\n      description:\n        'An `ArtifactTool` must not declare `artifactConstructor` — it answers queries against an artifact and cannot itself return one (infinite re-wrapping). The ArtifactTool schema forbids the field at runtime; this surfaces it at the construction site.',\n    },\n    schema: [],\n    messages: {\n      forbidArtifactConstructor:\n        '`new ArtifactTool` must not set `artifactConstructor` — an artifact-query tool cannot itself return a SpooledArtifact (it would re-wrap forever). The ArtifactTool schema forbids this field. Remove it. Opt out with an eslint-disable-next-line adk/artifact-tool-forbids-artifact-constructor comment + reason.',\n    },\n  },\n  defaultOptions: [],\n  create(context) {\n    return {\n      NewExpression(node: TSESTree.NewExpression) {\n        if (node.callee.type !== 'Identifier' || node.callee.name !== 'ArtifactTool') return\n        const arg = node.arguments[0]\n        if (!arg || arg.type !== 'ObjectExpression') return\n\n        for (const p of arg.properties) {\n          if (p.type === 'SpreadElement') continue\n          if (literalKey(p) === 'artifactConstructor' && !isUndefinedValue(p.value)) {\n            context.report({ node: p, messageId: 'forbidArtifactConstructor' })\n          }\n        }\n      },\n    }\n  },\n})\n\nexport default artifactToolForbidsArtifactConstructorRule\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAqBA,IAAM,cAAc,SAAgD;CAClE,IAAI,KAAK,UAAU,OAAO,KAAA;CAC1B,IAAI,KAAK,IAAI,SAAS,cAAc,OAAO,KAAK,IAAI;CACpD,IAAI,KAAK,IAAI,SAAS,aAAa,OAAO,KAAK,IAAI,UAAU,UAAU,OAAO,KAAK,IAAI;AAEzF;AAEA,IAAM,oBAAoB,SACxB,KAAK,SAAS,gBAAgB,KAAK,SAAS;;AAG9C,IAAM,6CAA6C,eAAA,WAAW;CAC5D,MAAM;CACN,MAAM;EACJ,MAAM;EACN,MAAM,EACJ,aACE,0PACJ;EACA,QAAQ,CAAC;EACT,UAAU,EACR,2BACE,qTACJ;CACF;CACA,gBAAgB,CAAC;CACjB,OAAO,SAAS;EACd,OAAO,EACL,cAAc,MAA8B;GAC1C,IAAI,KAAK,OAAO,SAAS,gBAAgB,KAAK,OAAO,SAAS,gBAAgB;GAC9E,MAAM,MAAM,KAAK,UAAU;GAC3B,IAAI,CAAC,OAAO,IAAI,SAAS,oBAAoB;GAE7C,KAAK,MAAM,KAAK,IAAI,YAAY;IAC9B,IAAI,EAAE,SAAS,iBAAiB;IAChC,IAAI,WAAW,CAAC,MAAM,yBAAyB,CAAC,iBAAiB,EAAE,KAAK,GACtE,QAAQ,OAAO;KAAE,MAAM;KAAG,WAAW;IAA4B,CAAC;GAEtE;EACF,EACF;CACF;AACF,CAAC"}

package/eslint/rules/artifact_tool_forbids_artifact_constructor.d.ts

@@ -14,6 +14,7 @@
  * Opt-out:
  *   // eslint-disable-next-line adk/artifact-tool-forbids-artifact-constructor -- <reason>
  */
+/** ESLint rule: flags `new ArtifactTool({ … })` that sets the forbidden `artifactConstructor` option. */
 declare const artifactToolForbidsArtifactConstructorRule: import("@typescript-eslint/utils/ts-eslint").RuleModule<"forbidArtifactConstructor", [
 ], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
     name: string;

package/eslint/rules/artifact_tool_forbids_artifact_constructor.mjs

@@ -22,6 +22,7 @@ var literalKey = (prop) => {
 	if (prop.key.type === "Literal" && typeof prop.key.value === "string") return prop.key.value;
 };
 var isUndefinedValue = (node) => node.type === "Identifier" && node.name === "undefined";
+/** ESLint rule: flags `new ArtifactTool({ … })` that sets the forbidden `artifactConstructor` option. */
 var artifactToolForbidsArtifactConstructorRule = createRule({
 	name: "artifact-tool-forbids-artifact-constructor",
 	meta: {

package/eslint/rules/artifact_tool_forbids_artifact_constructor.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"artifact_tool_forbids_artifact_constructor.mjs","names":[],"sources":["../../../src/eslint/rules/artifact_tool_forbids_artifact_constructor.ts"],"sourcesContent":["/**\n * @module @nhtio/adk/eslint/rules/artifact_tool_forbids_artifact_constructor\n *\n * Flags `new ArtifactTool({ … })` whose options literal sets an `artifactConstructor`.\n *\n * Why: an `ArtifactTool` is the tool that answers queries AGAINST a spooled artifact — it must not\n * itself return a `SpooledArtifact`, or the result would be re-wrapped into another artifact whose\n * query tools are themselves `ArtifactTool`s, and so on without end. The base `RawTool` accepts an\n * `artifactConstructor` (the subclass used to wrap a tool's bytes), but `ArtifactTool` explicitly\n * FORBIDS it (`artifactConstructor: validator.any().forbidden()` in its schema). Supplying one is a\n * recursion footgun the constructor rejects at runtime; this rule surfaces it at the construction\n * site so it fails lint.\n *\n * Opt-out:\n *   // eslint-disable-next-line adk/artifact-tool-forbids-artifact-constructor -- <reason>\n */\n\nimport { createRule } from './common'\n\nimport type { TSESTree } from '@typescript-eslint/utils'\n\nconst literalKey = (prop: TSESTree.Property): string | undefined => {\n  if (prop.computed) return undefined\n  if (prop.key.type === 'Identifier') return prop.key.name\n  if (prop.key.type === 'Literal' && typeof prop.key.value === 'string') return prop.key.value\n  return undefined\n}\n\nconst isUndefinedValue = (node: TSESTree.Node): boolean =>\n  node.type === 'Identifier' && node.name === 'undefined'\n\nconst artifactToolForbidsArtifactConstructorRule = createRule({\n  name: 'artifact-tool-forbids-artifact-constructor',\n  meta: {\n    type: 'problem',\n    docs: {\n      description:\n        'An `ArtifactTool` must not declare `artifactConstructor` — it answers queries against an artifact and cannot itself return one (infinite re-wrapping). The ArtifactTool schema forbids the field at runtime; this surfaces it at the construction site.',\n    },\n    schema: [],\n    messages: {\n      forbidArtifactConstructor:\n        '`new ArtifactTool` must not set `artifactConstructor` — an artifact-query tool cannot itself return a SpooledArtifact (it would re-wrap forever). The ArtifactTool schema forbids this field. Remove it. Opt out with an eslint-disable-next-line adk/artifact-tool-forbids-artifact-constructor comment + reason.',\n    },\n  },\n  defaultOptions: [],\n  create(context) {\n    return {\n      NewExpression(node: TSESTree.NewExpression) {\n        if (node.callee.type !== 'Identifier' || node.callee.name !== 'ArtifactTool') return\n        const arg = node.arguments[0]\n        if (!arg || arg.type !== 'ObjectExpression') return\n\n        for (const p of arg.properties) {\n          if (p.type === 'SpreadElement') continue\n          if (literalKey(p) === 'artifactConstructor' && !isUndefinedValue(p.value)) {\n            context.report({ node: p, messageId: 'forbidArtifactConstructor' })\n          }\n        }\n      },\n    }\n  },\n})\n\nexport default artifactToolForbidsArtifactConstructorRule\n"],"mappings":";;;;;;;;;;;;;;;;;;AAqBA,IAAM,cAAc,SAAgD;CAClE,IAAI,KAAK,UAAU,OAAO,KAAA;CAC1B,IAAI,KAAK,IAAI,SAAS,cAAc,OAAO,KAAK,IAAI;CACpD,IAAI,KAAK,IAAI,SAAS,aAAa,OAAO,KAAK,IAAI,UAAU,UAAU,OAAO,KAAK,IAAI;AAEzF;AAEA,IAAM,oBAAoB,SACxB,KAAK,SAAS,gBAAgB,KAAK,SAAS;AAE9C,IAAM,6CAA6C,WAAW;CAC5D,MAAM;CACN,MAAM;EACJ,MAAM;EACN,MAAM,EACJ,aACE,0PACJ;EACA,QAAQ,CAAC;EACT,UAAU,EACR,2BACE,qTACJ;CACF;CACA,gBAAgB,CAAC;CACjB,OAAO,SAAS;EACd,OAAO,EACL,cAAc,MAA8B;GAC1C,IAAI,KAAK,OAAO,SAAS,gBAAgB,KAAK,OAAO,SAAS,gBAAgB;GAC9E,MAAM,MAAM,KAAK,UAAU;GAC3B,IAAI,CAAC,OAAO,IAAI,SAAS,oBAAoB;GAE7C,KAAK,MAAM,KAAK,IAAI,YAAY;IAC9B,IAAI,EAAE,SAAS,iBAAiB;IAChC,IAAI,WAAW,CAAC,MAAM,yBAAyB,CAAC,iBAAiB,EAAE,KAAK,GACtE,QAAQ,OAAO;KAAE,MAAM;KAAG,WAAW;IAA4B,CAAC;GAEtE;EACF,EACF;CACF;AACF,CAAC"}
+{"version":3,"file":"artifact_tool_forbids_artifact_constructor.mjs","names":[],"sources":["../../../src/eslint/rules/artifact_tool_forbids_artifact_constructor.ts"],"sourcesContent":["/**\n * @module @nhtio/adk/eslint/rules/artifact_tool_forbids_artifact_constructor\n *\n * Flags `new ArtifactTool({ … })` whose options literal sets an `artifactConstructor`.\n *\n * Why: an `ArtifactTool` is the tool that answers queries AGAINST a spooled artifact — it must not\n * itself return a `SpooledArtifact`, or the result would be re-wrapped into another artifact whose\n * query tools are themselves `ArtifactTool`s, and so on without end. The base `RawTool` accepts an\n * `artifactConstructor` (the subclass used to wrap a tool's bytes), but `ArtifactTool` explicitly\n * FORBIDS it (`artifactConstructor: validator.any().forbidden()` in its schema). Supplying one is a\n * recursion footgun the constructor rejects at runtime; this rule surfaces it at the construction\n * site so it fails lint.\n *\n * Opt-out:\n *   // eslint-disable-next-line adk/artifact-tool-forbids-artifact-constructor -- <reason>\n */\n\nimport { createRule } from './common'\n\nimport type { TSESTree } from '@typescript-eslint/utils'\n\nconst literalKey = (prop: TSESTree.Property): string | undefined => {\n  if (prop.computed) return undefined\n  if (prop.key.type === 'Identifier') return prop.key.name\n  if (prop.key.type === 'Literal' && typeof prop.key.value === 'string') return prop.key.value\n  return undefined\n}\n\nconst isUndefinedValue = (node: TSESTree.Node): boolean =>\n  node.type === 'Identifier' && node.name === 'undefined'\n\n/** ESLint rule: flags `new ArtifactTool({ … })` that sets the forbidden `artifactConstructor` option. */\nconst artifactToolForbidsArtifactConstructorRule = createRule({\n  name: 'artifact-tool-forbids-artifact-constructor',\n  meta: {\n    type: 'problem',\n    docs: {\n      description:\n        'An `ArtifactTool` must not declare `artifactConstructor` — it answers queries against an artifact and cannot itself return one (infinite re-wrapping). The ArtifactTool schema forbids the field at runtime; this surfaces it at the construction site.',\n    },\n    schema: [],\n    messages: {\n      forbidArtifactConstructor:\n        '`new ArtifactTool` must not set `artifactConstructor` — an artifact-query tool cannot itself return a SpooledArtifact (it would re-wrap forever). The ArtifactTool schema forbids this field. Remove it. Opt out with an eslint-disable-next-line adk/artifact-tool-forbids-artifact-constructor comment + reason.',\n    },\n  },\n  defaultOptions: [],\n  create(context) {\n    return {\n      NewExpression(node: TSESTree.NewExpression) {\n        if (node.callee.type !== 'Identifier' || node.callee.name !== 'ArtifactTool') return\n        const arg = node.arguments[0]\n        if (!arg || arg.type !== 'ObjectExpression') return\n\n        for (const p of arg.properties) {\n          if (p.type === 'SpreadElement') continue\n          if (literalKey(p) === 'artifactConstructor' && !isUndefinedValue(p.value)) {\n            context.report({ node: p, messageId: 'forbidArtifactConstructor' })\n          }\n        }\n      },\n    }\n  },\n})\n\nexport default artifactToolForbidsArtifactConstructorRule\n"],"mappings":";;;;;;;;;;;;;;;;;;AAqBA,IAAM,cAAc,SAAgD;CAClE,IAAI,KAAK,UAAU,OAAO,KAAA;CAC1B,IAAI,KAAK,IAAI,SAAS,cAAc,OAAO,KAAK,IAAI;CACpD,IAAI,KAAK,IAAI,SAAS,aAAa,OAAO,KAAK,IAAI,UAAU,UAAU,OAAO,KAAK,IAAI;AAEzF;AAEA,IAAM,oBAAoB,SACxB,KAAK,SAAS,gBAAgB,KAAK,SAAS;;AAG9C,IAAM,6CAA6C,WAAW;CAC5D,MAAM;CACN,MAAM;EACJ,MAAM;EACN,MAAM,EACJ,aACE,0PACJ;EACA,QAAQ,CAAC;EACT,UAAU,EACR,2BACE,qTACJ;CACF;CACA,gBAAgB,CAAC;CACjB,OAAO,SAAS;EACd,OAAO,EACL,cAAc,MAA8B;GAC1C,IAAI,KAAK,OAAO,SAAS,gBAAgB,KAAK,OAAO,SAAS,gBAAgB;GAC9E,MAAM,MAAM,KAAK,UAAU;GAC3B,IAAI,CAAC,OAAO,IAAI,SAAS,oBAAoB;GAE7C,KAAK,MAAM,KAAK,IAAI,YAAY;IAC9B,IAAI,EAAE,SAAS,iBAAiB;IAChC,IAAI,WAAW,CAAC,MAAM,yBAAyB,CAAC,iBAAiB,EAAE,KAAK,GACtE,QAAQ,OAAO;KAAE,MAAM;KAAG,WAAW;IAA4B,CAAC;GAEtE;EACF,EACF;CACF;AACF,CAAC"}

package/eslint/rules/no_model_in_tool_handler.cjs

@@ -31,6 +31,7 @@ var literalKey = (prop) => {
 	if (prop.key.type === "Identifier") return prop.key.name;
 	if (prop.key.type === "Literal" && typeof prop.key.value === "string") return prop.key.value;
 };
+/** ESLint rule: flags referencing the model or LLM adapter inside a tool handler. */
 var noModelInToolHandlerRule = require_common.createRule({
 	name: "no-model-in-tool-handler",
 	meta: {

package/eslint/rules/no_model_in_tool_handler.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"no_model_in_tool_handler.cjs","names":[],"sources":["../../../src/eslint/rules/no_model_in_tool_handler.ts"],"sourcesContent":["/**\n * @module @nhtio/adk/eslint/rules/no_model_in_tool_handler\n *\n * Flags an LLM/model call inside a `Tool` / `ArtifactTool` `handler`.\n *\n * Why: the executor owns the dispatch loop. A tool handler runs as one step the model proposed; it\n * must do work and return a result, not start its own reasoning loop. Calling a model from inside a\n * handler hides a nested, unmanaged dispatch from the harness — no token accounting, no event\n * surfacing, no abort propagation. The one legitimate exception is a tool that is explicitly a\n * sub-agent running its own scoped dispatch; this rule allows a handler that constructs a\n * `new TurnRunner(...)` or calls the lower-level `DispatchRunner.dispatch(...)`.\n *\n * Detects provider SDK constructors (`new OpenAI()`, `new Anthropic()`) and chat/completion calls\n * (a `.create()` whose receiver chain passes through `messages`/`completions`/`responses`, or a\n * `generateContent()` call) within the `handler` function passed to `new Tool({ handler })` /\n * `new ArtifactTool({ handler })`, ignoring inner closures (so a sub-agent's own callbacks don't\n * false-positive).\n *\n * Opt-out:\n *   // eslint-disable-next-line adk/no-model-in-tool-handler -- <reason>\n */\n\nimport {\n  createRule,\n  isFunctionNode,\n  isLlmCall,\n  runsSubAgent,\n  walkBodySkippingNestedFunctions,\n} from './common'\n\nimport type { TSESTree } from '@typescript-eslint/utils'\n\nconst literalKey = (prop: TSESTree.Property): string | undefined => {\n  if (prop.computed) return undefined\n  if (prop.key.type === 'Identifier') return prop.key.name\n  if (prop.key.type === 'Literal' && typeof prop.key.value === 'string') return prop.key.value\n  return undefined\n}\n\nconst noModelInToolHandlerRule = createRule({\n  name: 'no-model-in-tool-handler',\n  meta: {\n    type: 'problem',\n    docs: {\n      description:\n        'A Tool/ArtifactTool handler must not invoke a model — the executor owns the dispatch loop. The only exception is a sub-agent tool that runs its own scoped dispatch via `new TurnRunner(...)` or `DispatchRunner.dispatch(...)`.',\n    },\n    schema: [],\n    messages: {\n      noModelInHandler:\n        'Do not call a model inside a tool handler — the executor owns the dispatch loop, and a model call here hides an unmanaged nested dispatch (no token accounting, events, or abort). If this tool is a sub-agent, run a scoped `new TurnRunner(...)` or `DispatchRunner.dispatch(...)` instead. Opt out with an eslint-disable-next-line adk/no-model-in-tool-handler comment + reason.',\n    },\n  },\n  defaultOptions: [],\n  create(context) {\n    return {\n      NewExpression(node: TSESTree.NewExpression) {\n        if (\n          node.callee.type !== 'Identifier' ||\n          (node.callee.name !== 'Tool' && node.callee.name !== 'ArtifactTool')\n        ) {\n          return\n        }\n        const arg = node.arguments[0]\n        if (!arg || arg.type !== 'ObjectExpression') return\n\n        const handlerProp = arg.properties.find(\n          (p): p is TSESTree.Property => p.type === 'Property' && literalKey(p) === 'handler'\n        )\n        if (!handlerProp || !isFunctionNode(handlerProp.value)) return\n        const handler = handlerProp.value\n\n        // A sub-agent tool legitimately runs a scoped dispatch (new TurnRunner / DispatchRunner.dispatch)\n        // — that's the documented exception.\n        if (runsSubAgent(handler.body)) return\n\n        walkBodySkippingNestedFunctions(handler.body, (n) => {\n          if (isLlmCall(n)) {\n            context.report({ node: n, messageId: 'noModelInHandler' })\n          }\n        })\n      },\n    }\n  },\n})\n\nexport default noModelInToolHandlerRule\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,IAAM,cAAc,SAAgD;CAClE,IAAI,KAAK,UAAU,OAAO,KAAA;CAC1B,IAAI,KAAK,IAAI,SAAS,cAAc,OAAO,KAAK,IAAI;CACpD,IAAI,KAAK,IAAI,SAAS,aAAa,OAAO,KAAK,IAAI,UAAU,UAAU,OAAO,KAAK,IAAI;AAEzF;AAEA,IAAM,2BAA2B,eAAA,WAAW;CAC1C,MAAM;CACN,MAAM;EACJ,MAAM;EACN,MAAM,EACJ,aACE,mOACJ;EACA,QAAQ,CAAC;EACT,UAAU,EACR,kBACE,wXACJ;CACF;CACA,gBAAgB,CAAC;CACjB,OAAO,SAAS;EACd,OAAO,EACL,cAAc,MAA8B;GAC1C,IACE,KAAK,OAAO,SAAS,gBACpB,KAAK,OAAO,SAAS,UAAU,KAAK,OAAO,SAAS,gBAErD;GAEF,MAAM,MAAM,KAAK,UAAU;GAC3B,IAAI,CAAC,OAAO,IAAI,SAAS,oBAAoB;GAE7C,MAAM,cAAc,IAAI,WAAW,MAChC,MAA8B,EAAE,SAAS,cAAc,WAAW,CAAC,MAAM,SAC5E;GACA,IAAI,CAAC,eAAe,CAAC,eAAA,eAAe,YAAY,KAAK,GAAG;GACxD,MAAM,UAAU,YAAY;GAI5B,IAAI,eAAA,aAAa,QAAQ,IAAI,GAAG;GAEhC,eAAA,gCAAgC,QAAQ,OAAO,MAAM;IACnD,IAAI,eAAA,UAAU,CAAC,GACb,QAAQ,OAAO;KAAE,MAAM;KAAG,WAAW;IAAmB,CAAC;GAE7D,CAAC;EACH,EACF;CACF;AACF,CAAC"}
+{"version":3,"file":"no_model_in_tool_handler.cjs","names":[],"sources":["../../../src/eslint/rules/no_model_in_tool_handler.ts"],"sourcesContent":["/**\n * @module @nhtio/adk/eslint/rules/no_model_in_tool_handler\n *\n * Flags an LLM/model call inside a `Tool` / `ArtifactTool` `handler`.\n *\n * Why: the executor owns the dispatch loop. A tool handler runs as one step the model proposed; it\n * must do work and return a result, not start its own reasoning loop. Calling a model from inside a\n * handler hides a nested, unmanaged dispatch from the harness — no token accounting, no event\n * surfacing, no abort propagation. The one legitimate exception is a tool that is explicitly a\n * sub-agent running its own scoped dispatch; this rule allows a handler that constructs a\n * `new TurnRunner(...)` or calls the lower-level `DispatchRunner.dispatch(...)`.\n *\n * Detects provider SDK constructors (`new OpenAI()`, `new Anthropic()`) and chat/completion calls\n * (a `.create()` whose receiver chain passes through `messages`/`completions`/`responses`, or a\n * `generateContent()` call) within the `handler` function passed to `new Tool({ handler })` /\n * `new ArtifactTool({ handler })`, ignoring inner closures (so a sub-agent's own callbacks don't\n * false-positive).\n *\n * Opt-out:\n *   // eslint-disable-next-line adk/no-model-in-tool-handler -- <reason>\n */\n\nimport {\n  createRule,\n  isFunctionNode,\n  isLlmCall,\n  runsSubAgent,\n  walkBodySkippingNestedFunctions,\n} from './common'\n\nimport type { TSESTree } from '@typescript-eslint/utils'\n\nconst literalKey = (prop: TSESTree.Property): string | undefined => {\n  if (prop.computed) return undefined\n  if (prop.key.type === 'Identifier') return prop.key.name\n  if (prop.key.type === 'Literal' && typeof prop.key.value === 'string') return prop.key.value\n  return undefined\n}\n\n/** ESLint rule: flags referencing the model or LLM adapter inside a tool handler. */\nconst noModelInToolHandlerRule = createRule({\n  name: 'no-model-in-tool-handler',\n  meta: {\n    type: 'problem',\n    docs: {\n      description:\n        'A Tool/ArtifactTool handler must not invoke a model — the executor owns the dispatch loop. The only exception is a sub-agent tool that runs its own scoped dispatch via `new TurnRunner(...)` or `DispatchRunner.dispatch(...)`.',\n    },\n    schema: [],\n    messages: {\n      noModelInHandler:\n        'Do not call a model inside a tool handler — the executor owns the dispatch loop, and a model call here hides an unmanaged nested dispatch (no token accounting, events, or abort). If this tool is a sub-agent, run a scoped `new TurnRunner(...)` or `DispatchRunner.dispatch(...)` instead. Opt out with an eslint-disable-next-line adk/no-model-in-tool-handler comment + reason.',\n    },\n  },\n  defaultOptions: [],\n  create(context) {\n    return {\n      NewExpression(node: TSESTree.NewExpression) {\n        if (\n          node.callee.type !== 'Identifier' ||\n          (node.callee.name !== 'Tool' && node.callee.name !== 'ArtifactTool')\n        ) {\n          return\n        }\n        const arg = node.arguments[0]\n        if (!arg || arg.type !== 'ObjectExpression') return\n\n        const handlerProp = arg.properties.find(\n          (p): p is TSESTree.Property => p.type === 'Property' && literalKey(p) === 'handler'\n        )\n        if (!handlerProp || !isFunctionNode(handlerProp.value)) return\n        const handler = handlerProp.value\n\n        // A sub-agent tool legitimately runs a scoped dispatch (new TurnRunner / DispatchRunner.dispatch)\n        // — that's the documented exception.\n        if (runsSubAgent(handler.body)) return\n\n        walkBodySkippingNestedFunctions(handler.body, (n) => {\n          if (isLlmCall(n)) {\n            context.report({ node: n, messageId: 'noModelInHandler' })\n          }\n        })\n      },\n    }\n  },\n})\n\nexport default noModelInToolHandlerRule\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,IAAM,cAAc,SAAgD;CAClE,IAAI,KAAK,UAAU,OAAO,KAAA;CAC1B,IAAI,KAAK,IAAI,SAAS,cAAc,OAAO,KAAK,IAAI;CACpD,IAAI,KAAK,IAAI,SAAS,aAAa,OAAO,KAAK,IAAI,UAAU,UAAU,OAAO,KAAK,IAAI;AAEzF;;AAGA,IAAM,2BAA2B,eAAA,WAAW;CAC1C,MAAM;CACN,MAAM;EACJ,MAAM;EACN,MAAM,EACJ,aACE,mOACJ;EACA,QAAQ,CAAC;EACT,UAAU,EACR,kBACE,wXACJ;CACF;CACA,gBAAgB,CAAC;CACjB,OAAO,SAAS;EACd,OAAO,EACL,cAAc,MAA8B;GAC1C,IACE,KAAK,OAAO,SAAS,gBACpB,KAAK,OAAO,SAAS,UAAU,KAAK,OAAO,SAAS,gBAErD;GAEF,MAAM,MAAM,KAAK,UAAU;GAC3B,IAAI,CAAC,OAAO,IAAI,SAAS,oBAAoB;GAE7C,MAAM,cAAc,IAAI,WAAW,MAChC,MAA8B,EAAE,SAAS,cAAc,WAAW,CAAC,MAAM,SAC5E;GACA,IAAI,CAAC,eAAe,CAAC,eAAA,eAAe,YAAY,KAAK,GAAG;GACxD,MAAM,UAAU,YAAY;GAI5B,IAAI,eAAA,aAAa,QAAQ,IAAI,GAAG;GAEhC,eAAA,gCAAgC,QAAQ,OAAO,MAAM;IACnD,IAAI,eAAA,UAAU,CAAC,GACb,QAAQ,OAAO;KAAE,MAAM;KAAG,WAAW;IAAmB,CAAC;GAE7D,CAAC;EACH,EACF;CACF;AACF,CAAC"}

package/eslint/rules/no_model_in_tool_handler.d.ts

@@ -19,6 +19,7 @@
  * Opt-out:
  *   // eslint-disable-next-line adk/no-model-in-tool-handler -- <reason>
  */
+/** ESLint rule: flags referencing the model or LLM adapter inside a tool handler. */
 declare const noModelInToolHandlerRule: import("@typescript-eslint/utils/ts-eslint").RuleModule<"noModelInHandler", [
 ], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
     name: string;

package/eslint/rules/no_model_in_tool_handler.mjs

@@ -26,6 +26,7 @@ var literalKey = (prop) => {
 	if (prop.key.type === "Identifier") return prop.key.name;
 	if (prop.key.type === "Literal" && typeof prop.key.value === "string") return prop.key.value;
 };
+/** ESLint rule: flags referencing the model or LLM adapter inside a tool handler. */
 var noModelInToolHandlerRule = createRule({
 	name: "no-model-in-tool-handler",
 	meta: {

package/eslint/rules/no_model_in_tool_handler.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"no_model_in_tool_handler.mjs","names":[],"sources":["../../../src/eslint/rules/no_model_in_tool_handler.ts"],"sourcesContent":["/**\n * @module @nhtio/adk/eslint/rules/no_model_in_tool_handler\n *\n * Flags an LLM/model call inside a `Tool` / `ArtifactTool` `handler`.\n *\n * Why: the executor owns the dispatch loop. A tool handler runs as one step the model proposed; it\n * must do work and return a result, not start its own reasoning loop. Calling a model from inside a\n * handler hides a nested, unmanaged dispatch from the harness — no token accounting, no event\n * surfacing, no abort propagation. The one legitimate exception is a tool that is explicitly a\n * sub-agent running its own scoped dispatch; this rule allows a handler that constructs a\n * `new TurnRunner(...)` or calls the lower-level `DispatchRunner.dispatch(...)`.\n *\n * Detects provider SDK constructors (`new OpenAI()`, `new Anthropic()`) and chat/completion calls\n * (a `.create()` whose receiver chain passes through `messages`/`completions`/`responses`, or a\n * `generateContent()` call) within the `handler` function passed to `new Tool({ handler })` /\n * `new ArtifactTool({ handler })`, ignoring inner closures (so a sub-agent's own callbacks don't\n * false-positive).\n *\n * Opt-out:\n *   // eslint-disable-next-line adk/no-model-in-tool-handler -- <reason>\n */\n\nimport {\n  createRule,\n  isFunctionNode,\n  isLlmCall,\n  runsSubAgent,\n  walkBodySkippingNestedFunctions,\n} from './common'\n\nimport type { TSESTree } from '@typescript-eslint/utils'\n\nconst literalKey = (prop: TSESTree.Property): string | undefined => {\n  if (prop.computed) return undefined\n  if (prop.key.type === 'Identifier') return prop.key.name\n  if (prop.key.type === 'Literal' && typeof prop.key.value === 'string') return prop.key.value\n  return undefined\n}\n\nconst noModelInToolHandlerRule = createRule({\n  name: 'no-model-in-tool-handler',\n  meta: {\n    type: 'problem',\n    docs: {\n      description:\n        'A Tool/ArtifactTool handler must not invoke a model — the executor owns the dispatch loop. The only exception is a sub-agent tool that runs its own scoped dispatch via `new TurnRunner(...)` or `DispatchRunner.dispatch(...)`.',\n    },\n    schema: [],\n    messages: {\n      noModelInHandler:\n        'Do not call a model inside a tool handler — the executor owns the dispatch loop, and a model call here hides an unmanaged nested dispatch (no token accounting, events, or abort). If this tool is a sub-agent, run a scoped `new TurnRunner(...)` or `DispatchRunner.dispatch(...)` instead. Opt out with an eslint-disable-next-line adk/no-model-in-tool-handler comment + reason.',\n    },\n  },\n  defaultOptions: [],\n  create(context) {\n    return {\n      NewExpression(node: TSESTree.NewExpression) {\n        if (\n          node.callee.type !== 'Identifier' ||\n          (node.callee.name !== 'Tool' && node.callee.name !== 'ArtifactTool')\n        ) {\n          return\n        }\n        const arg = node.arguments[0]\n        if (!arg || arg.type !== 'ObjectExpression') return\n\n        const handlerProp = arg.properties.find(\n          (p): p is TSESTree.Property => p.type === 'Property' && literalKey(p) === 'handler'\n        )\n        if (!handlerProp || !isFunctionNode(handlerProp.value)) return\n        const handler = handlerProp.value\n\n        // A sub-agent tool legitimately runs a scoped dispatch (new TurnRunner / DispatchRunner.dispatch)\n        // — that's the documented exception.\n        if (runsSubAgent(handler.body)) return\n\n        walkBodySkippingNestedFunctions(handler.body, (n) => {\n          if (isLlmCall(n)) {\n            context.report({ node: n, messageId: 'noModelInHandler' })\n          }\n        })\n      },\n    }\n  },\n})\n\nexport default noModelInToolHandlerRule\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAgCA,IAAM,cAAc,SAAgD;CAClE,IAAI,KAAK,UAAU,OAAO,KAAA;CAC1B,IAAI,KAAK,IAAI,SAAS,cAAc,OAAO,KAAK,IAAI;CACpD,IAAI,KAAK,IAAI,SAAS,aAAa,OAAO,KAAK,IAAI,UAAU,UAAU,OAAO,KAAK,IAAI;AAEzF;AAEA,IAAM,2BAA2B,WAAW;CAC1C,MAAM;CACN,MAAM;EACJ,MAAM;EACN,MAAM,EACJ,aACE,mOACJ;EACA,QAAQ,CAAC;EACT,UAAU,EACR,kBACE,wXACJ;CACF;CACA,gBAAgB,CAAC;CACjB,OAAO,SAAS;EACd,OAAO,EACL,cAAc,MAA8B;GAC1C,IACE,KAAK,OAAO,SAAS,gBACpB,KAAK,OAAO,SAAS,UAAU,KAAK,OAAO,SAAS,gBAErD;GAEF,MAAM,MAAM,KAAK,UAAU;GAC3B,IAAI,CAAC,OAAO,IAAI,SAAS,oBAAoB;GAE7C,MAAM,cAAc,IAAI,WAAW,MAChC,MAA8B,EAAE,SAAS,cAAc,WAAW,CAAC,MAAM,SAC5E;GACA,IAAI,CAAC,eAAe,CAAC,eAAe,YAAY,KAAK,GAAG;GACxD,MAAM,UAAU,YAAY;GAI5B,IAAI,aAAa,QAAQ,IAAI,GAAG;GAEhC,gCAAgC,QAAQ,OAAO,MAAM;IACnD,IAAI,UAAU,CAAC,GACb,QAAQ,OAAO;KAAE,MAAM;KAAG,WAAW;IAAmB,CAAC;GAE7D,CAAC;EACH,EACF;CACF;AACF,CAAC"}
+{"version":3,"file":"no_model_in_tool_handler.mjs","names":[],"sources":["../../../src/eslint/rules/no_model_in_tool_handler.ts"],"sourcesContent":["/**\n * @module @nhtio/adk/eslint/rules/no_model_in_tool_handler\n *\n * Flags an LLM/model call inside a `Tool` / `ArtifactTool` `handler`.\n *\n * Why: the executor owns the dispatch loop. A tool handler runs as one step the model proposed; it\n * must do work and return a result, not start its own reasoning loop. Calling a model from inside a\n * handler hides a nested, unmanaged dispatch from the harness — no token accounting, no event\n * surfacing, no abort propagation. The one legitimate exception is a tool that is explicitly a\n * sub-agent running its own scoped dispatch; this rule allows a handler that constructs a\n * `new TurnRunner(...)` or calls the lower-level `DispatchRunner.dispatch(...)`.\n *\n * Detects provider SDK constructors (`new OpenAI()`, `new Anthropic()`) and chat/completion calls\n * (a `.create()` whose receiver chain passes through `messages`/`completions`/`responses`, or a\n * `generateContent()` call) within the `handler` function passed to `new Tool({ handler })` /\n * `new ArtifactTool({ handler })`, ignoring inner closures (so a sub-agent's own callbacks don't\n * false-positive).\n *\n * Opt-out:\n *   // eslint-disable-next-line adk/no-model-in-tool-handler -- <reason>\n */\n\nimport {\n  createRule,\n  isFunctionNode,\n  isLlmCall,\n  runsSubAgent,\n  walkBodySkippingNestedFunctions,\n} from './common'\n\nimport type { TSESTree } from '@typescript-eslint/utils'\n\nconst literalKey = (prop: TSESTree.Property): string | undefined => {\n  if (prop.computed) return undefined\n  if (prop.key.type === 'Identifier') return prop.key.name\n  if (prop.key.type === 'Literal' && typeof prop.key.value === 'string') return prop.key.value\n  return undefined\n}\n\n/** ESLint rule: flags referencing the model or LLM adapter inside a tool handler. */\nconst noModelInToolHandlerRule = createRule({\n  name: 'no-model-in-tool-handler',\n  meta: {\n    type: 'problem',\n    docs: {\n      description:\n        'A Tool/ArtifactTool handler must not invoke a model — the executor owns the dispatch loop. The only exception is a sub-agent tool that runs its own scoped dispatch via `new TurnRunner(...)` or `DispatchRunner.dispatch(...)`.',\n    },\n    schema: [],\n    messages: {\n      noModelInHandler:\n        'Do not call a model inside a tool handler — the executor owns the dispatch loop, and a model call here hides an unmanaged nested dispatch (no token accounting, events, or abort). If this tool is a sub-agent, run a scoped `new TurnRunner(...)` or `DispatchRunner.dispatch(...)` instead. Opt out with an eslint-disable-next-line adk/no-model-in-tool-handler comment + reason.',\n    },\n  },\n  defaultOptions: [],\n  create(context) {\n    return {\n      NewExpression(node: TSESTree.NewExpression) {\n        if (\n          node.callee.type !== 'Identifier' ||\n          (node.callee.name !== 'Tool' && node.callee.name !== 'ArtifactTool')\n        ) {\n          return\n        }\n        const arg = node.arguments[0]\n        if (!arg || arg.type !== 'ObjectExpression') return\n\n        const handlerProp = arg.properties.find(\n          (p): p is TSESTree.Property => p.type === 'Property' && literalKey(p) === 'handler'\n        )\n        if (!handlerProp || !isFunctionNode(handlerProp.value)) return\n        const handler = handlerProp.value\n\n        // A sub-agent tool legitimately runs a scoped dispatch (new TurnRunner / DispatchRunner.dispatch)\n        // — that's the documented exception.\n        if (runsSubAgent(handler.body)) return\n\n        walkBodySkippingNestedFunctions(handler.body, (n) => {\n          if (isLlmCall(n)) {\n            context.report({ node: n, messageId: 'noModelInHandler' })\n          }\n        })\n      },\n    }\n  },\n})\n\nexport default noModelInToolHandlerRule\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAgCA,IAAM,cAAc,SAAgD;CAClE,IAAI,KAAK,UAAU,OAAO,KAAA;CAC1B,IAAI,KAAK,IAAI,SAAS,cAAc,OAAO,KAAK,IAAI;CACpD,IAAI,KAAK,IAAI,SAAS,aAAa,OAAO,KAAK,IAAI,UAAU,UAAU,OAAO,KAAK,IAAI;AAEzF;;AAGA,IAAM,2BAA2B,WAAW;CAC1C,MAAM;CACN,MAAM;EACJ,MAAM;EACN,MAAM,EACJ,aACE,mOACJ;EACA,QAAQ,CAAC;EACT,UAAU,EACR,kBACE,wXACJ;CACF;CACA,gBAAgB,CAAC;CACjB,OAAO,SAAS;EACd,OAAO,EACL,cAAc,MAA8B;GAC1C,IACE,KAAK,OAAO,SAAS,gBACpB,KAAK,OAAO,SAAS,UAAU,KAAK,OAAO,SAAS,gBAErD;GAEF,MAAM,MAAM,KAAK,UAAU;GAC3B,IAAI,CAAC,OAAO,IAAI,SAAS,oBAAoB;GAE7C,MAAM,cAAc,IAAI,WAAW,MAChC,MAA8B,EAAE,SAAS,cAAc,WAAW,CAAC,MAAM,SAC5E;GACA,IAAI,CAAC,eAAe,CAAC,eAAe,YAAY,KAAK,GAAG;GACxD,MAAM,UAAU,YAAY;GAI5B,IAAI,aAAa,QAAQ,IAAI,GAAG;GAEhC,gCAAgC,QAAQ,OAAO,MAAM;IACnD,IAAI,UAAU,CAAC,GACb,QAAQ,OAAO;KAAE,MAAM;KAAG,WAAW;IAAmB,CAAC;GAE7D,CAAC;EACH,EACF;CACF;AACF,CAAC"}

package/eslint/rules/require_validator_any_required.cjs

@@ -72,6 +72,7 @@ var collectChainCalls = (anyCall) => {
 	return calls;
 };
 var chainCalls = (calls, name) => calls.some((c) => c.callee.type === "MemberExpression" && c.callee.property.type === "Identifier" && c.callee.property.name === name);
+/** ESLint rule: flags a validator `any()` schema lacking an explicit required/optional/forbidden disposition. */
 var requireValidatorAnyRequiredRule = require_common.createRule({
 	name: "require-validator-any-required",
 	meta: {

package/eslint/rules/require_validator_any_required.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"require_validator_any_required.cjs","names":[],"sources":["../../../src/eslint/rules/require_validator_any_required.ts"],"sourcesContent":["/**\n * @module @nhtio/adk/eslint/rules/require_validator_any_required\n *\n * Flags every `validator.any()` schema chain that does not declare intent with `.required()`\n * or `.optional()`.\n *\n * Why: in `@nhtio/validation`, `.any()` ADMITS `null`/`undefined` unless you make it `.required()`.\n * That default is silent and easy to miss — a schema you believe rejects missing values quietly\n * accepts them, and any `.custom()` refinement is skipped for an absent value (a `.custom()` guard\n * is the usual way this surfaces, e.g. `implementsX(undefined) === true`). The fix is to make the\n * disposition an EXPLICIT declaration with no ambiguity — every `.any()` must say which it is:\n *   - `.required()`  → reject null/undefined\n *   - `.optional()`  → deliberately allow null/undefined\n *   - `.default(x)`  → allow absence, substituting a fallback value\n *   - `.forbidden()` → the value must be absent\n * This applies whether the `.any()` is top-level or nested inside `items(...)` / `alternatives(...)`:\n * the enclosing schema being `.required()` does NOT govern an inner `.any()`'s null/undefined handling.\n *\n * The sharpest illustration is `.valid(null)`: an author writing `validator.any().valid(null)`\n * means \"must be exactly null\" — but because `.any()` admits `undefined`, that schema actually\n * accepts BOTH `null` and `undefined` (and `undefined !== null`). The fix is\n * `validator.any().required().valid(null)`.\n *\n * Opt-out (e.g. a bare `.any()` used purely as a type argument like `items(validator.any())`):\n *   // eslint-disable-next-line adk/require-validator-any-required -- <reason>\n */\n\nimport { createRule } from './common'\n\nimport type { TSESTree } from '@typescript-eslint/utils'\n\n// The base identifier a member/call chain roots at, e.g. `validator` in `validator.any()` or\n// `validator.alternatives(...).any()`. Returns undefined if the chain doesn't root at a plain name.\nconst baseIdentifierName = (node: TSESTree.Node | undefined): string | undefined => {\n  let cur: TSESTree.Node | undefined = node\n  while (cur) {\n    if (cur.type === 'Identifier') return cur.name\n    if (cur.type === 'MemberExpression') {\n      cur = cur.object\n      continue\n    }\n    if (cur.type === 'CallExpression') {\n      cur = cur.callee\n      continue\n    }\n    return undefined\n  }\n  return undefined\n}\n\n// `validator.any()` (or a `validator.…().any()` chain) — NOT `expect.any()`, `_.any()`, etc.\nconst isAnyCall = (node: TSESTree.CallExpression): boolean =>\n  node.callee.type === 'MemberExpression' &&\n  node.callee.property.type === 'Identifier' &&\n  node.callee.property.name === 'any' &&\n  baseIdentifierName(node.callee.object) === 'validator'\n\n// Collect every CallExpression in the method chain `anyCall` belongs to — inward through the\n// callee object (`a.b().c()` -> `a.b()`) and outward through `.parent` links\n// (`x.any()` -> `x.any().required` -> `x.any().required()`).\nconst collectChainCalls = (anyCall: TSESTree.CallExpression): TSESTree.CallExpression[] => {\n  const calls: TSESTree.CallExpression[] = []\n\n  let cur: TSESTree.Node | null = anyCall\n  while (cur && cur.type === 'CallExpression') {\n    calls.push(cur)\n    cur = cur.callee.type === 'MemberExpression' ? cur.callee.object : null\n  }\n\n  cur = anyCall\n  while (cur) {\n    const p: TSESTree.Node | undefined = cur.parent\n    if (!p) break\n    if (p.type === 'MemberExpression' && p.object === cur) {\n      cur = p\n      continue\n    }\n    if (p.type === 'CallExpression' && p.callee === cur) {\n      calls.push(p)\n      cur = p\n      continue\n    }\n    break\n  }\n\n  return calls\n}\n\nconst chainCalls = (calls: TSESTree.CallExpression[], name: string): boolean =>\n  calls.some(\n    (c) =>\n      c.callee.type === 'MemberExpression' &&\n      c.callee.property.type === 'Identifier' &&\n      c.callee.property.name === name\n  )\n\nconst requireValidatorAnyRequiredRule = createRule({\n  name: 'require-validator-any-required',\n  meta: {\n    type: 'problem',\n    docs: {\n      description:\n        '`validator.any()` admits null/undefined unless `.required()`; make the disposition explicit by ending every `.any()` in `.required()`, `.optional()`, or `.default(…)`. Opt out with a tactical disable comment + reason.',\n    },\n    schema: [],\n    messages: {\n      declareIntent:\n        '`validator.any()` admits null/undefined unless made `.required()`. Make the disposition explicit: end this `.any()` in `.required()` (reject null/undefined), `.optional()` (deliberately allow it), or `.default(…)` (allow it with a fallback) — applies even when nested in items()/alternatives(). Or add an eslint-disable-next-line adk/require-validator-any-required comment with a reason.',\n    },\n  },\n  defaultOptions: [],\n  create(context) {\n    return {\n      CallExpression(node: TSESTree.CallExpression) {\n        if (!isAnyCall(node)) return\n        const calls = collectChainCalls(node)\n        // An unambiguous disposition declaration clears the rule:\n        //   .required()  — reject null/undefined\n        //   .optional()  — deliberately allow null/undefined\n        //   .default(x)  — allow absence, substituting a fallback\n        //   .forbidden() — the value must be absent\n        if (\n          chainCalls(calls, 'required') ||\n          chainCalls(calls, 'optional') ||\n          chainCalls(calls, 'default') ||\n          chainCalls(calls, 'forbidden')\n        ) {\n          return\n        }\n        const reportNode = node.callee.type === 'MemberExpression' ? node.callee.property : node\n        context.report({ node: reportNode, messageId: 'declareIntent' })\n      },\n    }\n  },\n})\n\nexport default requireValidatorAnyRequiredRule\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCA,IAAM,sBAAsB,SAAwD;CAClF,IAAI,MAAiC;CACrC,OAAO,KAAK;EACV,IAAI,IAAI,SAAS,cAAc,OAAO,IAAI;EAC1C,IAAI,IAAI,SAAS,oBAAoB;GACnC,MAAM,IAAI;GACV;EACF;EACA,IAAI,IAAI,SAAS,kBAAkB;GACjC,MAAM,IAAI;GACV;EACF;EACA;CACF;AAEF;AAGA,IAAM,aAAa,SACjB,KAAK,OAAO,SAAS,sBACrB,KAAK,OAAO,SAAS,SAAS,gBAC9B,KAAK,OAAO,SAAS,SAAS,SAC9B,mBAAmB,KAAK,OAAO,MAAM,MAAM;AAK7C,IAAM,qBAAqB,YAAgE;CACzF,MAAM,QAAmC,CAAC;CAE1C,IAAI,MAA4B;CAChC,OAAO,OAAO,IAAI,SAAS,kBAAkB;EAC3C,MAAM,KAAK,GAAG;EACd,MAAM,IAAI,OAAO,SAAS,qBAAqB,IAAI,OAAO,SAAS;CACrE;CAEA,MAAM;CACN,OAAO,KAAK;EACV,MAAM,IAA+B,IAAI;EACzC,IAAI,CAAC,GAAG;EACR,IAAI,EAAE,SAAS,sBAAsB,EAAE,WAAW,KAAK;GACrD,MAAM;GACN;EACF;EACA,IAAI,EAAE,SAAS,oBAAoB,EAAE,WAAW,KAAK;GACnD,MAAM,KAAK,CAAC;GACZ,MAAM;GACN;EACF;EACA;CACF;CAEA,OAAO;AACT;AAEA,IAAM,cAAc,OAAkC,SACpD,MAAM,MACH,MACC,EAAE,OAAO,SAAS,sBAClB,EAAE,OAAO,SAAS,SAAS,gBAC3B,EAAE,OAAO,SAAS,SAAS,IAC/B;AAEF,IAAM,kCAAkC,eAAA,WAAW;CACjD,MAAM;CACN,MAAM;EACJ,MAAM;EACN,MAAM,EACJ,aACE,4NACJ;EACA,QAAQ,CAAC;EACT,UAAU,EACR,eACE,sYACJ;CACF;CACA,gBAAgB,CAAC;CACjB,OAAO,SAAS;EACd,OAAO,EACL,eAAe,MAA+B;GAC5C,IAAI,CAAC,UAAU,IAAI,GAAG;GACtB,MAAM,QAAQ,kBAAkB,IAAI;GAMpC,IACE,WAAW,OAAO,UAAU,KAC5B,WAAW,OAAO,UAAU,KAC5B,WAAW,OAAO,SAAS,KAC3B,WAAW,OAAO,WAAW,GAE7B;GAEF,MAAM,aAAa,KAAK,OAAO,SAAS,qBAAqB,KAAK,OAAO,WAAW;GACpF,QAAQ,OAAO;IAAE,MAAM;IAAY,WAAW;GAAgB,CAAC;EACjE,EACF;CACF;AACF,CAAC"}
+{"version":3,"file":"require_validator_any_required.cjs","names":[],"sources":["../../../src/eslint/rules/require_validator_any_required.ts"],"sourcesContent":["/**\n * @module @nhtio/adk/eslint/rules/require_validator_any_required\n *\n * Flags every `validator.any()` schema chain that does not declare intent with `.required()`\n * or `.optional()`.\n *\n * Why: in `@nhtio/validation`, `.any()` ADMITS `null`/`undefined` unless you make it `.required()`.\n * That default is silent and easy to miss — a schema you believe rejects missing values quietly\n * accepts them, and any `.custom()` refinement is skipped for an absent value (a `.custom()` guard\n * is the usual way this surfaces, e.g. `implementsX(undefined) === true`). The fix is to make the\n * disposition an EXPLICIT declaration with no ambiguity — every `.any()` must say which it is:\n *   - `.required()`  → reject null/undefined\n *   - `.optional()`  → deliberately allow null/undefined\n *   - `.default(x)`  → allow absence, substituting a fallback value\n *   - `.forbidden()` → the value must be absent\n * This applies whether the `.any()` is top-level or nested inside `items(...)` / `alternatives(...)`:\n * the enclosing schema being `.required()` does NOT govern an inner `.any()`'s null/undefined handling.\n *\n * The sharpest illustration is `.valid(null)`: an author writing `validator.any().valid(null)`\n * means \"must be exactly null\" — but because `.any()` admits `undefined`, that schema actually\n * accepts BOTH `null` and `undefined` (and `undefined !== null`). The fix is\n * `validator.any().required().valid(null)`.\n *\n * Opt-out (e.g. a bare `.any()` used purely as a type argument like `items(validator.any())`):\n *   // eslint-disable-next-line adk/require-validator-any-required -- <reason>\n */\n\nimport { createRule } from './common'\n\nimport type { TSESTree } from '@typescript-eslint/utils'\n\n// The base identifier a member/call chain roots at, e.g. `validator` in `validator.any()` or\n// `validator.alternatives(...).any()`. Returns undefined if the chain doesn't root at a plain name.\nconst baseIdentifierName = (node: TSESTree.Node | undefined): string | undefined => {\n  let cur: TSESTree.Node | undefined = node\n  while (cur) {\n    if (cur.type === 'Identifier') return cur.name\n    if (cur.type === 'MemberExpression') {\n      cur = cur.object\n      continue\n    }\n    if (cur.type === 'CallExpression') {\n      cur = cur.callee\n      continue\n    }\n    return undefined\n  }\n  return undefined\n}\n\n// `validator.any()` (or a `validator.…().any()` chain) — NOT `expect.any()`, `_.any()`, etc.\nconst isAnyCall = (node: TSESTree.CallExpression): boolean =>\n  node.callee.type === 'MemberExpression' &&\n  node.callee.property.type === 'Identifier' &&\n  node.callee.property.name === 'any' &&\n  baseIdentifierName(node.callee.object) === 'validator'\n\n// Collect every CallExpression in the method chain `anyCall` belongs to — inward through the\n// callee object (`a.b().c()` -> `a.b()`) and outward through `.parent` links\n// (`x.any()` -> `x.any().required` -> `x.any().required()`).\nconst collectChainCalls = (anyCall: TSESTree.CallExpression): TSESTree.CallExpression[] => {\n  const calls: TSESTree.CallExpression[] = []\n\n  let cur: TSESTree.Node | null = anyCall\n  while (cur && cur.type === 'CallExpression') {\n    calls.push(cur)\n    cur = cur.callee.type === 'MemberExpression' ? cur.callee.object : null\n  }\n\n  cur = anyCall\n  while (cur) {\n    const p: TSESTree.Node | undefined = cur.parent\n    if (!p) break\n    if (p.type === 'MemberExpression' && p.object === cur) {\n      cur = p\n      continue\n    }\n    if (p.type === 'CallExpression' && p.callee === cur) {\n      calls.push(p)\n      cur = p\n      continue\n    }\n    break\n  }\n\n  return calls\n}\n\nconst chainCalls = (calls: TSESTree.CallExpression[], name: string): boolean =>\n  calls.some(\n    (c) =>\n      c.callee.type === 'MemberExpression' &&\n      c.callee.property.type === 'Identifier' &&\n      c.callee.property.name === name\n  )\n\n/** ESLint rule: flags a validator `any()` schema lacking an explicit required/optional/forbidden disposition. */\nconst requireValidatorAnyRequiredRule = createRule({\n  name: 'require-validator-any-required',\n  meta: {\n    type: 'problem',\n    docs: {\n      description:\n        '`validator.any()` admits null/undefined unless `.required()`; make the disposition explicit by ending every `.any()` in `.required()`, `.optional()`, or `.default(…)`. Opt out with a tactical disable comment + reason.',\n    },\n    schema: [],\n    messages: {\n      declareIntent:\n        '`validator.any()` admits null/undefined unless made `.required()`. Make the disposition explicit: end this `.any()` in `.required()` (reject null/undefined), `.optional()` (deliberately allow it), or `.default(…)` (allow it with a fallback) — applies even when nested in items()/alternatives(). Or add an eslint-disable-next-line adk/require-validator-any-required comment with a reason.',\n    },\n  },\n  defaultOptions: [],\n  create(context) {\n    return {\n      CallExpression(node: TSESTree.CallExpression) {\n        if (!isAnyCall(node)) return\n        const calls = collectChainCalls(node)\n        // An unambiguous disposition declaration clears the rule:\n        //   .required()  — reject null/undefined\n        //   .optional()  — deliberately allow null/undefined\n        //   .default(x)  — allow absence, substituting a fallback\n        //   .forbidden() — the value must be absent\n        if (\n          chainCalls(calls, 'required') ||\n          chainCalls(calls, 'optional') ||\n          chainCalls(calls, 'default') ||\n          chainCalls(calls, 'forbidden')\n        ) {\n          return\n        }\n        const reportNode = node.callee.type === 'MemberExpression' ? node.callee.property : node\n        context.report({ node: reportNode, messageId: 'declareIntent' })\n      },\n    }\n  },\n})\n\nexport default requireValidatorAnyRequiredRule\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCA,IAAM,sBAAsB,SAAwD;CAClF,IAAI,MAAiC;CACrC,OAAO,KAAK;EACV,IAAI,IAAI,SAAS,cAAc,OAAO,IAAI;EAC1C,IAAI,IAAI,SAAS,oBAAoB;GACnC,MAAM,IAAI;GACV;EACF;EACA,IAAI,IAAI,SAAS,kBAAkB;GACjC,MAAM,IAAI;GACV;EACF;EACA;CACF;AAEF;AAGA,IAAM,aAAa,SACjB,KAAK,OAAO,SAAS,sBACrB,KAAK,OAAO,SAAS,SAAS,gBAC9B,KAAK,OAAO,SAAS,SAAS,SAC9B,mBAAmB,KAAK,OAAO,MAAM,MAAM;AAK7C,IAAM,qBAAqB,YAAgE;CACzF,MAAM,QAAmC,CAAC;CAE1C,IAAI,MAA4B;CAChC,OAAO,OAAO,IAAI,SAAS,kBAAkB;EAC3C,MAAM,KAAK,GAAG;EACd,MAAM,IAAI,OAAO,SAAS,qBAAqB,IAAI,OAAO,SAAS;CACrE;CAEA,MAAM;CACN,OAAO,KAAK;EACV,MAAM,IAA+B,IAAI;EACzC,IAAI,CAAC,GAAG;EACR,IAAI,EAAE,SAAS,sBAAsB,EAAE,WAAW,KAAK;GACrD,MAAM;GACN;EACF;EACA,IAAI,EAAE,SAAS,oBAAoB,EAAE,WAAW,KAAK;GACnD,MAAM,KAAK,CAAC;GACZ,MAAM;GACN;EACF;EACA;CACF;CAEA,OAAO;AACT;AAEA,IAAM,cAAc,OAAkC,SACpD,MAAM,MACH,MACC,EAAE,OAAO,SAAS,sBAClB,EAAE,OAAO,SAAS,SAAS,gBAC3B,EAAE,OAAO,SAAS,SAAS,IAC/B;;AAGF,IAAM,kCAAkC,eAAA,WAAW;CACjD,MAAM;CACN,MAAM;EACJ,MAAM;EACN,MAAM,EACJ,aACE,4NACJ;EACA,QAAQ,CAAC;EACT,UAAU,EACR,eACE,sYACJ;CACF;CACA,gBAAgB,CAAC;CACjB,OAAO,SAAS;EACd,OAAO,EACL,eAAe,MAA+B;GAC5C,IAAI,CAAC,UAAU,IAAI,GAAG;GACtB,MAAM,QAAQ,kBAAkB,IAAI;GAMpC,IACE,WAAW,OAAO,UAAU,KAC5B,WAAW,OAAO,UAAU,KAC5B,WAAW,OAAO,SAAS,KAC3B,WAAW,OAAO,WAAW,GAE7B;GAEF,MAAM,aAAa,KAAK,OAAO,SAAS,qBAAqB,KAAK,OAAO,WAAW;GACpF,QAAQ,OAAO;IAAE,MAAM;IAAY,WAAW;GAAgB,CAAC;EACjE,EACF;CACF;AACF,CAAC"}

package/eslint/rules/require_validator_any_required.d.ts

@@ -24,6 +24,7 @@
  * Opt-out (e.g. a bare `.any()` used purely as a type argument like `items(validator.any())`):
  *   // eslint-disable-next-line adk/require-validator-any-required -- <reason>
  */
+/** ESLint rule: flags a validator `any()` schema lacking an explicit required/optional/forbidden disposition. */
 declare const requireValidatorAnyRequiredRule: import("@typescript-eslint/utils/ts-eslint").RuleModule<"declareIntent", [
 ], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
     name: string;

package/eslint/rules/require_validator_any_required.mjs

@@ -67,6 +67,7 @@ var collectChainCalls = (anyCall) => {
 	return calls;
 };
 var chainCalls = (calls, name) => calls.some((c) => c.callee.type === "MemberExpression" && c.callee.property.type === "Identifier" && c.callee.property.name === name);
+/** ESLint rule: flags a validator `any()` schema lacking an explicit required/optional/forbidden disposition. */
 var requireValidatorAnyRequiredRule = createRule({
 	name: "require-validator-any-required",
 	meta: {

package/eslint/rules/require_validator_any_required.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"require_validator_any_required.mjs","names":[],"sources":["../../../src/eslint/rules/require_validator_any_required.ts"],"sourcesContent":["/**\n * @module @nhtio/adk/eslint/rules/require_validator_any_required\n *\n * Flags every `validator.any()` schema chain that does not declare intent with `.required()`\n * or `.optional()`.\n *\n * Why: in `@nhtio/validation`, `.any()` ADMITS `null`/`undefined` unless you make it `.required()`.\n * That default is silent and easy to miss — a schema you believe rejects missing values quietly\n * accepts them, and any `.custom()` refinement is skipped for an absent value (a `.custom()` guard\n * is the usual way this surfaces, e.g. `implementsX(undefined) === true`). The fix is to make the\n * disposition an EXPLICIT declaration with no ambiguity — every `.any()` must say which it is:\n *   - `.required()`  → reject null/undefined\n *   - `.optional()`  → deliberately allow null/undefined\n *   - `.default(x)`  → allow absence, substituting a fallback value\n *   - `.forbidden()` → the value must be absent\n * This applies whether the `.any()` is top-level or nested inside `items(...)` / `alternatives(...)`:\n * the enclosing schema being `.required()` does NOT govern an inner `.any()`'s null/undefined handling.\n *\n * The sharpest illustration is `.valid(null)`: an author writing `validator.any().valid(null)`\n * means \"must be exactly null\" — but because `.any()` admits `undefined`, that schema actually\n * accepts BOTH `null` and `undefined` (and `undefined !== null`). The fix is\n * `validator.any().required().valid(null)`.\n *\n * Opt-out (e.g. a bare `.any()` used purely as a type argument like `items(validator.any())`):\n *   // eslint-disable-next-line adk/require-validator-any-required -- <reason>\n */\n\nimport { createRule } from './common'\n\nimport type { TSESTree } from '@typescript-eslint/utils'\n\n// The base identifier a member/call chain roots at, e.g. `validator` in `validator.any()` or\n// `validator.alternatives(...).any()`. Returns undefined if the chain doesn't root at a plain name.\nconst baseIdentifierName = (node: TSESTree.Node | undefined): string | undefined => {\n  let cur: TSESTree.Node | undefined = node\n  while (cur) {\n    if (cur.type === 'Identifier') return cur.name\n    if (cur.type === 'MemberExpression') {\n      cur = cur.object\n      continue\n    }\n    if (cur.type === 'CallExpression') {\n      cur = cur.callee\n      continue\n    }\n    return undefined\n  }\n  return undefined\n}\n\n// `validator.any()` (or a `validator.…().any()` chain) — NOT `expect.any()`, `_.any()`, etc.\nconst isAnyCall = (node: TSESTree.CallExpression): boolean =>\n  node.callee.type === 'MemberExpression' &&\n  node.callee.property.type === 'Identifier' &&\n  node.callee.property.name === 'any' &&\n  baseIdentifierName(node.callee.object) === 'validator'\n\n// Collect every CallExpression in the method chain `anyCall` belongs to — inward through the\n// callee object (`a.b().c()` -> `a.b()`) and outward through `.parent` links\n// (`x.any()` -> `x.any().required` -> `x.any().required()`).\nconst collectChainCalls = (anyCall: TSESTree.CallExpression): TSESTree.CallExpression[] => {\n  const calls: TSESTree.CallExpression[] = []\n\n  let cur: TSESTree.Node | null = anyCall\n  while (cur && cur.type === 'CallExpression') {\n    calls.push(cur)\n    cur = cur.callee.type === 'MemberExpression' ? cur.callee.object : null\n  }\n\n  cur = anyCall\n  while (cur) {\n    const p: TSESTree.Node | undefined = cur.parent\n    if (!p) break\n    if (p.type === 'MemberExpression' && p.object === cur) {\n      cur = p\n      continue\n    }\n    if (p.type === 'CallExpression' && p.callee === cur) {\n      calls.push(p)\n      cur = p\n      continue\n    }\n    break\n  }\n\n  return calls\n}\n\nconst chainCalls = (calls: TSESTree.CallExpression[], name: string): boolean =>\n  calls.some(\n    (c) =>\n      c.callee.type === 'MemberExpression' &&\n      c.callee.property.type === 'Identifier' &&\n      c.callee.property.name === name\n  )\n\nconst requireValidatorAnyRequiredRule = createRule({\n  name: 'require-validator-any-required',\n  meta: {\n    type: 'problem',\n    docs: {\n      description:\n        '`validator.any()` admits null/undefined unless `.required()`; make the disposition explicit by ending every `.any()` in `.required()`, `.optional()`, or `.default(…)`. Opt out with a tactical disable comment + reason.',\n    },\n    schema: [],\n    messages: {\n      declareIntent:\n        '`validator.any()` admits null/undefined unless made `.required()`. Make the disposition explicit: end this `.any()` in `.required()` (reject null/undefined), `.optional()` (deliberately allow it), or `.default(…)` (allow it with a fallback) — applies even when nested in items()/alternatives(). Or add an eslint-disable-next-line adk/require-validator-any-required comment with a reason.',\n    },\n  },\n  defaultOptions: [],\n  create(context) {\n    return {\n      CallExpression(node: TSESTree.CallExpression) {\n        if (!isAnyCall(node)) return\n        const calls = collectChainCalls(node)\n        // An unambiguous disposition declaration clears the rule:\n        //   .required()  — reject null/undefined\n        //   .optional()  — deliberately allow null/undefined\n        //   .default(x)  — allow absence, substituting a fallback\n        //   .forbidden() — the value must be absent\n        if (\n          chainCalls(calls, 'required') ||\n          chainCalls(calls, 'optional') ||\n          chainCalls(calls, 'default') ||\n          chainCalls(calls, 'forbidden')\n        ) {\n          return\n        }\n        const reportNode = node.callee.type === 'MemberExpression' ? node.callee.property : node\n        context.report({ node: reportNode, messageId: 'declareIntent' })\n      },\n    }\n  },\n})\n\nexport default requireValidatorAnyRequiredRule\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCA,IAAM,sBAAsB,SAAwD;CAClF,IAAI,MAAiC;CACrC,OAAO,KAAK;EACV,IAAI,IAAI,SAAS,cAAc,OAAO,IAAI;EAC1C,IAAI,IAAI,SAAS,oBAAoB;GACnC,MAAM,IAAI;GACV;EACF;EACA,IAAI,IAAI,SAAS,kBAAkB;GACjC,MAAM,IAAI;GACV;EACF;EACA;CACF;AAEF;AAGA,IAAM,aAAa,SACjB,KAAK,OAAO,SAAS,sBACrB,KAAK,OAAO,SAAS,SAAS,gBAC9B,KAAK,OAAO,SAAS,SAAS,SAC9B,mBAAmB,KAAK,OAAO,MAAM,MAAM;AAK7C,IAAM,qBAAqB,YAAgE;CACzF,MAAM,QAAmC,CAAC;CAE1C,IAAI,MAA4B;CAChC,OAAO,OAAO,IAAI,SAAS,kBAAkB;EAC3C,MAAM,KAAK,GAAG;EACd,MAAM,IAAI,OAAO,SAAS,qBAAqB,IAAI,OAAO,SAAS;CACrE;CAEA,MAAM;CACN,OAAO,KAAK;EACV,MAAM,IAA+B,IAAI;EACzC,IAAI,CAAC,GAAG;EACR,IAAI,EAAE,SAAS,sBAAsB,EAAE,WAAW,KAAK;GACrD,MAAM;GACN;EACF;EACA,IAAI,EAAE,SAAS,oBAAoB,EAAE,WAAW,KAAK;GACnD,MAAM,KAAK,CAAC;GACZ,MAAM;GACN;EACF;EACA;CACF;CAEA,OAAO;AACT;AAEA,IAAM,cAAc,OAAkC,SACpD,MAAM,MACH,MACC,EAAE,OAAO,SAAS,sBAClB,EAAE,OAAO,SAAS,SAAS,gBAC3B,EAAE,OAAO,SAAS,SAAS,IAC/B;AAEF,IAAM,kCAAkC,WAAW;CACjD,MAAM;CACN,MAAM;EACJ,MAAM;EACN,MAAM,EACJ,aACE,4NACJ;EACA,QAAQ,CAAC;EACT,UAAU,EACR,eACE,sYACJ;CACF;CACA,gBAAgB,CAAC;CACjB,OAAO,SAAS;EACd,OAAO,EACL,eAAe,MAA+B;GAC5C,IAAI,CAAC,UAAU,IAAI,GAAG;GACtB,MAAM,QAAQ,kBAAkB,IAAI;GAMpC,IACE,WAAW,OAAO,UAAU,KAC5B,WAAW,OAAO,UAAU,KAC5B,WAAW,OAAO,SAAS,KAC3B,WAAW,OAAO,WAAW,GAE7B;GAEF,MAAM,aAAa,KAAK,OAAO,SAAS,qBAAqB,KAAK,OAAO,WAAW;GACpF,QAAQ,OAAO;IAAE,MAAM;IAAY,WAAW;GAAgB,CAAC;EACjE,EACF;CACF;AACF,CAAC"}
+{"version":3,"file":"require_validator_any_required.mjs","names":[],"sources":["../../../src/eslint/rules/require_validator_any_required.ts"],"sourcesContent":["/**\n * @module @nhtio/adk/eslint/rules/require_validator_any_required\n *\n * Flags every `validator.any()` schema chain that does not declare intent with `.required()`\n * or `.optional()`.\n *\n * Why: in `@nhtio/validation`, `.any()` ADMITS `null`/`undefined` unless you make it `.required()`.\n * That default is silent and easy to miss — a schema you believe rejects missing values quietly\n * accepts them, and any `.custom()` refinement is skipped for an absent value (a `.custom()` guard\n * is the usual way this surfaces, e.g. `implementsX(undefined) === true`). The fix is to make the\n * disposition an EXPLICIT declaration with no ambiguity — every `.any()` must say which it is:\n *   - `.required()`  → reject null/undefined\n *   - `.optional()`  → deliberately allow null/undefined\n *   - `.default(x)`  → allow absence, substituting a fallback value\n *   - `.forbidden()` → the value must be absent\n * This applies whether the `.any()` is top-level or nested inside `items(...)` / `alternatives(...)`:\n * the enclosing schema being `.required()` does NOT govern an inner `.any()`'s null/undefined handling.\n *\n * The sharpest illustration is `.valid(null)`: an author writing `validator.any().valid(null)`\n * means \"must be exactly null\" — but because `.any()` admits `undefined`, that schema actually\n * accepts BOTH `null` and `undefined` (and `undefined !== null`). The fix is\n * `validator.any().required().valid(null)`.\n *\n * Opt-out (e.g. a bare `.any()` used purely as a type argument like `items(validator.any())`):\n *   // eslint-disable-next-line adk/require-validator-any-required -- <reason>\n */\n\nimport { createRule } from './common'\n\nimport type { TSESTree } from '@typescript-eslint/utils'\n\n// The base identifier a member/call chain roots at, e.g. `validator` in `validator.any()` or\n// `validator.alternatives(...).any()`. Returns undefined if the chain doesn't root at a plain name.\nconst baseIdentifierName = (node: TSESTree.Node | undefined): string | undefined => {\n  let cur: TSESTree.Node | undefined = node\n  while (cur) {\n    if (cur.type === 'Identifier') return cur.name\n    if (cur.type === 'MemberExpression') {\n      cur = cur.object\n      continue\n    }\n    if (cur.type === 'CallExpression') {\n      cur = cur.callee\n      continue\n    }\n    return undefined\n  }\n  return undefined\n}\n\n// `validator.any()` (or a `validator.…().any()` chain) — NOT `expect.any()`, `_.any()`, etc.\nconst isAnyCall = (node: TSESTree.CallExpression): boolean =>\n  node.callee.type === 'MemberExpression' &&\n  node.callee.property.type === 'Identifier' &&\n  node.callee.property.name === 'any' &&\n  baseIdentifierName(node.callee.object) === 'validator'\n\n// Collect every CallExpression in the method chain `anyCall` belongs to — inward through the\n// callee object (`a.b().c()` -> `a.b()`) and outward through `.parent` links\n// (`x.any()` -> `x.any().required` -> `x.any().required()`).\nconst collectChainCalls = (anyCall: TSESTree.CallExpression): TSESTree.CallExpression[] => {\n  const calls: TSESTree.CallExpression[] = []\n\n  let cur: TSESTree.Node | null = anyCall\n  while (cur && cur.type === 'CallExpression') {\n    calls.push(cur)\n    cur = cur.callee.type === 'MemberExpression' ? cur.callee.object : null\n  }\n\n  cur = anyCall\n  while (cur) {\n    const p: TSESTree.Node | undefined = cur.parent\n    if (!p) break\n    if (p.type === 'MemberExpression' && p.object === cur) {\n      cur = p\n      continue\n    }\n    if (p.type === 'CallExpression' && p.callee === cur) {\n      calls.push(p)\n      cur = p\n      continue\n    }\n    break\n  }\n\n  return calls\n}\n\nconst chainCalls = (calls: TSESTree.CallExpression[], name: string): boolean =>\n  calls.some(\n    (c) =>\n      c.callee.type === 'MemberExpression' &&\n      c.callee.property.type === 'Identifier' &&\n      c.callee.property.name === name\n  )\n\n/** ESLint rule: flags a validator `any()` schema lacking an explicit required/optional/forbidden disposition. */\nconst requireValidatorAnyRequiredRule = createRule({\n  name: 'require-validator-any-required',\n  meta: {\n    type: 'problem',\n    docs: {\n      description:\n        '`validator.any()` admits null/undefined unless `.required()`; make the disposition explicit by ending every `.any()` in `.required()`, `.optional()`, or `.default(…)`. Opt out with a tactical disable comment + reason.',\n    },\n    schema: [],\n    messages: {\n      declareIntent:\n        '`validator.any()` admits null/undefined unless made `.required()`. Make the disposition explicit: end this `.any()` in `.required()` (reject null/undefined), `.optional()` (deliberately allow it), or `.default(…)` (allow it with a fallback) — applies even when nested in items()/alternatives(). Or add an eslint-disable-next-line adk/require-validator-any-required comment with a reason.',\n    },\n  },\n  defaultOptions: [],\n  create(context) {\n    return {\n      CallExpression(node: TSESTree.CallExpression) {\n        if (!isAnyCall(node)) return\n        const calls = collectChainCalls(node)\n        // An unambiguous disposition declaration clears the rule:\n        //   .required()  — reject null/undefined\n        //   .optional()  — deliberately allow null/undefined\n        //   .default(x)  — allow absence, substituting a fallback\n        //   .forbidden() — the value must be absent\n        if (\n          chainCalls(calls, 'required') ||\n          chainCalls(calls, 'optional') ||\n          chainCalls(calls, 'default') ||\n          chainCalls(calls, 'forbidden')\n        ) {\n          return\n        }\n        const reportNode = node.callee.type === 'MemberExpression' ? node.callee.property : node\n        context.report({ node: reportNode, messageId: 'declareIntent' })\n      },\n    }\n  },\n})\n\nexport default requireValidatorAnyRequiredRule\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCA,IAAM,sBAAsB,SAAwD;CAClF,IAAI,MAAiC;CACrC,OAAO,KAAK;EACV,IAAI,IAAI,SAAS,cAAc,OAAO,IAAI;EAC1C,IAAI,IAAI,SAAS,oBAAoB;GACnC,MAAM,IAAI;GACV;EACF;EACA,IAAI,IAAI,SAAS,kBAAkB;GACjC,MAAM,IAAI;GACV;EACF;EACA;CACF;AAEF;AAGA,IAAM,aAAa,SACjB,KAAK,OAAO,SAAS,sBACrB,KAAK,OAAO,SAAS,SAAS,gBAC9B,KAAK,OAAO,SAAS,SAAS,SAC9B,mBAAmB,KAAK,OAAO,MAAM,MAAM;AAK7C,IAAM,qBAAqB,YAAgE;CACzF,MAAM,QAAmC,CAAC;CAE1C,IAAI,MAA4B;CAChC,OAAO,OAAO,IAAI,SAAS,kBAAkB;EAC3C,MAAM,KAAK,GAAG;EACd,MAAM,IAAI,OAAO,SAAS,qBAAqB,IAAI,OAAO,SAAS;CACrE;CAEA,MAAM;CACN,OAAO,KAAK;EACV,MAAM,IAA+B,IAAI;EACzC,IAAI,CAAC,GAAG;EACR,IAAI,EAAE,SAAS,sBAAsB,EAAE,WAAW,KAAK;GACrD,MAAM;GACN;EACF;EACA,IAAI,EAAE,SAAS,oBAAoB,EAAE,WAAW,KAAK;GACnD,MAAM,KAAK,CAAC;GACZ,MAAM;GACN;EACF;EACA;CACF;CAEA,OAAO;AACT;AAEA,IAAM,cAAc,OAAkC,SACpD,MAAM,MACH,MACC,EAAE,OAAO,SAAS,sBAClB,EAAE,OAAO,SAAS,SAAS,gBAC3B,EAAE,OAAO,SAAS,SAAS,IAC/B;;AAGF,IAAM,kCAAkC,WAAW;CACjD,MAAM;CACN,MAAM;EACJ,MAAM;EACN,MAAM,EACJ,aACE,4NACJ;EACA,QAAQ,CAAC;EACT,UAAU,EACR,eACE,sYACJ;CACF;CACA,gBAAgB,CAAC;CACjB,OAAO,SAAS;EACd,OAAO,EACL,eAAe,MAA+B;GAC5C,IAAI,CAAC,UAAU,IAAI,GAAG;GACtB,MAAM,QAAQ,kBAAkB,IAAI;GAMpC,IACE,WAAW,OAAO,UAAU,KAC5B,WAAW,OAAO,UAAU,KAC5B,WAAW,OAAO,SAAS,KAC3B,WAAW,OAAO,WAAW,GAE7B;GAEF,MAAM,aAAa,KAAK,OAAO,SAAS,qBAAqB,KAAK,OAAO,WAAW;GACpF,QAAQ,OAAO;IAAE,MAAM;IAAY,WAAW;GAAgB,CAAC;EACjE,EACF;CACF;AACF,CAAC"}

package/eslint/rules/thought_payload_requires_replay_tag.cjs

@@ -32,6 +32,7 @@ var literalKey = (prop) => {
 	if (prop.key.type === "Literal" && typeof prop.key.value === "string") return prop.key.value;
 };
 var isUndefinedValue = (node) => node.type === "Identifier" && node.name === "undefined";
+/** ESLint rule: flags a Thought constructed with a payload but no replayCompatibility tag. */
 var thoughtPayloadRequiresReplayTagRule = require_common.createRule({
 	name: "thought-payload-requires-replay-tag",
 	meta: {

package/eslint/rules/thought_payload_requires_replay_tag.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"thought_payload_requires_replay_tag.cjs","names":[],"sources":["../../../src/eslint/rules/thought_payload_requires_replay_tag.ts"],"sourcesContent":["/**\n * @module @nhtio/adk/eslint/rules/thought_payload_requires_replay_tag\n *\n * Flags `new Thought({ … })` whose options literal sets a `payload` but omits a\n * `replayCompatibility` tag.\n *\n * Why: a `Thought` may carry a vendor-opaque `payload` that the harness cannot interpret, to be\n * replayed back to a matching model wire. The ADK can only route that payload if the thought also\n * declares which adapter wire-shape it is replayable into, via `replayCompatibility`. A `payload`\n * with no `replayCompatibility` is a footgun: the harness has no way to know which adapter can\n * consume it, so it is dropped silently. The `Thought` constructor enforces this cross-field\n * invariant at runtime (`payload` present ⇒ `replayCompatibility` required); this rule surfaces it\n * statically at the construction site so it fails lint, not just at runtime.\n *\n * Detects the common literal form: a `new Thought({ … })` options object that has a `payload`\n * property but no `replayCompatibility` property. Spreads or computed keys are not analyzable here —\n * those fall back to the runtime check.\n *\n * Opt-out:\n *   // eslint-disable-next-line adk/thought-payload-requires-replay-tag -- <reason>\n */\n\nimport { createRule } from './common'\n\nimport type { TSESTree } from '@typescript-eslint/utils'\n\nconst literalKey = (prop: TSESTree.Property): string | undefined => {\n  if (prop.computed) return undefined\n  if (prop.key.type === 'Identifier') return prop.key.name\n  if (prop.key.type === 'Literal' && typeof prop.key.value === 'string') return prop.key.value\n  return undefined\n}\n\n// True when the property value is statically `undefined` (the absent case) — `payload: undefined`\n// is equivalent to omitting it, so it should not trigger the rule.\nconst isUndefinedValue = (node: TSESTree.Node): boolean =>\n  node.type === 'Identifier' && node.name === 'undefined'\n\nconst thoughtPayloadRequiresReplayTagRule = createRule({\n  name: 'thought-payload-requires-replay-tag',\n  meta: {\n    type: 'problem',\n    docs: {\n      description:\n        'A `Thought` carrying a `payload` must declare `replayCompatibility`; otherwise the harness cannot route the opaque payload to a matching adapter and drops it. Enforced at runtime by the Thought constructor; this surfaces it at the construction site.',\n    },\n    schema: [],\n    messages: {\n      requireReplayTag:\n        '`new Thought({ payload })` requires a `replayCompatibility` tag — without it the harness cannot route the opaque payload to an adapter and silently drops it. Add `replayCompatibility: \"<wire-shape-id>\"`, or remove the payload. Opt out with an eslint-disable-next-line adk/thought-payload-requires-replay-tag comment + reason.',\n    },\n  },\n  defaultOptions: [],\n  create(context) {\n    return {\n      NewExpression(node: TSESTree.NewExpression) {\n        if (node.callee.type !== 'Identifier' || node.callee.name !== 'Thought') return\n        const arg = node.arguments[0]\n        if (!arg || arg.type !== 'ObjectExpression') return\n\n        let payloadProp: TSESTree.Property | undefined\n        let hasReplayTag = false\n        let hasSpread = false\n        for (const p of arg.properties) {\n          if (p.type === 'SpreadElement') {\n            hasSpread = true\n            continue\n          }\n          const key = literalKey(p)\n          if (key === 'payload' && !isUndefinedValue(p.value)) payloadProp = p\n          else if (key === 'replayCompatibility' && !isUndefinedValue(p.value)) hasReplayTag = true\n        }\n\n        // A spread could supply replayCompatibility we can't see — stay conservative, don't flag.\n        if (payloadProp && !hasReplayTag && !hasSpread) {\n          context.report({ node: payloadProp, messageId: 'requireReplayTag' })\n        }\n      },\n    }\n  },\n})\n\nexport default thoughtPayloadRequiresReplayTagRule\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,IAAM,cAAc,SAAgD;CAClE,IAAI,KAAK,UAAU,OAAO,KAAA;CAC1B,IAAI,KAAK,IAAI,SAAS,cAAc,OAAO,KAAK,IAAI;CACpD,IAAI,KAAK,IAAI,SAAS,aAAa,OAAO,KAAK,IAAI,UAAU,UAAU,OAAO,KAAK,IAAI;AAEzF;AAIA,IAAM,oBAAoB,SACxB,KAAK,SAAS,gBAAgB,KAAK,SAAS;AAE9C,IAAM,sCAAsC,eAAA,WAAW;CACrD,MAAM;CACN,MAAM;EACJ,MAAM;EACN,MAAM,EACJ,aACE,4PACJ;EACA,QAAQ,CAAC;EACT,UAAU,EACR,kBACE,0UACJ;CACF;CACA,gBAAgB,CAAC;CACjB,OAAO,SAAS;EACd,OAAO,EACL,cAAc,MAA8B;GAC1C,IAAI,KAAK,OAAO,SAAS,gBAAgB,KAAK,OAAO,SAAS,WAAW;GACzE,MAAM,MAAM,KAAK,UAAU;GAC3B,IAAI,CAAC,OAAO,IAAI,SAAS,oBAAoB;GAE7C,IAAI;GACJ,IAAI,eAAe;GACnB,IAAI,YAAY;GAChB,KAAK,MAAM,KAAK,IAAI,YAAY;IAC9B,IAAI,EAAE,SAAS,iBAAiB;KAC9B,YAAY;KACZ;IACF;IACA,MAAM,MAAM,WAAW,CAAC;IACxB,IAAI,QAAQ,aAAa,CAAC,iBAAiB,EAAE,KAAK,GAAG,cAAc;SAC9D,IAAI,QAAQ,yBAAyB,CAAC,iBAAiB,EAAE,KAAK,GAAG,eAAe;GACvF;GAGA,IAAI,eAAe,CAAC,gBAAgB,CAAC,WACnC,QAAQ,OAAO;IAAE,MAAM;IAAa,WAAW;GAAmB,CAAC;EAEvE,EACF;CACF;AACF,CAAC"}
+{"version":3,"file":"thought_payload_requires_replay_tag.cjs","names":[],"sources":["../../../src/eslint/rules/thought_payload_requires_replay_tag.ts"],"sourcesContent":["/**\n * @module @nhtio/adk/eslint/rules/thought_payload_requires_replay_tag\n *\n * Flags `new Thought({ … })` whose options literal sets a `payload` but omits a\n * `replayCompatibility` tag.\n *\n * Why: a `Thought` may carry a vendor-opaque `payload` that the harness cannot interpret, to be\n * replayed back to a matching model wire. The ADK can only route that payload if the thought also\n * declares which adapter wire-shape it is replayable into, via `replayCompatibility`. A `payload`\n * with no `replayCompatibility` is a footgun: the harness has no way to know which adapter can\n * consume it, so it is dropped silently. The `Thought` constructor enforces this cross-field\n * invariant at runtime (`payload` present ⇒ `replayCompatibility` required); this rule surfaces it\n * statically at the construction site so it fails lint, not just at runtime.\n *\n * Detects the common literal form: a `new Thought({ … })` options object that has a `payload`\n * property but no `replayCompatibility` property. Spreads or computed keys are not analyzable here —\n * those fall back to the runtime check.\n *\n * Opt-out:\n *   // eslint-disable-next-line adk/thought-payload-requires-replay-tag -- <reason>\n */\n\nimport { createRule } from './common'\n\nimport type { TSESTree } from '@typescript-eslint/utils'\n\nconst literalKey = (prop: TSESTree.Property): string | undefined => {\n  if (prop.computed) return undefined\n  if (prop.key.type === 'Identifier') return prop.key.name\n  if (prop.key.type === 'Literal' && typeof prop.key.value === 'string') return prop.key.value\n  return undefined\n}\n\n// True when the property value is statically `undefined` (the absent case) — `payload: undefined`\n// is equivalent to omitting it, so it should not trigger the rule.\nconst isUndefinedValue = (node: TSESTree.Node): boolean =>\n  node.type === 'Identifier' && node.name === 'undefined'\n\n/** ESLint rule: flags a Thought constructed with a payload but no replayCompatibility tag. */\nconst thoughtPayloadRequiresReplayTagRule = createRule({\n  name: 'thought-payload-requires-replay-tag',\n  meta: {\n    type: 'problem',\n    docs: {\n      description:\n        'A `Thought` carrying a `payload` must declare `replayCompatibility`; otherwise the harness cannot route the opaque payload to a matching adapter and drops it. Enforced at runtime by the Thought constructor; this surfaces it at the construction site.',\n    },\n    schema: [],\n    messages: {\n      requireReplayTag:\n        '`new Thought({ payload })` requires a `replayCompatibility` tag — without it the harness cannot route the opaque payload to an adapter and silently drops it. Add `replayCompatibility: \"<wire-shape-id>\"`, or remove the payload. Opt out with an eslint-disable-next-line adk/thought-payload-requires-replay-tag comment + reason.',\n    },\n  },\n  defaultOptions: [],\n  create(context) {\n    return {\n      NewExpression(node: TSESTree.NewExpression) {\n        if (node.callee.type !== 'Identifier' || node.callee.name !== 'Thought') return\n        const arg = node.arguments[0]\n        if (!arg || arg.type !== 'ObjectExpression') return\n\n        let payloadProp: TSESTree.Property | undefined\n        let hasReplayTag = false\n        let hasSpread = false\n        for (const p of arg.properties) {\n          if (p.type === 'SpreadElement') {\n            hasSpread = true\n            continue\n          }\n          const key = literalKey(p)\n          if (key === 'payload' && !isUndefinedValue(p.value)) payloadProp = p\n          else if (key === 'replayCompatibility' && !isUndefinedValue(p.value)) hasReplayTag = true\n        }\n\n        // A spread could supply replayCompatibility we can't see — stay conservative, don't flag.\n        if (payloadProp && !hasReplayTag && !hasSpread) {\n          context.report({ node: payloadProp, messageId: 'requireReplayTag' })\n        }\n      },\n    }\n  },\n})\n\nexport default thoughtPayloadRequiresReplayTagRule\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,IAAM,cAAc,SAAgD;CAClE,IAAI,KAAK,UAAU,OAAO,KAAA;CAC1B,IAAI,KAAK,IAAI,SAAS,cAAc,OAAO,KAAK,IAAI;CACpD,IAAI,KAAK,IAAI,SAAS,aAAa,OAAO,KAAK,IAAI,UAAU,UAAU,OAAO,KAAK,IAAI;AAEzF;AAIA,IAAM,oBAAoB,SACxB,KAAK,SAAS,gBAAgB,KAAK,SAAS;;AAG9C,IAAM,sCAAsC,eAAA,WAAW;CACrD,MAAM;CACN,MAAM;EACJ,MAAM;EACN,MAAM,EACJ,aACE,4PACJ;EACA,QAAQ,CAAC;EACT,UAAU,EACR,kBACE,0UACJ;CACF;CACA,gBAAgB,CAAC;CACjB,OAAO,SAAS;EACd,OAAO,EACL,cAAc,MAA8B;GAC1C,IAAI,KAAK,OAAO,SAAS,gBAAgB,KAAK,OAAO,SAAS,WAAW;GACzE,MAAM,MAAM,KAAK,UAAU;GAC3B,IAAI,CAAC,OAAO,IAAI,SAAS,oBAAoB;GAE7C,IAAI;GACJ,IAAI,eAAe;GACnB,IAAI,YAAY;GAChB,KAAK,MAAM,KAAK,IAAI,YAAY;IAC9B,IAAI,EAAE,SAAS,iBAAiB;KAC9B,YAAY;KACZ;IACF;IACA,MAAM,MAAM,WAAW,CAAC;IACxB,IAAI,QAAQ,aAAa,CAAC,iBAAiB,EAAE,KAAK,GAAG,cAAc;SAC9D,IAAI,QAAQ,yBAAyB,CAAC,iBAAiB,EAAE,KAAK,GAAG,eAAe;GACvF;GAGA,IAAI,eAAe,CAAC,gBAAgB,CAAC,WACnC,QAAQ,OAAO;IAAE,MAAM;IAAa,WAAW;GAAmB,CAAC;EAEvE,EACF;CACF;AACF,CAAC"}

package/eslint/rules/thought_payload_requires_replay_tag.d.ts

@@ -19,6 +19,7 @@
  * Opt-out:
  *   // eslint-disable-next-line adk/thought-payload-requires-replay-tag -- <reason>
  */
+/** ESLint rule: flags a Thought constructed with a payload but no replayCompatibility tag. */
 declare const thoughtPayloadRequiresReplayTagRule: import("@typescript-eslint/utils/ts-eslint").RuleModule<"requireReplayTag", [
 ], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
     name: string;

package/eslint/rules/thought_payload_requires_replay_tag.mjs

@@ -27,6 +27,7 @@ var literalKey = (prop) => {
 	if (prop.key.type === "Literal" && typeof prop.key.value === "string") return prop.key.value;
 };
 var isUndefinedValue = (node) => node.type === "Identifier" && node.name === "undefined";
+/** ESLint rule: flags a Thought constructed with a payload but no replayCompatibility tag. */
 var thoughtPayloadRequiresReplayTagRule = createRule({
 	name: "thought-payload-requires-replay-tag",
 	meta: {

package/eslint/rules/thought_payload_requires_replay_tag.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"thought_payload_requires_replay_tag.mjs","names":[],"sources":["../../../src/eslint/rules/thought_payload_requires_replay_tag.ts"],"sourcesContent":["/**\n * @module @nhtio/adk/eslint/rules/thought_payload_requires_replay_tag\n *\n * Flags `new Thought({ … })` whose options literal sets a `payload` but omits a\n * `replayCompatibility` tag.\n *\n * Why: a `Thought` may carry a vendor-opaque `payload` that the harness cannot interpret, to be\n * replayed back to a matching model wire. The ADK can only route that payload if the thought also\n * declares which adapter wire-shape it is replayable into, via `replayCompatibility`. A `payload`\n * with no `replayCompatibility` is a footgun: the harness has no way to know which adapter can\n * consume it, so it is dropped silently. The `Thought` constructor enforces this cross-field\n * invariant at runtime (`payload` present ⇒ `replayCompatibility` required); this rule surfaces it\n * statically at the construction site so it fails lint, not just at runtime.\n *\n * Detects the common literal form: a `new Thought({ … })` options object that has a `payload`\n * property but no `replayCompatibility` property. Spreads or computed keys are not analyzable here —\n * those fall back to the runtime check.\n *\n * Opt-out:\n *   // eslint-disable-next-line adk/thought-payload-requires-replay-tag -- <reason>\n */\n\nimport { createRule } from './common'\n\nimport type { TSESTree } from '@typescript-eslint/utils'\n\nconst literalKey = (prop: TSESTree.Property): string | undefined => {\n  if (prop.computed) return undefined\n  if (prop.key.type === 'Identifier') return prop.key.name\n  if (prop.key.type === 'Literal' && typeof prop.key.value === 'string') return prop.key.value\n  return undefined\n}\n\n// True when the property value is statically `undefined` (the absent case) — `payload: undefined`\n// is equivalent to omitting it, so it should not trigger the rule.\nconst isUndefinedValue = (node: TSESTree.Node): boolean =>\n  node.type === 'Identifier' && node.name === 'undefined'\n\nconst thoughtPayloadRequiresReplayTagRule = createRule({\n  name: 'thought-payload-requires-replay-tag',\n  meta: {\n    type: 'problem',\n    docs: {\n      description:\n        'A `Thought` carrying a `payload` must declare `replayCompatibility`; otherwise the harness cannot route the opaque payload to a matching adapter and drops it. Enforced at runtime by the Thought constructor; this surfaces it at the construction site.',\n    },\n    schema: [],\n    messages: {\n      requireReplayTag:\n        '`new Thought({ payload })` requires a `replayCompatibility` tag — without it the harness cannot route the opaque payload to an adapter and silently drops it. Add `replayCompatibility: \"<wire-shape-id>\"`, or remove the payload. Opt out with an eslint-disable-next-line adk/thought-payload-requires-replay-tag comment + reason.',\n    },\n  },\n  defaultOptions: [],\n  create(context) {\n    return {\n      NewExpression(node: TSESTree.NewExpression) {\n        if (node.callee.type !== 'Identifier' || node.callee.name !== 'Thought') return\n        const arg = node.arguments[0]\n        if (!arg || arg.type !== 'ObjectExpression') return\n\n        let payloadProp: TSESTree.Property | undefined\n        let hasReplayTag = false\n        let hasSpread = false\n        for (const p of arg.properties) {\n          if (p.type === 'SpreadElement') {\n            hasSpread = true\n            continue\n          }\n          const key = literalKey(p)\n          if (key === 'payload' && !isUndefinedValue(p.value)) payloadProp = p\n          else if (key === 'replayCompatibility' && !isUndefinedValue(p.value)) hasReplayTag = true\n        }\n\n        // A spread could supply replayCompatibility we can't see — stay conservative, don't flag.\n        if (payloadProp && !hasReplayTag && !hasSpread) {\n          context.report({ node: payloadProp, messageId: 'requireReplayTag' })\n        }\n      },\n    }\n  },\n})\n\nexport default thoughtPayloadRequiresReplayTagRule\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AA0BA,IAAM,cAAc,SAAgD;CAClE,IAAI,KAAK,UAAU,OAAO,KAAA;CAC1B,IAAI,KAAK,IAAI,SAAS,cAAc,OAAO,KAAK,IAAI;CACpD,IAAI,KAAK,IAAI,SAAS,aAAa,OAAO,KAAK,IAAI,UAAU,UAAU,OAAO,KAAK,IAAI;AAEzF;AAIA,IAAM,oBAAoB,SACxB,KAAK,SAAS,gBAAgB,KAAK,SAAS;AAE9C,IAAM,sCAAsC,WAAW;CACrD,MAAM;CACN,MAAM;EACJ,MAAM;EACN,MAAM,EACJ,aACE,4PACJ;EACA,QAAQ,CAAC;EACT,UAAU,EACR,kBACE,0UACJ;CACF;CACA,gBAAgB,CAAC;CACjB,OAAO,SAAS;EACd,OAAO,EACL,cAAc,MAA8B;GAC1C,IAAI,KAAK,OAAO,SAAS,gBAAgB,KAAK,OAAO,SAAS,WAAW;GACzE,MAAM,MAAM,KAAK,UAAU;GAC3B,IAAI,CAAC,OAAO,IAAI,SAAS,oBAAoB;GAE7C,IAAI;GACJ,IAAI,eAAe;GACnB,IAAI,YAAY;GAChB,KAAK,MAAM,KAAK,IAAI,YAAY;IAC9B,IAAI,EAAE,SAAS,iBAAiB;KAC9B,YAAY;KACZ;IACF;IACA,MAAM,MAAM,WAAW,CAAC;IACxB,IAAI,QAAQ,aAAa,CAAC,iBAAiB,EAAE,KAAK,GAAG,cAAc;SAC9D,IAAI,QAAQ,yBAAyB,CAAC,iBAAiB,EAAE,KAAK,GAAG,eAAe;GACvF;GAGA,IAAI,eAAe,CAAC,gBAAgB,CAAC,WACnC,QAAQ,OAAO;IAAE,MAAM;IAAa,WAAW;GAAmB,CAAC;EAEvE,EACF;CACF;AACF,CAAC"}
+{"version":3,"file":"thought_payload_requires_replay_tag.mjs","names":[],"sources":["../../../src/eslint/rules/thought_payload_requires_replay_tag.ts"],"sourcesContent":["/**\n * @module @nhtio/adk/eslint/rules/thought_payload_requires_replay_tag\n *\n * Flags `new Thought({ … })` whose options literal sets a `payload` but omits a\n * `replayCompatibility` tag.\n *\n * Why: a `Thought` may carry a vendor-opaque `payload` that the harness cannot interpret, to be\n * replayed back to a matching model wire. The ADK can only route that payload if the thought also\n * declares which adapter wire-shape it is replayable into, via `replayCompatibility`. A `payload`\n * with no `replayCompatibility` is a footgun: the harness has no way to know which adapter can\n * consume it, so it is dropped silently. The `Thought` constructor enforces this cross-field\n * invariant at runtime (`payload` present ⇒ `replayCompatibility` required); this rule surfaces it\n * statically at the construction site so it fails lint, not just at runtime.\n *\n * Detects the common literal form: a `new Thought({ … })` options object that has a `payload`\n * property but no `replayCompatibility` property. Spreads or computed keys are not analyzable here —\n * those fall back to the runtime check.\n *\n * Opt-out:\n *   // eslint-disable-next-line adk/thought-payload-requires-replay-tag -- <reason>\n */\n\nimport { createRule } from './common'\n\nimport type { TSESTree } from '@typescript-eslint/utils'\n\nconst literalKey = (prop: TSESTree.Property): string | undefined => {\n  if (prop.computed) return undefined\n  if (prop.key.type === 'Identifier') return prop.key.name\n  if (prop.key.type === 'Literal' && typeof prop.key.value === 'string') return prop.key.value\n  return undefined\n}\n\n// True when the property value is statically `undefined` (the absent case) — `payload: undefined`\n// is equivalent to omitting it, so it should not trigger the rule.\nconst isUndefinedValue = (node: TSESTree.Node): boolean =>\n  node.type === 'Identifier' && node.name === 'undefined'\n\n/** ESLint rule: flags a Thought constructed with a payload but no replayCompatibility tag. */\nconst thoughtPayloadRequiresReplayTagRule = createRule({\n  name: 'thought-payload-requires-replay-tag',\n  meta: {\n    type: 'problem',\n    docs: {\n      description:\n        'A `Thought` carrying a `payload` must declare `replayCompatibility`; otherwise the harness cannot route the opaque payload to a matching adapter and drops it. Enforced at runtime by the Thought constructor; this surfaces it at the construction site.',\n    },\n    schema: [],\n    messages: {\n      requireReplayTag:\n        '`new Thought({ payload })` requires a `replayCompatibility` tag — without it the harness cannot route the opaque payload to an adapter and silently drops it. Add `replayCompatibility: \"<wire-shape-id>\"`, or remove the payload. Opt out with an eslint-disable-next-line adk/thought-payload-requires-replay-tag comment + reason.',\n    },\n  },\n  defaultOptions: [],\n  create(context) {\n    return {\n      NewExpression(node: TSESTree.NewExpression) {\n        if (node.callee.type !== 'Identifier' || node.callee.name !== 'Thought') return\n        const arg = node.arguments[0]\n        if (!arg || arg.type !== 'ObjectExpression') return\n\n        let payloadProp: TSESTree.Property | undefined\n        let hasReplayTag = false\n        let hasSpread = false\n        for (const p of arg.properties) {\n          if (p.type === 'SpreadElement') {\n            hasSpread = true\n            continue\n          }\n          const key = literalKey(p)\n          if (key === 'payload' && !isUndefinedValue(p.value)) payloadProp = p\n          else if (key === 'replayCompatibility' && !isUndefinedValue(p.value)) hasReplayTag = true\n        }\n\n        // A spread could supply replayCompatibility we can't see — stay conservative, don't flag.\n        if (payloadProp && !hasReplayTag && !hasSpread) {\n          context.report({ node: payloadProp, messageId: 'requireReplayTag' })\n        }\n      },\n    }\n  },\n})\n\nexport default thoughtPayloadRequiresReplayTagRule\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AA0BA,IAAM,cAAc,SAAgD;CAClE,IAAI,KAAK,UAAU,OAAO,KAAA;CAC1B,IAAI,KAAK,IAAI,SAAS,cAAc,OAAO,KAAK,IAAI;CACpD,IAAI,KAAK,IAAI,SAAS,aAAa,OAAO,KAAK,IAAI,UAAU,UAAU,OAAO,KAAK,IAAI;AAEzF;AAIA,IAAM,oBAAoB,SACxB,KAAK,SAAS,gBAAgB,KAAK,SAAS;;AAG9C,IAAM,sCAAsC,WAAW;CACrD,MAAM;CACN,MAAM;EACJ,MAAM;EACN,MAAM,EACJ,aACE,4PACJ;EACA,QAAQ,CAAC;EACT,UAAU,EACR,kBACE,0UACJ;CACF;CACA,gBAAgB,CAAC;CACjB,OAAO,SAAS;EACd,OAAO,EACL,cAAc,MAA8B;GAC1C,IAAI,KAAK,OAAO,SAAS,gBAAgB,KAAK,OAAO,SAAS,WAAW;GACzE,MAAM,MAAM,KAAK,UAAU;GAC3B,IAAI,CAAC,OAAO,IAAI,SAAS,oBAAoB;GAE7C,IAAI;GACJ,IAAI,eAAe;GACnB,IAAI,YAAY;GAChB,KAAK,MAAM,KAAK,IAAI,YAAY;IAC9B,IAAI,EAAE,SAAS,iBAAiB;KAC9B,YAAY;KACZ;IACF;IACA,MAAM,MAAM,WAAW,CAAC;IACxB,IAAI,QAAQ,aAAa,CAAC,iBAAiB,EAAE,KAAK,GAAG,cAAc;SAC9D,IAAI,QAAQ,yBAAyB,CAAC,iBAAiB,EAAE,KAAK,GAAG,eAAe;GACvF;GAGA,IAAI,eAAe,CAAC,gBAAgB,CAAC,WACnC,QAAQ,OAAO;IAAE,MAAM;IAAa,WAAW;GAAmB,CAAC;EAEvE,EACF;CACF;AACF,CAAC"}

package/eslint/rules/token_encoding_requires_context_window.cjs

@@ -30,6 +30,7 @@ var literalKey = (prop) => {
 	if (prop.key.type === "Literal" && typeof prop.key.value === "string") return prop.key.value;
 };
 var isNullOrUndefined = (node) => node.type === "Literal" && node.value === null || node.type === "Identifier" && node.name === "undefined";
+/** ESLint rule: flags setting a tokenEncoding without also setting a contextWindow. */
 var tokenEncodingRequiresContextWindowRule = require_common.createRule({
 	name: "token-encoding-requires-context-window",
 	meta: {

package/eslint/rules/token_encoding_requires_context_window.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"token_encoding_requires_context_window.cjs","names":[],"sources":["../../../src/eslint/rules/token_encoding_requires_context_window.ts"],"sourcesContent":["/**\n * @module @nhtio/adk/eslint/rules/token_encoding_requires_context_window\n *\n * Flags a Chat Completions adapter options literal that sets a non-null `tokenEncoding` but omits\n * `contextWindow`.\n *\n * Why: the OpenAI / WebLLM Chat Completions batteries only perform local token counting + overflow\n * protection when BOTH `tokenEncoding` (how to count) and `contextWindow` (the budget to count\n * against) are provided. Setting `tokenEncoding` alone is a footgun — the encoding is configured but\n * there is no ceiling to enforce, so the overflow guard silently never runs. The adapters throw on\n * this cross-field mismatch at iteration time; this rule surfaces it at the construction site.\n *\n * Detects `new OpenAIChatCompletionsAdapter({ … })` / `new WebLLMChatCompletionsAdapter({ … })`\n * (and any `*ChatCompletionsAdapter`) where `tokenEncoding` is present and not `null`/`undefined`\n * while `contextWindow` is absent.\n *\n * Opt-out:\n *   // eslint-disable-next-line adk/token-encoding-requires-context-window -- <reason>\n */\n\nimport { createRule } from './common'\n\nimport type { TSESTree } from '@typescript-eslint/utils'\n\nconst literalKey = (prop: TSESTree.Property): string | undefined => {\n  if (prop.computed) return undefined\n  if (prop.key.type === 'Identifier') return prop.key.name\n  if (prop.key.type === 'Literal' && typeof prop.key.value === 'string') return prop.key.value\n  return undefined\n}\n\nconst isNullOrUndefined = (node: TSESTree.Node): boolean =>\n  (node.type === 'Literal' && node.value === null) ||\n  (node.type === 'Identifier' && node.name === 'undefined')\n\nconst tokenEncodingRequiresContextWindowRule = createRule({\n  name: 'token-encoding-requires-context-window',\n  meta: {\n    type: 'problem',\n    docs: {\n      description:\n        'A Chat Completions adapter configured with a non-null `tokenEncoding` must also set `contextWindow`; otherwise token counting is configured but the overflow guard has no budget and never runs. The adapters enforce this at runtime; this surfaces it at the construction site.',\n    },\n    schema: [],\n    messages: {\n      requireContextWindow:\n        '`tokenEncoding` is set but `contextWindow` is missing — the adapter counts tokens with no budget to enforce, so the context-overflow guard never runs. Add `contextWindow`, or drop `tokenEncoding`. Opt out with an eslint-disable-next-line adk/token-encoding-requires-context-window comment + reason.',\n    },\n  },\n  defaultOptions: [],\n  create(context) {\n    return {\n      NewExpression(node: TSESTree.NewExpression) {\n        if (node.callee.type !== 'Identifier') return\n        if (!/ChatCompletionsAdapter$/.test(node.callee.name)) return\n        const arg = node.arguments[0]\n        if (!arg || arg.type !== 'ObjectExpression') return\n\n        let tokenEncodingProp: TSESTree.Property | undefined\n        let hasContextWindow = false\n        let hasSpread = false\n        for (const p of arg.properties) {\n          if (p.type === 'SpreadElement') {\n            hasSpread = true\n            continue\n          }\n          const key = literalKey(p)\n          if (key === 'tokenEncoding' && !isNullOrUndefined(p.value)) tokenEncodingProp = p\n          else if (key === 'contextWindow' && !isNullOrUndefined(p.value)) hasContextWindow = true\n        }\n\n        // A spread could supply contextWindow we can't see — stay conservative, don't flag.\n        if (tokenEncodingProp && !hasContextWindow && !hasSpread) {\n          context.report({ node: tokenEncodingProp, messageId: 'requireContextWindow' })\n        }\n      },\n    }\n  },\n})\n\nexport default tokenEncodingRequiresContextWindowRule\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,IAAM,cAAc,SAAgD;CAClE,IAAI,KAAK,UAAU,OAAO,KAAA;CAC1B,IAAI,KAAK,IAAI,SAAS,cAAc,OAAO,KAAK,IAAI;CACpD,IAAI,KAAK,IAAI,SAAS,aAAa,OAAO,KAAK,IAAI,UAAU,UAAU,OAAO,KAAK,IAAI;AAEzF;AAEA,IAAM,qBAAqB,SACxB,KAAK,SAAS,aAAa,KAAK,UAAU,QAC1C,KAAK,SAAS,gBAAgB,KAAK,SAAS;AAE/C,IAAM,yCAAyC,eAAA,WAAW;CACxD,MAAM;CACN,MAAM;EACJ,MAAM;EACN,MAAM,EACJ,aACE,oRACJ;EACA,QAAQ,CAAC;EACT,UAAU,EACR,sBACE,6SACJ;CACF;CACA,gBAAgB,CAAC;CACjB,OAAO,SAAS;EACd,OAAO,EACL,cAAc,MAA8B;GAC1C,IAAI,KAAK,OAAO,SAAS,cAAc;GACvC,IAAI,CAAC,0BAA0B,KAAK,KAAK,OAAO,IAAI,GAAG;GACvD,MAAM,MAAM,KAAK,UAAU;GAC3B,IAAI,CAAC,OAAO,IAAI,SAAS,oBAAoB;GAE7C,IAAI;GACJ,IAAI,mBAAmB;GACvB,IAAI,YAAY;GAChB,KAAK,MAAM,KAAK,IAAI,YAAY;IAC9B,IAAI,EAAE,SAAS,iBAAiB;KAC9B,YAAY;KACZ;IACF;IACA,MAAM,MAAM,WAAW,CAAC;IACxB,IAAI,QAAQ,mBAAmB,CAAC,kBAAkB,EAAE,KAAK,GAAG,oBAAoB;SAC3E,IAAI,QAAQ,mBAAmB,CAAC,kBAAkB,EAAE,KAAK,GAAG,mBAAmB;GACtF;GAGA,IAAI,qBAAqB,CAAC,oBAAoB,CAAC,WAC7C,QAAQ,OAAO;IAAE,MAAM;IAAmB,WAAW;GAAuB,CAAC;EAEjF,EACF;CACF;AACF,CAAC"}
+{"version":3,"file":"token_encoding_requires_context_window.cjs","names":[],"sources":["../../../src/eslint/rules/token_encoding_requires_context_window.ts"],"sourcesContent":["/**\n * @module @nhtio/adk/eslint/rules/token_encoding_requires_context_window\n *\n * Flags a Chat Completions adapter options literal that sets a non-null `tokenEncoding` but omits\n * `contextWindow`.\n *\n * Why: the OpenAI / WebLLM Chat Completions batteries only perform local token counting + overflow\n * protection when BOTH `tokenEncoding` (how to count) and `contextWindow` (the budget to count\n * against) are provided. Setting `tokenEncoding` alone is a footgun — the encoding is configured but\n * there is no ceiling to enforce, so the overflow guard silently never runs. The adapters throw on\n * this cross-field mismatch at iteration time; this rule surfaces it at the construction site.\n *\n * Detects `new OpenAIChatCompletionsAdapter({ … })` / `new WebLLMChatCompletionsAdapter({ … })`\n * (and any `*ChatCompletionsAdapter`) where `tokenEncoding` is present and not `null`/`undefined`\n * while `contextWindow` is absent.\n *\n * Opt-out:\n *   // eslint-disable-next-line adk/token-encoding-requires-context-window -- <reason>\n */\n\nimport { createRule } from './common'\n\nimport type { TSESTree } from '@typescript-eslint/utils'\n\nconst literalKey = (prop: TSESTree.Property): string | undefined => {\n  if (prop.computed) return undefined\n  if (prop.key.type === 'Identifier') return prop.key.name\n  if (prop.key.type === 'Literal' && typeof prop.key.value === 'string') return prop.key.value\n  return undefined\n}\n\nconst isNullOrUndefined = (node: TSESTree.Node): boolean =>\n  (node.type === 'Literal' && node.value === null) ||\n  (node.type === 'Identifier' && node.name === 'undefined')\n\n/** ESLint rule: flags setting a tokenEncoding without also setting a contextWindow. */\nconst tokenEncodingRequiresContextWindowRule = createRule({\n  name: 'token-encoding-requires-context-window',\n  meta: {\n    type: 'problem',\n    docs: {\n      description:\n        'A Chat Completions adapter configured with a non-null `tokenEncoding` must also set `contextWindow`; otherwise token counting is configured but the overflow guard has no budget and never runs. The adapters enforce this at runtime; this surfaces it at the construction site.',\n    },\n    schema: [],\n    messages: {\n      requireContextWindow:\n        '`tokenEncoding` is set but `contextWindow` is missing — the adapter counts tokens with no budget to enforce, so the context-overflow guard never runs. Add `contextWindow`, or drop `tokenEncoding`. Opt out with an eslint-disable-next-line adk/token-encoding-requires-context-window comment + reason.',\n    },\n  },\n  defaultOptions: [],\n  create(context) {\n    return {\n      NewExpression(node: TSESTree.NewExpression) {\n        if (node.callee.type !== 'Identifier') return\n        if (!/ChatCompletionsAdapter$/.test(node.callee.name)) return\n        const arg = node.arguments[0]\n        if (!arg || arg.type !== 'ObjectExpression') return\n\n        let tokenEncodingProp: TSESTree.Property | undefined\n        let hasContextWindow = false\n        let hasSpread = false\n        for (const p of arg.properties) {\n          if (p.type === 'SpreadElement') {\n            hasSpread = true\n            continue\n          }\n          const key = literalKey(p)\n          if (key === 'tokenEncoding' && !isNullOrUndefined(p.value)) tokenEncodingProp = p\n          else if (key === 'contextWindow' && !isNullOrUndefined(p.value)) hasContextWindow = true\n        }\n\n        // A spread could supply contextWindow we can't see — stay conservative, don't flag.\n        if (tokenEncodingProp && !hasContextWindow && !hasSpread) {\n          context.report({ node: tokenEncodingProp, messageId: 'requireContextWindow' })\n        }\n      },\n    }\n  },\n})\n\nexport default tokenEncodingRequiresContextWindowRule\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,IAAM,cAAc,SAAgD;CAClE,IAAI,KAAK,UAAU,OAAO,KAAA;CAC1B,IAAI,KAAK,IAAI,SAAS,cAAc,OAAO,KAAK,IAAI;CACpD,IAAI,KAAK,IAAI,SAAS,aAAa,OAAO,KAAK,IAAI,UAAU,UAAU,OAAO,KAAK,IAAI;AAEzF;AAEA,IAAM,qBAAqB,SACxB,KAAK,SAAS,aAAa,KAAK,UAAU,QAC1C,KAAK,SAAS,gBAAgB,KAAK,SAAS;;AAG/C,IAAM,yCAAyC,eAAA,WAAW;CACxD,MAAM;CACN,MAAM;EACJ,MAAM;EACN,MAAM,EACJ,aACE,oRACJ;EACA,QAAQ,CAAC;EACT,UAAU,EACR,sBACE,6SACJ;CACF;CACA,gBAAgB,CAAC;CACjB,OAAO,SAAS;EACd,OAAO,EACL,cAAc,MAA8B;GAC1C,IAAI,KAAK,OAAO,SAAS,cAAc;GACvC,IAAI,CAAC,0BAA0B,KAAK,KAAK,OAAO,IAAI,GAAG;GACvD,MAAM,MAAM,KAAK,UAAU;GAC3B,IAAI,CAAC,OAAO,IAAI,SAAS,oBAAoB;GAE7C,IAAI;GACJ,IAAI,mBAAmB;GACvB,IAAI,YAAY;GAChB,KAAK,MAAM,KAAK,IAAI,YAAY;IAC9B,IAAI,EAAE,SAAS,iBAAiB;KAC9B,YAAY;KACZ;IACF;IACA,MAAM,MAAM,WAAW,CAAC;IACxB,IAAI,QAAQ,mBAAmB,CAAC,kBAAkB,EAAE,KAAK,GAAG,oBAAoB;SAC3E,IAAI,QAAQ,mBAAmB,CAAC,kBAAkB,EAAE,KAAK,GAAG,mBAAmB;GACtF;GAGA,IAAI,qBAAqB,CAAC,oBAAoB,CAAC,WAC7C,QAAQ,OAAO;IAAE,MAAM;IAAmB,WAAW;GAAuB,CAAC;EAEjF,EACF;CACF;AACF,CAAC"}

package/eslint/rules/token_encoding_requires_context_window.d.ts

@@ -17,6 +17,7 @@
  * Opt-out:
  *   // eslint-disable-next-line adk/token-encoding-requires-context-window -- <reason>
  */
+/** ESLint rule: flags setting a tokenEncoding without also setting a contextWindow. */
 declare const tokenEncodingRequiresContextWindowRule: import("@typescript-eslint/utils/ts-eslint").RuleModule<"requireContextWindow", [
 ], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
     name: string;

package/eslint/rules/token_encoding_requires_context_window.mjs

@@ -25,6 +25,7 @@ var literalKey = (prop) => {
 	if (prop.key.type === "Literal" && typeof prop.key.value === "string") return prop.key.value;
 };
 var isNullOrUndefined = (node) => node.type === "Literal" && node.value === null || node.type === "Identifier" && node.name === "undefined";
+/** ESLint rule: flags setting a tokenEncoding without also setting a contextWindow. */
 var tokenEncodingRequiresContextWindowRule = createRule({
 	name: "token-encoding-requires-context-window",
 	meta: {

package/eslint/rules/token_encoding_requires_context_window.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"token_encoding_requires_context_window.mjs","names":[],"sources":["../../../src/eslint/rules/token_encoding_requires_context_window.ts"],"sourcesContent":["/**\n * @module @nhtio/adk/eslint/rules/token_encoding_requires_context_window\n *\n * Flags a Chat Completions adapter options literal that sets a non-null `tokenEncoding` but omits\n * `contextWindow`.\n *\n * Why: the OpenAI / WebLLM Chat Completions batteries only perform local token counting + overflow\n * protection when BOTH `tokenEncoding` (how to count) and `contextWindow` (the budget to count\n * against) are provided. Setting `tokenEncoding` alone is a footgun — the encoding is configured but\n * there is no ceiling to enforce, so the overflow guard silently never runs. The adapters throw on\n * this cross-field mismatch at iteration time; this rule surfaces it at the construction site.\n *\n * Detects `new OpenAIChatCompletionsAdapter({ … })` / `new WebLLMChatCompletionsAdapter({ … })`\n * (and any `*ChatCompletionsAdapter`) where `tokenEncoding` is present and not `null`/`undefined`\n * while `contextWindow` is absent.\n *\n * Opt-out:\n *   // eslint-disable-next-line adk/token-encoding-requires-context-window -- <reason>\n */\n\nimport { createRule } from './common'\n\nimport type { TSESTree } from '@typescript-eslint/utils'\n\nconst literalKey = (prop: TSESTree.Property): string | undefined => {\n  if (prop.computed) return undefined\n  if (prop.key.type === 'Identifier') return prop.key.name\n  if (prop.key.type === 'Literal' && typeof prop.key.value === 'string') return prop.key.value\n  return undefined\n}\n\nconst isNullOrUndefined = (node: TSESTree.Node): boolean =>\n  (node.type === 'Literal' && node.value === null) ||\n  (node.type === 'Identifier' && node.name === 'undefined')\n\nconst tokenEncodingRequiresContextWindowRule = createRule({\n  name: 'token-encoding-requires-context-window',\n  meta: {\n    type: 'problem',\n    docs: {\n      description:\n        'A Chat Completions adapter configured with a non-null `tokenEncoding` must also set `contextWindow`; otherwise token counting is configured but the overflow guard has no budget and never runs. The adapters enforce this at runtime; this surfaces it at the construction site.',\n    },\n    schema: [],\n    messages: {\n      requireContextWindow:\n        '`tokenEncoding` is set but `contextWindow` is missing — the adapter counts tokens with no budget to enforce, so the context-overflow guard never runs. Add `contextWindow`, or drop `tokenEncoding`. Opt out with an eslint-disable-next-line adk/token-encoding-requires-context-window comment + reason.',\n    },\n  },\n  defaultOptions: [],\n  create(context) {\n    return {\n      NewExpression(node: TSESTree.NewExpression) {\n        if (node.callee.type !== 'Identifier') return\n        if (!/ChatCompletionsAdapter$/.test(node.callee.name)) return\n        const arg = node.arguments[0]\n        if (!arg || arg.type !== 'ObjectExpression') return\n\n        let tokenEncodingProp: TSESTree.Property | undefined\n        let hasContextWindow = false\n        let hasSpread = false\n        for (const p of arg.properties) {\n          if (p.type === 'SpreadElement') {\n            hasSpread = true\n            continue\n          }\n          const key = literalKey(p)\n          if (key === 'tokenEncoding' && !isNullOrUndefined(p.value)) tokenEncodingProp = p\n          else if (key === 'contextWindow' && !isNullOrUndefined(p.value)) hasContextWindow = true\n        }\n\n        // A spread could supply contextWindow we can't see — stay conservative, don't flag.\n        if (tokenEncodingProp && !hasContextWindow && !hasSpread) {\n          context.report({ node: tokenEncodingProp, messageId: 'requireContextWindow' })\n        }\n      },\n    }\n  },\n})\n\nexport default tokenEncodingRequiresContextWindowRule\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAwBA,IAAM,cAAc,SAAgD;CAClE,IAAI,KAAK,UAAU,OAAO,KAAA;CAC1B,IAAI,KAAK,IAAI,SAAS,cAAc,OAAO,KAAK,IAAI;CACpD,IAAI,KAAK,IAAI,SAAS,aAAa,OAAO,KAAK,IAAI,UAAU,UAAU,OAAO,KAAK,IAAI;AAEzF;AAEA,IAAM,qBAAqB,SACxB,KAAK,SAAS,aAAa,KAAK,UAAU,QAC1C,KAAK,SAAS,gBAAgB,KAAK,SAAS;AAE/C,IAAM,yCAAyC,WAAW;CACxD,MAAM;CACN,MAAM;EACJ,MAAM;EACN,MAAM,EACJ,aACE,oRACJ;EACA,QAAQ,CAAC;EACT,UAAU,EACR,sBACE,6SACJ;CACF;CACA,gBAAgB,CAAC;CACjB,OAAO,SAAS;EACd,OAAO,EACL,cAAc,MAA8B;GAC1C,IAAI,KAAK,OAAO,SAAS,cAAc;GACvC,IAAI,CAAC,0BAA0B,KAAK,KAAK,OAAO,IAAI,GAAG;GACvD,MAAM,MAAM,KAAK,UAAU;GAC3B,IAAI,CAAC,OAAO,IAAI,SAAS,oBAAoB;GAE7C,IAAI;GACJ,IAAI,mBAAmB;GACvB,IAAI,YAAY;GAChB,KAAK,MAAM,KAAK,IAAI,YAAY;IAC9B,IAAI,EAAE,SAAS,iBAAiB;KAC9B,YAAY;KACZ;IACF;IACA,MAAM,MAAM,WAAW,CAAC;IACxB,IAAI,QAAQ,mBAAmB,CAAC,kBAAkB,EAAE,KAAK,GAAG,oBAAoB;SAC3E,IAAI,QAAQ,mBAAmB,CAAC,kBAAkB,EAAE,KAAK,GAAG,mBAAmB;GACtF;GAGA,IAAI,qBAAqB,CAAC,oBAAoB,CAAC,WAC7C,QAAQ,OAAO;IAAE,MAAM;IAAmB,WAAW;GAAuB,CAAC;EAEjF,EACF;CACF;AACF,CAAC"}
+{"version":3,"file":"token_encoding_requires_context_window.mjs","names":[],"sources":["../../../src/eslint/rules/token_encoding_requires_context_window.ts"],"sourcesContent":["/**\n * @module @nhtio/adk/eslint/rules/token_encoding_requires_context_window\n *\n * Flags a Chat Completions adapter options literal that sets a non-null `tokenEncoding` but omits\n * `contextWindow`.\n *\n * Why: the OpenAI / WebLLM Chat Completions batteries only perform local token counting + overflow\n * protection when BOTH `tokenEncoding` (how to count) and `contextWindow` (the budget to count\n * against) are provided. Setting `tokenEncoding` alone is a footgun — the encoding is configured but\n * there is no ceiling to enforce, so the overflow guard silently never runs. The adapters throw on\n * this cross-field mismatch at iteration time; this rule surfaces it at the construction site.\n *\n * Detects `new OpenAIChatCompletionsAdapter({ … })` / `new WebLLMChatCompletionsAdapter({ … })`\n * (and any `*ChatCompletionsAdapter`) where `tokenEncoding` is present and not `null`/`undefined`\n * while `contextWindow` is absent.\n *\n * Opt-out:\n *   // eslint-disable-next-line adk/token-encoding-requires-context-window -- <reason>\n */\n\nimport { createRule } from './common'\n\nimport type { TSESTree } from '@typescript-eslint/utils'\n\nconst literalKey = (prop: TSESTree.Property): string | undefined => {\n  if (prop.computed) return undefined\n  if (prop.key.type === 'Identifier') return prop.key.name\n  if (prop.key.type === 'Literal' && typeof prop.key.value === 'string') return prop.key.value\n  return undefined\n}\n\nconst isNullOrUndefined = (node: TSESTree.Node): boolean =>\n  (node.type === 'Literal' && node.value === null) ||\n  (node.type === 'Identifier' && node.name === 'undefined')\n\n/** ESLint rule: flags setting a tokenEncoding without also setting a contextWindow. */\nconst tokenEncodingRequiresContextWindowRule = createRule({\n  name: 'token-encoding-requires-context-window',\n  meta: {\n    type: 'problem',\n    docs: {\n      description:\n        'A Chat Completions adapter configured with a non-null `tokenEncoding` must also set `contextWindow`; otherwise token counting is configured but the overflow guard has no budget and never runs. The adapters enforce this at runtime; this surfaces it at the construction site.',\n    },\n    schema: [],\n    messages: {\n      requireContextWindow:\n        '`tokenEncoding` is set but `contextWindow` is missing — the adapter counts tokens with no budget to enforce, so the context-overflow guard never runs. Add `contextWindow`, or drop `tokenEncoding`. Opt out with an eslint-disable-next-line adk/token-encoding-requires-context-window comment + reason.',\n    },\n  },\n  defaultOptions: [],\n  create(context) {\n    return {\n      NewExpression(node: TSESTree.NewExpression) {\n        if (node.callee.type !== 'Identifier') return\n        if (!/ChatCompletionsAdapter$/.test(node.callee.name)) return\n        const arg = node.arguments[0]\n        if (!arg || arg.type !== 'ObjectExpression') return\n\n        let tokenEncodingProp: TSESTree.Property | undefined\n        let hasContextWindow = false\n        let hasSpread = false\n        for (const p of arg.properties) {\n          if (p.type === 'SpreadElement') {\n            hasSpread = true\n            continue\n          }\n          const key = literalKey(p)\n          if (key === 'tokenEncoding' && !isNullOrUndefined(p.value)) tokenEncodingProp = p\n          else if (key === 'contextWindow' && !isNullOrUndefined(p.value)) hasContextWindow = true\n        }\n\n        // A spread could supply contextWindow we can't see — stay conservative, don't flag.\n        if (tokenEncodingProp && !hasContextWindow && !hasSpread) {\n          context.report({ node: tokenEncodingProp, messageId: 'requireContextWindow' })\n        }\n      },\n    }\n  },\n})\n\nexport default tokenEncodingRequiresContextWindowRule\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAwBA,IAAM,cAAc,SAAgD;CAClE,IAAI,KAAK,UAAU,OAAO,KAAA;CAC1B,IAAI,KAAK,IAAI,SAAS,cAAc,OAAO,KAAK,IAAI;CACpD,IAAI,KAAK,IAAI,SAAS,aAAa,OAAO,KAAK,IAAI,UAAU,UAAU,OAAO,KAAK,IAAI;AAEzF;AAEA,IAAM,qBAAqB,SACxB,KAAK,SAAS,aAAa,KAAK,UAAU,QAC1C,KAAK,SAAS,gBAAgB,KAAK,SAAS;;AAG/C,IAAM,yCAAyC,WAAW;CACxD,MAAM;CACN,MAAM;EACJ,MAAM;EACN,MAAM,EACJ,aACE,oRACJ;EACA,QAAQ,CAAC;EACT,UAAU,EACR,sBACE,6SACJ;CACF;CACA,gBAAgB,CAAC;CACjB,OAAO,SAAS;EACd,OAAO,EACL,cAAc,MAA8B;GAC1C,IAAI,KAAK,OAAO,SAAS,cAAc;GACvC,IAAI,CAAC,0BAA0B,KAAK,KAAK,OAAO,IAAI,GAAG;GACvD,MAAM,MAAM,KAAK,UAAU;GAC3B,IAAI,CAAC,OAAO,IAAI,SAAS,oBAAoB;GAE7C,IAAI;GACJ,IAAI,mBAAmB;GACvB,IAAI,YAAY;GAChB,KAAK,MAAM,KAAK,IAAI,YAAY;IAC9B,IAAI,EAAE,SAAS,iBAAiB;KAC9B,YAAY;KACZ;IACF;IACA,MAAM,MAAM,WAAW,CAAC;IACxB,IAAI,QAAQ,mBAAmB,CAAC,kBAAkB,EAAE,KAAK,GAAG,oBAAoB;SAC3E,IAAI,QAAQ,mBAAmB,CAAC,kBAAkB,EAAE,KAAK,GAAG,mBAAmB;GACtF;GAGA,IAAI,qBAAqB,CAAC,oBAAoB,CAAC,WAC7C,QAAQ,OAAO;IAAE,MAAM;IAAmB,WAAW;GAAuB,CAAC;EAEjF,EACF;CACF;AACF,CAAC"}

package/eslint/rules.cjs

@@ -1,10 +1,10 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 require("../chunk-Ble4zEEl.js");
+const require_eslint_rules_artifact_tool_forbids_artifact_constructor = require("./rules/artifact_tool_forbids_artifact_constructor.cjs");
 const require_eslint_rules_no_model_in_tool_handler = require("./rules/no_model_in_tool_handler.cjs");
 const require_eslint_rules_require_validator_any_required = require("./rules/require_validator_any_required.cjs");
 const require_eslint_rules_thought_payload_requires_replay_tag = require("./rules/thought_payload_requires_replay_tag.cjs");
 const require_eslint_rules_token_encoding_requires_context_window = require("./rules/token_encoding_requires_context_window.cjs");
-const require_eslint_rules_artifact_tool_forbids_artifact_constructor = require("./rules/artifact_tool_forbids_artifact_constructor.cjs");
 exports.artifactToolForbidsArtifactConstructor = require_eslint_rules_artifact_tool_forbids_artifact_constructor.default;
 exports.noModelInToolHandler = require_eslint_rules_no_model_in_tool_handler.default;
 exports.requireValidatorAnyRequired = require_eslint_rules_require_validator_any_required.default;

package/eslint/rules.mjs

@@ -1,6 +1,6 @@
+import artifactToolForbidsArtifactConstructorRule from "./rules/artifact_tool_forbids_artifact_constructor.mjs";
 import noModelInToolHandlerRule from "./rules/no_model_in_tool_handler.mjs";
 import requireValidatorAnyRequiredRule from "./rules/require_validator_any_required.mjs";
 import thoughtPayloadRequiresReplayTagRule from "./rules/thought_payload_requires_replay_tag.mjs";
 import tokenEncodingRequiresContextWindowRule from "./rules/token_encoding_requires_context_window.mjs";
-import artifactToolForbidsArtifactConstructorRule from "./rules/artifact_tool_forbids_artifact_constructor.mjs";
 export { artifactToolForbidsArtifactConstructorRule as artifactToolForbidsArtifactConstructor, noModelInToolHandlerRule as noModelInToolHandler, requireValidatorAnyRequiredRule as requireValidatorAnyRequired, thoughtPayloadRequiresReplayTagRule as thoughtPayloadRequiresReplayTag, tokenEncodingRequiresContextWindowRule as tokenEncodingRequiresContextWindow };

package/eslint.cjs

@@ -3,11 +3,11 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 require("./chunk-Ble4zEEl.js");
+const require_eslint_rules_artifact_tool_forbids_artifact_constructor = require("./eslint/rules/artifact_tool_forbids_artifact_constructor.cjs");
 const require_eslint_rules_no_model_in_tool_handler = require("./eslint/rules/no_model_in_tool_handler.cjs");
 const require_eslint_rules_require_validator_any_required = require("./eslint/rules/require_validator_any_required.cjs");
 const require_eslint_rules_thought_payload_requires_replay_tag = require("./eslint/rules/thought_payload_requires_replay_tag.cjs");
 const require_eslint_rules_token_encoding_requires_context_window = require("./eslint/rules/token_encoding_requires_context_window.cjs");
-const require_eslint_rules_artifact_tool_forbids_artifact_constructor = require("./eslint/rules/artifact_tool_forbids_artifact_constructor.cjs");
 //#region src/eslint/index.ts
 /**
 * @module @nhtio/adk/eslint
@@ -49,7 +49,7 @@ var rules = {
 var plugin = {
 	meta: {
 		name: "@nhtio/adk/eslint",
-		version: "1.20260607.2"
+		version: "1.20260609.1"
 	},
 	rules
 };

package/eslint.mjs

@@ -1,8 +1,8 @@
+import artifactToolForbidsArtifactConstructorRule from "./eslint/rules/artifact_tool_forbids_artifact_constructor.mjs";
 import noModelInToolHandlerRule from "./eslint/rules/no_model_in_tool_handler.mjs";
 import requireValidatorAnyRequiredRule from "./eslint/rules/require_validator_any_required.mjs";
 import thoughtPayloadRequiresReplayTagRule from "./eslint/rules/thought_payload_requires_replay_tag.mjs";
 import tokenEncodingRequiresContextWindowRule from "./eslint/rules/token_encoding_requires_context_window.mjs";
-import artifactToolForbidsArtifactConstructorRule from "./eslint/rules/artifact_tool_forbids_artifact_constructor.mjs";
 //#region src/eslint/index.ts
 /**
 * @module @nhtio/adk/eslint
@@ -44,7 +44,7 @@ var rules = {
 var plugin = {
 	meta: {
 		name: "@nhtio/adk/eslint",
-		version: "1.20260607.2"
+		version: "1.20260609.1"
 	},
 	rules
 };

package/{exceptions-BeWH2FwP.mjs → exceptions-BDhN0Xzr.mjs}

@@ -62,6 +62,7 @@ var BaseException = class BaseException extends Error {
 		if (help !== void 0) this.help = help;
 		Error.captureStackTrace(this, ErrorConstructor);
 	}
+	/** Tag used by `Object.prototype.toString` — reports the concrete exception class name. */
 	get [Symbol.toStringTag]() {
 		return this.constructor.name;
 	}
@@ -203,7 +204,7 @@ var asyncValidateOrThrow = async (schema, value, convert = false) => {
 * @typeParam T - Tuple of printf format argument types. Pass a non-empty tuple to require
 *   callers to supply interpolation values at the throw site.
 *
-* @param name - The `name` property set on thrown instances (used by {@link isNamedException}).
+* @param name - The `name` property set on thrown instances (used by `isNamedException`).
 * @param message - Printf-style template string for the error message.
 * @param code - Machine-readable error code stored on the static and instance `code` property.
 * @param status - HTTP status code associated with this exception class.
@@ -241,4 +242,4 @@ var createException = (name, message, code, status, fatal) => {
 //#endregion
 export { validateOrThrow as a, passesSchema as i, ValidationException as n, BaseException as o, asyncValidateOrThrow as r, createException as t };
 
-//# sourceMappingURL=exceptions-BeWH2FwP.mjs.map
+//# sourceMappingURL=exceptions-BDhN0Xzr.mjs.map