agentlang 0.1.9 → 0.2.1

package/src/runtime/module.ts

@@ -23,7 +23,7 @@ import {
 } from '../language/generated/ast.js';
 import {
   Path,
-  splitFqName,
+  nameToPath,
   isString,
   isNumber,
   isBoolean,
@@ -42,6 +42,7 @@ import {
   findUqCompositeAttributes,
   escapeFqName,
   encryptPassword,
+  splitFqName,
 } from './util.js';
 import { parseStatement } from '../language/parser.js';
 import { ActiveSessionInfo, AdminSession } from './auth/defs.js';
@@ -52,6 +53,7 @@ import {
   AgentCondition,
   AgentGlossaryEntry,
   AgentScenario,
+  getAgentDirectives,
   getAgentDirectivesJson,
   getAgentGlossary,
   getAgentResponseSchema,
@@ -295,7 +297,7 @@ export class Record extends ModuleEntry {
         let t: string | undefined = isArrayType ? a.arrayType : a.type;
         if (a.refSpec) {
           let fp = a.refSpec.ref;
-          const rp = splitFqName(fp);
+          const rp = nameToPath(fp);
           if (!rp.hasModule()) {
             rp.setModuleName(this.moduleName);
             fp = rp.asFqName();
@@ -515,14 +517,34 @@ export class Record extends ModuleEntry {
   }
 
   override toString(): string {
+    return this.toString_();
+  }
+
+  toString_(internParentSchema: boolean = false): string {
     if (this.type == RecordType.EVENT && this.meta && this.meta.get(SystemDefinedEvent)) {
       return '';
     }
     let s: string = `${RecordType[this.type].toLowerCase()} ${this.name}`;
-    if (this.parentEntryName) {
+    let scm: RecordSchema = this.schema;
+    if (this.parentEntryName && !internParentSchema) {
       s = s.concat(` extends ${this.parentEntryName}`);
+      scm = newRecordSchema();
+      let modName = this.moduleName;
+      let pname = this.parentEntryName;
+      if (isFqName(pname)) {
+        const parts = splitFqName(pname);
+        modName = parts[0];
+        pname = parts[1];
+      }
+      const p = fetchModule(modName).getEntry(pname) as Record;
+      const pks = new Set(p.schema.keys());
+      this.schema.forEach((v: AttributeSpec, n: string) => {
+        if (!pks.has(n)) {
+          scm.set(n, v);
+        }
+      });
     }
-    let scms = recordSchemaToString(this.schema);
+    let scms = recordSchemaToString(scm);
     if (this.rbac && this.rbac.length > 0) {
       const rbs = this.rbac.map((rs: RbacSpecification) => {
         return rs.toString();
@@ -563,7 +585,7 @@ function fetchModuleByEntryName(
   suspectModuleName: string
 ): FetchModuleByEntryNameResult {
   if (isFqName(entryName)) {
-    const path: Path = splitFqName(entryName);
+    const path: Path = nameToPath(entryName);
     entryName = path.getEntryName();
     suspectModuleName = path.getModuleName();
   }
@@ -623,7 +645,7 @@ function asPropertiesMap(props: PropertyDefinition[]): Map<string, any> | undefi
 function maybeProcessRefProperty(props: Map<string, any>): Map<string, any> {
   const v: string | undefined = props.get('ref');
   if (v != undefined) {
-    const parts: Path = splitFqName(v);
+    const parts: Path = nameToPath(v);
     if (!parts.hasModule()) {
       parts.setModuleName(activeModule);
     }
@@ -902,26 +924,46 @@ export class Agent extends Record {
     return this.getStrings('flows');
   }
 
+  getAgentFqName(): string {
+    return makeFqName(this.moduleName, this.getName());
+  }
+
   setDirectives(conds: AgentCondition[]): Agent {
-    registerAgentDirectives(this.getFqName(), conds);
+    registerAgentDirectives(this.getAgentFqName(), conds);
     return this;
   }
 
+  getDirectives(): AgentCondition[] | undefined {
+    return getAgentDirectives(this.getAgentFqName());
+  }
+
   setScenarios(scenarios: AgentScenario[]): Agent {
-    registerAgentScenarios(this.getFqName(), scenarios);
+    registerAgentScenarios(this.getAgentFqName(), scenarios);
     return this;
   }
 
+  getScenarios(): AgentScenario[] | undefined {
+    return getAgentScenarios(this.getAgentFqName());
+  }
+
   setGlossary(glossary: AgentGlossaryEntry[]): Agent {
-    registerAgentGlossary(this.getFqName(), glossary);
+    registerAgentGlossary(this.getAgentFqName(), glossary);
     return this;
   }
 
+  getGlossary(): AgentGlossaryEntry[] | undefined {
+    return getAgentGlossary(this.getAgentFqName());
+  }
+
   setResponseSchema(entryName: string): Agent {
-    registerAgentResponseSchema(this.getFqName(), entryName);
+    registerAgentResponseSchema(this.getAgentFqName(), entryName);
     return this;
   }
 
+  getResponseSchema(): string | undefined {
+    return getAgentResponseSchema(this.getAgentFqName());
+  }
+
   override toString(): string {
     const attrs = new Array<string>();
     this.attributes.forEach((value: any, key: string) => {
@@ -1025,7 +1067,7 @@ export type RelationshipNode = {
 };
 
 export function newRelNodeEntry(nodeFqName: string, alias?: string): RelationshipNode {
-  const p: Path = splitFqName(nodeFqName);
+  const p: Path = nameToPath(nodeFqName);
   return {
     path: p,
     alias: alias ? alias : p.getEntryName(),
@@ -1043,7 +1085,7 @@ function relNodeEntryToString(node: RelationshipNode): string {
 }
 
 function asRelNodeEntry(n: NodeDefinition): RelationshipNode {
-  const path: Path = splitFqName(n.name);
+  const path: Path = nameToPath(n.name);
   let modName = activeModule;
   const entryName = path.getEntryName();
   if (path.hasModule()) {
@@ -1523,6 +1565,25 @@ export function flowGraphNext(
   return undefined;
 }
 
+export class Decision extends ModuleEntry {
+  cases: string[];
+
+  constructor(name: string, moduleName: string, cases: string[]) {
+    super(name, moduleName);
+    this.cases = cases;
+  }
+
+  joinedCases(): string {
+    return this.cases.join('\n');
+  }
+
+  override toString(): string {
+    return `decision ${this.name} {
+      ${this.cases.join('\n')}
+    }`;
+  }
+}
+
 class StandaloneStatement extends ModuleEntry {
   stmt: Statement;
 
@@ -1588,10 +1649,12 @@ export class Module {
   getFlow(name: string): Flow | undefined {
     const n = Flow.asFlowName(name);
     if (this.hasEntry(n)) {
-      return this.getEntry(n) as Flow;
-    } else {
-      return undefined;
+      const e = this.getEntry(n);
+      if (e instanceof Flow) {
+        return e as Flow;
+      }
     }
+    return undefined;
   }
 
   getAllFlows(): Flow[] {
@@ -1607,6 +1670,22 @@ export class Module {
     return false;
   }
 
+  addDecision(name: string, cases: string[]): Decision {
+    const d = new Decision(name, this.name, cases);
+    this.addEntry(d);
+    return d;
+  }
+
+  getDecision(name: string): Decision | undefined {
+    if (this.hasEntry(name)) {
+      const e = this.getEntry(name);
+      if (e instanceof Decision) {
+        return e as Decision;
+      }
+    }
+    return undefined;
+  }
+
   addStandaloneStatement(stmt: Statement): StandaloneStatement {
     const s = new StandaloneStatement(stmt, this.name);
     this.addEntry(s);
@@ -1918,7 +1997,7 @@ export function isBuiltInType(type: string): boolean {
 
 export function isValidType(type: string): boolean {
   if (isBuiltInType(type)) return true;
-  const path: Path = splitFqName(type);
+  const path: Path = nameToPath(type);
   let modName: string = '';
   if (path.hasModule()) modName = path.getModuleName();
   else modName = activeModule;
@@ -2286,7 +2365,7 @@ export function prePostWorkflowName(
   entityName: string,
   moduleName?: string
 ): string {
-  const parts = splitFqName(entityName);
+  const parts = nameToPath(entityName);
   const mname = parts.hasModule() ? parts.getModuleName() : moduleName;
   if (!mname) {
     throw new Error(`Cannot infer module name for ${entityName}`);
@@ -2312,7 +2391,7 @@ export function parsePrePostWorkflowName(name: string): ThinWfHeader {
 
 function getEntityDef(entityName: string, moduleName: string): Entity | undefined {
   try {
-    const parts = splitFqName(entityName);
+    const parts = nameToPath(entityName);
     const mname = parts.hasModule() ? parts.getModuleName() : moduleName;
     return getEntity(parts.getEntryName(), mname);
   } catch (reason: any) {
@@ -2327,7 +2406,7 @@ export function getWorkflow(eventInstance: Instance): Workflow {
 
 export function getWorkflowForEvent(eventName: string, moduleName?: string): Workflow {
   if (isFqName(eventName)) {
-    const parts = splitFqName(eventName);
+    const parts = nameToPath(eventName);
     eventName = parts.getEntryName();
     moduleName = parts.getModuleName();
   }
@@ -2351,7 +2430,7 @@ export function getEntity(name: string, moduleName: string): Entity | undefined
 }
 
 function isEntryOfType(t: RecordType, fqName: string): boolean {
-  const path = splitFqName(fqName);
+  const path = nameToPath(fqName);
   const mod = fetchModule(path.getModuleName());
   return mod.isEntryOfType(t, path.getEntryName());
 }
@@ -3177,7 +3256,7 @@ export function instanceToObject<Type>(inst: Instance, obj: any): Type {
 }
 
 export function getEntityRbacRules(entityFqName: string): RbacSpecification[] | undefined {
-  const p = splitFqName(entityFqName);
+  const p = nameToPath(entityFqName);
   const mn = p.getModuleName();
   const en = p.getEntryName();
   const m = isModule(mn) && fetchModule(mn);
@@ -3191,7 +3270,7 @@ export function getEntityRbacRules(entityFqName: string): RbacSpecification[] |
 }
 
 export function asJSONSchema(fqName: string): string {
-  const parts = splitFqName(fqName);
+  const parts = nameToPath(fqName);
   if (parts.hasModule()) {
     const mod = fetchModule(parts.getModuleName());
     const record = mod.getRecord(parts.getEntryName());
@@ -3209,3 +3288,13 @@ export function asJSONSchema(fqName: string): string {
     throw new Error(`Failed to find module for ${fqName}`);
   }
 }
+
+export function getDecision(name: string, moduleName: string): Decision | undefined {
+  if (isFqName(name)) {
+    const parts = splitFqName(name);
+    name = parts[1];
+    moduleName = parts[0];
+  }
+  const m = fetchModule(moduleName);
+  return m.getDecision(name);
+}

package/src/runtime/modules/ai.ts

@@ -1,4 +1,4 @@
-import { isFqName, makeCoreModuleName, makeFqName, splitFqName } from '../util.js';
+import { isFqName, makeCoreModuleName, makeFqName, nameToPath, splitFqName } from '../util.js';
 import {
   Environment,
   GlobalEnvironment,
@@ -7,12 +7,15 @@ import {
 } from '../interpreter.js';
 import {
   asJSONSchema,
+  Decision,
   fetchModule,
+  getDecision,
   Instance,
   instanceToObject,
   isModule,
   makeInstance,
   newInstanceAttributes,
+  Record,
 } from '../module.js';
 import { provider } from '../agents/registry.js';
 import {
@@ -27,6 +30,7 @@ import {
   AgentCondition,
   AgentGlossaryEntry,
   AgentScenario,
+  DecisionAgentInstructions,
   FlowExecInstructions,
   getAgentDirectives,
   getAgentGlossary,
@@ -38,6 +42,8 @@ import {
 import { PathAttributeNameQuery } from '../defs.js';
 import { logger } from '../logger.js';
 import { FlowStep } from '../agents/flows.js';
+import Handlebars from 'handlebars';
+import { Statement } from '../../language/generated/ast.js';
 
 export const CoreAIModuleName = makeCoreModuleName('ai');
 export const AgentEntityName = 'Agent';
@@ -112,6 +118,7 @@ export class AgentInstance {
   private hasModuleTools = false;
   private withSession = true;
   private fqName: string | undefined;
+  private decisionExecutor = false;
 
   private constructor() {}
 
@@ -136,7 +143,7 @@ export class AgentInstance {
       for (let i = 0; i < agent.toolsArray.length; ++i) {
         const n = agent.toolsArray[i];
         if (isFqName(n)) {
-          const parts = splitFqName(n);
+          const parts = nameToPath(n);
           agent.hasModuleTools = isModule(parts.getModuleName());
         } else {
           agent.hasModuleTools = isModule(n);
@@ -147,7 +154,11 @@ export class AgentInstance {
     return agent;
   }
 
-  static FromFlowStep(step: FlowStep, flowAgent: AgentInstance): AgentInstance {
+  static FromFlowStep(step: FlowStep, flowAgent: AgentInstance, context: string): AgentInstance {
+    const desc = getDecision(step, flowAgent.moduleName);
+    if (desc) {
+      return AgentInstance.FromDecision(desc, flowAgent, context);
+    }
     const fqs = isFqName(step) ? step : `${flowAgent.moduleName}/${step}`;
     const instruction = `Analyse the context and generate the pattern required to invoke ${fqs}.
     Never include references in the pattern. All attribute values must be literals derived from the context.`;
@@ -162,7 +173,21 @@ export class AgentInstance {
         .set('tools', fqs)
         .set('type', 'planner')
     );
-    return AgentInstance.FromInstance(inst);
+    return AgentInstance.FromInstance(inst).disableSession();
+  }
+
+  static FromDecision(desc: Decision, flowAgent: AgentInstance, context: string): AgentInstance {
+    const instruction = `${DecisionAgentInstructions}\n${context}\n\n${desc.joinedCases()}`;
+    const inst = makeInstance(
+      CoreAIModuleName,
+      AgentEntityName,
+      newInstanceAttributes()
+        .set('llm', flowAgent.llm)
+        .set('name', `${desc.name}_agent`)
+        .set('moduleName', flowAgent.moduleName)
+        .set('instruction', instruction)
+    );
+    return AgentInstance.FromInstance(inst).disableSession().markAsDecisionExecutor();
   }
 
   disableSession(): AgentInstance {
@@ -187,6 +212,15 @@ export class AgentInstance {
     return this.type == 'flow-exec';
   }
 
+  markAsDecisionExecutor(): AgentInstance {
+    this.decisionExecutor = true;
+    return this;
+  }
+
+  isDecisionExecutor(): boolean {
+    return this.decisionExecutor;
+  }
+
   private directivesAsString(fqName: string): string {
     const conds = getAgentDirectives(fqName);
     if (conds) {
@@ -202,14 +236,9 @@ export class AgentInstance {
     return '';
   }
 
-  private cachedInstruction: string | undefined = undefined;
-
-  private getFullInstructions(): string {
-    if (this.cachedInstruction) {
-      return this.cachedInstruction;
-    }
+  private getFullInstructions(env: Environment): string {
     const fqName = this.getFqName();
-    this.cachedInstruction = `${this.instruction || ''} ${this.directivesAsString(fqName)}`;
+    let finalInstruction = `${this.instruction || ''} ${this.directivesAsString(fqName)}`;
     const gls = getAgentGlossary(fqName);
     if (gls) {
       const glss = new Array<string>();
@@ -218,23 +247,39 @@ export class AgentInstance {
           `${age.name}: ${age.meaning}. ${age.synonyms ? `These words are synonyms for ${age.name}: ${age.synonyms}` : ''}`
         );
       });
-      this.cachedInstruction = `${this.cachedInstruction}\nThe following glossary will be helpful for understanding user requests.
+      finalInstruction = `${finalInstruction}\nThe following glossary will be helpful for understanding user requests.
       ${glss.join('\n')}\n`;
     }
     const scenarios = getAgentScenarios(fqName);
     if (scenarios) {
       const scs = new Array<string>();
       scenarios.forEach((sc: AgentScenario) => {
-        scs.push(`User: ${sc.user}\nAI: ${sc.ai}\n`);
+        const aiResp = processScenarioResponse(sc.ai);
+        scs.push(`User: ${sc.user}\nAI: ${aiResp}\n`);
       });
-      this.cachedInstruction = `${this.cachedInstruction}\nHere are some example user requests and the corresponding responses you are supposed to produce:\n${scs.join('\n')}`;
+      finalInstruction = `${finalInstruction}\nHere are some example user requests and the corresponding responses you are supposed to produce:\n${scs.join('\n')}`;
     }
     const responseSchema = getAgentResponseSchema(fqName);
     if (responseSchema) {
-      this.cachedInstruction = `${this.cachedInstruction}\nReturn your response in the following JSON schema:\n${asJSONSchema(responseSchema)}
+      finalInstruction = `${finalInstruction}\nReturn your response in the following JSON schema:\n${asJSONSchema(responseSchema)}
 Only return a pure JSON object with no extra text, annotations etc.`;
     }
-    return this.cachedInstruction;
+    const spad = env.getScratchPad();
+    if (spad != undefined) {
+      if (finalInstruction.indexOf('{{') > 0) {
+        return AgentInstance.maybeRewriteTemplatePatterns(spad, finalInstruction);
+      } else {
+        const ctx = JSON.stringify(spad);
+        return `${finalInstruction}\nSome additional context:\n${ctx}`;
+      }
+    } else {
+      return finalInstruction;
+    }
+  }
+
+  private static maybeRewriteTemplatePatterns(scratchPad: any, instruction: string): string {
+    const templ = Handlebars.compile(instruction);
+    return templ(scratchPad);
   }
 
   maybeValidateJsonResponse(response: string | undefined): object | undefined {
@@ -242,7 +287,7 @@ Only return a pure JSON object with no extra text, annotations etc.`;
       const responseSchema = getAgentResponseSchema(this.getFqName());
       if (responseSchema) {
         const attrs = JSON.parse(response);
-        const parts = splitFqName(responseSchema);
+        const parts = nameToPath(responseSchema);
         const moduleName = parts.getModuleName();
         const entryName = parts.getEntryName();
         const attrsMap = new Map(Object.entries(attrs));
@@ -317,23 +362,32 @@ Only return a pure JSON object with no extra text, annotations etc.`;
     }
     const sess: Instance | null = this.withSession ? await findAgentChatSession(chatId, env) : null;
     let msgs: BaseMessage[] | undefined;
+    let cachedMsg: string | undefined = undefined;
     if (sess) {
       msgs = sess.lookup('messages');
     } else {
-      msgs = [systemMessage(this.getFullInstructions() || '')];
+      cachedMsg = this.getFullInstructions(env);
+      msgs = [systemMessage(cachedMsg || '')];
     }
     if (msgs) {
       try {
         const sysMsg = msgs[0];
         if (isplnr || isflow) {
           const s = isplnr ? PlannerInstructions : FlowExecInstructions;
-          const newSysMsg = systemMessage(
-            `${s}\n${this.toolsAsString()}\n${this.getFullInstructions()}`
-          );
+          const ts = this.toolsAsString();
+          const msg = `${s}\n${ts}\n${cachedMsg || this.getFullInstructions(env)}`;
+          const newSysMsg = systemMessage(msg);
           msgs[0] = newSysMsg;
         }
         msgs.push(humanMessage(await this.maybeAddRelevantDocuments(message, env)));
         const externalToolSpecs = this.getExternalToolSpecs();
+        logger.debug(
+          `Invoking LLM ${this.llm} via agent ${this.fqName} with messages:\n${msgs
+            .map((bm: BaseMessage) => {
+              return bm.content;
+            })
+            .join('\n')}`
+        );
         const response: AIResponse = await p.invoke(msgs, externalToolSpecs);
         msgs.push(assistantMessage(response.content));
         if (isplnr) {
@@ -412,7 +466,7 @@ Only return a pure JSON object with no extra text, annotations etc.`;
         let moduleName: string | undefined;
         let entryName: string | undefined;
         if (isFqName(n)) {
-          const parts = splitFqName(n);
+          const parts = nameToPath(n);
           moduleName = parts.getModuleName();
           entryName = parts.getEntryName();
         } else {
@@ -423,7 +477,10 @@ Only return a pure JSON object with no extra text, annotations etc.`;
           if (entryName) {
             const hasmod = slimModules.has(moduleName);
             const defs = hasmod ? slimModules.get(moduleName) : new Array<string>();
-            defs?.push(m.getEntry(entryName).toString());
+            const entry = m.getEntry(entryName);
+            const s =
+              entry instanceof Record ? (entry as Record).toString_(true) : entry.toString();
+            defs?.push(s);
             if (!hasmod && defs) {
               slimModules.set(moduleName, defs);
             }
@@ -562,3 +619,20 @@ export async function saveAgentChatSession(chatId: string, messages: any[], env:
 export function agentName(agentInstance: Instance): string {
   return agentInstance.lookup('name');
 }
+
+function processScenarioResponse(resp: string): string {
+  const r = resp.trimStart();
+  if (r.startsWith('[') || r.startsWith('{')) {
+    return resp;
+  }
+  if (isFqName(r)) {
+    const parts = splitFqName(r);
+    const m = fetchModule(parts[0]);
+    const wf = m.getWorkflowForEvent(parts[1]);
+    const ss = wf.statements.map((stmt: Statement) => {
+      return stmt.$cstNode?.text;
+    });
+    return `[${ss.join(';\n')}]`;
+  }
+  return resp;
+}

package/src/runtime/resolvers/interface.ts

@@ -13,7 +13,7 @@ import {
   newInstanceAttributes,
   Relationship,
 } from '../module.js';
-import { CrudType, splitFqName } from '../util.js';
+import { CrudType, nameToPath } from '../util.js';
 import { DefaultAuthInfo, ResolverAuthInfo } from './authinfo.js';
 
 export type JoinInfo = {
@@ -223,7 +223,7 @@ export class Resolver {
         } else {
           const eventName = getSubscriptionEvent(this.name);
           if (eventName) {
-            const path = splitFqName(eventName);
+            const path = nameToPath(eventName);
             const inst = makeInstance(
               path.getModuleName(),
               path.getEntryName(),

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

@@ -13,7 +13,7 @@ import {
   newInstanceAttributes,
   Relationship,
 } from '../../module.js';
-import { escapeFqName, makeFqName, splitFqName } from '../../util.js';
+import { escapeFqName, makeFqName, nameToPath } from '../../util.js';
 import { JoinInfo, Resolver } from '../interface.js';
 import { asTableReference } from './dbutil.js';
 import {
@@ -259,7 +259,7 @@ export class SqlDbResolver extends Resolver {
     const joinClauses: JoinClause[] = [];
     this.processJoinInfo(tableName, inst, joinsSpec, joinClauses);
     intoSpec.forEach((v: string, k: string) => {
-      const p = splitFqName(v);
+      const p = nameToPath(v);
       const mn = p.hasModule() ? p.getModuleName() : inst.moduleName;
       intoSpec.set(k, asTableReference(mn, p.getEntryName()));
     });

package/src/runtime/util.ts

@@ -141,7 +141,7 @@ export function isFqName(s: string): boolean {
   return s.indexOf('/') > 0;
 }
 
-export function splitFqName(s: string): Path {
+export function nameToPath(s: string): Path {
   if (s.indexOf('/') > 0) {
     const parts: string[] = s.split('/');
     return new Path(parts[0], parts[1]);
@@ -149,6 +149,10 @@ export function splitFqName(s: string): Path {
   return new Path(undefined, s);
 }
 
+export function splitFqName(s: string): string[] {
+  return s.split('/');
+}
+
 export function splitRefs(s: string): string[] {
   if (s.indexOf('.') > 0) {
     return s.split('.');

package/src/syntaxes/agentlang.monarch.ts

@@ -1,12 +1,12 @@
 // Monarch syntax highlighting for the agentlang language.
 export default {
     keywords: [
-        '@actions','@after','@as','@async','@before','@catch','@distinct','@enum','@expr','@from','@into','@meta','@oneof','@rbac','@ref','@then','@upsert','@with_unique','agent','allow','and','await','between','contains','create','delete','else','entity','error','event','extends','false','flow','for','if','import','in','like','module','not','not_found','onSubscription','or','purge','query','read','record','relationship','resolver','return','roles','subscribe','true','update','upsert','where','workflow'
+        '@actions','@after','@as','@async','@before','@catch','@distinct','@enum','@expr','@from','@into','@meta','@oneof','@rbac','@ref','@then','@upsert','@with_unique','agent','allow','and','await','between','case','contains','create','decision','delete','else','entity','error','event','extends','false','flow','for','if','import','in','like','module','not','not_found','onSubscription','or','purge','query','read','record','relationship','resolver','return','roles','subscribe','true','update','upsert','where','workflow'
     ],
     operators: [
-        '!=','*','+',',','-','-->','.','/',':',';','<','<=','<>','=','>','>=','?','@'
+        '!=','*','+',',','-','-->','.','/',':',';','<','<=','<>','=','==','>','>=','?','@'
     ],
-    symbols: /!=|\(|\)|\*|\+|,|-|-->|\.|\/|:|;|<|<=|<>|=|>|>=|\?|@|\[|\]|\{|\}/,
+    symbols: /!=|\(|\)|\*|\+|,|-|-->|\.|\/|:|;|<|<=|<>|=|==|>|>=|\?|@|\[|\]|\{|\}/,
 
     tokenizer: {
         initial: [