exoagent 0.0.11 → 0.0.13

package/README.md

@@ -21,7 +21,7 @@ ExoAgent uses **Object Capabilities (OCap)** to enforce security at the runtime
 
 It doesn't matter if the LLM gets jailbroken. It runs inside a sandbox where invalid actions are mathematically impossible. Security as a system invariant, not a polite suggestion.
 
-![ExoAgent Architecture](./website/public/architecture.png)
+![ExoAgent Architecture](./website/public/architecture.jpg)
 
 ## Quick Start
 
@@ -73,15 +73,14 @@ class User extends db.Table('users').as('user') {
 ```typescript
 import { google } from '@ai-sdk/google'
 import { generateText, stepCountIs } from 'ai'
-import { CodeMode, createDenoSandbox } from 'exoagent'
+import { codemode } from 'exoagent'
 
 // Create a capability scoped to user_id=1
 const userCap = User.on(u => u.id['='](1)).from()
 
-// Wrap with CodeMode for sandboxed execution
-const codeMode = new CodeMode(createDenoSandbox())
-const codeTool = await codeMode.wrap({
-  currentUser: () => userCap,
+// Wrap with codemode for sandboxed execution
+const codeTool = await codemode({
+  currentUser: userCap,
 }, schemaString) // schemaString = the class definitions above as a string
 
 const result = await generateText({
@@ -115,17 +114,15 @@ npx tsx saas-bot.ts
 
 Note the examples require:
 1. NodeJS (runtime)
-2. [Deno](https://docs.deno.com/runtime/getting_started/installation/) (sandbox)
-3. An LLM API key set via one of the env vars:
+2. An LLM API key set via one of the env vars:
    - `OPENAI_API_KEY`
    - `ANTHROPIC_API_KEY`
    - `GOOGLE_GENERATIVE_AI_API_KEY`
 
 ## Architecture
 ExoAgent sits between your LLM and your infrastructure as a regular tool.
-1. **Protocol**: Uses [Cap'n Web](https://github.com/cloudflare/capnweb) (RPC) as the transport.
-2. **Runtime**: Runs in a JS code sandbox (user-configured; Deno supported out of the box, more to come).
-3. **Query Builder**: Uses a custom capability SQL builder that compiles to safe SQL.
+1. **Evaluator**: A custom sandboxed JavaScript evaluator (`exoeval`) that only allows safe operations.
+2. **Query Builder**: A capability-based SQL builder that compiles to safe SQL with scoped access.
 
 ## ⚠️ Project Status: Experimental (v0.0.x)
 ExoAgent is an exploration of capability-based security for LLMs. While the architecture (OCaps + Sandboxing) is theoretically robust, this specific implementation is new and may contain bugs.

package/dist/code-mode.d.ts

@@ -1,26 +1,8 @@
 import { Tool, ToolExecutionOptions } from 'ai';
-import { RpcTarget } from '../packages/capnweb/dist';
-import { RpcToolset } from './rpc-toolset';
 import { z } from 'zod';
-export type SafeEvalResult = {
-    wait: () => Promise<void>;
-    input: ReadableStream<Uint8Array>;
-    output: WritableStream<Uint8Array>;
-};
-export type SafeEvalContext<R> = {
-    kind: 'direct';
-    safeEval: (code: string) => Promise<SafeEvalResult>;
-    sandboxContext: string;
-} | {
-    kind: 'rpc';
-    safeEval: (code: string, api: RpcTarget) => Promise<R>;
-};
 type FlatTools = {
     [key: string]: Tool;
 } | Tool[];
-type RpcTools = {
-    [key: string]: () => RpcToolset;
-};
 type ExecutableTool<R> = {
     description: string;
     inputSchema: z.ZodSchema<{
@@ -30,10 +12,6 @@ type ExecutableTool<R> = {
         code: string;
     }, opts: ToolExecutionOptions) => Promise<R>;
 };
-export declare class CodeMode<R> {
-    private context;
-    constructor(context: SafeEvalContext<R>);
-    wrap(tools: FlatTools): Promise<ExecutableTool<R>>;
-    wrap(tools: RpcTools | FlatTools, dts: string): Promise<ExecutableTool<R>>;
-}
+export declare function codemode<R>(tools: FlatTools): Promise<ExecutableTool<R>>;
+export declare function codemode<R>(tools: object, dts: string): Promise<ExecutableTool<R>>;
 export {};

package/dist/exoeval/builtins.d.ts

@@ -0,0 +1,173 @@
+import { ExpressionContext } from './expr';
+export declare class ExoArray<T = unknown> {
+    constructor(...args: Parameters<typeof Array>);
+    get length(): number;
+    get map(): <U>(callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[];
+    get filter(): {
+        <S extends any>(predicate: (value: any, index: number, array: any[]) => value is S, thisArg?: any): S[];
+        (predicate: (value: any, index: number, array: any[]) => unknown, thisArg?: any): any[];
+    };
+    get reduce(): {
+        (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any): any;
+        (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any, initialValue: any): any;
+        <U>(callbackfn: (previousValue: U, currentValue: any, currentIndex: number, array: any[]) => U, initialValue: U): U;
+    };
+    get reduceRight(): {
+        (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any): any;
+        (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any, initialValue: any): any;
+        <U>(callbackfn: (previousValue: U, currentValue: any, currentIndex: number, array: any[]) => U, initialValue: U): U;
+    };
+    get find(): {
+        <S extends any>(predicate: (value: any, index: number, obj: any[]) => value is S, thisArg?: any): S | undefined;
+        (predicate: (value: any, index: number, obj: any[]) => unknown, thisArg?: any): any;
+    };
+    get findIndex(): (predicate: (value: any, index: number, obj: any[]) => unknown, thisArg?: any) => number;
+    get findLast(): {
+        <S extends any>(predicate: (value: any, index: number, array: any[]) => value is S, thisArg?: any): S | undefined;
+        (predicate: (value: any, index: number, array: any[]) => unknown, thisArg?: any): any;
+    };
+    get findLastIndex(): (predicate: (value: any, index: number, array: any[]) => unknown, thisArg?: any) => number;
+    get some(): (predicate: (value: any, index: number, array: any[]) => unknown, thisArg?: any) => boolean;
+    get every(): {
+        <S extends any>(predicate: (value: any, index: number, array: any[]) => value is S, thisArg?: any): this is S[];
+        (predicate: (value: any, index: number, array: any[]) => unknown, thisArg?: any): boolean;
+    };
+    get flatMap(): <U, This = undefined>(callback: (this: This, value: any, index: number, array: any[]) => U | readonly U[], thisArg?: This | undefined) => U[];
+    get toSorted(): (compareFn?: ((a: any, b: any) => number) | undefined) => any[];
+    get at(): (index: number) => any;
+    get slice(): (start?: number, end?: number) => any[];
+    get join(): (separator?: string) => string;
+    get concat(): {
+        (...items: ConcatArray<any>[]): any[];
+        (...items: any[]): any[];
+    };
+    get indexOf(): (searchElement: any, fromIndex?: number) => number;
+    get lastIndexOf(): (searchElement: any, fromIndex?: number) => number;
+    get includes(): (searchElement: any, fromIndex?: number) => boolean;
+    get flat(): <A, D extends number = 1>(this: A, depth?: D | undefined) => FlatArray<A, D>[];
+    get entries(): () => ArrayIterator<[number, any]>;
+    get keys(): () => ArrayIterator<number>;
+    get values(): () => ArrayIterator<any>;
+    get toReversed(): () => any[];
+    get toSpliced(): {
+        (start: number, deleteCount: number, ...items: any[]): any[];
+        (start: number, deleteCount?: number): any[];
+    };
+    get with(): (index: number, value: any) => any[];
+    static from(arrayLike: ArrayLike<unknown>): unknown[];
+    static isArray(value: unknown): value is any[];
+}
+export declare class ExoString {
+    constructor(...args: Parameters<typeof String>);
+    get length(): number;
+    get at(): (index: number) => string | undefined;
+    get charAt(): (pos: number) => string;
+    get charCodeAt(): (index: number) => number;
+    get codePointAt(): (pos: number) => number | undefined;
+    get concat(): (...strings: string[]) => string;
+    get endsWith(): (searchString: string, endPosition?: number) => boolean;
+    get includes(): (searchString: string, position?: number) => boolean;
+    get indexOf(): (searchString: string, position?: number) => number;
+    get lastIndexOf(): (searchString: string, position?: number) => number;
+    get padEnd(): (maxLength: number, fillString?: string) => string;
+    get padStart(): (maxLength: number, fillString?: string) => string;
+    get repeat(): (count: number) => string;
+    get replace(): {
+        (searchValue: string | RegExp, replaceValue: string): string;
+        (searchValue: string | RegExp, replacer: (substring: string, ...args: any[]) => string): string;
+        (searchValue: {
+            [Symbol.replace](string: string, replaceValue: string): string;
+        }, replaceValue: string): string;
+        (searchValue: {
+            [Symbol.replace](string: string, replacer: (substring: string, ...args: any[]) => string): string;
+        }, replacer: (substring: string, ...args: any[]) => string): string;
+    };
+    get replaceAll(): {
+        (searchValue: string | RegExp, replaceValue: string): string;
+        (searchValue: string | RegExp, replacer: (substring: string, ...args: any[]) => string): string;
+    };
+    get slice(): (start?: number, end?: number) => string;
+    get split(): {
+        (separator: string | RegExp, limit?: number): string[];
+        (splitter: {
+            [Symbol.split](string: string, limit?: number): string[];
+        }, limit?: number): string[];
+    };
+    get startsWith(): (searchString: string, position?: number) => boolean;
+    get substring(): (start: number, end?: number) => string;
+    get toLowerCase(): () => string;
+    get toUpperCase(): () => string;
+    get trim(): () => string;
+    get trimEnd(): () => string;
+    get trimStart(): () => string;
+}
+export declare class ExoDate {
+    constructor();
+    constructor(value: string | number | Date);
+    constructor(year: number, month: number, date?: number, hours?: number, minutes?: number, seconds?: number, ms?: number);
+    get getTime(): () => number;
+    get getFullYear(): () => number;
+    get getMonth(): () => number;
+    get getDate(): () => number;
+    get getHours(): () => number;
+    get getMinutes(): () => number;
+    get getSeconds(): () => number;
+    get getMilliseconds(): () => number;
+    get toISOString(): () => string;
+    get toLocaleDateString(): {
+        (): string;
+        (locales?: string | string[], options?: Intl.DateTimeFormatOptions): string;
+        (locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
+    };
+    get toLocaleTimeString(): {
+        (): string;
+        (locales?: string | string[], options?: Intl.DateTimeFormatOptions): string;
+        (locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
+    };
+    get toLocaleString(): {
+        (): string;
+        (locales?: string | string[], options?: Intl.DateTimeFormatOptions): string;
+        (locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
+    };
+    get valueOf(): () => number;
+    static now(): number;
+    static parse(dateString: string): number;
+}
+export declare class ExoObject {
+    static keys(ctx: ExpressionContext, obj: unknown): unknown;
+    static values(ctx: ExpressionContext, obj: unknown): unknown;
+    static entries(ctx: ExpressionContext, obj: unknown): unknown;
+    static fromEntries(entries: [string, unknown][]): {
+        [k: string]: unknown;
+    };
+}
+export declare class ExoBoolean {
+    constructor(...args: Parameters<typeof Boolean>);
+    get valueOf(): () => boolean;
+}
+export declare class ExoJSON {
+    static parse(text: string): any;
+    static stringify(value: unknown, replacer?: null, space?: number): string;
+}
+export declare class ExoMath {
+    static min(a: number, b: number): number;
+    static max(a: number, b: number): number;
+    static round(x: number): number;
+    static floor(x: number): number;
+    static ceil(x: number): number;
+    static abs(x: number): number;
+    static sqrt(x: number): number;
+    static pow(base: number, exp: number): number;
+    static log(x: number): number;
+    static random(): number;
+    static sign(x: number): number;
+    static trunc(x: number): number;
+}
+export declare class ExoNumber {
+    constructor(...args: Parameters<typeof Number>);
+    static parseInt(s: string, radix?: number): number;
+    static parseFloat(s: string): number;
+    static isNaN(value: unknown): boolean;
+    static isFinite(value: unknown): boolean;
+    static isInteger(value: unknown): boolean;
+}

package/dist/exoeval/evaluator.d.ts

@@ -0,0 +1,59 @@
+import { Control, ExpressionContext } from './expr';
+import { Scope } from './scope';
+import { Invariant } from './utils';
+import type * as acorn from 'acorn';
+export type EvalResult<Expr, Ret = Expr> = Generator<Control<InternalControl<Expr>> | Expr, Ret, unknown>;
+type InternalControl<Expr> = {
+    control: 'await';
+    value: Expr;
+} | {
+    control: 'return';
+    value: Expr;
+};
+type BuiltinPrototypes = {
+    Array?: object;
+    String?: object;
+    Number?: object;
+    Boolean?: object;
+    Date?: object;
+};
+export declare class Evaluator<Expr> {
+    private readonly ast;
+    readonly code: string;
+    readonly ctx: ExpressionContext<Expr>;
+    readonly scope: Scope<Expr>;
+    readonly builtinPrototypes: BuiltinPrototypes;
+    readonly inv: Invariant;
+    constructor(ast: acorn.Node, code: string, ctx: ExpressionContext<Expr>, scope: Scope<Expr>, builtinPrototypes: BuiltinPrototypes);
+    with({ newScope }: {
+        newScope?: boolean;
+    }): Evaluator<Expr>;
+    Identifier(node: acorn.Identifier): EvalResult<Expr>;
+    Literal(node: acorn.Literal): EvalResult<Expr>;
+    ChainExpression(node: acorn.ChainExpression): EvalResult<Expr>;
+    MemberExpression(node: acorn.MemberExpression): EvalResult<Expr>;
+    evalArray(elements: (acorn.Expression | acorn.SpreadElement | null)[]): EvalResult<Expr, Expr[]>;
+    CallExpression(node: acorn.CallExpression): EvalResult<Expr>;
+    ArrayExpression(node: acorn.ArrayExpression): EvalResult<Expr>;
+    assertAllowedProperty(key: string | number, node: acorn.Node): void;
+    defineProperty(obj: object, key: string | number, value: unknown, node: acorn.Node): void;
+    getExoProperty(obj: Expr, key: string | number, node: acorn.Node, optional: boolean): EvalResult<Expr>;
+    getBuiltinPrototype(value: unknown): unknown;
+    ObjectExpression(node: acorn.ObjectExpression): EvalResult<Expr>;
+    AwaitExpression(node: acorn.AwaitExpression): EvalResult<Expr>;
+    evalStatements(statements: (acorn.Statement | acorn.ModuleDeclaration)[]): EvalResult<Expr>;
+    evalFunctionCall(node: acorn.Function, args: Expr[]): EvalResult<Expr>;
+    ArrowFunctionExpression(node: acorn.ArrowFunctionExpression): EvalResult<Expr>;
+    UnaryExpression(node: acorn.UnaryExpression): EvalResult<Expr>;
+    ConditionalExpression(node: acorn.ConditionalExpression): EvalResult<Expr>;
+    BinaryExpression(node: acorn.BinaryExpression): EvalResult<Expr>;
+    LogicalExpression(node: acorn.LogicalExpression): EvalResult<Expr>;
+    TemplateLiteral(node: acorn.TemplateLiteral): EvalResult<Expr>;
+    NewExpression(node: acorn.NewExpression): EvalResult<Expr>;
+    Expression(node: acorn.Expression): EvalResult<Expr>;
+    $(node: acorn.Expression): EvalResult<Expr, unknown>;
+    makeReturn(value: Expr, node: acorn.Node): EvalResult<Expr>;
+    Statement(node: acorn.Statement): EvalResult<Expr>;
+    Program(node: acorn.Program): Expr | Promise<Expr>;
+}
+export {};

package/dist/exoeval/expr.d.ts

@@ -0,0 +1,50 @@
+declare const control: unique symbol;
+export type Control<V extends {
+    value: unknown;
+} = {
+    value: unknown;
+}> = {
+    [control]: V;
+};
+export declare function getControl<C extends Control>(cntrl: C): C[typeof control];
+export declare function getControl(value: object): {
+    value: unknown;
+} | undefined;
+export declare const isControl: (value: unknown) => value is Control;
+export declare const makeControl: <T, V extends {
+    value: T;
+}>(obj: V) => Control<V>;
+export declare const isPlainObject: (value: unknown) => value is {
+    [key: string]: unknown;
+};
+export declare abstract class ExpressionContext<Expr = unknown> {
+    abstract of(value: unknown): Expr;
+    abstract doGen<C extends Control<{
+        value: Expr;
+    }>>(gen: Generator<C | Expr, Expr, unknown>): Generator<C, Expr, unknown>;
+    abstract sequence(expr: Expr): {
+        [key in string | number]: Expr;
+    } | Expr[] | null | undefined;
+    abstract sequencePromiseLike(expr: Expr): PromiseLike<Expr> | Expr;
+    abstract distribute(entries: {
+        [key in string | number]: Expr;
+    } | Expr[]): Expr;
+    abstract isExpr(value: unknown): value is Expr;
+    abstract call(callee: Expr, args: Expr[]): Expr;
+    do(gen: Generator<Expr, Expr, unknown>): Expr;
+    chain(expr: Expr, then: (value: unknown) => Expr): Expr;
+}
+export declare class IdentityContext extends ExpressionContext<unknown> {
+    doGen<C extends Control<{
+        value: unknown;
+    }>>(gen: Generator<C | unknown, unknown, unknown>): Generator<C, unknown, unknown>;
+    of(value: unknown): unknown;
+    call(callee: unknown, args: unknown[]): unknown;
+    sequence(obj: unknown): {
+        [key in string | number]: unknown;
+    } | unknown[] | null | undefined;
+    sequencePromiseLike(expr: unknown): unknown;
+    distribute(entries: unknown): unknown;
+    isExpr(value: unknown): value is unknown;
+}
+export {};

package/dist/exoeval/index.d.ts

@@ -0,0 +1,6 @@
+import { ExpressionContext } from './expr';
+export { asToolFn } from './tool';
+export type { ToolFunction } from './tool';
+export declare function exoEval(code: string): unknown;
+export declare function exoEval<T>(code: string, ctx: ExpressionContext<T>): T;
+export declare function exoFn<T extends (...args: any[]) => unknown>(fn: T): T;

package/dist/exoeval/scope.d.ts

@@ -0,0 +1,13 @@
+import { EvalResult, Evaluator } from './evaluator';
+import type * as acorn from 'acorn';
+export declare class Scope<T> {
+    private readonly parent;
+    private readonly bindings;
+    constructor(parent: Scope<T> | undefined);
+    get(node: acorn.Identifier, evaluator: Evaluator<T>): T;
+    set(node: acorn.Identifier, value: T, evaluator: Evaluator<T>): void;
+    bind(param: acorn.Pattern, value: T, evaluator: Evaluator<T>): EvalResult<T>;
+    AssignmentPattern(param: acorn.AssignmentPattern, value: T, evaluator: Evaluator<T>): EvalResult<T, void>;
+    ArrayPattern(param: acorn.ArrayPattern, value: T, evaluator: Evaluator<T>): EvalResult<T, void>;
+    ObjectPattern(param: acorn.ObjectPattern, value: T, evaluator: Evaluator<T>): EvalResult<T, void>;
+}

package/dist/exoeval/tool.d.ts

@@ -0,0 +1,44 @@
+import { StandardSchemaV1 } from '@standard-schema/spec';
+export declare const toolSymbol: unique symbol;
+export declare const toolFieldsSymbol: unique symbol;
+export type ToolKind = 'raw' | 'expr' | 'constructor';
+export type ToolFunction<T extends (...args: unknown[]) => unknown = (...args: unknown[]) => unknown> = T & ((...args: unknown[]) => unknown) & {
+    [toolSymbol]?: ToolKind;
+};
+export type ToolConstructor<T extends new (...args: unknown[]) => unknown = new (...args: unknown[]) => unknown> = T & {
+    [toolSymbol]?: ToolKind;
+};
+type SchemaToParam<Schema extends StandardSchemaV1> = Schema extends StandardSchemaV1<infer Params> ? Params : never;
+type SchemasToParams<Schemas extends StandardSchemaV1[]> = {
+    [K in keyof Schemas]: SchemaToParam<Schemas[K]>;
+};
+export declare const validateArgs: <Schemas extends StandardSchemaV1[]>(methodName: string, inputSchemas: Schemas, args: SchemasToParams<Schemas>) => SchemasToParams<Schemas>;
+export declare const registerToolField: (obj: unknown, key: string) => void;
+/**
+ * @tool decorator - marks a method, getter, field, or class as a tool
+ *
+ * Methods: returns a replacement function on the prototype with validation + toolSymbol.
+ * Getters: returns a replacement getter with toolSymbol on the function.
+ *          If the getter returns a function, it's wrapped with asTool(fn, undefined, schemas).
+ * Fields:  adds field name to toolFieldsSymbol Set on instance.
+ *          If value is a function with schemas, wraps with asTool.
+ * Classes: returns replacement class with constructor validation + toolSymbol.
+ */
+export declare function tool<Schemas extends StandardSchemaV1[]>(...argSchemas: Schemas): {
+    <This, Value extends (this: This, ...args: SchemasToParams<Schemas>) => any>(target: Value, context: ClassMethodDecoratorContext<This, Value>): Value;
+    <This, Value>(target: (this: This) => Value, context: ClassGetterDecoratorContext<This, Value>): (this: This) => Value;
+    <This, Value>(target: undefined, context: ClassFieldDecoratorContext<This, Value>): (value: Value) => Value;
+    <Value extends abstract new (...args: any) => any>(target: Value, context: ClassDecoratorContext<Value>): void;
+};
+export declare const fn: {
+    returns(retSchema: StandardSchemaV1): StandardSchemaV1<unknown, unknown> & {
+        optional: () => StandardSchemaV1;
+    };
+};
+export declare const expr: () => (target: any, _context: ClassMethodDecoratorContext) => any;
+export declare function asToolFn<Schemas extends StandardSchemaV1[], T extends (...args: SchemasToParams<Schemas>) => unknown>(fn: T, schemas: Schemas): T & ToolFunction;
+export declare const isToolableFunction: (value: unknown) => value is ToolFunction;
+export declare const isExprFunction: (value: unknown) => boolean;
+export declare const isToolableConstructor: (value: unknown) => value is ToolConstructor;
+export declare const getTool: (thisArg: unknown, obj: unknown, key: string | number) => unknown;
+export {};

package/dist/exoeval/utils.d.ts

@@ -0,0 +1,9 @@
+import type * as acorn from 'acorn';
+export declare const disallowedProperties: Set<string>;
+export declare const formatCodeMessage: (code: string, position: number, message: string) => string;
+export declare class Invariant {
+    private readonly code;
+    constructor(code: string);
+    parse(condition: boolean, message: string, node: acorn.Node): asserts condition;
+    eval(condition: boolean, message: string, node: acorn.Node, value: unknown): asserts condition;
+}

package/dist/index.d.ts

@@ -1,5 +1,3 @@
-export { createDenoSandbox } from './code-mode-deno.js';
-export { CodeMode } from './code-mode.js';
-export type { SafeEvalContext, SafeEvalResult } from './code-mode.js';
-export { RpcToolset, tool } from './rpc-toolset.js';
-export type { ToolCallback } from './rpc-toolset.js';
+export { codemode } from './code-mode';
+export { exoEval } from './exoeval';
+export { tool } from './exoeval/tool';