agentlang 0.9.5 → 0.9.7

package/src/language/parser.ts

@@ -411,27 +411,27 @@ function asFnCallPattern(fnCall: FnCall): FunctionCallPattern {
 }
 
 function introspectLiteral(lit: Literal): BasePattern {
-  if (lit.id) {
+  if (lit.id !== undefined) {
     return LiteralPattern.Id(lit.id);
-  } else if (lit.num) {
+  } else if (lit.num !== undefined) {
     return LiteralPattern.Number(lit.num);
-  } else if (lit.ref) {
+  } else if (lit.ref !== undefined) {
     return LiteralPattern.Reference(lit.ref);
   } else if (lit.str !== undefined) {
     return LiteralPattern.String(lit.str);
-  } else if (lit.bool) {
+  } else if (lit.bool !== undefined) {
     return LiteralPattern.Boolean(lit.bool == 'true' ? true : false);
-  } else if (lit.fnCall) {
+  } else if (lit.fnCall !== undefined) {
     return asFnCallPattern(lit.fnCall);
-  } else if (lit.asyncFnCall) {
+  } else if (lit.asyncFnCall !== undefined) {
     return asFnCallPattern(lit.asyncFnCall.fnCall).asAsync();
-  } else if (lit.array) {
+  } else if (lit.array !== undefined) {
     return LiteralPattern.Array(
       lit.array.vals.map((stmt: Statement) => {
         return introspectStatement(stmt);
       })
     );
-  } else if (lit.map) {
+  } else if (lit.map !== undefined) {
     return introspectMapLiteral(lit.map);
   } else {
     throw new Error(`Invalid literal - ${lit}`);

package/src/runtime/agents/common.ts

@@ -167,6 +167,9 @@ The following usage is NOT valid:
 
 <pattern> if (<expr>)
 
+Also C-style ternary-expressions of the form \`condition ? consequent : alternative\` IS INVALID in Agentlang. Always use a proper
+\`if-else\` statement.
+
 A pattern may execute asynchronously and its eventual result can be handled by patterns provided in the '@then' clause. An example is shown below:
 
 {sendChatMessage {to "amy", "text" "hello"}} @as response @then {
@@ -362,6 +365,105 @@ case or cases you selected and no additional text or comments. If you decide to
 Also select the case that is the best match for the given context, no need to look for a perfect match for all values specified in the context.
 Now apply the same analysis to the following context and cases provided by the user.
 `;
+export const EvalInstructions = `Consider the following request passed to an intelligent agent and its response. Rate the response on a scale of
+1-5, where 1 being the lowest score (response unacceptable) and 5 being the highest score (best response). Also describe why you gave a particular score.
+Reply in the JSON format {score: <score-for-the-response, summary: <your-reasons-for-giving-the-score>}`;
+
+export const LearningAgentInstructions = `Summarize requirements and use-cases as three constructs: 'decisions' and 'glossaries'.
+Your response must be encoded in JSON. The exact schema will be described later, but let's first consider an example that will help clarify
+how decisions and glossaries could be generate from a use-case. This use-case is from the insurance industry:
+
+In insurance, a claim is a formal request made by a policyholder (or beneficiary) to an insurance company asking for financial
+compensation or service because a covered event (loss) has occurred. When the company receives a claim, look at its risk-factor and
+set its approval-mode accordingly. If the risk-factor is 'low', then set the approval-mode to 'auto', if it's 'medium' then set approval-mode to
+'manual'. If the risk-factor is 'high', then set approval-mode to 'investigate'.
+
+Given the above use-case you should return the summary as:
+{
+  "summary": "A claim is a request for insurance benefits after a covered loss, and its risk level determines
+  whether it is auto-approved, manually reviewed, or investigated.",
+  "glossary": [
+    {
+      "word": "claim",
+      "meaning": "A claim is a request to an insurer for payment or service after a covered loss."
+    }
+  ],
+  "decisions": [
+    {
+      "name": "setApprovalByRiskFactor",
+      "conditions": [
+        {
+          "if": "risk-factor is low",
+          "then": "auto"
+        },
+        {
+          "if": "risk-factor is medium",
+          "then": "manual"
+        },
+        {
+          "if": "risk-factor is high",
+          "then": "investigate"
+        }
+      ]
+    }
+  ]
+}
+
+Sometimes, the use-case will also contain some examples, which you can summarize as 'scenarios'. An example follows:
+
+The ACME company gives salary-hikes to employees based on their sales. If the sales is $50000 or above, a 5-percent hike is given.
+If the sales is between $20000 and $50000, a hike of 2.5% is given. For sales below $20000, no hike is given. An employee who hit
+the target of $50000 is said to have hit a "jackpot". For example, if you see a message that says - "jake@acme.com hit a jackpot", that means
+the employee 'jake@acme.com' is eligible for a 5% hike.
+
+Given the above instruction, you should return:
+
+{
+  "summary": "ACME determines employee salary hikes based on achieved sales figures, with higher sales resulting in higher percentage increases. Employees who meet or exceed the top sales threshold are described as having hit a jackpot.",
+  "glossary": [
+    {
+      "word": "salary-hike",
+      "meaning": "An increase in an employee's salary based on defined performance criteria."
+    },
+    {
+      "word": "sales",
+      "meaning": "The total revenue generated by an employee, used as the basis for determining salary hikes."
+    },
+    {
+      "word": "jackpot",
+      "meaning": "A term used for employees whose sales are 50000 or above, making them eligible for the highest salary hike."
+    }
+  ],
+  "decisions": [
+    {
+      "name": "determineSalaryHikeBySales",
+      "conditions": [
+        {
+          "if": "sales is 50000 or above",
+          "then": "5-percent hike"
+        },
+        {
+          "if": "sales is between 20000 and 50000",
+          "then": "2.5-percent hike"
+        },
+        {
+          "if": "sales is below 20000",
+          "then": "no hike"
+        }
+      ]
+    }
+  ],
+  "scenarios": [
+    {
+      "user": "jake@acme.com hit a jackpot",
+      "ai": "give jake@acme.com a hike of 5-percent"
+    }
+  ]
+}
+
+For some user-requests, it may not be able to produce glossary or decisions (or both). In such cases, just return the 'summary'.
+Now process the user-request that follows.
+`;
 
 export type AgentCondition = {
   if: string;
@@ -575,3 +677,8 @@ export function getAgentScratchNames(agentFqName: string): Set<string> | undefin
 export function removeAgentScratchNames(agentFqName: string) {
   AgentScratchNames.delete(agentFqName);
 }
+
+export type AgentSummary = {
+  data: string;
+  summary: string;
+};

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

@@ -181,15 +181,15 @@ export class AnthropicProvider implements AgentServiceProvider {
     if (!config) {
       return {
         ...defaultConfig,
-        apiKey: process.env.ANTHROPIC_API_KEY || getLocalEnv('ANTHROPIC_API_KEY'),
+        apiKey: process.env.AGENTLANG_ANTHROPIC_KEY || getLocalEnv('AGENTLANG_ANTHROPIC_KEY'),
       };
     }
 
     const apiKey =
       config.get('apiKey') ||
       config.get('api_key') ||
-      process.env.ANTHROPIC_API_KEY ||
-      getLocalEnv('ANTHROPIC_API_KEY');
+      process.env.AGENTLANG_ANTHROPIC_KEY ||
+      getLocalEnv('AGENTLANG_ANTHROPIC_KEY');
 
     return {
       model: config.get('model') || defaultConfig.model,
@@ -266,7 +266,7 @@ export class AnthropicProvider implements AgentServiceProvider {
   ): Promise<AIResponse> {
     if (!this.config.apiKey) {
       throw new Error(
-        'Anthropic API key is required. Set ANTHROPIC_API_KEY environment variable or use setLocalEnv("ANTHROPIC_API_KEY", key) or provide apiKey in config.'
+        'Anthropic API key is required. Set AGENTLANG_ANTHROPIC_KEY environment variable or use setLocalEnv("AGENTLANG_ANTHROPIC_KEY", key) or provide apiKey in config.'
       );
     }
 

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

@@ -69,15 +69,15 @@ export class OpenAIProvider implements AgentServiceProvider {
     if (!config) {
       return {
         ...defaultConfig,
-        apiKey: process.env.OPENAI_API_KEY || getLocalEnv('OPENAI_API_KEY'),
+        apiKey: process.env.AGENTLANG_OPENAI_KEY || getLocalEnv('AGENTLANG_OPENAI_KEY'),
       };
     }
 
     const apiKey =
       config.get('apiKey') ||
       config.get('api_key') ||
-      process.env.OPENAI_API_KEY ||
-      getLocalEnv('OPENAI_API_KEY');
+      process.env.AGENTLANG_OPENAI_KEY ||
+      getLocalEnv('AGENTLANG_OPENAI_KEY');
 
     return {
       model: config.get('model') || defaultConfig.model,
@@ -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 use setLocalEnv("OPENAI_API_KEY", key) or provide apiKey in config.'
+        'OpenAI API key is required. Set AGENTLANG_OPENAI_KEY environment variable or use setLocalEnv("AGENTLANG_OPENAI_KEY", key) or provide apiKey in config.'
       );
     }
     if (externalToolSpecs) {

package/src/runtime/docs.ts

@@ -1,5 +1,6 @@
-import { getFileSystem } from '../utils/fs-utils.js';
 import { logger } from './logger.js';
+import { isNodeEnv } from '../utils/runtime.js';
+import { getFileSystem } from '../utils/fs-utils.js';
 
 const DocFetchers = new Map<string, Function>();
 
@@ -25,6 +26,39 @@ export async function fetchDoc(url: string): Promise<string | undefined> {
   else return undefined;
 }
 
+let PDFParse: any = null;
+let pdfWorkerSet = false;
+
+async function getPDFParse() {
+  if (!PDFParse) {
+    const pdfModule = await import('pdf-parse');
+    PDFParse = pdfModule.PDFParse;
+
+    // Set up web worker for browser
+    if (!isNodeEnv && !pdfWorkerSet && PDFParse.setWorker) {
+      // Worker is served from public/ directory
+      PDFParse.setWorker('/pdf.worker.mjs');
+      pdfWorkerSet = true;
+    }
+  }
+  return PDFParse;
+}
+
+async function parsePdfBuffer(buffer: Uint8Array): Promise<string> {
+  try {
+    const PDFParseClass = await getPDFParse();
+    const parser = new PDFParseClass({
+      data: buffer,
+      verbosity: 0,
+    });
+    const data = await parser.getText();
+    return data.text;
+  } catch (error: any) {
+    logger.error(`Failed to parse PDF: ${error.message}`);
+    throw new Error(`PDF parsing failed: ${error.message}`);
+  }
+}
+
 async function httpFetcher(url: string): Promise<string | undefined> {
   try {
     const response = await fetch(url, {
@@ -32,12 +66,24 @@ async function httpFetcher(url: string): Promise<string | undefined> {
     });
 
     if (!response.ok) {
-      logger.error(
-        `Failed to fetch document ${url}, HTTP error! status: ${response.status} ${response.text} ${response.statusText}`
-      );
+      logger.error(`Failed to fetch document ${url}, HTTP error! status: ${response.status}`);
       return undefined;
     }
-    return await response.text();
+
+    const contentType = response.headers.get('content-type') || '';
+    const content = await response.arrayBuffer();
+
+    const lowerUrl = url.toLowerCase();
+
+    // Process based on content type or file extension
+    if (contentType.includes('application/pdf') || lowerUrl.endsWith('.pdf')) {
+      return await parsePdfBuffer(new Uint8Array(content));
+    } else if (contentType.includes('text/markdown') || lowerUrl.endsWith('.md')) {
+      return new TextDecoder().decode(content);
+    } else {
+      // Default to text
+      return new TextDecoder().decode(content);
+    }
   } catch (reason: any) {
     logger.error(`Failed to fetch document ${url}: ${reason}`);
   }
@@ -45,11 +91,76 @@ async function httpFetcher(url: string): Promise<string | undefined> {
 }
 
 async function fetchFile(path: string): Promise<string> {
-  const fs = await getFileSystem();
-  if (path.startsWith('.')) {
-    path = `${process.cwd()}${path.substring(1)}`;
+  const lowerPath = path.toLowerCase();
+
+  if (lowerPath.endsWith('.pdf')) {
+    return await fetchPdfFile(path);
+  } else if (
+    lowerPath.endsWith('.md') ||
+    lowerPath.endsWith('.markdown') ||
+    lowerPath.endsWith('.mdown')
+  ) {
+    return await fetchMarkdownFile(path);
+  } else {
+    // Default: plain text
+    return await fetchTextFile(path);
+  }
+}
+
+async function fetchPdfFile(path: string): Promise<string> {
+  try {
+    const fs = await getFileSystem();
+
+    if (isNodeEnv && path.startsWith('.')) {
+      path = `${process.cwd()}${path.substring(1)}`;
+    }
+
+    const content = await fs.readFile(path);
+
+    let buffer: Uint8Array;
+    if (typeof content === 'string') {
+      buffer = new TextEncoder().encode(content);
+    } else if (Buffer.isBuffer(content)) {
+      buffer = new Uint8Array(content);
+    } else {
+      buffer = new Uint8Array(Buffer.from(content));
+    }
+
+    return await parsePdfBuffer(buffer);
+  } catch (error: any) {
+    logger.error(`Failed to read PDF file ${path}: ${error.message}`);
+    throw error;
+  }
+}
+
+async function fetchMarkdownFile(path: string): Promise<string> {
+  try {
+    const fs = await getFileSystem();
+
+    if (isNodeEnv && path.startsWith('.')) {
+      path = `${process.cwd()}${path.substring(1)}`;
+    }
+
+    return await fs.readFile(path);
+  } catch (error: any) {
+    logger.error(`Failed to read Markdown file ${path}: ${error.message}`);
+    throw error;
+  }
+}
+
+async function fetchTextFile(path: string): Promise<string> {
+  try {
+    const fs = await getFileSystem();
+
+    if (isNodeEnv && path.startsWith('.')) {
+      path = `${process.cwd()}${path.substring(1)}`;
+    }
+
+    return await fs.readFile(path);
+  } catch (error: any) {
+    logger.error(`Failed to read text file ${path}: ${error.message}`);
+    throw error;
   }
-  return fs.readFile(path);
 }
 
 registerDocFetcher('http', httpFetcher);

package/src/runtime/embeddings/chunker.ts

@@ -0,0 +1,50 @@
+export class TextChunker {
+  private chunkSize: number;
+  private chunkOverlap: number;
+  private separators: string[] = ['\n\n', '\n', '. ', ' ', ''];
+
+  constructor(chunkSize: number = 1000, chunkOverlap: number = 200) {
+    this.chunkSize = chunkSize;
+    this.chunkOverlap = chunkOverlap;
+  }
+
+  splitText(text: string): string[] {
+    if (text.length <= this.chunkSize) {
+      return [text];
+    }
+
+    const chunks: string[] = [];
+    let start = 0;
+
+    while (start < text.length) {
+      let end = Math.min(start + this.chunkSize, text.length);
+
+      if (end < text.length) {
+        end = this.findBestSplitPoint(text, start, end);
+      }
+
+      chunks.push(text.substring(start, end));
+      start = end - this.chunkOverlap;
+
+      if (start < 0) start = 0;
+      if (start >= text.length - this.chunkOverlap) {
+        if (start < text.length) {
+          chunks.push(text.substring(start));
+        }
+        break;
+      }
+    }
+
+    return chunks;
+  }
+
+  private findBestSplitPoint(text: string, start: number, end: number): number {
+    for (const sep of this.separators) {
+      const lastSep = text.lastIndexOf(sep, end);
+      if (lastSep > start) {
+        return Math.min(lastSep + sep.length, end);
+      }
+    }
+    return end;
+  }
+}

package/src/runtime/embeddings/index.ts

@@ -0,0 +1,5 @@
+export { EmbeddingProvider, EmbeddingProviderConfig } from './provider.js';
+export { EmbeddingService } from '../resolvers/sqldb/impl.js';
+export { TextChunker } from './chunker.js';
+export { embeddingProvider, getDefaultEmbeddingProvider } from './registry.js';
+export { OpenAIEmbeddingProvider, OpenAIEmbeddingConfig } from './openai.js';

package/src/runtime/embeddings/openai.ts

@@ -0,0 +1,49 @@
+import { OpenAIEmbeddings } from '@langchain/openai';
+import { EmbeddingProvider, EmbeddingProviderConfig } from './provider.js';
+import { getLocalEnv } from '../auth/defs.js';
+
+export interface OpenAIEmbeddingConfig extends EmbeddingProviderConfig {
+  model?: string;
+  dimensions?: number;
+  maxRetries?: number;
+}
+
+export class OpenAIEmbeddingProvider extends EmbeddingProvider {
+  private openaiConfig: OpenAIEmbeddingConfig;
+
+  constructor(config?: EmbeddingProviderConfig) {
+    super(config || {});
+    this.openaiConfig = (this.config as OpenAIEmbeddingConfig) || {};
+  }
+
+  protected createEmbeddings(): OpenAIEmbeddings {
+    const config: any = {
+      apiKey: this.resolveApiKey(),
+    };
+
+    if (this.openaiConfig.model) {
+      config.model = this.openaiConfig.model;
+    }
+
+    if (this.openaiConfig.dimensions) {
+      config.dimensions = this.openaiConfig.dimensions;
+    }
+
+    if (this.openaiConfig.maxRetries !== undefined) {
+      config.maxRetries = this.openaiConfig.maxRetries;
+    }
+
+    return new OpenAIEmbeddings(config);
+  }
+
+  protected resolveApiKey(): string {
+    if (this.openaiConfig.apiKey) {
+      return this.openaiConfig.apiKey;
+    }
+    return process.env.AGENTLANG_OPENAI_KEY || getLocalEnv('AGENTLANG_OPENAI_KEY') || '';
+  }
+
+  getProviderName(): string {
+    return 'openai';
+  }
+}

package/src/runtime/embeddings/provider.ts

@@ -0,0 +1,37 @@
+import { Embeddings } from '@langchain/core/embeddings';
+
+export interface EmbeddingProviderConfig {
+  chunkSize?: number;
+  chunkOverlap?: number;
+  apiKey?: string;
+  model?: string;
+  [key: string]: any;
+}
+
+export abstract class EmbeddingProvider {
+  protected config: EmbeddingProviderConfig;
+  protected embeddings: Embeddings;
+
+  constructor(config: EmbeddingProviderConfig = {}) {
+    this.config = config;
+    this.embeddings = this.createEmbeddings();
+  }
+
+  protected abstract createEmbeddings(): Embeddings;
+  protected abstract resolveApiKey(): string;
+
+  abstract getProviderName(): string;
+
+  async embedText(text: string): Promise<number[]> {
+    return await this.embeddings.embedQuery(text);
+  }
+
+  getConfig(): EmbeddingProviderConfig {
+    return { ...this.config };
+  }
+
+  updateConfig(newConfig: Partial<EmbeddingProviderConfig>): void {
+    this.config = { ...this.config, ...newConfig };
+    this.embeddings = this.createEmbeddings();
+  }
+}

package/src/runtime/embeddings/registry.ts

@@ -0,0 +1,17 @@
+import { OpenAIEmbeddingProvider } from './openai.js';
+
+const EmbeddingProviders = new Map().set('openai', OpenAIEmbeddingProvider);
+
+export function embeddingProvider(service: string): any {
+  const requestedService = service.toLowerCase();
+  const provider = EmbeddingProviders.get(requestedService);
+  if (provider) {
+    return provider;
+  } else {
+    throw new Error(`No embedding provider found for ${service}`);
+  }
+}
+
+export function getDefaultEmbeddingProvider(): string {
+  return 'openai';
+}

package/src/runtime/exec-graph.ts

@@ -468,15 +468,18 @@ export async function executeEventHelper(eventInstance: Instance, env?: Environm
     isLocalEnv = true;
   }
   let g: ExecGraph | undefined;
+  let escalatedRole: string | undefined;
   if (!isAgentEventInstance(eventInstance)) {
     g = await generateExecutionGraph(fqn);
     if (!g) {
       throw new Error(`Failed to generate graph for event ${fqn}`);
     }
+    escalatedRole = getWorkflowForEvent(fqn).getRoleEscalation();
   }
   const oldModuleName = env.switchActiveModuleName(eventInstance.moduleName);
   env.bind(eventInstance.name, eventInstance);
   env.bind(eventInstance.getFqName(), eventInstance);
+  if (escalatedRole) env.setEscalatedRole(escalatedRole);
   try {
     if (g) {
       await executeGraph(g, env);
@@ -498,6 +501,7 @@ export async function executeEventHelper(eventInstance: Instance, env?: Environm
     }
     throw err;
   } finally {
+    env.resetEscalatedRole();
     if (!isLocalEnv) env.switchActiveModuleName(oldModuleName);
   }
 }