exoagent 0.0.1 → 0.0.3

package/dist/rpc-toolset-BnC2BXPq.js

@@ -0,0 +1,146 @@
+import { inspect } from "node:util";
+import { RpcTarget } from "capnweb";
+const validate = (schema, value) => {
+  if ("~standard" in schema) {
+    const validation = schema["~standard"].validate(value);
+    if (validation instanceof Promise) {
+      throw new TypeError(`Validation must be synchronous`);
+    }
+    if (validation.issues) {
+      throw new Error(`Invalid value: ${validation.issues.map((e) => e.message).join(", ")}`);
+    }
+  } else {
+    if (!schema(value)) {
+      throw new Error(`Invalid value: ${inspect(value)} (expected ${schema.name || schema.toString()})`);
+    }
+  }
+};
+const toolMetadataKey = Symbol("toolMetadata");
+const setToolMetadata = (target, metadata) => {
+  const meta = target;
+  meta[toolMetadataKey] = {
+    ...meta[toolMetadataKey],
+    ...metadata
+  };
+};
+function toolDef(inputSchema) {
+  return (target, context) => {
+    if (context.kind !== "method") {
+      throw new Error(`Tool decorator can only be used on methods`);
+    }
+    const methodName = String(context.name);
+    const replacementMethod = function(...args) {
+      const expectedArgs = inputSchema ? 1 : 0;
+      if (args.length > expectedArgs) {
+        throw new Error(`Tool ${methodName} got too many arguments: ${args.length} provided (expected ${expectedArgs})`);
+      }
+      if (inputSchema) {
+        const arg = args[0];
+        validate(inputSchema, arg);
+        return target.call(this, arg);
+      } else {
+        return target.call(this);
+      }
+    };
+    setToolMetadata(replacementMethod, { runtimeValidationEnabled: true });
+    return replacementMethod;
+  };
+}
+function toolUnsafeNoValidation() {
+  return (target, context) => {
+    if (context.kind !== "method") {
+      throw new Error(`Tool decorator can only be used on methods`);
+    }
+    setToolMetadata(target, { runtimeValidationEnabled: true });
+    return target;
+  };
+}
+const callbackMetadataKey = Symbol("callbackMetadata");
+function callbackTool() {
+  return (target, context) => {
+    if (context.kind !== "method") {
+      throw new Error(`Tool decorator can only be used on methods`);
+    }
+    const methodName = String(context.name);
+    const replacementMethod = function(...args) {
+      if (args.length !== 1) {
+        throw new Error(`Tool ${methodName} got too many arguments: ${args.length} provided (expected 1)`);
+      }
+      const callback = args[0];
+      if (typeof callback !== "function") {
+        throw new TypeError(`Callback for tool ${methodName} must be a function`);
+      }
+      const callbackWrapped = (() => {
+        throw new Error(`Callback for tool ${methodName} must be wrapped with \`tool.unwrapCallback\``);
+      });
+      callbackWrapped[callbackMetadataKey] = {
+        callback
+      };
+      return target.call(this, callbackWrapped);
+    };
+    setToolMetadata(replacementMethod, { runtimeValidationEnabled: true });
+    return replacementMethod;
+  };
+}
+const unwrapCallback = (toolCallback, returnSchema) => (arg, then, opts) => {
+  const callback = callbackMetadataKey in toolCallback ? toolCallback[callbackMetadataKey].callback : toolCallback;
+  let isPromise = false;
+  try {
+    const result = callback(arg);
+    if (result instanceof Promise) {
+      isPromise = true;
+      let ret;
+      ret = result.then(async (r) => {
+        validate(returnSchema, r);
+        return then(r);
+      }, opts?.catch);
+      if (opts?.finally) {
+        ret = ret.finally(opts.finally);
+      }
+      return ret;
+    }
+    validate(returnSchema, result);
+    return then(result);
+  } catch (error) {
+    if (opts?.catch) {
+      return opts.catch(error);
+    }
+    throw error;
+  } finally {
+    if (!isPromise) {
+      opts?.finally?.();
+    }
+  }
+};
+const tool = toolDef;
+tool.callback = callbackTool;
+tool.unwrap = unwrapCallback;
+tool.unsafeNoValidation = toolUnsafeNoValidation;
+class RpcToolset extends RpcTarget {
+  constructor() {
+    super();
+    let prototype = Object.getPrototypeOf(this);
+    while (prototype !== null && prototype !== RpcToolset.prototype) {
+      for (const key of Object.getOwnPropertyNames(prototype)) {
+        if (key === "constructor") {
+          continue;
+        }
+        const descriptor = Object.getOwnPropertyDescriptor(prototype, key);
+        const fn = descriptor?.value ?? descriptor?.get;
+        if (!fn || typeof fn !== "function") {
+          throw new Error(`RpcToolset prototype must be methods or getters: ${key} is not`);
+        }
+        const meta = fn;
+        if (!meta[toolMetadataKey]?.runtimeValidationEnabled) {
+          throw new Error(`Prototype method \`${key}\` is not a tool. Did you forget to use the @tool decorator?`);
+        }
+      }
+      prototype = Object.getPrototypeOf(prototype);
+    }
+  }
+}
+export {
+  RpcToolset as R,
+  setToolMetadata as s,
+  tool as t
+};

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

@@ -154,7 +154,11 @@ declare class QueryBuilder<N extends string, TN extends TableNamespace, S extend
   offset(offset: number): QueryBuilder<N, TN, S>;
   join<N2 extends string, F2 extends TableClass<N2>>(fromItem: F2 | NamespacedExpression<TN, F2>, on?: NamespacedExpression<TN & { [k in N2]: InstanceType<F2> }, SqlExpressionIn>): QueryBuilder<N, TN & { [k in N2]: InstanceType<F2> }, S>;
   join<N2 extends string, F2 extends RowLike>(fromItem: FromItem<N2, F2> | NamespacedExpression<TN, FromItem<N2, F2>>, on?: NamespacedExpression<TN & { [k in N2]: F2 }, SqlExpressionIn>): QueryBuilder<N, TN & { [k in N2]: F2 }, S>;
-  execute(): Promise<{ [key in keyof S]: unknown }[]>;
+  execute(): Promise<{
+    results: { [key in keyof S]: unknown }[];
+    sql?: string;
+    parameters?: readonly unknown[];
+  }>;
   private paramsForCopy;
   toRowLike: () => S;
   compile: (opts?: {
@@ -190,8 +194,13 @@ declare class Database {
   private kysely?;
   constructor(dialect: Dialect, opts?: {
     logQuery?: (raw: CompiledQuery) => void;
+    returnExecutedQuery?: boolean;
   } | undefined);
-  execute(query: RawSql): Promise<unknown[]>;
+  execute(query: RawSql): Promise<{
+    results: unknown[];
+    sql?: string;
+    parameters?: readonly unknown[];
+  }>;
   Table<N extends string>(name: N): TableClass<N>;
 }
 //#endregion

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

@@ -0,0 +1,45 @@
+import { RpcToolset } from './rpc-toolset';
+export declare class TestToolset extends RpcToolset {
+    add(input: {
+        a: number;
+        b: number;
+    }): Promise<number>;
+    toolset2(): Promise<TestToolset2>;
+    userForId({ id }: {
+        id: string;
+    }): Promise<typeof User>;
+}
+export declare class TestToolset2 extends RpcToolset {
+    subtract(input: {
+        a: number;
+        b: number;
+    }): Promise<number>;
+}
+declare const User_base: Omit<import('./sql').TableClass<"users">, keyof import('./sql').TableClass<string>> & import('./sql').TableClass<"user"> & (new () => {
+    opts?: {
+        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;
+    name: import('./sql/expression').ColumnReferenceExpression;
+    email: import('./sql/expression').ColumnReferenceExpression;
+    age: import('./sql/expression').ColumnReferenceExpression;
+    posts(): typeof Post;
+}
+declare const Post_base: Omit<import('./sql').TableClass<"posts">, keyof import('./sql').TableClass<string>> & import('./sql').TableClass<"post"> & (new () => {
+    opts?: {
+        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;
+    userId: import('./sql/expression').ColumnReferenceExpression;
+    title: import('./sql/expression').ColumnReferenceExpression;
+    content: import('./sql/expression').ColumnReferenceExpression;
+}
+export {};