@bluefly/openstandardagents 0.1.9

package/src/adk/state/index.ts

@@ -0,0 +1,217 @@
+/**
+ * ADK State Management for OSSA
+ * Implements session.state pattern for inter-agent communication
+ */
+
+export interface ADKSessionState {
+  [key: string]: any;
+}
+
+export interface ADKSession {
+  id: string;
+  state: ADKSessionState;
+  temp: ADKSessionState;  // Turn-specific temporary state
+  metadata: {
+    created_at: Date;
+    updated_at: Date;
+    agent_trace: string[];
+  };
+}
+
+/**
+ * ADK Session Manager for OSSA
+ */
+export class OSSASessionManager {
+  private sessions: Map<string, ADKSession> = new Map();
+
+  /**
+   * Create a new session
+   */
+  createSession(id?: string): ADKSession {
+    const sessionId = id || this.generateSessionId();
+    
+    const session: ADKSession = {
+      id: sessionId,
+      state: {},
+      temp: {},
+      metadata: {
+        created_at: new Date(),
+        updated_at: new Date(),
+        agent_trace: []
+      }
+    };
+    
+    this.sessions.set(sessionId, session);
+    return session;
+  }
+
+  /**
+   * Get existing session
+   */
+  getSession(id: string): ADKSession | undefined {
+    return this.sessions.get(id);
+  }
+
+  /**
+   * Update session state
+   */
+  updateState(sessionId: string, key: string, value: any): void {
+    const session = this.sessions.get(sessionId);
+    if (!session) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+    
+    session.state[key] = value;
+    session.metadata.updated_at = new Date();
+  }
+
+  /**
+   * Update temporary state (cleared after each turn)
+   */
+  updateTempState(sessionId: string, key: string, value: any): void {
+    const session = this.sessions.get(sessionId);
+    if (!session) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+    
+    session.temp[key] = value;
+  }
+
+  /**
+   * Clear temporary state
+   */
+  clearTempState(sessionId: string): void {
+    const session = this.sessions.get(sessionId);
+    if (session) {
+      session.temp = {};
+    }
+  }
+
+  /**
+   * Add agent to trace
+   */
+  addAgentTrace(sessionId: string, agentName: string): void {
+    const session = this.sessions.get(sessionId);
+    if (session) {
+      session.metadata.agent_trace.push(agentName);
+      session.metadata.updated_at = new Date();
+    }
+  }
+
+  /**
+   * Interpolate state variables in text
+   */
+  interpolateState(text: string, sessionId: string): string {
+    const session = this.sessions.get(sessionId);
+    if (!session) return text;
+    
+    // Replace {variable} with state value
+    return text.replace(/\{(\w+)\}/g, (match, key) => {
+      // Check temp state first, then persistent state
+      if (session.temp[key] !== undefined) {
+        return session.temp[key];
+      }
+      if (session.state[key] !== undefined) {
+        return session.state[key];
+      }
+      return match;
+    });
+  }
+
+  /**
+   * Clone session for parallel execution
+   */
+  cloneSession(sessionId: string): ADKSession {
+    const original = this.sessions.get(sessionId);
+    if (!original) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+    
+    const clonedId = this.generateSessionId();
+    const cloned: ADKSession = {
+      id: clonedId,
+      state: { ...original.state },
+      temp: { ...original.temp },
+      metadata: {
+        created_at: new Date(),
+        updated_at: new Date(),
+        agent_trace: [...original.metadata.agent_trace]
+      }
+    };
+    
+    this.sessions.set(clonedId, cloned);
+    return cloned;
+  }
+
+  /**
+   * Merge sessions (for parallel execution results)
+   */
+  mergeSessions(targetId: string, sourceIds: string[]): void {
+    const target = this.sessions.get(targetId);
+    if (!target) {
+      throw new Error(`Target session not found: ${targetId}`);
+    }
+    
+    for (const sourceId of sourceIds) {
+      const source = this.sessions.get(sourceId);
+      if (source) {
+        // Merge state (source overwrites target for conflicts)
+        Object.assign(target.state, source.state);
+        
+        // Merge agent traces
+        target.metadata.agent_trace.push(...source.metadata.agent_trace);
+        
+        // Clean up source session
+        this.sessions.delete(sourceId);
+      }
+    }
+    
+    target.metadata.updated_at = new Date();
+  }
+
+  /**
+   * Clean up old sessions
+   */
+  cleanupSessions(olderThan: Date): number {
+    let cleaned = 0;
+    
+    for (const [id, session] of this.sessions.entries()) {
+      if (session.metadata.updated_at < olderThan) {
+        this.sessions.delete(id);
+        cleaned++;
+      }
+    }
+    
+    return cleaned;
+  }
+
+  /**
+   * Generate unique session ID
+   */
+  private generateSessionId(): string {
+    return `session_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  }
+
+  /**
+   * Export session for debugging
+   */
+  exportSession(sessionId: string): any {
+    const session = this.sessions.get(sessionId);
+    if (!session) return null;
+    
+    return {
+      id: session.id,
+      state: session.state,
+      temp: session.temp,
+      metadata: {
+        created_at: session.metadata.created_at.toISOString(),
+        updated_at: session.metadata.updated_at.toISOString(),
+        agent_trace: session.metadata.agent_trace,
+        state_keys: Object.keys(session.state),
+        temp_keys: Object.keys(session.temp)
+      }
+    };
+  }
+}
+
+export const sessionManager = new OSSASessionManager();

package/src/adk/tools/index.ts

@@ -0,0 +1,291 @@
+/**
+ * ADK Tool System for OSSA
+ * Maps OSSA capabilities to ADK tools and AgentTools
+ */
+
+import { ADKAgent } from '../agents/index.js';
+
+export interface ADKTool {
+  name: string;
+  description: string;
+  parameters?: any;
+  function: (params: any) => Promise<any>;
+}
+
+export interface AgentTool extends ADKTool {
+  agent: ADKAgent;
+  delegation_type: 'explicit' | 'implicit';
+}
+
+/**
+ * OSSA Tool Registry for ADK
+ */
+export class OSSAToolRegistry {
+  private tools: Map<string, ADKTool> = new Map();
+  private agentTools: Map<string, AgentTool> = new Map();
+  private capabilityMapping: Map<string, string[]> = new Map();
+
+  constructor() {
+    this.initializeDefaultTools();
+    this.initializeCapabilityMappings();
+  }
+
+  /**
+   * Initialize default OSSA tools
+   */
+  private initializeDefaultTools(): void {
+    // Data processing tools
+    this.registerTool({
+      name: 'process_data',
+      description: 'Process and transform data',
+      parameters: {
+        type: 'object',
+        properties: {
+          data: { type: 'any' },
+          operation: { type: 'string' }
+        }
+      },
+      function: async (params) => {
+        return {
+          processed: true,
+          data: params.data,
+          operation: params.operation
+        };
+      }
+    });
+
+    // API interaction tools
+    this.registerTool({
+      name: 'api_call',
+      description: 'Make API calls to external services',
+      parameters: {
+        type: 'object',
+        properties: {
+          url: { type: 'string' },
+          method: { type: 'string' },
+          body: { type: 'any' }
+        }
+      },
+      function: async (params) => {
+        return {
+          status: 200,
+          response: 'API call simulated',
+          url: params.url
+        };
+      }
+    });
+
+    // Database operations
+    this.registerTool({
+      name: 'database_query',
+      description: 'Execute database queries',
+      parameters: {
+        type: 'object',
+        properties: {
+          query: { type: 'string' },
+          params: { type: 'array' }
+        }
+      },
+      function: async (params) => {
+        return {
+          rows: [],
+          query: params.query
+        };
+      }
+    });
+
+    // File operations
+    this.registerTool({
+      name: 'file_operation',
+      description: 'Perform file system operations',
+      parameters: {
+        type: 'object',
+        properties: {
+          operation: { type: 'string', enum: ['read', 'write', 'delete'] },
+          path: { type: 'string' },
+          content: { type: 'string' }
+        }
+      },
+      function: async (params) => {
+        return {
+          success: true,
+          operation: params.operation,
+          path: params.path
+        };
+      }
+    });
+
+    // Validation tools
+    this.registerTool({
+      name: 'validate',
+      description: 'Validate data against schemas',
+      parameters: {
+        type: 'object',
+        properties: {
+          data: { type: 'any' },
+          schema: { type: 'any' }
+        }
+      },
+      function: async (params) => {
+        return {
+          valid: true,
+          errors: []
+        };
+      }
+    });
+
+    // Monitoring tools
+    this.registerTool({
+      name: 'collect_metrics',
+      description: 'Collect system metrics',
+      parameters: {
+        type: 'object',
+        properties: {
+          target: { type: 'string' },
+          metrics: { type: 'array' }
+        }
+      },
+      function: async (params) => {
+        return {
+          metrics: {
+            cpu: Math.random() * 100,
+            memory: Math.random() * 100,
+            timestamp: new Date().toISOString()
+          }
+        };
+      }
+    });
+  }
+
+  /**
+   * Initialize capability to tool mappings
+   */
+  private initializeCapabilityMappings(): void {
+    // Map OSSA capabilities to tools
+    this.capabilityMapping.set('data-processing', ['process_data', 'validate']);
+    this.capabilityMapping.set('api-integration', ['api_call']);
+    this.capabilityMapping.set('database-operations', ['database_query']);
+    this.capabilityMapping.set('file-management', ['file_operation']);
+    this.capabilityMapping.set('validation', ['validate']);
+    this.capabilityMapping.set('monitoring', ['collect_metrics']);
+    this.capabilityMapping.set('orchestration', []);  // Uses AgentTools instead
+    this.capabilityMapping.set('governance', ['validate']);
+  }
+
+  /**
+   * Register a new tool
+   */
+  registerTool(tool: ADKTool): void {
+    this.tools.set(tool.name, tool);
+  }
+
+  /**
+   * Register an agent as a tool (AgentTool pattern)
+   */
+  registerAgentTool(agent: ADKAgent, delegationType: 'explicit' | 'implicit' = 'explicit'): void {
+    const agentTool: AgentTool = {
+      name: `invoke_${agent.config.name}`,
+      description: `Delegate to ${agent.config.name} agent: ${agent.config.description}`,
+      agent,
+      delegation_type: delegationType,
+      function: async (params) => {
+        // Simulate agent invocation
+        return {
+          delegated_to: agent.config.name,
+          input: params,
+          result: `Executed by ${agent.config.name}`
+        };
+      }
+    };
+    
+    this.agentTools.set(agentTool.name, agentTool);
+  }
+
+  /**
+   * Get tools for capabilities
+   */
+  getToolsForCapabilities(capabilities: string[]): ADKTool[] {
+    const toolNames = new Set<string>();
+    
+    for (const capability of capabilities) {
+      const mappedTools = this.capabilityMapping.get(capability) || [];
+      mappedTools.forEach(name => toolNames.add(name));
+    }
+    
+    const tools: ADKTool[] = [];
+    for (const name of toolNames) {
+      const tool = this.tools.get(name);
+      if (tool) {
+        tools.push(tool);
+      }
+    }
+    
+    return tools;
+  }
+
+  /**
+   * Get agent tools for orchestration
+   */
+  getAgentTools(): AgentTool[] {
+    return Array.from(this.agentTools.values());
+  }
+
+  /**
+   * Execute a tool
+   */
+  async executeTool(name: string, params: any): Promise<any> {
+    const tool = this.tools.get(name) || this.agentTools.get(name);
+    
+    if (!tool) {
+      throw new Error(`Tool not found: ${name}`);
+    }
+    
+    return tool.function(params);
+  }
+
+  /**
+   * List all available tools
+   */
+  listTools(): { standard: string[], agent: string[] } {
+    return {
+      standard: Array.from(this.tools.keys()),
+      agent: Array.from(this.agentTools.keys())
+    };
+  }
+
+  /**
+   * Export tool definitions (for LLM context)
+   */
+  exportToolDefinitions(): any[] {
+    const definitions: any[] = [];
+    
+    // Standard tools
+    for (const [name, tool] of this.tools) {
+      definitions.push({
+        type: 'function',
+        function: {
+          name,
+          description: tool.description,
+          parameters: tool.parameters || {}
+        }
+      });
+    }
+    
+    // Agent tools
+    for (const [name, tool] of this.agentTools) {
+      definitions.push({
+        type: 'agent_tool',
+        function: {
+          name,
+          description: tool.description,
+          agent: tool.agent.config.name,
+          delegation_type: tool.delegation_type
+        }
+      });
+    }
+    
+    return definitions;
+  }
+}
+
+export const toolRegistry = new OSSAToolRegistry();