@bluefly/openstandardagents 0.4.9 → 0.5.1

package/dist/services/runtime/openai.adapter.js

@@ -2,198 +2,236 @@
  * OpenAI Runtime Adapter
  * Runs OSSA agents using OpenAI's function calling API
  */
-import OpenAI from 'openai';
+import * as crypto from 'crypto';
+import { createOpenAI } from '@ai-sdk/openai';
+import { ToolLoopAgent, stepCountIs } from 'ai';
+import { z } from 'zod';
 export class OpenAIAdapter {
-    client;
     manifest;
     tools = new Map();
     messages = [];
+    apiKey;
     constructor(manifest, apiKey) {
         this.manifest = manifest;
-        this.client = new OpenAI({
-            apiKey: apiKey || process.env.OPENAI_API_KEY,
-        });
+        this.apiKey = apiKey || process.env.OPENAI_API_KEY;
     }
     /**
      * Get the model to use from manifest
      */
-    getModel() {
-        // Check OpenAI extension first
+    getModelName() {
         if (this.manifest.extensions?.openai_agents?.model) {
             return this.manifest.extensions.openai_agents.model;
         }
-        // Fall back to LLM config
         if (this.manifest.spec.llm?.model) {
             return this.manifest.spec.llm.model;
         }
-        // Default
         return 'gpt-4o-mini';
     }
     /**
      * Get system prompt from manifest
      */
     getSystemPrompt() {
-        // Check OpenAI extension first
         if (this.manifest.extensions?.openai_agents?.instructions) {
             return this.manifest.extensions.openai_agents.instructions;
         }
-        // Fall back to role
         return this.manifest.spec.role;
     }
     /**
-     * Convert OSSA tools to OpenAI function calling format
+     * Register a tool handler
      */
-    getOpenAITools() {
-        const openaiTools = [];
-        // Check for tools_mapping in OpenAI extension
+    registerToolHandler(name, handler) {
+        // Basic tool mapping from manifest
         const toolsMapping = this.manifest.extensions?.openai_agents?.tools_mapping;
         if (toolsMapping) {
             for (const mapping of toolsMapping) {
-                const toolDef = {
-                    name: mapping.openai_tool_name || mapping.ossa_capability,
-                    description: mapping.description || `Execute ${mapping.ossa_capability}`,
-                    parameters: mapping.parameters || {
-                        type: 'object',
-                        properties: {},
-                        required: [],
-                    },
-                };
-                this.tools.set(toolDef.name, toolDef);
-                openaiTools.push({
-                    type: 'function',
-                    function: {
-                        name: toolDef.name,
-                        description: toolDef.description,
-                        parameters: toolDef.parameters,
-                    },
-                });
+                const tName = mapping.openai_tool_name || mapping.ossa_capability;
+                if (tName === name) {
+                    this.tools.set(name, {
+                        name,
+                        description: mapping.description || `Execute ${mapping.ossa_capability}`,
+                        parameters: mapping.parameters || { type: 'object', properties: {} },
+                        handler,
+                    });
+                    return;
+                }
             }
         }
-        // Also check spec.tools for basic tool definitions
+        // Fallback for spec.tools
         if (this.manifest.spec.tools) {
             for (const tool of this.manifest.spec.tools) {
-                if (tool.name && !this.tools.has(tool.name)) {
-                    const toolDef = {
-                        name: tool.name,
+                if (tool.name === name) {
+                    this.tools.set(name, {
+                        name,
                         description: `Execute ${tool.name} (${tool.type})`,
-                        parameters: {
-                            type: 'object',
-                            properties: {},
-                            required: [],
-                        },
-                    };
-                    this.tools.set(tool.name, toolDef);
-                    openaiTools.push({
-                        type: 'function',
-                        function: {
-                            name: tool.name,
-                            description: toolDef.description,
-                            parameters: toolDef.parameters,
-                        },
+                        parameters: { type: 'object', properties: {} },
+                        handler,
                     });
+                    return;
                 }
             }
         }
-        return openaiTools;
-    }
-    /**
-     * Register a tool handler
-     */
-    registerToolHandler(name, handler) {
-        const tool = this.tools.get(name);
-        if (tool) {
-            tool.handler = handler;
-        }
-    }
-    /**
-     * Execute a tool call
-     */
-    async executeTool(name, args) {
-        const tool = this.tools.get(name);
-        if (!tool) {
-            return `Error: Tool '${name}' not found`;
-        }
-        if (tool.handler) {
-            try {
-                return await tool.handler(args);
-            }
-            catch (error) {
-                return `Error executing ${name}: ${error instanceof Error ? error.message : String(error)}`;
-            }
-        }
-        // No handler registered - fail explicitly
-        throw new Error(`No handler registered for tool: ${name}`);
     }
     /**
      * Initialize the conversation
      */
     initialize() {
-        this.messages = [
-            {
-                role: 'system',
-                content: this.getSystemPrompt(),
-            },
-        ];
+        this.messages = [];
     }
     /**
-     * Send a message and get a response
+     * Send a message and get a response using AI SDK ToolLoopAgent.
+     * Publishes StateClaims and ReplayPackets to ContractPlane.
      */
     async chat(userMessage, options) {
-        // Add user message
+        const contractPlaneUrl = process.env.CONTRACTPLANE_URL || 'https://contractplane.blueflyagents.com';
+        const startTime = new Date().toISOString();
+        // 1. Resolve Context Packs (Economy Layer)
+        const contextPacks = await this.resolveContextPacks(contractPlaneUrl);
+        const enrichedSystemPrompt = this.getSystemPrompt() + "\n\nContext Packs:\n" + JSON.stringify(contextPacks);
         this.messages.push({
             role: 'user',
             content: userMessage,
         });
-        const tools = this.getOpenAITools();
-        let turnCount = 0;
-        const maxTurns = options?.maxTurns || 10;
-        while (turnCount < maxTurns) {
-            turnCount++;
-            // Call OpenAI
-            const response = await this.client.chat.completions.create({
-                model: this.getModel(),
-                messages: this.messages,
-                tools: tools.length > 0 ? tools : undefined,
-                temperature: this.manifest.spec.llm?.temperature ?? 0.7,
-                max_tokens: this.manifest.spec.llm?.maxTokens,
-            });
-            const choice = response.choices[0];
-            const message = choice.message;
-            // Add assistant message to history
-            this.messages.push(message);
-            // Check if we need to call tools
-            if (message.tool_calls && message.tool_calls.length > 0) {
-                if (options?.verbose) {
-                    console.log(`\n[Calling ${message.tool_calls.length} tool(s)...]`);
-                }
-                // Execute each tool call
-                for (const toolCall of message.tool_calls) {
-                    // Type guard for function tool calls
-                    if (toolCall.type !== 'function')
-                        continue;
-                    const funcCall = toolCall;
-                    const args = JSON.parse(funcCall.function.arguments);
+        // Convert internal tools to AI SDK tools
+        const sdkTools = {};
+        for (const [name, def] of this.tools) {
+            sdkTools[name] = {
+                description: def.description,
+                parameters: z.any(),
+                execute: async (args) => {
                     if (options?.verbose) {
-                        console.log(`  → ${funcCall.function.name}(${JSON.stringify(args)})`);
+                        console.log(`  → ${name}(${JSON.stringify(args)})`);
                     }
-                    const result = await this.executeTool(funcCall.function.name, args);
+                    const result = await def.handler(args);
+                    // Publish tool execution as a StateClaim (Evidence)
+                    await this.publishStateClaim(contractPlaneUrl, {
+                        subject: `task:${this.manifest.metadata.name}`,
+                        claim_type: 'evidence.tool_execution',
+                        payload: {
+                            tool: name,
+                            args,
+                            result_summary: result.substring(0, 500)
+                        }
+                    });
                     if (options?.verbose) {
                         console.log(`  ← ${result.substring(0, 100)}${result.length > 100 ? '...' : ''}`);
                     }
-                    // Add tool result to messages
-                    this.messages.push({
-                        role: 'tool',
-                        tool_call_id: toolCall.id,
-                        content: result,
-                    });
+                    return result;
+                },
+            };
+        }
+        // 2. Execute with Economics (ExecutionProfile) via ToolLoopAgent
+        const openaiProvider = createOpenAI({
+            apiKey: this.apiKey,
+        });
+        const agent = new ToolLoopAgent({
+            model: openaiProvider(this.getModelName()),
+            instructions: enrichedSystemPrompt,
+            tools: sdkTools,
+            stopWhen: stepCountIs(options?.maxTurns || 10),
+        });
+        const result = await agent.generate({
+            prompt: userMessage,
+        });
+        // Sync result back to history
+        this.messages.push({
+            role: 'assistant',
+            content: result.text,
+        });
+        // 3. Publish final intent/judgment as a StateClaim
+        await this.publishStateClaim(contractPlaneUrl, {
+            subject: `conversation:${this.manifest.metadata.name}`,
+            claim_type: 'intent.response',
+            payload: {
+                text: result.text,
+                usage: result.usage,
+            }
+        });
+        // 4. Generate and Publish Replay Packet (Reproducibility & Escrow)
+        const reasoningTrace = JSON.stringify(this.messages);
+        const reasoningHash = crypto.createHash('sha256').update(reasoningTrace).digest('hex');
+        await this.publishReplayPacket(contractPlaneUrl, {
+            metadata: {
+                id: `replay:${Math.random().toString(36).substring(7)}`,
+                timestamp: startTime,
+                agent_id: this.manifest.metadata.name
+            },
+            spec: {
+                execution_profile: this.manifest.economics?.execution_profile || 'default-balanced',
+                model_class: this.manifest.economics?.token_class || 'balanced-work',
+                inputs: {
+                    prompts: [enrichedSystemPrompt, userMessage],
+                    context_packs: this.manifest.spec.tools?.filter(t => t.type === 'context_pack').map(t => t.name) || []
+                },
+                accounting: {
+                    compute_tokens: result.usage.totalTokens,
+                    context_tokens: 0 // Calculated by mesh
+                },
+                escrow: {
+                    mode: 'structured-only',
+                    reasoning_hash: reasoningHash,
+                    policy_gate: 'audit_only'
+                },
+                output: {
+                    text: result.text,
+                    confidence: 1.0 // Simple heuristic for now
+                }
+            }
+        });
+        return result.text;
+    }
+    /**
+     * Resolves context packs via the State Plane.
+     */
+    async resolveContextPacks(baseUrl) {
+        const packs = [];
+        const contextPackRefs = this.manifest.spec.tools?.filter(t => t.type === 'context_pack') || [];
+        for (const ref of contextPackRefs) {
+            try {
+                const response = await fetch(`${baseUrl}/api/v1/statemesh/context/${ref.name}`);
+                if (response.ok) {
+                    packs.push(await response.json());
                 }
-                // Continue the loop to get the final response
-                continue;
             }
-            // No tool calls, return the response
-            return message.content || '';
+            catch (e) {
+                console.error(`Failed to resolve context pack: ${ref.name}`);
+            }
+        }
+        return packs;
+    }
+    /**
+     * Publish a Replay Packet to ContractPlane.
+     */
+    async publishReplayPacket(baseUrl, packet) {
+        try {
+            await fetch(`${baseUrl}/api/v1/statemesh/replays`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(packet)
+            });
+        }
+        catch (e) {
+            console.error('Failed to record Replay Packet');
+        }
+    }
+    /**
+     * Publish a claim to the ContractPlane State Plane API
+     */
+    async publishStateClaim(baseUrl, claim) {
+        try {
+            await fetch(`${baseUrl}/api/v1/statemesh/claims`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    ...claim,
+                    producer_id: `agent://${this.manifest.metadata.name}`,
+                    confidence: 100,
+                    trust_tier: this.manifest.security?.tier || 'unverified'
+                })
+            });
+        }
+        catch (error) {
+            console.error(`Failed to publish StateClaim: ${error instanceof Error ? error.message : String(error)}`);
         }
-        return 'Max turns reached without completion';
     }
     /**
      * Get agent info
@@ -201,7 +239,7 @@ export class OpenAIAdapter {
     getAgentInfo() {
         return {
             name: this.manifest.metadata.name,
-            model: this.getModel(),
+            model: this.getModelName(),
             tools: Array.from(this.tools.keys()),
         };
     }

package/dist/services/skill-registry.service.d.ts

@@ -16,9 +16,9 @@ declare const SkillMetadataSchema: z.ZodObject<{
     description: z.ZodString;
     priority: z.ZodDefault<z.ZodNumber>;
     contexts: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        review: "review";
         production: "production";
         development: "development";
-        review: "review";
         testing: "testing";
     }>>>;
     enabled: z.ZodDefault<z.ZodBoolean>;

package/dist/services/skills-pipeline/skills-research.service.js

@@ -58,13 +58,53 @@ const DEFAULT_SOURCES = [
  * Common English stop words to exclude from trigger extraction
  */
 const STOP_WORDS = new Set([
-    'the', 'and', 'for', 'are', 'but', 'not', 'you', 'all',
-    'can', 'her', 'was', 'one', 'our', 'out', 'has', 'have',
-    'with', 'this', 'that', 'from', 'they', 'been', 'said',
-    'each', 'which', 'their', 'will', 'other', 'about', 'many',
-    'then', 'them', 'these', 'some', 'would', 'make', 'like',
-    'into', 'could', 'time', 'very', 'when', 'come', 'made',
-    'use', 'using', 'used',
+    'the',
+    'and',
+    'for',
+    'are',
+    'but',
+    'not',
+    'you',
+    'all',
+    'can',
+    'her',
+    'was',
+    'one',
+    'our',
+    'out',
+    'has',
+    'have',
+    'with',
+    'this',
+    'that',
+    'from',
+    'they',
+    'been',
+    'said',
+    'each',
+    'which',
+    'their',
+    'will',
+    'other',
+    'about',
+    'many',
+    'then',
+    'them',
+    'these',
+    'some',
+    'would',
+    'make',
+    'like',
+    'into',
+    'could',
+    'time',
+    'very',
+    'when',
+    'come',
+    'made',
+    'use',
+    'using',
+    'used',
 ]);
 let SkillsResearchService = class SkillsResearchService {
     indexPath;

package/dist/services/taxonomy-service.d.ts

@@ -6,8 +6,8 @@ import { z } from 'zod';
 export declare const TaxonomyCategoryTypeSchema: z.ZodEnum<{
     custom: "custom";
     runtime: "runtime";
-    capability: "capability";
     role: "role";
+    capability: "capability";
     domain: "domain";
 }>;
 export declare const TaxonomyCategoryInputSchema: z.ZodObject<{
@@ -16,8 +16,8 @@ export declare const TaxonomyCategoryInputSchema: z.ZodObject<{
     type: z.ZodEnum<{
         custom: "custom";
         runtime: "runtime";
-        capability: "capability";
         role: "role";
+        capability: "capability";
         domain: "domain";
     }>;
     level: z.ZodNumber;
@@ -31,8 +31,8 @@ export declare const TaxonomyCategorySchema: z.ZodObject<{
     type: z.ZodEnum<{
         custom: "custom";
         runtime: "runtime";
-        capability: "capability";
         role: "role";
+        capability: "capability";
         domain: "domain";
     }>;
     level: z.ZodNumber;

package/dist/services/trust/trust.service.js

@@ -157,7 +157,9 @@ export async function verifyAgentSignature(manifest, signature, agentId) {
             ...base,
             verified,
             tier: verified ? 'verified-signature' : 'signed',
-            reason: verified ? undefined : 'Signature verification failed — payload mismatch or invalid key',
+            reason: verified
+                ? undefined
+                : 'Signature verification failed — payload mismatch or invalid key',
         };
     }
     catch (err) {
@@ -190,7 +192,7 @@ export async function signAgentManifest(manifest, privateKeyHex, issuer) {
         type: 'Ed25519',
         value: signatureB64,
         publicKey: publicKeyB64,
-        timestamp: new Date().toISOString()
+        timestamp: new Date().toISOString(),
     };
     if (issuer) {
         signature.issuer = issuer;
@@ -201,8 +203,8 @@ export async function signAgentManifest(manifest, privateKeyHex, issuer) {
         ...manifest,
         metadata: {
             ...metadata,
-            'x-signature': signature
-        }
+            'x-signature': signature,
+        },
     };
 }
 // ─── Utilities ──────────────────────────────────────────────

package/dist/services/validation-zod.service.js

@@ -22,16 +22,7 @@ import { z } from 'zod';
 import { inject, injectable } from 'inversify';
 import { SchemaRepository } from '../repositories/schema.repository.js';
 import { MessagingValidator } from './validators/messaging.validator.js';
-import { CursorValidator } from './validators/cursor.validator.js';
-import { OpenAIValidator } from './validators/openai.validator.js';
-import { CrewAIValidator } from './validators/crewai.validator.js';
-import { LangChainValidator } from './validators/langchain.validator.js';
-import { AnthropicValidator } from './validators/anthropic.validator.js';
-import { LangflowValidator } from './validators/langflow.validator.js';
-import { AutoGenValidator } from './validators/autogen.validator.js';
-import { VercelAIValidator } from './validators/vercel-ai.validator.js';
-import { LlamaIndexValidator } from './validators/llamaindex.validator.js';
-import { LangGraphValidator } from './validators/langgraph.validator.js';
+import { createValidatorRegistry, } from './validators/registry.js';
 /**
  * Convert Zod error to Ajv ErrorObject format for compatibility
  */
@@ -85,18 +76,8 @@ let ValidationZodService = class ValidationZodService {
     platformValidators;
     constructor(schemaRepository) {
         this.schemaRepository = schemaRepository;
-        // Initialize platform validators
-        this.platformValidators = new Map();
-        this.platformValidators.set('cursor', new CursorValidator());
-        this.platformValidators.set('openai_agents', new OpenAIValidator());
-        this.platformValidators.set('crewai', new CrewAIValidator());
-        this.platformValidators.set('langchain', new LangChainValidator());
-        this.platformValidators.set('anthropic', new AnthropicValidator());
-        this.platformValidators.set('langflow', new LangflowValidator());
-        this.platformValidators.set('autogen', new AutoGenValidator());
-        this.platformValidators.set('vercel_ai', new VercelAIValidator());
-        this.platformValidators.set('llamaindex', new LlamaIndexValidator());
-        this.platformValidators.set('langgraph', new LangGraphValidator());
+        // Single source of truth: all platform validators live in registry.ts
+        this.platformValidators = createValidatorRegistry();
     }
     /**
      * Validate OSSA agent manifest using Zod

package/dist/services/validators/index.d.ts

@@ -2,6 +2,7 @@
  * Platform Validators Index
  * Exports all platform-specific validators
  */
+export { createValidatorRegistry, type PlatformValidator } from './registry.js';
 export { CursorValidator } from './cursor.validator.js';
 export { OpenAIValidator } from './openai.validator.js';
 export { CrewAIValidator } from './crewai.validator.js';

package/dist/services/validators/index.js

@@ -3,6 +3,7 @@
  * Platform Validators Index
  * Exports all platform-specific validators
  */
+export { createValidatorRegistry } from './registry.js';
 export { CursorValidator } from './cursor.validator.js';
 export { OpenAIValidator } from './openai.validator.js';
 export { CrewAIValidator } from './crewai.validator.js';

package/dist/services/validators/registry.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Validator Registry Factory
+ *
+ * Single source of truth for all platform validators — add new validators here only.
+ *
+ * DRY: eliminates duplicate Map initialization across ValidationService implementations.
+ * To add a new platform validator: import it here and add one entry to the Map.
+ */
+import type { OssaAgent, ValidationResult } from '../../types/index.js';
+/** Shared interface for all platform validators registered in the registry. */
+export interface PlatformValidator {
+    validate(manifest: OssaAgent): ValidationResult;
+}
+/**
+ * Create the canonical map of platform validators.
+ *
+ * Keys match the extension names used in OSSA agent manifests
+ * (i.e. the keys of `manifest.extensions`).
+ */
+export declare function createValidatorRegistry(): Map<string, PlatformValidator>;
+//# sourceMappingURL=registry.d.ts.map

package/dist/services/validators/registry.js

@@ -0,0 +1,42 @@
+// @ts-nocheck
+/**
+ * Validator Registry Factory
+ *
+ * Single source of truth for all platform validators — add new validators here only.
+ *
+ * DRY: eliminates duplicate Map initialization across ValidationService implementations.
+ * To add a new platform validator: import it here and add one entry to the Map.
+ */
+import { CursorValidator } from './cursor.validator.js';
+import { OpenAIValidator } from './openai.validator.js';
+import { CrewAIValidator } from './crewai.validator.js';
+import { LangChainValidator } from './langchain.validator.js';
+import { AnthropicValidator } from './anthropic.validator.js';
+import { LangflowValidator } from './langflow.validator.js';
+import { AutoGenValidator } from './autogen.validator.js';
+import { VercelAIValidator } from './vercel-ai.validator.js';
+import { LlamaIndexValidator } from './llamaindex.validator.js';
+import { LangGraphValidator } from './langgraph.validator.js';
+import { KagentValidator } from './kagent.validator.js';
+/**
+ * Create the canonical map of platform validators.
+ *
+ * Keys match the extension names used in OSSA agent manifests
+ * (i.e. the keys of `manifest.extensions`).
+ */
+export function createValidatorRegistry() {
+    return new Map([
+        ['cursor', new CursorValidator()],
+        ['openai_agents', new OpenAIValidator()],
+        ['crewai', new CrewAIValidator()],
+        ['langchain', new LangChainValidator()],
+        ['anthropic', new AnthropicValidator()],
+        ['langflow', new LangflowValidator()],
+        ['autogen', new AutoGenValidator()],
+        ['vercel_ai', new VercelAIValidator()],
+        ['llamaindex', new LlamaIndexValidator()],
+        ['langgraph', new LangGraphValidator()],
+        ['kagent', new KagentValidator()],
+    ]);
+}
+//# sourceMappingURL=registry.js.map

package/dist/skills/test-skill/package.json

@@ -31,6 +31,6 @@
   ],
   "ossa": {
     "type": "claude-skill",
-    "skillPath": "/var/folders/48/d86hncy50j93r_vzsv6knttr0000gn/T/ossa-export-test-1773084155160/test-skill"
+    "skillPath": "/var/folders/48/d86hncy50j93r_vzsv6knttr0000gn/T/ossa-export-test-1774702067895/test-skill"
   }
 }