agentlang 0.0.11 → 0.0.13

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

@@ -0,0 +1,166 @@
+import { ChatAnthropic } from '@langchain/anthropic';
+import { AgentServiceProvider, AIResponse, asAIResponse } from '../provider.js';
+import { BaseMessage } from '@langchain/core/messages';
+
+export interface AnthropicConfig {
+  model?: string;
+  temperature?: number;
+  maxTokens?: number;
+  maxRetries?: number;
+  apiKey?: string;
+  clientOptions?: {
+    defaultHeaders?: Record<string, string>;
+    [key: string]: any;
+  };
+  enablePromptCaching?: boolean;
+  cacheControl?: 'ephemeral';
+}
+
+export class AnthropicProvider implements AgentServiceProvider {
+  private model: ChatAnthropic;
+  private config: AnthropicConfig;
+
+  constructor(config?: Map<string, any>) {
+    this.config = this.parseConfig(config);
+
+    const chatConfig: any = {
+      model: this.config.model,
+      temperature: this.config.temperature,
+      maxTokens: this.config.maxTokens,
+      maxRetries: this.config.maxRetries,
+    };
+
+    if (this.config.apiKey) {
+      chatConfig.apiKey = this.config.apiKey;
+    }
+
+    if (this.config.clientOptions) {
+      chatConfig.clientOptions = this.config.clientOptions;
+    }
+
+    if (this.config.enablePromptCaching) {
+      chatConfig.clientOptions = {
+        ...chatConfig.clientOptions,
+        defaultHeaders: {
+          ...chatConfig.clientOptions?.defaultHeaders,
+          'anthropic-beta': 'prompt-caching-2024-07-31',
+        },
+      };
+    }
+
+    this.model = new ChatAnthropic(chatConfig);
+  }
+
+  private parseConfig(config?: Map<string, any>): AnthropicConfig {
+    const defaultConfig: AnthropicConfig = {
+      model: 'claude-sonnet-4-20250514',
+      temperature: 0.7,
+      maxTokens: 8192,
+      maxRetries: 2,
+      enablePromptCaching: false,
+      cacheControl: 'ephemeral',
+    };
+
+    if (!config) {
+      return {
+        ...defaultConfig,
+        apiKey: process.env.ANTHROPIC_API_KEY,
+      };
+    }
+
+    const apiKey = config.get('apiKey') || config.get('api_key') || process.env.ANTHROPIC_API_KEY;
+
+    return {
+      model: config.get('model') || defaultConfig.model,
+      temperature: config.get('temperature') ?? defaultConfig.temperature,
+      maxTokens: config.get('maxTokens') || config.get('max_tokens') || defaultConfig.maxTokens,
+      maxRetries: config.get('maxRetries') || config.get('max_retries') || defaultConfig.maxRetries,
+      enablePromptCaching:
+        config.get('enablePromptCaching') ||
+        config.get('enable_prompt_caching') ||
+        defaultConfig.enablePromptCaching,
+      cacheControl:
+        config.get('cacheControl') || config.get('cache_control') || defaultConfig.cacheControl,
+      apiKey,
+      clientOptions: config.get('clientOptions') || config.get('client_options'),
+    };
+  }
+
+  async invoke(messages: BaseMessage[]): Promise<AIResponse> {
+    if (!this.config.apiKey) {
+      throw new Error(
+        'Anthropic API key is required. Set ANTHROPIC_API_KEY environment variable or provide apiKey in config.'
+      );
+    }
+
+    let processedMessages = messages;
+
+    if (this.config.enablePromptCaching && messages.length > 0) {
+      processedMessages = this.applyCacheControl(messages);
+    }
+
+    return asAIResponse(await this.model.invoke(processedMessages));
+  }
+
+  private applyCacheControl(messages: BaseMessage[]): BaseMessage[] {
+    // Apply cache control to the last system message if present
+    // This follows Anthropic's recommendation to cache long context at the end of system messages
+    if (messages.length === 0) return messages;
+
+    const processedMessages = [...messages];
+
+    // Find the last system message and apply cache control
+    for (let i = processedMessages.length - 1; i >= 0; i--) {
+      const message = processedMessages[i];
+      if (message._getType() === 'system') {
+        // Apply cache control to system message content
+        const content = message.content;
+        if (typeof content === 'string' && content.length > 1000) {
+          // Only cache if content is substantial (>1000 chars as a heuristic)
+          (message as any).additional_kwargs = {
+            ...((message as any).additional_kwargs || {}),
+            cache_control: { type: 'ephemeral' },
+          };
+        }
+        break;
+      }
+    }
+
+    return processedMessages;
+  }
+
+  getConfig(): AnthropicConfig {
+    return { ...this.config };
+  }
+
+  updateConfig(newConfig: Partial<AnthropicConfig>): void {
+    this.config = { ...this.config, ...newConfig };
+
+    const chatConfig: any = {
+      model: this.config.model,
+      temperature: this.config.temperature,
+      maxTokens: this.config.maxTokens,
+      maxRetries: this.config.maxRetries,
+    };
+
+    if (this.config.apiKey) {
+      chatConfig.apiKey = this.config.apiKey;
+    }
+
+    if (this.config.clientOptions) {
+      chatConfig.clientOptions = this.config.clientOptions;
+    }
+
+    if (this.config.enablePromptCaching) {
+      chatConfig.clientOptions = {
+        ...chatConfig.clientOptions,
+        defaultHeaders: {
+          ...chatConfig.clientOptions?.defaultHeaders,
+          'anthropic-beta': 'prompt-caching-2024-07-31',
+        },
+      };
+    }
+
+    this.model = new ChatAnthropic(chatConfig);
+  }
+}

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

@@ -2,18 +2,138 @@ import { ChatOpenAI } from '@langchain/openai';
 import { AgentServiceProvider, AIResponse, asAIResponse } from '../provider.js';
 import { BaseMessage } from '@langchain/core/messages';
 
+export interface OpenAIConfig {
+  model?: string;
+  temperature?: number;
+  maxTokens?: number;
+  topP?: number;
+  frequencyPenalty?: number;
+  presencePenalty?: number;
+  maxRetries?: number;
+  apiKey?: string;
+  configuration?: {
+    baseURL?: string;
+    defaultHeaders?: Record<string, string>;
+    [key: string]: any;
+  };
+  streamUsage?: boolean;
+  logprobs?: boolean;
+  topLogprobs?: number;
+}
+
 export class OpenAIProvider implements AgentServiceProvider {
   private model: ChatOpenAI;
+  private config: OpenAIConfig;
 
   constructor(config?: Map<string, any>) {
-    let modelName = 'gpt-4.1-2025-04-14';
-    if (config) {
-      modelName = config.get('model') || modelName;
+    this.config = this.parseConfig(config);
+
+    const chatConfig: any = {
+      model: this.config.model,
+      temperature: this.config.temperature,
+      maxTokens: this.config.maxTokens,
+      topP: this.config.topP,
+      frequencyPenalty: this.config.frequencyPenalty,
+      presencePenalty: this.config.presencePenalty,
+      maxRetries: this.config.maxRetries,
+      streamUsage: this.config.streamUsage,
+      logprobs: this.config.logprobs,
+      topLogprobs: this.config.topLogprobs,
+    };
+
+    if (this.config.apiKey) {
+      chatConfig.apiKey = this.config.apiKey;
+    }
+
+    if (this.config.configuration) {
+      chatConfig.configuration = this.config.configuration;
     }
-    this.model = new ChatOpenAI({ model: modelName });
+
+    this.model = new ChatOpenAI(chatConfig);
+  }
+
+  private parseConfig(config?: Map<string, any>): OpenAIConfig {
+    const defaultConfig: OpenAIConfig = {
+      model: 'gpt-4o',
+      temperature: 0.7,
+      maxTokens: 4096,
+      topP: 1.0,
+      frequencyPenalty: 0,
+      presencePenalty: 0,
+      maxRetries: 2,
+      streamUsage: true,
+      logprobs: false,
+    };
+
+    if (!config) {
+      return {
+        ...defaultConfig,
+        apiKey: process.env.OPENAI_API_KEY,
+      };
+    }
+
+    const apiKey = config.get('apiKey') || config.get('api_key') || process.env.OPENAI_API_KEY;
+
+    return {
+      model: config.get('model') || defaultConfig.model,
+      temperature: config.get('temperature') ?? defaultConfig.temperature,
+      maxTokens: config.get('maxTokens') || config.get('max_tokens') || defaultConfig.maxTokens,
+      topP: config.get('topP') || config.get('top_p') || defaultConfig.topP,
+      frequencyPenalty:
+        config.get('frequencyPenalty') ||
+        config.get('frequency_penalty') ||
+        defaultConfig.frequencyPenalty,
+      presencePenalty:
+        config.get('presencePenalty') ||
+        config.get('presence_penalty') ||
+        defaultConfig.presencePenalty,
+      maxRetries: config.get('maxRetries') || config.get('max_retries') || defaultConfig.maxRetries,
+      streamUsage:
+        config.get('streamUsage') || config.get('stream_usage') || defaultConfig.streamUsage,
+      logprobs: config.get('logprobs') ?? defaultConfig.logprobs,
+      topLogprobs: config.get('topLogprobs') || config.get('top_logprobs'),
+      apiKey,
+      configuration: config.get('configuration'),
+    };
   }
 
   async invoke(messages: BaseMessage[]): 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.'
+      );
+    }
     return asAIResponse(await this.model.invoke(messages));
   }
+
+  getConfig(): OpenAIConfig {
+    return { ...this.config };
+  }
+
+  updateConfig(newConfig: Partial<OpenAIConfig>): void {
+    this.config = { ...this.config, ...newConfig };
+
+    const chatConfig: any = {
+      model: this.config.model,
+      temperature: this.config.temperature,
+      maxTokens: this.config.maxTokens,
+      topP: this.config.topP,
+      frequencyPenalty: this.config.frequencyPenalty,
+      presencePenalty: this.config.presencePenalty,
+      maxRetries: this.config.maxRetries,
+      streamUsage: this.config.streamUsage,
+      logprobs: this.config.logprobs,
+      topLogprobs: this.config.topLogprobs,
+    };
+
+    if (this.config.apiKey) {
+      chatConfig.apiKey = this.config.apiKey;
+    }
+
+    if (this.config.configuration) {
+      chatConfig.configuration = this.config.configuration;
+    }
+
+    this.model = new ChatOpenAI(chatConfig);
+  }
 }

package/src/runtime/agents/registry.ts

@@ -1,9 +1,56 @@
 import { OpenAIProvider } from './impl/openai.js';
+import { AnthropicProvider } from './impl/anthropic.js';
 
-const Providers = new Map().set('openai', OpenAIProvider);
+const Providers = new Map().set('openai', OpenAIProvider).set('anthropic', AnthropicProvider);
 
 export function provider(service: string) {
-  const p = Providers.get(service.toLowerCase());
-  if (p) return p;
-  else throw new Error(`No provider found for ${service}`);
+  const requestedService = service.toLowerCase();
+  let p = Providers.get(requestedService);
+
+  if (p) {
+    // Check if the requested provider has its API key available
+    if (isProviderAvailable(requestedService)) {
+      return p;
+    } else {
+      // Try to find an alternative available provider
+      const availableService = getAvailableProvider();
+      if (availableService && availableService !== requestedService) {
+        p = Providers.get(availableService);
+        if (p) return p;
+      }
+      throw new Error(
+        `${service} provider requested but ${service.toUpperCase()}_API_KEY not found. Available providers: ${getAvailableProviders().join(', ') || 'none'}`
+      );
+    }
+  } else {
+    throw new Error(`No provider found for ${service}`);
+  }
+}
+
+function isProviderAvailable(service: string): boolean {
+  switch (service) {
+    case 'openai':
+      return !!process.env.OPENAI_API_KEY;
+    case 'anthropic':
+      return !!process.env.ANTHROPIC_API_KEY;
+    default:
+      return false;
+  }
+}
+
+function getAvailableProvider(): string | null {
+  if (process.env.ANTHROPIC_API_KEY) {
+    return 'anthropic';
+  }
+  if (process.env.OPENAI_API_KEY) {
+    return 'openai';
+  }
+  return 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');
+  return available;
 }

package/src/runtime/interpreter.ts

@@ -408,15 +408,21 @@ export class Environment extends Instance {
     return this.activeTransactions;
   }
 
+  async resetActiveTransactions(commit: boolean): Promise<Environment> {
+    await this.endAllTransactions(commit);
+    this.activeTransactions = new Map<string, string>();
+    return this;
+  }
+
   async getTransactionForResolver(resolver: Resolver): Promise<string> {
     const n: string = resolver.getName();
-    let txnId: string | undefined = this.getActiveTransactions().get(n);
+    let txnId: string | undefined = this.activeTransactions.get(n);
     if (txnId) {
       return txnId;
     } else {
       txnId = await resolver.startTransaction();
       if (txnId) {
-        this.getActiveTransactions().set(n, txnId);
+        this.activeTransactions.set(n, txnId);
         return txnId;
       } else {
         throw new Error(`Failed to start transaction for ${n}`);
@@ -430,7 +436,7 @@ export class Environment extends Instance {
   }
 
   private async endAllTransactions(commit: boolean): Promise<void> {
-    const txns: Map<string, string> = this.getActiveTransactions();
+    const txns: Map<string, string> = this.activeTransactions;
     for (const n of txns.keys()) {
       const txnId: string | undefined = txns.get(n);
       if (txnId) {
@@ -952,6 +958,7 @@ async function evaluateCrudMap(crud: CrudMap, env: Environment): Promise<void> {
   const attrs = inst.attributes;
   const qattrs = inst.queryAttributes;
   const isQueryAll = crud.name.endsWith(QuerySuffix);
+  const distinct: boolean = crud.distinct.length > 0;
   if (attrs.size > 0) {
     await maybeValidateOneOfRefs(inst, env);
   }
@@ -964,7 +971,7 @@ async function evaluateCrudMap(crud: CrudMap, env: Environment): Promise<void> {
     if (qattrs == undefined && !isQueryAll) {
       throw new Error(`Pattern for ${entryName} with 'into' clause must be a query`);
     }
-    await evaluateJoinQuery(crud.into, inst, crud.relationships, env);
+    await evaluateJoinQuery(crud.into, inst, crud.relationships, distinct, env);
     return;
   }
   if (isEntityInstance(inst) || isBetweenRelationship(inst.name, inst.moduleName)) {
@@ -1051,7 +1058,7 @@ async function evaluateCrudMap(crud: CrudMap, env: Environment): Promise<void> {
           isReadForUpdate,
           env.isInDeleteMode()
         );
-        const insts: Instance[] = await res.queryInstances(inst, isQueryAll);
+        const insts: Instance[] = await res.queryInstances(inst, isQueryAll, distinct);
         env.setLastResult(insts);
       }
       if (crud.relationships != undefined) {
@@ -1184,6 +1191,7 @@ async function evaluateJoinQuery(
   intoSpec: SelectIntoSpec,
   inst: Instance,
   relationships: RelationshipPattern[],
+  distinct: boolean,
   env: Environment
 ): Promise<void> {
   const normIntoSpec = new Map<string, string>();
@@ -1196,7 +1204,7 @@ async function evaluateJoinQuery(
     joinsSpec = await walkJoinQueryPattern(relationships[i], joinsSpec, env);
   }
   const resolver = await getResolverForPath(inst.name, moduleName, env);
-  const result: Result = await resolver.queryByJoin(inst, joinsSpec, normIntoSpec);
+  const result: Result = await resolver.queryByJoin(inst, joinsSpec, normIntoSpec, distinct);
   env.setLastResult(result);
 }
 

package/src/runtime/jsmodules.ts

@@ -17,7 +17,7 @@ export async function importModule(path: string, name: string, moduleFileName?:
     }
     path = `${s}${sep}${path}`;
   }
-  if ((path.startsWith(sep) || path.startsWith('.')) && moduleFileName) {
+  if (!(path.startsWith(sep) || path.startsWith('.'))) {
     path = process.cwd() + sep + path;
   }
   const m = await import(/* @vite-ignore */ path);

package/src/runtime/resolvers/interface.ts

@@ -100,8 +100,12 @@ export class Resolver {
    * @param {Instance} inst - an Instance with query attributes
    * @param {boolean} queryAll - if this flag is set, fetch all instances
    */
-  public async queryInstances(inst: Instance, queryAll: boolean): Promise<any> {
-    return this.notImpl(`queryInstances(${inst}, ${queryAll})`);
+  public async queryInstances(
+    inst: Instance,
+    queryAll: boolean,
+    distinct: boolean = false
+  ): Promise<any> {
+    return this.notImpl(`queryInstances(${inst}, ${queryAll}, ${distinct})`);
   }
 
   /**
@@ -130,9 +134,10 @@ export class Resolver {
   public async queryByJoin(
     inst: Instance,
     joinsSpec: JoinInfo[],
-    intoSpec: Map<string, string>
+    intoSpec: Map<string, string>,
+    distinct: boolean = false
   ): Promise<any> {
-    return this.notImpl(`queryByJoin(${inst}, ${joinsSpec}, ${intoSpec})`);
+    return this.notImpl(`queryByJoin(${inst}, ${joinsSpec}, ${intoSpec}, ${distinct})`);
   }
 
   /**

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

@@ -185,7 +185,11 @@ function makeSqliteDataSource(
   });
 }
 
-export const DbType = 'sqlite';
+const DbType = 'sqlite';
+
+function getDbType(config?: DatabaseConfig): string {
+  return process.env.AL_DB_TYPE || config?.type || DbType;
+}
 
 function getDsFunction(
   config: DatabaseConfig | undefined
@@ -194,7 +198,7 @@ function getDsFunction(
   config: DatabaseConfig | undefined,
   synchronize?: boolean | undefined
 ) => DataSource {
-  switch (process.env.AL_DB_TYPE || config?.type || DbType) {
+  switch (getDbType(config)) {
     case 'sqlite':
       return makeSqliteDataSource;
     case 'postgres':
@@ -204,6 +208,10 @@ function getDsFunction(
   }
 }
 
+export function isUsingSqlite(): boolean {
+  return getDbType() == 'sqlite';
+}
+
 export async function initDatabase(config: DatabaseConfig | undefined) {
   if (defaultDataSource == undefined) {
     const mkds = getDsFunction(config);
@@ -602,8 +610,8 @@ function mkBetweenClause(tableName: string | undefined, k: string, queryVals: an
     const v1 = isstr ? `'${ov[0]}'` : ov[0];
     const v2 = isstr ? `'${ov[1]}'` : ov[1];
     const s = tableName
-      ? `${tableName}.${k} BETWEEN ${v1} AND ${v2}`
-      : `${k} BETWEEN ${v1} AND ${v2}`;
+      ? `"${tableName}"."${k}" BETWEEN ${v1} AND ${v2}`
+      : `"${k}" BETWEEN ${v1} AND ${v2}`;
     delete queryVals[k];
     return s;
   } else {
@@ -619,8 +627,8 @@ function objectToWhereClause(queryObj: object, queryVals: any, tableName?: strin
       op == 'between'
         ? mkBetweenClause(tableName, value[0], queryVals)
         : tableName
-          ? `${tableName}.${value[0]} ${op} :${value[0]}`
-          : `${value[0]} ${op} :${value[0]}`;
+          ? `"${tableName}"."${value[0]}" ${op} :${value[0]}`
+          : `"${value[0]}" ${op} :${value[0]}`;
     clauses.push(clause);
   });
   return clauses.join(' AND ');
@@ -637,7 +645,7 @@ function objectToRawWhereClause(queryObj: object, queryVals: any, tableName?: st
     } else {
       const ov: any = queryVals[k];
       const v = isString(ov) ? `'${ov}'` : ov;
-      clause = tableName ? `${tableName}.${k} ${op} ${v}` : `${k} ${op} ${v}`;
+      clause = tableName ? `"${tableName}"."${k}" ${op} ${v}` : `"${k}" ${op} ${v}`;
     }
     clauses.push(clause);
   });
@@ -652,6 +660,7 @@ export async function getMany(
   tableName: string,
   queryObj: object | undefined,
   queryVals: object | undefined,
+  distinct: boolean,
   ctx: DbContext
 ): Promise<any> {
   const alias: string = tableName.toLowerCase();
@@ -697,6 +706,9 @@ export async function getMany(
   if (ownersJoinCond) {
     qb.innerJoin(ot, otAlias, ownersJoinCond.join(' AND '));
   }
+  if (distinct) {
+    qb.distinct(true);
+  }
   qb.where(queryStr, queryVals);
   return await qb.getMany();
 }
@@ -707,6 +719,7 @@ export async function getManyByJoin(
   queryVals: object | undefined,
   joinClauses: JoinClause[],
   intoSpec: Map<string, string>,
+  distinct: boolean,
   ctx: DbContext
 ): Promise<any> {
   const alias: string = tableName.toLowerCase();
@@ -746,7 +759,7 @@ export async function getManyByJoin(
       }
     }
   });
-  const sql = `SELECT ${intoSpecToSql(intoSpec)} FROM ${tableName} ${joinSql.join('\n')} WHERE ${queryStr}`;
+  const sql = `SELECT ${distinct ? 'DISTINCT' : ''} ${intoSpecToSql(intoSpec)} FROM ${tableName} ${joinSql.join('\n')} WHERE ${queryStr}`;
   logger.debug(`Join Query: ${sql}`);
   const qb = getDatasourceForTransaction(ctx.txnId).getRepository(tableName).manager;
   return await qb.query(sql);

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

@@ -30,8 +30,15 @@ export type TableSchema = {
   columns: TableSpec;
 };
 
-export function asTableName(moduleName: string, entityName: string): string {
-  return `${moduleName}_${entityName}`.toLowerCase();
+export function asTableReference(moduleName: string, ref: string): string {
+  if (ref.indexOf('.') > 0) {
+    const parts = ref.split('.')
+    const r = `${moduleName}_${parts[0]}`.toLowerCase()
+    const colref = parts.slice(1).join('.')
+    return `"${r}"."${colref}"`;
+  } else {
+    return `${moduleName}_${ref}`.toLowerCase()
+  }
 }
 
 export function modulesAsDbSchema(): TableSchema[] {
@@ -46,7 +53,7 @@ export function modulesAsDbSchema(): TableSchema[] {
     const allEntries: Record[] = entities.concat(betRels) as Record[];
     allEntries.forEach((ent: Record) => {
       const tspec: TableSchema = {
-        name: asTableName(n, ent.name),
+        name: asTableReference(n, ent.name),
         columns: entitySchemaToTable(ent.schema),
       };
       result.push(tspec);
@@ -85,7 +92,7 @@ function ormSchemaFromRecordSchema(moduleName: string, entry: Record, hasOwnPk?:
   const entityName = entry.name
   const scm: RecordSchema = entry.schema
   const result = new EntitySchemaOptions<any>()
-  result.tableName = asTableName(moduleName, entityName)
+  result.tableName = asTableReference(moduleName, entityName)
   result.name = result.tableName
   const cols = new Map<string, any>()
   const indices = new Array<any>()