@ziggs-ai/agent-sdk 0.10.2 → 0.10.4

package/dist/agent/toolManagerToSdkMcp.js

@@ -53,6 +53,25 @@ function parametersToZodShape(parameters) {
     }
     return shape;
 }
+/**
+ * ZIG-1215 — the Claude brain's args are validated here, before `eff` hands
+ * them to the shared executor, so a plain shape means an unknown param is
+ * stripped at this layer and ToolManager's own check never sees it. Closing
+ * the object is what makes the rejection reach the brain: the call fails with
+ * the offending key named, instead of succeeding on a request it silently
+ * altered. The published schema also carries `additionalProperties: false`,
+ * so the typo is usually caught before the call is made at all.
+ */
+function strictParams(toolName, shape) {
+    const accepted = Object.keys(shape).join(', ') || '(none)';
+    return z.strictObject(shape, {
+        error: (issue) => issue.code === 'unrecognized_keys'
+            ? `Unknown parameter(s) ${issue.keys.map((k) => `"${k}"`).join(', ')} — ` +
+                `${toolName} did not run. Accepted params: ${accepted}. ` +
+                `Check for a typo and call again; nothing was changed.`
+            : undefined,
+    });
+}
 function toCallToolResult(value) {
     const text = typeof value === 'string' ? value : JSON.stringify(value, null, 2);
     return { content: [{ type: 'text', text }] };
@@ -71,9 +90,10 @@ export function buildSdkToolDefs(toolDefs, getContext) {
         const name = String(fn['name'] ?? '');
         const description = String(fn['description'] ?? name);
         const shape = parametersToZodShape(fn['parameters']);
-        const inputSchema = Object.keys(shape).length > 0
-            ? shape
-            : { _: z.record(z.string(), z.unknown()).optional() };
+        // A zero-param tool keeps the `_` envelope the Claude SDK needs, but the
+        // envelope itself is closed too — its free-form payload is still checked
+        // against the tool's own schema downstream in ToolManager.
+        const inputSchema = strictParams(name, Object.keys(shape).length > 0 ? shape : { _: z.record(z.string(), z.unknown()).optional() });
         return {
             name,
             description,

package/dist/tools/ToolManager.js

@@ -9,6 +9,25 @@ function makeError(message, type, extra) {
         Object.assign(err, extra);
     return err;
 }
+/**
+ * ZIG-1215 — Ajv's own wording for a rejected unknown param is "must NOT have
+ * additional properties", which names neither the offending key nor the ones
+ * that would have worked. An agent reading that has nothing to correct against,
+ * so the typo is named alongside the menu it should have come from.
+ */
+function describeErrors(parameters, errors) {
+    const unknown = (errors ?? [])
+        .map((e) => e)
+        .filter((e) => e.keyword === 'additionalProperties')
+        .map((e) => e.params?.additionalProperty)
+        .filter((k) => typeof k === 'string');
+    if (unknown.length === 0)
+        return ajv.errorsText(errors);
+    const props = parameters.properties ?? {};
+    const accepted = Object.keys(props).join(', ') || '(none)';
+    return (`unknown parameter(s) ${unknown.map((k) => `"${k}"`).join(', ')} — ` +
+        `accepted params: ${accepted}. Check for a typo and call again; nothing was changed.`);
+}
 function stripNullish(args) {
     if (!args || typeof args !== 'object' || Array.isArray(args))
         return args;
@@ -68,7 +87,7 @@ export class ToolManager extends ToolProvider {
         const validate = ajv.compile(parameters);
         if (!validate(args)) {
             const name = tool.schema.function?.['name'];
-            throw makeError(`Invalid args for "${name}": ${ajv.errorsText(validate.errors)}`, 'validation_error', { data: { errors: validate.errors } });
+            throw makeError(`Invalid args for "${name}": ${describeErrors(parameters, validate.errors)}`, 'validation_error', { data: { errors: validate.errors } });
         }
     }
 }

package/dist/tools/defineTool.js

@@ -48,7 +48,14 @@ export function defineTool(name, params, handler, options = {}) {
         throw new Error('defineTool: name is required');
     if (!handler || typeof handler !== 'function')
         throw new Error('defineTool: handler function is required');
-    const parameters = convertObject(params || {});
+    // ZIG-1215 — the top level is closed so a misspelled param is rejected by
+    // ToolManager's Ajv pass instead of being dropped on the floor. JSON Schema
+    // allows unknown keys by default, so without this the validation ran and
+    // passed while the handler quietly ignored what the model asked for.
+    // Nested objects stay open: the typo class this guards against is at the
+    // call surface the model writes, and closing nested payloads (task result,
+    // plan) would reject shapes the backend accepts.
+    const parameters = { ...convertObject(params || {}), additionalProperties: false };
     const fn = { name, parameters };
     if (options.description)
         fn['description'] = options.description;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ziggs-ai/agent-sdk",
-  "version": "0.10.2",
+  "version": "0.10.4",
   "description": "Agent framework SDK for building autonomous agents on the Ziggs platform",
   "type": "module",
   "main": "dist/index.js",
@@ -26,7 +26,7 @@
     "@anthropic-ai/claude-agent-sdk": "^0.3.204",
     "@anthropic-ai/sdk": "^0.110.0",
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "@ziggs-ai/api-client": "^0.9.1",
+    "@ziggs-ai/api-client": "^0.9.3",
     "ajv": "^8.17.1",
     "dotenv": "^17.2.3",
     "openai": "^4.0.0",