agentlang/out/runtime/interpreter.d.ts

The easiest way to build the most reliable AI agents - enterprise-grade teams of AI agents that collaborate with each other and humans

import { CrudMap, Delete, Expr, ForEach, FullTextSearch, If, Pattern, Purge, Return, RuntimeHint, Statement } from '../language/generated/ast.js';
import { Instance, Relationship } from './module.js';
import { Resolver } from './resolvers/interface.js';
import { CrudType } from './util.js';
import { ActiveSessionInfo } from './auth/defs.js';
export type Result = any;
export declare function isEmptyResult(r: Result): boolean;
type BetweenRelInfo = {
    relationship: Relationship;
    connectedInstance: Instance;
};
type CatchHandlers = Map<string, Statement>;
export declare class Environment extends Instance {
    parent: Environment | undefined;
    private activeModule;
    private activeEventInstance;
    private activeUser;
    private activeUserSet;
    private lastResult;
    private trashedResult;
    private returnFlag;
    private parentPath;
    private normalizedParentPath;
    private betweenRelInfo;
    private activeResolvers;
    private activeTransactions;
    private inUpsertMode;
    private inDeleteMode;
    private inKernelMode;
    private suspensionId;
    private preGeneratedSuspensionId;
    private activeCatchHandlers;
    private eventExecutor;
    private statementsExecutor;
    private scratchPad;
    private agentMode;
    private agentChatId;
    private monitor;
    private activeUserData;
    constructor(name?: string, parent?: Environment);
    static from(parent: Environment, name?: string | undefined, isAsync?: boolean): Environment;
    static fromInstance(inst: Instance): Environment;
    asSerializableObject(): object;
    static FromSerializableObject(obj: any): Environment;
    lookup(k: string): Result;
    bind(k: string, v: any): Environment;
    bindInstance(inst: Instance): Environment;
    private static FlowContextTag;
    setFlowContext(s: string): Environment;
    resetFlowContext(): Environment;
    getFlowContext(): string | undefined;
    addToScratchPad(k: string, data: any): Environment;
    private addAttributesToScratchPad;
    getScratchPad(): any;
    resetScratchPad(): Environment;
    setScratchPad(obj: any): Environment;
    private templateMappings;
    setTemplateMapping(k: string, v: string): Environment;
    rewriteTemplateMappings(s: string): string;
    resetTemplateMappings(): Environment;
    static SuspensionUserData: string;
    bindSuspensionUserData(userData: string): Environment;
    lookupSuspensionUserData(): string | undefined;
    maybeLookupAgentInstance(entryName: string): Instance | undefined;
    setActiveEvent(eventInst: Instance | undefined): Environment;
    getActiveEventInstance(): Instance | undefined;
    isSuspended(): boolean;
    suspend(): string;
    releaseSuspension(): Environment;
    fetchSuspensionId(): string;
    markForReturn(): Environment;
    isMarkedForReturn(): boolean;
    propagateLastResult(): Environment;
    resetReturnFlag(): Environment;
    protected propagateSuspension(suspId: string): void;
    getSuspensionId(): string;
    getActiveAuthContext(): ActiveSessionInfo | undefined;
    getActiveToken(): string | undefined;
    setActiveUser(userId: string): Environment;
    getActiveUser(): string;
    setLastResult(result: Result): Environment;
    revokeLastResult(): Environment;
    getLastResult(): Result;
    getActiveModuleName(): string;
    switchActiveModuleName(newModuleName: string): string;
    setParentPath(path: string): Environment;
    getParentPath(): string | undefined;
    setNormalizedParentPath(path: string): Environment;
    getNormalizedParentPath(): string | undefined;
    setBetweenRelInfo(info: BetweenRelInfo): Environment;
    getBetweenRelInfo(): BetweenRelInfo | undefined;
    setActiveResolvers(resolvers: Map<string, Resolver>): Environment;
    getActiveResolvers(): Map<string, Resolver>;
    getResolver(resolverName: string): Resolver | undefined;
    addResolver(resolver: Resolver): Promise<Environment>;
    setActiveTransactions(txns: Map<string, string>): Environment;
    getActiveTransactions(): Map<string, string>;
    resetActiveTransactions(commit: boolean): Promise<Environment>;
    getTransactionForResolver(resolver: Resolver): Promise<string>;
    ensureTransactionForResolver(resolver: Resolver): Promise<Environment>;
    private endAllTransactions;
    callInTransaction(f: Function): Promise<any>;
    commitAllTransactions(): Promise<void>;
    rollbackAllTransactions(): Promise<void>;
    setInUpsertMode(flag: boolean): Environment;
    isInUpsertMode(): boolean;
    setInDeleteMode(flag: boolean): Environment;
    isInDeleteMode(): boolean;
    setInKernelMode(flag: boolean): Environment;
    isInKernelMode(): boolean;
    pushHandlers(handlers: CatchHandlers): boolean;
    hasHandlers(): boolean;
    popHandlers(): CatchHandlers;
    setEventExecutor(exec: Function): Environment;
    getEventExecutor(): Function | undefined;
    unsetEventExecutor(): Environment;
    setStatementsExecutor(f: Function): Environment;
    getStatementsExecutor(): Function | undefined;
    callWithStatementsExecutor(exec: Function, f: Function): Promise<any>;
    setActiveUserData(data: any): Environment;
    getActiveUserData(): any;
    inChatAgentMode(): Environment;
    inPlannerAgentMode(): Environment;
    resetAgentMode(): Environment;
    isInAgentChatMode(): boolean;
    isAgentModeSet(): boolean;
    setAgentChatId(chatId: string): Environment;
    getAgentChatId(): string | undefined;
    appendEntryToMonitor(stmt: string): Environment;
    setMonitorEntryError(reason: string): Environment;
    setMonitorEntryResult(result: any): Environment;
    flagMonitorEntryAsLlm(): Environment;
    flagMonitorEntryAsPlanner(): Environment;
    flagMonitorEntryAsFlow(): Environment;
    flagMonitorEntryAsFlowStep(): Environment;
    flagMonitorEntryAsDecision(): Environment;
    setMonitorEntryLlmPrompt(s: string): Environment;
    setMonitorEntryLlmResponse(s: string): Environment;
    incrementMonitor(): Environment;
    decrementMonitor(): Environment;
    setMonitorFlowResult(): Environment;
}
export declare const GlobalEnvironment: Environment;
export declare let evaluate: (eventInstance: Instance, continuation?: Function, activeEnv?: Environment, kernelCall?: boolean) => Promise<Result>;
export declare function setEvaluateFn(f: any): Function;
export declare function evaluateAsEvent(moduleName: string, eventName: string, attrs: Array<any> | object, activeSession?: ActiveSessionInfo, env?: Environment, kernelCall?: boolean): Promise<Result>;
export declare function makeEventEvaluator(moduleName: string): Function;
export declare function evaluateStatements(stmts: Statement[], env: Environment, continuation?: Function): Promise<void>;
export declare function evaluateStatement(stmt: Statement, env: Environment): Promise<void>;
export declare function maybeBindStatementResultToAlias(hints: RuntimeHint[], env: Environment): void;
export declare let parseAndEvaluateStatement: (stmtString: string, activeUserId?: string, actievEnv?: Environment) => Promise<Result>;
export declare function setParseAndEvaluateStatementFn(f: any): Function;
export declare function lookupAllInstances(entityFqName: string): Promise<Instance[]>;
export declare class PatternHandler {
    handleExpression(expr: Expr, env: Environment): Promise<void>;
    handleCrudMap(crudMap: CrudMap, env: Environment): Promise<void>;
    handleForEach(forEach: ForEach, env: Environment): Promise<void>;
    handleIf(_if: If, env: Environment): Promise<void>;
    handleDelete(del: Delete, env: Environment): Promise<void>;
    handlePurge(purge: Purge, env: Environment): Promise<void>;
    handleFullTextSearch(fullTextSearch: FullTextSearch, env: Environment): Promise<void>;
    handleReturn(ret: Return, env: Environment): Promise<void>;
}
export declare function evaluatePattern(pat: Pattern, env: Environment, handler?: PatternHandler): Promise<void>;
export declare const DocEventName: string;
export declare function handleAgentInvocation(agentEventInst: Instance, env: Environment): Promise<void>;
export declare function restartFlow(flowContext: string[], userData: string, env: Environment): Promise<void>;
export declare function handleOpenApiEvent(eventInst: Instance, env: Environment): Promise<void>;
export declare function maybeDeleteQueriedInstances(queryEnv: Environment, env: Environment, purge?: boolean): Promise<void>;
export declare function evaluateExpression(expr: Expr, env: Environment): Promise<void>;
export declare function callPostEventOnSubscription(crudType: CrudType, inst: Instance, env?: Environment): Promise<any>;
export declare function runPostCreateEvents(inst: Instance, env: Environment): Promise<void>;
export declare function runPostUpdateEvents(inst: Instance, oldInst: Instance | undefined, env: Environment): Promise<void>;
export declare function runPostDeleteEvents(inst: Instance, env: Environment): Promise<void>;
export declare function fetchConfig(configEntityName: string): Promise<any>;
export {};
//# sourceMappingURL=interpreter.d.ts.map