agentlang 0.0.50 → 0.0.52

package/src/runtime/agents/impl/openai.ts

@@ -105,7 +105,7 @@ export class OpenAIProvider implements AgentServiceProvider {
   async invoke(messages: BaseMessage[], externalToolSpecs: any[] | undefined): Promise<AIResponse> {
     if (!this.config.apiKey) {
       throw new Error(
-        'OpenAI API key is required. Set OPENAI_API_KEY environment variable or provide apiKey in config.'
+        'OpenAI API key is required. Set OPENAI_API_KEY environment variable or use setLocalEnv("OPENAI_API_KEY", key) or provide apiKey in config.'
       );
     }
     if (externalToolSpecs) {

package/src/runtime/agents/registry.ts

@@ -1,5 +1,6 @@
 import { OpenAIProvider } from './impl/openai.js';
 import { AnthropicProvider } from './impl/anthropic.js';
+import { getLocalEnv } from '../auth/defs.js';
 
 const Providers = new Map().set('openai', OpenAIProvider).set('anthropic', AnthropicProvider);
 
@@ -18,6 +19,7 @@ export function provider(service: string) {
         p = Providers.get(availableService);
         if (p) return p;
       }
+
       const errorMessage = `${service} provider requested but ${service.toUpperCase()}_API_KEY not found. Available providers: ${getAvailableProviders().join(', ') || 'none'}`;
       console.error(errorMessage);
       throw new Error(errorMessage);
@@ -30,19 +32,19 @@ export function provider(service: string) {
 function isProviderAvailable(service: string): boolean {
   switch (service) {
     case 'openai':
-      return !!process.env.OPENAI_API_KEY;
+      return !!(process.env.OPENAI_API_KEY || getLocalEnv('OPENAI_API_KEY'));
     case 'anthropic':
-      return !!process.env.ANTHROPIC_API_KEY;
+      return !!(process.env.ANTHROPIC_API_KEY || getLocalEnv('ANTHROPIC_API_KEY'));
     default:
       return false;
   }
 }
 
 function getAvailableProvider(): string | null {
-  if (process.env.ANTHROPIC_API_KEY) {
+  if (process.env.ANTHROPIC_API_KEY || getLocalEnv('ANTHROPIC_API_KEY')) {
     return 'anthropic';
   }
-  if (process.env.OPENAI_API_KEY) {
+  if (process.env.OPENAI_API_KEY || getLocalEnv('OPENAI_API_KEY')) {
     return 'openai';
   }
   return null;
@@ -50,7 +52,11 @@ function getAvailableProvider(): string | null {
 
 function getAvailableProviders(): string[] {
   const available: string[] = [];
-  if (process.env.ANTHROPIC_API_KEY) available.push('anthropic');
-  if (process.env.OPENAI_API_KEY) available.push('openai');
+  if (process.env.ANTHROPIC_API_KEY || getLocalEnv('ANTHROPIC_API_KEY')) {
+    available.push('anthropic');
+  }
+  if (process.env.OPENAI_API_KEY || getLocalEnv('OPENAI_API_KEY')) {
+    available.push('openai');
+  }
   return available;
 }

package/src/runtime/interpreter.ts

@@ -47,7 +47,8 @@ import {
   Relationship,
   Workflow,
 } from './module.js';
-import { JoinInfo, Resolver, ResolverAuthInfo } from './resolvers/interface.js';
+import { JoinInfo, Resolver } from './resolvers/interface.js';
+import { ResolverAuthInfo } from './resolvers/authinfo.js';
 import { SqlDbResolver } from './resolvers/sqldb/impl.js';
 import {
   CrudType,
@@ -70,15 +71,7 @@ import {
 import { getResolver, getResolverNameForPath } from './resolvers/registry.js';
 import { parseStatement, parseWorkflow } from '../language/parser.js';
 import { ActiveSessionInfo, AdminSession, AdminUserId } from './auth/defs.js';
-import {
-  AgentInstance,
-  AgentEntityName,
-  AgentFqName,
-  findAgentByName,
-  FlowSpec,
-  getAgentFlow,
-  FlowStep,
-} from './modules/ai.js';
+import { AgentInstance, AgentEntityName, AgentFqName, findAgentByName } from './modules/ai.js';
 import { logger } from './logger.js';
 import {
   FlowSuspensionTag,
@@ -97,6 +90,7 @@ import {
 import { invokeModuleFn } from './jsmodules.js';
 import { invokeOpenApiEvent, isOpenApiEventInstance } from './openapi.js';
 import { fetchDoc } from './docs.js';
+import { FlowSpec, FlowStep, getAgentFlow } from './agents/common.js';
 
 export type Result = any;
 
@@ -169,6 +163,7 @@ export class Environment extends Instance {
       this.activeResolvers = new Map<string, Resolver>();
       this.activeTransactions = new Map<string, string>();
       this.activeCatchHandlers = new Array<CatchHandlers>();
+      this.attributes.set('process', process);
     }
   }
 

package/src/runtime/loader.ts

@@ -48,6 +48,7 @@ import {
   removeModule,
   newInstanceAttributes,
   addAgent,
+  fetchModule,
 } from './module.js';
 import {
   escapeSpecialChars,
@@ -67,13 +68,7 @@ import { maybeGetValidationErrors, parse, parseModule, parseWorkflow } from '../
 import { logger } from './logger.js';
 import { Environment, evaluateStatements, GlobalEnvironment } from './interpreter.js';
 import { createPermission, createRole } from './modules/auth.js';
-import {
-  AgentEntityName,
-  CoreAIModuleName,
-  LlmEntityName,
-  registerAgentFlow,
-  registerFlow,
-} from './modules/ai.js';
+import { AgentEntityName, CoreAIModuleName, LlmEntityName } from './modules/ai.js';
 import { GenericResolver, GenericResolverMethods } from './resolvers/interface.js';
 import { registerResolver, setResolver } from './resolvers/registry.js';
 import { Config, ConfigSchema, setAppConfig } from './state.js';
@@ -81,6 +76,7 @@ import { getModuleFn, importModule } from './jsmodules.js';
 import { SetSubscription } from './defs.js';
 import { ExtendedFileSystem } from '../utils/fs/interfaces.js';
 import z from 'zod';
+import { registerAgentFlow, registerFlow } from './agents/common.js';
 
 export async function extractDocument(
   fileName: string,
@@ -431,7 +427,7 @@ export function addWorkflowFromDef(def: WorkflowDefinition, moduleName: string):
 
 const StandaloneStatements = new Map<string, Statement[]>();
 
-function addStandaloneStatement(stmt: Statement, moduleName: string) {
+function addStandaloneStatement(stmt: Statement, moduleName: string, userDefined = true) {
   let stmts: Array<Statement> | undefined = StandaloneStatements.get(moduleName);
   if (stmts == undefined) {
     stmts = new Array<Statement>();
@@ -440,6 +436,10 @@ function addStandaloneStatement(stmt: Statement, moduleName: string) {
   if (!StandaloneStatements.has(moduleName)) {
     StandaloneStatements.set(moduleName, stmts);
   }
+  if (userDefined) {
+    const m = fetchModule(moduleName);
+    m.addStandaloneStatement(stmt);
+  }
 }
 
 export async function runStandaloneStatements() {
@@ -486,6 +486,8 @@ async function addAgentDefinition(def: AgentDefinition, moduleName: string) {
         });
         attrsStrs.push(`type "flow-exec"`);
         attrs.set('type', 'flow-exec');
+        attrsStrs.push(`flows "${fnames}"`);
+        attrs.set('flows', fnames);
       } else {
         throw new Error(`Invalid flows list in agent ${name}`);
       }
@@ -526,10 +528,11 @@ async function addAgentDefinition(def: AgentDefinition, moduleName: string) {
   }, @upsert}`;
   let wf = createAgent;
   if (llmName) {
-    wf = `{${CoreAIModuleName}/${LlmEntityName} {name "${llmName}"}, @upsert}; ${wf}`;
+    const service = process.env.ANTHROPIC_API_KEY ? 'anthropic' : 'openai';
+    wf = `{${CoreAIModuleName}/${LlmEntityName} {name "${llmName}", service "${service}"}, @upsert}; ${wf}`;
   }
   (await parseWorkflow(`workflow A {${wf}}`)).statements.forEach((stmt: Statement) => {
-    addStandaloneStatement(stmt, moduleName);
+    addStandaloneStatement(stmt, moduleName, false);
   });
   addAgent(def.name, attrs, moduleName);
 }
@@ -569,7 +572,17 @@ function processAgentArrayValue(expr: Expr | undefined, attrName: string): strin
 
 function addFlowDefinition(def: FlowDefinition, moduleName: string) {
   if (def.body && def.$cstNode) {
-    registerFlow(`${moduleName}/${def.name}`, def.$cstNode.text);
+    const m = fetchModule(moduleName);
+    const sdef = def.$cstNode.text;
+    const idx = sdef.indexOf('{');
+    let f = '';
+    if (idx > 0) {
+      f = sdef.substring(idx + 1, sdef.lastIndexOf('}')).trim();
+    } else {
+      f = sdef;
+    }
+    m.addFlow(def.name, f);
+    registerFlow(`${moduleName}/${def.name}`, f);
   }
 }
 

package/src/runtime/module.ts

@@ -816,42 +816,63 @@ export class Agent extends Record {
     return this.removeAgentAttribute('type');
   }
 
-  setTools(tools: string[]): Agent {
-    this.attributes.set('tools', tools.join(','));
+  private setStrings(attrName: string, v: string[]): Agent {
+    this.attributes.set(attrName, v.join(','));
     return this;
   }
 
-  getTools(): string[] | undefined {
-    const tools = this.attributes.get('tools');
-    if (tools) {
-      return tools.split(',');
+  private getStrings(attrName: string): string[] | undefined {
+    const v = this.attributes.get(attrName);
+    if (v) {
+      return v.split(',');
     } else {
       return undefined;
     }
   }
 
+  setTools(tools: string[]): Agent {
+    return this.setStrings('tools', tools);
+  }
+
+  getTools(): string[] | undefined {
+    return this.getStrings('tools');
+  }
+
   removeTools(): Agent {
     return this.removeAgentAttribute('tools');
   }
 
   setDocuments(docs: string[]): Agent {
-    this.attributes.set('documents', docs.join(','));
-    return this;
+    return this.setStrings('documents', docs);
   }
 
-  getDocuments(): string {
-    return this.attributes.get('documents');
+  getDocuments(): string[] | undefined {
+    return this.getStrings('documents');
   }
 
   removeDocuments(): Agent {
     return this.removeAgentAttribute('documents');
   }
 
+  setFlows(flows: string[]): Agent {
+    return this.setStrings('flows', flows);
+  }
+
+  getFlows(): string[] | undefined {
+    return this.getStrings('flows');
+  }
+
   override toString(): string {
     const attrs = new Array<string>();
     this.attributes.forEach((value: any, key: string) => {
-      if (key != 'moduleName') {
-        const v = isString(value) ? `"${value}"` : value;
+      const skip = key == 'moduleName' || (key == 'type' && value == 'flow-exec');
+      if (!skip) {
+        let v = value;
+        if (key == 'flows') {
+          v = `[${v}]`;
+        } else if (isString(v)) {
+          v = `"${v}"`;
+        }
         attrs.push(`    ${key} ${v}`);
       }
     });
@@ -1295,6 +1316,59 @@ export class Workflow extends ModuleEntry {
   }
 }
 
+export class Flow extends ModuleEntry {
+  flowSteps: string[];
+
+  constructor(name: string, moduleName: string, flow?: string) {
+    super(name, moduleName);
+    this.flowSteps = new Array<string>();
+    flow?.split('\n').forEach((step: string) => {
+      const s = step.trim();
+      if (s.length > 0) {
+        this.flowSteps.push(s);
+      }
+    });
+  }
+
+  getFlow(): string {
+    return this.flowSteps.join('\n');
+  }
+
+  removeStep(index: number): Flow {
+    this.flowSteps.splice(index, 1);
+    return this;
+  }
+
+  insertStep(index: number, s: string): Flow {
+    this.flowSteps.splice(index, 0, s);
+    return this;
+  }
+
+  stepsCount(): number {
+    return this.flowSteps.length;
+  }
+
+  override toString(): string {
+    return `flow ${this.name} {
+      ${this.getFlow()}
+    }`;
+  }
+}
+
+class StandaloneStatement extends ModuleEntry {
+  stmt: Statement;
+
+  constructor(stmt: Statement, moduleName: string) {
+    super(crypto.randomUUID(), moduleName);
+    this.stmt = stmt;
+  }
+
+  override toString(): string {
+    if (this.stmt.$cstNode) return this.stmt.$cstNode?.text;
+    else return '';
+  }
+}
+
 const EmptyWorkflow: Workflow = new Workflow('', [], DefaultModuleName);
 
 export function isEmptyWorkflow(wf: Workflow): boolean {
@@ -1340,6 +1414,32 @@ export class Module {
     return this.removeEntry(Agent.EscapeName(agentName));
   }
 
+  addFlow(name: string, flowString?: string): Flow {
+    const flow: Flow = new Flow(name, this.name, flowString);
+    this.addEntry(flow);
+    return flow;
+  }
+
+  getFlow(name: string): Flow | undefined {
+    if (this.hasEntry(name)) {
+      return this.getEntry(name) as Flow;
+    }
+    return undefined;
+  }
+
+  addStandaloneStatement(stmt: Statement): StandaloneStatement {
+    const s = new StandaloneStatement(stmt, this.name);
+    this.addEntry(s);
+    return s;
+  }
+
+  getStandaloneStatement(name: string): StandaloneStatement | undefined {
+    if (this.hasEntry(name)) {
+      return this.getEntry(name) as StandaloneStatement;
+    }
+    return undefined;
+  }
+
   private getEntryIndex(entryName: string): number {
     return this.entries.findIndex((v: ModuleEntry) => {
       return v.name == entryName;

package/src/runtime/modules/ai.ts

@@ -22,7 +22,7 @@ import {
   systemMessage,
 } from '../agents/provider.js';
 import { AIMessage, BaseMessage, HumanMessage } from '@langchain/core/messages';
-import { FlowExecInstructions, PlannerInstructions } from '../agents/common.js';
+import { FlowExecInstructions, FlowStep, PlannerInstructions } from '../agents/common.js';
 import { PathAttributeNameQuery } from '../defs.js';
 import { logger } from '../logger.js';
 
@@ -49,6 +49,7 @@ entity ${AgentEntityName} {
     channels String @optional, // comma-separated list of channel names
     output String @optional, // fq-name of another agent to which the result will be pushed
     role String @optional,
+    flows String @optional,
     llm String
 }
 
@@ -95,6 +96,7 @@ export class AgentInstance {
   runWorkflows: boolean = true;
   output: string | undefined;
   role: string | undefined;
+  flows: string | undefined;
   private toolsArray: string[] | undefined = undefined;
   private hasModuleTools = false;
   private withSession = true;
@@ -416,40 +418,3 @@ export async function saveAgentChatSession(chatId: string, messages: any[], env:
 export function agentName(agentInstance: Instance): string {
   return agentInstance.lookup('name');
 }
-
-export type FlowSpec = string;
-export type FlowStep = string;
-
-const AgentFlows = new Map<string, string[]>();
-const FlowRegistry = new Map<string, FlowSpec>();
-
-export function registerFlow(name: string, flow: FlowSpec): string {
-  FlowRegistry.set(name, flow);
-  return name;
-}
-
-export function getFlow(name: string): FlowSpec | undefined {
-  return FlowRegistry.get(name);
-}
-
-export function registerAgentFlow(agentName: string, flowSpecName: string): string {
-  let currentFlows = AgentFlows.get(agentName);
-  if (currentFlows) {
-    currentFlows.push(flowSpecName);
-  } else {
-    currentFlows = new Array<string>();
-    currentFlows.push(flowSpecName);
-  }
-  AgentFlows.set(agentName, currentFlows);
-  return agentName;
-}
-
-// Return the first flow registered with the agent.
-export function getAgentFlow(agentName: string): FlowSpec | undefined {
-  const currentFlows = AgentFlows.get(agentName);
-  if (currentFlows) {
-    return getFlow(currentFlows[0]);
-  } else {
-    return undefined;
-  }
-}

package/src/runtime/resolvers/authinfo.ts

@@ -0,0 +1,14 @@
+export class ResolverAuthInfo {
+  userId: string;
+  readForUpdate = false;
+  readForDelete = false;
+
+  constructor(userId: string, readForUpdate?: boolean, readForDelete?: boolean) {
+    this.userId = userId;
+    if (readForUpdate != undefined) this.readForUpdate = readForUpdate;
+    if (readForDelete != undefined) this.readForDelete = readForDelete;
+  }
+}
+
+// This user-id is only for testing. Override per session from the HTTP layer.
+export const DefaultAuthInfo = new ResolverAuthInfo('9459a305-5ee6-415d-986d-caaf6d6e2828');

package/src/runtime/resolvers/interface.ts

@@ -1,7 +1,6 @@
 import {
   callPostEventOnSubscription,
   Environment,
-  evaluate,
   runPostCreateEvents,
   runPostDeleteEvents,
   runPostUpdateEvents,
@@ -15,24 +14,7 @@ import {
   Relationship,
 } from '../module.js';
 import { CrudType, splitFqName } from '../util.js';
-
-export class ResolverAuthInfo {
-  userId: string;
-  readForUpdate: boolean = false;
-  readForDelete: boolean = false;
-
-  constructor(userId: string, readForUpdate?: boolean, readForDelete?: boolean) {
-    this.userId = userId;
-    if (readForUpdate != undefined) this.readForUpdate = readForUpdate;
-    if (readForDelete != undefined) this.readForDelete = readForDelete;
-  }
-}
-
-export const DefaultAuthInfo = new ResolverAuthInfo(
-  // This user-id is only for testing, per-session user-id needs to be set from
-  // the HTTP layer.
-  '9459a305-5ee6-415d-986d-caaf6d6e2828'
-);
+import { DefaultAuthInfo, ResolverAuthInfo } from './authinfo.js';
 
 export type JoinInfo = {
   relationship: Relationship;
@@ -242,6 +224,7 @@ export class Resolver {
               path.getEntryName(),
               newInstanceAttributes().set('data', result)
             );
+            const { evaluate } = await import('../interpreter.js');
             return await evaluate(inst);
           }
         }

package/src/runtime/resolvers/sqldb/database.ts

@@ -6,7 +6,7 @@ import {
   OwnersSuffix,
   VectorSuffix,
 } from './dbutil.js';
-import { DefaultAuthInfo, ResolverAuthInfo } from '../interface.js';
+import { DefaultAuthInfo, ResolverAuthInfo } from '../authinfo.js';
 import { canUserCreate, canUserDelete, canUserRead, canUserUpdate } from '../../modules/auth.js';
 import { Environment, GlobalEnvironment } from '../../interpreter.js';
 import {
@@ -17,7 +17,6 @@ import {
   RbacSpecification,
   Relationship,
 } from '../../module.js';
-import pgvector from 'pgvector';
 import { isString } from '../../util.js';
 import {
   DeletedFlagAttributeName,
@@ -194,10 +193,60 @@ function makeSqliteDataSource(
   });
 }
 
+function isBrowser(): boolean {
+  // window for DOM pages, self+importScripts for web workers
+  return (
+    (typeof window !== 'undefined' && typeof (window as any).document !== 'undefined') ||
+    (typeof self !== 'undefined' && typeof (self as any).importScripts === 'function')
+  );
+}
+
+function defaultLocateFile(file: string): string {
+  // Out-of-the-box: use the official CDN in browsers.
+  if (isBrowser()) {
+    return `https://sql.js.org/dist/${file}`;
+  }
+  // Node: resolve from node_modules/sql.js/dist
+  try {
+    /* eslint-disable-next-line @typescript-eslint/no-require-imports */
+    const path = require('path');
+
+    const base = require.resolve('sql.js/dist/sql-wasm.js');
+    return path.join(path.dirname(base), file);
+  } catch {
+    return file;
+  }
+}
+
+function makeSqljsDataSource(
+  entities: EntitySchema[],
+  _config: DatabaseConfig | undefined,
+  synchronize: boolean = true
+): DataSource {
+  return new DataSource({
+    type: 'sqljs',
+    autoSave: false,
+    sqlJsConfig: {
+      locateFile: defaultLocateFile,
+    },
+    synchronize: synchronize,
+    entities: entities,
+  });
+}
+
 const DbType = 'sqlite';
 
 function getDbType(config?: DatabaseConfig): string {
-  return process.env.AL_DB_TYPE || config?.type || DbType;
+  if (config?.type) return config.type;
+  let envType: string | undefined;
+  try {
+    if (typeof process !== 'undefined' && process.env) {
+      envType = process.env.AL_DB_TYPE;
+    }
+  } catch {}
+  if (envType) return envType;
+  if (isBrowser()) return 'sqljs';
+  return DbType;
 }
 
 function getDsFunction(
@@ -212,6 +261,8 @@ function getDsFunction(
       return makeSqliteDataSource;
     case 'postgres':
       return makePostgresDataSource;
+    case 'sqljs':
+      return makeSqljsDataSource;
     default:
       throw new Error(`Unsupported database type - ${config?.type}`);
   }
@@ -221,6 +272,15 @@ export function isUsingSqlite(): boolean {
   return getDbType() == 'sqlite';
 }
 
+export function isUsingSqljs(): boolean {
+  return getDbType() == 'sqljs';
+}
+
+export function isVectorStoreSupported(): boolean {
+  // Only Postgres supports pgvector
+  return getDbType() === 'postgres';
+}
+
 export async function initDatabase(config: DatabaseConfig | undefined) {
   if (defaultDataSource == undefined) {
     const mkds = getDsFunction(config);
@@ -268,9 +328,11 @@ export async function addRowForFullTextSearch(
   vect: number[],
   ctx: DbContext
 ) {
+  if (!isVectorStoreSupported()) return;
   try {
     const vecTableName = tableName + VectorSuffix;
     const qb = getDatasourceForTransaction(ctx.txnId).createQueryBuilder();
+    const { default: pgvector } = await import('pgvector');
     await qb
       .insert()
       .into(vecTableName)
@@ -282,6 +344,10 @@ export async function addRowForFullTextSearch(
 }
 
 export async function initVectorStore(tableNames: string[], ctx: DbContext) {
+  if (!isVectorStoreSupported()) {
+    logger.info(`Vector store not supported for ${getDbType()}, skipping init...`);
+    return;
+  }
   let notInited = true;
   tableNames.forEach(async (vecTableName: string) => {
     const vecRepo = getDatasourceForTransaction(ctx.txnId).getRepository(vecTableName);
@@ -312,9 +378,14 @@ export async function vectorStoreSearch(
   limit: number,
   ctx: DbContext
 ): Promise<any> {
+  if (!isVectorStoreSupported()) {
+    // Not supported on sqljs/sqlite
+    return [];
+  }
   try {
     const vecTableName = tableName + VectorSuffix;
     const qb = getDatasourceForTransaction(ctx.txnId).getRepository(tableName).manager;
+    const { default: pgvector } = await import('pgvector');
     return await qb.query(
       `select id from ${vecTableName} order by embedding <-> $1 LIMIT ${limit}`,
       [pgvector.toSql(searchVec)]
@@ -329,6 +400,7 @@ export async function vectorStoreSearchEntryExists(
   id: string,
   ctx: DbContext
 ): Promise<boolean> {
+  if (!isVectorStoreSupported()) return false;
   try {
     const qb = getDatasourceForTransaction(ctx.txnId).getRepository(tableName).manager;
     const vecTableName = tableName + VectorSuffix;
@@ -341,6 +413,7 @@ export async function vectorStoreSearchEntryExists(
 }
 
 export async function deleteFullTextSearchEntry(tableName: string, id: string, ctx: DbContext) {
+  if (!isVectorStoreSupported()) return;
   try {
     const qb = getDatasourceForTransaction(ctx.txnId).getRepository(tableName).manager;
     const vecTableName = tableName + VectorSuffix;