npm - exoagent - Versions diffs - 0.0.1 → 0.0.2 - Mend

exoagent 0.0.1 → 0.0.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (34) hide show

package/README.md +109 -30
package/dist/capnweb/index-workers.cjs +2811 -0
package/dist/capnweb/index-workers.cjs.map +1 -0
package/dist/capnweb/index-workers.d.cts +2 -0
package/dist/capnweb/index-workers.d.ts +2 -0
package/dist/capnweb/index-workers.js +2774 -0
package/dist/capnweb/index-workers.js.map +1 -0
package/dist/capnweb/index.cjs +2788 -0
package/dist/capnweb/index.cjs.map +1 -0
package/dist/capnweb/index.d.cts +383 -0
package/dist/capnweb/index.d.ts +383 -0
package/dist/{code-mode-runtime.mjs → capnweb/index.js} +342 -90
package/dist/capnweb/index.js.map +1 -0
package/dist/capnweb-test-helpers.d.ts +25 -0
package/dist/code-mode-deno.d.ts +13 -0
package/dist/code-mode-runtime.d.ts +1 -0
package/dist/code-mode.d.ts +39 -0
package/dist/index.d.ts +5 -0
package/dist/index.mjs +97 -3391
package/dist/rpc-toolset-BnC2BXPq.js +146 -0
package/dist/rpc-toolset-test-helpers.d.mts +11 -2
package/dist/rpc-toolset-test-helpers.d.ts +45 -0
package/dist/rpc-toolset-test-helpers.mjs +12 -1371
package/dist/rpc-toolset.d.ts +34 -0
package/dist/sql/builder.d.ts +127 -0
package/dist/sql/expression.d.ts +69 -0
package/dist/sql/sql.d.ts +4 -0
package/dist/sql/test-helpers.d.ts +9 -0
package/dist/sql.d.ts +2 -0
package/dist/sql.mjs +553 -0
package/dist/stream-transport.d.ts +11 -0
package/dist/tool-wrapper.d.ts +16 -0
package/package.json +26 -12
package/dist/index.d.mts +0 -426

package/dist/index.d.mts DELETED Viewed

@@ -1,426 +0,0 @@
-import { Tool } from "ai";
-import * as kysely0 from "kysely";
-import { CompiledQuery, Dialect, RawBuilder } from "kysely";
-import { StandardSchemaV1 } from "@standard-schema/spec";
-//#region packages/capnweb/dist/index.d.ts
-// Branded types for identifying `WorkerEntrypoint`/`DurableObject`/`Target`s.
-// TypeScript uses *structural* typing meaning anything with the same shape as type `T` is a `T`.
-// For the classes exported by `cloudflare:workers` we want *nominal* typing (i.e. we only want to
-// accept `WorkerEntrypoint` from `cloudflare:workers`, not any other class with the same shape)
-declare const __RPC_STUB_BRAND: '__RPC_STUB_BRAND';
-declare const __RPC_TARGET_BRAND: '__RPC_TARGET_BRAND';
-interface RpcTargetBranded {
-  [__RPC_TARGET_BRAND]: never;
-}
-// Types that can be used through `Stub`s
-type Stubable = RpcTargetBranded | ((...args: any[]) => any);
-// Types that can be passed over RPC
-// The reason for using a generic type here is to build a serializable subset of structured
-//   cloneable composite types. This allows types defined with the "interface" keyword to pass the
-//   serializable check as well. Otherwise, only types defined with the "type" keyword would pass.
-type RpcCompatible<T> =
-// Structured cloneables
-BaseType
-// Structured cloneable composites
-| Map<T extends Map<infer U, unknown> ? RpcCompatible<U> : never, T extends Map<unknown, infer U> ? RpcCompatible<U> : never> | Set<T extends Set<infer U> ? RpcCompatible<U> : never> | Array<T extends Array<infer U> ? RpcCompatible<U> : never> | ReadonlyArray<T extends ReadonlyArray<infer U> ? RpcCompatible<U> : never> | { [K in keyof T]: K extends number | string ? RpcCompatible<T[K]> : never } | Promise<T extends Promise<infer U> ? RpcCompatible<U> : never>
-// Special types
-| Stub<Stubable>
-// Serialized as stubs, see `Stubify`
-| Stubable;
-// Base type for all RPC stubs, including common memory management methods.
-// `T` is used as a marker type for unwrapping `Stub`s later.
-interface StubBase<T extends RpcCompatible<T>> extends Disposable {
-  [__RPC_STUB_BRAND]: T;
-  dup(): this;
-  onRpcBroken(callback: (error: any) => void): void;
-}
-type Stub<T extends RpcCompatible<T>> = T extends object ? Provider<T> & StubBase<T> : StubBase<T>;
-type TypedArray = Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array | Int8Array | Int16Array | Int32Array | BigUint64Array | BigInt64Array | Float32Array | Float64Array;
-// This represents all the types that can be sent as-is over an RPC boundary
-type BaseType = void | undefined | null | boolean | number | bigint | string | TypedArray | ArrayBuffer | DataView | Date | Error | RegExp | ReadableStream<Uint8Array> | WritableStream<Uint8Array> | Request | Response | Headers;
-// Recursively rewrite all `Stubable` types with `Stub`s, and resolve promises.
-// prettier-ignore
-type Stubify<T> = T extends Stubable ? Stub<T> : T extends Promise<infer U> ? Stubify<U> : T extends StubBase<any> ? T : T extends Map<infer K, infer V> ? Map<Stubify<K>, Stubify<V>> : T extends Set<infer V> ? Set<Stubify<V>> : T extends [] ? [] : T extends [infer Head, ...infer Tail] ? [Stubify<Head>, ...Stubify<Tail>] : T extends readonly [] ? readonly [] : T extends readonly [infer Head, ...infer Tail] ? readonly [Stubify<Head>, ...Stubify<Tail>] : T extends Array<infer V> ? Array<Stubify<V>> : T extends ReadonlyArray<infer V> ? ReadonlyArray<Stubify<V>> : T extends BaseType ? T
-// When using "unknown" instead of "any", interfaces are not stubified.
-: T extends {
-  [key: string | number]: any;
-} ? { [K in keyof T]: Stubify<T[K]> } : T;
-// Recursively rewrite all `Stub<T>`s with the corresponding `T`s.
-// Note we use `StubBase` instead of `Stub` here to avoid circular dependencies:
-// `Stub` depends on `Provider`, which depends on `Unstubify`, which would depend on `Stub`.
-// prettier-ignore
-type UnstubifyInner<T> = T extends StubBase<infer V> ? (T | V) // can provide either stub or local RpcTarget
-: T extends Map<infer K, infer V> ? Map<Unstubify<K>, Unstubify<V>> : T extends Set<infer V> ? Set<Unstubify<V>> : T extends [] ? [] : T extends [infer Head, ...infer Tail] ? [Unstubify<Head>, ...Unstubify<Tail>] : T extends readonly [] ? readonly [] : T extends readonly [infer Head, ...infer Tail] ? readonly [Unstubify<Head>, ...Unstubify<Tail>] : T extends Array<infer V> ? Array<Unstubify<V>> : T extends ReadonlyArray<infer V> ? ReadonlyArray<Unstubify<V>> : T extends BaseType ? T : T extends {
-  [key: string | number]: unknown;
-} ? { [K in keyof T]: Unstubify<T[K]> } : T;
-// You can put promises anywhere in the params and they'll be resolved before delivery.
-// (This also covers RpcPromise, because it's defined as being a Promise.)
-type Unstubify<T> = UnstubifyInner<T> | Promise<UnstubifyInner<T>>;
-type UnstubifyAll<A extends any[]> = { [I in keyof A]: Unstubify<A[I]> };
-// Utility type for adding `Disposable`s to `object` types only.
-// Note `unknown & T` is equivalent to `T`.
-type MaybeDisposable<T> = T extends object ? Disposable : unknown;
-// Type for method return or property on an RPC interface.
-// - Stubable types are replaced by stubs.
-// - RpcCompatible types are passed by value, with stubable types replaced by stubs
-//   and a top-level `Disposer`.
-// Everything else can't be passed over RPC.
-// Technically, we use custom thenables here, but they quack like `Promise`s.
-// Intersecting with `(Maybe)Provider` allows pipelining.
-// prettier-ignore
-type Result<R$1> = R$1 extends Stubable ? Promise<Stub<R$1>> & Provider<R$1> & StubBase<R$1> : R$1 extends RpcCompatible<R$1> ? Promise<Stubify<R$1> & MaybeDisposable<R$1>> & Provider<R$1> & StubBase<R$1> : never;
-// Type for method or property on an RPC interface.
-// For methods, unwrap `Stub`s in parameters, and rewrite returns to be `Result`s.
-// Unwrapping `Stub`s allows calling with `Stubable` arguments.
-// For properties, rewrite types to be `Result`s.
-// In each case, unwrap `Promise`s.
-type MethodOrProperty<V$1> = V$1 extends ((...args: infer P) => infer R) ? (...args: UnstubifyAll<P>) => Result<Awaited<R>> : Result<Awaited<V$1>>;
-// Type for the callable part of an `Provider` if `T` is callable.
-// This is intersected with methods/properties.
-type MaybeCallableProvider<T> = T extends ((...args: any[]) => any) ? MethodOrProperty<T> : unknown;
-// Base type for all other types providing RPC-like interfaces.
-// Rewrites all methods/properties to be `MethodOrProperty`s, while preserving callable types.
-type Provider<T> = MaybeCallableProvider<T> & (T extends Array<infer U> ? {
-  [key: number]: MethodOrProperty<U>;
-} & {
-  map<V$1>(callback: (elem: U) => V$1): Result<Array<V$1>>;
-} : { [K in Exclude<keyof T, symbol | keyof StubBase<never>>]: MethodOrProperty<T[K]> } & {
-  map<V$1>(callback: (value: NonNullable<T>) => V$1): Result<Array<V$1>>;
-});
-/**
- * Options to customize behavior of an RPC session. All functions which start a session should
- * optionally accept this.
- */
-type RpcSessionOptions = {
-  /**
-   * If provided, this function will be called whenever an `Error` object is serialized (for any
-   * reason, not just because it was thrown). This can be used to log errors, and also to redact
-   * them.
-   *
-   * If `onSendError` returns an Error object, than object will be substituted in place of the
-   * original. If it has a stack property, the stack will be sent to the client.
-   *
-   * If `onSendError` doesn't return anything (or is not provided at all), the default behavior is
-   * to serialize the error with the stack omitted.
-   */
-  onSendError?: (error: Error) => Error | void;
-};
-/**
- * For use in Cloudflare Workers: Construct an HTTP response that starts a WebSocket RPC session
- * with the given `localMain`.
- */
-/**
- * Represents a reference to a remote object, on which methods may be remotely invoked via RPC.
- *
- * `RpcStub` can represent any interface (when using TypeScript, you pass the specific interface
- * type as `T`, but this isn't known at runtime). The way this works is, `RpcStub` is actually a
- * `Proxy`. It makes itself appear as if every possible method / property name is defined. You can
- * invoke any method name, and the invocation will be sent to the server. If it turns out that no
- * such method exists on the remote object, an exception is thrown back. But the client does not
- * actually know, until that point, what methods exist.
- */
-type RpcStub<T extends RpcCompatible<T>> = Stub<T>;
-declare const RpcStub: {
-  new <T extends RpcCompatible<T>>(value: T): RpcStub<T>;
-};
-/**
- * Represents the result of an RPC call.
- *
- * Also used to represent properties. That is, `stub.foo` evaluates to an `RpcPromise` for the
- * value of `foo`.
- *
- * This isn't actually a JavaScript `Promise`. It does, however, have `then()`, `catch()`, and
- * `finally()` methods, like `Promise` does, and because it has a `then()` method, JavaScript will
- * allow you to treat it like a promise, e.g. you can `await` it.
- *
- * An `RpcPromise` is also a proxy, just like `RpcStub`, where calling methods or awaiting
- * properties will make a pipelined network request.
- *
- * Note that and `RpcPromise` is "lazy": the actual final result is not requested from the server
- * until you actually `await` the promise (or call `then()`, etc. on it). This is an optimization:
- * if you only intend to use the promise for pipelining and you never await it, then there's no
- * need to transmit the resolution!
- */
-/**
- * Classes which are intended to be passed by reference and called over RPC must extend
- * `RpcTarget`. A class which does not extend `RpcTarget` (and which doesn't have built-in support
- * from the RPC system) cannot be passed in an RPC message at all; an exception will be thrown.
- *
- * Note that on Cloudflare Workers, this `RpcTarget` is an alias for the one exported from the
- * "cloudflare:workers" module, so they can be used interchangably.
- */
-interface RpcTarget extends RpcTargetBranded {}
-declare const RpcTarget: {
-  new (): RpcTarget;
-};
-/**
- * Empty interface used as default type parameter for sessions where the other side doesn't
- * necessarily export a main interface.
- */
-interface Empty {}
-/**
- * Start a WebSocket session given either an already-open WebSocket or a URL.
- *
- * @param webSocket Either the `wss://` URL to connect to, or an already-open WebSocket object to
- * use.
- * @param localMain The main RPC interface to expose to the peer. Returns a stub for the main
- * interface exposed from the peer.
- */
-declare let newWebSocketRpcSession: <T extends RpcCompatible<T> = Empty>(webSocket: WebSocket | string, localMain?: any, options?: RpcSessionOptions) => RpcStub<T>;
-/**
- * Initiate an HTTP batch session from the client side.
- *
- * The parameters to this method have exactly the same signature as `fetch()`, but the return
- * value is an RpcStub. You can customize anything about the request except for the method
- * (it will always be set to POST) and the body (which the RPC system will fill in).
- */
-/**
- * Implements unified handling of HTTP-batch and WebSocket responses for the Cloudflare Workers
- * Runtime.
- *
- * SECURITY WARNING: This function accepts cross-origin requests. If you do not want this, you
- * should validate the `Origin` header before calling this, or use `newHttpBatchRpcSession()` and
- * `newWebSocketRpcSession()` directly with appropriate security measures for each type of request.
- * But if your API uses in-band authorization (i.e. it has an RPC method that takes the user's
- * credentials as parameters and returns the authorized API), then cross-origin requests should
- * be safe.
- */
-declare function newWorkersRpcResponse(request: Request, localMain: any): Promise<Response>;
-//#endregion
-//#region src/rpc-toolset.d.ts
-declare function toolDef(): <This, Return>(target: (this: This) => Return, context: ClassMethodDecoratorContext<This, (this: This) => Return>) => (this: This) => Return;
-declare function toolDef<TInput>(inputSchema: StandardSchemaV1<TInput, TInput>): <This, Return>(target: (this: This, arg: TInput) => Return, context: ClassMethodDecoratorContext<This, (this: This, arg: TInput) => Return>) => (this: This, arg: TInput) => Return;
-declare function toolUnsafeNoValidation(): <This, Return>(target: (this: This, ...args: any[]) => Return, context: ClassMethodDecoratorContext<This, (...unknown: any[]) => Return>) => any;
-declare const callbackMetadataKey: unique symbol;
-type ToolCallback<T extends (arg: any) => unknown> = T | {
-  [callbackMetadataKey]: {
-    callback: T;
-  };
-};
-type Fn = ToolCallback<(arg: any) => any>;
-declare function callbackTool(): <This, Return>(target: (this: This, arg: Fn) => Return, context: ClassMethodDecoratorContext<This, (this: This, arg: Fn) => Return>) => (this: This, arg: Fn) => Return;
-declare const unwrapCallback: <A, V$1>(toolCallback: ToolCallback<(arg: A) => V$1>, returnSchema: StandardSchemaV1<V$1, V$1> | ((arg: unknown) => arg is V$1)) => <R$1>(arg: A, then: (result: V$1) => R$1, opts?: {
-  catch?: (error: unknown) => R$1;
-  finally?: () => void;
-}) => R$1;
-type ToolAnnotation = typeof toolDef & {
-  callback: typeof callbackTool;
-  unwrap: typeof unwrapCallback;
-  unsafeNoValidation: typeof toolUnsafeNoValidation;
-};
-declare const tool: ToolAnnotation;
-declare class RpcToolset extends RpcTarget {
-  constructor();
-}
-//#endregion
-//#region src/code-mode.d.ts
-type SafeEvalResult = {
-  wait: () => Promise<void>;
-  input: ReadableStream<Uint8Array>;
-  output: WritableStream<Uint8Array>;
-};
-type SafeEvalContext = {
-  safeEval: (code: string) => Promise<SafeEvalResult>;
-  sandboxContext: string;
-};
-type FlatTools = {
-  [key: string]: Tool;
-} | Tool[];
-type RpcTools = {
-  [key: string]: () => RpcToolset;
-};
-declare class CodeMode {
-  private context;
-  constructor(context: SafeEvalContext);
-  wrap(tools: FlatTools): Promise<Tool>;
-  wrap(tools: RpcTools | FlatTools, dts: string): Promise<Tool>;
-}
-//#endregion
-//#region src/code-mode-deno.d.ts
-/**
- * Creates a SafeEvalContext that uses Deno as the sandbox runtime.
- *
- * @param options - Configuration options for Deno sandbox
- * @param options.args - Deno custom arguments (default: [])
- * @param options.denoPath - Path to deno executable (default: 'deno')
- * @returns A SafeEvalContext configured for Deno
- */
-declare function createDenoSandbox(options?: {
-  args?: string[];
-  denoPath?: string;
-}): SafeEvalContext;
-//#endregion
-//#region src/sql/sql.d.ts
-type RawSql = RawBuilder<unknown>;
-//#endregion
-//#region src/sql/expression.d.ts
-type LiteralValue = number | string | boolean | null;
-type SqlExpressionIn = LiteralValue | SqlExpression;
-declare class SqlExpression extends RpcToolset {
-  precedence: number;
-  constructor(precedence?: number);
-  compile: () => RawSql;
-  or(expr: SqlExpression): BinaryExpression;
-  and(expr: SqlExpression): BinaryExpression;
-  not(): UnaryExpression;
-  isNull(): UnaryExpression;
-  isNotNull(): UnaryExpression;
-  '<'(expr: SqlExpression | number | string): BinaryExpression;
-  '<='(expr: SqlExpression | number | string): BinaryExpression;
-  '>'(expr: SqlExpression | number | string): BinaryExpression;
-  '>='(expr: SqlExpression | number | string): BinaryExpression;
-  '='(expr: SqlExpressionIn): BinaryExpression;
-  '<>'(expr: SqlExpressionIn): BinaryExpression;
-  '!='(expr: SqlExpressionIn): BinaryExpression;
-  'LIKE'(expr: SqlExpression | string): BinaryExpression;
-  'NOT LIKE'(expr: SqlExpression | string): BinaryExpression;
-  '+'(expr: SqlExpression | number | string): BinaryExpression;
-  '-'(expr: SqlExpression | number | string): BinaryExpression;
-  '*'(expr: SqlExpression | number | string): BinaryExpression;
-  '/'(expr: SqlExpression | number | string): BinaryExpression;
-  '%'(expr: SqlExpression | number | string): BinaryExpression;
-  asc(): OrderByValue;
-  desc(): OrderByValue;
-}
-declare class BinaryExpression extends SqlExpression {
-  private readonly left;
-  private readonly right;
-  private readonly operator;
-  constructor(left: SqlExpression, right: SqlExpression, operator: RawSql, precedence?: number);
-  compile: () => kysely0.RawBuilder<unknown>;
-}
-declare class UnaryExpression extends SqlExpression {
-  private readonly operand;
-  private readonly operator;
-  private readonly placement;
-  constructor(operand: SqlExpression, operator: RawSql, placement: 'prefix' | 'postfix', precedence?: number);
-  compile: () => kysely0.RawBuilder<unknown>;
-}
-declare class ColumnReferenceExpression extends SqlExpression {
-  readonly alias: string;
-  readonly column: string;
-  constructor(alias: string, column: string);
-  compile: () => kysely0.RawBuilder<unknown>;
-}
-declare class OrderByValue {
-  value: SqlExpression;
-  direction?: RawSql | undefined;
-  constructor(value: SqlExpression, direction?: RawSql | undefined);
-}
-//#endregion
-//#region src/sql/builder.d.ts
-type RowLikeRaw = {
-  [key: string]: SqlExpression;
-};
-type RowLikeRawIn = {
-  [key: string]: SqlExpressionIn;
-};
-type RowLike = RowLikeRaw | TableBase;
-type RowLikeIn = RowLikeRawIn | RowLike;
-type AsRowLike<R$1 extends RowLikeIn> = R$1 extends TableBase ? R$1 : { [key in keyof R$1]: R$1[key] extends SqlExpression ? R$1[key] : SqlExpression };
-type NamespacedExpression<A, R$1> = (arg: A) => R$1;
-type FromItem<N extends string, F extends RowLike> = {
-  alias: N;
-  toRowLike: () => F;
-  compile: (opts?: {
-    isSubquery?: boolean;
-  }) => RawSql;
-  onExpression?: SqlExpression;
-};
-type TableNamespace = {
-  [key: string]: RowLike;
-};
-type OrderByItem<TN extends TableNamespace> = NamespacedExpression<TN, SqlExpression | SqlExpression[] | OrderByValue | OrderByValue[] | (SqlExpression | OrderByValue)[]>;
-type Tables<TN extends TableNamespace> = { [k in keyof TN & string]: {
-  fromItem: FromItem<k, TN[k]>;
-  joinType: 'inner' | 'left' | null;
-  on?: SqlExpression;
-  isLateral: boolean;
-} };
-type QueryBuilderParams<N extends string, TN extends TableNamespace, S extends RowLike> = {
-  db: Database;
-  alias: N;
-  tables: Tables<TN>;
-  selectRowLike: S;
-  whereExpression?: SqlExpression;
-  orderByExpressions?: OrderByValue[];
-  limit?: number;
-  offset?: number;
-  rawTable: TableClass<N> | undefined;
-};
-declare class QueryBuilder<N extends string, TN extends TableNamespace, S extends RowLike> extends RpcToolset implements FromItem<N, S> {
-  #private;
-  readonly alias: N;
-  private selectRowLike;
-  private tables;
-  private whereExpression?;
-  private orderByExpressions?;
-  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>;
-  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 & { [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 }[]>;
-  private paramsForCopy;
-  toRowLike: () => S;
-  compile: (opts?: {
-    isSubquery?: boolean;
-  }) => kysely0.RawBuilder<unknown>;
-}
-declare class TableBase extends RpcToolset {
-  opts?: {
-    remapColumns?: boolean;
-  };
-  column: (this: InstanceType<TableClass<string>>, columnName: string) => ColumnReferenceExpression;
-}
-type TableClass<N extends string = string> = {
-  new (opts?: {
-    remapColumns?: boolean;
-  }): TableBase;
-  as: <T extends TableClass, N2 extends string>(this: T, alias: N2) => Omit<T, keyof TableClass> & TableClass<N2> & {
-    new (): InstanceType<T>;
-  };
-  toRowLike: <T extends TableClass>(this: T, opts?: {
-    remapColumns?: boolean;
-  }) => InstanceType<T>;
-  from: <T extends TableClass>(this: T) => QueryBuilder<N, { [k in N]: InstanceType<T> }, InstanceType<T>>;
-  on: <T extends TableClass>(this: T, on: NamespacedExpression<InstanceType<T>, SqlExpression>) => T;
-  compile: () => RawSql;
-  alias: N;
-  tableName: string;
-  onExpression?: SqlExpression;
-};
-declare class Database {
-  private dialect;
-  private opts?;
-  private kysely?;
-  constructor(dialect: Dialect, opts?: {
-    logQuery?: (raw: CompiledQuery) => void;
-  } | undefined);
-  execute(query: RawSql): Promise<unknown[]>;
-  Table<N extends string>(name: N): TableClass<N>;
-}
-//#endregion
-export { CodeMode, Database, RpcToolset, type SafeEvalContext, type SafeEvalResult, type TableClass, type ToolCallback, createDenoSandbox, newWebSocketRpcSession, newWorkersRpcResponse, tool };