opc-agent 1.1.1 → 1.1.2

package/tests/i18n.test.ts

@@ -1,41 +1,41 @@
-import { describe, it, expect } from 'vitest';
-import { t, setLocale, getLocale, detectLocale, addMessages } from '../src/i18n';
-
-describe('i18n', () => {
-  it('should return English messages by default', () => {
-    setLocale('en');
-    expect(t('agent.greeting')).toBe('Hello! How can I help you?');
-  });
-
-  it('should return Chinese messages', () => {
-    setLocale('zh-CN');
-    expect(t('agent.greeting')).toBe('你好！有什么可以帮你的？');
-    setLocale('en'); // reset
-  });
-
-  it('should interpolate params', () => {
-    setLocale('en');
-    expect(t('agent.started', { name: 'TestBot' })).toBe('Agent "TestBot" started successfully');
-  });
-
-  it('should fall back to key if not found', () => {
-    expect(t('nonexistent.key')).toBe('nonexistent.key');
-  });
-
-  it('should get and set locale', () => {
-    setLocale('zh-CN');
-    expect(getLocale()).toBe('zh-CN');
-    setLocale('en');
-    expect(getLocale()).toBe('en');
-  });
-
-  it('should add custom messages', () => {
-    addMessages('en', { 'custom.key': 'Custom value' });
-    expect(t('custom.key')).toBe('Custom value');
-  });
-
-  it('should detect locale from environment', () => {
-    const locale = detectLocale();
-    expect(['en', 'zh-CN']).toContain(locale);
-  });
-});
+import { describe, it, expect } from 'vitest';
+import { t, setLocale, getLocale, detectLocale, addMessages } from '../src/i18n';
+
+describe('i18n', () => {
+  it('should return English messages by default', () => {
+    setLocale('en');
+    expect(t('agent.greeting')).toBe('Hello! How can I help you?');
+  });
+
+  it('should return Chinese messages', () => {
+    setLocale('zh-CN');
+    expect(t('agent.greeting')).toBe('你好！有什么可以帮你的？');
+    setLocale('en'); // reset
+  });
+
+  it('should interpolate params', () => {
+    setLocale('en');
+    expect(t('agent.started', { name: 'TestBot' })).toBe('Agent "TestBot" started successfully');
+  });
+
+  it('should fall back to key if not found', () => {
+    expect(t('nonexistent.key')).toBe('nonexistent.key');
+  });
+
+  it('should get and set locale', () => {
+    setLocale('zh-CN');
+    expect(getLocale()).toBe('zh-CN');
+    setLocale('en');
+    expect(getLocale()).toBe('en');
+  });
+
+  it('should add custom messages', () => {
+    addMessages('en', { 'custom.key': 'Custom value' });
+    expect(t('custom.key')).toBe('Custom value');
+  });
+
+  it('should detect locale from environment', () => {
+    const locale = detectLocale();
+    expect(['en', 'zh-CN']).toContain(locale);
+  });
+});

package/tests/mcp.test.ts

@@ -1,54 +1,54 @@
-import { describe, it, expect } from 'vitest';
-import { MCPToolRegistry, createMCPTool } from '../src/tools/mcp';
-
-describe('MCP Tool System', () => {
-  it('should register and list tools', () => {
-    const registry = new MCPToolRegistry();
-    const tool = createMCPTool('calculator', 'Basic calculator', {
-      type: 'object',
-      properties: { expression: { type: 'string' } },
-    }, async (input) => ({ content: `Result: ${input.expression}` }));
-
-    registry.register(tool);
-    expect(registry.has('calculator')).toBe(true);
-    expect(registry.list().length).toBe(1);
-    expect(registry.list()[0].name).toBe('calculator');
-  });
-
-  it('should execute a tool', async () => {
-    const registry = new MCPToolRegistry();
-    registry.register(createMCPTool('echo', 'Echo tool', {}, async (input) => ({
-      content: `Echo: ${input.text}`,
-    })));
-
-    const result = await registry.execute('echo', { text: 'hello' });
-    expect(result.content).toBe('Echo: hello');
-    expect(result.isError).toBeUndefined();
-  });
-
-  it('should return error for missing tool', async () => {
-    const registry = new MCPToolRegistry();
-    const result = await registry.execute('nonexistent', {});
-    expect(result.isError).toBe(true);
-    expect(result.content).toContain('not found');
-  });
-
-  it('should handle tool execution errors', async () => {
-    const registry = new MCPToolRegistry();
-    registry.register(createMCPTool('failing', 'Fails', {}, async () => {
-      throw new Error('boom');
-    }));
-
-    const result = await registry.execute('failing', {});
-    expect(result.isError).toBe(true);
-    expect(result.content).toContain('boom');
-  });
-
-  it('should unregister tools', () => {
-    const registry = new MCPToolRegistry();
-    registry.register(createMCPTool('temp', 'Temp', {}, async () => ({ content: '' })));
-    expect(registry.has('temp')).toBe(true);
-    registry.unregister('temp');
-    expect(registry.has('temp')).toBe(false);
-  });
-});
+import { describe, it, expect } from 'vitest';
+import { MCPToolRegistry, createMCPTool } from '../src/tools/mcp';
+
+describe('MCP Tool System', () => {
+  it('should register and list tools', () => {
+    const registry = new MCPToolRegistry();
+    const tool = createMCPTool('calculator', 'Basic calculator', {
+      type: 'object',
+      properties: { expression: { type: 'string' } },
+    }, async (input) => ({ content: `Result: ${input.expression}` }));
+
+    registry.register(tool);
+    expect(registry.has('calculator')).toBe(true);
+    expect(registry.list().length).toBe(1);
+    expect(registry.list()[0].name).toBe('calculator');
+  });
+
+  it('should execute a tool', async () => {
+    const registry = new MCPToolRegistry();
+    registry.register(createMCPTool('echo', 'Echo tool', {}, async (input) => ({
+      content: `Echo: ${input.text}`,
+    })));
+
+    const result = await registry.execute('echo', { text: 'hello' });
+    expect(result.content).toBe('Echo: hello');
+    expect(result.isError).toBeUndefined();
+  });
+
+  it('should return error for missing tool', async () => {
+    const registry = new MCPToolRegistry();
+    const result = await registry.execute('nonexistent', {});
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('not found');
+  });
+
+  it('should handle tool execution errors', async () => {
+    const registry = new MCPToolRegistry();
+    registry.register(createMCPTool('failing', 'Fails', {}, async () => {
+      throw new Error('boom');
+    }));
+
+    const result = await registry.execute('failing', {});
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('boom');
+  });
+
+  it('should unregister tools', () => {
+    const registry = new MCPToolRegistry();
+    registry.register(createMCPTool('temp', 'Temp', {}, async () => ({ content: '' })));
+    expect(registry.has('temp')).toBe(true);
+    registry.unregister('temp');
+    expect(registry.has('temp')).toBe(false);
+  });
+});

package/tests/oad.test.ts

@@ -1,68 +1,68 @@
-import { describe, it, expect } from 'vitest';
-import { OADSchema } from '../src/schema/oad';
-
-describe('OAD Schema', () => {
-  it('should parse a valid OAD document', () => {
-    const doc = OADSchema.parse({
-      apiVersion: 'opc/v1',
-      kind: 'Agent',
-      metadata: { name: 'test-agent' },
-      spec: {},
-    });
-    expect(doc.metadata.name).toBe('test-agent');
-    expect(doc.metadata.version).toBe('1.0.0');
-    expect(doc.spec.model).toBe('deepseek-chat');
-  });
-
-  it('should reject invalid apiVersion', () => {
-    expect(() =>
-      OADSchema.parse({
-        apiVersion: 'v2',
-        kind: 'Agent',
-        metadata: { name: 'test' },
-        spec: {},
-      })
-    ).toThrow();
-  });
-
-  it('should parse full document with all fields', () => {
-    const doc = OADSchema.parse({
-      apiVersion: 'opc/v1',
-      kind: 'Agent',
-      metadata: {
-        name: 'full-agent',
-        version: '2.0.0',
-        description: 'A full agent',
-        author: 'Test',
-        license: 'MIT',
-        marketplace: { certified: true, category: 'support' },
-      },
-      spec: {
-        provider: { default: 'openai', allowed: ['openai'] },
-        model: 'gpt-4',
-        systemPrompt: 'You are helpful.',
-        skills: [{ name: 'faq', description: 'FAQ skill' }],
-        channels: [{ type: 'web', port: 8080 }],
-        memory: { shortTerm: true, longTerm: true },
-        dtv: {
-          trust: { level: 'certified' },
-          value: { metrics: ['response_time'] },
-        },
-      },
-    });
-    expect(doc.metadata.version).toBe('2.0.0');
-    expect(doc.spec.channels[0].port).toBe(8080);
-    expect(doc.spec.dtv?.trust?.level).toBe('certified');
-  });
-
-  it('should reject missing metadata.name', () => {
-    expect(() =>
-      OADSchema.parse({
-        apiVersion: 'opc/v1',
-        kind: 'Agent',
-        metadata: {},
-        spec: {},
-      })
-    ).toThrow();
-  });
-});
+import { describe, it, expect } from 'vitest';
+import { OADSchema } from '../src/schema/oad';
+
+describe('OAD Schema', () => {
+  it('should parse a valid OAD document', () => {
+    const doc = OADSchema.parse({
+      apiVersion: 'opc/v1',
+      kind: 'Agent',
+      metadata: { name: 'test-agent' },
+      spec: {},
+    });
+    expect(doc.metadata.name).toBe('test-agent');
+    expect(doc.metadata.version).toBe('1.0.0');
+    expect(doc.spec.model).toBe('deepseek-chat');
+  });
+
+  it('should reject invalid apiVersion', () => {
+    expect(() =>
+      OADSchema.parse({
+        apiVersion: 'v2',
+        kind: 'Agent',
+        metadata: { name: 'test' },
+        spec: {},
+      })
+    ).toThrow();
+  });
+
+  it('should parse full document with all fields', () => {
+    const doc = OADSchema.parse({
+      apiVersion: 'opc/v1',
+      kind: 'Agent',
+      metadata: {
+        name: 'full-agent',
+        version: '2.0.0',
+        description: 'A full agent',
+        author: 'Test',
+        license: 'MIT',
+        marketplace: { certified: true, category: 'support' },
+      },
+      spec: {
+        provider: { default: 'openai', allowed: ['openai'] },
+        model: 'gpt-4',
+        systemPrompt: 'You are helpful.',
+        skills: [{ name: 'faq', description: 'FAQ skill' }],
+        channels: [{ type: 'web', port: 8080 }],
+        memory: { shortTerm: true, longTerm: true },
+        dtv: {
+          trust: { level: 'certified' },
+          value: { metrics: ['response_time'] },
+        },
+      },
+    });
+    expect(doc.metadata.version).toBe('2.0.0');
+    expect(doc.spec.channels[0].port).toBe(8080);
+    expect(doc.spec.dtv?.trust?.level).toBe('certified');
+  });
+
+  it('should reject missing metadata.name', () => {
+    expect(() =>
+      OADSchema.parse({
+        apiVersion: 'opc/v1',
+        kind: 'Agent',
+        metadata: {},
+        spec: {},
+      })
+    ).toThrow();
+  });
+});

package/tests/performance.test.ts

@@ -1,115 +1,115 @@
-import { describe, it, expect } from 'vitest';
-import { ConnectionPool, RequestBatcher, LazyLoader } from '../src/core/performance';
-
-describe('ConnectionPool', () => {
-  it('should acquire and release connections', () => {
-    const pool = new ConnectionPool(3);
-    const conn = pool.acquire('openai');
-    expect(conn.inUse).toBe(true);
-    pool.release(conn.id);
-    const stats = pool.getStats();
-    expect(stats['openai'].total).toBe(1);
-    expect(stats['openai'].inUse).toBe(0);
-  });
-
-  it('should reuse released connections', () => {
-    const pool = new ConnectionPool(2);
-    const c1 = pool.acquire('openai');
-    pool.release(c1.id);
-    const c2 = pool.acquire('openai');
-    expect(c2.id).toBe(c1.id);
-  });
-
-  it('should drain all connections', () => {
-    const pool = new ConnectionPool();
-    pool.acquire('openai');
-    pool.acquire('deepseek');
-    pool.drain();
-    expect(pool.getStats()).toEqual({});
-  });
-});
-
-describe('RequestBatcher', () => {
-  it('should batch requests', async () => {
-    const batcher = new RequestBatcher<string>(
-      async (batch) => batch.map(s => s.toUpperCase()),
-      2,
-      10,
-    );
-
-    const [r1, r2] = await Promise.all([
-      batcher.add('hello'),
-      batcher.add('world'),
-    ]);
-    expect(r1).toBe('HELLO');
-    expect(r2).toBe('WORLD');
-  });
-
-  it('should flush on timer', async () => {
-    const batcher = new RequestBatcher<number>(
-      async (batch) => batch.map(n => n * 2),
-      10,
-      20,
-    );
-
-    const result = await batcher.add(5);
-    expect(result).toBe(10);
-  });
-
-  it('should track pending count', () => {
-    const batcher = new RequestBatcher<string>(
-      async (batch) => batch,
-      100,
-      10000,
-    );
-    batcher.add('a');
-    batcher.add('b');
-    expect(batcher.pending).toBe(2);
-  });
-});
-
-describe('LazyLoader', () => {
-  it('should lazily load items', async () => {
-    const loader = new LazyLoader<string>();
-    let loadCount = 0;
-    loader.register('greeting', async () => { loadCount++; return 'hello'; });
-
-    expect(loader.isLoaded('greeting')).toBe(false);
-    const val = await loader.get('greeting');
-    expect(val).toBe('hello');
-    expect(loader.isLoaded('greeting')).toBe(true);
-
-    // Second call should use cache
-    await loader.get('greeting');
-    expect(loadCount).toBe(1);
-  });
-
-  it('should throw for unregistered items', async () => {
-    const loader = new LazyLoader();
-    await expect(loader.get('unknown')).rejects.toThrow('No loader registered');
-  });
-
-  it('should evict and reload', async () => {
-    const loader = new LazyLoader<number>();
-    let count = 0;
-    loader.register('counter', async () => ++count);
-    
-    await loader.get('counter');
-    expect(loader.loadedCount).toBe(1);
-    loader.evict('counter');
-    expect(loader.loadedCount).toBe(0);
-    await loader.get('counter');
-    expect(count).toBe(2);
-  });
-
-  it('should clear all', async () => {
-    const loader = new LazyLoader<string>();
-    loader.register('a', async () => 'a');
-    loader.register('b', async () => 'b');
-    await loader.get('a');
-    await loader.get('b');
-    loader.clear();
-    expect(loader.loadedCount).toBe(0);
-    expect(loader.registeredCount).toBe(2);
-  });
-});
+import { describe, it, expect } from 'vitest';
+import { ConnectionPool, RequestBatcher, LazyLoader } from '../src/core/performance';
+
+describe('ConnectionPool', () => {
+  it('should acquire and release connections', () => {
+    const pool = new ConnectionPool(3);
+    const conn = pool.acquire('openai');
+    expect(conn.inUse).toBe(true);
+    pool.release(conn.id);
+    const stats = pool.getStats();
+    expect(stats['openai'].total).toBe(1);
+    expect(stats['openai'].inUse).toBe(0);
+  });
+
+  it('should reuse released connections', () => {
+    const pool = new ConnectionPool(2);
+    const c1 = pool.acquire('openai');
+    pool.release(c1.id);
+    const c2 = pool.acquire('openai');
+    expect(c2.id).toBe(c1.id);
+  });
+
+  it('should drain all connections', () => {
+    const pool = new ConnectionPool();
+    pool.acquire('openai');
+    pool.acquire('deepseek');
+    pool.drain();
+    expect(pool.getStats()).toEqual({});
+  });
+});
+
+describe('RequestBatcher', () => {
+  it('should batch requests', async () => {
+    const batcher = new RequestBatcher<string>(
+      async (batch) => batch.map(s => s.toUpperCase()),
+      2,
+      10,
+    );
+
+    const [r1, r2] = await Promise.all([
+      batcher.add('hello'),
+      batcher.add('world'),
+    ]);
+    expect(r1).toBe('HELLO');
+    expect(r2).toBe('WORLD');
+  });
+
+  it('should flush on timer', async () => {
+    const batcher = new RequestBatcher<number>(
+      async (batch) => batch.map(n => n * 2),
+      10,
+      20,
+    );
+
+    const result = await batcher.add(5);
+    expect(result).toBe(10);
+  });
+
+  it('should track pending count', () => {
+    const batcher = new RequestBatcher<string>(
+      async (batch) => batch,
+      100,
+      10000,
+    );
+    batcher.add('a');
+    batcher.add('b');
+    expect(batcher.pending).toBe(2);
+  });
+});
+
+describe('LazyLoader', () => {
+  it('should lazily load items', async () => {
+    const loader = new LazyLoader<string>();
+    let loadCount = 0;
+    loader.register('greeting', async () => { loadCount++; return 'hello'; });
+
+    expect(loader.isLoaded('greeting')).toBe(false);
+    const val = await loader.get('greeting');
+    expect(val).toBe('hello');
+    expect(loader.isLoaded('greeting')).toBe(true);
+
+    // Second call should use cache
+    await loader.get('greeting');
+    expect(loadCount).toBe(1);
+  });
+
+  it('should throw for unregistered items', async () => {
+    const loader = new LazyLoader();
+    await expect(loader.get('unknown')).rejects.toThrow('No loader registered');
+  });
+
+  it('should evict and reload', async () => {
+    const loader = new LazyLoader<number>();
+    let count = 0;
+    loader.register('counter', async () => ++count);
+    
+    await loader.get('counter');
+    expect(loader.loadedCount).toBe(1);
+    loader.evict('counter');
+    expect(loader.loadedCount).toBe(0);
+    await loader.get('counter');
+    expect(count).toBe(2);
+  });
+
+  it('should clear all', async () => {
+    const loader = new LazyLoader<string>();
+    loader.register('a', async () => 'a');
+    loader.register('b', async () => 'b');
+    await loader.get('a');
+    await loader.get('b');
+    loader.clear();
+    expect(loader.loadedCount).toBe(0);
+    expect(loader.registeredCount).toBe(2);
+  });
+});