@looopy-ai/core 2.1.22 → 2.1.24

package/dist/observability/tracing.d.ts

@@ -8,7 +8,7 @@ export interface TraceContext {
 export interface TelemetryConfig {
     serviceName?: string;
     serviceVersion?: string;
-    environment?: string;
+    stage?: string;
     otlpEndpoint?: string;
     enabled?: boolean;
 }

package/dist/observability/tracing.js

@@ -76,16 +76,16 @@ export function initializeTracing(config) {
     }
     const serviceName = config?.serviceName || 'looopy';
     const serviceVersion = config?.serviceVersion || '1.0.0';
-    const environment = config?.environment || process.env.NODE_ENV || 'development';
+    const stage = config?.stage || process.env.STAGE || 'dev';
     DEFAULT_LOGGER.trace({
         serviceName,
         serviceVersion,
-        environment,
+        stage,
     }, 'Initializing OpenTelemetry tracing');
     const resource = resourceFromAttributes({
         [ATTR_SERVICE_NAME]: serviceName,
         [ATTR_SERVICE_VERSION]: serviceVersion,
-        'deployment.environment': environment,
+        'deployment.environment': stage,
     });
     const otlpEndpoint = config?.otlpEndpoint ||
         process.env.OTEL_EXPORTER_OTLP_ENDPOINT ||

package/dist/plugins/agent-academy.d.ts

@@ -1,9 +1,9 @@
-import type { Skill } from '../types';
+import type { MaterializedSkill, Skill } from '../types';
 import type { IterationContext, Plugin, SystemPrompt } from '../types/core';
 export declare const learnSkillToolName = "learn_skill";
 export declare const getInstruction: (instruction: string | (() => Promise<string>)) => Promise<string>;
 export declare const skill: (definition: Skill) => Skill;
 export type AgentAcademyOptions<AuthContext> = {
-    learnSkillPrompt?: (skills: Skill[], context: IterationContext<AuthContext>) => Promise<string | SystemPrompt>;
+    learnSkillPrompt?: (skills: MaterializedSkill[], context: IterationContext<AuthContext>) => Promise<string | SystemPrompt>;
 };
 export declare function agentAcademy<AuthContext>(skills: Skill[], options?: AgentAcademyOptions<AuthContext>): Plugin<AuthContext>;

package/dist/plugins/agent-academy.js

@@ -12,13 +12,6 @@ export const skill = (definition) => {
     return { ...definition };
 };
 export function agentAcademy(skills, options) {
-    const skillMap = new Map();
-    for (const skill of skills) {
-        if (skillMap.has(skill.name)) {
-            throw new Error(`Duplicate skill name: ${skill.name}`);
-        }
-        skillMap.set(skill.name, skill);
-    }
     const learnSkillToolDefinition = {
         id: learnSkillToolName,
         description: 'Learns a new skill from the available agent academy.',
@@ -35,13 +28,18 @@ export function agentAcademy(skills, options) {
         },
     };
     const learnSkillPromptFn = options?.learnSkillPrompt ?? defaultPrompt;
+    const materializedSkillsPromises = skills.map(async (s) => ({
+        ...s,
+        instruction: await getInstruction(s.instruction),
+    }));
+    const materializedSkills = Promise.all(materializedSkillsPromises);
     return {
         name: 'agent-academy',
         generateSystemPrompts: async (context) => {
             if (!learnSkillPromptFn) {
                 return [];
             }
-            const prompt = await learnSkillPromptFn(skills, context);
+            const prompt = await learnSkillPromptFn(await materializedSkills, context);
             if (typeof prompt === 'string') {
                 return [
                     {
@@ -82,6 +80,7 @@ export function agentAcademy(skills, options) {
                     name: z.string().describe('The name of the skill to learn.'),
                 });
                 const validatedParams = schema.parse(toolCall.function.arguments);
+                const skillMap = buildMaterializedSkillMap(await materializedSkills);
                 const foundSkill = skillMap.get(validatedParams.name);
                 if (!foundSkill) {
                     const availableSkills = Array.from(skillMap.values())
@@ -129,9 +128,14 @@ export function agentAcademy(skills, options) {
         }).pipe(mergeMap((result) => toolResultToEvents(result)), catchError((error) => of(toolErrorEvent(toolCall, error instanceof Error ? error.message : String(error))))),
     };
 }
+const buildMaterializedSkillMap = (skills) => {
+    const map = new Map();
+    skills.forEach((skill) => {
+        map.set(skill.name, skill);
+    });
+    return map;
+};
 const defaultPrompt = (skills) => {
-    const skillList = skills
-        .map((skill) => `- **${skill.name}**: ${typeof skill.instruction === 'string' ? skill.instruction : 'A useful skill.'}`)
-        .join('\n');
+    const skillList = skills.map((skill) => `- **${skill.name}**: ${skill.instruction}`).join('\n');
     return `You can learn new skills using the learn_skill tool. The available skills are:\n\n${skillList}\n\nTo learn a skill, call the learn_skill tool with the name of the skill you want to learn.`;
 };

package/dist/types/skills.d.ts

@@ -3,6 +3,11 @@ export interface Skill {
     description: string;
     instruction: string | (() => Promise<string>);
 }
+export interface MaterializedSkill {
+    name: string;
+    description: string;
+    instruction: string;
+}
 export interface SkillRegistration {
     [key: string]: Skill;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@looopy-ai/core",
-  "version": "2.1.22",
+  "version": "2.1.24",
   "description": "RxJS-based AI agent framework",
   "repository": {
     "url": "https://github.com/looopy-ai/lib"