@tabbybyte/kimten 0.1.1 → 0.1.2

package/README.md

@@ -145,7 +145,10 @@ Create a new cat.
 
 ### Optional (extra whiskers)
 
-* `toys` → object map of async functions (tools the model may call), default: `{}`
+* `toys` → object map of tool definitions. Each entry can be:
+  * async function shorthand: `async (args) => result`
+  * object form: `{ inputSchema?, description?, strict?, execute }`
+  default: `{}`
 * `personality` → system prompt / behavior description (default: `"You are a helpful assistant."`)
 * `hops` → max agent loop steps (default: `10`)  
   prevents infinite zoomies 🌀
@@ -194,7 +197,7 @@ Refer to https://ai-sdk.dev/docs/foundations/providers-and-models
 
 ### Add tools freely
 
-Tools are just async functions:
+Tools can stay simple:
 
 ```js
 toys: {
@@ -207,6 +210,22 @@ toys: {
 
 The model decides when to use them.
 
+For stronger arg validation and better tool selection, use object form:
+
+```js
+import { z } from 'zod';
+
+toys: {
+  add: {
+    description: 'Add two numbers.',
+    inputSchema: z.object({ a: z.number(), b: z.number() }),
+    async execute({ a, b }) {
+      return a + b;
+    },
+  },
+}
+```
+
 ### Structured output = sanity
 
 Use Zod schemas whenever possible.  

package/lib/tools.js

@@ -16,21 +16,21 @@ export function normalizeToys(toys) {
   }
 
   if (!isPlainObject(toys)) {
-    throw new TypeError('Kimten config "toys" must be an object map of functions.');
+    throw new TypeError('Kimten config "toys" must be an object map of functions or tool definitions.');
   }
 
   const wrapped = {};
 
-  for (const [name, fn] of Object.entries(toys)) {
-    if (typeof fn !== 'function') {
-      throw new TypeError(`Kimten tool "${name}" must be a function.`);
-    }
+  for (const [name, entry] of Object.entries(toys)) {
+    const definition = normalizeToyDefinition(name, entry);
 
     wrapped[name] = tool({
-      inputSchema: z.any(),
+      inputSchema: definition.inputSchema,
+      ...(definition.description ? { description: definition.description } : {}),
+      ...(definition.strict !== undefined ? { strict: definition.strict } : {}),
       async execute(args) {
         try {
-          const result = await fn(args);
+          const result = await definition.execute(args);
           return toJsonSafe(result);
         } catch (error) {
           return {
@@ -45,6 +45,40 @@ export function normalizeToys(toys) {
   return wrapped;
 }
 
+function normalizeToyDefinition(name, entry) {
+  if (typeof entry === 'function') {
+    return {
+      inputSchema: z.any(),
+      execute: entry,
+    };
+  }
+
+  if (!isPlainObject(entry)) {
+    throw new TypeError(
+      `Kimten tool "${name}" must be a function or an object with execute(args).`
+    );
+  }
+
+  if (typeof entry.execute !== 'function') {
+    throw new TypeError(`Kimten tool "${name}" object form must include execute(args).`);
+  }
+
+  if (entry.description !== undefined && typeof entry.description !== 'string') {
+    throw new TypeError(`Kimten tool "${name}" description must be a string when provided.`);
+  }
+
+  if (entry.strict !== undefined && typeof entry.strict !== 'boolean') {
+    throw new TypeError(`Kimten tool "${name}" strict must be a boolean when provided.`);
+  }
+
+  return {
+    inputSchema: entry.inputSchema ?? z.any(),
+    execute: entry.execute,
+    description: entry.description,
+    strict: entry.strict,
+  };
+}
+
 function toJsonSafe(value) {
   if (value === undefined) {
     return null;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tabbybyte/kimten",
-  "version": "0.1.1",
-    "publishConfig": {
+  "version": "0.1.2",
+  "publishConfig": {
     "access": "public"
   },
   "description": "A micro-agent library: thin wrapper over the Agent interface from Vercel's AI SDK Core v6+",