agentlang 0.4.3 → 0.4.5

package/src/language/parser.ts

@@ -399,3 +399,15 @@ export function introspectIf(ifpat: If): IfPattern {
 function introspectDelete(deletePat: Delete): DeletePattern {
   return new DeletePattern(introspectPattern(deletePat.pattern));
 }
+
+export type CasePattern = {
+  condition: BasePattern;
+  body: BasePattern;
+};
+
+export async function introspectCase(caseStr: string): Promise<CasePattern> {
+  const s = `if ${caseStr.trim().substring(4).trimStart()}`;
+  const pat = await introspect(s);
+  const ifPat = pat[0] as IfPattern;
+  return { condition: ifPat.condition, body: ifPat.body[0] };
+}

package/src/runtime/loader.ts

@@ -44,6 +44,9 @@ import {
   isPublicEventDefinition,
   AgentXtraAttribute,
   If,
+  isRetryDefinition,
+  RetryDefinition,
+  SetAttribute,
 } from '../language/generated/ast.js';
 import {
   addEntity,
@@ -64,6 +67,7 @@ import {
   newInstanceAttributes,
   addAgent,
   fetchModule,
+  Retry,
 } from './module.js';
 import {
   asStringLiteralsMap,
@@ -915,6 +919,67 @@ function addGlossaryEntryDefintion(def: GlossaryEntryDefinition, moduleName: str
   }
 }
 
+function addRetryDefinition(def: RetryDefinition, moduleName: string) {
+  const retry = new Retry(def.name, moduleName, def.attempts !== undefined ? def.attempts : 0);
+  if (def.backoff) {
+    def.backoff.attributes.forEach((attr: SetAttribute) => {
+      if (isLiteral(attr.value)) {
+        switch (attr.name) {
+          case 'strategy':
+            switch (attr.value.id || attr.value.str) {
+              case 'exponential':
+                retry.setExponentialBackoff();
+                break;
+              case 'linear':
+                retry.setLinearBackoff();
+                break;
+              case 'constant':
+                retry.setConstantBackoff();
+                break;
+              default:
+                throw new Error(`Invalid backoff strategy ${attr.value} specified for ${def.name}`);
+            }
+            break;
+          case 'delay':
+            if (attr.value.num) {
+              retry.setBackoffDelay(attr.value.num);
+            } else {
+              throw new Error(`Backoff delay must be a numeric value for ${def.name}`);
+            }
+            break;
+          case 'magnitude':
+            switch (attr.value.id || attr.value.str) {
+              case 'milliseconds':
+                retry.setBackoffMagnitudeAsMilliseconds();
+                break;
+              case 'seconds':
+                retry.setBackoffMagnitudeAsSeconds();
+                break;
+              case 'minutes':
+                retry.setBackoffMagnitudeAsMinutes();
+                break;
+              default:
+                throw new Error(`Invalid backoff magnitude ${attr.value} set for ${def.name}`);
+            }
+            break;
+          case 'factor':
+            if (attr.value.num) {
+              retry.setBackoffFactor(attr.value.num);
+            } else {
+              throw new Error(`Backoff factor must be a number for ${def.name}`);
+            }
+            break;
+          default:
+            throw new Error(`Invalid backoff option ${attr.name} specified for ${def.name}`);
+        }
+      } else {
+        throw new Error(`strategy must be a string in ${def.name}`);
+      }
+    });
+  }
+  fetchModule(moduleName).addRetry(retry);
+}
+
 function addResolverDefinition(def: ResolverDefinition, moduleName: string) {
   const resolverName = `${moduleName}/${def.name}`;
   const paths = def.paths;
@@ -981,6 +1046,7 @@ export async function addFromDef(def: Definition, moduleName: string) {
   else if (isScenarioDefinition(def)) addScenarioDefintion(def, moduleName);
   else if (isDirectiveDefinition(def)) addDirectiveDefintion(def, moduleName);
   else if (isGlossaryEntryDefinition(def)) addGlossaryEntryDefintion(def, moduleName);
+  else if (isRetryDefinition(def)) addRetryDefinition(def, moduleName);
 }
 
 export async function parseAndIntern(code: string, moduleName?: string) {

package/src/runtime/module.ts

@@ -1689,6 +1689,178 @@ export function flowGraphNext(
   return undefined;
 }
 
+type BackoffStrategy = 'e' | 'l' | 'c'; // exponential, linear, constant
+type BackoffMagnitude = 'ms' | 's' | 'm'; // milliseconds, seconds, minutes
+
+export type RetryBackoff = {
+  strategy: BackoffStrategy | undefined;
+  delay: number | undefined;
+  magnitude: BackoffMagnitude | undefined;
+  factor: number | undefined;
+};
+
+export class Retry extends ModuleEntry {
+  attempts: number;
+  private backoff: RetryBackoff;
+
+  constructor(name: string, moduleName: string, attempts: number) {
+    super(name, moduleName);
+    this.attempts = attempts <= 0 ? 0 : attempts;
+    this.backoff = {
+      strategy: undefined,
+      delay: undefined,
+      magnitude: undefined,
+      factor: undefined,
+    };
+  }
+
+  setExponentialBackoff(): Retry {
+    this.backoff.strategy = 'e';
+    return this;
+  }
+
+  isExponentialBackoff(): boolean {
+    return this.backoff.strategy === 'e';
+  }
+
+  setLinearBackoff(): Retry {
+    this.backoff.strategy = 'l';
+    return this;
+  }
+
+  isLinearBackoff(): boolean {
+    return this.backoff.strategy === 'l';
+  }
+
+  setConstantBackoff(): Retry {
+    this.backoff.strategy = 'c';
+    return this;
+  }
+
+  isConstantBackoff(): boolean {
+    return this.backoff.strategy === undefined || this.backoff.strategy === 'c';
+  }
+
+  setBackoffDelay(n: number): Retry {
+    if (n > 0) {
+      this.backoff.delay = n;
+    }
+    return this;
+  }
+
+  setBackoffMagnitudeAsMilliseconds(): Retry {
+    this.backoff.magnitude = 'ms';
+    return this;
+  }
+
+  backoffMagnitudeIsMilliseconds(): boolean {
+    return this.backoff.magnitude === 'ms';
+  }
+
+  setBackoffMagnitudeAsSeconds(): Retry {
+    this.backoff.magnitude = 's';
+    return this;
+  }
+
+  backoffMagnitudeIsSeconds(): boolean {
+    return this.backoff.magnitude === 's';
+  }
+
+  setBackoffMagnitudeAsMinutes(): Retry {
+    this.backoff.magnitude = 'm';
+    return this;
+  }
+
+  backoffMagnitudeIsMinutes(): boolean {
+    return this.backoff.magnitude === 'm';
+  }
+
+  setBackoffFactor(n: number): Retry {
+    if (n !== 0) this.backoff.factor = n;
+    return this;
+  }
+
+  getNextDelayMs(attempt: number): number {
+    if (attempt >= this.attempts) {
+      return 0;
+    }
+    const delay = this.backoff.delay === undefined ? 2 : this.backoff.delay;
+    if (attempt <= 0 || this.isConstantBackoff()) {
+      return this.normalizeDelay(delay);
+    }
+    let d = delay;
+    let i = 0;
+    const factor = this.backoff.factor === undefined ? 1 : this.backoff.factor;
+    if (this.isExponentialBackoff()) {
+      while (i < attempt) {
+        d *= factor;
+        ++i;
+      }
+    } else {
+      while (i < attempt) {
+        d += factor;
+        ++i;
+      }
+    }
+    return this.normalizeDelay(d);
+  }
+
+  private normalizeDelay(d: number): number {
+    if (this.backoffMagnitudeIsMilliseconds()) return d;
+    else if (this.backoffMagnitudeIsSeconds()) return d * 1000;
+    else return d * 60 * 1000;
+  }
+
+  private backoffToString(): string | undefined {
+    const strat = this.backoff.strategy;
+    const delay = this.backoff.delay;
+    const mag = this.backoff.magnitude;
+    const fact = this.backoff.factor;
+    if (strat === undefined && delay === undefined && mag === undefined && fact === undefined) {
+      return undefined;
+    }
+    const ss = new Array<string>();
+    if (strat !== undefined) {
+      let s = 'constant';
+      if (this.isExponentialBackoff()) {
+        s = 'exponential';
+      } else if (this.isLinearBackoff()) {
+        s = 'linear';
+      }
+      ss.push(`strategy ${s}`);
+    }
+    if (delay !== undefined) {
+      ss.push(`delay ${delay}`);
+    }
+    if (mag !== undefined) {
+      let s = 'milliseconds';
+      if (this.backoffMagnitudeIsSeconds()) {
+        s = 'seconds';
+      } else if (this.backoffMagnitudeIsMinutes()) {
+        s = 'minutes';
+      }
+      ss.push(`magnitude ${s}`);
+    }
+    if (fact !== undefined) {
+      ss.push(`factor ${fact}`);
+    }
+    return `backoff {
+       ${ss.join(',\n       ')}
+    }`;
+  }
+
+  override toString(): string {
+    const s = `agentlang/retry ${this.name} {
+    attempts ${this.attempts}`;
+    const b = this.backoffToString();
+    if (b) {
+      return `${s},\n    ${b}\n}`;
+    } else {
+      return `${s}\n}`;
+    }
+  }
+}
+
 export class Decision extends ModuleEntry {
   cases: string[];
 
@@ -1959,6 +2131,21 @@ export class Module {
     return this;
   }
 
+  addRetry(retry: Retry): Module {
+    this.addEntry(retry);
+    return this;
+  }
+
+  getRetry(name: string): Retry | undefined {
+    if (this.hasEntry(name)) {
+      const e = this.getEntry(name);
+      if (e instanceof Retry) {
+        return e as Retry;
+      }
+    }
+    return undefined;
+  }
+
   addStandaloneStatement(stmt: Statement): StandaloneStatement {
     const s = new StandaloneStatement(stmt, this.name);
     this.addEntry(s);

package/src/runtime/modules/ai.ts

@@ -1,4 +1,13 @@
-import { isFqName, makeCoreModuleName, makeFqName, nameToPath, splitFqName } from '../util.js';
+import {
+  escapeSpecialChars,
+  isFqName,
+  isString,
+  makeCoreModuleName,
+  makeFqName,
+  nameToPath,
+  sleepMilliseconds,
+  splitFqName,
+} from '../util.js';
 import {
   Environment,
   GlobalEnvironment,
@@ -16,6 +25,7 @@ import {
   makeInstance,
   newInstanceAttributes,
   Record,
+  Retry,
 } from '../module.js';
 import { provider } from '../agents/registry.js';
 import {
@@ -68,6 +78,8 @@ entity ${AgentEntityName} {
     channels String @optional, // comma-separated list of channel names
     role String @optional,
     flows String @optional,
+    validate String @optional,
+    retry String @optional,
     llm String
 }
 
@@ -113,11 +125,14 @@ export class AgentInstance {
   runWorkflows: boolean = true;
   role: string | undefined;
   flows: string | undefined;
+  validate: string | undefined;
+  retry: string | undefined;
   private toolsArray: string[] | undefined = undefined;
   private hasModuleTools = false;
   private withSession = true;
   private fqName: string | undefined;
   private decisionExecutor = false;
+  private retryObj: Retry | undefined;
 
   private constructor() {}
 
@@ -150,6 +165,15 @@ export class AgentInstance {
         if (agent.hasModuleTools) break;
       }
     }
+    if (agent.retry) {
+      let n = agent.retry;
+      if (!isFqName(n)) {
+        n = `${agent.moduleName}/${n}`;
+      }
+      const parts = splitFqName(n);
+      const m = fetchModule(parts[0]);
+      agent.retryObj = m.getRetry(parts[1]);
+    }
     return agent;
   }
 
@@ -404,7 +428,11 @@ Only return a pure JSON object with no extra text, annotations etc.`;
             })
             .join('\n')}`
         );
-        const response: AIResponse = await p.invoke(msgs, externalToolSpecs);
+        let response: AIResponse = await p.invoke(msgs, externalToolSpecs);
+        const v = this.getValidationEvent();
+        if (v) {
+          response = await this.handleValidation(response, v, msgs, p);
+        }
         msgs.push(assistantMessage(response.content));
         if (isplnr) {
           msgs[0] = sysMsg;
@@ -422,6 +450,73 @@ Only return a pure JSON object with no extra text, annotations etc.`;
     }
   }
 
+  private async invokeValidator(
+    response: AIResponse,
+    validationEventName: string
+  ): Promise<Instance> {
+    let isstr = false;
+    try {
+      const c = JSON.parse(response.content);
+      isstr = isString(c);
+    } catch (reason: any) {
+      logger.debug(`invokeValidator json/parse - ${reason}`);
+    }
+    const d = isstr ? `"${escapeSpecialChars(response.content)}"` : response.content;
+    const r: Instance = await parseAndEvaluateStatement(`{${validationEventName} {data ${d}}}`);
+    return r;
+  }
+
+  private async handleValidation(
+    response: AIResponse,
+    validationEventName: string,
+    msgs: BaseMessage[],
+    provider: AgentServiceProvider
+  ): Promise<AIResponse> {
+    let r: Instance = await this.invokeValidator(response, validationEventName);
+    const status = r.lookup('status');
+    if (status === 'ok') {
+      return response;
+    } else {
+      if (this.retryObj) {
+        let resp = response;
+        let attempt = 0;
+        let delay = this.retryObj.getNextDelayMs(attempt);
+        while (delay) {
+          msgs.push(assistantMessage(resp.content));
+          const vs = JSON.stringify(r.asSerializableObject());
+          msgs.push(
+            humanMessage(
+              `Validation for your last response failed with this result: \n${vs}\n\nFix the errors.`
+            )
+          );
+          await sleepMilliseconds(delay);
+          resp = await provider.invoke(msgs, undefined);
+          r = await this.invokeValidator(resp, validationEventName);
+          if (r.lookup('status') === 'ok') {
+            return resp;
+          }
+          delay = this.retryObj.getNextDelayMs(++attempt);
+        }
+        throw new Error(
+          `Agent ${this.name} failed to generate a valid response after ${attempt} attempts`
+        );
+      } else {
+        return response;
+      }
+    }
+  }
+
+  private getValidationEvent(): string | undefined {
+    if (this.validate) {
+      if (isFqName(this.validate)) {
+        return this.validate;
+      } else {
+        return `${this.moduleName}/${this.validate}`;
+      }
+    }
+    return undefined;
+  }
+
   private getExternalToolSpecs(): any[] | undefined {
     let result: any[] | undefined = undefined;
     if (this.toolsArray) {

package/src/runtime/modules/core.ts

@@ -54,7 +54,7 @@ resolver suspensionResolver ["${DefaultModuleName}/activeSuspension"] {
 }
 
 workflow createSuspension {
-  {suspension 
+  {suspension
     {id createSuspension.id
      continuation createSuspension.continuation,
      env createSuspension.env,
@@ -64,6 +64,15 @@ workflow createSuspension {
 @public workflow restartSuspension {
   await Core.restartSuspension(restartSuspension.id, restartSuspension.data)
 }
+
+record ValidationRequest {
+    data Any
+}
+
+record ValidationResult {
+    status @enum("ok", "error"),
+    reason String @optional
+}
 `;
 
 export const CoreModules: string[] = [];

package/src/runtime/util.ts

@@ -230,12 +230,10 @@ export function makeCoreModuleName(n: string): string {
 const InitFunctions: Function[] = [];
 
 export function registerInitFunction(f: Function) {
-
   InitFunctions.push(f);
 }
 
 export async function runInitFunctions() {
-  console.log('Running init functions', InitFunctions.length, InitFunctions);
   for (let i = 0; i < InitFunctions.length; ++i) {
     await InitFunctions[i]();
   }

package/src/syntaxes/agentlang.monarch.ts

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

package/out/runtime/modules/files.d.ts

@@ -1,18 +0,0 @@
-import { Result, Environment } from '../interpreter.js';
-import { ActiveSessionInfo } from '../auth/defs.js';
-export declare const CoreFilesModuleName: string;
-declare const _default: string;
-export default _default;
-export declare function createFileRecord(fileInfo: {
-    filename: string;
-    originalName: string;
-    mimetype: string;
-    size: number;
-    path: string;
-    uploadedBy?: string;
-}, sessionInfo?: ActiveSessionInfo, callback?: (result: Result) => void, env?: Environment): Promise<Result>;
-export declare function findFileByFilename(filename: string, sessionInfo?: ActiveSessionInfo, callback?: (result: Result) => void, env?: Environment): Promise<Result>;
-export declare function deleteFileRecord(filename: string, sessionInfo?: ActiveSessionInfo, callback?: (result: Result) => void, env?: Environment): Promise<Result>;
-export declare function listAllFiles(sessionInfo?: ActiveSessionInfo, callback?: (result: Result) => void, env?: Environment): Promise<Result>;
-export declare function listUserFiles(userId: string, sessionInfo?: ActiveSessionInfo, callback?: (result: Result) => void, env?: Environment): Promise<Result>;
-//# sourceMappingURL=files.d.ts.map

package/out/runtime/modules/files.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"files.d.ts","sourceRoot":"","sources":["../../../src/runtime/modules/files.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,WAAW,EAAY,MAAM,mBAAmB,CAAC;AAIlE,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAEpD,eAAO,MAAM,mBAAmB,QAA8B,CAAC;;AAE/D,wBA2DE;AAEF,wBAAsB,gBAAgB,CACpC,QAAQ,EAAE;IACR,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,EACD,WAAW,CAAC,EAAE,iBAAiB,EAC/B,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,EACnC,GAAG,CAAC,EAAE,WAAW,GAChB,OAAO,CAAC,MAAM,CAAC,CAqBjB;AAED,wBAAsB,kBAAkB,CACtC,QAAQ,EAAE,MAAM,EAChB,WAAW,CAAC,EAAE,iBAAiB,EAC/B,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,EACnC,GAAG,CAAC,EAAE,WAAW,GAChB,OAAO,CAAC,MAAM,CAAC,CAcjB;AAED,wBAAsB,gBAAgB,CACpC,QAAQ,EAAE,MAAM,EAChB,WAAW,CAAC,EAAE,iBAAiB,EAC/B,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,EACnC,GAAG,CAAC,EAAE,WAAW,GAChB,OAAO,CAAC,MAAM,CAAC,CAcjB;AAED,wBAAsB,YAAY,CAChC,WAAW,CAAC,EAAE,iBAAiB,EAC/B,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,EACnC,GAAG,CAAC,EAAE,WAAW,GAChB,OAAO,CAAC,MAAM,CAAC,CAYjB;AAED,wBAAsB,aAAa,CACjC,MAAM,EAAE,MAAM,EACd,WAAW,CAAC,EAAE,iBAAiB,EAC/B,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,EACnC,GAAG,CAAC,EAAE,WAAW,GAChB,OAAO,CAAC,MAAM,CAAC,CAcjB"}

package/out/runtime/modules/files.js

@@ -1,116 +0,0 @@
-import { evaluate } from '../interpreter.js';
-import { makeCoreModuleName } from '../util.js';
-import { makeInstance, objectAsInstanceAttributes } from '../module.js';
-import crypto from 'crypto';
-export const CoreFilesModuleName = makeCoreModuleName('files');
-export default `module ${CoreFilesModuleName}
-
-entity File {
-    id String @id,
-    filename String @unique @indexed,
-    originalName String @optional,
-    mimetype String @default("application/octet-stream"),
-    size Int @optional,
-    uploadedBy String @optional,
-    uploadedAt DateTime @default(now()),
-    path String @optional,
-    @rbac [(roles: [*], allow: [create])
-           (allow: [read, delete], where: auth.user = this.uploadedBy)]
-}
-
-workflow CreateFile {
-  {File {id CreateFile.id,
-         filename CreateFile.filename,
-         originalName CreateFile.originalName,
-         mimetype CreateFile.mimetype,
-         size CreateFile.size,
-         uploadedBy CreateFile.uploadedBy,
-         uploadedAt CreateFile.uploadedAt,
-         path CreateFile.path},
-  @upsert}
-}
-
-workflow FindFile {
-  {File {id? FindFile.id}} @as [file];
-  file
-}
-
-workflow FindFileByFilename {
-  {File {filename? FindFileByFilename.filename}} @as [file];
-  file
-}
-
-workflow ListFiles {
-  {File? {}}
-}
-
-workflow ListUserFiles {
-  {File {uploadedBy? ListUserFiles.userId}}
-}
-
-workflow DeleteFile {
-  delete {File {id? DeleteFile.id}}
-}
-
-workflow DeleteFileByFilename {
-  delete {File {filename? DeleteFileByFilename.filename}}
-}
-
-workflow UpdateFile {
-  {File {id? UpdateFile.id,
-         originalName UpdateFile.originalName,
-         mimetype UpdateFile.mimetype,
-         size UpdateFile.size}}
-}
-`;
-export async function createFileRecord(fileInfo, sessionInfo, callback, env) {
-    let inst = makeInstance(CoreFilesModuleName, 'CreateFile', objectAsInstanceAttributes({
-        id: crypto.randomUUID(),
-        filename: fileInfo.filename,
-        originalName: fileInfo.originalName,
-        mimetype: fileInfo.mimetype,
-        size: fileInfo.size,
-        path: fileInfo.path,
-        uploadedBy: fileInfo.uploadedBy || '',
-        uploadedAt: new Date().toISOString(),
-    }));
-    if (sessionInfo) {
-        inst = inst.setAuthContext(sessionInfo);
-    }
-    return await evaluate(inst, callback, env);
-}
-export async function findFileByFilename(filename, sessionInfo, callback, env) {
-    let inst = makeInstance(CoreFilesModuleName, 'FindFileByFilename', objectAsInstanceAttributes({
-        filename: filename,
-    }));
-    if (sessionInfo) {
-        inst = inst.setAuthContext(sessionInfo);
-    }
-    return await evaluate(inst, callback, env);
-}
-export async function deleteFileRecord(filename, sessionInfo, callback, env) {
-    let inst = makeInstance(CoreFilesModuleName, 'DeleteFileByFilename', objectAsInstanceAttributes({
-        filename: filename,
-    }));
-    if (sessionInfo) {
-        inst = inst.setAuthContext(sessionInfo);
-    }
-    return await evaluate(inst, callback, env);
-}
-export async function listAllFiles(sessionInfo, callback, env) {
-    let inst = makeInstance(CoreFilesModuleName, 'ListFiles', objectAsInstanceAttributes({}));
-    if (sessionInfo) {
-        inst = inst.setAuthContext(sessionInfo);
-    }
-    return await evaluate(inst, callback, env);
-}
-export async function listUserFiles(userId, sessionInfo, callback, env) {
-    let inst = makeInstance(CoreFilesModuleName, 'ListUserFiles', objectAsInstanceAttributes({
-        userId: userId,
-    }));
-    if (sessionInfo) {
-        inst = inst.setAuthContext(sessionInfo);
-    }
-    return await evaluate(inst, callback, env);
-}
-//# sourceMappingURL=files.js.map

package/out/runtime/modules/files.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"files.js","sourceRoot":"","sources":["../../../src/runtime/modules/files.ts"],"names":[],"mappings":"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"}