@jini-ai/core 0.6.15-rc.1 → 0.6.15

package/dist/tool-input-normalization.d.ts

@@ -1,4 +1,3 @@
-import type { ToolRegistration } from './tool-registry.js';
 export { ToolInputNormalizationError } from './tool-input-errors.js';
 /** A value-free account of canonicalization; domain hooks use the same contract as the gate. */
 export interface NormalizedToolInput {
@@ -8,8 +7,17 @@ export interface NormalizedToolInput {
 export type ToolInputNormalizer = (required: {
     input: Readonly<Record<string, unknown>>;
 }, optional?: Record<string, never>) => NormalizedToolInput | Promise<NormalizedToolInput>;
+/** Only the registration facts consumed by normalization; carries no execution authority. */
+interface NormalizationRegistration {
+    readonly descriptor: {
+        readonly id: string;
+        readonly inputSchema?: unknown;
+    };
+    readonly invocationSchema?: unknown;
+    readonly normalizeInput?: ToolInputNormalizer;
+}
 /** Canonicalize one batch layer (including declared aliases) before merging; leave value conversion
- * and domain hooks for final normalization. Throws ToolInputError for collisions within this layer, never across
+ * and domain hooks for final normalization. Throws ToolInputError for differing colliding values within this layer, never across
  * layers. Uses the same bounded schema walk as normalizeToolInput.
  * @example canonicalizeToolInputKeys({ input: { max_chars: '1000' }, schema });
  */
@@ -28,7 +36,7 @@ export declare function canonicalizeToolInputKeys({ input, schema }: {
  */
 export declare function normalizeToolInput({ input, registration }: {
     input: unknown;
-    registration: Pick<ToolRegistration, 'descriptor' | 'normalizeInput' | 'invocationSchema'>;
+    registration: NormalizationRegistration;
 }, _options?: Record<string, never>): Promise<NormalizedToolInput>;
 /** Keep result shapes intact and make rewrite notes visible in plain and MCP tool results. */
 export declare function withNormalizationNotes({ output, notes }: {

package/dist/tool-input-normalization.js

@@ -117,10 +117,14 @@ function unknownKeyError({ key, location, shape }, _options = {}) {
     const names = [...shape.names.filter(name => required.has(name)), ...shape.names.filter(name => !required.has(name))];
     const declared = names.map(name => `${name} (${required.has(name) ? 'required' : 'optional'})`).join(', ') || 'none';
     const hints = names.filter(name => nearMiss({ left: keyShape(key), right: keyShape(name) }));
-    const suggestion = hints.length ? ` Did you mean ${hints.map(name => `'${name}'`).join(', ')}?` : '';
+    const quotedHints = hints.map(name => `'${name}'`).join(', ');
+    const suggestion = hints.length ? ` Did you mean ${quotedHints}?` : '';
     return new ToolInputError({ message: `Unknown input '${location}'. Declared inputs: ${declared}.${suggestion} Resend with the declared name.` });
 }
-/** One key of an object: canonical rename + recursion, closed-schema refusal, or open pass-through. */
+/** One key of an object: canonical rename + recursion, closed-schema refusal, or open pass-through.
+ * Agreeing scalar aliases coalesce after coercion; differing values still fail without disclosure.
+ * @complexity The bounded child walk plus O(1) source/value checks.
+ */
 function normalizeEntry({ key, raw, shape, sources, step }) {
     const { path, depth, walk } = step;
     const location = path ? `${path}.${key}` : key;
@@ -131,13 +135,15 @@ function normalizeEntry({ key, raw, shape, sources, step }) {
         const childSchema = object(shape.schema.additionalProperties) ? shape.schema.additionalProperties : undefined;
         return [key, normalizeValue({ value: raw, schema: childSchema, step: { path: location, depth: depth + 1, walk } })];
     }
-    const previous = sources.get(target);
-    if (previous !== undefined)
-        throw new ToolInputError({ message: `Conflicting inputs '${previous}' and '${key}' both name '${target}'. Send only '${target}'.` });
-    sources.set(target, key);
     if (target !== key)
         walk.notes.push(`${location}→${target}`);
-    return [target, normalizeValue({ value: raw, schema: shape.properties[target], step: { path: `${path ? `${path}.` : ''}${target}`, depth: depth + 1, walk } })];
+    const parentPrefix = path ? `${path}.` : '';
+    const value = normalizeValue({ value: raw, schema: shape.properties[target], step: { path: `${parentPrefix}${target}`, depth: depth + 1, walk } });
+    const previous = sources.get(target);
+    if (previous !== undefined && !Object.is(previous.value, value))
+        throw new ToolInputError({ message: `Conflicting inputs '${previous.key}' and '${key}' both name '${target}'. Send only '${target}'.` });
+    sources.set(target, { key, value });
+    return [target, value];
 }
 function normalizeObject({ value, schema, step }) {
     const properties = object(schema.properties) ? schema.properties : {};
@@ -170,7 +176,7 @@ function walkRoot({ input, schema, notes, validateClosed, keysOnly }) {
     return normalizeValue({ value: input, schema, step: { path: '', depth: 0, walk: { notes, validateClosed, keysOnly } } });
 }
 /** Canonicalize one batch layer (including declared aliases) before merging; leave value conversion
- * and domain hooks for final normalization. Throws ToolInputError for collisions within this layer, never across
+ * and domain hooks for final normalization. Throws ToolInputError for differing colliding values within this layer, never across
  * layers. Uses the same bounded schema walk as normalizeToolInput.
  * @example canonicalizeToolInputKeys({ input: { max_chars: '1000' }, schema });
  */

package/dist/tool-metadata-types.d.ts

@@ -7,6 +7,11 @@ export interface ToolApprovalMetadata {
     readonly rule?: string;
 }
 export interface ToolMetadata<A extends ToolApprovalMetadata = ToolApprovalMetadata> {
+    /** Human-facing action name and optional button verb; presentation only, never authority. */
+    readonly title?: string;
+    /** Plain-language consequence shown before approval; never used to classify or authorize. */
+    readonly summary?: string;
+    readonly actionVerb?: string;
     /** Installed guidance capabilities needed by a writer; independent of permission and risk. */
     readonly guidanceCapabilities?: readonly string[];
     readonly search?: {

package/dist/tool-registry.d.ts

@@ -163,6 +163,11 @@ export interface ToolExecutionContext {
 /** Optional handler ports supplied by the invoking transport. */
 export interface ToolExecutionOptions {
     readonly emitSurface?: SurfaceEmitter;
+    /** Reports the human wait to the executor so concurrent writes can be refused. This is
+     * notification only; it never supplies a confirmation decision or grants authority. */
+    readonly onApprovalStateChange?: (required: {
+        pending: boolean;
+    }, optional?: Record<string, never>) => void;
     /** Invoke through the same executor, retaining this call's principal, run, cancellation and
      * transport gates. Rejects on denial, failed confirmation, validation or execution failure.
      * A composition-owned registry may retain a source registration behind a derived catalog card.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jini-ai/core",
-  "version": "0.6.15-rc.1",
+  "version": "0.6.15",
   "description": "The Jini kernel: typed DI tokens, pack composition and lifecycle, the tool registry, redaction, and origin/API-token auth primitives. Zero dependencies.",
   "license": "Apache-2.0",
   "repository": {