exoagent 0.0.11 → 0.0.13

package/dist/rpc-toolset-test-helpers.d.ts

@@ -1,5 +1,4 @@
-import { RpcToolset } from './rpc-toolset';
-export declare class TestToolset extends RpcToolset {
+export declare class TestToolset {
     add(input: {
         a: number;
         b: number;
@@ -9,7 +8,7 @@ export declare class TestToolset extends RpcToolset {
         id: string;
     }): Promise<typeof User>;
 }
-export declare class TestToolset2 extends RpcToolset {
+export declare class TestToolset2 {
     subtract(input: {
         a: number;
         b: number;
@@ -20,7 +19,6 @@ declare const User_base: Omit<import('./sql').TableClass<"users">, keyof import(
         remapColumns?: boolean;
     };
     column: (this: InstanceType<import('./sql').TableClass<string>>, columnName: string) => import('./sql/expression').ColumnReferenceExpression;
-    __RPC_TARGET_BRAND: never;
 });
 export declare class User extends User_base {
     id: import('./sql/expression').ColumnReferenceExpression;
@@ -34,7 +32,6 @@ declare const Post_base: Omit<import('./sql').TableClass<"posts">, keyof import(
         remapColumns?: boolean;
     };
     column: (this: InstanceType<import('./sql').TableClass<string>>, columnName: string) => import('./sql/expression').ColumnReferenceExpression;
-    __RPC_TARGET_BRAND: never;
 });
 export declare class Post extends Post_base {
     id: import('./sql/expression').ColumnReferenceExpression;

package/dist/sql/builder.d.ts

@@ -1,5 +1,4 @@
 import { CompiledQuery, Dialect } from 'kysely';
-import { ToolCallback, RpcToolset } from '../rpc-toolset';
 import { SqlExpressionIn, ColumnReferenceExpression, OrderByValue, SqlExpression } from './expression';
 import { RawSql } from './sql';
 type RowLikeRaw = {
@@ -26,7 +25,7 @@ export declare const isFromItem: (value: unknown) => value is FromItem<string, R
 type TableNamespace = {
     [key: string]: RowLike;
 };
-type OrderByItem<TN extends TableNamespace> = NamespacedExpression<TN, SqlExpression | SqlExpression[] | OrderByValue | OrderByValue[] | (SqlExpression | OrderByValue)[]>;
+type OrderByItem = SqlExpression | SqlExpression[] | OrderByValue | OrderByValue[] | (SqlExpression | OrderByValue)[];
 type Tables<TN extends TableNamespace> = {
     [k in keyof TN & string]: {
         fromItem: FromItem<k, TN[k]>;
@@ -46,7 +45,7 @@ type QueryBuilderParams<N extends string, TN extends TableNamespace, S extends R
     offset?: number;
     rawTable: TableClass<N> | undefined;
 };
-declare class QueryBuilder<N extends string, TN extends TableNamespace, S extends RowLike> extends RpcToolset implements FromItem<N, S> {
+declare class QueryBuilder<N extends string, TN extends TableNamespace, S extends RowLike> implements FromItem<N, S> {
     #private;
     readonly alias: N;
     private selectRowLike;
@@ -56,9 +55,9 @@ declare class QueryBuilder<N extends string, TN extends TableNamespace, S extend
     private arg;
     private rawTable;
     constructor(params: QueryBuilderParams<N, TN, S>);
-    select<S2 extends RowLikeIn>(select: ToolCallback<(arg: TN) => S2>): QueryBuilder<N, TN, AsRowLike<S2>>;
-    where(where: ToolCallback<(arg: TN) => SqlExpressionIn>): QueryBuilder<N, TN, S>;
-    orderBy(orderBy: ToolCallback<OrderByItem<TN>>): QueryBuilder<N, TN, S>;
+    select<S2 extends RowLikeIn>(select: (arg: TN) => S2): QueryBuilder<N, TN, AsRowLike<S2>>;
+    where(where: (arg: TN) => SqlExpressionIn): QueryBuilder<N, TN, S>;
+    orderBy(orderBy: (arg: TN) => OrderByItem): QueryBuilder<N, TN, S>;
     limit(limit: number): QueryBuilder<N, TN, S>;
     offset(offset: number): QueryBuilder<N, TN, S>;
     join<N2 extends string, F2 extends TableClass<N2>>(fromItem: F2 | NamespacedExpression<TN, F2>, on?: NamespacedExpression<TN & {
@@ -84,7 +83,7 @@ declare class QueryBuilder<N extends string, TN extends TableNamespace, S extend
         isSubquery?: boolean;
     }) => import('kysely').RawBuilder<unknown>;
 }
-declare class TableBase extends RpcToolset {
+declare class TableBase {
     opts?: {
         remapColumns?: boolean;
     };

package/dist/sql/expression.d.ts

@@ -1,10 +1,9 @@
 import { RawSql } from './sql';
-import { RpcToolset } from '../rpc-toolset';
 type LiteralValue = number | string | boolean | null;
 export type SqlExpressionIn = LiteralValue | SqlExpression;
 export declare const asSqlExpression: (value: LiteralValue | SqlExpression) => SqlExpression;
 export declare const isSqlExpressionIn: (value: unknown) => value is SqlExpressionIn;
-export declare class SqlExpression extends RpcToolset {
+export declare class SqlExpression {
     precedence: number;
     constructor(precedence?: number);
     compile: () => RawSql;

package/dist/sql.mjs

@@ -9,15 +9,15 @@ var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { en
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __decoratorStart = (base) => [, , , __create(base?.[__knownSymbol("metadata")] ?? null)];
 var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
-var __expectFn = (fn) => fn !== void 0 && typeof fn !== "function" ? __typeError("Function expected") : fn;
-var __decoratorContext = (kind, name, done, metadata, fns) => ({ kind: __decoratorStrings[kind], name, metadata, addInitializer: (fn) => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null)) });
+var __expectFn = (fn2) => fn2 !== void 0 && typeof fn2 !== "function" ? __typeError("Function expected") : fn2;
+var __decoratorContext = (kind, name, done, metadata, fns) => ({ kind: __decoratorStrings[kind], name, metadata, addInitializer: (fn2) => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn2 || null)) });
 var __decoratorMetadata = (array, target) => __defNormalProp(target, __knownSymbol("metadata"), array[3]);
 var __runInitializers = (array, flags, self, value) => {
   for (var i = 0, fns = array[flags >> 1], n = fns && fns.length; i < n; i++) flags & 1 ? fns[i].call(self) : value = fns[i].call(self, value);
   return value;
 };
 var __decorateElement = (array, flags, name, decorators, target, extra) => {
-  var fn, it, done, ctx, access, k = flags & 7, s = !!(flags & 8), p = !!(flags & 16);
+  var fn2, it, done, ctx, access, k = flags & 7, s = !!(flags & 8), p = !!(flags & 16);
   var j = k > 3 ? array.length + 1 : k ? s ? 1 : 2 : 0, key = __decoratorStrings[k + 5];
   var initializers = k > 3 && (array[j - 1] = []), extraInitializers = array[j] || (array[j] = []);
   var desc = k && (!p && !s && (target = target.prototype), k < 5 && (k > 3 || !p) && __getOwnPropDesc(k < 4 ? target : { get [name]() {
@@ -36,7 +36,7 @@ var __decorateElement = (array, flags, name, decorators, target, extra) => {
     it = (0, decorators[i])(k ? k < 4 ? p ? extra : desc[key] : k > 4 ? void 0 : { get: desc.get, set: desc.set } : target, ctx), done._ = 1;
     if (k ^ 4 || it === void 0) __expectFn(it) && (k > 4 ? initializers.unshift(it) : k ? p ? extra = it : desc[key] = it : target = it);
     else if (typeof it !== "object" || it === null) __typeError("Object expected");
-    else __expectFn(fn = it.get) && (desc.get = fn), __expectFn(fn = it.set) && (desc.set = fn), __expectFn(fn = it.init) && initializers.unshift(fn);
+    else __expectFn(fn2 = it.get) && (desc.get = fn2), __expectFn(fn2 = it.set) && (desc.set = fn2), __expectFn(fn2 = it.init) && initializers.unshift(fn2);
   }
   return k || __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
 };
@@ -47,11 +47,11 @@ var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read fr
 var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
 var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
-var _desc_dec, _asc_dec, ___dec, ___dec2, ___dec3, ___dec4, ___dec5, _NOT_LIKE_dec, _LIKE_dec, ____dec, ____dec2, ___dec6, ____dec3, ___dec7, ____dec4, ___dec8, _isNotNull_dec, _isNull_dec, _not_dec, _and_dec, _or_dec, _a, _init, _execute_dec, _join_dec, _offset_dec, _limit_dec, _orderBy_dec, _where_dec, _select_dec, _b, _db, _limit, _offset, _init2;
+var _desc_dec, _asc_dec, ___dec, ___dec2, ___dec3, ___dec4, ___dec5, _NOT_LIKE_dec, _LIKE_dec, ____dec, ____dec2, ___dec6, ____dec3, ___dec7, ____dec4, ___dec8, _isNotNull_dec, _isNull_dec, _not_dec, _and_dec, _or_dec, _init, _execute_dec, _join_dec, _offset_dec, _limit_dec, _orderBy_dec, _where_dec, _select_dec, _db, _limit, _offset, _init2;
 import { sql as sql$1, Kysely } from "kysely";
 import invariant from "tiny-invariant";
 import z from "zod";
-import { R as RpcToolset, t as tool, s as setToolMetadata } from "./rpc-toolset-BnC2BXPq.js";
+import { a as tool, r as registerToolField, f as fn } from "./tool-DGs9ZxVn.js";
 const sql = sql$1;
 const buildSql = (parts, separator = sql$1` `) => {
   return sql$1.join(parts.filter((x) => x != null), separator);
@@ -65,9 +65,9 @@ const isSqlExpressionIn = (value) => {
 const zSqlExpression = z.custom((val) => val instanceof SqlExpression);
 const zNumericSqlExpression = z.union([zSqlExpression, z.number(), z.string()]);
 const zSqlExpressionIn = z.union([zSqlExpression, z.number(), z.string(), z.boolean(), z.null()]);
-class SqlExpression extends (_a = RpcToolset, _or_dec = [tool(zSqlExpression)], _and_dec = [tool(zSqlExpression)], _not_dec = [tool()], _isNull_dec = [tool()], _isNotNull_dec = [tool()], ___dec8 = [tool(zNumericSqlExpression)], ____dec4 = [tool(zNumericSqlExpression)], ___dec7 = [tool(zNumericSqlExpression)], ____dec3 = [tool(zNumericSqlExpression)], ___dec6 = [tool(zSqlExpressionIn)], ____dec2 = [tool(zSqlExpressionIn)], ____dec = [tool(zSqlExpressionIn)], _LIKE_dec = [tool(z.union([zSqlExpression, z.string()]))], _NOT_LIKE_dec = [tool(z.union([zSqlExpression, z.string()]))], ___dec5 = [tool(zNumericSqlExpression)], ___dec4 = [tool(zNumericSqlExpression)], ___dec3 = [tool(zNumericSqlExpression)], ___dec2 = [tool(zNumericSqlExpression)], ___dec = [tool(zNumericSqlExpression)], _asc_dec = [tool()], _desc_dec = [tool()], _a) {
+_or_dec = [tool(zSqlExpression)], _and_dec = [tool(zSqlExpression)], _not_dec = [tool()], _isNull_dec = [tool()], _isNotNull_dec = [tool()], ___dec8 = [tool(zNumericSqlExpression)], ____dec4 = [tool(zNumericSqlExpression)], ___dec7 = [tool(zNumericSqlExpression)], ____dec3 = [tool(zNumericSqlExpression)], ___dec6 = [tool(zSqlExpressionIn)], ____dec2 = [tool(zSqlExpressionIn)], ____dec = [tool(zSqlExpressionIn)], _LIKE_dec = [tool(z.union([zSqlExpression, z.string()]))], _NOT_LIKE_dec = [tool(z.union([zSqlExpression, z.string()]))], ___dec5 = [tool(zNumericSqlExpression)], ___dec4 = [tool(zNumericSqlExpression)], ___dec3 = [tool(zNumericSqlExpression)], ___dec2 = [tool(zNumericSqlExpression)], ___dec = [tool(zNumericSqlExpression)], _asc_dec = [tool()], _desc_dec = [tool()];
+class SqlExpression {
   constructor(precedence = 100) {
-    super();
     __runInitializers(_init, 5, this);
     // `= () => ` to ensure the method is a direct property of the class instance,
     // not a method of the class prototype
@@ -140,7 +140,7 @@ class SqlExpression extends (_a = RpcToolset, _or_dec = [tool(zSqlExpression)],
     return new OrderByValue(this, sql`DESC`);
   }
 }
-_init = __decoratorStart(_a);
+_init = __decoratorStart(null);
 __decorateElement(_init, 1, "or", _or_dec, SqlExpression);
 __decorateElement(_init, 1, "and", _and_dec, SqlExpression);
 __decorateElement(_init, 1, "not", _not_dec, SqlExpression);
@@ -294,13 +294,19 @@ const combinePredicates = (...predicates) => {
   }
   return filtered.reduce((acc, predicate) => acc.and(predicate));
 };
+const isOrderByItem = (value) => {
+  if (Array.isArray(value)) {
+    return value.every((e) => e instanceof SqlExpression || e instanceof OrderByValue);
+  }
+  return value instanceof SqlExpression || value instanceof OrderByValue;
+};
 const namespacedArg = (tables) => {
   return Object.fromEntries(Object.entries(tables).map(([k, v]) => [k, v.fromItem.toRowLike()]));
 };
-const _QueryBuilder = class _QueryBuilder extends (_b = RpcToolset, _select_dec = [tool.callback()], _where_dec = [tool.callback()], _orderBy_dec = [tool.callback()], _limit_dec = [tool(z.number().int().nonnegative())], _offset_dec = [tool(z.number().int().nonnegative())], _join_dec = [tool.unsafeNoValidation()], _execute_dec = [tool()], _b) {
+_select_dec = [tool(fn.returns(z.any()))], _where_dec = [tool(fn.returns(z.custom(isSqlExpressionIn)))], _orderBy_dec = [tool(fn.returns(z.custom(isOrderByItem)))], _limit_dec = [tool(z.number().int().nonnegative())], _offset_dec = [tool(z.number().int().nonnegative())], _join_dec = [tool(z.any(), z.any())], _execute_dec = [tool()];
+const _QueryBuilder = class _QueryBuilder {
   // set only when created directly from a TableClass
   constructor(params) {
-    super();
     __runInitializers(_init2, 5, this);
     __privateAdd(this, _db);
     __publicField(this, "alias");
@@ -370,32 +376,22 @@ const _QueryBuilder = class _QueryBuilder extends (_b = RpcToolset, _select_dec
     this.rawTable = params.rawTable;
   }
   select(select) {
-    const selectUnwrapped = tool.unwrap(select, isRowLikeIn);
-    return selectUnwrapped(this.arg, (result) => {
-      return new _QueryBuilder({ ...this.paramsForCopy(), selectRowLike: asRowLike(result) });
-    });
+    const result = select(this.arg);
+    invariant(isRowLikeIn(result), "select must return a RowLikeIn");
+    return new _QueryBuilder({ ...this.paramsForCopy(), selectRowLike: asRowLike(result) });
   }
   where(where) {
-    const whereUnwrapped = tool.unwrap(where, isSqlExpressionIn);
-    return whereUnwrapped(this.arg, (result) => {
-      return new _QueryBuilder({ ...this.paramsForCopy(), whereExpression: combinePredicates(this.whereExpression, asSqlExpression(result)) });
-    });
+    const result = where(this.arg);
+    return new _QueryBuilder({ ...this.paramsForCopy(), whereExpression: combinePredicates(this.whereExpression, asSqlExpression(result)) });
   }
   orderBy(orderBy) {
-    const orderByUnwrapped = tool.unwrap(orderBy, (arg) => {
-      if (Array.isArray(arg)) {
-        return arg.every((e) => e instanceof SqlExpression || e instanceof OrderByValue);
-      }
-      return arg instanceof SqlExpression || arg instanceof OrderByValue;
-    });
-    return orderByUnwrapped(this.arg, (raw) => {
-      const rawArray = Array.isArray(raw) ? raw : [raw];
-      const exprs = rawArray.map((e) => {
-        invariant(e instanceof SqlExpression || e instanceof OrderByValue, "orderBy must return a SqlExpression/OrderByValue or an array of SqlExpressions/OrderByValues");
-        return e instanceof SqlExpression ? new OrderByValue(e) : e;
-      });
-      return new _QueryBuilder({ ...this.paramsForCopy(), orderByExpressions: (this.orderByExpressions ?? []).concat(exprs) });
+    const raw = orderBy(this.arg);
+    const rawArray = Array.isArray(raw) ? raw : [raw];
+    const exprs = rawArray.map((e) => {
+      invariant(e instanceof SqlExpression || e instanceof OrderByValue, "orderBy must return a SqlExpression/OrderByValue or an array of SqlExpressions/OrderByValues");
+      return e instanceof SqlExpression ? new OrderByValue(e) : e;
     });
+    return new _QueryBuilder({ ...this.paramsForCopy(), orderByExpressions: (this.orderByExpressions ?? []).concat(exprs) });
   }
   limit(limit) {
     invariant(typeof limit === "number" && limit >= 0, "limit must be greater than or equal to 0");
@@ -407,44 +403,42 @@ const _QueryBuilder = class _QueryBuilder extends (_b = RpcToolset, _select_dec
   }
   join(fromItem, on) {
     const fromItemCallbackRaw = isFromItem(fromItem) ? () => fromItem : fromItem;
-    const fromItemCallback = tool.unwrap(fromItemCallbackRaw, isFromItem);
-    const res = fromItemCallback(this.arg, (fromItemResolved) => {
-      if (fromItemResolved instanceof _QueryBuilder && fromItemResolved.rawTable) {
-        fromItemResolved = fromItemResolved.rawTable;
-      }
-      const alias = fromItemResolved.alias;
-      if (this.tables[alias]) {
-        throw new Error(`Join already exists: ${alias} in ${Object.keys(this.tables)}`);
+    let fromItemResolved = fromItemCallbackRaw(this.arg);
+    invariant(isFromItem(fromItemResolved), "fromItem must return a FromItem");
+    if (fromItemResolved instanceof _QueryBuilder && fromItemResolved.rawTable) {
+      fromItemResolved = fromItemResolved.rawTable;
+    }
+    const alias = fromItemResolved.alias;
+    invariant(typeof alias === "string" && isSafeAlias(alias), "alias must be a safe alias");
+    if (this.tables[alias]) {
+      throw new Error(`Join already exists: ${alias} in ${Object.keys(this.tables)}`);
+    }
+    const arg = {
+      ...this.arg,
+      [alias]: fromItemResolved.toRowLike()
+    };
+    const onRaw = on?.(arg);
+    invariant(onRaw === void 0 || isSqlExpressionIn(onRaw), "on must return a SqlExpressionIn");
+    const onResolved = combinePredicates(onRaw !== void 0 ? asSqlExpression(onRaw) : void 0, fromItemResolved.onExpression);
+    invariant(onResolved != null, "Must specify an `on` expression or use `Table.on` to set the on expression");
+    invariant(onResolved instanceof SqlExpression, "on must return a SqlExpression");
+    const tablesWithAlias = {
+      ...this.tables,
+      [alias]: {
+        fromItem: fromItemResolved,
+        on: onResolved,
+        joinType: "inner",
+        // If `fromItem` is a function that returns a QueryBuilder, it is implicitly a lateral join (depends on the other tables)
+        isLateral: !isFromItem(fromItem) && fromItemResolved instanceof _QueryBuilder
       }
-      const arg = {
-        ...this.arg,
-        [alias]: fromItemResolved.toRowLike()
-      };
-      const onCallback = tool.unwrap(on ?? (() => void 0), (raw) => raw === void 0 || isSqlExpressionIn(raw));
-      return onCallback(arg, (onRaw) => {
-        const onResolved = combinePredicates(onRaw !== void 0 ? asSqlExpression(onRaw) : void 0, fromItemResolved.onExpression);
-        invariant(onResolved != null, "Must specify an `on` expression or use `Table.on` to set the on expression");
-        invariant(onResolved instanceof SqlExpression, "on must return a SqlExpression");
-        const tablesWithAlias = {
-          ...this.tables,
-          [alias]: {
-            fromItem: fromItemResolved,
-            on: onResolved,
-            joinType: "inner",
-            // If `fromItem` is a function that returns a QueryBuilder, it is implicitly a lateral join (depends on the other tables)
-            isLateral: !isFromItem(fromItem) && fromItemResolved instanceof _QueryBuilder
-          }
-        };
-        return new _QueryBuilder({ ...this.paramsForCopy(), tables: tablesWithAlias });
-      });
-    });
-    return res;
+    };
+    return new _QueryBuilder({ ...this.paramsForCopy(), tables: tablesWithAlias });
   }
   async execute() {
     return await __privateGet(this, _db).execute(this.compile());
   }
 };
-_init2 = __decoratorStart(_b);
+_init2 = __decoratorStart(null);
 _db = new WeakMap();
 _limit = new WeakMap();
 _offset = new WeakMap();
@@ -457,7 +451,7 @@ __decorateElement(_init2, 1, "join", _join_dec, _QueryBuilder);
 __decorateElement(_init2, 1, "execute", _execute_dec, _QueryBuilder);
 __decoratorMetadata(_init2, _QueryBuilder);
 let QueryBuilder = _QueryBuilder;
-class TableBase extends RpcToolset {
+class TableBase {
   opts;
   // `= () => ` to ensure the method is a direct property of the class instance,
   // not a method of the class prototype
@@ -498,18 +492,8 @@ const table = (db, name) => {
       for (const key of Object.keys(rowLike)) {
         const value = rowLike[key];
         if (value instanceof UnboundColumnReferenceExpression) {
-          const proto = Object.getPrototypeOf(rowLike);
-          const getter = function() {
-            const cls = this.constructor;
-            return new ColumnReferenceExpression(cls.alias ?? cls.tableName, this.opts?.remapColumns ? key : value.column);
-          };
-          setToolMetadata(getter, { runtimeValidationEnabled: true });
-          Object.defineProperty(proto, key, {
-            get: getter,
-            enumerable: true,
-            configurable: true
-          });
-          delete rowLike[key];
+          rowLike[key] = new ColumnReferenceExpression(this.alias ?? this.tableName, opts?.remapColumns ? key : value.column);
+          registerToolField(rowLike, key);
         }
       }
       return rowLike;

package/dist/tool-DGs9ZxVn.js

@@ -0,0 +1,175 @@
+const toolSymbol = Symbol("tool");
+const toolFieldsSymbol = Symbol("toolFields");
+const validate = (schema, value, index) => {
+  const validation = schema["~standard"].validate(value);
+  if (validation instanceof Promise) {
+    throw new TypeError(`Validation must be synchronous: ${validation} ${value}`);
+  }
+  if (validation.issues) {
+    const msg = validation.issues.map((e) => e.message).join(", ");
+    throw new TypeError(`Invalid value: ${msg}${index != null ? ` for argument ${index}` : ""}`);
+  }
+  return validation.value;
+};
+const validateArgs = (methodName, inputSchemas, args) => {
+  const ret = [];
+  if (args.length > inputSchemas.length) {
+    throw new TypeError(`${methodName}: Too many arguments: ${args.length} > ${inputSchemas.length}`);
+  }
+  for (const [index, schema] of inputSchemas.entries()) {
+    ret.push(validate(schema, args[index], index));
+  }
+  return ret;
+};
+const registerToolField = (obj, key) => {
+  if (!Object.getOwnPropertyDescriptor(obj, toolFieldsSymbol)) {
+    Object.defineProperty(obj, toolFieldsSymbol, {
+      value: /* @__PURE__ */ new Set(),
+      writable: false,
+      enumerable: false,
+      configurable: false
+    });
+  }
+  obj[toolFieldsSymbol].add(key);
+};
+function tool(...argSchemas) {
+  return function(target, context) {
+    const key = String(context.name);
+    if (context.kind === "method") {
+      return asToolFn(target, argSchemas);
+    }
+    if (context.kind === "getter") {
+      const newGetter = function() {
+        const result = Reflect.apply(target, this, []);
+        if (typeof result === "function") {
+          return asToolFn(result, argSchemas);
+        }
+        return result;
+      };
+      return asToolFn(newGetter, []);
+    }
+    if (context.kind === "field") {
+      context.addInitializer(function() {
+        registerToolField(this, key);
+      });
+      return function(initialValue) {
+        if (typeof initialValue === "function") {
+          return asToolFn(initialValue, argSchemas);
+        }
+        return initialValue;
+      };
+    }
+    if (context.kind === "class") {
+      return asToolConstructor(target, argSchemas);
+    }
+  };
+}
+const makeFnSchema = (retSchema, allowOptional = false) => {
+  const schema = {
+    "~standard": {
+      version: 1,
+      vendor: "exoeval",
+      validate: (value) => {
+        if (value === void 0 && allowOptional)
+          return { value: void 0 };
+        if (typeof value !== "function") {
+          return { issues: [{ message: "Expected a function" }] };
+        }
+        return {
+          value: (...args) => {
+            const res = Reflect.apply(value, void 0, args);
+            if (res != null && typeof res === "object" && "then" in res && typeof res.then === "function") {
+              throw new TypeError(`${value.name}: Promise not allowed`);
+            }
+            return validate(retSchema, res);
+          }
+        };
+      }
+    }
+  };
+  return Object.assign(schema, {
+    optional() {
+      return makeFnSchema(retSchema, true);
+    }
+  });
+};
+const fn = {
+  returns(retSchema) {
+    return makeFnSchema(retSchema);
+  }
+};
+const expr = () => (target, _context) => {
+  target[toolSymbol] = "expr";
+  return target;
+};
+function asToolFn(fn2, schemas) {
+  const name = fn2.name || "anonymous";
+  const { [name]: wrapped } = {
+    [name](...args) {
+      const validatedArgs = validateArgs(name, schemas, args);
+      return Reflect.apply(fn2, this, validatedArgs);
+    }
+  };
+  wrapped[toolSymbol] = "raw";
+  return wrapped;
+}
+function asToolConstructor(Original, argSchemas) {
+  const { [Original.name]: Wrapped } = { [Original.name]: class extends Original {
+    constructor(...args) {
+      const validated = argSchemas.length > 0 ? validateArgs(`new ${Original.name}`, argSchemas, args) : args;
+      super(...validated);
+    }
+  } };
+  Wrapped[toolSymbol] = "constructor";
+  return Wrapped;
+}
+const isToolableFunction = (value) => {
+  return typeof value === "function" && value[toolSymbol] === "raw";
+};
+const isExprFunction = (value) => {
+  return typeof value === "function" && value[toolSymbol] === "expr";
+};
+const isToolableConstructor = (value) => {
+  return typeof value === "function" && value[toolSymbol] === "constructor";
+};
+const getToolUnbound = (thisArg, obj, key) => {
+  let current = obj;
+  while (current != null) {
+    const desc = Object.getOwnPropertyDescriptor(current, key);
+    if (desc) {
+      if (desc.get && isToolableFunction(desc.get)) {
+        return desc.get.call(thisArg);
+      }
+      if (isToolableFunction(desc.value) || isExprFunction(desc.value)) {
+        return desc.value;
+      }
+      if (current[toolFieldsSymbol]?.has(String(key))) {
+        return "value" in desc ? desc.value : desc.get?.call(thisArg);
+      }
+      return void 0;
+    }
+    current = Object.getPrototypeOf(current);
+  }
+  return void 0;
+};
+const getTool = (thisArg, obj, key) => {
+  const unbound = getToolUnbound(thisArg, obj, key);
+  if (typeof unbound === "function" && toolSymbol in unbound) {
+    const bound = unbound.bind(thisArg);
+    bound[toolSymbol] = unbound[toolSymbol];
+    return bound;
+  }
+  return unbound;
+};
+export {
+  tool as a,
+  isToolableFunction as b,
+  isToolableConstructor as c,
+  asToolFn as d,
+  expr as e,
+  fn as f,
+  getTool as g,
+  isExprFunction as i,
+  registerToolField as r,
+  toolFieldsSymbol as t
+};

package/dist/tool-wrapper.d.ts

@@ -1,16 +1,9 @@
 import { Tool, ToolExecutionOptions } from 'ai';
-import { RpcToolset } from './rpc-toolset';
+import { ToolFunction } from './exoeval';
 export type WrappableTools = {
-    [key: string]: Tool | (() => RpcToolset);
-} | Tool[];
-export declare function generateToolTypes(tools: WrappableTools, name: string): AsyncGenerator<string, void, unknown>;
-export declare const generateToolApi: (tools: WrappableTools, opts: ToolExecutionOptions) => {
-    new (code: string): {
-        __return_value__: unknown;
-        __raw_code__: string;
-        __code__(): Promise<string>;
-        __return__(result: unknown): void;
-        __RPC_TARGET_BRAND: never;
-    };
+    [key: string]: Tool;
+} | Tool[] | {
+    [k in string]: ToolFunction;
 };
-export type ToolApi = InstanceType<ReturnType<typeof generateToolApi>>;
+export declare function generateToolTypes(tools: WrappableTools, name: string): AsyncGenerator<string, void, unknown>;
+export declare const wrapTools: (tools: WrappableTools, opts: ToolExecutionOptions) => { [k in string]: ToolFunction; };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "exoagent",
   "type": "module",
-  "version": "0.0.11",
+  "version": "0.0.13",
   "description": "The OS kernel to safely unleash your agents",
   "author": "Ryan Rasti <https://github.com/ryanrasti>",
   "license": "MIT",
@@ -40,32 +40,27 @@
   ],
   "scripts": {
     "clean": "rm -rf dist",
-    "build": "npm run clean && npm run build:runtime && npm run build:main && npm run build:capnweb && npm run build:test-deps",
+    "build": "npm run clean && npm run build:main",
     "build:main": "vite build",
-    "build:runtime": "esbuild src/code-mode-runtime.ts --bundle --format=esm --target=es2022 --outfile=dist/code-mode-runtime.mjs --packages=external",
-    "build:capnweb": "npm pack ./packages/capnweb --pack-destination dist && mkdir -p dist/capnweb && tar -xzf dist/capnweb-*.tgz --strip-components=1 -C dist/capnweb && rm dist/capnweb-*.tgz",
-    "build:test-deps": "tsdown --config tsdown.test-deps.config.ts",
     "dev": "tsdown --watch",
     "lint": "eslint",
     "prepublishOnly": "npm run build",
     "release": "bumpp",
     "start": "tsx src/index.ts",
-    "pretest": "npm run build:runtime",
     "test": "vitest --run",
     "typecheck": "tsc",
-    "ci:capnweb": "cd packages/capnweb && npm ci && npm run build",
-    "ci:examples": "npm --prefix ./examples run ci",
-    "ci": "npm run ci:capnweb && npm ci && npm run lint && npm run typecheck && npm run build && npm run test && npm run ci:examples"
+    "check:examples": "npm --prefix ./examples run check",
+    "check": "npm ci && npm run lint && npm run typecheck && npm run build && npm run test && npm run check:examples"
   },
   "peerDependencies": {
     "ai": "^6.0.0"
   },
   "dependencies": {
     "camelcase": "^9.0.0",
-    "capnweb": "file:dist/capnweb",
     "json-schema": "^0.4.0",
     "json-schema-to-typescript": "^15.0.0",
     "kysely": "^0.28.9",
+    "secure-json-parse": "^4.1.0",
     "tiny-invariant": "^1.3.3",
     "zod": "^4.2.1",
     "zod-to-json-schema": "^3.25.0"
@@ -77,6 +72,7 @@
     "@electric-sql/pglite": "^0.3.15",
     "@standard-schema/spec": "^1.1.0",
     "@types/node": "25.0.1",
+    "acorn": "^8.16.0",
     "bumpp": "10.3.2",
     "eslint": "9.39.2",
     "kysely-pglite-dialect": "^1.2.0",

package/dist/capnweb/LICENSE.txt

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025 Cloudflare, Inc.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.