@bluefly/openstandardagents 0.5.0 → 0.5.1

package/dist/services/mcp/bridge.service.js

@@ -55,7 +55,12 @@ let McpBridgeService = class McpBridgeService {
         if (!fs.existsSync(registryDir)) {
             fs.mkdirSync(registryDir, { recursive: true });
         }
-        fs.writeFileSync(registryPath, yaml.dump({ generatedBy: 'ossa-mcp-bridge', apiVersion: getApiVersion(), updatedAt: new Date().toISOString(), servers }, { lineWidth: 120 }), 'utf8');
+        fs.writeFileSync(registryPath, yaml.dump({
+            generatedBy: 'ossa-mcp-bridge',
+            apiVersion: getApiVersion(),
+            updatedAt: new Date().toISOString(),
+            servers,
+        }, { lineWidth: 120 }), 'utf8');
         return registryPath;
     }
     saveToolManifest(workspaceDir, server) {
@@ -93,7 +98,11 @@ let McpBridgeService = class McpBridgeService {
     async discoverToolsViaSDK(command, args) {
         let client;
         try {
-            const transport = new StdioClientTransport({ command, args, env: process.env });
+            const transport = new StdioClientTransport({
+                command,
+                args,
+                env: process.env,
+            });
             client = new Client({ name: 'ossa-mcp-bridge', version: '1.0.0' }, { capabilities: {} });
             await client.connect(transport);
             const { tools } = await client.listTools();
@@ -108,7 +117,9 @@ let McpBridgeService = class McpBridgeService {
                 try {
                     await client.close();
                 }
-                catch { /* swallow */ }
+                catch {
+                    /* swallow */
+                }
             }
         }
     }
@@ -123,7 +134,8 @@ let McpBridgeService = class McpBridgeService {
             command: cfg.command,
             args: cfg.args,
             url: cfg.url,
-            transport: cfg.transport ?? (cfg.command ? 'stdio' : 'sse'),
+            transport: cfg.transport ??
+                (cfg.command ? 'stdio' : 'sse'),
         }));
     }
     /**
@@ -159,7 +171,14 @@ let McpBridgeService = class McpBridgeService {
         for (const entry of newEntries) {
             this.saveToolManifest(dir, entry);
         }
-        return { action: 'sync', source, serversFound: parsed.length, serversImported: newEntries.length, registryPath, servers: newEntries };
+        return {
+            action: 'sync',
+            source,
+            serversFound: parsed.length,
+            serversImported: newEntries.length,
+            registryPath,
+            servers: newEntries,
+        };
     }
     async list(workspaceDir) {
         const dir = path.resolve(workspaceDir);
@@ -175,13 +194,25 @@ let McpBridgeService = class McpBridgeService {
         const [serverName, method] = toolName.split('/');
         const server = servers.find((s) => s.name === serverName);
         if (!server) {
-            return { allowed: false, reason: `"${serverName}" not in OSSA bridge registry. Run: ossa mcp bridge sync <source>` };
+            return {
+                allowed: false,
+                reason: `"${serverName}" not in OSSA bridge registry. Run: ossa mcp bridge sync <source>`,
+            };
         }
         // Verify the specific tool name if we have a tool list from SDK discovery
-        if (server.tools && server.tools.length > 0 && method && !server.tools.includes(method)) {
-            return { allowed: false, reason: `Tool "${method}" not found on server "${serverName}". Known tools: ${server.tools.join(', ')}` };
+        if (server.tools &&
+            server.tools.length > 0 &&
+            method &&
+            !server.tools.includes(method)) {
+            return {
+                allowed: false,
+                reason: `Tool "${method}" not found on server "${serverName}". Known tools: ${server.tools.join(', ')}`,
+            };
         }
-        return { allowed: true, reason: `Agent "${agentId}" is authorized to call "${toolName}" via OSSA bridge.` };
+        return {
+            allowed: true,
+            reason: `Agent "${agentId}" is authorized to call "${toolName}" via OSSA bridge.`,
+        };
     }
 };
 McpBridgeService = __decorate([

package/dist/services/openapi-extensions-validation.d.ts

@@ -0,0 +1,20 @@
+import { type ErrorObject } from 'ajv';
+export interface OpenApiExtensionsValidationWarning {
+    path: string;
+    message: string;
+}
+export interface OpenApiExtensionsSummary {
+    hasMetadata: boolean;
+    hasOssa: boolean;
+    hasAgent: boolean;
+    operationExtensions: number;
+    capabilitySchemaExtensions: number;
+}
+export interface OpenApiExtensionsValidationDetails {
+    valid: boolean;
+    errors: ErrorObject[];
+    warnings: OpenApiExtensionsValidationWarning[];
+    ossaExtensions: OpenApiExtensionsSummary;
+}
+export declare function validateOpenApiExtensionsDocument(openapiSpec: unknown): OpenApiExtensionsValidationDetails;
+//# sourceMappingURL=openapi-extensions-validation.d.ts.map

package/dist/services/openapi-extensions-validation.js

@@ -0,0 +1,193 @@
+import Ajv from 'ajv';
+import addFormats from 'ajv-formats';
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const currentFilePath = fileURLToPath(import.meta.url);
+const currentDir = dirname(currentFilePath);
+const SCHEMA_PATHS = [
+    resolve(currentDir, '../../spec/extensions/openapi/ossa-openapi-extensions.schema.json'),
+    resolve(currentDir, '../spec/extensions/openapi/ossa-openapi-extensions.schema.json'),
+];
+let cachedValidator;
+function getSchemaPath() {
+    const schemaPath = SCHEMA_PATHS.find((candidate) => existsSync(candidate));
+    if (!schemaPath) {
+        throw new Error(`OSSA OpenAPI extensions schema not found. Checked: ${SCHEMA_PATHS.join(', ')}`);
+    }
+    return schemaPath;
+}
+function getValidator() {
+    if (cachedValidator) {
+        return cachedValidator;
+    }
+    const schema = JSON.parse(readFileSync(getSchemaPath(), 'utf-8'));
+    const ajv = new Ajv({
+        allErrors: true,
+        strict: false,
+        validateFormats: true,
+        verbose: true,
+    });
+    addFormats(ajv);
+    cachedValidator = ajv.compile(schema);
+    return cachedValidator;
+}
+function countOperationExtensions(doc) {
+    let count = 0;
+    const paths = doc.paths;
+    if (!paths) {
+        return count;
+    }
+    const methods = [
+        'get',
+        'put',
+        'post',
+        'delete',
+        'options',
+        'head',
+        'patch',
+        'trace',
+    ];
+    for (const pathItem of Object.values(paths)) {
+        for (const method of methods) {
+            const operation = pathItem[method];
+            if (!operation) {
+                continue;
+            }
+            if (operation['x-ossa-capability'])
+                count++;
+            if (operation['x-ossa-autonomy'])
+                count++;
+            if (operation['x-ossa-constraints'])
+                count++;
+            if (operation['x-ossa-tools'])
+                count++;
+            if (operation['x-ossa-llm'])
+                count++;
+        }
+    }
+    return count;
+}
+function countCapabilitySchemaExtensions(doc) {
+    const components = doc.components;
+    if (!components?.schemas) {
+        return 0;
+    }
+    return Object.values(components.schemas).filter((schema) => schema &&
+        typeof schema === 'object' &&
+        'x-ossa-capability-schema' in schema).length;
+}
+function generateWarnings(doc) {
+    const warnings = [];
+    if (!doc['x-ossa-metadata']) {
+        warnings.push({
+            path: '/',
+            message: 'Missing x-ossa-metadata extension. Consider adding OSSA metadata for compliance tracking.',
+        });
+    }
+    else {
+        const metadata = doc['x-ossa-metadata'];
+        if (!metadata.compliance) {
+            warnings.push({
+                path: '/x-ossa-metadata',
+                message: 'Missing compliance configuration. Consider adding compliance level and frameworks.',
+            });
+        }
+        if (!metadata.observability) {
+            warnings.push({
+                path: '/x-ossa-metadata',
+                message: 'Missing observability configuration. Consider enabling tracing, metrics, and logging.',
+            });
+        }
+    }
+    if (!doc['x-ossa']) {
+        warnings.push({
+            path: '/',
+            message: 'Missing x-ossa extension. Agent identification is recommended for OSSA compliance.',
+        });
+    }
+    const paths = doc.paths;
+    if (!paths) {
+        return warnings;
+    }
+    const methods = [
+        'get',
+        'put',
+        'post',
+        'delete',
+        'options',
+        'head',
+        'patch',
+        'trace',
+    ];
+    for (const [pathKey, pathItem] of Object.entries(paths)) {
+        for (const method of methods) {
+            const operation = pathItem[method];
+            if (!operation || !operation.operationId) {
+                continue;
+            }
+            if (!operation['x-ossa-capability']) {
+                warnings.push({
+                    path: `/paths${pathKey}/${method}`,
+                    message: `Operation ${operation.operationId} missing x-ossa-capability. Consider linking to an agent capability.`,
+                });
+            }
+            if (['post', 'put', 'patch', 'delete'].includes(method) &&
+                !operation['x-ossa-autonomy']) {
+                warnings.push({
+                    path: `/paths${pathKey}/${method}`,
+                    message: `Write operation ${operation.operationId} missing x-ossa-autonomy. Consider defining autonomy level.`,
+                });
+            }
+        }
+    }
+    return warnings;
+}
+export function validateOpenApiExtensionsDocument(openapiSpec) {
+    if (!openapiSpec || typeof openapiSpec !== 'object') {
+        return {
+            valid: false,
+            errors: [
+                {
+                    instancePath: '',
+                    schemaPath: '',
+                    keyword: 'type',
+                    params: { type: 'object' },
+                    message: 'OpenAPI spec must be an object',
+                },
+            ],
+            warnings: [],
+            ossaExtensions: {
+                hasMetadata: false,
+                hasOssa: false,
+                hasAgent: false,
+                operationExtensions: 0,
+                capabilitySchemaExtensions: 0,
+            },
+        };
+    }
+    const doc = openapiSpec;
+    const validate = getValidator();
+    const valid = validate(doc);
+    return {
+        valid,
+        errors: valid
+            ? []
+            : (validate.errors || []).map((error) => ({
+                instancePath: error.instancePath || '',
+                schemaPath: error.schemaPath || '',
+                keyword: error.keyword || 'validation',
+                params: error.params || {},
+                message: error.message || 'Validation error',
+            })),
+        warnings: generateWarnings(doc),
+        ossaExtensions: {
+            hasMetadata: !!doc['x-ossa-metadata'],
+            hasOssa: !!doc['x-ossa'],
+            hasAgent: !!doc['x-agent'],
+            operationExtensions: countOperationExtensions(doc),
+            capabilitySchemaExtensions: countCapabilitySchemaExtensions(doc),
+        },
+    };
+}
+//# sourceMappingURL=openapi-extensions-validation.js.map

package/dist/services/release-automation/merge-request.service.d.ts

@@ -10,10 +10,10 @@ import { z } from 'zod';
  */
 declare const MergeRequestFilterSchema: z.ZodObject<{
     state: z.ZodOptional<z.ZodEnum<{
+        locked: "locked";
         closed: "closed";
         opened: "opened";
         merged: "merged";
-        locked: "locked";
     }>>;
     page: z.ZodDefault<z.ZodNumber>;
     perPage: z.ZodDefault<z.ZodNumber>;
@@ -35,19 +35,19 @@ export declare class MergeRequestService extends BaseCrudService<MergeRequest, C
         title: z.ZodOptional<z.ZodString>;
         description: z.ZodOptional<z.ZodString>;
         state: z.ZodOptional<z.ZodEnum<{
+            locked: "locked";
             closed: "closed";
             opened: "opened";
             merged: "merged";
-            locked: "locked";
         }>>;
         labels: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>;
     protected filterSchema: z.ZodObject<{
         state: z.ZodOptional<z.ZodEnum<{
+            locked: "locked";
             closed: "closed";
             opened: "opened";
             merged: "merged";
-            locked: "locked";
         }>>;
         page: z.ZodDefault<z.ZodNumber>;
         perPage: z.ZodDefault<z.ZodNumber>;
@@ -59,10 +59,10 @@ export declare class MergeRequestService extends BaseCrudService<MergeRequest, C
         sourceBranch: z.ZodString;
         targetBranch: z.ZodString;
         state: z.ZodEnum<{
+            locked: "locked";
             closed: "closed";
             opened: "opened";
             merged: "merged";
-            locked: "locked";
         }>;
         mergeStatus: z.ZodOptional<z.ZodEnum<{
             can_be_merged: "can_be_merged";

package/dist/services/release-automation/release-buttons.js

@@ -89,10 +89,10 @@ async function releaseToGitHub() {
     execSync(`gh release create ${tag} \
     --title "Release ${version}" \
     --notes "${releaseNotes}" \
-    --repo blueflyio/openstandardagents`, { stdio: 'inherit' });
+    --repo $(CI_PROJECT_PATH)`, { stdio: 'inherit' });
     // 2. Upload artifacts
     execSync(`gh release upload ${tag} dist/*.tgz \
-    --repo blueflyio/openstandardagents`, { stdio: 'inherit' });
+    --repo $(CI_PROJECT_PATH)`, { stdio: 'inherit' });
     console.log('✅ GitHub release successful');
 }
 async function deployWebsite() {
@@ -131,7 +131,7 @@ npm install openstandardagents@${version}
 
 ### 🔗 Links
 - [npm Package](https://www.npmjs.com/package/openstandardagents/v/${version})
-- [GitHub Release](https://github.com/blueflyio/openstandardagents/releases/tag/v${version})
+- [GitHub Release](https://github.com/$(CI_PROJECT_PATH)/releases/tag/v${version})
 - [Documentation](https://openstandardagents.org/docs)
 - [Changelog](https://openstandardagents.org/docs/changelog)
 

package/dist/services/release-automation/schemas/release.schema.d.ts

@@ -32,10 +32,10 @@ export declare const MilestoneStateSchema: z.ZodEnum<{
  * Merge Request State
  */
 export declare const MergeRequestStateSchema: z.ZodEnum<{
+    locked: "locked";
     closed: "closed";
     opened: "opened";
     merged: "merged";
-    locked: "locked";
 }>;
 /**
  * Merge Status
@@ -173,10 +173,10 @@ export declare const MergeRequestSchema: z.ZodObject<{
     sourceBranch: z.ZodString;
     targetBranch: z.ZodString;
     state: z.ZodEnum<{
+        locked: "locked";
         closed: "closed";
         opened: "opened";
         merged: "merged";
-        locked: "locked";
     }>;
     mergeStatus: z.ZodOptional<z.ZodEnum<{
         can_be_merged: "can_be_merged";
@@ -211,10 +211,10 @@ export declare const UpdateMergeRequestRequestSchema: z.ZodObject<{
     title: z.ZodOptional<z.ZodString>;
     description: z.ZodOptional<z.ZodString>;
     state: z.ZodOptional<z.ZodEnum<{
+        locked: "locked";
         closed: "closed";
         opened: "opened";
         merged: "merged";
-        locked: "locked";
     }>>;
     labels: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;

package/dist/services/runtime/openai.adapter.d.ts

@@ -25,7 +25,35 @@ export interface OssaManifest {
             config?: Record<string, unknown>;
         }>;
     };
+    economics?: {
+        execution_profile?: string;
+        token_class?: string;
+        compression_policy?: string;
+        token_sovereignty?: {
+            tokenization_boundary?: 'local' | 'provider' | 'hybrid';
+            context_retention?: string;
+            sovereign_embeddings?: boolean;
+        };
+    };
+    security?: {
+        tier?: string;
+    };
     extensions?: {
+        statemesh?: {
+            emits?: Array<{
+                schema: string;
+                ttl?: string;
+                projections_supported?: string[];
+            }>;
+            consumes?: Array<{
+                schema: string;
+                required_attestation?: boolean;
+            }>;
+            authority?: {
+                can_challenge?: string[];
+                can_merge?: boolean;
+            };
+        };
         openai_agents?: {
             model?: string;
             instructions?: string;
@@ -46,42 +74,47 @@ export interface ToolDefinition {
     name: string;
     description: string;
     parameters: Record<string, unknown>;
-    handler?: (args: Record<string, unknown>) => Promise<string>;
+    handler?: (args: any) => Promise<string>;
 }
 export declare class OpenAIAdapter {
-    private client;
     private manifest;
     private tools;
     private messages;
+    private apiKey?;
     constructor(manifest: OssaManifest, apiKey?: string);
     /**
      * Get the model to use from manifest
      */
-    private getModel;
+    private getModelName;
     /**
      * Get system prompt from manifest
      */
     private getSystemPrompt;
-    /**
-     * Convert OSSA tools to OpenAI function calling format
-     */
-    private getOpenAITools;
     /**
      * Register a tool handler
      */
-    registerToolHandler(name: string, handler: (args: Record<string, unknown>) => Promise<string>): void;
-    /**
-     * Execute a tool call
-     */
-    private executeTool;
+    registerToolHandler(name: string, handler: (args: any) => Promise<string>): void;
     /**
      * Initialize the conversation
      */
     initialize(): void;
     /**
-     * Send a message and get a response
+     * Send a message and get a response using AI SDK ToolLoopAgent.
+     * Publishes StateClaims and ReplayPackets to ContractPlane.
      */
     chat(userMessage: string, options?: RunOptions): Promise<string>;
+    /**
+     * Resolves context packs via the State Plane.
+     */
+    private resolveContextPacks;
+    /**
+     * Publish a Replay Packet to ContractPlane.
+     */
+    private publishReplayPacket;
+    /**
+     * Publish a claim to the ContractPlane State Plane API
+     */
+    private publishStateClaim;
     /**
      * Get agent info
      */