@bluefly/openstandardagents 0.4.8 → 0.4.9

package/.version.json

@@ -1,7 +1,7 @@
 {
-  "current": "0.4.7",
-  "latest_stable": "0.4.7",
-  "spec_version": "0.4.7",
-  "spec_path": "spec/v0.4",
+  "current": "0.4.9",
+  "latest_stable": "0.4.8",
+  "spec_version": "0.4.9",
+  "spec_path": "spec/v0.5",
   "schema_file": "agent.schema.json"
 }

package/CHANGELOG.md

@@ -7,8 +7,22 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.5.0] - 2026-03-08
+
 ### Added
 - **AgentScope integration**: Add AgentScope as supported agent framework with Python adapter, Drupal module, MCP server, A2A endpoint, and example manifests
+- **AgentScope adapter example**: Drupal module (`examples/drupal/ai_agents_agentscope/`) demonstrating AgentScope ReAct assistant integration via OSSA manifest
+- **v0.5 spec directory**: `spec/v0.5/` with agent identity, security posture, and protocol declarations schemas
+
+### Changed
+- Bumped version to 0.5.0
+- Schema default export now points to `spec/v0.5/agent.schema.json`
+
+## [0.4.8] - 2026-03-07
+
+### Changed
+- Backported AgentScope framework support to v0.4.x
+- Updated README with AgentScope in What's New
 
 ## [0.4.7] - 2026-03-06
 

package/README.md

@@ -14,16 +14,29 @@ OSSA is not a protocol (like MCP or A2A) and not a framework (like LangChain or
 - **Builds on A2A** - Supports A2A messaging and agent-to-agent communication
 - **Extends protocols** - Adds deployment and packaging layer on top of communication protocols
 
-## 🇺🇸 NIST AI Agent Standards Alignment
+## 🇺🇸 NIST CAISI RFI Alignment (NIST-2025-0035)
 
-OSSA v0.4.6 natively aligns with the [NIST AI Agent Standards Initiative](https://www.nist.gov/caisi/ai-agent-standards-initiative) driven by the Center for AI Standards and Innovation (CAISI) and the Information Technology Laboratory (ITL).
+OSSA natively aligns with the [NIST CAISI Request for Information on Collaborative AI Systems Integration](https://www.regulations.gov/docket/NIST-2025-0035), providing the critical **Contract Layer** missing from current agent protocols.
 
-- **Secure Interoperability**: OSSA's `A2AExtension` schema guarantees seamless multi-vendor agent coordination across network boundaries using standardized protocols.
-- **Agent Identity & Authorization**: Built-in `AgentIdentity`, `AccessTier`, and `SeparationOfDuties` schemas immediately fulfill ITL's criteria for zero-trust verifiable credentials, semantic role isolation, and self-rotating service accounts.
-- **Provable Compliance**: The `metadata.compliance` specification allows agents to cryptographically declare their alignment to Federal and industry governance frameworks directly in their manifest.
+- **Agent Identity (IA-3)**: W3C Decentralized Identifiers (GAID) provide cryptographic origin authentication for agents.
+- **Pre-Authorization (AC-3, AC-6)**: Deterministic AWS Cedar policies evaluated at the transport layer enforce zero-trust bounds before an LLM receives context.
+- **Federated Discovery**: Integration with DUADP (`.well-known` endpoints) scales agent discovery securely across organizational boundaries without centralized lock-in.
+- **Supply Chain Security (SI-7)**: Cryptographically signed manifests (`x-signature`) and explicit OSCAL/SBOM pointers prevent tool poisoning and supply chain attacks.
 
 ## What's New
 
+### AgentScope Integration (v0.4.8)
+
+- **New agent framework**: `agentscope` — Alibaba's production-ready Python agent framework (Apache 2.0, 17.8k stars) now supported as an OSSA agent type
+- **Python adapter**: Full OSSA-to-AgentScope bridge — reads OSSA manifests, instantiates ReActAgent with MCP tools, A2A protocol, memory backends (Mem0, Redis, ReMe)
+- **MCP server wrapper**: Expose any AgentScope agent as an MCP server for Claude Code, Cursor, VS Code
+- **A2A endpoint**: Serve AgentScope agents as discoverable A2A protocol endpoints with `.well-known/agent.json`
+- **Drupal module**: `ai_agents_agentscope` — contrib-first AiProvider plugin bridging AgentScope into Drupal's AI Agents ecosystem
+- **Docker support**: Dockerfile + docker-compose for containerized AgentScope runtime
+- **CLI**: `ossa-agentscope run|validate|serve` commands for manifest-driven agent execution
+- **Unique capabilities** not available in other frameworks: RL-based agent training, realtime voice agents, built-in evaluation framework
+- **Schema**: `extensions.agentscope` block in v0.4 and v0.5 specs with agent_class, capabilities, memory_backend, orchestration, formatter, compression, skill_dirs
+
 ### OpenAI Agents SDK Export (2026-02-16)
 
 - **New export platform**: `openai-agents-sdk` (22nd platform) — generates runnable `@openai/agents` TypeScript packages from OSSA manifests
@@ -175,6 +188,8 @@ const server = await mcpService.exposeMCPServer(typescriptAgent);
 npm install -g @bluefly/openstandardagents
 ```
 
+OSSA uses [`@bluefly/duadp`](https://www.npmjs.com/package/@bluefly/duadp) for agent discovery and federation via the [UADP protocol](https://github.com/blueflyio/duadp).
+
 ## Quick Start
 
 ```bash

package/dist/.version.json

@@ -1,7 +1,7 @@
 {
-  "current": "0.4.7",
-  "latest_stable": "0.4.7",
-  "spec_version": "0.4.7",
-  "spec_path": "spec/v0.4",
+  "current": "0.4.9",
+  "latest_stable": "0.4.8",
+  "spec_version": "0.4.9",
+  "spec_path": "spec/v0.5",
   "schema_file": "agent.schema.json"
 }

package/dist/adapters/a2a/__tests__/mcp-integration.spec.js

@@ -9,7 +9,7 @@ import { MCPIntegrationService, MCPMessageType } from '../mcp-integration.js';
 function createTestAgent(name, namespace) {
     return {
         id: crypto.randomUUID(),
-        uri: `agent://${namespace}/${name}`,
+        uri: `uadp://${namespace}/${name}`,
         name,
         namespace,
         capabilities: ['test'],

package/dist/adapters/a2a/a2a-protocol.d.ts

@@ -22,7 +22,7 @@ export interface AgentIdentity {
     namespace: string;
     /** Agent name */
     name: string;
-    /** Agent URI format: agent://{namespace}/{name} */
+    /** Agent URI format: uadp://{namespace}/{name} */
     uri: string;
     /** Agent capabilities */
     capabilities: string[];

package/dist/adapters/a2a/a2a-tool.js

@@ -20,7 +20,7 @@ export const A2A_TOOL = {
         properties: {
             targetAgent: {
                 type: 'string',
-                description: 'Agent ID or URI to communicate with (format: agent://namespace/name or UUID)',
+                description: 'Agent ID or URI to communicate with (format: uadp://namespace/name or UUID)',
             },
             message: {
                 type: 'object',
@@ -244,7 +244,7 @@ export class A2AToolHandler {
             return agent.identity;
         }
         // Parse agent URI if provided
-        if (agentId.startsWith('agent://')) {
+        if (agentId.startsWith('uadp://')) {
             const match = agentId.match(/^agent:\/\/([^/]+)\/(.+)$/);
             if (match) {
                 return {
@@ -265,7 +265,7 @@ export class A2AToolHandler {
             id: 'current-agent',
             namespace: 'default',
             name: 'current',
-            uri: 'agent://default/current',
+            uri: 'uadp://default/current',
             capabilities: [],
             version: '1.0.0',
         };

package/dist/adapters/a2a/delegation.js

@@ -78,7 +78,7 @@ export class DelegationService {
                 id: 'consumer',
                 namespace: 'default',
                 name: 'consumer',
-                uri: 'agent://default/consumer',
+                uri: 'uadp://default/consumer',
                 capabilities: [],
                 version: '1.0.0',
             },

package/dist/adapters/base/common-file-generator.d.ts

@@ -13,7 +13,7 @@ import { type TeamTargetPlatform } from '../../services/multi-agent/team-generat
 /**
  * Supported target platforms for file generation
  */
-export type Platform = 'langchain' | 'crewai' | 'mcp' | 'npm' | 'drupal' | 'gitlab-duo' | 'docker' | 'kubernetes' | 'custom';
+export type Platform = 'langchain' | 'crewai' | 'agentscope' | 'mcp' | 'npm' | 'drupal' | 'gitlab-duo' | 'docker' | 'kubernetes' | 'custom';
 /**
  * Options for package.json generation
  */

package/dist/adapters/base/common-file-generator.js

@@ -34,6 +34,9 @@ const PLATFORM_SCRIPTS = {
     crewai: {
         start: 'python main.py',
     },
+    agentscope: {
+        start: 'python main.py',
+    },
     'gitlab-duo': {
         build: 'tsc',
         start: 'node dist/index.js',
@@ -67,6 +70,7 @@ const PLATFORM_DEPENDENCIES = {
     },
     npm: {},
     crewai: {},
+    agentscope: {},
     'gitlab-duo': {},
     docker: {},
     kubernetes: {},
@@ -88,6 +92,7 @@ const PLATFORM_DEV_DEPENDENCIES = {
     },
     npm: {},
     crewai: {},
+    agentscope: {},
     'gitlab-duo': {
         '@types/node': '^20.0.0',
         typescript: '^5.0.0',
@@ -260,6 +265,19 @@ __pycache__/
 venv/
 .venv/
 *.egg-info/
+`,
+    agentscope: `
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+.Python
+venv/
+.venv/
+*.egg-info/
+# AgentScope
+runs/
+.agentscope/
 `,
     mcp: '',
     npm: '',
@@ -427,6 +445,8 @@ function getDefaultInstallCommand(platform) {
             return 'npm install';
         case 'crewai':
             return 'pip install -r requirements.txt';
+        case 'agentscope':
+            return 'pip install agentscope\npip install -r requirements.txt';
         case 'docker':
             return 'docker build -t agent .';
         case 'kubernetes':
@@ -448,6 +468,8 @@ function getDefaultUsage(platform, name) {
             return `import agent from '${name}';\nconsole.log(agent.metadata);`;
         case 'crewai':
             return 'python main.py';
+        case 'agentscope':
+            return 'python main.py';
         case 'docker':
             return 'docker run agent';
         case 'kubernetes':

package/dist/cli/banner.js

@@ -21,7 +21,7 @@ ${chalk.cyan('╚═════════════════════
 `;
 /** Standalone wizard logo: bold ASCII/ANSI art for agent creation wizard. */
 export const WIZARD_LOGO = `
-${chalk.cyan('  ') + chalk.bold.blue('  ___   ____   ____   ___   ') + chalk.cyan('     ') + chalk.blue('agent://')}
+${chalk.cyan('  ') + chalk.bold.blue('  ___   ____   ____   ___   ') + chalk.cyan('     ') + chalk.blue('uadp://')}
 ${chalk.cyan('  ') + chalk.bold.blue(' / _ \\ / __ \\ / ___| / _ \\  ') + chalk.cyan('     ') + chalk.gray('open standard')}
 ${chalk.cyan('  ') + chalk.bold.blue('| | | | |  | \\___ \\| | | | ') + chalk.cyan('  ') + chalk.cyan('---') + chalk.blue('---') + chalk.cyan('---') + chalk.blue('---')}
 ${chalk.cyan('  ') + chalk.bold.blue('| | | | |  | |___) | |_| | ') + chalk.cyan('  ') + chalk.white('O') + chalk.cyan(' S ') + chalk.white('S') + chalk.cyan(' A')}

package/dist/cli/commands/agents-sync.command.d.ts

@@ -0,0 +1,19 @@
+/**
+ * OSSA Agents Sync Command
+ *
+ * Syncs platform agents between locations:
+ *   NAS:    /Volumes/AgentPlatform/.agents/platform-agents/
+ *   Local:  ~/.agents/platform-agents/
+ *   Oracle: /opt/agent-platform/.agents/platform-agents/ (via SSH)
+ *
+ * Also scans project .agents/ folders and builds a unified registry.
+ *
+ * Usage:
+ *   ossa agents-sync                    # Sync NAS → local
+ *   ossa agents-sync --target oracle    # Sync NAS → Oracle
+ *   ossa agents-sync --scan             # Scan all project .agents/ folders
+ *   ossa agents-sync --publish <url>    # Publish all agents to DUADP node
+ */
+import { Command } from 'commander';
+export declare const agentsSyncCommand: Command;
+//# sourceMappingURL=agents-sync.command.d.ts.map

package/dist/cli/commands/agents-sync.command.js

@@ -0,0 +1,268 @@
+/**
+ * OSSA Agents Sync Command
+ *
+ * Syncs platform agents between locations:
+ *   NAS:    /Volumes/AgentPlatform/.agents/platform-agents/
+ *   Local:  ~/.agents/platform-agents/
+ *   Oracle: /opt/agent-platform/.agents/platform-agents/ (via SSH)
+ *
+ * Also scans project .agents/ folders and builds a unified registry.
+ *
+ * Usage:
+ *   ossa agents-sync                    # Sync NAS → local
+ *   ossa agents-sync --target oracle    # Sync NAS → Oracle
+ *   ossa agents-sync --scan             # Scan all project .agents/ folders
+ *   ossa agents-sync --publish <url>    # Publish all agents to DUADP node
+ */
+import { Command } from 'commander';
+import chalk from 'chalk';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+const NAS_AGENTS_PATH = '/Volumes/AgentPlatform/.agents/platform-agents';
+const LOCAL_AGENTS_PATH = path.join(os.homedir(), '.agents', 'platform-agents');
+const ORACLE_AGENTS_PATH = '/opt/agent-platform/.agents/platform-agents';
+function copyDirRecursive(src, dest, stats) {
+    if (!fs.existsSync(src))
+        return;
+    if (!fs.existsSync(dest)) {
+        fs.mkdirSync(dest, { recursive: true });
+    }
+    const entries = fs.readdirSync(src, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        if (entry.name === 'node_modules' || entry.name === '.git')
+            continue;
+        if (entry.isDirectory()) {
+            copyDirRecursive(srcPath, destPath, stats);
+        }
+        else {
+            try {
+                const srcStat = fs.statSync(srcPath);
+                const destExists = fs.existsSync(destPath);
+                if (destExists) {
+                    const destStat = fs.statSync(destPath);
+                    if (srcStat.mtimeMs <= destStat.mtimeMs) {
+                        stats.skipped++;
+                        continue;
+                    }
+                }
+                fs.copyFileSync(srcPath, destPath);
+                stats.copied++;
+            }
+            catch (err) {
+                stats.errors++;
+            }
+        }
+    }
+}
+function scanAgentsDir(agentsPath) {
+    const agents = [];
+    if (!fs.existsSync(agentsPath))
+        return agents;
+    // Check @ossa/ scoped agents
+    const ossaPath = path.join(agentsPath, '.agents', '@ossa');
+    if (fs.existsSync(ossaPath)) {
+        const entries = fs.readdirSync(ossaPath, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                agents.push(`@ossa/${entry.name}`);
+            }
+        }
+    }
+    // Check top-level agents
+    const topLevel = path.join(agentsPath, '.agents');
+    if (fs.existsSync(topLevel)) {
+        const entries = fs.readdirSync(topLevel, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isDirectory() &&
+                !entry.name.startsWith('@') &&
+                entry.name !== 'skills') {
+                agents.push(entry.name);
+            }
+        }
+    }
+    return agents;
+}
+export const agentsSyncCommand = new Command('agents-sync')
+    .description('Sync platform agents between NAS, local, and Oracle')
+    .option('--source <path>', 'Source agents directory', NAS_AGENTS_PATH)
+    .option('--target <target>', 'Target: "local" (default), "oracle", or a path', 'local')
+    .option('--scan', 'Scan all WORKING_DEMOs projects for .agents/ folders')
+    .option('--publish <url>', 'Publish all agents to a DUADP node')
+    .option('--dry-run', 'Show what would be synced without doing it')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+    // Scan mode — find all .agents/ across projects
+    if (options.scan) {
+        const workingDemos = path.join(os.homedir(), 'Sites', 'blueflyio', 'WORKING_DEMOs');
+        if (!fs.existsSync(workingDemos)) {
+            console.error(chalk.red(`Not found: ${workingDemos}`));
+            process.exit(1);
+        }
+        const projects = fs.readdirSync(workingDemos, { withFileTypes: true });
+        const allAgents = {};
+        for (const project of projects) {
+            if (!project.isDirectory())
+                continue;
+            const projectPath = path.join(workingDemos, project.name);
+            // Check .agents/
+            const dotAgents = path.join(projectPath, '.agents');
+            if (fs.existsSync(dotAgents)) {
+                const entries = fs
+                    .readdirSync(dotAgents, { withFileTypes: true })
+                    .filter((e) => e.isDirectory() ||
+                    e.name.endsWith('.ossa.yaml') ||
+                    e.name.endsWith('.ossa.json'))
+                    .map((e) => e.name);
+                if (entries.length > 0) {
+                    allAgents[project.name] = entries;
+                }
+            }
+            // Check agents/
+            const agents = path.join(projectPath, 'agents');
+            if (fs.existsSync(agents) && !allAgents[project.name]) {
+                const entries = fs
+                    .readdirSync(agents, { withFileTypes: true })
+                    .filter((e) => e.isDirectory() ||
+                    e.name.endsWith('.ossa.yaml') ||
+                    e.name.endsWith('.ossa.json'))
+                    .map((e) => e.name);
+                if (entries.length > 0) {
+                    allAgents[`${project.name}/agents`] = entries;
+                }
+            }
+        }
+        if (options.json) {
+            console.log(JSON.stringify(allAgents, null, 2));
+        }
+        else {
+            console.log(chalk.cyan.bold('\nAgent Inventory Across Projects\n'));
+            let totalAgents = 0;
+            for (const [project, agents] of Object.entries(allAgents)) {
+                console.log(chalk.white.bold(`  ${project}/`));
+                for (const agent of agents) {
+                    console.log(chalk.gray(`    ${agent}`));
+                    totalAgents++;
+                }
+            }
+            console.log(chalk.cyan(`\n  ${Object.keys(allAgents).length} projects, ${totalAgents} agents/manifests\n`));
+        }
+        // Also show platform agents from NAS
+        if (fs.existsSync(options.source)) {
+            const nasAgents = scanAgentsDir(options.source);
+            if (!options.json) {
+                console.log(chalk.cyan.bold(`Platform Agents (${options.source})`));
+                console.log(chalk.white(`  ${nasAgents.length} agents available`));
+                console.log(chalk.gray(`  ${nasAgents.slice(0, 10).join(', ')}${nasAgents.length > 10 ? `, ... +${nasAgents.length - 10} more` : ''}`));
+            }
+        }
+        process.exit(0);
+    }
+    // Sync mode
+    const sourcePath = options.source;
+    let destPath;
+    switch (options.target) {
+        case 'local':
+            destPath = LOCAL_AGENTS_PATH;
+            break;
+        case 'oracle':
+            // For Oracle, we'd need SSH — show the rsync command instead
+            console.log(chalk.cyan('Oracle sync requires rsync over SSH:'));
+            console.log(chalk.white(`  rsync -avz --delete ${sourcePath}/ ubuntu@oracle-platform.tailcf98b3.ts.net:${ORACLE_AGENTS_PATH}/`));
+            process.exit(0);
+            break;
+        default:
+            destPath = options.target;
+    }
+    if (!fs.existsSync(sourcePath)) {
+        console.error(chalk.red(`Source not found: ${sourcePath}`));
+        console.error(chalk.yellow('Is the NAS mounted at /Volumes/AgentPlatform/?'));
+        process.exit(1);
+    }
+    if (options.dryRun) {
+        const agents = scanAgentsDir(sourcePath);
+        console.log(chalk.cyan('Dry run — would sync:'));
+        console.log(chalk.white(`  Source: ${sourcePath}`));
+        console.log(chalk.white(`  Dest:   ${destPath}`));
+        console.log(chalk.white(`  Agents: ${agents.length}`));
+        for (const agent of agents.slice(0, 15)) {
+            console.log(chalk.gray(`    ${agent}`));
+        }
+        if (agents.length > 15) {
+            console.log(chalk.gray(`    ... +${agents.length - 15} more`));
+        }
+        process.exit(0);
+    }
+    // Do the sync
+    console.log(chalk.cyan(`Syncing agents...`));
+    console.log(chalk.gray(`  From: ${sourcePath}`));
+    console.log(chalk.gray(`  To:   ${destPath}`));
+    const stats = {
+        copied: 0,
+        skipped: 0,
+        errors: 0,
+        agents: [],
+    };
+    copyDirRecursive(sourcePath, destPath, stats);
+    stats.agents = scanAgentsDir(destPath);
+    if (options.json) {
+        console.log(JSON.stringify(stats, null, 2));
+    }
+    else {
+        console.log(chalk.green(`\n✓ Synced: ${stats.copied} files copied, ${stats.skipped} skipped, ${stats.errors} errors`));
+        console.log(chalk.white(`  ${stats.agents.length} agents available locally`));
+    }
+    // Publish to DUADP if requested
+    if (options.publish) {
+        console.log(chalk.cyan(`\nPublishing ${stats.agents.length} agents to ${options.publish}...`));
+        let published = 0;
+        let failed = 0;
+        for (const agentName of stats.agents) {
+            const cleanName = agentName.replace('@ossa/', '');
+            const manifestPaths = [
+                path.join(destPath, '.agents', '@ossa', cleanName, 'manifest.ossa.yaml'),
+                path.join(destPath, '.agents', '@ossa', cleanName, 'agent.ossa.yaml'),
+                path.join(destPath, '.agents', '@ossa', cleanName, 'manifest.ossa.json'),
+            ];
+            let manifestContent = null;
+            for (const mp of manifestPaths) {
+                if (fs.existsSync(mp)) {
+                    manifestContent = fs.readFileSync(mp, 'utf-8');
+                    break;
+                }
+            }
+            if (!manifestContent)
+                continue;
+            try {
+                // Parse YAML/JSON
+                let manifest;
+                if (manifestContent.trim().startsWith('{')) {
+                    manifest = JSON.parse(manifestContent);
+                }
+                else {
+                    // Basic YAML parse — for full support would need yaml package
+                    // For now just publish as-is to the DUADP node
+                    continue; // Skip YAML for now, only JSON
+                }
+                const response = await fetch(`${options.publish}/api/v1/publish`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(manifest),
+                });
+                if (response.ok) {
+                    published++;
+                }
+                else {
+                    failed++;
+                }
+            }
+            catch {
+                failed++;
+            }
+        }
+        console.log(chalk.green(`✓ Published: ${published}, Failed: ${failed}`));
+    }
+});
+//# sourceMappingURL=agents-sync.command.js.map

package/dist/cli/commands/discover.js

@@ -7,73 +7,69 @@
  *   ossa discover --org blueflyio --min-trust 0.8
  *   ossa discover --json
  */
-import { Command } from 'commander';
+import { DuadpClient } from '@bluefly/duadp';
 import chalk from 'chalk';
 import Table from 'cli-table3';
-import axios from 'axios';
+import { Command } from 'commander';
 import { addRegistryOptions, resolveRegistryUrl, } from '../utils/standard-options.js';
 /**
- * Agent Protocol Client for interacting with agent-protocol service
+ * Agent Protocol Client for interacting with UADP registry
  */
 class AgentProtocolClient {
-    baseUrl;
-    token;
+    client;
     constructor(config) {
-        this.baseUrl = config?.baseUrl || process.env.OSSA_REGISTRY_URL || '';
-        this.token =
-            config?.apiKey ||
-                process.env.AGENT_PROTOCOL_TOKEN ||
-                process.env.GITLAB_PRIVATE_TOKEN;
+        const baseUrl = config?.baseUrl || process.env.OSSA_REGISTRY_URL || 'https://uadp.blueflyagents.com';
+        this.client = new DuadpClient(baseUrl, {
+            token: config?.apiKey || process.env.AGENT_PROTOCOL_TOKEN || process.env.GITLAB_PRIVATE_TOKEN,
+        });
     }
     /**
-     * Search for agents in the registry
+     * Search for agents in the registry using UADP
      */
     async searchAgents(query, filters) {
         try {
-            const params = new URLSearchParams();
-            if (query) {
-                params.append('q', query);
-            }
-            if (filters?.capability) {
-                params.append('capability', filters.capability);
-            }
-            if (filters?.org) {
-                params.append('org', filters.org);
-            }
-            if (filters?.minTrust !== undefined) {
-                params.append('minTrust', filters.minTrust.toString());
-            }
-            if (filters?.limit !== undefined) {
-                params.append('limit', filters.limit.toString());
-            }
-            const headers = {
-                'Content-Type': 'application/json',
-            };
-            if (this.token) {
-                headers['Authorization'] = `Bearer ${this.token}`;
-            }
-            const response = await axios.get(`${this.baseUrl}/api/v1/agents/search`, {
-                params,
-                headers,
-                timeout: 30000,
+            const response = await this.client.listAgents({
+                search: query,
+                limit: filters?.limit,
+            });
+            // Map UADP OssaAgent to AgentSearchResult
+            return response.data.map((agent) => {
+                // Handle variations in agent schema mapping
+                const capabilities = agent.spec?.capabilities || [];
+                const mappedCapabilities = capabilities.map((c) => typeof c === 'string' ? c : (c.name || 'unknown'));
+                // Map Tier 1 to 4 to a trust score 0-1
+                let trustLevel = 0.5;
+                const tier = agent.security?.tier;
+                if (tier === 'tier_4_system_admin')
+                    trustLevel = 1.0;
+                else if (tier === 'tier_3_write_elevated')
+                    trustLevel = 0.8;
+                else if (tier === 'tier_2_write_limited')
+                    trustLevel = 0.6;
+                else if (tier === 'tier_1_read')
+                    trustLevel = 0.4;
+                return {
+                    gaid: agent.metadata?.catalog?.catalog_id || `uadp://${this.client.nodeInfo?.node_id || 'remote'}/${agent.metadata?.name}`,
+                    name: agent.metadata?.name || 'unknown',
+                    organization: agent.metadata?.identity?.namespace || 'community',
+                    capabilities: mappedCapabilities,
+                    trustLevel: trustLevel,
+                    trustTier: tier || 'unverified',
+                    description: agent.metadata?.description || '',
+                    verified: !!agent.metadata?.identity?.publisher?.pgp_key,
+                };
+            }).filter((a) => {
+                if (filters?.minTrust && (a.trustLevel || 0) < filters.minTrust)
+                    return false;
+                if (filters?.org && a.organization !== filters.org)
+                    return false;
+                if (filters?.capability && !a.capabilities.includes(filters.capability))
+                    return false;
+                return true;
             });
-            return response.data.agents || response.data || [];
         }
         catch (error) {
-            if (axios.isAxiosError(error)) {
-                if (error.response?.status === 404) {
-                    throw new Error('Agent search endpoint not found. Ensure agent-protocol service is running.');
-                }
-                else if (error.response?.status === 401) {
-                    throw new Error('Authentication failed. Set AGENT_PROTOCOL_TOKEN environment variable.');
-                }
-                else if (error.code === 'ECONNREFUSED') {
-                    throw new Error(`Cannot connect to agent-protocol service at ${this.baseUrl}. ` +
-                        `Set AGENT_PROTOCOL_URL to the correct endpoint.`);
-                }
-                throw new Error(`Agent search failed: ${error.response?.data?.message || error.message}`);
-            }
-            throw error;
+            throw new Error(`UADP search failed: ${error.message}`);
         }
     }
 }