@bluefly/openstandardagents 0.4.4 → 0.4.6

package/dist/adapters/anthropic/messages.js

@@ -1,92 +1,70 @@
 /**
  * Message Format Conversion
- * Convert between OSSA and Anthropic message formats
+ * Convert between OSSA and Anthropic SDK message formats
  */
 /**
- * Convert OSSA messages to Anthropic format
+ * Convert OSSA messages to Anthropic SDK format
  */
 export function convertToAnthropicMessages(messages) {
-    // Extract system message if present
+    // Extract system message
     let system;
     const conversationMessages = [];
     for (const msg of messages) {
         if (msg.role === 'system') {
-            // Combine multiple system messages
-            if (typeof msg.content === 'string') {
-                system = system ? `${system}\n\n${msg.content}` : msg.content;
-            }
-            else {
-                // Extract text from content blocks
-                const textBlocks = msg.content.filter((b) => b.type === 'text');
-                const text = textBlocks
+            const text = typeof msg.content === 'string'
+                ? msg.content
+                : msg.content
+                    .filter((b) => b.type === 'text')
                     .map((b) => b.text)
                     .join('\n');
-                system = system ? `${system}\n\n${text}` : text;
-            }
+            system = system ? `${system}\n\n${text}` : text;
         }
         else {
             conversationMessages.push(msg);
         }
     }
-    // Convert conversation messages
-    const anthropicMessages = conversationMessages.map((msg) => {
-        if (typeof msg.content === 'string') {
-            return {
-                role: msg.role,
-                content: msg.content,
-            };
-        }
-        // Convert content blocks
-        const content = [];
-        for (const block of msg.content) {
-            if (block.type === 'text') {
-                content.push({
-                    type: 'text',
-                    text: block.text,
-                });
-            }
-            else if (block.type === 'image') {
-                // Convert image URL to base64 if needed
-                const [mediaType, data] = block.source.split(',');
-                content.push({
-                    type: 'image',
-                    source: {
-                        type: 'base64',
-                        media_type: (block.mediaType ||
-                            mediaType.split(':')[1].split(';')[0]),
-                        data: data || block.source,
-                    },
-                });
-            }
-            else if (block.type === 'tool_use') {
-                content.push({
-                    type: 'tool_use',
-                    id: block.id,
-                    name: block.name,
-                    input: block.input,
-                });
-            }
-            else if (block.type === 'tool_result') {
-                content.push({
+    // Convert messages to SDK format
+    const anthropicMessages = conversationMessages.map((msg) => ({
+        role: msg.role,
+        content: typeof msg.content === 'string'
+            ? msg.content
+            : msg.content.map((block) => {
+                if (block.type === 'text') {
+                    return { type: 'text', text: block.text };
+                }
+                if (block.type === 'image') {
+                    const [mediaType, data] = block.source.split(',');
+                    return {
+                        type: 'image',
+                        source: {
+                            type: 'base64',
+                            media_type: (block.mediaType ||
+                                mediaType.split(':')[1].split(';')[0]),
+                            data: data || block.source,
+                        },
+                    };
+                }
+                if (block.type === 'tool_use') {
+                    return {
+                        type: 'tool_use',
+                        id: block.id,
+                        name: block.name,
+                        input: block.input,
+                    };
+                }
+                // tool_result
+                return {
                     type: 'tool_result',
                     tool_use_id: block.tool_use_id,
                     content: block.content,
                     is_error: block.is_error,
-                });
-            }
-        }
-        return {
-            role: msg.role,
-            content,
-        };
-    });
-    return {
-        system,
-        messages: anthropicMessages,
-    };
+                };
+            }),
+    }));
+    return { system, messages: anthropicMessages };
 }
 /**
- * Convert Anthropic message to OSSA format
+ * Convert Anthropic SDK message to OSSA format
  */
 export function convertFromAnthropicMessage(anthropicMessage) {
     if (typeof anthropicMessage.content === 'string') {
@@ -99,19 +77,14 @@ export function convertFromAnthropicMessage(anthropicMessage) {
     const content = [];
     for (const block of anthropicMessage.content) {
         if (block.type === 'text') {
-            content.push({
-                type: 'text',
-                text: block.text,
-            });
+            content.push({ type: 'text', text: block.text });
         }
         else if (block.type === 'image') {
-            // Convert image to data URL
-            const source = block.source.type === 'base64'
-                ? `data:${block.source.media_type};base64,${block.source.data}`
-                : '';
             content.push({
                 type: 'image',
-                source,
+                source: block.source.type === 'base64'
+                    ? `data:${block.source.media_type};base64,${block.source.data}`
+                    : '',
                 mediaType: block.source.type === 'base64' ? block.source.media_type : undefined,
             });
         }
@@ -133,11 +106,9 @@ export function convertFromAnthropicMessage(anthropicMessage) {
                 is_error: block.is_error,
             });
         }
+        // Ignore other block types (thinking, document, server_tool_use, etc.)
     }
-    return {
-        role: anthropicMessage.role,
-        content,
-    };
+    return { role: anthropicMessage.role, content };
 }
 /**
  * Create a text message
@@ -292,26 +263,16 @@ export function mergeMessages(messages) {
         const next = messages[i];
         if (current.role === next.role && current.role !== 'system') {
             // Merge content
-            if (typeof current.content === 'string' &&
-                typeof next.content === 'string') {
-                current = {
-                    ...current,
-                    content: `${current.content}\n\n${next.content}`,
-                };
-            }
-            else {
-                // Convert to array format
-                const currentBlocks = typeof current.content === 'string'
-                    ? [{ type: 'text', text: current.content }]
-                    : current.content;
-                const nextBlocks = typeof next.content === 'string'
-                    ? [{ type: 'text', text: next.content }]
-                    : next.content;
-                current = {
-                    ...current,
-                    content: [...currentBlocks, ...nextBlocks],
-                };
-            }
+            const currentBlocks = typeof current.content === 'string'
+                ? [{ type: 'text', text: current.content }]
+                : current.content;
+            const nextBlocks = typeof next.content === 'string'
+                ? [{ type: 'text', text: next.content }]
+                : next.content;
+            current = {
+                ...current,
+                content: [...currentBlocks, ...nextBlocks],
+            };
         }
         else {
             merged.push(current);

package/dist/adapters/anthropic/tools.d.ts

@@ -102,25 +102,10 @@ export declare function createTool(name: string, description: string, properties
  * Common tool templates
  */
 export declare const COMMON_TOOLS: {
-    /**
-     * Web search tool
-     */
     readonly webSearch: Tool;
-    /**
-     * Read file tool
-     */
     readonly readFile: Tool;
-    /**
-     * Write file tool
-     */
     readonly writeFile: Tool;
-    /**
-     * Execute code tool
-     */
     readonly executeCode: Tool;
-    /**
-     * HTTP request tool
-     */
     readonly httpRequest: Tool;
 };
 //# sourceMappingURL=tools.d.ts.map

package/dist/adapters/anthropic/tools.js

@@ -33,15 +33,9 @@ export class ToolMapper {
                 if (tool.type === 'function' &&
                     tool.name &&
                     typeof tool.name === 'string') {
-                    const toolName = tool.name;
-                    const anthropicTool = this.convertFunctionToTool({
-                        ...tool,
-                        name: toolName,
-                    });
+                    const anthropicTool = this.convertFunctionToTool(tool);
                     tools.push(anthropicTool);
-                    this.tools.set(tool.name, {
-                        tool: anthropicTool,
-                    });
+                    this.tools.set(tool.name, { tool: anthropicTool });
                 }
                 else if (tool.type === 'mcp' && tool.capabilities) {
                     // MCP tools - convert each capability
@@ -49,17 +43,11 @@ export class ToolMapper {
                         const capability = {
                             name: capName,
                             description: `MCP capability: ${capName}`,
-                            input_schema: {
-                                type: 'object',
-                                properties: {},
-                            },
+                            input_schema: { type: 'object', properties: {} },
                         };
                         const anthropicTool = this.convertCapabilityToTool(capability);
                         tools.push(anthropicTool);
-                        this.tools.set(capName, {
-                            tool: anthropicTool,
-                            capability,
-                        });
+                        this.tools.set(capName, { tool: anthropicTool, capability });
                     }
                 }
             }
@@ -79,9 +67,8 @@ export class ToolMapper {
      */
     registerToolHandler(name, handler) {
         const toolDef = this.tools.get(name);
-        if (!toolDef) {
+        if (!toolDef)
             return false;
-        }
         toolDef.handler = handler;
         return true;
     }
@@ -103,9 +90,7 @@ export class ToolMapper {
     async executeTool(name, input) {
         const toolDef = this.tools.get(name);
         if (!toolDef) {
-            return JSON.stringify({
-                error: `Tool '${name}' not found`,
-            });
+            return JSON.stringify({ error: `Tool '${name}' not found` });
         }
         if (!toolDef.handler) {
             return JSON.stringify({
@@ -145,13 +130,14 @@ export class ToolMapper {
      */
     convertFunctionToTool(tool) {
         const config = tool.config || {};
-        const description = config.description || `Function: ${tool.name}`;
+        const name = tool.name || 'unnamed_tool';
+        const description = config.description || `Function: ${name}`;
         const inputSchema = config.input_schema || {
             type: 'object',
             properties: {},
         };
         return {
-            name: tool.name,
+            name,
             description,
             input_schema: this.normalizeInputSchema(inputSchema),
         };
@@ -160,16 +146,11 @@ export class ToolMapper {
      * Normalize input schema to Anthropic format
      */
     normalizeInputSchema(schema) {
-        // Ensure schema is object type
-        const normalized = {
+        return {
             type: 'object',
             properties: schema.properties || {},
+            ...(Array.isArray(schema.required) && { required: schema.required }),
         };
-        // Add required fields if present
-        if (Array.isArray(schema.required)) {
-            normalized.required = schema.required;
-        }
-        return normalized;
     }
 }
 /**
@@ -185,7 +166,6 @@ export function createToolMapper(agent) {
  */
 export function extractCapabilities(agent) {
     const capabilities = [];
-    // From spec.tools
     if (agent.spec?.tools) {
         for (const tool of agent.spec.tools) {
             if (tool.type === 'function' && tool.name && tool.config) {
@@ -263,74 +243,30 @@ export function createTool(name, description, properties, required) {
  * Common tool templates
  */
 export const COMMON_TOOLS = {
-    /**
-     * Web search tool
-     */
     webSearch: createTool('web_search', 'Search the web for information', {
-        query: {
-            type: 'string',
-            description: 'The search query',
-        },
+        query: { type: 'string', description: 'The search query' },
         max_results: {
             type: 'number',
             description: 'Maximum number of results to return',
         },
     }, ['query']),
-    /**
-     * Read file tool
-     */
-    readFile: createTool('read_file', 'Read contents of a file', {
-        path: {
-            type: 'string',
-            description: 'File path to read',
-        },
-    }, ['path']),
-    /**
-     * Write file tool
-     */
+    readFile: createTool('read_file', 'Read contents of a file', { path: { type: 'string', description: 'File path to read' } }, ['path']),
     writeFile: createTool('write_file', 'Write contents to a file', {
-        path: {
-            type: 'string',
-            description: 'File path to write',
-        },
-        content: {
-            type: 'string',
-            description: 'Content to write',
-        },
+        path: { type: 'string', description: 'File path to write' },
+        content: { type: 'string', description: 'Content to write' },
     }, ['path', 'content']),
-    /**
-     * Execute code tool
-     */
     executeCode: createTool('execute_code', 'Execute code in a sandboxed environment', {
         language: {
             type: 'string',
             description: 'Programming language (python, javascript, etc.)',
         },
-        code: {
-            type: 'string',
-            description: 'Code to execute',
-        },
+        code: { type: 'string', description: 'Code to execute' },
     }, ['language', 'code']),
-    /**
-     * HTTP request tool
-     */
     httpRequest: createTool('http_request', 'Make an HTTP request', {
-        url: {
-            type: 'string',
-            description: 'URL to request',
-        },
-        method: {
-            type: 'string',
-            description: 'HTTP method (GET, POST, etc.)',
-        },
-        headers: {
-            type: 'object',
-            description: 'Request headers',
-        },
-        body: {
-            type: 'string',
-            description: 'Request body',
-        },
+        url: { type: 'string', description: 'URL to request' },
+        method: { type: 'string', description: 'HTTP method (GET, POST, etc.)' },
+        headers: { type: 'object', description: 'Request headers' },
+        body: { type: 'string', description: 'Request body' },
     }, ['url']),
 };
 //# sourceMappingURL=tools.js.map

package/dist/adapters/autogen/config-adapter.d.ts

@@ -0,0 +1,22 @@
+/**
+ * AutoGen Config-Only Adapter
+ *
+ * Provides lightweight Microsoft AutoGen agent JSON config.
+ * This adapter is registered in the PlatformRegistry so the MCP server
+ * can delegate to it instead of using inline conversion logic.
+ *
+ * SOLID: Single Responsibility - AutoGen config-only export
+ */
+import { BaseAdapter } from '../base/adapter.interface.js';
+import type { OssaAgent, ExportOptions, ExportResult, ConfigResult } from '../base/adapter.interface.js';
+export declare class AutogenConfigAdapter extends BaseAdapter {
+    readonly platform = "autogen";
+    readonly displayName = "AutoGen";
+    readonly description = "Microsoft AutoGen agent configuration";
+    readonly status: "alpha";
+    readonly supportedVersions: string[];
+    export(manifest: OssaAgent, _options?: ExportOptions): Promise<ExportResult>;
+    getExample(): OssaAgent;
+    toConfig(manifest: OssaAgent): Promise<ConfigResult>;
+}
+//# sourceMappingURL=config-adapter.d.ts.map

package/dist/adapters/autogen/config-adapter.js

@@ -0,0 +1,72 @@
+/**
+ * AutoGen Config-Only Adapter
+ *
+ * Provides lightweight Microsoft AutoGen agent JSON config.
+ * This adapter is registered in the PlatformRegistry so the MCP server
+ * can delegate to it instead of using inline conversion logic.
+ *
+ * SOLID: Single Responsibility - AutoGen config-only export
+ */
+import { BaseAdapter } from '../base/adapter.interface.js';
+export class AutogenConfigAdapter extends BaseAdapter {
+    platform = 'autogen';
+    displayName = 'AutoGen';
+    description = 'Microsoft AutoGen agent configuration';
+    status = 'alpha';
+    supportedVersions = ['v0.4'];
+    async export(manifest, _options) {
+        return this.createResult(false, [], 'Use toConfig() for AutoGen export');
+    }
+    getExample() {
+        return {
+            apiVersion: 'ossa/v0.4',
+            kind: 'Agent',
+            metadata: { name: 'autogen-example', version: '1.0.0' },
+            spec: { role: 'Example AutoGen agent' },
+        };
+    }
+    async toConfig(manifest) {
+        const meta = manifest.metadata || { name: 'agent', version: '0.0.0' };
+        const autogenTools = (manifest.spec?.tools || []);
+        const config = {
+            name: meta.name,
+            description: meta.description || '',
+            system_message: manifest.spec?.role || '',
+            llm_config: {
+                config_list: [
+                    {
+                        model: manifest.spec?.llm?.model || 'gpt-4',
+                        api_type: manifest.spec?.llm?.provider === 'anthropic'
+                            ? 'anthropic'
+                            : 'openai',
+                    },
+                ],
+                ...(manifest.spec?.llm?.temperature != null
+                    ? { temperature: manifest.spec.llm.temperature }
+                    : {}),
+                ...(manifest.spec?.llm?.maxTokens != null
+                    ? { max_tokens: manifest.spec.llm.maxTokens }
+                    : {}),
+            },
+            ...(autogenTools.length > 0
+                ? {
+                    tools: autogenTools.map((t) => ({
+                        name: t.name || 'unnamed',
+                        description: t.description || '',
+                        ...(t.inputSchema || t.input_schema
+                            ? { parameters: t.inputSchema || t.input_schema }
+                            : {}),
+                    })),
+                }
+                : {}),
+            metadata: {
+                ossa_version: manifest.apiVersion || 'ossa/v0.4',
+            },
+        };
+        return {
+            config,
+            filename: `${meta.name}.autogen.json`,
+        };
+    }
+}
+//# sourceMappingURL=config-adapter.js.map

package/dist/adapters/base/adapter.interface.d.ts

@@ -48,7 +48,7 @@ export interface ExportResult {
         /**
          * Additional platform-specific metadata
          */
-        [key: string]: any;
+        [key: string]: unknown;
     };
     /**
      * Error message if export failed
@@ -103,11 +103,64 @@ export interface ExportOptions {
     /**
      * Platform-specific options
      */
-    platformOptions?: Record<string, any>;
+    platformOptions?: Record<string, unknown>;
     /**
      * Dry run mode - validate only, don't write files
      */
     dryRun?: boolean;
+    /**
+     * Master flag: generate full "Perfect Agent" structure.
+     * Enables all include* flags below.
+     */
+    perfectAgent?: boolean;
+    /**
+     * Generate .well-known/agent-card.json for universal agent discovery
+     */
+    includeAgentCard?: boolean;
+    /**
+     * Generate AGENTS.md (AAIF convention, adopted by 60K+ projects)
+     */
+    includeAgentsMd?: boolean;
+    /**
+     * Include multi-agent team scaffolding
+     * (auto-detected from spec.team, spec.swarm, or agentArchitecture.pattern)
+     */
+    includeTeam?: boolean;
+    /**
+     * Generate identity/ with DID document (.well-known/did.json)
+     */
+    includeDID?: boolean;
+    /**
+     * Generate evals/ with CLEAR framework config and golden sets
+     */
+    includeEvals?: boolean;
+    /**
+     * Generate governance/ with compliance, policies, audit config
+     */
+    includeGovernance?: boolean;
+    /**
+     * Generate observability/ with OTel traces, metrics, dashboards
+     */
+    includeObservability?: boolean;
+}
+/**
+ * Adapter maturity status
+ */
+export type AdapterStatus = 'production' | 'beta' | 'alpha' | 'planned';
+/**
+ * Lightweight config-only export result.
+ * Used by MCP tool responses and other contexts where full file scaffolds
+ * are too heavy.
+ */
+export interface ConfigResult {
+    /**
+     * The converted configuration object (platform-specific JSON)
+     */
+    config: Record<string, unknown>;
+    /**
+     * Suggested filename for the config (e.g. 'agent.kagent.yaml')
+     */
+    filename: string;
 }
 /**
  * Platform Adapter Interface
@@ -127,6 +180,10 @@ export interface PlatformAdapter {
      * Platform description
      */
     readonly description: string;
+    /**
+     * Adapter maturity status — honest reporting of readiness
+     */
+    readonly status: AdapterStatus;
     /**
      * Supported OSSA versions
      */
@@ -152,6 +209,15 @@ export interface PlatformAdapter {
      * @returns Example OSSA manifest optimized for this platform
      */
     getExample(): OssaAgent;
+    /**
+     * Produce a lightweight JSON config suitable for MCP tool responses.
+     * Unlike export() which generates full multi-file project scaffolds,
+     * toConfig() returns a single JSON object representing the platform config.
+     *
+     * @param manifest - OSSA agent manifest
+     * @returns Lightweight config result with config object and suggested filename
+     */
+    toConfig(manifest: OssaAgent): Promise<ConfigResult>;
 }
 /**
  * Validation result
@@ -203,6 +269,10 @@ export interface ValidationWarning {
      * Suggestion for fixing warning
      */
     suggestion?: string;
+    /**
+     * Warning code
+     */
+    code?: string;
 }
 /**
  * Base adapter implementation with common functionality
@@ -211,6 +281,7 @@ export declare abstract class BaseAdapter implements PlatformAdapter {
     abstract readonly platform: string;
     abstract readonly displayName: string;
     abstract readonly description: string;
+    abstract readonly status: AdapterStatus;
     abstract readonly supportedVersions: string[];
     abstract export(manifest: OssaAgent, options?: ExportOptions): Promise<ExportResult>;
     /**
@@ -233,5 +304,24 @@ export declare abstract class BaseAdapter implements PlatformAdapter {
      * Helper: Create agent.ossa.yaml manifest file for provenance
      */
     protected createManifestFile(manifest: OssaAgent): ExportFile;
+    /**
+     * Default toConfig() — throws unless overridden by the adapter.
+     * Adapters that support lightweight config-only export should override this.
+     */
+    toConfig(manifest: OssaAgent): Promise<ConfigResult>;
+    /**
+     * Resolve effective options: if perfectAgent is set, enable all flags.
+     */
+    protected resolvePerfectAgentOptions(options?: ExportOptions): ExportOptions;
+    /**
+     * Detect if manifest defines a multi-agent system
+     */
+    isMultiAgent(manifest: OssaAgent): boolean;
+    /**
+     * Generate all "perfect agent" supplementary files.
+     * Called by adapters when ExportOptions.perfectAgent is true.
+     * Delegates to generatePerfectAgentBundle() in common-file-generator.
+     */
+    generatePerfectAgentFiles(manifest: OssaAgent, options?: ExportOptions): ExportFile[];
 }
 //# sourceMappingURL=adapter.interface.d.ts.map